wepwebkit.org is a statically generated site for WPE. The website aims to be simple to maintain and with little complexity and dependencies. It is built with 11ty and Liquid templates - and that’s pretty much it.
+The actual site is hosted by Igalia who are the primary maintainers of the project.
+In order to setup, you just just have to check it out, switch to the checked out directory and then npm install.
In order to test it all you need to do is
+npm install && npm run serveThis will build the project, start a server, and your terminal will provide you useful links to actually get to it.
+_site is the output folder, where the generated and served content lives. It is committed and github pages used to provide a sharable dev URL in case you want to discuss proposed changes easily or test for something without exposing things behind your own firewall.
_includes contains templates and partials. Currently our templates are based on a variant of Stylish Portfolio simply because that is what we had to start with.
_posts contains much of the actual content: release notes, security advisories, posts, etc as .md files with front matter. These generate individual .html files in _site.
assets contain images and things, they are copied directly into their relevant directory in _site.
css This is where our CSS goes. Currently, our CSS is overrides and customizations for the Stylish Portfolio CSS. There is no preprocessing at the moment.
release contains the markdown and directory structure for the release schedule page.
vendor this contains thirdparty stuff that we will use directly in the site - it is copied wholesale into its relevant spot in the output directory (_site). There is currently too much in there - our page uses stylish portfolio, which uses bootstrap, which uses jQuery and font-awesome and simple-line-icons. These in turn contain things for bundling, pre-processing with several different preprocessors, etc. We will probably simplify this further, that’s a lot of downloads, code and round-trips for such a simple site.
about contains page posts that are about various aspects of wpe
In the root directory you will also find some top level files - index.htmlwhich is the template for the main page, release.md which is the template for creating the release pages, a package.json which is, well, what you’d expect and .eleventy.js which does some very understandable work in creating a date filter for outputting dates (because of how some of the old content exists), and creates some ‘recent’ collections for simple templating of things like release notes and security advisories.
In order to write a new release or security advisory piece in the website
+you just have to create a new file inside _posts folder using
+Markdown syntax.
Should you need anything else, you will find 11ty’s documentation pretty helpful.
diff --git a/aperezdc/compat-table-2.42.x/_authors/aperez/index.html b/aperezdc/compat-table-2.42.x/_authors/aperez/index.html new file mode 100644 index 000000000..5125bfca0 --- /dev/null +++ b/aperezdc/compat-table-2.42.x/_authors/aperez/index.html @@ -0,0 +1,17 @@ +
+ This article was written by Adrián Pérez.
+ 
+ This article was written by Nikolas Zimmermann. WPE WebKit is widely adopted in many industries, including digital signage, professional audio, video and broadcasting, home appliances, set-top boxes, and automative and in-flight infotainment systems.
+
+If you need a fast and lightweight web runtime for Linux-based embedded devices that supports most current web standards, has hardware acceleration wherever it is advantageous, and has a strong focus on multimedia applications, WPE WebKit is a great choice.
+WPE WebKit offers great possibilities for deployment on different platforms, thanks to its underlying design which allows for integration in a variety of hardware configurations. At a minimum, only EGL and OpenGL ES 2 support and basic GStreamer integration are required.
+WPE is the official WebKit port for embedded platforms. WPE is uniquely designed +for embedded systems in that it doesn’t depend on any user-interface toolkit +such as the traditional Cocoa, GTK, etc toolkits.
+
+WPE is considered a hybrid port because it defers the final web page delivery for display to a rendering backend. A traditional port would provide a widget for a given toolkit, but WPE opted for a different and more flexible approach.
+The common interface between WPEWebKit and its rendering backends is provided by
+libwpe. On one side, once
+WPEWebKit has a graphical representation of the final composited Web page ready
+for rendering, it invokes a callback function on libwpe. On the other side,
+the WPE application has to register a view backend on the WPE WebView. This view
+backend is provided by the rendering backend. The view backend receives the Web
+page representation from libwpe, usually as an EGLImage, and is in charge of
+presenting it in the application, on-screen.
The decoupling between generating the WebPage representation on WebKit side and +the actual rendering on the application side provides a very flexible design. +For instance, WPE integrators can easily develop a new rendering backend for +specific embedded platforms that might have a graphics driver with special API +requirements.
+WPE provides a rendering backend aiming to target the most common platforms and +leverage the existing graphics stack available in the +Freedesktop umbrella eco-system. +WPEBackend-FDO is the reference +implementation of the base rendering backend design. WPEBackend-FDO provides an API +for WPE applications that aims to ease the handling of rendering either +on-screen using EGL, or off-screen using SHM.
+In a traditional WebKit port, the provided widget usually also handles input +(keyboard, mouse, touch) events and is in charge of relaying them to the +internal WebKit input-methods components.
+As WPE doesn’t provide a widget, it relies on libwpe APIs to relay input
+events from the WPE application to the internal WebKit input-methods components.
+This design again adds flexibility to the overall WPE architecture, enabling
+applications to support new input devices without having to go through a UI
+toolkit first.
In the example of the Cog WPE browser, the +application relies on Wayland protocols for user input to communicate events +coming from the Wayland compositor to WPE.
+While there are several simple ways for developers to experiment with and explore WPE, none are tuned for performance. Generally, shipping products for embedded systems are performance-tuned custom builds. To make this easier, there is also meta-webkit, which provides build recipes, WebKit based runtimes, and browsers for use with OpenEmbedded and/or Yocto.
+We also have some performance tips that might be helpful.
+ + + + +If you can see this, you should be redirecting this URL to /about/get-wpe.html.
+ + \ No newline at end of file diff --git a/aperezdc/compat-table-2.42.x/about/faq.html b/aperezdc/compat-table-2.42.x/about/faq.html new file mode 100644 index 000000000..1d07785a6 --- /dev/null +++ b/aperezdc/compat-table-2.42.x/about/faq.html @@ -0,0 +1,257 @@ + + + + + + + + + + + +Historically, the WebPlatformForEmbedded flavor of WPE came first. It included several adaptations for the Reference Design Kit (RDK) platform, as well as different fixes for its supported devices. Quoting the RDK website:
+++RDK is a fully modular, portable, and customizable open source software +solution that standardizes core functions used in video, broadband and IoT +devices.
+
The RDK WPE page provides more +information about WPE in the RDK platform.
+In 2017, engineers from Igalia submitted a new flavor of WPE, suitable for upstream hosting under the webkit.org umbrella. This version of WPE is released every 6 months from the code hosted on the upstream repository. This flavor of WPE is maintained upstream and provides regular security updates.
+WPE has been ported to a wide range of hardware platforms. The team aims to expand the list even further, so don’t hesitate to contact us if you can’t find your favorite SoC in the list.
+WPE currently only works on Linux-based operating systems. We are currently working on supporting Android, though. If you require WPE to run on any other OS, don’t hesitate to contact us.
+The WebKit project provides a features status page to which you can refer. However, that information should be taken with a grain of salt. The multi-platform nature of WebKit implies that ports have different build-time and runtime configurations.
+The WPE project currently does not have an official list of the Web features it supports. It might provide one in the future, but for the time being, we recommend users check for specific features by testing WPE through the Cog browser.
+As of March 2022 the facts are:
+Taking these facts into account, the WPEWebKit maintainers have decided to leave WebRTC support disabled in the default build configuration of the official release tarballs because:
+In order to solve these issues, an alternative WebRTC backend based on GstWebRTC will be enabled by default in the WPE upstream CMake build, hopefully during 2023; bug #235885 is being used to track progress. This new backend will seamlessly integrate with hardware-accelerated encoders and decoders on most embedded platforms. GstWebRTC depends on OpenSSL, which is released under an Apache-style license, so it doesn’t have limitations regarding redistribution in binary form.
+There is code in WebKit to support Encrypted Media Extensions (EME), but in any case, you will need a license agreement with DRM CDM providers to access it, since this part is not open source. There are three ways you can get this working:
+From Cog’s README:
+++Cog is a small single “window” launcher for the WebKit WPE port. It is small, +provides no user interface, and is suitable to be used as a Web application +container. The “window” may be fullscreen depending on the WPE backend being +used.
+
Cog’s usage scenarios span from a MiniBrowser application to a full web-app container application meant to run HTML-based user interfaces on embedded platforms and products.
+Although it can run on Linux-based desktop environments, Cog is not a full-blown Web Browser to be compared with Google Chrome or Safari. Cog’s primary environment is on embedded platforms, and it can run within a Wayland compositor such as Weston. Additionally, if the platform supports KMS/DRM, Cog can run as a full-screen standalone browser, this use-case is very common on kiosk products for instance.
+If you are a developer aiming to enable WPE on a certain embedded platform, Cog combined with WPEBackend-FDO provides the most flexible solution for agile tinkering and to test WPE’s features.
+As we say in Galicia, “it depends”.
+WPE’s architecture was designed in order to +decouple rendering out of the Web engine and delegate this task to rendering +backends and to the application running the Web engine—it does not strictly +require usage of Wayland.
+Typically when talking about Wayland we tend to conflate many things:
+Wayland itself is an IPC +protocol which happens to be designed to move buffers containing pixel +data and input events from one process to another.
+The Wayland package typically contains the reference implementation
+of the protocol, libwayland. Other implementations are theoretically
+possible.
By extension we may refer to a compositor, which is a program that
+implements the server–side of the Wayland
+protocol—possibly with the aid of libwayland.
If you use WPEBackend-fdo, it internally uses the Wayland
+protocol (via libwayland) to pass rendered frames from the WPEWebProcess
+program to the application that embeds the web view—that we call “the UI
+process”. As this is an implementation detail of the backend, the fact that
+Wayland is used as IPC protocol does not need to be known by the application.
+A compositor may be required or not depending on how the UI process displays
+the web content.
For example, Cog can act as a Wayland client using its FDO platform plug-in, and in that case a +Wayland compositor is required. On the other hand, using Cog’s DRM platform plug-in it will display +rendered web content directly on screen (without a running Wayland +compositor). Note that in both cases WPEBackend-fdo is used as backend, +which means that the Wayland protocol is still in use.
+Some WPE backends may not require Wayland at all. Such is the case
+of WPEBackend-rdk in some configurations
+(USE_BACKEND_BCM_RPI, USE_BACKEND_BCM_NEXUS, etc.)
The application embedding WPE is responsible for rendering popups and dialogs. The reference WPE Browser, Cog, has limited support for these features (as of 2021, it supports option menus).
+Depending on which platform rendering plugin is enabled at build time, the Cog browser might depend on the wayland-protocols project to generate source files needed in order to act as a Wayland client to the compositor (server) implementing those protocols.
+So for instance, if you enable the FDO platform plugin and want to use it at runtime to have Cog running as a Wayland application, then the plugin will try to consume some Wayland protocols from the server, such as xdg-shell, fullscreen-shell-unstable-v1, presentation-time and linux-dmabuf-unstable-v1. Those protocols can’t be used without first generating source files derived from each protocol XML spec definition. This is all part of the Wayland design.
If you are building an embedded system image yourself, make sure there is at least one font installed that can be used as fallback by Fontconfig. You can use the fc-list program to print the list of known fonts.
If you are building an embedded system image yourself, make sure that the
+GStreamer elements autoaudiosink and alsasink are installed. Even if your
+system uses some other audio output by default (PulseAudio, PipeWire, etc.)
+ALSA is always tried as the last fallback if all the other available sinks
+fail.
If you are building an embedded system image yourself, make sure to install
+the shared MIME database is installed—in most distributions
+this is part of a package named shared-mime-info. WebKit uses it to
+determine which kind of data within file before loading it. Note that this is
+not needed if you plan to loading remote resources because HTTP servers
+provide the needed information in the Content-Type HTTP header.
If you can see this, you should be redirecting this URL to /about/get-wpe.html.
+ + \ No newline at end of file diff --git a/aperezdc/compat-table-2.42.x/about/get-wpe.html b/aperezdc/compat-table-2.42.x/about/get-wpe.html new file mode 100644 index 000000000..4f681d3f5 --- /dev/null +++ b/aperezdc/compat-table-2.42.x/about/get-wpe.html @@ -0,0 +1,283 @@ + + + + + + + + + + + +WPE is an open source/free software project. That means that you can +get the source code directly and modify it to serve your needs. While +this can sometimes be an involved process, there are different ways to +get your hands on WPE, depending on what you need.
+Before getting the code, it’s a good idea to be familiar with what you +will need. The different components that are needed to run WPE are:
+These packages are not just a quick and simple way to test WPE but +they also come with all the development files and documentation +necessary to build and test software that uses this web engine. Some +of the distributions that already have built packages for WPE are:
+This list is not exhaustive, so if you use a different distributions, +there might be packages for it already. Refer to the official +documentation of your distribution for information on how to install packages.
+A simple way to cross-compile WPE and its dependencies for a target +architecture is to use an existing build framework. We provide recipes +for a OpenEmbedded/Yocto layer for WPE. +There are specific instructions in the +project wiki.
+We periodically package WPE and its associated libraries, following a +predictable release schedule, to make sure that +both stable and development versions are available to users, +deployers, and developers. Following the release schedule is the best +way to follow the progress of WPE, get a sense of what’s coming, and +properly prepare for updates in your production deployments.
+Unstable releases are development versions, that give a preview of +what’s coming in the next stable release. These are useful for +beta-testing, and to prepare to upgrade your deployment to an upcoming +stable release when this is out. Unstable releases should never be +used in production.
+Below is a summary of the latest stable and unstable releases for WPE +and its components:
+This is the most involved way to get the source code, and it’s only +recommended for developers who are interested in getting involved in +the development of the project, or who need to implement any feature +that is not yet available in WPE. Additionally, this can be also be +a good way to track down any bug you might find and to fix it.
+Instead of downloading each of these components on their own, a good way to start is to fetch the WebKit repository +and use its build system to fetch all the dependencies. Check the instructions for building WebKit.
+If you find any problem or want to know more about optimizing WPE for your hardware or use cases, please contact us.
+
+The most recent stable and development releases of WPE codebases.
+How often does WEPWebKit release, and when?
+A complete archive of our security adviories, often with download links.
+A few pointers on how to get better performance out of WPEwebkit. (Github Wiki)
+We understand that WPE is interesting from many perspectives, and to people of potentially vastly different backgrounds. Let’s help you find what you’re looking for.
+WPE is currently running on a wide range of hardware, including devices made by:
+
WPE WebKit is widely adopted by many industries, including digital signage, professional audio, home appliances, set-top-boxes, automotive, and inflight infotainment. Countless devices deployed around the globe are already using WPE WebKit as their web runtime platform, and use is growing rapidly.
+
+
▶
+ 
▶
+ 
▶
+ 
▶
+ 
▶
+ WPE is currently running on a wide range of hardware. This page lists configurations which are known to work, sorted by manufacturer.
+Note that this list is not exhaustive. Reports of unlisted configurations are welcome.
+| Series | +GPU | +Driver | +WPE Backend | +Cog Shells | +
|---|---|---|---|---|
| i.MX 51 | +Imageon Z460 | +freedreno (reverse-engineered) | +fdo | +fdo, drm | +
| i.MX 53 | +Imageon Z460 | +freedreno (reverse-engineered) | +fdo | +fdo, drm | +
| i.MX 6 | +Vivante GC2000 | +etnaviv (reverse-engineered) | +fdo | +fdo, drm | +
| i.MX 6 | +Vivante GC2000 | +Vivante (Proprietary) | +fdo | +fdo | +
| i.MX 6 | +Vivante GC2000 | +Vivante (Proprietary) | +rdk, VIV_IMX6_EGL |
+n/a | +
| i.MX 8M | +Vivante GC7000 | +etnaviv (reverse-engineered) | +fdo | +fdo, drm | +
| i.MX 8M | +Vivante GC7000 | +Vivante (Proprietary) | +fdo | +fdo | +
| Device | +GPU | +Driver | +WPE Backend | +Cog Shells | +
|---|---|---|---|---|
| Arris VIP5202W | +VideoCore IV | +Proprietary | +rdk, BCM_NEXUS or USE_BACKEND_BCM_NEXUS_WAYLAND |
+n/a | +
| Raspberry Pi 3 | +VideoCore IV | +Proprietary | +rdk, BCM_RPI |
+n/a | +
| Raspberry Pi 3 | +VideoCore IV | +Mesa vc4 | +fdo | +fdo, drm | +
| Raspberry Pi 4 | +VideoCore V | +Mesa v3d | +fdo | +fdo | +
| Device | +GPU | +Driver | +WPE Backend | +Cog Shells | +
|---|---|---|---|---|
| APQ8017 | +Adreno 306 | +Proprietary | +Custom | +n/a | +
| Device | +GPU | +Driver | +WPE Backend | +Cog Shells | +
|---|---|---|---|---|
| Jetson TK1 | +Tegra K1 | ++ | + | + |
| Device | +GPU | +Driver | +WPE Backend | +Cog Shells | +
|---|---|---|---|---|
| RK3399 | +Mali T860MP4 | +panfrost (reverse-engineered) | +fdo | +fdo | +
| RK3399 | +Mali T860MP4 | +Mali (Proprietary) | ++ | + |
| Device | +GPU | +Driver | +WPE Backend | +Cog Shells | +
|---|---|---|---|---|
| Any | +AMD | +Mesa amdgpu | +fdo | +fdo | +
| Any | +Intel | +Mesa i965 | +fdo | +fdo, drm | +
| Any | +Intel | +Mesa iris | +fdo | +fdo, drm | +
| Device | +GPU | +Driver | +WPE Backend | +Cog Shells | +
|---|---|---|---|---|
| Beaglebone | +PowerVR SGX530 | +Proprietary | ++ | + |
+WPE WebKit is widely adopted in many industries, including digital signage, home appliances, set-top boxes, and automative and in-flight infotainment systems.
+Explore the different methods to get the source code and/or binaries for WPE
+The maintainer and sponsor of WPEwebkit, Igalia is an open-source and web standards consultancy spanning the globe.
+Long ago, it might have been reasonable to imagine browsers only in the realm of desktop computers. However, embedded browsers are in everything these days: cars, signs, tablets, gaming systems, televisions and appliances. They’re even in space!
+The Web Platform is a frequently chosen foundational technology for many reasons, including:
+The fact that over the past few years, billions of new devices have come online, and the implications of this are still under-discussed. We believe developers need to be able explore and understand this space, and that lessons learned here are potentially helpful to the larger web ecosystem as well. However, this can be challenging, because embedded browsers are a little different…
+For many of us, a browser is an application like the one you’re probably using now. You click an icon on your graphical operating system (OS), navigate somewhere with a URL bar, search, and so on. You have bookmarks and tabs that you can drag around, and lots of other features.
+In contrast, an embedded browser is contained within another application or is built for a specific purpose and runs in an embedded system, and the application controlling the embedded browser does not provide all the typical features of browsers running in desktops.
+Furthermore, for most embedded systems there isn’t a common desktop OS for the browser to run on — in fact, the OS is built specifically for that type of device, and the embedded browser is built along with it. Part of the reason for this is that, by and large, they are not general-purpose computing devices. They have slightly different security concerns, and they also run on often radically different sorts of hardware than desktop, laptop or many mobile devices.
+So, what really is an embedded browser?
+A “proper” browser is, in all likelihood, the application in which you are reading this. This browser is built on one of three open source projects: WebKit, Chromium or Gecko. Each of these projects defines an engine — that is, they provide an architecture through which something else (e.g., a browser) can bind to the top layer of the engine in order to drive us from URL to URL, and use the engine’s bottom layer to do things like actually put content on the screen, render graphics, receive input from devices like keyboards, mice and pointing devices, and connect to things like the text-to-speech subsystem.
+In terms of WebKit-based browsers, a “port” is the set of extra layers that provides facilities at those top and bottom layers of the engine. The WebKit project has a few “official” ports that are available from webkit.org/downloads/. Some, like Safari, are fully-featured desktop browsers. WebKitGTK is a port for the GTK GUI toolkit, used among others by the desktop browser Epiphany.
+WPE (“Web Platform for Embedded”) is the official port for embedded systems, and it adds another layer to the architecture allowing for more easily swappable backends (the graphics layers, windowing and so on) and simpler bindings for programmatic top-level control in Linux based systems. Cog is another project that makes it easier to launch and drive WPE views.
+In other words, WPE is designed to be built and optimized for your embedded device in order to deliver the best performance. What all of this means is that there isn’t really a single “WPE” that’s as easy to provide as many browsers that you’re probably familiar with.
+ +Welcome to the new Blog section on wpewebkit.org!
+Today is a special day for Igalia, especially for those colleagues that work on WebKit: +Five years ago, on the 21st of April 2017, the WPE port was announced by our colleague +Žan Doberšek on the WebKit mailing list.
+Let’s take some time to celebrate and recap how WPE evolved from the early prototyping days to the product empowering hundreds of millions of devices +worldwide today.
+
+To get everyone on the same page, let’s start by reiterating what WPE is: a WebKit port optimized for embedded devices. +It allows you to embed a full-fledged Web browser engine that supports a large set of modern Web technologies into your product. +WPE itself is not a Web browser such as Safari, Chrome or Firefox but contains the underlying building blocks to load, parse and +render websites. To learn more about the distinction between a Web browser and a Web browser engine read our explainer.
+You might ask yourself, what does “optimized for embedded devices” mean in practice? Unlike most other WebKit ports, WPE does not +rely on a specific user-interface toolkit, such as Qt, GTK, Cocoa, +etc., nor does it offer any integration with these kinds of toolkits. WPE WebKit is light-weight, integrates well with a +variety of hardware configurations, and only requires a minimum set of APIs on your side: +EGL and OpenGL ES 2.
+The idea for a new WebKit port was born in 2014, as part of a collaboration between Metrological +and Igalia. The goal of this collaboration was to have a WebKit port running efficiently on their set-top boxes, +utilizing a modern Wayland based Linux graphics architecture. Back then, QtWebKit was popular +among embedders; however, it was unmaintained and its future was unclear since Qt wanted to transition +from using WebKit to Blink.
+In September 2014 a group of Igalians forked the WebKitGtk port, removed all GTK toolkit dependencies, and prototyped what was necessary +to achieve the goal: rendering websites without involving any of the traditional toolkits and instead utilizing a Wayland-based rendering approach.
+During development it became apparent that this WebKit port is generally useful for all our customers and the community as a whole. +Therefore Igalia decided to aim for an even more flexible design, where Wayland is only one of the possible backends. +Our fellow Igalian Miguel Gomez reported in his late 2016 blog post +about this change, and the renaming of the port: WPE appears for the first time in public.
+The project’s removal of the Wayland dependency and the subsequent reorganization lead to the architecture we have today, +consisting of not only the WPE port itself but a whole ecosystem of projects such as libwpe, +WPEBackend-fdo, WPEBackend-rdk, etc., +that together form the WPE project.
+After months of focused engineering efforts, the downstream work was finished and Igalia was ready to announce WPE to the +public on the 17th of April 2017, with the promise that Igalia +will maintain the port alongside the existing WebKitGtk port. That is not a cheap bill: maintaining an upstream port is a recurring +multi-million dollar investment. Just in order to keep the port itself healthy, as updates are made all around it, requires infrastructure, +bots and a team of fully dedicated engineers to deal with maintenance, testing, triaging, tickets, etc. To implement new Web standards, fix +related bugs or design and contribute features requires an even more considerable amount of resources.
+Since then, Igalia ramped up the WPE investments and steadily advanced the port while helping customers to integrate WPE into their +environments. Today WPE is healthy, runs on many platforms, and offers the most flexible browser architecture at present. Also, thanks in great +part to this work, Igalia was responsible for nearly 16.5% of all commits in WebKit itself last year, helping make the larger project +and ecosystem around it healthier too.
+However, none of this would be possible without the commitment of many Igalians pushing the project forward every day for the past 8 years. +A new People Behind WPE series will be launched soon: over the following months, the Igalians involved with WPE will introduce themselves, their area of +expertise, and talk about a specific WPE related technical topic. You’ll get to know the people behind the product and a first-class technical overview +of individual parts of the WPE architecture! We plan to release a new article every 3-4 weeks, so be sure to visit wpewebkit.org/blog +again soon and enjoy the upcoming People Behind WPE series.
+Feel free to spread the word and make noise about WPE. Stay healthy, stay tuned!
+ + + +
+ This article was written by Nikolas Zimmermann. In the previous post in this series, +we explained that WPE is a WebKit +port optimized for embedded devices. In this post, we’ll dive into a +more technical overview of the different components of WPE, WebKit, +and how they all fit together. If you’re still wondering what a web +engine is or how WPE came to be, we recommend you to go back to the +first post in the series and then come back here.
+To understand what makes WPE special, we first need to have a basic +understanding of the architecture of WebKit itself, and how it ties +together a given architecture/platform and a user-facing web browser.
+WebKit, the engine, is split into different components that +encapsulate its different parts. At the heart of it is WebCore. As the +name suggests, this contains the core features of the engine +(rendering, layout, platform access, HTML and DOM support, the +graphics layer, etc). However, some of these ultimately depend heavily +on the OS and underlying software platform in order to function. For +example: how do we actually do any I/O on different platforms? How do +we render onscreen? What’s the underlying multimedia platform and how +does it decode media and play it?
+WebCore handles the multitude of potential answers to these questions +by abstracting the implementation of each component and allowing port +developers to fill the gaps for each supported platforms. For example, +for rendering on Mac, Cocoa APIs implement the graphics APIs +needed. On Linux, this can be done through different implementations +via Wayland, Vulkan, etc. For networking I/O on Mac, the networking +APIs in the Foundation framework are used. On Linux, libsoup fills +that gap, and so on.
+On the opposite side, for browser implementors to be able to write a +browser using WebKit, an API is needed. WebKit, after all, is a +library. WebKit ports, besides providing the platform support +described above, also provide APIs that suit the target environments: +The Apple ports provide Objective-C APIs (which are then used to write +Safari and the iOS browsers, for instance), while the GTK+ port +provides a GObject-based APIs for Linux (that are used in Epiphany, +the GNOME browser, and other GNOME applications that rely on WebKit to +render HTML). All of these APIs are built on top of an internal, +middle-man, C API that is meant to make it easy for each port to +provide a high-level API for browser developers.
+With all this in place, it would seem that it shouldn’t be so +difficult for any vendor trying to reuse WebKit in a new platform to +support new hardware and implement a browser, right? All that you need +to do is:
+Does that sound easy? No, it’s not easy at all! In fact, +implementation of ports in this fashion is strongly discouraged and +vendors who have tried this approach in the past have had to do a huge +effort just to play catch-up with the fast-paced development of +WebKit. This is where WPE comes to the rescue.
+To simplify the task of porting WebKit to different platforms, Igalia +started working on a platform-agnostic, Linux-based, and full-featured +port of WebKit. This port relies on existing and mature platform +backends for everything that can be easily reused across platforms: +multimedia, networking, and I/O, which are already present in-tree and +are used by Linux ports, like the GTK one. For the areas that are most +likely to require hardware-specific support (that is, graphics and +input), WPE abstracts the implementation so that it can be more easily +provided out of tree, allowing implementors to avoid having to deal +with the WebKit internals more than what’s strictly needed.
+Additionally, WPE provides a high-level API that can be used to +implement actual browsers. This API is very similar to the WebKitGTK +API, making it easy for developers already familiar with the latter to +start working with WPE. The cog library also serves as a wrapper +around WPE to make it easier still. Once WPE was mature enough, it was +accepted by Apple as an official WebKit port, meaning that the port +lives now in-tree and takes immediate advantage of the many +improvements that land on the WebKit repository on a daily basis.
+
The WPE port has several components. Some are in-tree (that is, are a +part of WebKit itself), while others are out-of-tree. Let’s examine +those components and how they relate to each other, from top to +bottom:
+An implementor interested in building a browser in a new architecture +only needs to focus on the development of the last component – a WPE +backend. Having a backend, starting the development of a +WebKit-powered browser is already much easier than it ever was!
+For a more detailed description of the architecture of WPE and WebKit, +check this article on the architecture of WPE.
+If you have made it this far, you should give WPE a try!
+We have listed several on the exploring WPE +page. From there, you will see that depending on how interested you +are in the project, your background, and what you’d like to do with +it, there are different ways!
+It can be as easy as installing WPE directly from the most popular +Linux distributions. If you want to build WPE yourself, +you can use Yocto and if +you’d like to contribute—that’s very welcome!
+Happy hacking!
+ + + +Following the previous post in the series about WPE where we talked about the WPE components, this post will explain briefly the WPE graphics architecture, and how the engine is able to render HTML content into the display. If you haven’t read the previous entries in this blog post series about WPE, we recommend you to start with the first post in the series for an introduction, and then come back to this.
+As the document is parsed, it will begin building the DOM tree and load-blocking CSS resources. At some point, possibly before the entire DOM tree is built, it’s time to draw things on the screen. The first step to render the content of a page is to perform what’s called the attachment, which is merging the DOM tree with the CSS rules, in order to create the RenderTree. This RenderTree is a collection of RenderObjects, structured into a tree, and each of these RenderObjects represent the elements in the DOM tree that have visual output. RenderObjects have the capability to render the associated DOM tree node into a surface by using the GraphicsContext class (in the case of WPE, this GraphicsContext uses Cairo to perform the rendering).
+Once the RenderTree is created, the layout is performed, ensuring that each of the RenderObjects have their proper size and position set.
+
It would be possible to render the content of the web page just traversing this RenderTree and painting each of the RenderObjects, but there would be problems when rendering elements that overlap each other, because the order of the elements in the RenderTree doesn’t necessarily match the order in which they must be painted in order to get the appropriate result. For example, an element with a big z-index value should be painted last, no matter its position in the RenderTree.
This is an example of how some HTML content is translated into the RenderTree (there are some RenderObjects missing here that are not relevant for the explanation).
+
In order to ensure that the elements of the RenderTree are rendered in the appropriate order, the concept of RenderLayer is added. A RenderLayer represents a layer in the document containing some elements that have to be rendered at the same depth (even though this is not exactly the case, you can think of each RenderLayer as a group of RenderObjects that are at a certain z-index). Each RenderObject is associated to a RenderLayer either directly or indirectly via an ancestor RenderObject.
RenderLayers are grouped into a tree, which is called the RenderLayer tree, and RenderLayer children are sorted into two lists: those that are below the RenderLayer, and those that are above. With this we have a structure that has grouped all the RenderObjects that have to be rendered together: they will be on top of the content that has been rendered by the RenderLayers below this one, and below the content rendered by the RenderLayers over this one.
+There are several conditions that can decide whether a RenderLayer is needed for some element, it doesn’t necessarily needs to be due to the usage of z-index. It can be required due to transparency, CSS filters, overflow, transformations, and so on.
Continuing with the example, these are RenderLayers that we would get for that HTML code:
+
We can see that there are four RenderLayers:
+RenderLayers have a paint method that is able to paint all the RenderObjects associated to the layer into a GraphicsContext (as mentioned, WPE uses Cairo for this). As in the previous case, it’s possible to paint the content of the page at this point just by traversing the RenderLayer tree and requesting the RenderLayers to paint their content, but in this case the result will be the correct one. Actually this is what WebKitGTK does when it’s run with accelerated compositing disabled.
+While with the previous step we are already able to render the page contents, this approach is not very efficient, especially when the page contains animations, elements with transparency, etc. This is because in order to paint a single pixel, all the RenderLayers need to be traversed, and those that are contributing to that pixel need to be repainted (totally or partially), even if the content of those RenderLayers hasn’t changed. For example, think about an animation that’s moving an element. For each frame of that animation, the animated element needs to be repainted, but the area that was covered by the animated element in the last frame needs to be repainted as well. The same happens if there’s a translucent element on top of other content. If the translucent element changes, it needs to be repainted, but the content below the translucent element needs to be repainted as well because the blend needs to be performed again.
+This would be much more efficient if the content that doesn’t change was somehow separated from the content that’s changing, and we could render those two types of content separately. This is where the composition stage comes into action.
+The idea here is that we’re going to paint the RenderLayer contents into intermediate buffers, and then compose those buffers one on top of the other to get the final result. This last step is what we call composition. And it fixes the problems we mentioned with animations of transparency: animations don’t require repainting several RenderLayers. Actually moving an element just means painting one buffer with an offset during the composition. And for transparency, we just need to perform the new blending of the two buffers during the composition, but the RenderLayers of the content below the translucent element don’t need to be repainted.
+Once we have the RenderLayer tree, we could just paint each RenderLayer in its own buffer in order to perform the composition. But this would be a waste of memory, as not every RenderLayer needs a buffer. We introduce here a new component, the GraphicsLayer.
+GraphicsLayers are a structure used to group those RenderLayers that will render into the same buffer, and it will also contain all the information required to perform the composition of these buffers. A RenderLayer may have a GraphicsLayer associated to it if it requires its own buffer to render. Otherwise, it will render into an ancestor’s buffer (specifically, the first ancestor that has a GraphicsLayer). As usual, GraphicsLayers are structured into a tree.
+This is how the example code would be translated into GraphicsLayers.
+
We can see that we have now three GraphicsLayers:
+With this structure, now we can render the intermediate buffers of the RenderView and the transformed RenderBlock, and we don’t need to update them any more. For each frame, those buffers will be composited together with the RenderVideo buffer. This RenderVideo will be updating its buffer whenever a new video frame arrives, but it won’t affect the content of the other GraphicsLayers.
+So now we have successfully separated the content that is changing and needs to be updated from the content that remains constant and doesn’t need to be repainted anymore, just composited.
+There’s something else that be done in order to increase the rendering performance, and it’s using the GPU to perform the composition. The GPU is highly optimized to perform operations like the buffer composition that we need to do, as well as handle 3D transforms, blending, etc. We just need to upload the buffers into textures and let the GPU handle the required operations. WPE does this though the usage of the EGL and GLES2 graphics APIs. In order to perform the composition, EGL is used to create a GLES2 EGLContext. Using that context, the intermediate buffers are uploaded to textures, and then those textures are positioned and composited according to their appropriate positions. This leverages the GPU for the composition work, leaving the CPU free to perform other tasks.
This is why this step is called accelerated compositing.
+But there’s more.
+Until this point, all the steps that are needed to render the content of the page are performed in the main thread. This means that while the main thread is rendering and compositing, it’s not able to perform other tasks, like run JS code.
+WPE improves this by using a parallel thread whose only mission is to perform the composition. You can think of it as a thread that runs a loop that composites the incoming buffers using the GPU when there’s content to render. This is what we call threaded accelerated compositing.
+This is specially useful when there’s a video or an animation running on the page:
+If there’s a video running in the page, in the non-threaded case, for each video frame the main thread would need to get the frame and perform the composition with the rest of the page content. In the threaded case, the video element delivers the frames directly to the compositor thread, and requests a composition to be done, without the main thread being involved at all.
+If there’s an animation, in the non-threaded case, for each frame of the animation the main thread would need to calculate the animation step and then perform the composition of the animated element with the rest of the page content. In the threaded case, the animation is passed to the compositor thread, and the animation steps are calculated on that thread, triggering a composition when needed. The main thread doesn’t need to do anything besides starting the animation.
+It would take another post to explain in detail how the threaded accelerated composition is implemented on WPE, but if you’re curious about it, know that WPE uses an specialization of the GraphicsLayer called CoordinatedGraphicsLayer in order to implement this. You can use that as an starting point.
+So this is the whole process that’s performed in WPE in order to display the content of a page. We hope it’s useful!
+At Igalia we’re constantly evolving and improving WPE, and have ongoing efforts to improve the graphics architecture as well. Besides small optimizations and refactors here and there, the most important goals that we have are:
+Add a GPU process. Currently the EGL and GLES2 operations are performed in the web process. As there can be several web processes running when several pages are open, this means the browser can be using a lot of EGL contexts in total, which is a waste of memory. Also, all these processes could potentially be affected by errors, leaks, etc., in the code that handles the GPU operations. The idea is to centralize all the GPU operations into a single process, the GPU one, so all the web processes will issue paint requests to the GPU process instead of painting their content themselves. This will reduce the memory usage and improve the software’s robustness.
+Remove CPU rasterization and paint all the content with GLES2. Using the CPU to paint the layer contents with cairo is expensive, especially in platforms with slow CPUs, as embedded devices sometimes do. Our goal here is to completely remove the cairo rasterization and use GLES2 calls to render the 2D primitives. This will greatly improve the rendering performance.
+Use ANGLE to perform WebGL operations. WPE currently implements the WebGL 1.0 specification through direct calls to GLES2 methods. We are changing this in order to perform the operations using ANGLE, which will allow WPE to support the WebGL 2.0 specification as well.
+In the previous post there was a mention of backends that are used to integrate with the underlying platform. How is this relevant to the graphics architecture?
+Backends have several missions when it comes to communicate with the platform, but regarding graphics, they have two functions to achieve:
+Provide a platform dependent surface that WPE will render to. This can be a normal buffer, a Wayland buffer, a native window, or whatever, as long as the system EGL implementation allows creating an EGLContext to render to it.
Process WPE indications that a new frame has been rendered, performing whatever tasks are necessary to take that frame to the display. Also notify WPE when that frame was been displayed.
+The most common example of this is a Wayland backend, which provides a buffer to WPE for rendering. When WPE has finished rendering the content, it notifies the backend, which sends the buffer to the Wayland compositor, and notifies back to WPE when the frame has been displayed.
+So, whatever platform you want to run WPE on, you need to have a backend providing at least these capabilities.
+This was a brief overview of how WPE rendering works, and also what are the major improvements we’re trying to achieve at Igalia. We’re constantly putting in a lot of work to keep WPE the best web engine available for embedded devices.
+If this post got you interested in collaborating with WPE development, or you are in need of a web engine to run on your embedded device, feel free to contact us. We’ll be pleased to help!
+We also have open positions at the WebKit team at Igalia. If you’re motivated by this field and you’re interested in developing your career around it, you can apply here!
+ + + +At the heart of any browser engine is networking: Connecting with services and other users. Unlike other engines, WebKit approaches this more abstractly by leaving a large portion of the networking up to individual ports. This includes network protocols such as HTTP, WebSockets, and WebRTC. The upside to this approach is a higher level of integration with the system-provided libraries and features so WebKit will behave similarly to other software on the platform often with more centralized configuration.
+Due to this abstraction there are a few independent layers that make up the networking stack of WPE. In this post, I’ll break down what each layer accomplishes as well as give some insight into the codebase’s structure.
+
+Before we get into the libraries used for WPE, let’s discuss WebKit itself. Despite abstracting out a lot of the protocol handling, WebKit itself still needs to understand a lot of fundamentals of HTTP.
+WebCore (discussed in WPE Overview) understands HTTP requests, headers, and cookies, as they are required to implement many higher-level features. What it does not do is the network operations, most parsing, or on-disk storage. In the codebase, these are represented by ResourceRequest and ResourceResponse objects, which map to general HTTP functionality.
A core part of modern web engine security is the multi-process model. In order to defend against exploits, each website runs in its own isolated process that does not have network access. In order to allow for network access, they must talk over IPC to a dedicated NetworkProcess, typically one per browser instance. The NetworkProcess receives a ResourceRequest, creates a NetworkDataTask with it to download the data, and responds with a ResourceResponse to the WebProcess which looks like this:
+WPE implements the platform-specific versions of the classes above as ResourceRequestSoup and NetworkDataTaskSoup, primarily using a library called libsoup.
The libsoup library was originally created for the GNOME project’s email client and has since grown to be a very featureful HTTP implementation, now maintained by Igalia.
+At a high level, the main task that libsoup does is manage connections and queued requests to websites and then efficiently streams the responses back to WPE. Properly implementing HTTP is a fairly large task, and this is a non-exhaustive list of features it implements: HTTP/1.1, HTTP/2, WebSockets, cookies, decompression, multiple authentication standards, HSTS, and HTTP proxies.
+On its own, libsoup is really focused on the HTTP layer and uses the GLib library to implement many of its networking features in a portable way. This is where TCP, DNS, and TLS are handled. It is also directly used by WebKit for URI parsing and DNS pre-caching.
+Using GLib also helps standardize behavior across modern Linux systems. It allows configuration of a global proxy resolver that WebKit, along with other applications, can use.
+Another unique detail of our stack is that TLS is fully abstracted inside of GLib by a project called GLib-Networking. This project provides multiple implementations of TLS that can be chosen at runtime, including OpenSSL and gnutls on Linux. The benefit here is that clients can choose the implementation they prefer—whether for licensing, certification, or technical reasons.
+Let’s go step by step to see some real world usage. If we call webkit_web_view_load_uri() for a new domain it will:
ResourceRequest in WebCore that represents an HTTP request with a few basic headers set.
+ResourceRequestSoup will create its own internal representation for the request using soup_message_new_for_uri().NetworkProcess to load this request as a NetworkDataTask.NetworkDataTaskSoup will send/receive the request/response with soup_session_send() which queues the message to be sent.GSocketClient which does a DNS lookup and TCP connection.
+GTlsClientConnection will use a library such as gnutls to do a TLS handshake.NetworkProcess back to the main process as a ResourceResponse eventually loading the data in the WebProcess.In conclusion, WebKit provides a very flexible abstraction for platforms, and WPE leverages mature system libraries to provide a portable implementation. It has many layers, but they are all well organized and suited to their tasks.
+If you are working with WPE and are interested in collaborating, feel free to contact us. If you are interested in working with Igalia, you can apply here.
+ + + +In the previous posts, my colleagues Claudio and Miguel wrote respectively about the major components of the project and, specifically, the graphics architecture of WPE. Today, you’ll see our efforts to improve the quality of both WPE and the experience of working and using it. While the previous entries in this blog post series about WPE aren’t necessarily required in order to read this one, we recommend you to starting with the first post in the series.
+Testing is an essential part of the WebKit project, primarily due to the large number of use cases covered by HTML/CSS/Javascript specifications and the need for the project to work correctly in a wide range of configurations.
+As an official port of WebKit, WPE uses the former’s testing infrastructure, based on BuildBot. There are two primary servers, one working as an early warning system by testing the patches before they’re committed to the main repository, and another for more extensive testing after accepting the incoming changes.
+
+Currently, the WPE testing bots target debug and release configurations using the Flatpak SDK (more on it later in this article) on 64bit Intel-based Linux Debian systems. We have plans of adding bots running on Raspberry Pi boards in the future. Alongside nightly testing, we keep builder bots covering the Ubuntu LTS/Debian versions we support. After August 14th, 2022, the earliest supported versions will be Ubuntu 20.04 LTS and Debian 11 (Bullseye).
+Initially, the WPE builder bots build WPE in both release and debug configurations and feed the built packages into the tester bots, which run some test suites according to their configuration, each suite focused in one aspect of the project:
+Due to a large number of tests and the fast development of both WebKit and the specifications—it’s not uncommon to have dozens of daily commits touching dozens of tests—it’s hard to keep the testing bots green.
+For example, while we try to make the tests work on all platforms, many old layout tests use the -expected.txt scheme, where the render tree is printed in a textual format with the text sized in pixels for every node. While this works fine in most cases, many tests have minor differences between the expected result in the Mac platform and the WPE/GTK platform. One of the causes is the font rendering particularities of each port.
Thankfully, this situation improved significantly since the beginning of the project. Among the efforts, many tests are now using a “reference” HTML file, which are HTML files that render to the same expected result as the test case, so both the test case and the reference will use the same font rendering scheme and can be compared pixel by pixel.
+This section focuses on the experience of building and running WPE in a regular Linux x86–64 system. In a future post, we’ll cover building for and running on embedded devices.
+Recently, WebKit moved to GitHub, so you can clone it directly from there:
+$ mkdir ~/dev
+$ git clone https://github.com/WebKit/WebKit.git
+Note: Due to the size of the project history, you might want to use --depth=1 to clone a single revision, followed by git pull --unshallow from inside the cloned repository to fetch the history if needed.
There’s more information in WebKit’s GitHub wiki about setting up the git checkout for contributing code back to WebKit. It’ll set up some git hooks to do some tasks required by the project, like formatting the commit message and automatically linking the pull request to the Bugzilla issue.
+All commands in the following sections are run from inside the cloned repository.
+Like most complex software projects, WebKit has a reasonably extensive list of dependencies. Keeping a reference set of their versions frozen during development is desirable to make it easier to reproduce bugs and test results. In older times, WPE and WebKitGTK used JHBuild to freeze a set of dependencies. While this worked for a long time, it did not cover all dependencies. Sometimes, there could be minor differences in the layout tests between the reference test bots and the developer machine due to some dependency resolved by the host system outside JHBuild.
+To improve reproducibility, since 2020, WPE and WebKitGTK have been using an SDK based on Flatpak (kudos to my colleagues Thibault Saunier and Philippe Normand), with a much more extensive dependency coverage and isolation from the host system. Alongside the dependencies, it ships some tools like rr and supports tools like clangd. Almost all bots enable this SDK, the exception being the LTS/Stable bots; as in the latter, we want to build with the already available packages in each distribution.
$ ./Tools/Scripts/update-webkit-flatpak
+The command will set up the local flatpak repository at ./WebKitBuild/UserFlatpak with the downloaded SDK and create some bundled icecc toolchains. This enables distributed builds in local networks…
Once the SDK download finishes, you can use the helper script ./Tools/Scripts/build-webkit, which wraps the cmake command with some pre-set options commonly used in normal development, like enabling developer-only features usually disabled in regular builds. Manually invoking cmake is possible, although usually only when you want more control over the build. To build WPE in release mode, use:
$ ./Tools/Scripts/build-webkit --release --wpe
+Optionally, you can pass it multiple arguments to be fed directly to make or cmake with the switches --makeargs=... and --cmakeargs=..., respectively. For example, --makeargs="-j8" will limit make to 8 parallel jobs and --cmakeargs="-DENABLE_GAMEPAD=1" will enable gamepad support (requires libmanette, bundled in the SDK).
The first build might take a while (up to almost one hour in a regular laptop). Fortunately, the SDK uses ccache to avoid recompiling the same object files, so subsequent builds without significant changes usually are faster. For more info on speeding the build, check the wiki.
To run Cog, the reference WPE browser, you need a Wayland server, which is common in most Linux systems nowadays.
+$ ./Tools/Scripts/run-minibrowser --wpe --release https://wpewebkit.org/
+
+To run the API tests, which reside in Tools/TestWebKitAPI/Tests/, you can use the following command:
$ ./Tools/Scripts/run-wpe-tests --release --display-server=headless
+Other test suites:
+./Tools/Scripts/run-wpe-tests./Tools/Scripts/run-javascriptcore-tests./Tools/Scripts/run-webdriver-testsAs stated when we described the test suites, the main challenge in testing is keeping up with the fast pace of development, as it’s not uncommon to have some revisions updating hundreds of tests.
+After hacking locally, you can submit your changes following the workflow listed in the WebKit wiki.
+If you don’t want to build your WPE build or image, there are some options to get a taste of WPE listed on our website.
+With this, we conclude this brief overview of WPE automated testing and the main tools we use in our daily work with WPE. In future posts in this area we’ll go deeper in other subjects like testing on embedded boards and debugging practices.
+If this post got you interested in collaborating with WPE development, or you are in need of a web engine to run on your embedded device, feel free to contact us. We’ll be pleased to help!
+We also have open positions at the WebKit team at Igalia. If you’re motivated by this field and you’re interested in developing your career around it, you can apply here!
+ + + +In the previous posts of this series, various aspects of the WPE port architecture were covered. Besides maintaining and advancing the WPE port according to our customers’ needs, Igalia also participates in the development of the WebCore engine itself, which is shared by all WebKit ports. WebCore is the part of the browser engine that does the heavy lifting: it contains all functionality necessary to load, parse, lay out, and paint Web content.
+Since late 2019, Igalia has been working on a new SVG engine, dubbed Layer-Based SVG Engine (LBSE), that will unify the HTML/SVG rendering pipelines in WebCore. This will resolve long-standing design issues of the “legacy” SVG engine and unlock a bunch of new exciting possibilities for Web developers to get creative with SVG. Hardware-accelerated compositing, driven by CSS transform animations, 3D perspective transformations for arbitrary SVG elements, CSS z-index support for all SVG graphics elements, and proper coverage rectangle computations and repaints are just a few highlights of the capabilities the future SVG engine will offer.
In this article, an overview is given about the problems that LBSE aims to solve, and the importance of a performant, well-integrated SVG engine especially for the embedded market. Finally, the current upstreaming status is summarized including an outlook for the year 2023.
+Before diving into the technical topics, let’s take a few minutes to recap the motivations behind the LBSE work, and explain the importance of a well-integrated, performant SVG engine in WebKit, especially for the embedded market.
+Many of our customers build products that utilize a Linux-powered embedded device, typically using non-x86 CPUs, custom displays with built-in input capabilities (e.g., capacitive touchscreens) often without large amounts of memory or even permanent storage. The software stack for these devices usually consists of a device-specific Linux distribution, containing the proprietary network, GPU, and drivers for the embedded device - the vendor-approved “reference distribution”.
+No matter what type of product is built nowadays, many of them need an active Internet connection, to e.g. update their software stack and access additional information. Besides the UI needed to control the product, a lot of additional dialogs, wizards and menus have to be provided to be able to alter the devices’ “system settings”, such as date/time information, time zones, display brightness, WiFi credentials, Bluetooth settings, and so on.
+A variety of toolkits exist that assist in writing GUI applications for embedded devices, with a few open-source projects on the market, as well as commercial products providing closed-source, proprietary solutions, that specifically target the embedded market and are often optimized for specific target device families, e.g. certain ARM processors / certain GPUs.
+If the need arises, not only to communicate with the Internet but also to display arbitrary Web content, WPE comes into play. As presented in the first post in this series, the flexible and modular WPE architecture makes it an ideal choice for any product in the embedded market that needs Web browsing abilities. The GLib/C-based WPE public APIs allow for customization of the browsing engine and its settings (react on page load/input events, inject custom JS objects, modify style sheets, etc.) and allow the embedder to control/monitor all relevant Web browsing-related activities.
+With a full-fledged Web engine at hand, one might ponder if it is feasible to replace the whole native GUI stack with a set of Web pages/applications, and only use WPE to paint the UI in full-screen mode, thus migrating away from native GUI applications — following the trend in the desktop market. The number of organizations migrating native GUI applications into Web applications is rapidly increasing, since there are compelling reasons for Web apps: “write once, use everywhere”, avoiding vendor lock-in, easy/reliable deployment and update mechanisms, and efficient test/development cycles (local in-browser testing!).
+Due to the sheer capabilities of the Web platform, it has grown to an environment in which any kind of application can be developed – ranging from video editing applications, big data processing pipelines to 3D games, all using JS/WebAssembly in a browser, presented using HTML5/CSS. And as an important bonus: in 2023, it’s much easier to find and attract talented Web developers and designers that are fluent in HTML/CSS/JS, than those that are comfortable designing UI applications in proprietary, closed-source C/C++ frameworks.
+A long-term customer, successfully using WPE in their products, had very similar thoughts and carried out a study, contracting external Web designers to build a complete UI prototype using Web technology. The mock-up made extensive use of SVG2, embedded inline into HTML5 documents or via other mechanisms (CSS background-image, etc.). The UI fulfilled all expectations and worked great in Blink and WebKit-based browsers, delivering smooth animations. On the target device, however, the performance was too slow, far away from usable. A thorough analysis revealed that large parts of the Web page were constantly repainted, and layout operations were repeated for every frame when animations were active. The accumulated time to display a new frame during animations was in the order of a few milliseconds on desktop machines, but took 20-25 milliseconds on the target device, making smooth 60 FPS animations impossible.
The poor performance is not the result of shortcomings in the WPE port of WebKit: when replacing the aforementioned animated SVG document fragments with HTML/CSS “equivalents” (e.g. simulating SVG circles with CSS border-radius tricks) the performance issue vanisheed. Why? SVG lacks support for a key feature called accelerated compositing, which has been available for HTML/CSS since its introduction more than a decade ago. This compositing heavily relies on the Layer Tree, which is unaware of SVG. Extending the Layer Tree implementation to account for SVG is the main motivation for LBSE.
If you are unfamiliar with the concepts of Render Tree and Layer Tree, you might want to read the “Key concepts” section of an earlier LBSE design document, which provides an overview of the topic.
+The LBSE effort began in October 2019 as a research project, to find out an ideal design for the SVG Render Tree, that allows SVG to re-use the existing Layer Tree implementation with minimal changes. The aim for LBSE is to share as much code as possible with the HTML/CSS implementation, removing the need for things like SVG specific clipping/masking/filter code and disjoint HTML counterparts for the same operations.
+After an extensive phase of experimentation, two abandoned approaches, and a long time spent on regression fixing, the LBSE prototype was finally finished after almost two years of work. It passed all 60k+ WebKit layout tests and offered initial support for compositing, 3D transformations, z-index, and more. The intent was to prove that we can reach feature parity with the legacy SVG engine and retrieve the very same visual results, pixel-by-pixel (except for progressions of LBSE). Shortly after the finalization, the prototype was presented during the WebKit contributors meeting in 2021.
As the name “prototype” indicates, LBSE was not ready for integration into WebKit at this point. It replaced the old SVG engine with a new one, resulting in a monolithic patch exceeding 650 KB of code changes. External contributions generally demand small patches, with ChangeLogs, tests, etc. – no conscientious reviewer in any company would approve a patch replacing a core component of a browser engine in one shot. Splitting up into small pieces is also not going to work, since SVG needs to be kept intact upstream all the time. Duplicating the whole SVG engine? Not practicable either. With that problem in mind, a fruitful discussion took place with Apple during and after the WebKit contributors meeting: a realistic upstreaming strategy was defined - thanks Simon Fraser for suggesting a pragmatic approach!
+The idea is simple: bootstrap LBSE in parallel to the legacy SVG engine. Upstream LBSE behind a compile-time flag and additionally a runtime setting. This way the LBSE code is compiled by the EWS bots during upstreaming (rules out bit-rot) and we gain the ability to turn LBSE on, selectively, from our layout tests – very useful during early bootstrapping. For WebKit, that strategy is the best – for LBSE another major effort is necessary: moving from a drop-in replacement approach to a dual-stack SVG engine: LBSE + legacy built into the same WebKit binaries. At least the timing was good since a split-up into small pieces was needed anyhow for upstreaming. Time to dissect the huge branch into logical, atomic pieces with proper change logs.
+Before we jump to the upstreaming status, one question should be answered, that came up during the WebKit contributors meeting and also during various discussions: why don’t you just fix the existing SVG engine and instead propose a new one - isn’t that too risky for Web compatibility?
+
+There was no initial intention to come up with a new SVG engine. During LBSE development it became apparent how much SVG-specific code can be erased when unifying certain aspects with HTML/CSS. After carrying out the integration work, layout/painting and hit-testing work fundamentally different than before. Since that time, LBSE is labeled as a “new SVG engine”, even though the SVG DOM tree part remained almost identical. Web compatibility will improve with LBSE: a few long-standing, critical interop issues with other browser vendors are solved in LBSE. Therefore, there are no concerns regarding Web compatibility risks from our side.
+To answer the initial question, whether it is possible to fix the existing SVG engine to add layer support without adding a “new” SVG engine in parallel? Short answer: no.
+In the following section, it is shown that adding support for layers implies changing the class hierarchy of the SVG render tree. All SVG renderers need to inherit from RenderLayerModelObject – a change like this cannot be split up easily into small, atomic pieces. Improving the design is difficult if there’s a requirement to keep the SVG engine working all the time upstream: all patches in that direction end up being large as many renderers have to be changed at the same time. Having distinct, LBSE-only implementations of SVG renderers, independent of the legacy engine, leaves a lot of freedom to strive for an optimal design, free of legacy constraints, and avoids huge patches that are impossible to review.
Let’s close the introduction and review the upstreaming status, and discuss where we stand today.
+To unify the HTML/CSS and SVG rendering pipelines there are two possible paths to choose from: teach the Layer Tree about the SVG Render Tree and its rendering model, or vice-versa. For the latter path, the HTML/CSS-specific RenderLayer needs to split into HTML/SVG subclasses and a base class, that is constructible from non-RenderLayerModelObject-derived renderers. The layer management code currently in RenderLayerModelObject would need to move into another place, and so forth. This invasive approach can potentially break lots of things. Besides that danger, many places in the layer/compositing system would need subtle changes to account for the specific needs of SVG (e.g. different coordinate system origin/convention).
Therefore the former route was chosen, which requires transforming the SVG render tree class hierarchy, such that all renderers that need to manage layers derive from RenderLayerModelObject. Using this approach support, for SVG can be added to the layer/compositing system in a non-invasive manner, with only a minimum of SVG-specific changes. The following class hierarchy diagrams illustrate the planned changes.
+
+The first graph shows the class hierarchy of the render tree in the legacy SVG engine: RenderObject is the base class for all nodes in the render tree. RenderBoxModelObject is the common base class for all HTML/CSS renderers. It inherits from RenderLayerModelObject, potentially allowing HTML renderers to create layers. For the SVG part of the render tree, there is no common base class shared by all the SVG renderers, for historical reasons.
The second graph shows only the SVG renderers of the LBSE class hierarchy. In that design, all relevant SVG renderers may create/destroy/manage layers, via RenderLayerModelObject. More information regarding the challenges can be found in the earlier LBSE design document.
The upstreaming work started in December 2021, with the introduction of a new layer-aware root renderer for the SVG render subtree: RenderSVGRoot. The existing RenderSVGRoot class was renamed to LegacyRenderSVGRoot (as well as any files, comments, etc.) and all call sites and build systems were adapted. Afterward, a stub implementation of a layer-aware RenderSVGRoot class was added and assured that the new renderer is created for the corresponding SVG DOM element if LBSE is activated.
That process needs to be repeated for all SVG renderers that have substantially changed in LBSE and thus deserve an LBSE-specific upstream implementation. For all other cases, in-file #if ENABLE(LAYER_BASED_SVG_ENGINE) ... #endif blocks will be used to encapsulate LBSE-specific behavior. For example, RenderSVGText / RenderSVGInlineText are almost identical in LBSE downstream, compared to their legacy variants; thus, they are going to share the renderer implementation between the legacy SVG engine and LBSE.
The multi-step procedure was repeated for RenderSVGModelObject (the base class for SVG graphics primitives), RenderSVGShape, RenderSVGRect, and RenderSVGContainer. Core functionality such as laying out children of a container, previously hidden in SVGRenderSupport::layoutChildren() in the legacy SVG engine, now lives in a dedicated class: SVGContainerLayout. Computing the various SVG bounding boxes - object/stroke/decorated bounding box - is precisely specified in SVG2 and got a dedicated implementation as the SVGBoundingBoxComputation class, instead of fragmenting the algorithms all over the SVG render tree as in the legacy SVG engine.
By February 2022, enough functionality was in place to construct the LBSE render tree for basic SVG documents, utilizing nested containers and rectangles as leaves. While this doesn’t sound exciting at all, it provided an ideal environment to implement support for SVG in the RenderLayer-related code - before converting all SVG renderers to LBSE, and before implementing painting in the SVG renderers.
Both RenderLayer and RenderLayerBacking query CSS geometry information such as border box, padding box, or content box from their associated renderer, which is expected to be a RenderBox in many places. This is incorrect for SVG: RenderSVGModelObject inherits from RenderLayerModelObject, but not from RenderBox since it doesn’t adhere to the CSS box model. Various call sites cast the associated renderer to RenderBox to call e.g. borderBoxRect() to retrieve the border box rectangle. There are similar accessors in SVG to query the geometry, but there is no equivalent of a border box or other CSS concetps in SVG. Therefore, we extended RenderSVGModelObject to provide a CSS box model view of an SVG renderer, by offering methods such as borderBoxRectEquivalent() or visualOverflowRectEquivalent() that return geometry information in the same coordinate system using the same conventions as their HTML/CSS counterparts.
We also refactored RenderLayer to use a proxy method - rendererBorderBoxRect() - that provides access to the borderBoxRect() for HTML and the borderBoxRectEquivalent() for SVG renderers, and the same fix to RenderLayerBacking. With these fixes in place, support to position and size SVG layers and to compute overflow information could be added – both pre-conditions to enable painting.
By March 2022, LBSE was able to paint basic SVG documents - a major milestone for the bootstrapping process, demonstrating that the layer painting code was functional for SVG. It was time to move on to transformations: implementing RenderSVGTransformableContainer (e.g. <g> elements with a non-identity transform attribute or CSS transform property) and CSS/SVG transform support for all other graphics primitives, utilizing the RenderLayer-based CSS Transform implementation. As preparation, the existing code was reviewed and cleaned up: transform-origin computation was decoupled from CTM computation (CTM = current transformation matrix, see CSS Transforms Module Level 1) and transform-box computations were unified in a single place.
In April 2022, 2D transforms were enabled and became fully functional a few weeks later. Besides missing compositing support upstream, downstream work showed that enabling 3D transforms for SVG required fixing a decade-old bug that made the computed perspective transformation dependent on the choice of transform-origin. That became apparent when testing the layer code with SVG, which uses different default values for certain transform-related CSS properties than HTML does: transform-box: view-box and transform-origin: 0 0 are the relevant defaults for SVG, referring to the top-left corner of nearest SVG viewport vs. the center of the element in HTML.
By May 2022, the legacy SVG text rendering code was altered to be usable for LBSE as well. At this point, it made sense to run layout tests using LBSE. Previously most tests were expected to fail, as most either utilize text, paths, or shapes, and sometimes all three together. LBSE render tree text dumps (dumping the parsed render tree structure in a text file) were added for all tests in the LayoutTests/svg subdirectory, as well as a new pixel test baseline (screenshots of the rendering as PNGs), generated using the legacy SVG engine, to verify that LBSE produces pixel-accurate results. All upcoming LBSE patches are expected to change the expected layout test result baseline, and/or the TestExpectations file, depending on the type of patch. This will ease the reviewing process a lot for future patches.
To further proceed, a test-driven approach was used to prioritize the implementation of the missing functionality. At that time, missing viewBox support for outer <svg> elements was causing many broken tests. The effect of the transformation induced by the viewBox attribute, specified on outer <svg> elements, cannot be implemented as an additional CSS transformation applied to the outermost <svg> element, as that would affect the painted dimensions of the SVG document, which are subject to the CSS width/height properties and the size negotiation logic only. The viewBox attribute is supposed to only affect the visual appearance of the descendants, by establishing a new local coordinate system for them. The legacy SVG engine manually handled the viewBox-induced transformation in various places throughout LegacyRenderSVGRoot, to only affect the painting of the descendants and not e.g. the position/dimension of the border surrounding the <svg>, if the CSS border property is specified. In LBSE, transformations are handled on RenderLayer-level and not in the renderers anymore.
By July 2022, after testing different approaches, a proper solution to add viewBox support was upstreamed. The chosen solution makes use of another CSS concept that arises in the context of generated content: “anonymous boxes”. The idea is to wrap the direct descendants of RenderSVGRoot in an anonymous RenderSVGViewportContainer (“anonymous” = no associated DOM element) and apply the viewBox transformation as a regular CSS transformation on the anonymous renderer. With that approach, LBSE is left with just a single, unified viewBox implementation, without error-prone special cases in RenderSVGRoot, unlike the legacy SVG engine which has two disjoint implementations in LegacyRenderSVGViewportContainer and LegacyRenderSVGRoot.
After the summer holidays, in August 2022, the next major milestone was reached: enabling compositing support for arbitrary SVG elements, bringing z-index support, hardware-accelerated compositing and 3D transforms to SVG. This time all lessons learned from the previous LBSE prototypes were taken into account, resulting in a complete compositing implementation, that works in various scenarios: different transform-box / transform-origin combinations, inline SVG enclosed by absolute/relative positioned CSS boxes and many more, all way more polished than in the “final” LBSE prototype.
The aforementioned patch contained a fix for a long-standing bug (“Composited elements appear pixelated when scaled up using transform”), that made composited elements look blurry when scaling up with a CSS transform animation. The so-called “backing scale factor” of the associated GraphicLayers (see here for details about the role of GraphicLayer in the compositing system) never changes during the animation. Therefore, the rendered image was scaled up instead of re-rendering the content at the right scale. LBSE now enforces updates of that scale factor, to avoid blurry SVGs. The fix is not activated yet for HTML as that requires more thought - see the previously-linked bug report for details.
With all the new features in place and covered by tests, it was time to finish the remaining SVG renderers: RenderSVGEllipse, RenderSVGPath and RenderSVGViewportContainer (for inner <svg> elements), RenderSVGHiddenContainer, RenderSVGImage, and RenderSVGForeignObject. A proper <foreignObject> implementation was lacking in WebKit for 15+ years, due to the fundamental problem that the layer tree was not aware of the SVG subtree. The LBSE variant of RenderSVGForeignObject looks trivial, yet offers a fully compatible <foreignObject> implementation - for the first time without issues with non-static positioned content as a direct child of <foreignObject>, at least a few weeks later after it landed.
Returning to the test-driven approach, the next best target to fix was text rendering, which was working but not pixel-perfect. The legacy SVG engine takes into account the transformation from the text element up to the topmost renderer when computing the effective “on-screen” font size used to select a font for drawing/measuring, during layout time. LBSE needed a way to calculate the CTM for a given SVG renderer, up to a given ancestor renderer (or root), taking into account all possible transformation scenarios, including CSS transform, translate, rotate, SVG transform attribute, shifts due to transform-origin, perspective transformations, and much more. The same functionality is required to implement getCTM() / getScreenCTM().
By the end of August 2022, SVGLayerTransformComputation was added that re-used the existing mapLocalToContainer() / TranformState API to obtain the CTM. The CTM construction and ancestor chain walk - to accumulate the final transformation matrix - is performed by mapLocalToContainer() and no longer needs a special, incomplete SVG approach: the existing general approach now works for SVG too.
September 2022 was mostly devoted to bug fixes related to pixel-snapping. Outermost <svg> elements were not always enforcing stacking contexts and failed to align to device pixels. All other elements behaved fine with respect to pixel snapping (not applied for SVG elements) unless compositing layers were active. In that case, a RenderLayerBacking code path was used that unconditionally applied pixel-snapping - avoid that for SVG.
By October 2022 LBSE could properly display SVGs embedded into HTML host documents via <object> elements – the size negotiation logic failed to take into account the LBSE-specific renderers before. CSS background-image / list-image / HTML <img> / etc. were fixed as well. Zooming and panning support were implemented and improved compared to the legacy engine. Along the way an important bug was fixed, one that other browsers had already fixed back in 2014. The bug caused percentage-sized documents (e.g. width: 100%; height: 100%) that also specify a viewBox to always keep the document size, regardless of the zoom level. Thus, upon zooming, only the stroke width enlarged, but not the boundaries of the document, and thus scrollbars never appeared.
Over the following weeks, text-related issues had to be fixed, which were responsible for a bunch of the remaining test issues. Transformed text did not render, which turned out to be a simple mistake. More tests were upstreamed, related to compositing and transformations. More test coverage revealed that transform changes were not handled consistently – it took a period of investigation to land a proper fix. SVG transform / SMIL <animateMotion> / SMIL <animateTransform> / CSS transform changes are now handled consistently in LBSE, leading to proper repaints, as expected.
+Transformation support can be considered complete and properly handled both during the painting and layout phases. Dynamic changes at runtime are correctly triggering invalidations. However, the Web-exposed SVG DOM API that allows querying the transformation matrices of SVG elements, such as getCTM() and getScreenCTM(), was still missing. By November 2022 a complete implementation was upstreamed, that utilized the new SVGLayerTransformComputation class to construct the desired transformation matrices. This way the same internal API is used for painting/layout/hit-testing and implementing the SVG DOM accessors.
By December 2022 LBSE was in a good shape: most important architectural changes were upstreamed and the most basic features were implemented. The year closed with a proposed patch that will avoid re-layout when an element’s transform changes. The legacy SVG engine always needs a re-layout if transform changes, as the size of each ancestor can depend on the presence of transformations on the child elements – a bad design decision two decades ago that LBSE will resolve. Only repainting should happen, but no layouts, in LBSE.
+Let’s move on to 2023, and recap what’s still missing in LBSE.
+Besides fixing all remaining test regressions (see LayoutTests/platform/mac-ventura-wk2-lbse-text/TestExpectations) “SVG resources” are missing in LBSE. That includes all “paint servers” and advanced painting operations: there is no support for linear/radial gradients, no support for patterns, and no support for clipping/masking and filters.
From the painting capabilities, LBSE is still in a basic shape. However, this was intentional, since a lot of the existing code for SVG resource handling is no longer needed in LBSE. Clipping/masking and filters will be handled via RenderLayer, reusing the existing HTML/CSS implementations. Temporary ImageBuffers are no longer needed for clipping, and thus there is no need to cache the “per client” state in the resource system (e.g. re-using the cached clipping mask for repainting). This will simplify the implementation of the “SVG resources” a lot.
Therefore the first task in 2023 is to implement clipping, then masking, gradients, patterns, and as the last item, filters, since they require a substantial amount of refactoring in RenderLayerFilters.
+Note that these implementations are already complete in LBSE downstream and do not need to be invented from scratch. The first patches in that direction should be up for review by February 2023.
After all “SVG resources” are implemented in LBSE, feature parity is almost there and performance work will follow afterward. WebKit has a golden rule to never ship a performance regression; therefore, LBSE needs to be at least as fast in the standard performance tests, such as MotionMark, before it can replace the legacy engine. Currently, LBSE is slower than the legacy engine with respect to static rendering performance. Quoting numbers does not help at present, since the problem is well understood and will be resolved in the following months.
+LBSE currently creates more RenderLayer objects than necessary: for each renderer, unconditionally. This is a great stress test of the layer system, and helpful for bootstrapping, but the associated overhead and complexity are simply not necessary for many cases, and actively hurt performance. LBSE already outperforms the legacy SVG engine whenever animated content is viewed, if it benefits from the hardware acceleration in LBSE.
2023 will be an exciting year, and hopefully brings LBSE to the masses, stay tuned!
+“A picture is worth a thousand words”, so we’d like to share with you the videos shown during the WebKit contributors meeting in 2022 that demo the LBSE capabilities. Be sure to check them out so you can get a good picture of the state of the work. Enjoy!
+Accelerated 2D transforms (Tiger)
++ +
+Accelerated 3D transform (Tiger)
++ +
++ +
++ +
+We at Igalia are doing our best to fulfill the mission and complete the LBSE upstreaming as fast as possible. In the meanwhile, let us know about your thoughts:
+Thanks for your attention! Be sure to keep an eye on our “Upstreaming status” page at GitHub to follow LBSE development.
+ + + +
+ This article was written by Nikolas Zimmermann. Most Web content is designed entirely for screen display—and there is a +lot of it—so it will spend its life in the somewhat restricted sandbox +implemented by a web browser. But rich user interfaces using Web technologies +in all kinds of consumer devices require some degree of integration, an +escape hatch to interact with the rest of their software and hardware. This is +where a Web engine like WPE designed to be embeddable shines: not only does +WPE provide a stable API, it is also comprehensive in +supporting a number of ways to integrate with its environment further than +the plethora of available Web platform APIs.
+Integrating a “Web view” (the main entry point of the WPE embedding +API) involves providing extension points, which allow the +Web content (HTML/CSS/JavaScript) it loads to call into native code provided +by the client application (typically written in C/C++) from JavaScript, and +vice versa. There are a number of ways in which this can be achieved:
+In this post we will explore the first two, as they can support many +interesting use cases without introducing the additional complexity of +extending the JavaScript virtual machine. Let’s dive in!
+We will be referring to the code of a tiny browser written for the occasion.
+Telling WebKit how to call our native code involves creating a
+WebKitUserContentManager, customizing it, and then
+associating it with web views during their creation. The only exception to
+this are URI scheme handlers, which are registered
+using webkit_web_context_register_uri_scheme(). This
+minimal browser includes an on_create_view function, which is the perfect
+place to do the configuration:
static WebKitWebView*
on_create_view(CogShell *shell, CogPlatform *platform)
{
g_autoptr(GError) error = NULL;
WebKitWebViewBackend *view_backend = cog_platform_get_view_backend(platform, NULL, &error);
if (!view_backend)
g_error("Cannot obtain view backend: %s", error->message);
g_autoptr(WebKitUserContentManager) content_manager = create_content_manager(); /** NEW! **/
configure_web_context(cog_shell_get_web_context(shell)); /** NEW! **/
g_autoptr(WebKitWebView) web_view =
g_object_new(WEBKIT_TYPE_WEB_VIEW,
"user-content-manager", content_manager, /** NEW! **/
"settings", cog_shell_get_web_settings(shell),
"web-context", cog_shell_get_web_context(shell),
"backend", view_backend,
NULL);
cog_platform_init_web_view(platform, web_view);
webkit_web_view_load_uri(web_view, s_starturl);
return g_steal_pointer(&web_view);
}g_autoptr?
+ Does it relate to g_steal_pointer?
+ This does not look like C!In the shown code examples, g_autoptr(T) is a preprocessor macro provided by
+GLib that declares a pointer variable of the T type, and arranges for
+freeing resources automatically when the variable goes out of scope. For
+objects this results in
+g_object_unref()
+being called.
Internally the macro takes advantage of the __attribute__((cleanup, ...))
+compiler extension, which is supported by GCC and Clang. GLib also includes a
+convenience
+macro that
+can be used to define cleanups for your own types.
As for g_steal_pointer, it is useful to indicate that the ownership of a
+pointer declared with g_autoptr is transferred outside from the current
+scope. The function returns the same pointer passed as parameter and
+resets it to NULL, thus preventing cleanup functions from running.
The size has been kept small thanks to reusing code from the Cog +core library. As a bonus, it should +run on Wayland, X11, and even on a bare display using the DRM/KMS +subsystem directly. Compiling and running it, assuming you already have the +dependencies installed, should be as easy as running:
+cc -o minicog minicog.c $(pkg-config cogcore --libs --cflags)
./minicog wpewebkit.orgIf the current session kind is not automatically detected, a second parameter
+can be used to manually choose among wl (Wayland), x11, drm, and so on:
./minicog wpewebkit.org x11The full, unmodified source for this minimal browser is included right below.
+minicog.c source
+ (Gist)
+
+/*
+ * SPDX-License-Identifier: MIT
+ *
+ * cc -o minicog minicog.c $(pkg-config wpe-webkit-1.1 cogcore --cflags --libs)
+ */
+
+#include <cog/cog.h>
+
+static const char *s_starturl = NULL;
+
+static WebKitWebView*
+on_create_view(CogShell *shell, CogPlatform *platform)
+{
+ g_autoptr(GError) error = NULL;
+ WebKitWebViewBackend *view_backend = cog_platform_get_view_backend(platform, NULL, &error);
+ if (!view_backend)
+ g_error("Cannot obtain view backend: %s", error->message);
+
+ g_autoptr(WebKitWebView) web_view =
+ g_object_new(WEBKIT_TYPE_WEB_VIEW,
+ "settings", cog_shell_get_web_settings(shell),
+ "web-context", cog_shell_get_web_context(shell),
+ "backend", view_backend,
+ NULL);
+ cog_platform_init_web_view(platform, web_view);
+ webkit_web_view_load_uri(web_view, s_starturl);
+ return g_steal_pointer(&web_view);
+}
+
+int
+main(int argc, char *argv[])
+{
+ g_set_application_name("minicog");
+
+ if (argc != 2 && argc != 3) {
+ g_printerr("Usage: %s [URL [platform]]\n", argv[0]);
+ return EXIT_FAILURE;
+ }
+
+ g_autoptr(GError) error = NULL;
+ if (!(s_starturl = cog_uri_guess_from_user_input(argv[1], TRUE, &error)))
+ g_error("Invalid URL '%s': %s", argv[1], error->message);
+
+ cog_modules_add_directory(COG_MODULEDIR);
+
+ g_autoptr(GApplication) app = g_application_new(NULL, G_APPLICATION_DEFAULT_FLAGS);
+ g_autoptr(CogShell) shell = cog_shell_new("minicog", FALSE);
+ g_autoptr(CogPlatform) platform =
+ cog_platform_new((argc == 3) ? argv[2] : g_getenv("COG_PLATFORM"), &error);
+ if (!platform)
+ g_error("Cannot create platform: %s", error->message);
+
+ if (!cog_platform_setup(platform, shell, "", &error))
+ g_error("Cannot setup platform: %s\n", error->message);
+
+ g_signal_connect(shell, "create-view", G_CALLBACK(on_create_view), platform);
+ g_signal_connect_swapped(app, "shutdown", G_CALLBACK(cog_shell_shutdown), shell);
+ g_signal_connect_swapped(app, "startup", G_CALLBACK(cog_shell_startup), shell);
+ g_signal_connect(app, "activate", G_CALLBACK(g_application_hold), NULL);
+
+ return g_application_run(app, 1, argv);
+}
+
+ A URI scheme handler allows “teaching” the web engine how to handle any
+load (pages, subresources, the Fetch API,
+XmlHttpRequest, …)—if you ever wondered how Firefox implements
+about:config or how Chromium does chrome://flags, this is it. Also,
+WPE WebKit has public API for this. Roughly:
Let’s add an echo handler to our minimal browser that +replies back with the requested URI. Registering the scheme is +straightforward enough:
+static void
configure_web_context(WebKitWebContext *context)
{
webkit_web_context_register_uri_scheme(context,
"echo",
handle_echo_request,
NULL /* userdata */,
NULL /* destroy_notify */);
}The userdata parameter above is a convention used in many C libraries, and
+specially in these based on GLib when there are callback functions involved.
+It allows the user to supply a pointer to arbitrary data, which will be
+passed later on as a parameter to the callback (handle_echo_request in the
+example) when it gets invoked later on.
As for the destroy_notify parameter, it allows passing a function with the
+signature void func(void*) (type
+GDestroyNotify) which
+is invoked with userdata as the argument once the user data is no longer
+needed. In the example above, this callback function would be invoked when the
+URI scheme is unregistered. Or, from a different perspective, this callback is
+used to notify that the user data can now be destroyed.
One way of implementing handle_echo_request() could be wrapping the request
+URI, which is part of the WebKitURISchemeRequest parameter to the handler,
+stash it into a GBytes
+container, and create an input stream to read back its
+contents:
static void
handle_echo_request(WebKitURISchemeRequest *request, void *userdata)
{
const char *request_uri = webkit_uri_scheme_request_get_uri(request);
g_print("Request URI: %s\n", request_uri);
g_autoptr(GBytes) data = g_bytes_new(request_uri, strlen(request_uri));
g_autoptr(GInputStream) stream = g_memory_input_stream_new_from_bytes(data);
webkit_uri_scheme_request_finish(request, stream, g_bytes_get_size(data), "text/plain");
}Note how we need to tell WebKit how to finish the load +request, +in this case only with the data stream, but it is possible to have more +control of the +response +or return an +error.
+With these changes, it is now possible to make page loads from the new custom +URI scheme:
+
+ The main roadblock one may find when using custom URI schemes is that loads
+are affected by CORS
+checks. Not only that, WebKit by default does not allow sending cross-origin
+requests to custom URI schemes. This is by design: instead of accidentally
+leaking potentially sensitive data to websites, developers embedding a web
+view need to consciously opt-in to allow CORS requests and
+send back suitable Access-Control-Allow-* response headers.
In practice, the additional setup involves
+retrieving
+the WebKitSecurityManager being used by the WebKitWebContext and
+registering the scheme as
+CORS-enabled.
+Then, in the handler function for the custom URI scheme, create a
+WebKitURISchemeResponse,
+which allows fine-grained control of the response, including setting
+headers,
+and finishing the request instead with
+webkit_uri_scheme_request_finish_with_response().
Note that WebKit cuts some corners when using CORS with custom URI schemes:
+handlers will not receive preflight OPTIONS requests. Instead, the CORS
+headers from the replies are inspected, and if access needs to be denied
+then the data stream with the response contents is discarded.
In addition to providing a complete CORS-enabled custom URI scheme example, +we recommend the Will It CORS? tool +to help troubleshoot issues.
+Once we have WPE WebKit calling into our custom code, there are no limits +to what a URI scheme handler can do—as long as it involves replying +to requests. Here are some ideas:
+app:/... fetch content from it. Or, make the scheme handler
+load data using GResource and bundle the application
+inside your program.While URI scheme handlers +allow streaming large chunks of data back into the Web engine, for exchanging +smaller pieces of information in a more programmatic fashion it may be +preferable to exchange messages without the need to trigger resource loads. +The user script messages part of the +WebKitUserContentManager API can be used this way:
+window.webkit.messageHandlers.<name>.postMessage(), the signal is
+emitted, and the native callback functions invoked.postMessage() elsewhere?Yes, +you +have. +The name is the same because it provides a similar functionality (send a +message), it guarantees little (the receiver should validate messages), and +there are similar +restrictions +in the kind of values that can be passed along.
+Let’s add a feature to our minimal browser that will allow +JavaScript code to trigger rebooting or powering off the device where it is +running. While this should definitely not be functionality exposed to the +open Web, it is perfectly acceptable in an embedded device where we control +what gets loaded with WPE, and that exclusively uses a web application as its +user interface.
+
+ First, create a WebKitUserContentManager, register the message handler,
+and connect a callback to its associated signal:
static WebKitUserContentManager*
create_content_manager(void)
{
g_autoptr(WebKitUserContentManager) content_manager = webkit_user_content_manager_new();
webkit_user_content_manager_register_script_message_handler(content_manager, "powerControl");
g_signal_connect(content_manager, "script-message-received::powerControl",
G_CALLBACK(handle_power_control_message), NULL);
return g_steal_pointer(&content_manager);
}The callback receives a WebKitJavascriptResult, from which we
+can get the JSCValue with the contents of the parameter
+passed to the postMessage() function. The JSCValue can now be inspected
+to check for malformed messages and determine the action to take, and
+then arrange to call reboot():
static void
handle_power_control_message(WebKitUserContentManager *content_manager,
WebKitJavascriptResult *js_result, void *userdata)
{
JSCValue *value = webkit_javascript_result_get_js_value(js_result);
if (!jsc_value_is_string(value)) {
g_warning("Invalid powerControl message: argument is not a string");
return;
}
g_autofree char *value_as_string = jsc_value_to_string(value);
int action;
if (strcmp(value_as_string, "poweroff") == 0) {
action = RB_POWER_OFF;
} else if (strcmp(value_as_string, "reboot") == 0) {
action = RB_AUTOBOOT;
} else {
g_warning("Invalid powerControl message: '%s'", value_as_string);
return;
}
g_message("Device will %s now!", value_as_string);
sync(); reboot(action);
}Note that the reboot() system call above will most likely fail because it
+needs administrative privileges. While the browser process could run as root
+to sidestep this issue—definitely not recommended!—it would be
+better to grant the CAP_SYS_BOOT capability to the process, and much
+better to ask the system manager daemon to handle the job. In machines
+using systemd a good option is to call the .Halt()
+and .Reboot() methods of its org.freedesktop.systemd1 interface.
Now we can write a small HTML document with some JavaScript sprinkled on top +to arrange sending the messages:
+<html>
<head>
<meta charset="utf-8" />
<title>Device Power Control</title>
</head>
<body>
<button id="reboot">Reboot</button>
<button id="poweroff">Power Off</button>
<script type="text/javascript">
function addHandler(name) {
document.getElementById(name).addEventListener("click", (event) => {
window.webkit.messageHandlers.powerControl.postMessage(name);
return false;
});
}
addHandler("reboot");
addHandler("poweroff");
</script>
</body>
</html>The complete source code for this example can be found +in this Gist.
+But how can one return values from user messages back to the JavaScript code +running in the context of the web page? Until recently, the only option +available was exposing some known function in the page’s JavaScript code, and +then using +webkit_web_view_run_javascript() +to call it from native code later on. To make this more idiomatic and allow +waiting on a Promise, an approach like the following works:
+.postMessage() which add an unique identifier as part of the message,
+create a Promise, and store it in a Map indexed by the identifier.
+The Promise is itself returned from the functions.webkit_web_view_run_javascript() to pass it back, along with the
+information needed to resolve the promise.Promise from
+the Map that corresponds to the identifier, and resolves it.To make this approach a bit more palatable, we could tell WebKit to inject a +script +along with the regular content, which would provide the helper +functions +needed to achieve this.
+Nevertheless, the approach outlined above is cumbersome and can be
+tricky to get right, not to mention that the effort needs to be duplicated in
+each application. Therefore, we have recently added new API hooks to provide this
+as a built-in feature, so starting in WPE WebKit 2.40 the recommended approach
+involves using
+webkit_user_content_manager_register_script_message_handler_with_reply()
+to register handlers instead. This way, calling .postMessage() now returns a
+Promise to the JavaScript code, and the callbacks connected to the
+script-message-with-reply-received
+signal now receive a
+WebKitScriptMessageReply,
+which can be used to resolve the promise—either on the spot, or
+asynchronously later on.
User script messages are a powerful and rather flexible facility to make WPE +integrate web content into a complete system. The provided example is rather +simple, but as long as we do not need to pass huge amounts of data in +messages the possibilities are almost endless—especially with the +added convenience in WPE WebKit 2.40. Here are more ideas that can +be built on top of user script messages:
+Promise that gets resolved when it has received changes.
+For example, this could make the user interface of a smart thermostat
+react to temperate updates from a sensor.WPE has been designed from the ground up to integrate with the rest of the +system, instead of having a sole focus on rendering Web content inside a +monolithic web browser application. Accordingly, the public API must be +comprehensive enough to use it as a component of any application. This +results in features that allow plugging into the web engine at different +layers to provide custom behaviour.
+At Igalia we have years of experience embedding WebKit into all kinds of +applications, and we are always sympathetic to the needs of such systems. If +you are interested collaborating with WPE development, or searching for a +solution that can tightly integrate web content in your device, feel free to +contact us.
+ + + + +
+ This article was written by Adrián Pérez.
+ Don’t miss any news related to WPE – our blog aims to share information regarding WPE: explainers, how-to articles and general information regarding WPE, WebKit +and the Web platform. Also check out the official WebKit blog regarding news on the engine itself.
+
+
+ Following the previous post in the series about WPE where we talked about the WPE components, this post will explain briefly the WPE graphics architecture, and how the engine is able to render HTML content into the display.
+
+
+ In the previous post in this series, we explained that WPE is a WebKit port optimized for embedded devices. In this post, we'll dive into a more technical overview of the different components of WPE, WebKit, and how they all fit together.
+
+
+ Welcome to the new Blog section on wpewebkit.org! Let's take some time to celebrate and recap how WPE evolved from the early prototyping days to the product empowering hundreds of millions of devices worldwide today.
+
+
+WPE WebKit brought RDK (Reference Design Kit), a modern, performant web browser, to millions of screens. It enables operators to manage devices and easily customize their UIs and apps and provides analytics to improve the customer experience and drive business results.
+Delivering a fast and memory-efficient browser for embedded systems is a challenging task, so Igalia helped Metrological build a new full-screen browser engine which stripped away all unnecessary toolkit elements.
+With years of experience around WebKit platform integration, Igalia worked to produce a new WebKit port, WPE, which interfaced directly with Wayland and the graphics driver. Additionally, Igalia pushed forward the implementation of a multi-platform multi-threaded compositor, enabling better performance on low-end multicore processors. WPE is an official port of WebKit.
+ + + + +
+
+Digital signage web rendering players have many advantages and are a trend nowadays. They allow to use HTML5 for composing the UI, provisioning and scheduling new contents to the screens from the cloud is simple and effortless, they provide a robust environment with an automatic crash recovery system, etc. They are also a great choice for digital signage kiosk deployments.
+WPE WebKit is an excellent option to use as web rendering engine for Linux-based digital signage players, specially for the low-end market, where WPE Webkit allows to achieve great graphics and rendering performance in the less powerful devices like the ones based on the Raspberry Pi. As a result, WPE WebKit is naturally compatible with the hardware of the main digital signage manufactures that rely on these kind of lower-powered devices.
+ + + + +Don’t miss any news related to WPE – our blog aims to share information regarding WPE: explainers, how-to articles and general information regarding WPE, WebKit +and the Web platform. Also check out the official WebKit blog regarding news on the engine itself.
+
+
+ This post explores some of the ways in which WPE WebKit can integrate with +its surrounding environment, in order to expose platform functionality to +Web content seamlessly.
+
+
+ Let's take a detour from the previous WPE architecture related posts to other aspects of our work on WebKit at Igalia. Today, the status of the development of WebKits' new SVG engine is presented, along with an introduction to the topic, and an outlook for 2023.
+
+
+ Digital signage web rendering players have many advantages and are a trend nowadays.
+
+
+ WPE WebKit brought RDK (Reference Design Kit), a modern, performant web browser, to millions of screens.
+
+
+ In this post we'll cover the many layers of the networking stack that WPE uses including libsoup and glib.
+
+
+ In the previous posts, my colleagues Claudio and Miguel wrote respectively about the major components of the project and, specifically, the graphics architecture of WPE. Today, you'll see our efforts to improve the quality of both WPE and the experience of working and using it.
+If you can see this, you should be redirecting this URL to /about/get-wpe.html.
+ + \ No newline at end of file diff --git a/aperezdc/compat-table-2.42.x/css/fonts.css b/aperezdc/compat-table-2.42.x/css/fonts.css new file mode 100644 index 000000000..4ca2ac07a --- /dev/null +++ b/aperezdc/compat-table-2.42.x/css/fonts.css @@ -0,0 +1,114 @@ +/* Normal */ +@font-face { + font-family: 'Source Sans Pro'; + font-style: normal; + font-variant: common-ligatures; + font-weight: 400; + src: + local('Source Sans Variable'), + local('Source Sans 3 VF'), + local('Source Sans Pro'), + local('Source Sans Pro Regular'), + local('SourceSansPro-Regular'), + local('Source Sans 3'), + local('SourceSans3-Regular'), + url('../assets/SourceSans3VF-Roman.ttf.woff2') format('woff2'), + url('../assets/SourceSans3VF-Roman.ttf.woff') format('woff'), + url('../assets/SourceSans3VF-Roman.ttf') format('truetype'), + url('../assets/SourceSans3VF-Roman.otf') format('opentype'); +} + +/* Bold */ +@font-face { + font-family: 'Source Sans Pro'; + font-style: normal; + font-variant: common-ligatures; + font-weight: 700; + src: + local('Source Sans Variable'), + local('Source Sans 3 VF'), + local('Source Sans Pro Bold'), + local('SourceSansPro-Bold'), + local('Source Sans 3'), + local('SourceSans3-Bold'), + url('../assets/SourceSans3VF-Roman.ttf.woff2') format('woff2'), + url('../assets/SourceSans3VF-Roman.ttf.woff') format('woff'), + url('../assets/SourceSans3VF-Roman.ttf') format('truetype'), + url('../assets/SourceSans3VF-Roman.otf') format('opentype'); +} + +/* Light */ +@font-face { + font-family: 'Source Sans Pro'; + font-style: normal; + font-variant: common-ligatures; + font-weight: 100; + src: + local('Source Sans Variable'), + local('Source Sans 3 VF'), + local('Source Sans Pro Light'), + local('SourceSansPro-Light'), + local('Source Sans 3'), + local('SourceSans3-Light'), + url('../assets/SourceSans3VF-Roman.ttf.woff2') format('woff2'), + url('../assets/SourceSans3VF-Roman.ttf.woff') format('woff'), + url('../assets/SourceSans3VF-Roman.ttf') format('truetype'), + url('../assets/SourceSans3VF-Roman.otf') format('opentype'); +} + +/* Italic */ +@font-face { + font-family: 'Source Sans Pro'; + font-style: italic; + font-variant: common-ligatures; + font-weight: 400; + src: + local('Source Sans Variable'), + local('Source Sans 3 VF'), + local('Source Sans Pro Italic'), + local('SourceSansPro-Italic'), + local('Source Sans 3'), + local('SourceSans3-Italic'), + url('../assets/SourceSans3VF-Italic.ttf.woff2') format('woff2'), + url('../assets/SourceSans3VF-Italic.ttf.woff') format('woff'), + url('../assets/SourceSans3VF-Italic.ttf') format('truetype'), + url('../assets/SourceSans3VF-Italic.otf') format('opentype'); +} + +/* Bold Italic */ +@font-face { + font-family: 'Source Sans Pro'; + font-style: italic; + font-variant: common-ligatures; + font-weight: 700; + src: + local('Source Sans Variable'), + local('Source Sans 3 VF'), + local('Source Sans Pro Bold Italic'), + local('SourceSansPro-BoldItalic'), + local('Source Sans 3'), + local('SourceSans3-BoldItalic'), + url('../assets/SourceSans3VF-Italic.ttf.woff2') format('woff2'), + url('../assets/SourceSans3VF-Italic.ttf.woff') format('woff'), + url('../assets/SourceSans3VF-Italic.ttf') format('truetype'), + url('../assets/SourceSans3VF-Italic.otf') format('opentype'); +} + +/* Light Italic */ +@font-face { + font-family: 'Source Sans Pro'; + font-style: italic; + font-variant: common-ligatures; + font-weight: 100; + src: + local('Source Sans Variable'), + local('Source Sans 3 VF'), + local('Source Sans Pro Light Italic'), + local('SourceSansPro-LightItalic'), + local('Source Sans 3'), + local('SourceSans3-LightItalic'), + url('../assets/SourceSans3VF-Italic.ttf.woff2') format('woff2'), + url('../assets/SourceSans3VF-Italic.ttf.woff') format('woff'), + url('../assets/SourceSans3VF-Italic.ttf') format('truetype'), + url('../assets/SourceSans3VF-Italic.otf') format('opentype'); +} diff --git a/aperezdc/compat-table-2.42.x/css/prism.css b/aperezdc/compat-table-2.42.x/css/prism.css new file mode 100644 index 000000000..4f42c07c4 --- /dev/null +++ b/aperezdc/compat-table-2.42.x/css/prism.css @@ -0,0 +1,2 @@ +/* PrismJS 1.29.0 theme from https://prismjs.com/download.html */ +code[class*=language-],pre[class*=language-]{color:#000;background:0 0;text-shadow:0 1px #fff;font-family:Consolas,Monaco,'Andale Mono','Ubuntu Mono',monospace;font-size:0.85rem;text-align:left;white-space:pre;word-spacing:normal;word-break:normal;word-wrap:normal;line-height:1.35;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-hyphens:none;-moz-hyphens:none;-ms-hyphens:none;hyphens:none}code[class*=language-] ::-moz-selection,code[class*=language-]::-moz-selection,pre[class*=language-] ::-moz-selection,pre[class*=language-]::-moz-selection{text-shadow:none;background:#b3d4fc}code[class*=language-] ::selection,code[class*=language-]::selection,pre[class*=language-] ::selection,pre[class*=language-]::selection{text-shadow:none;background:#b3d4fc}@media print{code[class*=language-],pre[class*=language-]{text-shadow:none}}pre[class*=language-]{padding:1em;margin:.5em 0;overflow:auto}:not(pre)>code[class*=language-],pre[class*=language-]{background:#f1f1f1}:not(pre)>code[class*=language-]{padding:.1em;border-radius:.3em;white-space:normal}.token.cdata,.token.comment,.token.doctype,.token.prolog{color:#708090}.token.punctuation{color:#999}.token.namespace{opacity:.7}.token.boolean,.token.constant,.token.deleted,.token.number,.token.property,.token.symbol,.token.tag{color:#905}.token.attr-name,.token.builtin,.token.char,.token.inserted,.token.selector,.token.string{color:#690}.language-css .token.string,.style .token.string,.token.entity,.token.operator,.token.url{color:#9a6e3a;background:hsla(0,0%,100%,.5)}.token.atrule,.token.attr-value,.token.keyword{color:#07a}.token.class-name,.token.function{color:#dd4a68}.token.important,.token.regex,.token.variable{color:#e90}.token.bold,.token.important{font-weight:700}.token.italic{font-style:italic}.token.entity{cursor:help} diff --git a/aperezdc/compat-table-2.42.x/css/stylish-portfolio.css b/aperezdc/compat-table-2.42.x/css/stylish-portfolio.css new file mode 100644 index 000000000..94c95d807 --- /dev/null +++ b/aperezdc/compat-table-2.42.x/css/stylish-portfolio.css @@ -0,0 +1,495 @@ +.navbar-nav { + margin-right: 4rem; +} + +strong { + font-weight: 800; +} + +body, +html { + width: 100%; + height: 100%; +} + +body { + font-family: 'Source Sans Pro'; +} + +ul { margin: 1rem auto; padding-left: 4rem; } +ul li { text-align: left; } + +.btn-xl { + padding: 1.25rem 2.5rem; +} + +.content-section { + padding-top: 7.5rem; + padding-bottom: 7.5rem; +} + +.content-section.small-section { + padding-top: 2rem; + padding-bottom: 2rem; +} + +.content-section-heading h2 { + font-size: 3rem; +} + +.content-section-heading h3 { + font-size: 1rem; + text-transform: uppercase; +} + +.release-heading { + margin-bottom: 0; +} + +h1, +h2, +h3, +h4, +h5, +h6 { + font-weight: 700; +} + +.text-faded { + color: rgba(255, 255, 255, 0.7); +} + +/* Map */ +.map { + height: 30rem; +} + +@media (max-width: 992px) { + .map { + height: 75%; + } +} + +.map iframe { + pointer-events: none; +} + +.scroll-to-top { + position: fixed; + right: 15px; + bottom: 15px; + display: none; + width: 50px; + height: 50px; + text-align: center; + color: white; + background: rgba(52, 58, 64, 0.5); + line-height: 45px; +} + +.scroll-to-top:focus, .scroll-to-top:hover { + color: white; +} + +.scroll-to-top:hover { + background: #343a40; +} + +.scroll-to-top i { + font-weight: 800; +} + +. + +/* Side Menu */ +#sidebar-wrapper { + position: fixed; + z-index: 2; + right: 0; + width: 250px; + height: 100%; + -webkit-transition: all 0.4s ease 0s; + -moz-transition: all 0.4s ease 0s; + -ms-transition: all 0.4s ease 0s; + -o-transition: all 0.4s ease 0s; + transition: all 0.4s ease 0s; + transform: translateX(250px); + background: #1D809F; + border-left: 1px solid rgba(255, 255, 255, 0.1); +} + +.sidebar-nav { + position: absolute; + top: 0; + width: 250px; + margin: 0; + padding: 0; + list-style: none; +} + +.sidebar-nav li.sidebar-nav-item a { + display: block; + text-decoration: none; + color: #fff; + padding: 15px; +} + +.sidebar-nav li a:hover { + text-decoration: none; + color: #fff; + background: rgba(255, 255, 255, 0.2); +} + +.sidebar-nav li a:active, +.sidebar-nav li a:focus { + text-decoration: none; +} + +.sidebar-nav > .sidebar-brand { + font-size: 1.2rem; + background: rgba(52, 58, 64, 0.1); + height: 80px; + line-height: 50px; + padding-top: 15px; + padding-bottom: 15px; + padding-left: 15px; +} + +.sidebar-nav > .sidebar-brand a { + color: #fff; +} + +.sidebar-nav > .sidebar-brand a:hover { + color: #fff; + background: none; +} + +#sidebar-wrapper.active { + right: 250px; + width: 250px; + -webkit-transition: all 0.4s ease 0s; + -moz-transition: all 0.4s ease 0s; + -ms-transition: all 0.4s ease 0s; + -o-transition: all 0.4s ease 0s; + transition: all 0.4s ease 0s; +} + +.menu-toggle { + position: fixed; + right: 15px; + top: 15px; + width: 50px; + height: 50px; + text-align: center; + color: #fff; + background: rgba(52, 58, 64, 0.5); + line-height: 50px; + z-index: 999; +} + +.menu-toggle:focus, .menu-toggle:hover { + color: #fff; +} + +.menu-toggle:hover { + background: #343a40; +} + +.card { + min-width: 21rem; + max-width: 100%; +} + +.service-icon { + background-color: #fff; + color: #1D809F; + height: 7rem; + width: 7rem; + display: block; + line-height: 7.5rem; + font-size: 2.25rem; + box-shadow: 0 3px 3px 0 rgba(0, 0, 0, 0.1); +} + +.callout { + padding: 15rem 0; + background: linear-gradient(90deg, rgba(255, 255, 255, 0.1) 0%, rgba(255, 255, 255, 0.1) 100%); + background-position: center center; + background-repeat: no-repeat; + background-size: cover; +} + +.callout h2 { + font-size: 3.5rem; + font-weight: 700; + display: block; + max-width: 30rem; +} + +.portfolio-item { + display: block; + position: relative; + overflow: hidden; + max-width: 530px; + margin: auto auto 1rem; +} + +.portfolio-item .caption { + display: flex; + height: 100%; + width: 100%; + background-color: rgba(33, 37, 41, 0.2); + position: absolute; + top: 0; + bottom: 0; + z-index: 1; +} + +.portfolio-item .caption .caption-content { + color: #fff; + margin: auto 2rem 2rem; +} + +.portfolio-item .caption .caption-content h2 { + font-size: 0.8rem; + text-transform: uppercase; +} + +.portfolio-item .caption .caption-content p { + font-weight: 300; + font-size: 1.2rem; +} + +@media (min-width: 1300px) { + .card { + min-width: 21rem !important; + } + +} +@media (min-width: 992px) { + .portfolio-item { + max-width: none; + margin: 0; + } + .portfolio-item .caption { + -webkit-transition: -webkit-clip-path 0.25s ease-out, background-color 0.7s; + -webkit-clip-path: inset(0px); + clip-path: inset(0px); + } + .portfolio-item .caption .caption-content { + transition: opacity 0.25s; + margin-left: 5rem; + margin-right: 5rem; + margin-bottom: 5rem; + } + .portfolio-item img { + -webkit-transition: -webkit-clip-path 0.25s ease-out; + -webkit-clip-path: inset(-1px); + clip-path: inset(-1px); + } + .portfolio-item:hover img { + -webkit-clip-path: inset(2rem); + clip-path: inset(2rem); + } + .portfolio-item:hover .caption { + background-color: rgba(29, 128, 159, 0.9); + -webkit-clip-path: inset(2rem); + clip-path: inset(2rem); + } + + #webkit-powers-embedded { + padding: 2rem; + background: url(https://www.igalia.com/assets/i/headers/header-industries-tv.jpg); + background-size: contain; + background-repeat: no-repeat; + background-position-y: center + } + + + .footer.footer { + grid-template-columns: 300px auto; + grid-template-rows: repeat(2,auto); + } + .footer.footer a.navbar-brand { + grid-row: 1 / -1; + } + .footer.footer nav.social { + grid-column: 2; + align-self: end; + } + .footer.footer nav.social ul { + margin: 0; + padding: 0; + } + .footer.footer li { + display: inline; + } + .footer.footer li a { + display: inline; + } +} + +table { + margin: 1em auto; + border: 1px solid #eaeaea; + background: #fafafa; +} + +table td, table th { + padding: 0.2em 0.75em; +} + +table thead, table th { + background: #eaeaea; +} + +table tr:nth-child(even) { + background: #efefef; +} + +footer.footer { + padding: 1rem; + +} + +footer.footer .social-link { + display: block; + height: 4rem; + width: 4rem; + line-height: 4.3rem; + font-size: 1.5rem; + background-color: #1D809F; + transition: background-color 0.15s ease-in-out; + box-shadow: 0 3px 3px 0 rgba(0, 0, 0, 0.1); +} + +footer.footer .social-link:hover { + background-color: #155d74; + text-decoration: none; +} + +a { + color: #1D809F; +} + +a:hover, a:focus, a:active { + color: #155d74; +} + +.text-faded > a { + color: rgba(255, 255, 255, 0.7); +} + +.text-faded > a:hover, .text-faded > a:focus, .text-faded > a:active { + color: rgba(230, 230, 230, 0.7); +} + +.btn-primary { + background-color: #1c77c7 !important; + border-color: #1D809F !important; + color: #fff !important; +} + +.btn-primary:hover, .btn-primary:focus, .btn-primary:active { + background-color: #155d74 !important; + border-color: #155d74 !important; +} + +.btn-secondary { + background-color: #ecb807 !important; + border-color: #ecb807 !important; + color: #fff !important; +} + +.btn-secondary:hover, .btn-secondary:focus, .btn-secondary:active { + background-color: #ba9106 !important; + border-color: #ba9106 !important; +} + +.btn-dark { + color: #fff !important; +} + +.btn { + box-shadow: 0px 3px 3px 0px rgba(0, 0, 0, 0.1); + font-weight: 700; +} + +.bg-primary { + background-color: #1593ED !important; +} + +.bg-tertiary { + background-color: black !important; +} + +.text-primary { + color: #1D809F !important; +} + +.text-secondary { + color: #ecb807 !important; +} + + +#contact { + padding-top: 1.5rem; + padding-bottom: 0.5rem; +} + +footer.footer { + padding: 1rem; + display: grid; +} + +footer .container { + display: flex; + align-self: center; +} + +ol ol, +ul ul, +ol ul, +ul ol { + margin-top: 1rem; + margin-bottom: 1rem; +} + +#webkit-powers-embedded { + padding: 0 !important; +} + +#about-code-section .badge { + margin-left: 1rem; +} + +.text-light a { + color: white; +} + +blockquote { + background-color: rgba(230, 230, 230, 0.7); +} + +.author-line { + margin-top: -2rem; + border: 2px solid lightgray; + width: 100%; +} + +hr.author-line + div { + margin-top: 1.5rem; + color: #666; +} +hr.author-line + div > img.circle-mask { + margin-top: -1rem; +} + +.circle-mask { + width: 8rem; + height: auto; + float: left; + margin-right: 2rem; + margin-bottom: 2rem; + border-radius: 50%; +} diff --git a/aperezdc/compat-table-2.42.x/css/stylish-portfolio.min.css b/aperezdc/compat-table-2.42.x/css/stylish-portfolio.min.css new file mode 100644 index 000000000..e4bb538fc --- /dev/null +++ b/aperezdc/compat-table-2.42.x/css/stylish-portfolio.min.css @@ -0,0 +1 @@ +body,html{width:100%;height:100%}body{font-family:'Source Sans Pro'}.btn-xl{padding:1.25rem 2.5rem}.content-section{padding-top:7.5rem;padding-bottom:7.5rem}.content-section.small-section{padding-top:2rem;padding-bottom:2rem}.content-section-heading h2{font-size:3rem}.content-section-heading h3{font-size:1rem;text-transform:uppercase}h1,h2,h3,h4,h5,h6{font-weight:700}.text-faded{color:rgba(255,255,255,.7)}.map{height:30rem}@media (max-width:992px){.map{height:75%}}.map iframe{pointer-events:none}.scroll-to-top{position:fixed;right:15px;bottom:15px;display:none;width:50px;height:50px;text-align:center;color:#fff;background:rgba(52,58,64,.5);line-height:45px}.scroll-to-top:focus,.scroll-to-top:hover{color:#fff}.scroll-to-top:hover{background:#343a40}.scroll-to-top i{font-weight:800}.masthead{position:relative;display:table;width:100%;height:auto;padding-top:4rem;padding-bottom:4rem;background:linear-gradient(90deg,rgba(255,255,255,.1) 0,rgba(255,255,255,.1) 100%);background-position:center center;background-repeat:no-repeat;background-size:cover}.masthead h1{font-size:4rem;margin:0;padding:0}@media (min-width:992px){.masthead h1{font-size:5.5rem}}.masthead.small-header{padding-top:2rem;padding-bottom:2rem;min-height:10rem;height:15rem}#sidebar-wrapper{position:fixed;z-index:2;right:0;width:250px;height:100%;-webkit-transition:all .4s ease 0s;-moz-transition:all .4s ease 0s;-ms-transition:all .4s ease 0s;-o-transition:all .4s ease 0s;transition:all .4s ease 0s;transform:translateX(250px);background:#1d809f;border-left:1px solid rgba(255,255,255,.1)}.sidebar-nav{position:absolute;top:0;width:250px;margin:0;padding:0;list-style:none}.sidebar-nav li.sidebar-nav-item a{display:block;text-decoration:none;color:#fff;padding:15px}.sidebar-nav li a:hover{text-decoration:none;color:#fff;background:rgba(255,255,255,.2)}.sidebar-nav li a:active,.sidebar-nav li a:focus{text-decoration:none}.sidebar-nav>.sidebar-brand{font-size:1.2rem;background:rgba(52,58,64,.1);height:80px;line-height:50px;padding-top:15px;padding-bottom:15px;padding-left:15px}.sidebar-nav>.sidebar-brand a{color:#fff}.sidebar-nav>.sidebar-brand a:hover{color:#fff;background:0 0}#sidebar-wrapper.active{right:250px;width:250px;-webkit-transition:all .4s ease 0s;-moz-transition:all .4s ease 0s;-ms-transition:all .4s ease 0s;-o-transition:all .4s ease 0s;transition:all .4s ease 0s}.menu-toggle{position:fixed;right:15px;top:15px;width:50px;height:50px;text-align:center;color:#fff;background:rgba(52,58,64,.5);line-height:50px;z-index:999}.menu-toggle:focus,.menu-toggle:hover{color:#fff}.menu-toggle:hover{background:#343a40}.service-icon{background-color:#fff;color:#1d809f;height:7rem;width:7rem;display:block;line-height:7.5rem;font-size:2.25rem;box-shadow:0 3px 3px 0 rgba(0,0,0,.1)}.callout{padding:15rem 0;background:linear-gradient(90deg,rgba(255,255,255,.1) 0,rgba(255,255,255,.1) 100%);background-position:center center;background-repeat:no-repeat;background-size:cover}.callout h2{font-size:3.5rem;font-weight:700;display:block;max-width:30rem}.portfolio-item{display:block;position:relative;overflow:hidden;max-width:530px;margin:auto auto 1rem}.portfolio-item .caption{display:flex;height:100%;width:100%;background-color:rgba(33,37,41,.2);position:absolute;top:0;bottom:0;z-index:1}.portfolio-item .caption .caption-content{color:#fff;margin:auto 2rem 2rem}.portfolio-item .caption .caption-content h2{font-size:.8rem;text-transform:uppercase}.portfolio-item .caption .caption-content p{font-weight:300;font-size:1.2rem}@media (min-width:992px){.portfolio-item{max-width:none;margin:0}.portfolio-item .caption{-webkit-transition:-webkit-clip-path .25s ease-out,background-color .7s;-webkit-clip-path:inset(0);clip-path:inset(0)}.portfolio-item .caption .caption-content{transition:opacity .25s;margin-left:5rem;margin-right:5rem;margin-bottom:5rem}.portfolio-item img{-webkit-transition:-webkit-clip-path .25s ease-out;-webkit-clip-path:inset(-1px);clip-path:inset(-1px)}.portfolio-item:hover img{-webkit-clip-path:inset(2rem);clip-path:inset(2rem)}.portfolio-item:hover .caption{background-color:rgba(29,128,159,.9);-webkit-clip-path:inset(2rem);clip-path:inset(2rem)}}table{margin:1em auto;border:1px solid #eaeaea;background:#fafafa}table td,table th{padding:.2em .75em}table th,table thead{background:#eaeaea}table tr:nth-child(even){background:#efefef}footer.footer{padding-top:5rem;padding-bottom:5rem}footer.footer .social-link{display:block;height:4rem;width:4rem;line-height:4.3rem;font-size:1.5rem;background-color:#1d809f;transition:background-color .15s ease-in-out;box-shadow:0 3px 3px 0 rgba(0,0,0,.1)}footer.footer .social-link:hover{background-color:#155d74;text-decoration:none}a{color:#1d809f}a:active,a:focus,a:hover{color:#155d74}.text-faded>a{color:rgba(255,255,255,.7)}.text-faded>a:active,.text-faded>a:focus,.text-faded>a:hover{color:rgba(230,230,230,.7)}.btn-primary{background-color:#1d809f!important;border-color:#1d809f!important;color:#fff!important}.btn-primary:active,.btn-primary:focus,.btn-primary:hover{background-color:#155d74!important;border-color:#155d74!important}.btn-secondary{background-color:#ecb807!important;border-color:#ecb807!important;color:#fff!important}.btn-secondary:active,.btn-secondary:focus,.btn-secondary:hover{background-color:#ba9106!important;border-color:#ba9106!important}.btn-dark{color:#fff!important}.btn{box-shadow:0 3px 3px 0 rgba(0,0,0,.1);font-weight:700}.bg-primary{background-color:#1d809f!important}.text-primary{color:#1d809f!important}.text-secondary{color:#ecb807!important} \ No newline at end of file diff --git a/aperezdc/compat-table-2.42.x/css/v2.css b/aperezdc/compat-table-2.42.x/css/v2.css new file mode 100755 index 000000000..f8ce5737c --- /dev/null +++ b/aperezdc/compat-table-2.42.x/css/v2.css @@ -0,0 +1,718 @@ +img[src*="placeholder"] { +max-height: 4em; +} + +html { + --mainColMax: 75rem; +/* + --colorMain: #1593ED; +*/ + --colorMain: #0D71B9; + --dashH: linear-gradient(90deg, currentColor 25%, + transparent 25% 75%, + currentColor 75%) 0 100% / 8px 1px repeat-x; + --dashV: linear-gradient(180deg, currentColor 25%, + transparent 25% 75%, + currentColor 75%) 0 0 / 1px 8px repeat-y; + height: auto; + min-height: 100%; + max-width: 100vw; +} + +:target { + scroll-margin-top: 7rem; +} + +@supports not (-ms-ime-align: auto) { + /* + * Resets forWhile there are several simple ways for developers to experiment with and explore WPE, none are tuned for performance. Generally, shipping products for embedded systems are performance-tuned custom builds. To make this easier, there is also meta-webkit, which provides build recipes, WebKit based runtimes, and browsers for use with OpenEmbedded and/or Yocto.
+There are also pre-built packages available for many Linux distributions.
+WPE WebKit follows a 6-month development cycle:
+WPE WebKit and WebKitGTK share a fair amount of code. Therefore, both projects produce their feature releases simultaneously, and share the same release branches. For bug-fix releases, the release teams for both projects try to sync their version numbers as well as they can.
+WPE is the official WebKit port for Linux-based embedded platforms. WPE is uniquely designed for embedded systems in that it doesn’t depend on any user-interface toolkits such as the traditional Cocoa, GTK, etc toolkits.
+
+We've been collecting answers to lots of common questions we've been asked. If you've got questions, you might just find a ready answer in the FAQ.
++A WebKit port for Linux-based embedded devices designed with flexibility and hardware acceleration in mind, leveraging common 3D graphics APIs for best performance. +
+Get WPE +The Web Platform is a frequently chosen foundational technology for many reasons, including:
+WPE is currently running on a wide range of hardware. This page lists configurations which are known to work, sorted by manufacturer:
+WPE WebKit is widely adopted by many industries, including digital signage, professional audio, home appliances, set-top-boxes, automotive, and inflight infotainment. Countless devices deployed around the globe are already using WPE WebKit as their web runtime platform, and use is growing rapidly.
+
+Digital signage web rendering players have many advantages and are a trend nowadays. They feature use of HTML for composing the user interface, simple and effortless provisioning and scheduling new contents to the screen from the cloud, a robust environment with an automatic crash recovery system, and more.
+ +
+
+WPE is the official WebKit port for embedded platforms. WPE is uniquely designed for embedded systems in that it doesn’t depend on any user-interface toolkits such as the traditional Cocoa, GTK, etc toolkits.
+
+We’ve been collecting answers to lots of common questions we’ve been asked. If you have questions, you might find a ready answer in the FAQ.
+
+
+
+WPEWebKit is developed by Igalia, an open-source consultancy with a lot of experience working on the Web platform. As the maintainers of this official port of WebKit, Igalia has a great deal of experience with meeting hardware and software challenges in the embedded space and several others. Get in touch!
+igalia.com +| +Top + | + |
+ |
+ |
+ |
+
| +WebKitApplicationInfo * + | ++webkit_application_info_new () + | +
| +WebKitApplicationInfo * + | ++webkit_application_info_ref () + | +
| +void + | ++webkit_application_info_unref () + | +
| +void + | ++webkit_application_info_set_name () + | +
| const gchar * + | ++webkit_application_info_get_name () + | +
| +void + | ++webkit_application_info_set_version () + | +
| +void + | ++webkit_application_info_get_version () + | +
WebKitApplicationInfo *
+webkit_application_info_new (void);
+Creates a new WebKitApplicationInfo
+ +Since: 2.18
+WebKitApplicationInfo *
+webkit_application_info_ref (WebKitApplicationInfo *info);
+Atomically increments the reference count of info
+ by one. This
+function is MT-safe and may be called from any thread.
Since: 2.18
+void
+webkit_application_info_unref (WebKitApplicationInfo *info);
+Atomically decrements the reference count of info
+ by one. If the
+reference count drops to 0, all memory allocated by the WebKitApplicationInfo is
+released. This function is MT-safe and may be called from any
+thread.
Since: 2.18
+void +webkit_application_info_set_name (+WebKitApplicationInfo *info, +const gchar *name);
Set the name of the application. If not provided, or NULL is passed,
+g_get_prgname() will be used.
Since: 2.18
+const gchar *
+webkit_application_info_get_name (WebKitApplicationInfo *info);
+Get the name of the application. If webkit_application_info_set_name() hasn't been
+called with a valid name, this returns g_get_prgname().
Since: 2.18
+void +webkit_application_info_set_version (+WebKitApplicationInfo *info, +guint64 major, +guint64 minor, +guint64 micro);
Set the application version. If the application doesn't use the format +major.minor.micro you can pass 0 as the micro to use major.minor, or pass +0 as both micro and minor to use only major number. Any other format must +be converted to major.minor.micro so that it can be used in version comparisons.
+info |
++ | + |
major |
+the major version number |
++ |
minor |
+the minor version number |
++ |
micro |
+the micro version number |
++ |
Since: 2.18
+void +webkit_application_info_get_version (+WebKitApplicationInfo *info, +guint64 *major, +guint64 *minor, +guint64 *micro);
Get the application version previously set with webkit_application_info_set_version().
info |
++ | + |
major |
+return location for the major version number. |
+[out] | +
minor |
+return location for the minor version number. |
+[out][allow-none] | +
micro |
+return location for the micro version number. |
+[out][allow-none] | +
Since: 2.18
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitAuthenticationRequest+WebKitAuthenticationRequest — Represents an authentication request + |
++ |
| struct | +WebKitAuthenticationRequest | +
| enum | +WebKitAuthenticationScheme | +
| + | WebKitCredential | +
| enum | +WebKitCredentialPersistence | +
Whenever a client attempts to load a page protected by HTTP +authentication, credentials will need to be provided to authorize access. +To allow the client to decide how it wishes to handle authentication, +WebKit will fire a “authenticate” signal with a +WebKitAuthenticationRequest object to provide client side +authentication support. Credentials are exposed through the +WebKitCredential object.
+In case the client application does not wish +to handle this signal WebKit will provide a default handler. To handle +authentication asynchronously, simply increase the reference count of the +WebKitAuthenticationRequest object.
+void +webkit_authentication_request_authenticate + (+WebKitAuthenticationRequest *request, +WebKitCredential *credential);
Authenticate the WebKitAuthenticationRequest using the WebKitCredential
+supplied. To continue without credentials, pass NULL as credential
+.
request |
++ | + |
credential |
+A WebKitCredential, or |
+[transfer none][allow-none] | +
Since: 2.2
+void
+webkit_authentication_request_cancel (WebKitAuthenticationRequest *request);
+Cancel the authentication challenge. This will also cancel the page loading and result in a
+“load-failed” signal with a WebKitNetworkError of type WEBKIT_NETWORK_ERROR_CANCELLED being emitted.
Since: 2.2
+gboolean
+webkit_authentication_request_can_save_credentials
+ (WebKitAuthenticationRequest *request);
+Determine whether the authentication method associated with this
+WebKitAuthenticationRequest should allow the storage of credentials.
+This will return FALSE if WebKit doesn't support credential storing
+or if private browsing is enabled.
Since: 2.2
+const gchar *
+webkit_authentication_request_get_host
+ (WebKitAuthenticationRequest *request);
+Get the host that this authentication challenge is applicable to.
+ + +Since: 2.2
+guint
+webkit_authentication_request_get_port
+ (WebKitAuthenticationRequest *request);
+Get the port that this authentication challenge is applicable to.
+ + +Since: 2.2
+gboolean
+webkit_authentication_request_is_retry
+ (WebKitAuthenticationRequest *request);
+Determine whether this this is a first attempt or a retry for this authentication challenge.
+ + +Since: 2.2
+WebKitCredential *
+webkit_authentication_request_get_proposed_credential
+ (WebKitAuthenticationRequest *request);
+Get the WebKitCredential of the proposed authentication challenge that was +stored from a previous session. The client can use this directly for +authentication or construct their own WebKitCredential.
+ +A WebKitCredential encapsulating credential details
+or NULL if there is no stored credential.
[transfer full]
+Since: 2.2
+const gchar *
+webkit_authentication_request_get_realm
+ (WebKitAuthenticationRequest *request);
+Get the realm that this authentication challenge is applicable to.
+ + +Since: 2.2
+WebKitAuthenticationScheme
+webkit_authentication_request_get_scheme
+ (WebKitAuthenticationRequest *request);
+Get the authentication scheme of the authentication challenge.
+ + +Since: 2.2
+gboolean
+webkit_authentication_request_is_for_proxy
+ (WebKitAuthenticationRequest *request);
+Determine whether the authentication challenge is associated with a proxy server rather than an "origin" server.
+ + +Since: 2.2
+WebKitCredential * +webkit_credential_new (+const gchar *username, +const gchar *password, +WebKitCredentialPersistence persistence);
Create a new credential from the provided username, password and persistence mode.
+username |
+The username for the new credential |
++ |
password |
+The password for the new credential |
++ |
persistence |
+The WebKitCredentialPersistence of the new credential |
++ |
Since: 2.2
+WebKitCredential *
+webkit_credential_copy (WebKitCredential *credential);
+Make a copy of the WebKitCredential.
+ + +Since: 2.2
+void
+webkit_credential_free (WebKitCredential *credential);
+Free the WebKitCredential.
+ +Since: 2.2
+const gchar *
+webkit_credential_get_password (WebKitCredential *credential);
+Get the password currently held by this WebKitCredential.
+ + +Since: 2.2
+WebKitCredentialPersistence
+webkit_credential_get_persistence (WebKitCredential *credential);
+Get the persistence mode currently held by this WebKitCredential.
+ + +Since: 2.2
+const gchar *
+webkit_credential_get_username (WebKitCredential *credential);
+Get the username currently held by this WebKitCredential.
+ + +Since: 2.2
+gboolean
+webkit_credential_has_password (WebKitCredential *credential);
+Determine whether this credential has a password stored.
+ + +Since: 2.2
+Enum values representing the authentication scheme.
+Since: 2.2
+“cancelled” signalvoid +user_function (WebKitAuthenticationRequest *request, + gpointer user_data)+
This signal is emitted when the user authentication request is +cancelled. It allows the application to dismiss its authentication +dialog in case of page load failure for example.
+request |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.2
+| +Top + | + |
+ |
+ |
+ |
+
| const char * + | ++webkit_automation_session_get_id () + | +
| +void + | ++webkit_automation_session_set_application_info () + | +
| +WebKitApplicationInfo * + | ++webkit_automation_session_get_application_info () + | +
WebKitAutomationSession represents an automation session of a WebKitWebContext. +When a new session is requested, a WebKitAutomationSession is created and the signal +WebKitWebContext::automation-started is emitted with the WebKitAutomationSession as +argument. Then, the automation client can request the session to create a new +WebKitWebView to interact with it. When this happens the signal “create-web-view” +is emitted.
+const char *
+webkit_automation_session_get_id (WebKitAutomationSession *session);
+Get the unique identifier of a WebKitAutomationSession
+ + +Since: 2.18
+void +webkit_automation_session_set_application_info + (+WebKitAutomationSession *session, +WebKitApplicationInfo *info);
Set the application information to session
+. This information will be used by the driver service
+to match the requested capabilities with the actual application information. If this information
+is not provided to the session when a new automation session is requested, the creation might fail
+if the client requested a specific browser name or version. This will not have any effect when called
+after the automation session has been fully created, so this must be called in the callback of
+“automation-started” signal.
Since: 2.18
+WebKitApplicationInfo *
+webkit_automation_session_get_application_info
+ (WebKitAutomationSession *session);
+Get the WebKitAutomationSession previously set with webkit_automation_session_set_application_info().
the WebKitAutomationSession of session
+, or NULL if no one has been set.
[transfer none]
+Since: 2.18
+“id” property“id” gchar *+
The session unique identifier.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.18
+“create-web-view” signalWebKitWebView* +user_function (WebKitAutomationSession *session, + gpointer user_data)+
This signal is emitted when the automation client requests a new +browsing context to interact with it. The callback handler should +return a WebKitWebView created with “is-controlled-by-automation” +construct property enabled. The returned WebKitWebView could be an existing +web view or a new one created and added to a new tab or window.
+session |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.18
+| +Top + | + |
+ |
+ |
+ |
+
| +guint + | ++webkit_back_forward_list_get_length () + | +
| +WebKitBackForwardListItem * + | ++webkit_back_forward_list_get_current_item () + | +
| +WebKitBackForwardListItem * + | ++webkit_back_forward_list_get_back_item () + | +
| +WebKitBackForwardListItem * + | ++webkit_back_forward_list_get_forward_item () + | +
| +WebKitBackForwardListItem * + | ++webkit_back_forward_list_get_nth_item () + | +
| +GList * + | ++webkit_back_forward_list_get_back_list () + | +
| +GList * + | ++webkit_back_forward_list_get_back_list_with_limit () + | +
| +GList * + | ++webkit_back_forward_list_get_forward_list () + | +
| +GList * + | ++webkit_back_forward_list_get_forward_list_with_limit () + | +
WebKitBackForwardList maintains a list of visited pages used to +navigate to recent pages. Items are inserted in the list in the +order they are visited.
+WebKitBackForwardList also maintains the notion of the current item
+(which is always at index 0), the preceding item (which is at index -1),
+and the following item (which is at index 1).
+Methods webkit_web_view_go_back() and webkit_web_view_go_forward() move
+the current item backward or forward by one. Method
+webkit_web_view_go_to_back_forward_list_item() sets the current item to the
+specified item. All other methods returning WebKitBackForwardListItems
+do not change the value of the current item, they just return the requested
+item or items.
guint
+webkit_back_forward_list_get_length (WebKitBackForwardList *back_forward_list);
+
+
+WebKitBackForwardListItem *
+webkit_back_forward_list_get_current_item
+ (WebKitBackForwardList *back_forward_list);
+Returns the current item in back_forward_list
+.
a WebKitBackForwardListItem
+or NULL if back_forward_list
+is empty.
[nullable][transfer none]
+WebKitBackForwardListItem *
+webkit_back_forward_list_get_back_item
+ (WebKitBackForwardList *back_forward_list);
+Returns the item that precedes the current item.
+ +the WebKitBackForwardListItem
+preceding the current item or NULL.
[nullable][transfer none]
+WebKitBackForwardListItem *
+webkit_back_forward_list_get_forward_item
+ (WebKitBackForwardList *back_forward_list);
+Returns the item that follows the current item.
+ +the WebKitBackForwardListItem
+following the current item or NULL.
[nullable][transfer none]
+WebKitBackForwardListItem * +webkit_back_forward_list_get_nth_item (+WebKitBackForwardList *back_forward_list, +gint index);
Returns the item at a given index relative to the current item.
+ +the WebKitBackForwardListItem
+located at the specified index relative to the current item or NULL.
[nullable][transfer none]
+GList *
+webkit_back_forward_list_get_back_list
+ (WebKitBackForwardList *back_forward_list);
+
+a GList of +items preceding the current item.
+[element-type WebKit2.BackForwardListItem][transfer container]
+GList * +webkit_back_forward_list_get_back_list_with_limit + (+WebKitBackForwardList *back_forward_list, +guint limit);
back_forward_list |
++ | + |
limit |
+the number of items to retrieve |
++ |
a GList of
+items preceding the current item limited by limit
+.
[element-type WebKit2.BackForwardListItem][transfer container]
+GList *
+webkit_back_forward_list_get_forward_list
+ (WebKitBackForwardList *back_forward_list);
+
+a GList of +items following the current item.
+[element-type WebKit2.BackForwardListItem][transfer container]
+GList * +webkit_back_forward_list_get_forward_list_with_limit + (+WebKitBackForwardList *back_forward_list, +guint limit);
back_forward_list |
++ | + |
limit |
+the number of items to retrieve |
++ |
a GList of
+items following the current item limited by limit
+.
[element-type WebKit2.BackForwardListItem][transfer container]
+“changed” signalvoid +user_function (WebKitBackForwardList *back_forward_list, + WebKitBackForwardListItem *item_added, + gpointer items_removed, + gpointer user_data)+
This signal is emitted when back_forward_list
+ changes. This happens
+when the current item is updated, a new item is added or one or more
+items are removed. Note that both item_added
+ and items_removed
+ can
+NULL when only the current item is updated. Items are only removed
+when the list is cleared or the maximum items limit is reached.
back_forward_list |
+the WebKitBackForwardList on which the signal was emitted |
++ |
item_added |
+the WebKitBackForwardListItem added or |
+[allow-none] | +
items_removed |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitBackForwardListItem+WebKitBackForwardListItem — One item of the WebKitBackForwardList + |
++ |
| const gchar * + | ++webkit_back_forward_list_item_get_title () + | +
| const gchar * + | ++webkit_back_forward_list_item_get_uri () + | +
| const gchar * + | ++webkit_back_forward_list_item_get_original_uri () + | +
A history item is part of the WebKitBackForwardList and consists +out of a title and a URI.
+const gchar *
+webkit_back_forward_list_item_get_title
+ (WebKitBackForwardListItem *list_item);
+
+
+const gchar *
+webkit_back_forward_list_item_get_uri (WebKitBackForwardListItem *list_item);
+This URI may differ from the original URI if the page was,
+for example, redirected to a new location.
+See also webkit_back_forward_list_item_get_original_uri().
const gchar *
+webkit_back_forward_list_item_get_original_uri
+ (WebKitBackForwardListItem *list_item);
+See also webkit_back_forward_list_item_get_uri().
| +Top + | + |
+ |
+ |
+ |
+
+WebKitContextMenu+WebKitContextMenu — Represents the context menu in a WebKitWebView + |
++ |
| +WebKitContextMenu * + | ++webkit_context_menu_new () + | +
| +WebKitContextMenu * + | ++webkit_context_menu_new_with_items () + | +
| +void + | ++webkit_context_menu_prepend () + | +
| +void + | ++webkit_context_menu_append () + | +
| +void + | ++webkit_context_menu_insert () + | +
| +void + | ++webkit_context_menu_move_item () + | +
| +GList * + | ++webkit_context_menu_get_items () + | +
| +guint + | ++webkit_context_menu_get_n_items () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_first () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_last () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_get_item_at_position () + | +
| +void + | ++webkit_context_menu_remove () + | +
| +void + | ++webkit_context_menu_remove_all () + | +
| +void + | ++webkit_context_menu_set_user_data () + | +
| +GVariant * + | ++webkit_context_menu_get_user_data () + | +
WebKitContextMenu represents a context menu containing +WebKitContextMenuItems in a WebKitWebView.
+When a WebKitWebView is about to display the context menu, it
+emits the “context-menu” signal, which has the
+WebKitContextMenu as an argument. You can modify it, adding new
+submenus that you can create with webkit_context_menu_new(), adding
+new WebKitContextMenuItems with
+webkit_context_menu_prepend(), webkit_context_menu_append() or
+webkit_context_menu_insert(), maybe after having removed the
+existing ones with webkit_context_menu_remove_all().
WebKitContextMenu *
+webkit_context_menu_new (void);
+Creates a new WebKitContextMenu object to be used as a submenu of an existing
+WebKitContextMenu. The context menu of a WebKitWebView is created by the view
+and passed as an argument of “context-menu” signal.
+To add items to the menu use webkit_context_menu_prepend(),
+webkit_context_menu_append() or webkit_context_menu_insert().
+See also webkit_context_menu_new_with_items() to create a WebKitContextMenu with
+a list of initial items.
WebKitContextMenu *
+webkit_context_menu_new_with_items (GList *items);
+Creates a new WebKitContextMenu object to be used as a submenu of an existing
+WebKitContextMenu with the given initial items.
+See also webkit_context_menu_new()
items |
+a GList of WebKitContextMenuItem. |
+[element-type WebKitContextMenuItem] | +
void +webkit_context_menu_prepend (+WebKitContextMenu *menu, +WebKitContextMenuItem *item);
Adds item
+ at the beginning of the menu
+.
void +webkit_context_menu_append (+WebKitContextMenu *menu, +WebKitContextMenuItem *item);
Adds item
+ at the end of the menu
+.
void +webkit_context_menu_insert (+WebKitContextMenu *menu, +WebKitContextMenuItem *item, +gint position);
Inserts item
+ into the menu
+ at the given position.
+If position
+ is negative, or is larger than the number of items
+in the WebKitContextMenu, the item is added on to the end of
+the menu
+. The first position is 0.
menu |
++ | + |
item |
+the WebKitContextMenuItem to add |
++ |
position |
+the position to insert the item |
++ |
void +webkit_context_menu_move_item (+WebKitContextMenu *menu, +WebKitContextMenuItem *item, +gint position);
Moves item
+ to the given position in the menu
+.
+If position
+ is negative, or is larger than the number of items
+in the WebKitContextMenu, the item is added on to the end of
+the menu
+.
+The first position is 0.
menu |
++ | + |
item |
+the WebKitContextMenuItem to add |
++ |
position |
+the new position to move the item |
++ |
GList *
+webkit_context_menu_get_items (WebKitContextMenu *menu);
+Returns the item list of menu
+.
a GList of +WebKitContextMenuItems.
+[element-type WebKitContextMenuItem][transfer none]
+guint
+webkit_context_menu_get_n_items (WebKitContextMenu *menu);
+Gets the length of the menu
+.
WebKitContextMenuItem *
+webkit_context_menu_first (WebKitContextMenu *menu);
+Gets the first item in the menu
+.
the first WebKitContextMenuItem of menu
+,
+or NULL if the WebKitContextMenu is empty.
[transfer none]
+WebKitContextMenuItem *
+webkit_context_menu_last (WebKitContextMenu *menu);
+Gets the last item in the menu
+.
the last WebKitContextMenuItem of menu
+,
+or NULL if the WebKitContextMenu is empty.
[transfer none]
+WebKitContextMenuItem * +webkit_context_menu_get_item_at_position + (+WebKitContextMenu *menu, +guint position);
Gets the item at the given position in the menu
+.
menu |
++ | + |
position |
+the position of the item, counting from 0 |
++ |
the WebKitContextMenuItem at position position
+in menu
+,
+or NULL if the position is off the end of the menu
+.
[transfer none]
+void +webkit_context_menu_remove (+WebKitContextMenu *menu, +WebKitContextMenuItem *item);
Removes item
+ from the menu
+.
+See also webkit_context_menu_remove_all() to remove all items.
void
+webkit_context_menu_remove_all (WebKitContextMenu *menu);
+Removes all items of the menu
+.
void +webkit_context_menu_set_user_data (+WebKitContextMenu *menu, +GVariant *user_data);
Sets user data to menu
+.
+This function can be used from a Web Process extension to set user data
+that can be retrieved from the UI Process using webkit_context_menu_get_user_data().
+If the user_data
+ GVariant is floating, it is consumed.
Since: 2.8
+GVariant *
+webkit_context_menu_get_user_data (WebKitContextMenu *menu);
+Gets the user data of menu
+.
+This function can be used from the UI Process to get user data previously set
+from the Web Process with webkit_context_menu_set_user_data().
Since: 2.8
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitContextMenuItem+WebKitContextMenuItem — One item of the WebKitContextMenu + |
++ |
| +WebKitContextMenuItem * + | ++webkit_context_menu_item_new_from_gaction () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_item_new_from_stock_action () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_item_new_from_stock_action_with_label () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_item_new_with_submenu () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_item_new_separator () + | +
| +GAction * + | ++webkit_context_menu_item_get_gaction () + | +
| +WebKitContextMenuAction + | ++webkit_context_menu_item_get_stock_action () + | +
| +gboolean + | ++webkit_context_menu_item_is_separator () + | +
| +void + | ++webkit_context_menu_item_set_submenu () + | +
| +WebKitContextMenu * + | ++webkit_context_menu_item_get_submenu () + | +
The WebKitContextMenu is composed of WebKitContextMenuItems. These items can be created from a GtkAction, from a +WebKitContextMenuAction or from a WebKitContextMenuAction and a +label. These WebKitContextMenuActions denote stock actions +for the items. You can also create separators and submenus.
+WebKitContextMenuItem * +webkit_context_menu_item_new_from_gaction + (+GAction *action, +const gchar *label, +GVariant *target);
Creates a new WebKitContextMenuItem for the given action
+ and label
+. On activation
+target
+ will be passed as parameter to the callback.
Since: 2.18
+WebKitContextMenuItem *
+webkit_context_menu_item_new_from_stock_action
+ (WebKitContextMenuAction action);
+Creates a new WebKitContextMenuItem for the given stock action.
+Stock actions are handled automatically by WebKit so that, for example,
+when a menu item created with a WEBKIT_CONTEXT_MENU_ACTION_STOP is
+activated the action associated will be handled by WebKit and the current
+load operation will be stopped. You can get the GtkAction of a
+WebKitContextMenuItem created with a WebKitContextMenuAction with
+webkit_context_menu_item_get_action() and connect to “activate” signal
+to be notified when the item is activated. But you can't prevent the associated
+action from being performed.
WebKitContextMenuItem * +webkit_context_menu_item_new_from_stock_action_with_label + (+WebKitContextMenuAction action, +const gchar *label);
Creates a new WebKitContextMenuItem for the given stock action using the given label
+.
+Stock actions have a predefined label, this method can be used to create a
+WebKitContextMenuItem for a WebKitContextMenuAction but using a custom label.
action |
+a WebKitContextMenuAction stock action |
++ |
label |
+a custom label text to use instead of the predefined one |
++ |
WebKitContextMenuItem * +webkit_context_menu_item_new_with_submenu + (+const gchar *label, +WebKitContextMenu *submenu);
Creates a new WebKitContextMenuItem using the given label
+ with a submenu.
label |
+the menu item label text |
++ |
submenu |
+a WebKitContextMenu to set |
++ |
WebKitContextMenuItem *
+webkit_context_menu_item_new_separator
+ (void);
+Creates a new WebKitContextMenuItem representing a separator.
+ +GAction *
+webkit_context_menu_item_get_gaction (WebKitContextMenuItem *item);
+Gets the action associated to item
+ as a GAction.
the GAction associated to the WebKitContextMenuItem,
+or NULL if item
+is a separator.
[transfer none]
+Since: 2.18
+WebKitContextMenuAction
+webkit_context_menu_item_get_stock_action
+ (WebKitContextMenuItem *item);
+Gets the WebKitContextMenuAction of item
+. If the WebKitContextMenuItem was not
+created for a stock action WEBKIT_CONTEXT_MENU_ACTION_CUSTOM will be
+returned. If the WebKitContextMenuItem is a separator WEBKIT_CONTEXT_MENU_ACTION_NO_ACTION
+will be returned.
gboolean
+webkit_context_menu_item_is_separator (WebKitContextMenuItem *item);
+Checks whether item
+ is a separator.
void +webkit_context_menu_item_set_submenu (+WebKitContextMenuItem *item, +WebKitContextMenu *submenu);
Sets or replaces the item
+ submenu. If submenu
+ is NULL the current
+submenu of item
+ is removed.
WebKitContextMenu *
+webkit_context_menu_item_get_submenu (WebKitContextMenuItem *item);
+Gets the submenu of item
+.
the WebKitContextMenu representing the submenu of
+item
+or NULL if item
+doesn't have a submenu.
[transfer none]
+Enum values used to denote the stock actions for +WebKitContextMenuItems
+| + |
+ No action, used by separator menu items. + |
++ |
| + |
+ Open current link. + |
++ |
| + |
+ Open current link in a new window. + |
++ |
| + |
+ Download link destination. + |
++ |
| + |
+ Copy link location to the clipboard. + |
++ |
| + |
+ Open current image in a new window. + |
++ |
| + |
+ Download current image. + |
++ |
| + |
+ Copy current image to the clipboard. + |
++ |
| + |
+ Open current frame in a new window. + |
++ |
| + |
+ Load the previous history item. + |
++ |
| + |
+ Load the next history item. + |
++ |
| + |
+ Stop any ongoing loading operation. + |
++ |
| + |
+ Reload the contents of current view. + |
++ |
| + |
+ Copy current selection the clipboard. + |
++ |
| + |
+ Cut current selection to the clipboard. + |
++ |
| + |
+ Paste clipboard contents. + |
++ |
| + |
+ A proposed replacement for a misspelled word. + |
++ |
| + |
+ An indicator that spellchecking found no proposed replacements. + |
++ |
| + |
+ Causes the spellchecker to ignore the word for this session. + |
++ |
| + |
+ Causes the spellchecker to add the word to the dictionary. + |
++ |
| + |
+ Ignore grammar. + |
++ |
| + |
+ Font options menu. + |
++ |
| + |
+ Bold. + |
++ |
| + |
+ Italic. + |
++ |
| + |
+ Underline. + |
++ |
| + |
+ Outline. + |
++ |
| + |
+ Open current element in the inspector. + |
++ |
| + |
+ Open current video element in a new window. + |
++ |
| + |
+ Open current audio element in a new window. + |
++ |
| + |
+ Copy video link location in to the clipboard. + |
++ |
| + |
+ Copy audio link location in to the clipboard. + |
++ |
| + |
+ Enable or disable media controls. + |
++ |
| + |
+ Enable or disable media loop. + |
++ |
| + |
+ Show current video element in fullscreen mode. + |
++ |
| + |
+ Play current media element. + |
++ |
| + |
+ Pause current media element. + |
++ |
| + |
+ Mute current media element. + |
++ |
| + |
+ Download video to disk. Since 2.2 + |
++ |
| + |
+ Download audio to disk. Since 2.2 + |
++ |
| + |
+ Custom action defined by applications. + |
++ |
| +Top + | + |
+ |
+ |
+ |
+
+WebKitCookieManager+WebKitCookieManager — Defines how to handle cookies in a WebKitWebContext + |
++ |
| +void + | ++webkit_cookie_manager_set_persistent_storage () + | +
| +void + | ++webkit_cookie_manager_set_accept_policy () + | +
| +void + | ++webkit_cookie_manager_get_accept_policy () + | +
| +WebKitCookieAcceptPolicy + | ++webkit_cookie_manager_get_accept_policy_finish () + | +
| +void + | ++webkit_cookie_manager_add_cookie () + | +
| +gboolean + | ++webkit_cookie_manager_add_cookie_finish () + | +
| +void + | ++webkit_cookie_manager_get_cookies () + | +
| +GList * + | ++webkit_cookie_manager_get_cookies_finish () + | +
| +void + | ++webkit_cookie_manager_delete_cookie () + | +
| +gboolean + | ++webkit_cookie_manager_delete_cookie_finish () + | +
| struct | +WebKitCookieManager | +
| enum | +WebKitCookiePersistentStorage | +
| enum | +WebKitCookieAcceptPolicy | +
The WebKitCookieManager defines how to set up and handle cookies.
+You can get it from a WebKitWebsiteDataManager with
+webkit_website_data_manager_get_cookie_manager(), and use it to set where to
+store cookies with webkit_cookie_manager_set_persistent_storage(),
+or to set the acceptance policy, with webkit_cookie_manager_get_accept_policy().
void +webkit_cookie_manager_set_persistent_storage + (+WebKitCookieManager *cookie_manager, +const gchar *filename, +WebKitCookiePersistentStorage storage);
Set the filename
+ where non-session cookies are stored persistently using
+storage
+ as the format to read/write the cookies.
+Cookies are initially read from filename
+ to create an initial set of cookies.
+Then, non-session cookies will be written to filename
+ when the WebKitCookieManager::changed
+signal is emitted.
+By default, cookie_manager
+ doesn't store the cookies persistently, so you need to call this
+method to keep cookies saved across sessions.
This method should never be called on a WebKitCookieManager associated to an ephemeral WebKitWebsiteDataManager.
+ +void +webkit_cookie_manager_set_accept_policy + (+WebKitCookieManager *cookie_manager, +WebKitCookieAcceptPolicy policy);
Set the cookie acceptance policy of cookie_manager
+ as policy
+.
void +webkit_cookie_manager_get_accept_policy + (+WebKitCookieManager *cookie_manager, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously get the cookie acceptance policy of cookie_manager
+.
When the operation is finished, callback
+ will be called. You can then call
+webkit_cookie_manager_get_accept_policy_finish() to get the result of the operation.
cookie_manager |
++ | + |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
WebKitCookieAcceptPolicy +webkit_cookie_manager_get_accept_policy_finish + (+WebKitCookieManager *cookie_manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_cookie_manager_get_accept_policy().
cookie_manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
void +webkit_cookie_manager_add_cookie (+WebKitCookieManager *cookie_manager, +SoupCookie *cookie, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously add a SoupCookie to the underlying storage.
+When the operation is finished, callback
+ will be called. You can then call
+webkit_cookie_manager_add_cookie_finish() to get the result of the operation.
cookie_manager |
++ | + |
cookie |
+the SoupCookie to be added |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.20
+gboolean +webkit_cookie_manager_add_cookie_finish + (+WebKitCookieManager *cookie_manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_cookie_manager_add_cookie().
cookie_manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
Since: 2.20
+void +webkit_cookie_manager_get_cookies (+WebKitCookieManager *cookie_manager, +const gchar *uri, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously get a list of SoupCookie from cookie_manager
+ associated with uri
+, which
+must be either an HTTP or an HTTPS URL.
When the operation is finished, callback
+ will be called. You can then call
+webkit_cookie_manager_get_cookies_finish() to get the result of the operation.
cookie_manager |
++ | + |
uri |
+the URI associated to the cookies to be retrieved |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.20
+GList * +webkit_cookie_manager_get_cookies_finish + (+WebKitCookieManager *cookie_manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_cookie_manager_get_cookies().
+The return value is a GSList of SoupCookie instances which should be released
+with g_list_free_full() and soup_cookie_free().
cookie_manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
Since: 2.20
+void +webkit_cookie_manager_delete_cookie (+WebKitCookieManager *cookie_manager, +SoupCookie *cookie, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously delete a SoupCookie from the current session.
+When the operation is finished, callback
+ will be called. You can then call
+webkit_cookie_manager_delete_cookie_finish() to get the result of the operation.
cookie_manager |
++ | + |
cookie |
+the SoupCookie to be deleted |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.20
+gboolean +webkit_cookie_manager_delete_cookie_finish + (+WebKitCookieManager *cookie_manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_cookie_manager_delete_cookie().
cookie_manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
Since: 2.20
+Enum values used to denote the cookie persistent storage types.
+ +“changed” signalvoid +user_function (WebKitCookieManager *cookie_manager, + gpointer user_data)+
This signal is emitted when cookies are added, removed or modified.
+cookie_manager |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitDownload+WebKitDownload — Object used to communicate with the application when downloading + |
++ |
| +WebKitURIRequest * + | ++webkit_download_get_request () + | +
| const gchar * + | ++webkit_download_get_destination () + | +
| +void + | ++webkit_download_set_destination () + | +
| +WebKitURIResponse * + | ++webkit_download_get_response () + | +
| +void + | ++webkit_download_cancel () + | +
| +gdouble + | ++webkit_download_get_estimated_progress () + | +
| +gdouble + | ++webkit_download_get_elapsed_time () + | +
| +guint64 + | ++webkit_download_get_received_data_length () + | +
| +WebKitWebView * + | ++webkit_download_get_web_view () + | +
| +gboolean + | ++webkit_download_get_allow_overwrite () + | +
| +void + | ++webkit_download_set_allow_overwrite () + | +
| gboolean | +allow-overwrite | +Read / Write | +
| +gchar * | +destination | +Read | +
| gdouble | +estimated-progress | +Read | +
| +WebKitURIResponse * | +response | +Read | +
| void | +created-destination | +Run Last | +
| gboolean | +decide-destination | +Run Last | +
| void | +failed | +Run Last | +
| void | +finished | +Run Last | +
| void | +received-data | +Run Last | +
WebKitDownload carries information about a download request and +response, including a WebKitURIRequest and a WebKitURIResponse +objects. The application may use this object to control the +download process, or to simply figure out what is to be downloaded, +and handle the download process itself.
+WebKitURIRequest *
+webkit_download_get_request (WebKitDownload *download);
+Retrieves the WebKitURIRequest object that backs the download +process.
+ + +const gchar *
+webkit_download_get_destination (WebKitDownload *download);
+Obtains the URI to which the downloaded file will be written. You +can connect to “created-destination” to make +sure this method returns a valid destination.
+ + +void +webkit_download_set_destination (+WebKitDownload *download, +const gchar *uri);
Sets the URI to which the downloaded file will be written.
+This method should be called before the download transfer
+starts or it will not have any effect on the ongoing download
+operation. To set the destination using the filename suggested
+by the server connect to “decide-destination”
+signal and call webkit_download_set_destination(). If you want to
+set a fixed destination URI that doesn't depend on the suggested
+filename you can connect to notify::response signal and call
+webkit_download_set_destination().
+If “decide-destination” signal is not handled
+and destination URI is not set when the download transfer starts,
+the file will be saved with the filename suggested by the server in
+G_USER_DIRECTORY_DOWNLOAD directory.
WebKitURIResponse *
+webkit_download_get_response (WebKitDownload *download);
+Retrieves the WebKitURIResponse object that backs the download
+process. This method returns NULL if called before the response
+is received from the server. You can connect to notify::response
+signal to be notified when the response is received.
the WebKitURIResponse, or NULL if
+the response hasn't been received yet.
[transfer none]
+void
+webkit_download_cancel (WebKitDownload *download);
+Cancels the download. When the ongoing download
+operation is effectively cancelled the signal
+“failed” is emitted with
+WEBKIT_DOWNLOAD_ERROR_CANCELLED_BY_USER error.
gdouble
+webkit_download_get_estimated_progress
+ (WebKitDownload *download);
+Gets the value of the “estimated-progress” property.
+You can monitor the estimated progress of the download operation by
+connecting to the notify::estimated-progress signal of download
+.
gdouble
+webkit_download_get_elapsed_time (WebKitDownload *download);
+Gets the elapsed time in seconds, including any fractional part. +If the download finished, had an error or was cancelled this is +the time between its start and the event.
+ + +guint64
+webkit_download_get_received_data_length
+ (WebKitDownload *download);
+Gets the length of the data already downloaded for download
+
+in bytes.
WebKitWebView *
+webkit_download_get_web_view (WebKitDownload *download);
+Get the WebKitWebView that initiated the download.
+ +the WebKitWebView that initiated download
+,
+or NULL if download
+was not initiated by a WebKitWebView.
[transfer none]
+gboolean
+webkit_download_get_allow_overwrite (WebKitDownload *download);
+Returns the current value of the “allow-overwrite” property, +which determines whether the download will overwrite an existing file on +disk, or if it will fail if the destination already exists.
+ + +Since: 2.6
+void +webkit_download_set_allow_overwrite (+WebKitDownload *download, +gboolean allowed);
Sets the “allow-overwrite” property, which determines whether +the download may overwrite an existing file on disk, or if it will fail if +the destination already exists.
+download |
++ | + |
allowed |
+the new value for the “allow-overwrite” property |
++ |
Since: 2.6
+“allow-overwrite” property“allow-overwrite” gboolean+
Whether or not the download is allowed to overwrite an existing file on
+disk. If this property is FALSE and the destination already exists,
+the download will fail.
Flags: Read / Write
+Default value: FALSE
+Since: 2.6
+“destination” property“destination” gchar *+
The local URI to where the download will be saved.
+Flags: Read
+Default value: NULL
+“estimated-progress” property“estimated-progress” gdouble+
An estimate of the percent completion for the download operation. +This value will range from 0.0 to 1.0. The value is an estimate +based on the total number of bytes expected to be received for +a download. +If you need a more accurate progress information you can connect to +“received-data” signal to track the progress.
+Flags: Read
+Allowed values: [0,1]
+Default value: 1
+“response” property“response” WebKitURIResponse *+
The WebKitURIResponse associated with this download.
+Flags: Read
+“created-destination” signalvoid +user_function (WebKitDownload *download, + gchar *destination, + gpointer user_data)+
This signal is emitted after “decide-destination” and before
+“received-data” to notify that destination file has been
+created successfully at destination
+.
download |
+the WebKitDownload |
++ |
destination |
+the destination URI |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“decide-destination” signalgboolean +user_function (WebKitDownload *download, + gchar *suggested_filename, + gpointer user_data)+
This signal is emitted after response is received to
+decide a destination URI for the download. If this signal is not
+handled the file will be downloaded to G_USER_DIRECTORY_DOWNLOAD
+directory using suggested_filename
+.
download |
+the WebKitDownload |
++ |
suggested_filename |
+the filename suggested for the download |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“failed” signalvoid +user_function (WebKitDownload *download, + GError *error, + gpointer user_data)+
This signal is emitted when an error occurs during the download
+operation. The given error
+, of the domain WEBKIT_DOWNLOAD_ERROR,
+contains further details of the failure. If the download is cancelled
+with webkit_download_cancel(), this signal is emitted with error
+WEBKIT_DOWNLOAD_ERROR_CANCELLED_BY_USER. The download operation finishes
+after an error and “finished” signal is emitted after this one.
download |
+the WebKitDownload |
++ |
error |
+the GError that was triggered |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“finished” signalvoid +user_function (WebKitDownload *download, + gpointer user_data)+
This signal is emitted when download finishes successfully or due to an error. +In case of errors “failed” signal is emitted before this one.
+download |
+the WebKitDownload |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“received-data” signalvoid +user_function (WebKitDownload *download, + guint64 data_length, + gpointer user_data)+
This signal is emitted after response is received, +every time new data has been written to the destination. It's +useful to know the progress of the download operation.
+download |
+the WebKitDownload |
++ |
data_length |
+the length of data received in bytes |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
| +guint + | ++webkit_editor_state_get_typing_attributes () + | +
| +gboolean + | ++webkit_editor_state_is_cut_available () + | +
| +gboolean + | ++webkit_editor_state_is_copy_available () + | +
| +gboolean + | ++webkit_editor_state_is_paste_available () + | +
| +gboolean + | ++webkit_editor_state_is_undo_available () + | +
| +gboolean + | ++webkit_editor_state_is_redo_available () + | +
| struct | +WebKitEditorState | +
| enum | +WebKitEditorTypingAttributes | +
WebKitEditorState represents the state of a WebKitWebView editor.
+Use webkit_web_view_get_editor_state() to get the WebKitEditorState
+of a WebKitWebView.
guint
+webkit_editor_state_get_typing_attributes
+ (WebKitEditorState *editor_state);
+Gets the typing attributes at the current cursor position. +If there is a selection, this returns the typing attributes +of the selected text. Note that in case of a selection, +typing attributes are considered active only when they are +present throughout the selection.
+ + +Since: 2.10
+gboolean
+webkit_editor_state_is_cut_available (WebKitEditorState *editor_state);
+Gets whether a cut command can be issued.
+ + +Since: 2.20
+gboolean
+webkit_editor_state_is_copy_available (WebKitEditorState *editor_state);
+Gets whether a copy command can be issued.
+ + +Since: 2.20
+gboolean
+webkit_editor_state_is_paste_available
+ (WebKitEditorState *editor_state);
+Gets whether a paste command can be issued.
+ + +Since: 2.20
+gboolean
+webkit_editor_state_is_undo_available (WebKitEditorState *editor_state);
+Gets whether an undo command can be issued.
+ + +Since: 2.20
+gboolean
+webkit_editor_state_is_redo_available (WebKitEditorState *editor_state);
+Gets whether a redo command can be issued.
+ + +Since: 2.20
+Enum values with flags representing typing attributes.
+| + |
+ No typing attributes. + |
++ |
| + |
+ Bold typing attribute. + |
++ |
| + |
+ Italic typing attribute. + |
++ |
| + |
+ Underline typing attribute. + |
++ |
| + |
+ Strikethrough typing attribute. + |
++ |
Since: 2.10
+“typing-attributes” property“typing-attributes” guint+
Bitmask of WebKitEditorTypingAttributes flags.
+See webkit_editor_state_get_typing_attributes() for more information.
Flags: Read
+Default value: 0
+Since: 2.10
+| +Top + | + |
+ |
+ |
+ |
+
| +gchar * + | ++webkit_favicon_database_get_favicon_uri () + | +
| +void + | ++webkit_favicon_database_clear () + | +
| struct | +WebKitFaviconDatabase | +
| #define | +WEBKIT_FAVICON_DATABASE_ERROR | +
| enum | +WebKitFaviconDatabaseError | +
WebKitFaviconDatabase provides access to the icons associated with +web sites.
+WebKit will automatically look for available icons in <link> +elements on opened pages as well as an existing favicon.ico and +load the images found into a memory cache if possible. That cache +is frozen to an on-disk database for persistence.
+If “enable-private-browsing” is TRUE, new icons
+won't be added to the on-disk database and no existing icons will
+be deleted from it. Nevertheless, WebKit will still store them in
+the in-memory cache during the current execution.
gchar * +webkit_favicon_database_get_favicon_uri + (+WebKitFaviconDatabase *database, +const gchar *page_uri);
Obtains the URI of the favicon for the given page_uri
+.
database |
++ | + |
page_uri |
+URI of the page containing the icon |
++ |
a newly allocated URI for the favicon, or NULL if the
+database doesn't have a favicon for page_uri
+.
void
+webkit_favicon_database_clear (WebKitFaviconDatabase *database);
+Clears all icons from the database.
+ +#define WEBKIT_FAVICON_DATABASE_ERROR (webkit_favicon_database_error_quark()) ++
Enum values used to denote the various errors related to the WebKitFaviconDatabase.
+| + |
+ The WebKitFaviconDatabase has not been initialized yet + |
++ |
| + |
+ There is not an icon available for the requested URL + |
++ |
| + |
+ There might be an icon for the requested URL, but its data is unknown at the moment + |
++ |
“favicon-changed” signalvoid +user_function (WebKitFaviconDatabase *database, + gchar *page_uri, + gchar *favicon_uri, + gpointer user_data)+
This signal is emitted when the favicon URI of page_uri
+ has
+been changed to favicon_uri
+ in the database. You can connect
+to this signal and call webkit_favicon_database_get_favicon()
+to get the favicon. If you are interested in the favicon of a
+WebKitWebView it's easier to use the “favicon”
+property. See webkit_web_view_get_favicon() for more details.
database |
+the object on which the signal is emitted |
++ |
page_uri |
+the URI of the Web page containing the icon |
++ |
favicon_uri |
+the URI of the favicon |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
| const gchar * const * + | ++webkit_file_chooser_request_get_mime_types () + | +
| +gboolean + | ++webkit_file_chooser_request_get_select_multiple () + | +
| +void + | ++webkit_file_chooser_request_select_files () + | +
| const gchar * const * + | ++webkit_file_chooser_request_get_selected_files () + | +
| +void + | ++webkit_file_chooser_request_cancel () + | +
| GStrv | +mime-types | +Read | +
| gboolean | +select-multiple | +Read | +
| GStrv | +selected-files | +Read | +
Whenever the user interacts with an <input type='file' /> +HTML element, WebKit will need to show a dialog to choose one or +more files to be uploaded to the server along with the rest of the +form data. For that to happen in a general way, instead of just +opening a GtkFileChooserDialog (which might be not desirable in +some cases, which could prefer to use their own file chooser +dialog), WebKit will fire the “run-file-chooser” +signal with a WebKitFileChooserRequest object, which will allow +the client application to specify the files to be selected, to +inspect the details of the request (e.g. if multiple selection +should be allowed) and to cancel the request, in case nothing was +selected.
+In case the client application does not wish to handle this signal, +WebKit will provide a default handler which will asynchronously run +a regular GtkFileChooserDialog for the user to interact with.
+const gchar * const *
+webkit_file_chooser_request_get_mime_types
+ (WebKitFileChooserRequest *request);
+Get the list of MIME types the file chooser dialog should handle, +in the format specified in RFC 2046 for "media types". Its contents +depend on the value of the 'accept' attribute for HTML input +elements. This function should normally be called before presenting +the file chooser dialog to the user, to decide whether to allow the +user to select multiple files at once or only one.
+ + +gboolean
+webkit_file_chooser_request_get_select_multiple
+ (WebKitFileChooserRequest *request);
+Determine whether the file chooser associated to this +WebKitFileChooserRequest should allow selecting multiple files, +which depends on the HTML input element having a 'multiple' +attribute defined.
+ + +void +webkit_file_chooser_request_select_files + (+WebKitFileChooserRequest *request, +const gchar * const *files);
Ask WebKit to select local files for upload and complete the +request.
+request |
++ | + |
files |
+a
+ |
+[array zero-terminated=1][transfer none] | +
const gchar * const *
+webkit_file_chooser_request_get_selected_files
+ (WebKitFileChooserRequest *request);
+Get the list of selected files currently associated to the +request. Initially, the return value of this method contains any +files selected in previous file chooser requests for this HTML +input element. Once webkit_file_chooser_request_select_files, the +value will reflect whatever files are given.
+This function should normally be called only before presenting the +file chooser dialog to the user, to decide whether to perform some +extra action, like pre-selecting the files from a previous request.
+ + +void
+webkit_file_chooser_request_cancel (WebKitFileChooserRequest *request);
+Ask WebKit to cancel the request. It's important to do this in case +no selection has been made in the client, otherwise the request +won't be properly completed and the browser will keep the request +pending forever, which might cause the browser to hang.
+ +“mime-types” property“mime-types” GStrv+
A NULL-terminated array of strings containing the list of MIME
+types the file chooser dialog should handle. See
+webkit_file_chooser_request_get_mime_types() for more details.
Flags: Read
+“select-multiple” property“select-multiple” gboolean+
Whether the file chooser should allow selecting multiple
+files. See
+webkit_file_chooser_request_get_select_multiple() for
+more details.
Flags: Read
+Default value: FALSE
+“selected-files” property“selected-files” GStrv+
A NULL-terminated array of strings containing the list of
+selected files associated to the current request. See
+webkit_file_chooser_request_get_selected_files() for more details.
Flags: Read
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitFindController+WebKitFindController — Controls text search in a WebKitWebView + |
++ |
| +void + | ++webkit_find_controller_search () + | +
| +void + | ++webkit_find_controller_search_finish () + | +
| +void + | ++webkit_find_controller_search_next () + | +
| +void + | ++webkit_find_controller_search_previous () + | +
| const gchar * + | ++webkit_find_controller_get_search_text () + | +
| +void + | ++webkit_find_controller_count_matches () + | +
| +guint32 + | ++webkit_find_controller_get_options () + | +
| +guint + | ++webkit_find_controller_get_max_match_count () + | +
| +WebKitWebView * + | ++webkit_find_controller_get_web_view () + | +
| guint | +max-match-count | +Read | +
| WebKitFindOptions | +options | +Read | +
| +gchar * | +text | +Read | +
| +WebKitWebView * | +web-view | +Read / Write / Construct Only | +
| void | +counted-matches | +Run Last | +
| void | +failed-to-find-text | +Run Last | +
| void | +found-text | +Run Last | +
A WebKitFindController is used to search text in a WebKitWebView. You
+can get a WebKitWebView's WebKitFindController with
+webkit_web_view_get_find_controller(), and later use it to search
+for text using webkit_find_controller_search(), or get the
+number of matches using webkit_find_controller_count_matches(). The
+operations are asynchronous and trigger signals when ready, such as
+“found-text”,
+“failed-to-find-text” or
+“counted-matches”.
void +webkit_find_controller_search (+WebKitFindController *find_controller, +const gchar *search_text, +guint32 find_options, +guint max_match_count);
Looks for search_text
+ in the WebKitWebView associated with
+find_controller
+ since the beginning of the document highlighting
+up to max_match_count
+ matches. The outcome of the search will be
+asynchronously provided by the “found-text”
+and “failed-to-find-text” signals.
To look for the next or previous occurrences of the same text
+with the same find options use webkit_find_controller_search_next()
+and/or webkit_find_controller_search_previous(). The
+WebKitFindController will use the same text and options for the
+following searches unless they are modified by another call to this
+method.
Note that if the number of matches is higher than max_match_count
+
+then “found-text” will report G_MAXUINT matches
+instead of the actual number.
Callers should call webkit_find_controller_search_finish() to
+finish the current search operation.
find_controller |
++ | + |
search_text |
+the text to look for |
++ |
find_options |
+a bitmask with the WebKitFindOptions used in the search |
++ |
max_match_count |
+the maximum number of matches allowed in the search |
++ |
void
+webkit_find_controller_search_finish (WebKitFindController *find_controller);
+Finishes a find operation started by
+webkit_find_controller_search(). It will basically unhighlight
+every text match found.
This method will be typically called when the search UI is +closed/hidden by the client application.
+ +void
+webkit_find_controller_search_next (WebKitFindController *find_controller);
+Looks for the next occurrence of the search text.
+Calling this method before webkit_find_controller_search() or
+webkit_find_controller_count_matches() is a programming error.
void
+webkit_find_controller_search_previous
+ (WebKitFindController *find_controller);
+Looks for the previous occurrence of the search text.
+Calling this method before webkit_find_controller_search() or
+webkit_find_controller_count_matches() is a programming error.
const gchar *
+webkit_find_controller_get_search_text
+ (WebKitFindController *find_controller);
+Gets the text that find_controller
+ is currently searching
+for. This text is passed to either
+webkit_find_controller_search() or
+webkit_find_controller_count_matches().
void +webkit_find_controller_count_matches (+WebKitFindController *find_controller, +const gchar *search_text, +guint32 find_options, +guint max_match_count);
Counts the number of matches for search_text
+ found in the
+WebKitWebView with the provided find_options
+. The number of
+matches will be provided by the
+“counted-matches” signal.
find_controller |
++ | + |
search_text |
+the text to look for |
++ |
find_options |
+a bitmask with the WebKitFindOptions used in the search |
++ |
max_match_count |
+the maximum number of matches allowed in the search |
++ |
guint32
+webkit_find_controller_get_options (WebKitFindController *find_controller);
+Gets a bitmask containing the WebKitFindOptions associated with +the current search.
+ + +guint
+webkit_find_controller_get_max_match_count
+ (WebKitFindController *find_controller);
+Gets the maximum number of matches to report during a text
+lookup. This number is passed as the last argument of
+webkit_find_controller_search() or
+webkit_find_controller_count_matches().
WebKitWebView *
+webkit_find_controller_get_web_view (WebKitFindController *find_controller);
+Gets the WebKitWebView this find controller is associated to. Do +not dereference the returned instance as it belongs to the +WebKitFindController.
+ + +Enum values used to specify search options.
+| + |
+ no search flags, this means a case + sensitive, no wrap, forward only search. + |
++ |
| + |
+ case insensitive search. + |
++ |
| + |
+ search text only at the + begining of the words. + |
++ |
| + |
+ treat + capital letters in the middle of words as word start. + |
++ |
| + |
+ search backwards. + |
++ |
| + |
+ if not present search will stop + at the end of the document. + |
++ |
“max-match-count” property“max-match-count” guint+
The maximum number of matches to report for a given search.
+Flags: Read
+Default value: 0
+“options” property“options” WebKitFindOptions+
The options to be used in the search operation.
+Flags: Read
+“text” property“text” gchar *+
The current search text for this WebKitFindController.
+Flags: Read
+Default value: NULL
+“web-view” property“web-view” WebKitWebView *+
The WebKitWebView this controller is associated to.
+Flags: Read / Write / Construct Only
+“counted-matches” signalvoid +user_function (WebKitFindController *find_controller, + guint match_count, + gpointer user_data)+
This signal is emitted when the WebKitFindController has
+counted the number of matches for a given text after a call
+to webkit_find_controller_count_matches().
find_controller |
++ | + |
match_count |
+the number of matches of the search text |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“failed-to-find-text” signalvoid +user_function (WebKitFindController *find_controller, + gpointer user_data)+
This signal is emitted when a search operation does not find
+any result for the given text. It will be issued if the text
+is not found asynchronously after a call to
+webkit_find_controller_search(), webkit_find_controller_search_next()
+or webkit_find_controller_search_previous().
find_controller |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“found-text” signalvoid +user_function (WebKitFindController *find_controller, + guint match_count, + gpointer user_data)+
This signal is emitted when a given text is found in the web
+page text. It will be issued if the text is found
+asynchronously after a call to webkit_find_controller_search(),
+webkit_find_controller_search_next() or
+webkit_find_controller_search_previous().
find_controller |
++ | + |
match_count |
+the number of matches found of the search text |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitFormSubmissionRequest+WebKitFormSubmissionRequest — Represents a form submission request + |
++ |
| +gboolean + | ++webkit_form_submission_request_list_text_fields () + | +
| +void + | ++webkit_form_submission_request_submit () + | +
When a form is about to be submitted in a WebKitWebView, the
+“submit-form” signal is emitted. Its request argument
+contains information about the text fields of the form, that are
+typically used to store login information, returned as lists by
+webkit_form_submission_request_list_text_fields(). You can submit the
+form with webkit_form_submission_request_submit().
gboolean +webkit_form_submission_request_list_text_fields + (+WebKitFormSubmissionRequest *request, +GPtrArray **field_names, +GPtrArray **field_values);
Get lists with the names and values of the text fields contained in
+the form associated to request
+. Note that names and values may be
+NULL.
If this function returns FALSE, then both field_names
+ and
+field_values
+ will be empty.
request |
++ | + |
field_names |
+names of the text fields in the form. |
+[out][optional][element-type utf8][transfer none] | +
field_values |
+values of the text fields in the form. |
+[out][optional][element-type utf8][transfer none] | +
Since: 2.20
+void
+webkit_form_submission_request_submit (WebKitFormSubmissionRequest *request);
+Continue the form submission.
+ +| +Top + | + |
+ |
+ |
+ |
+
+WebKitGeolocationPermissionRequest+WebKitGeolocationPermissionRequest — A permission request for sharing user's location + |
++ |
+WebKitGeolocationPermissionRequest implements + WebKitPermissionRequest.
+WebKitGeolocationPermissionRequest represents a request for +permission to decide whether WebKit should provide the user's +location to a website when requested through the Geolocation API.
+When a WebKitGeolocationPermissionRequest is not handled by the user, +it is denied by default.
+When embedding web views in your application, you *must* configure an
+application identifier to allow web content to use geolocation services.
+The identifier *must* match the name of the .desktop file which describes
+the application, sans the suffix.
If your application uses GApplication (or any subclass like
+GtkApplication), WebKit will automatically use the identifier returned by
+g_application_get_application_id(). This is the recommended approach for
+enabling geolocation in applications.
If an identifier cannot be obtained through GApplication, the value
+returned by g_get_prgname() will be used instead as a fallback. For
+programs which cannot use GApplication, calling g_set_prgname() early
+during initialization is needed when the name of the executable on disk
+does not match the name of a valid .desktop file.
| +Top + | + |
+ |
+ |
+ |
+
| +guint + | ++webkit_hit_test_result_get_context () + | +
| +gboolean + | ++webkit_hit_test_result_context_is_link () + | +
| +gboolean + | ++webkit_hit_test_result_context_is_image () + | +
| +gboolean + | ++webkit_hit_test_result_context_is_media () + | +
| +gboolean + | ++webkit_hit_test_result_context_is_editable () + | +
| +gboolean + | ++webkit_hit_test_result_context_is_selection () + | +
| +gboolean + | ++webkit_hit_test_result_context_is_scrollbar () + | +
| const gchar * + | ++webkit_hit_test_result_get_link_uri () + | +
| const gchar * + | ++webkit_hit_test_result_get_link_title () + | +
| const gchar * + | ++webkit_hit_test_result_get_link_label () + | +
| const gchar * + | ++webkit_hit_test_result_get_image_uri () + | +
| const gchar * + | ++webkit_hit_test_result_get_media_uri () + | +
| guint | +context | +Read / Write / Construct Only | +
| +gchar * | +image-uri | +Read / Write / Construct Only | +
| +gchar * | +link-label | +Read / Write / Construct Only | +
| +gchar * | +link-title | +Read / Write / Construct Only | +
| +gchar * | +link-uri | +Read / Write / Construct Only | +
| +gchar * | +media-uri | +Read / Write / Construct Only | +
| struct | +WebKitHitTestResult | +
| enum | +WebKitHitTestResultContext | +
A Hit Test is an operation to get context information about a given +point in a WebKitWebView. WebKitHitTestResult represents the +result of a Hit Test. It provides context information about what is +at the coordinates of the Hit Test, such as if there's a link, +an image or a media.
+You can get the context of the HitTestResult with
+webkit_hit_test_result_get_context() that returns a bitmask of
+WebKitHitTestResultContext flags. You can also use
+webkit_hit_test_result_context_is_link(), webkit_hit_test_result_context_is_image() and
+webkit_hit_test_result_context_is_media() to determine whether there's
+a link, image or a media element at the coordinates of the Hit Test.
+Note that it's possible that several WebKitHitTestResultContext flags
+are active at the same time, for example if there's a link containing an image.
When the mouse is moved over a WebKitWebView a Hit Test is performed +for the mouse coordinates and “mouse-target-changed” +signal is emitted with a WebKitHitTestResult.
+guint
+webkit_hit_test_result_get_context (WebKitHitTestResult *hit_test_result);
+Gets the value of the “context” property.
+ + +gboolean
+webkit_hit_test_result_context_is_link
+ (WebKitHitTestResult *hit_test_result);
+Gets whether WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK flag is present in
+“context”.
gboolean
+webkit_hit_test_result_context_is_image
+ (WebKitHitTestResult *hit_test_result);
+Gets whether WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE flag is present in
+“context”.
gboolean
+webkit_hit_test_result_context_is_media
+ (WebKitHitTestResult *hit_test_result);
+Gets whether WEBKIT_HIT_TEST_RESULT_CONTEXT_MEDIA flag is present in
+“context”.
gboolean
+webkit_hit_test_result_context_is_editable
+ (WebKitHitTestResult *hit_test_result);
+Gets whether WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE flag is present in
+“context”.
gboolean
+webkit_hit_test_result_context_is_selection
+ (WebKitHitTestResult *hit_test_result);
+Gets whether WEBKIT_HIT_TEST_RESULT_CONTEXT_SELECTION flag is present in
+“context”.
TRUE if there's a selected element at the coordinates of the hit_test_result
+,
+or FALSE otherwise
Since: 2.8
+gboolean
+webkit_hit_test_result_context_is_scrollbar
+ (WebKitHitTestResult *hit_test_result);
+Gets whether WEBKIT_HIT_TEST_RESULT_CONTEXT_SCROLLBAR flag is present in
+“context”.
const gchar *
+webkit_hit_test_result_get_link_uri (WebKitHitTestResult *hit_test_result);
+Gets the value of the “link-uri” property.
+ + the URI of the link element in the coordinates of the Hit Test,
+or NULL if there isn't a link element in hit_test_result
+context
const gchar *
+webkit_hit_test_result_get_link_title (WebKitHitTestResult *hit_test_result);
+Gets the value of the “link-title” property.
+ + the title of the link element in the coordinates of the Hit Test,
+or NULL if there isn't a link element in hit_test_result
+context or the
+link element doesn't have a title
const gchar *
+webkit_hit_test_result_get_link_label (WebKitHitTestResult *hit_test_result);
+Gets the value of the “link-label” property.
+ + the label of the link element in the coordinates of the Hit Test,
+or NULL if there isn't a link element in hit_test_result
+context or the
+link element doesn't have a label
const gchar *
+webkit_hit_test_result_get_image_uri (WebKitHitTestResult *hit_test_result);
+Gets the value of the “image-uri” property.
+ + the URI of the image element in the coordinates of the Hit Test,
+or NULL if there isn't an image element in hit_test_result
+context
const gchar *
+webkit_hit_test_result_get_media_uri (WebKitHitTestResult *hit_test_result);
+Gets the value of the “media-uri” property.
+ + the URI of the media element in the coordinates of the Hit Test,
+or NULL if there isn't a media element in hit_test_result
+context
Enum values with flags representing the context of a WebKitHitTestResult.
+ +“context” property“context” guint+
Bitmask of WebKitHitTestResultContext flags representing +the context of the WebKitHitTestResult.
+Flags: Read / Write / Construct Only
+Default value: 0
+“image-uri” property“image-uri” gchar *+
The URI of the image if flag WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE
+is present in “context”
Flags: Read / Write / Construct Only
+Default value: NULL
+“link-label” property“link-label” gchar *+
The label of the link if flag WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK
+is present in “context”
Flags: Read / Write / Construct Only
+Default value: NULL
+“link-title” property“link-title” gchar *+
The title of the link if flag WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK
+is present in “context”
Flags: Read / Write / Construct Only
+Default value: NULL
+“link-uri” property“link-uri” gchar *+
The URI of the link if flag WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK
+is present in “context”
Flags: Read / Write / Construct Only
+Default value: NULL
+“media-uri” property“media-uri” gchar *+
The URI of the media if flag WEBKIT_HIT_TEST_RESULT_CONTEXT_MEDIA
+is present in “context”
Flags: Read / Write / Construct Only
+Default value: NULL
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitInstallMissingMediaPluginsPermissionRequest+WebKitInstallMissingMediaPluginsPermissionRequest — A permission request for installing missing media plugins + |
++ |
| const gchar * + | ++webkit_install_missing_media_plugins_permission_request_get_description () + | +
+WebKitInstallMissingMediaPluginsPermissionRequest implements + WebKitPermissionRequest.
+WebKitInstallMissingMediaPluginsPermissionRequest represents a request for +permission to decide whether WebKit should try to start a helper application to +install missing media plugins when the media backend couldn't play a media because +the required plugins were not available.
+When a WebKitInstallMissingMediaPluginsPermissionRequest is not handled by the user, +it is allowed by default.
+const gchar *
+webkit_install_missing_media_plugins_permission_request_get_description
+ (WebKitInstallMissingMediaPluginsPermissionRequest *request);
+Gets the description about the missing plugins provided by the media backend when a media couldn't be played.
+ + +Since: 2.10
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitNavigationAction * + | ++webkit_navigation_action_copy () + | +
| +void + | ++webkit_navigation_action_free () + | +
| +WebKitNavigationType + | ++webkit_navigation_action_get_navigation_type () + | +
| +guint + | ++webkit_navigation_action_get_mouse_button () + | +
| +guint + | ++webkit_navigation_action_get_modifiers () + | +
| +WebKitURIRequest * + | ++webkit_navigation_action_get_request () + | +
| +gboolean + | ++webkit_navigation_action_is_user_gesture () + | +
| +gboolean + | ++webkit_navigation_action_is_redirect () + | +
WebKitNavigationAction *
+webkit_navigation_action_copy (WebKitNavigationAction *navigation);
+Make a copy of navigation
+.
Since: 2.6
+void
+webkit_navigation_action_free (WebKitNavigationAction *navigation);
+Free the WebKitNavigationAction
+ +Since: 2.6
+WebKitNavigationType
+webkit_navigation_action_get_navigation_type
+ (WebKitNavigationAction *navigation);
+Return the type of action that triggered the navigation.
+ + +Since: 2.6
+guint
+webkit_navigation_action_get_mouse_button
+ (WebKitNavigationAction *navigation);
+Return the number of the mouse button that triggered the navigation, or 0 if +the navigation was not started by a mouse event.
+ + +Since: 2.6
+guint
+webkit_navigation_action_get_modifiers
+ (WebKitNavigationAction *navigation);
+Return a bitmask of GdkModifierType values describing the modifier keys that were in effect +when the navigation was requested
+ + +Since: 2.6
+WebKitURIRequest *
+webkit_navigation_action_get_request (WebKitNavigationAction *navigation);
+Return the WebKitURIRequest associated with the navigation action. +Modifications to the returned object are not taken +into account when the request is sent over the network, and is intended +only to aid in evaluating whether a navigation action should be taken or +not. To modify requests before they are sent over the network the +“send-request” signal can be used instead.
+ + +Since: 2.6
+gboolean
+webkit_navigation_action_is_user_gesture
+ (WebKitNavigationAction *navigation);
+Return whether the navigation was triggered by a user gesture like a mouse click.
+ + +Since: 2.6
+gboolean
+webkit_navigation_action_is_redirect (WebKitNavigationAction *navigation);
+Returns whether the navigation
+ was redirected.
Since: 2.20
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitNavigationPolicyDecision+WebKitNavigationPolicyDecision — A policy decision for navigation actions + |
++ |
| +WebKitNavigationAction * + | ++webkit_navigation_policy_decision_get_navigation_action () + | +
| const gchar * + | ++webkit_navigation_policy_decision_get_frame_name () + | +
| +gchar * | +frame-name | +Read | +
| +WebKitNavigationAction * | +navigation-action | +Read | +
| struct | +WebKitNavigationPolicyDecision | +
| enum | +WebKitNavigationType | +
WebKitNavigationPolicyDecision represents a policy decision for events associated with +navigations. If the value of “mouse-button” is not 0, then +the navigation was triggered by a mouse event.
+WebKitNavigationAction *
+webkit_navigation_policy_decision_get_navigation_action
+ (WebKitNavigationPolicyDecision *decision);
+Gets the value of the “navigation-action” property.
+ + +Since: 2.6
+const gchar *
+webkit_navigation_policy_decision_get_frame_name
+ (WebKitNavigationPolicyDecision *decision);
+Gets the value of the “frame-name” property.
+ + +Enum values used to denote the various navigation types.
+| + |
+ The navigation was triggered by clicking a link. + |
++ |
| + |
+ The navigation was triggered by submitting a form. + |
++ |
| + |
+ The navigation was triggered by navigating forward or backward. + |
++ |
| + |
+ The navigation was triggered by reloading. + |
++ |
| + |
+ The navigation was triggered by resubmitting a form. + |
++ |
| + |
+ The navigation was triggered by some other action. + |
++ |
“frame-name” property“frame-name” gchar *+
If this navigation request targets a new frame, this property contains
+the name of that frame. For example if the decision was triggered by clicking a
+link with a target attribute equal to "_blank", this property will contain the
+value of that attribute. In all other cases, this value will be NULL.
Flags: Read
+Default value: NULL
+“navigation-action” property“navigation-action” WebKitNavigationAction *+
The WebKitNavigationAction that triggered this policy decision.
+Flags: Read
+Since: 2.6
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitNetworkProxySettings * + | ++webkit_network_proxy_settings_new () + | +
| +WebKitNetworkProxySettings * + | ++webkit_network_proxy_settings_copy () + | +
| +void + | ++webkit_network_proxy_settings_free () + | +
| +void + | ++webkit_network_proxy_settings_add_proxy_for_scheme () + | +
WebKitNetworkProxySettings can be used to provide a custom proxy configuration
+to a WebKitWebContext. You need to call webkit_web_context_set_network_proxy_settings()
+with WEBKIT_NETWORK_PROXY_MODE_CUSTOM and a WebKitNetworkProxySettings.
WebKitNetworkProxySettings * +webkit_network_proxy_settings_new (+const gchar *default_proxy_uri, +const gchar * const *ignore_hosts);
Create a new WebKitNetworkProxySettings with the given default_proxy_uri
+ and ignore_hosts
+.
The default proxy URI will be used for any URI that doesn't match ignore_hosts
+, and doesn't match any
+of the schemes added with webkit_network_proxy_settings_add_proxy_for_scheme().
+If default_proxy_uri
+ starts with "socks://", it will be treated as referring to all three of the
+socks5, socks4a, and socks4 proxy types.
ignore_hosts
+ is a list of hostnames and IP addresses that the resolver should allow direct connections to.
+Entries can be in one of 4 formats:
+A hostname, such as "example.com", ".example.com", or "*.example.com", any of which match "example.com" or +any subdomain of it. +
+An IPv4 or IPv6 address, such as "192.168.1.1", which matches only that address. +
+A hostname or IP address followed by a port, such as "example.com:80", which matches whatever the hostname or IP +address would match, but only for URLs with the (explicitly) indicated port. In the case of an IPv6 address, the address +part must appear in brackets: "[::1]:443" +
+An IP address range, given by a base address and prefix length, such as "fe80::/10", which matches any address in that range. +
Note that when dealing with Unicode hostnames, the matching is done against the ASCII form of the name.
+Also note that hostname exclusions apply only to connections made to hosts identified by name, and IP address exclusions apply only
+to connections made to hosts identified by address. That is, if example.com has an address of 192.168.1.1, and ignore_hosts
+
+contains only "192.168.1.1", then a connection to "example.com" will use the proxy, and a connection to 192.168.1.1" will not.
default_proxy_uri |
+the default proxy URI to use, or |
+[allow-none] | +
ignore_hosts |
+an optional list of hosts/IP addresses to not use a proxy for. |
+[allow-none][array zero-terminated=1] | +
Since: 2.16
+WebKitNetworkProxySettings *
+webkit_network_proxy_settings_copy (WebKitNetworkProxySettings *proxy_settings);
+Make a copy of the WebKitNetworkProxySettings.
+ + +Since: 2.16
+void
+webkit_network_proxy_settings_free (WebKitNetworkProxySettings *proxy_settings);
+Free the WebKitNetworkProxySettings.
+ +Since: 2.16
+void +webkit_network_proxy_settings_add_proxy_for_scheme + (+WebKitNetworkProxySettings *proxy_settings, +const gchar *scheme, +const gchar *proxy_uri);
Adds a URI-scheme-specific proxy. URIs whose scheme matches uri_scheme
+ will be proxied via proxy_uri
+.
+As with the default proxy URI, if proxy_uri
+ starts with "socks://", it will be treated as referring to
+all three of the socks5, socks4a, and socks4 proxy types.
proxy_settings |
++ | + |
scheme |
+the URI scheme to add a proxy for |
++ |
proxy_uri |
+the proxy URI to use for |
++ |
Since: 2.16
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitNotification+WebKitNotification — Object used to hold information about a notification that should be shown to the user. + |
++ |
| +guint64 + | ++webkit_notification_get_id () + | +
| const gchar * + | ++webkit_notification_get_title () + | +
| const gchar * + | ++webkit_notification_get_body () + | +
| const gchar * + | ++webkit_notification_get_tag () + | +
| +void + | ++webkit_notification_close () + | +
| +void + | ++webkit_notification_clicked () + | +
guint64
+webkit_notification_get_id (WebKitNotification *notification);
+Obtains the unique id for the notification.
+ + +Since: 2.8
+const gchar *
+webkit_notification_get_title (WebKitNotification *notification);
+Obtains the title for the notification.
+ + +Since: 2.8
+const gchar *
+webkit_notification_get_body (WebKitNotification *notification);
+Obtains the body for the notification.
+ + +Since: 2.8
+const gchar *
+webkit_notification_get_tag (WebKitNotification *notification);
+Obtains the tag identifier for the notification.
+ + +Since: 2.16
+void
+webkit_notification_close (WebKitNotification *notification);
+Closes the notification.
+ +Since: 2.8
+void
+webkit_notification_clicked (WebKitNotification *notification);
+Tells WebKit the notification has been clicked. This will emit the +“clicked” signal.
+ +Since: 2.12
+“body” property“body” gchar *+
The body for the notification.
+Flags: Read
+Default value: NULL
+Since: 2.8
+“id” property“id” guint64+
The unique id for the notification.
+Flags: Read
+Default value: 0
+Since: 2.8
+“tag” property“tag” gchar *+
The tag identifier for the notification.
+Flags: Read
+Default value: NULL
+Since: 2.16
+“title” property“title” gchar *+
The title for the notification.
+Flags: Read
+Default value: NULL
+Since: 2.8
+“clicked” signalvoid +user_function (WebKitNotification *notification, + gpointer user_data)+
Emitted when a notification has been clicked. See webkit_notification_clicked().
notification |
+the WebKitNotification on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.12
+“closed” signalvoid +user_function (WebKitNotification *notification, + gpointer user_data)+
Emitted when a notification has been withdrawn.
+The default handler will close the notification using libnotify, if built with +support for it.
+notification |
+the WebKitNotification on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.8
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitNotificationPermissionRequest+WebKitNotificationPermissionRequest — A permission request for displaying web notifications + |
++ |
+WebKitNotificationPermissionRequest implements + WebKitPermissionRequest.
+WebKitNotificationPermissionRequest represents a request for +permission to decide whether WebKit should provide the user with +notifications through the Web Notification API.
+When a WebKitNotificationPermissionRequest is not handled by the user, +it is denied by default.
+| +Top + | + |
+ |
+ |
+ |
+
| +void + | ++webkit_permission_request_allow () + | +
| +void + | ++webkit_permission_request_deny () + | +
+WebKitPermissionRequest is implemented by + WebKitDeviceInfoPermissionRequest, WebKitGeolocationPermissionRequest, WebKitInstallMissingMediaPluginsPermissionRequest, WebKitNotificationPermissionRequest and WebKitUserMediaPermissionRequest.
+There are situations where an embedder would need to ask the user +for permission to do certain types of operations, such as switching +to fullscreen mode or reporting the user's location through the +standard Geolocation API. In those cases, WebKit will emit a +“permission-request” signal with a +WebKitPermissionRequest object attached to it.
+void
+webkit_permission_request_allow (WebKitPermissionRequest *request);
+Allow the action which triggered this request.
+ +void
+webkit_permission_request_deny (WebKitPermissionRequest *request);
+Deny the action which triggered this request.
+ +| +Top + | + |
+ |
+ |
+ |
+
| const gchar * + | ++webkit_plugin_get_name () + | +
| const gchar * + | ++webkit_plugin_get_description () + | +
| const gchar * + | ++webkit_plugin_get_path () + | +
| +GList * + | ++webkit_plugin_get_mime_info_list () + | +
| +WebKitMimeInfo * + | ++webkit_mime_info_ref () + | +
| +void + | ++webkit_mime_info_unref () + | +
| const gchar * + | ++webkit_mime_info_get_mime_type () + | +
| const gchar * + | ++webkit_mime_info_get_description () + | +
| const gchar * const * + | ++webkit_mime_info_get_extensions () + | +
This object represents a single plugin, found while scanning the
+various platform plugin directories. This object can be used to get
+more information about a plugin, and enable/disable it, allowing
+fine-grained control of plugins. The list of available plugins can
+be obtained from the WebKitWebContext, with
+webkit_web_context_get_plugins().
const gchar *
+webkit_plugin_get_description (WebKitPlugin *plugin);
+
+
+GList *
+webkit_plugin_get_mime_info_list (WebKitPlugin *plugin);
+Get information about MIME types handled by the plugin, +as a list of WebKitMimeInfo.
+ + +WebKitMimeInfo *
+webkit_mime_info_ref (WebKitMimeInfo *info);
+Atomically increments the reference count of info
+ by one. This
+function is MT-safe and may be called from any thread.
void
+webkit_mime_info_unref (WebKitMimeInfo *info);
+Atomically decrements the reference count of info
+ by one. If the
+reference count drops to 0, all memory allocated by the WebKitMimeInfo is
+released. This function is MT-safe and may be called from any
+thread.
const gchar *
+webkit_mime_info_get_mime_type (WebKitMimeInfo *info);
+
+
+const gchar *
+webkit_mime_info_get_description (WebKitMimeInfo *info);
+
+
+const gchar * const *
+webkit_mime_info_get_extensions (WebKitMimeInfo *info);
+Get the list of file extensions associated to the
+MIME type of info
+
| +Top + | + |
+ |
+ |
+ |
+
| +void + | ++webkit_policy_decision_download () + | +
| +void + | ++webkit_policy_decision_ignore () + | +
| +void + | ++webkit_policy_decision_use () + | +
GObject + ╰── WebKitPolicyDecision + ├── WebKitNavigationPolicyDecision + ╰── WebKitResponsePolicyDecision ++
Often WebKit allows the client to decide the policy for certain
+operations. For instance, a client may want to open a link in a new
+tab, block a navigation entirely, query the user or trigger a download
+instead of a navigation. In these cases WebKit will fire the
+“decide-policy” signal with a WebKitPolicyDecision
+object. If the signal handler does nothing, WebKit will act as if
+webkit_policy_decision_use() was called as soon as signal handling
+completes. To make a policy decision asynchronously, simply increment
+the reference count of the WebKitPolicyDecision object.
void
+webkit_policy_decision_download (WebKitPolicyDecision *decision);
+Spawn a download from this decision.
+ +void
+webkit_policy_decision_ignore (WebKitPolicyDecision *decision);
+Ignore the action which triggered this decision. For instance, for a +WebKitResponsePolicyDecision, this would cancel the request.
+ +void
+webkit_policy_decision_use (WebKitPolicyDecision *decision);
+Accept the action which triggered this decision.
+ +| +Top + | + |
+ |
+ |
+ |
+
+WebKitResponsePolicyDecision+WebKitResponsePolicyDecision — A policy decision for resource responses + |
++ |
| +WebKitURIRequest * + | ++webkit_response_policy_decision_get_request () + | +
| +WebKitURIResponse * + | ++webkit_response_policy_decision_get_response () + | +
| +gboolean + | ++webkit_response_policy_decision_is_mime_type_supported () + | +
| +WebKitURIRequest * | +request | +Read | +
| +WebKitURIResponse * | +response | +Read | +
WebKitResponsePolicyDecision represents a policy decision for a +resource response, whether from the network or the local system. +A very common use case for these types of decision is deciding +whether or not to download a particular resource or to load it +normally.
+WebKitURIRequest *
+webkit_response_policy_decision_get_request
+ (WebKitResponsePolicyDecision *decision);
+Return the WebKitURIRequest associated with the response decision. +Modifications to the returned object are not taken +into account when the request is sent over the network, and is intended +only to aid in evaluating whether a response decision should be taken or +not. To modify requests before they are sent over the network the +“send-request” signal can be used instead.
+ + +WebKitURIResponse *
+webkit_response_policy_decision_get_response
+ (WebKitResponsePolicyDecision *decision);
+Gets the value of the “response” property.
+ + +gboolean
+webkit_response_policy_decision_is_mime_type_supported
+ (WebKitResponsePolicyDecision *decision);
+Gets whether the MIME type of the response can be displayed in the WebKitWebView
+that triggered this policy decision request. See also webkit_web_view_can_show_mime_type().
Since: 2.4
+“request” property“request” WebKitURIRequest *+
This property contains the WebKitURIRequest associated with this +policy decision.
+Flags: Read
+“response” property“response” WebKitURIResponse *+
This property contains the WebKitURIResponse associated with this +policy decision.
+Flags: Read
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitSecurityManager+WebKitSecurityManager — Controls security settings in a WebKitWebContext + |
++ |
| +void + | ++webkit_security_manager_register_uri_scheme_as_local () + | +
| +gboolean + | ++webkit_security_manager_uri_scheme_is_local () + | +
| +void + | ++webkit_security_manager_register_uri_scheme_as_no_access () + | +
| +gboolean + | ++webkit_security_manager_uri_scheme_is_no_access () + | +
| +void + | ++webkit_security_manager_register_uri_scheme_as_display_isolated () + | +
| +gboolean + | ++webkit_security_manager_uri_scheme_is_display_isolated () + | +
| +void + | ++webkit_security_manager_register_uri_scheme_as_secure () + | +
| +gboolean + | ++webkit_security_manager_uri_scheme_is_secure () + | +
| +void + | ++webkit_security_manager_register_uri_scheme_as_cors_enabled () + | +
| +gboolean + | ++webkit_security_manager_uri_scheme_is_cors_enabled () + | +
| +void + | ++webkit_security_manager_register_uri_scheme_as_empty_document () + | +
| +gboolean + | ++webkit_security_manager_uri_scheme_is_empty_document () + | +
The WebKitSecurityManager defines security settings for URI
+schemes in a WebKitWebContext. Get it from the context with
+webkit_web_context_get_security_manager(), and use it to register a
+URI scheme with a certain security level, or to check if it already
+has it.
void +webkit_security_manager_register_uri_scheme_as_local + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Register scheme
+ as a local scheme. This means that other non-local pages
+cannot link to or access URIs of this scheme.
gboolean +webkit_security_manager_uri_scheme_is_local + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Whether scheme
+ is considered as a local scheme.
+See also webkit_security_manager_register_uri_scheme_as_local().
void +webkit_security_manager_register_uri_scheme_as_no_access + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Register scheme
+ as a no-access scheme. This means that pages loaded
+with this URI scheme cannot access pages loaded with any other URI scheme.
gboolean +webkit_security_manager_uri_scheme_is_no_access + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Whether scheme
+ is considered as a no-access scheme.
+See also webkit_security_manager_register_uri_scheme_as_no_access().
void +webkit_security_manager_register_uri_scheme_as_display_isolated + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Register scheme
+ as a display isolated scheme. This means that pages cannot
+display these URIs unless they are from the same scheme.
gboolean +webkit_security_manager_uri_scheme_is_display_isolated + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Whether scheme
+ is considered as a display isolated scheme.
+See also webkit_security_manager_register_uri_scheme_as_display_isolated().
void +webkit_security_manager_register_uri_scheme_as_secure + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Register scheme
+ as a secure scheme. This means that mixed
+content warnings won't be generated for this scheme when
+included by an HTTPS page.
gboolean +webkit_security_manager_uri_scheme_is_secure + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Whether scheme
+ is considered as a secure scheme.
+See also webkit_security_manager_register_uri_scheme_as_secure().
void +webkit_security_manager_register_uri_scheme_as_cors_enabled + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Register scheme
+ as a CORS (Cross-origin resource sharing) enabled scheme.
+This means that CORS requests are allowed. See W3C CORS specification
+http://www.w3.org/TR/cors/.
gboolean +webkit_security_manager_uri_scheme_is_cors_enabled + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Whether scheme
+ is considered as a CORS enabled scheme.
+See also webkit_security_manager_register_uri_scheme_as_cors_enabled().
void +webkit_security_manager_register_uri_scheme_as_empty_document + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Register scheme
+ as an empty document scheme. This means that
+they are allowed to commit synchronously.
gboolean +webkit_security_manager_uri_scheme_is_empty_document + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Whether scheme
+ is considered as an empty document scheme.
+See also webkit_security_manager_register_uri_scheme_as_empty_document().
| +Top + | + |
+ |
+ |
+ |
+
| +WebKitSecurityOrigin * + | ++webkit_security_origin_new () + | +
| +WebKitSecurityOrigin * + | ++webkit_security_origin_new_for_uri () + | +
| +WebKitSecurityOrigin * + | ++webkit_security_origin_ref () + | +
| +void + | ++webkit_security_origin_unref () + | +
| const gchar * + | ++webkit_security_origin_get_protocol () + | +
| const gchar * + | ++webkit_security_origin_get_host () + | +
| +guint16 + | ++webkit_security_origin_get_port () + | +
| +gboolean + | ++webkit_security_origin_is_opaque () + | +
| +gchar * + | ++webkit_security_origin_to_string () + | +
WebKitSecurityOrigin is a representation of a security domain +defined by websites. A security origin normally consists of a +protocol, a hostname, and a port number. It is also possible for a +security origin to be opaque, as defined by the HTML standard, in +which case it has no associated protocol, host, or port.
+Websites with the same security origin can access each other's +resources for client-side scripting or database access.
+WebKitSecurityOrigin * +webkit_security_origin_new (+const gchar *protocol, +const gchar *host, +guint16 port);
Create a new security origin from the provided protocol, host and +port.
+protocol |
+The protocol for the new origin |
++ |
host |
+The host for the new origin |
++ |
port |
+The port number for the new origin, or 0 to indicate the
+default port for |
++ |
Since: 2.16
+WebKitSecurityOrigin *
+webkit_security_origin_new_for_uri (const gchar *uri);
+Create a new security origin from the provided URI. Components of
+uri
+ other than protocol, host, and port do not affect the created
+WebKitSecurityOrigin.
Since: 2.16
+WebKitSecurityOrigin *
+webkit_security_origin_ref (WebKitSecurityOrigin *origin);
+Atomically increments the reference count of origin
+ by one.
+This function is MT-safe and may be called from any thread.
Since: 2.16
+void
+webkit_security_origin_unref (WebKitSecurityOrigin *origin);
+Atomically decrements the reference count of origin
+ by one.
+If the reference count drops to 0, all memory allocated by
+WebKitSecurityOrigin is released. This function is MT-safe and may be
+called from any thread.
Since: 2.16
+const gchar *
+webkit_security_origin_get_protocol (WebKitSecurityOrigin *origin);
+Gets the protocol of origin
+, or NULL if origin
+ is opaque.
Since: 2.16
+const gchar *
+webkit_security_origin_get_host (WebKitSecurityOrigin *origin);
+Gets the hostname of origin
+, or NULL if origin
+ is opaque or if its
+protocol does not require a host component.
Since: 2.16
+guint16
+webkit_security_origin_get_port (WebKitSecurityOrigin *origin);
+Gets the port of origin
+. This function will always return 0 if the
+port is the default port for the given protocol. For example,
+http://example.com has the same security origin as
+http://example.com:80, and this function will return 0 for a
+WebKitSecurityOrigin constructed from either URI. It will also
+return 0 if origin
+ is opaque.
Since: 2.16
+gboolean
+webkit_security_origin_is_opaque (WebKitSecurityOrigin *origin);
+Gets whether origin
+ is an opaque security origin, which does not
+possess an associated protocol, host, or port.
Since: 2.16
+gchar *
+webkit_security_origin_to_string (WebKitSecurityOrigin *origin);
+Gets a string representation of origin
+. The string representation
+is a valid URI with only protocol, host, and port components. It may
+be NULL, but usually only if origin
+ is opaque.
Since: 2.16
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitSettings+WebKitSettings — Control the behaviour of a WebKitWebView + |
++ |
| gboolean | +allow-file-access-from-file-urls | +Read / Write / Construct | +
| gboolean | +allow-modal-dialogs | +Read / Write / Construct | +
| gboolean | +allow-universal-access-from-file-urls | +Read / Write / Construct | +
| gboolean | +auto-load-images | +Read / Write / Construct | +
| +gchar * | +cursive-font-family | +Read / Write / Construct | +
| +gchar * | +default-charset | +Read / Write / Construct | +
| +gchar * | +default-font-family | +Read / Write / Construct | +
| guint | +default-font-size | +Read / Write / Construct | +
| guint | +default-monospace-font-size | +Read / Write / Construct | +
| gboolean | +draw-compositing-indicators | +Read / Write / Construct | +
| gboolean | +enable-accelerated-2d-canvas | +Read / Write / Construct | +
| gboolean | +enable-caret-browsing | +Read / Write / Construct | +
| gboolean | +enable-developer-extras | +Read / Write / Construct | +
| gboolean | +enable-dns-prefetching | +Read / Write / Construct | +
| gboolean | +enable-encrypted-media | +Read / Write / Construct | +
| gboolean | +enable-frame-flattening | +Read / Write / Construct | +
| gboolean | +enable-fullscreen | +Read / Write / Construct | +
| gboolean | +enable-html5-database | +Read / Write / Construct | +
| gboolean | +enable-html5-local-storage | +Read / Write / Construct | +
| gboolean | +enable-hyperlink-auditing | +Read / Write / Construct | +
| gboolean | +enable-java | +Read / Write / Construct | +
| gboolean | +enable-javascript | +Read / Write / Construct | +
| gboolean | +enable-javascript-markup | +Read / Write / Construct | +
| gboolean | +enable-media-capabilities | +Read / Write / Construct | +
| gboolean | +enable-media-stream | +Read / Write / Construct | +
| gboolean | +enable-mediasource | +Read / Write / Construct | +
| gboolean | +enable-mock-capture-devices | +Read / Write / Construct | +
| gboolean | +enable-offline-web-application-cache | +Read / Write / Construct | +
| gboolean | +enable-page-cache | +Read / Write / Construct | +
| gboolean | +enable-plugins | +Read / Write / Construct | +
| gboolean | +enable-resizable-text-areas | +Read / Write / Construct | +
| gboolean | +enable-site-specific-quirks | +Read / Write / Construct | +
| gboolean | +enable-smooth-scrolling | +Read / Write / Construct | +
| gboolean | +enable-spatial-navigation | +Read / Write / Construct | +
| gboolean | +enable-tabs-to-links | +Read / Write / Construct | +
| gboolean | +enable-webaudio | +Read / Write / Construct | +
| gboolean | +enable-webgl | +Read / Write / Construct | +
| gboolean | +enable-write-console-messages-to-stdout | +Read / Write / Construct | +
| gboolean | +enable-xss-auditor | +Read / Write / Construct | +
| +gchar * | +fantasy-font-family | +Read / Write / Construct | +
| gboolean | +javascript-can-access-clipboard | +Read / Write / Construct | +
| gboolean | +javascript-can-open-windows-automatically | +Read / Write / Construct | +
| gboolean | +load-icons-ignoring-image-load-setting | +Read / Write / Construct | +
| gboolean | +media-playback-allows-inline | +Read / Write / Construct | +
| gboolean | +media-playback-requires-user-gesture | +Read / Write / Construct | +
| guint | +minimum-font-size | +Read / Write / Construct | +
| +gchar * | +monospace-font-family | +Read / Write / Construct | +
| +gchar * | +pictograph-font-family | +Read / Write / Construct | +
| gboolean | +print-backgrounds | +Read / Write / Construct | +
| +gchar * | +sans-serif-font-family | +Read / Write / Construct | +
| +gchar * | +serif-font-family | +Read / Write / Construct | +
| +gchar * | +user-agent | +Read / Write / Construct | +
| gboolean | +zoom-text-only | +Read / Write / Construct | +
WebKitSettings can be applied to a WebKitWebView to control text charset, +color, font sizes, printing mode, script support, loading of images and various +other things on a WebKitWebView. After creation, a WebKitSettings object +contains default settings.
+1 +2 +3 |
+ /* Disable JavaScript. */ +WebKitSettings *settings = webkit_web_view_group_get_settings (my_view_group); +webkit_settings_set_enable_javascript (settings, FALSE); |
+
WebKitSettings *
+webkit_settings_new (void);
+Creates a new WebKitSettings instance with default values. It must
+be manually attached to a WebKitWebView.
+See also webkit_settings_new_with_settings().
WebKitSettings * +webkit_settings_new_with_settings (+const gchar *first_setting_name, +...);
Creates a new WebKitSettings instance with the given settings. It must +be manually attached to a WebKitWebView.
+first_setting_name |
+name of first setting to set |
++ |
... |
+value of first setting, followed by more settings,
+ |
++ |
gboolean
+webkit_settings_get_auto_load_images (WebKitSettings *settings);
+Get the “auto-load-images” property.
+ + +void +webkit_settings_set_auto_load_images (+WebKitSettings *settings, +gboolean enabled);
Set the “auto-load-images” property.
+ +gboolean
+webkit_settings_get_enable_frame_flattening
+ (WebKitSettings *settings);
+Get the “enable-frame-flattening” property.
+ + +void +webkit_settings_set_enable_frame_flattening + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-frame-flattening” property.
+ +gboolean
+webkit_settings_get_enable_html5_database
+ (WebKitSettings *settings);
+Get the “enable-html5-database” property.
+ + +void +webkit_settings_set_enable_html5_database + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-html5-database” property.
+ +gboolean
+webkit_settings_get_enable_html5_local_storage
+ (WebKitSettings *settings);
+Get the “enable-html5-local-storage” property.
+ + +void +webkit_settings_set_enable_html5_local_storage + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-html5-local-storage” property.
+ +gboolean
+webkit_settings_get_enable_hyperlink_auditing
+ (WebKitSettings *settings);
+Get the “enable-hyperlink-auditing” property.
+ + +void +webkit_settings_set_enable_hyperlink_auditing + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-hyperlink-auditing” property.
+ +gboolean
+webkit_settings_get_enable_java (WebKitSettings *settings);
+Get the “enable-java” property.
+ + +void +webkit_settings_set_enable_java (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-java” property.
+ +gboolean
+webkit_settings_get_enable_javascript (WebKitSettings *settings);
+Get the “enable-javascript” property.
+ + +void +webkit_settings_set_enable_javascript (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-javascript” property.
+ +gboolean
+webkit_settings_get_enable_javascript_markup
+ (WebKitSettings *settings);
+Get the “enable-javascript-markup” property.
+ + +Since: 2.24
+void +webkit_settings_set_enable_javascript_markup + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-javascript-markup” property.
+ +Since: 2.24
+gboolean
+webkit_settings_get_enable_offline_web_application_cache
+ (WebKitSettings *settings);
+Get the “enable-offline-web-application-cache” property.
+ + +void +webkit_settings_set_enable_offline_web_application_cache + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-offline-web-application-cache” property.
+ +gboolean
+webkit_settings_get_enable_plugins (WebKitSettings *settings);
+Get the “enable-plugins” property.
+ + +void +webkit_settings_set_enable_plugins (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-plugins” property.
+ +gboolean
+webkit_settings_get_enable_xss_auditor
+ (WebKitSettings *settings);
+Get the “enable-xss-auditor” property.
+ + +void +webkit_settings_set_enable_xss_auditor + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-xss-auditor” property.
+ +gboolean
+webkit_settings_get_javascript_can_open_windows_automatically
+ (WebKitSettings *settings);
+Get the “javascript-can-open-windows-automatically” property.
+ + +void +webkit_settings_set_javascript_can_open_windows_automatically + (+WebKitSettings *settings, +gboolean enabled);
Set the “javascript-can-open-windows-automatically” property.
+ +gboolean
+webkit_settings_get_load_icons_ignoring_image_load_setting
+ (WebKitSettings *settings);
+Get the “load-icons-ignoring-image-load-setting” property.
+ + +void +webkit_settings_set_load_icons_ignoring_image_load_setting + (+WebKitSettings *settings, +gboolean enabled);
Set the “load-icons-ignoring-image-load-setting” property.
+ +const gchar *
+webkit_settings_get_default_font_family
+ (WebKitSettings *settings);
+void +webkit_settings_set_default_font_family + (+WebKitSettings *settings, +const gchar *default_font_family);
Set the “default-font-family” property.
+ +const gchar *
+webkit_settings_get_monospace_font_family
+ (WebKitSettings *settings);
+Gets the “monospace-font-family” property.
+ + +void +webkit_settings_set_monospace_font_family + (+WebKitSettings *settings, +const gchar *monospace_font_family);
Set the “monospace-font-family” property.
+ +const gchar *
+webkit_settings_get_serif_font_family (WebKitSettings *settings);
+Gets the “serif-font-family” property.
+ + +void +webkit_settings_set_serif_font_family (+WebKitSettings *settings, +const gchar *serif_font_family);
Set the “serif-font-family” property.
+ +const gchar *
+webkit_settings_get_sans_serif_font_family
+ (WebKitSettings *settings);
+Gets the “sans-serif-font-family” property.
+ + +void +webkit_settings_set_sans_serif_font_family + (+WebKitSettings *settings, +const gchar *sans_serif_font_family);
Set the “sans-serif-font-family” property.
+ +const gchar *
+webkit_settings_get_cursive_font_family
+ (WebKitSettings *settings);
+Gets the “cursive-font-family” property.
+ + +void +webkit_settings_set_cursive_font_family + (+WebKitSettings *settings, +const gchar *cursive_font_family);
Set the “cursive-font-family” property.
+ +const gchar *
+webkit_settings_get_fantasy_font_family
+ (WebKitSettings *settings);
+Gets the “fantasy-font-family” property.
+ + +void +webkit_settings_set_fantasy_font_family + (+WebKitSettings *settings, +const gchar *fantasy_font_family);
Set the “fantasy-font-family” property.
+ +const gchar *
+webkit_settings_get_pictograph_font_family
+ (WebKitSettings *settings);
+Gets the “pictograph-font-family” property.
+ + +void +webkit_settings_set_pictograph_font_family + (+WebKitSettings *settings, +const gchar *pictograph_font_family);
Set the “pictograph-font-family” property.
+ +guint32
+webkit_settings_get_default_font_size (WebKitSettings *settings);
+Gets the “default-font-size” property.
+ + +void +webkit_settings_set_default_font_size (+WebKitSettings *settings, +guint32 font_size);
Set the “default-font-size” property.
+ +guint32
+webkit_settings_get_default_monospace_font_size
+ (WebKitSettings *settings);
+Gets the “default-monospace-font-size” property.
+ + +void +webkit_settings_set_default_monospace_font_size + (+WebKitSettings *settings, +guint32 font_size);
Set the “default-monospace-font-size” property.
+ +guint32
+webkit_settings_get_minimum_font_size (WebKitSettings *settings);
+Gets the “minimum-font-size” property.
+ + +void +webkit_settings_set_minimum_font_size (+WebKitSettings *settings, +guint32 font_size);
Set the “minimum-font-size” property.
+ +const gchar *
+webkit_settings_get_default_charset (WebKitSettings *settings);
+Gets the “default-charset” property.
+ + +void +webkit_settings_set_default_charset (+WebKitSettings *settings, +const gchar *default_charset);
Set the “default-charset” property.
+ +gboolean
+webkit_settings_get_enable_developer_extras
+ (WebKitSettings *settings);
+Get the “enable-developer-extras” property.
+ + +void +webkit_settings_set_enable_developer_extras + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-developer-extras” property.
+ +gboolean
+webkit_settings_get_enable_resizable_text_areas
+ (WebKitSettings *settings);
+Get the “enable-resizable-text-areas” property.
+ + +void +webkit_settings_set_enable_resizable_text_areas + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-resizable-text-areas” property.
+ +gboolean
+webkit_settings_get_enable_tabs_to_links
+ (WebKitSettings *settings);
+Get the “enable-tabs-to-links” property.
+ + +void +webkit_settings_set_enable_tabs_to_links + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-tabs-to-links” property.
+ +gboolean
+webkit_settings_get_enable_dns_prefetching
+ (WebKitSettings *settings);
+Get the “enable-dns-prefetching” property.
+ + +void +webkit_settings_set_enable_dns_prefetching + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-dns-prefetching” property.
+ +gboolean
+webkit_settings_get_enable_caret_browsing
+ (WebKitSettings *settings);
+Get the “enable-caret-browsing” property.
+ + +void +webkit_settings_set_enable_caret_browsing + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-caret-browsing” property.
+ +gboolean
+webkit_settings_get_enable_fullscreen (WebKitSettings *settings);
+Get the “enable-fullscreen” property.
+ + +void +webkit_settings_set_enable_fullscreen (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-fullscreen” property.
+ +gboolean
+webkit_settings_get_print_backgrounds (WebKitSettings *settings);
+Get the “print-backgrounds” property.
+ + +void +webkit_settings_set_print_backgrounds (+WebKitSettings *settings, +gboolean print_backgrounds);
Set the “print-backgrounds” property.
+ +gboolean
+webkit_settings_get_enable_webaudio (WebKitSettings *settings);
+Get the “enable-webaudio” property.
+ + +void +webkit_settings_set_enable_webaudio (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-webaudio” property.
+ +gboolean
+webkit_settings_get_enable_webgl (WebKitSettings *settings);
+Get the “enable-webgl” property.
+ + +void +webkit_settings_set_enable_webgl (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-webgl” property.
+ +void +webkit_settings_set_allow_modal_dialogs + (+WebKitSettings *settings, +gboolean allowed);
Set the “allow-modal-dialogs” property.
+ +gboolean
+webkit_settings_get_allow_modal_dialogs
+ (WebKitSettings *settings);
+Get the “allow-modal-dialogs” property.
+ + +gboolean
+webkit_settings_get_zoom_text_only (WebKitSettings *settings);
+Get the “zoom-text-only” property.
+ + +void +webkit_settings_set_zoom_text_only (+WebKitSettings *settings, +gboolean zoom_text_only);
Set the “zoom-text-only” property.
+ +gboolean
+webkit_settings_get_javascript_can_access_clipboard
+ (WebKitSettings *settings);
+Get the “javascript-can-access-clipboard” property.
+ + +void +webkit_settings_set_javascript_can_access_clipboard + (+WebKitSettings *settings, +gboolean enabled);
Set the “javascript-can-access-clipboard” property.
+ +gboolean
+webkit_settings_get_media_playback_requires_user_gesture
+ (WebKitSettings *settings);
+Get the “media-playback-requires-user-gesture” property.
+ + +void +webkit_settings_set_media_playback_requires_user_gesture + (+WebKitSettings *settings, +gboolean enabled);
Set the “media-playback-requires-user-gesture” property.
+ +gboolean
+webkit_settings_get_media_playback_allows_inline
+ (WebKitSettings *settings);
+Get the “media-playback-allows-inline” property.
+ + +void +webkit_settings_set_media_playback_allows_inline + (+WebKitSettings *settings, +gboolean enabled);
Set the “media-playback-allows-inline” property.
+ +gboolean
+webkit_settings_get_draw_compositing_indicators
+ (WebKitSettings *settings);
+Get the “draw-compositing-indicators” property.
+ + +void +webkit_settings_set_draw_compositing_indicators + (+WebKitSettings *settings, +gboolean enabled);
Set the “draw-compositing-indicators” property.
+ +gboolean
+webkit_settings_get_enable_site_specific_quirks
+ (WebKitSettings *settings);
+Get the “enable-site-specific-quirks” property.
+ + +void +webkit_settings_set_enable_site_specific_quirks + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-site-specific-quirks” property.
+ +gboolean
+webkit_settings_get_enable_page_cache (WebKitSettings *settings);
+Get the “enable-page-cache” property.
+ + +void +webkit_settings_set_enable_page_cache (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-page-cache” property.
+ +const gchar *
+webkit_settings_get_user_agent (WebKitSettings *settings);
+Get the “user-agent” property.
+ + +void +webkit_settings_set_user_agent (+WebKitSettings *settings, +const gchar *user_agent);
Set the “user-agent” property.
+settings |
++ | + |
user_agent |
+The new custom user agent string or |
+[allow-none] | +
void +webkit_settings_set_user_agent_with_application_details + (+WebKitSettings *settings, +const gchar *application_name, +const gchar *application_version);
Set the “user-agent” property by appending the application details to the default user +agent. If no application name or version is given, the default user agent used will be used. If only +the version is given, the default engine version is used with the given application name.
+ +gboolean
+webkit_settings_get_enable_smooth_scrolling
+ (WebKitSettings *settings);
+Get the “enable-smooth-scrolling” property.
+ + +void +webkit_settings_set_enable_smooth_scrolling + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-smooth-scrolling” property.
+ +gboolean
+webkit_settings_get_enable_accelerated_2d_canvas
+ (WebKitSettings *settings);
+Get the “enable-accelerated-2d-canvas” property.
+ + +Since: 2.2
+void +webkit_settings_set_enable_accelerated_2d_canvas + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-accelerated-2d-canvas” property.
+ +Since: 2.2
+gboolean
+webkit_settings_get_enable_write_console_messages_to_stdout
+ (WebKitSettings *settings);
+Get the “enable-write-console-messages-to-stdout” property.
+ + +Since: 2.2
+void +webkit_settings_set_enable_write_console_messages_to_stdout + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-write-console-messages-to-stdout” property.
+ +Since: 2.2
+gboolean
+webkit_settings_get_enable_media_stream
+ (WebKitSettings *settings);
+Get the “enable-media-stream” property.
+ + +Since: 2.4
+void +webkit_settings_set_enable_media_stream + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-media-stream” property.
+ +Since: 2.4
+gboolean
+webkit_settings_get_enable_mock_capture_devices
+ (WebKitSettings *settings);
+Get the “enable-mock-capture-devices” property.
+ + +Since: 2.24
+void +webkit_settings_set_enable_mock_capture_devices + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-mock-capture-devices” property.
+ +Since: 2.4
+gboolean
+webkit_settings_get_enable_spatial_navigation
+ (WebKitSettings *settings);
+Get the “enable-spatial-navigation” property.
+ + +Since: 2.2
+void +webkit_settings_set_enable_spatial_navigation + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-spatial-navigation” property.
+ +Since: 2.2
+gboolean
+webkit_settings_get_enable_mediasource
+ (WebKitSettings *settings);
+Get the “enable-mediasource” property.
+ + +Since: 2.4
+void +webkit_settings_set_enable_mediasource + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-mediasource” property.
+ +Since: 2.4
+gboolean
+webkit_settings_get_enable_encrypted_media
+ (WebKitSettings *settings);
+Get the “enable-encrypted-media” property.
+ + +Since: 2.20
+void +webkit_settings_set_enable_encrypted_media + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-encrypted-media” property.
+ +Since: 2.20
+gboolean
+webkit_settings_get_enable_media_capabilities
+ (WebKitSettings *settings);
+Get the “enable-media-capabilities” property.
+ + +Since: 2.22
+void +webkit_settings_set_enable_media_capabilities + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-media-capabilities” property.
+ +Since: 2.22
+gboolean
+webkit_settings_get_allow_file_access_from_file_urls
+ (WebKitSettings *settings);
+Get the “allow-file-access-from-file-urls” property.
+ + +Since: 2.10
+void +webkit_settings_set_allow_file_access_from_file_urls + (+WebKitSettings *settings, +gboolean allowed);
Set the “allow-file-access-from-file-urls” property.
+ +Since: 2.10
+gboolean
+webkit_settings_get_allow_universal_access_from_file_urls
+ (WebKitSettings *settings);
+Get the “allow-universal-access-from-file-urls” property.
+ + +Since: 2.14
+void +webkit_settings_set_allow_universal_access_from_file_urls + (+WebKitSettings *settings, +gboolean allowed);
Set the “allow-universal-access-from-file-urls” property.
+ +Since: 2.14
+“allow-file-access-from-file-urls” property“allow-file-access-from-file-urls” gboolean+
Whether file access is allowed from file URLs. By default, when +something is loaded in a WebKitWebView using a file URI, cross +origin requests to other file resources are not allowed. This +setting allows you to change that behaviour, so that it would be +possible to do a XMLHttpRequest of a local file, for example.
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.10
+“allow-modal-dialogs” property“allow-modal-dialogs” gboolean+
Determine whether it's allowed to create and run modal dialogs
+from a WebKitWebView through JavaScript with
+window.showModalDialog. If it's set to
+FALSE, the associated WebKitWebView won't be able to create
+new modal dialogs, so not even the “create”
+signal will be emitted.
Flags: Read / Write / Construct
+Default value: FALSE
+“allow-universal-access-from-file-urls” property“allow-universal-access-from-file-urls” gboolean+
Whether or not JavaScript running in the context of a file scheme URL +should be allowed to access content from any origin. By default, when +something is loaded in a WebKitWebView using a file scheme URL, +access to the local file system and arbitrary local storage is not +allowed. This setting allows you to change that behaviour, so that +it would be possible to use local storage, for example.
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.14
+“auto-load-images” property“auto-load-images” gboolean+
Determines whether images should be automatically loaded or not. +On devices where network bandwidth is of concern, it might be +useful to turn this property off.
+Flags: Read / Write / Construct
+Default value: TRUE
+“cursive-font-family” property“cursive-font-family” gchar *+
The font family used as the default for content using a cursive font.
+Flags: Read / Write / Construct
+Default value: "serif"
+“default-charset” property“default-charset” gchar *+
The default text charset used when interpreting content with an unspecified charset.
+Flags: Read / Write / Construct
+Default value: "iso-8859-1"
+“default-font-family” property“default-font-family” gchar *+
The font family to use as the default for content that does not specify a font.
+Flags: Read / Write / Construct
+Default value: "sans-serif"
+“default-font-size” property“default-font-size” guint+
The default font size in pixels to use for content displayed if +no font size is specified.
+Flags: Read / Write / Construct
+Default value: 16
+“default-monospace-font-size” property“default-monospace-font-size” guint+
The default font size in pixels to use for content displayed in +monospace font if no font size is specified.
+Flags: Read / Write / Construct
+Default value: 13
+“draw-compositing-indicators” property“draw-compositing-indicators” gboolean+
Whether to draw compositing borders and repaint counters on layers drawn +with accelerated compositing. This is useful for debugging issues related +to web content that is composited with the GPU.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-accelerated-2d-canvas” property“enable-accelerated-2d-canvas” gboolean+
Enable or disable accelerated 2D canvas. Accelerated 2D canvas is only available +if WebKit was compiled with a version of Cairo including the unstable CairoGL API. +When accelerated 2D canvas is enabled, WebKit may render some 2D canvas content +using hardware accelerated drawing operations.
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.2
+“enable-caret-browsing” property“enable-caret-browsing” gboolean+
Whether to enable accessibility enhanced keyboard navigation.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-developer-extras” property“enable-developer-extras” gboolean+
Determines whether or not developer tools, such as the Web Inspector, are enabled.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-dns-prefetching” property“enable-dns-prefetching” gboolean+
Determines whether or not to prefetch domain names. DNS prefetching attempts +to resolve domain names before a user tries to follow a link.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-encrypted-media” property“enable-encrypted-media” gboolean+
Enable or disable support for Encrypted Media API on pages. +EncryptedMedia is an experimental JavaScript API for playing encrypted media in HTML. +This property will only work as intended if the EncryptedMedia feature is enabled at build time +with the ENABLE_ENCRYPTED_MEDIA flag.
+See https://www.w3.org/TR/encrypted-media/
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.20
+“enable-frame-flattening” property“enable-frame-flattening” gboolean+
Whether to enable the frame flattening. With this setting each subframe is expanded +to its contents, which will flatten all the frames to become one scrollable page. +On touch devices scrollable subframes on a page can result in a confusing user experience.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-fullscreen” property“enable-fullscreen” gboolean+
Whether to enable the Javascript Fullscreen API. The API +allows any HTML element to request fullscreen display. See also +the current draft of the spec: +http://www.w3.org/TR/fullscreen/
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-html5-database” property“enable-html5-database” gboolean+
Whether to enable HTML5 client-side SQL database support. Client-side +SQL database allows web pages to store structured data and be able to +use SQL to manipulate that data asynchronously.
+HTML5 database specification is available at +http://www.w3.org/TR/webdatabase/.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-html5-local-storage” property“enable-html5-local-storage” gboolean+
Whether to enable HTML5 local storage support. Local storage provides +simple synchronous storage access.
+HTML5 local storage specification is available at +http://dev.w3.org/html5/webstorage/.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-hyperlink-auditing” property“enable-hyperlink-auditing” gboolean+
Determines whether or not hyperlink auditing is enabled.
+The hyperlink auditing specification is available at +http://www.whatwg.org/specs/web-apps/current-work/multipage/links.htmlhyperlink-auditing.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-java” property“enable-java” gboolean+
Determines whether or not Java is enabled on the page.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-javascript” property“enable-javascript” gboolean+
Determines whether or not JavaScript executes within a page.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-javascript-markup” property“enable-javascript-markup” gboolean+
Determines whether or not JavaScript markup is allowed in document. When this setting is disabled,
+all JavaScript-related elements and attributes are removed from the document during parsing. Note that
+executing JavaScript is still allowed if “enable-javascript” is TRUE.
Flags: Read / Write / Construct
+Default value: TRUE
+Since: 2.24
+“enable-media-capabilities” property“enable-media-capabilities” gboolean+
Enable or disable support for MediaCapabilities on pages. This +specification intends to provide APIs to allow websites to make an optimal +decision when picking media content for the user. The APIs will expose +information about the decoding and encoding capabilities for a given format +but also output capabilities to find the best match based on the device’s +display.
+See also https://wicg.github.io/media-capabilities/
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.22
+“enable-media-stream” property“enable-media-stream” gboolean+
Enable or disable support for MediaStream on pages. MediaStream +is an experimental proposal for allowing web pages to access +audio and video devices for capture.
+See also http://dev.w3.org/2011/webrtc/editor/getusermedia.html
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.4
+“enable-mediasource” property“enable-mediasource” gboolean+
Enable or disable support for MediaSource on pages. MediaSource +extends HTMLMediaElement to allow JavaScript to generate media +streams for playback.
+See also http://www.w3.org/TR/media-source/
+Flags: Read / Write / Construct
+Default value: TRUE
+Since: 2.4
+“enable-mock-capture-devices” property“enable-mock-capture-devices” gboolean+
Enable or disable the Mock Capture Devices. Those are fake +Microphone and Camera devices to be used as MediaStream +sources.
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.24
+“enable-offline-web-application-cache” property“enable-offline-web-application-cache” gboolean+
Whether to enable HTML5 offline web application cache support. Offline +web application cache allows web applications to run even when +the user is not connected to the network.
+HTML5 offline web application specification is available at +http://dev.w3.org/html5/spec/offline.html.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-page-cache” property“enable-page-cache” gboolean+
Enable or disable the page cache. Disabling the page cache is +generally only useful for special circumstances like low-memory +scenarios or special purpose applications like static HTML +viewers. This setting only controls the Page Cache, this cache +is different than the disk-based or memory-based traditional +resource caches, its point is to make going back and forth +between pages much faster. For details about the different types +of caches and their purposes see: +http://webkit.org/blog/427/webkit-page-cache-i-the-basics/
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-plugins” property“enable-plugins” gboolean+
Determines whether or not plugins on the page are enabled.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-resizable-text-areas” property“enable-resizable-text-areas” gboolean+
Determines whether or not text areas can be resized.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-site-specific-quirks” property“enable-site-specific-quirks” gboolean+
Whether to turn on site-specific quirks. Turning this on will +tell WebKit to use some site-specific workarounds for +better web compatibility. For example, older versions of +MediaWiki will incorrectly send to WebKit a CSS file with KHTML +workarounds. By turning on site-specific quirks, WebKit will +special-case this and other cases to make some specific sites work.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-smooth-scrolling” property“enable-smooth-scrolling” gboolean+
Enable or disable smooth scrolling.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-spatial-navigation” property“enable-spatial-navigation” gboolean+
Whether to enable Spatial Navigation. This feature consists in the ability +to navigate between focusable elements in a Web page, such as hyperlinks +and form controls, by using Left, Right, Up and Down arrow keys. +For example, if an user presses the Right key, heuristics determine whether +there is an element they might be trying to reach towards the right, and if +there are multiple elements, which element they probably wants.
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.4
+“enable-tabs-to-links” property“enable-tabs-to-links” gboolean+
Determines whether the tab key cycles through the elements on the page. +When this setting is enabled, users will be able to focus the next element +in the page by pressing the tab key. If the selected element is editable, +then pressing tab key will insert the tab character.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-webaudio” property“enable-webaudio” gboolean+
Enable or disable support for WebAudio on pages. WebAudio is an +experimental proposal for allowing web pages to generate Audio +WAVE data from JavaScript. The standard is currently a +work-in-progress by the W3C Audio Working Group.
+See also https://dvcs.w3.org/hg/audio/raw-file/tip/webaudio/specification.html
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-webgl” property“enable-webgl” gboolean+
Enable or disable support for WebGL on pages. WebGL is an experimental +proposal for allowing web pages to use OpenGL ES-like calls directly. The +standard is currently a work-in-progress by the Khronos Group.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-write-console-messages-to-stdout” property“enable-write-console-messages-to-stdout” gboolean+
Enable or disable writing console messages to stdout. These are messages +sent to the console with console.log and related methods.
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.2
+“enable-xss-auditor” property“enable-xss-auditor” gboolean+
Whether to enable the XSS auditor. This feature filters some kinds of +reflective XSS attacks on vulnerable web sites.
+Flags: Read / Write / Construct
+Default value: TRUE
+“fantasy-font-family” property“fantasy-font-family” gchar *+
The font family used as the default for content using a fantasy font.
+Flags: Read / Write / Construct
+Default value: "serif"
+“javascript-can-access-clipboard” property“javascript-can-access-clipboard” gboolean+
Whether JavaScript can access the clipboard. The default value is FALSE. If
+set to TRUE, document.execCommand() allows cut, copy and paste commands.
Flags: Read / Write / Construct
+Default value: FALSE
+“javascript-can-open-windows-automatically” property“javascript-can-open-windows-automatically” gboolean+
Whether JavaScript can open popup windows automatically without user +intervention.
+Flags: Read / Write / Construct
+Default value: FALSE
+“load-icons-ignoring-image-load-setting” property“load-icons-ignoring-image-load-setting” gboolean+
Determines whether a site can load favicons irrespective +of the value of “auto-load-images”.
+Flags: Read / Write / Construct
+Default value: FALSE
+“media-playback-allows-inline” property“media-playback-allows-inline” gboolean+
Whether media playback is full-screen only or inline playback is allowed.
+This is TRUE by default, so media playback can be inline. Setting it to
+FALSE allows specifying that media playback should be always fullscreen.
Flags: Read / Write / Construct
+Default value: TRUE
+“media-playback-requires-user-gesture” property“media-playback-requires-user-gesture” gboolean+
Whether a user gesture (such as clicking the play button) +would be required to start media playback or load media. This is off +by default, so media playback could start automatically. +Setting it on requires a gesture by the user to start playback, or to +load the media.
+Flags: Read / Write / Construct
+Default value: FALSE
+“minimum-font-size” property“minimum-font-size” guint+
The minimum font size in pixels used to display text. This setting +controls the absolute smallest size. Values other than 0 can +potentially break page layouts.
+Flags: Read / Write / Construct
+Default value: 0
+“monospace-font-family” property“monospace-font-family” gchar *+
The font family used as the default for content using a monospace font.
+Flags: Read / Write / Construct
+Default value: "monospace"
+“pictograph-font-family” property“pictograph-font-family” gchar *+
The font family used as the default for content using a pictograph font.
+Flags: Read / Write / Construct
+Default value: "serif"
+“print-backgrounds” property“print-backgrounds” gboolean+
Whether background images should be drawn during printing.
+Flags: Read / Write / Construct
+Default value: TRUE
+“sans-serif-font-family” property“sans-serif-font-family” gchar *+
The font family used as the default for content using a sans-serif font.
+Flags: Read / Write / Construct
+Default value: "sans-serif"
+“serif-font-family” property“serif-font-family” gchar *+
The font family used as the default for content using a serif font.
+Flags: Read / Write / Construct
+Default value: "serif"
+“user-agent” property“user-agent” gchar *+
The user-agent string used by WebKit. Unusual user-agent strings may cause web
+content to render incorrectly or fail to run, as many web pages are written to
+parse the user-agent strings of only the most popular browsers. Therefore, it's
+typically better to not completely override the standard user-agent, but to use
+webkit_settings_set_user_agent_with_application_details() instead.
If this property is set to the empty string or NULL, it will revert to the standard
+user-agent.
Flags: Read / Write / Construct
+Default value: NULL
+“zoom-text-only” property“zoom-text-only” gboolean+
Whether “zoom-level” affects only the +text of the page or all the contents. Other contents containing text +like form controls will be also affected by zoom factor when +this property is enabled.
+Flags: Read / Write / Construct
+Default value: FALSE
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitURIRequest * + | ++webkit_uri_request_new () + | +
| const gchar * + | ++webkit_uri_request_get_uri () + | +
| +void + | ++webkit_uri_request_set_uri () + | +
| const gchar * + | ++webkit_uri_request_get_http_method () + | +
| +SoupMessageHeaders * + | ++webkit_uri_request_get_http_headers () + | +
A WebKitURIRequest can be created with a URI using the
+webkit_uri_request_new() method, and you can get the URI of an
+existing request with the webkit_uri_request_get_uri() one.
WebKitURIRequest *
+webkit_uri_request_new (const gchar *uri);
+Creates a new WebKitURIRequest for the given URI.
+ + +const gchar *
+webkit_uri_request_get_uri (WebKitURIRequest *request);
+
+
+void +webkit_uri_request_set_uri (+WebKitURIRequest *request, +const gchar *uri);
Set the URI of request
+
const gchar *
+webkit_uri_request_get_http_method (WebKitURIRequest *request);
+Get the HTTP method of the WebKitURIRequest.
+ + +Since: 2.12
+SoupMessageHeaders *
+webkit_uri_request_get_http_headers (WebKitURIRequest *request);
+Get the HTTP headers of a WebKitURIRequest as a SoupMessageHeaders.
+ +a SoupMessageHeaders with the HTTP headers of request
+or NULL if request
+is not an HTTP request.
[transfer none]
+“uri” property“uri” gchar *+
The URI to which the request will be made.
+Flags: Read / Write / Construct
+Default value: "about:blank"
+| +Top + | + |
+ |
+ |
+ |
+
| const gchar * + | ++webkit_uri_response_get_uri () + | +
| +guint + | ++webkit_uri_response_get_status_code () + | +
| +guint64 + | ++webkit_uri_response_get_content_length () + | +
| const gchar * + | ++webkit_uri_response_get_mime_type () + | +
| const gchar * + | ++webkit_uri_response_get_suggested_filename () + | +
| +SoupMessageHeaders * + | ++webkit_uri_response_get_http_headers () + | +
| guint64 | +content-length | +Read | +
| +SoupMessageHeaders * | +http-headers | +Read | +
| +gchar * | +mime-type | +Read | +
| guint | +status-code | +Read | +
| +gchar * | +suggested-filename | +Read | +
| +gchar * | +uri | +Read | +
A WebKitURIResponse contains information such as the URI, the +status code, the content length, the mime type, the HTTP status or +the suggested filename.
+const gchar *
+webkit_uri_response_get_uri (WebKitURIResponse *response);
+
+
+guint
+webkit_uri_response_get_status_code (WebKitURIResponse *response);
+Get the status code of the WebKitURIResponse as returned by
+the server. It will normally be a SoupKnownStatusCode, for
+example SOUP_STATUS_OK, though the server can respond with any
+unsigned integer.
guint64
+webkit_uri_response_get_content_length
+ (WebKitURIResponse *response);
+Get the expected content length of the WebKitURIResponse. It can +be 0 if the server provided an incorrect or missing Content-Length.
+ + +const gchar *
+webkit_uri_response_get_mime_type (WebKitURIResponse *response);
+
+
+const gchar *
+webkit_uri_response_get_suggested_filename
+ (WebKitURIResponse *response);
+Get the suggested filename for response
+, as specified by
+the 'Content-Disposition' HTTP header, or NULL if it's not
+present.
the suggested filename or NULL if
+the 'Content-Disposition' HTTP header is not present.
[transfer none]
+SoupMessageHeaders *
+webkit_uri_response_get_http_headers (WebKitURIResponse *response);
+Get the HTTP headers of a WebKitURIResponse as a SoupMessageHeaders.
+ +a SoupMessageHeaders with the HTTP headers of response
+or NULL if response
+is not an HTTP response.
[transfer none]
+Since: 2.6
+“content-length” property“content-length” guint64+
The expected content length of the response.
+Flags: Read
+Default value: 0
+“http-headers” property“http-headers” SoupMessageHeaders *+
The HTTP headers of the response, or NULL if the response is not an HTTP response.
Flags: Read
+Since: 2.6
+“mime-type” property“mime-type” gchar *+
The MIME type of the response.
+Flags: Read
+Default value: NULL
+“status-code” property“status-code” guint+
The status code of the response as returned by the server.
+Flags: Read
+Default value: 0
+“suggested-filename” property“suggested-filename” gchar *+
The suggested filename for the URI response.
+Flags: Read
+Default value: NULL
+“uri” property“uri” gchar *+
The URI for which the response was made.
+Flags: Read
+Default value: NULL
+| +Top + | + |
+ |
+ |
+ |
+
| const gchar * + | ++webkit_uri_scheme_request_get_scheme () + | +
| const gchar * + | ++webkit_uri_scheme_request_get_uri () + | +
| const gchar * + | ++webkit_uri_scheme_request_get_path () + | +
| +WebKitWebView * + | ++webkit_uri_scheme_request_get_web_view () + | +
| +void + | ++webkit_uri_scheme_request_finish () + | +
| +void + | ++webkit_uri_scheme_request_finish_error () + | +
If you register a particular URI scheme in a WebKitWebContext,
+using webkit_web_context_register_uri_scheme(), you have to provide
+a WebKitURISchemeRequestCallback. After that, when a URI request
+is made with that particular scheme, your callback will be
+called. There you will be able to access properties such as the
+scheme, the URI and path, and the WebKitWebView that initiated the
+request, and also finish the request with
+webkit_uri_scheme_request_finish().
const gchar *
+webkit_uri_scheme_request_get_scheme (WebKitURISchemeRequest *request);
+Get the URI scheme of request
+
const gchar *
+webkit_uri_scheme_request_get_uri (WebKitURISchemeRequest *request);
+Get the URI of request
+
const gchar *
+webkit_uri_scheme_request_get_path (WebKitURISchemeRequest *request);
+Get the URI path of request
+
WebKitWebView *
+webkit_uri_scheme_request_get_web_view
+ (WebKitURISchemeRequest *request);
+Get the WebKitWebView that initiated the request.
+ + +void +webkit_uri_scheme_request_finish (+WebKitURISchemeRequest *request, +GInputStream *stream, +gint64 stream_length, +const gchar *mime_type);
Finish a WebKitURISchemeRequest by setting the contents of the request and its mime type.
+request |
++ | + |
stream |
+a GInputStream to read the contents of the request |
++ |
stream_length |
+the length of the stream or -1 if not known |
++ |
mime_type |
+the content type of the stream or |
+[allow-none] | +
void +webkit_uri_scheme_request_finish_error + (+WebKitURISchemeRequest *request, +GError *error);
Finish a WebKitURISchemeRequest with a GError.
+request |
++ | + |
error |
+a GError that will be passed to the WebKitWebView |
++ |
Since: 2.2
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitUserContentManager+WebKitUserContentManager — Manages user-defined content which affects web pages. + |
++ |
| +WebKitUserContentManager * + | ++webkit_user_content_manager_new () + | +
| +void + | ++webkit_user_content_manager_add_style_sheet () + | +
| +void + | ++webkit_user_content_manager_remove_all_style_sheets () + | +
| +void + | ++webkit_user_content_manager_add_script () + | +
| +void + | ++webkit_user_content_manager_remove_all_scripts () + | +
| +gboolean + | ++webkit_user_content_manager_register_script_message_handler () + | +
| +void + | ++webkit_user_content_manager_unregister_script_message_handler () + | +
| +gboolean + | ++webkit_user_content_manager_register_script_message_handler_in_world () + | +
| +void + | ++webkit_user_content_manager_unregister_script_message_handler_in_world () + | +
| +void + | ++webkit_user_content_manager_add_filter () + | +
| +void + | ++webkit_user_content_manager_remove_filter () + | +
| +void + | ++webkit_user_content_manager_remove_all_filters () + | +
Using a WebKitUserContentManager user CSS style sheets can be set to
+be injected in the web pages loaded by a WebKitWebView, by
+webkit_user_content_manager_add_style_sheet().
To use a WebKitUserContentManager, it must be created using
+webkit_user_content_manager_new(), and then passed to
+webkit_web_view_new_with_user_content_manager(). User style
+sheets can be created with webkit_user_style_sheet_new().
User style sheets can be added and removed at any time, but +they will affect the web pages loaded afterwards.
+WebKitUserContentManager *
+webkit_user_content_manager_new (void);
+Creates a new user content manager.
+ +Since: 2.6
+void +webkit_user_content_manager_add_style_sheet + (+WebKitUserContentManager *manager, +WebKitUserStyleSheet *stylesheet);
Adds a WebKitUserStyleSheet to the given WebKitUserContentManager. +The same WebKitUserStyleSheet can be reused with multiple +WebKitUserContentManager instances.
+ +Since: 2.6
+void
+webkit_user_content_manager_remove_all_style_sheets
+ (WebKitUserContentManager *manager);
+Removes all user style sheets from the given WebKitUserContentManager.
+ +Since: 2.6
+void +webkit_user_content_manager_add_script + (+WebKitUserContentManager *manager, +WebKitUserScript *script);
Adds a WebKitUserScript to the given WebKitUserContentManager. +The same WebKitUserScript can be reused with multiple +WebKitUserContentManager instances.
+ +Since: 2.6
+void
+webkit_user_content_manager_remove_all_scripts
+ (WebKitUserContentManager *manager);
+Removes all user scripts from the given WebKitUserContentManager
+ +Since: 2.6
+gboolean +webkit_user_content_manager_register_script_message_handler + (+WebKitUserContentManager *manager, +const gchar *name);
Registers a new user script message handler. After it is registered,
+scripts can use window.webkit.messageHandlers.<name>.postMessage(value)
+to send messages. Those messages are received by connecting handlers
+to the “script-message-received” signal. The
+handler name is used as the detail of the signal. To avoid race
+conditions between registering the handler name, and starting to
+receive the signals, it is recommended to connect to the signal
+*before* registering the handler name:
1 +2 +3 +4 +5 |
+ WebKitWebView *view = webkit_web_view_new (); +WebKitUserContentManager *manager = webkit_web_view_get_user_content_manager (); +g_signal_connect (manager, "script-message-received::foobar", + G_CALLBACK (handle_script_message), NULL); +webkit_user_content_manager_register_script_message_handler (manager, "foobar"); |
+
Registering a script message handler will fail if the requested +name has been already registered before.
+ + +Since: 2.8
+void +webkit_user_content_manager_unregister_script_message_handler + (+WebKitUserContentManager *manager, +const gchar *name);
Unregisters a previously registered message handler.
+Note that this does *not* disconnect handlers for the +“script-message-received” signal; +they will be kept connected, but the signal will not be emitted +unless the handler name is registered again.
+See also webkit_user_content_manager_register_script_message_handler().
Since: 2.8
+gboolean +webkit_user_content_manager_register_script_message_handler_in_world + (+WebKitUserContentManager *manager, +const gchar *name, +const gchar *world_name);
Registers a new user script message handler in script world with name world_name
+.
+See webkit_user_content_manager_register_script_message_handler() for full description.
Registering a script message handler will fail if the requested +name has been already registered before.
+manager |
++ | + |
name |
+Name of the script message channel |
++ |
world_name |
+the name of a WebKitScriptWorld |
++ |
Since: 2.22
+void +webkit_user_content_manager_unregister_script_message_handler_in_world + (+WebKitUserContentManager *manager, +const gchar *name, +const gchar *world_name);
Unregisters a previously registered message handler in script world with name world_name
+.
Note that this does *not* disconnect handlers for the +“script-message-received” signal; +they will be kept connected, but the signal will not be emitted +unless the handler name is registered again.
+See also webkit_user_content_manager_register_script_message_handler_in_world().
manager |
++ | + |
name |
+Name of the script message channel |
++ |
world_name |
+the name of a WebKitScriptWorld |
++ |
Since: 2.22
+void +webkit_user_content_manager_add_filter + (+WebKitUserContentManager *manager, +WebKitUserContentFilter *filter);
Adds a WebKitUserContentFilter to the given WebKitUserContentManager. +The same WebKitUserContentFilter can be reused with multiple +WebKitUserContentManager instances.
+Filters need to be saved and loaded from WebKitUserContentFilterStore.
+ +Since: 2.24
+void +webkit_user_content_manager_remove_filter + (+WebKitUserContentManager *manager, +WebKitUserContentFilter *filter);
Removes a filter from the given WebKitUserContentManager.
+Since 2.24
+ +void
+webkit_user_content_manager_remove_all_filters
+ (WebKitUserContentManager *manager);
+Removes all content filters from the given WebKitUserContentManager.
+ +Since: 2.24
+“script-message-received” signalvoid +user_function (WebKitUserContentManager *manager, + WebKitJavascriptResult *js_result, + gpointer user_data)+
This signal is emitted when JavaScript in a web view calls
+window.webkit.messageHandlers.<name>.postMessage(), after registering
+<name> using
+webkit_user_content_manager_register_script_message_handler()
+manager |
++ | + |
js_result |
+the WebKitJavascriptResult holding the value received from the JavaScript world. |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Has Details
+Since: 2.8
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitUserMediaPermissionRequest+WebKitUserMediaPermissionRequest — A permission request for accessing user's audio/video devices. + |
++ |
| +gboolean + | ++webkit_user_media_permission_is_for_audio_device () + | +
| +gboolean + | ++webkit_user_media_permission_is_for_video_device () + | +
| gboolean | +is-for-audio-device | +Read | +
| gboolean | +is-for-video-device | +Read | +
WebKitUserMediaPermissionRequest represents a request for +permission to decide whether WebKit should be allowed to access the user's +audio and video source devices when requested through the getUserMedia API.
+When a WebKitUserMediaPermissionRequest is not handled by the user, +it is denied by default.
+gboolean
+webkit_user_media_permission_is_for_audio_device
+ (WebKitUserMediaPermissionRequest *request);
+
+
+Since: 2.8
+gboolean
+webkit_user_media_permission_is_for_video_device
+ (WebKitUserMediaPermissionRequest *request);
+
+
+Since: 2.8
+“is-for-audio-device” property“is-for-audio-device” gboolean+
Whether the media device to which the permission was requested has a microphone or not.
+Flags: Read
+Default value: FALSE
+“is-for-video-device” property“is-for-video-device” gboolean+
Whether the media device to which the permission was requested has a video capture capability or not.
+Flags: Read
+Default value: FALSE
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitWebContext+WebKitWebContext — Manages aspects common to all WebKitWebViews + |
++ |
| +WebKitWebsiteDataManager * | +website-data-manager | +Read / Write / Construct Only | +
| void | +automation-started | +Run Last | +
| void | +download-started | +Run Last | +
| void | +initialize-notification-permissions | +Run Last | +
| void | +initialize-web-extensions | +Run Last | +
| struct | +WebKitWebContext | +
| enum | +WebKitCacheModel | +
| enum | +WebKitProcessModel | +
| enum | +WebKitTLSErrorsPolicy | +
| enum | +WebKitNetworkProxyMode | +
The WebKitWebContext manages all aspects common to all +WebKitWebViews.
+You can define the WebKitCacheModel and WebKitProcessModel with
+webkit_web_context_set_cache_model() and
+webkit_web_context_set_process_model(), depending on the needs of
+your application. You can access the WebKitSecurityManager to specify
+the behaviour of your application regarding security using
+webkit_web_context_get_security_manager().
It is also possible to change your preferred language or enable
+spell checking, using webkit_web_context_set_preferred_languages(),
+webkit_web_context_set_spell_checking_languages() and
+webkit_web_context_set_spell_checking_enabled().
You can use webkit_web_context_register_uri_scheme() to register
+custom URI schemes, and manage several other settings.
TLS certificate validation failure is now treated as a transport
+error by default. To handle TLS failures differently, you can
+connect to “load-failed-with-tls-errors”.
+Alternatively, you can use webkit_web_context_set_tls_errors_policy()
+to set the policy WEBKIT_TLS_ERRORS_POLICY_IGNORE; however, this is
+not appropriate for Internet applications.
WebKitWebContext *
+webkit_web_context_get_default (void);
+Gets the default web context
+ +WebKitWebContext *
+webkit_web_context_new (void);
+Create a new WebKitWebContext
+ +Since: 2.8
+WebKitWebContext *
+webkit_web_context_new_ephemeral (void);
+Create a new ephemeral WebKitWebContext. An ephemeral WebKitWebContext is a context +created with an ephemeral WebKitWebsiteDataManager. This is just a convenient method +to create ephemeral contexts without having to create your own WebKitWebsiteDataManager. +All WebKitWebViews associated with this context will also be ephemeral. Websites will +not store any data in the client storage. +This is normally used to implement private instances.
+ +Since: 2.16
+WebKitWebContext *
+webkit_web_context_new_with_website_data_manager
+ (WebKitWebsiteDataManager *manager);
+Create a new WebKitWebContext with a WebKitWebsiteDataManager.
+ + +Since: 2.10
+gboolean
+webkit_web_context_is_ephemeral (WebKitWebContext *context);
+Get whether a WebKitWebContext is ephemeral.
+ + +Since: 2.16
+gboolean
+webkit_web_context_is_automation_allowed
+ (WebKitWebContext *context);
+Get whether automation is allowed in context
+.
+See also webkit_web_context_set_automation_allowed().
Since: 2.18
+void +webkit_web_context_set_automation_allowed + (+WebKitWebContext *context, +gboolean allowed);
Set whether automation is allowed in context
+. When automation is enabled the browser could
+be controlled by another process by requesting an automation session. When a new automation
+session is requested the signal “automation-started” is emitted.
+Automation is disabled by default, so you need to explicitly call this method passing TRUE
+to enable it.
Note that only one WebKitWebContext can have automation enabled, so this will do nothing +if there's another WebKitWebContext with automation already enabled.
+ +Since: 2.18
+WebKitWebsiteDataManager *
+webkit_web_context_get_website_data_manager
+ (WebKitWebContext *context);
+Get the WebKitWebsiteDataManager of context
+.
Since: 2.10
+WebKitCacheModel
+webkit_web_context_get_cache_model (WebKitWebContext *context);
+Returns the current cache model. For more information about this
+value check the documentation of the function
+webkit_web_context_set_cache_model().
void +webkit_web_context_set_cache_model (+WebKitWebContext *context, +WebKitCacheModel cache_model);
Specifies a usage model for WebViews, which WebKit will use to +determine its caching behavior. All web views follow the cache +model. This cache model determines the RAM and disk space to use +for caching previously viewed content .
+Research indicates that users tend to browse within clusters of +documents that hold resources in common, and to revisit previously +visited documents. WebKit and the frameworks below it include +built-in caches that take advantage of these patterns, +substantially improving document load speed in browsing +situations. The WebKit cache model controls the behaviors of all of +these caches, including various WebCore caches.
+Browsers can improve document load speed substantially by
+specifying WEBKIT_CACHE_MODEL_WEB_BROWSER. Applications without a
+browsing interface can reduce memory usage substantially by
+specifying WEBKIT_CACHE_MODEL_DOCUMENT_VIEWER. The default value is
+WEBKIT_CACHE_MODEL_WEB_BROWSER.
guint
+webkit_web_context_get_web_process_count_limit
+ (WebKitWebContext *context);
+Gets the maximum number of web processes that can be created at the same time for the context
+.
Since: 2.10
+void +webkit_web_context_set_web_process_count_limit + (+WebKitWebContext *context, +guint limit);
Sets the maximum number of web processes that can be created at the same time for the context
+.
+The default value is 0 and means no limit.
This method **must be called before any web process has been created**, +as early as possible in your application. Calling it later will make +your application crash.
+context |
+the WebKitWebContext |
++ |
limit |
+the maximum number of web processes |
++ |
Since: 2.10
+void
+webkit_web_context_clear_cache (WebKitWebContext *context);
+Clears all resources currently cached.
+See also webkit_web_context_set_cache_model().
void +webkit_web_context_set_network_proxy_settings + (+WebKitWebContext *context, +WebKitNetworkProxyMode proxy_mode, +WebKitNetworkProxySettings *proxy_settings);
Set the network proxy settings to be used by connections started in context
+.
+By default WEBKIT_NETWORK_PROXY_MODE_DEFAULT is used, which means that the
+system settings will be used (g_proxy_resolver_get_default()).
+If you want to override the system default settings, you can either use
+WEBKIT_NETWORK_PROXY_MODE_NO_PROXY to make sure no proxies are used at all,
+or WEBKIT_NETWORK_PROXY_MODE_CUSTOM to provide your own proxy settings.
+When proxy_mode
+ is WEBKIT_NETWORK_PROXY_MODE_CUSTOM proxy_settings
+ must be
+a valid WebKitNetworkProxySettings; otherwise, proxy_settings
+ must be NULL.
context |
++ | + |
proxy_mode |
++ | + |
proxy_settings |
+a WebKitNetworkProxySettings, or |
+[allow-none] | +
Since: 2.16
+WebKitDownload * +webkit_web_context_download_uri (+WebKitWebContext *context, +const gchar *uri);
Requests downloading of the specified URI string. The download operation
+will not be associated to any WebKitWebView, if you are interested in
+starting a download from a particular WebKitWebView use
+webkit_web_view_download_uri() instead.
WebKitCookieManager *
+webkit_web_context_get_cookie_manager (WebKitWebContext *context);
+Get the WebKitCookieManager of the context
+'s WebKitWebsiteDataManager.
WebKitFaviconDatabase *
+webkit_web_context_get_favicon_database
+ (WebKitWebContext *context);
+Get the WebKitFaviconDatabase associated with context
+.
To initialize the database you need to call
+webkit_web_context_set_favicon_database_directory().
void +webkit_web_context_set_favicon_database_directory + (+WebKitWebContext *context, +const gchar *path);
Set the directory path to be used to store the favicons database
+for context
+ on disk. Passing NULL as path
+ means using the
+default directory for the platform (see g_get_user_cache_dir()).
Calling this method also means enabling the favicons database for +its use from the applications, so that's why it's expected to be +called only once. Further calls for the same instance of +WebKitWebContext won't cause any effect.
+context |
++ | + |
path |
+an absolute path to the icon database
+directory or |
+[allow-none] | +
const gchar *
+webkit_web_context_get_favicon_database_directory
+ (WebKitWebContext *context);
+Get the directory path being used to store the favicons database
+for context
+, or NULL if
+webkit_web_context_set_favicon_database_directory() hasn't been
+called yet.
This function will always return the same path after having called
+webkit_web_context_set_favicon_database_directory() for the first
+time.
the path of the directory of the favicons
+database associated with context
+, or NULL.
[transfer none]
+WebKitSecurityManager *
+webkit_web_context_get_security_manager
+ (WebKitWebContext *context);
+Get the WebKitSecurityManager of context
+.
void +webkit_web_context_set_additional_plugins_directory + (+WebKitWebContext *context, +const gchar *directory);
Set an additional directory where WebKit will look for plugins.
+ +void +webkit_web_context_get_plugins (+WebKitWebContext *context, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously get the list of installed plugins.
+When the operation is finished, callback
+ will be called. You can then call
+webkit_web_context_get_plugins_finish() to get the result of the operation.
context |
++ | + |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
GList * +webkit_web_context_get_plugins_finish (+WebKitWebContext *context, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_context_get_plugins.
+context |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
a GList of WebKitPlugin. You must free the GList with
+g_list_free() and unref the WebKitPlugins with g_object_unref() when you're done with them.
[element-type WebKitPlugin][transfer full]
+gboolean
+webkit_web_context_get_spell_checking_enabled
+ (WebKitWebContext *context);
+Get whether spell checking feature is currently enabled.
+ + +void +webkit_web_context_set_spell_checking_enabled + (+WebKitWebContext *context, +gboolean enabled);
Enable or disable the spell checking feature.
+ +const gchar * const *
+webkit_web_context_get_spell_checking_languages
+ (WebKitWebContext *context);
+Get the the list of spell checking languages associated with
+context
+, or NULL if no languages have been previously set.
See webkit_web_context_set_spell_checking_languages() for more
+details on the format of the languages in the list.
void +webkit_web_context_set_spell_checking_languages + (+WebKitWebContext *context, +const gchar * const *languages);
Set the list of spell checking languages to be used for spell +checking.
+The locale string typically is in the form lang_COUNTRY, where lang +is an ISO-639 language code, and COUNTRY is an ISO-3166 country code. +For instance, sv_FI for Swedish as written in Finland or pt_BR +for Portuguese as written in Brazil.
+You need to call this function with a valid list of languages at +least once in order to properly enable the spell checking feature +in WebKit.
+context |
++ | + |
languages |
+a |
+[array zero-terminated=1][transfer none] | +
void +webkit_web_context_set_preferred_languages + (+WebKitWebContext *context, +const gchar * const *languages);
Set the list of preferred languages, sorted from most desirable +to least desirable. The list will be used to build the "Accept-Language" +header that will be included in the network requests started by +the WebKitWebContext.
+context |
++ | + |
languages |
+a |
+[allow-none][array zero-terminated=1][element-type utf8][transfer none] | +
void +webkit_web_context_set_tls_errors_policy + (+WebKitWebContext *context, +WebKitTLSErrorsPolicy policy);
Set the TLS errors policy of context
+ as policy
+
WebKitTLSErrorsPolicy
+webkit_web_context_get_tls_errors_policy
+ (WebKitWebContext *context);
+Get the TLS errors policy of context
+
void +webkit_web_context_set_web_extensions_directory + (+WebKitWebContext *context, +const gchar *directory);
Set the directory where WebKit will look for Web Extensions. +This method must be called before loading anything in this context, +otherwise it will not have any effect. You can connect to +“initialize-web-extensions” to call this method +before anything is loaded.
+ +void +webkit_web_context_set_web_extensions_initialization_user_data + (+WebKitWebContext *context, +GVariant *user_data);
Set user data to be passed to Web Extensions on initialization. +The data will be passed to the +WebKitWebExtensionInitializeWithUserDataFunction. +This method must be called before loading anything in this context, +otherwise it will not have any effect. You can connect to +“initialize-web-extensions” to call this method +before anything is loaded.
+ +Since: 2.4
+void +webkit_web_context_prefetch_dns (+WebKitWebContext *context, +const gchar *hostname);
Resolve the domain name of the given hostname
+ in advance, so that if a URI
+of hostname
+ is requested the load will be performed more quickly.
void +webkit_web_context_allow_tls_certificate_for_host + (+WebKitWebContext *context, +GTlsCertificate *certificate, +const gchar *host);
Ignore further TLS errors on the host
+ for the certificate present in info
+.
context |
++ | + |
certificate |
++ | + |
host |
+the host for which a certificate is to be allowed |
++ |
Since: 2.6
+WebKitProcessModel
+webkit_web_context_get_process_model (WebKitWebContext *context);
+Returns the current process model. For more information about this value
+see webkit_web_context_set_process_model().
Since: 2.4
+void +webkit_web_context_set_process_model (+WebKitWebContext *context, +WebKitProcessModel process_model);
Specifies a process model for WebViews, which WebKit will use to
+determine how auxiliary processes are handled. The default setting
+(WEBKIT_PROCESS_MODEL_SHARED_SECONDARY_PROCESS) is suitable for most
+applications which embed a small amount of WebViews, or are used to
+display documents which are considered safe — like local files.
Applications which may potentially use a large amount of WebViews
+—for example a multi-tabbed web browser— may want to use
+WEBKIT_PROCESS_MODEL_MULTIPLE_SECONDARY_PROCESSES, which will use
+one process per view most of the time, while still allowing for web
+views to share a process when needed (for example when different
+views interact with each other). Using this model, when a process
+hangs or crashes, only the WebViews using it stop working, while
+the rest of the WebViews in the application will still function
+normally.
This method **must be called before any web process has been created**, +as early as possible in your application. Calling it later will make +your application crash.
+ +Since: 2.4
+void +webkit_web_context_initialize_notification_permissions + (+WebKitWebContext *context, +GList *allowed_origins, +GList *disallowed_origins);
Sets initial desktop notification permissions for the context
+.
+allowed_origins
+ and disallowed_origins
+ must each be GList of
+WebKitSecurityOrigin objects representing origins that will,
+respectively, either always or never have permission to show desktop
+notifications. No WebKitNotificationPermissionRequest will ever be
+generated for any of the security origins represented in
+allowed_origins
+ or disallowed_origins
+. This function is necessary
+because some webpages proactively check whether they have permission
+to display notifications without ever creating a permission request.
This function only affects web processes that have not already been +created. The best time to call it is when handling +“initialize-notification-permissions” so as to +ensure that new web processes receive the most recent set of +permissions.
+context |
+the WebKitWebContext |
++ |
allowed_origins |
+a GList of security origins. |
+[element-type WebKitSecurityOrigin] | +
disallowed_origins |
+a GList of security origins. |
+[element-type WebKitSecurityOrigin] | +
Since: 2.16
+void +(*WebKitURISchemeRequestCallback) (+WebKitURISchemeRequest *request, +gpointer user_data);
Type definition for a function that will be called back when an URI request is +made for a user registered URI scheme.
+ +void +webkit_web_context_register_uri_scheme + (+WebKitWebContext *context, +const gchar *scheme, +WebKitURISchemeRequestCallback callback, +gpointer user_data, +GDestroyNotify user_data_destroy_func);
Register scheme
+ in context
+, so that when an URI request with scheme
+ is made in the
+WebKitWebContext, the WebKitURISchemeRequestCallback registered will be called with a
+WebKitURISchemeRequest.
+It is possible to handle URI scheme requests asynchronously, by calling g_object_ref() on the
+WebKitURISchemeRequest and calling webkit_uri_scheme_request_finish() later
+when the data of the request is available or
+webkit_uri_scheme_request_finish_error() in case of error.
1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 |
+ static void +about_uri_scheme_request_cb (WebKitURISchemeRequest *request, + gpointer user_data) +{ + GInputStream *stream; + gsize stream_length; + const gchar *path; + + path = webkit_uri_scheme_request_get_path (request); + if (!g_strcmp0 (path, "plugins")) { + /* Create a GInputStream with the contents of plugins about page, and set its length to stream_length */ + } else if (!g_strcmp0 (path, "memory")) { + /* Create a GInputStream with the contents of memory about page, and set its length to stream_length */ + } else if (!g_strcmp0 (path, "applications")) { + /* Create a GInputStream with the contents of applications about page, and set its length to stream_length */ + } else if (!g_strcmp0 (path, "example")) { + gchar *contents; + + contents = g_strdup_printf ("<html><body><p>Example about page</p></body></html>"); + stream_length = strlen (contents); + stream = g_memory_input_stream_new_from_data (contents, stream_length, g_free); + } else { + GError *error; + + error = g_error_new (ABOUT_HANDLER_ERROR, ABOUT_HANDLER_ERROR_INVALID, "Invalid about:%s page.", path); + webkit_uri_scheme_request_finish_error (request, error); + g_error_free (error); + return; + } + webkit_uri_scheme_request_finish (request, stream, stream_length, "text/html"); + g_object_unref (stream); +} |
+
Enum values used for determining the WebKitWebContext cache model.
+| + |
+ Disable the cache completely, which + substantially reduces memory usage. Useful for applications that only + access a single local file, with no navigation to other pages. No remote + resources will be cached. + |
++ |
| + |
+ Improve document load speed substantially + by caching a very large number of resources and previously viewed content. + |
++ |
| + |
+ A cache model optimized for viewing + a series of local files -- for example, a documentation viewer or a website + designer. WebKit will cache a moderate number of resources. + |
++ |
Enum values used for determining the WebKitWebContext process model.
+| + |
+ Use a single process to + perform content rendering. The process is shared among all the + WebKitWebView instances created by the application: if the process + hangs or crashes all the web views in the application will be affected. + This is the default process model, and it should suffice for most cases. + |
++ |
| + |
+ Use one process + for each WebKitWebView, while still allowing for some of them to + share a process in certain situations. The main advantage + of this process model is that the rendering process for a web view + can crash while the rest of the views keep working normally. This + process model is indicated for applications which may use a number + of web views and the content of in each must not interfere with the + rest — for example a full-fledged web browser with support for + multiple tabs. + |
++ |
Since: 2.4
+Enum values used to denote the TLS errors policy.
+| + |
+ Ignore TLS errors. + |
++ |
| + |
+ TLS errors will emit + “load-failed-with-tls-errors” and, if the signal is handled, + finish the load. In case the signal is not handled, + “load-failed” is emitted before the load finishes. + |
++ |
“website-data-manager” property“website-data-manager” WebKitWebsiteDataManager *+
The WebKitWebsiteDataManager associated with this context.
+Flags: Read / Write / Construct Only
+Since: 2.10
+“automation-started” signalvoid +user_function (WebKitWebContext *context, + WebKitAutomationSession *session, + gpointer user_data)+
This signal is emitted when a new automation request is made.
+Note that it will never be emitted if automation is not enabled in context
+,
+see webkit_web_context_set_automation_allowed() for more details.
context |
+the WebKitWebContext |
++ |
session |
+the WebKitAutomationSession associated with this event |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.18
+“download-started” signalvoid +user_function (WebKitWebContext *context, + WebKitDownload *download, + gpointer user_data)+
This signal is emitted when a new download request is made.
+context |
+the WebKitWebContext |
++ |
download |
+the WebKitDownload associated with this event |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“initialize-notification-permissions” signalvoid +user_function (WebKitWebContext *context, + gpointer user_data)+
This signal is emitted when a WebKitWebContext needs to set
+initial notification permissions for a web process. It is emitted
+when a new web process is about to be launched, and signals the
+most appropriate moment to use
+webkit_web_context_initialize_notification_permissions(). If no
+notification permissions have changed since the last time this
+signal was emitted, then there is no need to call
+webkit_web_context_initialize_notification_permissions() again.
context |
+the WebKitWebContext |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.16
+“initialize-web-extensions” signalvoid +user_function (WebKitWebContext *context, + gpointer user_data)+
This signal is emitted when a new web process is about to be
+launched. It signals the most appropriate moment to use
+webkit_web_context_set_web_extensions_initialization_user_data()
+and webkit_web_context_set_web_extensions_directory().
context |
+the WebKitWebContext |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.4
+| +Top + | + |
+ |
+ |
+ |
+
| const gchar * + | ++webkit_web_resource_get_uri () + | +
| +WebKitURIResponse * + | ++webkit_web_resource_get_response () + | +
| +void + | ++webkit_web_resource_get_data () + | +
| +guchar * + | ++webkit_web_resource_get_data_finish () + | +
| +WebKitURIResponse * | +response | +Read | +
| +gchar * | +uri | +Read | +
| void | +failed | +Run Last | +
| void | +failed-with-tls-errors | +Run Last | +
| void | +finished | +Run Last | +
| void | +received-data | +Run Last | +
| void | +sent-request | +Run Last | +
A WebKitWebResource encapsulates content for each resource at the +end of a particular URI. For example, one WebKitWebResource will +be created for each separate image and stylesheet when a page is +loaded.
+You can access the response and the URI for a given
+WebKitWebResource, using webkit_web_resource_get_uri() and
+webkit_web_resource_get_response(), as well as the raw data, using
+webkit_web_resource_get_data().
const gchar *
+webkit_web_resource_get_uri (WebKitWebResource *resource);
+Returns the current active URI of resource
+. The active URI might change during
+a load operation:
+ When the resource load starts, the active URI is the requested URI +
+ When the initial request is sent to the server, “sent-request” + signal is emitted without a redirected response, the active URI is the URI of + the request sent to the server. +
+ In case of a server redirection, “sent-request” signal + is emitted again with a redirected response, the active URI is the URI the request + was redirected to. +
+ When the response is received from the server, the active URI is the final + one and it will not change again. +
You can monitor the active URI by connecting to the notify::uri
+signal of resource
+.
WebKitURIResponse *
+webkit_web_resource_get_response (WebKitWebResource *resource);
+Retrieves the WebKitURIResponse of the resource load operation.
+This method returns NULL if called before the response
+is received from the server. You can connect to notify::response
+signal to be notified when the response is received.
the WebKitURIResponse, or NULL if
+the response hasn't been received yet.
[transfer none]
+void +webkit_web_resource_get_data (+WebKitWebResource *resource, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously get the raw data for resource
+.
When the operation is finished, callback
+ will be called. You can then call
+webkit_web_resource_get_data_finish() to get the result of the operation.
resource |
++ | + |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
guchar * +webkit_web_resource_get_data_finish (+WebKitWebResource *resource, +GAsyncResult *result, +gsize *length, +GError **error);
Finish an asynchronous operation started with webkit_web_resource_get_data().
resource |
++ | + |
result |
++ | + |
length |
+return location for the length of the resource data. |
+[out][allow-none] | +
error |
+return location for error or |
++ |
“response” property“response” WebKitURIResponse *+
The WebKitURIResponse associated with this resource.
+Flags: Read
+“uri” property“uri” gchar *+
The current active URI of the WebKitWebResource.
+See webkit_web_resource_get_uri() for more details.
Flags: Read
+Default value: NULL
+“failed” signalvoid +user_function (WebKitWebResource *resource, + GError *error, + gpointer user_data)+
This signal is emitted when an error occurs during the resource +load operation.
+resource |
++ | + |
error |
+the GError that was triggered |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“failed-with-tls-errors” signalvoid +user_function (WebKitWebResource *resource, + GTlsCertificate *certificate, + GTlsCertificateFlags errors, + gpointer user_data)+
This signal is emitted when a TLS error occurs during the resource load operation.
+resource |
++ | + |
certificate |
++ | + |
errors |
+a GTlsCertificateFlags with the verification status of |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.8
+“finished” signalvoid +user_function (WebKitWebResource *resource, + gpointer user_data)+
This signal is emitted when the resource load finishes successfully +or due to an error. In case of errors “failed” signal +is emitted before this one.
+resource |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“received-data” signalvoid +user_function (WebKitWebResource *resource, + guint64 data_length, + gpointer user_data)+
This signal is emitted after response is received, +every time new data has been received. It's +useful to know the progress of the resource load operation.
+resource |
++ | + |
data_length |
+the length of data received in bytes |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“sent-request” signalvoid +user_function (WebKitWebResource *resource, + WebKitURIRequest *request, + WebKitURIResponse *redirected_response, + gpointer user_data)+
This signal is emitted when request
+ has been sent to the
+server. In case of a server redirection this signal is
+emitted again with the request
+ argument containing the new
+request sent to the server due to the redirection and the
+redirected_response
+ parameter containing the response
+received by the server for the initial request.
resource |
++ | + |
request |
++ | + |
redirected_response |
+a WebKitURIResponse, or |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitWebViewBackend * | +backend | +Read / Write / Construct Only | +
| gboolean | +editable | +Read / Write | +
| gdouble | +estimated-load-progress | +Read | +
| gboolean | +is-controlled-by-automation | +Read / Write / Construct Only | +
| gboolean | +is-ephemeral | +Read / Write / Construct Only | +
| gboolean | +is-loading | +Read | +
| gboolean | +is-playing-audio | +Read | +
| +WebKitWebView * | +related-view | +Write / Construct Only | +
| +WebKitSettings * | +settings | +Write / Construct | +
| +gchar * | +title | +Read | +
| +gchar * | +uri | +Read | +
| +WebKitUserContentManager * | +user-content-manager | +Read / Write / Construct Only | +
| +WebKitWebContext * | +web-context | +Read / Write / Construct Only | +
| gdouble | +zoom-level | +Read / Write | +
| gboolean | +authenticate | +Run Last | +
| void | +close | +Run Last | +
| gboolean | +context-menu | +Run Last | +
| void | +context-menu-dismissed | +Run Last | +
| +WebKitWebView* | +create | +Run Last | +
| gboolean | +decide-policy | +Run Last | +
| gboolean | +enter-fullscreen | +Run Last | +
| void | +insecure-content-detected | +Run Last | +
| gboolean | +leave-fullscreen | +Run Last | +
| void | +load-changed | +Run Last | +
| gboolean | +load-failed | +Run Last | +
| gboolean | +load-failed-with-tls-errors | +Run Last | +
| void | +mouse-target-changed | +Run Last | +
| gboolean | +permission-request | +Run Last | +
| void | +ready-to-show | +Run Last | +
| void | +resource-load-started | +Run Last | +
| void | +run-as-modal | +Run Last | +
| gboolean | +run-file-chooser | +Run Last | +
| gboolean | +script-dialog | +Run Last | +
| gboolean | +show-notification | +Run Last | +
| void | +submit-form | +Run Last | +
| void | +web-process-terminated | +Run Last | +
| + | WebKitWebView | +
| enum | +WebKitLoadEvent | +
| enum | +WebKitPolicyDecisionType | +
| enum | +WebKitSaveMode | +
| enum | +WebKitInsecureContentEvent | +
| enum | +WebKitWebProcessTerminationReason | +
| #define | +WEBKIT_EDITING_COMMAND_CUT | +
| #define | +WEBKIT_EDITING_COMMAND_COPY | +
| #define | +WEBKIT_EDITING_COMMAND_PASTE | +
| #define | +WEBKIT_EDITING_COMMAND_SELECT_ALL | +
| #define | +WEBKIT_EDITING_COMMAND_UNDO | +
| #define | +WEBKIT_EDITING_COMMAND_REDO | +
| #define | +WEBKIT_EDITING_COMMAND_INSERT_IMAGE | +
| #define | +WEBKIT_EDITING_COMMAND_CREATE_LINK | +
| + | WebKitJavascriptResult | +
| + | WebKitScriptDialog | +
| enum | +WebKitScriptDialogType | +
| + | WebKitWebViewSessionState | +
GBoxed + ├── WebKitJavascriptResult + ├── WebKitScriptDialog + ╰── WebKitWebViewSessionState + GObject + ╰── WebKitWebView ++
WebKitWebView is the central class of the WPE WebKit and WebKitGTK +APIs. It is responsible for managing the drawing of the content and +forwarding of events. You can load any URI into the WebKitWebView or +a data string. With WebKitSettings you can control various aspects +of the rendering and loading of the content.
+Note that in WebKitGTK, WebKitWebView is scrollable by itself, so +you don't need to embed it in a GtkScrolledWindow.
+void +(*WebKitFrameDisplayedCallback) (+WebKitWebView *web_view, +gpointer user_data);
Callback to be called when a frame is displayed in a webKitWebView.
+ +Since: 2.24
+WebKitWebView * +webkit_web_view_new_with_context (+WebKitWebViewBackend *backend, +WebKitWebContext *context);
WebKitWebView * +webkit_web_view_new_with_related_view (+WebKitWebViewBackend *backend, +WebKitWebView *web_view);
WebKitWebView * +webkit_web_view_new_with_settings (+WebKitWebViewBackend *backend, +WebKitSettings *settings);
WebKitWebView * +webkit_web_view_new_with_user_content_manager + (+WebKitWebViewBackend *backend, +WebKitUserContentManager *user_content_manager);
WebKitWebViewBackend *
+webkit_web_view_get_backend (WebKitWebView *web_view);
+Get the WebKitWebViewBackend of web_view
+
Since: 2.20
+gboolean
+webkit_web_view_is_ephemeral (WebKitWebView *web_view);
+Get whether a WebKitWebView is ephemeral. To create an ephemeral WebKitWebView you need to
+use g_object_new() and pass is-ephemeral property with TRUE value. See
+“is-ephemeral” for more details.
+If web_view
+ was created with a ephemeral “related-view” or an
+ephemeral “web-context” it will also be ephemeral.
Since: 2.16
+gboolean
+webkit_web_view_is_controlled_by_automation
+ (WebKitWebView *web_view);
+Get whether a WebKitWebView was created with “is-controlled-by-automation” +property enabled. Only WebKitWebViews controlled by automation can be used in an +automation session.
+ + +Since: 2.18
+WebKitWebContext *
+webkit_web_view_get_context (WebKitWebView *web_view);
+Gets the web context of web_view
+.
WebKitUserContentManager *
+webkit_web_view_get_user_content_manager
+ (WebKitWebView *web_view);
+Gets the user content manager associated to web_view
+.
Since: 2.6
+WebKitWebsiteDataManager *
+webkit_web_view_get_website_data_manager
+ (WebKitWebView *web_view);
+Get the WebKitWebsiteDataManager associated to web_view
+. If web_view
+ is not ephemeral,
+the returned WebKitWebsiteDataManager will be the same as the WebKitWebsiteDataManager
+of web_view
+'s WebKitWebContext.
Since: 2.16
+void
+webkit_web_view_try_close (WebKitWebView *web_view);
+Tries to close the web_view
+. This will fire the onbeforeunload event
+to ask the user for confirmation to close the page. If there isn't an
+onbeforeunload event handler or the user confirms to close the page,
+the “close” signal is emitted, otherwise nothing happens.
Since: 2.12
+void +webkit_web_view_load_uri (+WebKitWebView *web_view, +const gchar *uri);
Requests loading of the specified URI string. +You can monitor the load operation by connecting to +“load-changed” signal.
+ +void +webkit_web_view_load_html (+WebKitWebView *web_view, +const gchar *content, +const gchar *base_uri);
Load the given content
+ string with the specified base_uri
+.
+If base_uri
+ is not NULL, relative URLs in the content
+ will be
+resolved against base_uri
+ and absolute local paths must be children of the base_uri
+.
+For security reasons absolute local paths that are not children of base_uri
+
+will cause the web process to terminate.
+If you need to include URLs in content
+ that are local paths in a different
+directory than base_uri
+ you can build a data URI for them. When base_uri
+ is NULL,
+it defaults to "about:blank". The mime type of the document will be "text/html".
+You can monitor the load operation by connecting to “load-changed” signal.
web_view |
++ | + |
content |
+The HTML string to load |
++ |
base_uri |
+The base URI for relative locations or |
+[allow-none] | +
void +webkit_web_view_load_alternate_html (+WebKitWebView *web_view, +const gchar *content, +const gchar *content_uri, +const gchar *base_uri);
Load the given content
+ string for the URI content_uri
+.
+This allows clients to display page-loading errors in the WebKitWebView itself.
+When this method is called from “load-failed” signal to show an
+error page, then the back-forward list is maintained appropriately.
+For everything else this method works the same way as webkit_web_view_load_html().
web_view |
++ | + |
content |
+the new content to display as the main page of the |
++ |
content_uri |
+the URI for the alternate page content |
++ |
base_uri |
+the base URI for relative locations or |
+[allow-none] | +
void +webkit_web_view_load_plain_text (+WebKitWebView *web_view, +const gchar *plain_text);
Load the specified plain_text
+ string into web_view
+. The mime type of
+document will be "text/plain". You can monitor the load
+operation by connecting to “load-changed” signal.
void +webkit_web_view_load_bytes (+WebKitWebView *web_view, +GBytes *bytes, +const gchar *mime_type, +const gchar *encoding, +const gchar *base_uri);
Load the specified bytes
+ into web_view
+ using the given mime_type
+ and encoding
+.
+When mime_type
+ is NULL, it defaults to "text/html".
+When encoding
+ is NULL, it defaults to "UTF-8".
+When base_uri
+ is NULL, it defaults to "about:blank".
+You can monitor the load operation by connecting to “load-changed” signal.
Since: 2.6
+void +webkit_web_view_load_request (+WebKitWebView *web_view, +WebKitURIRequest *request);
Requests loading of the specified WebKitURIRequest. +You can monitor the load operation by connecting to +“load-changed” signal.
+ +gboolean
+webkit_web_view_can_go_back (WebKitWebView *web_view);
+Determines whether web_view
+ has a previous history item.
void
+webkit_web_view_go_back (WebKitWebView *web_view);
+Loads the previous history item. +You can monitor the load operation by connecting to +“load-changed” signal.
+ +gboolean
+webkit_web_view_can_go_forward (WebKitWebView *web_view);
+Determines whether web_view
+ has a next history item.
void
+webkit_web_view_go_forward (WebKitWebView *web_view);
+Loads the next history item. +You can monitor the load operation by connecting to +“load-changed” signal.
+ +const gchar *
+webkit_web_view_get_title (WebKitWebView *web_view);
+Gets the value of the “title” property.
+You can connect to notify::title signal of web_view
+ to
+be notified when the title has been received.
guint64
+webkit_web_view_get_page_id (WebKitWebView *web_view);
+Get the identifier of the WebKitWebPage corresponding to +the WebKitWebView
+ + +void
+webkit_web_view_reload (WebKitWebView *web_view);
+Reloads the current contents of web_view
+.
+See also webkit_web_view_reload_bypass_cache().
void
+webkit_web_view_reload_bypass_cache (WebKitWebView *web_view);
+Reloads the current contents of web_view
+ without
+using any cached data.
void
+webkit_web_view_stop_loading (WebKitWebView *web_view);
+Stops any ongoing loading operation in web_view
+.
+This method does nothing if no content is being loaded.
+If there is a loading operation in progress, it will be cancelled and
+“load-failed” signal will be emitted with
+WEBKIT_NETWORK_ERROR_CANCELLED error.
gboolean
+webkit_web_view_is_loading (WebKitWebView *web_view);
+Gets the value of the “is-loading” property.
+You can monitor when a WebKitWebView is loading a page by connecting to
+notify::is-loading signal of web_view
+. This is useful when you are
+interesting in knowing when the view is loading something but not in the
+details about the status of the load operation, for example to start a spinner
+when the view is loading a page and stop it when it finishes.
gboolean
+webkit_web_view_is_playing_audio (WebKitWebView *web_view);
+Gets the value of the “is-playing-audio” property.
+You can monitor when a page in a WebKitWebView is playing audio by
+connecting to the notify::is-playing-audio signal of web_view
+. This
+is useful when the application wants to provide visual feedback when a
+page is producing sound.
Since: 2.8
+gdouble
+webkit_web_view_get_estimated_load_progress
+ (WebKitWebView *web_view);
+Gets the value of the “estimated-load-progress” property.
+You can monitor the estimated progress of a load operation by
+connecting to the notify::estimated-load-progress signal of web_view
+.
const gchar *
+webkit_web_view_get_custom_charset (WebKitWebView *web_view);
+Returns the current custom character encoding name of web_view
+.
the current custom character encoding name or NULL if no
+custom character encoding has been set.
void +webkit_web_view_set_custom_charset (+WebKitWebView *web_view, +const gchar *charset);
Sets the current custom character encoding override of web_view
+. The custom
+character encoding will override any text encoding detected via HTTP headers or
+META tags. Calling this method will stop any current load operation and reload the
+current page. Setting the custom character encoding to NULL removes the character
+encoding override.
web_view |
++ | + |
charset |
+a character encoding name or |
+[allow-none] | +
WebKitBackForwardList *
+webkit_web_view_get_back_forward_list (WebKitWebView *web_view);
+Obtains the WebKitBackForwardList associated with the given WebKitWebView. The +WebKitBackForwardList is owned by the WebKitWebView.
+ + +void +webkit_web_view_go_to_back_forward_list_item + (+WebKitWebView *web_view, +WebKitBackForwardListItem *list_item);
Loads the specific history item list_item
+.
+You can monitor the load operation by connecting to
+“load-changed” signal.
const gchar *
+webkit_web_view_get_uri (WebKitWebView *web_view);
+Returns the current active URI of web_view
+. The active URI might change during
+a load operation:
+ When nothing has been loaded yet on web_view the active URI is NULL.
+
+ When a new load operation starts the active URI is the requested URI: +
+
+ If the load operation was started by webkit_web_view_load_uri(),
+ the requested URI is the given one.
+
+ If the load operation was started by webkit_web_view_load_html(),
+ the requested URI is "about:blank".
+
+ If the load operation was started by webkit_web_view_load_alternate_html(),
+ the requested URI is content URI provided.
+
+ If the load operation was started by webkit_web_view_go_back() or
+ webkit_web_view_go_forward(), the requested URI is the original URI
+ of the previous/next item in the WebKitBackForwardList of web_view.
+
+ If the load operation was started by
+ webkit_web_view_go_to_back_forward_list_item(), the requested URI
+ is the opriginal URI of the given WebKitBackForwardListItem.
+
+
+
+ If there is a server redirection during the load operation,
+ the active URI is the redirected URI. When the signal
+ “load-changed” is emitted with WEBKIT_LOAD_REDIRECTED
+ event, the active URI is already updated to the redirected URI.
+
+ When the signal “load-changed” is emitted
+ with WEBKIT_LOAD_COMMITTED event, the active URI is the final
+ one and it will not change unless a new load operation is started
+ or a navigation action within the same page is performed.
+
You can monitor the active URI by connecting to the notify::uri
+signal of web_view
+.
void +webkit_web_view_set_settings (+WebKitWebView *web_view, +WebKitSettings *settings);
Sets the WebKitSettings to be applied to web_view
+. The
+existing WebKitSettings of web_view
+ will be replaced by
+settings
+. New settings are applied immediately on web_view
+.
+The same WebKitSettings object can be shared
+by multiple WebKitWebViews.
WebKitSettings *
+webkit_web_view_get_settings (WebKitWebView *web_view);
+Gets the WebKitSettings currently applied to web_view
+.
+If no other WebKitSettings have been explicitly applied to
+web_view
+ with webkit_web_view_set_settings(), the default
+WebKitSettings will be returned. This method always returns
+a valid WebKitSettings object.
+To modify any of the web_view
+ settings, you can either create
+a new WebKitSettings object with webkit_settings_new(), setting
+the desired preferences, and then replace the existing web_view
+
+settings with webkit_web_view_set_settings() or get the existing
+web_view
+ settings and update it directly. WebKitSettings objects
+can be shared by multiple WebKitWebViews, so modifying
+the settings of a WebKitWebView would affect other
+WebKitWebViews using the same WebKitSettings.
WebKitWindowProperties *
+webkit_web_view_get_window_properties (WebKitWebView *web_view);
+Get the WebKitWindowProperties object containing the properties
+that the window containing web_view
+ should have.
void +webkit_web_view_set_zoom_level (+WebKitWebView *web_view, +gdouble zoom_level);
Set the zoom level of web_view
+, i.e. the factor by which the
+view contents are scaled with respect to their original size.
gdouble
+webkit_web_view_get_zoom_level (WebKitWebView *web_view);
+Get the zoom level of web_view
+, i.e. the factor by which the
+view contents are scaled with respect to their original size.
void +webkit_web_view_can_execute_editing_command + (+WebKitWebView *web_view, +const gchar *command, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously check if it is possible to execute the given editing command.
+When the operation is finished, callback
+ will be called. You can then call
+webkit_web_view_can_execute_editing_command_finish() to get the result of the operation.
web_view |
++ | + |
command |
+the command to check |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
gboolean +webkit_web_view_can_execute_editing_command_finish + (+WebKitWebView *web_view, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_view_can_execute_editing_command().
web_view |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
void +webkit_web_view_execute_editing_command + (+WebKitWebView *web_view, +const gchar *command);
Request to execute the given command
+ for web_view
+. You can use
+webkit_web_view_can_execute_editing_command() to check whether
+it's possible to execute the command.
void +webkit_web_view_execute_editing_command_with_argument + (+WebKitWebView *web_view, +const char *command, +const char *argument);
Request to execute the given command
+ with argument
+ for web_view
+. You can use
+webkit_web_view_can_execute_editing_command() to check whether
+it's possible to execute the command.
web_view |
++ | + |
command |
+the command to execute |
++ |
argument |
+the command argument |
++ |
Since: 2.10
+WebKitFindController *
+webkit_web_view_get_find_controller (WebKitWebView *web_view);
+Gets the WebKitFindController that will allow the caller to query +the WebKitWebView for the text to look for.
+ + +void +webkit_web_view_run_javascript (+WebKitWebView *web_view, +const gchar *script, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously run script
+ in the context of the current page in web_view
+. If
+WebKitSettings:enable-javascript is FALSE, this method will do nothing.
When the operation is finished, callback
+ will be called. You can then call
+webkit_web_view_run_javascript_finish() to get the result of the operation.
web_view |
++ | + |
script |
+the script to run |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the script finished. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
WebKitJavascriptResult * +webkit_web_view_run_javascript_finish (+WebKitWebView *web_view, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_view_run_javascript().
This is an example of using webkit_web_view_run_javascript() with a script returning
+a string:
1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 |
+ static void +web_view_javascript_finished (GObject *object, + GAsyncResult *result, + gpointer user_data) +{ + WebKitJavascriptResult *js_result; + JSCValue *value; + GError *error = NULL; + + js_result = webkit_web_view_run_javascript_finish (WEBKIT_WEB_VIEW (object), result, &error); + if (!js_result) { + g_warning ("Error running javascript: %s", error->message); + g_error_free (error); + return; + } + + value = webkit_javascript_result_get_js_value (js_result); + if (jsc_value_is_string (value)) { + JSCException *exception; + gchar *str_value; + + str_value = jsc_value_to_string (value); + exception = jsc_context_get_exception (jsc_value_get_context (value)); + if (exception) + g_warning ("Error running javascript: %s", jsc_exception_get_message (exception)); + else + g_print ("Script result: %s\n", str_value); + g_free (str_value); + } else { + g_warning ("Error running javascript: unexpected return value"); + } + webkit_javascript_result_unref (js_result); +} + +static void +web_view_get_link_url (WebKitWebView *web_view, + const gchar *link_id) +{ + gchar *script; + + script = g_strdup_printf ("window.document.getElementById('%s').href;", link_id); + webkit_web_view_run_javascript (web_view, script, NULL, web_view_javascript_finished, NULL); + g_free (script); +} |
+
web_view |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
a WebKitJavascriptResult with the result of the last executed statement in script
+or NULL in case of error.
[transfer full]
+void +webkit_web_view_run_javascript_in_world + (+WebKitWebView *web_view, +const gchar *script, +const gchar *world_name, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously run script
+ in the script world with name world_name
+ of the current page context in web_view
+.
+If WebKitSettings:enable-javascript is FALSE, this method will do nothing.
When the operation is finished, callback
+ will be called. You can then call
+webkit_web_view_run_javascript_in_world_finish() to get the result of the operation.
web_view |
++ | + |
script |
+the script to run |
++ |
world_name |
+the name of a WebKitScriptWorld |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the script finished. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.22
+WebKitJavascriptResult * +webkit_web_view_run_javascript_in_world_finish + (+WebKitWebView *web_view, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_view_run_javascript_in_world().
web_view |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
a WebKitJavascriptResult with the result of the last executed statement in script
+or NULL in case of error.
[transfer full]
+Since: 2.22
+void +webkit_web_view_run_javascript_from_gresource + (+WebKitWebView *web_view, +const gchar *resource, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously run the script from resource
+ in the context of the
+current page in web_view
+.
When the operation is finished, callback
+ will be called. You can
+then call webkit_web_view_run_javascript_from_gresource_finish() to get the result
+of the operation.
web_view |
++ | + |
resource |
+the location of the resource to load |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the script finished. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
WebKitJavascriptResult * +webkit_web_view_run_javascript_from_gresource_finish + (+WebKitWebView *web_view, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_view_run_javascript_from_gresource().
Check webkit_web_view_run_javascript_finish() for a usage example.
web_view |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
a WebKitJavascriptResult with the result of the last executed statement in script
+or NULL in case of error.
[transfer full]
+gboolean +webkit_web_view_can_show_mime_type (+WebKitWebView *web_view, +const gchar *mime_type);
Whether or not a MIME type can be displayed in web_view
+.
void +webkit_web_view_save (+WebKitWebView *web_view, +WebKitSaveMode save_mode, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously save the current web page associated to the
+WebKitWebView into a self-contained format using the mode
+specified in save_mode
+.
When the operation is finished, callback
+ will be called. You can
+then call webkit_web_view_save_finish() to get the result of the
+operation.
web_view |
++ | + |
save_mode |
+the WebKitSaveMode specifying how the web page should be saved. |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
GInputStream * +webkit_web_view_save_finish (+WebKitWebView *web_view, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_view_save().
web_view |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
a GInputStream with the result of saving
+the current web page or NULL in case of error.
[transfer full]
+void +webkit_web_view_save_to_file (+WebKitWebView *web_view, +GFile *file, +WebKitSaveMode save_mode, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously save the current web page associated to the
+WebKitWebView into a self-contained format using the mode
+specified in save_mode
+ and writing it to file
+.
When the operation is finished, callback
+ will be called. You can
+then call webkit_web_view_save_to_file_finish() to get the result of the
+operation.
web_view |
++ | + |
file |
+the GFile where the current web page should be saved to. |
++ |
save_mode |
+the WebKitSaveMode specifying how the web page should be saved. |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
gboolean +webkit_web_view_save_to_file_finish (+WebKitWebView *web_view, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_view_save_to_file().
web_view |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
WebKitDownload * +webkit_web_view_download_uri (+WebKitWebView *web_view, +const char *uri);
Requests downloading of the specified URI string for web_view
+.
gboolean +webkit_web_view_get_tls_info (+WebKitWebView *web_view, +GTlsCertificate **certificate, +GTlsCertificateFlags *errors);
Retrieves the GTlsCertificate associated with the main resource of web_view
+,
+and the GTlsCertificateFlags showing what problems, if any, have been found
+with that certificate.
+If the connection is not HTTPS, this function returns FALSE.
+This function should be called after a response has been received from the
+server, so you can connect to “load-changed” and call this function
+when it's emitted with WEBKIT_LOAD_COMMITTED event.
Note that this function provides no information about the security of the web
+page if the current WebKitTLSErrorsPolicy is WEBKIT_TLS_ERRORS_POLICY_IGNORE
+,
+as subresources of the page may be controlled by an attacker. This function
+may safely be used to determine the security status of the current page only
+if the current WebKitTLSErrorsPolicy is WEBKIT_TLS_ERRORS_POLICY_FAIL
+, in
+which case subresources that fail certificate verification will be blocked.
web_view |
++ | + |
certificate |
+return location for a GTlsCertificate. |
+[out][transfer none] | +
errors |
+return location for a GTlsCertificateFlags the verification status of |
+[out] | +
void +webkit_web_view_set_editable (+WebKitWebView *web_view, +gboolean editable);
Sets whether the user is allowed to edit the HTML document.
+If editable
+ is TRUE, web_view
+ allows the user to edit the HTML document. If
+editable
+ is FALSE, an element in web_view
+'s document can only be edited if the
+CONTENTEDITABLE attribute has been set on the element or one of its parent
+elements. By default a WebKitWebView is not editable.
Normally, a HTML document is not editable unless the elements within the +document are editable. This function provides a way to make the contents +of a WebKitWebView editable without altering the document or DOM structure.
+web_view |
++ | + |
editable |
+a gboolean indicating the editable state |
++ |
Since: 2.8
+WebKitEditorState *
+webkit_web_view_get_editor_state (WebKitWebView *web_view);
+Gets the web editor state of web_view
+.
Since: 2.10
+WebKitWebViewSessionState *
+webkit_web_view_get_session_state (WebKitWebView *web_view);
+Gets the current session state of web_view
+
Since: 2.12
+void +webkit_web_view_restore_session_state (+WebKitWebView *web_view, +WebKitWebViewSessionState *state);
Restore the web_view
+ session state from state
+
Since: 2.12
+WebKitWebResource *
+webkit_web_view_get_main_resource (WebKitWebView *web_view);
+Return the main resource of web_view
+.
the main WebKitWebResource of the view
+or NULL if nothing has been loaded.
[transfer none]
+guint +webkit_web_view_add_frame_displayed_callback + (+WebKitWebView *web_view, +WebKitFrameDisplayedCallback callback, +gpointer user_data, +GDestroyNotify destroy_notify);
Add a callback to be called when the backend notifies that a frame has been displayed in web_view
+.
web_view |
++ | + |
callback |
++ | + |
user_data |
+user data to pass to |
+[closure] | +
destroy_notify |
+destroy notifier for |
+[nullable] | +
an identifier that should be passed to webkit_web_view_remove_frame_displayed_callback()
+to remove the callback.
Since: 2.24
+void +webkit_web_view_remove_frame_displayed_callback + (+WebKitWebView *web_view, +guint id);
Removes a WebKitFrameDisplayedCallback previously added to web_view
+ with
+webkit_web_view_add_frame_displayed_callback().
Since: 2.24
+WebKitJavascriptResult *
+webkit_javascript_result_ref (WebKitJavascriptResult *js_result);
+Atomically increments the reference count of js_result
+ by one. This
+function is MT-safe and may be called from any thread.
void
+webkit_javascript_result_unref (WebKitJavascriptResult *js_result);
+Atomically decrements the reference count of js_result
+ by one. If the
+reference count drops to 0, all memory allocated by the WebKitJavascriptResult is
+released. This function is MT-safe and may be called from any
+thread.
JSCValue *
+webkit_javascript_result_get_js_value (WebKitJavascriptResult *js_result);
+Get the JSCValue of js_result
+.
Since: 2.22
+WebKitScriptDialog *
+webkit_script_dialog_ref (WebKitScriptDialog *dialog);
+Atomically increments the reference count of dialog
+ by one. This
+function is MT-safe and may be called from any thread.
Since: 2.24
+void
+webkit_script_dialog_unref (WebKitScriptDialog *dialog);
+Atomically decrements the reference count of dialog
+ by one. If the
+reference count drops to 0, all memory allocated by the WebKitScriptdialog is
+released. This function is MT-safe and may be called from any
+thread.
Since: 2.24
+WebKitScriptDialogType
+webkit_script_dialog_get_dialog_type (WebKitScriptDialog *dialog);
+Get the dialog type of a WebKitScriptDialog.
+ + +const gchar *
+webkit_script_dialog_get_message (WebKitScriptDialog *dialog);
+Get the message of a WebKitScriptDialog.
+ + +void +webkit_script_dialog_confirm_set_confirmed + (+WebKitScriptDialog *dialog, +gboolean confirmed);
This method is used for WEBKIT_SCRIPT_DIALOG_CONFIRM and WEBKIT_SCRIPT_DIALOG_BEFORE_UNLOAD_CONFIRM dialogs when
+“script-dialog” signal is emitted to set whether the user
+confirmed the dialog or not. The default implementation of “script-dialog”
+signal sets TRUE when the OK or Stay buttons are clicked and FALSE otherwise.
+It's an error to use this method with a WebKitScriptDialog that is not of type
+WEBKIT_SCRIPT_DIALOG_CONFIRM or WEBKIT_SCRIPT_DIALOG_BEFORE_UNLOAD_CONFIRM
const gchar *
+webkit_script_dialog_prompt_get_default_text
+ (WebKitScriptDialog *dialog);
+Get the default text of a WebKitScriptDialog of type WEBKIT_SCRIPT_DIALOG_PROMPT.
+It's an error to use this method with a WebKitScriptDialog that is not of type
+WEBKIT_SCRIPT_DIALOG_PROMPT.
void +webkit_script_dialog_prompt_set_text (+WebKitScriptDialog *dialog, +const gchar *text);
This method is used for WEBKIT_SCRIPT_DIALOG_PROMPT dialogs when
+“script-dialog” signal is emitted to set the text
+entered by the user. The default implementation of “script-dialog”
+signal sets the text of the entry form when OK button is clicked, otherwise NULL is set.
+It's an error to use this method with a WebKitScriptDialog that is not of type
+WEBKIT_SCRIPT_DIALOG_PROMPT.
void
+webkit_script_dialog_close (WebKitScriptDialog *dialog);
+Close dialog
+. When handling a WebKitScriptDialog asynchronously (webkit_script_dialog_ref()
+was called in “script-dialog” callback), this function needs to be called to notify
+that we are done with the script dialog. The dialog will be closed on destruction if this function
+hasn't been called before.
Since: 2.24
+WebKitWebViewSessionState *
+webkit_web_view_session_state_new (GBytes *data);
+Creates a new WebKitWebViewSessionState from serialized data.
+ +a new WebKitWebViewSessionState, or NULL if data
+doesn't contain a
+valid serialized WebKitWebViewSessionState.
[transfer full]
+Since: 2.12
+WebKitWebViewSessionState *
+webkit_web_view_session_state_ref (WebKitWebViewSessionState *state);
+Atomically increments the reference count of state
+ by one. This
+function is MT-safe and may be called from any thread.
Since: 2.12
+void
+webkit_web_view_session_state_unref (WebKitWebViewSessionState *state);
+Atomically decrements the reference count of state
+ by one. If the
+reference count drops to 0, all memory allocated by the WebKitWebViewSessionState is
+released. This function is MT-safe and may be called from any thread.
Since: 2.12
+GBytes *
+webkit_web_view_session_state_serialize
+ (WebKitWebViewSessionState *state);
+Serializes a WebKitWebViewSessionState.
+ + +Since: 2.12
+Enum values used to denote the different events that happen during a +WebKitWebView load operation.
+| + |
+ A new load request has been made. +No data has been received yet, empty structures have +been allocated to perform the load; the load may still +fail due to transport issues such as not being able to +resolve a name, or connect to a port. + |
++ |
| + |
+ A provisional data source received +a server redirect. + |
++ |
| + |
+ The content started arriving for a page load. +The necessary transport requirements are established, and the +load is being performed. + |
++ |
| + |
+ Load completed. All resources are done loading +or there was an error during the load operation. + |
++ |
Enum values used for determining the type of a policy decision during +“decide-policy”.
+| + |
+ This type of policy decision
+ is requested when WebKit is about to navigate to a new page in either the
+ main frame or a subframe. Acceptable policy decisions are either
+ |
++ |
| + |
+ This type of policy decision
+ is requested when WebKit is about to create a new window. Acceptable policy
+ decisions are either |
++ |
| + |
+ This type of decision is used when WebKit has
+ received a response for a network resource and is about to start the load.
+ Note that these resources include all subresources of a page such as images
+ and stylesheets as well as main documents. Appropriate policy responses to
+ this decision are |
++ |
Enum values to specify the different ways in which a WebKitWebView +can save its current web page into a self-contained file.
+ +Enum values used to denote the different events which can trigger +the detection of insecure content.
+ +Enum values used to specify the reason why the web process terminated abnormally.
+ +Since: 2.20
+#define WEBKIT_EDITING_COMMAND_CUT "Cut" ++
The cut clipboard command. Copies the current selection inside
+a WebKitWebView to the clipboard and deletes the selected content.
+You can check whether it's possible to execute the command with
+webkit_web_view_can_execute_editing_command(). In general it's
+possible to cut to the clipboard when the WebKitWebView content is
+editable and there is an active selection.
#define WEBKIT_EDITING_COMMAND_COPY "Copy" ++
The copy clipboard command. Copies the current selection inside
+a WebKitWebView to the clipboard.
+You can check whether it's possible to execute the command with
+webkit_web_view_can_execute_editing_command(). In general it's
+possible to copy to the clipboard when there is an active selection
+inside the WebKitWebView.
#define WEBKIT_EDITING_COMMAND_PASTE "Paste" ++
The paste clipboard command. Pastes the contents of the clipboard to
+a WebKitWebView.
+You can check whether it's possible to execute the command with
+webkit_web_view_can_execute_editing_command(). In general it's possible
+to paste from the clipboard when the WebKitWebView content is editable
+and clipboard is not empty.
#define WEBKIT_EDITING_COMMAND_SELECT_ALL "SelectAll" ++
The select all command. Selects all the content of the current text field in
+a WebKitWebView.
+It is always possible to select all text, no matter whether the
+WebKitWebView content is editable or not. You can still check it
+with webkit_web_view_can_execute_editing_command().
#define WEBKIT_EDITING_COMMAND_UNDO "Undo" ++
The undo command. Undoes the last editing command in a WebKitWebView.
+You can check whether it's possible to execute the command with
+webkit_web_view_can_execute_editing_command(). It's only possible
+to undo a command after a previously executed editing operation.
#define WEBKIT_EDITING_COMMAND_REDO "Redo" ++
The redo command. Redoes a previously undone editing command in
+a WebKitWebView.
+You can check whether it's possible to execute the command with
+webkit_web_view_can_execute_editing_command(). It's only possible
+to redo a command when it has been previously undone.
#define WEBKIT_EDITING_COMMAND_INSERT_IMAGE "InsertImage" ++
The insert image command. Creates an image element that is inserted at
+the current cursor position. It receives an URI as argument,
+that is used as the image source. This command should be executed with
+webkit_web_view_execute_editing_command_with_argument().
Since: 2.10
+#define WEBKIT_EDITING_COMMAND_CREATE_LINK "CreateLink" ++
The create link command. Creates a link element that is inserted at
+the current cursor position. If there's a selection, the selected text
+will be used as the link text, otherwise the URL itself will be used.
+It receives the link URL as argument. This command should be executed
+with webkit_web_view_execute_editing_command_with_argument()
Since: 2.10
+Enum values used for determining the type of WebKitScriptDialog
+| + |
+ Alert script dialog, used to show a +message to the user. + |
++ |
| + |
+ Confirm script dialog, used to ask +confirmation to the user. + |
++ |
| + |
+ Prompt script dialog, used to ask +information to the user. + |
++ |
| + |
+ Before unload confirm dialog, +used to ask confirmation to leave the current page to the user. Since 2.12 + |
++ |
“backend” property“backend” WebKitWebViewBackend *+
The WebKitWebViewBackend of the view.
+Flags: Read / Write / Construct Only
+Since: 2.20
+“editable” property“editable” gboolean+
Whether the pages loaded inside WebKitWebView are editable. For more
+information see webkit_web_view_set_editable().
Flags: Read / Write
+Default value: FALSE
+Since: 2.8
+“estimated-load-progress” property“estimated-load-progress” gdouble+
An estimate of the percent completion for the current loading operation. +This value will range from 0.0 to 1.0 and, once a load completes, +will remain at 1.0 until a new load starts, at which point it +will be reset to 0.0. +The value is an estimate based on the total number of bytes expected +to be received for a document, including all its possible subresources +and child documents.
+Flags: Read
+Allowed values: [0,1]
+Default value: 0
+“is-controlled-by-automation” property“is-controlled-by-automation” gboolean+
Whether the WebKitWebView is controlled by automation. This should only be used when +creating a new WebKitWebView as a response to “create-web-view” +signal request.
+Flags: Read / Write / Construct Only
+Default value: FALSE
+Since: 2.18
+“is-ephemeral” property“is-ephemeral” gboolean+
Whether the WebKitWebView is ephemeral. An ephemeral web view never writes
+website data to the client storage, no matter what WebKitWebsiteDataManager
+its context is using. This is normally used to implement private browsing mode.
+This is a G_PARAM_CONSTRUCT_ONLY property, so you have to create a ephemeral
+WebKitWebView and it can't be changed. Note that all WebKitWebViews
+created with an ephemeral WebKitWebContext will be ephemeral automatically.
+See also webkit_web_context_new_ephemeral().
Flags: Read / Write / Construct Only
+Default value: FALSE
+Since: 2.16
+“is-loading” property“is-loading” gboolean+
Whether the WebKitWebView is currently loading a page. This property becomes
+TRUE as soon as a new load operation is requested and before the
+“load-changed” signal is emitted with WEBKIT_LOAD_STARTED and
+at that point the active URI is the requested one.
+When the load operation finishes the property is set to FALSE before
+“load-changed” is emitted with WEBKIT_LOAD_FINISHED.
Flags: Read
+Default value: FALSE
+“is-playing-audio” property“is-playing-audio” gboolean+
Whether the WebKitWebView is currently playing audio from a page.
+This property becomes TRUE as soon as web content starts playing any
+kind of audio. When a page is no longer playing any kind of sound,
+the property is set back to FALSE.
Flags: Read
+Default value: FALSE
+Since: 2.8
+“related-view” property“related-view” WebKitWebView *+
The related WebKitWebView used when creating the view to share the +same web process. This property is not readable because the related +web view is only valid during the object construction.
+Flags: Write / Construct Only
+Since: 2.4
+“settings” property“settings” WebKitSettings *+
The WebKitSettings of the view.
+Flags: Write / Construct
+Since: 2.6
+“title” property“title” gchar *+
The main frame document title of this WebKitWebView. If
+the title has not been received yet, it will be NULL.
Flags: Read
+Default value: NULL
+“uri” property“uri” gchar *+
The current active URI of the WebKitWebView.
+See webkit_web_view_get_uri() for more details.
Flags: Read
+Default value: NULL
+“user-content-manager” property“user-content-manager” WebKitUserContentManager *+
The WebKitUserContentManager of the view.
+Flags: Read / Write / Construct Only
+Since: 2.6
+“web-context” property“web-context” WebKitWebContext *+
The WebKitWebContext of the view.
+Flags: Read / Write / Construct Only
+“zoom-level” property“zoom-level” gdouble+
The zoom level of the WebKitWebView content.
+See webkit_web_view_set_zoom_level() for more details.
Flags: Read / Write
+Allowed values: >= 0
+Default value: 1
+“authenticate” signalgboolean +user_function (WebKitWebView *web_view, + WebKitAuthenticationRequest *request, + gpointer user_data)+
This signal is emitted when the user is challenged with HTTP
+authentication. To let the application access or supply
+the credentials as well as to allow the client application
+to either cancel the request or perform the authentication,
+the signal will pass an instance of the
+WebKitAuthenticationRequest in the request
+ argument.
+To handle this signal asynchronously you should keep a ref
+of the request and return TRUE. To disable HTTP authentication
+entirely, connect to this signal and simply return TRUE.
The default signal handler will run a default authentication +dialog asynchronously for the user to interact with.
+web_view |
+the WebKitWebView on which the signal is emitted |
++ |
request |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+Since: 2.2
+“close” signalvoid +user_function (WebKitWebView *web_view, + gpointer user_data)+
Emitted when closing a WebKitWebView is requested. This occurs when a
+call is made from JavaScript's window.close function or
+after trying to close the web_view
+ with webkit_web_view_try_close().
+It is the owner's responsibility to handle this signal to hide or
+destroy the WebKitWebView, if necessary.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“context-menu” signalgboolean +user_function (WebKitWebView *web_view, + WebKitContextMenu *context_menu, + gpointer event, + WebKitHitTestResult *hit_test_result, + gpointer user_data)+
Emitted when a context menu is about to be displayed to give the application +a chance to customize the proposed menu, prevent the menu from being displayed, +or build its own context menu.
+
+ To customize the proposed menu you can use webkit_context_menu_prepend(),
+ webkit_context_menu_append() or webkit_context_menu_insert() to add new
+ WebKitContextMenuItems to context_menu, webkit_context_menu_move_item()
+ to reorder existing items, or webkit_context_menu_remove() to remove an
+ existing item. The signal handler should return FALSE, and the menu represented
+ by context_menu will be shown.
+
+ To prevent the menu from being displayed you can just connect to this signal
+ and return TRUE so that the proposed menu will not be shown.
+
+ To build your own menu, you can remove all items from the proposed menu with
+ webkit_context_menu_remove_all(), add your own items and return FALSE so
+ that the menu will be shown. You can also ignore the proposed WebKitContextMenu,
+ build your own GtkMenu and return TRUE to prevent the proposed menu from being shown.
+
+ If you just want the default menu to be shown always, simply don't connect to this + signal because showing the proposed context menu is the default behaviour. +
The event
+ is expected to be one of the following types:
+a GdkEventButton of type GDK_BUTTON_PRESS when the context menu
+was triggered with mouse.
+
+a GdkEventKey of type GDK_KEY_PRESS if the keyboard was used to show
+the menu.
+
+a generic GdkEvent of type GDK_NOTHING when the “popup-menu”
+signal was used to show the context menu.
+
If the signal handler returns FALSE the context menu represented by context_menu
+
+will be shown, if it return TRUE the context menu will not be shown.
The proposed WebKitContextMenu passed in context_menu
+ argument is only valid
+during the signal emission.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
context_menu |
+the proposed WebKitContextMenu |
++ |
event |
+the GdkEvent that triggered the context menu |
++ |
hit_test_result |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“context-menu-dismissed” signalvoid +user_function (WebKitWebView *web_view, + gpointer user_data)+
Emitted after “context-menu” signal, if the context menu is shown, +to notify that the context menu is dismissed.
+web_view |
+the WebKitWebView on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“create” signalWebKitWebView* +user_function (WebKitWebView *web_view, + WebKitNavigationAction *navigation_action, + gpointer user_data)+
Emitted when the creation of a new WebKitWebView is requested. +If this signal is handled the signal handler should return the +newly created WebKitWebView.
+The WebKitNavigationAction parameter contains information about the +navigation action that triggered this signal.
+When using WEBKIT_PROCESS_MODEL_MULTIPLE_SECONDARY_PROCESSES
+process model, the new WebKitWebView should be related to
+web_view
+ to share the same web process, see webkit_web_view_new_with_related_view()
+for more details.
The new WebKitWebView should not be displayed to the user +until the “ready-to-show” signal is emitted.
+web_view |
+the WebKitWebView on which the signal is emitted |
++ |
navigation_action |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
a newly allocated WebKitWebView widget
+or NULL to propagate the event further.
[transfer full]
+Flags: Run Last
+“decide-policy” signalgboolean +user_function (WebKitWebView *web_view, + WebKitPolicyDecision *decision, + WebKitPolicyDecisionType decision_type, + gpointer user_data)+
This signal is emitted when WebKit is requesting the client to decide a policy
+decision, such as whether to navigate to a page, open a new window or whether or
+not to download a resource. The WebKitNavigationPolicyDecision passed in the
+decision
+ argument is a generic type, but should be casted to a more
+specific type when making the decision. For example:
1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 |
+ static gboolean +decide_policy_cb (WebKitWebView *web_view, + WebKitPolicyDecision *decision, + WebKitPolicyDecisionType type) +{ + switch (type) { + case WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION: { + WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision); + /* Make a policy decision here. */ + break; + } + case WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION: { + WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision); + /* Make a policy decision here. */ + break; + } + case WEBKIT_POLICY_DECISION_TYPE_RESPONSE: + WebKitResponsePolicyDecision *response = WEBKIT_RESPONSE_POLICY_DECISION (decision); + /* Make a policy decision here. */ + break; + default: + /* Making no decision results in webkit_policy_decision_use(). */ + return FALSE; + } + return TRUE; +} |
+
It is possible to make policy decision asynchronously, by simply calling g_object_ref()
+on the decision
+ argument and returning TRUE to block the default signal handler.
+If the last reference is removed on a WebKitPolicyDecision and no decision has been
+made explicitly, webkit_policy_decision_use() will be the default policy decision. The
+default signal handler will simply call webkit_policy_decision_use(). Only the first
+policy decision chosen for a given WebKitPolicyDecision will have any affect.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
decision |
++ | + |
decision_type |
+a WebKitPolicyDecisionType denoting the type of |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“enter-fullscreen” signalgboolean +user_function (WebKitWebView *web_view, + gpointer user_data)+
Emitted when JavaScript code calls
+element.webkitRequestFullScreen. If the
+signal is not handled the WebKitWebView will proceed to full screen
+its top level window. This signal can be used by client code to
+request permission to the user prior doing the full screen
+transition and eventually prepare the top-level window
+(e.g. hide some widgets that would otherwise be part of the
+full screen window).
web_view |
+the WebKitWebView on which the signal is emitted. |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to continue emission of the event.
Flags: Run Last
+“insecure-content-detected” signalvoid +user_function (WebKitWebView *web_view, + WebKitInsecureContentEvent event, + gpointer user_data)+
This signal is emitted when insecure content has been detected +in a page loaded through a secure connection. This typically +means that a external resource from an unstrusted source has +been run or displayed, resulting in a mix of HTTPS and +non-HTTPS content.
+You can check the event
+ parameter to know exactly which kind
+of event has been detected (see WebKitInsecureContentEvent).
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
event |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“leave-fullscreen” signalgboolean +user_function (WebKitWebView *web_view, + gpointer user_data)+
Emitted when the WebKitWebView is about to restore its top level +window out of its full screen state. This signal can be used by +client code to restore widgets hidden during the +“enter-fullscreen” stage for instance.
+web_view |
+the WebKitWebView on which the signal is emitted. |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to continue emission of the event.
Flags: Run Last
+“load-changed” signalvoid +user_function (WebKitWebView *web_view, + WebKitLoadEvent load_event, + gpointer user_data)+
Emitted when a load operation in web_view
+ changes.
+The signal is always emitted with WEBKIT_LOAD_STARTED when a
+new load request is made and WEBKIT_LOAD_FINISHED when the load
+finishes successfully or due to an error. When the ongoing load
+operation fails “load-failed” signal is emitted
+before “load-changed” is emitted with
+WEBKIT_LOAD_FINISHED.
+If a redirection is received from the server, this signal is emitted
+with WEBKIT_LOAD_REDIRECTED after the initial emission with
+WEBKIT_LOAD_STARTED and before WEBKIT_LOAD_COMMITTED.
+When the page content starts arriving the signal is emitted with
+WEBKIT_LOAD_COMMITTED event.
You can handle this signal and use a switch to track any ongoing +load operation.
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 |
+ static void web_view_load_changed (WebKitWebView *web_view, + WebKitLoadEvent load_event, + gpointer user_data) +{ + switch (load_event) { + case WEBKIT_LOAD_STARTED: + /* New load, we have now a provisional URI */ + provisional_uri = webkit_web_view_get_uri (web_view); + /* Here we could start a spinner or update the + * location bar with the provisional URI */ + break; + case WEBKIT_LOAD_REDIRECTED: + redirected_uri = webkit_web_view_get_uri (web_view); + break; + case WEBKIT_LOAD_COMMITTED: + /* The load is being performed. Current URI is + * the final one and it won't change unless a new + * load is requested or a navigation within the + * same page is performed */ + uri = webkit_web_view_get_uri (web_view); + break; + case WEBKIT_LOAD_FINISHED: + /* Load finished, we can now stop the spinner */ + break; + } +} |
+
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
load_event |
+the WebKitLoadEvent |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“load-failed” signalgboolean +user_function (WebKitWebView *web_view, + WebKitLoadEvent load_event, + gchar *failing_uri, + GError *error, + gpointer user_data)+
Emitted when an error occurs during a load operation.
+If the error happened when starting to load data for a page
+load_event
+ will be WEBKIT_LOAD_STARTED. If it happened while
+loading a committed data source load_event
+ will be WEBKIT_LOAD_COMMITTED.
+Since a load error causes the load operation to finish, the signal
+WebKitWebView::load-changed will always be emitted with
+WEBKIT_LOAD_FINISHED event right after this one.
By default, if the signal is not handled, a stock error page will be displayed. +You need to handle the signal if you want to provide your own error page.
+web_view |
+the WebKitWebView on which the signal is emitted |
++ |
load_event |
+the WebKitLoadEvent of the load operation |
++ |
failing_uri |
+the URI that failed to load |
++ |
error |
+the GError that was triggered |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“load-failed-with-tls-errors” signalgboolean +user_function (WebKitWebView *web_view, + gchar *failing_uri, + GTlsCertificate *certificate, + GTlsCertificateFlags errors, + gpointer user_data)+
Emitted when a TLS error occurs during a load operation.
+To allow an exception for this certificate
+
+and the host of failing_uri
+ use webkit_web_context_allow_tls_certificate_for_host().
To handle this signal asynchronously you should call g_object_ref() on certificate
+
+and return TRUE.
If FALSE is returned, “load-failed” will be emitted. The load
+will finish regardless of the returned value.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
failing_uri |
+the URI that failed to load |
++ |
certificate |
++ | + |
errors |
+a GTlsCertificateFlags with the verification status of |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+Since: 2.6
+“mouse-target-changed” signalvoid +user_function (WebKitWebView *web_view, + WebKitHitTestResult *hit_test_result, + guint modifiers, + gpointer user_data)+
This signal is emitted when the mouse cursor moves over an
+element such as a link, image or a media element. To determine
+what type of element the mouse cursor is over, a Hit Test is performed
+on the current mouse coordinates and the result is passed in the
+hit_test_result
+ argument. The modifiers
+ argument is a bitmask of
+GdkModifierType flags indicating the state of modifier keys.
+The signal is emitted again when the mouse is moved out of the
+current element with a new hit_test_result
+.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
hit_test_result |
++ | + |
modifiers |
+a bitmask of GdkModifierType |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“permission-request” signalgboolean +user_function (WebKitWebView *web_view, + WebKitPermissionRequest *request, + gpointer user_data)+
This signal is emitted when WebKit is requesting the client to +decide about a permission request, such as allowing the browser +to switch to fullscreen mode, sharing its location or similar +operations.
+A possible way to use this signal could be through a dialog +allowing the user decide what to do with the request:
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 |
+ static gboolean permission_request_cb (WebKitWebView *web_view, + WebKitPermissionRequest *request, + GtkWindow *parent_window) +{ + GtkWidget *dialog = gtk_message_dialog_new (parent_window, + GTK_DIALOG_MODAL, + GTK_MESSAGE_QUESTION, + GTK_BUTTONS_YES_NO, + "Allow Permission Request?"); + gtk_widget_show (dialog); + gint result = gtk_dialog_run (GTK_DIALOG (dialog)); + + switch (result) { + case GTK_RESPONSE_YES: + webkit_permission_request_allow (request); + break; + default: + webkit_permission_request_deny (request); + break; + } + gtk_widget_destroy (dialog); + + return TRUE; +} |
+
It is possible to handle permission requests asynchronously, by
+simply calling g_object_ref() on the request
+ argument and
+returning TRUE to block the default signal handler. If the
+last reference is removed on a WebKitPermissionRequest and the
+request has not been handled, webkit_permission_request_deny()
+will be the default action.
If the signal is not handled, the request
+ will be completed automatically
+by the specific WebKitPermissionRequest that could allow or deny it. Check the
+documentation of classes implementing WebKitPermissionRequest interface to know
+their default action.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
request |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“ready-to-show” signalvoid +user_function (WebKitWebView *web_view, + gpointer user_data)+
Emitted after “create” on the newly created WebKitWebView
+when it should be displayed to the user. When this signal is emitted
+all the information about how the window should look, including
+size, position, whether the location, status and scrollbars
+should be displayed, is already set on the WebKitWindowProperties
+of web_view
+. See also webkit_web_view_get_window_properties().
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“resource-load-started” signalvoid +user_function (WebKitWebView *web_view, + WebKitWebResource *resource, + WebKitURIRequest *request, + gpointer user_data)+
Emitted when a new resource is going to be loaded. The request
+ parameter
+contains the WebKitURIRequest that will be sent to the server.
+You can monitor the load operation by connecting to the different signals
+of resource
+.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
resource |
++ | + |
request |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“run-as-modal” signalvoid +user_function (WebKitWebView *web_view, + gpointer user_data)+
Emitted after “ready-to-show” on the newly
+created WebKitWebView when JavaScript code calls
+window.showModalDialog. The purpose of
+this signal is to allow the client application to prepare the
+new view to behave as modal. Once the signal is emitted a new
+main loop will be run to block user interaction in the parent
+WebKitWebView until the new dialog is closed.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“run-file-chooser” signalgboolean +user_function (WebKitWebView *web_view, + WebKitFileChooserRequest *request, + gpointer user_data)+
This signal is emitted when the user interacts with a <input
+type='file' /> HTML element, requesting from WebKit to show
+a dialog to select one or more files to be uploaded. To let the
+application know the details of the file chooser, as well as to
+allow the client application to either cancel the request or
+perform an actual selection of files, the signal will pass an
+instance of the WebKitFileChooserRequest in the request
+
+argument.
The default signal handler will asynchronously run a regular +GtkFileChooserDialog for the user to interact with.
+web_view |
+the WebKitWebView on which the signal is emitted |
++ |
request |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“script-dialog” signalgboolean +user_function (WebKitWebView *web_view, + WebKitScriptDialog *dialog, + gpointer user_data)+
Emitted when JavaScript code calls window.alert,
+window.confirm or window.prompt,
+or when onbeforeunload event is fired.
+The dialog
+ parameter should be used to build the dialog.
+If the signal is not handled a different dialog will be built and shown depending
+on the dialog type:
+ WEBKIT_SCRIPT_DIALOG_ALERT: message dialog with a single Close button.
+
+ WEBKIT_SCRIPT_DIALOG_CONFIRM: message dialog with OK and Cancel buttons.
+
+ WEBKIT_SCRIPT_DIALOG_PROMPT: message dialog with OK and Cancel buttons and
+ a text entry with the default text.
+
+ WEBKIT_SCRIPT_DIALOG_BEFORE_UNLOAD_CONFIRM: message dialog with Stay and Leave buttons.
+
It is possible to handle the script dialog request asynchronously, by simply
+caling webkit_script_dialog_ref() on the dialog
+ argument and calling
+webkit_script_dialog_close() when done.
+If the last reference is removed on a WebKitScriptDialog and the dialog has not been
+closed, webkit_script_dialog_close() will be called.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
dialog |
+the WebKitScriptDialog to show |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“show-notification” signalgboolean +user_function (WebKitWebView *web_view, + WebKitNotification *notification, + gpointer user_data)+
This signal is emitted when a notification should be presented to the
+user. The notification
+ is kept alive until either: 1) the web page cancels it
+or 2) a navigation happens.
The default handler will emit a notification using libnotify, if built with +support for it.
+web_view |
+the WebKitWebView |
++ |
notification |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.8
+“submit-form” signalvoid +user_function (WebKitWebView *web_view, + WebKitFormSubmissionRequest *request, + gpointer user_data)+
This signal is emitted when a form is about to be submitted. The request
+
+argument passed contains information about the text fields of the form. This
+is typically used to store login information that can be used later to
+pre-fill the form.
+The form will not be submitted until webkit_form_submission_request_submit() is called.
It is possible to handle the form submission request asynchronously, by
+simply calling g_object_ref() on the request
+ argument and calling
+webkit_form_submission_request_submit() when done to continue with the form submission.
+If the last reference is removed on a WebKitFormSubmissionRequest and the
+form has not been submitted, webkit_form_submission_request_submit() will be called.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
request |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“web-process-terminated” signalvoid +user_function (WebKitWebView *web_view, + WebKitWebProcessTerminationReason reason, + gpointer user_data)+
This signal is emitted when the web process terminates abnormally due
+to reason
+.
web_view |
+the WebKitWebView |
++ |
reason |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.20
+| +Top + | + |
+ |
+ |
+ |
+
| struct wpe_view_backend * + | ++webkit_web_view_backend_get_wpe_backend () + | +
| +WebKitWebViewBackend * + | ++webkit_web_view_backend_new () + | +
| #define | +WEBKIT_TYPE_WEB_VIEW_BACKEND | +
| + | WebKitWebViewBackend | +
A WebKitWebViewBackend is a boxed type wrapping a WPE backend used to create a
+WebKitWebView. A WebKitWebViewBackend is created with webkit_web_view_backend_new()
+and it should be passed to a WebKitWebView constructor that will take the ownership.
struct wpe_view_backend *
+webkit_web_view_backend_get_wpe_backend
+ (WebKitWebViewBackend *view_backend);
+Get the WPE backend of view_backend
+
Since: 2.20
+WebKitWebViewBackend * +webkit_web_view_backend_new (+struct wpe_view_backend *backend, +GDestroyNotify notify, +gpointer user_data);
Create a new WebKitWebViewBackend for the given WPE backend
+. You can pass a GDestroyNotify
+that will be called when the object is destroyed passing user_data
+ as the argument. If notify
+
+is NULL, wpe_view_backend_destroy() will be used with backend
+ as argument.
+The returned WebKitWebViewBackend should never be freed by the user; it must be passed to a
+WebKitWebView constructor that will take the ownership.
backend |
+a wpe_view_backend. |
+[transfer full] | +
notify |
+a GDestroyNotify, or |
+[nullable] | +
user_data |
+user data to pass to |
++ |
Since: 2.20
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitWebsiteData * + | ++webkit_website_data_ref () + | +
| +void + | ++webkit_website_data_unref () + | +
| const char * + | ++webkit_website_data_get_name () + | +
| +WebKitWebsiteDataTypes + | ++webkit_website_data_get_types () + | +
| +guint64 + | ++webkit_website_data_get_size () + | +
WebKitWebsiteData represents data stored in the client by a particular website.
+A website is normally a set of URLs grouped by domain name. You can get the website name,
+which is usually the domain, with webkit_website_data_get_name().
+Documents loaded from the file system, like file:// URIs, are all grouped in the same WebKitWebsiteData
+with the name "Local files".
A website can store different types of data in the client side. WebKitWebsiteDataTypes is an enum containing
+all the possible data types; use webkit_website_data_get_types() to get the bitmask of data types.
+It's also possible to know the size of the data stored for some of the WebKitWebsiteDataTypes by using
+webkit_website_data_get_size().
A list of WebKitWebsiteData can be retrieved with webkit_website_data_manager_fetch(). See WebKitWebsiteDataManager
+for more information.
WebKitWebsiteData *
+webkit_website_data_ref (WebKitWebsiteData *website_data);
+Atomically increments the reference count of website_data
+ by one.
+This function is MT-safe and may be called from any thread.
Since: 2.16
+void
+webkit_website_data_unref (WebKitWebsiteData *website_data);
+Atomically decrements the reference count of website_data
+ by one.
+If the reference count drops to 0, all memory allocated by
+WebKitWebsiteData is released. This function is MT-safe and may be
+called from any thread.
Since: 2.16
+const char *
+webkit_website_data_get_name (WebKitWebsiteData *website_data);
+Gets the name of WebKitWebsiteData. This is the website name, normally represented by +a domain or host name. All local documents are grouped in the same WebKitWebsiteData using +the name "Local files".
+ + +Since: 2.16
+WebKitWebsiteDataTypes
+webkit_website_data_get_types (WebKitWebsiteData *website_data);
+Gets the types of data stored in the client for a WebKitWebsiteData. These are the
+types actually present, not the types queried with webkit_website_data_manager_fetch().
Since: 2.16
+guint64 +webkit_website_data_get_size (+WebKitWebsiteData *website_data, +WebKitWebsiteDataTypes types);
Gets the size of the data of types types
+ in a WebKitWebsiteData.
+Note that currently the data size is only known for WEBKIT_WEBSITE_DATA_DISK_CACHE data type
+so for all other types 0 will be returned.
website_data |
++ | + |
types |
+a bitmask of WebKitWebsiteDataTypes |
++ |
Since: 2.16
+Enum values with flags representing types of Website data.
+| + |
+ Memory cache. + |
++ |
| + |
+ HTTP disk cache. + |
++ |
| + |
+ Offline web application cache. + |
++ |
| + |
+ Session storage data. + |
++ |
| + |
+ Local storage data. + |
++ |
| + |
+ WebSQL databases. + |
++ |
| + |
+ IndexedDB databases. + |
++ |
| + |
+ Plugins data. + |
++ |
| + |
+ Cookies. + |
++ |
| + |
+ Hash salt used to generate the device ids used by webpages. Since 2.24 + |
++ |
| + |
+ All types. + |
++ |
Since: 2.16
+| +Top + | + |
+ |
+ |
+ |
+
| +gchar * | +base-cache-directory | +Read / Write / Construct Only | +
| +gchar * | +base-data-directory | +Read / Write / Construct Only | +
| +gchar * | +disk-cache-directory | +Read / Write / Construct Only | +
| +gchar * | +indexeddb-directory | +Read / Write / Construct Only | +
| gboolean | +is-ephemeral | +Read / Write / Construct Only | +
| +gchar * | +local-storage-directory | +Read / Write / Construct Only | +
| +gchar * | +offline-application-cache-directory | +Read / Write / Construct Only | +
| +gchar * | +websql-directory | +Read / Write / Construct Only | +
WebKitWebsiteDataManager allows you to manage the data that websites
+can store in the client file system like databases or caches.
+You can use WebKitWebsiteDataManager to configure the local directories
+where the Website data will be stored, by creating a new manager with
+webkit_website_data_manager_new() passing the values you want to set.
+You can set all the possible configuration values or only some of them,
+a default value will be used automatically for the configuration options
+not provided. “base-data-directory” and
+“base-cache-directory” are two special properties
+that can be used to set a common base directory for all Website data and
+caches. It's possible to provide both, a base directory and a specific value,
+but in that case, the specific value takes precedence over the base directory.
+The newly created WebKitWebsiteDataManager must be passed as a construct property
+to a WebKitWebContext, you can use webkit_web_context_new_with_website_data_manager()
+to create a new WebKitWebContext with a WebKitWebsiteDataManager.
+In case you don't want to set any specific configuration, you don't need to create
+a WebKitWebsiteDataManager, the WebKitWebContext will create a WebKitWebsiteDataManager
+with the default configuration. To get the WebKitWebsiteDataManager of a WebKitWebContext
+you can use webkit_web_context_get_website_data_manager().
A WebKitWebsiteDataManager can also be ephemeral and then all the directories configuration
+is not needed because website data will never persist. You can create an ephemeral WebKitWebsiteDataManager
+with webkit_website_data_manager_new_ephemeral(). Then you can pass an ephemeral WebKitWebsiteDataManager to
+a WebKitWebContext to make it ephemeral or use webkit_web_context_new_ephemeral() and the WebKitWebsiteDataManager
+will be automatically created by the WebKitWebContext.
WebKitWebsiteDataManager can also be used to fetch websites data, remove data +stored by particular websites, or clear data for all websites modified since a given +period of time.
+WebKitWebsiteDataManager * +webkit_website_data_manager_new (+const gchar *first_option_name, +...);
Creates a new WebKitWebsiteDataManager with the given options. It must +be passed as construction parameter of a WebKitWebContext.
+first_option_name |
+name of the first option to set |
++ |
... |
+value of first option, followed by more options, |
++ |
Since: 2.10
+WebKitWebsiteDataManager *
+webkit_website_data_manager_new_ephemeral
+ (void);
+Creates an ephemeral WebKitWebsiteDataManager. See “is-ephemeral” for more details.
+ +Since: 2.16
+gboolean
+webkit_website_data_manager_is_ephemeral
+ (WebKitWebsiteDataManager *manager);
+Get whether a WebKitWebsiteDataManager is ephemeral. See “is-ephemeral” for more details.
+ + +Since: 2.16
+const gchar *
+webkit_website_data_manager_get_base_data_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “base-data-directory” property.
+ +the base directory for Website data, or NULL if
+“base-data-directory” was not provided or manager
+is ephemeral.
[allow-none]
+Since: 2.10
+const gchar *
+webkit_website_data_manager_get_base_cache_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “base-cache-directory” property.
+ +the base directory for Website cache, or NULL if
+“base-cache-directory” was not provided or manager
+is ephemeral.
[allow-none]
+Since: 2.10
+const gchar *
+webkit_website_data_manager_get_local_storage_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “local-storage-directory” property.
+ +the directory where local storage data is stored or NULL if manager
+is ephemeral.
[allow-none]
+Since: 2.10
+const gchar *
+webkit_website_data_manager_get_disk_cache_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “disk-cache-directory” property.
+ +the directory where HTTP disk cache is stored or NULL if manager
+is ephemeral.
[allow-none]
+Since: 2.10
+const gchar *
+webkit_website_data_manager_get_offline_application_cache_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “offline-application-cache-directory” property.
+ +the directory where offline web application cache is stored or NULL if manager
+is ephemeral.
[allow-none]
+Since: 2.10
+const gchar *
+webkit_website_data_manager_get_indexeddb_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “indexeddb-directory” property.
+ +the directory where IndexedDB databases are stored or NULL if manager
+is ephemeral.
[allow-none]
+Since: 2.10
+const gchar *
+webkit_website_data_manager_get_websql_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “websql-directory” property.
+ +the directory where WebSQL databases are stored or NULL if manager
+is ephemeral.
[allow-none]
+Since: 2.10
+WebKitCookieManager *
+webkit_website_data_manager_get_cookie_manager
+ (WebKitWebsiteDataManager *manager);
+Get the WebKitCookieManager of manager
+.
Since: 2.16
+void +webkit_website_data_manager_fetch (+WebKitWebsiteDataManager *manager, +WebKitWebsiteDataTypes types, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously get the list of WebKitWebsiteData for the given types
+.
When the operation is finished, callback
+ will be called. You can then call
+webkit_website_data_manager_fetch_finish() to get the result of the operation.
manager |
++ | + |
types |
++ | + |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.16
+GList * +webkit_website_data_manager_fetch_finish + (+WebKitWebsiteDataManager *manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_website_data_manager_fetch().
manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
a GList of WebKitWebsiteData. You must free the GList with
+g_list_free() and unref the WebKitWebsiteDatas with webkit_website_data_unref() when you're done with them.
[element-type WebKitWebsiteData][transfer full]
+Since: 2.16
+void +webkit_website_data_manager_remove (+WebKitWebsiteDataManager *manager, +WebKitWebsiteDataTypes types, +GList *website_data, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously removes the website data of the for the given types
+ for websites in the given website_data
+ list.
+Use webkit_website_data_manager_clear() if you want to remove the website data for all sites.
When the operation is finished, callback
+ will be called. You can then call
+webkit_website_data_manager_remove_finish() to get the result of the operation.
manager |
++ | + |
types |
++ | + |
website_data |
+a GList of WebKitWebsiteData. |
+[element-type WebKitWebsiteData] | +
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.16
+gboolean +webkit_website_data_manager_remove_finish + (+WebKitWebsiteDataManager *manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_website_data_manager_remove().
manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
Since: 2.16
+void +webkit_website_data_manager_clear (+WebKitWebsiteDataManager *manager, +WebKitWebsiteDataTypes types, +GTimeSpan timespan, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously clear the website data of the given types
+ modified in the past timespan
+.
+If timespan
+ is 0, all website data will be removed.
When the operation is finished, callback
+ will be called. You can then call
+webkit_website_data_manager_clear_finish() to get the result of the operation.
Due to implementation limitations, this function does not currently delete
+any stored cookies if timespan
+ is nonzero. This behavior may change in the
+future.
manager |
++ | + |
types |
++ | + |
timespan |
++ | + |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.16
+gboolean +webkit_website_data_manager_clear_finish + (+WebKitWebsiteDataManager *manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_website_data_manager_clear()
manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
Since: 2.16
+“base-cache-directory” property“base-cache-directory” gchar *+
The base directory for Website cache. This is used as a base directory +for any Website cache when no specific cache directory has been provided.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+“base-data-directory” property“base-data-directory” gchar *+
The base directory for Website data. This is used as a base directory +for any Website data when no specific data directory has been provided.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+“disk-cache-directory” property“disk-cache-directory” gchar *+
The directory where HTTP disk cache will be stored.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+“indexeddb-directory” property“indexeddb-directory” gchar *+
The directory where IndexedDB databases will be stored.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+“is-ephemeral” property“is-ephemeral” gboolean+
Whether the WebKitWebsiteDataManager is ephemeral. An ephemeral WebKitWebsiteDataManager +handles all websites data as non-persistent, and nothing will be written to the client +storage. Note that if you create an ephemeral WebKitWebsiteDataManager all other construction +parameters to configure data directories will be ignored.
+Flags: Read / Write / Construct Only
+Default value: FALSE
+Since: 2.16
+“local-storage-directory” property“local-storage-directory” gchar *+
The directory where local storage data will be stored.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+“offline-application-cache-directory” property“offline-application-cache-directory” gchar *+
The directory where offline web application cache will be stored.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+“websql-directory” property“websql-directory” gchar *+
The directory where WebSQL databases will be stored.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitWindowProperties+WebKitWindowProperties — Window properties of a WebKitWebView + |
++ |
| +gboolean + | ++webkit_window_properties_get_toolbar_visible () + | +
| +gboolean + | ++webkit_window_properties_get_statusbar_visible () + | +
| +gboolean + | ++webkit_window_properties_get_scrollbars_visible () + | +
| +gboolean + | ++webkit_window_properties_get_menubar_visible () + | +
| +gboolean + | ++webkit_window_properties_get_locationbar_visible () + | +
| +gboolean + | ++webkit_window_properties_get_resizable () + | +
| +gboolean + | ++webkit_window_properties_get_fullscreen () + | +
| gboolean | +fullscreen | +Read / Write / Construct Only | +
| gboolean | +locationbar-visible | +Read / Write / Construct Only | +
| gboolean | +menubar-visible | +Read / Write / Construct Only | +
| gboolean | +resizable | +Read / Write / Construct Only | +
| gboolean | +scrollbars-visible | +Read / Write / Construct Only | +
| gboolean | +statusbar-visible | +Read / Write / Construct Only | +
| gboolean | +toolbar-visible | +Read / Write / Construct Only | +
The content of a WebKitWebView can request to change certain +properties of the window containing the view. This can include the x, y position +of the window, the width and height but also if a toolbar, +scrollbar, statusbar, locationbar should be visible to the user, +and the request to show the WebKitWebView fullscreen.
+The “ready-to-show” signal handler is the proper place +to apply the initial window properties. Then you can monitor the +WebKitWindowProperties by connecting to ::notify signal.
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 |
+ static void ready_to_show_cb (WebKitWebView *web_view, gpointer user_data) +{ + GtkWidget *window; + WebKitWindowProperties *window_properties; + gboolean visible; + + /* Create the window to contain the WebKitWebView */ + window = browser_window_new (); + gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (web_view)); + gtk_widget_show (GTK_WIDGET (web_view)); + + /* Get the WebKitWindowProperties of the web view and monitor it */ + window_properties = webkit_web_view_get_window_properties (web_view); + g_signal_connect (window_properties, "notify::geometry", + G_CALLBACK (window_geometry_changed), window); + g_signal_connect (window_properties, "notify::toolbar-visible", + G_CALLBACK (window_toolbar_visibility_changed), window); + g_signal_connect (window_properties, "notify::menubar-visible", + G_CALLBACK (window_menubar_visibility_changed), window); + .... + + /* Apply the window properties before showing the window */ + visible = webkit_window_properties_get_toolbar_visible (window_properties); + browser_window_set_toolbar_visible (BROWSER_WINDOW (window), visible); + visible = webkit_window_properties_get_menubar_visible (window_properties); + browser_window_set_menubar_visible (BROWSER_WINDOW (window), visible); + .... + + if (webkit_window_properties_get_fullscreen (window_properties)) { + gtk_window_fullscreen (GTK_WINDOW (window)); + } else { + GdkRectangle geometry; + + gtk_window_set_resizable (GTK_WINDOW (window), + webkit_window_properties_get_resizable (window_properties)); + webkit_window_properties_get_geometry (window_properties, &geometry); + gtk_window_move (GTK_WINDOW (window), geometry.x, geometry.y); + gtk_window_resize (GTK_WINDOW (window), geometry.width, geometry.height); + } + + gtk_widget_show (window); +} |
+
gboolean
+webkit_window_properties_get_toolbar_visible
+ (WebKitWindowProperties *window_properties);
+Get whether the window should have the toolbar visible or not.
+ + +gboolean
+webkit_window_properties_get_statusbar_visible
+ (WebKitWindowProperties *window_properties);
+Get whether the window should have the statusbar visible or not.
+ + +gboolean
+webkit_window_properties_get_scrollbars_visible
+ (WebKitWindowProperties *window_properties);
+Get whether the window should have the scrollbars visible or not.
+ + +gboolean
+webkit_window_properties_get_menubar_visible
+ (WebKitWindowProperties *window_properties);
+Get whether the window should have the menubar visible or not.
+ + +gboolean
+webkit_window_properties_get_locationbar_visible
+ (WebKitWindowProperties *window_properties);
+Get whether the window should have the locationbar visible or not.
+ + +gboolean
+webkit_window_properties_get_resizable
+ (WebKitWindowProperties *window_properties);
+Get whether the window should be resizable by the user or not.
+ + +gboolean
+webkit_window_properties_get_fullscreen
+ (WebKitWindowProperties *window_properties);
+Get whether the window should be shown in fullscreen state or not.
+ + +“fullscreen” property“fullscreen” gboolean+
Whether window will be displayed fullscreen.
+Flags: Read / Write / Construct Only
+Default value: FALSE
+“locationbar-visible” property“locationbar-visible” gboolean+
Whether the locationbar should be visible for the window.
+Flags: Read / Write / Construct Only
+Default value: TRUE
+“menubar-visible” property“menubar-visible” gboolean+
Whether the menubar should be visible for the window.
+Flags: Read / Write / Construct Only
+Default value: TRUE
+“resizable” property“resizable” gboolean+
Whether the window can be resized.
+Flags: Read / Write / Construct Only
+Default value: TRUE
+“scrollbars-visible” property“scrollbars-visible” gboolean+
Whether the scrollbars should be visible for the window.
+Flags: Read / Write / Construct Only
+Default value: TRUE
+“statusbar-visible” property“statusbar-visible” gboolean+
Whether the statusbar should be visible for the window.
+Flags: Read / Write / Construct Only
+Default value: TRUE
+“toolbar-visible” property“toolbar-visible” gboolean+
Whether the toolbar should be visible for the window.
+Flags: Read / Write / Construct Only
+Default value: TRUE
+| + | |
+ |
+ |
+ |
+
NULL is OK, both for passing and for returning.
Parameter points to an array of items.
This parameter is a 'user_data', for callbacks; many bindings can pass NULL here.
Generics and defining elements of containers and arrays.
NULL may be passed as the value in, out, in-out; or as a return value.
NULL may be passed instead of a pointer to a location.
Parameter for returning results. Default is transfer full.
The callback is valid until first called.
Free data container after the code is done.
Free data after the code is done.
Don't free data after the code is done.
| + | |
+ |
+ |
+ |
+
| + | |
+ |
+ |
+ |
+
| + | |
+ |
+ |
+ |
+
WPE Reference Manual |
|---|
for WPE WebKit 2.23.90
| +Top + | + |
+ |
+ |
+ |
+
| +GQuark + | ++webkit_network_error_quark () + | +
| +GQuark + | ++webkit_plugin_error_quark () + | +
| +GQuark + | ++webkit_policy_error_quark () + | +
| +GQuark + | ++webkit_download_error_quark () + | +
| +GQuark + | ++webkit_javascript_error_quark () + | +
| +GQuark + | ++webkit_snapshot_error_quark () + | +
| +GQuark + | ++webkit_user_content_filter_error_quark () + | +
| #define | +WEBKIT_NETWORK_ERROR | +
| #define | +WEBKIT_PLUGIN_ERROR | +
| #define | +WEBKIT_POLICY_ERROR | +
| #define | +WEBKIT_DOWNLOAD_ERROR | +
| #define | +WEBKIT_JAVASCRIPT_ERROR | +
| #define | +WEBKIT_SNAPSHOT_ERROR | +
| #define | +WEBKIT_USER_CONTENT_FILTER_ERROR | +
| enum | +WebKitNetworkError | +
| enum | +WebKitPluginError | +
| enum | +WebKitPolicyError | +
| enum | +WebKitDownloadError | +
| enum | +WebKitJavascriptError | +
| enum | +WebKitSnapshotError | +
| enum | +WebKitUserContentFilterError | +
GQuark
+webkit_user_content_filter_error_quark
+ (void);
+#define WEBKIT_USER_CONTENT_FILTER_ERROR webkit_user_content_filter_error_quark () ++
Enum values used to denote the various network errors.
+ +Enum values used to denote the various plugin errors.
+| + |
+ Generic plugin load failure + |
++ |
| + |
+ Load failure due to missing plugin + |
++ |
| + |
+ Load failure due to inability to load plugin + |
++ |
| + |
+ Load failure due to missing Java support that is required to load plugin + |
++ |
| + |
+ Load failure due to connection cancellation + |
++ |
| + |
+ Load failure since plugin handles the load + |
++ |
Enum values used to denote the various policy errors.
+| + |
+ Generic load failure due to policy error + |
++ |
| + |
+ Load failure due to unsupported mime type + |
++ |
| + |
+ Load failure due to URI that can not be shown + |
++ |
| + |
+ Load failure due to frame load interruption by policy change + |
++ |
| + |
+ Load failure due to port restriction + |
++ |
Enum values used to denote errors happening when executing JavaScript
+ +Enum values used to denote errors happening when creating snapshots of WebKitWebView
+ +| +Top + | + |
+ |
+ |
+ |
+
gchar *
+webkit_uri_for_display (const gchar *uri);
+Use this function to format a URI for display. The URIs used internally by +WebKit may contain percent-encoded characters or Punycode, which are not +generally suitable to display to users. This function provides protection +against IDN homograph attacks, so in some cases the host part of the returned +URI may be in Punycode if the safety check fails.
+ + +Since: 2.24
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitUserStyleSheet * + | ++webkit_user_style_sheet_ref () + | +
| +void + | ++webkit_user_style_sheet_unref () + | +
| +WebKitUserStyleSheet * + | ++webkit_user_style_sheet_new () + | +
| +WebKitUserStyleSheet * + | ++webkit_user_style_sheet_new_for_world () + | +
| +WebKitUserScript * + | ++webkit_user_script_ref () + | +
| +void + | ++webkit_user_script_unref () + | +
| +WebKitUserScript * + | ++webkit_user_script_new () + | +
| +WebKitUserScript * + | ++webkit_user_script_new_for_world () + | +
| +WebKitUserContentFilter * + | ++webkit_user_content_filter_ref () + | +
| +void + | ++webkit_user_content_filter_unref () + | +
| const char * + | ++webkit_user_content_filter_get_identifier () + | +
| + | WebKitUserStyleSheet | +
| + | WebKitUserScript | +
| enum | +WebKitUserContentInjectedFrames | +
| enum | +WebKitUserStyleLevel | +
| enum | +WebKitUserScriptInjectionTime | +
| + | WebKitUserContentFilter | +
GBoxed + ├── WebKitUserContentFilter + ├── WebKitUserScript + ╰── WebKitUserStyleSheet ++
WebKitUserStyleSheet *
+webkit_user_style_sheet_ref (WebKitUserStyleSheet *user_style_sheet);
+Atomically increments the reference count of user_style_sheet
+ by one.
+This function is MT-safe and may be called from any thread.
Since: 2.6
+void
+webkit_user_style_sheet_unref (WebKitUserStyleSheet *user_style_sheet);
+Atomically decrements the reference count of user_style_sheet
+ by one.
+If the reference count drops to 0, all memory allocated by
+WebKitUserStyleSheet is released. This function is MT-safe and may be
+called from any thread.
Since: 2.6
+WebKitUserStyleSheet * +webkit_user_style_sheet_new (+const gchar *source, +WebKitUserContentInjectedFrames injected_frames, +WebKitUserStyleLevel level, +const gchar * const *whitelist, +const gchar * const *blacklist);
Creates a new user style sheet. Style sheets can be applied to some URIs
+only by passing non-null values for whitelist
+ or blacklist
+. Passing a
+NULL whitelist implies that all URIs are on the whitelist. The style
+sheet is applied if an URI matches the whitelist and not the blacklist.
+URI patterns must be of the form [protocol]://[host]/[path], where the
+*host* and *path* components can contain the wildcard character (*) to
+represent zero or more other characters.
source |
+Source code of the user style sheet. |
++ |
injected_frames |
+A WebKitUserContentInjectedFrames value |
++ |
level |
++ | + |
whitelist |
+A whitelist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
blacklist |
+A blacklist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
Since: 2.6
+WebKitUserStyleSheet * +webkit_user_style_sheet_new_for_world (+const gchar *source, +WebKitUserContentInjectedFrames injected_frames, +WebKitUserStyleLevel level, +const gchar *world_name, +const gchar * const *whitelist, +const gchar * const *blacklist);
Creates a new user style sheet for script world with name world_name
+.
+See webkit_user_style_sheet_new() for a full description.
source |
+Source code of the user style sheet. |
++ |
injected_frames |
+A WebKitUserContentInjectedFrames value |
++ |
level |
++ | + |
world_name |
+the name of a WebKitScriptWorld |
++ |
whitelist |
+A whitelist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
blacklist |
+A blacklist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
Since: 2.22
+WebKitUserScript *
+webkit_user_script_ref (WebKitUserScript *user_script);
+Atomically increments the reference count of user_script
+ by one.
+This function is MT-safe and may be called from any thread.
Since: 2.6
+void
+webkit_user_script_unref (WebKitUserScript *user_script);
+Atomically decrements the reference count of user_script
+ by one.
+If the reference count drops to 0, all memory allocated by
+WebKitUserScript is released. This function is MT-safe and may be called
+from any thread.
Since: 2.6
+WebKitUserScript * +webkit_user_script_new (+const gchar *source, +WebKitUserContentInjectedFrames injected_frames, +WebKitUserScriptInjectionTime injection_time, +const gchar * const *whitelist, +const gchar * const *blacklist);
Creates a new user script. Scripts can be applied to some URIs
+only by passing non-null values for whitelist
+ or blacklist
+. Passing a
+NULL whitelist implies that all URIs are on the whitelist. The script
+is applied if an URI matches the whitelist and not the blacklist.
+URI patterns must be of the form [protocol]://[host]/[path], where the
+*host* and *path* components can contain the wildcard character (*) to
+represent zero or more other characters.
source |
+Source code of the user script. |
++ |
injected_frames |
+A WebKitUserContentInjectedFrames value |
++ |
injection_time |
+A WebKitUserScriptInjectionTime value |
++ |
whitelist |
+A whitelist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
blacklist |
+A blacklist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
Since: 2.6
+WebKitUserScript * +webkit_user_script_new_for_world (+const gchar *source, +WebKitUserContentInjectedFrames injected_frames, +WebKitUserScriptInjectionTime injection_time, +const gchar *world_name, +const gchar * const *whitelist, +const gchar * const *blacklist);
Creates a new user script for script world with name world_name
+.
+See webkit_user_script_new() for a full description.
source |
+Source code of the user script. |
++ |
injected_frames |
+A WebKitUserContentInjectedFrames value |
++ |
injection_time |
+A WebKitUserScriptInjectionTime value |
++ |
world_name |
+the name of a WebKitScriptWorld |
++ |
whitelist |
+A whitelist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
blacklist |
+A blacklist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
Since: 2.22
+WebKitUserContentFilter *
+webkit_user_content_filter_ref (WebKitUserContentFilter *user_content_filter);
+Atomically increments the reference count of user_content_filter
+ by one.
+This function is MT-safe and may be called from any thread.
Since: 2.24
+void
+webkit_user_content_filter_unref (WebKitUserContentFilter *user_content_filter);
+Atomically decrements the reference count of user_content_filter
+ by one.
+If the reference count drops to 0, all the memory allocated by the
+WebKitUserContentFilter is released. This function is MT-safe and may
+be called from any thread.
Since: 2.24
+const char *
+webkit_user_content_filter_get_identifier
+ (WebKitUserContentFilter *user_content_filter);
+Obtain the identifier previously used to save the user_content_filter
+ in the
+WebKitUserContentFilterStore.
Since: 2.24
+Specifies in which frames user style sheets are to be inserted in.
+| + |
+ Insert the user style + sheet in all the frames loaded by the web view, including + nested frames. This is the default. + |
++ |
| + |
+ Insert the user style + sheet *only* in the top-level frame loaded by the web view, + and *not* in the nested frames. + |
++ |
Since: 2.6
+Specifies how to treat an user style sheet.
+| + |
+ The style sheet is an user style sheet, + its contents always override other style sheets. This is the default. + |
++ |
| + |
+ The style sheet will be treated as if + it was provided by the loaded documents. That means other user style + sheets may still override it. + |
++ |
Since: 2.6
+Specifies at which place of documents an user script will be inserted.
+ +Since: 2.6
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitApplicationInfo * + | ++webkit_application_info_new () + | +
| +WebKitApplicationInfo * + | ++webkit_application_info_ref () + | +
| +void + | ++webkit_application_info_unref () + | +
| +void + | ++webkit_application_info_set_name () + | +
| const gchar * + | ++webkit_application_info_get_name () + | +
| +void + | ++webkit_application_info_set_version () + | +
| +void + | ++webkit_application_info_get_version () + | +
WebKitApplicationInfo *
+webkit_application_info_new (void);
+Creates a new WebKitApplicationInfo
+ +Since: 2.18
+WebKitApplicationInfo *
+webkit_application_info_ref (WebKitApplicationInfo *info);
+Atomically increments the reference count of info
+ by one. This
+function is MT-safe and may be called from any thread.
Since: 2.18
+void
+webkit_application_info_unref (WebKitApplicationInfo *info);
+Atomically decrements the reference count of info
+ by one. If the
+reference count drops to 0, all memory allocated by the WebKitApplicationInfo is
+released. This function is MT-safe and may be called from any
+thread.
Since: 2.18
+void +webkit_application_info_set_name (+WebKitApplicationInfo *info, +const gchar *name);
Set the name of the application. If not provided, or NULL is passed,
+g_get_prgname() will be used.
Since: 2.18
+const gchar *
+webkit_application_info_get_name (WebKitApplicationInfo *info);
+Get the name of the application. If webkit_application_info_set_name() hasn't been
+called with a valid name, this returns g_get_prgname().
Since: 2.18
+void +webkit_application_info_set_version (+WebKitApplicationInfo *info, +guint64 major, +guint64 minor, +guint64 micro);
Set the application version. If the application doesn't use the format +major.minor.micro you can pass 0 as the micro to use major.minor, or pass +0 as both micro and minor to use only major number. Any other format must +be converted to major.minor.micro so that it can be used in version comparisons.
+info |
++ | + |
major |
+the major version number |
++ |
minor |
+the minor version number |
++ |
micro |
+the micro version number |
++ |
Since: 2.18
+void +webkit_application_info_get_version (+WebKitApplicationInfo *info, +guint64 *major, +guint64 *minor, +guint64 *micro);
Get the application version previously set with webkit_application_info_set_version().
info |
++ | + |
major |
+return location for the major version number. |
+[out] | +
minor |
+return location for the minor version number. |
+[out][allow-none] | +
micro |
+return location for the micro version number. |
+[out][allow-none] | +
Since: 2.18
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitAuthenticationRequest+WebKitAuthenticationRequest — Represents an authentication request + |
++ |
| struct | +WebKitAuthenticationRequest | +
| enum | +WebKitAuthenticationScheme | +
| + | WebKitCredential | +
| enum | +WebKitCredentialPersistence | +
Whenever a client attempts to load a page protected by HTTP +authentication, credentials will need to be provided to authorize access. +To allow the client to decide how it wishes to handle authentication, +WebKit will fire a “authenticate” signal with a +WebKitAuthenticationRequest object to provide client side +authentication support. Credentials are exposed through the +WebKitCredential object.
+In case the client application does not wish +to handle this signal WebKit will provide a default handler. To handle +authentication asynchronously, simply increase the reference count of the +WebKitAuthenticationRequest object.
+void +webkit_authentication_request_authenticate + (+WebKitAuthenticationRequest *request, +WebKitCredential *credential);
Authenticate the WebKitAuthenticationRequest using the WebKitCredential
+supplied. To continue without credentials, pass NULL as credential
+.
request |
++ | + |
credential |
+A WebKitCredential, or |
+[transfer none][allow-none] | +
Since: 2.2
+void
+webkit_authentication_request_cancel (WebKitAuthenticationRequest *request);
+Cancel the authentication challenge. This will also cancel the page loading and result in a
+“load-failed” signal with a WebKitNetworkError of type WEBKIT_NETWORK_ERROR_CANCELLED being emitted.
Since: 2.2
+gboolean
+webkit_authentication_request_can_save_credentials
+ (WebKitAuthenticationRequest *request);
+Determine whether the authentication method associated with this
+WebKitAuthenticationRequest should allow the storage of credentials.
+This will return FALSE if WebKit doesn't support credential storing
+or if private browsing is enabled.
Since: 2.2
+const gchar *
+webkit_authentication_request_get_host
+ (WebKitAuthenticationRequest *request);
+Get the host that this authentication challenge is applicable to.
+ + +Since: 2.2
+guint
+webkit_authentication_request_get_port
+ (WebKitAuthenticationRequest *request);
+Get the port that this authentication challenge is applicable to.
+ + +Since: 2.2
+gboolean
+webkit_authentication_request_is_retry
+ (WebKitAuthenticationRequest *request);
+Determine whether this this is a first attempt or a retry for this authentication challenge.
+ + +Since: 2.2
+WebKitCredential *
+webkit_authentication_request_get_proposed_credential
+ (WebKitAuthenticationRequest *request);
+Get the WebKitCredential of the proposed authentication challenge that was +stored from a previous session. The client can use this directly for +authentication or construct their own WebKitCredential.
+ +A WebKitCredential encapsulating credential details
+or NULL if there is no stored credential.
[transfer full]
+Since: 2.2
+const gchar *
+webkit_authentication_request_get_realm
+ (WebKitAuthenticationRequest *request);
+Get the realm that this authentication challenge is applicable to.
+ + +Since: 2.2
+WebKitAuthenticationScheme
+webkit_authentication_request_get_scheme
+ (WebKitAuthenticationRequest *request);
+Get the authentication scheme of the authentication challenge.
+ + +Since: 2.2
+gboolean
+webkit_authentication_request_is_for_proxy
+ (WebKitAuthenticationRequest *request);
+Determine whether the authentication challenge is associated with a proxy server rather than an "origin" server.
+ + +Since: 2.2
+WebKitCredential * +webkit_credential_new (+const gchar *username, +const gchar *password, +WebKitCredentialPersistence persistence);
Create a new credential from the provided username, password and persistence mode.
+username |
+The username for the new credential |
++ |
password |
+The password for the new credential |
++ |
persistence |
+The WebKitCredentialPersistence of the new credential |
++ |
Since: 2.2
+WebKitCredential *
+webkit_credential_copy (WebKitCredential *credential);
+Make a copy of the WebKitCredential.
+ + +Since: 2.2
+void
+webkit_credential_free (WebKitCredential *credential);
+Free the WebKitCredential.
+ +Since: 2.2
+const gchar *
+webkit_credential_get_password (WebKitCredential *credential);
+Get the password currently held by this WebKitCredential.
+ + +Since: 2.2
+WebKitCredentialPersistence
+webkit_credential_get_persistence (WebKitCredential *credential);
+Get the persistence mode currently held by this WebKitCredential.
+ + +Since: 2.2
+const gchar *
+webkit_credential_get_username (WebKitCredential *credential);
+Get the username currently held by this WebKitCredential.
+ + +Since: 2.2
+gboolean
+webkit_credential_has_password (WebKitCredential *credential);
+Determine whether this credential has a password stored.
+ + +Since: 2.2
+Enum values representing the authentication scheme.
+Since: 2.2
+“cancelled” signalvoid +user_function (WebKitAuthenticationRequest *request, + gpointer user_data)+
This signal is emitted when the user authentication request is +cancelled. It allows the application to dismiss its authentication +dialog in case of page load failure for example.
+request |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.2
+| +Top + | + |
+ |
+ |
+ |
+
| const char * + | ++webkit_automation_session_get_id () + | +
| +void + | ++webkit_automation_session_set_application_info () + | +
| +WebKitApplicationInfo * + | ++webkit_automation_session_get_application_info () + | +
WebKitAutomationSession represents an automation session of a WebKitWebContext. +When a new session is requested, a WebKitAutomationSession is created and the signal +WebKitWebContext::automation-started is emitted with the WebKitAutomationSession as +argument. Then, the automation client can request the session to create a new +WebKitWebView to interact with it. When this happens the signal “create-web-view” +is emitted.
+const char *
+webkit_automation_session_get_id (WebKitAutomationSession *session);
+Get the unique identifier of a WebKitAutomationSession
+ + +Since: 2.18
+void +webkit_automation_session_set_application_info + (+WebKitAutomationSession *session, +WebKitApplicationInfo *info);
Set the application information to session
+. This information will be used by the driver service
+to match the requested capabilities with the actual application information. If this information
+is not provided to the session when a new automation session is requested, the creation might fail
+if the client requested a specific browser name or version. This will not have any effect when called
+after the automation session has been fully created, so this must be called in the callback of
+“automation-started” signal.
Since: 2.18
+WebKitApplicationInfo *
+webkit_automation_session_get_application_info
+ (WebKitAutomationSession *session);
+Get the WebKitAutomationSession previously set with webkit_automation_session_set_application_info().
the WebKitAutomationSession of session
+, or NULL if no one has been set.
[transfer none]
+Since: 2.18
+“id” property“id” gchar *+
The session unique identifier.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.18
+“create-web-view” signalWebKitWebView* +user_function (WebKitAutomationSession *session, + gpointer user_data)+
This signal is emitted when the automation client requests a new +browsing context to interact with it. The callback handler should +return a WebKitWebView created with “is-controlled-by-automation” +construct property enabled. The returned WebKitWebView could be an existing +web view or a new one created and added to a new tab or window.
+session |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.18
+| +Top + | + |
+ |
+ |
+ |
+
| +guint + | ++webkit_back_forward_list_get_length () + | +
| +WebKitBackForwardListItem * + | ++webkit_back_forward_list_get_current_item () + | +
| +WebKitBackForwardListItem * + | ++webkit_back_forward_list_get_back_item () + | +
| +WebKitBackForwardListItem * + | ++webkit_back_forward_list_get_forward_item () + | +
| +WebKitBackForwardListItem * + | ++webkit_back_forward_list_get_nth_item () + | +
| +GList * + | ++webkit_back_forward_list_get_back_list () + | +
| +GList * + | ++webkit_back_forward_list_get_back_list_with_limit () + | +
| +GList * + | ++webkit_back_forward_list_get_forward_list () + | +
| +GList * + | ++webkit_back_forward_list_get_forward_list_with_limit () + | +
WebKitBackForwardList maintains a list of visited pages used to +navigate to recent pages. Items are inserted in the list in the +order they are visited.
+WebKitBackForwardList also maintains the notion of the current item
+(which is always at index 0), the preceding item (which is at index -1),
+and the following item (which is at index 1).
+Methods webkit_web_view_go_back() and webkit_web_view_go_forward() move
+the current item backward or forward by one. Method
+webkit_web_view_go_to_back_forward_list_item() sets the current item to the
+specified item. All other methods returning WebKitBackForwardListItems
+do not change the value of the current item, they just return the requested
+item or items.
guint
+webkit_back_forward_list_get_length (WebKitBackForwardList *back_forward_list);
+
+
+WebKitBackForwardListItem *
+webkit_back_forward_list_get_current_item
+ (WebKitBackForwardList *back_forward_list);
+Returns the current item in back_forward_list
+.
a WebKitBackForwardListItem
+or NULL if back_forward_list
+is empty.
[nullable][transfer none]
+WebKitBackForwardListItem *
+webkit_back_forward_list_get_back_item
+ (WebKitBackForwardList *back_forward_list);
+Returns the item that precedes the current item.
+ +the WebKitBackForwardListItem
+preceding the current item or NULL.
[nullable][transfer none]
+WebKitBackForwardListItem *
+webkit_back_forward_list_get_forward_item
+ (WebKitBackForwardList *back_forward_list);
+Returns the item that follows the current item.
+ +the WebKitBackForwardListItem
+following the current item or NULL.
[nullable][transfer none]
+WebKitBackForwardListItem * +webkit_back_forward_list_get_nth_item (+WebKitBackForwardList *back_forward_list, +gint index);
Returns the item at a given index relative to the current item.
+ +the WebKitBackForwardListItem
+located at the specified index relative to the current item or NULL.
[nullable][transfer none]
+GList *
+webkit_back_forward_list_get_back_list
+ (WebKitBackForwardList *back_forward_list);
+
+a GList of +items preceding the current item.
+[element-type WebKit2.BackForwardListItem][transfer container]
+GList * +webkit_back_forward_list_get_back_list_with_limit + (+WebKitBackForwardList *back_forward_list, +guint limit);
back_forward_list |
++ | + |
limit |
+the number of items to retrieve |
++ |
a GList of
+items preceding the current item limited by limit
+.
[element-type WebKit2.BackForwardListItem][transfer container]
+GList *
+webkit_back_forward_list_get_forward_list
+ (WebKitBackForwardList *back_forward_list);
+
+a GList of +items following the current item.
+[element-type WebKit2.BackForwardListItem][transfer container]
+GList * +webkit_back_forward_list_get_forward_list_with_limit + (+WebKitBackForwardList *back_forward_list, +guint limit);
back_forward_list |
++ | + |
limit |
+the number of items to retrieve |
++ |
a GList of
+items following the current item limited by limit
+.
[element-type WebKit2.BackForwardListItem][transfer container]
+“changed” signalvoid +user_function (WebKitBackForwardList *back_forward_list, + WebKitBackForwardListItem *item_added, + gpointer items_removed, + gpointer user_data)+
This signal is emitted when back_forward_list
+ changes. This happens
+when the current item is updated, a new item is added or one or more
+items are removed. Note that both item_added
+ and items_removed
+ can
+NULL when only the current item is updated. Items are only removed
+when the list is cleared or the maximum items limit is reached.
back_forward_list |
+the WebKitBackForwardList on which the signal was emitted |
++ |
item_added |
+the WebKitBackForwardListItem added or |
+[allow-none] | +
items_removed |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitBackForwardListItem+WebKitBackForwardListItem — One item of the WebKitBackForwardList + |
++ |
| const gchar * + | ++webkit_back_forward_list_item_get_title () + | +
| const gchar * + | ++webkit_back_forward_list_item_get_uri () + | +
| const gchar * + | ++webkit_back_forward_list_item_get_original_uri () + | +
A history item is part of the WebKitBackForwardList and consists +out of a title and a URI.
+const gchar *
+webkit_back_forward_list_item_get_title
+ (WebKitBackForwardListItem *list_item);
+
+
+const gchar *
+webkit_back_forward_list_item_get_uri (WebKitBackForwardListItem *list_item);
+This URI may differ from the original URI if the page was,
+for example, redirected to a new location.
+See also webkit_back_forward_list_item_get_original_uri().
const gchar *
+webkit_back_forward_list_item_get_original_uri
+ (WebKitBackForwardListItem *list_item);
+See also webkit_back_forward_list_item_get_uri().
| +Top + | + |
+ |
+ |
+ |
+
+WebKitContextMenu+WebKitContextMenu — Represents the context menu in a WebKitWebView + |
++ |
| +WebKitContextMenu * + | ++webkit_context_menu_new () + | +
| +WebKitContextMenu * + | ++webkit_context_menu_new_with_items () + | +
| +void + | ++webkit_context_menu_prepend () + | +
| +void + | ++webkit_context_menu_append () + | +
| +void + | ++webkit_context_menu_insert () + | +
| +void + | ++webkit_context_menu_move_item () + | +
| +GList * + | ++webkit_context_menu_get_items () + | +
| +guint + | ++webkit_context_menu_get_n_items () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_first () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_last () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_get_item_at_position () + | +
| +void + | ++webkit_context_menu_remove () + | +
| +void + | ++webkit_context_menu_remove_all () + | +
| +void + | ++webkit_context_menu_set_user_data () + | +
| +GVariant * + | ++webkit_context_menu_get_user_data () + | +
WebKitContextMenu represents a context menu containing +WebKitContextMenuItems in a WebKitWebView.
+When a WebKitWebView is about to display the context menu, it
+emits the “context-menu” signal, which has the
+WebKitContextMenu as an argument. You can modify it, adding new
+submenus that you can create with webkit_context_menu_new(), adding
+new WebKitContextMenuItems with
+webkit_context_menu_prepend(), webkit_context_menu_append() or
+webkit_context_menu_insert(), maybe after having removed the
+existing ones with webkit_context_menu_remove_all().
WebKitContextMenu *
+webkit_context_menu_new (void);
+Creates a new WebKitContextMenu object to be used as a submenu of an existing
+WebKitContextMenu. The context menu of a WebKitWebView is created by the view
+and passed as an argument of “context-menu” signal.
+To add items to the menu use webkit_context_menu_prepend(),
+webkit_context_menu_append() or webkit_context_menu_insert().
+See also webkit_context_menu_new_with_items() to create a WebKitContextMenu with
+a list of initial items.
WebKitContextMenu *
+webkit_context_menu_new_with_items (GList *items);
+Creates a new WebKitContextMenu object to be used as a submenu of an existing
+WebKitContextMenu with the given initial items.
+See also webkit_context_menu_new()
items |
+a GList of WebKitContextMenuItem. |
+[element-type WebKitContextMenuItem] | +
void +webkit_context_menu_prepend (+WebKitContextMenu *menu, +WebKitContextMenuItem *item);
Adds item
+ at the beginning of the menu
+.
void +webkit_context_menu_append (+WebKitContextMenu *menu, +WebKitContextMenuItem *item);
Adds item
+ at the end of the menu
+.
void +webkit_context_menu_insert (+WebKitContextMenu *menu, +WebKitContextMenuItem *item, +gint position);
Inserts item
+ into the menu
+ at the given position.
+If position
+ is negative, or is larger than the number of items
+in the WebKitContextMenu, the item is added on to the end of
+the menu
+. The first position is 0.
menu |
++ | + |
item |
+the WebKitContextMenuItem to add |
++ |
position |
+the position to insert the item |
++ |
void +webkit_context_menu_move_item (+WebKitContextMenu *menu, +WebKitContextMenuItem *item, +gint position);
Moves item
+ to the given position in the menu
+.
+If position
+ is negative, or is larger than the number of items
+in the WebKitContextMenu, the item is added on to the end of
+the menu
+.
+The first position is 0.
menu |
++ | + |
item |
+the WebKitContextMenuItem to add |
++ |
position |
+the new position to move the item |
++ |
GList *
+webkit_context_menu_get_items (WebKitContextMenu *menu);
+Returns the item list of menu
+.
a GList of +WebKitContextMenuItems.
+[element-type WebKitContextMenuItem][transfer none]
+guint
+webkit_context_menu_get_n_items (WebKitContextMenu *menu);
+Gets the length of the menu
+.
WebKitContextMenuItem *
+webkit_context_menu_first (WebKitContextMenu *menu);
+Gets the first item in the menu
+.
the first WebKitContextMenuItem of menu
+,
+or NULL if the WebKitContextMenu is empty.
[transfer none]
+WebKitContextMenuItem *
+webkit_context_menu_last (WebKitContextMenu *menu);
+Gets the last item in the menu
+.
the last WebKitContextMenuItem of menu
+,
+or NULL if the WebKitContextMenu is empty.
[transfer none]
+WebKitContextMenuItem * +webkit_context_menu_get_item_at_position + (+WebKitContextMenu *menu, +guint position);
Gets the item at the given position in the menu
+.
menu |
++ | + |
position |
+the position of the item, counting from 0 |
++ |
the WebKitContextMenuItem at position position
+in menu
+,
+or NULL if the position is off the end of the menu
+.
[transfer none]
+void +webkit_context_menu_remove (+WebKitContextMenu *menu, +WebKitContextMenuItem *item);
Removes item
+ from the menu
+.
+See also webkit_context_menu_remove_all() to remove all items.
void
+webkit_context_menu_remove_all (WebKitContextMenu *menu);
+Removes all items of the menu
+.
void +webkit_context_menu_set_user_data (+WebKitContextMenu *menu, +GVariant *user_data);
Sets user data to menu
+.
+This function can be used from a Web Process extension to set user data
+that can be retrieved from the UI Process using webkit_context_menu_get_user_data().
+If the user_data
+ GVariant is floating, it is consumed.
Since: 2.8
+GVariant *
+webkit_context_menu_get_user_data (WebKitContextMenu *menu);
+Gets the user data of menu
+.
+This function can be used from the UI Process to get user data previously set
+from the Web Process with webkit_context_menu_set_user_data().
Since: 2.8
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitContextMenuItem+WebKitContextMenuItem — One item of the WebKitContextMenu + |
++ |
| +WebKitContextMenuItem * + | ++webkit_context_menu_item_new_from_gaction () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_item_new_from_stock_action () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_item_new_from_stock_action_with_label () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_item_new_with_submenu () + | +
| +WebKitContextMenuItem * + | ++webkit_context_menu_item_new_separator () + | +
| +GAction * + | ++webkit_context_menu_item_get_gaction () + | +
| +WebKitContextMenuAction + | ++webkit_context_menu_item_get_stock_action () + | +
| +gboolean + | ++webkit_context_menu_item_is_separator () + | +
| +void + | ++webkit_context_menu_item_set_submenu () + | +
| +WebKitContextMenu * + | ++webkit_context_menu_item_get_submenu () + | +
The WebKitContextMenu is composed of WebKitContextMenuItems. These items can be created from a GtkAction, from a +WebKitContextMenuAction or from a WebKitContextMenuAction and a +label. These WebKitContextMenuActions denote stock actions +for the items. You can also create separators and submenus.
+WebKitContextMenuItem * +webkit_context_menu_item_new_from_gaction + (+GAction *action, +const gchar *label, +GVariant *target);
Creates a new WebKitContextMenuItem for the given action
+ and label
+. On activation
+target
+ will be passed as parameter to the callback.
Since: 2.18
+WebKitContextMenuItem *
+webkit_context_menu_item_new_from_stock_action
+ (WebKitContextMenuAction action);
+Creates a new WebKitContextMenuItem for the given stock action.
+Stock actions are handled automatically by WebKit so that, for example,
+when a menu item created with a WEBKIT_CONTEXT_MENU_ACTION_STOP is
+activated the action associated will be handled by WebKit and the current
+load operation will be stopped. You can get the GtkAction of a
+WebKitContextMenuItem created with a WebKitContextMenuAction with
+webkit_context_menu_item_get_action() and connect to “activate” signal
+to be notified when the item is activated. But you can't prevent the associated
+action from being performed.
WebKitContextMenuItem * +webkit_context_menu_item_new_from_stock_action_with_label + (+WebKitContextMenuAction action, +const gchar *label);
Creates a new WebKitContextMenuItem for the given stock action using the given label
+.
+Stock actions have a predefined label, this method can be used to create a
+WebKitContextMenuItem for a WebKitContextMenuAction but using a custom label.
action |
+a WebKitContextMenuAction stock action |
++ |
label |
+a custom label text to use instead of the predefined one |
++ |
WebKitContextMenuItem * +webkit_context_menu_item_new_with_submenu + (+const gchar *label, +WebKitContextMenu *submenu);
Creates a new WebKitContextMenuItem using the given label
+ with a submenu.
label |
+the menu item label text |
++ |
submenu |
+a WebKitContextMenu to set |
++ |
WebKitContextMenuItem *
+webkit_context_menu_item_new_separator
+ (void);
+Creates a new WebKitContextMenuItem representing a separator.
+ +GAction *
+webkit_context_menu_item_get_gaction (WebKitContextMenuItem *item);
+Gets the action associated to item
+ as a GAction.
the GAction associated to the WebKitContextMenuItem,
+or NULL if item
+is a separator.
[transfer none]
+Since: 2.18
+WebKitContextMenuAction
+webkit_context_menu_item_get_stock_action
+ (WebKitContextMenuItem *item);
+Gets the WebKitContextMenuAction of item
+. If the WebKitContextMenuItem was not
+created for a stock action WEBKIT_CONTEXT_MENU_ACTION_CUSTOM will be
+returned. If the WebKitContextMenuItem is a separator WEBKIT_CONTEXT_MENU_ACTION_NO_ACTION
+will be returned.
gboolean
+webkit_context_menu_item_is_separator (WebKitContextMenuItem *item);
+Checks whether item
+ is a separator.
void +webkit_context_menu_item_set_submenu (+WebKitContextMenuItem *item, +WebKitContextMenu *submenu);
Sets or replaces the item
+ submenu. If submenu
+ is NULL the current
+submenu of item
+ is removed.
WebKitContextMenu *
+webkit_context_menu_item_get_submenu (WebKitContextMenuItem *item);
+Gets the submenu of item
+.
the WebKitContextMenu representing the submenu of
+item
+or NULL if item
+doesn't have a submenu.
[transfer none]
+Enum values used to denote the stock actions for +WebKitContextMenuItems
+| + |
+ No action, used by separator menu items. + |
++ |
| + |
+ Open current link. + |
++ |
| + |
+ Open current link in a new window. + |
++ |
| + |
+ Download link destination. + |
++ |
| + |
+ Copy link location to the clipboard. + |
++ |
| + |
+ Open current image in a new window. + |
++ |
| + |
+ Download current image. + |
++ |
| + |
+ Copy current image to the clipboard. + |
++ |
| + |
+ Open current frame in a new window. + |
++ |
| + |
+ Load the previous history item. + |
++ |
| + |
+ Load the next history item. + |
++ |
| + |
+ Stop any ongoing loading operation. + |
++ |
| + |
+ Reload the contents of current view. + |
++ |
| + |
+ Copy current selection the clipboard. + |
++ |
| + |
+ Cut current selection to the clipboard. + |
++ |
| + |
+ Paste clipboard contents. + |
++ |
| + |
+ A proposed replacement for a misspelled word. + |
++ |
| + |
+ An indicator that spellchecking found no proposed replacements. + |
++ |
| + |
+ Causes the spellchecker to ignore the word for this session. + |
++ |
| + |
+ Causes the spellchecker to add the word to the dictionary. + |
++ |
| + |
+ Ignore grammar. + |
++ |
| + |
+ Font options menu. + |
++ |
| + |
+ Bold. + |
++ |
| + |
+ Italic. + |
++ |
| + |
+ Underline. + |
++ |
| + |
+ Outline. + |
++ |
| + |
+ Open current element in the inspector. + |
++ |
| + |
+ Open current video element in a new window. + |
++ |
| + |
+ Open current audio element in a new window. + |
++ |
| + |
+ Copy video link location in to the clipboard. + |
++ |
| + |
+ Copy audio link location in to the clipboard. + |
++ |
| + |
+ Enable or disable media controls. + |
++ |
| + |
+ Enable or disable media loop. + |
++ |
| + |
+ Show current video element in fullscreen mode. + |
++ |
| + |
+ Play current media element. + |
++ |
| + |
+ Pause current media element. + |
++ |
| + |
+ Mute current media element. + |
++ |
| + |
+ Download video to disk. Since 2.2 + |
++ |
| + |
+ Download audio to disk. Since 2.2 + |
++ |
| + |
+ Custom action defined by applications. + |
++ |
| +Top + | + |
+ |
+ |
+ |
+
+WebKitCookieManager+WebKitCookieManager — Defines how to handle cookies in a WebKitWebContext + |
++ |
| +void + | ++webkit_cookie_manager_set_persistent_storage () + | +
| +void + | ++webkit_cookie_manager_set_accept_policy () + | +
| +void + | ++webkit_cookie_manager_get_accept_policy () + | +
| +WebKitCookieAcceptPolicy + | ++webkit_cookie_manager_get_accept_policy_finish () + | +
| +void + | ++webkit_cookie_manager_add_cookie () + | +
| +gboolean + | ++webkit_cookie_manager_add_cookie_finish () + | +
| +void + | ++webkit_cookie_manager_get_cookies () + | +
| +GList * + | ++webkit_cookie_manager_get_cookies_finish () + | +
| +void + | ++webkit_cookie_manager_delete_cookie () + | +
| +gboolean + | ++webkit_cookie_manager_delete_cookie_finish () + | +
| struct | +WebKitCookieManager | +
| enum | +WebKitCookiePersistentStorage | +
| enum | +WebKitCookieAcceptPolicy | +
The WebKitCookieManager defines how to set up and handle cookies.
+You can get it from a WebKitWebsiteDataManager with
+webkit_website_data_manager_get_cookie_manager(), and use it to set where to
+store cookies with webkit_cookie_manager_set_persistent_storage(),
+or to set the acceptance policy, with webkit_cookie_manager_get_accept_policy().
void +webkit_cookie_manager_set_persistent_storage + (+WebKitCookieManager *cookie_manager, +const gchar *filename, +WebKitCookiePersistentStorage storage);
Set the filename
+ where non-session cookies are stored persistently using
+storage
+ as the format to read/write the cookies.
+Cookies are initially read from filename
+ to create an initial set of cookies.
+Then, non-session cookies will be written to filename
+ when the WebKitCookieManager::changed
+signal is emitted.
+By default, cookie_manager
+ doesn't store the cookies persistently, so you need to call this
+method to keep cookies saved across sessions.
This method should never be called on a WebKitCookieManager associated to an ephemeral WebKitWebsiteDataManager.
+ +void +webkit_cookie_manager_set_accept_policy + (+WebKitCookieManager *cookie_manager, +WebKitCookieAcceptPolicy policy);
Set the cookie acceptance policy of cookie_manager
+ as policy
+.
void +webkit_cookie_manager_get_accept_policy + (+WebKitCookieManager *cookie_manager, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously get the cookie acceptance policy of cookie_manager
+.
When the operation is finished, callback
+ will be called. You can then call
+webkit_cookie_manager_get_accept_policy_finish() to get the result of the operation.
cookie_manager |
++ | + |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
WebKitCookieAcceptPolicy +webkit_cookie_manager_get_accept_policy_finish + (+WebKitCookieManager *cookie_manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_cookie_manager_get_accept_policy().
cookie_manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
void +webkit_cookie_manager_add_cookie (+WebKitCookieManager *cookie_manager, +SoupCookie *cookie, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously add a SoupCookie to the underlying storage.
+When the operation is finished, callback
+ will be called. You can then call
+webkit_cookie_manager_add_cookie_finish() to get the result of the operation.
cookie_manager |
++ | + |
cookie |
+the SoupCookie to be added |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.20
+gboolean +webkit_cookie_manager_add_cookie_finish + (+WebKitCookieManager *cookie_manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_cookie_manager_add_cookie().
cookie_manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
Since: 2.20
+void +webkit_cookie_manager_get_cookies (+WebKitCookieManager *cookie_manager, +const gchar *uri, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously get a list of SoupCookie from cookie_manager
+ associated with uri
+, which
+must be either an HTTP or an HTTPS URL.
When the operation is finished, callback
+ will be called. You can then call
+webkit_cookie_manager_get_cookies_finish() to get the result of the operation.
cookie_manager |
++ | + |
uri |
+the URI associated to the cookies to be retrieved |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.20
+GList * +webkit_cookie_manager_get_cookies_finish + (+WebKitCookieManager *cookie_manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_cookie_manager_get_cookies().
+The return value is a GSList of SoupCookie instances which should be released
+with g_list_free_full() and soup_cookie_free().
cookie_manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
Since: 2.20
+void +webkit_cookie_manager_delete_cookie (+WebKitCookieManager *cookie_manager, +SoupCookie *cookie, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously delete a SoupCookie from the current session.
+When the operation is finished, callback
+ will be called. You can then call
+webkit_cookie_manager_delete_cookie_finish() to get the result of the operation.
cookie_manager |
++ | + |
cookie |
+the SoupCookie to be deleted |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.20
+gboolean +webkit_cookie_manager_delete_cookie_finish + (+WebKitCookieManager *cookie_manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_cookie_manager_delete_cookie().
cookie_manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
Since: 2.20
+Enum values used to denote the cookie persistent storage types.
+ +“changed” signalvoid +user_function (WebKitCookieManager *cookie_manager, + gpointer user_data)+
This signal is emitted when cookies are added, removed or modified.
+cookie_manager |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitDownload+WebKitDownload — Object used to communicate with the application when downloading + |
++ |
| +WebKitURIRequest * + | ++webkit_download_get_request () + | +
| const gchar * + | ++webkit_download_get_destination () + | +
| +void + | ++webkit_download_set_destination () + | +
| +WebKitURIResponse * + | ++webkit_download_get_response () + | +
| +void + | ++webkit_download_cancel () + | +
| +gdouble + | ++webkit_download_get_estimated_progress () + | +
| +gdouble + | ++webkit_download_get_elapsed_time () + | +
| +guint64 + | ++webkit_download_get_received_data_length () + | +
| +WebKitWebView * + | ++webkit_download_get_web_view () + | +
| +gboolean + | ++webkit_download_get_allow_overwrite () + | +
| +void + | ++webkit_download_set_allow_overwrite () + | +
| gboolean | +allow-overwrite | +Read / Write | +
| +gchar * | +destination | +Read | +
| gdouble | +estimated-progress | +Read | +
| +WebKitURIResponse * | +response | +Read | +
| void | +created-destination | +Run Last | +
| gboolean | +decide-destination | +Run Last | +
| void | +failed | +Run Last | +
| void | +finished | +Run Last | +
| void | +received-data | +Run Last | +
WebKitDownload carries information about a download request and +response, including a WebKitURIRequest and a WebKitURIResponse +objects. The application may use this object to control the +download process, or to simply figure out what is to be downloaded, +and handle the download process itself.
+WebKitURIRequest *
+webkit_download_get_request (WebKitDownload *download);
+Retrieves the WebKitURIRequest object that backs the download +process.
+ + +const gchar *
+webkit_download_get_destination (WebKitDownload *download);
+Obtains the URI to which the downloaded file will be written. You +can connect to “created-destination” to make +sure this method returns a valid destination.
+ + +void +webkit_download_set_destination (+WebKitDownload *download, +const gchar *uri);
Sets the URI to which the downloaded file will be written.
+This method should be called before the download transfer
+starts or it will not have any effect on the ongoing download
+operation. To set the destination using the filename suggested
+by the server connect to “decide-destination”
+signal and call webkit_download_set_destination(). If you want to
+set a fixed destination URI that doesn't depend on the suggested
+filename you can connect to notify::response signal and call
+webkit_download_set_destination().
+If “decide-destination” signal is not handled
+and destination URI is not set when the download transfer starts,
+the file will be saved with the filename suggested by the server in
+G_USER_DIRECTORY_DOWNLOAD directory.
WebKitURIResponse *
+webkit_download_get_response (WebKitDownload *download);
+Retrieves the WebKitURIResponse object that backs the download
+process. This method returns NULL if called before the response
+is received from the server. You can connect to notify::response
+signal to be notified when the response is received.
the WebKitURIResponse, or NULL if
+the response hasn't been received yet.
[transfer none]
+void
+webkit_download_cancel (WebKitDownload *download);
+Cancels the download. When the ongoing download
+operation is effectively cancelled the signal
+“failed” is emitted with
+WEBKIT_DOWNLOAD_ERROR_CANCELLED_BY_USER error.
gdouble
+webkit_download_get_estimated_progress
+ (WebKitDownload *download);
+Gets the value of the “estimated-progress” property.
+You can monitor the estimated progress of the download operation by
+connecting to the notify::estimated-progress signal of download
+.
gdouble
+webkit_download_get_elapsed_time (WebKitDownload *download);
+Gets the elapsed time in seconds, including any fractional part. +If the download finished, had an error or was cancelled this is +the time between its start and the event.
+ + +guint64
+webkit_download_get_received_data_length
+ (WebKitDownload *download);
+Gets the length of the data already downloaded for download
+
+in bytes.
WebKitWebView *
+webkit_download_get_web_view (WebKitDownload *download);
+Get the WebKitWebView that initiated the download.
+ +the WebKitWebView that initiated download
+,
+or NULL if download
+was not initiated by a WebKitWebView.
[transfer none]
+gboolean
+webkit_download_get_allow_overwrite (WebKitDownload *download);
+Returns the current value of the “allow-overwrite” property, +which determines whether the download will overwrite an existing file on +disk, or if it will fail if the destination already exists.
+ + +Since: 2.6
+void +webkit_download_set_allow_overwrite (+WebKitDownload *download, +gboolean allowed);
Sets the “allow-overwrite” property, which determines whether +the download may overwrite an existing file on disk, or if it will fail if +the destination already exists.
+download |
++ | + |
allowed |
+the new value for the “allow-overwrite” property |
++ |
Since: 2.6
+“allow-overwrite” property“allow-overwrite” gboolean+
Whether or not the download is allowed to overwrite an existing file on
+disk. If this property is FALSE and the destination already exists,
+the download will fail.
Flags: Read / Write
+Default value: FALSE
+Since: 2.6
+“destination” property“destination” gchar *+
The local URI to where the download will be saved.
+Flags: Read
+Default value: NULL
+“estimated-progress” property“estimated-progress” gdouble+
An estimate of the percent completion for the download operation. +This value will range from 0.0 to 1.0. The value is an estimate +based on the total number of bytes expected to be received for +a download. +If you need a more accurate progress information you can connect to +“received-data” signal to track the progress.
+Flags: Read
+Allowed values: [0,1]
+Default value: 1
+“response” property“response” WebKitURIResponse *+
The WebKitURIResponse associated with this download.
+Flags: Read
+“created-destination” signalvoid +user_function (WebKitDownload *download, + gchar *destination, + gpointer user_data)+
This signal is emitted after “decide-destination” and before
+“received-data” to notify that destination file has been
+created successfully at destination
+.
download |
+the WebKitDownload |
++ |
destination |
+the destination URI |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“decide-destination” signalgboolean +user_function (WebKitDownload *download, + gchar *suggested_filename, + gpointer user_data)+
This signal is emitted after response is received to
+decide a destination URI for the download. If this signal is not
+handled the file will be downloaded to G_USER_DIRECTORY_DOWNLOAD
+directory using suggested_filename
+.
download |
+the WebKitDownload |
++ |
suggested_filename |
+the filename suggested for the download |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“failed” signalvoid +user_function (WebKitDownload *download, + GError *error, + gpointer user_data)+
This signal is emitted when an error occurs during the download
+operation. The given error
+, of the domain WEBKIT_DOWNLOAD_ERROR,
+contains further details of the failure. If the download is cancelled
+with webkit_download_cancel(), this signal is emitted with error
+WEBKIT_DOWNLOAD_ERROR_CANCELLED_BY_USER. The download operation finishes
+after an error and “finished” signal is emitted after this one.
download |
+the WebKitDownload |
++ |
error |
+the GError that was triggered |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“finished” signalvoid +user_function (WebKitDownload *download, + gpointer user_data)+
This signal is emitted when download finishes successfully or due to an error. +In case of errors “failed” signal is emitted before this one.
+download |
+the WebKitDownload |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“received-data” signalvoid +user_function (WebKitDownload *download, + guint64 data_length, + gpointer user_data)+
This signal is emitted after response is received, +every time new data has been written to the destination. It's +useful to know the progress of the download operation.
+download |
+the WebKitDownload |
++ |
data_length |
+the length of data received in bytes |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
| +guint + | ++webkit_editor_state_get_typing_attributes () + | +
| +gboolean + | ++webkit_editor_state_is_cut_available () + | +
| +gboolean + | ++webkit_editor_state_is_copy_available () + | +
| +gboolean + | ++webkit_editor_state_is_paste_available () + | +
| +gboolean + | ++webkit_editor_state_is_undo_available () + | +
| +gboolean + | ++webkit_editor_state_is_redo_available () + | +
| struct | +WebKitEditorState | +
| enum | +WebKitEditorTypingAttributes | +
WebKitEditorState represents the state of a WebKitWebView editor.
+Use webkit_web_view_get_editor_state() to get the WebKitEditorState
+of a WebKitWebView.
guint
+webkit_editor_state_get_typing_attributes
+ (WebKitEditorState *editor_state);
+Gets the typing attributes at the current cursor position. +If there is a selection, this returns the typing attributes +of the selected text. Note that in case of a selection, +typing attributes are considered active only when they are +present throughout the selection.
+ + +Since: 2.10
+gboolean
+webkit_editor_state_is_cut_available (WebKitEditorState *editor_state);
+Gets whether a cut command can be issued.
+ + +Since: 2.20
+gboolean
+webkit_editor_state_is_copy_available (WebKitEditorState *editor_state);
+Gets whether a copy command can be issued.
+ + +Since: 2.20
+gboolean
+webkit_editor_state_is_paste_available
+ (WebKitEditorState *editor_state);
+Gets whether a paste command can be issued.
+ + +Since: 2.20
+gboolean
+webkit_editor_state_is_undo_available (WebKitEditorState *editor_state);
+Gets whether an undo command can be issued.
+ + +Since: 2.20
+gboolean
+webkit_editor_state_is_redo_available (WebKitEditorState *editor_state);
+Gets whether a redo command can be issued.
+ + +Since: 2.20
+Enum values with flags representing typing attributes.
+| + |
+ No typing attributes. + |
++ |
| + |
+ Bold typing attribute. + |
++ |
| + |
+ Italic typing attribute. + |
++ |
| + |
+ Underline typing attribute. + |
++ |
| + |
+ Strikethrough typing attribute. + |
++ |
Since: 2.10
+“typing-attributes” property“typing-attributes” guint+
Bitmask of WebKitEditorTypingAttributes flags.
+See webkit_editor_state_get_typing_attributes() for more information.
Flags: Read
+Default value: 0
+Since: 2.10
+| +Top + | + |
+ |
+ |
+ |
+
| +gchar * + | ++webkit_favicon_database_get_favicon_uri () + | +
| +void + | ++webkit_favicon_database_clear () + | +
| struct | +WebKitFaviconDatabase | +
| #define | +WEBKIT_FAVICON_DATABASE_ERROR | +
| enum | +WebKitFaviconDatabaseError | +
WebKitFaviconDatabase provides access to the icons associated with +web sites.
+WebKit will automatically look for available icons in <link> +elements on opened pages as well as an existing favicon.ico and +load the images found into a memory cache if possible. That cache +is frozen to an on-disk database for persistence.
+If “enable-private-browsing” is TRUE, new icons
+won't be added to the on-disk database and no existing icons will
+be deleted from it. Nevertheless, WebKit will still store them in
+the in-memory cache during the current execution.
gchar * +webkit_favicon_database_get_favicon_uri + (+WebKitFaviconDatabase *database, +const gchar *page_uri);
Obtains the URI of the favicon for the given page_uri
+.
database |
++ | + |
page_uri |
+URI of the page containing the icon |
++ |
a newly allocated URI for the favicon, or NULL if the
+database doesn't have a favicon for page_uri
+.
void
+webkit_favicon_database_clear (WebKitFaviconDatabase *database);
+Clears all icons from the database.
+ +#define WEBKIT_FAVICON_DATABASE_ERROR (webkit_favicon_database_error_quark()) ++
Enum values used to denote the various errors related to the WebKitFaviconDatabase.
+| + |
+ The WebKitFaviconDatabase has not been initialized yet + |
++ |
| + |
+ There is not an icon available for the requested URL + |
++ |
| + |
+ There might be an icon for the requested URL, but its data is unknown at the moment + |
++ |
“favicon-changed” signalvoid +user_function (WebKitFaviconDatabase *database, + gchar *page_uri, + gchar *favicon_uri, + gpointer user_data)+
This signal is emitted when the favicon URI of page_uri
+ has
+been changed to favicon_uri
+ in the database. You can connect
+to this signal and call webkit_favicon_database_get_favicon()
+to get the favicon. If you are interested in the favicon of a
+WebKitWebView it's easier to use the “favicon”
+property. See webkit_web_view_get_favicon() for more details.
database |
+the object on which the signal is emitted |
++ |
page_uri |
+the URI of the Web page containing the icon |
++ |
favicon_uri |
+the URI of the favicon |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
| const gchar * const * + | ++webkit_file_chooser_request_get_mime_types () + | +
| +gboolean + | ++webkit_file_chooser_request_get_select_multiple () + | +
| +void + | ++webkit_file_chooser_request_select_files () + | +
| const gchar * const * + | ++webkit_file_chooser_request_get_selected_files () + | +
| +void + | ++webkit_file_chooser_request_cancel () + | +
| GStrv | +mime-types | +Read | +
| gboolean | +select-multiple | +Read | +
| GStrv | +selected-files | +Read | +
Whenever the user interacts with an <input type='file' /> +HTML element, WebKit will need to show a dialog to choose one or +more files to be uploaded to the server along with the rest of the +form data. For that to happen in a general way, instead of just +opening a GtkFileChooserDialog (which might be not desirable in +some cases, which could prefer to use their own file chooser +dialog), WebKit will fire the “run-file-chooser” +signal with a WebKitFileChooserRequest object, which will allow +the client application to specify the files to be selected, to +inspect the details of the request (e.g. if multiple selection +should be allowed) and to cancel the request, in case nothing was +selected.
+In case the client application does not wish to handle this signal, +WebKit will provide a default handler which will asynchronously run +a regular GtkFileChooserDialog for the user to interact with.
+const gchar * const *
+webkit_file_chooser_request_get_mime_types
+ (WebKitFileChooserRequest *request);
+Get the list of MIME types the file chooser dialog should handle, +in the format specified in RFC 2046 for "media types". Its contents +depend on the value of the 'accept' attribute for HTML input +elements. This function should normally be called before presenting +the file chooser dialog to the user, to decide whether to allow the +user to select multiple files at once or only one.
+ + +gboolean
+webkit_file_chooser_request_get_select_multiple
+ (WebKitFileChooserRequest *request);
+Determine whether the file chooser associated to this +WebKitFileChooserRequest should allow selecting multiple files, +which depends on the HTML input element having a 'multiple' +attribute defined.
+ + +void +webkit_file_chooser_request_select_files + (+WebKitFileChooserRequest *request, +const gchar * const *files);
Ask WebKit to select local files for upload and complete the +request.
+request |
++ | + |
files |
+a
+ |
+[array zero-terminated=1][transfer none] | +
const gchar * const *
+webkit_file_chooser_request_get_selected_files
+ (WebKitFileChooserRequest *request);
+Get the list of selected files currently associated to the +request. Initially, the return value of this method contains any +files selected in previous file chooser requests for this HTML +input element. Once webkit_file_chooser_request_select_files, the +value will reflect whatever files are given.
+This function should normally be called only before presenting the +file chooser dialog to the user, to decide whether to perform some +extra action, like pre-selecting the files from a previous request.
+ + +void
+webkit_file_chooser_request_cancel (WebKitFileChooserRequest *request);
+Ask WebKit to cancel the request. It's important to do this in case +no selection has been made in the client, otherwise the request +won't be properly completed and the browser will keep the request +pending forever, which might cause the browser to hang.
+ +“mime-types” property“mime-types” GStrv+
A NULL-terminated array of strings containing the list of MIME
+types the file chooser dialog should handle. See
+webkit_file_chooser_request_get_mime_types() for more details.
Flags: Read
+“select-multiple” property“select-multiple” gboolean+
Whether the file chooser should allow selecting multiple
+files. See
+webkit_file_chooser_request_get_select_multiple() for
+more details.
Flags: Read
+Default value: FALSE
+“selected-files” property“selected-files” GStrv+
A NULL-terminated array of strings containing the list of
+selected files associated to the current request. See
+webkit_file_chooser_request_get_selected_files() for more details.
Flags: Read
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitFindController+WebKitFindController — Controls text search in a WebKitWebView + |
++ |
| +void + | ++webkit_find_controller_search () + | +
| +void + | ++webkit_find_controller_search_finish () + | +
| +void + | ++webkit_find_controller_search_next () + | +
| +void + | ++webkit_find_controller_search_previous () + | +
| const gchar * + | ++webkit_find_controller_get_search_text () + | +
| +void + | ++webkit_find_controller_count_matches () + | +
| +guint32 + | ++webkit_find_controller_get_options () + | +
| +guint + | ++webkit_find_controller_get_max_match_count () + | +
| +WebKitWebView * + | ++webkit_find_controller_get_web_view () + | +
| guint | +max-match-count | +Read | +
| WebKitFindOptions | +options | +Read | +
| +gchar * | +text | +Read | +
| +WebKitWebView * | +web-view | +Read / Write / Construct Only | +
| void | +counted-matches | +Run Last | +
| void | +failed-to-find-text | +Run Last | +
| void | +found-text | +Run Last | +
A WebKitFindController is used to search text in a WebKitWebView. You
+can get a WebKitWebView's WebKitFindController with
+webkit_web_view_get_find_controller(), and later use it to search
+for text using webkit_find_controller_search(), or get the
+number of matches using webkit_find_controller_count_matches(). The
+operations are asynchronous and trigger signals when ready, such as
+“found-text”,
+“failed-to-find-text” or
+“counted-matches”.
void +webkit_find_controller_search (+WebKitFindController *find_controller, +const gchar *search_text, +guint32 find_options, +guint max_match_count);
Looks for search_text
+ in the WebKitWebView associated with
+find_controller
+ since the beginning of the document highlighting
+up to max_match_count
+ matches. The outcome of the search will be
+asynchronously provided by the “found-text”
+and “failed-to-find-text” signals.
To look for the next or previous occurrences of the same text
+with the same find options use webkit_find_controller_search_next()
+and/or webkit_find_controller_search_previous(). The
+WebKitFindController will use the same text and options for the
+following searches unless they are modified by another call to this
+method.
Note that if the number of matches is higher than max_match_count
+
+then “found-text” will report G_MAXUINT matches
+instead of the actual number.
Callers should call webkit_find_controller_search_finish() to
+finish the current search operation.
find_controller |
++ | + |
search_text |
+the text to look for |
++ |
find_options |
+a bitmask with the WebKitFindOptions used in the search |
++ |
max_match_count |
+the maximum number of matches allowed in the search |
++ |
void
+webkit_find_controller_search_finish (WebKitFindController *find_controller);
+Finishes a find operation started by
+webkit_find_controller_search(). It will basically unhighlight
+every text match found.
This method will be typically called when the search UI is +closed/hidden by the client application.
+ +void
+webkit_find_controller_search_next (WebKitFindController *find_controller);
+Looks for the next occurrence of the search text.
+Calling this method before webkit_find_controller_search() or
+webkit_find_controller_count_matches() is a programming error.
void
+webkit_find_controller_search_previous
+ (WebKitFindController *find_controller);
+Looks for the previous occurrence of the search text.
+Calling this method before webkit_find_controller_search() or
+webkit_find_controller_count_matches() is a programming error.
const gchar *
+webkit_find_controller_get_search_text
+ (WebKitFindController *find_controller);
+Gets the text that find_controller
+ is currently searching
+for. This text is passed to either
+webkit_find_controller_search() or
+webkit_find_controller_count_matches().
void +webkit_find_controller_count_matches (+WebKitFindController *find_controller, +const gchar *search_text, +guint32 find_options, +guint max_match_count);
Counts the number of matches for search_text
+ found in the
+WebKitWebView with the provided find_options
+. The number of
+matches will be provided by the
+“counted-matches” signal.
find_controller |
++ | + |
search_text |
+the text to look for |
++ |
find_options |
+a bitmask with the WebKitFindOptions used in the search |
++ |
max_match_count |
+the maximum number of matches allowed in the search |
++ |
guint32
+webkit_find_controller_get_options (WebKitFindController *find_controller);
+Gets a bitmask containing the WebKitFindOptions associated with +the current search.
+ + +guint
+webkit_find_controller_get_max_match_count
+ (WebKitFindController *find_controller);
+Gets the maximum number of matches to report during a text
+lookup. This number is passed as the last argument of
+webkit_find_controller_search() or
+webkit_find_controller_count_matches().
WebKitWebView *
+webkit_find_controller_get_web_view (WebKitFindController *find_controller);
+Gets the WebKitWebView this find controller is associated to. Do +not dereference the returned instance as it belongs to the +WebKitFindController.
+ + +Enum values used to specify search options.
+| + |
+ no search flags, this means a case + sensitive, no wrap, forward only search. + |
++ |
| + |
+ case insensitive search. + |
++ |
| + |
+ search text only at the + begining of the words. + |
++ |
| + |
+ treat + capital letters in the middle of words as word start. + |
++ |
| + |
+ search backwards. + |
++ |
| + |
+ if not present search will stop + at the end of the document. + |
++ |
“max-match-count” property“max-match-count” guint+
The maximum number of matches to report for a given search.
+Flags: Read
+Default value: 0
+“options” property“options” WebKitFindOptions+
The options to be used in the search operation.
+Flags: Read
+“text” property“text” gchar *+
The current search text for this WebKitFindController.
+Flags: Read
+Default value: NULL
+“web-view” property“web-view” WebKitWebView *+
The WebKitWebView this controller is associated to.
+Flags: Read / Write / Construct Only
+“counted-matches” signalvoid +user_function (WebKitFindController *find_controller, + guint match_count, + gpointer user_data)+
This signal is emitted when the WebKitFindController has
+counted the number of matches for a given text after a call
+to webkit_find_controller_count_matches().
find_controller |
++ | + |
match_count |
+the number of matches of the search text |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“failed-to-find-text” signalvoid +user_function (WebKitFindController *find_controller, + gpointer user_data)+
This signal is emitted when a search operation does not find
+any result for the given text. It will be issued if the text
+is not found asynchronously after a call to
+webkit_find_controller_search(), webkit_find_controller_search_next()
+or webkit_find_controller_search_previous().
find_controller |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“found-text” signalvoid +user_function (WebKitFindController *find_controller, + guint match_count, + gpointer user_data)+
This signal is emitted when a given text is found in the web
+page text. It will be issued if the text is found
+asynchronously after a call to webkit_find_controller_search(),
+webkit_find_controller_search_next() or
+webkit_find_controller_search_previous().
find_controller |
++ | + |
match_count |
+the number of matches found of the search text |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitFormSubmissionRequest+WebKitFormSubmissionRequest — Represents a form submission request + |
++ |
| +gboolean + | ++webkit_form_submission_request_list_text_fields () + | +
| +void + | ++webkit_form_submission_request_submit () + | +
When a form is about to be submitted in a WebKitWebView, the
+“submit-form” signal is emitted. Its request argument
+contains information about the text fields of the form, that are
+typically used to store login information, returned as lists by
+webkit_form_submission_request_list_text_fields(). You can submit the
+form with webkit_form_submission_request_submit().
gboolean +webkit_form_submission_request_list_text_fields + (+WebKitFormSubmissionRequest *request, +GPtrArray **field_names, +GPtrArray **field_values);
Get lists with the names and values of the text fields contained in
+the form associated to request
+. Note that names and values may be
+NULL.
If this function returns FALSE, then both field_names
+ and
+field_values
+ will be empty.
request |
++ | + |
field_names |
+names of the text fields in the form. |
+[out][optional][element-type utf8][transfer none] | +
field_values |
+values of the text fields in the form. |
+[out][optional][element-type utf8][transfer none] | +
Since: 2.20
+void
+webkit_form_submission_request_submit (WebKitFormSubmissionRequest *request);
+Continue the form submission.
+ +| +Top + | + |
+ |
+ |
+ |
+
+WebKitGeolocationPermissionRequest+WebKitGeolocationPermissionRequest — A permission request for sharing user's location + |
++ |
+WebKitGeolocationPermissionRequest implements + WebKitPermissionRequest.
+WebKitGeolocationPermissionRequest represents a request for +permission to decide whether WebKit should provide the user's +location to a website when requested through the Geolocation API.
+When a WebKitGeolocationPermissionRequest is not handled by the user, +it is denied by default.
+When embedding web views in your application, you *must* configure an
+application identifier to allow web content to use geolocation services.
+The identifier *must* match the name of the .desktop file which describes
+the application, sans the suffix.
If your application uses GApplication (or any subclass like
+GtkApplication), WebKit will automatically use the identifier returned by
+g_application_get_application_id(). This is the recommended approach for
+enabling geolocation in applications.
If an identifier cannot be obtained through GApplication, the value
+returned by g_get_prgname() will be used instead as a fallback. For
+programs which cannot use GApplication, calling g_set_prgname() early
+during initialization is needed when the name of the executable on disk
+does not match the name of a valid .desktop file.
| +Top + | + |
+ |
+ |
+ |
+
| +guint + | ++webkit_hit_test_result_get_context () + | +
| +gboolean + | ++webkit_hit_test_result_context_is_link () + | +
| +gboolean + | ++webkit_hit_test_result_context_is_image () + | +
| +gboolean + | ++webkit_hit_test_result_context_is_media () + | +
| +gboolean + | ++webkit_hit_test_result_context_is_editable () + | +
| +gboolean + | ++webkit_hit_test_result_context_is_selection () + | +
| +gboolean + | ++webkit_hit_test_result_context_is_scrollbar () + | +
| const gchar * + | ++webkit_hit_test_result_get_link_uri () + | +
| const gchar * + | ++webkit_hit_test_result_get_link_title () + | +
| const gchar * + | ++webkit_hit_test_result_get_link_label () + | +
| const gchar * + | ++webkit_hit_test_result_get_image_uri () + | +
| const gchar * + | ++webkit_hit_test_result_get_media_uri () + | +
| guint | +context | +Read / Write / Construct Only | +
| +gchar * | +image-uri | +Read / Write / Construct Only | +
| +gchar * | +link-label | +Read / Write / Construct Only | +
| +gchar * | +link-title | +Read / Write / Construct Only | +
| +gchar * | +link-uri | +Read / Write / Construct Only | +
| +gchar * | +media-uri | +Read / Write / Construct Only | +
| struct | +WebKitHitTestResult | +
| enum | +WebKitHitTestResultContext | +
A Hit Test is an operation to get context information about a given +point in a WebKitWebView. WebKitHitTestResult represents the +result of a Hit Test. It provides context information about what is +at the coordinates of the Hit Test, such as if there's a link, +an image or a media.
+You can get the context of the HitTestResult with
+webkit_hit_test_result_get_context() that returns a bitmask of
+WebKitHitTestResultContext flags. You can also use
+webkit_hit_test_result_context_is_link(), webkit_hit_test_result_context_is_image() and
+webkit_hit_test_result_context_is_media() to determine whether there's
+a link, image or a media element at the coordinates of the Hit Test.
+Note that it's possible that several WebKitHitTestResultContext flags
+are active at the same time, for example if there's a link containing an image.
When the mouse is moved over a WebKitWebView a Hit Test is performed +for the mouse coordinates and “mouse-target-changed” +signal is emitted with a WebKitHitTestResult.
+guint
+webkit_hit_test_result_get_context (WebKitHitTestResult *hit_test_result);
+Gets the value of the “context” property.
+ + +gboolean
+webkit_hit_test_result_context_is_link
+ (WebKitHitTestResult *hit_test_result);
+Gets whether WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK flag is present in
+“context”.
gboolean
+webkit_hit_test_result_context_is_image
+ (WebKitHitTestResult *hit_test_result);
+Gets whether WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE flag is present in
+“context”.
gboolean
+webkit_hit_test_result_context_is_media
+ (WebKitHitTestResult *hit_test_result);
+Gets whether WEBKIT_HIT_TEST_RESULT_CONTEXT_MEDIA flag is present in
+“context”.
gboolean
+webkit_hit_test_result_context_is_editable
+ (WebKitHitTestResult *hit_test_result);
+Gets whether WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE flag is present in
+“context”.
gboolean
+webkit_hit_test_result_context_is_selection
+ (WebKitHitTestResult *hit_test_result);
+Gets whether WEBKIT_HIT_TEST_RESULT_CONTEXT_SELECTION flag is present in
+“context”.
TRUE if there's a selected element at the coordinates of the hit_test_result
+,
+or FALSE otherwise
Since: 2.8
+gboolean
+webkit_hit_test_result_context_is_scrollbar
+ (WebKitHitTestResult *hit_test_result);
+Gets whether WEBKIT_HIT_TEST_RESULT_CONTEXT_SCROLLBAR flag is present in
+“context”.
const gchar *
+webkit_hit_test_result_get_link_uri (WebKitHitTestResult *hit_test_result);
+Gets the value of the “link-uri” property.
+ + the URI of the link element in the coordinates of the Hit Test,
+or NULL if there isn't a link element in hit_test_result
+context
const gchar *
+webkit_hit_test_result_get_link_title (WebKitHitTestResult *hit_test_result);
+Gets the value of the “link-title” property.
+ + the title of the link element in the coordinates of the Hit Test,
+or NULL if there isn't a link element in hit_test_result
+context or the
+link element doesn't have a title
const gchar *
+webkit_hit_test_result_get_link_label (WebKitHitTestResult *hit_test_result);
+Gets the value of the “link-label” property.
+ + the label of the link element in the coordinates of the Hit Test,
+or NULL if there isn't a link element in hit_test_result
+context or the
+link element doesn't have a label
const gchar *
+webkit_hit_test_result_get_image_uri (WebKitHitTestResult *hit_test_result);
+Gets the value of the “image-uri” property.
+ + the URI of the image element in the coordinates of the Hit Test,
+or NULL if there isn't an image element in hit_test_result
+context
const gchar *
+webkit_hit_test_result_get_media_uri (WebKitHitTestResult *hit_test_result);
+Gets the value of the “media-uri” property.
+ + the URI of the media element in the coordinates of the Hit Test,
+or NULL if there isn't a media element in hit_test_result
+context
Enum values with flags representing the context of a WebKitHitTestResult.
+ +“context” property“context” guint+
Bitmask of WebKitHitTestResultContext flags representing +the context of the WebKitHitTestResult.
+Flags: Read / Write / Construct Only
+Default value: 0
+“image-uri” property“image-uri” gchar *+
The URI of the image if flag WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE
+is present in “context”
Flags: Read / Write / Construct Only
+Default value: NULL
+“link-label” property“link-label” gchar *+
The label of the link if flag WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK
+is present in “context”
Flags: Read / Write / Construct Only
+Default value: NULL
+“link-title” property“link-title” gchar *+
The title of the link if flag WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK
+is present in “context”
Flags: Read / Write / Construct Only
+Default value: NULL
+“link-uri” property“link-uri” gchar *+
The URI of the link if flag WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK
+is present in “context”
Flags: Read / Write / Construct Only
+Default value: NULL
+“media-uri” property“media-uri” gchar *+
The URI of the media if flag WEBKIT_HIT_TEST_RESULT_CONTEXT_MEDIA
+is present in “context”
Flags: Read / Write / Construct Only
+Default value: NULL
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitInstallMissingMediaPluginsPermissionRequest+WebKitInstallMissingMediaPluginsPermissionRequest — A permission request for installing missing media plugins + |
++ |
| const gchar * + | ++webkit_install_missing_media_plugins_permission_request_get_description () + | +
+WebKitInstallMissingMediaPluginsPermissionRequest implements + WebKitPermissionRequest.
+WebKitInstallMissingMediaPluginsPermissionRequest represents a request for +permission to decide whether WebKit should try to start a helper application to +install missing media plugins when the media backend couldn't play a media because +the required plugins were not available.
+When a WebKitInstallMissingMediaPluginsPermissionRequest is not handled by the user, +it is allowed by default.
+const gchar *
+webkit_install_missing_media_plugins_permission_request_get_description
+ (WebKitInstallMissingMediaPluginsPermissionRequest *request);
+Gets the description about the missing plugins provided by the media backend when a media couldn't be played.
+ + +Since: 2.10
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitNavigationAction * + | ++webkit_navigation_action_copy () + | +
| +void + | ++webkit_navigation_action_free () + | +
| +WebKitNavigationType + | ++webkit_navigation_action_get_navigation_type () + | +
| +guint + | ++webkit_navigation_action_get_mouse_button () + | +
| +guint + | ++webkit_navigation_action_get_modifiers () + | +
| +WebKitURIRequest * + | ++webkit_navigation_action_get_request () + | +
| +gboolean + | ++webkit_navigation_action_is_user_gesture () + | +
| +gboolean + | ++webkit_navigation_action_is_redirect () + | +
WebKitNavigationAction *
+webkit_navigation_action_copy (WebKitNavigationAction *navigation);
+Make a copy of navigation
+.
Since: 2.6
+void
+webkit_navigation_action_free (WebKitNavigationAction *navigation);
+Free the WebKitNavigationAction
+ +Since: 2.6
+WebKitNavigationType
+webkit_navigation_action_get_navigation_type
+ (WebKitNavigationAction *navigation);
+Return the type of action that triggered the navigation.
+ + +Since: 2.6
+guint
+webkit_navigation_action_get_mouse_button
+ (WebKitNavigationAction *navigation);
+Return the number of the mouse button that triggered the navigation, or 0 if +the navigation was not started by a mouse event.
+ + +Since: 2.6
+guint
+webkit_navigation_action_get_modifiers
+ (WebKitNavigationAction *navigation);
+Return a bitmask of GdkModifierType values describing the modifier keys that were in effect +when the navigation was requested
+ + +Since: 2.6
+WebKitURIRequest *
+webkit_navigation_action_get_request (WebKitNavigationAction *navigation);
+Return the WebKitURIRequest associated with the navigation action. +Modifications to the returned object are not taken +into account when the request is sent over the network, and is intended +only to aid in evaluating whether a navigation action should be taken or +not. To modify requests before they are sent over the network the +“send-request” signal can be used instead.
+ + +Since: 2.6
+gboolean
+webkit_navigation_action_is_user_gesture
+ (WebKitNavigationAction *navigation);
+Return whether the navigation was triggered by a user gesture like a mouse click.
+ + +Since: 2.6
+gboolean
+webkit_navigation_action_is_redirect (WebKitNavigationAction *navigation);
+Returns whether the navigation
+ was redirected.
Since: 2.20
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitNavigationPolicyDecision+WebKitNavigationPolicyDecision — A policy decision for navigation actions + |
++ |
| +WebKitNavigationAction * + | ++webkit_navigation_policy_decision_get_navigation_action () + | +
| const gchar * + | ++webkit_navigation_policy_decision_get_frame_name () + | +
| +gchar * | +frame-name | +Read | +
| +WebKitNavigationAction * | +navigation-action | +Read | +
| struct | +WebKitNavigationPolicyDecision | +
| enum | +WebKitNavigationType | +
WebKitNavigationPolicyDecision represents a policy decision for events associated with +navigations. If the value of “mouse-button” is not 0, then +the navigation was triggered by a mouse event.
+WebKitNavigationAction *
+webkit_navigation_policy_decision_get_navigation_action
+ (WebKitNavigationPolicyDecision *decision);
+Gets the value of the “navigation-action” property.
+ + +Since: 2.6
+const gchar *
+webkit_navigation_policy_decision_get_frame_name
+ (WebKitNavigationPolicyDecision *decision);
+Gets the value of the “frame-name” property.
+ + +Enum values used to denote the various navigation types.
+| + |
+ The navigation was triggered by clicking a link. + |
++ |
| + |
+ The navigation was triggered by submitting a form. + |
++ |
| + |
+ The navigation was triggered by navigating forward or backward. + |
++ |
| + |
+ The navigation was triggered by reloading. + |
++ |
| + |
+ The navigation was triggered by resubmitting a form. + |
++ |
| + |
+ The navigation was triggered by some other action. + |
++ |
“frame-name” property“frame-name” gchar *+
If this navigation request targets a new frame, this property contains
+the name of that frame. For example if the decision was triggered by clicking a
+link with a target attribute equal to "_blank", this property will contain the
+value of that attribute. In all other cases, this value will be NULL.
Flags: Read
+Default value: NULL
+“navigation-action” property“navigation-action” WebKitNavigationAction *+
The WebKitNavigationAction that triggered this policy decision.
+Flags: Read
+Since: 2.6
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitNetworkProxySettings * + | ++webkit_network_proxy_settings_new () + | +
| +WebKitNetworkProxySettings * + | ++webkit_network_proxy_settings_copy () + | +
| +void + | ++webkit_network_proxy_settings_free () + | +
| +void + | ++webkit_network_proxy_settings_add_proxy_for_scheme () + | +
WebKitNetworkProxySettings can be used to provide a custom proxy configuration
+to a WebKitWebContext. You need to call webkit_web_context_set_network_proxy_settings()
+with WEBKIT_NETWORK_PROXY_MODE_CUSTOM and a WebKitNetworkProxySettings.
WebKitNetworkProxySettings * +webkit_network_proxy_settings_new (+const gchar *default_proxy_uri, +const gchar * const *ignore_hosts);
Create a new WebKitNetworkProxySettings with the given default_proxy_uri
+ and ignore_hosts
+.
The default proxy URI will be used for any URI that doesn't match ignore_hosts
+, and doesn't match any
+of the schemes added with webkit_network_proxy_settings_add_proxy_for_scheme().
+If default_proxy_uri
+ starts with "socks://", it will be treated as referring to all three of the
+socks5, socks4a, and socks4 proxy types.
ignore_hosts
+ is a list of hostnames and IP addresses that the resolver should allow direct connections to.
+Entries can be in one of 4 formats:
+A hostname, such as "example.com", ".example.com", or "*.example.com", any of which match "example.com" or +any subdomain of it. +
+An IPv4 or IPv6 address, such as "192.168.1.1", which matches only that address. +
+A hostname or IP address followed by a port, such as "example.com:80", which matches whatever the hostname or IP +address would match, but only for URLs with the (explicitly) indicated port. In the case of an IPv6 address, the address +part must appear in brackets: "[::1]:443" +
+An IP address range, given by a base address and prefix length, such as "fe80::/10", which matches any address in that range. +
Note that when dealing with Unicode hostnames, the matching is done against the ASCII form of the name.
+Also note that hostname exclusions apply only to connections made to hosts identified by name, and IP address exclusions apply only
+to connections made to hosts identified by address. That is, if example.com has an address of 192.168.1.1, and ignore_hosts
+
+contains only "192.168.1.1", then a connection to "example.com" will use the proxy, and a connection to 192.168.1.1" will not.
default_proxy_uri |
+the default proxy URI to use, or |
+[allow-none] | +
ignore_hosts |
+an optional list of hosts/IP addresses to not use a proxy for. |
+[allow-none][array zero-terminated=1] | +
Since: 2.16
+WebKitNetworkProxySettings *
+webkit_network_proxy_settings_copy (WebKitNetworkProxySettings *proxy_settings);
+Make a copy of the WebKitNetworkProxySettings.
+ + +Since: 2.16
+void
+webkit_network_proxy_settings_free (WebKitNetworkProxySettings *proxy_settings);
+Free the WebKitNetworkProxySettings.
+ +Since: 2.16
+void +webkit_network_proxy_settings_add_proxy_for_scheme + (+WebKitNetworkProxySettings *proxy_settings, +const gchar *scheme, +const gchar *proxy_uri);
Adds a URI-scheme-specific proxy. URIs whose scheme matches uri_scheme
+ will be proxied via proxy_uri
+.
+As with the default proxy URI, if proxy_uri
+ starts with "socks://", it will be treated as referring to
+all three of the socks5, socks4a, and socks4 proxy types.
proxy_settings |
++ | + |
scheme |
+the URI scheme to add a proxy for |
++ |
proxy_uri |
+the proxy URI to use for |
++ |
Since: 2.16
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitNotification+WebKitNotification — Object used to hold information about a notification that should be shown to the user. + |
++ |
| +guint64 + | ++webkit_notification_get_id () + | +
| const gchar * + | ++webkit_notification_get_title () + | +
| const gchar * + | ++webkit_notification_get_body () + | +
| const gchar * + | ++webkit_notification_get_tag () + | +
| +void + | ++webkit_notification_close () + | +
| +void + | ++webkit_notification_clicked () + | +
guint64
+webkit_notification_get_id (WebKitNotification *notification);
+Obtains the unique id for the notification.
+ + +Since: 2.8
+const gchar *
+webkit_notification_get_title (WebKitNotification *notification);
+Obtains the title for the notification.
+ + +Since: 2.8
+const gchar *
+webkit_notification_get_body (WebKitNotification *notification);
+Obtains the body for the notification.
+ + +Since: 2.8
+const gchar *
+webkit_notification_get_tag (WebKitNotification *notification);
+Obtains the tag identifier for the notification.
+ + +Since: 2.16
+void
+webkit_notification_close (WebKitNotification *notification);
+Closes the notification.
+ +Since: 2.8
+void
+webkit_notification_clicked (WebKitNotification *notification);
+Tells WebKit the notification has been clicked. This will emit the +“clicked” signal.
+ +Since: 2.12
+“body” property“body” gchar *+
The body for the notification.
+Flags: Read
+Default value: NULL
+Since: 2.8
+“id” property“id” guint64+
The unique id for the notification.
+Flags: Read
+Default value: 0
+Since: 2.8
+“tag” property“tag” gchar *+
The tag identifier for the notification.
+Flags: Read
+Default value: NULL
+Since: 2.16
+“title” property“title” gchar *+
The title for the notification.
+Flags: Read
+Default value: NULL
+Since: 2.8
+“clicked” signalvoid +user_function (WebKitNotification *notification, + gpointer user_data)+
Emitted when a notification has been clicked. See webkit_notification_clicked().
notification |
+the WebKitNotification on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.12
+“closed” signalvoid +user_function (WebKitNotification *notification, + gpointer user_data)+
Emitted when a notification has been withdrawn.
+The default handler will close the notification using libnotify, if built with +support for it.
+notification |
+the WebKitNotification on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.8
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitNotificationPermissionRequest+WebKitNotificationPermissionRequest — A permission request for displaying web notifications + |
++ |
+WebKitNotificationPermissionRequest implements + WebKitPermissionRequest.
+WebKitNotificationPermissionRequest represents a request for +permission to decide whether WebKit should provide the user with +notifications through the Web Notification API.
+When a WebKitNotificationPermissionRequest is not handled by the user, +it is denied by default.
+| +Top + | + |
+ |
+ |
+ |
+
| +void + | ++webkit_permission_request_allow () + | +
| +void + | ++webkit_permission_request_deny () + | +
+WebKitPermissionRequest is implemented by + WebKitDeviceInfoPermissionRequest, WebKitGeolocationPermissionRequest, WebKitInstallMissingMediaPluginsPermissionRequest, WebKitNotificationPermissionRequest and WebKitUserMediaPermissionRequest.
+There are situations where an embedder would need to ask the user +for permission to do certain types of operations, such as switching +to fullscreen mode or reporting the user's location through the +standard Geolocation API. In those cases, WebKit will emit a +“permission-request” signal with a +WebKitPermissionRequest object attached to it.
+void
+webkit_permission_request_allow (WebKitPermissionRequest *request);
+Allow the action which triggered this request.
+ +void
+webkit_permission_request_deny (WebKitPermissionRequest *request);
+Deny the action which triggered this request.
+ +| +Top + | + |
+ |
+ |
+ |
+
| const gchar * + | ++webkit_plugin_get_name () + | +
| const gchar * + | ++webkit_plugin_get_description () + | +
| const gchar * + | ++webkit_plugin_get_path () + | +
| +GList * + | ++webkit_plugin_get_mime_info_list () + | +
| +WebKitMimeInfo * + | ++webkit_mime_info_ref () + | +
| +void + | ++webkit_mime_info_unref () + | +
| const gchar * + | ++webkit_mime_info_get_mime_type () + | +
| const gchar * + | ++webkit_mime_info_get_description () + | +
| const gchar * const * + | ++webkit_mime_info_get_extensions () + | +
This object represents a single plugin, found while scanning the
+various platform plugin directories. This object can be used to get
+more information about a plugin, and enable/disable it, allowing
+fine-grained control of plugins. The list of available plugins can
+be obtained from the WebKitWebContext, with
+webkit_web_context_get_plugins().
const gchar *
+webkit_plugin_get_description (WebKitPlugin *plugin);
+
+
+GList *
+webkit_plugin_get_mime_info_list (WebKitPlugin *plugin);
+Get information about MIME types handled by the plugin, +as a list of WebKitMimeInfo.
+ + +WebKitMimeInfo *
+webkit_mime_info_ref (WebKitMimeInfo *info);
+Atomically increments the reference count of info
+ by one. This
+function is MT-safe and may be called from any thread.
void
+webkit_mime_info_unref (WebKitMimeInfo *info);
+Atomically decrements the reference count of info
+ by one. If the
+reference count drops to 0, all memory allocated by the WebKitMimeInfo is
+released. This function is MT-safe and may be called from any
+thread.
const gchar *
+webkit_mime_info_get_mime_type (WebKitMimeInfo *info);
+
+
+const gchar *
+webkit_mime_info_get_description (WebKitMimeInfo *info);
+
+
+const gchar * const *
+webkit_mime_info_get_extensions (WebKitMimeInfo *info);
+Get the list of file extensions associated to the
+MIME type of info
+
| +Top + | + |
+ |
+ |
+ |
+
| +void + | ++webkit_policy_decision_download () + | +
| +void + | ++webkit_policy_decision_ignore () + | +
| +void + | ++webkit_policy_decision_use () + | +
GObject + ╰── WebKitPolicyDecision + ├── WebKitNavigationPolicyDecision + ╰── WebKitResponsePolicyDecision ++
Often WebKit allows the client to decide the policy for certain
+operations. For instance, a client may want to open a link in a new
+tab, block a navigation entirely, query the user or trigger a download
+instead of a navigation. In these cases WebKit will fire the
+“decide-policy” signal with a WebKitPolicyDecision
+object. If the signal handler does nothing, WebKit will act as if
+webkit_policy_decision_use() was called as soon as signal handling
+completes. To make a policy decision asynchronously, simply increment
+the reference count of the WebKitPolicyDecision object.
void
+webkit_policy_decision_download (WebKitPolicyDecision *decision);
+Spawn a download from this decision.
+ +void
+webkit_policy_decision_ignore (WebKitPolicyDecision *decision);
+Ignore the action which triggered this decision. For instance, for a +WebKitResponsePolicyDecision, this would cancel the request.
+ +void
+webkit_policy_decision_use (WebKitPolicyDecision *decision);
+Accept the action which triggered this decision.
+ +| +Top + | + |
+ |
+ |
+ |
+
+WebKitResponsePolicyDecision+WebKitResponsePolicyDecision — A policy decision for resource responses + |
++ |
| +WebKitURIRequest * + | ++webkit_response_policy_decision_get_request () + | +
| +WebKitURIResponse * + | ++webkit_response_policy_decision_get_response () + | +
| +gboolean + | ++webkit_response_policy_decision_is_mime_type_supported () + | +
| +WebKitURIRequest * | +request | +Read | +
| +WebKitURIResponse * | +response | +Read | +
WebKitResponsePolicyDecision represents a policy decision for a +resource response, whether from the network or the local system. +A very common use case for these types of decision is deciding +whether or not to download a particular resource or to load it +normally.
+WebKitURIRequest *
+webkit_response_policy_decision_get_request
+ (WebKitResponsePolicyDecision *decision);
+Return the WebKitURIRequest associated with the response decision. +Modifications to the returned object are not taken +into account when the request is sent over the network, and is intended +only to aid in evaluating whether a response decision should be taken or +not. To modify requests before they are sent over the network the +“send-request” signal can be used instead.
+ + +WebKitURIResponse *
+webkit_response_policy_decision_get_response
+ (WebKitResponsePolicyDecision *decision);
+Gets the value of the “response” property.
+ + +gboolean
+webkit_response_policy_decision_is_mime_type_supported
+ (WebKitResponsePolicyDecision *decision);
+Gets whether the MIME type of the response can be displayed in the WebKitWebView
+that triggered this policy decision request. See also webkit_web_view_can_show_mime_type().
Since: 2.4
+“request” property“request” WebKitURIRequest *+
This property contains the WebKitURIRequest associated with this +policy decision.
+Flags: Read
+“response” property“response” WebKitURIResponse *+
This property contains the WebKitURIResponse associated with this +policy decision.
+Flags: Read
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitSecurityManager+WebKitSecurityManager — Controls security settings in a WebKitWebContext + |
++ |
| +void + | ++webkit_security_manager_register_uri_scheme_as_local () + | +
| +gboolean + | ++webkit_security_manager_uri_scheme_is_local () + | +
| +void + | ++webkit_security_manager_register_uri_scheme_as_no_access () + | +
| +gboolean + | ++webkit_security_manager_uri_scheme_is_no_access () + | +
| +void + | ++webkit_security_manager_register_uri_scheme_as_display_isolated () + | +
| +gboolean + | ++webkit_security_manager_uri_scheme_is_display_isolated () + | +
| +void + | ++webkit_security_manager_register_uri_scheme_as_secure () + | +
| +gboolean + | ++webkit_security_manager_uri_scheme_is_secure () + | +
| +void + | ++webkit_security_manager_register_uri_scheme_as_cors_enabled () + | +
| +gboolean + | ++webkit_security_manager_uri_scheme_is_cors_enabled () + | +
| +void + | ++webkit_security_manager_register_uri_scheme_as_empty_document () + | +
| +gboolean + | ++webkit_security_manager_uri_scheme_is_empty_document () + | +
The WebKitSecurityManager defines security settings for URI
+schemes in a WebKitWebContext. Get it from the context with
+webkit_web_context_get_security_manager(), and use it to register a
+URI scheme with a certain security level, or to check if it already
+has it.
void +webkit_security_manager_register_uri_scheme_as_local + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Register scheme
+ as a local scheme. This means that other non-local pages
+cannot link to or access URIs of this scheme.
gboolean +webkit_security_manager_uri_scheme_is_local + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Whether scheme
+ is considered as a local scheme.
+See also webkit_security_manager_register_uri_scheme_as_local().
void +webkit_security_manager_register_uri_scheme_as_no_access + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Register scheme
+ as a no-access scheme. This means that pages loaded
+with this URI scheme cannot access pages loaded with any other URI scheme.
gboolean +webkit_security_manager_uri_scheme_is_no_access + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Whether scheme
+ is considered as a no-access scheme.
+See also webkit_security_manager_register_uri_scheme_as_no_access().
void +webkit_security_manager_register_uri_scheme_as_display_isolated + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Register scheme
+ as a display isolated scheme. This means that pages cannot
+display these URIs unless they are from the same scheme.
gboolean +webkit_security_manager_uri_scheme_is_display_isolated + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Whether scheme
+ is considered as a display isolated scheme.
+See also webkit_security_manager_register_uri_scheme_as_display_isolated().
void +webkit_security_manager_register_uri_scheme_as_secure + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Register scheme
+ as a secure scheme. This means that mixed
+content warnings won't be generated for this scheme when
+included by an HTTPS page.
gboolean +webkit_security_manager_uri_scheme_is_secure + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Whether scheme
+ is considered as a secure scheme.
+See also webkit_security_manager_register_uri_scheme_as_secure().
void +webkit_security_manager_register_uri_scheme_as_cors_enabled + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Register scheme
+ as a CORS (Cross-origin resource sharing) enabled scheme.
+This means that CORS requests are allowed. See W3C CORS specification
+http://www.w3.org/TR/cors/.
gboolean +webkit_security_manager_uri_scheme_is_cors_enabled + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Whether scheme
+ is considered as a CORS enabled scheme.
+See also webkit_security_manager_register_uri_scheme_as_cors_enabled().
void +webkit_security_manager_register_uri_scheme_as_empty_document + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Register scheme
+ as an empty document scheme. This means that
+they are allowed to commit synchronously.
gboolean +webkit_security_manager_uri_scheme_is_empty_document + (+WebKitSecurityManager *security_manager, +const gchar *scheme);
Whether scheme
+ is considered as an empty document scheme.
+See also webkit_security_manager_register_uri_scheme_as_empty_document().
| +Top + | + |
+ |
+ |
+ |
+
| +WebKitSecurityOrigin * + | ++webkit_security_origin_new () + | +
| +WebKitSecurityOrigin * + | ++webkit_security_origin_new_for_uri () + | +
| +WebKitSecurityOrigin * + | ++webkit_security_origin_ref () + | +
| +void + | ++webkit_security_origin_unref () + | +
| const gchar * + | ++webkit_security_origin_get_protocol () + | +
| const gchar * + | ++webkit_security_origin_get_host () + | +
| +guint16 + | ++webkit_security_origin_get_port () + | +
| +gboolean + | ++webkit_security_origin_is_opaque () + | +
| +gchar * + | ++webkit_security_origin_to_string () + | +
WebKitSecurityOrigin is a representation of a security domain +defined by websites. A security origin normally consists of a +protocol, a hostname, and a port number. It is also possible for a +security origin to be opaque, as defined by the HTML standard, in +which case it has no associated protocol, host, or port.
+Websites with the same security origin can access each other's +resources for client-side scripting or database access.
+WebKitSecurityOrigin * +webkit_security_origin_new (+const gchar *protocol, +const gchar *host, +guint16 port);
Create a new security origin from the provided protocol, host and +port.
+protocol |
+The protocol for the new origin |
++ |
host |
+The host for the new origin |
++ |
port |
+The port number for the new origin, or 0 to indicate the
+default port for |
++ |
Since: 2.16
+WebKitSecurityOrigin *
+webkit_security_origin_new_for_uri (const gchar *uri);
+Create a new security origin from the provided URI. Components of
+uri
+ other than protocol, host, and port do not affect the created
+WebKitSecurityOrigin.
Since: 2.16
+WebKitSecurityOrigin *
+webkit_security_origin_ref (WebKitSecurityOrigin *origin);
+Atomically increments the reference count of origin
+ by one.
+This function is MT-safe and may be called from any thread.
Since: 2.16
+void
+webkit_security_origin_unref (WebKitSecurityOrigin *origin);
+Atomically decrements the reference count of origin
+ by one.
+If the reference count drops to 0, all memory allocated by
+WebKitSecurityOrigin is released. This function is MT-safe and may be
+called from any thread.
Since: 2.16
+const gchar *
+webkit_security_origin_get_protocol (WebKitSecurityOrigin *origin);
+Gets the protocol of origin
+, or NULL if origin
+ is opaque.
Since: 2.16
+const gchar *
+webkit_security_origin_get_host (WebKitSecurityOrigin *origin);
+Gets the hostname of origin
+, or NULL if origin
+ is opaque or if its
+protocol does not require a host component.
Since: 2.16
+guint16
+webkit_security_origin_get_port (WebKitSecurityOrigin *origin);
+Gets the port of origin
+. This function will always return 0 if the
+port is the default port for the given protocol. For example,
+http://example.com has the same security origin as
+http://example.com:80, and this function will return 0 for a
+WebKitSecurityOrigin constructed from either URI. It will also
+return 0 if origin
+ is opaque.
Since: 2.16
+gboolean
+webkit_security_origin_is_opaque (WebKitSecurityOrigin *origin);
+Gets whether origin
+ is an opaque security origin, which does not
+possess an associated protocol, host, or port.
Since: 2.16
+gchar *
+webkit_security_origin_to_string (WebKitSecurityOrigin *origin);
+Gets a string representation of origin
+. The string representation
+is a valid URI with only protocol, host, and port components. It may
+be NULL, but usually only if origin
+ is opaque.
Since: 2.16
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitSettings+WebKitSettings — Control the behaviour of a WebKitWebView + |
++ |
| gboolean | +allow-file-access-from-file-urls | +Read / Write / Construct | +
| gboolean | +allow-modal-dialogs | +Read / Write / Construct | +
| gboolean | +allow-universal-access-from-file-urls | +Read / Write / Construct | +
| gboolean | +auto-load-images | +Read / Write / Construct | +
| +gchar * | +cursive-font-family | +Read / Write / Construct | +
| +gchar * | +default-charset | +Read / Write / Construct | +
| +gchar * | +default-font-family | +Read / Write / Construct | +
| guint | +default-font-size | +Read / Write / Construct | +
| guint | +default-monospace-font-size | +Read / Write / Construct | +
| gboolean | +draw-compositing-indicators | +Read / Write / Construct | +
| gboolean | +enable-accelerated-2d-canvas | +Read / Write / Construct | +
| gboolean | +enable-caret-browsing | +Read / Write / Construct | +
| gboolean | +enable-developer-extras | +Read / Write / Construct | +
| gboolean | +enable-dns-prefetching | +Read / Write / Construct | +
| gboolean | +enable-encrypted-media | +Read / Write / Construct | +
| gboolean | +enable-frame-flattening | +Read / Write / Construct | +
| gboolean | +enable-fullscreen | +Read / Write / Construct | +
| gboolean | +enable-html5-database | +Read / Write / Construct | +
| gboolean | +enable-html5-local-storage | +Read / Write / Construct | +
| gboolean | +enable-hyperlink-auditing | +Read / Write / Construct | +
| gboolean | +enable-java | +Read / Write / Construct | +
| gboolean | +enable-javascript | +Read / Write / Construct | +
| gboolean | +enable-javascript-markup | +Read / Write / Construct | +
| gboolean | +enable-media-capabilities | +Read / Write / Construct | +
| gboolean | +enable-media-stream | +Read / Write / Construct | +
| gboolean | +enable-mediasource | +Read / Write / Construct | +
| gboolean | +enable-mock-capture-devices | +Read / Write / Construct | +
| gboolean | +enable-offline-web-application-cache | +Read / Write / Construct | +
| gboolean | +enable-page-cache | +Read / Write / Construct | +
| gboolean | +enable-plugins | +Read / Write / Construct | +
| gboolean | +enable-resizable-text-areas | +Read / Write / Construct | +
| gboolean | +enable-site-specific-quirks | +Read / Write / Construct | +
| gboolean | +enable-smooth-scrolling | +Read / Write / Construct | +
| gboolean | +enable-spatial-navigation | +Read / Write / Construct | +
| gboolean | +enable-tabs-to-links | +Read / Write / Construct | +
| gboolean | +enable-webaudio | +Read / Write / Construct | +
| gboolean | +enable-webgl | +Read / Write / Construct | +
| gboolean | +enable-write-console-messages-to-stdout | +Read / Write / Construct | +
| gboolean | +enable-xss-auditor | +Read / Write / Construct | +
| +gchar * | +fantasy-font-family | +Read / Write / Construct | +
| gboolean | +javascript-can-access-clipboard | +Read / Write / Construct | +
| gboolean | +javascript-can-open-windows-automatically | +Read / Write / Construct | +
| gboolean | +load-icons-ignoring-image-load-setting | +Read / Write / Construct | +
| gboolean | +media-playback-allows-inline | +Read / Write / Construct | +
| gboolean | +media-playback-requires-user-gesture | +Read / Write / Construct | +
| guint | +minimum-font-size | +Read / Write / Construct | +
| +gchar * | +monospace-font-family | +Read / Write / Construct | +
| +gchar * | +pictograph-font-family | +Read / Write / Construct | +
| gboolean | +print-backgrounds | +Read / Write / Construct | +
| +gchar * | +sans-serif-font-family | +Read / Write / Construct | +
| +gchar * | +serif-font-family | +Read / Write / Construct | +
| +gchar * | +user-agent | +Read / Write / Construct | +
| gboolean | +zoom-text-only | +Read / Write / Construct | +
WebKitSettings can be applied to a WebKitWebView to control text charset, +color, font sizes, printing mode, script support, loading of images and various +other things on a WebKitWebView. After creation, a WebKitSettings object +contains default settings.
+1 +2 +3 |
+ /* Disable JavaScript. */ +WebKitSettings *settings = webkit_web_view_group_get_settings (my_view_group); +webkit_settings_set_enable_javascript (settings, FALSE); |
+
WebKitSettings *
+webkit_settings_new (void);
+Creates a new WebKitSettings instance with default values. It must
+be manually attached to a WebKitWebView.
+See also webkit_settings_new_with_settings().
WebKitSettings * +webkit_settings_new_with_settings (+const gchar *first_setting_name, +...);
Creates a new WebKitSettings instance with the given settings. It must +be manually attached to a WebKitWebView.
+first_setting_name |
+name of first setting to set |
++ |
... |
+value of first setting, followed by more settings,
+ |
++ |
gboolean
+webkit_settings_get_auto_load_images (WebKitSettings *settings);
+Get the “auto-load-images” property.
+ + +void +webkit_settings_set_auto_load_images (+WebKitSettings *settings, +gboolean enabled);
Set the “auto-load-images” property.
+ +gboolean
+webkit_settings_get_enable_frame_flattening
+ (WebKitSettings *settings);
+Get the “enable-frame-flattening” property.
+ + +void +webkit_settings_set_enable_frame_flattening + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-frame-flattening” property.
+ +gboolean
+webkit_settings_get_enable_html5_database
+ (WebKitSettings *settings);
+Get the “enable-html5-database” property.
+ + +void +webkit_settings_set_enable_html5_database + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-html5-database” property.
+ +gboolean
+webkit_settings_get_enable_html5_local_storage
+ (WebKitSettings *settings);
+Get the “enable-html5-local-storage” property.
+ + +void +webkit_settings_set_enable_html5_local_storage + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-html5-local-storage” property.
+ +gboolean
+webkit_settings_get_enable_hyperlink_auditing
+ (WebKitSettings *settings);
+Get the “enable-hyperlink-auditing” property.
+ + +void +webkit_settings_set_enable_hyperlink_auditing + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-hyperlink-auditing” property.
+ +gboolean
+webkit_settings_get_enable_java (WebKitSettings *settings);
+Get the “enable-java” property.
+ + +void +webkit_settings_set_enable_java (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-java” property.
+ +gboolean
+webkit_settings_get_enable_javascript (WebKitSettings *settings);
+Get the “enable-javascript” property.
+ + +void +webkit_settings_set_enable_javascript (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-javascript” property.
+ +gboolean
+webkit_settings_get_enable_javascript_markup
+ (WebKitSettings *settings);
+Get the “enable-javascript-markup” property.
+ + +Since: 2.24
+void +webkit_settings_set_enable_javascript_markup + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-javascript-markup” property.
+ +Since: 2.24
+gboolean
+webkit_settings_get_enable_offline_web_application_cache
+ (WebKitSettings *settings);
+Get the “enable-offline-web-application-cache” property.
+ + +void +webkit_settings_set_enable_offline_web_application_cache + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-offline-web-application-cache” property.
+ +gboolean
+webkit_settings_get_enable_plugins (WebKitSettings *settings);
+Get the “enable-plugins” property.
+ + +void +webkit_settings_set_enable_plugins (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-plugins” property.
+ +gboolean
+webkit_settings_get_enable_xss_auditor
+ (WebKitSettings *settings);
+Get the “enable-xss-auditor” property.
+ + +void +webkit_settings_set_enable_xss_auditor + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-xss-auditor” property.
+ +gboolean
+webkit_settings_get_javascript_can_open_windows_automatically
+ (WebKitSettings *settings);
+Get the “javascript-can-open-windows-automatically” property.
+ + +void +webkit_settings_set_javascript_can_open_windows_automatically + (+WebKitSettings *settings, +gboolean enabled);
Set the “javascript-can-open-windows-automatically” property.
+ +gboolean
+webkit_settings_get_load_icons_ignoring_image_load_setting
+ (WebKitSettings *settings);
+Get the “load-icons-ignoring-image-load-setting” property.
+ + +void +webkit_settings_set_load_icons_ignoring_image_load_setting + (+WebKitSettings *settings, +gboolean enabled);
Set the “load-icons-ignoring-image-load-setting” property.
+ +const gchar *
+webkit_settings_get_default_font_family
+ (WebKitSettings *settings);
+void +webkit_settings_set_default_font_family + (+WebKitSettings *settings, +const gchar *default_font_family);
Set the “default-font-family” property.
+ +const gchar *
+webkit_settings_get_monospace_font_family
+ (WebKitSettings *settings);
+Gets the “monospace-font-family” property.
+ + +void +webkit_settings_set_monospace_font_family + (+WebKitSettings *settings, +const gchar *monospace_font_family);
Set the “monospace-font-family” property.
+ +const gchar *
+webkit_settings_get_serif_font_family (WebKitSettings *settings);
+Gets the “serif-font-family” property.
+ + +void +webkit_settings_set_serif_font_family (+WebKitSettings *settings, +const gchar *serif_font_family);
Set the “serif-font-family” property.
+ +const gchar *
+webkit_settings_get_sans_serif_font_family
+ (WebKitSettings *settings);
+Gets the “sans-serif-font-family” property.
+ + +void +webkit_settings_set_sans_serif_font_family + (+WebKitSettings *settings, +const gchar *sans_serif_font_family);
Set the “sans-serif-font-family” property.
+ +const gchar *
+webkit_settings_get_cursive_font_family
+ (WebKitSettings *settings);
+Gets the “cursive-font-family” property.
+ + +void +webkit_settings_set_cursive_font_family + (+WebKitSettings *settings, +const gchar *cursive_font_family);
Set the “cursive-font-family” property.
+ +const gchar *
+webkit_settings_get_fantasy_font_family
+ (WebKitSettings *settings);
+Gets the “fantasy-font-family” property.
+ + +void +webkit_settings_set_fantasy_font_family + (+WebKitSettings *settings, +const gchar *fantasy_font_family);
Set the “fantasy-font-family” property.
+ +const gchar *
+webkit_settings_get_pictograph_font_family
+ (WebKitSettings *settings);
+Gets the “pictograph-font-family” property.
+ + +void +webkit_settings_set_pictograph_font_family + (+WebKitSettings *settings, +const gchar *pictograph_font_family);
Set the “pictograph-font-family” property.
+ +guint32
+webkit_settings_get_default_font_size (WebKitSettings *settings);
+Gets the “default-font-size” property.
+ + +void +webkit_settings_set_default_font_size (+WebKitSettings *settings, +guint32 font_size);
Set the “default-font-size” property.
+ +guint32
+webkit_settings_get_default_monospace_font_size
+ (WebKitSettings *settings);
+Gets the “default-monospace-font-size” property.
+ + +void +webkit_settings_set_default_monospace_font_size + (+WebKitSettings *settings, +guint32 font_size);
Set the “default-monospace-font-size” property.
+ +guint32
+webkit_settings_get_minimum_font_size (WebKitSettings *settings);
+Gets the “minimum-font-size” property.
+ + +void +webkit_settings_set_minimum_font_size (+WebKitSettings *settings, +guint32 font_size);
Set the “minimum-font-size” property.
+ +const gchar *
+webkit_settings_get_default_charset (WebKitSettings *settings);
+Gets the “default-charset” property.
+ + +void +webkit_settings_set_default_charset (+WebKitSettings *settings, +const gchar *default_charset);
Set the “default-charset” property.
+ +gboolean
+webkit_settings_get_enable_developer_extras
+ (WebKitSettings *settings);
+Get the “enable-developer-extras” property.
+ + +void +webkit_settings_set_enable_developer_extras + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-developer-extras” property.
+ +gboolean
+webkit_settings_get_enable_resizable_text_areas
+ (WebKitSettings *settings);
+Get the “enable-resizable-text-areas” property.
+ + +void +webkit_settings_set_enable_resizable_text_areas + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-resizable-text-areas” property.
+ +gboolean
+webkit_settings_get_enable_tabs_to_links
+ (WebKitSettings *settings);
+Get the “enable-tabs-to-links” property.
+ + +void +webkit_settings_set_enable_tabs_to_links + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-tabs-to-links” property.
+ +gboolean
+webkit_settings_get_enable_dns_prefetching
+ (WebKitSettings *settings);
+Get the “enable-dns-prefetching” property.
+ + +void +webkit_settings_set_enable_dns_prefetching + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-dns-prefetching” property.
+ +gboolean
+webkit_settings_get_enable_caret_browsing
+ (WebKitSettings *settings);
+Get the “enable-caret-browsing” property.
+ + +void +webkit_settings_set_enable_caret_browsing + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-caret-browsing” property.
+ +gboolean
+webkit_settings_get_enable_fullscreen (WebKitSettings *settings);
+Get the “enable-fullscreen” property.
+ + +void +webkit_settings_set_enable_fullscreen (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-fullscreen” property.
+ +gboolean
+webkit_settings_get_print_backgrounds (WebKitSettings *settings);
+Get the “print-backgrounds” property.
+ + +void +webkit_settings_set_print_backgrounds (+WebKitSettings *settings, +gboolean print_backgrounds);
Set the “print-backgrounds” property.
+ +gboolean
+webkit_settings_get_enable_webaudio (WebKitSettings *settings);
+Get the “enable-webaudio” property.
+ + +void +webkit_settings_set_enable_webaudio (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-webaudio” property.
+ +gboolean
+webkit_settings_get_enable_webgl (WebKitSettings *settings);
+Get the “enable-webgl” property.
+ + +void +webkit_settings_set_enable_webgl (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-webgl” property.
+ +void +webkit_settings_set_allow_modal_dialogs + (+WebKitSettings *settings, +gboolean allowed);
Set the “allow-modal-dialogs” property.
+ +gboolean
+webkit_settings_get_allow_modal_dialogs
+ (WebKitSettings *settings);
+Get the “allow-modal-dialogs” property.
+ + +gboolean
+webkit_settings_get_zoom_text_only (WebKitSettings *settings);
+Get the “zoom-text-only” property.
+ + +void +webkit_settings_set_zoom_text_only (+WebKitSettings *settings, +gboolean zoom_text_only);
Set the “zoom-text-only” property.
+ +gboolean
+webkit_settings_get_javascript_can_access_clipboard
+ (WebKitSettings *settings);
+Get the “javascript-can-access-clipboard” property.
+ + +void +webkit_settings_set_javascript_can_access_clipboard + (+WebKitSettings *settings, +gboolean enabled);
Set the “javascript-can-access-clipboard” property.
+ +gboolean
+webkit_settings_get_media_playback_requires_user_gesture
+ (WebKitSettings *settings);
+Get the “media-playback-requires-user-gesture” property.
+ + +void +webkit_settings_set_media_playback_requires_user_gesture + (+WebKitSettings *settings, +gboolean enabled);
Set the “media-playback-requires-user-gesture” property.
+ +gboolean
+webkit_settings_get_media_playback_allows_inline
+ (WebKitSettings *settings);
+Get the “media-playback-allows-inline” property.
+ + +void +webkit_settings_set_media_playback_allows_inline + (+WebKitSettings *settings, +gboolean enabled);
Set the “media-playback-allows-inline” property.
+ +gboolean
+webkit_settings_get_draw_compositing_indicators
+ (WebKitSettings *settings);
+Get the “draw-compositing-indicators” property.
+ + +void +webkit_settings_set_draw_compositing_indicators + (+WebKitSettings *settings, +gboolean enabled);
Set the “draw-compositing-indicators” property.
+ +gboolean
+webkit_settings_get_enable_site_specific_quirks
+ (WebKitSettings *settings);
+Get the “enable-site-specific-quirks” property.
+ + +void +webkit_settings_set_enable_site_specific_quirks + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-site-specific-quirks” property.
+ +gboolean
+webkit_settings_get_enable_page_cache (WebKitSettings *settings);
+Get the “enable-page-cache” property.
+ + +void +webkit_settings_set_enable_page_cache (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-page-cache” property.
+ +const gchar *
+webkit_settings_get_user_agent (WebKitSettings *settings);
+Get the “user-agent” property.
+ + +void +webkit_settings_set_user_agent (+WebKitSettings *settings, +const gchar *user_agent);
Set the “user-agent” property.
+settings |
++ | + |
user_agent |
+The new custom user agent string or |
+[allow-none] | +
void +webkit_settings_set_user_agent_with_application_details + (+WebKitSettings *settings, +const gchar *application_name, +const gchar *application_version);
Set the “user-agent” property by appending the application details to the default user +agent. If no application name or version is given, the default user agent used will be used. If only +the version is given, the default engine version is used with the given application name.
+ +gboolean
+webkit_settings_get_enable_smooth_scrolling
+ (WebKitSettings *settings);
+Get the “enable-smooth-scrolling” property.
+ + +void +webkit_settings_set_enable_smooth_scrolling + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-smooth-scrolling” property.
+ +gboolean
+webkit_settings_get_enable_accelerated_2d_canvas
+ (WebKitSettings *settings);
+Get the “enable-accelerated-2d-canvas” property.
+ + +Since: 2.2
+void +webkit_settings_set_enable_accelerated_2d_canvas + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-accelerated-2d-canvas” property.
+ +Since: 2.2
+gboolean
+webkit_settings_get_enable_write_console_messages_to_stdout
+ (WebKitSettings *settings);
+Get the “enable-write-console-messages-to-stdout” property.
+ + +Since: 2.2
+void +webkit_settings_set_enable_write_console_messages_to_stdout + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-write-console-messages-to-stdout” property.
+ +Since: 2.2
+gboolean
+webkit_settings_get_enable_media_stream
+ (WebKitSettings *settings);
+Get the “enable-media-stream” property.
+ + +Since: 2.4
+void +webkit_settings_set_enable_media_stream + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-media-stream” property.
+ +Since: 2.4
+gboolean
+webkit_settings_get_enable_mock_capture_devices
+ (WebKitSettings *settings);
+Get the “enable-mock-capture-devices” property.
+ + +Since: 2.24
+void +webkit_settings_set_enable_mock_capture_devices + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-mock-capture-devices” property.
+ +Since: 2.4
+gboolean
+webkit_settings_get_enable_spatial_navigation
+ (WebKitSettings *settings);
+Get the “enable-spatial-navigation” property.
+ + +Since: 2.2
+void +webkit_settings_set_enable_spatial_navigation + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-spatial-navigation” property.
+ +Since: 2.2
+gboolean
+webkit_settings_get_enable_mediasource
+ (WebKitSettings *settings);
+Get the “enable-mediasource” property.
+ + +Since: 2.4
+void +webkit_settings_set_enable_mediasource + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-mediasource” property.
+ +Since: 2.4
+gboolean
+webkit_settings_get_enable_encrypted_media
+ (WebKitSettings *settings);
+Get the “enable-encrypted-media” property.
+ + +Since: 2.20
+void +webkit_settings_set_enable_encrypted_media + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-encrypted-media” property.
+ +Since: 2.20
+gboolean
+webkit_settings_get_enable_media_capabilities
+ (WebKitSettings *settings);
+Get the “enable-media-capabilities” property.
+ + +Since: 2.22
+void +webkit_settings_set_enable_media_capabilities + (+WebKitSettings *settings, +gboolean enabled);
Set the “enable-media-capabilities” property.
+ +Since: 2.22
+gboolean
+webkit_settings_get_allow_file_access_from_file_urls
+ (WebKitSettings *settings);
+Get the “allow-file-access-from-file-urls” property.
+ + +Since: 2.10
+void +webkit_settings_set_allow_file_access_from_file_urls + (+WebKitSettings *settings, +gboolean allowed);
Set the “allow-file-access-from-file-urls” property.
+ +Since: 2.10
+gboolean
+webkit_settings_get_allow_universal_access_from_file_urls
+ (WebKitSettings *settings);
+Get the “allow-universal-access-from-file-urls” property.
+ + +Since: 2.14
+void +webkit_settings_set_allow_universal_access_from_file_urls + (+WebKitSettings *settings, +gboolean allowed);
Set the “allow-universal-access-from-file-urls” property.
+ +Since: 2.14
+“allow-file-access-from-file-urls” property“allow-file-access-from-file-urls” gboolean+
Whether file access is allowed from file URLs. By default, when +something is loaded in a WebKitWebView using a file URI, cross +origin requests to other file resources are not allowed. This +setting allows you to change that behaviour, so that it would be +possible to do a XMLHttpRequest of a local file, for example.
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.10
+“allow-modal-dialogs” property“allow-modal-dialogs” gboolean+
Determine whether it's allowed to create and run modal dialogs
+from a WebKitWebView through JavaScript with
+window.showModalDialog. If it's set to
+FALSE, the associated WebKitWebView won't be able to create
+new modal dialogs, so not even the “create”
+signal will be emitted.
Flags: Read / Write / Construct
+Default value: FALSE
+“allow-universal-access-from-file-urls” property“allow-universal-access-from-file-urls” gboolean+
Whether or not JavaScript running in the context of a file scheme URL +should be allowed to access content from any origin. By default, when +something is loaded in a WebKitWebView using a file scheme URL, +access to the local file system and arbitrary local storage is not +allowed. This setting allows you to change that behaviour, so that +it would be possible to use local storage, for example.
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.14
+“auto-load-images” property“auto-load-images” gboolean+
Determines whether images should be automatically loaded or not. +On devices where network bandwidth is of concern, it might be +useful to turn this property off.
+Flags: Read / Write / Construct
+Default value: TRUE
+“cursive-font-family” property“cursive-font-family” gchar *+
The font family used as the default for content using a cursive font.
+Flags: Read / Write / Construct
+Default value: "serif"
+“default-charset” property“default-charset” gchar *+
The default text charset used when interpreting content with an unspecified charset.
+Flags: Read / Write / Construct
+Default value: "iso-8859-1"
+“default-font-family” property“default-font-family” gchar *+
The font family to use as the default for content that does not specify a font.
+Flags: Read / Write / Construct
+Default value: "sans-serif"
+“default-font-size” property“default-font-size” guint+
The default font size in pixels to use for content displayed if +no font size is specified.
+Flags: Read / Write / Construct
+Default value: 16
+“default-monospace-font-size” property“default-monospace-font-size” guint+
The default font size in pixels to use for content displayed in +monospace font if no font size is specified.
+Flags: Read / Write / Construct
+Default value: 13
+“draw-compositing-indicators” property“draw-compositing-indicators” gboolean+
Whether to draw compositing borders and repaint counters on layers drawn +with accelerated compositing. This is useful for debugging issues related +to web content that is composited with the GPU.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-accelerated-2d-canvas” property“enable-accelerated-2d-canvas” gboolean+
Enable or disable accelerated 2D canvas. Accelerated 2D canvas is only available +if WebKit was compiled with a version of Cairo including the unstable CairoGL API. +When accelerated 2D canvas is enabled, WebKit may render some 2D canvas content +using hardware accelerated drawing operations.
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.2
+“enable-caret-browsing” property“enable-caret-browsing” gboolean+
Whether to enable accessibility enhanced keyboard navigation.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-developer-extras” property“enable-developer-extras” gboolean+
Determines whether or not developer tools, such as the Web Inspector, are enabled.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-dns-prefetching” property“enable-dns-prefetching” gboolean+
Determines whether or not to prefetch domain names. DNS prefetching attempts +to resolve domain names before a user tries to follow a link.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-encrypted-media” property“enable-encrypted-media” gboolean+
Enable or disable support for Encrypted Media API on pages. +EncryptedMedia is an experimental JavaScript API for playing encrypted media in HTML. +This property will only work as intended if the EncryptedMedia feature is enabled at build time +with the ENABLE_ENCRYPTED_MEDIA flag.
+See https://www.w3.org/TR/encrypted-media/
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.20
+“enable-frame-flattening” property“enable-frame-flattening” gboolean+
Whether to enable the frame flattening. With this setting each subframe is expanded +to its contents, which will flatten all the frames to become one scrollable page. +On touch devices scrollable subframes on a page can result in a confusing user experience.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-fullscreen” property“enable-fullscreen” gboolean+
Whether to enable the Javascript Fullscreen API. The API +allows any HTML element to request fullscreen display. See also +the current draft of the spec: +http://www.w3.org/TR/fullscreen/
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-html5-database” property“enable-html5-database” gboolean+
Whether to enable HTML5 client-side SQL database support. Client-side +SQL database allows web pages to store structured data and be able to +use SQL to manipulate that data asynchronously.
+HTML5 database specification is available at +http://www.w3.org/TR/webdatabase/.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-html5-local-storage” property“enable-html5-local-storage” gboolean+
Whether to enable HTML5 local storage support. Local storage provides +simple synchronous storage access.
+HTML5 local storage specification is available at +http://dev.w3.org/html5/webstorage/.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-hyperlink-auditing” property“enable-hyperlink-auditing” gboolean+
Determines whether or not hyperlink auditing is enabled.
+The hyperlink auditing specification is available at +http://www.whatwg.org/specs/web-apps/current-work/multipage/links.htmlhyperlink-auditing.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-java” property“enable-java” gboolean+
Determines whether or not Java is enabled on the page.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-javascript” property“enable-javascript” gboolean+
Determines whether or not JavaScript executes within a page.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-javascript-markup” property“enable-javascript-markup” gboolean+
Determines whether or not JavaScript markup is allowed in document. When this setting is disabled,
+all JavaScript-related elements and attributes are removed from the document during parsing. Note that
+executing JavaScript is still allowed if “enable-javascript” is TRUE.
Flags: Read / Write / Construct
+Default value: TRUE
+Since: 2.24
+“enable-media-capabilities” property“enable-media-capabilities” gboolean+
Enable or disable support for MediaCapabilities on pages. This +specification intends to provide APIs to allow websites to make an optimal +decision when picking media content for the user. The APIs will expose +information about the decoding and encoding capabilities for a given format +but also output capabilities to find the best match based on the device’s +display.
+See also https://wicg.github.io/media-capabilities/
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.22
+“enable-media-stream” property“enable-media-stream” gboolean+
Enable or disable support for MediaStream on pages. MediaStream +is an experimental proposal for allowing web pages to access +audio and video devices for capture.
+See also http://dev.w3.org/2011/webrtc/editor/getusermedia.html
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.4
+“enable-mediasource” property“enable-mediasource” gboolean+
Enable or disable support for MediaSource on pages. MediaSource +extends HTMLMediaElement to allow JavaScript to generate media +streams for playback.
+See also http://www.w3.org/TR/media-source/
+Flags: Read / Write / Construct
+Default value: TRUE
+Since: 2.4
+“enable-mock-capture-devices” property“enable-mock-capture-devices” gboolean+
Enable or disable the Mock Capture Devices. Those are fake +Microphone and Camera devices to be used as MediaStream +sources.
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.24
+“enable-offline-web-application-cache” property“enable-offline-web-application-cache” gboolean+
Whether to enable HTML5 offline web application cache support. Offline +web application cache allows web applications to run even when +the user is not connected to the network.
+HTML5 offline web application specification is available at +http://dev.w3.org/html5/spec/offline.html.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-page-cache” property“enable-page-cache” gboolean+
Enable or disable the page cache. Disabling the page cache is +generally only useful for special circumstances like low-memory +scenarios or special purpose applications like static HTML +viewers. This setting only controls the Page Cache, this cache +is different than the disk-based or memory-based traditional +resource caches, its point is to make going back and forth +between pages much faster. For details about the different types +of caches and their purposes see: +http://webkit.org/blog/427/webkit-page-cache-i-the-basics/
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-plugins” property“enable-plugins” gboolean+
Determines whether or not plugins on the page are enabled.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-resizable-text-areas” property“enable-resizable-text-areas” gboolean+
Determines whether or not text areas can be resized.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-site-specific-quirks” property“enable-site-specific-quirks” gboolean+
Whether to turn on site-specific quirks. Turning this on will +tell WebKit to use some site-specific workarounds for +better web compatibility. For example, older versions of +MediaWiki will incorrectly send to WebKit a CSS file with KHTML +workarounds. By turning on site-specific quirks, WebKit will +special-case this and other cases to make some specific sites work.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-smooth-scrolling” property“enable-smooth-scrolling” gboolean+
Enable or disable smooth scrolling.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-spatial-navigation” property“enable-spatial-navigation” gboolean+
Whether to enable Spatial Navigation. This feature consists in the ability +to navigate between focusable elements in a Web page, such as hyperlinks +and form controls, by using Left, Right, Up and Down arrow keys. +For example, if an user presses the Right key, heuristics determine whether +there is an element they might be trying to reach towards the right, and if +there are multiple elements, which element they probably wants.
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.4
+“enable-tabs-to-links” property“enable-tabs-to-links” gboolean+
Determines whether the tab key cycles through the elements on the page. +When this setting is enabled, users will be able to focus the next element +in the page by pressing the tab key. If the selected element is editable, +then pressing tab key will insert the tab character.
+Flags: Read / Write / Construct
+Default value: TRUE
+“enable-webaudio” property“enable-webaudio” gboolean+
Enable or disable support for WebAudio on pages. WebAudio is an +experimental proposal for allowing web pages to generate Audio +WAVE data from JavaScript. The standard is currently a +work-in-progress by the W3C Audio Working Group.
+See also https://dvcs.w3.org/hg/audio/raw-file/tip/webaudio/specification.html
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-webgl” property“enable-webgl” gboolean+
Enable or disable support for WebGL on pages. WebGL is an experimental +proposal for allowing web pages to use OpenGL ES-like calls directly. The +standard is currently a work-in-progress by the Khronos Group.
+Flags: Read / Write / Construct
+Default value: FALSE
+“enable-write-console-messages-to-stdout” property“enable-write-console-messages-to-stdout” gboolean+
Enable or disable writing console messages to stdout. These are messages +sent to the console with console.log and related methods.
+Flags: Read / Write / Construct
+Default value: FALSE
+Since: 2.2
+“enable-xss-auditor” property“enable-xss-auditor” gboolean+
Whether to enable the XSS auditor. This feature filters some kinds of +reflective XSS attacks on vulnerable web sites.
+Flags: Read / Write / Construct
+Default value: TRUE
+“fantasy-font-family” property“fantasy-font-family” gchar *+
The font family used as the default for content using a fantasy font.
+Flags: Read / Write / Construct
+Default value: "serif"
+“javascript-can-access-clipboard” property“javascript-can-access-clipboard” gboolean+
Whether JavaScript can access the clipboard. The default value is FALSE. If
+set to TRUE, document.execCommand() allows cut, copy and paste commands.
Flags: Read / Write / Construct
+Default value: FALSE
+“javascript-can-open-windows-automatically” property“javascript-can-open-windows-automatically” gboolean+
Whether JavaScript can open popup windows automatically without user +intervention.
+Flags: Read / Write / Construct
+Default value: FALSE
+“load-icons-ignoring-image-load-setting” property“load-icons-ignoring-image-load-setting” gboolean+
Determines whether a site can load favicons irrespective +of the value of “auto-load-images”.
+Flags: Read / Write / Construct
+Default value: FALSE
+“media-playback-allows-inline” property“media-playback-allows-inline” gboolean+
Whether media playback is full-screen only or inline playback is allowed.
+This is TRUE by default, so media playback can be inline. Setting it to
+FALSE allows specifying that media playback should be always fullscreen.
Flags: Read / Write / Construct
+Default value: TRUE
+“media-playback-requires-user-gesture” property“media-playback-requires-user-gesture” gboolean+
Whether a user gesture (such as clicking the play button) +would be required to start media playback or load media. This is off +by default, so media playback could start automatically. +Setting it on requires a gesture by the user to start playback, or to +load the media.
+Flags: Read / Write / Construct
+Default value: FALSE
+“minimum-font-size” property“minimum-font-size” guint+
The minimum font size in pixels used to display text. This setting +controls the absolute smallest size. Values other than 0 can +potentially break page layouts.
+Flags: Read / Write / Construct
+Default value: 0
+“monospace-font-family” property“monospace-font-family” gchar *+
The font family used as the default for content using a monospace font.
+Flags: Read / Write / Construct
+Default value: "monospace"
+“pictograph-font-family” property“pictograph-font-family” gchar *+
The font family used as the default for content using a pictograph font.
+Flags: Read / Write / Construct
+Default value: "serif"
+“print-backgrounds” property“print-backgrounds” gboolean+
Whether background images should be drawn during printing.
+Flags: Read / Write / Construct
+Default value: TRUE
+“sans-serif-font-family” property“sans-serif-font-family” gchar *+
The font family used as the default for content using a sans-serif font.
+Flags: Read / Write / Construct
+Default value: "sans-serif"
+“serif-font-family” property“serif-font-family” gchar *+
The font family used as the default for content using a serif font.
+Flags: Read / Write / Construct
+Default value: "serif"
+“user-agent” property“user-agent” gchar *+
The user-agent string used by WebKit. Unusual user-agent strings may cause web
+content to render incorrectly or fail to run, as many web pages are written to
+parse the user-agent strings of only the most popular browsers. Therefore, it's
+typically better to not completely override the standard user-agent, but to use
+webkit_settings_set_user_agent_with_application_details() instead.
If this property is set to the empty string or NULL, it will revert to the standard
+user-agent.
Flags: Read / Write / Construct
+Default value: NULL
+“zoom-text-only” property“zoom-text-only” gboolean+
Whether “zoom-level” affects only the +text of the page or all the contents. Other contents containing text +like form controls will be also affected by zoom factor when +this property is enabled.
+Flags: Read / Write / Construct
+Default value: FALSE
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitURIRequest * + | ++webkit_uri_request_new () + | +
| const gchar * + | ++webkit_uri_request_get_uri () + | +
| +void + | ++webkit_uri_request_set_uri () + | +
| const gchar * + | ++webkit_uri_request_get_http_method () + | +
| +SoupMessageHeaders * + | ++webkit_uri_request_get_http_headers () + | +
A WebKitURIRequest can be created with a URI using the
+webkit_uri_request_new() method, and you can get the URI of an
+existing request with the webkit_uri_request_get_uri() one.
WebKitURIRequest *
+webkit_uri_request_new (const gchar *uri);
+Creates a new WebKitURIRequest for the given URI.
+ + +const gchar *
+webkit_uri_request_get_uri (WebKitURIRequest *request);
+
+
+void +webkit_uri_request_set_uri (+WebKitURIRequest *request, +const gchar *uri);
Set the URI of request
+
const gchar *
+webkit_uri_request_get_http_method (WebKitURIRequest *request);
+Get the HTTP method of the WebKitURIRequest.
+ + +Since: 2.12
+SoupMessageHeaders *
+webkit_uri_request_get_http_headers (WebKitURIRequest *request);
+Get the HTTP headers of a WebKitURIRequest as a SoupMessageHeaders.
+ +a SoupMessageHeaders with the HTTP headers of request
+or NULL if request
+is not an HTTP request.
[transfer none]
+“uri” property“uri” gchar *+
The URI to which the request will be made.
+Flags: Read / Write / Construct
+Default value: "about:blank"
+| +Top + | + |
+ |
+ |
+ |
+
| const gchar * + | ++webkit_uri_response_get_uri () + | +
| +guint + | ++webkit_uri_response_get_status_code () + | +
| +guint64 + | ++webkit_uri_response_get_content_length () + | +
| const gchar * + | ++webkit_uri_response_get_mime_type () + | +
| const gchar * + | ++webkit_uri_response_get_suggested_filename () + | +
| +SoupMessageHeaders * + | ++webkit_uri_response_get_http_headers () + | +
| guint64 | +content-length | +Read | +
| +SoupMessageHeaders * | +http-headers | +Read | +
| +gchar * | +mime-type | +Read | +
| guint | +status-code | +Read | +
| +gchar * | +suggested-filename | +Read | +
| +gchar * | +uri | +Read | +
A WebKitURIResponse contains information such as the URI, the +status code, the content length, the mime type, the HTTP status or +the suggested filename.
+const gchar *
+webkit_uri_response_get_uri (WebKitURIResponse *response);
+
+
+guint
+webkit_uri_response_get_status_code (WebKitURIResponse *response);
+Get the status code of the WebKitURIResponse as returned by
+the server. It will normally be a SoupKnownStatusCode, for
+example SOUP_STATUS_OK, though the server can respond with any
+unsigned integer.
guint64
+webkit_uri_response_get_content_length
+ (WebKitURIResponse *response);
+Get the expected content length of the WebKitURIResponse. It can +be 0 if the server provided an incorrect or missing Content-Length.
+ + +const gchar *
+webkit_uri_response_get_mime_type (WebKitURIResponse *response);
+
+
+const gchar *
+webkit_uri_response_get_suggested_filename
+ (WebKitURIResponse *response);
+Get the suggested filename for response
+, as specified by
+the 'Content-Disposition' HTTP header, or NULL if it's not
+present.
the suggested filename or NULL if
+the 'Content-Disposition' HTTP header is not present.
[transfer none]
+SoupMessageHeaders *
+webkit_uri_response_get_http_headers (WebKitURIResponse *response);
+Get the HTTP headers of a WebKitURIResponse as a SoupMessageHeaders.
+ +a SoupMessageHeaders with the HTTP headers of response
+or NULL if response
+is not an HTTP response.
[transfer none]
+Since: 2.6
+“content-length” property“content-length” guint64+
The expected content length of the response.
+Flags: Read
+Default value: 0
+“http-headers” property“http-headers” SoupMessageHeaders *+
The HTTP headers of the response, or NULL if the response is not an HTTP response.
Flags: Read
+Since: 2.6
+“mime-type” property“mime-type” gchar *+
The MIME type of the response.
+Flags: Read
+Default value: NULL
+“status-code” property“status-code” guint+
The status code of the response as returned by the server.
+Flags: Read
+Default value: 0
+“suggested-filename” property“suggested-filename” gchar *+
The suggested filename for the URI response.
+Flags: Read
+Default value: NULL
+“uri” property“uri” gchar *+
The URI for which the response was made.
+Flags: Read
+Default value: NULL
+| +Top + | + |
+ |
+ |
+ |
+
| const gchar * + | ++webkit_uri_scheme_request_get_scheme () + | +
| const gchar * + | ++webkit_uri_scheme_request_get_uri () + | +
| const gchar * + | ++webkit_uri_scheme_request_get_path () + | +
| +WebKitWebView * + | ++webkit_uri_scheme_request_get_web_view () + | +
| +void + | ++webkit_uri_scheme_request_finish () + | +
| +void + | ++webkit_uri_scheme_request_finish_error () + | +
If you register a particular URI scheme in a WebKitWebContext,
+using webkit_web_context_register_uri_scheme(), you have to provide
+a WebKitURISchemeRequestCallback. After that, when a URI request
+is made with that particular scheme, your callback will be
+called. There you will be able to access properties such as the
+scheme, the URI and path, and the WebKitWebView that initiated the
+request, and also finish the request with
+webkit_uri_scheme_request_finish().
const gchar *
+webkit_uri_scheme_request_get_scheme (WebKitURISchemeRequest *request);
+Get the URI scheme of request
+
const gchar *
+webkit_uri_scheme_request_get_uri (WebKitURISchemeRequest *request);
+Get the URI of request
+
const gchar *
+webkit_uri_scheme_request_get_path (WebKitURISchemeRequest *request);
+Get the URI path of request
+
WebKitWebView *
+webkit_uri_scheme_request_get_web_view
+ (WebKitURISchemeRequest *request);
+Get the WebKitWebView that initiated the request.
+ + +void +webkit_uri_scheme_request_finish (+WebKitURISchemeRequest *request, +GInputStream *stream, +gint64 stream_length, +const gchar *mime_type);
Finish a WebKitURISchemeRequest by setting the contents of the request and its mime type.
+request |
++ | + |
stream |
+a GInputStream to read the contents of the request |
++ |
stream_length |
+the length of the stream or -1 if not known |
++ |
mime_type |
+the content type of the stream or |
+[allow-none] | +
void +webkit_uri_scheme_request_finish_error + (+WebKitURISchemeRequest *request, +GError *error);
Finish a WebKitURISchemeRequest with a GError.
+request |
++ | + |
error |
+a GError that will be passed to the WebKitWebView |
++ |
Since: 2.2
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitUserContentManager+WebKitUserContentManager — Manages user-defined content which affects web pages. + |
++ |
| +WebKitUserContentManager * + | ++webkit_user_content_manager_new () + | +
| +void + | ++webkit_user_content_manager_add_style_sheet () + | +
| +void + | ++webkit_user_content_manager_remove_all_style_sheets () + | +
| +void + | ++webkit_user_content_manager_add_script () + | +
| +void + | ++webkit_user_content_manager_remove_all_scripts () + | +
| +gboolean + | ++webkit_user_content_manager_register_script_message_handler () + | +
| +void + | ++webkit_user_content_manager_unregister_script_message_handler () + | +
| +gboolean + | ++webkit_user_content_manager_register_script_message_handler_in_world () + | +
| +void + | ++webkit_user_content_manager_unregister_script_message_handler_in_world () + | +
| +void + | ++webkit_user_content_manager_add_filter () + | +
| +void + | ++webkit_user_content_manager_remove_filter () + | +
| +void + | ++webkit_user_content_manager_remove_all_filters () + | +
Using a WebKitUserContentManager user CSS style sheets can be set to
+be injected in the web pages loaded by a WebKitWebView, by
+webkit_user_content_manager_add_style_sheet().
To use a WebKitUserContentManager, it must be created using
+webkit_user_content_manager_new(), and then passed to
+webkit_web_view_new_with_user_content_manager(). User style
+sheets can be created with webkit_user_style_sheet_new().
User style sheets can be added and removed at any time, but +they will affect the web pages loaded afterwards.
+WebKitUserContentManager *
+webkit_user_content_manager_new (void);
+Creates a new user content manager.
+ +Since: 2.6
+void +webkit_user_content_manager_add_style_sheet + (+WebKitUserContentManager *manager, +WebKitUserStyleSheet *stylesheet);
Adds a WebKitUserStyleSheet to the given WebKitUserContentManager. +The same WebKitUserStyleSheet can be reused with multiple +WebKitUserContentManager instances.
+ +Since: 2.6
+void
+webkit_user_content_manager_remove_all_style_sheets
+ (WebKitUserContentManager *manager);
+Removes all user style sheets from the given WebKitUserContentManager.
+ +Since: 2.6
+void +webkit_user_content_manager_add_script + (+WebKitUserContentManager *manager, +WebKitUserScript *script);
Adds a WebKitUserScript to the given WebKitUserContentManager. +The same WebKitUserScript can be reused with multiple +WebKitUserContentManager instances.
+ +Since: 2.6
+void
+webkit_user_content_manager_remove_all_scripts
+ (WebKitUserContentManager *manager);
+Removes all user scripts from the given WebKitUserContentManager
+ +Since: 2.6
+gboolean +webkit_user_content_manager_register_script_message_handler + (+WebKitUserContentManager *manager, +const gchar *name);
Registers a new user script message handler. After it is registered,
+scripts can use window.webkit.messageHandlers.<name>.postMessage(value)
+to send messages. Those messages are received by connecting handlers
+to the “script-message-received” signal. The
+handler name is used as the detail of the signal. To avoid race
+conditions between registering the handler name, and starting to
+receive the signals, it is recommended to connect to the signal
+*before* registering the handler name:
1 +2 +3 +4 +5 |
+ WebKitWebView *view = webkit_web_view_new (); +WebKitUserContentManager *manager = webkit_web_view_get_user_content_manager (); +g_signal_connect (manager, "script-message-received::foobar", + G_CALLBACK (handle_script_message), NULL); +webkit_user_content_manager_register_script_message_handler (manager, "foobar"); |
+
Registering a script message handler will fail if the requested +name has been already registered before.
+ + +Since: 2.8
+void +webkit_user_content_manager_unregister_script_message_handler + (+WebKitUserContentManager *manager, +const gchar *name);
Unregisters a previously registered message handler.
+Note that this does *not* disconnect handlers for the +“script-message-received” signal; +they will be kept connected, but the signal will not be emitted +unless the handler name is registered again.
+See also webkit_user_content_manager_register_script_message_handler().
Since: 2.8
+gboolean +webkit_user_content_manager_register_script_message_handler_in_world + (+WebKitUserContentManager *manager, +const gchar *name, +const gchar *world_name);
Registers a new user script message handler in script world with name world_name
+.
+See webkit_user_content_manager_register_script_message_handler() for full description.
Registering a script message handler will fail if the requested +name has been already registered before.
+manager |
++ | + |
name |
+Name of the script message channel |
++ |
world_name |
+the name of a WebKitScriptWorld |
++ |
Since: 2.22
+void +webkit_user_content_manager_unregister_script_message_handler_in_world + (+WebKitUserContentManager *manager, +const gchar *name, +const gchar *world_name);
Unregisters a previously registered message handler in script world with name world_name
+.
Note that this does *not* disconnect handlers for the +“script-message-received” signal; +they will be kept connected, but the signal will not be emitted +unless the handler name is registered again.
+See also webkit_user_content_manager_register_script_message_handler_in_world().
manager |
++ | + |
name |
+Name of the script message channel |
++ |
world_name |
+the name of a WebKitScriptWorld |
++ |
Since: 2.22
+void +webkit_user_content_manager_add_filter + (+WebKitUserContentManager *manager, +WebKitUserContentFilter *filter);
Adds a WebKitUserContentFilter to the given WebKitUserContentManager. +The same WebKitUserContentFilter can be reused with multiple +WebKitUserContentManager instances.
+Filters need to be saved and loaded from WebKitUserContentFilterStore.
+ +Since: 2.24
+void +webkit_user_content_manager_remove_filter + (+WebKitUserContentManager *manager, +WebKitUserContentFilter *filter);
Removes a filter from the given WebKitUserContentManager.
+Since 2.24
+ +void
+webkit_user_content_manager_remove_all_filters
+ (WebKitUserContentManager *manager);
+Removes all content filters from the given WebKitUserContentManager.
+ +Since: 2.24
+“script-message-received” signalvoid +user_function (WebKitUserContentManager *manager, + WebKitJavascriptResult *js_result, + gpointer user_data)+
This signal is emitted when JavaScript in a web view calls
+window.webkit.messageHandlers.<name>.postMessage(), after registering
+<name> using
+webkit_user_content_manager_register_script_message_handler()
+manager |
++ | + |
js_result |
+the WebKitJavascriptResult holding the value received from the JavaScript world. |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Has Details
+Since: 2.8
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitUserMediaPermissionRequest+WebKitUserMediaPermissionRequest — A permission request for accessing user's audio/video devices. + |
++ |
| +gboolean + | ++webkit_user_media_permission_is_for_audio_device () + | +
| +gboolean + | ++webkit_user_media_permission_is_for_video_device () + | +
| gboolean | +is-for-audio-device | +Read | +
| gboolean | +is-for-video-device | +Read | +
WebKitUserMediaPermissionRequest represents a request for +permission to decide whether WebKit should be allowed to access the user's +audio and video source devices when requested through the getUserMedia API.
+When a WebKitUserMediaPermissionRequest is not handled by the user, +it is denied by default.
+gboolean
+webkit_user_media_permission_is_for_audio_device
+ (WebKitUserMediaPermissionRequest *request);
+
+
+Since: 2.8
+gboolean
+webkit_user_media_permission_is_for_video_device
+ (WebKitUserMediaPermissionRequest *request);
+
+
+Since: 2.8
+“is-for-audio-device” property“is-for-audio-device” gboolean+
Whether the media device to which the permission was requested has a microphone or not.
+Flags: Read
+Default value: FALSE
+“is-for-video-device” property“is-for-video-device” gboolean+
Whether the media device to which the permission was requested has a video capture capability or not.
+Flags: Read
+Default value: FALSE
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitWebContext+WebKitWebContext — Manages aspects common to all WebKitWebViews + |
++ |
| +WebKitWebsiteDataManager * | +website-data-manager | +Read / Write / Construct Only | +
| void | +automation-started | +Run Last | +
| void | +download-started | +Run Last | +
| void | +initialize-notification-permissions | +Run Last | +
| void | +initialize-web-extensions | +Run Last | +
| struct | +WebKitWebContext | +
| enum | +WebKitCacheModel | +
| enum | +WebKitProcessModel | +
| enum | +WebKitTLSErrorsPolicy | +
| enum | +WebKitNetworkProxyMode | +
The WebKitWebContext manages all aspects common to all +WebKitWebViews.
+You can define the WebKitCacheModel and WebKitProcessModel with
+webkit_web_context_set_cache_model() and
+webkit_web_context_set_process_model(), depending on the needs of
+your application. You can access the WebKitSecurityManager to specify
+the behaviour of your application regarding security using
+webkit_web_context_get_security_manager().
It is also possible to change your preferred language or enable
+spell checking, using webkit_web_context_set_preferred_languages(),
+webkit_web_context_set_spell_checking_languages() and
+webkit_web_context_set_spell_checking_enabled().
You can use webkit_web_context_register_uri_scheme() to register
+custom URI schemes, and manage several other settings.
TLS certificate validation failure is now treated as a transport
+error by default. To handle TLS failures differently, you can
+connect to “load-failed-with-tls-errors”.
+Alternatively, you can use webkit_web_context_set_tls_errors_policy()
+to set the policy WEBKIT_TLS_ERRORS_POLICY_IGNORE; however, this is
+not appropriate for Internet applications.
WebKitWebContext *
+webkit_web_context_get_default (void);
+Gets the default web context
+ +WebKitWebContext *
+webkit_web_context_new (void);
+Create a new WebKitWebContext
+ +Since: 2.8
+WebKitWebContext *
+webkit_web_context_new_ephemeral (void);
+Create a new ephemeral WebKitWebContext. An ephemeral WebKitWebContext is a context +created with an ephemeral WebKitWebsiteDataManager. This is just a convenient method +to create ephemeral contexts without having to create your own WebKitWebsiteDataManager. +All WebKitWebViews associated with this context will also be ephemeral. Websites will +not store any data in the client storage. +This is normally used to implement private instances.
+ +Since: 2.16
+WebKitWebContext *
+webkit_web_context_new_with_website_data_manager
+ (WebKitWebsiteDataManager *manager);
+Create a new WebKitWebContext with a WebKitWebsiteDataManager.
+ + +Since: 2.10
+gboolean
+webkit_web_context_is_ephemeral (WebKitWebContext *context);
+Get whether a WebKitWebContext is ephemeral.
+ + +Since: 2.16
+gboolean
+webkit_web_context_is_automation_allowed
+ (WebKitWebContext *context);
+Get whether automation is allowed in context
+.
+See also webkit_web_context_set_automation_allowed().
Since: 2.18
+void +webkit_web_context_set_automation_allowed + (+WebKitWebContext *context, +gboolean allowed);
Set whether automation is allowed in context
+. When automation is enabled the browser could
+be controlled by another process by requesting an automation session. When a new automation
+session is requested the signal “automation-started” is emitted.
+Automation is disabled by default, so you need to explicitly call this method passing TRUE
+to enable it.
Note that only one WebKitWebContext can have automation enabled, so this will do nothing +if there's another WebKitWebContext with automation already enabled.
+ +Since: 2.18
+WebKitWebsiteDataManager *
+webkit_web_context_get_website_data_manager
+ (WebKitWebContext *context);
+Get the WebKitWebsiteDataManager of context
+.
Since: 2.10
+WebKitCacheModel
+webkit_web_context_get_cache_model (WebKitWebContext *context);
+Returns the current cache model. For more information about this
+value check the documentation of the function
+webkit_web_context_set_cache_model().
void +webkit_web_context_set_cache_model (+WebKitWebContext *context, +WebKitCacheModel cache_model);
Specifies a usage model for WebViews, which WebKit will use to +determine its caching behavior. All web views follow the cache +model. This cache model determines the RAM and disk space to use +for caching previously viewed content .
+Research indicates that users tend to browse within clusters of +documents that hold resources in common, and to revisit previously +visited documents. WebKit and the frameworks below it include +built-in caches that take advantage of these patterns, +substantially improving document load speed in browsing +situations. The WebKit cache model controls the behaviors of all of +these caches, including various WebCore caches.
+Browsers can improve document load speed substantially by
+specifying WEBKIT_CACHE_MODEL_WEB_BROWSER. Applications without a
+browsing interface can reduce memory usage substantially by
+specifying WEBKIT_CACHE_MODEL_DOCUMENT_VIEWER. The default value is
+WEBKIT_CACHE_MODEL_WEB_BROWSER.
guint
+webkit_web_context_get_web_process_count_limit
+ (WebKitWebContext *context);
+Gets the maximum number of web processes that can be created at the same time for the context
+.
Since: 2.10
+void +webkit_web_context_set_web_process_count_limit + (+WebKitWebContext *context, +guint limit);
Sets the maximum number of web processes that can be created at the same time for the context
+.
+The default value is 0 and means no limit.
This method **must be called before any web process has been created**, +as early as possible in your application. Calling it later will make +your application crash.
+context |
+the WebKitWebContext |
++ |
limit |
+the maximum number of web processes |
++ |
Since: 2.10
+void
+webkit_web_context_clear_cache (WebKitWebContext *context);
+Clears all resources currently cached.
+See also webkit_web_context_set_cache_model().
void +webkit_web_context_set_network_proxy_settings + (+WebKitWebContext *context, +WebKitNetworkProxyMode proxy_mode, +WebKitNetworkProxySettings *proxy_settings);
Set the network proxy settings to be used by connections started in context
+.
+By default WEBKIT_NETWORK_PROXY_MODE_DEFAULT is used, which means that the
+system settings will be used (g_proxy_resolver_get_default()).
+If you want to override the system default settings, you can either use
+WEBKIT_NETWORK_PROXY_MODE_NO_PROXY to make sure no proxies are used at all,
+or WEBKIT_NETWORK_PROXY_MODE_CUSTOM to provide your own proxy settings.
+When proxy_mode
+ is WEBKIT_NETWORK_PROXY_MODE_CUSTOM proxy_settings
+ must be
+a valid WebKitNetworkProxySettings; otherwise, proxy_settings
+ must be NULL.
context |
++ | + |
proxy_mode |
++ | + |
proxy_settings |
+a WebKitNetworkProxySettings, or |
+[allow-none] | +
Since: 2.16
+WebKitDownload * +webkit_web_context_download_uri (+WebKitWebContext *context, +const gchar *uri);
Requests downloading of the specified URI string. The download operation
+will not be associated to any WebKitWebView, if you are interested in
+starting a download from a particular WebKitWebView use
+webkit_web_view_download_uri() instead.
WebKitCookieManager *
+webkit_web_context_get_cookie_manager (WebKitWebContext *context);
+Get the WebKitCookieManager of the context
+'s WebKitWebsiteDataManager.
WebKitFaviconDatabase *
+webkit_web_context_get_favicon_database
+ (WebKitWebContext *context);
+Get the WebKitFaviconDatabase associated with context
+.
To initialize the database you need to call
+webkit_web_context_set_favicon_database_directory().
void +webkit_web_context_set_favicon_database_directory + (+WebKitWebContext *context, +const gchar *path);
Set the directory path to be used to store the favicons database
+for context
+ on disk. Passing NULL as path
+ means using the
+default directory for the platform (see g_get_user_cache_dir()).
Calling this method also means enabling the favicons database for +its use from the applications, so that's why it's expected to be +called only once. Further calls for the same instance of +WebKitWebContext won't cause any effect.
+context |
++ | + |
path |
+an absolute path to the icon database
+directory or |
+[allow-none] | +
const gchar *
+webkit_web_context_get_favicon_database_directory
+ (WebKitWebContext *context);
+Get the directory path being used to store the favicons database
+for context
+, or NULL if
+webkit_web_context_set_favicon_database_directory() hasn't been
+called yet.
This function will always return the same path after having called
+webkit_web_context_set_favicon_database_directory() for the first
+time.
the path of the directory of the favicons
+database associated with context
+, or NULL.
[transfer none]
+WebKitSecurityManager *
+webkit_web_context_get_security_manager
+ (WebKitWebContext *context);
+Get the WebKitSecurityManager of context
+.
void +webkit_web_context_set_additional_plugins_directory + (+WebKitWebContext *context, +const gchar *directory);
Set an additional directory where WebKit will look for plugins.
+ +void +webkit_web_context_get_plugins (+WebKitWebContext *context, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously get the list of installed plugins.
+When the operation is finished, callback
+ will be called. You can then call
+webkit_web_context_get_plugins_finish() to get the result of the operation.
context |
++ | + |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
GList * +webkit_web_context_get_plugins_finish (+WebKitWebContext *context, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_context_get_plugins.
+context |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
a GList of WebKitPlugin. You must free the GList with
+g_list_free() and unref the WebKitPlugins with g_object_unref() when you're done with them.
[element-type WebKitPlugin][transfer full]
+gboolean
+webkit_web_context_get_spell_checking_enabled
+ (WebKitWebContext *context);
+Get whether spell checking feature is currently enabled.
+ + +void +webkit_web_context_set_spell_checking_enabled + (+WebKitWebContext *context, +gboolean enabled);
Enable or disable the spell checking feature.
+ +const gchar * const *
+webkit_web_context_get_spell_checking_languages
+ (WebKitWebContext *context);
+Get the the list of spell checking languages associated with
+context
+, or NULL if no languages have been previously set.
See webkit_web_context_set_spell_checking_languages() for more
+details on the format of the languages in the list.
void +webkit_web_context_set_spell_checking_languages + (+WebKitWebContext *context, +const gchar * const *languages);
Set the list of spell checking languages to be used for spell +checking.
+The locale string typically is in the form lang_COUNTRY, where lang +is an ISO-639 language code, and COUNTRY is an ISO-3166 country code. +For instance, sv_FI for Swedish as written in Finland or pt_BR +for Portuguese as written in Brazil.
+You need to call this function with a valid list of languages at +least once in order to properly enable the spell checking feature +in WebKit.
+context |
++ | + |
languages |
+a |
+[array zero-terminated=1][transfer none] | +
void +webkit_web_context_set_preferred_languages + (+WebKitWebContext *context, +const gchar * const *languages);
Set the list of preferred languages, sorted from most desirable +to least desirable. The list will be used to build the "Accept-Language" +header that will be included in the network requests started by +the WebKitWebContext.
+context |
++ | + |
languages |
+a |
+[allow-none][array zero-terminated=1][element-type utf8][transfer none] | +
void +webkit_web_context_set_tls_errors_policy + (+WebKitWebContext *context, +WebKitTLSErrorsPolicy policy);
Set the TLS errors policy of context
+ as policy
+
WebKitTLSErrorsPolicy
+webkit_web_context_get_tls_errors_policy
+ (WebKitWebContext *context);
+Get the TLS errors policy of context
+
void +webkit_web_context_set_web_extensions_directory + (+WebKitWebContext *context, +const gchar *directory);
Set the directory where WebKit will look for Web Extensions. +This method must be called before loading anything in this context, +otherwise it will not have any effect. You can connect to +“initialize-web-extensions” to call this method +before anything is loaded.
+ +void +webkit_web_context_set_web_extensions_initialization_user_data + (+WebKitWebContext *context, +GVariant *user_data);
Set user data to be passed to Web Extensions on initialization. +The data will be passed to the +WebKitWebExtensionInitializeWithUserDataFunction. +This method must be called before loading anything in this context, +otherwise it will not have any effect. You can connect to +“initialize-web-extensions” to call this method +before anything is loaded.
+ +Since: 2.4
+void +webkit_web_context_prefetch_dns (+WebKitWebContext *context, +const gchar *hostname);
Resolve the domain name of the given hostname
+ in advance, so that if a URI
+of hostname
+ is requested the load will be performed more quickly.
void +webkit_web_context_allow_tls_certificate_for_host + (+WebKitWebContext *context, +GTlsCertificate *certificate, +const gchar *host);
Ignore further TLS errors on the host
+ for the certificate present in info
+.
context |
++ | + |
certificate |
++ | + |
host |
+the host for which a certificate is to be allowed |
++ |
Since: 2.6
+WebKitProcessModel
+webkit_web_context_get_process_model (WebKitWebContext *context);
+Returns the current process model. For more information about this value
+see webkit_web_context_set_process_model().
Since: 2.4
+void +webkit_web_context_set_process_model (+WebKitWebContext *context, +WebKitProcessModel process_model);
Specifies a process model for WebViews, which WebKit will use to
+determine how auxiliary processes are handled. The default setting
+(WEBKIT_PROCESS_MODEL_SHARED_SECONDARY_PROCESS) is suitable for most
+applications which embed a small amount of WebViews, or are used to
+display documents which are considered safe — like local files.
Applications which may potentially use a large amount of WebViews
+—for example a multi-tabbed web browser— may want to use
+WEBKIT_PROCESS_MODEL_MULTIPLE_SECONDARY_PROCESSES, which will use
+one process per view most of the time, while still allowing for web
+views to share a process when needed (for example when different
+views interact with each other). Using this model, when a process
+hangs or crashes, only the WebViews using it stop working, while
+the rest of the WebViews in the application will still function
+normally.
This method **must be called before any web process has been created**, +as early as possible in your application. Calling it later will make +your application crash.
+ +Since: 2.4
+void +webkit_web_context_initialize_notification_permissions + (+WebKitWebContext *context, +GList *allowed_origins, +GList *disallowed_origins);
Sets initial desktop notification permissions for the context
+.
+allowed_origins
+ and disallowed_origins
+ must each be GList of
+WebKitSecurityOrigin objects representing origins that will,
+respectively, either always or never have permission to show desktop
+notifications. No WebKitNotificationPermissionRequest will ever be
+generated for any of the security origins represented in
+allowed_origins
+ or disallowed_origins
+. This function is necessary
+because some webpages proactively check whether they have permission
+to display notifications without ever creating a permission request.
This function only affects web processes that have not already been +created. The best time to call it is when handling +“initialize-notification-permissions” so as to +ensure that new web processes receive the most recent set of +permissions.
+context |
+the WebKitWebContext |
++ |
allowed_origins |
+a GList of security origins. |
+[element-type WebKitSecurityOrigin] | +
disallowed_origins |
+a GList of security origins. |
+[element-type WebKitSecurityOrigin] | +
Since: 2.16
+void +(*WebKitURISchemeRequestCallback) (+WebKitURISchemeRequest *request, +gpointer user_data);
Type definition for a function that will be called back when an URI request is +made for a user registered URI scheme.
+ +void +webkit_web_context_register_uri_scheme + (+WebKitWebContext *context, +const gchar *scheme, +WebKitURISchemeRequestCallback callback, +gpointer user_data, +GDestroyNotify user_data_destroy_func);
Register scheme
+ in context
+, so that when an URI request with scheme
+ is made in the
+WebKitWebContext, the WebKitURISchemeRequestCallback registered will be called with a
+WebKitURISchemeRequest.
+It is possible to handle URI scheme requests asynchronously, by calling g_object_ref() on the
+WebKitURISchemeRequest and calling webkit_uri_scheme_request_finish() later
+when the data of the request is available or
+webkit_uri_scheme_request_finish_error() in case of error.
1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 |
+ static void +about_uri_scheme_request_cb (WebKitURISchemeRequest *request, + gpointer user_data) +{ + GInputStream *stream; + gsize stream_length; + const gchar *path; + + path = webkit_uri_scheme_request_get_path (request); + if (!g_strcmp0 (path, "plugins")) { + /* Create a GInputStream with the contents of plugins about page, and set its length to stream_length */ + } else if (!g_strcmp0 (path, "memory")) { + /* Create a GInputStream with the contents of memory about page, and set its length to stream_length */ + } else if (!g_strcmp0 (path, "applications")) { + /* Create a GInputStream with the contents of applications about page, and set its length to stream_length */ + } else if (!g_strcmp0 (path, "example")) { + gchar *contents; + + contents = g_strdup_printf ("<html><body><p>Example about page</p></body></html>"); + stream_length = strlen (contents); + stream = g_memory_input_stream_new_from_data (contents, stream_length, g_free); + } else { + GError *error; + + error = g_error_new (ABOUT_HANDLER_ERROR, ABOUT_HANDLER_ERROR_INVALID, "Invalid about:%s page.", path); + webkit_uri_scheme_request_finish_error (request, error); + g_error_free (error); + return; + } + webkit_uri_scheme_request_finish (request, stream, stream_length, "text/html"); + g_object_unref (stream); +} |
+
Enum values used for determining the WebKitWebContext cache model.
+| + |
+ Disable the cache completely, which + substantially reduces memory usage. Useful for applications that only + access a single local file, with no navigation to other pages. No remote + resources will be cached. + |
++ |
| + |
+ Improve document load speed substantially + by caching a very large number of resources and previously viewed content. + |
++ |
| + |
+ A cache model optimized for viewing + a series of local files -- for example, a documentation viewer or a website + designer. WebKit will cache a moderate number of resources. + |
++ |
Enum values used for determining the WebKitWebContext process model.
+| + |
+ Use a single process to + perform content rendering. The process is shared among all the + WebKitWebView instances created by the application: if the process + hangs or crashes all the web views in the application will be affected. + This is the default process model, and it should suffice for most cases. + |
++ |
| + |
+ Use one process + for each WebKitWebView, while still allowing for some of them to + share a process in certain situations. The main advantage + of this process model is that the rendering process for a web view + can crash while the rest of the views keep working normally. This + process model is indicated for applications which may use a number + of web views and the content of in each must not interfere with the + rest — for example a full-fledged web browser with support for + multiple tabs. + |
++ |
Since: 2.4
+Enum values used to denote the TLS errors policy.
+| + |
+ Ignore TLS errors. + |
++ |
| + |
+ TLS errors will emit + “load-failed-with-tls-errors” and, if the signal is handled, + finish the load. In case the signal is not handled, + “load-failed” is emitted before the load finishes. + |
++ |
“website-data-manager” property“website-data-manager” WebKitWebsiteDataManager *+
The WebKitWebsiteDataManager associated with this context.
+Flags: Read / Write / Construct Only
+Since: 2.10
+“automation-started” signalvoid +user_function (WebKitWebContext *context, + WebKitAutomationSession *session, + gpointer user_data)+
This signal is emitted when a new automation request is made.
+Note that it will never be emitted if automation is not enabled in context
+,
+see webkit_web_context_set_automation_allowed() for more details.
context |
+the WebKitWebContext |
++ |
session |
+the WebKitAutomationSession associated with this event |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.18
+“download-started” signalvoid +user_function (WebKitWebContext *context, + WebKitDownload *download, + gpointer user_data)+
This signal is emitted when a new download request is made.
+context |
+the WebKitWebContext |
++ |
download |
+the WebKitDownload associated with this event |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“initialize-notification-permissions” signalvoid +user_function (WebKitWebContext *context, + gpointer user_data)+
This signal is emitted when a WebKitWebContext needs to set
+initial notification permissions for a web process. It is emitted
+when a new web process is about to be launched, and signals the
+most appropriate moment to use
+webkit_web_context_initialize_notification_permissions(). If no
+notification permissions have changed since the last time this
+signal was emitted, then there is no need to call
+webkit_web_context_initialize_notification_permissions() again.
context |
+the WebKitWebContext |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.16
+“initialize-web-extensions” signalvoid +user_function (WebKitWebContext *context, + gpointer user_data)+
This signal is emitted when a new web process is about to be
+launched. It signals the most appropriate moment to use
+webkit_web_context_set_web_extensions_initialization_user_data()
+and webkit_web_context_set_web_extensions_directory().
context |
+the WebKitWebContext |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.4
+| +Top + | + |
+ |
+ |
+ |
+
| const gchar * + | ++webkit_web_resource_get_uri () + | +
| +WebKitURIResponse * + | ++webkit_web_resource_get_response () + | +
| +void + | ++webkit_web_resource_get_data () + | +
| +guchar * + | ++webkit_web_resource_get_data_finish () + | +
| +WebKitURIResponse * | +response | +Read | +
| +gchar * | +uri | +Read | +
| void | +failed | +Run Last | +
| void | +failed-with-tls-errors | +Run Last | +
| void | +finished | +Run Last | +
| void | +received-data | +Run Last | +
| void | +sent-request | +Run Last | +
A WebKitWebResource encapsulates content for each resource at the +end of a particular URI. For example, one WebKitWebResource will +be created for each separate image and stylesheet when a page is +loaded.
+You can access the response and the URI for a given
+WebKitWebResource, using webkit_web_resource_get_uri() and
+webkit_web_resource_get_response(), as well as the raw data, using
+webkit_web_resource_get_data().
const gchar *
+webkit_web_resource_get_uri (WebKitWebResource *resource);
+Returns the current active URI of resource
+. The active URI might change during
+a load operation:
+ When the resource load starts, the active URI is the requested URI +
+ When the initial request is sent to the server, “sent-request” + signal is emitted without a redirected response, the active URI is the URI of + the request sent to the server. +
+ In case of a server redirection, “sent-request” signal + is emitted again with a redirected response, the active URI is the URI the request + was redirected to. +
+ When the response is received from the server, the active URI is the final + one and it will not change again. +
You can monitor the active URI by connecting to the notify::uri
+signal of resource
+.
WebKitURIResponse *
+webkit_web_resource_get_response (WebKitWebResource *resource);
+Retrieves the WebKitURIResponse of the resource load operation.
+This method returns NULL if called before the response
+is received from the server. You can connect to notify::response
+signal to be notified when the response is received.
the WebKitURIResponse, or NULL if
+the response hasn't been received yet.
[transfer none]
+void +webkit_web_resource_get_data (+WebKitWebResource *resource, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously get the raw data for resource
+.
When the operation is finished, callback
+ will be called. You can then call
+webkit_web_resource_get_data_finish() to get the result of the operation.
resource |
++ | + |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
guchar * +webkit_web_resource_get_data_finish (+WebKitWebResource *resource, +GAsyncResult *result, +gsize *length, +GError **error);
Finish an asynchronous operation started with webkit_web_resource_get_data().
resource |
++ | + |
result |
++ | + |
length |
+return location for the length of the resource data. |
+[out][allow-none] | +
error |
+return location for error or |
++ |
“response” property“response” WebKitURIResponse *+
The WebKitURIResponse associated with this resource.
+Flags: Read
+“uri” property“uri” gchar *+
The current active URI of the WebKitWebResource.
+See webkit_web_resource_get_uri() for more details.
Flags: Read
+Default value: NULL
+“failed” signalvoid +user_function (WebKitWebResource *resource, + GError *error, + gpointer user_data)+
This signal is emitted when an error occurs during the resource +load operation.
+resource |
++ | + |
error |
+the GError that was triggered |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“failed-with-tls-errors” signalvoid +user_function (WebKitWebResource *resource, + GTlsCertificate *certificate, + GTlsCertificateFlags errors, + gpointer user_data)+
This signal is emitted when a TLS error occurs during the resource load operation.
+resource |
++ | + |
certificate |
++ | + |
errors |
+a GTlsCertificateFlags with the verification status of |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.8
+“finished” signalvoid +user_function (WebKitWebResource *resource, + gpointer user_data)+
This signal is emitted when the resource load finishes successfully +or due to an error. In case of errors “failed” signal +is emitted before this one.
+resource |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“received-data” signalvoid +user_function (WebKitWebResource *resource, + guint64 data_length, + gpointer user_data)+
This signal is emitted after response is received, +every time new data has been received. It's +useful to know the progress of the resource load operation.
+resource |
++ | + |
data_length |
+the length of data received in bytes |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“sent-request” signalvoid +user_function (WebKitWebResource *resource, + WebKitURIRequest *request, + WebKitURIResponse *redirected_response, + gpointer user_data)+
This signal is emitted when request
+ has been sent to the
+server. In case of a server redirection this signal is
+emitted again with the request
+ argument containing the new
+request sent to the server due to the redirection and the
+redirected_response
+ parameter containing the response
+received by the server for the initial request.
resource |
++ | + |
request |
++ | + |
redirected_response |
+a WebKitURIResponse, or |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitWebViewBackend * | +backend | +Read / Write / Construct Only | +
| gboolean | +editable | +Read / Write | +
| gdouble | +estimated-load-progress | +Read | +
| gboolean | +is-controlled-by-automation | +Read / Write / Construct Only | +
| gboolean | +is-ephemeral | +Read / Write / Construct Only | +
| gboolean | +is-loading | +Read | +
| gboolean | +is-playing-audio | +Read | +
| +WebKitWebView * | +related-view | +Write / Construct Only | +
| +WebKitSettings * | +settings | +Write / Construct | +
| +gchar * | +title | +Read | +
| +gchar * | +uri | +Read | +
| +WebKitUserContentManager * | +user-content-manager | +Read / Write / Construct Only | +
| +WebKitWebContext * | +web-context | +Read / Write / Construct Only | +
| gdouble | +zoom-level | +Read / Write | +
| gboolean | +authenticate | +Run Last | +
| void | +close | +Run Last | +
| gboolean | +context-menu | +Run Last | +
| void | +context-menu-dismissed | +Run Last | +
| +WebKitWebView* | +create | +Run Last | +
| gboolean | +decide-policy | +Run Last | +
| gboolean | +enter-fullscreen | +Run Last | +
| void | +insecure-content-detected | +Run Last | +
| gboolean | +leave-fullscreen | +Run Last | +
| void | +load-changed | +Run Last | +
| gboolean | +load-failed | +Run Last | +
| gboolean | +load-failed-with-tls-errors | +Run Last | +
| void | +mouse-target-changed | +Run Last | +
| gboolean | +permission-request | +Run Last | +
| void | +ready-to-show | +Run Last | +
| void | +resource-load-started | +Run Last | +
| void | +run-as-modal | +Run Last | +
| gboolean | +run-file-chooser | +Run Last | +
| gboolean | +script-dialog | +Run Last | +
| gboolean | +show-notification | +Run Last | +
| void | +submit-form | +Run Last | +
| void | +web-process-terminated | +Run Last | +
| + | WebKitWebView | +
| enum | +WebKitLoadEvent | +
| enum | +WebKitPolicyDecisionType | +
| enum | +WebKitSaveMode | +
| enum | +WebKitInsecureContentEvent | +
| enum | +WebKitWebProcessTerminationReason | +
| #define | +WEBKIT_EDITING_COMMAND_CUT | +
| #define | +WEBKIT_EDITING_COMMAND_COPY | +
| #define | +WEBKIT_EDITING_COMMAND_PASTE | +
| #define | +WEBKIT_EDITING_COMMAND_SELECT_ALL | +
| #define | +WEBKIT_EDITING_COMMAND_UNDO | +
| #define | +WEBKIT_EDITING_COMMAND_REDO | +
| #define | +WEBKIT_EDITING_COMMAND_INSERT_IMAGE | +
| #define | +WEBKIT_EDITING_COMMAND_CREATE_LINK | +
| + | WebKitJavascriptResult | +
| + | WebKitScriptDialog | +
| enum | +WebKitScriptDialogType | +
| + | WebKitWebViewSessionState | +
GBoxed + ├── WebKitJavascriptResult + ├── WebKitScriptDialog + ╰── WebKitWebViewSessionState + GObject + ╰── WebKitWebView ++
WebKitWebView is the central class of the WPE WebKit and WebKitGTK +APIs. It is responsible for managing the drawing of the content and +forwarding of events. You can load any URI into the WebKitWebView or +a data string. With WebKitSettings you can control various aspects +of the rendering and loading of the content.
+Note that in WebKitGTK, WebKitWebView is scrollable by itself, so +you don't need to embed it in a GtkScrolledWindow.
+void +(*WebKitFrameDisplayedCallback) (+WebKitWebView *web_view, +gpointer user_data);
Callback to be called when a frame is displayed in a webKitWebView.
+ +Since: 2.24
+WebKitWebView * +webkit_web_view_new_with_context (+WebKitWebViewBackend *backend, +WebKitWebContext *context);
WebKitWebView * +webkit_web_view_new_with_related_view (+WebKitWebViewBackend *backend, +WebKitWebView *web_view);
WebKitWebView * +webkit_web_view_new_with_settings (+WebKitWebViewBackend *backend, +WebKitSettings *settings);
WebKitWebView * +webkit_web_view_new_with_user_content_manager + (+WebKitWebViewBackend *backend, +WebKitUserContentManager *user_content_manager);
WebKitWebViewBackend *
+webkit_web_view_get_backend (WebKitWebView *web_view);
+Get the WebKitWebViewBackend of web_view
+
Since: 2.20
+gboolean
+webkit_web_view_is_ephemeral (WebKitWebView *web_view);
+Get whether a WebKitWebView is ephemeral. To create an ephemeral WebKitWebView you need to
+use g_object_new() and pass is-ephemeral property with TRUE value. See
+“is-ephemeral” for more details.
+If web_view
+ was created with a ephemeral “related-view” or an
+ephemeral “web-context” it will also be ephemeral.
Since: 2.16
+gboolean
+webkit_web_view_is_controlled_by_automation
+ (WebKitWebView *web_view);
+Get whether a WebKitWebView was created with “is-controlled-by-automation” +property enabled. Only WebKitWebViews controlled by automation can be used in an +automation session.
+ + +Since: 2.18
+WebKitWebContext *
+webkit_web_view_get_context (WebKitWebView *web_view);
+Gets the web context of web_view
+.
WebKitUserContentManager *
+webkit_web_view_get_user_content_manager
+ (WebKitWebView *web_view);
+Gets the user content manager associated to web_view
+.
Since: 2.6
+WebKitWebsiteDataManager *
+webkit_web_view_get_website_data_manager
+ (WebKitWebView *web_view);
+Get the WebKitWebsiteDataManager associated to web_view
+. If web_view
+ is not ephemeral,
+the returned WebKitWebsiteDataManager will be the same as the WebKitWebsiteDataManager
+of web_view
+'s WebKitWebContext.
Since: 2.16
+void
+webkit_web_view_try_close (WebKitWebView *web_view);
+Tries to close the web_view
+. This will fire the onbeforeunload event
+to ask the user for confirmation to close the page. If there isn't an
+onbeforeunload event handler or the user confirms to close the page,
+the “close” signal is emitted, otherwise nothing happens.
Since: 2.12
+void +webkit_web_view_load_uri (+WebKitWebView *web_view, +const gchar *uri);
Requests loading of the specified URI string. +You can monitor the load operation by connecting to +“load-changed” signal.
+ +void +webkit_web_view_load_html (+WebKitWebView *web_view, +const gchar *content, +const gchar *base_uri);
Load the given content
+ string with the specified base_uri
+.
+If base_uri
+ is not NULL, relative URLs in the content
+ will be
+resolved against base_uri
+ and absolute local paths must be children of the base_uri
+.
+For security reasons absolute local paths that are not children of base_uri
+
+will cause the web process to terminate.
+If you need to include URLs in content
+ that are local paths in a different
+directory than base_uri
+ you can build a data URI for them. When base_uri
+ is NULL,
+it defaults to "about:blank". The mime type of the document will be "text/html".
+You can monitor the load operation by connecting to “load-changed” signal.
web_view |
++ | + |
content |
+The HTML string to load |
++ |
base_uri |
+The base URI for relative locations or |
+[allow-none] | +
void +webkit_web_view_load_alternate_html (+WebKitWebView *web_view, +const gchar *content, +const gchar *content_uri, +const gchar *base_uri);
Load the given content
+ string for the URI content_uri
+.
+This allows clients to display page-loading errors in the WebKitWebView itself.
+When this method is called from “load-failed” signal to show an
+error page, then the back-forward list is maintained appropriately.
+For everything else this method works the same way as webkit_web_view_load_html().
web_view |
++ | + |
content |
+the new content to display as the main page of the |
++ |
content_uri |
+the URI for the alternate page content |
++ |
base_uri |
+the base URI for relative locations or |
+[allow-none] | +
void +webkit_web_view_load_plain_text (+WebKitWebView *web_view, +const gchar *plain_text);
Load the specified plain_text
+ string into web_view
+. The mime type of
+document will be "text/plain". You can monitor the load
+operation by connecting to “load-changed” signal.
void +webkit_web_view_load_bytes (+WebKitWebView *web_view, +GBytes *bytes, +const gchar *mime_type, +const gchar *encoding, +const gchar *base_uri);
Load the specified bytes
+ into web_view
+ using the given mime_type
+ and encoding
+.
+When mime_type
+ is NULL, it defaults to "text/html".
+When encoding
+ is NULL, it defaults to "UTF-8".
+When base_uri
+ is NULL, it defaults to "about:blank".
+You can monitor the load operation by connecting to “load-changed” signal.
Since: 2.6
+void +webkit_web_view_load_request (+WebKitWebView *web_view, +WebKitURIRequest *request);
Requests loading of the specified WebKitURIRequest. +You can monitor the load operation by connecting to +“load-changed” signal.
+ +gboolean
+webkit_web_view_can_go_back (WebKitWebView *web_view);
+Determines whether web_view
+ has a previous history item.
void
+webkit_web_view_go_back (WebKitWebView *web_view);
+Loads the previous history item. +You can monitor the load operation by connecting to +“load-changed” signal.
+ +gboolean
+webkit_web_view_can_go_forward (WebKitWebView *web_view);
+Determines whether web_view
+ has a next history item.
void
+webkit_web_view_go_forward (WebKitWebView *web_view);
+Loads the next history item. +You can monitor the load operation by connecting to +“load-changed” signal.
+ +const gchar *
+webkit_web_view_get_title (WebKitWebView *web_view);
+Gets the value of the “title” property.
+You can connect to notify::title signal of web_view
+ to
+be notified when the title has been received.
guint64
+webkit_web_view_get_page_id (WebKitWebView *web_view);
+Get the identifier of the WebKitWebPage corresponding to +the WebKitWebView
+ + +void
+webkit_web_view_reload (WebKitWebView *web_view);
+Reloads the current contents of web_view
+.
+See also webkit_web_view_reload_bypass_cache().
void
+webkit_web_view_reload_bypass_cache (WebKitWebView *web_view);
+Reloads the current contents of web_view
+ without
+using any cached data.
void
+webkit_web_view_stop_loading (WebKitWebView *web_view);
+Stops any ongoing loading operation in web_view
+.
+This method does nothing if no content is being loaded.
+If there is a loading operation in progress, it will be cancelled and
+“load-failed” signal will be emitted with
+WEBKIT_NETWORK_ERROR_CANCELLED error.
gboolean
+webkit_web_view_is_loading (WebKitWebView *web_view);
+Gets the value of the “is-loading” property.
+You can monitor when a WebKitWebView is loading a page by connecting to
+notify::is-loading signal of web_view
+. This is useful when you are
+interesting in knowing when the view is loading something but not in the
+details about the status of the load operation, for example to start a spinner
+when the view is loading a page and stop it when it finishes.
gboolean
+webkit_web_view_is_playing_audio (WebKitWebView *web_view);
+Gets the value of the “is-playing-audio” property.
+You can monitor when a page in a WebKitWebView is playing audio by
+connecting to the notify::is-playing-audio signal of web_view
+. This
+is useful when the application wants to provide visual feedback when a
+page is producing sound.
Since: 2.8
+gdouble
+webkit_web_view_get_estimated_load_progress
+ (WebKitWebView *web_view);
+Gets the value of the “estimated-load-progress” property.
+You can monitor the estimated progress of a load operation by
+connecting to the notify::estimated-load-progress signal of web_view
+.
const gchar *
+webkit_web_view_get_custom_charset (WebKitWebView *web_view);
+Returns the current custom character encoding name of web_view
+.
the current custom character encoding name or NULL if no
+custom character encoding has been set.
void +webkit_web_view_set_custom_charset (+WebKitWebView *web_view, +const gchar *charset);
Sets the current custom character encoding override of web_view
+. The custom
+character encoding will override any text encoding detected via HTTP headers or
+META tags. Calling this method will stop any current load operation and reload the
+current page. Setting the custom character encoding to NULL removes the character
+encoding override.
web_view |
++ | + |
charset |
+a character encoding name or |
+[allow-none] | +
WebKitBackForwardList *
+webkit_web_view_get_back_forward_list (WebKitWebView *web_view);
+Obtains the WebKitBackForwardList associated with the given WebKitWebView. The +WebKitBackForwardList is owned by the WebKitWebView.
+ + +void +webkit_web_view_go_to_back_forward_list_item + (+WebKitWebView *web_view, +WebKitBackForwardListItem *list_item);
Loads the specific history item list_item
+.
+You can monitor the load operation by connecting to
+“load-changed” signal.
const gchar *
+webkit_web_view_get_uri (WebKitWebView *web_view);
+Returns the current active URI of web_view
+. The active URI might change during
+a load operation:
+ When nothing has been loaded yet on web_view the active URI is NULL.
+
+ When a new load operation starts the active URI is the requested URI: +
+
+ If the load operation was started by webkit_web_view_load_uri(),
+ the requested URI is the given one.
+
+ If the load operation was started by webkit_web_view_load_html(),
+ the requested URI is "about:blank".
+
+ If the load operation was started by webkit_web_view_load_alternate_html(),
+ the requested URI is content URI provided.
+
+ If the load operation was started by webkit_web_view_go_back() or
+ webkit_web_view_go_forward(), the requested URI is the original URI
+ of the previous/next item in the WebKitBackForwardList of web_view.
+
+ If the load operation was started by
+ webkit_web_view_go_to_back_forward_list_item(), the requested URI
+ is the opriginal URI of the given WebKitBackForwardListItem.
+
+
+
+ If there is a server redirection during the load operation,
+ the active URI is the redirected URI. When the signal
+ “load-changed” is emitted with WEBKIT_LOAD_REDIRECTED
+ event, the active URI is already updated to the redirected URI.
+
+ When the signal “load-changed” is emitted
+ with WEBKIT_LOAD_COMMITTED event, the active URI is the final
+ one and it will not change unless a new load operation is started
+ or a navigation action within the same page is performed.
+
You can monitor the active URI by connecting to the notify::uri
+signal of web_view
+.
void +webkit_web_view_set_settings (+WebKitWebView *web_view, +WebKitSettings *settings);
Sets the WebKitSettings to be applied to web_view
+. The
+existing WebKitSettings of web_view
+ will be replaced by
+settings
+. New settings are applied immediately on web_view
+.
+The same WebKitSettings object can be shared
+by multiple WebKitWebViews.
WebKitSettings *
+webkit_web_view_get_settings (WebKitWebView *web_view);
+Gets the WebKitSettings currently applied to web_view
+.
+If no other WebKitSettings have been explicitly applied to
+web_view
+ with webkit_web_view_set_settings(), the default
+WebKitSettings will be returned. This method always returns
+a valid WebKitSettings object.
+To modify any of the web_view
+ settings, you can either create
+a new WebKitSettings object with webkit_settings_new(), setting
+the desired preferences, and then replace the existing web_view
+
+settings with webkit_web_view_set_settings() or get the existing
+web_view
+ settings and update it directly. WebKitSettings objects
+can be shared by multiple WebKitWebViews, so modifying
+the settings of a WebKitWebView would affect other
+WebKitWebViews using the same WebKitSettings.
WebKitWindowProperties *
+webkit_web_view_get_window_properties (WebKitWebView *web_view);
+Get the WebKitWindowProperties object containing the properties
+that the window containing web_view
+ should have.
void +webkit_web_view_set_zoom_level (+WebKitWebView *web_view, +gdouble zoom_level);
Set the zoom level of web_view
+, i.e. the factor by which the
+view contents are scaled with respect to their original size.
gdouble
+webkit_web_view_get_zoom_level (WebKitWebView *web_view);
+Get the zoom level of web_view
+, i.e. the factor by which the
+view contents are scaled with respect to their original size.
void +webkit_web_view_can_execute_editing_command + (+WebKitWebView *web_view, +const gchar *command, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously check if it is possible to execute the given editing command.
+When the operation is finished, callback
+ will be called. You can then call
+webkit_web_view_can_execute_editing_command_finish() to get the result of the operation.
web_view |
++ | + |
command |
+the command to check |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
gboolean +webkit_web_view_can_execute_editing_command_finish + (+WebKitWebView *web_view, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_view_can_execute_editing_command().
web_view |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
void +webkit_web_view_execute_editing_command + (+WebKitWebView *web_view, +const gchar *command);
Request to execute the given command
+ for web_view
+. You can use
+webkit_web_view_can_execute_editing_command() to check whether
+it's possible to execute the command.
void +webkit_web_view_execute_editing_command_with_argument + (+WebKitWebView *web_view, +const char *command, +const char *argument);
Request to execute the given command
+ with argument
+ for web_view
+. You can use
+webkit_web_view_can_execute_editing_command() to check whether
+it's possible to execute the command.
web_view |
++ | + |
command |
+the command to execute |
++ |
argument |
+the command argument |
++ |
Since: 2.10
+WebKitFindController *
+webkit_web_view_get_find_controller (WebKitWebView *web_view);
+Gets the WebKitFindController that will allow the caller to query +the WebKitWebView for the text to look for.
+ + +void +webkit_web_view_run_javascript (+WebKitWebView *web_view, +const gchar *script, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously run script
+ in the context of the current page in web_view
+. If
+WebKitSettings:enable-javascript is FALSE, this method will do nothing.
When the operation is finished, callback
+ will be called. You can then call
+webkit_web_view_run_javascript_finish() to get the result of the operation.
web_view |
++ | + |
script |
+the script to run |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the script finished. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
WebKitJavascriptResult * +webkit_web_view_run_javascript_finish (+WebKitWebView *web_view, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_view_run_javascript().
This is an example of using webkit_web_view_run_javascript() with a script returning
+a string:
1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 |
+ static void +web_view_javascript_finished (GObject *object, + GAsyncResult *result, + gpointer user_data) +{ + WebKitJavascriptResult *js_result; + JSCValue *value; + GError *error = NULL; + + js_result = webkit_web_view_run_javascript_finish (WEBKIT_WEB_VIEW (object), result, &error); + if (!js_result) { + g_warning ("Error running javascript: %s", error->message); + g_error_free (error); + return; + } + + value = webkit_javascript_result_get_js_value (js_result); + if (jsc_value_is_string (value)) { + JSCException *exception; + gchar *str_value; + + str_value = jsc_value_to_string (value); + exception = jsc_context_get_exception (jsc_value_get_context (value)); + if (exception) + g_warning ("Error running javascript: %s", jsc_exception_get_message (exception)); + else + g_print ("Script result: %s\n", str_value); + g_free (str_value); + } else { + g_warning ("Error running javascript: unexpected return value"); + } + webkit_javascript_result_unref (js_result); +} + +static void +web_view_get_link_url (WebKitWebView *web_view, + const gchar *link_id) +{ + gchar *script; + + script = g_strdup_printf ("window.document.getElementById('%s').href;", link_id); + webkit_web_view_run_javascript (web_view, script, NULL, web_view_javascript_finished, NULL); + g_free (script); +} |
+
web_view |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
a WebKitJavascriptResult with the result of the last executed statement in script
+or NULL in case of error.
[transfer full]
+void +webkit_web_view_run_javascript_in_world + (+WebKitWebView *web_view, +const gchar *script, +const gchar *world_name, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously run script
+ in the script world with name world_name
+ of the current page context in web_view
+.
+If WebKitSettings:enable-javascript is FALSE, this method will do nothing.
When the operation is finished, callback
+ will be called. You can then call
+webkit_web_view_run_javascript_in_world_finish() to get the result of the operation.
web_view |
++ | + |
script |
+the script to run |
++ |
world_name |
+the name of a WebKitScriptWorld |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the script finished. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.22
+WebKitJavascriptResult * +webkit_web_view_run_javascript_in_world_finish + (+WebKitWebView *web_view, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_view_run_javascript_in_world().
web_view |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
a WebKitJavascriptResult with the result of the last executed statement in script
+or NULL in case of error.
[transfer full]
+Since: 2.22
+void +webkit_web_view_run_javascript_from_gresource + (+WebKitWebView *web_view, +const gchar *resource, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously run the script from resource
+ in the context of the
+current page in web_view
+.
When the operation is finished, callback
+ will be called. You can
+then call webkit_web_view_run_javascript_from_gresource_finish() to get the result
+of the operation.
web_view |
++ | + |
resource |
+the location of the resource to load |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the script finished. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
WebKitJavascriptResult * +webkit_web_view_run_javascript_from_gresource_finish + (+WebKitWebView *web_view, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_view_run_javascript_from_gresource().
Check webkit_web_view_run_javascript_finish() for a usage example.
web_view |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
a WebKitJavascriptResult with the result of the last executed statement in script
+or NULL in case of error.
[transfer full]
+gboolean +webkit_web_view_can_show_mime_type (+WebKitWebView *web_view, +const gchar *mime_type);
Whether or not a MIME type can be displayed in web_view
+.
void +webkit_web_view_save (+WebKitWebView *web_view, +WebKitSaveMode save_mode, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously save the current web page associated to the
+WebKitWebView into a self-contained format using the mode
+specified in save_mode
+.
When the operation is finished, callback
+ will be called. You can
+then call webkit_web_view_save_finish() to get the result of the
+operation.
web_view |
++ | + |
save_mode |
+the WebKitSaveMode specifying how the web page should be saved. |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
GInputStream * +webkit_web_view_save_finish (+WebKitWebView *web_view, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_view_save().
web_view |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
a GInputStream with the result of saving
+the current web page or NULL in case of error.
[transfer full]
+void +webkit_web_view_save_to_file (+WebKitWebView *web_view, +GFile *file, +WebKitSaveMode save_mode, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously save the current web page associated to the
+WebKitWebView into a self-contained format using the mode
+specified in save_mode
+ and writing it to file
+.
When the operation is finished, callback
+ will be called. You can
+then call webkit_web_view_save_to_file_finish() to get the result of the
+operation.
web_view |
++ | + |
file |
+the GFile where the current web page should be saved to. |
++ |
save_mode |
+the WebKitSaveMode specifying how the web page should be saved. |
++ |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
gboolean +webkit_web_view_save_to_file_finish (+WebKitWebView *web_view, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_web_view_save_to_file().
web_view |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
WebKitDownload * +webkit_web_view_download_uri (+WebKitWebView *web_view, +const char *uri);
Requests downloading of the specified URI string for web_view
+.
gboolean +webkit_web_view_get_tls_info (+WebKitWebView *web_view, +GTlsCertificate **certificate, +GTlsCertificateFlags *errors);
Retrieves the GTlsCertificate associated with the main resource of web_view
+,
+and the GTlsCertificateFlags showing what problems, if any, have been found
+with that certificate.
+If the connection is not HTTPS, this function returns FALSE.
+This function should be called after a response has been received from the
+server, so you can connect to “load-changed” and call this function
+when it's emitted with WEBKIT_LOAD_COMMITTED event.
Note that this function provides no information about the security of the web
+page if the current WebKitTLSErrorsPolicy is WEBKIT_TLS_ERRORS_POLICY_IGNORE
+,
+as subresources of the page may be controlled by an attacker. This function
+may safely be used to determine the security status of the current page only
+if the current WebKitTLSErrorsPolicy is WEBKIT_TLS_ERRORS_POLICY_FAIL
+, in
+which case subresources that fail certificate verification will be blocked.
web_view |
++ | + |
certificate |
+return location for a GTlsCertificate. |
+[out][transfer none] | +
errors |
+return location for a GTlsCertificateFlags the verification status of |
+[out] | +
void +webkit_web_view_set_editable (+WebKitWebView *web_view, +gboolean editable);
Sets whether the user is allowed to edit the HTML document.
+If editable
+ is TRUE, web_view
+ allows the user to edit the HTML document. If
+editable
+ is FALSE, an element in web_view
+'s document can only be edited if the
+CONTENTEDITABLE attribute has been set on the element or one of its parent
+elements. By default a WebKitWebView is not editable.
Normally, a HTML document is not editable unless the elements within the +document are editable. This function provides a way to make the contents +of a WebKitWebView editable without altering the document or DOM structure.
+web_view |
++ | + |
editable |
+a gboolean indicating the editable state |
++ |
Since: 2.8
+WebKitEditorState *
+webkit_web_view_get_editor_state (WebKitWebView *web_view);
+Gets the web editor state of web_view
+.
Since: 2.10
+WebKitWebViewSessionState *
+webkit_web_view_get_session_state (WebKitWebView *web_view);
+Gets the current session state of web_view
+
Since: 2.12
+void +webkit_web_view_restore_session_state (+WebKitWebView *web_view, +WebKitWebViewSessionState *state);
Restore the web_view
+ session state from state
+
Since: 2.12
+WebKitWebResource *
+webkit_web_view_get_main_resource (WebKitWebView *web_view);
+Return the main resource of web_view
+.
the main WebKitWebResource of the view
+or NULL if nothing has been loaded.
[transfer none]
+guint +webkit_web_view_add_frame_displayed_callback + (+WebKitWebView *web_view, +WebKitFrameDisplayedCallback callback, +gpointer user_data, +GDestroyNotify destroy_notify);
Add a callback to be called when the backend notifies that a frame has been displayed in web_view
+.
web_view |
++ | + |
callback |
++ | + |
user_data |
+user data to pass to |
+[closure] | +
destroy_notify |
+destroy notifier for |
+[nullable] | +
an identifier that should be passed to webkit_web_view_remove_frame_displayed_callback()
+to remove the callback.
Since: 2.24
+void +webkit_web_view_remove_frame_displayed_callback + (+WebKitWebView *web_view, +guint id);
Removes a WebKitFrameDisplayedCallback previously added to web_view
+ with
+webkit_web_view_add_frame_displayed_callback().
Since: 2.24
+WebKitJavascriptResult *
+webkit_javascript_result_ref (WebKitJavascriptResult *js_result);
+Atomically increments the reference count of js_result
+ by one. This
+function is MT-safe and may be called from any thread.
void
+webkit_javascript_result_unref (WebKitJavascriptResult *js_result);
+Atomically decrements the reference count of js_result
+ by one. If the
+reference count drops to 0, all memory allocated by the WebKitJavascriptResult is
+released. This function is MT-safe and may be called from any
+thread.
JSCValue *
+webkit_javascript_result_get_js_value (WebKitJavascriptResult *js_result);
+Get the JSCValue of js_result
+.
Since: 2.22
+WebKitScriptDialog *
+webkit_script_dialog_ref (WebKitScriptDialog *dialog);
+Atomically increments the reference count of dialog
+ by one. This
+function is MT-safe and may be called from any thread.
Since: 2.24
+void
+webkit_script_dialog_unref (WebKitScriptDialog *dialog);
+Atomically decrements the reference count of dialog
+ by one. If the
+reference count drops to 0, all memory allocated by the WebKitScriptdialog is
+released. This function is MT-safe and may be called from any
+thread.
Since: 2.24
+WebKitScriptDialogType
+webkit_script_dialog_get_dialog_type (WebKitScriptDialog *dialog);
+Get the dialog type of a WebKitScriptDialog.
+ + +const gchar *
+webkit_script_dialog_get_message (WebKitScriptDialog *dialog);
+Get the message of a WebKitScriptDialog.
+ + +void +webkit_script_dialog_confirm_set_confirmed + (+WebKitScriptDialog *dialog, +gboolean confirmed);
This method is used for WEBKIT_SCRIPT_DIALOG_CONFIRM and WEBKIT_SCRIPT_DIALOG_BEFORE_UNLOAD_CONFIRM dialogs when
+“script-dialog” signal is emitted to set whether the user
+confirmed the dialog or not. The default implementation of “script-dialog”
+signal sets TRUE when the OK or Stay buttons are clicked and FALSE otherwise.
+It's an error to use this method with a WebKitScriptDialog that is not of type
+WEBKIT_SCRIPT_DIALOG_CONFIRM or WEBKIT_SCRIPT_DIALOG_BEFORE_UNLOAD_CONFIRM
const gchar *
+webkit_script_dialog_prompt_get_default_text
+ (WebKitScriptDialog *dialog);
+Get the default text of a WebKitScriptDialog of type WEBKIT_SCRIPT_DIALOG_PROMPT.
+It's an error to use this method with a WebKitScriptDialog that is not of type
+WEBKIT_SCRIPT_DIALOG_PROMPT.
void +webkit_script_dialog_prompt_set_text (+WebKitScriptDialog *dialog, +const gchar *text);
This method is used for WEBKIT_SCRIPT_DIALOG_PROMPT dialogs when
+“script-dialog” signal is emitted to set the text
+entered by the user. The default implementation of “script-dialog”
+signal sets the text of the entry form when OK button is clicked, otherwise NULL is set.
+It's an error to use this method with a WebKitScriptDialog that is not of type
+WEBKIT_SCRIPT_DIALOG_PROMPT.
void
+webkit_script_dialog_close (WebKitScriptDialog *dialog);
+Close dialog
+. When handling a WebKitScriptDialog asynchronously (webkit_script_dialog_ref()
+was called in “script-dialog” callback), this function needs to be called to notify
+that we are done with the script dialog. The dialog will be closed on destruction if this function
+hasn't been called before.
Since: 2.24
+WebKitWebViewSessionState *
+webkit_web_view_session_state_new (GBytes *data);
+Creates a new WebKitWebViewSessionState from serialized data.
+ +a new WebKitWebViewSessionState, or NULL if data
+doesn't contain a
+valid serialized WebKitWebViewSessionState.
[transfer full]
+Since: 2.12
+WebKitWebViewSessionState *
+webkit_web_view_session_state_ref (WebKitWebViewSessionState *state);
+Atomically increments the reference count of state
+ by one. This
+function is MT-safe and may be called from any thread.
Since: 2.12
+void
+webkit_web_view_session_state_unref (WebKitWebViewSessionState *state);
+Atomically decrements the reference count of state
+ by one. If the
+reference count drops to 0, all memory allocated by the WebKitWebViewSessionState is
+released. This function is MT-safe and may be called from any thread.
Since: 2.12
+GBytes *
+webkit_web_view_session_state_serialize
+ (WebKitWebViewSessionState *state);
+Serializes a WebKitWebViewSessionState.
+ + +Since: 2.12
+Enum values used to denote the different events that happen during a +WebKitWebView load operation.
+| + |
+ A new load request has been made. +No data has been received yet, empty structures have +been allocated to perform the load; the load may still +fail due to transport issues such as not being able to +resolve a name, or connect to a port. + |
++ |
| + |
+ A provisional data source received +a server redirect. + |
++ |
| + |
+ The content started arriving for a page load. +The necessary transport requirements are established, and the +load is being performed. + |
++ |
| + |
+ Load completed. All resources are done loading +or there was an error during the load operation. + |
++ |
Enum values used for determining the type of a policy decision during +“decide-policy”.
+| + |
+ This type of policy decision
+ is requested when WebKit is about to navigate to a new page in either the
+ main frame or a subframe. Acceptable policy decisions are either
+ |
++ |
| + |
+ This type of policy decision
+ is requested when WebKit is about to create a new window. Acceptable policy
+ decisions are either |
++ |
| + |
+ This type of decision is used when WebKit has
+ received a response for a network resource and is about to start the load.
+ Note that these resources include all subresources of a page such as images
+ and stylesheets as well as main documents. Appropriate policy responses to
+ this decision are |
++ |
Enum values to specify the different ways in which a WebKitWebView +can save its current web page into a self-contained file.
+ +Enum values used to denote the different events which can trigger +the detection of insecure content.
+ +Enum values used to specify the reason why the web process terminated abnormally.
+ +Since: 2.20
+#define WEBKIT_EDITING_COMMAND_CUT "Cut" ++
The cut clipboard command. Copies the current selection inside
+a WebKitWebView to the clipboard and deletes the selected content.
+You can check whether it's possible to execute the command with
+webkit_web_view_can_execute_editing_command(). In general it's
+possible to cut to the clipboard when the WebKitWebView content is
+editable and there is an active selection.
#define WEBKIT_EDITING_COMMAND_COPY "Copy" ++
The copy clipboard command. Copies the current selection inside
+a WebKitWebView to the clipboard.
+You can check whether it's possible to execute the command with
+webkit_web_view_can_execute_editing_command(). In general it's
+possible to copy to the clipboard when there is an active selection
+inside the WebKitWebView.
#define WEBKIT_EDITING_COMMAND_PASTE "Paste" ++
The paste clipboard command. Pastes the contents of the clipboard to
+a WebKitWebView.
+You can check whether it's possible to execute the command with
+webkit_web_view_can_execute_editing_command(). In general it's possible
+to paste from the clipboard when the WebKitWebView content is editable
+and clipboard is not empty.
#define WEBKIT_EDITING_COMMAND_SELECT_ALL "SelectAll" ++
The select all command. Selects all the content of the current text field in
+a WebKitWebView.
+It is always possible to select all text, no matter whether the
+WebKitWebView content is editable or not. You can still check it
+with webkit_web_view_can_execute_editing_command().
#define WEBKIT_EDITING_COMMAND_UNDO "Undo" ++
The undo command. Undoes the last editing command in a WebKitWebView.
+You can check whether it's possible to execute the command with
+webkit_web_view_can_execute_editing_command(). It's only possible
+to undo a command after a previously executed editing operation.
#define WEBKIT_EDITING_COMMAND_REDO "Redo" ++
The redo command. Redoes a previously undone editing command in
+a WebKitWebView.
+You can check whether it's possible to execute the command with
+webkit_web_view_can_execute_editing_command(). It's only possible
+to redo a command when it has been previously undone.
#define WEBKIT_EDITING_COMMAND_INSERT_IMAGE "InsertImage" ++
The insert image command. Creates an image element that is inserted at
+the current cursor position. It receives an URI as argument,
+that is used as the image source. This command should be executed with
+webkit_web_view_execute_editing_command_with_argument().
Since: 2.10
+#define WEBKIT_EDITING_COMMAND_CREATE_LINK "CreateLink" ++
The create link command. Creates a link element that is inserted at
+the current cursor position. If there's a selection, the selected text
+will be used as the link text, otherwise the URL itself will be used.
+It receives the link URL as argument. This command should be executed
+with webkit_web_view_execute_editing_command_with_argument()
Since: 2.10
+Enum values used for determining the type of WebKitScriptDialog
+| + |
+ Alert script dialog, used to show a +message to the user. + |
++ |
| + |
+ Confirm script dialog, used to ask +confirmation to the user. + |
++ |
| + |
+ Prompt script dialog, used to ask +information to the user. + |
++ |
| + |
+ Before unload confirm dialog, +used to ask confirmation to leave the current page to the user. Since 2.12 + |
++ |
“backend” property“backend” WebKitWebViewBackend *+
The WebKitWebViewBackend of the view.
+Flags: Read / Write / Construct Only
+Since: 2.20
+“editable” property“editable” gboolean+
Whether the pages loaded inside WebKitWebView are editable. For more
+information see webkit_web_view_set_editable().
Flags: Read / Write
+Default value: FALSE
+Since: 2.8
+“estimated-load-progress” property“estimated-load-progress” gdouble+
An estimate of the percent completion for the current loading operation. +This value will range from 0.0 to 1.0 and, once a load completes, +will remain at 1.0 until a new load starts, at which point it +will be reset to 0.0. +The value is an estimate based on the total number of bytes expected +to be received for a document, including all its possible subresources +and child documents.
+Flags: Read
+Allowed values: [0,1]
+Default value: 0
+“is-controlled-by-automation” property“is-controlled-by-automation” gboolean+
Whether the WebKitWebView is controlled by automation. This should only be used when +creating a new WebKitWebView as a response to “create-web-view” +signal request.
+Flags: Read / Write / Construct Only
+Default value: FALSE
+Since: 2.18
+“is-ephemeral” property“is-ephemeral” gboolean+
Whether the WebKitWebView is ephemeral. An ephemeral web view never writes
+website data to the client storage, no matter what WebKitWebsiteDataManager
+its context is using. This is normally used to implement private browsing mode.
+This is a G_PARAM_CONSTRUCT_ONLY property, so you have to create a ephemeral
+WebKitWebView and it can't be changed. Note that all WebKitWebViews
+created with an ephemeral WebKitWebContext will be ephemeral automatically.
+See also webkit_web_context_new_ephemeral().
Flags: Read / Write / Construct Only
+Default value: FALSE
+Since: 2.16
+“is-loading” property“is-loading” gboolean+
Whether the WebKitWebView is currently loading a page. This property becomes
+TRUE as soon as a new load operation is requested and before the
+“load-changed” signal is emitted with WEBKIT_LOAD_STARTED and
+at that point the active URI is the requested one.
+When the load operation finishes the property is set to FALSE before
+“load-changed” is emitted with WEBKIT_LOAD_FINISHED.
Flags: Read
+Default value: FALSE
+“is-playing-audio” property“is-playing-audio” gboolean+
Whether the WebKitWebView is currently playing audio from a page.
+This property becomes TRUE as soon as web content starts playing any
+kind of audio. When a page is no longer playing any kind of sound,
+the property is set back to FALSE.
Flags: Read
+Default value: FALSE
+Since: 2.8
+“related-view” property“related-view” WebKitWebView *+
The related WebKitWebView used when creating the view to share the +same web process. This property is not readable because the related +web view is only valid during the object construction.
+Flags: Write / Construct Only
+Since: 2.4
+“settings” property“settings” WebKitSettings *+
The WebKitSettings of the view.
+Flags: Write / Construct
+Since: 2.6
+“title” property“title” gchar *+
The main frame document title of this WebKitWebView. If
+the title has not been received yet, it will be NULL.
Flags: Read
+Default value: NULL
+“uri” property“uri” gchar *+
The current active URI of the WebKitWebView.
+See webkit_web_view_get_uri() for more details.
Flags: Read
+Default value: NULL
+“user-content-manager” property“user-content-manager” WebKitUserContentManager *+
The WebKitUserContentManager of the view.
+Flags: Read / Write / Construct Only
+Since: 2.6
+“web-context” property“web-context” WebKitWebContext *+
The WebKitWebContext of the view.
+Flags: Read / Write / Construct Only
+“zoom-level” property“zoom-level” gdouble+
The zoom level of the WebKitWebView content.
+See webkit_web_view_set_zoom_level() for more details.
Flags: Read / Write
+Allowed values: >= 0
+Default value: 1
+“authenticate” signalgboolean +user_function (WebKitWebView *web_view, + WebKitAuthenticationRequest *request, + gpointer user_data)+
This signal is emitted when the user is challenged with HTTP
+authentication. To let the application access or supply
+the credentials as well as to allow the client application
+to either cancel the request or perform the authentication,
+the signal will pass an instance of the
+WebKitAuthenticationRequest in the request
+ argument.
+To handle this signal asynchronously you should keep a ref
+of the request and return TRUE. To disable HTTP authentication
+entirely, connect to this signal and simply return TRUE.
The default signal handler will run a default authentication +dialog asynchronously for the user to interact with.
+web_view |
+the WebKitWebView on which the signal is emitted |
++ |
request |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+Since: 2.2
+“close” signalvoid +user_function (WebKitWebView *web_view, + gpointer user_data)+
Emitted when closing a WebKitWebView is requested. This occurs when a
+call is made from JavaScript's window.close function or
+after trying to close the web_view
+ with webkit_web_view_try_close().
+It is the owner's responsibility to handle this signal to hide or
+destroy the WebKitWebView, if necessary.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“context-menu” signalgboolean +user_function (WebKitWebView *web_view, + WebKitContextMenu *context_menu, + gpointer event, + WebKitHitTestResult *hit_test_result, + gpointer user_data)+
Emitted when a context menu is about to be displayed to give the application +a chance to customize the proposed menu, prevent the menu from being displayed, +or build its own context menu.
+
+ To customize the proposed menu you can use webkit_context_menu_prepend(),
+ webkit_context_menu_append() or webkit_context_menu_insert() to add new
+ WebKitContextMenuItems to context_menu, webkit_context_menu_move_item()
+ to reorder existing items, or webkit_context_menu_remove() to remove an
+ existing item. The signal handler should return FALSE, and the menu represented
+ by context_menu will be shown.
+
+ To prevent the menu from being displayed you can just connect to this signal
+ and return TRUE so that the proposed menu will not be shown.
+
+ To build your own menu, you can remove all items from the proposed menu with
+ webkit_context_menu_remove_all(), add your own items and return FALSE so
+ that the menu will be shown. You can also ignore the proposed WebKitContextMenu,
+ build your own GtkMenu and return TRUE to prevent the proposed menu from being shown.
+
+ If you just want the default menu to be shown always, simply don't connect to this + signal because showing the proposed context menu is the default behaviour. +
The event
+ is expected to be one of the following types:
+a GdkEventButton of type GDK_BUTTON_PRESS when the context menu
+was triggered with mouse.
+
+a GdkEventKey of type GDK_KEY_PRESS if the keyboard was used to show
+the menu.
+
+a generic GdkEvent of type GDK_NOTHING when the “popup-menu”
+signal was used to show the context menu.
+
If the signal handler returns FALSE the context menu represented by context_menu
+
+will be shown, if it return TRUE the context menu will not be shown.
The proposed WebKitContextMenu passed in context_menu
+ argument is only valid
+during the signal emission.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
context_menu |
+the proposed WebKitContextMenu |
++ |
event |
+the GdkEvent that triggered the context menu |
++ |
hit_test_result |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“context-menu-dismissed” signalvoid +user_function (WebKitWebView *web_view, + gpointer user_data)+
Emitted after “context-menu” signal, if the context menu is shown, +to notify that the context menu is dismissed.
+web_view |
+the WebKitWebView on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“create” signalWebKitWebView* +user_function (WebKitWebView *web_view, + WebKitNavigationAction *navigation_action, + gpointer user_data)+
Emitted when the creation of a new WebKitWebView is requested. +If this signal is handled the signal handler should return the +newly created WebKitWebView.
+The WebKitNavigationAction parameter contains information about the +navigation action that triggered this signal.
+When using WEBKIT_PROCESS_MODEL_MULTIPLE_SECONDARY_PROCESSES
+process model, the new WebKitWebView should be related to
+web_view
+ to share the same web process, see webkit_web_view_new_with_related_view()
+for more details.
The new WebKitWebView should not be displayed to the user +until the “ready-to-show” signal is emitted.
+web_view |
+the WebKitWebView on which the signal is emitted |
++ |
navigation_action |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
a newly allocated WebKitWebView widget
+or NULL to propagate the event further.
[transfer full]
+Flags: Run Last
+“decide-policy” signalgboolean +user_function (WebKitWebView *web_view, + WebKitPolicyDecision *decision, + WebKitPolicyDecisionType decision_type, + gpointer user_data)+
This signal is emitted when WebKit is requesting the client to decide a policy
+decision, such as whether to navigate to a page, open a new window or whether or
+not to download a resource. The WebKitNavigationPolicyDecision passed in the
+decision
+ argument is a generic type, but should be casted to a more
+specific type when making the decision. For example:
1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 |
+ static gboolean +decide_policy_cb (WebKitWebView *web_view, + WebKitPolicyDecision *decision, + WebKitPolicyDecisionType type) +{ + switch (type) { + case WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION: { + WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision); + /* Make a policy decision here. */ + break; + } + case WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION: { + WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision); + /* Make a policy decision here. */ + break; + } + case WEBKIT_POLICY_DECISION_TYPE_RESPONSE: + WebKitResponsePolicyDecision *response = WEBKIT_RESPONSE_POLICY_DECISION (decision); + /* Make a policy decision here. */ + break; + default: + /* Making no decision results in webkit_policy_decision_use(). */ + return FALSE; + } + return TRUE; +} |
+
It is possible to make policy decision asynchronously, by simply calling g_object_ref()
+on the decision
+ argument and returning TRUE to block the default signal handler.
+If the last reference is removed on a WebKitPolicyDecision and no decision has been
+made explicitly, webkit_policy_decision_use() will be the default policy decision. The
+default signal handler will simply call webkit_policy_decision_use(). Only the first
+policy decision chosen for a given WebKitPolicyDecision will have any affect.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
decision |
++ | + |
decision_type |
+a WebKitPolicyDecisionType denoting the type of |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“enter-fullscreen” signalgboolean +user_function (WebKitWebView *web_view, + gpointer user_data)+
Emitted when JavaScript code calls
+element.webkitRequestFullScreen. If the
+signal is not handled the WebKitWebView will proceed to full screen
+its top level window. This signal can be used by client code to
+request permission to the user prior doing the full screen
+transition and eventually prepare the top-level window
+(e.g. hide some widgets that would otherwise be part of the
+full screen window).
web_view |
+the WebKitWebView on which the signal is emitted. |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to continue emission of the event.
Flags: Run Last
+“insecure-content-detected” signalvoid +user_function (WebKitWebView *web_view, + WebKitInsecureContentEvent event, + gpointer user_data)+
This signal is emitted when insecure content has been detected +in a page loaded through a secure connection. This typically +means that a external resource from an unstrusted source has +been run or displayed, resulting in a mix of HTTPS and +non-HTTPS content.
+You can check the event
+ parameter to know exactly which kind
+of event has been detected (see WebKitInsecureContentEvent).
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
event |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“leave-fullscreen” signalgboolean +user_function (WebKitWebView *web_view, + gpointer user_data)+
Emitted when the WebKitWebView is about to restore its top level +window out of its full screen state. This signal can be used by +client code to restore widgets hidden during the +“enter-fullscreen” stage for instance.
+web_view |
+the WebKitWebView on which the signal is emitted. |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to continue emission of the event.
Flags: Run Last
+“load-changed” signalvoid +user_function (WebKitWebView *web_view, + WebKitLoadEvent load_event, + gpointer user_data)+
Emitted when a load operation in web_view
+ changes.
+The signal is always emitted with WEBKIT_LOAD_STARTED when a
+new load request is made and WEBKIT_LOAD_FINISHED when the load
+finishes successfully or due to an error. When the ongoing load
+operation fails “load-failed” signal is emitted
+before “load-changed” is emitted with
+WEBKIT_LOAD_FINISHED.
+If a redirection is received from the server, this signal is emitted
+with WEBKIT_LOAD_REDIRECTED after the initial emission with
+WEBKIT_LOAD_STARTED and before WEBKIT_LOAD_COMMITTED.
+When the page content starts arriving the signal is emitted with
+WEBKIT_LOAD_COMMITTED event.
You can handle this signal and use a switch to track any ongoing +load operation.
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 |
+ static void web_view_load_changed (WebKitWebView *web_view, + WebKitLoadEvent load_event, + gpointer user_data) +{ + switch (load_event) { + case WEBKIT_LOAD_STARTED: + /* New load, we have now a provisional URI */ + provisional_uri = webkit_web_view_get_uri (web_view); + /* Here we could start a spinner or update the + * location bar with the provisional URI */ + break; + case WEBKIT_LOAD_REDIRECTED: + redirected_uri = webkit_web_view_get_uri (web_view); + break; + case WEBKIT_LOAD_COMMITTED: + /* The load is being performed. Current URI is + * the final one and it won't change unless a new + * load is requested or a navigation within the + * same page is performed */ + uri = webkit_web_view_get_uri (web_view); + break; + case WEBKIT_LOAD_FINISHED: + /* Load finished, we can now stop the spinner */ + break; + } +} |
+
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
load_event |
+the WebKitLoadEvent |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“load-failed” signalgboolean +user_function (WebKitWebView *web_view, + WebKitLoadEvent load_event, + gchar *failing_uri, + GError *error, + gpointer user_data)+
Emitted when an error occurs during a load operation.
+If the error happened when starting to load data for a page
+load_event
+ will be WEBKIT_LOAD_STARTED. If it happened while
+loading a committed data source load_event
+ will be WEBKIT_LOAD_COMMITTED.
+Since a load error causes the load operation to finish, the signal
+WebKitWebView::load-changed will always be emitted with
+WEBKIT_LOAD_FINISHED event right after this one.
By default, if the signal is not handled, a stock error page will be displayed. +You need to handle the signal if you want to provide your own error page.
+web_view |
+the WebKitWebView on which the signal is emitted |
++ |
load_event |
+the WebKitLoadEvent of the load operation |
++ |
failing_uri |
+the URI that failed to load |
++ |
error |
+the GError that was triggered |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“load-failed-with-tls-errors” signalgboolean +user_function (WebKitWebView *web_view, + gchar *failing_uri, + GTlsCertificate *certificate, + GTlsCertificateFlags errors, + gpointer user_data)+
Emitted when a TLS error occurs during a load operation.
+To allow an exception for this certificate
+
+and the host of failing_uri
+ use webkit_web_context_allow_tls_certificate_for_host().
To handle this signal asynchronously you should call g_object_ref() on certificate
+
+and return TRUE.
If FALSE is returned, “load-failed” will be emitted. The load
+will finish regardless of the returned value.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
failing_uri |
+the URI that failed to load |
++ |
certificate |
++ | + |
errors |
+a GTlsCertificateFlags with the verification status of |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+Since: 2.6
+“mouse-target-changed” signalvoid +user_function (WebKitWebView *web_view, + WebKitHitTestResult *hit_test_result, + guint modifiers, + gpointer user_data)+
This signal is emitted when the mouse cursor moves over an
+element such as a link, image or a media element. To determine
+what type of element the mouse cursor is over, a Hit Test is performed
+on the current mouse coordinates and the result is passed in the
+hit_test_result
+ argument. The modifiers
+ argument is a bitmask of
+GdkModifierType flags indicating the state of modifier keys.
+The signal is emitted again when the mouse is moved out of the
+current element with a new hit_test_result
+.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
hit_test_result |
++ | + |
modifiers |
+a bitmask of GdkModifierType |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“permission-request” signalgboolean +user_function (WebKitWebView *web_view, + WebKitPermissionRequest *request, + gpointer user_data)+
This signal is emitted when WebKit is requesting the client to +decide about a permission request, such as allowing the browser +to switch to fullscreen mode, sharing its location or similar +operations.
+A possible way to use this signal could be through a dialog +allowing the user decide what to do with the request:
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 |
+ static gboolean permission_request_cb (WebKitWebView *web_view, + WebKitPermissionRequest *request, + GtkWindow *parent_window) +{ + GtkWidget *dialog = gtk_message_dialog_new (parent_window, + GTK_DIALOG_MODAL, + GTK_MESSAGE_QUESTION, + GTK_BUTTONS_YES_NO, + "Allow Permission Request?"); + gtk_widget_show (dialog); + gint result = gtk_dialog_run (GTK_DIALOG (dialog)); + + switch (result) { + case GTK_RESPONSE_YES: + webkit_permission_request_allow (request); + break; + default: + webkit_permission_request_deny (request); + break; + } + gtk_widget_destroy (dialog); + + return TRUE; +} |
+
It is possible to handle permission requests asynchronously, by
+simply calling g_object_ref() on the request
+ argument and
+returning TRUE to block the default signal handler. If the
+last reference is removed on a WebKitPermissionRequest and the
+request has not been handled, webkit_permission_request_deny()
+will be the default action.
If the signal is not handled, the request
+ will be completed automatically
+by the specific WebKitPermissionRequest that could allow or deny it. Check the
+documentation of classes implementing WebKitPermissionRequest interface to know
+their default action.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
request |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“ready-to-show” signalvoid +user_function (WebKitWebView *web_view, + gpointer user_data)+
Emitted after “create” on the newly created WebKitWebView
+when it should be displayed to the user. When this signal is emitted
+all the information about how the window should look, including
+size, position, whether the location, status and scrollbars
+should be displayed, is already set on the WebKitWindowProperties
+of web_view
+. See also webkit_web_view_get_window_properties().
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“resource-load-started” signalvoid +user_function (WebKitWebView *web_view, + WebKitWebResource *resource, + WebKitURIRequest *request, + gpointer user_data)+
Emitted when a new resource is going to be loaded. The request
+ parameter
+contains the WebKitURIRequest that will be sent to the server.
+You can monitor the load operation by connecting to the different signals
+of resource
+.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
resource |
++ | + |
request |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“run-as-modal” signalvoid +user_function (WebKitWebView *web_view, + gpointer user_data)+
Emitted after “ready-to-show” on the newly
+created WebKitWebView when JavaScript code calls
+window.showModalDialog. The purpose of
+this signal is to allow the client application to prepare the
+new view to behave as modal. Once the signal is emitted a new
+main loop will be run to block user interaction in the parent
+WebKitWebView until the new dialog is closed.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“run-file-chooser” signalgboolean +user_function (WebKitWebView *web_view, + WebKitFileChooserRequest *request, + gpointer user_data)+
This signal is emitted when the user interacts with a <input
+type='file' /> HTML element, requesting from WebKit to show
+a dialog to select one or more files to be uploaded. To let the
+application know the details of the file chooser, as well as to
+allow the client application to either cancel the request or
+perform an actual selection of files, the signal will pass an
+instance of the WebKitFileChooserRequest in the request
+
+argument.
The default signal handler will asynchronously run a regular +GtkFileChooserDialog for the user to interact with.
+web_view |
+the WebKitWebView on which the signal is emitted |
++ |
request |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“script-dialog” signalgboolean +user_function (WebKitWebView *web_view, + WebKitScriptDialog *dialog, + gpointer user_data)+
Emitted when JavaScript code calls window.alert,
+window.confirm or window.prompt,
+or when onbeforeunload event is fired.
+The dialog
+ parameter should be used to build the dialog.
+If the signal is not handled a different dialog will be built and shown depending
+on the dialog type:
+ WEBKIT_SCRIPT_DIALOG_ALERT: message dialog with a single Close button.
+
+ WEBKIT_SCRIPT_DIALOG_CONFIRM: message dialog with OK and Cancel buttons.
+
+ WEBKIT_SCRIPT_DIALOG_PROMPT: message dialog with OK and Cancel buttons and
+ a text entry with the default text.
+
+ WEBKIT_SCRIPT_DIALOG_BEFORE_UNLOAD_CONFIRM: message dialog with Stay and Leave buttons.
+
It is possible to handle the script dialog request asynchronously, by simply
+caling webkit_script_dialog_ref() on the dialog
+ argument and calling
+webkit_script_dialog_close() when done.
+If the last reference is removed on a WebKitScriptDialog and the dialog has not been
+closed, webkit_script_dialog_close() will be called.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
dialog |
+the WebKitScriptDialog to show |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to propagate the event further.
Flags: Run Last
+“show-notification” signalgboolean +user_function (WebKitWebView *web_view, + WebKitNotification *notification, + gpointer user_data)+
This signal is emitted when a notification should be presented to the
+user. The notification
+ is kept alive until either: 1) the web page cancels it
+or 2) a navigation happens.
The default handler will emit a notification using libnotify, if built with +support for it.
+web_view |
+the WebKitWebView |
++ |
notification |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.8
+“submit-form” signalvoid +user_function (WebKitWebView *web_view, + WebKitFormSubmissionRequest *request, + gpointer user_data)+
This signal is emitted when a form is about to be submitted. The request
+
+argument passed contains information about the text fields of the form. This
+is typically used to store login information that can be used later to
+pre-fill the form.
+The form will not be submitted until webkit_form_submission_request_submit() is called.
It is possible to handle the form submission request asynchronously, by
+simply calling g_object_ref() on the request
+ argument and calling
+webkit_form_submission_request_submit() when done to continue with the form submission.
+If the last reference is removed on a WebKitFormSubmissionRequest and the
+form has not been submitted, webkit_form_submission_request_submit() will be called.
web_view |
+the WebKitWebView on which the signal is emitted |
++ |
request |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“web-process-terminated” signalvoid +user_function (WebKitWebView *web_view, + WebKitWebProcessTerminationReason reason, + gpointer user_data)+
This signal is emitted when the web process terminates abnormally due
+to reason
+.
web_view |
+the WebKitWebView |
++ |
reason |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.20
+| +Top + | + |
+ |
+ |
+ |
+
| struct wpe_view_backend * + | ++webkit_web_view_backend_get_wpe_backend () + | +
| +WebKitWebViewBackend * + | ++webkit_web_view_backend_new () + | +
| #define | +WEBKIT_TYPE_WEB_VIEW_BACKEND | +
| + | WebKitWebViewBackend | +
A WebKitWebViewBackend is a boxed type wrapping a WPE backend used to create a
+WebKitWebView. A WebKitWebViewBackend is created with webkit_web_view_backend_new()
+and it should be passed to a WebKitWebView constructor that will take the ownership.
struct wpe_view_backend *
+webkit_web_view_backend_get_wpe_backend
+ (WebKitWebViewBackend *view_backend);
+Get the WPE backend of view_backend
+
Since: 2.20
+WebKitWebViewBackend * +webkit_web_view_backend_new (+struct wpe_view_backend *backend, +GDestroyNotify notify, +gpointer user_data);
Create a new WebKitWebViewBackend for the given WPE backend
+. You can pass a GDestroyNotify
+that will be called when the object is destroyed passing user_data
+ as the argument. If notify
+
+is NULL, wpe_view_backend_destroy() will be used with backend
+ as argument.
+The returned WebKitWebViewBackend should never be freed by the user; it must be passed to a
+WebKitWebView constructor that will take the ownership.
backend |
+a wpe_view_backend. |
+[transfer full] | +
notify |
+a GDestroyNotify, or |
+[nullable] | +
user_data |
+user data to pass to |
++ |
Since: 2.20
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitWebsiteData * + | ++webkit_website_data_ref () + | +
| +void + | ++webkit_website_data_unref () + | +
| const char * + | ++webkit_website_data_get_name () + | +
| +WebKitWebsiteDataTypes + | ++webkit_website_data_get_types () + | +
| +guint64 + | ++webkit_website_data_get_size () + | +
WebKitWebsiteData represents data stored in the client by a particular website.
+A website is normally a set of URLs grouped by domain name. You can get the website name,
+which is usually the domain, with webkit_website_data_get_name().
+Documents loaded from the file system, like file:// URIs, are all grouped in the same WebKitWebsiteData
+with the name "Local files".
A website can store different types of data in the client side. WebKitWebsiteDataTypes is an enum containing
+all the possible data types; use webkit_website_data_get_types() to get the bitmask of data types.
+It's also possible to know the size of the data stored for some of the WebKitWebsiteDataTypes by using
+webkit_website_data_get_size().
A list of WebKitWebsiteData can be retrieved with webkit_website_data_manager_fetch(). See WebKitWebsiteDataManager
+for more information.
WebKitWebsiteData *
+webkit_website_data_ref (WebKitWebsiteData *website_data);
+Atomically increments the reference count of website_data
+ by one.
+This function is MT-safe and may be called from any thread.
Since: 2.16
+void
+webkit_website_data_unref (WebKitWebsiteData *website_data);
+Atomically decrements the reference count of website_data
+ by one.
+If the reference count drops to 0, all memory allocated by
+WebKitWebsiteData is released. This function is MT-safe and may be
+called from any thread.
Since: 2.16
+const char *
+webkit_website_data_get_name (WebKitWebsiteData *website_data);
+Gets the name of WebKitWebsiteData. This is the website name, normally represented by +a domain or host name. All local documents are grouped in the same WebKitWebsiteData using +the name "Local files".
+ + +Since: 2.16
+WebKitWebsiteDataTypes
+webkit_website_data_get_types (WebKitWebsiteData *website_data);
+Gets the types of data stored in the client for a WebKitWebsiteData. These are the
+types actually present, not the types queried with webkit_website_data_manager_fetch().
Since: 2.16
+guint64 +webkit_website_data_get_size (+WebKitWebsiteData *website_data, +WebKitWebsiteDataTypes types);
Gets the size of the data of types types
+ in a WebKitWebsiteData.
+Note that currently the data size is only known for WEBKIT_WEBSITE_DATA_DISK_CACHE data type
+so for all other types 0 will be returned.
website_data |
++ | + |
types |
+a bitmask of WebKitWebsiteDataTypes |
++ |
Since: 2.16
+Enum values with flags representing types of Website data.
+| + |
+ Memory cache. + |
++ |
| + |
+ HTTP disk cache. + |
++ |
| + |
+ Offline web application cache. + |
++ |
| + |
+ Session storage data. + |
++ |
| + |
+ Local storage data. + |
++ |
| + |
+ WebSQL databases. + |
++ |
| + |
+ IndexedDB databases. + |
++ |
| + |
+ Plugins data. + |
++ |
| + |
+ Cookies. + |
++ |
| + |
+ Hash salt used to generate the device ids used by webpages. Since 2.24 + |
++ |
| + |
+ All types. + |
++ |
Since: 2.16
+| +Top + | + |
+ |
+ |
+ |
+
| +gchar * | +base-cache-directory | +Read / Write / Construct Only | +
| +gchar * | +base-data-directory | +Read / Write / Construct Only | +
| +gchar * | +disk-cache-directory | +Read / Write / Construct Only | +
| +gchar * | +indexeddb-directory | +Read / Write / Construct Only | +
| gboolean | +is-ephemeral | +Read / Write / Construct Only | +
| +gchar * | +local-storage-directory | +Read / Write / Construct Only | +
| +gchar * | +offline-application-cache-directory | +Read / Write / Construct Only | +
| +gchar * | +websql-directory | +Read / Write / Construct Only | +
WebKitWebsiteDataManager allows you to manage the data that websites
+can store in the client file system like databases or caches.
+You can use WebKitWebsiteDataManager to configure the local directories
+where the Website data will be stored, by creating a new manager with
+webkit_website_data_manager_new() passing the values you want to set.
+You can set all the possible configuration values or only some of them,
+a default value will be used automatically for the configuration options
+not provided. “base-data-directory” and
+“base-cache-directory” are two special properties
+that can be used to set a common base directory for all Website data and
+caches. It's possible to provide both, a base directory and a specific value,
+but in that case, the specific value takes precedence over the base directory.
+The newly created WebKitWebsiteDataManager must be passed as a construct property
+to a WebKitWebContext, you can use webkit_web_context_new_with_website_data_manager()
+to create a new WebKitWebContext with a WebKitWebsiteDataManager.
+In case you don't want to set any specific configuration, you don't need to create
+a WebKitWebsiteDataManager, the WebKitWebContext will create a WebKitWebsiteDataManager
+with the default configuration. To get the WebKitWebsiteDataManager of a WebKitWebContext
+you can use webkit_web_context_get_website_data_manager().
A WebKitWebsiteDataManager can also be ephemeral and then all the directories configuration
+is not needed because website data will never persist. You can create an ephemeral WebKitWebsiteDataManager
+with webkit_website_data_manager_new_ephemeral(). Then you can pass an ephemeral WebKitWebsiteDataManager to
+a WebKitWebContext to make it ephemeral or use webkit_web_context_new_ephemeral() and the WebKitWebsiteDataManager
+will be automatically created by the WebKitWebContext.
WebKitWebsiteDataManager can also be used to fetch websites data, remove data +stored by particular websites, or clear data for all websites modified since a given +period of time.
+WebKitWebsiteDataManager * +webkit_website_data_manager_new (+const gchar *first_option_name, +...);
Creates a new WebKitWebsiteDataManager with the given options. It must +be passed as construction parameter of a WebKitWebContext.
+first_option_name |
+name of the first option to set |
++ |
... |
+value of first option, followed by more options, |
++ |
Since: 2.10
+WebKitWebsiteDataManager *
+webkit_website_data_manager_new_ephemeral
+ (void);
+Creates an ephemeral WebKitWebsiteDataManager. See “is-ephemeral” for more details.
+ +Since: 2.16
+gboolean
+webkit_website_data_manager_is_ephemeral
+ (WebKitWebsiteDataManager *manager);
+Get whether a WebKitWebsiteDataManager is ephemeral. See “is-ephemeral” for more details.
+ + +Since: 2.16
+const gchar *
+webkit_website_data_manager_get_base_data_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “base-data-directory” property.
+ +the base directory for Website data, or NULL if
+“base-data-directory” was not provided or manager
+is ephemeral.
[allow-none]
+Since: 2.10
+const gchar *
+webkit_website_data_manager_get_base_cache_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “base-cache-directory” property.
+ +the base directory for Website cache, or NULL if
+“base-cache-directory” was not provided or manager
+is ephemeral.
[allow-none]
+Since: 2.10
+const gchar *
+webkit_website_data_manager_get_local_storage_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “local-storage-directory” property.
+ +the directory where local storage data is stored or NULL if manager
+is ephemeral.
[allow-none]
+Since: 2.10
+const gchar *
+webkit_website_data_manager_get_disk_cache_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “disk-cache-directory” property.
+ +the directory where HTTP disk cache is stored or NULL if manager
+is ephemeral.
[allow-none]
+Since: 2.10
+const gchar *
+webkit_website_data_manager_get_offline_application_cache_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “offline-application-cache-directory” property.
+ +the directory where offline web application cache is stored or NULL if manager
+is ephemeral.
[allow-none]
+Since: 2.10
+const gchar *
+webkit_website_data_manager_get_indexeddb_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “indexeddb-directory” property.
+ +the directory where IndexedDB databases are stored or NULL if manager
+is ephemeral.
[allow-none]
+Since: 2.10
+const gchar *
+webkit_website_data_manager_get_websql_directory
+ (WebKitWebsiteDataManager *manager);
+Get the “websql-directory” property.
+ +the directory where WebSQL databases are stored or NULL if manager
+is ephemeral.
[allow-none]
+Since: 2.10
+WebKitCookieManager *
+webkit_website_data_manager_get_cookie_manager
+ (WebKitWebsiteDataManager *manager);
+Get the WebKitCookieManager of manager
+.
Since: 2.16
+void +webkit_website_data_manager_fetch (+WebKitWebsiteDataManager *manager, +WebKitWebsiteDataTypes types, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously get the list of WebKitWebsiteData for the given types
+.
When the operation is finished, callback
+ will be called. You can then call
+webkit_website_data_manager_fetch_finish() to get the result of the operation.
manager |
++ | + |
types |
++ | + |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.16
+GList * +webkit_website_data_manager_fetch_finish + (+WebKitWebsiteDataManager *manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_website_data_manager_fetch().
manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
a GList of WebKitWebsiteData. You must free the GList with
+g_list_free() and unref the WebKitWebsiteDatas with webkit_website_data_unref() when you're done with them.
[element-type WebKitWebsiteData][transfer full]
+Since: 2.16
+void +webkit_website_data_manager_remove (+WebKitWebsiteDataManager *manager, +WebKitWebsiteDataTypes types, +GList *website_data, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously removes the website data of the for the given types
+ for websites in the given website_data
+ list.
+Use webkit_website_data_manager_clear() if you want to remove the website data for all sites.
When the operation is finished, callback
+ will be called. You can then call
+webkit_website_data_manager_remove_finish() to get the result of the operation.
manager |
++ | + |
types |
++ | + |
website_data |
+a GList of WebKitWebsiteData. |
+[element-type WebKitWebsiteData] | +
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.16
+gboolean +webkit_website_data_manager_remove_finish + (+WebKitWebsiteDataManager *manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_website_data_manager_remove().
manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
Since: 2.16
+void +webkit_website_data_manager_clear (+WebKitWebsiteDataManager *manager, +WebKitWebsiteDataTypes types, +GTimeSpan timespan, +GCancellable *cancellable, +GAsyncReadyCallback callback, +gpointer user_data);
Asynchronously clear the website data of the given types
+ modified in the past timespan
+.
+If timespan
+ is 0, all website data will be removed.
When the operation is finished, callback
+ will be called. You can then call
+webkit_website_data_manager_clear_finish() to get the result of the operation.
Due to implementation limitations, this function does not currently delete
+any stored cookies if timespan
+ is nonzero. This behavior may change in the
+future.
manager |
++ | + |
types |
++ | + |
timespan |
++ | + |
cancellable |
+a GCancellable or |
+[allow-none] | +
callback |
+a GAsyncReadyCallback to call when the request is satisfied. |
+[scope async] | +
user_data |
+the data to pass to callback function. |
+[closure] | +
Since: 2.16
+gboolean +webkit_website_data_manager_clear_finish + (+WebKitWebsiteDataManager *manager, +GAsyncResult *result, +GError **error);
Finish an asynchronous operation started with webkit_website_data_manager_clear()
manager |
++ | + |
result |
++ | + |
error |
+return location for error or |
++ |
Since: 2.16
+“base-cache-directory” property“base-cache-directory” gchar *+
The base directory for Website cache. This is used as a base directory +for any Website cache when no specific cache directory has been provided.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+“base-data-directory” property“base-data-directory” gchar *+
The base directory for Website data. This is used as a base directory +for any Website data when no specific data directory has been provided.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+“disk-cache-directory” property“disk-cache-directory” gchar *+
The directory where HTTP disk cache will be stored.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+“indexeddb-directory” property“indexeddb-directory” gchar *+
The directory where IndexedDB databases will be stored.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+“is-ephemeral” property“is-ephemeral” gboolean+
Whether the WebKitWebsiteDataManager is ephemeral. An ephemeral WebKitWebsiteDataManager +handles all websites data as non-persistent, and nothing will be written to the client +storage. Note that if you create an ephemeral WebKitWebsiteDataManager all other construction +parameters to configure data directories will be ignored.
+Flags: Read / Write / Construct Only
+Default value: FALSE
+Since: 2.16
+“local-storage-directory” property“local-storage-directory” gchar *+
The directory where local storage data will be stored.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+“offline-application-cache-directory” property“offline-application-cache-directory” gchar *+
The directory where offline web application cache will be stored.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+“websql-directory” property“websql-directory” gchar *+
The directory where WebSQL databases will be stored.
+Flags: Read / Write / Construct Only
+Default value: NULL
+Since: 2.10
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitWindowProperties+WebKitWindowProperties — Window properties of a WebKitWebView + |
++ |
| +gboolean + | ++webkit_window_properties_get_toolbar_visible () + | +
| +gboolean + | ++webkit_window_properties_get_statusbar_visible () + | +
| +gboolean + | ++webkit_window_properties_get_scrollbars_visible () + | +
| +gboolean + | ++webkit_window_properties_get_menubar_visible () + | +
| +gboolean + | ++webkit_window_properties_get_locationbar_visible () + | +
| +gboolean + | ++webkit_window_properties_get_resizable () + | +
| +gboolean + | ++webkit_window_properties_get_fullscreen () + | +
| gboolean | +fullscreen | +Read / Write / Construct Only | +
| gboolean | +locationbar-visible | +Read / Write / Construct Only | +
| gboolean | +menubar-visible | +Read / Write / Construct Only | +
| gboolean | +resizable | +Read / Write / Construct Only | +
| gboolean | +scrollbars-visible | +Read / Write / Construct Only | +
| gboolean | +statusbar-visible | +Read / Write / Construct Only | +
| gboolean | +toolbar-visible | +Read / Write / Construct Only | +
The content of a WebKitWebView can request to change certain +properties of the window containing the view. This can include the x, y position +of the window, the width and height but also if a toolbar, +scrollbar, statusbar, locationbar should be visible to the user, +and the request to show the WebKitWebView fullscreen.
+The “ready-to-show” signal handler is the proper place +to apply the initial window properties. Then you can monitor the +WebKitWindowProperties by connecting to ::notify signal.
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 |
+ static void ready_to_show_cb (WebKitWebView *web_view, gpointer user_data) +{ + GtkWidget *window; + WebKitWindowProperties *window_properties; + gboolean visible; + + /* Create the window to contain the WebKitWebView */ + window = browser_window_new (); + gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (web_view)); + gtk_widget_show (GTK_WIDGET (web_view)); + + /* Get the WebKitWindowProperties of the web view and monitor it */ + window_properties = webkit_web_view_get_window_properties (web_view); + g_signal_connect (window_properties, "notify::geometry", + G_CALLBACK (window_geometry_changed), window); + g_signal_connect (window_properties, "notify::toolbar-visible", + G_CALLBACK (window_toolbar_visibility_changed), window); + g_signal_connect (window_properties, "notify::menubar-visible", + G_CALLBACK (window_menubar_visibility_changed), window); + .... + + /* Apply the window properties before showing the window */ + visible = webkit_window_properties_get_toolbar_visible (window_properties); + browser_window_set_toolbar_visible (BROWSER_WINDOW (window), visible); + visible = webkit_window_properties_get_menubar_visible (window_properties); + browser_window_set_menubar_visible (BROWSER_WINDOW (window), visible); + .... + + if (webkit_window_properties_get_fullscreen (window_properties)) { + gtk_window_fullscreen (GTK_WINDOW (window)); + } else { + GdkRectangle geometry; + + gtk_window_set_resizable (GTK_WINDOW (window), + webkit_window_properties_get_resizable (window_properties)); + webkit_window_properties_get_geometry (window_properties, &geometry); + gtk_window_move (GTK_WINDOW (window), geometry.x, geometry.y); + gtk_window_resize (GTK_WINDOW (window), geometry.width, geometry.height); + } + + gtk_widget_show (window); +} |
+
gboolean
+webkit_window_properties_get_toolbar_visible
+ (WebKitWindowProperties *window_properties);
+Get whether the window should have the toolbar visible or not.
+ + +gboolean
+webkit_window_properties_get_statusbar_visible
+ (WebKitWindowProperties *window_properties);
+Get whether the window should have the statusbar visible or not.
+ + +gboolean
+webkit_window_properties_get_scrollbars_visible
+ (WebKitWindowProperties *window_properties);
+Get whether the window should have the scrollbars visible or not.
+ + +gboolean
+webkit_window_properties_get_menubar_visible
+ (WebKitWindowProperties *window_properties);
+Get whether the window should have the menubar visible or not.
+ + +gboolean
+webkit_window_properties_get_locationbar_visible
+ (WebKitWindowProperties *window_properties);
+Get whether the window should have the locationbar visible or not.
+ + +gboolean
+webkit_window_properties_get_resizable
+ (WebKitWindowProperties *window_properties);
+Get whether the window should be resizable by the user or not.
+ + +gboolean
+webkit_window_properties_get_fullscreen
+ (WebKitWindowProperties *window_properties);
+Get whether the window should be shown in fullscreen state or not.
+ + +“fullscreen” property“fullscreen” gboolean+
Whether window will be displayed fullscreen.
+Flags: Read / Write / Construct Only
+Default value: FALSE
+“locationbar-visible” property“locationbar-visible” gboolean+
Whether the locationbar should be visible for the window.
+Flags: Read / Write / Construct Only
+Default value: TRUE
+“menubar-visible” property“menubar-visible” gboolean+
Whether the menubar should be visible for the window.
+Flags: Read / Write / Construct Only
+Default value: TRUE
+“resizable” property“resizable” gboolean+
Whether the window can be resized.
+Flags: Read / Write / Construct Only
+Default value: TRUE
+“scrollbars-visible” property“scrollbars-visible” gboolean+
Whether the scrollbars should be visible for the window.
+Flags: Read / Write / Construct Only
+Default value: TRUE
+“statusbar-visible” property“statusbar-visible” gboolean+
Whether the statusbar should be visible for the window.
+Flags: Read / Write / Construct Only
+Default value: TRUE
+“toolbar-visible” property“toolbar-visible” gboolean+
Whether the toolbar should be visible for the window.
+Flags: Read / Write / Construct Only
+Default value: TRUE
+| + | |
+ |
+ |
+ |
+
NULL is OK, both for passing and for returning.
Parameter points to an array of items.
This parameter is a 'user_data', for callbacks; many bindings can pass NULL here.
Generics and defining elements of containers and arrays.
NULL may be passed as the value in, out, in-out; or as a return value.
NULL may be passed instead of a pointer to a location.
Parameter for returning results. Default is transfer full.
The callback is valid until first called.
Free data container after the code is done.
Free data after the code is done.
Don't free data after the code is done.
| + | |
+ |
+ |
+ |
+
| + | |
+ |
+ |
+ |
+
| + | |
+ |
+ |
+ |
+
WPE Reference Manual |
|---|
for WPE WebKit 2.23.90
| +Top + | + |
+ |
+ |
+ |
+
| +GQuark + | ++webkit_network_error_quark () + | +
| +GQuark + | ++webkit_plugin_error_quark () + | +
| +GQuark + | ++webkit_policy_error_quark () + | +
| +GQuark + | ++webkit_download_error_quark () + | +
| +GQuark + | ++webkit_javascript_error_quark () + | +
| +GQuark + | ++webkit_snapshot_error_quark () + | +
| +GQuark + | ++webkit_user_content_filter_error_quark () + | +
| #define | +WEBKIT_NETWORK_ERROR | +
| #define | +WEBKIT_PLUGIN_ERROR | +
| #define | +WEBKIT_POLICY_ERROR | +
| #define | +WEBKIT_DOWNLOAD_ERROR | +
| #define | +WEBKIT_JAVASCRIPT_ERROR | +
| #define | +WEBKIT_SNAPSHOT_ERROR | +
| #define | +WEBKIT_USER_CONTENT_FILTER_ERROR | +
| enum | +WebKitNetworkError | +
| enum | +WebKitPluginError | +
| enum | +WebKitPolicyError | +
| enum | +WebKitDownloadError | +
| enum | +WebKitJavascriptError | +
| enum | +WebKitSnapshotError | +
| enum | +WebKitUserContentFilterError | +
GQuark
+webkit_user_content_filter_error_quark
+ (void);
+#define WEBKIT_USER_CONTENT_FILTER_ERROR webkit_user_content_filter_error_quark () ++
Enum values used to denote the various network errors.
+ +Enum values used to denote the various plugin errors.
+| + |
+ Generic plugin load failure + |
++ |
| + |
+ Load failure due to missing plugin + |
++ |
| + |
+ Load failure due to inability to load plugin + |
++ |
| + |
+ Load failure due to missing Java support that is required to load plugin + |
++ |
| + |
+ Load failure due to connection cancellation + |
++ |
| + |
+ Load failure since plugin handles the load + |
++ |
Enum values used to denote the various policy errors.
+| + |
+ Generic load failure due to policy error + |
++ |
| + |
+ Load failure due to unsupported mime type + |
++ |
| + |
+ Load failure due to URI that can not be shown + |
++ |
| + |
+ Load failure due to frame load interruption by policy change + |
++ |
| + |
+ Load failure due to port restriction + |
++ |
Enum values used to denote errors happening when executing JavaScript
+ +Enum values used to denote errors happening when creating snapshots of WebKitWebView
+ +| +Top + | + |
+ |
+ |
+ |
+
gchar *
+webkit_uri_for_display (const gchar *uri);
+Use this function to format a URI for display. The URIs used internally by +WebKit may contain percent-encoded characters or Punycode, which are not +generally suitable to display to users. This function provides protection +against IDN homograph attacks, so in some cases the host part of the returned +URI may be in Punycode if the safety check fails.
+ + +Since: 2.24
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitUserStyleSheet * + | ++webkit_user_style_sheet_ref () + | +
| +void + | ++webkit_user_style_sheet_unref () + | +
| +WebKitUserStyleSheet * + | ++webkit_user_style_sheet_new () + | +
| +WebKitUserStyleSheet * + | ++webkit_user_style_sheet_new_for_world () + | +
| +WebKitUserScript * + | ++webkit_user_script_ref () + | +
| +void + | ++webkit_user_script_unref () + | +
| +WebKitUserScript * + | ++webkit_user_script_new () + | +
| +WebKitUserScript * + | ++webkit_user_script_new_for_world () + | +
| +WebKitUserContentFilter * + | ++webkit_user_content_filter_ref () + | +
| +void + | ++webkit_user_content_filter_unref () + | +
| const char * + | ++webkit_user_content_filter_get_identifier () + | +
| + | WebKitUserStyleSheet | +
| + | WebKitUserScript | +
| enum | +WebKitUserContentInjectedFrames | +
| enum | +WebKitUserStyleLevel | +
| enum | +WebKitUserScriptInjectionTime | +
| + | WebKitUserContentFilter | +
GBoxed + ├── WebKitUserContentFilter + ├── WebKitUserScript + ╰── WebKitUserStyleSheet ++
WebKitUserStyleSheet *
+webkit_user_style_sheet_ref (WebKitUserStyleSheet *user_style_sheet);
+Atomically increments the reference count of user_style_sheet
+ by one.
+This function is MT-safe and may be called from any thread.
Since: 2.6
+void
+webkit_user_style_sheet_unref (WebKitUserStyleSheet *user_style_sheet);
+Atomically decrements the reference count of user_style_sheet
+ by one.
+If the reference count drops to 0, all memory allocated by
+WebKitUserStyleSheet is released. This function is MT-safe and may be
+called from any thread.
Since: 2.6
+WebKitUserStyleSheet * +webkit_user_style_sheet_new (+const gchar *source, +WebKitUserContentInjectedFrames injected_frames, +WebKitUserStyleLevel level, +const gchar * const *whitelist, +const gchar * const *blacklist);
Creates a new user style sheet. Style sheets can be applied to some URIs
+only by passing non-null values for whitelist
+ or blacklist
+. Passing a
+NULL whitelist implies that all URIs are on the whitelist. The style
+sheet is applied if an URI matches the whitelist and not the blacklist.
+URI patterns must be of the form [protocol]://[host]/[path], where the
+*host* and *path* components can contain the wildcard character (*) to
+represent zero or more other characters.
source |
+Source code of the user style sheet. |
++ |
injected_frames |
+A WebKitUserContentInjectedFrames value |
++ |
level |
++ | + |
whitelist |
+A whitelist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
blacklist |
+A blacklist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
Since: 2.6
+WebKitUserStyleSheet * +webkit_user_style_sheet_new_for_world (+const gchar *source, +WebKitUserContentInjectedFrames injected_frames, +WebKitUserStyleLevel level, +const gchar *world_name, +const gchar * const *whitelist, +const gchar * const *blacklist);
Creates a new user style sheet for script world with name world_name
+.
+See webkit_user_style_sheet_new() for a full description.
source |
+Source code of the user style sheet. |
++ |
injected_frames |
+A WebKitUserContentInjectedFrames value |
++ |
level |
++ | + |
world_name |
+the name of a WebKitScriptWorld |
++ |
whitelist |
+A whitelist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
blacklist |
+A blacklist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
Since: 2.22
+WebKitUserScript *
+webkit_user_script_ref (WebKitUserScript *user_script);
+Atomically increments the reference count of user_script
+ by one.
+This function is MT-safe and may be called from any thread.
Since: 2.6
+void
+webkit_user_script_unref (WebKitUserScript *user_script);
+Atomically decrements the reference count of user_script
+ by one.
+If the reference count drops to 0, all memory allocated by
+WebKitUserScript is released. This function is MT-safe and may be called
+from any thread.
Since: 2.6
+WebKitUserScript * +webkit_user_script_new (+const gchar *source, +WebKitUserContentInjectedFrames injected_frames, +WebKitUserScriptInjectionTime injection_time, +const gchar * const *whitelist, +const gchar * const *blacklist);
Creates a new user script. Scripts can be applied to some URIs
+only by passing non-null values for whitelist
+ or blacklist
+. Passing a
+NULL whitelist implies that all URIs are on the whitelist. The script
+is applied if an URI matches the whitelist and not the blacklist.
+URI patterns must be of the form [protocol]://[host]/[path], where the
+*host* and *path* components can contain the wildcard character (*) to
+represent zero or more other characters.
source |
+Source code of the user script. |
++ |
injected_frames |
+A WebKitUserContentInjectedFrames value |
++ |
injection_time |
+A WebKitUserScriptInjectionTime value |
++ |
whitelist |
+A whitelist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
blacklist |
+A blacklist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
Since: 2.6
+WebKitUserScript * +webkit_user_script_new_for_world (+const gchar *source, +WebKitUserContentInjectedFrames injected_frames, +WebKitUserScriptInjectionTime injection_time, +const gchar *world_name, +const gchar * const *whitelist, +const gchar * const *blacklist);
Creates a new user script for script world with name world_name
+.
+See webkit_user_script_new() for a full description.
source |
+Source code of the user script. |
++ |
injected_frames |
+A WebKitUserContentInjectedFrames value |
++ |
injection_time |
+A WebKitUserScriptInjectionTime value |
++ |
world_name |
+the name of a WebKitScriptWorld |
++ |
whitelist |
+A whitelist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
blacklist |
+A blacklist of URI patterns or |
+[array zero-terminated=1][allow-none] | +
Since: 2.22
+WebKitUserContentFilter *
+webkit_user_content_filter_ref (WebKitUserContentFilter *user_content_filter);
+Atomically increments the reference count of user_content_filter
+ by one.
+This function is MT-safe and may be called from any thread.
Since: 2.24
+void
+webkit_user_content_filter_unref (WebKitUserContentFilter *user_content_filter);
+Atomically decrements the reference count of user_content_filter
+ by one.
+If the reference count drops to 0, all the memory allocated by the
+WebKitUserContentFilter is released. This function is MT-safe and may
+be called from any thread.
Since: 2.24
+const char *
+webkit_user_content_filter_get_identifier
+ (WebKitUserContentFilter *user_content_filter);
+Obtain the identifier previously used to save the user_content_filter
+ in the
+WebKitUserContentFilterStore.
Since: 2.24
+Specifies in which frames user style sheets are to be inserted in.
+| + |
+ Insert the user style + sheet in all the frames loaded by the web view, including + nested frames. This is the default. + |
++ |
| + |
+ Insert the user style + sheet *only* in the top-level frame loaded by the web view, + and *not* in the nested frames. + |
++ |
Since: 2.6
+Specifies how to treat an user style sheet.
+| + |
+ The style sheet is an user style sheet, + its contents always override other style sheets. This is the default. + |
++ |
| + |
+ The style sheet will be treated as if + it was provided by the loaded documents. That means other user style + sheets may still override it. + |
++ |
Since: 2.6
+Specifies at which place of documents an user script will be inserted.
+ +Since: 2.6
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitConsoleMessage * + | ++webkit_console_message_copy () + | +
| +void + | ++webkit_console_message_free () + | +
| +WebKitConsoleMessageSource + | ++webkit_console_message_get_source () + | +
| +WebKitConsoleMessageLevel + | ++webkit_console_message_get_level () + | +
| const gchar * + | ++webkit_console_message_get_text () + | +
| +guint + | ++webkit_console_message_get_line () + | +
| const gchar * + | ++webkit_console_message_get_source_id () + | +
| + | WebKitConsoleMessage | +
| enum | +WebKitConsoleMessageSource | +
| enum | +WebKitConsoleMessageLevel | +
GBoxed + ╰── WebKitConsoleMessage + GEnum + ├── WebKitConsoleMessageLevel + ╰── WebKitConsoleMessageSource ++
WebKitConsoleMessage *
+webkit_console_message_copy (WebKitConsoleMessage *console_message);
+Make a copy of console_message
+.
Since: 2.12
+void
+webkit_console_message_free (WebKitConsoleMessage *console_message);
+Free the WebKitConsoleMessage
+ +Since: 2.12
+WebKitConsoleMessageSource
+webkit_console_message_get_source (WebKitConsoleMessage *console_message);
+Gets the source of a WebKitConsoleMessage
+ + +Since: 2.12
+WebKitConsoleMessageLevel
+webkit_console_message_get_level (WebKitConsoleMessage *console_message);
+Gets the log level of a WebKitConsoleMessage
+ + +Since: 2.12
+const gchar *
+webkit_console_message_get_text (WebKitConsoleMessage *console_message);
+Gets the text message of a WebKitConsoleMessage
+ + +Since: 2.12
+guint
+webkit_console_message_get_line (WebKitConsoleMessage *console_message);
+Gets the line number of a WebKitConsoleMessage
+ + +Since: 2.12
+const gchar *
+webkit_console_message_get_source_id (WebKitConsoleMessage *console_message);
+Gets the source identifier of a WebKitConsoleMessage
+ + +Since: 2.12
+Enum values used to denote the various sources of console messages.
+| + |
+ Message produced by JavaScript. + |
++ |
| + |
+ Network messages. + |
++ |
| + |
+ Messages produced by console API. + |
++ |
| + |
+ Security messages. + |
++ |
| + |
+ Other messages. + |
++ |
Since: 2.12
+| +Top + | + |
+ |
+ |
+ |
+
| +Top + | + |
+ |
+ |
+ |
+
| +gboolean + | ++webkit_dom_element_html_input_element_is_user_edited () + | +
| +gboolean + | ++webkit_dom_element_html_input_element_get_auto_filled () + | +
| +void + | ++webkit_dom_element_html_input_element_set_auto_filled () + | +
| +void + | ++webkit_dom_element_html_input_element_set_editing_value () + | +
gboolean
+webkit_dom_element_html_input_element_is_user_edited
+ (WebKitDOMElement *element);
+Get whether element
+ is an HTML text input element that has been edited by a user action.
Since: 2.22
+gboolean
+webkit_dom_element_html_input_element_get_auto_filled
+ (WebKitDOMElement *element);
+void +webkit_dom_element_html_input_element_set_auto_filled + (+WebKitDOMElement *element, +gboolean auto_filled);
Set whether the element is an HTML input element that has been filled automatically.
+If element
+ is not an HTML input element this function does nothing.
Since: 2.22
+void +webkit_dom_element_html_input_element_set_editing_value + (+WebKitDOMElement *element, +const char *value);
Set editing value of an HTML input element. If element
+ is not an HTML input element this function does nothing.
Since: 2.22
+| +Top + | + |
+ |
+ |
+ |
+
GObject + ╰── WebKitDOMObject + ╰── WebKitDOMNode + ├── WebKitDOMDocument + ╰── WebKitDOMElement ++
WebKitDOMNode *
+webkit_dom_node_for_js_value (JSCValue *value);
+Get the WebKitDOMNode for the DOM node referenced by value
+.
Since: 2.22
+| +Top + | + |
+ |
+ |
+ |
+
| +Top + | + |
+ |
+ |
+ |
+
| +gboolean + | ++webkit_frame_is_main_frame () + | +
| const gchar * + | ++webkit_frame_get_uri () + | +
| +JSCContext * + | ++webkit_frame_get_js_context () + | +
| +JSCContext * + | ++webkit_frame_get_js_context_for_script_world () + | +
| +JSCValue * + | ++webkit_frame_get_js_value_for_dom_object () + | +
| +JSCValue * + | ++webkit_frame_get_js_value_for_dom_object_in_script_world () + | +
gboolean
+webkit_frame_is_main_frame (WebKitFrame *frame);
+Gets whether frame
+ is the main frame of a WebKitWebPage
Since: 2.2
+const gchar *
+webkit_frame_get_uri (WebKitFrame *frame);
+Gets the current active URI of frame
+.
Since: 2.2
+JSCContext *
+webkit_frame_get_js_context (WebKitFrame *frame);
+Get the JavaScript execution context of frame
+. Use this function to bridge
+between the WebKit and JavaScriptCore APIs.
Since: 2.22
+JSCContext * +webkit_frame_get_js_context_for_script_world + (+WebKitFrame *frame, +WebKitScriptWorld *world);
Get the JavaScript execution context of frame
+ for the given WebKitScriptWorld.
the JSCContext for the JavaScript execution context of frame
+for world
+.
[transfer full]
+Since: 2.22
+JSCValue * +webkit_frame_get_js_value_for_dom_object + (+WebKitFrame *frame, +WebKitDOMObject *dom_object);
Get a JSCValue referencing the given DOM object. The value is created in the JavaScript execution
+context of frame
+.
Since: 2.22
+JSCValue * +webkit_frame_get_js_value_for_dom_object_in_script_world + (+WebKitFrame *frame, +WebKitDOMObject *dom_object, +WebKitScriptWorld *world);
Get a JSCValue referencing the given DOM object. The value is created in the JavaScript execution
+context of frame
+ for the given WebKitScriptWorld.
Since: 2.22
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitScriptWorld * + | ++webkit_script_world_get_default () + | +
| +WebKitScriptWorld * + | ++webkit_script_world_new () + | +
| +WebKitScriptWorld * + | ++webkit_script_world_new_with_name () + | +
| const char * + | ++webkit_script_world_get_name () + | +
WebKitScriptWorld *
+webkit_script_world_get_default (void);
+Get the default WebKitScriptWorld. This is the normal script world
+where all scripts are executed by default.
+You can get the JavaScript execution context of a WebKitScriptWorld
+for a given WebKitFrame with webkit_frame_get_javascript_context_for_script_world().
Since: 2.2
+WebKitScriptWorld *
+webkit_script_world_new (void);
+Creates a new isolated WebKitScriptWorld. Scripts executed in
+isolated worlds have access to the DOM but not to other variable
+or functions created by the page.
+The WebKitScriptWorld is created with a generated unique name. Use
+webkit_script_world_new_with_name() if you want to create it with a
+custom name.
+You can get the JavaScript execution context of a WebKitScriptWorld
+for a given WebKitFrame with webkit_frame_get_javascript_context_for_script_world().
Since: 2.2
+WebKitScriptWorld *
+webkit_script_world_new_with_name (const char *name);
+Creates a new isolated WebKitScriptWorld with a name. Scripts executed in
+isolated worlds have access to the DOM but not to other variable
+or functions created by the page.
+You can get the JavaScript execution context of a WebKitScriptWorld
+for a given WebKitFrame with webkit_frame_get_javascript_context_for_script_world().
Since: 2.22
+const char *
+webkit_script_world_get_name (WebKitScriptWorld *world);
+Get the name of a WebKitScriptWorld.
+ + +Since: 2.22
+“window-object-cleared” signalvoid +user_function (WebKitScriptWorld *world, + WebKitWebPage *page, + WebKitFrame *frame, + gpointer user_data)+
Emitted when the JavaScript window object in a WebKitScriptWorld has been
+cleared. This is the preferred place to set custom properties on the window
+object using the JavaScriptCore API. You can get the window object of frame
+
+from the JavaScript execution context of world
+ that is returned by
+webkit_frame_get_javascript_context_for_script_world().
world |
+the WebKitScriptWorld on which the signal is emitted |
++ |
page |
++ | + |
frame |
+the WebKitFrame to which |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.2
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitWebEditor+WebKitWebEditor — Access to editing capabilities of a WebKitWebPage + |
++ |
The WebKitWebEditor provides access to various editing capabilities of +a WebKitWebPage such as a possibility to react to the current selection in +WebKitWebPage.
+WebKitWebPage *
+webkit_web_editor_get_page (WebKitWebEditor *editor);
+Gets the WebKitWebPage that is associated with the WebKitWebEditor that can +be used to access the WebKitDOMDocument currently loaded into it.
+ + +Since: 2.10
+“selection-changed” signalvoid +user_function (WebKitWebEditor *editor, + gpointer user_data)+
This signal is emitted for every selection change inside a WebKitWebPage +as well as for every caret position change as the caret is a collapsed +selection.
+editor |
+the WebKitWebEditor on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.10
+| +Top + | + |
+ |
+ |
+ |
+
| +void + | ++(*WebKitWebExtensionInitializeFunction) () + | +
| +void + | ++(*WebKitWebExtensionInitializeWithUserDataFunction) () + | +
| +WebKitWebPage * + | ++webkit_web_extension_get_page () + | +
WebKitWebExtension is a loadable module for the WebProcess. It allows you to execute code in the +WebProcess and being able to use the DOM API, to change any request or to inject custom +JavaScript code, for example.
+To create a WebKitWebExtension you should write a module with an initialization function that could
+be either webkit_web_extension_initialize() with prototype WebKitWebExtensionInitializeFunction or
+webkit_web_extension_initialize_with_user_data() with prototype WebKitWebExtensionInitializeWithUserDataFunction.
+This function has to be public and it has to use the G_MODULE_EXPORT macro. It is called when the
+web process is initialized.
1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 |
+ static void +web_page_created_callback (WebKitWebExtension *extension, + WebKitWebPage *web_page, + gpointer user_data) +{ + g_print ("Page %d created for %s\n", + webkit_web_page_get_id (web_page), + webkit_web_page_get_uri (web_page)); +} + +G_MODULE_EXPORT void +webkit_web_extension_initialize (WebKitWebExtension *extension) +{ + g_signal_connect (extension, "page-created", + G_CALLBACK (web_page_created_callback), + NULL); +} |
+
The previous piece of code shows a trivial example of an extension that notifies when +a WebKitWebPage is created.
+WebKit has to know where it can find the created WebKitWebExtension. To do so you
+should use the webkit_web_context_set_web_extensions_directory() function. The signal
+“initialize-web-extensions” is the recommended place to call it.
To provide the initialization data used by the webkit_web_extension_initialize_with_user_data()
+function, you have to call webkit_web_context_set_web_extensions_initialization_user_data() with
+the desired data as parameter. You can see an example of this in the following piece of code:
1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 |
+ #define WEB_EXTENSIONS_DIRECTORY /* ... */ + +static void +initialize_web_extensions (WebKitWebContext *context, + gpointer user_data) +{ + /* Web Extensions get a different ID for each Web Process */ + static guint32 unique_id = 0; + + webkit_web_context_set_web_extensions_directory ( + context, WEB_EXTENSIONS_DIRECTORY); + webkit_web_context_set_web_extensions_initialization_user_data ( + context, g_variant_new_uint32 (unique_id++)); +} + +int main (int argc, char **argv) +{ + g_signal_connect (webkit_web_context_get_default (), + "initialize-web-extensions", + G_CALLBACK (initialize_web_extensions), + NULL); + + GtkWidget *view = webkit_web_view_new (); + + /* ... */ +} |
+
void
+(*WebKitWebExtensionInitializeFunction)
+ (WebKitWebExtension *extension);
+Type definition for a function that will be called to initialize +the web extension when the web process starts.
+ +void +(*WebKitWebExtensionInitializeWithUserDataFunction) + (+WebKitWebExtension *extension, +const GVariant *user_data);
Type definition for a function that will be called to initialize
+the web extensions when the web process starts, and which receives
+as additional argument the user data set with
+webkit_web_context_set_web_extensions_initialization_user_data().
Since: 2.4
+WebKitWebPage * +webkit_web_extension_get_page (+WebKitWebExtension *extension, +guint64 page_id);
Get the web page of the given page_id
+.
extension |
++ | + |
page_id |
+the identifier of the WebKitWebPage to get |
++ |
the WebKitWebPage for the given page_id
+, or NULL if the
+identifier doesn't correspond to an existing web page.
[transfer none]
+“page-created” signalvoid +user_function (WebKitWebExtension *extension, + WebKitWebPage *web_page, + gpointer user_data)+
This signal is emitted when a new WebKitWebPage is created in +the Web Process.
+extension |
+the WebKitWebExtension on which the signal is emitted |
++ |
web_page |
+the WebKitWebPage created |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitWebHitTestResult+WebKitWebHitTestResult — Result of a Hit Test (Web Process Extensions) + |
++ |
WebKitWebHitTestResult extends WebKitHitTestResult to provide information +about the WebKitDOMNode in the coordinates of the Hit Test.
+WebKitDOMNode *
+webkit_web_hit_test_result_get_node (WebKitWebHitTestResult *hit_test_result);
+Get the WebKitDOMNode in the coordinates of the Hit Test.
+ + +Since: 2.8
+“node” property“node” WebKitDOMNode *+
The WebKitDOMNode
+Flags: Read / Write / Construct Only
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitDOMDocument * + | ++webkit_web_page_get_dom_document () + | +
| +guint64 + | ++webkit_web_page_get_id () + | +
| const gchar * + | ++webkit_web_page_get_uri () + | +
| +WebKitFrame * + | ++webkit_web_page_get_main_frame () + | +
| +WebKitWebEditor * + | ++webkit_web_page_get_editor () + | +
| void | +console-message-sent | +Run Last | +
| gboolean | +context-menu | +Run Last | +
| void | +document-loaded | +Run Last | +
| void | +form-controls-associated | +Run Last | +
| gboolean | +send-request | +Run Last | +
| void | +will-submit-form | +Run Last | +
WebKitDOMDocument *
+webkit_web_page_get_dom_document (WebKitWebPage *web_page);
+Get the WebKitDOMDocument currently loaded in web_page
+
the WebKitDOMDocument currently loaded, or NULL
+if no document is currently loaded.
[transfer none]
+guint64
+webkit_web_page_get_id (WebKitWebPage *web_page);
+Get the identifier of the WebKitWebPage
+ + +const gchar *
+webkit_web_page_get_uri (WebKitWebPage *web_page);
+Returns the current active URI of web_page
+.
You can monitor the active URI by connecting to the notify::uri
+signal of web_page
+.
WebKitFrame *
+webkit_web_page_get_main_frame (WebKitWebPage *web_page);
+Returns the main frame of a WebKitWebPage.
+ + +Since: 2.2
+WebKitWebEditor *
+webkit_web_page_get_editor (WebKitWebPage *web_page);
+Gets the WebKitWebEditor of a WebKitWebPage.
+ + +Since: 2.10
+Used to indicate a particular stage in form submission. See +“will-submit-form”.
+ +“uri” property“uri” gchar *+
The current active URI of the WebKitWebPage.
+Flags: Read
+Default value: NULL
+“console-message-sent” signalvoid +user_function (WebKitWebPage *web_page, + WebKitConsoleMessage *console_message, + gpointer user_data)+
Emitted when a message is sent to the console. This can be a message
+produced by the use of JavaScript console API, a JavaScript exception,
+a security error or other errors, warnings, debug or log messages.
+The console_message
+ contains information of the message.
web_page |
+the WebKitWebPage on which the signal is emitted |
++ |
console_message |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.12
+“context-menu” signalgboolean +user_function (WebKitWebPage *web_page, + WebKitContextMenu *context_menu, + WebKitWebHitTestResult *hit_test_result, + gpointer user_data)+
Emitted before a context menu is displayed in the UI Process to
+give the application a chance to customize the proposed menu,
+build its own context menu or pass user data to the UI Process.
+This signal is useful when the information available in the UI Process
+is not enough to build or customize the context menu, for example, to
+add menu entries depending on the WebKitDOMNode at the coordinates of the
+hit_test_result
+. Otherwise, it's recommended to use “context-menu”
+signal instead.
web_page |
+the WebKitWebPage on which the signal is emitted |
++ |
context_menu |
+the proposed WebKitContextMenu |
++ |
hit_test_result |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.8
+“document-loaded” signalvoid +user_function (WebKitWebPage *web_page, + gpointer user_data)+
This signal is emitted when the DOM document of a WebKitWebPage has been +loaded.
+You can wait for this signal to get the DOM document with
+webkit_web_page_get_dom_document().
web_page |
+the WebKitWebPage on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“form-controls-associated” signalvoid +user_function (WebKitWebPage *web_page, + GPtrArray *elements, + gpointer user_data)+
Emitted after form elements (or form associated elements) are associated to a particular web +page. This is useful to implement form auto filling for web pages where form fields are added +dynamically. This signal might be emitted multiple times for the same web page.
+Note that this signal could be also emitted when form controls are moved between forms. In
+that case, the elements
+ array carries the list of those elements which have moved.
Clients should take a reference to the members of the elements
+ array if it is desired to
+keep them alive after the signal handler returns.
web_page |
+the WebKitWebPage on which the signal is emitted |
++ |
elements |
+a GPtrArray of +WebKitDOMElement with the list of forms in the page. |
+[element-type WebKitDOMElement][transfer none] | +
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.16
+“send-request” signalgboolean +user_function (WebKitWebPage *web_page, + WebKitURIRequest *request, + WebKitURIResponse *redirected_response, + gpointer user_data)+
This signal is emitted when request
+ is about to be sent to
+the server. This signal can be used to modify the WebKitURIRequest
+that will be sent to the server. You can also cancel the resource load
+operation by connecting to this signal and returning TRUE.
In case of a server redirection this signal is
+emitted again with the request
+ argument containing the new
+request to be sent to the server due to the redirection and the
+redirected_response
+ parameter containing the response
+received by the server for the initial request.
Modifications to the WebKitURIRequest and its associated +SoupMessageHeaders will be taken into account when the request +is sent over the network.
+web_page |
+the WebKitWebPage on which the signal is emitted |
++ |
request |
+a WebKitURIRequest |
++ |
redirected_response |
+a WebKitURIResponse, or |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to continue emission of the event.
Flags: Run Last
+“will-submit-form” signalvoid +user_function (WebKitWebPage *web_page, + WebKitDOMElement *form, + WebKitFormSubmissionStep step, + WebKitFrame *source_frame, + WebKitFrame *target_frame, + GPtrArray *text_field_names, + GPtrArray *text_field_values, + gpointer user_data)+
This signal is emitted to indicate various points during form
+submission. step
+ indicates the current stage of form submission.
If this signal is emitted with WEBKIT_FORM_SUBMISSION_WILL_SEND_DOM_EVENT,
+then the DOM submit event is about to be emitted. JavaScript code
+may rely on the submit event to detect that the user has clicked
+on a submit button, and to possibly cancel the form submission
+before WEBKIT_FORM_SUBMISSION_WILL_COMPLETE. However, beware
+that, for historical reasons, the submit event is not emitted at
+all if the form submission is triggered by JavaScript. For these
+reasons, WEBKIT_FORM_SUBMISSION_WILL_SEND_DOM_EVENT may not
+be used to reliably detect whether a form will be submitted.
+Instead, use it to detect if a user has clicked on a form's
+submit button even if JavaScript later cancels the form
+submission, or to read the values of the form's fields even if
+JavaScript later clears certain fields before submitting. This
+may be needed, for example, to implement a robust browser
+password manager, as some misguided websites may use such
+techniques to attempt to thwart password managers.
If this signal is emitted with WEBKIT_FORM_SUBMISSION_WILL_COMPLETE,
+the form will imminently be submitted. It can no longer be
+cancelled. This event always occurs immediately before a form is
+submitted to its target, so use this event to reliably detect
+when a form is submitted. This event occurs after
+WEBKIT_FORM_SUBMISSION_WILL_SEND_DOM_EVENT if that event is
+emitted.
web_page |
+the WebKitWebPage on which the signal is emitted |
++ |
form |
+the WebKitDOMElement to be submitted, which will always correspond to an HTMLFormElement |
++ |
step |
+a WebKitFormSubmissionEventType indicating the current +stage of form submission |
++ |
source_frame |
+the WebKitFrame containing the form to be +submitted |
++ |
target_frame |
+the WebKitFrame containing the form's target,
+which may be the same as |
++ |
text_field_names |
+names of +the form's text fields. |
+[element-type utf8][transfer none] | +
text_field_values |
+values +of the form's text fields. |
+[element-type utf8][transfer none] | +
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.20
+| + | |
+ |
+ |
+ |
+
Generics and defining elements of containers and arrays.
Free data after the code is done.
Don't free data after the code is done.
| + | |
+ |
+ |
+ |
+
| + | |
+ |
+ |
+ |
+
| + | |
+ |
+ |
+ |
+
WPE WebExtensions and DOM Reference Manual |
|---|
for WPE WebKit 2.23.90
| +Top + | + |
+ |
+ |
+ |
+
| +WebKitConsoleMessage * + | ++webkit_console_message_copy () + | +
| +void + | ++webkit_console_message_free () + | +
| +WebKitConsoleMessageSource + | ++webkit_console_message_get_source () + | +
| +WebKitConsoleMessageLevel + | ++webkit_console_message_get_level () + | +
| const gchar * + | ++webkit_console_message_get_text () + | +
| +guint + | ++webkit_console_message_get_line () + | +
| const gchar * + | ++webkit_console_message_get_source_id () + | +
| + | WebKitConsoleMessage | +
| enum | +WebKitConsoleMessageSource | +
| enum | +WebKitConsoleMessageLevel | +
GBoxed + ╰── WebKitConsoleMessage + GEnum + ├── WebKitConsoleMessageLevel + ╰── WebKitConsoleMessageSource ++
WebKitConsoleMessage *
+webkit_console_message_copy (WebKitConsoleMessage *console_message);
+Make a copy of console_message
+.
Since: 2.12
+void
+webkit_console_message_free (WebKitConsoleMessage *console_message);
+Free the WebKitConsoleMessage
+ +Since: 2.12
+WebKitConsoleMessageSource
+webkit_console_message_get_source (WebKitConsoleMessage *console_message);
+Gets the source of a WebKitConsoleMessage
+ + +Since: 2.12
+WebKitConsoleMessageLevel
+webkit_console_message_get_level (WebKitConsoleMessage *console_message);
+Gets the log level of a WebKitConsoleMessage
+ + +Since: 2.12
+const gchar *
+webkit_console_message_get_text (WebKitConsoleMessage *console_message);
+Gets the text message of a WebKitConsoleMessage
+ + +Since: 2.12
+guint
+webkit_console_message_get_line (WebKitConsoleMessage *console_message);
+Gets the line number of a WebKitConsoleMessage
+ + +Since: 2.12
+const gchar *
+webkit_console_message_get_source_id (WebKitConsoleMessage *console_message);
+Gets the source identifier of a WebKitConsoleMessage
+ + +Since: 2.12
+Enum values used to denote the various sources of console messages.
+| + |
+ Message produced by JavaScript. + |
++ |
| + |
+ Network messages. + |
++ |
| + |
+ Messages produced by console API. + |
++ |
| + |
+ Security messages. + |
++ |
| + |
+ Other messages. + |
++ |
Since: 2.12
+| +Top + | + |
+ |
+ |
+ |
+
| +Top + | + |
+ |
+ |
+ |
+
| +gboolean + | ++webkit_dom_element_html_input_element_is_user_edited () + | +
| +gboolean + | ++webkit_dom_element_html_input_element_get_auto_filled () + | +
| +void + | ++webkit_dom_element_html_input_element_set_auto_filled () + | +
| +void + | ++webkit_dom_element_html_input_element_set_editing_value () + | +
gboolean
+webkit_dom_element_html_input_element_is_user_edited
+ (WebKitDOMElement *element);
+Get whether element
+ is an HTML text input element that has been edited by a user action.
Since: 2.22
+gboolean
+webkit_dom_element_html_input_element_get_auto_filled
+ (WebKitDOMElement *element);
+void +webkit_dom_element_html_input_element_set_auto_filled + (+WebKitDOMElement *element, +gboolean auto_filled);
Set whether the element is an HTML input element that has been filled automatically.
+If element
+ is not an HTML input element this function does nothing.
Since: 2.22
+void +webkit_dom_element_html_input_element_set_editing_value + (+WebKitDOMElement *element, +const char *value);
Set editing value of an HTML input element. If element
+ is not an HTML input element this function does nothing.
Since: 2.22
+| +Top + | + |
+ |
+ |
+ |
+
GObject + ╰── WebKitDOMObject + ╰── WebKitDOMNode + ├── WebKitDOMDocument + ╰── WebKitDOMElement ++
WebKitDOMNode *
+webkit_dom_node_for_js_value (JSCValue *value);
+Get the WebKitDOMNode for the DOM node referenced by value
+.
Since: 2.22
+| +Top + | + |
+ |
+ |
+ |
+
| +Top + | + |
+ |
+ |
+ |
+
| +gboolean + | ++webkit_frame_is_main_frame () + | +
| const gchar * + | ++webkit_frame_get_uri () + | +
| +JSCContext * + | ++webkit_frame_get_js_context () + | +
| +JSCContext * + | ++webkit_frame_get_js_context_for_script_world () + | +
| +JSCValue * + | ++webkit_frame_get_js_value_for_dom_object () + | +
| +JSCValue * + | ++webkit_frame_get_js_value_for_dom_object_in_script_world () + | +
gboolean
+webkit_frame_is_main_frame (WebKitFrame *frame);
+Gets whether frame
+ is the main frame of a WebKitWebPage
Since: 2.2
+const gchar *
+webkit_frame_get_uri (WebKitFrame *frame);
+Gets the current active URI of frame
+.
Since: 2.2
+JSCContext *
+webkit_frame_get_js_context (WebKitFrame *frame);
+Get the JavaScript execution context of frame
+. Use this function to bridge
+between the WebKit and JavaScriptCore APIs.
Since: 2.22
+JSCContext * +webkit_frame_get_js_context_for_script_world + (+WebKitFrame *frame, +WebKitScriptWorld *world);
Get the JavaScript execution context of frame
+ for the given WebKitScriptWorld.
the JSCContext for the JavaScript execution context of frame
+for world
+.
[transfer full]
+Since: 2.22
+JSCValue * +webkit_frame_get_js_value_for_dom_object + (+WebKitFrame *frame, +WebKitDOMObject *dom_object);
Get a JSCValue referencing the given DOM object. The value is created in the JavaScript execution
+context of frame
+.
Since: 2.22
+JSCValue * +webkit_frame_get_js_value_for_dom_object_in_script_world + (+WebKitFrame *frame, +WebKitDOMObject *dom_object, +WebKitScriptWorld *world);
Get a JSCValue referencing the given DOM object. The value is created in the JavaScript execution
+context of frame
+ for the given WebKitScriptWorld.
Since: 2.22
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitScriptWorld * + | ++webkit_script_world_get_default () + | +
| +WebKitScriptWorld * + | ++webkit_script_world_new () + | +
| +WebKitScriptWorld * + | ++webkit_script_world_new_with_name () + | +
| const char * + | ++webkit_script_world_get_name () + | +
WebKitScriptWorld *
+webkit_script_world_get_default (void);
+Get the default WebKitScriptWorld. This is the normal script world
+where all scripts are executed by default.
+You can get the JavaScript execution context of a WebKitScriptWorld
+for a given WebKitFrame with webkit_frame_get_javascript_context_for_script_world().
Since: 2.2
+WebKitScriptWorld *
+webkit_script_world_new (void);
+Creates a new isolated WebKitScriptWorld. Scripts executed in
+isolated worlds have access to the DOM but not to other variable
+or functions created by the page.
+The WebKitScriptWorld is created with a generated unique name. Use
+webkit_script_world_new_with_name() if you want to create it with a
+custom name.
+You can get the JavaScript execution context of a WebKitScriptWorld
+for a given WebKitFrame with webkit_frame_get_javascript_context_for_script_world().
Since: 2.2
+WebKitScriptWorld *
+webkit_script_world_new_with_name (const char *name);
+Creates a new isolated WebKitScriptWorld with a name. Scripts executed in
+isolated worlds have access to the DOM but not to other variable
+or functions created by the page.
+You can get the JavaScript execution context of a WebKitScriptWorld
+for a given WebKitFrame with webkit_frame_get_javascript_context_for_script_world().
Since: 2.22
+const char *
+webkit_script_world_get_name (WebKitScriptWorld *world);
+Get the name of a WebKitScriptWorld.
+ + +Since: 2.22
+“window-object-cleared” signalvoid +user_function (WebKitScriptWorld *world, + WebKitWebPage *page, + WebKitFrame *frame, + gpointer user_data)+
Emitted when the JavaScript window object in a WebKitScriptWorld has been
+cleared. This is the preferred place to set custom properties on the window
+object using the JavaScriptCore API. You can get the window object of frame
+
+from the JavaScript execution context of world
+ that is returned by
+webkit_frame_get_javascript_context_for_script_world().
world |
+the WebKitScriptWorld on which the signal is emitted |
++ |
page |
++ | + |
frame |
+the WebKitFrame to which |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.2
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitWebEditor+WebKitWebEditor — Access to editing capabilities of a WebKitWebPage + |
++ |
The WebKitWebEditor provides access to various editing capabilities of +a WebKitWebPage such as a possibility to react to the current selection in +WebKitWebPage.
+WebKitWebPage *
+webkit_web_editor_get_page (WebKitWebEditor *editor);
+Gets the WebKitWebPage that is associated with the WebKitWebEditor that can +be used to access the WebKitDOMDocument currently loaded into it.
+ + +Since: 2.10
+“selection-changed” signalvoid +user_function (WebKitWebEditor *editor, + gpointer user_data)+
This signal is emitted for every selection change inside a WebKitWebPage +as well as for every caret position change as the caret is a collapsed +selection.
+editor |
+the WebKitWebEditor on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.10
+| +Top + | + |
+ |
+ |
+ |
+
| +void + | ++(*WebKitWebExtensionInitializeFunction) () + | +
| +void + | ++(*WebKitWebExtensionInitializeWithUserDataFunction) () + | +
| +WebKitWebPage * + | ++webkit_web_extension_get_page () + | +
WebKitWebExtension is a loadable module for the WebProcess. It allows you to execute code in the +WebProcess and being able to use the DOM API, to change any request or to inject custom +JavaScript code, for example.
+To create a WebKitWebExtension you should write a module with an initialization function that could
+be either webkit_web_extension_initialize() with prototype WebKitWebExtensionInitializeFunction or
+webkit_web_extension_initialize_with_user_data() with prototype WebKitWebExtensionInitializeWithUserDataFunction.
+This function has to be public and it has to use the G_MODULE_EXPORT macro. It is called when the
+web process is initialized.
1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 |
+ static void +web_page_created_callback (WebKitWebExtension *extension, + WebKitWebPage *web_page, + gpointer user_data) +{ + g_print ("Page %d created for %s\n", + webkit_web_page_get_id (web_page), + webkit_web_page_get_uri (web_page)); +} + +G_MODULE_EXPORT void +webkit_web_extension_initialize (WebKitWebExtension *extension) +{ + g_signal_connect (extension, "page-created", + G_CALLBACK (web_page_created_callback), + NULL); +} |
+
The previous piece of code shows a trivial example of an extension that notifies when +a WebKitWebPage is created.
+WebKit has to know where it can find the created WebKitWebExtension. To do so you
+should use the webkit_web_context_set_web_extensions_directory() function. The signal
+“initialize-web-extensions” is the recommended place to call it.
To provide the initialization data used by the webkit_web_extension_initialize_with_user_data()
+function, you have to call webkit_web_context_set_web_extensions_initialization_user_data() with
+the desired data as parameter. You can see an example of this in the following piece of code:
1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 |
+ #define WEB_EXTENSIONS_DIRECTORY /* ... */ + +static void +initialize_web_extensions (WebKitWebContext *context, + gpointer user_data) +{ + /* Web Extensions get a different ID for each Web Process */ + static guint32 unique_id = 0; + + webkit_web_context_set_web_extensions_directory ( + context, WEB_EXTENSIONS_DIRECTORY); + webkit_web_context_set_web_extensions_initialization_user_data ( + context, g_variant_new_uint32 (unique_id++)); +} + +int main (int argc, char **argv) +{ + g_signal_connect (webkit_web_context_get_default (), + "initialize-web-extensions", + G_CALLBACK (initialize_web_extensions), + NULL); + + GtkWidget *view = webkit_web_view_new (); + + /* ... */ +} |
+
void
+(*WebKitWebExtensionInitializeFunction)
+ (WebKitWebExtension *extension);
+Type definition for a function that will be called to initialize +the web extension when the web process starts.
+ +void +(*WebKitWebExtensionInitializeWithUserDataFunction) + (+WebKitWebExtension *extension, +const GVariant *user_data);
Type definition for a function that will be called to initialize
+the web extensions when the web process starts, and which receives
+as additional argument the user data set with
+webkit_web_context_set_web_extensions_initialization_user_data().
Since: 2.4
+WebKitWebPage * +webkit_web_extension_get_page (+WebKitWebExtension *extension, +guint64 page_id);
Get the web page of the given page_id
+.
extension |
++ | + |
page_id |
+the identifier of the WebKitWebPage to get |
++ |
the WebKitWebPage for the given page_id
+, or NULL if the
+identifier doesn't correspond to an existing web page.
[transfer none]
+“page-created” signalvoid +user_function (WebKitWebExtension *extension, + WebKitWebPage *web_page, + gpointer user_data)+
This signal is emitted when a new WebKitWebPage is created in +the Web Process.
+extension |
+the WebKitWebExtension on which the signal is emitted |
++ |
web_page |
+the WebKitWebPage created |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+| +Top + | + |
+ |
+ |
+ |
+
+WebKitWebHitTestResult+WebKitWebHitTestResult — Result of a Hit Test (Web Process Extensions) + |
++ |
WebKitWebHitTestResult extends WebKitHitTestResult to provide information +about the WebKitDOMNode in the coordinates of the Hit Test.
+WebKitDOMNode *
+webkit_web_hit_test_result_get_node (WebKitWebHitTestResult *hit_test_result);
+Get the WebKitDOMNode in the coordinates of the Hit Test.
+ + +Since: 2.8
+“node” property“node” WebKitDOMNode *+
The WebKitDOMNode
+Flags: Read / Write / Construct Only
+| +Top + | + |
+ |
+ |
+ |
+
| +WebKitDOMDocument * + | ++webkit_web_page_get_dom_document () + | +
| +guint64 + | ++webkit_web_page_get_id () + | +
| const gchar * + | ++webkit_web_page_get_uri () + | +
| +WebKitFrame * + | ++webkit_web_page_get_main_frame () + | +
| +WebKitWebEditor * + | ++webkit_web_page_get_editor () + | +
| void | +console-message-sent | +Run Last | +
| gboolean | +context-menu | +Run Last | +
| void | +document-loaded | +Run Last | +
| void | +form-controls-associated | +Run Last | +
| gboolean | +send-request | +Run Last | +
| void | +will-submit-form | +Run Last | +
WebKitDOMDocument *
+webkit_web_page_get_dom_document (WebKitWebPage *web_page);
+Get the WebKitDOMDocument currently loaded in web_page
+
the WebKitDOMDocument currently loaded, or NULL
+if no document is currently loaded.
[transfer none]
+guint64
+webkit_web_page_get_id (WebKitWebPage *web_page);
+Get the identifier of the WebKitWebPage
+ + +const gchar *
+webkit_web_page_get_uri (WebKitWebPage *web_page);
+Returns the current active URI of web_page
+.
You can monitor the active URI by connecting to the notify::uri
+signal of web_page
+.
WebKitFrame *
+webkit_web_page_get_main_frame (WebKitWebPage *web_page);
+Returns the main frame of a WebKitWebPage.
+ + +Since: 2.2
+WebKitWebEditor *
+webkit_web_page_get_editor (WebKitWebPage *web_page);
+Gets the WebKitWebEditor of a WebKitWebPage.
+ + +Since: 2.10
+Used to indicate a particular stage in form submission. See +“will-submit-form”.
+ +“uri” property“uri” gchar *+
The current active URI of the WebKitWebPage.
+Flags: Read
+Default value: NULL
+“console-message-sent” signalvoid +user_function (WebKitWebPage *web_page, + WebKitConsoleMessage *console_message, + gpointer user_data)+
Emitted when a message is sent to the console. This can be a message
+produced by the use of JavaScript console API, a JavaScript exception,
+a security error or other errors, warnings, debug or log messages.
+The console_message
+ contains information of the message.
web_page |
+the WebKitWebPage on which the signal is emitted |
++ |
console_message |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.12
+“context-menu” signalgboolean +user_function (WebKitWebPage *web_page, + WebKitContextMenu *context_menu, + WebKitWebHitTestResult *hit_test_result, + gpointer user_data)+
Emitted before a context menu is displayed in the UI Process to
+give the application a chance to customize the proposed menu,
+build its own context menu or pass user data to the UI Process.
+This signal is useful when the information available in the UI Process
+is not enough to build or customize the context menu, for example, to
+add menu entries depending on the WebKitDOMNode at the coordinates of the
+hit_test_result
+. Otherwise, it's recommended to use “context-menu”
+signal instead.
web_page |
+the WebKitWebPage on which the signal is emitted |
++ |
context_menu |
+the proposed WebKitContextMenu |
++ |
hit_test_result |
++ | + |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.8
+“document-loaded” signalvoid +user_function (WebKitWebPage *web_page, + gpointer user_data)+
This signal is emitted when the DOM document of a WebKitWebPage has been +loaded.
+You can wait for this signal to get the DOM document with
+webkit_web_page_get_dom_document().
web_page |
+the WebKitWebPage on which the signal is emitted |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+“form-controls-associated” signalvoid +user_function (WebKitWebPage *web_page, + GPtrArray *elements, + gpointer user_data)+
Emitted after form elements (or form associated elements) are associated to a particular web +page. This is useful to implement form auto filling for web pages where form fields are added +dynamically. This signal might be emitted multiple times for the same web page.
+Note that this signal could be also emitted when form controls are moved between forms. In
+that case, the elements
+ array carries the list of those elements which have moved.
Clients should take a reference to the members of the elements
+ array if it is desired to
+keep them alive after the signal handler returns.
web_page |
+the WebKitWebPage on which the signal is emitted |
++ |
elements |
+a GPtrArray of +WebKitDOMElement with the list of forms in the page. |
+[element-type WebKitDOMElement][transfer none] | +
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.16
+“send-request” signalgboolean +user_function (WebKitWebPage *web_page, + WebKitURIRequest *request, + WebKitURIResponse *redirected_response, + gpointer user_data)+
This signal is emitted when request
+ is about to be sent to
+the server. This signal can be used to modify the WebKitURIRequest
+that will be sent to the server. You can also cancel the resource load
+operation by connecting to this signal and returning TRUE.
In case of a server redirection this signal is
+emitted again with the request
+ argument containing the new
+request to be sent to the server due to the redirection and the
+redirected_response
+ parameter containing the response
+received by the server for the initial request.
Modifications to the WebKitURIRequest and its associated +SoupMessageHeaders will be taken into account when the request +is sent over the network.
+web_page |
+the WebKitWebPage on which the signal is emitted |
++ |
request |
+a WebKitURIRequest |
++ |
redirected_response |
+a WebKitURIResponse, or |
++ |
user_data |
+user data set when the signal handler was connected. |
++ |
TRUE to stop other handlers from being invoked for the event.
+FALSE to continue emission of the event.
Flags: Run Last
+“will-submit-form” signalvoid +user_function (WebKitWebPage *web_page, + WebKitDOMElement *form, + WebKitFormSubmissionStep step, + WebKitFrame *source_frame, + WebKitFrame *target_frame, + GPtrArray *text_field_names, + GPtrArray *text_field_values, + gpointer user_data)+
This signal is emitted to indicate various points during form
+submission. step
+ indicates the current stage of form submission.
If this signal is emitted with WEBKIT_FORM_SUBMISSION_WILL_SEND_DOM_EVENT,
+then the DOM submit event is about to be emitted. JavaScript code
+may rely on the submit event to detect that the user has clicked
+on a submit button, and to possibly cancel the form submission
+before WEBKIT_FORM_SUBMISSION_WILL_COMPLETE. However, beware
+that, for historical reasons, the submit event is not emitted at
+all if the form submission is triggered by JavaScript. For these
+reasons, WEBKIT_FORM_SUBMISSION_WILL_SEND_DOM_EVENT may not
+be used to reliably detect whether a form will be submitted.
+Instead, use it to detect if a user has clicked on a form's
+submit button even if JavaScript later cancels the form
+submission, or to read the values of the form's fields even if
+JavaScript later clears certain fields before submitting. This
+may be needed, for example, to implement a robust browser
+password manager, as some misguided websites may use such
+techniques to attempt to thwart password managers.
If this signal is emitted with WEBKIT_FORM_SUBMISSION_WILL_COMPLETE,
+the form will imminently be submitted. It can no longer be
+cancelled. This event always occurs immediately before a form is
+submitted to its target, so use this event to reliably detect
+when a form is submitted. This event occurs after
+WEBKIT_FORM_SUBMISSION_WILL_SEND_DOM_EVENT if that event is
+emitted.
web_page |
+the WebKitWebPage on which the signal is emitted |
++ |
form |
+the WebKitDOMElement to be submitted, which will always correspond to an HTMLFormElement |
++ |
step |
+a WebKitFormSubmissionEventType indicating the current +stage of form submission |
++ |
source_frame |
+the WebKitFrame containing the form to be +submitted |
++ |
target_frame |
+the WebKitFrame containing the form's target,
+which may be the same as |
++ |
text_field_names |
+names of +the form's text fields. |
+[element-type utf8][transfer none] | +
text_field_values |
+values +of the form's text fields. |
+[element-type utf8][transfer none] | +
user_data |
+user data set when the signal handler was connected. |
++ |
Flags: Run Last
+Since: 2.20
+| + | |
+ |
+ |
+ |
+
Generics and defining elements of containers and arrays.
Free data after the code is done.
Don't free data after the code is done.
| + | |
+ |
+ |
+ |
+
| + | |
+ |
+ |
+ |
+
| + | |
+ |
+ |
+ |
+
WPE WebExtensions and DOM Reference Manual |
|---|
for WPE WebKit 2.23.90
This is a development release leading towards the 2.28 series.
+about:gpu.+wpewebkit-2.27.2.tar.xz (18.7 MiB) + md5sum: 7b3faa97084db376ff667f1bc84decb4 + sha1sum: dce71f425d873f5d6cdff2c0ee60f997a7ec8f55 + sha256sum: 6904ce94d73e5013fe9a18fe9f04f95e945210e6d755c7d7367c355f0f0d49f7 ++ + + + +
This is the first stable release in the 0.10 series.
++cog-0.10.0.tar.xz (97.9 KiB) + md5sum: 1b0407b6163a3a01afdfc0fb454a7570 + sha1sum: 911816c00a2b08f4cfd388b1d2e176835c9b4e9e + sha256sum: 2c72369c636ca4684370adad1344071b23c9ee2c851eb7d738fa2e1d7092031f ++ + + + +
This is the first bug fix release in the stable 0.10 series.
+COG_PLATFORM_HEADLESS CMake option to make the platform module optional.+cog-0.10.1.tar.xz (98.1 KiB) + md5sum: b997da3c143bc34ec5e953eb7e7ccefc + sha1sum: f25312141de918f41add3e3c9984faa985cda0a9 + sha256sum: aecf546d7b0645119d79559c5574cb5eb68364fc8409dfbd47a4920bd1f221bc ++ + + + +
This is the first development release leading towards the 0.12 series.
+--platform= command line option to the
+launcher is now optional.libsoup3.--enable-sandbox command line option, which allows isolating
+rendering processes from the rest of the system.--content-filter= command line option, which allows loading
+a content blocker (WebKitUserContentFilter) JSON rule set.fdo platform module to wl (Wayland) as it better reflects
+its usage; the old name still works e.g. when using cog --platform=fdo
+but it is considered deprecated and will cause a warning.+cog-0.11.1.tar.xz (109.0 KiB) + md5sum: b078bdc3a08930f4c8e61a458ad6b332 + sha1sum: ef41312c64871b7da26cab407ad3db27ee937bb0 + sha256sum: 6cbd60386e20bad62adccb26a2488c9eea0b609b12336476fac1fb71fcd26572 ++ + + + +
This is a development release leading towards the 0.12 series.
+cog_platform_teardown(), deinitilization of platform
+plug-in implementations is now done automatically as part of object
+finalization.+cog-0.11.90.tar.xz (109.4 KiB) + md5sum: 4e731010fc948fa156822f1868d63df7 + sha1sum: 9751bee357a72713323da8f8c180e825b4d783a1 + sha256sum: baf79b221e6297c533f98dad54a9715c7d55d6a1af1997e566705bc51e8ab228 ++ + + + +
This is the first stable release in the 0.12 series.
+--enable-sandbox command line option, which allows isolating
+rendering processes from the rest of the system.--content-filter= command line option, which allows loading
+a content blocker (WebKitUserContentFilter) JSON rule set.--platform= command line option to the
+launcher is now optional.libsoup3.cog_platform_teardown(), deinitilization of platform
+plug-in implementations is now done automatically as part of object
+finalization.fdo platform module to wl (Wayland) as it better reflects
+its usage; the old name still works e.g. when using cog --platform=fdo
+but it is considered deprecated and will cause a warning.+cog-0.12.0.tar.xz (109.4 KiB) + md5sum: 30d6f68914af0ba5c32ac14df504215a + sha1sum: de367b33fb45a1bca9e443ca5c1d6cae3833d759 + sha256sum: aad413a8aaf15d400d70f9c909a28b92b138f7b0c0d825978de8788d0d75208a ++ + + + +
This is the first bug fix release in the stable 0.12 series.
++cog-0.12.1.tar.xz (109.4 KiB) + md5sum: 25a80a5a8a52b8873933a128151b8928 + sha1sum: 3b9f67bc23cd9e3db2221366d6cde4ca0b06b811 + sha256sum: 23caaafa2ef5c2f6a97d467fcce908ea71087ad03b72deb9280225c0dd561c91 ++ + + + +
This is a bug fix release in the stable 0.12 series.
++cog-0.12.2.tar.xz (109.6 KiB) + md5sum: ab6828b3733c3d39fc47835172fdaded + sha1sum: 42d3d6aa935896e464f281c84c478b5994ebb7b3 + sha256sum: ccebdc1f216b698d1e780d3a71617bec1d2cd95ac5c9da59f563372463d97ed7 ++ + + + +
This is a bug fix release in the stable 0.12 series.
++cog-0.12.3.tar.xz (109.7 KiB) + md5sum: 320d01d8546144fba2e14bed3522c8c7 + sha1sum: 8e28b216bb2462325a1df1e8e03ac199487440b0 + sha256sum: f464065057373c0430f6267205d1ab3367b54ac04d15b6b5531683b03212f45f ++ + + + +
This is a bug fix release in the stable 0.12 series.
+--as-needed flag to the linker.+cog-0.12.4.tar.xz (109.8 KiB) + md5sum: cdb8acdc3acc9b5082e7db9c279155c3 + sha1sum: 600b30efadf55bf94ea5062a0a1b2ea0b74053e5 + sha256sum: 9983c621c8e14fca3792ff566cb6b86d6a1f17446eb4c083af4a5a749112982f ++ + + + +
This is the first development release leading towards the 0.14 series.
+CogLauncher from the library, as it is in practice an
+implementation detail of the cog launcher.+cog-0.13.1.tar.xz (110.6 KiB) + md5sum: 5c849e71de7ceb055ffa44df81b105f1 + sha1sum: 4556d5b8f1eac6aac907b20cfe92e39223bb8510 + sha256sum: a32732d91bf6297fa974aa9bf6d2dab10f7b2a00f2cc3076b2b786d39fa8e129 ++ + + + +
This is a development release leading towards the 0.14 series.
+--platform-params/-O command line option, which
+allows passing parameters to platforms plug-ins during initialization.cog -O renderer=gles,rotation=1.+cog-0.13.2.tar.xz (116.5 KiB) + md5sum: 57026de891085ed2efbd7d0a92b5f3e7 + sha1sum: 7a69602b4ae2cd7bea03e2ebfdc33c7bcde181a3 + sha256sum: 93dcc2a012ae8d261131c91e090c7a3ff5e530e7757a33c50bb2a6cc1523a0dd ++ + + + +
This is a development release leading towards the 0.14 series.
+COG_MODULEDIR being
+incorrectly defined as a relative path at build configuration time.+cog-0.13.3.tar.xz (117.3 KiB) + md5sum: f3f59b4c8e0336baf27be602ddc6f842 + sha1sum: b045d5ac0098fee33ac53f88488aac804150c7aa + sha256sum: d411142cd44781629e26b1fa8a8e5b8de45ca43014fdbdebdfa39a8b2c1eda4b ++ + + + +
This is a development release leading towards the 0.14 series.
+USE_SOUP2=ON can still be specified to build against libsoup2.wpebackend-fdo library in all components to avoid crashes due to multiple copies loaded with different behaviours..pc file when using an absolute directory for the CMAKE_INSTALL_LIBDIR option instead of a relative one.COG_WESTON_DIRECT_DISPLAY enabled.--as-needed linker flag is in use.+cog-0.13.90.tar.xz (119.7 KiB) + md5sum: 749f55793438c552185023a9bd744d6a + sha1sum: 82c885e8e942a97c7bb7d7c9b6e25ceba1b462c7 + sha256sum: a7ed11a10c41a9c4ad9692730357e6d86f2544d308d96018d26f80b234e16080 ++ + + + +
This is the first stable release in the 0.14 series.
+Launcher (cog):
--platform-params/-O command line option.Core library (libcogcore):
CogLauncher class is no longer available, as it was an
+implementation detail of the launcher.DRM/KMS platform (drm):
GTK4 platform (gtk4):
Wayland platform (wl):
X11 platform (x11):
+cog-0.14.0.tar.xz (119.8 KiB) + md5sum: 2352aaba1a4ff31b1d1fb559c4941a01 + sha1sum: 2da37ea6c25e45425aa80de4a129484ee226dd96 + sha256sum: e23936f1ce350ea5ea6fa0709b63d34776b05709388aed9c6cf3fdc41299de9f ++ + + + +
This is the first bug fix release in the stable 0.14 series.
+cogcore.pc file.+cog-0.14.1.tar.xz (119.8 KiB) + md5sum: 69d72ac046a0fc485ea7b61b96e7e7fc + sha1sum: 6236972b0ae0bce38a0a017610f161b349723862 + sha256sum: fb91104e25e1dde27189c91c70acc356e387f47acebaa8997e01ce5879c3a600 ++ + + + +
This is the first development release leading towards the 0.16 series.
+--proxy and --ignore-host command line options, which
+allow setting up a network proxy and a list of hosts that would bypass it.+cog-0.15.1.tar.xz (118.6 KiB) + md5sum: 8b2021df565d6780a645728a3e17cb9c + sha1sum: 67e186e8d7897bed5cfc07a36ce7e166d675358a + sha256sum: 9f8ab14696077c0b64a7e8dc269709e33aae17336f9405c9734752c4d174f350 ++ + + + +
This is the first stable release in the 0.16 series.
+General:
+Launcher (cog):
--gamepad= command line option to choose the gamepad
+implementation to use.--proxy= and --ignore-host= command line options, which
+allow setting up a network proxy and a list of hosts that would
+bypass it.+cog-0.16.0.tar.xz (119.1 KiB) + md5sum: 2705472ea4f333290973722c0862b21d + sha1sum: ef16e5e3d91d0da056fe5e4f596c211af7453b4e + sha256sum: 2956f719d36c9a6368f63901a0d1ceaf4d27f529f7df441b3748c36d72906fc6 ++ + + + +
This is the first bug fix release in the stable 0.16 series.
+drm_fourcc.h header is not installed
+in the default search paths.libweston-12-protocols.+cog-0.16.1.tar.xz (119.3 KiB) + md5sum: 1489740db6b4ea568578035c30b8b2f4 + sha1sum: 1235203085e7ccd8fc76eab6bdfcdb2e3ae38ea9 + sha256sum: 37c5f14123b8dcf077839f6c60f0d721d2a91bb37829e796f420126e6b0d38b5 ++ + + + +
This is the first development release leading towards the 0.18 series.
+libweston-12-protocols.+cog-0.17.1.tar.xz (121.4 KiB) + md5sum: 35c936b90ae89c976fc5d3bbe26a8ba6 + sha1sum: 36c7528fbf0b7e36826c629303016d488e431b87 + sha256sum: 69e7d3b62c206210c3c436746d1241bfb99a1e789e6c4b7cb65dd9ae72459d42 ++ + + + +
This is a development release leading towards the 0.18 series.
++cog-0.17.90.tar.xz (122.5 KiB) + md5sum: 343f8496c14c1c5d09708c1dfb83df78 + sha1sum: 5fdbaa382df921695c76e37a3fa5a841ccfd0f4f + sha256sum: beb98996c48927e7283961877d45acb7f26ed71d78be9c4984fbff30ed0bedb7 ++ + + + +
This is the first stable release in the 0.18 series.
+COG_PLATFORM_NAME and COG_PLATFORM_PARAMS.libweston-12-protocols.+cog-0.18.0.tar.xz (122.6 KiB) + md5sum: 9521458c72322e1b2e39e8b1cca93d24 + sha1sum: 73ec1684c31de7247ecbd5e852c16cf88416bedd + sha256sum: 410bf70f9aa3812db72d75c25cefee421efa0391ab03dc3c37299dfaa388f4fd ++ + + + +
This is the first bug fix release in the stable 0.18 series.
+CogShell holding one reference
+too much on them.+cog-0.18.1.tar.xz (122.7 KiB) + md5sum: 204ae9353ed828e4ac39b1dd4c5c35dd + sha1sum: f0f0ebcd279170f427be0ad57fd356faff1a2732 + sha256sum: 72e3a84052b459e2d53d0e8b947f20e27bf5d8049766c4c1594eb9c6b6cf7ab3 ++ + + + +
This is a development release leading towards the 0.4 series.
++cog-0.3.91.tar.xz (80.6KB) + md5sum: 0ecf0b1f95803ee65f69abcdd46558ff + sha1sum: d9a37933b624c65b7ff70543c37d3d2efc219e90 + sha256sum: 99c1b075bc41b9a492af846bafe5d7ce4046edd393b3f2e114ffcb33e3dfeef8 ++ + + + +
This is the first release in the 0.4 series.
+experimental-drm platform plug-in which uses KMS+DRM (Kernel Mode
+Setting, Direct Rendering Manager) for direct display on framebuffers,
+and libinput for input event processing.For more details about all the changes included in Cog 0.4 see the NEWS
+file included in the release tarball.
+cog-0.4.0.tar.xz (80.7 KiB) + md5sum: 75a0838ee6c81bb8df1b254f525440a6 + sha1sum: 284d2a641e6269b296057918602c8c94eb831527 + sha256sum: e9c13a51232434b7340a419b1e6f59c40c582cd80c8e60bd9ec7de16c904fc03 ++ + + + +
This is the first development release leading towards the 0.6 series.
+cog and cogctl.+cog-0.5.1.tar.xz (88.6 KiB) + md5sum: 48ceb4159b7f14324fa8d3c480968d40 + sha1sum: 501af1bb85acbcd94f64f02808475df8cbeb0a26 + sha256sum: 0160d942c7f2b832e4a7379f265e0e04e86a78b0e813340c36d029f98b74179e ++ + + + +
This is the first stable release in the 0.6 series.
+The FDO platform plug-in has received a number of improvements:
+wayland-cursor library is
+available at build time.Starting with this release the DRM platform plug-in is no longer considered +experimental.
++cog-0.6.0.tar.xz (89.4 KiB) + md5sum: a97df4f0e2d25f4da7cd9bb55294d30e + sha1sum: 9392d9251bab8a9f61d00297707e16a983127eae + sha256sum: 208f58e0533b269400875237a95e994c93da7234a29fd1c904e756b88963e35d ++ + + + +
This is the first development release leading towards the 0.8 series.
+libxkbcommon structures.+cog-0.7.1.tar.xz (93.6 KiB) + md5sum: f2c51cd444ca54d8042e99b3e8a3fa78 + sha1sum: e016a33693f470b05264e5f85c8e00c509c66348 + sha256sum: 42890e946652517abec8c0492d9fd8d827d5559652536a23a4c9ab8c1aecfe32 ++ + + + +
This is a development release leading towards the 0.8 series.
+--ignore-tls-errors command line option which allows
+ignoring TLS certificate validation errors.window.open() loading them in the active view.COG_PLATFORM_DRM_VIDEO_MODE environment variable.+cog-0.7.90.tar.xz (71.3 KiB) + md5sum: 6ad78ec3e08e570248f5892f7b7b4ca7 + sha1sum: fd69bb9dafb7ef763457f52a9008105d722932fe + sha256sum: 3bb940741b685e89305decc894acf0b4ed9fdc77f7878b70da48a1def2e71925 ++ + + + +
This is the first stable release in the 0.8 series.
+--ignore-tls-errors command line option which allows ignoring TLS certificate validation errors.window.open() loading them in the active view.COG_PLATFORM_DRM_VIDEO_MODE environment variable.+cog-0.8.0.tar.xz (71.3 KiB) + md5sum: f7aa8a425927cab247563411fc67c5a3 + sha1sum: 977559204dae0f9220e4c6b8ded7537899fd2daf + sha256sum: 181b1f4963cdf264b8068460a64d14c92a627f7138ebecc0f36fce085f4e92dd ++ + + + +
This is the first bug fix release in the stable 0.8 series.
+cog_web_view_connect_default_error_handlers() to avoid
+accidentally overriding already connected signal handlers.eglGetProcAddress().+cog-0.8.1.tar.xz (71.8 KiB) + md5sum: 21664fb04c9149dea6d68e13e6074276 + sha1sum: baabba7f0f6009c64ef0c4f7c5f807382cffef5d + sha256sum: b82e917eb764943b9859c631974f8f0e748b79ae87bb7a944f46c818740e0208 ++ + + + +
This is the first development release leading towards the 0.10 series.
+CogPrefixRoutesHandler, which can route URI scheme requests
+with different path prefixes to other handlers.CogShell.device-scale-factor property.CogDirectoryFilesHandler to use the URI host part
+as a path component, to ignore a certain amount of path components, and
+expose the base path as a property.COG_PLATFORM_DRM_MODE_MAX environment variable.zwp_fullscreen_shell_v1 protocol.headless platform module, which does not produce
+output and can be used without any graphics hardware e.g. in combination
+with Mesa’s software rasterization.x11 platform module, which uses an X11 window to paint
+rendered web content using XCB and OpenGL.+cog-0.9.1.tar.xz (85.6 KiB) + md5sum: 931010e105767fa6a30bb8a2719e6dfb + sha1sum: e724ade2b443c0e87f3b30255fdb1a1f3abba2e5 + sha256sum: 67581431b993c877c856d0c1ef3e8993e90add331eae6c7f79469b1fc0a72d2d ++ + + + +
This is a development release leading towards the 0.10 series.
+gtk4 platform module, which works on Wayland and uses
+GTK4 to render web content into a GtkGLArea and provides a minimal yet
+usable user interface+cog-0.9.90.tar.xz (97.9 KiB) + md5sum: 98cf1b24b95faa43f7e9c334c8b68889 + sha1sum: bbc405515d87ed32e8f101f80898bad5ae256c8f + sha256sum: 933adc74e7b2b7f879a0159b073aa601d58865621891c443d1c2481f9eee6c97 ++ + + + +
+ Stable + 2.42.2 +
++ Development + 2.41.2 +
++ Stable + 1.14.2 +
++ Development + 1.13.1 +
++ Stable + 1.14.1 +
++ Development + 1.15.1 +
++ Stable + 0.18.1 +
++ Development + 0.17.90 +
+This release changes the API version to 0.2, and introduces the following +changes and features:
+The library is now called libwpe to avoid confusion. The WPEBackend name
+used previously seemed to indicate that the library implemented a WPE
+backend. The new libwpe name better reflects that it contains code needed
+by the WPE WebKit port (#27).
The libwpe library now uses the libtool
+versioning convention
+(#21).
Handle conversion of keysyms to Unicode inside libwpe. This allowed to
+remove the unicode member from keyboard event structs, and removing
+wpe_input_key_mapper/wpe_input_key_mapper_interface
+(#23).
New field in event structs to specify keyboard modifiers +(#22).
+New API for keymap and composition handling based on libxkbcommon
+(#24).
+libwpe-1.0.0.tar.xz (45.4KB) + md5sum: b5ea32bd644811d5c6433cf1439763f7 + sha1sum: 6e51591c00a9a6128e19920807e6874794c723fd + sha256sum: aff11612123f9ab85a8b9a4bcdfb3a7503eba0a0d2d96f2cdecd30e911091719 ++ + + + +
This is a development release of libwpe, which introduces the following
+changes and features:
New API for observing and setting the view backend state (#36).
+Added a new wpe_renderer_backend_egl_get_platform() function which can
+be used to obtain a value which can be passed to eglGetPlatformDisplay()
+and eglGetPlatformDisplayEXT() (#39, #40).
Marked old function names containing the “backend” word as deprecated.
+The symbols are still available, but it is encouraged to use the new
+versions, e.g. prefer wpe_get_major_version() instead of
+wpe_backend_get_major_version() (#38).
Marked function table struct parameters passed to some API functions
+as const (#29).
Fixed headers so including <wpe-egl.h> results in <wpe.h> being included
+automatically in the correct order (#34).
Make instantiation of backends more robust by checking the validity of +interface pointers obtained from the backend (#30).
++libwpe-1.1.0.tar.xz (46.4KB) + md5sum: b34c3920cb749ebc74fe45a793cf57af + sha1sum: 69f0bc7f422c6a196c49439a454f7734ecac1126 + sha256sum: 72e34ad754be11abd1a438cfe195d8d644c52105ab2b1c3b39dec6228bc776ce ++ + + + +
This is a development release of libwpe, which introduces the following
+changes and features:
+libwpe-1.1.90.tar.xz (46.8KB) + md5sum: fa2498919b3d3bc0d0a9aaff601e9628 + sha1sum: 6c798e454f5e071533c50b2ee3af59887dfa6cf7 + sha256sum: d21dcf83f7e7405e8296c1732d240637d2facdb40e1c9879a1c0f9f222517592 ++ + + + +
This is the first stable release in the 1.10 series.
+wpe_renderer_backend_egl_target_interface to
+differentiate between destruction and deinitialization.+libwpe-1.10.0.tar.xz (50.8 KiB) + md5sum: 269ecb60d4ef80a0877d25a5828c8b82 + sha1sum: b3f48a48b0401da19deb60cb8f15f193dff799c1 + sha256sum: 2415e270d45e3595ed4052bc105f733744dc2d3677e12ff4a831e5029841084d ++ + + + +
This is the first bug fix release in the stable 1.10 series.
++libwpe-1.10.1.tar.xz (50.8 KiB) + md5sum: f60fc13b519a66d262afb76c77441870 + sha1sum: 1a8085b9a172d37e952c07bbb09b1654d4161ab2 + sha256sum: a327b3ffcf2356dbe8148c1db4bbdc5359d7e7163d177f67551a8393b144adf0 ++ + + + +
This is the first development release leading towards the 1.12 series.
++libwpe-1.11.1.tar.xz (53.2 KiB) + md5sum: a3c32caa18e8d4fc88fecb375880789b + sha1sum: 45f4040672351d385124845c59037ec026667edd + sha256sum: 71fec3e65f2aac29fde3dde692a7f502d7c0a58995169493e0efb9ee3c9d1477 ++ + + + +
This is the first stable release in the 1.12 series.
++libwpe-1.12.0.tar.xz (53.3 KiB) + md5sum: 5a3f11789535d826370ba465ea141393 + sha1sum: 91aa47a593a5db511d667b3bdbaa76dee4301311 + sha256sum: e8eeca228a6b4c36294cfb63f7d3ba9ada47a430904a5a973b3c99c96a44c18c ++ + + + +
This is the first bug fix release in the stable 1.12 series.
++libwpe-1.12.1.tar.xz (54.2 KiB) + md5sum: 3c8f9a1eb1d547a9c234356f3992e2b4 + sha1sum: 8d4b9a456dcf27ee5bfca46168dbc8066a0dd758 + sha256sum: 80d7e1c6e550279978bc1e1277f4e3d2efe9ca5155e5bbd842134cd5343df933 ++ + + + +
This is a bug fix release in the stable 1.12 series.
++libwpe-1.12.2.tar.xz (54.1 KiB) + md5sum: 33021c136035c8adfcccb2694dd48341 + sha1sum: 0c80d8605a49f43a642cd5f9905161a7bcc30136 + sha256sum: 4ac4fd0a8b562b721bffd0f46ae9f06c2b5a3114407581978be875a9d651642a ++ + + + +
This is a bug fix release in the stable 1.12 series.
++libwpe-1.12.3.tar.xz (54.3 KiB) + md5sum: e538eb8e521d92f2bde3c4cd864abaa1 + sha1sum: 9d94c411a502a10e68f69bd1fa273539cc6af2ca + sha256sum: b84fdbfbc849ce4fdf084bb28b58e5463b1b4b6cc8f200dc77b41f8545d5329d ++ + + + +
This is the first development release leading towards the 1.14 series.
+WPE_ENABLE_XKB build option, enabled by default, which can be used
+to completely avoid usage of libxkbcommon._wpe_loader_interface
+symbol, as dlopen() will not be used.+libwpe-1.13.1.tar.xz (59.3 KiB) + md5sum: 6870daa1c2b5d9963b6b0d715e0c0714 + sha1sum: 2a3be69f2f49011cc593a498d4fe309e0bc8c3ff + sha256sum: c3f55c8b98f1dc8ea7456880744098f5054ff5deba92a10dc93728710fbe9857 ++ + + + +
This is a development release leading towards the 1.14 series.
++libwpe-1.13.2.tar.xz (59.4 KiB) + md5sum: 31b267649eb1a5f472b07a66adab86e1 + sha1sum: 5de7bc3e4dd9f8d94df84395106547c0a0a904f9 + sha256sum: efcd97dc0f95ff7a506483ba3df944669cdc602b3fc45c9fd676dee0f8f92cac ++ + + + +
This is a development release leading towards the 1.14 series.
+wpe_gamepad_provider when creating
+new gamepad instances, and the associated wpe_gamepad_provider_get_backend()
+accessor.+libwpe-1.13.3.tar.xz (60.7 KiB) + md5sum: 2990e75589960412115bb8c9ee9a3203 + sha1sum: 7d7bab460189c0a07d2547b458d197f3c0f8ebd7 + sha256sum: 05f871922f6ca750c5689a38a346c3fba130417d3490dd52362b4fe22f334e96 ++ + + + +
This is a development release leading towards the 1.14 series.
++libwpe-1.13.90.tar.xz (60.8 KiB) + md5sum: d09ddc39ae33d09940f731c3cb1b5b51 + sha1sum: f73400ee19480eebd439c9aaea90ae3e11f2e742 + sha256sum: 97af9fbea3a70093e5f3979fa89594343e255942645c3b781d4f3517df5388a1 ++ + + + +
This is the first stable release in the 1.14 series.
+WPE_ENABLE_XKB build option, enabled by default, which can be used
+to avoid usage of libxkbcommon.+libwpe-1.14.0.tar.xz (61.5 KiB) + md5sum: f9737912975f979f9e4e01eec174a271 + sha1sum: 7a5d51c99254fc14ffcbcca9e8550cc7940fe871 + sha256sum: c073305bbac5f4402cc1c8a4753bfa3d63a408901f86182051eaa5a75dd89c00 ++ + + + +
This is the first bug fix release in the stable 1.14 series.
++libwpe-1.14.1.tar.xz (61.5 KiB) + md5sum: d834d70a6b3afb24a05ec188df248e52 + sha1sum: e51caba8198601f2b7c8dec3c67770c56c46eb24 + sha256sum: b1d0cdcf0f8dbb494e65b0f7913e357106da9a0d57f4fbb7b9d1238a6dbe9ade ++ + + + +
This is the first development release leading towards the 1.16 series.
++libwpe-1.15.1.tar.xz (62.0 KiB) + md5sum: 4d9e5eafc5b752daaa3c2a3c9e1b98ac + sha1sum: 0082ceb475175bfecd1172f2c0b292824d31561b + sha256sum: 14d36a93a05ab7ada9bec581720b8057336fe681bbbe59bda7d50cb8f3eba3a6 ++ + + + +
This is the first stable release of libwpe in the 1.2 series.
+libwpe-1.2.0.tar.xz (46.8KB) + md5sum: 060876c6a32ef1ae519cb9542d0ede06 + sha1sum: 5dd34eba8cc7625d2b1c679c509492941092d137 + sha256sum: f28035e7a8991fbb1a0e762f1b3d0e3cb57513a3164c75c7dc3eb0c11d9149fc ++ + + + +
This is a bug fix release of libwpe in the stable 1.2 series.
libxkbcommon headers are installed in a non-standard location (#48).+libwpe-1.2.1.tar.xz (46.9KB) + md5sum: 9f26865f06ecf933ddbbf067a7be735f + sha1sum: d3f6211a2acafe1bd1f41e826c8efae35335fc92 + sha256sum: 00e103c6fa226b0d979c29d14c9e8168c4bec7b0b5108f3705a037cda5609d7d ++ + + + +
This is the first development release of libwpe leading towards the 1.4 series.
+libwpe-1.3.0.tar.xz (47.0KB) + md5sum: 01bcda361a427d37829877add9e47eb4 + sha1sum: 81ff47e0dd40b4aea91543785b2c1d76690154f3 + sha256sum: 68986647af2433e74f830a06a497ed536dbc8721b04026ed82611a584be71148 ++ + + + +
This is a development release leading towards the 1.4 series.
++libwpe-1.3.1.tar.xz (47.0KB) + md5sum: ddc2638caa0b922eb6d36ee15080cfdb + sha1sum: d848f6af34e0084a6ab483a9c3635a038c36f931 + sha256sum: 5d5e23ce48b35278201b3b88e5b1a89bd54b38391721b4e74ce472c3905df8b0 ++ + + + +
This is a development release leading towards the 1.4 series.
++libwpe-1.3.91.tar.xz (48.4KB) + md5sum: a1e1eebd0eed068449be33be4b1c5a7d + sha1sum: 46941f39d9a8cb59cc222b0e2687c1ea0239d002 + sha256sum: 34d2e7057700d5cfaead4e554fe253d30613279f2e7b9e3ea4a307f06799f93f ++ + + + +
This is the first bug fix release in the stable 1.4 series.
+1.4.0 is used when building from tarballs.+libwpe-1.4.0.1.tar.xz (48.5 KiB) + md5sum: 1d4d38413ee0d0043f74d0445cab906f + sha1sum: a41480a0a85cfa11b3f87f801b7c37bc3410e060 + sha256sum: 09849dfb34877354f34f318e138971cf22e677b2179e1f0a8ea00ab0b7bd8e9b ++ + + + +
This is the first stable release in the 1.4 series.
++libwpe-1.4.0.tar.xz (48.4 KiB) + md5sum: 4b6dbaa2d40408975fe1be935367b4e8 + sha1sum: 18825932749edecd92a3bd31d4feffb5fd1150b4 + sha256sum: e2d3494fc33fe946ad917fd6a3abd127462b91bba62ef8b35507e92f8ede4188 ++ + + + +
This is a development release leading towards the 1.6 series.
++libwpe-1.5.90.tar.xz (48.7 KiB) + md5sum: 96ec945d3ae0a7a78c8db52c25e8e0f3 + sha1sum: cc4c0855a048519f6b634327de4f0d2de63b92f7 + sha256sum: 6e6e26f8c98267c33f926c03a7f280a0d21c3f713f95a38ef302ca3a6253c350 ++ + + + +
This is the first stable release in the 1.6 series.
+WPE_EXPORT are public.+libwpe-1.6.0.tar.xz (48.8 KiB) + md5sum: 6e8a2c279dcc3617db5ec7ac4c03d628 + sha1sum: e8424d5e29f35861d85acdc5962d8b59b53bb1ad + sha256sum: 3587c6b8a807f4bb76b268ba74ca82c6b395b90235db41ad8252224456193c90 ++ + + + +
This is the first development release leading towards the 1.8 series.
++libwpe-1.7.1.tar.xz (50.0 KiB) + md5sum: fa8326e2c4b87310cbfed035c36aca05 + sha1sum: d8ed571f39cd9c39d3fcf7053c78430e85fd689e + sha256sum: a784b7fa0c658b28071100f6f6749b0d85bbcddd82de028e07672ce13982d340 ++ + + + +
This is a development release leading towards the 1.8 series.
++libwpe-1.7.90.tar.xz (50.0 KiB) + md5sum: e53de66fdcfc9e61567234b529900b42 + sha1sum: 9545c65c7cb0d226825ae7fd638748d51d90355f + sha256sum: 313c07bc963f7628ee5f4536c1240be5d116b43d01eec441c847db993f95d1b6 ++ + + + +
This is the first stable release in the 1.8 series.
++libwpe-1.8.0.tar.xz (50.1 KiB) + md5sum: 328ea59dd8dee9107a49353536d00844 + sha1sum: 3c893b1e8118a06f082d98373e279a8f8e33750d + sha256sum: a6f00a7d091cbd4db57fe7ee3b4c12c6350921d654ed79812800a26c888481d2 ++ + + + +
This is the first development release leading towards the 1.10 series.
+libwpe as a subproject.+libwpe-1.9.1.tar.xz (50.2 KiB) + md5sum: 54b6f91fc310a7098dac49e0537af407 + sha1sum: 9ad1b35c488ff7c63864a9c5ff652a02291bf881 + sha256sum: ac1470f9811e74a5f9b063e25d27ed9e274a74078c65fbdcc6f6e3c590010bb8 ++ + + + +
This is a development release leading towards the 1.10 series.
++libwpe-1.9.90.tar.xz (50.6 KiB) + md5sum: e72c68b56ab09aa88d061e861e84a862 + sha1sum: ab027a467aafe5524d8764a01b70dfc2596d6c18 + sha256sum: 036b40b47e13c694ecc8055fdef0c7eb3cb872a05973b2b097a3620b78c1788d ++ + + + +
This is a development release leading towards the 1.10 series.
+wpe_renderer_backend_egl_target_interface to
+differentiate between destruction and deinitialization.+libwpe-1.9.91.tar.xz (50.7 KiB) + md5sum: 5f6840a357ef9cef7cf3ae06db51ce01 + sha1sum: a596f5246e6898faddf3e092f731a5888fe37d27 + sha256sum: 1d389f29ab1946669cf244ad621ff92b84ff8bcd9294df677444a0d876714196 ++ + + + +
WPE WebKit follows a 6-month development cycle:
+WPE WebKit and WebKitGTK share a fair amount of code. +Therefore, both projects produce their feature releases simultaneously, +and share the same release branches. For bug-fix releases, the release +teams for both projects try to sync their version numbers as well as they +can.
+Version numbers follow the major.minor.patch numbering scheme. Changes to
+the major version signify considerable architectural or API changes; the
+minor version number changes throughout the development cycle. Even numbers
+indicate stable releases and odd ones development releases. Lastly, the
+patch number is incremented for each release, and for stable release
+candidates it is bumped to 90.
| Kind | +Minor | +Patch | +
|---|---|---|
| Stable | +even | +any | +
| Development | +odd | +< 90 | +
| Release Candidate | +odd | +≥ 90 | +
For stable releases the following is always true, as long as the major
+version number stays the same:
patch releases are guaranteed to be backward-compatible both
+at the API and ABI level.minor releases may contain new features and backward-compatible
+changes in the public API. In general, the ABI will remain compatible as
+well, because we actively avoid breaking it unless strictly needed.The following table summarizes which stable releases of libwpe, WPE WebKit, +WPEBackend-fdo, and Cog are compatible and tested with each other (updated +April 2023). Distributors and packagers are strongly advised to use the +versions listed below.
+| WPE WebKit | +libwpe | +WPEBackend-fdo | +Cog | +
|---|---|---|---|
| 2.40.x | +1.14.x, 1.12.x | +1.14.x, 1.12.x | +0.16.x | +
| 2.38.x | +1.14.x, 1.12.x | +1.14.x, 1.12.x, 1.10.x | +0.16.x, 0.14.x, 0.12.x | +
| 2.36.x | +1.12.x, 1.10.x | +1.12.x, 1.10.x | +0.14.x, 0.12.x, 0.10.x | +
| 2.34.x | +1.12.x, 1.10.x, 1.8.x | +1.12.x, 1.10.x | +0.12.x, 0.10.x, 0.8.x | +
| 2.32.x | +1.10.x, 1.8.x, 1.6.x | +1.10.x, 1.8.x | +0.10.x, 0.8.x | +
| 2.30.x | +1.8.x, 1.6.x | +1.10.x, 1.8.x | +0.8.x, 0.6.x | +
| 2.28.x | +1.6.x | +1.6.x | +0.8.x, 0.6.x | +
| 2.26.x | +1.4.x | +1.4.x | +0.4.x | +
| 2.24.x | +1.2.x | +1.2.x | +0.3.x | +
| 2.22.x | +1.0.x | +1.0.x | +0.2.x | +
| 2.20.x | +< 1.0.0 | +< 1.0.0 | +≤ 0.1.x | +
Notes:
+WPE release tarballs are cryptographically signed and can be verified
+using PGP signatures (in an .asc file) and their
+checksums (in a .sums file). Everybody is encouraged to verify
+the integrity of downloaded files using them.
Every release is accompanied by a cryptographic signature produced by the +person in charge of publishing the release. This signature allows anyone to +check whether the files have been tampered with after they have been signed. +Forging a signature is practically impossible without gaining access to the +private key used. If that were to happen, the compromised key would be revoked +and all files re-signed with new keys.
+The following PGP keys are currently in use for signing releases:
+| Developer | Fingerprint |
|---|---|
| Adrián Pérez de Castro (key) | +5AA3 BC33 4FD7 E336 9E7C 77B2 91C5 59DB E4C9 123B | +
| Carlos García Campos (key) | +D7FC F61C F9A2 DEAB 31D8 1BD3 F3D3 22D0 EC45 82C3 | +
Once downloaded, keys need to be imported in the PGP keyring, for example with +GnuPG:
+% gpg --import aperez.key
+gpg: key 91C559DBE4C9123B: 1 signature not checked due to a missing key
+gpg: key 91C559DBE4C9123B: public key "Adrián Pérez de Castro <aperez@igalia.com>" imported
+gpg: key 56736249E4C9123B: 11 signatures not checked due to missing keys
+gpg: key 56736249E4C9123B: public key "Adrián Pérez de Castro <aperez@igalia.com>" imported
+gpg: Total number processed: 2
+gpg: imported: 2
+gpg: no ultimately trusted keys found
+The signature file for each release has the same name plus the .asc suffix.
+Given a download URL, the following illustrates the process:
% curl -sLO https://wpewebkit.org/releases/wpewebkit-2.34.3.tar.xz
+% curl -sLO https://wpewebkit.org/releases/wpewebkit-2.34.3.tar.xz.asc
+Now it is possible to verify the .tar.xz file against its signature:
% gpg --verify wpewebkit-2.34.3.tar.xz.asc
+gpg: assuming signed data in 'wpewebkit-2.34.3.tar.xz'
+gpg: Signature made lun 20 dic 2021 00:05:24 EET
+gpg: using DSA key 5AA3BC334FD7E3369E7C77B291C559DBE4C9123B
+gpg: Good signature from "Adrián Pérez de Castro <aperez@igalia.com>" [ultimate]
+gpg: aka "Adrián Pérez de Castro (personal) <adrian@perezdecastro.org>" [ultimate]
+Primary key fingerprint: 5AA3 BC33 4FD7 E336 9E7C 77B2 91C5 59DB E4C9 123B
+Checksums for release tarballs are also published along releases. While +suitable to check file integrity, using PGP signatures +provide a stronger guarantee.
+The checksums file for each release has the same name plus the .sums suffix.
+Given a download URL, the following illustrates how to calculate the SHA-256
+checksum on your end:
% curl -sLO https://wpewebkit.org/releases/wpewebkit-2.34.3.tar.xz
+% curl -sLO https://wpewebkit.org/releases/wpewebkit-2.34.3.tar.xz.sums
+% sha256sum wpewebkit-2.34.3.tar.xz | cut -f1 -d' '
+c35de4bfce35c81cbd6c1da27879b4ea33e20bd51d750ce296a4d100d45f40fc
+This can be compared with the value of the last line of the .sums file:
% cat wpewebkit-2.34.3.tar.xz.sums
+wpewebkit-2.34.3.tar.xz (22.5 MiB)
+ md5sum: f8eb92825bf6477fb04ca017926c2458
+ sha1sum: a72f507dfd6d4d579b2e6c939d7c171c2cfb1d92
+ sha256sum: c35de4bfce35c81cbd6c1da27879b4ea33e20bd51d750ce296a4d100d45f40fc
+Or, programmatically:
+% expected=$(tail -1 wpewebkit-2.34.3.tar.xz.sums | cut -f5 -d' ')
+% calculated=$(sha256sum wpewebkit-2.34.3.tar.xz | cut -f1 -d' ')
+% if [ "$expected" = "$calculated" ]; then echo ok ; else echo failed ; fi
+ok
+This is the first development release leading toward 2.22 series.
+Thanks to all the contributors who made possible this release, they +are far too many to list!
+ + + + +This is the last development release leading toward the 2.20 series.
+Thanks to all the contributors who made possible this release, they +are far too many to list!
+ + + + +This is the first stable release in the 2.20 series.
+Thanks to all the contributors who made possible this release, they +are far too many to list!
+ + + + +This is the first bug fix release in the stable 2.20 series.
+Thanks to all the contributors who made possible this release, they +are far too many to list!
+ + + + +This is the first bug fix release in the stable 2.20 series.
+requestAnimationFrame().Thanks to all the contributors who made possible this release, they +are far too many to list!
++wpewebkit-2.20.2.tar.xz (14.7MB) + md5sum: 07cb30291a8311f3cf126e3a2e3d0efb + sha1sum: 69f1206255989e969fcdfb5c63401fb1f5a37864 + sha256sum: 0950befe6e970c9219ccbc29f5ff08bcc0923f0a9ca5a4c7531d74f9e26617f2 ++ + + + +
This is a development release leading toward 2.22 series.
+Thanks to all the contributors who made possible this release, they +are far too many to list!
+ + + + +This is a development release leading towards the 2.22 series.
+Thanks to all the contributors who made possible this release, they +are far too many to list!
++wpewebkit-2.21.91.tar.xz (15.1MB) + md5sum: 08778a95eba2de141d8aaff3d802c811 + sha1sum: 708808649e4a0470fd8cae253f26c12ddfff99d4 + sha256sum: e75b1ca225fa9303017e954b6203e4f1750a7566fa852443e6fd574fd5f926b8 ++ + + + +
This is a development release leading towards the 2.22 series.
+warn_unused_result attribute to some JavaScriptCore GLib APIs.Thanks to all the contributors who made possible this release, they +are far too many to list!
++wpewebkit-2.21.92.tar.xz (15.1MB) + md5sum: c5fcb3768067978741d8e72b1055ab8b + sha1sum: 959bcf32702739f518c077964b003c5d0e8e8dc2 + sha256sum: 8ee366915aaf4f97950889863ac9951d21d94cae9c5f09d5f8e6efeb92069746 ++ + + + +
This is the first stable release in the 2.22 series.
+webkit_settings_set_enable_mediasource() has to be used to enable the
+feature.warn_unused_result attribute to some JavaScriptCore GLib APIs.jsc_ prefix not being exported.playbin3.Thanks to all the contributors who made possible this release, they +are far too many to list!
++wpewebkit-2.22.0.tar.xz (15.2MB) + md5sum: e23753c1b2984303e2523c18031b0736 + sha1sum: c69998d2a522287f5c894f8ed73b9f122d3ae949 + sha256sum: 625551aa60ad047639cc64be4259f03598c4ed5db5f7427251657f889e822208 ++ + + + +
This is the first bug fix release in the stable 2.22 series.
+ENABLE_MEDIA_SOURCE as a public build option.<iframe> elements.ENABLE_VIDEO=OFF and ENABLE_WEB_AUDIO=OFF.Thanks to all the contributors who made possible this release, they +are far too many to list!
++wpewebkit-2.22.1.tar.xz (15.2MB) + md5sum: 54f0f19aa4cf8d29e1e6b7a1f4d5608c + sha1sum: 1d11603bddb15ce9ca8d09cfa772d2109739a426 + sha256sum: 49212bd2ba03e28c09925971145f42fdc42a99d7ae2b8a02c8c0f4d012425350 ++ + + + +
This is a bug fix release in the stable 2.22 series.
+-DLOG_DISABLED=0.Thanks to all the contributors who made possible this release, they +are far too many to list!
++wpewebkit-2.22.2.tar.xz (15.2MB) + md5sum: 69c29ce376208b62b0cc43b750e27afb + sha1sum: 6ff4a3092ffff5e7600d00040984f988a76c6dc3 + sha256sum: 56dced284e9fe71a7c56abc881b240251863472aed41c3e32ee3b071c21e56a9 ++ + + + +
This is a bug fix release in the stable 2.22 series.
+USE_SYSTEM_MALLOC at build time.ENABLE_VIDEO=OFF and ENABLE_OPENGL=OFF.Thanks to all the contributors who made possible this release!
++wpewebkit-2.22.3.tar.xz (15.2MB) + md5sum: 6d0c693ea49a93fc9e701cf784245ea5 + sha1sum: d8a22bec787f38939c7922dc43bf27c9144cef74 + sha256sum: 241f177cded1a4ba3088716650eaaac25588878882170789b3c630ac45dbb2fa ++ + + + +
This is a bug fix release in the stable 2.22 series.
+Thanks to all the contributors who made possible this release!
++wpewebkit-2.22.4.tar.xz (15.2MB) + md5sum: 6e5c668473c57906bdec1c641bac4579 + sha1sum: 002b8b25f4fc26bfef68767b3ff1eba1aac53fa5 + sha256sum: 871e86b7e989de0c1224ac7ab8ed6d8b52756cf793a8c253b56ab8ba8d288c96 ++ + + + +
This is a bug fix release in the stable 2.22 series.
+Thanks to all the contributors who made possible this release!
++wpewebkit-2.22.5.tar.xz (15.2MB) + md5sum: 7b768bfae1295ebbc9a9038bf8fb6e6c + sha1sum: c85f927e0f17f1e7045a5d33c683d310c7af24de + sha256sum: d5e7b23e4f9e9f1b9d369faa4d527cdb59aef56b3e6a50a16dad243df5f699f3 ++ + + + +
This is a backwards-compatible, stable release of the WPE backend loader +library.
+New API to set and query the backend implementation library being used +(#19).
+New API to query the version library, both with macros at build time, +and functions at runtime +(#18).
+Trying to use a backend implementation library which does not provide
+a load_object callback will produce a meaningful error instead of
+silently failing.
+wpebackend-0.2.0.tar.xz (8.6KB) + md5sum: d04e44a32709dbb763ce1fcfc28bc6d8 + sha1sum: 4089cac12877ee1e09372953a281a46b8c8951e9 + sha256sum: ce33ff29b04175cb6fe6e6597a4b5e8ec9da0b8b5ae0745848902ac935d65823 ++ + + + +
Updated to use libwpe 1.0.0 +(#23, +#20).
+The libWPEBackend-fdo library now uses the libtool
+versioning convention
+(#22).
New API which supports exporting frames as EGL images. This provides
+applications with a ready to to render EGLImage, and has the advantage
+that the library hides the actual protocol used by the backend’s nested
+compositor from the application
+(#16).
Support using Wayland versions older than 1.10 +(#19).
++wpebackend-fdo-1.0.0.tar.xz (24.2KB) + md5sum: 5318728afb3bf7417293af67ce427963 + sha1sum: 7ee22bc1d585616f4ad2047d8be54ec396486211 + sha256sum: 7a747f87a1ae46d30144369050e3ce348b58986d04e1a139ba75c198fa636729 ++ + + + +
This is a bugfix release in the stable 1.0 series.
+wpe_fdo_initialize_for_egl_display() to be called multiple times;
+it will emit a warning when trying to switch to a different EGL display,
+which is unsupported (#26).+wpebackend-fdo-1.0.1.tar.xz (24.4KB) + md5sum: 2ee81a4212c18110a06a0c51c12e0d2e + sha1sum: cdc6ac95e302a2358204b766936a9bf8ef4f26f2 + sha256sum: 15b8b1febea5d9c271e95c35b3c1e13f870712a54bc5f689cfdbb96e2f070fc8 ++ + + + +
Thiss is the first development release leading towards the 1.2 series.
+Use the new libwpe API to notify when frames have been displayed +(#28).
+Allow calling wpe_fdo_initialize_for_egl_display() multiple times, with a
+warning printed to the standard error output when trying to switch displays
+(which is unsupported)
+(#26).
Provide a dummy implementation of the EGL offscreen target interface, to let +WebKit use Pbuffer-based offscreen contexts as fallback, instead of crashing +(5a4b58c).
+Minor cleanups in headers and function prototypes +(#25, +#24).
++wpebackend-fdo-1.1.0.tar.xz (24.6KB) + md5sum: dc852a6cafaf4b6392dcb91e36cd7abb + sha1sum: 688377f441e19273fe2b44c0a2ea9da149f97fa4 + sha256sum: f6c72130d16e50860cb83eb0f6e109c76f1826d2c6bee39025fb3651941761e7 ++ + + + +
This is a development release leading towards the 1.2 series.
+wpe_fdo_initialize_for_egl_display() now returns a boolean value
+which indicates whether initialization was successful (#32).const to explicitly indicate
+that they are not modified.+wpebackend-fdo-1.1.90.tar.xz (26.1KB) + md5sum: f5db0d3137d37e886c932b470808a779 + sha1sum: 9d0ea689f2215652b4cc5a790d78306c0707e56b + sha256sum: 31d9f1ae06968fe752055dde9d5cd7d5fd044c1aec92798bc0491d9a9cef84da ++ + + + +
This is a development release leading towards the 1.2 series.
+wpe-1.0.+wpebackend-fdo-1.1.91.tar.xz (26.1KB) + md5sum: 32a2a789188d300075b87bb3af967593 + sha1sum: 9dbc322a73019acd35a9e30b648d7843f96624ae + sha256sum: d20e5688e3e6d9fdf1c3ee083ea14720bf59354aa17f275a003b030e8131315d ++ + + + +
This is the first stable release in the 1.10 series.
+wl_resource for SHM exported buffers.wayland-scanner
+during cross-compilation, using a native machine file.+wpebackend-fdo-1.10.0.tar.xz (37.6 KiB) + md5sum: 306adbb0c66dc753e1794c83b7a2682b + sha1sum: bf71718a213c6511dea278ade5ce90967d181995 + sha256sum: b89dfd3500a4dec711132cd7bff72599e67d56a419d000730e14bb99547509cc ++ + + + +
This is the first stable release in the 1.12 series.
+wl_resource for SHM exported buffers.wayland-scanner during cross-compilation, using a native machine file.+wpebackend-fdo-1.12.0.tar.xz (42.1 KiB) + md5sum: c43b34a4b4933bcd80068ae5776ee346 + sha1sum: e2576d564bd6d9a86737a4cd31dd5827ebc00fdf + sha256sum: 6239c9c15523410798d66315de6b491712ab30009ba180f3e0dd076d9b0074ac ++ + + + +
This is the first bug fix release in the stable 1.12 series.
++wpebackend-fdo-1.12.1.tar.xz (42.1 KiB) + md5sum: 494f4a5b2bd89dacef37b69534b2e1ce + sha1sum: 72a85e4615e085926f7ad8fc8414f9c6a878ef28 + sha256sum: 45aa833c44ec292f31fa943b01b8cc75e54eb623ad7ba6a66fc2f118fe69e629 ++ + + + +
This is the first development release leading towards the 1.14 series.
++wpebackend-fdo-1.13.1.tar.xz (42.0 KiB) + md5sum: 4dd9a2a43f50042e0cfbf989ba392a2f + sha1sum: 6da476b35bb82e8ae8f4fe7050282aeded649924 + sha256sum: d61ca47ec52d7cd1d6f869f66d6ea247a53092acfad1a8cbab71836a82d3a0ae ++ + + + +
This is the first stable release in the 1.14 series.
++wpebackend-fdo-1.14.0.tar.xz (42.1 KiB) + md5sum: ea62dfa9ecb366598a837d7446ed48ac + sha1sum: 1500be9212381a404f4a46b22b90a9880ba11c01 + sha256sum: e75b0cb2c7145448416e8696013d8883f675c66c11ed750e06865efec5809155 ++ + + + +
This is the first bug fix release in the stable 1.14 series.
++wpebackend-fdo-1.14.1.tar.xz (42.2 KiB) + md5sum: 2b49218cdd16075b028bbaf5a4f57890 + sha1sum: a68db2480d29d53d7fa24c69888bacbab6efea11 + sha256sum: 01938dd93c62b3a47b18dd13c70d50490a8b8a6caec23c8550a3dbdbcc6bbb50 ++ + + + +
This is a bug fix release in the stable 1.14 series.
++wpebackend-fdo-1.14.2.tar.xz (42.3 KiB) + md5sum: dafd899646b2e31ef2d97938a638c48d + sha1sum: f453f8d77e93f4ac6ac81c1874d4d6bdcb45c253 + sha256sum: 93c9766ae9864eeaeaee2b0a74f22cbca08df42c1a1bdb55b086f2528e380d38 ++ + + + +
This is the first stable release in the 1.2 series.
++wpebackend-fdo-1.2.0.tar.xz (26.1KB) + md5sum: 74e1b2fc2bc19933b17ff4f8435f67cd + sha1sum: 60559697512fd483c1d918b708a3d1d130b74a0a + sha256sum: b1bb261273772af8f7d96d94989fc2ed0445ec06c7eb21f47a1b94e52422ddd5 ++ + + + +
Improved how CMake searches for wayland-scanner, making it friendlier for +cross-compilation (#39).
+Fixed the build when using EGL headers which define prototypes for +EGL extensions (#51), +and when the EGL_WAYLAND_BUFFER_WL definition is missing +(#50).
++wpebackend-fdo-1.2.1.tar.xz (26.8KB) + md5sum: fc76ac572ed03da8237d1e3e3991d0c3 + sha1sum: 8c994a25839b9df214c148c8892ee2c6f88ebbde + sha256sum: 6ef0852ecb9513a6789f8bbb9533083fcb165bb2d762eeb6d31e0b58c708cca0 ++ + + + +
--no-undefined is passed to the linker. This was caused
+due to an explicit reference to the GObject library missing in the linker
+command line.+wpebackend-fdo-1.2.2.tar.xz (26.8KB) + md5sum: 59b5fd6a3b64fe473458e16913ff9256 + sha1sum: d525044256dc7ee13fd64bc10d3e24e3b980125e + sha256sum: a2a50631eff7ec7ad1f787ab7ea9a524148588edbb42fff614ee404e1bcc126d ++ + + + +
This is a bug fix release in the stable 1.2 series.
++wpebackend-fdo-1.2.3.tar.xz (27.1 KiB) + md5sum: c9aba34bf43cebba37396f18b0d00a12 + sha1sum: 99b62a8ad31e096bcd2bc32b3fcb64836e1898d2 + sha256sum: 0f4ed84ec1042be862f009a86bd48a84a9b32817c381793d9de950613c244bfa ++ + + + +
This is the first development release leading towards the 1.4 series.
+EGLImageKHR
+(#37).+wpebackend-fdo-1.3.0.tar.xz (26.8KB) + md5sum: 6e00accb294fee5f2d27a716552284d2 + sha1sum: f07e4c92deae09b2904db1efdc457bfcce1551f9 + sha256sum: fed9ab29f5d53cf465188da80d014f3aa067c77704f8508c6bd17971fded359d ++ + + + +
This is a development release leading towards the 1.4 series.
++wpebackend-fdo-1.3.1.tar.xz (28.2KB) + md5sum: 4bd9b0c9b8b624ca806024c8ddfeb564 + sha1sum: aa37f3c59db557c0c0026a492e6928dad50877c0 + sha256sum: b0d136aa9ce9f94b1d06b258ed68c4a7b588b2e692d448d9c6eedb72edf56739 ++ + + + +
This is a development release leading towards the 1.4 series.
++wpebackend-fdo-1.3.91.tar.xz (29.4KB) + md5sum: 611e4c27b37c94ea3ed7162cb001b69c + sha1sum: 544aa7b9848aadc5fe8b6542dbf18ae0898bfaf5 + sha256sum: ebb4650755017be87ca630438d3908dd5fae2fa7fc8e90b0f70acd1ec0b015e2 ++ + + + +
This is the first stable release in the 1.4 series.
+EGLImageKHR.+wpebackend-fdo-1.4.0.tar.xz (29.5 KiB) + md5sum: 63553c3f43593c2a8c587c32e88fdf3c + sha1sum: a426d9a778ab52be2f4dd9cc7d324b43abac2f80 + sha256sum: a919ca4a5bc445f9419a5b7f3781cfc98e5abcf5d7259eb1869f5ab20fd18baf ++ + + + +
This is the first bug fix release in the stable 1.4 series.
++wpebackend-fdo-1.4.1.tar.xz (29.5 KiB) + md5sum: c6362491a4a38ddac42b66f140e1cff2 + sha1sum: 9217c8a5511bc53544b42cb23390256580ac4b0c + sha256sum: 6249a0b7cbfa662206a8d2fa24e2c574e75c681ad0e93468091f1dc68ddb299d ++ + + + +
This is a bug fix release in the stable 1.4 series.
+EGL/eglmesaext.h header.+wpebackend-fdo-1.4.2.tar.xz (29.6 KiB) + md5sum: d613bd5df2581f94542e22ec6033e574 + sha1sum: 44f22a2dd7fe5ead024cf9523cfd01a4f20befde + sha256sum: fc1a3483eaab4b382fb4ab5519825d3b4787d64dfb4bdbef160d5ad2cc388d1f ++ + + + +
This is a development release leading towards the 1.6 series.
++wpebackend-fdo-1.5.90.tar.xz (34.1 KiB) + md5sum: 0502f824b2ac0b3b49eb0ccbd80a85c6 + sha1sum: 412749092e4df00d5321e4c4528db090f6e552ba + sha256sum: 34d55e7d28235a03aa69beb283daf23fffe8f1953f47a8d8b9247e0d3eb97e4f ++ + + + +
This is the first stable release in the 1.6 series.
++wpebackend-fdo-1.6.0.tar.xz (34.2 KiB) + md5sum: 456afeed22f6749f7b2a97c11660835d + sha1sum: d128e2c7ff273d9b9f31217f6ac25be3b266d805 + sha256sum: 7f5bd7b9d8f97b1655f4dcd39fad92719d0fb3985b251da5802df13aaa09f567 ++ + + + +
This is the first bug fix release in the stable 1.6 series.
+EGLNativeDisplay definitions.+wpebackend-fdo-1.6.1.tar.xz (34.4 KiB) + md5sum: ea6c2a13e6c2423f2c2b0b31fcf9567b + sha1sum: 53e38189324d9c0c87f40164d8349a827663aabd + sha256sum: 740eee3327acfb462b8460519a219e30dc0a870326e88e2ddc4fe2c8de20b1c9 ++ + + + +
This is the first development release leading towards the 1.8 series.
++wpebackend-fdo-1.7.1.tar.xz (40.8 KiB) + md5sum: 7e66a08eecba6124f59bbce288c52fa1 + sha1sum: d72795efca8d6d4e624fc9e945cf279599e74bc0 + sha256sum: 9b980a73ea4e3762266c48f81ded56d9dcad4acf32bad9bd05d0dffdd454c6f5 ++ + + + +
This is a development release leading towards the 1.8 series.
++wpebackend-fdo-1.7.90.tar.xz (41.5 KiB) + md5sum: 70f9a4efb4586c98f4aa5425402a4dd8 + sha1sum: b3f0a006f0b613672b25f9d42137162ca46a208c + sha256sum: 65f06259c018a58a4555bf0719e0219a2acb6e82124435c33de9723d64335351 ++ + + + +
This is the first stable release in the 1.8 series.
++wpebackend-fdo-1.8.0.tar.xz (41.5 KiB) + md5sum: 6df96f80ff34c02d56f32a7a153a62c0 + sha1sum: 48dd8d5d525e0c89b8b7068fe51c439921804240 + sha256sum: 9652a99c75fe1c6eab0585b6395f4e104b2427e4d1f42969f1f77df29920d253 ++ + + + +
This is the first bug fix release in the stable 1.8 series.
++wpebackend-fdo-1.8.1.tar.xz (41.7 KiB) + md5sum: e7083e9fd325f289b23253b770d08d2e + sha1sum: 08472f1bcff6100ba963bdbe7347487253006ca0 + sha256sum: 8adb4475be949ae4092370de6a37d7b9e1d3704cf4674867312e87de2ff0d880 ++ + + + +
This is a bug fix release in the stable 1.8 series.
+<wpe/wpe.h> from the top-level API headers,
+as their consumers expect the public libwpe API to be defined as well.+wpebackend-fdo-1.8.2.tar.xz (41.8 KiB) + md5sum: 93ca185b5c0f539abbf7ab32cfdc96b2 + sha1sum: 715a1a1e0cfd85898a1f686ec4c5b79a1e8cfb9c + sha256sum: 98c291071128326a72918d670a46ef63268c43267928560ac3b84b6aebb2d78d ++ + + + +
This is a bug fix release in the stable 1.8 series.
++wpebackend-fdo-1.8.3.tar.xz (42.0 KiB) + md5sum: 980cbda207bf8f6263799c5062425737 + sha1sum: c849043039d805448715be90cb5b3491f0a90c5f + sha256sum: 3d0b4282a1bd9e0664d7a20abe14e982f3285296ac62de56cae2a404b9d28b9e ++ + + + +
This is a bug fix release in the stable 1.8 series.
++wpebackend-fdo-1.8.4.tar.xz (42.3 KiB) + md5sum: 9f4c98cba7805cd594f74f4991920ee7 + sha1sum: 4253a15f311ea1c5b7043846839829ed7838361f + sha256sum: def59bed5e8cdabb65ffa76ee2eef349fba7b42a75dac80f3da5954b17f4074a ++ + + + +
This is the first development release leading towards the 1.10 series.
+wpe_fdo_initialize_shm().+wpebackend-fdo-1.9.1.tar.xz (36.3 KiB) + md5sum: 7a233969c0ba50ba4b8f58dbfb43ffa5 + sha1sum: 9f38ca2cca28d69678076fc3a06f314846a96166 + sha256sum: a1dc4e506413719a0d84757797b645fa76590e6c8db23d2403d990dc2e196a64 ++ + + + +
This is a development release leading towards the 1.10 series.
+wl_resource for SHM exported buffers.<wpe/wpe.h> from the top-level API headers, as
+their consumers expect the public libwpe API to be defined as well.+wpebackend-fdo-1.9.90.tar.xz (37.1 KiB) + md5sum: da5f85b41a4a40d38f6ac9f1f0d062bc + sha1sum: 62103b07c6f2eb3dab3ff2e4259538c870c9e7db + sha256sum: 9d8330f54debb6273b432040dfde2b03e6eed8411dceda0093193a06276aba44 ++ + + + +
This is a development release leading towards the 1.10 series.
++wpebackend-fdo-1.9.91.tar.xz (37.2 KiB) + md5sum: 8787c05e9abe8f066c168881d97a9b32 + sha1sum: f4dc2c50deb0dbf421477f0a9f461c6184553c1f + sha256sum: 13dcbdaee3af8e46c6a2400c28f75a8f4ca24a41324a324184eb2b848964c3ff ++ + + + +
This is a development release leading towards the 1.10 series.
+wayland-scanner during
+cross-compilation, using a native machine file.+wpebackend-fdo-1.9.92.tar.xz (37.5 KiB) + md5sum: 5c2f7fab6623e0964bc0d1b4a01719f0 + sha1sum: d07fdfec0df53c57e3ed36a1efffecf30d1b418c + sha256sum: fc5b388a91d6f2c22803e1a21a6759a314b4539e5169c6e272bfc953a05fbb85 ++ + + + +
This is a development release leading toward 2.24 series.
+Thanks to all the contributors who made possible this release.
++wpewebkit-2.23.90.tar.xz (16.1MB) + md5sum: 06ab9cc7da53cf35ff9315800fb91140 + sha1sum: 5ed558f2e7d4b82adbe426b4574f24eac848fa60 + sha256sum: 070c4e838560b3dacc635af769c419ffb11ef3bb211f826115b2308990fc7ad8 ++ + + + +
This is a development release leading towards the 2.24 series.
+g_autoptr and friends.WebKitUserContentFilterStore to the API docs.wpe-1.0 and wpe-fdo-1.0.GObject in the JSC GLib API.wl_array_foreach.WebKitUserContentFilterStore.h header.Thanks to all the contributors who made possible this release.
++wpewebkit-2.23.91.tar.xz (16.0MB) + md5sum: 2c823548d9da12b466a8e2fb46c68d52 + sha1sum: 46ce9264373a6eb3f90beda3b94bf3a41cdeaf9e + sha256sum: 23885d07d19e25cd804dc1eda8d14c7ed248fcc0a2268d0a2133d38a2a81ac4b ++ + + + +
This is the first stable release in the 2.24 series.
+g_autoptr with WPE WebKit types.For more details about all the changes included in WPE WebKit 2.24 see the +NEWS file that is included in the tarball.
+Note that the 2.24 series require usage of libwpe 1.2.0 +or newer, and when using the FDO backend, WPEBackend-fdo 1.2.0 +or newer.
+Thanks to all the contributors who made possible this release.
++wpewebkit-2.24.0.tar.xz (16.0MB) + md5sum: 042848cd0d0f9f7fa54663db8e4751dc + sha1sum: 4f7ebd3364dd4e8d0e2dec11ccc33ed88c83ec2b + sha256sum: d2e5e444134720cbad5c8669996000a004943bb71ee6783aefa72a80bde1b35a ++ + + + +
This is a bug fix release in the stable 2.24 series.
+webkit_web_resource_get_data().outlook.live.com uses the modern UI.GObject or boxed types in the JavaScriptCore GLib API.+wpewebkit-2.24.1.tar.xz (16.1MB) + md5sum: 0f7b792874853416d8005b020bd90685 + sha1sum: d009c82afbc2c373a7f34ffda392e5c3b52dac7d + sha256sum: 95f2fb68429fbd901ea415d09fdd88d6d9ac5ec2d170bec9977093b12e5093a6 ++ + + + +
This is a bug fix release in the stable 2.24 series.
++wpewebkit-2.24.2.tar.xz (16.1MB) + md5sum: 3604a2167827c8354f6dcbab98305d7b + sha1sum: 1248d7723d0e6aec52cafc27a92c5c335c1abdd4 + sha256sum: cf251a467b3bcae50f97e22f4baccca49fcbbd54162dc5b71c0b1ebf655fd95f ++ + + + +
This is a bug fix release in the stable 2.24 series.
+application/xml in the Web Inspector, when loaded using XmlHttpRequest.ENABLE_VIDEO=OFF and ENABLE_WEB_AUDIO=OFF.+wpewebkit-2.24.3.tar.xz (16.1MB) + md5sum: b5c6fe640b03c3e87594da2c0a0a8469 + sha1sum: c9ccb6c4c65446e96ed6d534a1556db0fcca8268 + sha256sum: 907b20907a32a4288cbf67b56eab04cbbd997a7ca0f40b3c466cbbbbfba0e7ca ++ + + + +
This is the first development release leading towards the 2.26 series.
++wpewebkit-2.25.1.tar.xz (17.2MB) + md5sum: 380378f96d9f827ecb3b2f9f31fa7ba3 + sha1sum: d8bfdc420ff27638578b382fa9d77b2b1dea897f + sha256sum: 0ea209c7bfaec5c7fd7e731ff86a4db805db8c8306da1e20259b41eab39c41ee ++ + + + +
This is a development release leading towards the 2.26 series.
++wpewebkit-2.25.2.tar.xz (17.3MB) + md5sum: ca1aa8f78e1026a69c9f6b1a76f77e16 + sha1sum: e15cd93eaa8821c9e0ed0a82b6544b4624965e92 + sha256sum: b6485cdc79dce1a6f3a3196e3bc9832110067b121f8f552e3e2d8a0135f6ae27 ++ + + + +
This is a development release leading towards the 2.26 series.
+DISPLAY on X11.WEBKIT_USE_SINGLE_WEB_PROCESS environment variable to force single process model in all WebKitWebContext.
+This is a temporary solution for applications still depending on the single process mode behavior. It will be
+only available in 2.26 series.+wpewebkit-2.25.91.tar.xz (17.3MB) + md5sum: 16b74b3246b2787e8b200e9f3ec5285d + sha1sum: e3437547fce8ff9cb867157f6f82ba18b4d8a38b + sha256sum: 79921b8d04a9d5df7e3d4a3725746638df8f76705b1cd64fc31c093808fbb9a7 ++ + + + +
This is the first stable release in the 2.26 series.
+For more details about all the changes included in WPE WebKit 2.26 see
+the NEWS file included in the release tarball.
Thanks to all the contributors who made this release possible.
++wpewebkit-2.26.0.tar.xz (17.3 MiB) + md5sum: 59a2e64f145b3445187a22eff1f73293 + sha1sum: 757ab5da23ef7944332d4c57fcf56a932e933ce4 + sha256sum: a97a24fe0c22243c873c359d7636512c01016ea2068a457ba651040f1a07ee3e ++ + + + +
This is the first bug fix release in the stable 2.26 series.
+Thanks to all the contributors who made this release possible.
++wpewebkit-2.26.1.tar.xz (17.4 MiB) + md5sum: bec094fe878e03f42de751cbaf0b3e99 + sha1sum: 53dfafab8d5ccb537e7330febb9504c390e3bf52 + sha256sum: d1ae85dffb5bfc106c5ac6d5e73a3dfe3cb2c1df1f18c16103e1dc744cd4ac14 ++ + + + +
This is a bug fix release in the stable 2.26 series.
+prgname in dbus-proxy socket path.+wpewebkit-2.26.2.tar.xz (17.3 MiB) + md5sum: 057cc2647231e90c8197873df9a9f54c + sha1sum: eca4e35af2c2e70bd36a9bdef3bfbbfbd417210c + sha256sum: dd4fce390f1721d8d6d017fa712adb990f7230bde84a1b7d27327bd589053fdd ++ + + + +
This is a bug fix release in the stable 2.26 series.
++wpewebkit-2.26.3.tar.xz (17.4 MiB) + md5sum: 735beb5c1f825d5feda2e355aca6bec0 + sha1sum: aeda665b3a137ac748ff1d08ce9e4c751f7caf97 + sha256sum: 2da9fe9c3a8bdfecc4281d848a4eacdd7be8ac5e0fc397020094d68cf32c10b3 ++ + + + +
This is a bug fix release in the stable 2.26 series.❤️
++wpewebkit-2.26.4.tar.xz (17.4 MiB) + md5sum: 4cd2883ec9da38a0ffe413bb75239874 + sha1sum: 337f78ee237fe98c7e6e728d8fc0508069b007be + sha256sum: 0c292182864b63b725491f1a69b55c03e0e75f6db0875389caff31fe9c0d3ae9 ++ + + + +
This is the first development release leading towards the 2.28 series.
+about:gpu to show information about the graphics stack.WebKitWebView:page-id property.ENABLE_WEBDRIVER=OFF.+wpewebkit-2.27.1.tar.xz (18.6 MiB) + md5sum: db594627c4265b4fd7561965e7e6b91e + sha1sum: 6c0786162054411befc454ee09855c87c6e945ed + sha256sum: 3d2f05c16056603abb7ed040b1f62957f9971f6ecc0bda04f91727d04c9e960a ++ + + + +
This is a development release leading towards the 2.28 series.
++wpewebkit-2.27.3.tar.xz (18.8 MiB) + md5sum: c9d8e133cd407e8a56cbd63cecfe3ff3 + sha1sum: 002de6a949332be48c19e3841b189297030eb0f2 + sha256sum: 5523ac2584e37f9d69fa59593bbd4227e3c777bd3b78c86dfd4da5636922a77b ++ + + + +
This is a development release leading towards the 2.28 series.
+JSCValue to/from a JSON string.WebKitOptionMenu API.WebsiteDataManager.+wpewebkit-2.27.4.tar.xz (19.1 MiB) + md5sum: 05f044cf0a04432baaed9273b5ce90b6 + sha1sum: 34cdd412b05185335bafd67b380e446855487b81 + sha256sum: 70a4e00e7e4c754faf264ca69c6cd67ca399dae1d15cc8443a0a3aa71791838a ++ + + + +
This is a development release leading towards the 2.28 series.
+WebKitSettings.data: URI.-webkit-font-smoothing CSS property.+wpewebkit-2.27.90.tar.xz (19.3 MiB) + md5sum: e432bc68a407b6f390ebb907008803f5 + sha1sum: f2dff587f201b2186a6d2f17f5e5e4d4933e4b5b + sha256sum: 70f8e67e9534bb1f5d9d6f4efdfa00c2bc61c3581f1938c819aff0233fde0f46 ++ + + + +
This is a development release leading towards the 2.28 series.
+User-Agent quirks to fix the “Unsupported browser” message in
+several Google services.+wpewebkit-2.27.91.tar.xz (19.3 MiB) + md5sum: 17a6a9a12f8614be78a8b25b9bedf4e5 + sha1sum: 6dad9724e2d86362850e2618abff2ccd578838ea + sha256sum: 822c07a024d390faff8fa6889b00f10387e16012b99e734baa74368a523ec0b3 ++ + + + +
This is the first stable release in the 2.28 series.
+SameSite cookies.webkit://gpu to show information about the graphics stack.WebKitSettings.WebKitOptionMenu API.For more details about all the changes included in WPE WebKit 2.28.0 see the
+NEWS file included in the tarball.
Thanks to all the contributors who made this release possible! 🎉
++wpewebkit-2.28.0.tar.xz (19.3 MiB) + md5sum: 4298b9d38b4f05f92995422ea9979893 + sha1sum: 9e791b6112cca8cda51ae7e991b545f4bf0bb46c + sha256sum: a85cd3cb46206a4929a9562d53379a7e7e2ec1a3224b34e2dcf5da30bb906722 ++ + + + +
This is the first bug fix release in the stable 2.28 series.
++wpewebkit-2.28.1.tar.xz (19.3 MiB) + md5sum: 3d424c7f814ab2269bb1ff020cc44fbb + sha1sum: 09434ac6e2e7b0ae052339bf04943612b43e0a6d + sha256sum: 3763a536d55529bbf66fa3772e9c1b543ddf882fabd0ca337076555b176ee8c5 ++ + + + +
This is a bug fix release in the stable 2.28 series.
++wpewebkit-2.28.2.tar.xz (19.3 MiB) + md5sum: c1f17d4b031e9462692443e3c089789c + sha1sum: b109cfec921eb466227ab3b8d21c5f5717311c8e + sha256sum: 6929d28744702ead3574484ca02645c457a6fdcd6b43ccc9766d98dc3664e8dc ++ + + + +
This is a bug fix release in the stable 2.28 series.
++wpewebkit-2.28.3.tar.xz (19.3 MiB) + md5sum: 0b3655598f340a5c83cc26423fefcf36 + sha1sum: ea03d365584ef5e86ca28cec6ca072a4674e9312 + sha256sum: 2539263a4d73c00abfe0205f54770dc1f6d2b635edbe41e748b507254f21e98b ++ + + + +
This is a bug fix release in the stable 2.28 series.
++wpewebkit-2.28.4.tar.xz (19.3 MiB) + md5sum: 6ab041f6ebdb2e053981de5980c864e7 + sha1sum: b31739a86a269eac4ddd5e537cdf954224672450 + sha256sum: 785d83b99cd45cedb7c4f1f697db773a5a81eb0a42aeeafa3c623053f6fde87a ++ + + + +
This is the first development release leading towards the 2.30 series.
+webkit_authentication_request_get_security_origin().<img> elements.WebKitSettings property to set the media content types requiring hardware support.sndio to the Bubblewrap sandbox.USER_AGENT_BRANDING build option.User-Agent string on tablets and handheld devices.+wpewebkit-2.29.1.tar.xz (19.8 MiB) + md5sum: bf15fb4886a1fafbba06f84797ead8a5 + sha1sum: 56d690ecdc90b78b284d645f13b870374573660d + sha256sum: 016cbff49c9fa976f94075c681df784e83ac1b1338829d3d7b8cdad6b214cb89 ++ + + + +
This is a development release leading towards the 2.30 series.
+text-underline-offset and text-decoration-thickness.+wpewebkit-2.29.2.tar.xz (19.8 MiB) + md5sum: 28734dc4168115f4f1b9e4d43a87fb74 + sha1sum: effe1da4dce6c681aa9d70131e4f50699bb41def + sha256sum: c19650573125468a14faf702851e31af91ff22fdcbd92943abab8e1f6fee0a5a ++ + + + +
This is a development release leading towards the 2.30 series.
+clone syscall seccomp filter on s390x.+wpewebkit-2.29.90.tar.xz (20.1 MiB) + md5sum: 84601baa0e6d6069369a4f507f33a584 + sha1sum: f89abf92ce43ce55971b5b24c5cb7129ad19ec7a + sha256sum: c8e197ed171486b23a89dca833d166436eecfba0d35e39b76fd570b3d800df4c ++ + + + +
This is a development release leading towards the 2.30 series.
+Notification Web API.User-Agent quirk for Google Docs.User-Agent header after a redirect when a new quirk is required.+wpewebkit-2.29.91.tar.xz (20.1 MiB) + md5sum: 73825416635d06bb033c27c700b1079d + sha1sum: 5d0ad8a0929486c8f69557e11d6d6215c8da0150 + sha256sum: 76c29db290b47508b91d566539abfa3028374a8a7da3cdfc2b9b180ac8b9a290 ++ + + + +
This is the first stable release in the 2.30 series.
+<img> elements.User-Agent string on tablets and handheld devices.+wpewebkit-2.30.0.tar.xz (20.1 MiB) + md5sum: b91b85b645061189765a9455a0539df1 + sha1sum: 243f2759f6fd06fdaefa84cbfa80e49559fbd14b + sha256sum: d1a99383ac3344195d09b4a4256c15dc5269c8585b3d836f43a057e60bb6f460 ++ + + + +
This is the first bug fix release in the stable 2.30 series.
++wpewebkit-2.30.1.tar.xz (20.1 MiB) + md5sum: 251228a6e2917eff90a3eb6e9a7e920d + sha1sum: 7f5bdc79d4694ab5644b7fed9bd7311c2cbc988f + sha256sum: 78c0135d935b980fc64fbddf1fbaf441920edda4eeb4c16857ee8dc985650c25 ++ + + + +
This is a bug fix release in the stable 2.30 series.
+WebSocket requests not appearing in the inspector.WebSocket requests with Same-Site cookies.ENABLE_MEDIA_STREAM enabled and ENABLE_WEB_RTC disabled.ENABLE_ACCELERATED_2D_CANVAS enabled.+wpewebkit-2.30.2.tar.xz (20.1 MiB) + md5sum: 5b0fed3333b53dbb36e572935fd54a7b + sha1sum: a143723fb77c2ea20bad888b95ccc37a7dd5b375 + sha256sum: c94925ca2d655c7fc07dbc2d4b7a47a822c7699816a8cca35ed9efd676b5ba86 ++ + + + +
This is a bug fix release in the stable 2.30 series.
+USE_64KB_PAGE_BLOCK.User-Agent quirk.<iframe> scrolling when asynchronous scrolling is in use.+wpewebkit-2.30.3.tar.xz (20.1 MiB) + md5sum: 75f6ef1819b182043a25b916272ebec6 + sha1sum: 2ed723f779513205449e0c5b7c080eb19d635aee + sha256sum: f2dfc1a6279810353f601bb9bd0d8ef671b41b38352d679b93d01631c2bf7b4b ++ + + + +
This is a bug fix release in the stable 2.30 series.
+WebSocket when using libsoup older than 2.68.+wpewebkit-2.30.4.tar.xz (20.1 MiB) + md5sum: d423a01ffb5be44e6ad59b2cfb9d6eb3 + sha1sum: 2fdca7b888966ad2ed7d998bef52c9024dae063f + sha256sum: 1e521d85cf8cf344b9fd08eabad7a1d18a330fb7862a77eaf78d7d7b10d5f6ef ++ + + + +
This is a bug fix release in the stable 2.30 series.
++wpewebkit-2.30.5.tar.xz (20.1 MiB) + md5sum: 63a9a7b7f29862ec827a730ba6542e80 + sha1sum: 33136493672882d56617007d7ce65268cb79bda7 + sha256sum: 4b577f4f07c34bb5d453d62b7a41d9e937bd3a2827a92dcd6f47c35f27c8359a ++ + + + +
This is a bug fix release in the stable 2.30 series.
+User-Agent quirks again for Google Docs and Google Drive.+wpewebkit-2.30.6.tar.xz (20.1 MiB) + md5sum: e35b31932ad3da6c06736d8f2d347072 + sha1sum: 25a481e97e463df08fb2c0b0fa5d4299938670ac + sha256sum: 893a3098226f116bbb38a665a3053c7d30e3c5dca786b954f9aa38f8c8581468 ++ + + + +
This is the first development release leading towards the 2.32 series.
+WebKitContext
+to WebKitWebsiteDataManager.WebKitUserContentManager.WEBKIT_GST_ENABLE_AUDIO_MIXER=1 environment variable.webkit_web_view_can_show_mime_type() API will still trigger GStreamer
+initialization in the UIProcess, though.decodebin3.AudioFileReader and the WebAudio renderer.+wpewebkit-2.31.1.tar.xz (20.9 MiB) + md5sum: 58b278f1a0dbe11a9aae941890d2bfd5 + sha1sum: 9c73673d8b6e4482a8d6c5748a1b373c8ed41f33 + sha256sum: c503a39d2fbd7d102a29664939e2c6f55d4a7281d7ecada8c508eef451889f74 ++ + + + +
This is a development release leading towards the 2.32 series.
+flatpak-spawn subsandbox to not clear environment variables.WEBKIT_GST_USE_PLAYBIN3=1 environment variable).playbin3.+wpewebkit-2.31.90.tar.xz (21.0 MiB) + md5sum: 08b33357ebba570a41dbadb43fc8a2ca + sha1sum: 552aa054ee9f4f269e9db8e23cf004bbefc8a2bc + sha256sum: 8011c741fd00f2d8e704ece629d2d7f58b600b23bc76d7045e3a0e36506e6be3 ++ + + + +
This is a development release leading towards the 2.32 series.
+WebKitSecurityOrigin a simple data store for <protocol, host, port> and deprecate webkit_security_origin_is_opaque().+wpewebkit-2.31.91.tar.xz (21.0 MiB) + md5sum: fd7268a3078018440645c6362c3fab31 + sha1sum: 08a9687234eb5f9e7c3ff63b80d96c3fa5bb2cb0 + sha256sum: e5bea1323ad810533bcb7ec7918b4bc2d342b0ea2a2fa61a3063cdd019bcd3f0 ++ + + + +
This is the first stable release in the 2.32 series.
+WebKitUserContentManager.For more details about all the changes included in WPE WebKit 2.32 see the
+NEWS file that is included in the release tarball.
Thanks to all the contributors who made this release possible!
++wpewebkit-2.32.0.tar.xz (20.9 MiB) + md5sum: 5e20eb2cbb045d7bd460df9c7730abea + sha1sum: 624ced96b0877de7d6a087f04e49d0024e3aa4f8 + sha256sum: 6cfb18af9a180eeffffcaf34fea68d867ee59f633d811ced92bbead2d184b6ea ++ + + + +
This is the first bug fix release in the stable 2.32 series.
+WebKitWebView.is-muted property state
+and values returned by webkit_web_view_is_playing_audio().ENABLE_VIDEO=OFF.+wpewebkit-2.32.1.tar.xz (20.9 MiB) + md5sum: 1dd3f56b8eba16266166d757acb979fc + sha1sum: c5b3a48d886375a6982dd2dc5c9cc2f92f5a9690 + sha256sum: 7b6b39a12ccf3f84da4cc6ac59e02fbe328f7476eaeb9c23de9b9288c2c2f39c ++ + + + +
This is a bug fix release in the stable 2.32 series.
++wpewebkit-2.32.2.tar.xz (20.9 MiB) + md5sum: a6624736150045a54037457416820b19 + sha1sum: 7b41a49f97b4cb458b6896623a02f4861cbcf728 + sha256sum: 2f0ebef0395a5a9e37a8609093f86140f74504f9954f97799b95f5dfbe186739 ++ + + + +
This is a bug fix release in the stable 2.32 series.
+WebKitScriptWorld::window-object-cleared signal is always emitted.+wpewebkit-2.32.3.tar.xz (20.9 MiB) + md5sum: 1e34412c50fe8d1ff084738477ecad7e + sha1sum: 157344d8febfc89d6731404c30857f122f220d6e + sha256sum: 859bd1bbe51026aecfb2b6f5c8c024d88fb69ac6fcdc74c788c9fbe9499d740d ++ + + + +
This is a bug fix release in the stable 2.32 series.
+.asc extension to downloaded text/plain files.+wpewebkit-2.32.4.tar.xz (20.9 MiB) + md5sum: 94ca1cc3f7b2de8b96c59d6e59cafcd0 + sha1sum: 19b8ebdbfef193ca50f7625703d871db87624f86 + sha256sum: 381f1422cbc319db1aa42dda48de39590ed90ac3bec6b81ec83f3f2cae5c3eeb ++ + + + +
This is the first development release leading towards the 2.34 series.
+libsoup3 by default.libsoup3.+wpewebkit-2.33.1.tar.xz (22.3 MiB) + md5sum: 23f8813320d27dba0d05f8a19de31e94 + sha1sum: 69e92f68f9053254b61dae6b10b69d2c926afa9d + sha256sum: 113795bdfc25f07ef92a088d146cfea217740f118d46cb6eb181451aac1d69fd ++ + + + +
This is a development release leading towards the 2.34 series.
+libsoup3.glvideoflip and videoflip elements.WebKitScriptWorld::window-object-cleared signal is always emitted.position:sticky in RTL layers with scroll overflow.+wpewebkit-2.33.2.tar.xz (22.3 MiB) + md5sum: b971872001118137e5846aa2600e4345 + sha1sum: 2a720938173f6e7354dd17fad50ea18a9256dd20 + sha256sum: 0214db68d694872e1636f1aa74b7c9e727657a03301e05967437650b15fa7ba7 ++ + + + +
This is a development release leading towards the 2.34 series.
++wpewebkit-2.33.90.tar.xz (22.6 MiB) + md5sum: c1694bfab066ce74a5ca8151cbd52ced + sha1sum: 12348322dc4fadb48a8b55a0efd482977a8aeb79 + sha256sum: 8ffa2ab66708aa6f07fc9e2c56f4950184555b6265ee3dc927ca4e1a900d1166 ++ + + + +
This is the first stable release in the 2.34 series.
+libsoup3.libsoup3.+wpewebkit-2.34.0.tar.xz (22.5 MiB) + md5sum: de57b0a8bcf72337d4b66a1f8d9a3333 + sha1sum: 921493a35865c78b3a6896d34ae3bd5d6e4184dc + sha256sum: 64c962197854c7a8a4129eebf11b745abf94bbfee5ddf4202354e46e1ca5571d ++ + + + +
This is the first bug fix release in the stable 2.34 series.
+User-Agent browser versions.g_desktop_app_info_set_as_default_for_extension() passing HTML.+wpewebkit-2.34.1.tar.xz (22.5 MiB) + md5sum: 915e583b0e7e82efa155cbce917d6319 + sha1sum: 452081b6df9d079f26d22bd0dca9e90f87943089 + sha256sum: cb336986341be9c3a9b1ca2c18de0d29d90ae4e77b9967a6f6879597e7a969f7 ++ + + + +
This is a bug fix release in the stable 2.34 series.
+Home and PgDown keys.+wpewebkit-2.34.2.tar.xz (22.5 MiB) + md5sum: b26f07bc809d9fd3e54e815c22312f15 + sha1sum: 4200ef87a4e1eb1921f0f40779742381598e1429 + sha256sum: b1a3733c2d486c4da27f9636ccc39947da7d84258cd7a24a6fb0b842c9595c0b ++ + + + +
This is a bug fix release in the stable 2.34 series.
++wpewebkit-2.34.3.tar.xz (22.5 MiB) + md5sum: f8eb92825bf6477fb04ca017926c2458 + sha1sum: a72f507dfd6d4d579b2e6c939d7c171c2cfb1d92 + sha256sum: c35de4bfce35c81cbd6c1da27879b4ea33e20bd51d750ce296a4d100d45f40fc ++ + + + +
This is a bug fix release in the stable 2.34 series.
++wpewebkit-2.34.4.tar.xz (22.5 MiB) + md5sum: b0f7dcb18acfa94cfb42fea0fe10fb0d + sha1sum: de58481b43a6dba054097f619ee486f7889d7a56 + sha256sum: 3653ba42dbe22a4e6751b3f7cab8d2ebb2db5b7654c5d135a2f9bedf94778cee ++ + + + +
This is a bug fix release in the stable 2.34 series.
++wpewebkit-2.34.5.tar.xz (22.5 MiB) + md5sum: 27a8b9714868dd890d4a54f4ae4cf2b1 + sha1sum: 63259a958a380cc8c75a4f51dada630f4fe5dc1e + sha256sum: 0ef187cdcb83dbe9e7b2870f43543b68766ea3535fe8b056866e8e1d3ef02bc1 ++ + + + +
This is a bug fix release in the stable 2.34 series.
+libGL or libgl, as is the case on systems that use
+libglvnd.+wpewebkit-2.34.6.tar.xz (22.5 MiB) + md5sum: c9705270b342474cca28cf51632ccbbe + sha1sum: 44ae95de1b5ebf0a2b0ea3630b3677153c597402 + sha256sum: 301e895c8ed08ce7dccef3192b972f2ccfc2020463244c64069a636f2b05265f ++ + + + +
This is a bug fix release in the stable 2.34 series.
++wpewebkit-2.34.7.tar.xz (22.6 MiB) + md5sum: bfde1baded709a15da76fcc8e692174b + sha1sum: a88d1f1fdedef18a95b00a283d2b4a0c59dc25dc + sha256sum: 092659bf43e5bc6f2a5a7b8e612a39da5da56a04f41eacc716638f53a27c3412 ++ + + + +
This is the first development release leading towards the 2.36 series.
+jsc_value_object_define_property_accessor() to work with objects
+not having a wrapped instance.+wpewebkit-2.35.1.tar.xz (23.0 MiB) + md5sum: af4425cc560f3e2aae0294e4060aa2b6 + sha1sum: eaa8e7bdcb7e15c89c0b7f3bd977cb9e0586307c + sha256sum: 9de134d99e4311dde83ad117cdb611dc533b49b0fa0113a2ec2c55fc10b76f29 ++ + + + +
This is a development release leading towards the 2.36 series.
+XDG_DATA_DIRS available in the web process sanbox.WebKitSettings:enable-developer-extras option is no longer enabled by default.MSE_MAX_BUFFER_SIZE, and configure
+regular playback on-disk buffering with WPE_SHELL_DISABLE_MEDIA_DISK_CACHE and
+WPE_SHELL_MEDIA_DISK_CACHE_PATH environment variables.requestVideoFrameCallback().+wpewebkit-2.35.90.tar.xz (25.8 MiB) + md5sum: 6a3b5462dd1f7fdd18f5f776259ff04b + sha1sum: 719bca6dee53e18f336cfb24058445253bc6bedc + sha256sum: 5bcd55923b7c425ea8f04c6733a33706410f1508b912d6b676e681459b703d76 ++ + + + +
This is the first stable release in the 2.36 series.
+WebKitURISchemeResponse API to set HTTP response information to custom URI schemes.WebKitSettings:enable-developer-extras option is no longer enabled by default.+wpewebkit-2.36.0.tar.xz (24.5 MiB) + md5sum: b7b951cd7f6eb4a8585338505ce71234 + sha1sum: 904629a9ce3a4ab67d47315b008dc3152d504205 + sha256sum: 096aa9f87d9bfbfc80f558388a86721cdcc508b42ddef10bd270aec9aee96d5a ++ + + + +
This is the first bug fix release in the stable 2.36 series.
++wpewebkit-2.36.1.tar.xz (24.5 MiB) + md5sum: 7ba1c7fd0f67891ad137d11cac12f7a9 + sha1sum: 0918a4daded01f42e65ec02a69f21cd6705311db + sha256sum: ec83d8b2f8c3479ce9950d69440f3b9876ab70200fe6f4e07686054a0cba5723 ++ + + + +
This is a bug fix release in the stable 2.36 series.
++wpewebkit-2.36.2.tar.xz (24.5 MiB) + md5sum: bcfb465ae085835ae96c68fddc85ca44 + sha1sum: 1a5a6b7b5e94f4ea7e3462d6bdb5de7efa678f74 + sha256sum: 959519562701e2005f2767a62e85977d6c3e65858709b376c89d8e33502febb9 ++ + + + +
This is a bug fix release in the stable 2.36 series.
+WEBKIT_GST_ENABLE_LEGACY_VAAPI=1 in the environment.+wpewebkit-2.36.3.tar.xz (24.6 MiB) + md5sum: 8bc53f86a3489da31fdbb581e1b87f7a + sha1sum: 44a3d99ae48481917ddc478c5f91e6a4faa21ff5 + sha256sum: 66275debca7497daff3a7826734cd56262a807adb76c5dccdf257c89968c2fc8 ++ + + + +
This is a bug fix release in the stable 2.36 series.
+Collection interface for the loaded document.+wpewebkit-2.36.4.tar.xz (24.6 MiB) + md5sum: ba8e5f5444fd50f53906a7376b25bb26 + sha1sum: 91259642da6fe55446c3352eeeafdaa188fc14bd + sha256sum: 307a3bedf5d4299a861f773f631c39a44c3e6276c3af37f7cbefaed2c8d7c021 ++ + + + +
This is a bug fix release in the stable 2.36 series.
++wpewebkit-2.36.5.tar.xz (24.6 MiB) + md5sum: 99b9b0c3c8757edf03ddf550bea448e2 + sha1sum: d7deb766d1ff48b7f9d685fcd67ccc23e2962288 + sha256sum: f2461d533cd3820ea1855e2c8b0b0624b39add1389dc3ac09c2f27891a7a8caa ++ + + + +
This is a bug fix release in the stable 2.36 series.
++wpewebkit-2.36.6.tar.xz (24.6 MiB) + md5sum: db3afcb318c98fbe09c0a08449772fd2 + sha1sum: 29a777d9db75f2b415473cf72cd1e52bf3f993ee + sha256sum: e98a4eae2464ffaf4e5b53be08b9ae6386db511015c8002918b824d29f05d58f ++ + + + +
This is a bug fix release in the stable 2.36 series.
++wpewebkit-2.36.7.tar.xz (24.6 MiB) + md5sum: a9f8d521d8171292aab842d3e8ba227e + sha1sum: e9255b3592bbaac8b20af03cafa31cedfb0b4898 + sha256sum: f3747d72ffc562ad0cfb6218fdf6d897c78c4bdbf5618e0fa26906fba52b95c9 ++ + + + +
This is a bug fix release in the stable 2.36 series.
+WebKitWebView:web-process-terminated signal not being emitted
+for the first web view when sandboxing is enabled.+wpewebkit-2.36.8.tar.xz (24.6 MiB) + md5sum: 939dc646bb6652fde9a5b6512c17fc58 + sha1sum: f45936c578f7dcfbb6064e87da6c098efe093e68 + sha256sum: 8d42a349c910b2d0961b8d34fecef29cec3d21e3af5977346c90026692dc75eb ++ + + + +
This is the first development release leading towards the 2.38 series.
+Content-Security-Policy, for web extensions support.WEBKIT_INSPECTOR_HTTP_SERVER environment variable.gi-docgen for API documentation instead of gtk-doc.+wpewebkit-2.37.1.tar.xz (29.0 MiB) + md5sum: a44cf35f7b6f8e577f51c296e94aae2a + sha1sum: 4f31d83fd9d6f66cd04f745b633e541ecb93b51d + sha256sum: eb07b54190827ea860089fc711358658d952bcc62e36bc9bfa12dcfda9c21649 ++ + + + +
This is a development release leading towards the 2.38 series.
+libnotify dependency.USE_SYSTEM_MALLOC=ON.+wpewebkit-2.37.90.tar.xz (29.1 MiB) + md5sum: 0fff92b923b422b7309019db6ba62ca5 + sha1sum: 326dc99a594132bdcd56d0a3133b853cfdc6b2cd + sha256sum: e944f68958ee0bfd5dbb342179c3d9178a7e388a59c4e1ea8e98b7337ecf12f7 ++ + + + +
This is a development release leading towards the 2.38 series.
+WebKitSettings.enable-frame-flattening setting because the
+functionality will be removed in 2.40.+wpewebkit-2.37.91.tar.xz (29.1 MiB) + md5sum: 59f8570a7f08ff2f86e59a44ec413c2e + sha1sum: a8fc283f60f2cd0d1dd56a3ee5acfa1d3934e531 + sha256sum: 0e7e907367366797f657c4ba793988b15e6c5fff747a449521ea264c55f6d614 ++ + + + +
This is the first stable release in the 2.38 series.
+Content-Security-Policy, which can
+be used to implement support for web extensions.WEBKIT_INSPECTOR_HTTP_SERVER environment variable.libnotify dependency has been removed.+wpewebkit-2.38.0.tar.xz (29.1 MiB) + md5sum: e0e6b98c86351c39e41da475afc50780 + sha1sum: 66e6dd1c285a21ce50370fb4d60332838d801663 + sha256sum: e653e12eca63e6371c06d4cd9efcd5492db67f7d9ef324fd5d8668b1151e72b2 ++ + + + +
This is the first bug fix release in the stable 2.38 series.
++wpewebkit-2.38.1.tar.xz (29.7 MiB) + md5sum: c3a6e2c74543a4dd54bf0ca4879886c0 + sha1sum: bf7367472d8cbe2dd1a36e6b57ac6bc2ce7fbe2a + sha256sum: bfa913aa60c39659983cd906c10a97b2cef1ae0c0574c89ed43dae2a35fefc00 ++ + + + +
This is a bug fix release in the stable 2.38 series.
++wpewebkit-2.38.2.tar.xz (29.7 MiB) + md5sum: 451a450d64a45f2965d3c09792c63466 + sha1sum: 3bb8482562f3689b81c85936846af456620395ee + sha256sum: 5ce5ac6d5cb6c13469f52d2ece34b302524ff59caf05ecf0f7c62e12c48df422 ++ + + + +
This is a bug fix release in the stable 2.38 series.
++wpewebkit-2.38.3.tar.xz (29.7 MiB) + md5sum: 60f79ff8dc68280f756963af23b67d6d + sha1sum: de15119a0dc29776d3a11fca1df4238b471f960f + sha256sum: 1dd9075eec7253a1b0d038a73f92ddbb9174394e6a7527ec07b4464fa6290498 ++ + + + +
This is a bug fix release in the stable 2.38 series.
+WEBKIT_GST_ENABLE_HLS_SUPPORT=1 can be set in the
+environment to enable it back.ENABLE_INTROSPECTION when cross-compiling.ENABLE_WEBGL disabled.+wpewebkit-2.38.4.tar.xz (29.1 MiB) + md5sum: 1c947ef5b73049fc6c102c92013009bf + sha1sum: 7fe9a7d98401256b0c9872f1c2b702e56840cbd3 + sha256sum: 8c1bc113ef151fb0be2640824d323bc755dc97295ab7a1bc05e7ec589937a07b ++ + + + +
This is a bug fix release in the stable 2.38 series.
+WebKitFrame.+wpewebkit-2.38.5.tar.xz (29.1 MiB) + md5sum: 73f7abd0c1cc808032869f72602166e3 + sha1sum: 3f10a04758eeb349f63f841aff765dae25bcde1b + sha256sum: ff00fd3d0a4c6d551850a78a7dfe4883b6b7ebd93c5549e1121b2f43d3ac1661 ++ + + + +
This is a bug fix release in the stable 2.38 series.
+:has() CSS selectors in content filters.GApplication to operate correctly. Using GApplication
+is still recommended, but optional.-flto=auto).+wpewebkit-2.38.6.tar.xz (29.1 MiB) + md5sum: eb44d3132208218f3752170cae3220b8 + sha1sum: 5c541a10e216d8d9ca48572b3dc0f82bfb2236c5 + sha256sum: dcb6591456393c5366ad9abc62a808137d4fea039cbc7ef4c8d64ead506d035b ++ + + + +
This is a development release leading towards the 2.40 series.
+background-repeat: space.webkit_web_hit_test_result_get_js_node() to get the JSCValue for the node.WebKitWebFormManager and deprecate WebKitWebPage form related signals.WebKitConsoleMessage API.event parameter of WebKitWebView::context-menu and
+WebKitWebView::show-option-menu signals in favor of a getter in
+WebKitContextMenu and WebKitOptionMenu.context-menu signals for the media settings popup menu.webkit_download_set_destination()
+is called with empty destination.+wpewebkit-2.39.5.tar.xz (35.8 MiB) + md5sum: d46d9abddd4f5352cd2247e925ac0332 + sha1sum: ea91ce4b2fb93fd538ab48d5fa262bce84576c31 + sha256sum: 0c8d256349cbccbc7080992e590456c8a66690dbe547f2d481c86ac18cee5ef0 ++ + + + +
This is a development release leading towards the 2.40 series.
+WebKitFrame.WebKitConsoleMessage API implementation.webkitOptionMenuSetEvent when opening any combo box.webkit.h public header causing applications failing to build.webkit_web_view_new_with_*() constructors when building with the new GLib API.webkit_web_context_{get,set}_process_model() when building with the new GLib API.+wpewebkit-2.39.90.tar.xz (35.8 MiB) + md5sum: 36def91376043e3123e892336ea9965e + sha1sum: 8da1bcab365078346db5f9a971ec7ab344448817 + sha256sum: 9fc2e39a6a4db0d4e8ee7ba051e44a8ba3fc090fa82ac9a008e3d839bdd4852d ++ + + + +
This is a development release leading towards the 2.40 series.
+WebKitWebExtension to WebKitWebProcessExtension in the new API.WebKitJavascriptResult in favor of using JSCValue directly in the new API.WebKitURISchemeRequest.WebKitDownload::decide-destination signal asynchronously.WebKitDownload destination to be a path instead of a URI.webkit://gpu exportable as JSON.KeyboardEvent.repeat.+wpewebkit-2.39.91.tar.xz (35.8 MiB) + md5sum: 5062e94c0e5c6e70266c27f06be96add + sha1sum: 63d496852c5b0474aa5d6e45d34cefbbc4e5d1f4 + sha256sum: 1dab45e12697157d7970469620ce706fe3fc01daed4a4674b7a61dad1ee64259 ++ + + + +
This is the first stable release in the 2.40 series.
+-USE_SOUP2=ON, or the 1.1 API using
+-DENABLE_WPE_1_1_API=ON.-DENABLE_SPEECH_SYNTHESIS=OFF, which also avoids the Flite
+dependency.background-repeat: space.WebKitURISchemeRequest
+(reference).Promise and await
+(reference).webkit://gpu to the clipboard as JSON.+wpewebkit-2.40.0.tar.xz (35.8 MiB) + md5sum: a90114f905b7996925a73dbb6a36aa72 + sha1sum: 06e475479c71c829c1eb67a77cd1e7fe7f952ad0 + sha256sum: a8ec2bcfa1613768ab3ce7f65cac4f214835266c2ff59440d72180baec3086b6 ++ + + + +
This is the first bug fix release in the stable 2.40 series.
+GApplication to operate correctly. Using GApplication
+is still recommended, but optional.Accept HTTP header.font-feature-settings
+CSS property.libgcrypt-config script
+instead of a pkg-config module file.font-size-adjust CSS property.ccache is used in certain setups.+wpewebkit-2.40.1.tar.xz (35.8 MiB) + md5sum: 617b00eabfc84d9c38b49b5705ec9f81 + sha1sum: fe03c27eedc59c0df0193d5e361b26e42e3598b0 + sha256sum: c6b25e168b70f2121305ed078d0790e0aa4b0c73fce44e32ed42d4e5dd137ccb ++ + + + +
This is a bug fix release in the stable 2.40 series.
++wpewebkit-2.40.2.tar.xz (36.3 MiB) + md5sum: ef90aa029887004e7784a0d85d484a9f + sha1sum: f11b4977d98facc00bf6fa88c31548a1e1e72dec + sha256sum: 99b7ab42580ac5726a2c95bae90caf4cf5df89765e4a046ca72e97b7fd3bccc7 ++ + + + +
This is a bug fix release in the stable 2.40 series.
++wpewebkit-2.40.3.tar.xz (36.3 MiB) + md5sum: 1568a6b0669aef438de51c892b69215b + sha1sum: c840bd76b2c86cb8ca0d68b56598cb0abbafc727 + sha256sum: 05b6a9cb1d7d03485e0dc41b2a8e6f99a36aea23d32ba3ecb38d0d6860747ada ++ + + + +
This is a bug fix release in the stable 2.40 series.
++wpewebkit-2.40.4.tar.xz (36.3 MiB) + md5sum: 89a385f776095483f3479075bf5d4705 + sha1sum: f0fde6eaa6de8b6a982a013fe3b962c688d7c381 + sha256sum: 34d11fe79522081ecc2d623860c22ddd53ca29a0d08b4c0e55efbdc3e6a9435c ++ + + + +
This is a bug fix release in the stable 2.40 series.
++wpewebkit-2.40.5.tar.xz (36.3 MiB) + md5sum: 03a4628755bcd2edea12d1975587fd18 + sha1sum: 40405f973c882ada48a759f06f00922fa727caeb + sha256sum: 4c658d3049c50e98b12fd6623ec42772f25a99cc1c05b5347a10a8633c266733 ++ + + + +
This is a development release leading towards the 2.42 series.
+GApplication to operate correctly. Using GApplication
+is still recommended, but optional.webkit://gpu.touchmove events not being produced.USE_WPE_VIDEO_PLANE_DISPLAY_DMABUF enabled.WebKitClipboardPermissionRequest to handle DOM paste access requests.+wpewebkit-2.41.2.tar.xz (36.1 MiB) + md5sum: 48692ef442caeb49f5c506bd953dece7 + sha1sum: 29b6b697248ad969c7e0b7341dc16e6ee38f275e + sha256sum: 52498b5653807c65b2b19302904053beed890df8efbcd6cc08e696e215bdf3ce ++ + + + +
This is the first stable release in the 2.42 series.
++wpewebkit-2.42.0.tar.xz (35.1 MiB) + md5sum: 8bc18620afafc5b5087d529cd47c0721 + sha1sum: 125333c9bf4efa85f780ad422f3fb9fc39d43636 + sha256sum: acda4be341c6021e092b36612c88d596dae4dd7f41e6ac47425d645dffdfe5ed ++ + + + +
This is the first bug fix release in the stable 2.42 series.
++wpewebkit-2.42.1.tar.xz (35.1 MiB) + md5sum: 82b6c35797d3e640ed3c5e354d030dea + sha1sum: 6cb97b1d261ca47185f49a3b016586b825a5c750 + sha256sum: 18a2cf547a503420f4cb8f523a2f4c24b4dc2773abbe74c7d585e6d23cb27bac ++ + + + +
This is a bug fix release in the stable 2.42 series.
+User-Agent header.+wpewebkit-2.42.2.tar.xz (30.9 MiB) + md5sum: 4cc2472bce41a376cc3b82b1d76834fa + sha1sum: 2de79928a1742076226470b821239db88aaaa9a1 + sha256sum: df99bbc7007df60d77821e4c169312464f145c8aa6e34398a43da36a857285e8 ++ + + + +
Date Reported: June 13, 2018
+Advisory ID: WSA-2018-0005
+CVE identifiers: CVE-2018-4190, CVE-2018-4192, +CVE-2018-4199, CVE-2018-4201, +CVE-2018-4214, CVE-2018-4218, +CVE-2018-4222, CVE-2018-4232, +CVE-2018-4233, CVE-2018-11646, +CVE-2018-11712, CVE-2018-11713, +CVE-2018-12293, CVE-2018-12294.
+Several vulnerabilities were discovered in WebKitGTK+ and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK+ and +WPE WebKit. It is the best way to ensure that you are running a safe +version of WebKit. Please check our websites for information about the +latest stable releases.
+Further information about WebKitGTK+ and WPE WebKit security advisories can be found at +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: August 07, 2018
+Advisory ID: WSA-2018-0006
+CVE identifiers: CVE-2018-4246, CVE-2018-4261, +CVE-2018-4262, CVE-2018-4263, +CVE-2018-4264, CVE-2018-4265, +CVE-2018-4266, CVE-2018-4267, +CVE-2018-4270, CVE-2018-4271, +CVE-2018-4272, CVE-2018-4273, +CVE-2018-4278, CVE-2018-4284, +CVE-2018-12911.
+Several vulnerabilities were discovered in WebKitGTK+ and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK+ and +WPE WebKit. It is the best way to ensure that you are running safe +versions of WebKit. Please check our websites for information about the +latest stable releases.
+Further information about WebKitGTK+ and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: September 26, 2018
+Advisory ID: WSA-2018-0007
+CVE identifiers: CVE-2018-4207, CVE-2018-4208, +CVE-2018-4209, CVE-2018-4210, +CVE-2018-4212, CVE-2018-4213, +CVE-2018-4191, CVE-2018-4197, +CVE-2018-4299, CVE-2018-4306, +CVE-2018-4309, CVE-2018-4311, +CVE-2018-4312, CVE-2018-4314, +CVE-2018-4315, CVE-2018-4316, +CVE-2018-4317, CVE-2018-4318, +CVE-2018-4319, CVE-2018-4323, +CVE-2018-4328, CVE-2018-4358, +CVE-2018-4359, CVE-2018-4361.
+Several vulnerabilities were discovered in WebKitGTK+ and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK+ and +WPE WebKit. It is the best way to ensure that you are running safe +versions of WebKit. Please check our websites for information about the +latest stable releases.
+Further information about WebKitGTK+ and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: November 21, 2018
+Advisory ID: WSA-2018-0008
+CVE identifiers: CVE-2018-4345, CVE-2018-4372, +CVE-2018-4373, CVE-2018-4375, +CVE-2018-4376, CVE-2018-4378, +CVE-2018-4382, CVE-2018-4386, +CVE-2018-4392, CVE-2018-4416.
+Several vulnerabilities were discovered in WebKitGTK+ and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK+ and +WPE WebKit. It is the best way to ensure that you are running safe +versions of WebKit. Please check our websites for information about the +latest stable releases.
+Further information about WebKitGTK+ and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: December 13, 2018
+Advisory ID: WSA-2018-0009
+CVE identifiers: CVE-2018-4437, CVE-2018-4438, +CVE-2018-4441, CVE-2018-4442, +CVE-2018-4443, CVE-2018-4464.
+Several vulnerabilities were discovered in WebKitGTK+ and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK+ and +WPE WebKit. It is the best way to ensure that you are running safe +versions of WebKit. Please check our websites for information about the +latest stable releases.
+Further information about WebKitGTK+ and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: February 08, 2019
+Advisory ID: WSA-2019-0001
+CVE identifiers: CVE-2019-6212, CVE-2019-6215, +CVE-2019-6216, CVE-2019-6217, +CVE-2019-6226, CVE-2019-6227, +CVE-2019-6229, CVE-2019-6233, +CVE-2019-6234.
+Several vulnerabilities were discovered in WebKitGTK+ and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK+ and +WPE WebKit. It is the best way to ensure that you are running safe +versions of WebKit. Please check our websites for information about the +latest stable releases.
+Further information about WebKitGTK+ and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: April 10, 2019
+Advisory ID: WSA-2019-0002
+CVE identifiers: CVE-2019-6201, CVE-2019-6251, +CVE-2019-7285, CVE-2019-7292, +CVE-2019-8503, CVE-2019-8506, +CVE-2019-8515, CVE-2019-8518, +CVE-2019-8523, CVE-2019-8524, +CVE-2019-8535, CVE-2019-8536, +CVE-2019-8544, CVE-2019-8551, +CVE-2019-8558, CVE-2019-8559, +CVE-2019-8563, CVE-2019-11070.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: May 20, 2019
+Advisory ID: WSA-2019-0003
+CVE identifiers: CVE-2019-6237, CVE-2019-8571, +CVE-2019-8583, CVE-2019-8584, +CVE-2019-8586, CVE-2019-8587, +CVE-2019-8594, CVE-2019-8595, +CVE-2019-8596, CVE-2019-8597, +CVE-2019-8601, CVE-2019-8607, +CVE-2019-8608, CVE-2019-8609, +CVE-2019-8610, CVE-2019-8615, +CVE-2019-8611, CVE-2019-8619, +CVE-2019-8622, CVE-2019-8623.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: August 29, 2019
+Advisory ID: WSA-2019-0004
+CVE identifiers: CVE-2019-8644, CVE-2019-8649, +CVE-2019-8658, CVE-2019-8666, +CVE-2019-8669, CVE-2019-8671, +CVE-2019-8672, CVE-2019-8673, +CVE-2019-8676, CVE-2019-8677, +CVE-2019-8678, CVE-2019-8679, +CVE-2019-8680, CVE-2019-8681, +CVE-2019-8683, CVE-2019-8684, +CVE-2019-8686, CVE-2019-8687, +CVE-2019-8688, CVE-2019-8689, +CVE-2019-8690.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: October 29, 2019
+Advisory ID: WSA-2019-0005
+CVE identifiers: CVE-2019-8625, CVE-2019-8674, +CVE-2019-8707, CVE-2019-8719, +CVE-2019-8720, CVE-2019-8726, +CVE-2019-8733, CVE-2019-8735, +CVE-2019-8763, CVE-2019-8768, +CVE-2019-8769, CVE-2019-8771.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: November 08, 2019
+Advisory ID: WSA-2019-0006
+CVE identifiers: CVE-2019-8710, CVE-2019-8743, +CVE-2019-8764, CVE-2019-8765, +CVE-2019-8766, CVE-2019-8782, +CVE-2019-8783, CVE-2019-8808, +CVE-2019-8811, CVE-2019-8812, +CVE-2019-8813, CVE-2019-8814, +CVE-2019-8815, CVE-2019-8816, +CVE-2019-8819, CVE-2019-8820, +CVE-2019-8821, CVE-2019-8822, +CVE-2019-8823.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: January 23, 2020
+Advisory ID: WSA-2020-0001
+CVE identifiers: CVE-2019-8835, CVE-2019-8844, +CVE-2019-8846.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: February 14, 2020
+Advisory ID: WSA-2020-0002
+CVE identifiers: CVE-2020-3862, CVE-2020-3864, +CVE-2020-3865, CVE-2020-3867, +CVE-2020-3868.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: March 12, 2020
+Advisory ID: WSA-2020-0003
+CVE identifiers: CVE-2020-10018.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: April 16, 2020
+Advisory ID: WSA-2020-0004
+CVE identifiers: CVE-2020-11793.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: April 27, 2020
+Advisory ID: WSA-2020-0005
+CVE identifiers: CVE-2020-3885, CVE-2020-3894, +CVE-2020-3895, CVE-2020-3897, +CVE-2020-3899, CVE-2020-3900, +CVE-2020-3901, CVE-2020-3902.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: July 10, 2020
+Advisory ID: WSA-2020-0006
+CVE identifiers: CVE-2020-9802, CVE-2020-9803, +CVE-2020-9805, CVE-2020-9806, +CVE-2020-9807, CVE-2020-9843, +CVE-2020-9850, CVE-2020-13753.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: July 29, 2020
+Advisory ID: WSA-2020-0007
+CVE identifiers: CVE-2020-9862, CVE-2020-9893, +CVE-2020-9894, CVE-2020-9895, +CVE-2020-9915, CVE-2020-9925.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: November 23, 2020
+Advisory ID: WSA-2020-0008
+CVE identifiers: CVE-2020-13584, CVE-2020-9948, +CVE-2020-9951, CVE-2020-9952, +CVE-2020-9983.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: November 30, 2020
+Advisory ID: WSA-2020-0009
+CVE identifiers: CVE-2020-13543.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: February 15, 2021
+Advisory ID: WSA-2021-0001
+CVE identifiers: CVE-2020-13558.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: March 22, 2021
+Advisory ID: WSA-2021-0002
+CVE identifiers: CVE-2020-27918, CVE-2020-29623, +CVE-2020-9947, CVE-2021-1765, +CVE-2021-1789, CVE-2021-1799, +CVE-2021-1801, CVE-2021-1870.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: March 29, 2021
+Advisory ID: WSA-2021-0003
+CVE identifiers: CVE-2021-1788, CVE-2021-1844, +CVE-2021-1871.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: July 23, 2021
+Advisory ID: WSA-2021-0004
+CVE identifiers: CVE-2021-1817, CVE-2021-1820, +CVE-2021-1825, CVE-2021-1826, +CVE-2021-21775, CVE-2021-21779, +CVE-2021-21806, CVE-2021-30661, +CVE-2021-30663, CVE-2021-30665, +CVE-2021-30666, CVE-2021-30682, +CVE-2021-30689, CVE-2021-30720, +CVE-2021-30734, CVE-2021-30744, +CVE-2021-30749, CVE-2021-30758, +CVE-2021-30761, CVE-2021-30762, +CVE-2021-30795, CVE-2021-30797, +CVE-2021-30799.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: September 20, 2021
+Advisory ID: WSA-2021-0005
+CVE identifiers: CVE-2021-30858.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: October 26, 2021
+Advisory ID: WSA-2021-0006
+CVE identifiers: CVE-2021-30846, CVE-2021-30848, +CVE-2021-30849, CVE-2021-30851, +CVE-2021-30858, CVE-2021-42762.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: December 20, 2021
+Advisory ID: WSA-2021-0007
+CVE identifiers: CVE-2021-30809, CVE-2021-30818, +CVE-2021-30823, CVE-2021-30836, +CVE-2021-30884, CVE-2021-30887, +CVE-2021-30888, CVE-2021-30889, +CVE-2021-30890, CVE-2021-30897.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: January 21, 2022
+Advisory ID: WSA-2022-0001
+CVE identifiers: CVE-2021-30934, CVE-2021-30936, +CVE-2021-30951, CVE-2021-30952, +CVE-2021-30953, CVE-2021-30954, +CVE-2021-30984, CVE-2022-22594, +CVE-2021-45481, CVE-2021-45482, +CVE-2021-45483.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: February 09, 2022
+Advisory ID: WSA-2022-0002
+CVE identifiers: CVE-2022-22589, CVE-2022-22590, +CVE-2022-22592.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: February 17, 2022
+Advisory ID: WSA-2022-0003
+CVE identifiers: CVE-2022-22620.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: April 08, 2022
+Advisory ID: WSA-2022-0004
+CVE identifiers: CVE-2022-22624, CVE-2022-22628, +CVE-2022-22629, CVE-2022-22637.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: May 30, 2022
+Advisory ID: WSA-2022-0005
+CVE identifiers: CVE-2022-26700, CVE-2022-26709, +CVE-2022-26717, CVE-2022-26716, +CVE-2022-26719, CVE-2022-30293, +CVE-2022-30294.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: July 05, 2022
+Advisory ID: WSA-2022-0006
+CVE identifiers: CVE-2022-22662, CVE-2022-22677, +CVE-2022-26710.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: July 28, 2022
+Advisory ID: WSA-2022-0007
+CVE identifiers: CVE-2022-32792, CVE-2022-32816, +CVE-2022-2294.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: August 25, 2022
+Advisory ID: WSA-2022-0008
+CVE identifiers: CVE-2022-32893.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: September 19, 2022
+Advisory ID: WSA-2022-0009
+CVE identifiers: CVE-2022-32886, CVE-2022-32891, +CVE-2022-32912.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: November 04, 2022
+Advisory ID: WSA-2022-0010
+CVE identifiers: CVE-2022-32888, CVE-2022-32923, +CVE-2022-42799, CVE-2022-42823, +CVE-2022-42824.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: December 26, 2022
+Advisory ID: WSA-2022-0011
+CVE identifiers: CVE-2022-42852, CVE-2022-42856, +CVE-2022-42863, CVE-2022-42867, +CVE-2022-46691, CVE-2022-46692, +CVE-2022-46698, CVE-2022-46699, +CVE-2022-46700.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: February 02, 2023
+Advisory ID: WSA-2023-0001
+CVE identifiers: CVE-2023-23517, CVE-2023-23518, +CVE-2022-42826.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: February 15, 2023
+Advisory ID: WSA-2023-0002
+CVE identifiers: CVE-2023-23529.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: April 21, 2023
+Advisory ID: WSA-2023-0003
+CVE identifiers: CVE-2023-25358, CVE-2022-0108, +CVE-2022-32885, CVE-2023-27932, +CVE-2023-27954, CVE-2023-28205.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: May 30, 2023
+Advisory ID: WSA-2023-0004
+CVE identifiers: CVE-2023-28204, CVE-2023-32373.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: June 29, 2023
+Advisory ID: WSA-2023-0005
+CVE identifiers: CVE-2022-48503, CVE-2023-32435, +CVE-2023-32439.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: July 21, 2023
+Advisory ID: WSA-2023-0006
+CVE identifiers: CVE-2023-37450, CVE-2023-32393.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: August 02, 2023
+Advisory ID: WSA-2023-0007
+CVE identifiers: CVE-2023-38133, CVE-2023-38572, +CVE-2023-38592, CVE-2023-38594, +CVE-2023-38595, CVE-2023-38597, +CVE-2023-38599, CVE-2023-38600, +CVE-2023-38611.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: September 11, 2023
+Advisory ID: WSA-2023-0008
+CVE identifiers: CVE-2023-28198, CVE-2023-32370, +CVE-2023-40397.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +Date Reported: September 28, 2023
+Advisory ID: WSA-2023-0009
+CVE identifiers: CVE-2023-39928, CVE-2023-35074, +CVE-2023-39434, CVE-2023-40451, +CVE-2023-41074, CVE-2023-41993.
+Several vulnerabilities were discovered in WebKitGTK and WPE WebKit.
+We recommend updating to the latest stable versions of WebKitGTK and WPE +WebKit. It is the best way to ensure that you are running safe versions +of WebKit. Please check our websites for information about the latest +stable releases.
+Further information about WebKitGTK and WPE WebKit security advisories can be found at: +https://webkitgtk.org/security.html or https://wpewebkit.org/security/.
+ + + + +The latest security advisory available.
+ +`s get reset. However, we also reset the\n// bottom margin to use `rem` units instead of `em`.\np {\n margin-top: 0;\n margin-bottom: $paragraph-margin-bottom;\n}\n\n// Abbreviations\n//\n// 1. Duplicate behavior to the data-* attribute for our tooltip plugin\n// 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.\n// 3. Add explicit cursor to indicate changed behavior.\n// 4. Remove the bottom border in Firefox 39-.\n// 5. Prevent the text-decoration to be skipped.\n\nabbr[title],\nabbr[data-original-title] { // 1\n text-decoration: underline; // 2\n text-decoration: underline dotted; // 2\n cursor: help; // 3\n border-bottom: 0; // 4\n text-decoration-skip-ink: none; // 5\n}\n\naddress {\n margin-bottom: 1rem;\n font-style: normal;\n line-height: inherit;\n}\n\nol,\nul,\ndl {\n margin-top: 0;\n margin-bottom: 1rem;\n}\n\nol ol,\nul ul,\nol ul,\nul ol {\n margin-bottom: 0;\n}\n\ndt {\n font-weight: $dt-font-weight;\n}\n\ndd {\n margin-bottom: .5rem;\n margin-left: 0; // Undo browser default\n}\n\nblockquote {\n margin: 0 0 1rem;\n}\n\nb,\nstrong {\n font-weight: $font-weight-bolder; // Add the correct font weight in Chrome, Edge, and Safari\n}\n\nsmall {\n @include font-size(80%); // Add the correct font size in all browsers\n}\n\n//\n// Prevent `sub` and `sup` elements from affecting the line height in\n// all browsers.\n//\n\nsub,\nsup {\n position: relative;\n @include font-size(75%);\n line-height: 0;\n vertical-align: baseline;\n}\n\nsub { bottom: -.25em; }\nsup { top: -.5em; }\n\n\n//\n// Links\n//\n\na {\n color: $link-color;\n text-decoration: $link-decoration;\n background-color: transparent; // Remove the gray background on active links in IE 10.\n\n @include hover() {\n color: $link-hover-color;\n text-decoration: $link-hover-decoration;\n }\n}\n\n// And undo these styles for placeholder links/named anchors (without href).\n// It would be more straightforward to just use a[href] in previous block, but that\n// causes specificity issues in many other styles that are too complex to fix.\n// See https://github.com/twbs/bootstrap/issues/19402\n\na:not([href]) {\n color: inherit;\n text-decoration: none;\n\n @include hover() {\n color: inherit;\n text-decoration: none;\n }\n}\n\n\n//\n// Code\n//\n\npre,\ncode,\nkbd,\nsamp {\n font-family: $font-family-monospace;\n @include font-size(1em); // Correct the odd `em` font sizing in all browsers.\n}\n\npre {\n // Remove browser default top margin\n margin-top: 0;\n // Reset browser default of `1em` to use `rem`s\n margin-bottom: 1rem;\n // Don't allow content to break outside\n overflow: auto;\n}\n\n\n//\n// Figures\n//\n\nfigure {\n // Apply a consistent margin strategy (matches our type styles).\n margin: 0 0 1rem;\n}\n\n\n//\n// Images and content\n//\n\nimg {\n vertical-align: middle;\n border-style: none; // Remove the border on images inside links in IE 10-.\n}\n\nsvg {\n // Workaround for the SVG overflow bug in IE10/11 is still required.\n // See https://github.com/twbs/bootstrap/issues/26878\n overflow: hidden;\n vertical-align: middle;\n}\n\n\n//\n// Tables\n//\n\ntable {\n border-collapse: collapse; // Prevent double borders\n}\n\ncaption {\n padding-top: $table-cell-padding;\n padding-bottom: $table-cell-padding;\n color: $table-caption-color;\n text-align: left;\n caption-side: bottom;\n}\n\nth {\n // Matches default `