diff --git a/COPYING b/COPYING new file mode 100644 --- /dev/null +++ b/COPYING @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/Graphics/UI/Gtk/WebKit/CacheModel.chs b/Graphics/UI/Gtk/WebKit/CacheModel.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/CacheModel.chs @@ -0,0 +1,94 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.CacheModel +-- Author : Andy Stewart +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Object used to communicate with the application when downloading +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.CacheModel ( +#if WEBKIT_CHECK_VERSION (1,1,18) +-- * Enums + CacheModel (..), + +-- * Methods + getCacheModel, + setCacheModel, +#endif +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.Attributes +import System.Glib.Properties +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import Graphics.UI.Gtk.WebKit.Signals#} +{#import Graphics.UI.Gtk.WebKit.Internal#} +{#import System.Glib.GObject#} +{#import Graphics.UI.Gtk.General.Selection#} ( TargetList ) +{#import Graphics.UI.Gtk.MenuComboToolbar.Menu#} +{#import Graphics.UI.Gtk.General.Enums#} + +{#context lib="webkit" prefix ="webkit"#} + +#if WEBKIT_CHECK_VERSION (1,1,18) +------------------ +-- Enums + +{#enum CacheModel {underscoreToCase}#} + +------------------ +-- Methods +-- | Returns the current cache model. For more information about this value check the documentation of +-- the function 'setCacheModel'. +-- +-- * Since 1.1.18 +getCacheModel :: IO CacheModel +getCacheModel = + liftM (toEnum . fromIntegral) $ + {#call webkit_get_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 +-- WebkitCacheModelWebBrowser. Applications without a browsing interface can reduce memory usage +-- substantially by specifying WebkitCacheModelDocumentViewer. Default value is +-- WebkitCacheModelWebBrowser. +-- +-- * Since 1.1.18 +setCacheModel :: CacheModel -> IO () +setCacheModel model = + {#call webkit_set_cache_model #} ((fromIntegral . fromEnum) model) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Attr.chs b/Graphics/UI/Gtk/WebKit/DOM/Attr.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Attr.chs @@ -0,0 +1,45 @@ +module Graphics.UI.Gtk.WebKit.DOM.Attr + (attrGetName, attrGetSpecified, attrSetValue, attrGetValue, + attrGetOwnerElement, attrGetIsId) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +attrGetName :: (DOMAttrClass self) => self -> IO String +attrGetName self + = ({# call webkit_dom_attr_get_name #} (toDOMAttr self)) >>= + readUTFString + +attrGetSpecified :: (DOMAttrClass self) => self -> IO Bool +attrGetSpecified self + = toBool <$> + ({# call webkit_dom_attr_get_specified #} (toDOMAttr self)) + +attrSetValue :: (DOMAttrClass self) => self -> String -> IO () +attrSetValue self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_attr_set_value #} (toDOMAttr self) valPtr + errorPtr_ + +attrGetValue :: (DOMAttrClass self) => self -> IO String +attrGetValue self + = ({# call webkit_dom_attr_get_value #} (toDOMAttr self)) >>= + readUTFString + +attrGetOwnerElement :: + (DOMAttrClass self) => self -> IO (Maybe Element) +attrGetOwnerElement self + = maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_attr_get_owner_element #} (toDOMAttr self)) + +attrGetIsId :: (DOMAttrClass self) => self -> IO Bool +attrGetIsId self + = toBool <$> + ({# call webkit_dom_attr_get_is_id #} (toDOMAttr self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/BarInfo.chs b/Graphics/UI/Gtk/WebKit/DOM/BarInfo.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/BarInfo.chs @@ -0,0 +1,12 @@ +module Graphics.UI.Gtk.WebKit.DOM.BarInfo (barInfoGetVisible) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +barInfoGetVisible :: (BarInfoClass self) => self -> IO Bool +barInfoGetVisible self + = toBool <$> + ({# call webkit_dom_bar_info_get_visible #} (toBarInfo self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Blob.chs b/Graphics/UI/Gtk/WebKit/DOM/Blob.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Blob.chs @@ -0,0 +1,12 @@ +module Graphics.UI.Gtk.WebKit.DOM.Blob (blobGetSize) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +blobGetSize :: (BlobClass self) => self -> IO Word64 +blobGetSize self + = fromIntegral <$> + ({# call webkit_dom_blob_get_size #} (toBlob self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSRule.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSRule.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSRule.chs @@ -0,0 +1,49 @@ +module Graphics.UI.Gtk.WebKit.DOM.CSSRule + (cUNKNOWN_RULE, cSTYLE_RULE, cCHARSET_RULE, cIMPORT_RULE, + cMEDIA_RULE, cFONT_FACE_RULE, cPAGE_RULE, cWEBKIT_KEYFRAMES_RULE, + cWEBKIT_KEYFRAME_RULE, cssRuleSetCssText, cssRuleGetCssText, + cssRuleGetParentStyleSheet, cssRuleGetParentRule) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM +cUNKNOWN_RULE = 0 +cSTYLE_RULE = 1 +cCHARSET_RULE = 2 +cIMPORT_RULE = 3 +cMEDIA_RULE = 4 +cFONT_FACE_RULE = 5 +cPAGE_RULE = 6 +cWEBKIT_KEYFRAMES_RULE = 7 +cWEBKIT_KEYFRAME_RULE = 8 + +cssRuleSetCssText :: (CSSRuleClass self) => self -> String -> IO () +cssRuleSetCssText self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_css_rule_set_css_text #} (toCSSRule self) valPtr + errorPtr_ + +cssRuleGetCssText :: (CSSRuleClass self) => self -> IO String +cssRuleGetCssText self + = ({# call webkit_dom_css_rule_get_css_text #} (toCSSRule self)) + >>= + readUTFString + +cssRuleGetParentStyleSheet :: + (CSSRuleClass self) => self -> IO (Maybe CSSStyleSheet) +cssRuleGetParentStyleSheet self + = maybeNull (makeNewGObject mkCSSStyleSheet) + ({# call webkit_dom_css_rule_get_parent_style_sheet #} + (toCSSRule self)) + +cssRuleGetParentRule :: + (CSSRuleClass self) => self -> IO (Maybe CSSRule) +cssRuleGetParentRule self + = maybeNull (makeNewGObject mkCSSRule) + ({# call webkit_dom_css_rule_get_parent_rule #} (toCSSRule self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSRuleList.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSRuleList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSRuleList.chs @@ -0,0 +1,21 @@ +module Graphics.UI.Gtk.WebKit.DOM.CSSRuleList + (cssRuleListItem, cssRuleListGetLength) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +cssRuleListItem :: + (CSSRuleListClass self) => self -> Word -> IO (Maybe CSSRule) +cssRuleListItem self index + = maybeNull (makeNewGObject mkCSSRule) + ({# call webkit_dom_css_rule_list_item #} (toCSSRuleList self) + (fromIntegral index)) + +cssRuleListGetLength :: (CSSRuleListClass self) => self -> IO Word +cssRuleListGetLength self + = fromIntegral <$> + ({# call webkit_dom_css_rule_list_get_length #} + (toCSSRuleList self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSStyleDeclaration.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSStyleDeclaration.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSStyleDeclaration.chs @@ -0,0 +1,149 @@ +module Graphics.UI.Gtk.WebKit.DOM.CSSStyleDeclaration + (cssStyleDeclarationGetPropertyValue, + cssStyleDeclarationGetPropertyCSSValue, + cssStyleDeclarationRemoveProperty, + cssStyleDeclarationGetPropertyPriority, + cssStyleDeclarationSetProperty, cssStyleDeclarationItem, + cssStyleDeclarationGetPropertyShorthand, + cssStyleDeclarationIsPropertyImplicit, + cssStyleDeclarationSetCssText, cssStyleDeclarationGetCssText, + cssStyleDeclarationGetLength, cssStyleDeclarationGetParentRule) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +cssStyleDeclarationGetPropertyValue :: + (CSSStyleDeclarationClass self) => self -> String -> IO String +cssStyleDeclarationGetPropertyValue self propertyName + = (withUTFString propertyName $ + \ propertyNamePtr -> + {# call webkit_dom_css_style_declaration_get_property_value #} + (toCSSStyleDeclaration self) + propertyNamePtr) + >>= + readUTFString + +cssStyleDeclarationGetPropertyCSSValue :: + (CSSStyleDeclarationClass self) => + self -> String -> IO (Maybe CSSValue) +cssStyleDeclarationGetPropertyCSSValue self propertyName + = maybeNull (makeNewGObject mkCSSValue) + (withUTFString propertyName $ + \ propertyNamePtr -> + {# call webkit_dom_css_style_declaration_get_property_css_value #} + (toCSSStyleDeclaration self) + propertyNamePtr) + +cssStyleDeclarationRemoveProperty :: + (CSSStyleDeclarationClass self) => self -> String -> IO String +cssStyleDeclarationRemoveProperty self propertyName + = (propagateGError $ + \ errorPtr_ -> + withUTFString propertyName $ + \ propertyNamePtr -> + {# call webkit_dom_css_style_declaration_remove_property #} + (toCSSStyleDeclaration self) + propertyNamePtr + errorPtr_) + >>= + readUTFString + +cssStyleDeclarationGetPropertyPriority :: + (CSSStyleDeclarationClass self) => + self -> String -> IO String +cssStyleDeclarationGetPropertyPriority self propertyName + = (withUTFString propertyName $ + \ propertyNamePtr -> + {# call webkit_dom_css_style_declaration_get_property_priority #} + (toCSSStyleDeclaration self) + propertyNamePtr) + >>= + readUTFString + +cssStyleDeclarationSetProperty :: + (CSSStyleDeclarationClass self) => + self -> String -> String -> String -> IO () +cssStyleDeclarationSetProperty self propertyName value priority + = propagateGError $ + \ errorPtr_ -> + withUTFString priority $ + \ priorityPtr -> + withUTFString value $ + \ valuePtr -> + withUTFString propertyName $ + \ propertyNamePtr -> + {# call webkit_dom_css_style_declaration_set_property #} + (toCSSStyleDeclaration self) + propertyNamePtr + valuePtr + priorityPtr + errorPtr_ + +cssStyleDeclarationItem :: + (CSSStyleDeclarationClass self) => self -> Word -> IO String +cssStyleDeclarationItem self index + = ({# call webkit_dom_css_style_declaration_item #} + (toCSSStyleDeclaration self) + (fromIntegral index)) + >>= + readUTFString + +cssStyleDeclarationGetPropertyShorthand :: + (CSSStyleDeclarationClass self) => + self -> String -> IO String +cssStyleDeclarationGetPropertyShorthand self propertyName + = (withUTFString propertyName $ + \ propertyNamePtr -> + {# call webkit_dom_css_style_declaration_get_property_shorthand #} + (toCSSStyleDeclaration self) + propertyNamePtr) + >>= + readUTFString + +cssStyleDeclarationIsPropertyImplicit :: + (CSSStyleDeclarationClass self) => self -> String -> IO Bool +cssStyleDeclarationIsPropertyImplicit self propertyName + = toBool <$> + (withUTFString propertyName $ + \ propertyNamePtr -> + {# call webkit_dom_css_style_declaration_is_property_implicit #} + (toCSSStyleDeclaration self) + propertyNamePtr) + +cssStyleDeclarationSetCssText :: + (CSSStyleDeclarationClass self) => self -> String -> IO () +cssStyleDeclarationSetCssText self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_css_style_declaration_set_css_text #} + (toCSSStyleDeclaration self) + valPtr + errorPtr_ + +cssStyleDeclarationGetCssText :: + (CSSStyleDeclarationClass self) => self -> IO String +cssStyleDeclarationGetCssText self + = ({# call webkit_dom_css_style_declaration_get_css_text #} + (toCSSStyleDeclaration self)) + >>= + readUTFString + +cssStyleDeclarationGetLength :: + (CSSStyleDeclarationClass self) => self -> IO Word +cssStyleDeclarationGetLength self + = fromIntegral <$> + ({# call webkit_dom_css_style_declaration_get_length #} + (toCSSStyleDeclaration self)) + +cssStyleDeclarationGetParentRule :: + (CSSStyleDeclarationClass self) => self -> IO (Maybe CSSRule) +cssStyleDeclarationGetParentRule self + = maybeNull (makeNewGObject mkCSSRule) + ({# call webkit_dom_css_style_declaration_get_parent_rule #} + (toCSSStyleDeclaration self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSStyleSheet.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSStyleSheet.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSStyleSheet.chs @@ -0,0 +1,85 @@ +module Graphics.UI.Gtk.WebKit.DOM.CSSStyleSheet + (cssStyleSheetInsertRule, cssStyleSheetDeleteRule, + cssStyleSheetAddRule, cssStyleSheetRemoveRule, + cssStyleSheetGetOwnerRule, cssStyleSheetGetCssRules, + cssStyleSheetGetRules) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +cssStyleSheetInsertRule :: + (CSSStyleSheetClass self) => self -> String -> Word -> IO Word +cssStyleSheetInsertRule self rule index + = fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString rule $ + \ rulePtr -> + {# call webkit_dom_css_style_sheet_insert_rule #} + (toCSSStyleSheet self) + rulePtr + (fromIntegral index) + errorPtr_) + +cssStyleSheetDeleteRule :: + (CSSStyleSheetClass self) => self -> Word -> IO () +cssStyleSheetDeleteRule self index + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_css_style_sheet_delete_rule #} + (toCSSStyleSheet self) + (fromIntegral index) + errorPtr_ + +cssStyleSheetAddRule :: + (CSSStyleSheetClass self) => + self -> String -> String -> Word -> IO Int +cssStyleSheetAddRule self selector style index + = fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString style $ + \ stylePtr -> + withUTFString selector $ + \ selectorPtr -> + {# call webkit_dom_css_style_sheet_add_rule #} + (toCSSStyleSheet self) + selectorPtr + stylePtr + (fromIntegral index) + errorPtr_) + +cssStyleSheetRemoveRule :: + (CSSStyleSheetClass self) => self -> Word -> IO () +cssStyleSheetRemoveRule self index + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_css_style_sheet_remove_rule #} + (toCSSStyleSheet self) + (fromIntegral index) + errorPtr_ + +cssStyleSheetGetOwnerRule :: + (CSSStyleSheetClass self) => self -> IO (Maybe CSSRule) +cssStyleSheetGetOwnerRule self + = maybeNull (makeNewGObject mkCSSRule) + ({# call webkit_dom_css_style_sheet_get_owner_rule #} + (toCSSStyleSheet self)) + +cssStyleSheetGetCssRules :: + (CSSStyleSheetClass self) => self -> IO (Maybe CSSRuleList) +cssStyleSheetGetCssRules self + = maybeNull (makeNewGObject mkCSSRuleList) + ({# call webkit_dom_css_style_sheet_get_css_rules #} + (toCSSStyleSheet self)) + +cssStyleSheetGetRules :: + (CSSStyleSheetClass self) => self -> IO (Maybe CSSRuleList) +cssStyleSheetGetRules self + = maybeNull (makeNewGObject mkCSSRuleList) + ({# call webkit_dom_css_style_sheet_get_rules #} + (toCSSStyleSheet self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSValue.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSValue.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSValue.chs @@ -0,0 +1,37 @@ +module Graphics.UI.Gtk.WebKit.DOM.CSSValue + (cCSS_INHERIT, cCSS_PRIMITIVE_VALUE, cCSS_VALUE_LIST, cCSS_CUSTOM, + cssValueSetCssText, cssValueGetCssText, cssValueGetCssValueType) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM +cCSS_INHERIT = 0 +cCSS_PRIMITIVE_VALUE = 1 +cCSS_VALUE_LIST = 2 +cCSS_CUSTOM = 3 + +cssValueSetCssText :: + (CSSValueClass self) => self -> String -> IO () +cssValueSetCssText self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_css_value_set_css_text #} (toCSSValue self) + valPtr + errorPtr_ + +cssValueGetCssText :: (CSSValueClass self) => self -> IO String +cssValueGetCssText self + = ({# call webkit_dom_css_value_get_css_text #} (toCSSValue self)) + >>= + readUTFString + +cssValueGetCssValueType :: (CSSValueClass self) => self -> IO Word +cssValueGetCssValueType self + = fromIntegral <$> + ({# call webkit_dom_css_value_get_css_value_type #} + (toCSSValue self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CharacterData.chs b/Graphics/UI/Gtk/WebKit/DOM/CharacterData.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CharacterData.chs @@ -0,0 +1,103 @@ +module Graphics.UI.Gtk.WebKit.DOM.CharacterData + (characterDataSubstringData, characterDataAppendData, + characterDataInsertData, characterDataDeleteData, + characterDataReplaceData, characterDataSetData, + characterDataGetData, characterDataGetLength) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +characterDataSubstringData :: + (CharacterDataClass self) => self -> Word -> Word -> IO String +characterDataSubstringData self offset length + = (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_character_data_substring_data #} + (toCharacterData self) + (fromIntegral offset) + (fromIntegral length) + errorPtr_) + >>= + readUTFString + +characterDataAppendData :: + (CharacterDataClass self) => self -> String -> IO () +characterDataAppendData self data' + = propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_character_data_append_data #} + (toCharacterData self) + dataPtr + errorPtr_ + +characterDataInsertData :: + (CharacterDataClass self) => self -> Word -> String -> IO () +characterDataInsertData self offset data' + = propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_character_data_insert_data #} + (toCharacterData self) + (fromIntegral offset) + dataPtr + errorPtr_ + +characterDataDeleteData :: + (CharacterDataClass self) => self -> Word -> Word -> IO () +characterDataDeleteData self offset length + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_character_data_delete_data #} + (toCharacterData self) + (fromIntegral offset) + (fromIntegral length) + errorPtr_ + +characterDataReplaceData :: + (CharacterDataClass self) => + self -> Word -> Word -> String -> IO () +characterDataReplaceData self offset length data' + = propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_character_data_replace_data #} + (toCharacterData self) + (fromIntegral offset) + (fromIntegral length) + dataPtr + errorPtr_ + +characterDataSetData :: + (CharacterDataClass self) => self -> String -> IO () +characterDataSetData self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_character_data_set_data #} + (toCharacterData self) + valPtr + errorPtr_ + +characterDataGetData :: + (CharacterDataClass self) => self -> IO String +characterDataGetData self + = ({# call webkit_dom_character_data_get_data #} + (toCharacterData self)) + >>= + readUTFString + +characterDataGetLength :: + (CharacterDataClass self) => self -> IO Word +characterDataGetLength self + = fromIntegral <$> + ({# call webkit_dom_character_data_get_length #} + (toCharacterData self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Console.chs b/Graphics/UI/Gtk/WebKit/DOM/Console.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Console.chs @@ -0,0 +1,24 @@ +module Graphics.UI.Gtk.WebKit.DOM.Console + (consoleTime, consoleGroupEnd, consoleGetMemory) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +consoleTime :: (ConsoleClass self) => self -> String -> IO () +consoleTime self title + = withUTFString title $ + \ titlePtr -> + {# call webkit_dom_console_time #} (toConsole self) titlePtr + +consoleGroupEnd :: (ConsoleClass self) => self -> IO () +consoleGroupEnd self + = {# call webkit_dom_console_group_end #} (toConsole self) + +consoleGetMemory :: + (ConsoleClass self) => self -> IO (Maybe MemoryInfo) +consoleGetMemory self + = maybeNull (makeNewGObject mkMemoryInfo) + ({# call webkit_dom_console_get_memory #} (toConsole self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Css.chs b/Graphics/UI/Gtk/WebKit/DOM/Css.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Css.chs @@ -0,0 +1,7 @@ +module Graphics.UI.Gtk.WebKit.DOM.Css (CSSRule, CSSRuleClass) where + +data CSSRule = CSSRule + +class CSSRuleClass a + +instance CSSRuleClass CSSRule diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMApplicationCache.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMApplicationCache.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMApplicationCache.chs @@ -0,0 +1,105 @@ +module Graphics.UI.Gtk.WebKit.DOM.DOMApplicationCache + (domApplicationCacheUpdate, domApplicationCacheSwapCache, + domApplicationCacheAbort, domApplicationCacheDispatchEvent, + cUNCACHED, cIDLE, cCHECKING, cDOWNLOADING, cUPDATEREADY, cOBSOLETE, + domApplicationCacheGetStatus, domApplicationCacheOnchecking, + domApplicationCacheOnerror, domApplicationCacheOnnoupdate, + domApplicationCacheOndownloading, domApplicationCacheOnprogress, + domApplicationCacheOnupdateready, domApplicationCacheOncached, + domApplicationCacheOnobsolete) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +domApplicationCacheUpdate :: + (DOMApplicationCacheClass self) => self -> IO () +domApplicationCacheUpdate self + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_application_cache_update #} + (toDOMApplicationCache self) + errorPtr_ + +domApplicationCacheSwapCache :: + (DOMApplicationCacheClass self) => self -> IO () +domApplicationCacheSwapCache self + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_application_cache_swap_cache #} + (toDOMApplicationCache self) + errorPtr_ + +domApplicationCacheAbort :: + (DOMApplicationCacheClass self) => self -> IO () +domApplicationCacheAbort self + = {# call webkit_dom_dom_application_cache_abort #} + (toDOMApplicationCache self) + +domApplicationCacheDispatchEvent :: + (DOMApplicationCacheClass self, EventClass evt) => + self -> Maybe evt -> IO Bool +domApplicationCacheDispatchEvent self evt + = toBool <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_application_cache_dispatch_event #} + (toDOMApplicationCache self) + (maybe (Event nullForeignPtr) toEvent evt) + errorPtr_) +cUNCACHED = 0 +cIDLE = 1 +cCHECKING = 2 +cDOWNLOADING = 3 +cUPDATEREADY = 4 +cOBSOLETE = 5 + +domApplicationCacheGetStatus :: + (DOMApplicationCacheClass self) => self -> IO Word +domApplicationCacheGetStatus self + = fromIntegral <$> + ({# call webkit_dom_dom_application_cache_get_status #} + (toDOMApplicationCache self)) + +domApplicationCacheOnchecking :: + (DOMApplicationCacheClass self) => + Signal self (EventM UIEvent self ()) +domApplicationCacheOnchecking = (connect "checking") + +domApplicationCacheOnerror :: + (DOMApplicationCacheClass self) => + Signal self (EventM UIEvent self ()) +domApplicationCacheOnerror = (connect "error") + +domApplicationCacheOnnoupdate :: + (DOMApplicationCacheClass self) => + Signal self (EventM UIEvent self ()) +domApplicationCacheOnnoupdate = (connect "noupdate") + +domApplicationCacheOndownloading :: + (DOMApplicationCacheClass self) => + Signal self (EventM UIEvent self ()) +domApplicationCacheOndownloading = (connect "downloading") + +domApplicationCacheOnprogress :: + (DOMApplicationCacheClass self) => + Signal self (EventM UIEvent self ()) +domApplicationCacheOnprogress = (connect "progress") + +domApplicationCacheOnupdateready :: + (DOMApplicationCacheClass self) => + Signal self (EventM UIEvent self ()) +domApplicationCacheOnupdateready = (connect "updateready") + +domApplicationCacheOncached :: + (DOMApplicationCacheClass self) => + Signal self (EventM UIEvent self ()) +domApplicationCacheOncached = (connect "cached") + +domApplicationCacheOnobsolete :: + (DOMApplicationCacheClass self) => + Signal self (EventM UIEvent self ()) +domApplicationCacheOnobsolete = (connect "obsolete") diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMImplementation.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMImplementation.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMImplementation.chs @@ -0,0 +1,94 @@ +module Graphics.UI.Gtk.WebKit.DOM.DOMImplementation + (domImplementationHasFeature, domImplementationCreateDocumentType, + domImplementationCreateDocument, + domImplementationCreateCSSStyleSheet, + domImplementationCreateHTMLDocument) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +domImplementationHasFeature :: + (DOMImplementationClass self) => + self -> String -> String -> IO Bool +domImplementationHasFeature self feature version + = toBool <$> + (withUTFString version $ + \ versionPtr -> + withUTFString feature $ + \ featurePtr -> + {# call webkit_dom_dom_implementation_has_feature #} + (toDOMImplementation self) + featurePtr + versionPtr) + +domImplementationCreateDocumentType :: + (DOMImplementationClass self) => + self -> String -> String -> String -> IO (Maybe DocumentType) +domImplementationCreateDocumentType self qualifiedName publicId + systemId + = maybeNull (makeNewGObject mkDocumentType) + (propagateGError $ + \ errorPtr_ -> + withUTFString systemId $ + \ systemIdPtr -> + withUTFString publicId $ + \ publicIdPtr -> + withUTFString qualifiedName $ + \ qualifiedNamePtr -> + {# call webkit_dom_dom_implementation_create_document_type #} + (toDOMImplementation self) + qualifiedNamePtr + publicIdPtr + systemIdPtr + errorPtr_) + +domImplementationCreateDocument :: + (DOMImplementationClass self, DocumentTypeClass doctype) => + self -> String -> String -> Maybe doctype -> IO (Maybe Document) +domImplementationCreateDocument self namespaceURI qualifiedName + doctype + = maybeNull (makeNewGObject mkDocument) + (propagateGError $ + \ errorPtr_ -> + withUTFString qualifiedName $ + \ qualifiedNamePtr -> + withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_dom_implementation_create_document #} + (toDOMImplementation self) + namespaceURIPtr + qualifiedNamePtr + (maybe (DocumentType nullForeignPtr) toDocumentType doctype) + errorPtr_) + +domImplementationCreateCSSStyleSheet :: + (DOMImplementationClass self) => + self -> String -> String -> IO (Maybe CSSStyleSheet) +domImplementationCreateCSSStyleSheet self title media + = maybeNull (makeNewGObject mkCSSStyleSheet) + (propagateGError $ + \ errorPtr_ -> + withUTFString media $ + \ mediaPtr -> + withUTFString title $ + \ titlePtr -> + {# call webkit_dom_dom_implementation_create_css_style_sheet #} + (toDOMImplementation self) + titlePtr + mediaPtr + errorPtr_) + +domImplementationCreateHTMLDocument :: + (DOMImplementationClass self) => + self -> String -> IO (Maybe HTMLDocument) +domImplementationCreateHTMLDocument self title + = maybeNull (makeNewGObject mkHTMLDocument) + (withUTFString title $ + \ titlePtr -> + {# call webkit_dom_dom_implementation_create_html_document #} + (toDOMImplementation self) + titlePtr) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMMimeType.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMMimeType.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMMimeType.chs @@ -0,0 +1,33 @@ +module Graphics.UI.Gtk.WebKit.DOM.DOMMimeType + (domMimeTypeGetSuffixes, domMimeTypeGetDescription, + domMimeTypeGetEnabledPlugin) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +domMimeTypeGetSuffixes :: + (DOMMimeTypeClass self) => self -> IO String +domMimeTypeGetSuffixes self + = ({# call webkit_dom_dom_mime_type_get_suffixes #} + (toDOMMimeType self)) + >>= + readUTFString + +domMimeTypeGetDescription :: + (DOMMimeTypeClass self) => self -> IO String +domMimeTypeGetDescription self + = ({# call webkit_dom_dom_mime_type_get_description #} + (toDOMMimeType self)) + >>= + readUTFString + +domMimeTypeGetEnabledPlugin :: + (DOMMimeTypeClass self) => self -> IO (Maybe DOMPlugin) +domMimeTypeGetEnabledPlugin self + = maybeNull (makeNewGObject mkDOMPlugin) + ({# call webkit_dom_dom_mime_type_get_enabled_plugin #} + (toDOMMimeType self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMMimeTypeArray.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMMimeTypeArray.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMMimeTypeArray.chs @@ -0,0 +1,37 @@ +module Graphics.UI.Gtk.WebKit.DOM.DOMMimeTypeArray + (domMimeTypeArrayItem, domMimeTypeArrayNamedItem, + domMimeTypeArrayGetLength) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +domMimeTypeArrayItem :: + (DOMMimeTypeArrayClass self) => + self -> Word -> IO (Maybe DOMMimeType) +domMimeTypeArrayItem self index + = maybeNull (makeNewGObject mkDOMMimeType) + ({# call webkit_dom_dom_mime_type_array_item #} + (toDOMMimeTypeArray self) + (fromIntegral index)) + +domMimeTypeArrayNamedItem :: + (DOMMimeTypeArrayClass self) => + self -> String -> IO (Maybe DOMMimeType) +domMimeTypeArrayNamedItem self name + = maybeNull (makeNewGObject mkDOMMimeType) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_dom_mime_type_array_named_item #} + (toDOMMimeTypeArray self) + namePtr) + +domMimeTypeArrayGetLength :: + (DOMMimeTypeArrayClass self) => self -> IO Word +domMimeTypeArrayGetLength self + = fromIntegral <$> + ({# call webkit_dom_dom_mime_type_array_get_length #} + (toDOMMimeTypeArray self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMPlugin.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMPlugin.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMPlugin.chs @@ -0,0 +1,52 @@ +module Graphics.UI.Gtk.WebKit.DOM.DOMPlugin + (domPluginItem, domPluginNamedItem, domPluginGetName, + domPluginGetFilename, domPluginGetDescription, domPluginGetLength) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +domPluginItem :: + (DOMPluginClass self) => self -> Word -> IO (Maybe DOMMimeType) +domPluginItem self index + = maybeNull (makeNewGObject mkDOMMimeType) + ({# call webkit_dom_dom_plugin_item #} (toDOMPlugin self) + (fromIntegral index)) + +domPluginNamedItem :: + (DOMPluginClass self) => self -> String -> IO (Maybe DOMMimeType) +domPluginNamedItem self name + = maybeNull (makeNewGObject mkDOMMimeType) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_dom_plugin_named_item #} (toDOMPlugin self) + namePtr) + +domPluginGetName :: (DOMPluginClass self) => self -> IO String +domPluginGetName self + = ({# call webkit_dom_dom_plugin_get_name #} (toDOMPlugin self)) + >>= + readUTFString + +domPluginGetFilename :: (DOMPluginClass self) => self -> IO String +domPluginGetFilename self + = ({# call webkit_dom_dom_plugin_get_filename #} + (toDOMPlugin self)) + >>= + readUTFString + +domPluginGetDescription :: + (DOMPluginClass self) => self -> IO String +domPluginGetDescription self + = ({# call webkit_dom_dom_plugin_get_description #} + (toDOMPlugin self)) + >>= + readUTFString + +domPluginGetLength :: (DOMPluginClass self) => self -> IO Word +domPluginGetLength self + = fromIntegral <$> + ({# call webkit_dom_dom_plugin_get_length #} (toDOMPlugin self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMPluginArray.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMPluginArray.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMPluginArray.chs @@ -0,0 +1,43 @@ +module Graphics.UI.Gtk.WebKit.DOM.DOMPluginArray + (domPluginArrayItem, domPluginArrayNamedItem, + domPluginArrayRefresh, domPluginArrayGetLength) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +domPluginArrayItem :: + (DOMPluginArrayClass self) => self -> Word -> IO (Maybe DOMPlugin) +domPluginArrayItem self index + = maybeNull (makeNewGObject mkDOMPlugin) + ({# call webkit_dom_dom_plugin_array_item #} + (toDOMPluginArray self) + (fromIntegral index)) + +domPluginArrayNamedItem :: + (DOMPluginArrayClass self) => + self -> String -> IO (Maybe DOMPlugin) +domPluginArrayNamedItem self name + = maybeNull (makeNewGObject mkDOMPlugin) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_dom_plugin_array_named_item #} + (toDOMPluginArray self) + namePtr) + +domPluginArrayRefresh :: + (DOMPluginArrayClass self) => self -> Bool -> IO () +domPluginArrayRefresh self reload + = {# call webkit_dom_dom_plugin_array_refresh #} + (toDOMPluginArray self) + (fromBool reload) + +domPluginArrayGetLength :: + (DOMPluginArrayClass self) => self -> IO Word +domPluginArrayGetLength self + = fromIntegral <$> + ({# call webkit_dom_dom_plugin_array_get_length #} + (toDOMPluginArray self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMSecurityPolicy.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMSecurityPolicy.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMSecurityPolicy.chs @@ -0,0 +1,164 @@ +module Graphics.UI.Gtk.WebKit.DOM.DOMSecurityPolicy ( +#if WEBKIT_CHECK_VERSION(1,10,0) +#if !WEBKIT_CHECK_VERSION(2,0,0) + domSecurityPolicyIsActive, +#endif + domSecurityPolicyAllowsConnectionTo, + domSecurityPolicyAllowsFontFrom, domSecurityPolicyAllowsFormAction, + domSecurityPolicyAllowsFrameFrom, domSecurityPolicyAllowsImageFrom, + domSecurityPolicyAllowsMediaFrom, + domSecurityPolicyAllowsObjectFrom, + domSecurityPolicyAllowsPluginType, + domSecurityPolicyAllowsScriptFrom, + domSecurityPolicyAllowsStyleFrom, domSecurityPolicyAllowsEval, + domSecurityPolicyAllowsInlineScript, + domSecurityPolicyAllowsInlineStyle, domSecurityPolicyGetReportURIs +#endif +) where + +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +#if WEBKIT_CHECK_VERSION(1,10,0) +#if !WEBKIT_CHECK_VERSION(2,0,0) +domSecurityPolicyIsActive :: (DOMSecurityPolicyClass self) => self -> IO Bool +domSecurityPolicyIsActive self = toBool <$> + ({# call webkit_dom_dom_security_policy_is_active #} (toDOMSecurityPolicy self)) +#endif + +domSecurityPolicyAllowsConnectionTo :: (DOMSecurityPolicyClass self) => self -> String -> IO Bool +domSecurityPolicyAllowsConnectionTo self url = toBool <$> + (withUTFString url $ \urlPtr -> + {# call webkit_dom_dom_security_policy_allows_connection_to #} (toDOMSecurityPolicy self) urlPtr) + +domSecurityPolicyAllowsFontFrom :: + (DOMSecurityPolicyClass self) => self -> String -> IO Bool +domSecurityPolicyAllowsFontFrom self url + = toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_font_from #} + (toDOMSecurityPolicy self) + urlPtr) + +domSecurityPolicyAllowsFormAction :: + (DOMSecurityPolicyClass self) => self -> String -> IO Bool +domSecurityPolicyAllowsFormAction self url + = toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_form_action #} + (toDOMSecurityPolicy self) + urlPtr) + +domSecurityPolicyAllowsFrameFrom :: + (DOMSecurityPolicyClass self) => self -> String -> IO Bool +domSecurityPolicyAllowsFrameFrom self url + = toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_frame_from #} + (toDOMSecurityPolicy self) + urlPtr) + +domSecurityPolicyAllowsImageFrom :: + (DOMSecurityPolicyClass self) => self -> String -> IO Bool +domSecurityPolicyAllowsImageFrom self url + = toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_image_from #} + (toDOMSecurityPolicy self) + urlPtr) + +domSecurityPolicyAllowsMediaFrom :: + (DOMSecurityPolicyClass self) => self -> String -> IO Bool +domSecurityPolicyAllowsMediaFrom self url + = toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_media_from #} + (toDOMSecurityPolicy self) + urlPtr) + +domSecurityPolicyAllowsObjectFrom :: + (DOMSecurityPolicyClass self) => self -> String -> IO Bool +domSecurityPolicyAllowsObjectFrom self url + = toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_object_from #} + (toDOMSecurityPolicy self) + urlPtr) + +domSecurityPolicyAllowsPluginType :: + (DOMSecurityPolicyClass self) => self -> String -> IO Bool +domSecurityPolicyAllowsPluginType self type' + = toBool <$> + (withUTFString type' $ + \ typePtr -> + {# call webkit_dom_dom_security_policy_allows_plugin_type #} + (toDOMSecurityPolicy self) + typePtr) + +domSecurityPolicyAllowsScriptFrom :: + (DOMSecurityPolicyClass self) => self -> String -> IO Bool +domSecurityPolicyAllowsScriptFrom self url + = toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_script_from #} + (toDOMSecurityPolicy self) + urlPtr) + +domSecurityPolicyAllowsStyleFrom :: + (DOMSecurityPolicyClass self) => self -> String -> IO Bool +domSecurityPolicyAllowsStyleFrom self url + = toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_style_from #} + (toDOMSecurityPolicy self) + urlPtr) + + +domSecurityPolicyAllowsEval :: (DOMSecurityPolicyClass self) => self -> IO Bool +domSecurityPolicyAllowsEval self = toBool <$> +#if WEBKIT_CHECK_VERSION(2,0,0) + ({# call webkit_dom_dom_security_policy_get_allows_eval #} +#else + ({# call webkit_dom_dom_security_policy_allows_eval #} +#endif + (toDOMSecurityPolicy self)) + + +domSecurityPolicyAllowsInlineScript :: (DOMSecurityPolicyClass self) => self -> IO Bool +domSecurityPolicyAllowsInlineScript self = toBool <$> +#if WEBKIT_CHECK_VERSION(2,0,0) + ({# call webkit_dom_dom_security_policy_get_allows_inline_script #} +#else + ({# call webkit_dom_dom_security_policy_allows_inline_script #} +#endif + (toDOMSecurityPolicy self)) + + +domSecurityPolicyAllowsInlineStyle :: (DOMSecurityPolicyClass self) => self -> IO Bool +domSecurityPolicyAllowsInlineStyle self = toBool <$> +#if WEBKIT_CHECK_VERSION(2,0,0) + ({# call webkit_dom_dom_security_policy_get_allows_inline_style #} +#else + ({# call webkit_dom_dom_security_policy_allows_inline_style #} +#endif + (toDOMSecurityPolicy self)) + +domSecurityPolicyGetReportURIs :: + (DOMSecurityPolicyClass self) => self -> IO (Maybe DOMStringList) +domSecurityPolicyGetReportURIs self + = maybeNull (makeNewGObject mkDOMStringList) + ({# call webkit_dom_dom_security_policy_get_report_ur_is #} + (toDOMSecurityPolicy self)) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMSelection.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMSelection.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMSelection.chs @@ -0,0 +1,229 @@ +module Graphics.UI.Gtk.WebKit.DOM.DOMSelection + (domSelectionCollapse, domSelectionCollapseToEnd, + domSelectionCollapseToStart, domSelectionDeleteFromDocument, + domSelectionContainsNode, domSelectionSelectAllChildren, + domSelectionExtend, domSelectionGetRangeAt, + domSelectionRemoveAllRanges, domSelectionAddRange, + domSelectionModify, domSelectionSetBaseAndExtent, + domSelectionSetPosition, domSelectionEmpty, + domSelectionGetAnchorNode, domSelectionGetAnchorOffset, + domSelectionGetFocusNode, domSelectionGetFocusOffset, + domSelectionGetIsCollapsed, domSelectionGetRangeCount, + domSelectionGetBaseNode, domSelectionGetBaseOffset, + domSelectionGetExtentNode, domSelectionGetExtentOffset) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +domSelectionCollapse :: + (DOMSelectionClass self, NodeClass node) => + self -> Maybe node -> Int -> IO () +domSelectionCollapse self node index + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_collapse #} (toDOMSelection self) + (maybe (Node nullForeignPtr) toNode node) + (fromIntegral index) + errorPtr_ + +domSelectionCollapseToEnd :: + (DOMSelectionClass self) => self -> IO () +domSelectionCollapseToEnd self + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_collapse_to_end #} + (toDOMSelection self) + errorPtr_ + +domSelectionCollapseToStart :: + (DOMSelectionClass self) => self -> IO () +domSelectionCollapseToStart self + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_collapse_to_start #} + (toDOMSelection self) + errorPtr_ + +domSelectionDeleteFromDocument :: + (DOMSelectionClass self) => self -> IO () +domSelectionDeleteFromDocument self + = {# call webkit_dom_dom_selection_delete_from_document #} + (toDOMSelection self) + +domSelectionContainsNode :: + (DOMSelectionClass self, NodeClass node) => + self -> Maybe node -> Bool -> IO Bool +domSelectionContainsNode self node allowPartial + = toBool <$> + ({# call webkit_dom_dom_selection_contains_node #} + (toDOMSelection self) + (maybe (Node nullForeignPtr) toNode node) + (fromBool allowPartial)) + +domSelectionSelectAllChildren :: + (DOMSelectionClass self, NodeClass node) => + self -> Maybe node -> IO () +domSelectionSelectAllChildren self node + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_select_all_children #} + (toDOMSelection self) + (maybe (Node nullForeignPtr) toNode node) + errorPtr_ + +domSelectionExtend :: + (DOMSelectionClass self, NodeClass node) => + self -> Maybe node -> Int -> IO () +domSelectionExtend self node offset + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_extend #} (toDOMSelection self) + (maybe (Node nullForeignPtr) toNode node) + (fromIntegral offset) + errorPtr_ + +domSelectionGetRangeAt :: + (DOMSelectionClass self) => self -> Int -> IO (Maybe DOMRange) +domSelectionGetRangeAt self index + = maybeNull (makeNewGObject mkDOMRange) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_get_range_at #} + (toDOMSelection self) + (fromIntegral index) + errorPtr_) + +domSelectionRemoveAllRanges :: + (DOMSelectionClass self) => self -> IO () +domSelectionRemoveAllRanges self + = {# call webkit_dom_dom_selection_remove_all_ranges #} + (toDOMSelection self) + +domSelectionAddRange :: + (DOMSelectionClass self, DOMRangeClass range) => + self -> Maybe range -> IO () +domSelectionAddRange self range + = {# call webkit_dom_dom_selection_add_range #} + (toDOMSelection self) + (maybe (DOMRange nullForeignPtr) toDOMRange range) + +domSelectionModify :: + (DOMSelectionClass self) => + self -> String -> String -> String -> IO () +domSelectionModify self alter direction granularity + = withUTFString granularity $ + \ granularityPtr -> + withUTFString direction $ + \ directionPtr -> + withUTFString alter $ + \ alterPtr -> + {# call webkit_dom_dom_selection_modify #} (toDOMSelection self) + alterPtr + directionPtr + granularityPtr + +domSelectionSetBaseAndExtent :: + (DOMSelectionClass self, NodeClass baseNode, + NodeClass extentNode) => + self -> Maybe baseNode -> Int -> Maybe extentNode -> Int -> IO () +domSelectionSetBaseAndExtent self baseNode baseOffset extentNode + extentOffset + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_set_base_and_extent #} + (toDOMSelection self) + (maybe (Node nullForeignPtr) toNode baseNode) + (fromIntegral baseOffset) + (maybe (Node nullForeignPtr) toNode extentNode) + (fromIntegral extentOffset) + errorPtr_ + +domSelectionSetPosition :: + (DOMSelectionClass self, NodeClass node) => + self -> Maybe node -> Int -> IO () +domSelectionSetPosition self node offset + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_set_position #} + (toDOMSelection self) + (maybe (Node nullForeignPtr) toNode node) + (fromIntegral offset) + errorPtr_ + +domSelectionEmpty :: (DOMSelectionClass self) => self -> IO () +domSelectionEmpty self + = {# call webkit_dom_dom_selection_empty #} (toDOMSelection self) + +domSelectionGetAnchorNode :: + (DOMSelectionClass self) => self -> IO (Maybe Node) +domSelectionGetAnchorNode self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_dom_selection_get_anchor_node #} + (toDOMSelection self)) + +domSelectionGetAnchorOffset :: + (DOMSelectionClass self) => self -> IO Int +domSelectionGetAnchorOffset self + = fromIntegral <$> + ({# call webkit_dom_dom_selection_get_anchor_offset #} + (toDOMSelection self)) + +domSelectionGetFocusNode :: + (DOMSelectionClass self) => self -> IO (Maybe Node) +domSelectionGetFocusNode self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_dom_selection_get_focus_node #} + (toDOMSelection self)) + +domSelectionGetFocusOffset :: + (DOMSelectionClass self) => self -> IO Int +domSelectionGetFocusOffset self + = fromIntegral <$> + ({# call webkit_dom_dom_selection_get_focus_offset #} + (toDOMSelection self)) + +domSelectionGetIsCollapsed :: + (DOMSelectionClass self) => self -> IO Bool +domSelectionGetIsCollapsed self + = toBool <$> + ({# call webkit_dom_dom_selection_get_is_collapsed #} + (toDOMSelection self)) + +domSelectionGetRangeCount :: + (DOMSelectionClass self) => self -> IO Int +domSelectionGetRangeCount self + = fromIntegral <$> + ({# call webkit_dom_dom_selection_get_range_count #} + (toDOMSelection self)) + +domSelectionGetBaseNode :: + (DOMSelectionClass self) => self -> IO (Maybe Node) +domSelectionGetBaseNode self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_dom_selection_get_base_node #} + (toDOMSelection self)) + +domSelectionGetBaseOffset :: + (DOMSelectionClass self) => self -> IO Int +domSelectionGetBaseOffset self + = fromIntegral <$> + ({# call webkit_dom_dom_selection_get_base_offset #} + (toDOMSelection self)) + +domSelectionGetExtentNode :: + (DOMSelectionClass self) => self -> IO (Maybe Node) +domSelectionGetExtentNode self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_dom_selection_get_extent_node #} + (toDOMSelection self)) + +domSelectionGetExtentOffset :: + (DOMSelectionClass self) => self -> IO Int +domSelectionGetExtentOffset self + = fromIntegral <$> + ({# call webkit_dom_dom_selection_get_extent_offset #} + (toDOMSelection self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMSettableTokenList.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMSettableTokenList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMSettableTokenList.chs @@ -0,0 +1,25 @@ +module Graphics.UI.Gtk.WebKit.DOM.DOMSettableTokenList + (domSettableTokenListSetValue, domSettableTokenListGetValue) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +domSettableTokenListSetValue :: + (DOMSettableTokenListClass self) => self -> String -> IO () +domSettableTokenListSetValue self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_dom_settable_token_list_set_value #} + (toDOMSettableTokenList self) + valPtr + +domSettableTokenListGetValue :: + (DOMSettableTokenListClass self) => self -> IO String +domSettableTokenListGetValue self + = ({# call webkit_dom_dom_settable_token_list_get_value #} + (toDOMSettableTokenList self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMStringList.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMStringList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMStringList.chs @@ -0,0 +1,35 @@ +module Graphics.UI.Gtk.WebKit.DOM.DOMStringList + (domStringListItem, domStringListContains, domStringListGetLength) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +domStringListItem :: + (DOMStringListClass self) => self -> Word -> IO String +domStringListItem self index + = ({# call webkit_dom_dom_string_list_item #} + (toDOMStringList self) + (fromIntegral index)) + >>= + readUTFString + +domStringListContains :: + (DOMStringListClass self) => self -> String -> IO Bool +domStringListContains self string + = toBool <$> + (withUTFString string $ + \ stringPtr -> + {# call webkit_dom_dom_string_list_contains #} + (toDOMStringList self) + stringPtr) + +domStringListGetLength :: + (DOMStringListClass self) => self -> IO Word +domStringListGetLength self + = fromIntegral <$> + ({# call webkit_dom_dom_string_list_get_length #} + (toDOMStringList self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMTokenList.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMTokenList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMTokenList.chs @@ -0,0 +1,77 @@ +module Graphics.UI.Gtk.WebKit.DOM.DOMTokenList + (domTokenListItem, domTokenListContains, domTokenListAdd, + domTokenListRemove, domTokenListToggle, domTokenListGetLength) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +domTokenListItem :: + (DOMTokenListClass self) => self -> Word -> IO String +domTokenListItem self index + = ({# call webkit_dom_dom_token_list_item #} (toDOMTokenList self) + (fromIntegral index)) + >>= + readUTFString + +domTokenListContains :: + (DOMTokenListClass self) => self -> String -> IO Bool +domTokenListContains self token + = toBool <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString token $ + \ tokenPtr -> + {# call webkit_dom_dom_token_list_contains #} (toDOMTokenList self) + tokenPtr + errorPtr_) + +domTokenListAdd :: + (DOMTokenListClass self) => self -> String -> IO () +domTokenListAdd self token + = propagateGError $ + \ errorPtr_ -> + withUTFString token $ + \ tokenPtr -> + {# call webkit_dom_dom_token_list_add #} (toDOMTokenList self) + tokenPtr + errorPtr_ + +domTokenListRemove :: + (DOMTokenListClass self) => self -> String -> IO () +domTokenListRemove self token + = propagateGError $ + \ errorPtr_ -> + withUTFString token $ + \ tokenPtr -> + {# call webkit_dom_dom_token_list_remove #} (toDOMTokenList self) + tokenPtr + errorPtr_ + +#if WEBKIT_CHECK_VERSION(2,0,0) +domTokenListToggle :: (DOMTokenListClass self) => self -> String -> Bool -> IO Bool +domTokenListToggle self token force = toBool <$> (propagateGError $ \errorPtr_ -> withUTFString token $ \tokenPtr -> + {# call webkit_dom_dom_token_list_toggle #} (toDOMTokenList self) tokenPtr (fromBool force) errorPtr_) +#else +domTokenListToggle :: + (DOMTokenListClass self) => self -> String -> IO Bool +domTokenListToggle self token + = toBool <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString token $ + \ tokenPtr -> + {# call webkit_dom_dom_token_list_toggle #} (toDOMTokenList self) + tokenPtr + errorPtr_) +#endif + +domTokenListGetLength :: + (DOMTokenListClass self) => self -> IO Word +domTokenListGetLength self + = fromIntegral <$> + ({# call webkit_dom_dom_token_list_get_length #} + (toDOMTokenList self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMWindow.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMWindow.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMWindow.chs @@ -0,0 +1,875 @@ +module Graphics.UI.Gtk.WebKit.DOM.DOMWindow + (domWindowGetSelection, domWindowBlur, domWindowPrint, + domWindowStop, domWindowAlert, domWindowConfirm, domWindowPrompt, + domWindowFind, domWindowScrollBy, domWindowScrollTo, + domWindowScroll, domWindowMoveBy, domWindowMoveTo, + domWindowResizeBy, domWindowResizeTo, domWindowMatchMedia, + domWindowGetComputedStyle, + domWindowWebkitConvertPointFromPageToNode, + domWindowWebkitConvertPointFromNodeToPage, domWindowClearTimeout, + domWindowClearInterval, domWindowAtob, domWindowBtoa, + domWindowDispatchEvent, domWindowCaptureEvents, + domWindowReleaseEvents, domWindowGetScreen, domWindowGetHistory, + domWindowGetLocationbar, domWindowGetMenubar, + domWindowGetPersonalbar, domWindowGetScrollbars, + domWindowGetStatusbar, domWindowGetToolbar, domWindowGetNavigator, + domWindowGetClientInformation, domWindowGetFrameElement, + domWindowGetOffscreenBuffering, domWindowGetOuterHeight, + domWindowGetOuterWidth, domWindowGetInnerHeight, + domWindowGetInnerWidth, domWindowGetScreenX, domWindowGetScreenY, + domWindowGetScreenLeft, domWindowGetScreenTop, domWindowGetScrollX, + domWindowGetScrollY, domWindowGetPageXOffset, + domWindowGetPageYOffset, domWindowGetClosed, domWindowGetLength, + domWindowSetName, domWindowGetName, domWindowSetStatus, + domWindowGetStatus, domWindowSetDefaultStatus, + domWindowGetDefaultStatus, domWindowGetSelf, domWindowGetWindow, + domWindowGetFrames, domWindowGetOpener, domWindowGetParent, + domWindowGetTop, domWindowGetDocument, domWindowGetStyleMedia, + domWindowGetDevicePixelRatio, domWindowGetApplicationCache, + domWindowGetSessionStorage, domWindowGetLocalStorage, + domWindowGetConsole, domWindowOnabort, domWindowOnbeforeunload, + domWindowOnblur, domWindowOncanplay, domWindowOncanplaythrough, + domWindowOnchange, domWindowOnclick, domWindowOncontextmenu, + domWindowOndblclick, domWindowOndrag, domWindowOndragend, + domWindowOndragenter, domWindowOndragleave, domWindowOndragover, + domWindowOndragstart, domWindowOndrop, domWindowOndurationchange, + domWindowOnemptied, domWindowOnended, domWindowOnerror, + domWindowOnfocus, domWindowOnhashchange, domWindowOninput, + domWindowOninvalid, domWindowOnkeydown, domWindowOnkeypress, + domWindowOnkeyup, domWindowOnload, domWindowOnloadeddata, + domWindowOnloadedmetadata, domWindowOnloadstart, + domWindowOnmessage, domWindowOnmousedown, domWindowOnmousemove, + domWindowOnmouseout, domWindowOnmouseover, domWindowOnmouseup, + domWindowOnmousewheel, domWindowOnoffline, domWindowOnonline, + domWindowOnpagehide, domWindowOnpageshow, domWindowOnpause, + domWindowOnplay, domWindowOnplaying, domWindowOnpopstate, + domWindowOnprogress, domWindowOnratechange, domWindowOnresize, + domWindowOnscroll, domWindowOnseeked, domWindowOnseeking, + domWindowOnselect, domWindowOnstalled, domWindowOnstorage, + domWindowOnsubmit, domWindowOnsuspend, domWindowOntimeupdate, + domWindowOnunload, domWindowOnvolumechange, domWindowOnwaiting, + domWindowOnreset, domWindowOnsearch, domWindowOnwebkitanimationend, + domWindowOnwebkitanimationiteration, + domWindowOnwebkitanimationstart, domWindowOnwebkittransitionend, + domWindowOntouchstart, domWindowOntouchmove, domWindowOntouchend, + domWindowOntouchcancel, domWindowOndevicemotion, + domWindowOndeviceorientation +#if WEBKIT_CHECK_VERSION(1,10,0) + , domWindowOnwebkitdeviceproximity +#endif + ) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +domWindowGetSelection :: + (DOMWindowClass self) => self -> IO (Maybe DOMSelection) +domWindowGetSelection self + = maybeNull (makeNewGObject mkDOMSelection) + ({# call webkit_dom_dom_window_get_selection #} (toDOMWindow self)) + +domWindowBlur :: (DOMWindowClass self) => self -> IO () +domWindowBlur self + = {# call webkit_dom_dom_window_blur #} (toDOMWindow self) + +domWindowPrint :: (DOMWindowClass self) => self -> IO () +domWindowPrint self + = {# call webkit_dom_dom_window_print #} (toDOMWindow self) + +domWindowStop :: (DOMWindowClass self) => self -> IO () +domWindowStop self + = {# call webkit_dom_dom_window_stop #} (toDOMWindow self) + +domWindowAlert :: (DOMWindowClass self) => self -> String -> IO () +domWindowAlert self message + = withUTFString message $ + \ messagePtr -> + {# call webkit_dom_dom_window_alert #} (toDOMWindow self) + messagePtr + +domWindowConfirm :: + (DOMWindowClass self) => self -> String -> IO Bool +domWindowConfirm self message + = toBool <$> + (withUTFString message $ + \ messagePtr -> + {# call webkit_dom_dom_window_confirm #} (toDOMWindow self) + messagePtr) + +domWindowPrompt :: + (DOMWindowClass self) => self -> String -> String -> IO String +domWindowPrompt self message defaultValue + = (withUTFString defaultValue $ + \ defaultValuePtr -> + withUTFString message $ + \ messagePtr -> + {# call webkit_dom_dom_window_prompt #} (toDOMWindow self) + messagePtr + defaultValuePtr) + >>= + readUTFString + +domWindowFind :: + (DOMWindowClass self) => + self -> + String -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> IO Bool +domWindowFind self string caseSensitive backwards wrap wholeWord + searchInFrames showDialog + = toBool <$> + (withUTFString string $ + \ stringPtr -> + {# call webkit_dom_dom_window_find #} (toDOMWindow self) stringPtr + (fromBool caseSensitive) + (fromBool backwards) + (fromBool wrap) + (fromBool wholeWord) + (fromBool searchInFrames) + (fromBool showDialog)) + +domWindowScrollBy :: + (DOMWindowClass self) => self -> Int -> Int -> IO () +domWindowScrollBy self x y + = {# call webkit_dom_dom_window_scroll_by #} (toDOMWindow self) + (fromIntegral x) + (fromIntegral y) + +domWindowScrollTo :: + (DOMWindowClass self) => self -> Int -> Int -> IO () +domWindowScrollTo self x y + = {# call webkit_dom_dom_window_scroll_to #} (toDOMWindow self) + (fromIntegral x) + (fromIntegral y) + +domWindowScroll :: + (DOMWindowClass self) => self -> Int -> Int -> IO () +domWindowScroll self x y + = {# call webkit_dom_dom_window_scroll #} (toDOMWindow self) + (fromIntegral x) + (fromIntegral y) + +domWindowMoveBy :: + (DOMWindowClass self) => self -> Float -> Float -> IO () +domWindowMoveBy self x y + = {# call webkit_dom_dom_window_move_by #} (toDOMWindow self) + (realToFrac x) + (realToFrac y) + +domWindowMoveTo :: + (DOMWindowClass self) => self -> Float -> Float -> IO () +domWindowMoveTo self x y + = {# call webkit_dom_dom_window_move_to #} (toDOMWindow self) + (realToFrac x) + (realToFrac y) + +domWindowResizeBy :: + (DOMWindowClass self) => self -> Float -> Float -> IO () +domWindowResizeBy self x y + = {# call webkit_dom_dom_window_resize_by #} (toDOMWindow self) + (realToFrac x) + (realToFrac y) + +domWindowResizeTo :: + (DOMWindowClass self) => self -> Float -> Float -> IO () +domWindowResizeTo self width height + = {# call webkit_dom_dom_window_resize_to #} (toDOMWindow self) + (realToFrac width) + (realToFrac height) + +domWindowMatchMedia :: + (DOMWindowClass self) => + self -> String -> IO (Maybe MediaQueryList) +domWindowMatchMedia self query + = maybeNull (makeNewGObject mkMediaQueryList) + (withUTFString query $ + \ queryPtr -> + {# call webkit_dom_dom_window_match_media #} (toDOMWindow self) + queryPtr) + +domWindowGetComputedStyle :: + (DOMWindowClass self, ElementClass element) => + self -> Maybe element -> String -> IO (Maybe CSSStyleDeclaration) +domWindowGetComputedStyle self element pseudoElement + = maybeNull (makeNewGObject mkCSSStyleDeclaration) + (withUTFString pseudoElement $ + \ pseudoElementPtr -> + {# call webkit_dom_dom_window_get_computed_style #} + (toDOMWindow self) + (maybe (Element nullForeignPtr) toElement element) + pseudoElementPtr) + +domWindowWebkitConvertPointFromPageToNode :: + (DOMWindowClass self, NodeClass node, + WebKitPointClass p) => + self -> Maybe node -> Maybe p -> IO (Maybe WebKitPoint) +domWindowWebkitConvertPointFromPageToNode self node p + = maybeNull (makeNewGObject mkWebKitPoint) + ({# call + webkit_dom_dom_window_webkit_convert_point_from_page_to_node + #} + (toDOMWindow self) + (maybe (Node nullForeignPtr) toNode node) + (maybe (WebKitPoint nullForeignPtr) toWebKitPoint p)) + +domWindowWebkitConvertPointFromNodeToPage :: + (DOMWindowClass self, NodeClass node, + WebKitPointClass p) => + self -> Maybe node -> Maybe p -> IO (Maybe WebKitPoint) +domWindowWebkitConvertPointFromNodeToPage self node p + = maybeNull (makeNewGObject mkWebKitPoint) + ({# call + webkit_dom_dom_window_webkit_convert_point_from_node_to_page + #} + (toDOMWindow self) + (maybe (Node nullForeignPtr) toNode node) + (maybe (WebKitPoint nullForeignPtr) toWebKitPoint p)) + +domWindowClearTimeout :: + (DOMWindowClass self) => self -> Int -> IO () +domWindowClearTimeout self handle + = {# call webkit_dom_dom_window_clear_timeout #} (toDOMWindow self) + (fromIntegral handle) + +domWindowClearInterval :: + (DOMWindowClass self) => self -> Int -> IO () +domWindowClearInterval self handle + = {# call webkit_dom_dom_window_clear_interval #} + (toDOMWindow self) + (fromIntegral handle) + +domWindowAtob :: + (DOMWindowClass self) => self -> String -> IO String +domWindowAtob self string + = (propagateGError $ + \ errorPtr_ -> + withUTFString string $ + \ stringPtr -> + {# call webkit_dom_dom_window_atob #} (toDOMWindow self) stringPtr + errorPtr_) + >>= + readUTFString + +domWindowBtoa :: + (DOMWindowClass self) => self -> String -> IO String +domWindowBtoa self string + = (propagateGError $ + \ errorPtr_ -> + withUTFString string $ + \ stringPtr -> + {# call webkit_dom_dom_window_btoa #} (toDOMWindow self) stringPtr + errorPtr_) + >>= + readUTFString + +domWindowDispatchEvent :: + (DOMWindowClass self, EventClass evt) => + self -> Maybe evt -> IO Bool +domWindowDispatchEvent self evt + = toBool <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_window_dispatch_event #} (toDOMWindow self) + (maybe (Event nullForeignPtr) toEvent evt) + errorPtr_) + +domWindowCaptureEvents :: (DOMWindowClass self) => self -> IO () +domWindowCaptureEvents self + = {# call webkit_dom_dom_window_capture_events #} + (toDOMWindow self) + +domWindowReleaseEvents :: (DOMWindowClass self) => self -> IO () +domWindowReleaseEvents self + = {# call webkit_dom_dom_window_release_events #} + (toDOMWindow self) + +domWindowGetScreen :: + (DOMWindowClass self) => self -> IO (Maybe DOMScreen) +domWindowGetScreen self + = maybeNull (makeNewGObject mkDOMScreen) + ({# call webkit_dom_dom_window_get_screen #} (toDOMWindow self)) + +domWindowGetHistory :: + (DOMWindowClass self) => self -> IO (Maybe History) +domWindowGetHistory self + = maybeNull (makeNewGObject mkHistory) + ({# call webkit_dom_dom_window_get_history #} (toDOMWindow self)) + +domWindowGetLocationbar :: + (DOMWindowClass self) => self -> IO (Maybe BarInfo) +domWindowGetLocationbar self + = maybeNull (makeNewGObject mkBarInfo) + ({# call webkit_dom_dom_window_get_locationbar #} + (toDOMWindow self)) + +domWindowGetMenubar :: + (DOMWindowClass self) => self -> IO (Maybe BarInfo) +domWindowGetMenubar self + = maybeNull (makeNewGObject mkBarInfo) + ({# call webkit_dom_dom_window_get_menubar #} (toDOMWindow self)) + +domWindowGetPersonalbar :: + (DOMWindowClass self) => self -> IO (Maybe BarInfo) +domWindowGetPersonalbar self + = maybeNull (makeNewGObject mkBarInfo) + ({# call webkit_dom_dom_window_get_personalbar #} + (toDOMWindow self)) + +domWindowGetScrollbars :: + (DOMWindowClass self) => self -> IO (Maybe BarInfo) +domWindowGetScrollbars self + = maybeNull (makeNewGObject mkBarInfo) + ({# call webkit_dom_dom_window_get_scrollbars #} + (toDOMWindow self)) + +domWindowGetStatusbar :: + (DOMWindowClass self) => self -> IO (Maybe BarInfo) +domWindowGetStatusbar self + = maybeNull (makeNewGObject mkBarInfo) + ({# call webkit_dom_dom_window_get_statusbar #} (toDOMWindow self)) + +domWindowGetToolbar :: + (DOMWindowClass self) => self -> IO (Maybe BarInfo) +domWindowGetToolbar self + = maybeNull (makeNewGObject mkBarInfo) + ({# call webkit_dom_dom_window_get_toolbar #} (toDOMWindow self)) + +domWindowGetNavigator :: + (DOMWindowClass self) => self -> IO (Maybe Navigator) +domWindowGetNavigator self + = maybeNull (makeNewGObject mkNavigator) + ({# call webkit_dom_dom_window_get_navigator #} (toDOMWindow self)) + +domWindowGetClientInformation :: + (DOMWindowClass self) => self -> IO (Maybe Navigator) +domWindowGetClientInformation self + = maybeNull (makeNewGObject mkNavigator) + ({# call webkit_dom_dom_window_get_client_information #} + (toDOMWindow self)) + +domWindowGetFrameElement :: + (DOMWindowClass self) => self -> IO (Maybe Element) +domWindowGetFrameElement self + = maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_dom_window_get_frame_element #} + (toDOMWindow self)) + +domWindowGetOffscreenBuffering :: + (DOMWindowClass self) => self -> IO Bool +domWindowGetOffscreenBuffering self + = toBool <$> + ({# call webkit_dom_dom_window_get_offscreen_buffering #} + (toDOMWindow self)) + +domWindowGetOuterHeight :: (DOMWindowClass self) => self -> IO Int +domWindowGetOuterHeight self + = fromIntegral <$> + ({# call webkit_dom_dom_window_get_outer_height #} + (toDOMWindow self)) + +domWindowGetOuterWidth :: (DOMWindowClass self) => self -> IO Int +domWindowGetOuterWidth self + = fromIntegral <$> + ({# call webkit_dom_dom_window_get_outer_width #} + (toDOMWindow self)) + +domWindowGetInnerHeight :: (DOMWindowClass self) => self -> IO Int +domWindowGetInnerHeight self + = fromIntegral <$> + ({# call webkit_dom_dom_window_get_inner_height #} + (toDOMWindow self)) + +domWindowGetInnerWidth :: (DOMWindowClass self) => self -> IO Int +domWindowGetInnerWidth self + = fromIntegral <$> + ({# call webkit_dom_dom_window_get_inner_width #} + (toDOMWindow self)) + +domWindowGetScreenX :: (DOMWindowClass self) => self -> IO Int +domWindowGetScreenX self + = fromIntegral <$> + ({# call webkit_dom_dom_window_get_screen_x #} (toDOMWindow self)) + +domWindowGetScreenY :: (DOMWindowClass self) => self -> IO Int +domWindowGetScreenY self + = fromIntegral <$> + ({# call webkit_dom_dom_window_get_screen_y #} (toDOMWindow self)) + +domWindowGetScreenLeft :: (DOMWindowClass self) => self -> IO Int +domWindowGetScreenLeft self + = fromIntegral <$> + ({# call webkit_dom_dom_window_get_screen_left #} + (toDOMWindow self)) + +domWindowGetScreenTop :: (DOMWindowClass self) => self -> IO Int +domWindowGetScreenTop self + = fromIntegral <$> + ({# call webkit_dom_dom_window_get_screen_top #} + (toDOMWindow self)) + +domWindowGetScrollX :: (DOMWindowClass self) => self -> IO Int +domWindowGetScrollX self + = fromIntegral <$> + ({# call webkit_dom_dom_window_get_scroll_x #} (toDOMWindow self)) + +domWindowGetScrollY :: (DOMWindowClass self) => self -> IO Int +domWindowGetScrollY self + = fromIntegral <$> + ({# call webkit_dom_dom_window_get_scroll_y #} (toDOMWindow self)) + +domWindowGetPageXOffset :: (DOMWindowClass self) => self -> IO Int +domWindowGetPageXOffset self + = fromIntegral <$> + ({# call webkit_dom_dom_window_get_page_x_offset #} + (toDOMWindow self)) + +domWindowGetPageYOffset :: (DOMWindowClass self) => self -> IO Int +domWindowGetPageYOffset self + = fromIntegral <$> + ({# call webkit_dom_dom_window_get_page_y_offset #} + (toDOMWindow self)) + +domWindowGetClosed :: (DOMWindowClass self) => self -> IO Bool +domWindowGetClosed self + = toBool <$> + ({# call webkit_dom_dom_window_get_closed #} (toDOMWindow self)) + +domWindowGetLength :: (DOMWindowClass self) => self -> IO Word +domWindowGetLength self + = fromIntegral <$> + ({# call webkit_dom_dom_window_get_length #} (toDOMWindow self)) + +domWindowSetName :: + (DOMWindowClass self) => self -> String -> IO () +domWindowSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_dom_window_set_name #} (toDOMWindow self) valPtr + +domWindowGetName :: (DOMWindowClass self) => self -> IO String +domWindowGetName self + = ({# call webkit_dom_dom_window_get_name #} (toDOMWindow self)) + >>= + readUTFString + +domWindowSetStatus :: + (DOMWindowClass self) => self -> String -> IO () +domWindowSetStatus self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_dom_window_set_status #} (toDOMWindow self) + valPtr + +domWindowGetStatus :: (DOMWindowClass self) => self -> IO String +domWindowGetStatus self + = ({# call webkit_dom_dom_window_get_status #} (toDOMWindow self)) + >>= + readUTFString + +domWindowSetDefaultStatus :: + (DOMWindowClass self) => self -> String -> IO () +domWindowSetDefaultStatus self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_dom_window_set_default_status #} + (toDOMWindow self) + valPtr + +domWindowGetDefaultStatus :: + (DOMWindowClass self) => self -> IO String +domWindowGetDefaultStatus self + = ({# call webkit_dom_dom_window_get_default_status #} + (toDOMWindow self)) + >>= + readUTFString + +domWindowGetSelf :: + (DOMWindowClass self) => self -> IO (Maybe DOMWindow) +domWindowGetSelf self + = maybeNull (makeNewGObject mkDOMWindow) + ({# call webkit_dom_dom_window_get_self #} (toDOMWindow self)) + +domWindowGetWindow :: + (DOMWindowClass self) => self -> IO (Maybe DOMWindow) +domWindowGetWindow self + = maybeNull (makeNewGObject mkDOMWindow) + ({# call webkit_dom_dom_window_get_window #} (toDOMWindow self)) + +domWindowGetFrames :: + (DOMWindowClass self) => self -> IO (Maybe DOMWindow) +domWindowGetFrames self + = maybeNull (makeNewGObject mkDOMWindow) + ({# call webkit_dom_dom_window_get_frames #} (toDOMWindow self)) + +domWindowGetOpener :: + (DOMWindowClass self) => self -> IO (Maybe DOMWindow) +domWindowGetOpener self + = maybeNull (makeNewGObject mkDOMWindow) + ({# call webkit_dom_dom_window_get_opener #} (toDOMWindow self)) + +domWindowGetParent :: + (DOMWindowClass self) => self -> IO (Maybe DOMWindow) +domWindowGetParent self + = maybeNull (makeNewGObject mkDOMWindow) + ({# call webkit_dom_dom_window_get_parent #} (toDOMWindow self)) + +domWindowGetTop :: + (DOMWindowClass self) => self -> IO (Maybe DOMWindow) +domWindowGetTop self + = maybeNull (makeNewGObject mkDOMWindow) + ({# call webkit_dom_dom_window_get_top #} (toDOMWindow self)) + +domWindowGetDocument :: + (DOMWindowClass self) => self -> IO (Maybe Document) +domWindowGetDocument self + = maybeNull (makeNewGObject mkDocument) + ({# call webkit_dom_dom_window_get_document #} (toDOMWindow self)) + +domWindowGetStyleMedia :: + (DOMWindowClass self) => self -> IO (Maybe StyleMedia) +domWindowGetStyleMedia self + = maybeNull (makeNewGObject mkStyleMedia) + ({# call webkit_dom_dom_window_get_style_media #} + (toDOMWindow self)) + +domWindowGetDevicePixelRatio :: + (DOMWindowClass self) => self -> IO Double +domWindowGetDevicePixelRatio self + = realToFrac <$> + ({# call webkit_dom_dom_window_get_device_pixel_ratio #} + (toDOMWindow self)) + +domWindowGetApplicationCache :: + (DOMWindowClass self) => self -> IO (Maybe DOMApplicationCache) +domWindowGetApplicationCache self + = maybeNull (makeNewGObject mkDOMApplicationCache) + ({# call webkit_dom_dom_window_get_application_cache #} + (toDOMWindow self)) + +domWindowGetSessionStorage :: + (DOMWindowClass self) => self -> IO (Maybe Storage) +domWindowGetSessionStorage self + = maybeNull (makeNewGObject mkStorage) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_window_get_session_storage #} + (toDOMWindow self) + errorPtr_) + +domWindowGetLocalStorage :: + (DOMWindowClass self) => self -> IO (Maybe Storage) +domWindowGetLocalStorage self + = maybeNull (makeNewGObject mkStorage) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_window_get_local_storage #} + (toDOMWindow self) + errorPtr_) + +domWindowGetConsole :: + (DOMWindowClass self) => self -> IO (Maybe Console) +domWindowGetConsole self + = maybeNull (makeNewGObject mkConsole) + ({# call webkit_dom_dom_window_get_console #} (toDOMWindow self)) + +domWindowOnabort :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnabort = (connect "abort") + +domWindowOnbeforeunload :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnbeforeunload = (connect "beforeunload") + +domWindowOnblur :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnblur = (connect "blur") + +domWindowOncanplay :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOncanplay = (connect "canplay") + +domWindowOncanplaythrough :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOncanplaythrough = (connect "canplaythrough") + +domWindowOnchange :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnchange = (connect "change") + +domWindowOnclick :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOnclick = (connect "click") + +domWindowOncontextmenu :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOncontextmenu = (connect "contextmenu") + +domWindowOndblclick :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOndblclick = (connect "dblclick") + +domWindowOndrag :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOndrag = (connect "drag") + +domWindowOndragend :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOndragend = (connect "dragend") + +domWindowOndragenter :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOndragenter = (connect "dragenter") + +domWindowOndragleave :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOndragleave = (connect "dragleave") + +domWindowOndragover :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOndragover = (connect "dragover") + +domWindowOndragstart :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOndragstart = (connect "dragstart") + +domWindowOndrop :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOndrop = (connect "drop") + +domWindowOndurationchange :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOndurationchange = (connect "durationchange") + +domWindowOnemptied :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnemptied = (connect "emptied") + +domWindowOnended :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnended = (connect "ended") + +domWindowOnerror :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnerror = (connect "error") + +domWindowOnfocus :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnfocus = (connect "focus") + +domWindowOnhashchange :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnhashchange = (connect "hashchange") + +domWindowOninput :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOninput = (connect "input") + +domWindowOninvalid :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOninvalid = (connect "invalid") + +domWindowOnkeydown :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnkeydown = (connect "keydown") + +domWindowOnkeypress :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnkeypress = (connect "keypress") + +domWindowOnkeyup :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnkeyup = (connect "keyup") + +domWindowOnload :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnload = (connect "load") + +domWindowOnloadeddata :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnloadeddata = (connect "loadeddata") + +domWindowOnloadedmetadata :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnloadedmetadata = (connect "loadedmetadata") + +domWindowOnloadstart :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnloadstart = (connect "loadstart") + +domWindowOnmessage :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnmessage = (connect "message") + +domWindowOnmousedown :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOnmousedown = (connect "mousedown") + +domWindowOnmousemove :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOnmousemove = (connect "mousemove") + +domWindowOnmouseout :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOnmouseout = (connect "mouseout") + +domWindowOnmouseover :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOnmouseover = (connect "mouseover") + +domWindowOnmouseup :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOnmouseup = (connect "mouseup") + +domWindowOnmousewheel :: + (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) +domWindowOnmousewheel = (connect "mousewheel") + +domWindowOnoffline :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnoffline = (connect "offline") + +domWindowOnonline :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnonline = (connect "online") + +domWindowOnpagehide :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnpagehide = (connect "pagehide") + +domWindowOnpageshow :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnpageshow = (connect "pageshow") + +domWindowOnpause :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnpause = (connect "pause") + +domWindowOnplay :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnplay = (connect "play") + +domWindowOnplaying :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnplaying = (connect "playing") + +domWindowOnpopstate :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnpopstate = (connect "popstate") + +domWindowOnprogress :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnprogress = (connect "progress") + +domWindowOnratechange :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnratechange = (connect "ratechange") + +domWindowOnresize :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnresize = (connect "resize") + +domWindowOnscroll :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnscroll = (connect "scroll") + +domWindowOnseeked :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnseeked = (connect "seeked") + +domWindowOnseeking :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnseeking = (connect "seeking") + +domWindowOnselect :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnselect = (connect "select") + +domWindowOnstalled :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnstalled = (connect "stalled") + +domWindowOnstorage :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnstorage = (connect "storage") + +domWindowOnsubmit :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnsubmit = (connect "submit") + +domWindowOnsuspend :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnsuspend = (connect "suspend") + +domWindowOntimeupdate :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOntimeupdate = (connect "timeupdate") + +domWindowOnunload :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnunload = (connect "unload") + +domWindowOnvolumechange :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnvolumechange = (connect "volumechange") + +domWindowOnwaiting :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnwaiting = (connect "waiting") + +domWindowOnreset :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnreset = (connect "reset") + +domWindowOnsearch :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnsearch = (connect "search") + +domWindowOnwebkitanimationend :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnwebkitanimationend = (connect "webkitanimationend") + +domWindowOnwebkitanimationiteration :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnwebkitanimationiteration + = (connect "webkitanimationiteration") + +domWindowOnwebkitanimationstart :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnwebkitanimationstart = (connect "webkitanimationstart") + +domWindowOnwebkittransitionend :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnwebkittransitionend = (connect "webkittransitionend") + +domWindowOntouchstart :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOntouchstart = (connect "touchstart") + +domWindowOntouchmove :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOntouchmove = (connect "touchmove") + +domWindowOntouchend :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOntouchend = (connect "touchend") + +domWindowOntouchcancel :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOntouchcancel = (connect "touchcancel") + +domWindowOndevicemotion :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOndevicemotion = (connect "devicemotion") + +domWindowOndeviceorientation :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOndeviceorientation = (connect "deviceorientation") + +#if WEBKIT_CHECK_VERSION(1,10,0) +domWindowOnwebkitdeviceproximity :: + (DOMWindowClass self) => Signal self (EventM UIEvent self ()) +domWindowOnwebkitdeviceproximity + = (connect "webkitdeviceproximity") +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Document.chs b/Graphics/UI/Gtk/WebKit/DOM/Document.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Document.chs @@ -0,0 +1,987 @@ +module Graphics.UI.Gtk.WebKit.DOM.Document + (documentCreateElement, documentCreateDocumentFragment, + documentCreateTextNode, documentCreateComment, + documentCreateCDATASection, documentCreateProcessingInstruction, + documentCreateAttribute, documentCreateEntityReference, + documentGetElementsByTagName, documentImportNode, + documentCreateElementNS, documentCreateAttributeNS, + documentGetElementsByTagNameNS, documentGetElementById, + documentAdoptNode, documentCreateEvent, documentCreateRange, + documentCreateNodeIterator, documentCreateTreeWalker, + documentGetOverrideStyle, documentCreateExpression, + documentCreateNSResolver, documentEvaluate, documentExecCommand, + documentQueryCommandEnabled, documentQueryCommandIndeterm, + documentQueryCommandState, documentQueryCommandSupported, + documentQueryCommandValue, documentGetElementsByName, + documentElementFromPoint, documentCaretRangeFromPoint, + documentCreateCSSStyleDeclaration, documentGetElementsByClassName, + documentQuerySelector, documentQuerySelectorAll, + documentGetDoctype, documentGetImplementation, + documentGetDocumentElement, documentGetInputEncoding, + documentGetXmlEncoding, documentSetXmlVersion, + documentGetXmlVersion, documentSetXmlStandalone, + documentGetXmlStandalone, documentSetDocumentURI, + documentGetDocumentURI, documentGetDefaultView, + documentGetStyleSheets, documentSetTitle, documentGetTitle, + documentGetReferrer, documentGetDomain, documentSetCookie, + documentGetCookie, documentSetBody, documentGetBody, + documentGetHead, documentGetImages, documentGetApplets, + documentGetLinks, documentGetForms, documentGetAnchors, + documentGetLastModified, documentSetCharset, documentGetCharset, + documentGetDefaultCharset, documentGetReadyState, + documentGetCharacterSet, documentGetPreferredStylesheetSet, + documentSetSelectedStylesheetSet, documentGetSelectedStylesheetSet, + documentGetCompatMode, +#if WEBKIT_CHECK_VERSION(1,10,0) + documentGetWebkitPointerLockElement, +#endif + documentOnabort, documentOnblur, documentOnchange, documentOnclick, + documentOncontextmenu, documentOndblclick, documentOndrag, + documentOndragend, documentOndragenter, documentOndragleave, + documentOndragover, documentOndragstart, documentOndrop, + documentOnerror, documentOnfocus, documentOninput, + documentOninvalid, documentOnkeydown, documentOnkeypress, + documentOnkeyup, documentOnload, documentOnmousedown, + documentOnmousemove, documentOnmouseout, documentOnmouseover, + documentOnmouseup, documentOnmousewheel, + documentOnreadystatechange, documentOnscroll, documentOnselect, + documentOnsubmit, documentOnbeforecut, documentOncut, + documentOnbeforecopy, documentOncopy, documentOnbeforepaste, + documentOnpaste, documentOnreset, documentOnsearch, + documentOnselectstart, documentOnselectionchange, + documentOntouchstart, documentOntouchmove, documentOntouchend, + documentOntouchcancel, documentOnwebkitfullscreenchange, + documentOnwebkitfullscreenerror, +#if WEBKIT_CHECK_VERSION(1,10,0) + documentOnwebkitpointerlockchange, documentOnwebkitpointerlockerror, +#endif + documentGetWebkitVisibilityState, + documentGetWebkitHidden +#if WEBKIT_CHECK_VERSION(1,10,0) + , documentGetSecurityPolicy +#endif + ) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +documentCreateElement :: + (DocumentClass self) => self -> String -> IO (Maybe Element) +documentCreateElement self tagName + = maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + withUTFString tagName $ + \ tagNamePtr -> + {# call webkit_dom_document_create_element #} (toDocument self) + tagNamePtr + errorPtr_) + +documentCreateDocumentFragment :: + (DocumentClass self) => self -> IO (Maybe DocumentFragment) +documentCreateDocumentFragment self + = maybeNull (makeNewGObject mkDocumentFragment) + ({# call webkit_dom_document_create_document_fragment #} + (toDocument self)) + +documentCreateTextNode :: + (DocumentClass self) => self -> String -> IO (Maybe Text) +documentCreateTextNode self data' + = maybeNull (makeNewGObject mkText) + (withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_document_create_text_node #} (toDocument self) + dataPtr) + +documentCreateComment :: + (DocumentClass self) => self -> String -> IO (Maybe Comment) +documentCreateComment self data' + = maybeNull (makeNewGObject mkComment) + (withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_document_create_comment #} (toDocument self) + dataPtr) + +documentCreateCDATASection :: + (DocumentClass self) => self -> String -> IO (Maybe CDATASection) +documentCreateCDATASection self data' + = maybeNull (makeNewGObject mkCDATASection) + (propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_document_create_cdata_section #} + (toDocument self) + dataPtr + errorPtr_) + +documentCreateProcessingInstruction :: + (DocumentClass self) => + self -> String -> String -> IO (Maybe ProcessingInstruction) +documentCreateProcessingInstruction self target data' + = maybeNull (makeNewGObject mkProcessingInstruction) + (propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + withUTFString target $ + \ targetPtr -> + {# call webkit_dom_document_create_processing_instruction #} + (toDocument self) + targetPtr + dataPtr + errorPtr_) + +documentCreateAttribute :: + (DocumentClass self) => self -> String -> IO (Maybe DOMAttr) +documentCreateAttribute self name + = maybeNull (makeNewGObject mkDOMAttr) + (propagateGError $ + \ errorPtr_ -> + withUTFString name $ + \ namePtr -> + {# call webkit_dom_document_create_attribute #} (toDocument self) + namePtr + errorPtr_) + +documentCreateEntityReference :: + (DocumentClass self) => + self -> String -> IO (Maybe EntityReference) +documentCreateEntityReference self name + = maybeNull (makeNewGObject mkEntityReference) + (propagateGError $ + \ errorPtr_ -> + withUTFString name $ + \ namePtr -> + {# call webkit_dom_document_create_entity_reference #} + (toDocument self) + namePtr + errorPtr_) + +documentGetElementsByTagName :: + (DocumentClass self) => self -> String -> IO (Maybe NodeList) +documentGetElementsByTagName self tagname + = maybeNull (makeNewGObject mkNodeList) + (withUTFString tagname $ + \ tagnamePtr -> + {# call webkit_dom_document_get_elements_by_tag_name #} + (toDocument self) + tagnamePtr) + +documentImportNode :: + (DocumentClass self, NodeClass importedNode) => + self -> Maybe importedNode -> Bool -> IO (Maybe Node) +documentImportNode self importedNode deep + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_import_node #} (toDocument self) + (maybe (Node nullForeignPtr) toNode importedNode) + (fromBool deep) + errorPtr_) + +documentCreateElementNS :: + (DocumentClass self) => + self -> String -> String -> IO (Maybe Element) +documentCreateElementNS self namespaceURI qualifiedName + = maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + withUTFString qualifiedName $ + \ qualifiedNamePtr -> + withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_document_create_element_ns #} (toDocument self) + namespaceURIPtr + qualifiedNamePtr + errorPtr_) + +documentCreateAttributeNS :: + (DocumentClass self) => + self -> String -> String -> IO (Maybe DOMAttr) +documentCreateAttributeNS self namespaceURI qualifiedName + = maybeNull (makeNewGObject mkDOMAttr) + (propagateGError $ + \ errorPtr_ -> + withUTFString qualifiedName $ + \ qualifiedNamePtr -> + withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_document_create_attribute_ns #} + (toDocument self) + namespaceURIPtr + qualifiedNamePtr + errorPtr_) + +documentGetElementsByTagNameNS :: + (DocumentClass self) => + self -> String -> String -> IO (Maybe NodeList) +documentGetElementsByTagNameNS self namespaceURI localName + = maybeNull (makeNewGObject mkNodeList) + (withUTFString localName $ + \ localNamePtr -> + withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_document_get_elements_by_tag_name_ns #} + (toDocument self) + namespaceURIPtr + localNamePtr) + +documentGetElementById :: + (DocumentClass self) => self -> String -> IO (Maybe Element) +documentGetElementById self elementId + = maybeNull (makeNewGObject mkElement) + (withUTFString elementId $ + \ elementIdPtr -> + {# call webkit_dom_document_get_element_by_id #} (toDocument self) + elementIdPtr) + +documentAdoptNode :: + (DocumentClass self, NodeClass source) => + self -> Maybe source -> IO (Maybe Node) +documentAdoptNode self source + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_adopt_node #} (toDocument self) + (maybe (Node nullForeignPtr) toNode source) + errorPtr_) + +documentCreateEvent :: + (DocumentClass self) => self -> String -> IO (Maybe Event) +documentCreateEvent self eventType + = maybeNull (makeNewGObject mkEvent) + (propagateGError $ + \ errorPtr_ -> + withUTFString eventType $ + \ eventTypePtr -> + {# call webkit_dom_document_create_event #} (toDocument self) + eventTypePtr + errorPtr_) + +documentCreateRange :: + (DocumentClass self) => self -> IO (Maybe DOMRange) +documentCreateRange self + = maybeNull (makeNewGObject mkDOMRange) + ({# call webkit_dom_document_create_range #} (toDocument self)) + +documentCreateNodeIterator :: + (DocumentClass self, NodeClass root, NodeFilterClass filter) => + self -> + Maybe root -> + Word -> Maybe filter -> Bool -> IO (Maybe NodeIterator) +documentCreateNodeIterator self root whatToShow filter + expandEntityReferences + = maybeNull (makeNewGObject mkNodeIterator) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_create_node_iterator #} + (toDocument self) + (maybe (Node nullForeignPtr) toNode root) + (fromIntegral whatToShow) + (maybe (NodeFilter nullForeignPtr) toNodeFilter filter) + (fromBool expandEntityReferences) + errorPtr_) + +documentCreateTreeWalker :: + (DocumentClass self, NodeClass root, NodeFilterClass filter) => + self -> + Maybe root -> Word -> Maybe filter -> Bool -> IO (Maybe TreeWalker) +documentCreateTreeWalker self root whatToShow filter + expandEntityReferences + = maybeNull (makeNewGObject mkTreeWalker) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_create_tree_walker #} (toDocument self) + (maybe (Node nullForeignPtr) toNode root) + (fromIntegral whatToShow) + (maybe (NodeFilter nullForeignPtr) toNodeFilter filter) + (fromBool expandEntityReferences) + errorPtr_) + +documentGetOverrideStyle :: + (DocumentClass self, ElementClass element) => + self -> Maybe element -> String -> IO (Maybe CSSStyleDeclaration) +documentGetOverrideStyle self element pseudoElement + = maybeNull (makeNewGObject mkCSSStyleDeclaration) + (withUTFString pseudoElement $ + \ pseudoElementPtr -> + {# call webkit_dom_document_get_override_style #} (toDocument self) + (maybe (Element nullForeignPtr) toElement element) + pseudoElementPtr) + +documentCreateExpression :: + (DocumentClass self, XPathNSResolverClass resolver) => + self -> String -> Maybe resolver -> IO (Maybe XPathExpression) +documentCreateExpression self expression resolver + = maybeNull (makeNewGObject mkXPathExpression) + (propagateGError $ + \ errorPtr_ -> + withUTFString expression $ + \ expressionPtr -> + {# call webkit_dom_document_create_expression #} (toDocument self) + expressionPtr + (maybe (XPathNSResolver nullForeignPtr) toXPathNSResolver resolver) + errorPtr_) + +documentCreateNSResolver :: + (DocumentClass self, NodeClass nodeResolver) => + self -> Maybe nodeResolver -> IO (Maybe XPathNSResolver) +documentCreateNSResolver self nodeResolver + = maybeNull (makeNewGObject mkXPathNSResolver) + ({# call webkit_dom_document_create_ns_resolver #} + (toDocument self) + (maybe (Node nullForeignPtr) toNode nodeResolver)) + +documentEvaluate :: + (DocumentClass self, NodeClass contextNode, + XPathNSResolverClass resolver, XPathResultClass inResult) => + self -> + String -> + Maybe contextNode -> + Maybe resolver -> Word -> Maybe inResult -> IO (Maybe XPathResult) +documentEvaluate self expression contextNode resolver type' + inResult + = maybeNull (makeNewGObject mkXPathResult) + (propagateGError $ + \ errorPtr_ -> + withUTFString expression $ + \ expressionPtr -> + {# call webkit_dom_document_evaluate #} (toDocument self) + expressionPtr + (maybe (Node nullForeignPtr) toNode contextNode) + (maybe (XPathNSResolver nullForeignPtr) toXPathNSResolver resolver) + (fromIntegral type') + (maybe (XPathResult nullForeignPtr) toXPathResult inResult) + errorPtr_) + +documentExecCommand :: + (DocumentClass self) => self -> String -> Bool -> String -> IO Bool +documentExecCommand self command userInterface value + = toBool <$> + (withUTFString value $ + \ valuePtr -> + withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_exec_command #} (toDocument self) + commandPtr + (fromBool userInterface) + valuePtr) + +documentQueryCommandEnabled :: + (DocumentClass self) => self -> String -> IO Bool +documentQueryCommandEnabled self command + = toBool <$> + (withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_enabled #} + (toDocument self) + commandPtr) + +documentQueryCommandIndeterm :: + (DocumentClass self) => self -> String -> IO Bool +documentQueryCommandIndeterm self command + = toBool <$> + (withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_indeterm #} + (toDocument self) + commandPtr) + +documentQueryCommandState :: + (DocumentClass self) => self -> String -> IO Bool +documentQueryCommandState self command + = toBool <$> + (withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_state #} + (toDocument self) + commandPtr) + +documentQueryCommandSupported :: + (DocumentClass self) => self -> String -> IO Bool +documentQueryCommandSupported self command + = toBool <$> + (withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_supported #} + (toDocument self) + commandPtr) + +documentQueryCommandValue :: + (DocumentClass self) => self -> String -> IO String +documentQueryCommandValue self command + = (withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_value #} + (toDocument self) + commandPtr) + >>= + readUTFString + +documentGetElementsByName :: + (DocumentClass self) => self -> String -> IO (Maybe NodeList) +documentGetElementsByName self elementName + = maybeNull (makeNewGObject mkNodeList) + (withUTFString elementName $ + \ elementNamePtr -> + {# call webkit_dom_document_get_elements_by_name #} + (toDocument self) + elementNamePtr) + +documentElementFromPoint :: + (DocumentClass self) => self -> Int -> Int -> IO (Maybe Element) +documentElementFromPoint self x y + = maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_document_element_from_point #} + (toDocument self) + (fromIntegral x) + (fromIntegral y)) + +documentCaretRangeFromPoint :: + (DocumentClass self) => self -> Int -> Int -> IO (Maybe DOMRange) +documentCaretRangeFromPoint self x y + = maybeNull (makeNewGObject mkDOMRange) + ({# call webkit_dom_document_caret_range_from_point #} + (toDocument self) + (fromIntegral x) + (fromIntegral y)) + +documentCreateCSSStyleDeclaration :: + (DocumentClass self) => self -> IO (Maybe CSSStyleDeclaration) +documentCreateCSSStyleDeclaration self + = maybeNull (makeNewGObject mkCSSStyleDeclaration) + ({# call webkit_dom_document_create_css_style_declaration #} + (toDocument self)) + +documentGetElementsByClassName :: + (DocumentClass self) => self -> String -> IO (Maybe NodeList) +documentGetElementsByClassName self tagname + = maybeNull (makeNewGObject mkNodeList) + (withUTFString tagname $ + \ tagnamePtr -> + {# call webkit_dom_document_get_elements_by_class_name #} + (toDocument self) + tagnamePtr) + +documentQuerySelector :: + (DocumentClass self) => self -> String -> IO (Maybe Element) +documentQuerySelector self selectors + = maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_document_query_selector #} (toDocument self) + selectorsPtr + errorPtr_) + +documentQuerySelectorAll :: + (DocumentClass self) => self -> String -> IO (Maybe NodeList) +documentQuerySelectorAll self selectors + = maybeNull (makeNewGObject mkNodeList) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_document_query_selector_all #} (toDocument self) + selectorsPtr + errorPtr_) + +documentGetDoctype :: + (DocumentClass self) => self -> IO (Maybe DocumentType) +documentGetDoctype self + = maybeNull (makeNewGObject mkDocumentType) + ({# call webkit_dom_document_get_doctype #} (toDocument self)) + +documentGetImplementation :: + (DocumentClass self) => self -> IO (Maybe DOMImplementation) +documentGetImplementation self + = maybeNull (makeNewGObject mkDOMImplementation) + ({# call webkit_dom_document_get_implementation #} + (toDocument self)) + +documentGetDocumentElement :: + (DocumentClass self) => self -> IO (Maybe Element) +documentGetDocumentElement self + = maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_document_get_document_element #} + (toDocument self)) + +documentGetInputEncoding :: + (DocumentClass self) => self -> IO String +documentGetInputEncoding self + = ({# call webkit_dom_document_get_input_encoding #} + (toDocument self)) + >>= + readUTFString + +documentGetXmlEncoding :: (DocumentClass self) => self -> IO String +documentGetXmlEncoding self + = ({# call webkit_dom_document_get_xml_encoding #} + (toDocument self)) + >>= + readUTFString + +documentSetXmlVersion :: + (DocumentClass self) => self -> String -> IO () +documentSetXmlVersion self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_xml_version #} (toDocument self) + valPtr + errorPtr_ + +documentGetXmlVersion :: (DocumentClass self) => self -> IO String +documentGetXmlVersion self + = ({# call webkit_dom_document_get_xml_version #} + (toDocument self)) + >>= + readUTFString + +documentSetXmlStandalone :: + (DocumentClass self) => self -> Bool -> IO () +documentSetXmlStandalone self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_set_xml_standalone #} (toDocument self) + (fromBool val) + errorPtr_ + +documentGetXmlStandalone :: (DocumentClass self) => self -> IO Bool +documentGetXmlStandalone self + = toBool <$> + ({# call webkit_dom_document_get_xml_standalone #} + (toDocument self)) + +documentSetDocumentURI :: + (DocumentClass self) => self -> String -> IO () +documentSetDocumentURI self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_document_uri #} (toDocument self) + valPtr + +documentGetDocumentURI :: (DocumentClass self) => self -> IO String +documentGetDocumentURI self + = ({# call webkit_dom_document_get_document_uri #} + (toDocument self)) + >>= + readUTFString + +documentGetDefaultView :: + (DocumentClass self) => self -> IO (Maybe DOMWindow) +documentGetDefaultView self + = maybeNull (makeNewGObject mkDOMWindow) + ({# call webkit_dom_document_get_default_view #} (toDocument self)) + +documentGetStyleSheets :: + (DocumentClass self) => self -> IO (Maybe StyleSheetList) +documentGetStyleSheets self + = maybeNull (makeNewGObject mkStyleSheetList) + ({# call webkit_dom_document_get_style_sheets #} (toDocument self)) + +documentSetTitle :: (DocumentClass self) => self -> String -> IO () +documentSetTitle self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_title #} (toDocument self) valPtr + +documentGetTitle :: (DocumentClass self) => self -> IO String +documentGetTitle self + = ({# call webkit_dom_document_get_title #} (toDocument self)) >>= + readUTFString + +documentGetReferrer :: (DocumentClass self) => self -> IO String +documentGetReferrer self + = ({# call webkit_dom_document_get_referrer #} (toDocument self)) + >>= + readUTFString + +documentGetDomain :: (DocumentClass self) => self -> IO String +documentGetDomain self + = ({# call webkit_dom_document_get_domain #} (toDocument self)) >>= + readUTFString + +documentSetCookie :: + (DocumentClass self) => self -> String -> IO () +documentSetCookie self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_cookie #} (toDocument self) valPtr + errorPtr_ + +documentGetCookie :: (DocumentClass self) => self -> IO String +documentGetCookie self + = (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_get_cookie #} (toDocument self) + errorPtr_) + >>= + readUTFString + +documentSetBody :: + (HTMLElementClass val, DocumentClass self) => + self -> Maybe val -> IO () +documentSetBody self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_set_body #} (toDocument self) + (maybe (HTMLElement nullForeignPtr) toHTMLElement val) + errorPtr_ + +documentGetBody :: + (DocumentClass self) => self -> IO (Maybe HTMLElement) +documentGetBody self + = maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_document_get_body #} (toDocument self)) + +documentGetHead :: + (DocumentClass self) => self -> IO (Maybe HTMLHeadElement) +documentGetHead self + = maybeNull (makeNewGObject mkHTMLHeadElement) + ({# call webkit_dom_document_get_head #} (toDocument self)) + +documentGetImages :: + (DocumentClass self) => self -> IO (Maybe HTMLCollection) +documentGetImages self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_images #} (toDocument self)) + +documentGetApplets :: + (DocumentClass self) => self -> IO (Maybe HTMLCollection) +documentGetApplets self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_applets #} (toDocument self)) + +documentGetLinks :: + (DocumentClass self) => self -> IO (Maybe HTMLCollection) +documentGetLinks self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_links #} (toDocument self)) + +documentGetForms :: + (DocumentClass self) => self -> IO (Maybe HTMLCollection) +documentGetForms self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_forms #} (toDocument self)) + +documentGetAnchors :: + (DocumentClass self) => self -> IO (Maybe HTMLCollection) +documentGetAnchors self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_anchors #} (toDocument self)) + +documentGetLastModified :: + (DocumentClass self) => self -> IO String +documentGetLastModified self + = ({# call webkit_dom_document_get_last_modified #} + (toDocument self)) + >>= + readUTFString + +documentSetCharset :: + (DocumentClass self) => self -> String -> IO () +documentSetCharset self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_charset #} (toDocument self) valPtr + +documentGetCharset :: (DocumentClass self) => self -> IO String +documentGetCharset self + = ({# call webkit_dom_document_get_charset #} (toDocument self)) + >>= + readUTFString + +documentGetDefaultCharset :: + (DocumentClass self) => self -> IO String +documentGetDefaultCharset self + = ({# call webkit_dom_document_get_default_charset #} + (toDocument self)) + >>= + readUTFString + +documentGetReadyState :: (DocumentClass self) => self -> IO String +documentGetReadyState self + = ({# call webkit_dom_document_get_ready_state #} + (toDocument self)) + >>= + readUTFString + +documentGetCharacterSet :: + (DocumentClass self) => self -> IO String +documentGetCharacterSet self + = ({# call webkit_dom_document_get_character_set #} + (toDocument self)) + >>= + readUTFString + +documentGetPreferredStylesheetSet :: + (DocumentClass self) => self -> IO String +documentGetPreferredStylesheetSet self + = ({# call webkit_dom_document_get_preferred_stylesheet_set #} + (toDocument self)) + >>= + readUTFString + +documentSetSelectedStylesheetSet :: + (DocumentClass self) => self -> String -> IO () +documentSetSelectedStylesheetSet self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_selected_stylesheet_set #} + (toDocument self) + valPtr + +documentGetSelectedStylesheetSet :: + (DocumentClass self) => self -> IO String +documentGetSelectedStylesheetSet self + = ({# call webkit_dom_document_get_selected_stylesheet_set #} + (toDocument self)) + >>= + readUTFString + +documentGetCompatMode :: (DocumentClass self) => self -> IO String +documentGetCompatMode self + = ({# call webkit_dom_document_get_compat_mode #} + (toDocument self)) + >>= + readUTFString + +#if WEBKIT_CHECK_VERSION(1,10,0) +documentGetWebkitPointerLockElement :: + (DocumentClass self) => self -> IO (Maybe Element) +documentGetWebkitPointerLockElement self + = maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_document_get_webkit_pointer_lock_element #} + (toDocument self)) +#endif + +documentOnabort :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnabort = (connect "abort") + +documentOnblur :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnblur = (connect "blur") + +documentOnchange :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnchange = (connect "change") + +documentOnclick :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOnclick = (connect "click") + +documentOncontextmenu :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOncontextmenu = (connect "contextmenu") + +documentOndblclick :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOndblclick = (connect "dblclick") + +documentOndrag :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOndrag = (connect "drag") + +documentOndragend :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOndragend = (connect "dragend") + +documentOndragenter :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOndragenter = (connect "dragenter") + +documentOndragleave :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOndragleave = (connect "dragleave") + +documentOndragover :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOndragover = (connect "dragover") + +documentOndragstart :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOndragstart = (connect "dragstart") + +documentOndrop :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOndrop = (connect "drop") + +documentOnerror :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnerror = (connect "error") + +documentOnfocus :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnfocus = (connect "focus") + +documentOninput :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOninput = (connect "input") + +documentOninvalid :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOninvalid = (connect "invalid") + +documentOnkeydown :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnkeydown = (connect "keydown") + +documentOnkeypress :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnkeypress = (connect "keypress") + +documentOnkeyup :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnkeyup = (connect "keyup") + +documentOnload :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnload = (connect "load") + +documentOnmousedown :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOnmousedown = (connect "mousedown") + +documentOnmousemove :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOnmousemove = (connect "mousemove") + +documentOnmouseout :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOnmouseout = (connect "mouseout") + +documentOnmouseover :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOnmouseover = (connect "mouseover") + +documentOnmouseup :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOnmouseup = (connect "mouseup") + +documentOnmousewheel :: + (DocumentClass self) => Signal self (EventM MouseEvent self ()) +documentOnmousewheel = (connect "mousewheel") + +documentOnreadystatechange :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnreadystatechange = (connect "readystatechange") + +documentOnscroll :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnscroll = (connect "scroll") + +documentOnselect :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnselect = (connect "select") + +documentOnsubmit :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnsubmit = (connect "submit") + +documentOnbeforecut :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnbeforecut = (connect "beforecut") + +documentOncut :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOncut = (connect "cut") + +documentOnbeforecopy :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnbeforecopy = (connect "beforecopy") + +documentOncopy :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOncopy = (connect "copy") + +documentOnbeforepaste :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnbeforepaste = (connect "beforepaste") + +documentOnpaste :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnpaste = (connect "paste") + +documentOnreset :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnreset = (connect "reset") + +documentOnsearch :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnsearch = (connect "search") + +documentOnselectstart :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnselectstart = (connect "selectstart") + +documentOnselectionchange :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnselectionchange = (connect "selectionchange") + +documentOntouchstart :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOntouchstart = (connect "touchstart") + +documentOntouchmove :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOntouchmove = (connect "touchmove") + +documentOntouchend :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOntouchend = (connect "touchend") + +documentOntouchcancel :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOntouchcancel = (connect "touchcancel") + +documentOnwebkitfullscreenchange :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnwebkitfullscreenchange + = (connect "webkitfullscreenchange") + +documentOnwebkitfullscreenerror :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnwebkitfullscreenerror = (connect "webkitfullscreenerror") + +#if WEBKIT_CHECK_VERSION(1,10,0) +documentOnwebkitpointerlockchange :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnwebkitpointerlockchange + = (connect "webkitpointerlockchange") + +documentOnwebkitpointerlockerror :: + (DocumentClass self) => Signal self (EventM UIEvent self ()) +documentOnwebkitpointerlockerror + = (connect "webkitpointerlockerror") +#endif + +documentGetWebkitVisibilityState :: + (DocumentClass self) => self -> IO String +documentGetWebkitVisibilityState self + = ({# call webkit_dom_document_get_webkit_visibility_state #} + (toDocument self)) + >>= + readUTFString + +documentGetWebkitHidden :: (DocumentClass self) => self -> IO Bool +documentGetWebkitHidden self + = toBool <$> + ({# call webkit_dom_document_get_webkit_hidden #} + (toDocument self)) + +#if WEBKIT_CHECK_VERSION(1,10,0) +documentGetSecurityPolicy :: (DocumentClass self) => self -> IO (Maybe DOMSecurityPolicy) +documentGetSecurityPolicy = + maybeNull (makeNewGObject mkDOMSecurityPolicy) . {# call webkit_dom_document_get_security_policy #} . toDocument +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/DocumentType.chs b/Graphics/UI/Gtk/WebKit/DOM/DocumentType.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DocumentType.chs @@ -0,0 +1,57 @@ +module Graphics.UI.Gtk.WebKit.DOM.DocumentType + (documentTypeGetName, documentTypeGetEntities, + documentTypeGetNotations, documentTypeGetPublicId, + documentTypeGetSystemId, documentTypeGetInternalSubset) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +documentTypeGetName :: + (DocumentTypeClass self) => self -> IO String +documentTypeGetName self + = ({# call webkit_dom_document_type_get_name #} + (toDocumentType self)) + >>= + readUTFString + +documentTypeGetEntities :: + (DocumentTypeClass self) => self -> IO (Maybe NamedNodeMap) +documentTypeGetEntities self + = maybeNull (makeNewGObject mkNamedNodeMap) + ({# call webkit_dom_document_type_get_entities #} + (toDocumentType self)) + +documentTypeGetNotations :: + (DocumentTypeClass self) => self -> IO (Maybe NamedNodeMap) +documentTypeGetNotations self + = maybeNull (makeNewGObject mkNamedNodeMap) + ({# call webkit_dom_document_type_get_notations #} + (toDocumentType self)) + +documentTypeGetPublicId :: + (DocumentTypeClass self) => self -> IO String +documentTypeGetPublicId self + = ({# call webkit_dom_document_type_get_public_id #} + (toDocumentType self)) + >>= + readUTFString + +documentTypeGetSystemId :: + (DocumentTypeClass self) => self -> IO String +documentTypeGetSystemId self + = ({# call webkit_dom_document_type_get_system_id #} + (toDocumentType self)) + >>= + readUTFString + +documentTypeGetInternalSubset :: + (DocumentTypeClass self) => self -> IO String +documentTypeGetInternalSubset self + = ({# call webkit_dom_document_type_get_internal_subset #} + (toDocumentType self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/Element.chs b/Graphics/UI/Gtk/WebKit/DOM/Element.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Element.chs @@ -0,0 +1,638 @@ +module Graphics.UI.Gtk.WebKit.DOM.Element + (elementGetAttribute, elementSetAttribute, elementRemoveAttribute, + elementGetAttributeNode, elementSetAttributeNode, + elementRemoveAttributeNode, elementGetElementsByTagName, + elementGetAttributeNS, elementSetAttributeNS, + elementRemoveAttributeNS, elementGetElementsByTagNameNS, + elementGetAttributeNodeNS, elementSetAttributeNodeNS, + elementHasAttribute, elementHasAttributeNS, elementFocus, + elementBlur, elementScrollIntoView, elementScrollIntoViewIfNeeded, + elementScrollByLines, elementScrollByPages, + elementGetElementsByClassName, elementQuerySelector, + elementQuerySelectorAll, elementWebkitMatchesSelector, + elementGetTagName, elementGetStyle, elementGetOffsetLeft, + elementGetOffsetTop, elementGetOffsetWidth, elementGetOffsetHeight, + elementGetOffsetParent, elementGetClientLeft, elementGetClientTop, + elementGetClientWidth, elementGetClientHeight, + elementSetScrollLeft, elementGetScrollLeft, elementSetScrollTop, + elementGetScrollTop, elementGetScrollWidth, elementGetScrollHeight, +#if WEBKIT_CHECK_VERSION(1,10,0) + elementSetClassName, elementGetClassName, elementGetClassList, +#endif + elementGetFirstElementChild, elementGetLastElementChild, + elementGetPreviousElementSibling, elementGetNextElementSibling, + elementGetChildElementCount, +#if WEBKIT_CHECK_VERSION(1,10,0) + elementGetWebkitRegionOverset, +#endif + elementOnabort, elementOnblur, elementOnchange, elementOnclick, + elementOncontextmenu, elementOndblclick, elementOndrag, + elementOndragend, elementOndragenter, elementOndragleave, + elementOndragover, elementOndragstart, elementOndrop, + elementOnerror, elementOnfocus, elementOninput, elementOninvalid, + elementOnkeydown, elementOnkeypress, elementOnkeyup, elementOnload, + elementOnmousedown, elementOnmousemove, elementOnmouseout, + elementOnmouseover, elementOnmouseup, elementOnmousewheel, + elementOnscroll, elementOnselect, elementOnsubmit, + elementOnbeforecut, elementOncut, elementOnbeforecopy, + elementOncopy, elementOnbeforepaste, elementOnpaste, + elementOnreset, elementOnsearch, elementOnselectstart, + elementOntouchstart, elementOntouchmove, elementOntouchend, + elementOntouchcancel, elementOnwebkitfullscreenchange, + elementOnwebkitfullscreenerror) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +elementGetAttribute :: + (ElementClass self) => self -> String -> IO String +elementGetAttribute self name + = (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_get_attribute #} (toElement self) + namePtr) + >>= + readUTFString + +elementSetAttribute :: + (ElementClass self) => self -> String -> String -> IO () +elementSetAttribute self name value + = propagateGError $ + \ errorPtr_ -> + withUTFString value $ + \ valuePtr -> + withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_set_attribute #} (toElement self) + namePtr + valuePtr + errorPtr_ + +elementRemoveAttribute :: + (ElementClass self) => self -> String -> IO () +elementRemoveAttribute self name + = withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_remove_attribute #} (toElement self) + namePtr + +elementGetAttributeNode :: + (ElementClass self) => self -> String -> IO (Maybe DOMAttr) +elementGetAttributeNode self name + = maybeNull (makeNewGObject mkDOMAttr) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_get_attribute_node #} (toElement self) + namePtr) + +elementSetAttributeNode :: + (ElementClass self, DOMAttrClass newAttr) => + self -> Maybe newAttr -> IO (Maybe DOMAttr) +elementSetAttributeNode self newAttr + = maybeNull (makeNewGObject mkDOMAttr) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_element_set_attribute_node #} (toElement self) + (maybe (DOMAttr nullForeignPtr) toDOMAttr newAttr) + errorPtr_) + +elementRemoveAttributeNode :: + (ElementClass self, DOMAttrClass oldAttr) => + self -> Maybe oldAttr -> IO (Maybe DOMAttr) +elementRemoveAttributeNode self oldAttr + = maybeNull (makeNewGObject mkDOMAttr) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_element_remove_attribute_node #} + (toElement self) + (maybe (DOMAttr nullForeignPtr) toDOMAttr oldAttr) + errorPtr_) + +elementGetElementsByTagName :: + (ElementClass self) => self -> String -> IO (Maybe NodeList) +elementGetElementsByTagName self name + = maybeNull (makeNewGObject mkNodeList) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_get_elements_by_tag_name #} + (toElement self) + namePtr) + +elementGetAttributeNS :: + (ElementClass self) => self -> String -> String -> IO String +elementGetAttributeNS self namespaceURI localName + = (withUTFString localName $ + \ localNamePtr -> + withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_get_attribute_ns #} (toElement self) + namespaceURIPtr + localNamePtr) + >>= + readUTFString + +elementSetAttributeNS :: + (ElementClass self) => self -> String -> String -> String -> IO () +elementSetAttributeNS self namespaceURI qualifiedName value + = propagateGError $ + \ errorPtr_ -> + withUTFString value $ + \ valuePtr -> + withUTFString qualifiedName $ + \ qualifiedNamePtr -> + withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_set_attribute_ns #} (toElement self) + namespaceURIPtr + qualifiedNamePtr + valuePtr + errorPtr_ + +elementRemoveAttributeNS :: + (ElementClass self) => self -> String -> String -> IO () +elementRemoveAttributeNS self namespaceURI localName + = withUTFString localName $ + \ localNamePtr -> + withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_remove_attribute_ns #} (toElement self) + namespaceURIPtr + localNamePtr + +elementGetElementsByTagNameNS :: + (ElementClass self) => + self -> String -> String -> IO (Maybe NodeList) +elementGetElementsByTagNameNS self namespaceURI localName + = maybeNull (makeNewGObject mkNodeList) + (withUTFString localName $ + \ localNamePtr -> + withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_get_elements_by_tag_name_ns #} + (toElement self) + namespaceURIPtr + localNamePtr) + +elementGetAttributeNodeNS :: + (ElementClass self) => + self -> String -> String -> IO (Maybe DOMAttr) +elementGetAttributeNodeNS self namespaceURI localName + = maybeNull (makeNewGObject mkDOMAttr) + (withUTFString localName $ + \ localNamePtr -> + withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_get_attribute_node_ns #} + (toElement self) + namespaceURIPtr + localNamePtr) + +elementSetAttributeNodeNS :: + (ElementClass self, DOMAttrClass newAttr) => + self -> Maybe newAttr -> IO (Maybe DOMAttr) +elementSetAttributeNodeNS self newAttr + = maybeNull (makeNewGObject mkDOMAttr) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_element_set_attribute_node_ns #} + (toElement self) + (maybe (DOMAttr nullForeignPtr) toDOMAttr newAttr) + errorPtr_) + +elementHasAttribute :: + (ElementClass self) => self -> String -> IO Bool +elementHasAttribute self name + = toBool <$> + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_has_attribute #} (toElement self) + namePtr) + +elementHasAttributeNS :: + (ElementClass self) => self -> String -> String -> IO Bool +elementHasAttributeNS self namespaceURI localName + = toBool <$> + (withUTFString localName $ + \ localNamePtr -> + withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_has_attribute_ns #} (toElement self) + namespaceURIPtr + localNamePtr) + +elementFocus :: (ElementClass self) => self -> IO () +elementFocus self + = {# call webkit_dom_element_focus #} (toElement self) + +elementBlur :: (ElementClass self) => self -> IO () +elementBlur self + = {# call webkit_dom_element_blur #} (toElement self) + +elementScrollIntoView :: + (ElementClass self) => self -> Bool -> IO () +elementScrollIntoView self alignWithTop + = {# call webkit_dom_element_scroll_into_view #} (toElement self) + (fromBool alignWithTop) + +elementScrollIntoViewIfNeeded :: + (ElementClass self) => self -> Bool -> IO () +elementScrollIntoViewIfNeeded self centerIfNeeded + = {# call webkit_dom_element_scroll_into_view_if_needed #} + (toElement self) + (fromBool centerIfNeeded) + +elementScrollByLines :: (ElementClass self) => self -> Int -> IO () +elementScrollByLines self lines + = {# call webkit_dom_element_scroll_by_lines #} (toElement self) + (fromIntegral lines) + +elementScrollByPages :: (ElementClass self) => self -> Int -> IO () +elementScrollByPages self pages + = {# call webkit_dom_element_scroll_by_pages #} (toElement self) + (fromIntegral pages) + +elementGetElementsByClassName :: + (ElementClass self) => self -> String -> IO (Maybe NodeList) +elementGetElementsByClassName self name + = maybeNull (makeNewGObject mkNodeList) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_get_elements_by_class_name #} + (toElement self) + namePtr) + +elementQuerySelector :: + (ElementClass self) => self -> String -> IO (Maybe Element) +elementQuerySelector self selectors + = maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_element_query_selector #} (toElement self) + selectorsPtr + errorPtr_) + +elementQuerySelectorAll :: + (ElementClass self) => self -> String -> IO (Maybe NodeList) +elementQuerySelectorAll self selectors + = maybeNull (makeNewGObject mkNodeList) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_element_query_selector_all #} (toElement self) + selectorsPtr + errorPtr_) + +elementWebkitMatchesSelector :: + (ElementClass self) => self -> String -> IO Bool +elementWebkitMatchesSelector self selectors + = toBool <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_element_webkit_matches_selector #} + (toElement self) + selectorsPtr + errorPtr_) + +elementGetTagName :: (ElementClass self) => self -> IO String +elementGetTagName self + = ({# call webkit_dom_element_get_tag_name #} (toElement self)) >>= + readUTFString + +elementGetStyle :: + (ElementClass self) => self -> IO (Maybe CSSStyleDeclaration) +elementGetStyle self + = maybeNull (makeNewGObject mkCSSStyleDeclaration) + ({# call webkit_dom_element_get_style #} (toElement self)) + +elementGetOffsetLeft :: (ElementClass self) => self -> IO Int +elementGetOffsetLeft self + = fromIntegral <$> + ({# call webkit_dom_element_get_offset_left #} (toElement self)) + +elementGetOffsetTop :: (ElementClass self) => self -> IO Int +elementGetOffsetTop self + = fromIntegral <$> + ({# call webkit_dom_element_get_offset_top #} (toElement self)) + +elementGetOffsetWidth :: (ElementClass self) => self -> IO Int +elementGetOffsetWidth self + = fromIntegral <$> + ({# call webkit_dom_element_get_offset_width #} (toElement self)) + +elementGetOffsetHeight :: (ElementClass self) => self -> IO Int +elementGetOffsetHeight self + = fromIntegral <$> + ({# call webkit_dom_element_get_offset_height #} (toElement self)) + +elementGetOffsetParent :: + (ElementClass self) => self -> IO (Maybe Element) +elementGetOffsetParent self + = maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_offset_parent #} (toElement self)) + +elementGetClientLeft :: (ElementClass self) => self -> IO Int +elementGetClientLeft self + = fromIntegral <$> + ({# call webkit_dom_element_get_client_left #} (toElement self)) + +elementGetClientTop :: (ElementClass self) => self -> IO Int +elementGetClientTop self + = fromIntegral <$> + ({# call webkit_dom_element_get_client_top #} (toElement self)) + +elementGetClientWidth :: (ElementClass self) => self -> IO Int +elementGetClientWidth self + = fromIntegral <$> + ({# call webkit_dom_element_get_client_width #} (toElement self)) + +elementGetClientHeight :: (ElementClass self) => self -> IO Int +elementGetClientHeight self + = fromIntegral <$> + ({# call webkit_dom_element_get_client_height #} (toElement self)) + +elementSetScrollLeft :: (ElementClass self) => self -> Int -> IO () +elementSetScrollLeft self val + = {# call webkit_dom_element_set_scroll_left #} (toElement self) + (fromIntegral val) + +elementGetScrollLeft :: (ElementClass self) => self -> IO Int +elementGetScrollLeft self + = fromIntegral <$> + ({# call webkit_dom_element_get_scroll_left #} (toElement self)) + +elementSetScrollTop :: (ElementClass self) => self -> Int -> IO () +elementSetScrollTop self val + = {# call webkit_dom_element_set_scroll_top #} (toElement self) + (fromIntegral val) + +elementGetScrollTop :: (ElementClass self) => self -> IO Int +elementGetScrollTop self + = fromIntegral <$> + ({# call webkit_dom_element_get_scroll_top #} (toElement self)) + +elementGetScrollWidth :: (ElementClass self) => self -> IO Int +elementGetScrollWidth self + = fromIntegral <$> + ({# call webkit_dom_element_get_scroll_width #} (toElement self)) + +elementGetScrollHeight :: (ElementClass self) => self -> IO Int +elementGetScrollHeight self + = fromIntegral <$> + ({# call webkit_dom_element_get_scroll_height #} (toElement self)) + +#if WEBKIT_CHECK_VERSION(1,10,0) +elementSetClassName :: + (ElementClass self) => self -> String -> IO () +elementSetClassName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_element_set_class_name #} (toElement self) + valPtr + +elementGetClassName :: (ElementClass self) => self -> IO String +elementGetClassName self + = ({# call webkit_dom_element_get_class_name #} (toElement self)) + >>= + readUTFString + +elementGetClassList :: + (ElementClass self) => self -> IO (Maybe DOMTokenList) +elementGetClassList self + = maybeNull (makeNewGObject mkDOMTokenList) + ({# call webkit_dom_element_get_class_list #} (toElement self)) +#endif + +elementGetFirstElementChild :: + (ElementClass self) => self -> IO (Maybe Element) +elementGetFirstElementChild self + = maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_first_element_child #} + (toElement self)) + +elementGetLastElementChild :: + (ElementClass self) => self -> IO (Maybe Element) +elementGetLastElementChild self + = maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_last_element_child #} + (toElement self)) + +elementGetPreviousElementSibling :: + (ElementClass self) => self -> IO (Maybe Element) +elementGetPreviousElementSibling self + = maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_previous_element_sibling #} + (toElement self)) + +elementGetNextElementSibling :: + (ElementClass self) => self -> IO (Maybe Element) +elementGetNextElementSibling self + = maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_next_element_sibling #} + (toElement self)) + +elementGetChildElementCount :: + (ElementClass self) => self -> IO Word +elementGetChildElementCount self + = fromIntegral <$> + ({# call webkit_dom_element_get_child_element_count #} + (toElement self)) + +#if WEBKIT_CHECK_VERSION(1,10,0) +elementGetWebkitRegionOverset :: + (ElementClass self) => self -> IO String +elementGetWebkitRegionOverset self + = ({# call webkit_dom_element_get_webkit_region_overset #} + (toElement self)) + >>= + readUTFString +#endif + +elementOnabort :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnabort = (connect "abort") + +elementOnblur :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnblur = (connect "blur") + +elementOnchange :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnchange = (connect "change") + +elementOnclick :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOnclick = (connect "click") + +elementOncontextmenu :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOncontextmenu = (connect "contextmenu") + +elementOndblclick :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOndblclick = (connect "dblclick") + +elementOndrag :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOndrag = (connect "drag") + +elementOndragend :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOndragend = (connect "dragend") + +elementOndragenter :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOndragenter = (connect "dragenter") + +elementOndragleave :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOndragleave = (connect "dragleave") + +elementOndragover :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOndragover = (connect "dragover") + +elementOndragstart :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOndragstart = (connect "dragstart") + +elementOndrop :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOndrop = (connect "drop") + +elementOnerror :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnerror = (connect "error") + +elementOnfocus :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnfocus = (connect "focus") + +elementOninput :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOninput = (connect "input") + +elementOninvalid :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOninvalid = (connect "invalid") + +elementOnkeydown :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnkeydown = (connect "keydown") + +elementOnkeypress :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnkeypress = (connect "keypress") + +elementOnkeyup :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnkeyup = (connect "keyup") + +elementOnload :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnload = (connect "load") + +elementOnmousedown :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOnmousedown = (connect "mousedown") + +elementOnmousemove :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOnmousemove = (connect "mousemove") + +elementOnmouseout :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOnmouseout = (connect "mouseout") + +elementOnmouseover :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOnmouseover = (connect "mouseover") + +elementOnmouseup :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOnmouseup = (connect "mouseup") + +elementOnmousewheel :: + (ElementClass self) => Signal self (EventM MouseEvent self ()) +elementOnmousewheel = (connect "mousewheel") + +elementOnscroll :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnscroll = (connect "scroll") + +elementOnselect :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnselect = (connect "select") + +elementOnsubmit :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnsubmit = (connect "submit") + +elementOnbeforecut :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnbeforecut = (connect "beforecut") + +elementOncut :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOncut = (connect "cut") + +elementOnbeforecopy :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnbeforecopy = (connect "beforecopy") + +elementOncopy :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOncopy = (connect "copy") + +elementOnbeforepaste :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnbeforepaste = (connect "beforepaste") + +elementOnpaste :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnpaste = (connect "paste") + +elementOnreset :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnreset = (connect "reset") + +elementOnsearch :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnsearch = (connect "search") + +elementOnselectstart :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnselectstart = (connect "selectstart") + +elementOntouchstart :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOntouchstart = (connect "touchstart") + +elementOntouchmove :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOntouchmove = (connect "touchmove") + +elementOntouchend :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOntouchend = (connect "touchend") + +elementOntouchcancel :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOntouchcancel = (connect "touchcancel") + +elementOnwebkitfullscreenchange :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnwebkitfullscreenchange + = (connect "webkitfullscreenchange") + +elementOnwebkitfullscreenerror :: + (ElementClass self) => Signal self (EventM UIEvent self ()) +elementOnwebkitfullscreenerror = (connect "webkitfullscreenerror") diff --git a/Graphics/UI/Gtk/WebKit/DOM/Event.chs b/Graphics/UI/Gtk/WebKit/DOM/Event.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Event.chs @@ -0,0 +1,122 @@ +module Graphics.UI.Gtk.WebKit.DOM.Event + (eventStopPropagation, eventPreventDefault, eventInitEvent, + eventStopImmediatePropagation, cNONE, cCAPTURING_PHASE, cAT_TARGET, + cBUBBLING_PHASE, cMOUSEDOWN, cMOUSEUP, cMOUSEOVER, cMOUSEOUT, + cMOUSEMOVE, cMOUSEDRAG, cCLICK, cDBLCLICK, cKEYDOWN, cKEYUP, + cKEYPRESS, cDRAGDROP, cFOCUS, cBLUR, cSELECT, cCHANGE, + eventGetTarget, eventGetCurrentTarget, eventGetEventPhase, + eventGetBubbles, eventGetCancelable, eventGetTimeStamp, + eventGetDefaultPrevented, eventGetSrcElement, eventSetReturnValue, + eventGetReturnValue, eventSetCancelBubble, eventGetCancelBubble) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError + +eventStopPropagation :: (EventClass self) => self -> IO () +eventStopPropagation self + = {# call webkit_dom_event_stop_propagation #} (toEvent self) + +eventPreventDefault :: (EventClass self) => self -> IO () +eventPreventDefault self + = {# call webkit_dom_event_prevent_default #} (toEvent self) + +eventInitEvent :: + (EventClass self) => self -> String -> Bool -> Bool -> IO () +eventInitEvent self eventTypeArg canBubbleArg cancelableArg + = withUTFString eventTypeArg $ + \ eventTypeArgPtr -> + {# call webkit_dom_event_init_event #} (toEvent self) + eventTypeArgPtr + (fromBool canBubbleArg) + (fromBool cancelableArg) + +eventStopImmediatePropagation :: (EventClass self) => self -> IO () +eventStopImmediatePropagation self + = {# call webkit_dom_event_stop_immediate_propagation #} + (toEvent self) +cNONE = 0 +cCAPTURING_PHASE = 1 +cAT_TARGET = 2 +cBUBBLING_PHASE = 3 +cMOUSEDOWN = 1 +cMOUSEUP = 2 +cMOUSEOVER = 4 +cMOUSEOUT = 8 +cMOUSEMOVE = 16 +cMOUSEDRAG = 32 +cCLICK = 64 +cDBLCLICK = 128 +cKEYDOWN = 256 +cKEYUP = 512 +cKEYPRESS = 1024 +cDRAGDROP = 2048 +cFOCUS = 4096 +cBLUR = 8192 +cSELECT = 16384 +cCHANGE = 32768 + +eventGetTarget :: + (EventClass self) => self -> IO (Maybe EventTarget) +eventGetTarget self + = maybeNull (makeNewGObject mkEventTarget) + ({# call webkit_dom_event_get_target #} (toEvent self)) + +eventGetCurrentTarget :: + (EventClass self) => self -> IO (Maybe EventTarget) +eventGetCurrentTarget self + = maybeNull (makeNewGObject mkEventTarget) + ({# call webkit_dom_event_get_current_target #} (toEvent self)) + +eventGetEventPhase :: (EventClass self) => self -> IO Word +eventGetEventPhase self + = fromIntegral <$> + ({# call webkit_dom_event_get_event_phase #} (toEvent self)) + +eventGetBubbles :: (EventClass self) => self -> IO Bool +eventGetBubbles self + = toBool <$> + ({# call webkit_dom_event_get_bubbles #} (toEvent self)) + +eventGetCancelable :: (EventClass self) => self -> IO Bool +eventGetCancelable self + = toBool <$> + ({# call webkit_dom_event_get_cancelable #} (toEvent self)) + +eventGetTimeStamp :: (EventClass self) => self -> IO Word +eventGetTimeStamp self + = fromIntegral <$> + ({# call webkit_dom_event_get_time_stamp #} (toEvent self)) + +eventGetDefaultPrevented :: (EventClass self) => self -> IO Bool +eventGetDefaultPrevented self + = toBool <$> + ({# call webkit_dom_event_get_default_prevented #} (toEvent self)) + +eventGetSrcElement :: + (EventClass self) => self -> IO (Maybe EventTarget) +eventGetSrcElement self + = maybeNull (makeNewGObject mkEventTarget) + ({# call webkit_dom_event_get_src_element #} (toEvent self)) + +eventSetReturnValue :: (EventClass self) => self -> Bool -> IO () +eventSetReturnValue self val + = {# call webkit_dom_event_set_return_value #} (toEvent self) + (fromBool val) + +eventGetReturnValue :: (EventClass self) => self -> IO Bool +eventGetReturnValue self + = toBool <$> + ({# call webkit_dom_event_get_return_value #} (toEvent self)) + +eventSetCancelBubble :: (EventClass self) => self -> Bool -> IO () +eventSetCancelBubble self val + = {# call webkit_dom_event_set_cancel_bubble #} (toEvent self) + (fromBool val) + +eventGetCancelBubble :: (EventClass self) => self -> IO Bool +eventGetCancelBubble self + = toBool <$> + ({# call webkit_dom_event_get_cancel_bubble #} (toEvent self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/EventM.hs b/Graphics/UI/Gtk/WebKit/DOM/EventM.hs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/EventM.hs @@ -0,0 +1,263 @@ +module Graphics.UI.Gtk.WebKit.DOM.EventM +( + Signal (..) +, EventM (..) +, target +, event +, eventTarget +, eventCurrentTarget +, eventPhase +, bubbles +, cancelable +, timeStamp +, stopPropagation +, preventDefault +, defaultPrevented +, stopImmediatePropagation +, srcElement +, getCancelBubble +, cancelBubble +, getReturnValue +, returnValue +, uiView +, uiDetail +, uiKeyCode +, uiCharCode +, uiLayerX +, uiLayerY +, uiLayerXY +, uiPageX +, uiPageY +, uiPageXY +, uiWhich +, mouseScreenX +, mouseScreenY +, mouseScreenXY +, mouseClientX +, mouseClientY +, mouseClientXY +, mouseWebkitMovementX +, mouseWebkitMovementY +, mouseWebkitMovementXY +, mouseCtrlKey +, mouseShiftKey +, mouseAltKey +, mouseMetaKey +, mouseButton +, mouseRelatedTarget +, mouseOffsetX +, mouseOffsetY +, mouseOffsetXY +, mouseX +, mouseY +, mouseXY +, mouseFromElement +, mouseToElement +, connect +) +where +import Control.Applicative ((<$>)) +import Control.Monad.Reader ( ReaderT, ask, runReaderT ) +import Control.Monad.Trans ( liftIO ) +import Graphics.UI.Gtk.WebKit.Types +import Graphics.UI.Gtk.WebKit.DOM.Event +import Graphics.UI.Gtk.WebKit.DOM.UIEvent +import Graphics.UI.Gtk.WebKit.DOM.MouseEvent +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Data.Word (Word) + +type Signal target callback = target -> callback -> IO Bool + +type EventM e t a = ReaderT (t, e) IO a + +target :: EventM e t t +target = fst <$> ask + +event :: EventM e t e +event = snd <$> ask + +eventTarget :: EventClass e => EventM e t (Maybe EventTarget) +eventTarget = event >>= (liftIO . eventGetTarget) + +eventCurrentTarget :: EventClass e => EventM e t (Maybe EventTarget) +eventCurrentTarget = event >>= (liftIO . eventGetCurrentTarget) + +eventPhase :: EventClass e => EventM e t Word +eventPhase = event >>= (liftIO . eventGetEventPhase) + +bubbles :: EventClass e => EventM e t Bool +bubbles = event >>= (liftIO . eventGetBubbles) + +cancelable :: EventClass e => EventM e t Bool +cancelable = event >>= (liftIO . eventGetCancelable) + +timeStamp :: EventClass e => EventM e t Word +timeStamp = event >>= (liftIO . eventGetTimeStamp) + +stopPropagation :: EventClass e => EventM e t () +stopPropagation = event >>= (liftIO . eventStopPropagation) + +preventDefault :: EventClass e => EventM e t () +preventDefault = event >>= (liftIO . eventPreventDefault) + +defaultPrevented :: EventClass e => EventM e t Bool +defaultPrevented = event >>= (liftIO . eventGetDefaultPrevented) + +stopImmediatePropagation :: EventClass e => EventM e t () +stopImmediatePropagation = event >>= (liftIO . eventStopImmediatePropagation) + +srcElement :: EventClass e => EventM e t (Maybe EventTarget) +srcElement = event >>= (liftIO . eventGetSrcElement) + +getCancelBubble :: EventClass e => EventM e t Bool +getCancelBubble = event >>= (liftIO . eventGetCancelBubble) + +cancelBubble :: EventClass e => Bool -> EventM e t () +cancelBubble f = event >>= (liftIO . flip eventSetCancelBubble f) + +getReturnValue :: EventClass e => EventM e t Bool +getReturnValue = event >>= (liftIO . eventGetReturnValue) + +returnValue :: EventClass e => Bool -> EventM e t () +returnValue f = event >>= (liftIO . flip eventSetReturnValue f) + +uiView :: UIEventClass e => EventM e t (Maybe DOMWindow) +uiView = event >>= (liftIO . uiEventGetView) + +uiDetail :: UIEventClass e => EventM e t Int +uiDetail = event >>= (liftIO . uiEventGetDetail) + +uiKeyCode :: UIEventClass e => EventM e t Int +uiKeyCode = event >>= (liftIO . uiEventGetKeyCode) + +uiCharCode :: UIEventClass e => EventM e t Int +uiCharCode = event >>= (liftIO . uiEventGetCharCode) + +uiLayerX :: UIEventClass e => EventM e t Int +uiLayerX = event >>= (liftIO . uiEventGetLayerX) + +uiLayerY :: UIEventClass e => EventM e t Int +uiLayerY = event >>= (liftIO . uiEventGetLayerY) + +uiLayerXY :: UIEventClass e => EventM e t (Int, Int) +uiLayerXY = do + e <- event + liftIO $ do + x <- uiEventGetLayerX e + y <- uiEventGetLayerY e + return (x, y) + +uiPageX :: UIEventClass e => EventM e t Int +uiPageX = event >>= (liftIO . uiEventGetPageX) + +uiPageY :: UIEventClass e => EventM e t Int +uiPageY = event >>= (liftIO . uiEventGetPageY) + +uiPageXY :: UIEventClass e => EventM e t (Int, Int) +uiPageXY = do + e <- event + liftIO $ do + x <- uiEventGetPageX e + y <- uiEventGetPageY e + return (x, y) + +uiWhich :: UIEventClass e => EventM e t Int +uiWhich = event >>= (liftIO . uiEventGetWhich) + +mouseScreenX :: MouseEventClass e => EventM e t Int +mouseScreenX = event >>= (liftIO . mouseEventGetScreenX) + +mouseScreenY :: MouseEventClass e => EventM e t Int +mouseScreenY = event >>= (liftIO . mouseEventGetScreenY) + +mouseScreenXY :: MouseEventClass e => EventM e t (Int, Int) +mouseScreenXY = do + e <- event + liftIO $ do + x <- mouseEventGetScreenX e + y <- mouseEventGetScreenY e + return (x, y) + +mouseClientX :: MouseEventClass e => EventM e t Int +mouseClientX = event >>= (liftIO . mouseEventGetClientX) + +mouseClientY :: MouseEventClass e => EventM e t Int +mouseClientY = event >>= (liftIO . mouseEventGetClientY) + +mouseClientXY :: MouseEventClass e => EventM e t (Int, Int) +mouseClientXY = do + e <- event + liftIO $ do + x <- mouseEventGetClientX e + y <- mouseEventGetClientY e + return (x, y) + +mouseWebkitMovementX :: MouseEventClass e => EventM e t Int +mouseWebkitMovementX = event >>= (liftIO . mouseEventGetWebkitMovementX) + +mouseWebkitMovementY :: MouseEventClass e => EventM e t Int +mouseWebkitMovementY = event >>= (liftIO . mouseEventGetWebkitMovementY) + +mouseWebkitMovementXY :: MouseEventClass e => EventM e t (Int, Int) +mouseWebkitMovementXY = do + e <- event + liftIO $ do + x <- mouseEventGetWebkitMovementX e + y <- mouseEventGetWebkitMovementY e + return (x, y) + +mouseCtrlKey :: MouseEventClass e => EventM e t Bool +mouseCtrlKey = event >>= (liftIO . mouseEventGetCtrlKey) + +mouseShiftKey :: MouseEventClass e => EventM e t Bool +mouseShiftKey = event >>= (liftIO . mouseEventGetShiftKey) + +mouseAltKey :: MouseEventClass e => EventM e t Bool +mouseAltKey = event >>= (liftIO . mouseEventGetAltKey) + +mouseMetaKey :: MouseEventClass e => EventM e t Bool +mouseMetaKey = event >>= (liftIO . mouseEventGetMetaKey) + +mouseButton :: MouseEventClass e => EventM e t Word +mouseButton = event >>= (liftIO . mouseEventGetButton) + +mouseRelatedTarget :: MouseEventClass e => EventM e t (Maybe EventTarget) +mouseRelatedTarget = event >>= (liftIO . mouseEventGetRelatedTarget) + +mouseOffsetX :: MouseEventClass e => EventM e t Int +mouseOffsetX = event >>= (liftIO . mouseEventGetOffsetX) + +mouseOffsetY :: MouseEventClass e => EventM e t Int +mouseOffsetY = event >>= (liftIO . mouseEventGetOffsetY) + +mouseOffsetXY :: MouseEventClass e => EventM e t (Int, Int) +mouseOffsetXY = do + e <- event + liftIO $ do + x <- mouseEventGetOffsetX e + y <- mouseEventGetOffsetY e + return (x, y) + +mouseX :: MouseEventClass e => EventM e t Int +mouseX = event >>= (liftIO . mouseEventGetX) + +mouseY :: MouseEventClass e => EventM e t Int +mouseY = event >>= (liftIO . mouseEventGetY) + +mouseXY :: MouseEventClass e => EventM e t (Int, Int) +mouseXY = do + e <- event + liftIO $ do + x <- mouseEventGetX e + y <- mouseEventGetY e + return (x, y) + +mouseFromElement :: MouseEventClass e => EventM e t (Maybe Node) +mouseFromElement = event >>= (liftIO . mouseEventGetFromElement) + +mouseToElement :: MouseEventClass e => EventM e t (Maybe Node) +mouseToElement = event >>= (liftIO . mouseEventGetToElement) + +connect :: (GObjectClass t, EventClass e) => String -> t -> EventM e t () -> IO Bool +connect eventName target callback = + eventTargetAddEventListener target eventName False $ curry (runReaderT callback) diff --git a/Graphics/UI/Gtk/WebKit/DOM/EventTargetClosures.chs b/Graphics/UI/Gtk/WebKit/DOM/EventTargetClosures.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/EventTargetClosures.chs @@ -0,0 +1,35 @@ +{-# LANGUAGE CPP #-} +{-# CFILES events.c #-} +module Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures + (eventTargetAddEventListener) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError + +{# pointer *GClosure newtype #} + +foreign import ccall unsafe "gtk2hs_closure_new" + gtk2hs_closure_new :: StablePtr a -> IO (Ptr GClosure) + +eventTargetAddEventListener :: + (GObjectClass self, EventClass event) => + self -> String -> Bool -> (self -> event -> IO ()) -> IO Bool +eventTargetAddEventListener self eventName bubble user = do + sptr <- newStablePtr action + gclosurePtr <- gtk2hs_closure_new sptr + toBool <$> ( + withUTFString eventName $ \ eventNamePtr -> + {# call webkit_dom_event_target_add_event_listener_closure #} + (unsafeCastGObject $ toGObject self) + eventNamePtr + (GClosure gclosurePtr) + (fromBool bubble)) + where action :: Ptr GObject -> Ptr GObject -> IO () + action obj1 obj2 = + failOnGError $ + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj2) >>= \obj2' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') (unsafeCastGObject obj2') + diff --git a/Graphics/UI/Gtk/WebKit/DOM/Events.chs b/Graphics/UI/Gtk/WebKit/DOM/Events.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Events.chs @@ -0,0 +1,7 @@ +module Graphics.UI.Gtk.WebKit.DOM.Events (Event, EventClass) where + +data Event = Event + +class EventClass a + +instance EventClass Event diff --git a/Graphics/UI/Gtk/WebKit/DOM/File.chs b/Graphics/UI/Gtk/WebKit/DOM/File.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/File.chs @@ -0,0 +1,12 @@ +module Graphics.UI.Gtk.WebKit.DOM.File (fileGetName) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +fileGetName :: (FileClass self) => self -> IO String +fileGetName self + = ({# call webkit_dom_file_get_name #} (toFile self)) >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/FileList.chs b/Graphics/UI/Gtk/WebKit/DOM/FileList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/FileList.chs @@ -0,0 +1,20 @@ +module Graphics.UI.Gtk.WebKit.DOM.FileList + (fileListItem, fileListGetLength) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +fileListItem :: + (FileListClass self) => self -> Word -> IO (Maybe File) +fileListItem self index + = maybeNull (makeNewGObject mkFile) + ({# call webkit_dom_file_list_item #} (toFileList self) + (fromIntegral index)) + +fileListGetLength :: (FileListClass self) => self -> IO Word +fileListGetLength self + = fromIntegral <$> + ({# call webkit_dom_file_list_get_length #} (toFileList self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Geolocation.chs b/Graphics/UI/Gtk/WebKit/DOM/Geolocation.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Geolocation.chs @@ -0,0 +1,15 @@ +module Graphics.UI.Gtk.WebKit.DOM.Geolocation + (geolocationClearWatch) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +geolocationClearWatch :: + (GeolocationClass self) => self -> Int -> IO () +geolocationClearWatch self watchId + = {# call webkit_dom_geolocation_clear_watch #} + (toGeolocation self) + (fromIntegral watchId) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLAnchorElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLAnchorElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLAnchorElement.chs @@ -0,0 +1,349 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLAnchorElement + (htmlAnchorElementSetCharset, htmlAnchorElementGetCharset, + htmlAnchorElementSetCoords, htmlAnchorElementGetCoords, + htmlAnchorElementSetDownload, htmlAnchorElementGetDownload, + htmlAnchorElementSetHref, htmlAnchorElementGetHref, + htmlAnchorElementSetHreflang, htmlAnchorElementGetHreflang, + htmlAnchorElementSetName, htmlAnchorElementGetName, + htmlAnchorElementSetPing, htmlAnchorElementGetPing, + htmlAnchorElementSetRel, htmlAnchorElementGetRel, + htmlAnchorElementSetRev, htmlAnchorElementGetRev, + htmlAnchorElementSetShape, htmlAnchorElementGetShape, + htmlAnchorElementSetTarget, htmlAnchorElementGetTarget, + htmlAnchorElementSetHash, htmlAnchorElementGetHash, + htmlAnchorElementSetHost, htmlAnchorElementGetHost, + htmlAnchorElementSetHostname, htmlAnchorElementGetHostname, + htmlAnchorElementSetPathname, htmlAnchorElementGetPathname, + htmlAnchorElementSetPort, htmlAnchorElementGetPort, + htmlAnchorElementSetProtocol, htmlAnchorElementGetProtocol, + htmlAnchorElementSetSearch, htmlAnchorElementGetSearch, + htmlAnchorElementGetOrigin, htmlAnchorElementGetText) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlAnchorElementSetCharset :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetCharset self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_charset #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetCharset :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetCharset self + = ({# call webkit_dom_html_anchor_element_get_charset #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetCoords :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetCoords self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_coords #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetCoords :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetCoords self + = ({# call webkit_dom_html_anchor_element_get_coords #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetDownload :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetDownload self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_download #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetDownload :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetDownload self + = ({# call webkit_dom_html_anchor_element_get_download #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetHref :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetHref self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_href #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetHref :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetHref self + = ({# call webkit_dom_html_anchor_element_get_href #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetHreflang :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetHreflang self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_hreflang #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetHreflang :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetHreflang self + = ({# call webkit_dom_html_anchor_element_get_hreflang #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetName :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_name #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetName :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetName self + = ({# call webkit_dom_html_anchor_element_get_name #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetPing :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetPing self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_ping #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetPing :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetPing self + = ({# call webkit_dom_html_anchor_element_get_ping #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetRel :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetRel self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_rel #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetRel :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetRel self + = ({# call webkit_dom_html_anchor_element_get_rel #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetRev :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetRev self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_rev #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetRev :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetRev self + = ({# call webkit_dom_html_anchor_element_get_rev #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetShape :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetShape self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_shape #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetShape :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetShape self + = ({# call webkit_dom_html_anchor_element_get_shape #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetTarget :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetTarget self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_target #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetTarget :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetTarget self + = ({# call webkit_dom_html_anchor_element_get_target #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetHash :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetHash self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_hash #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetHash :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetHash self + = ({# call webkit_dom_html_anchor_element_get_hash #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetHost :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetHost self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_host #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetHost :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetHost self + = ({# call webkit_dom_html_anchor_element_get_host #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetHostname :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetHostname self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_hostname #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetHostname :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetHostname self + = ({# call webkit_dom_html_anchor_element_get_hostname #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetPathname :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetPathname self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_pathname #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetPathname :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetPathname self + = ({# call webkit_dom_html_anchor_element_get_pathname #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetPort :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetPort self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_port #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetPort :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetPort self + = ({# call webkit_dom_html_anchor_element_get_port #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetProtocol :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetProtocol self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_protocol #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetProtocol :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetProtocol self + = ({# call webkit_dom_html_anchor_element_get_protocol #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementSetSearch :: + (HTMLAnchorElementClass self) => self -> String -> IO () +htmlAnchorElementSetSearch self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_search #} + (toHTMLAnchorElement self) + valPtr + +htmlAnchorElementGetSearch :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetSearch self + = ({# call webkit_dom_html_anchor_element_get_search #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementGetOrigin :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetOrigin self + = ({# call webkit_dom_html_anchor_element_get_origin #} + (toHTMLAnchorElement self)) + >>= + readUTFString + +htmlAnchorElementGetText :: + (HTMLAnchorElementClass self) => self -> IO String +htmlAnchorElementGetText self + = ({# call webkit_dom_html_anchor_element_get_text #} + (toHTMLAnchorElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLAppletElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLAppletElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLAppletElement.chs @@ -0,0 +1,200 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLAppletElement + (htmlAppletElementSetAlign, htmlAppletElementGetAlign, + htmlAppletElementSetAlt, htmlAppletElementGetAlt, + htmlAppletElementSetArchive, htmlAppletElementGetArchive, + htmlAppletElementSetCode, htmlAppletElementGetCode, + htmlAppletElementSetCodeBase, htmlAppletElementGetCodeBase, + htmlAppletElementSetHeight, htmlAppletElementGetHeight, + htmlAppletElementSetHspace, htmlAppletElementGetHspace, + htmlAppletElementSetName, htmlAppletElementGetName, + htmlAppletElementSetObject, htmlAppletElementGetObject, + htmlAppletElementSetVspace, htmlAppletElementGetVspace, + htmlAppletElementSetWidth, htmlAppletElementGetWidth) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlAppletElementSetAlign :: + (HTMLAppletElementClass self) => self -> String -> IO () +htmlAppletElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_align #} + (toHTMLAppletElement self) + valPtr + +htmlAppletElementGetAlign :: + (HTMLAppletElementClass self) => self -> IO String +htmlAppletElementGetAlign self + = ({# call webkit_dom_html_applet_element_get_align #} + (toHTMLAppletElement self)) + >>= + readUTFString + +htmlAppletElementSetAlt :: + (HTMLAppletElementClass self) => self -> String -> IO () +htmlAppletElementSetAlt self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_alt #} + (toHTMLAppletElement self) + valPtr + +htmlAppletElementGetAlt :: + (HTMLAppletElementClass self) => self -> IO String +htmlAppletElementGetAlt self + = ({# call webkit_dom_html_applet_element_get_alt #} + (toHTMLAppletElement self)) + >>= + readUTFString + +htmlAppletElementSetArchive :: + (HTMLAppletElementClass self) => self -> String -> IO () +htmlAppletElementSetArchive self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_archive #} + (toHTMLAppletElement self) + valPtr + +htmlAppletElementGetArchive :: + (HTMLAppletElementClass self) => self -> IO String +htmlAppletElementGetArchive self + = ({# call webkit_dom_html_applet_element_get_archive #} + (toHTMLAppletElement self)) + >>= + readUTFString + +htmlAppletElementSetCode :: + (HTMLAppletElementClass self) => self -> String -> IO () +htmlAppletElementSetCode self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_code #} + (toHTMLAppletElement self) + valPtr + +htmlAppletElementGetCode :: + (HTMLAppletElementClass self) => self -> IO String +htmlAppletElementGetCode self + = ({# call webkit_dom_html_applet_element_get_code #} + (toHTMLAppletElement self)) + >>= + readUTFString + +htmlAppletElementSetCodeBase :: + (HTMLAppletElementClass self) => self -> String -> IO () +htmlAppletElementSetCodeBase self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_code_base #} + (toHTMLAppletElement self) + valPtr + +htmlAppletElementGetCodeBase :: + (HTMLAppletElementClass self) => self -> IO String +htmlAppletElementGetCodeBase self + = ({# call webkit_dom_html_applet_element_get_code_base #} + (toHTMLAppletElement self)) + >>= + readUTFString + +htmlAppletElementSetHeight :: + (HTMLAppletElementClass self) => self -> String -> IO () +htmlAppletElementSetHeight self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_height #} + (toHTMLAppletElement self) + valPtr + +htmlAppletElementGetHeight :: + (HTMLAppletElementClass self) => self -> IO String +htmlAppletElementGetHeight self + = ({# call webkit_dom_html_applet_element_get_height #} + (toHTMLAppletElement self)) + >>= + readUTFString + +htmlAppletElementSetHspace :: + (HTMLAppletElementClass self) => self -> Int -> IO () +htmlAppletElementSetHspace self val + = {# call webkit_dom_html_applet_element_set_hspace #} + (toHTMLAppletElement self) + (fromIntegral val) + +htmlAppletElementGetHspace :: + (HTMLAppletElementClass self) => self -> IO Int +htmlAppletElementGetHspace self + = fromIntegral <$> + ({# call webkit_dom_html_applet_element_get_hspace #} + (toHTMLAppletElement self)) + +htmlAppletElementSetName :: + (HTMLAppletElementClass self) => self -> String -> IO () +htmlAppletElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_name #} + (toHTMLAppletElement self) + valPtr + +htmlAppletElementGetName :: + (HTMLAppletElementClass self) => self -> IO String +htmlAppletElementGetName self + = ({# call webkit_dom_html_applet_element_get_name #} + (toHTMLAppletElement self)) + >>= + readUTFString + +htmlAppletElementSetObject :: + (HTMLAppletElementClass self) => self -> String -> IO () +htmlAppletElementSetObject self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_object #} + (toHTMLAppletElement self) + valPtr + +htmlAppletElementGetObject :: + (HTMLAppletElementClass self) => self -> IO String +htmlAppletElementGetObject self + = ({# call webkit_dom_html_applet_element_get_object #} + (toHTMLAppletElement self)) + >>= + readUTFString + +htmlAppletElementSetVspace :: + (HTMLAppletElementClass self) => self -> Int -> IO () +htmlAppletElementSetVspace self val + = {# call webkit_dom_html_applet_element_set_vspace #} + (toHTMLAppletElement self) + (fromIntegral val) + +htmlAppletElementGetVspace :: + (HTMLAppletElementClass self) => self -> IO Int +htmlAppletElementGetVspace self + = fromIntegral <$> + ({# call webkit_dom_html_applet_element_get_vspace #} + (toHTMLAppletElement self)) + +htmlAppletElementSetWidth :: + (HTMLAppletElementClass self) => self -> String -> IO () +htmlAppletElementSetWidth self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_width #} + (toHTMLAppletElement self) + valPtr + +htmlAppletElementGetWidth :: + (HTMLAppletElementClass self) => self -> IO String +htmlAppletElementGetWidth self + = ({# call webkit_dom_html_applet_element_get_width #} + (toHTMLAppletElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLAreaElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLAreaElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLAreaElement.chs @@ -0,0 +1,191 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLAreaElement + (htmlAreaElementSetAlt, htmlAreaElementGetAlt, + htmlAreaElementSetCoords, htmlAreaElementGetCoords, + htmlAreaElementSetHref, htmlAreaElementGetHref, + htmlAreaElementSetNoHref, htmlAreaElementGetNoHref, + htmlAreaElementSetPing, htmlAreaElementGetPing, + htmlAreaElementSetShape, htmlAreaElementGetShape, + htmlAreaElementSetTarget, htmlAreaElementGetTarget, + htmlAreaElementGetHash, htmlAreaElementGetHost, + htmlAreaElementGetHostname, htmlAreaElementGetPathname, + htmlAreaElementGetPort, htmlAreaElementGetProtocol, + htmlAreaElementGetSearch) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlAreaElementSetAlt :: + (HTMLAreaElementClass self) => self -> String -> IO () +htmlAreaElementSetAlt self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_area_element_set_alt #} + (toHTMLAreaElement self) + valPtr + +htmlAreaElementGetAlt :: + (HTMLAreaElementClass self) => self -> IO String +htmlAreaElementGetAlt self + = ({# call webkit_dom_html_area_element_get_alt #} + (toHTMLAreaElement self)) + >>= + readUTFString + +htmlAreaElementSetCoords :: + (HTMLAreaElementClass self) => self -> String -> IO () +htmlAreaElementSetCoords self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_area_element_set_coords #} + (toHTMLAreaElement self) + valPtr + +htmlAreaElementGetCoords :: + (HTMLAreaElementClass self) => self -> IO String +htmlAreaElementGetCoords self + = ({# call webkit_dom_html_area_element_get_coords #} + (toHTMLAreaElement self)) + >>= + readUTFString + +htmlAreaElementSetHref :: + (HTMLAreaElementClass self) => self -> String -> IO () +htmlAreaElementSetHref self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_area_element_set_href #} + (toHTMLAreaElement self) + valPtr + +htmlAreaElementGetHref :: + (HTMLAreaElementClass self) => self -> IO String +htmlAreaElementGetHref self + = ({# call webkit_dom_html_area_element_get_href #} + (toHTMLAreaElement self)) + >>= + readUTFString + +htmlAreaElementSetNoHref :: + (HTMLAreaElementClass self) => self -> Bool -> IO () +htmlAreaElementSetNoHref self val + = {# call webkit_dom_html_area_element_set_no_href #} + (toHTMLAreaElement self) + (fromBool val) + +htmlAreaElementGetNoHref :: + (HTMLAreaElementClass self) => self -> IO Bool +htmlAreaElementGetNoHref self + = toBool <$> + ({# call webkit_dom_html_area_element_get_no_href #} + (toHTMLAreaElement self)) + +htmlAreaElementSetPing :: + (HTMLAreaElementClass self) => self -> String -> IO () +htmlAreaElementSetPing self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_area_element_set_ping #} + (toHTMLAreaElement self) + valPtr + +htmlAreaElementGetPing :: + (HTMLAreaElementClass self) => self -> IO String +htmlAreaElementGetPing self + = ({# call webkit_dom_html_area_element_get_ping #} + (toHTMLAreaElement self)) + >>= + readUTFString + +htmlAreaElementSetShape :: + (HTMLAreaElementClass self) => self -> String -> IO () +htmlAreaElementSetShape self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_area_element_set_shape #} + (toHTMLAreaElement self) + valPtr + +htmlAreaElementGetShape :: + (HTMLAreaElementClass self) => self -> IO String +htmlAreaElementGetShape self + = ({# call webkit_dom_html_area_element_get_shape #} + (toHTMLAreaElement self)) + >>= + readUTFString + +htmlAreaElementSetTarget :: + (HTMLAreaElementClass self) => self -> String -> IO () +htmlAreaElementSetTarget self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_area_element_set_target #} + (toHTMLAreaElement self) + valPtr + +htmlAreaElementGetTarget :: + (HTMLAreaElementClass self) => self -> IO String +htmlAreaElementGetTarget self + = ({# call webkit_dom_html_area_element_get_target #} + (toHTMLAreaElement self)) + >>= + readUTFString + +htmlAreaElementGetHash :: + (HTMLAreaElementClass self) => self -> IO String +htmlAreaElementGetHash self + = ({# call webkit_dom_html_area_element_get_hash #} + (toHTMLAreaElement self)) + >>= + readUTFString + +htmlAreaElementGetHost :: + (HTMLAreaElementClass self) => self -> IO String +htmlAreaElementGetHost self + = ({# call webkit_dom_html_area_element_get_host #} + (toHTMLAreaElement self)) + >>= + readUTFString + +htmlAreaElementGetHostname :: + (HTMLAreaElementClass self) => self -> IO String +htmlAreaElementGetHostname self + = ({# call webkit_dom_html_area_element_get_hostname #} + (toHTMLAreaElement self)) + >>= + readUTFString + +htmlAreaElementGetPathname :: + (HTMLAreaElementClass self) => self -> IO String +htmlAreaElementGetPathname self + = ({# call webkit_dom_html_area_element_get_pathname #} + (toHTMLAreaElement self)) + >>= + readUTFString + +htmlAreaElementGetPort :: + (HTMLAreaElementClass self) => self -> IO String +htmlAreaElementGetPort self + = ({# call webkit_dom_html_area_element_get_port #} + (toHTMLAreaElement self)) + >>= + readUTFString + +htmlAreaElementGetProtocol :: + (HTMLAreaElementClass self) => self -> IO String +htmlAreaElementGetProtocol self + = ({# call webkit_dom_html_area_element_get_protocol #} + (toHTMLAreaElement self)) + >>= + readUTFString + +htmlAreaElementGetSearch :: + (HTMLAreaElementClass self) => self -> IO String +htmlAreaElementGetSearch self + = ({# call webkit_dom_html_area_element_get_search #} + (toHTMLAreaElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLBRElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLBRElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLBRElement.chs @@ -0,0 +1,25 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLBRElement + (htmlbrElementSetClear, htmlbrElementGetClear) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlbrElementSetClear :: + (HTMLBRElementClass self) => self -> String -> IO () +htmlbrElementSetClear self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_htmlbr_element_set_clear #} + (toHTMLBRElement self) + valPtr + +htmlbrElementGetClear :: + (HTMLBRElementClass self) => self -> IO String +htmlbrElementGetClear self + = ({# call webkit_dom_htmlbr_element_get_clear #} + (toHTMLBRElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseElement.chs @@ -0,0 +1,44 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLBaseElement + (htmlBaseElementSetHref, htmlBaseElementGetHref, + htmlBaseElementSetTarget, htmlBaseElementGetTarget) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlBaseElementSetHref :: + (HTMLBaseElementClass self) => self -> String -> IO () +htmlBaseElementSetHref self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_base_element_set_href #} + (toHTMLBaseElement self) + valPtr + +htmlBaseElementGetHref :: + (HTMLBaseElementClass self) => self -> IO String +htmlBaseElementGetHref self + = ({# call webkit_dom_html_base_element_get_href #} + (toHTMLBaseElement self)) + >>= + readUTFString + +htmlBaseElementSetTarget :: + (HTMLBaseElementClass self) => self -> String -> IO () +htmlBaseElementSetTarget self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_base_element_set_target #} + (toHTMLBaseElement self) + valPtr + +htmlBaseElementGetTarget :: + (HTMLBaseElementClass self) => self -> IO String +htmlBaseElementGetTarget self + = ({# call webkit_dom_html_base_element_get_target #} + (toHTMLBaseElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseFontElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseFontElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseFontElement.chs @@ -0,0 +1,59 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLBaseFontElement + (htmlBaseFontElementSetColor, htmlBaseFontElementGetColor, + htmlBaseFontElementSetFace, htmlBaseFontElementGetFace, + htmlBaseFontElementSetSize, htmlBaseFontElementGetSize) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlBaseFontElementSetColor :: + (HTMLBaseFontElementClass self) => self -> String -> IO () +htmlBaseFontElementSetColor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_base_font_element_set_color #} + (toHTMLBaseFontElement self) + valPtr + +htmlBaseFontElementGetColor :: + (HTMLBaseFontElementClass self) => self -> IO String +htmlBaseFontElementGetColor self + = ({# call webkit_dom_html_base_font_element_get_color #} + (toHTMLBaseFontElement self)) + >>= + readUTFString + +htmlBaseFontElementSetFace :: + (HTMLBaseFontElementClass self) => self -> String -> IO () +htmlBaseFontElementSetFace self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_base_font_element_set_face #} + (toHTMLBaseFontElement self) + valPtr + +htmlBaseFontElementGetFace :: + (HTMLBaseFontElementClass self) => self -> IO String +htmlBaseFontElementGetFace self + = ({# call webkit_dom_html_base_font_element_get_face #} + (toHTMLBaseFontElement self)) + >>= + readUTFString + +htmlBaseFontElementSetSize :: + (HTMLBaseFontElementClass self) => self -> Int -> IO () +htmlBaseFontElementSetSize self val + = {# call webkit_dom_html_base_font_element_set_size #} + (toHTMLBaseFontElement self) + (fromIntegral val) + +htmlBaseFontElementGetSize :: + (HTMLBaseFontElementClass self) => self -> IO Int +htmlBaseFontElementGetSize self + = fromIntegral <$> + ({# call webkit_dom_html_base_font_element_get_size #} + (toHTMLBaseFontElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLBodyElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLBodyElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLBodyElement.chs @@ -0,0 +1,180 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLBodyElement + (htmlBodyElementSetALink, htmlBodyElementGetALink, + htmlBodyElementSetBackground, htmlBodyElementGetBackground, + htmlBodyElementSetBgColor, htmlBodyElementGetBgColor, + htmlBodyElementSetLink, htmlBodyElementGetLink, + htmlBodyElementSetText, htmlBodyElementGetText, + htmlBodyElementSetVLink, htmlBodyElementGetVLink, + htmlBodyElementOnbeforeunload, htmlBodyElementOnhashchange, + htmlBodyElementOnmessage, htmlBodyElementOnoffline, + htmlBodyElementOnonline, htmlBodyElementOnpopstate, + htmlBodyElementOnresize, htmlBodyElementOnstorage, + htmlBodyElementOnunload, htmlBodyElementOnorientationchange, + htmlBodyElementOnblur, htmlBodyElementOnerror, + htmlBodyElementOnfocus, htmlBodyElementOnload) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlBodyElementSetALink :: + (HTMLBodyElementClass self) => self -> String -> IO () +htmlBodyElementSetALink self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_body_element_set_a_link #} + (toHTMLBodyElement self) + valPtr + +htmlBodyElementGetALink :: + (HTMLBodyElementClass self) => self -> IO String +htmlBodyElementGetALink self + = ({# call webkit_dom_html_body_element_get_a_link #} + (toHTMLBodyElement self)) + >>= + readUTFString + +htmlBodyElementSetBackground :: + (HTMLBodyElementClass self) => self -> String -> IO () +htmlBodyElementSetBackground self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_body_element_set_background #} + (toHTMLBodyElement self) + valPtr + +htmlBodyElementGetBackground :: + (HTMLBodyElementClass self) => self -> IO String +htmlBodyElementGetBackground self + = ({# call webkit_dom_html_body_element_get_background #} + (toHTMLBodyElement self)) + >>= + readUTFString + +htmlBodyElementSetBgColor :: + (HTMLBodyElementClass self) => self -> String -> IO () +htmlBodyElementSetBgColor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_body_element_set_bg_color #} + (toHTMLBodyElement self) + valPtr + +htmlBodyElementGetBgColor :: + (HTMLBodyElementClass self) => self -> IO String +htmlBodyElementGetBgColor self + = ({# call webkit_dom_html_body_element_get_bg_color #} + (toHTMLBodyElement self)) + >>= + readUTFString + +htmlBodyElementSetLink :: + (HTMLBodyElementClass self) => self -> String -> IO () +htmlBodyElementSetLink self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_body_element_set_link #} + (toHTMLBodyElement self) + valPtr + +htmlBodyElementGetLink :: + (HTMLBodyElementClass self) => self -> IO String +htmlBodyElementGetLink self + = ({# call webkit_dom_html_body_element_get_link #} + (toHTMLBodyElement self)) + >>= + readUTFString + +htmlBodyElementSetText :: + (HTMLBodyElementClass self) => self -> String -> IO () +htmlBodyElementSetText self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_body_element_set_text #} + (toHTMLBodyElement self) + valPtr + +htmlBodyElementGetText :: + (HTMLBodyElementClass self) => self -> IO String +htmlBodyElementGetText self + = ({# call webkit_dom_html_body_element_get_text #} + (toHTMLBodyElement self)) + >>= + readUTFString + +htmlBodyElementSetVLink :: + (HTMLBodyElementClass self) => self -> String -> IO () +htmlBodyElementSetVLink self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_body_element_set_v_link #} + (toHTMLBodyElement self) + valPtr + +htmlBodyElementGetVLink :: + (HTMLBodyElementClass self) => self -> IO String +htmlBodyElementGetVLink self + = ({# call webkit_dom_html_body_element_get_v_link #} + (toHTMLBodyElement self)) + >>= + readUTFString + +htmlBodyElementOnbeforeunload :: + (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) +htmlBodyElementOnbeforeunload = (connect "beforeunload") + +htmlBodyElementOnhashchange :: + (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) +htmlBodyElementOnhashchange = (connect "hashchange") + +htmlBodyElementOnmessage :: + (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) +htmlBodyElementOnmessage = (connect "message") + +htmlBodyElementOnoffline :: + (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) +htmlBodyElementOnoffline = (connect "offline") + +htmlBodyElementOnonline :: + (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) +htmlBodyElementOnonline = (connect "online") + +htmlBodyElementOnpopstate :: + (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) +htmlBodyElementOnpopstate = (connect "popstate") + +htmlBodyElementOnresize :: + (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) +htmlBodyElementOnresize = (connect "resize") + +htmlBodyElementOnstorage :: + (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) +htmlBodyElementOnstorage = (connect "storage") + +htmlBodyElementOnunload :: + (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) +htmlBodyElementOnunload = (connect "unload") + +htmlBodyElementOnorientationchange :: + (HTMLBodyElementClass self) => + Signal self (EventM UIEvent self ()) +htmlBodyElementOnorientationchange = (connect "orientationchange") + +htmlBodyElementOnblur :: + (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) +htmlBodyElementOnblur = (connect "blur") + +htmlBodyElementOnerror :: + (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) +htmlBodyElementOnerror = (connect "error") + +htmlBodyElementOnfocus :: + (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) +htmlBodyElementOnfocus = (connect "focus") + +htmlBodyElementOnload :: + (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) +htmlBodyElementOnload = (connect "load") diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLButtonElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLButtonElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLButtonElement.chs @@ -0,0 +1,218 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLButtonElement + (htmlButtonElementCheckValidity, + htmlButtonElementSetCustomValidity, htmlButtonElementSetAutofocus, + htmlButtonElementGetAutofocus, htmlButtonElementSetDisabled, + htmlButtonElementGetDisabled, htmlButtonElementGetForm, + htmlButtonElementSetFormAction, htmlButtonElementGetFormAction, + htmlButtonElementSetFormEnctype, htmlButtonElementGetFormEnctype, + htmlButtonElementSetFormMethod, htmlButtonElementGetFormMethod, + htmlButtonElementSetFormNoValidate, + htmlButtonElementGetFormNoValidate, htmlButtonElementSetFormTarget, + htmlButtonElementGetFormTarget, htmlButtonElementSetName, + htmlButtonElementGetName, htmlButtonElementSetValue, + htmlButtonElementGetValue, htmlButtonElementGetWillValidate, + htmlButtonElementGetValidity, + htmlButtonElementGetValidationMessage, htmlButtonElementGetLabels) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlButtonElementCheckValidity :: + (HTMLButtonElementClass self) => self -> IO Bool +htmlButtonElementCheckValidity self + = toBool <$> + ({# call webkit_dom_html_button_element_check_validity #} + (toHTMLButtonElement self)) + +htmlButtonElementSetCustomValidity :: + (HTMLButtonElementClass self) => self -> String -> IO () +htmlButtonElementSetCustomValidity self error + = withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_button_element_set_custom_validity #} + (toHTMLButtonElement self) + errorPtr + +htmlButtonElementSetAutofocus :: + (HTMLButtonElementClass self) => self -> Bool -> IO () +htmlButtonElementSetAutofocus self val + = {# call webkit_dom_html_button_element_set_autofocus #} + (toHTMLButtonElement self) + (fromBool val) + +htmlButtonElementGetAutofocus :: + (HTMLButtonElementClass self) => self -> IO Bool +htmlButtonElementGetAutofocus self + = toBool <$> + ({# call webkit_dom_html_button_element_get_autofocus #} + (toHTMLButtonElement self)) + +htmlButtonElementSetDisabled :: + (HTMLButtonElementClass self) => self -> Bool -> IO () +htmlButtonElementSetDisabled self val + = {# call webkit_dom_html_button_element_set_disabled #} + (toHTMLButtonElement self) + (fromBool val) + +htmlButtonElementGetDisabled :: + (HTMLButtonElementClass self) => self -> IO Bool +htmlButtonElementGetDisabled self + = toBool <$> + ({# call webkit_dom_html_button_element_get_disabled #} + (toHTMLButtonElement self)) + +htmlButtonElementGetForm :: + (HTMLButtonElementClass self) => self -> IO (Maybe HTMLFormElement) +htmlButtonElementGetForm self + = maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_button_element_get_form #} + (toHTMLButtonElement self)) + +htmlButtonElementSetFormAction :: + (HTMLButtonElementClass self) => self -> String -> IO () +htmlButtonElementSetFormAction self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_button_element_set_form_action #} + (toHTMLButtonElement self) + valPtr + +htmlButtonElementGetFormAction :: + (HTMLButtonElementClass self) => self -> IO String +htmlButtonElementGetFormAction self + = ({# call webkit_dom_html_button_element_get_form_action #} + (toHTMLButtonElement self)) + >>= + readUTFString + +htmlButtonElementSetFormEnctype :: + (HTMLButtonElementClass self) => self -> String -> IO () +htmlButtonElementSetFormEnctype self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_button_element_set_form_enctype #} + (toHTMLButtonElement self) + valPtr + +htmlButtonElementGetFormEnctype :: + (HTMLButtonElementClass self) => self -> IO String +htmlButtonElementGetFormEnctype self + = ({# call webkit_dom_html_button_element_get_form_enctype #} + (toHTMLButtonElement self)) + >>= + readUTFString + +htmlButtonElementSetFormMethod :: + (HTMLButtonElementClass self) => self -> String -> IO () +htmlButtonElementSetFormMethod self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_button_element_set_form_method #} + (toHTMLButtonElement self) + valPtr + +htmlButtonElementGetFormMethod :: + (HTMLButtonElementClass self) => self -> IO String +htmlButtonElementGetFormMethod self + = ({# call webkit_dom_html_button_element_get_form_method #} + (toHTMLButtonElement self)) + >>= + readUTFString + +htmlButtonElementSetFormNoValidate :: + (HTMLButtonElementClass self) => self -> Bool -> IO () +htmlButtonElementSetFormNoValidate self val + = {# call webkit_dom_html_button_element_set_form_no_validate #} + (toHTMLButtonElement self) + (fromBool val) + +htmlButtonElementGetFormNoValidate :: + (HTMLButtonElementClass self) => self -> IO Bool +htmlButtonElementGetFormNoValidate self + = toBool <$> + ({# call webkit_dom_html_button_element_get_form_no_validate #} + (toHTMLButtonElement self)) + +htmlButtonElementSetFormTarget :: + (HTMLButtonElementClass self) => self -> String -> IO () +htmlButtonElementSetFormTarget self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_button_element_set_form_target #} + (toHTMLButtonElement self) + valPtr + +htmlButtonElementGetFormTarget :: + (HTMLButtonElementClass self) => self -> IO String +htmlButtonElementGetFormTarget self + = ({# call webkit_dom_html_button_element_get_form_target #} + (toHTMLButtonElement self)) + >>= + readUTFString + +htmlButtonElementSetName :: + (HTMLButtonElementClass self) => self -> String -> IO () +htmlButtonElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_button_element_set_name #} + (toHTMLButtonElement self) + valPtr + +htmlButtonElementGetName :: + (HTMLButtonElementClass self) => self -> IO String +htmlButtonElementGetName self + = ({# call webkit_dom_html_button_element_get_name #} + (toHTMLButtonElement self)) + >>= + readUTFString + +htmlButtonElementSetValue :: + (HTMLButtonElementClass self) => self -> String -> IO () +htmlButtonElementSetValue self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_button_element_set_value #} + (toHTMLButtonElement self) + valPtr + +htmlButtonElementGetValue :: + (HTMLButtonElementClass self) => self -> IO String +htmlButtonElementGetValue self + = ({# call webkit_dom_html_button_element_get_value #} + (toHTMLButtonElement self)) + >>= + readUTFString + +htmlButtonElementGetWillValidate :: + (HTMLButtonElementClass self) => self -> IO Bool +htmlButtonElementGetWillValidate self + = toBool <$> + ({# call webkit_dom_html_button_element_get_will_validate #} + (toHTMLButtonElement self)) + +htmlButtonElementGetValidity :: + (HTMLButtonElementClass self) => self -> IO (Maybe ValidityState) +htmlButtonElementGetValidity self + = maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_button_element_get_validity #} + (toHTMLButtonElement self)) + +htmlButtonElementGetValidationMessage :: + (HTMLButtonElementClass self) => self -> IO String +htmlButtonElementGetValidationMessage self + = ({# call webkit_dom_html_button_element_get_validation_message #} + (toHTMLButtonElement self)) + >>= + readUTFString + +htmlButtonElementGetLabels :: + (HTMLButtonElementClass self) => self -> IO (Maybe NodeList) +htmlButtonElementGetLabels self + = maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_button_element_get_labels #} + (toHTMLButtonElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLCanvasElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLCanvasElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLCanvasElement.chs @@ -0,0 +1,38 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLCanvasElement + (htmlCanvasElementSetWidth, htmlCanvasElementGetWidth, + htmlCanvasElementSetHeight, htmlCanvasElementGetHeight) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlCanvasElementSetWidth :: + (HTMLCanvasElementClass self) => self -> Int -> IO () +htmlCanvasElementSetWidth self val + = {# call webkit_dom_html_canvas_element_set_width #} + (toHTMLCanvasElement self) + (fromIntegral val) + +htmlCanvasElementGetWidth :: + (HTMLCanvasElementClass self) => self -> IO Int +htmlCanvasElementGetWidth self + = fromIntegral <$> + ({# call webkit_dom_html_canvas_element_get_width #} + (toHTMLCanvasElement self)) + +htmlCanvasElementSetHeight :: + (HTMLCanvasElementClass self) => self -> Int -> IO () +htmlCanvasElementSetHeight self val + = {# call webkit_dom_html_canvas_element_set_height #} + (toHTMLCanvasElement self) + (fromIntegral val) + +htmlCanvasElementGetHeight :: + (HTMLCanvasElementClass self) => self -> IO Int +htmlCanvasElementGetHeight self + = fromIntegral <$> + ({# call webkit_dom_html_canvas_element_get_height #} + (toHTMLCanvasElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLCollection.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLCollection.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLCollection.chs @@ -0,0 +1,22 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLCollection + (htmlCollectionItem, htmlCollectionGetLength) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlCollectionItem :: + (HTMLCollectionClass self) => self -> Word -> IO (Maybe Node) +htmlCollectionItem self index + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_html_collection_item #} (toHTMLCollection self) + (fromIntegral index)) + +htmlCollectionGetLength :: + (HTMLCollectionClass self) => self -> IO Word +htmlCollectionGetLength self + = fromIntegral <$> + ({# call webkit_dom_html_collection_get_length #} + (toHTMLCollection self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDListElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDListElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDListElement.chs @@ -0,0 +1,22 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLDListElement + (htmldListElementSetCompact, htmldListElementGetCompact) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmldListElementSetCompact :: + (HTMLDListElementClass self) => self -> Bool -> IO () +htmldListElementSetCompact self val + = {# call webkit_dom_htmld_list_element_set_compact #} + (toHTMLDListElement self) + (fromBool val) + +htmldListElementGetCompact :: + (HTMLDListElementClass self) => self -> IO Bool +htmldListElementGetCompact self + = toBool <$> + ({# call webkit_dom_htmld_list_element_get_compact #} + (toHTMLDListElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDetailsElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDetailsElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDetailsElement.chs @@ -0,0 +1,22 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLDetailsElement + (htmlDetailsElementSetOpen, htmlDetailsElementGetOpen) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlDetailsElementSetOpen :: + (HTMLDetailsElementClass self) => self -> Bool -> IO () +htmlDetailsElementSetOpen self val + = {# call webkit_dom_html_details_element_set_open #} + (toHTMLDetailsElement self) + (fromBool val) + +htmlDetailsElementGetOpen :: + (HTMLDetailsElementClass self) => self -> IO Bool +htmlDetailsElementGetOpen self + = toBool <$> + ({# call webkit_dom_html_details_element_get_open #} + (toHTMLDetailsElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDirectoryElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDirectoryElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDirectoryElement.chs @@ -0,0 +1,23 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLDirectoryElement + (htmlDirectoryElementSetCompact, htmlDirectoryElementGetCompact) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlDirectoryElementSetCompact :: + (HTMLDirectoryElementClass self) => self -> Bool -> IO () +htmlDirectoryElementSetCompact self val + = {# call webkit_dom_html_directory_element_set_compact #} + (toHTMLDirectoryElement self) + (fromBool val) + +htmlDirectoryElementGetCompact :: + (HTMLDirectoryElementClass self) => self -> IO Bool +htmlDirectoryElementGetCompact self + = toBool <$> + ({# call webkit_dom_html_directory_element_get_compact #} + (toHTMLDirectoryElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDivElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDivElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDivElement.chs @@ -0,0 +1,25 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLDivElement + (htmlDivElementSetAlign, htmlDivElementGetAlign) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlDivElementSetAlign :: + (HTMLDivElementClass self) => self -> String -> IO () +htmlDivElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_div_element_set_align #} + (toHTMLDivElement self) + valPtr + +htmlDivElementGetAlign :: + (HTMLDivElementClass self) => self -> IO String +htmlDivElementGetAlign self + = ({# call webkit_dom_html_div_element_get_align #} + (toHTMLDivElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDocument.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDocument.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDocument.chs @@ -0,0 +1,216 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLDocument + (htmlDocumentOpen, htmlDocumentClose, htmlDocumentClear, + htmlDocumentCaptureEvents, htmlDocumentReleaseEvents, + htmlDocumentHasFocus, htmlDocumentGetEmbeds, + htmlDocumentGetPlugins, htmlDocumentGetScripts, + htmlDocumentGetWidth, htmlDocumentGetHeight, htmlDocumentSetDir, + htmlDocumentGetDir, htmlDocumentSetDesignMode, + htmlDocumentGetDesignMode, htmlDocumentGetCompatMode, + htmlDocumentGetActiveElement, htmlDocumentSetBgColor, + htmlDocumentGetBgColor, htmlDocumentSetFgColor, + htmlDocumentGetFgColor, htmlDocumentSetAlinkColor, + htmlDocumentGetAlinkColor, htmlDocumentSetLinkColor, + htmlDocumentGetLinkColor, htmlDocumentSetVlinkColor, + htmlDocumentGetVlinkColor) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlDocumentOpen :: (HTMLDocumentClass self) => self -> IO () +htmlDocumentOpen self + = {# call webkit_dom_html_document_open #} (toHTMLDocument self) + +htmlDocumentClose :: (HTMLDocumentClass self) => self -> IO () +htmlDocumentClose self + = {# call webkit_dom_html_document_close #} (toHTMLDocument self) + +htmlDocumentClear :: (HTMLDocumentClass self) => self -> IO () +htmlDocumentClear self + = {# call webkit_dom_html_document_clear #} (toHTMLDocument self) + +htmlDocumentCaptureEvents :: + (HTMLDocumentClass self) => self -> IO () +htmlDocumentCaptureEvents self + = {# call webkit_dom_html_document_capture_events #} + (toHTMLDocument self) + +htmlDocumentReleaseEvents :: + (HTMLDocumentClass self) => self -> IO () +htmlDocumentReleaseEvents self + = {# call webkit_dom_html_document_release_events #} + (toHTMLDocument self) + +htmlDocumentHasFocus :: (HTMLDocumentClass self) => self -> IO Bool +htmlDocumentHasFocus self + = toBool <$> + ({# call webkit_dom_html_document_has_focus #} + (toHTMLDocument self)) + +htmlDocumentGetEmbeds :: + (HTMLDocumentClass self) => self -> IO (Maybe HTMLCollection) +htmlDocumentGetEmbeds self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_document_get_embeds #} + (toHTMLDocument self)) + +htmlDocumentGetPlugins :: + (HTMLDocumentClass self) => self -> IO (Maybe HTMLCollection) +htmlDocumentGetPlugins self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_document_get_plugins #} + (toHTMLDocument self)) + +htmlDocumentGetScripts :: + (HTMLDocumentClass self) => self -> IO (Maybe HTMLCollection) +htmlDocumentGetScripts self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_document_get_scripts #} + (toHTMLDocument self)) + +htmlDocumentGetWidth :: (HTMLDocumentClass self) => self -> IO Int +htmlDocumentGetWidth self + = fromIntegral <$> + ({# call webkit_dom_html_document_get_width #} + (toHTMLDocument self)) + +htmlDocumentGetHeight :: (HTMLDocumentClass self) => self -> IO Int +htmlDocumentGetHeight self + = fromIntegral <$> + ({# call webkit_dom_html_document_get_height #} + (toHTMLDocument self)) + +htmlDocumentSetDir :: + (HTMLDocumentClass self) => self -> String -> IO () +htmlDocumentSetDir self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_dir #} (toHTMLDocument self) + valPtr + +htmlDocumentGetDir :: (HTMLDocumentClass self) => self -> IO String +htmlDocumentGetDir self + = ({# call webkit_dom_html_document_get_dir #} + (toHTMLDocument self)) + >>= + readUTFString + +htmlDocumentSetDesignMode :: + (HTMLDocumentClass self) => self -> String -> IO () +htmlDocumentSetDesignMode self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_design_mode #} + (toHTMLDocument self) + valPtr + +htmlDocumentGetDesignMode :: + (HTMLDocumentClass self) => self -> IO String +htmlDocumentGetDesignMode self + = ({# call webkit_dom_html_document_get_design_mode #} + (toHTMLDocument self)) + >>= + readUTFString + +htmlDocumentGetCompatMode :: + (HTMLDocumentClass self) => self -> IO String +htmlDocumentGetCompatMode self + = ({# call webkit_dom_html_document_get_compat_mode #} + (toHTMLDocument self)) + >>= + readUTFString + +htmlDocumentGetActiveElement :: + (HTMLDocumentClass self) => self -> IO (Maybe Element) +htmlDocumentGetActiveElement self + = maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_html_document_get_active_element #} + (toHTMLDocument self)) + +htmlDocumentSetBgColor :: + (HTMLDocumentClass self) => self -> String -> IO () +htmlDocumentSetBgColor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_bg_color #} + (toHTMLDocument self) + valPtr + +htmlDocumentGetBgColor :: + (HTMLDocumentClass self) => self -> IO String +htmlDocumentGetBgColor self + = ({# call webkit_dom_html_document_get_bg_color #} + (toHTMLDocument self)) + >>= + readUTFString + +htmlDocumentSetFgColor :: + (HTMLDocumentClass self) => self -> String -> IO () +htmlDocumentSetFgColor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_fg_color #} + (toHTMLDocument self) + valPtr + +htmlDocumentGetFgColor :: + (HTMLDocumentClass self) => self -> IO String +htmlDocumentGetFgColor self + = ({# call webkit_dom_html_document_get_fg_color #} + (toHTMLDocument self)) + >>= + readUTFString + +htmlDocumentSetAlinkColor :: + (HTMLDocumentClass self) => self -> String -> IO () +htmlDocumentSetAlinkColor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_alink_color #} + (toHTMLDocument self) + valPtr + +htmlDocumentGetAlinkColor :: + (HTMLDocumentClass self) => self -> IO String +htmlDocumentGetAlinkColor self + = ({# call webkit_dom_html_document_get_alink_color #} + (toHTMLDocument self)) + >>= + readUTFString + +htmlDocumentSetLinkColor :: + (HTMLDocumentClass self) => self -> String -> IO () +htmlDocumentSetLinkColor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_link_color #} + (toHTMLDocument self) + valPtr + +htmlDocumentGetLinkColor :: + (HTMLDocumentClass self) => self -> IO String +htmlDocumentGetLinkColor self + = ({# call webkit_dom_html_document_get_link_color #} + (toHTMLDocument self)) + >>= + readUTFString + +htmlDocumentSetVlinkColor :: + (HTMLDocumentClass self) => self -> String -> IO () +htmlDocumentSetVlinkColor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_vlink_color #} + (toHTMLDocument self) + valPtr + +htmlDocumentGetVlinkColor :: + (HTMLDocumentClass self) => self -> IO String +htmlDocumentGetVlinkColor self + = ({# call webkit_dom_html_document_get_vlink_color #} + (toHTMLDocument self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLElement.chs @@ -0,0 +1,402 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLElement + (htmlElementInsertAdjacentElement, htmlElementInsertAdjacentHTML, + htmlElementInsertAdjacentText, htmlElementClick, htmlElementSetId, + htmlElementGetId, htmlElementSetTitle, htmlElementGetTitle, + htmlElementSetLang, htmlElementGetLang, htmlElementSetTranslate, + htmlElementGetTranslate, htmlElementSetDir, htmlElementGetDir, + htmlElementSetTabIndex, htmlElementGetTabIndex, + htmlElementSetDraggable, htmlElementGetDraggable, + htmlElementSetWebkitdropzone, htmlElementGetWebkitdropzone, + htmlElementSetHidden, htmlElementGetHidden, + htmlElementSetAccessKey, htmlElementGetAccessKey, + htmlElementSetInnerHTML, htmlElementGetInnerHTML, + htmlElementSetInnerText, htmlElementGetInnerText, + htmlElementSetOuterHTML, htmlElementGetOuterHTML, + htmlElementSetOuterText, htmlElementGetOuterText, + htmlElementGetChildren, htmlElementSetContentEditable, + htmlElementGetContentEditable, htmlElementGetIsContentEditable, + htmlElementSetSpellcheck, htmlElementGetSpellcheck, + htmlElementSetItemScope, htmlElementGetItemScope, + htmlElementGetItemType, htmlElementSetItemId, htmlElementGetItemId, + htmlElementGetItemRef, htmlElementGetItemProp) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlElementInsertAdjacentElement :: + (HTMLElementClass self, ElementClass element) => + self -> String -> Maybe element -> IO (Maybe Element) +htmlElementInsertAdjacentElement self where' element + = maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + withUTFString where' $ + \ wherePtr -> + {# call webkit_dom_html_element_insert_adjacent_element #} + (toHTMLElement self) + wherePtr + (maybe (Element nullForeignPtr) toElement element) + errorPtr_) + +htmlElementInsertAdjacentHTML :: + (HTMLElementClass self) => self -> String -> String -> IO () +htmlElementInsertAdjacentHTML self where' html + = propagateGError $ + \ errorPtr_ -> + withUTFString html $ + \ htmlPtr -> + withUTFString where' $ + \ wherePtr -> + {# call webkit_dom_html_element_insert_adjacent_html #} + (toHTMLElement self) + wherePtr + htmlPtr + errorPtr_ + +htmlElementInsertAdjacentText :: + (HTMLElementClass self) => self -> String -> String -> IO () +htmlElementInsertAdjacentText self where' text + = propagateGError $ + \ errorPtr_ -> + withUTFString text $ + \ textPtr -> + withUTFString where' $ + \ wherePtr -> + {# call webkit_dom_html_element_insert_adjacent_text #} + (toHTMLElement self) + wherePtr + textPtr + errorPtr_ + +htmlElementClick :: (HTMLElementClass self) => self -> IO () +htmlElementClick self + = {# call webkit_dom_html_element_click #} (toHTMLElement self) + +htmlElementSetId :: + (HTMLElementClass self) => self -> String -> IO () +htmlElementSetId self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_id #} (toHTMLElement self) + valPtr + +htmlElementGetId :: (HTMLElementClass self) => self -> IO String +htmlElementGetId self + = ({# call webkit_dom_html_element_get_id #} (toHTMLElement self)) + >>= + readUTFString + +htmlElementSetTitle :: + (HTMLElementClass self) => self -> String -> IO () +htmlElementSetTitle self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_title #} (toHTMLElement self) + valPtr + +htmlElementGetTitle :: (HTMLElementClass self) => self -> IO String +htmlElementGetTitle self + = ({# call webkit_dom_html_element_get_title #} + (toHTMLElement self)) + >>= + readUTFString + +htmlElementSetLang :: + (HTMLElementClass self) => self -> String -> IO () +htmlElementSetLang self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_lang #} (toHTMLElement self) + valPtr + +htmlElementGetLang :: (HTMLElementClass self) => self -> IO String +htmlElementGetLang self + = ({# call webkit_dom_html_element_get_lang #} + (toHTMLElement self)) + >>= + readUTFString + +htmlElementSetTranslate :: + (HTMLElementClass self) => self -> Bool -> IO () +htmlElementSetTranslate self val + = {# call webkit_dom_html_element_set_translate #} + (toHTMLElement self) + (fromBool val) + +htmlElementGetTranslate :: + (HTMLElementClass self) => self -> IO Bool +htmlElementGetTranslate self + = toBool <$> + ({# call webkit_dom_html_element_get_translate #} + (toHTMLElement self)) + +htmlElementSetDir :: + (HTMLElementClass self) => self -> String -> IO () +htmlElementSetDir self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_dir #} (toHTMLElement self) + valPtr + +htmlElementGetDir :: (HTMLElementClass self) => self -> IO String +htmlElementGetDir self + = ({# call webkit_dom_html_element_get_dir #} (toHTMLElement self)) + >>= + readUTFString + +htmlElementSetTabIndex :: + (HTMLElementClass self) => self -> Int -> IO () +htmlElementSetTabIndex self val + = {# call webkit_dom_html_element_set_tab_index #} + (toHTMLElement self) + (fromIntegral val) + +htmlElementGetTabIndex :: (HTMLElementClass self) => self -> IO Int +htmlElementGetTabIndex self + = fromIntegral <$> + ({# call webkit_dom_html_element_get_tab_index #} + (toHTMLElement self)) + +htmlElementSetDraggable :: + (HTMLElementClass self) => self -> Bool -> IO () +htmlElementSetDraggable self val + = {# call webkit_dom_html_element_set_draggable #} + (toHTMLElement self) + (fromBool val) + +htmlElementGetDraggable :: + (HTMLElementClass self) => self -> IO Bool +htmlElementGetDraggable self + = toBool <$> + ({# call webkit_dom_html_element_get_draggable #} + (toHTMLElement self)) + +htmlElementSetWebkitdropzone :: + (HTMLElementClass self) => self -> String -> IO () +htmlElementSetWebkitdropzone self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_webkitdropzone #} + (toHTMLElement self) + valPtr + +htmlElementGetWebkitdropzone :: + (HTMLElementClass self) => self -> IO String +htmlElementGetWebkitdropzone self + = ({# call webkit_dom_html_element_get_webkitdropzone #} + (toHTMLElement self)) + >>= + readUTFString + +htmlElementSetHidden :: + (HTMLElementClass self) => self -> Bool -> IO () +htmlElementSetHidden self val + = {# call webkit_dom_html_element_set_hidden #} + (toHTMLElement self) + (fromBool val) + +htmlElementGetHidden :: (HTMLElementClass self) => self -> IO Bool +htmlElementGetHidden self + = toBool <$> + ({# call webkit_dom_html_element_get_hidden #} + (toHTMLElement self)) + +htmlElementSetAccessKey :: + (HTMLElementClass self) => self -> String -> IO () +htmlElementSetAccessKey self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_access_key #} + (toHTMLElement self) + valPtr + +htmlElementGetAccessKey :: + (HTMLElementClass self) => self -> IO String +htmlElementGetAccessKey self + = ({# call webkit_dom_html_element_get_access_key #} + (toHTMLElement self)) + >>= + readUTFString + +htmlElementSetInnerHTML :: + (HTMLElementClass self) => self -> String -> IO () +htmlElementSetInnerHTML self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_inner_html #} + (toHTMLElement self) + valPtr + errorPtr_ + +htmlElementGetInnerHTML :: + (HTMLElementClass self) => self -> IO String +htmlElementGetInnerHTML self + = ({# call webkit_dom_html_element_get_inner_html #} + (toHTMLElement self)) + >>= + readUTFString + +htmlElementSetInnerText :: + (HTMLElementClass self) => self -> String -> IO () +htmlElementSetInnerText self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_inner_text #} + (toHTMLElement self) + valPtr + errorPtr_ + +htmlElementGetInnerText :: + (HTMLElementClass self) => self -> IO String +htmlElementGetInnerText self + = ({# call webkit_dom_html_element_get_inner_text #} + (toHTMLElement self)) + >>= + readUTFString + +htmlElementSetOuterHTML :: + (HTMLElementClass self) => self -> String -> IO () +htmlElementSetOuterHTML self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_outer_html #} + (toHTMLElement self) + valPtr + errorPtr_ + +htmlElementGetOuterHTML :: + (HTMLElementClass self) => self -> IO String +htmlElementGetOuterHTML self + = ({# call webkit_dom_html_element_get_outer_html #} + (toHTMLElement self)) + >>= + readUTFString + +htmlElementSetOuterText :: + (HTMLElementClass self) => self -> String -> IO () +htmlElementSetOuterText self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_outer_text #} + (toHTMLElement self) + valPtr + errorPtr_ + +htmlElementGetOuterText :: + (HTMLElementClass self) => self -> IO String +htmlElementGetOuterText self + = ({# call webkit_dom_html_element_get_outer_text #} + (toHTMLElement self)) + >>= + readUTFString + +htmlElementGetChildren :: + (HTMLElementClass self) => self -> IO (Maybe HTMLCollection) +htmlElementGetChildren self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_element_get_children #} + (toHTMLElement self)) + +htmlElementSetContentEditable :: + (HTMLElementClass self) => self -> String -> IO () +htmlElementSetContentEditable self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_content_editable #} + (toHTMLElement self) + valPtr + errorPtr_ + +htmlElementGetContentEditable :: + (HTMLElementClass self) => self -> IO String +htmlElementGetContentEditable self + = ({# call webkit_dom_html_element_get_content_editable #} + (toHTMLElement self)) + >>= + readUTFString + +htmlElementGetIsContentEditable :: + (HTMLElementClass self) => self -> IO Bool +htmlElementGetIsContentEditable self + = toBool <$> + ({# call webkit_dom_html_element_get_is_content_editable #} + (toHTMLElement self)) + +htmlElementSetSpellcheck :: + (HTMLElementClass self) => self -> Bool -> IO () +htmlElementSetSpellcheck self val + = {# call webkit_dom_html_element_set_spellcheck #} + (toHTMLElement self) + (fromBool val) + +htmlElementGetSpellcheck :: + (HTMLElementClass self) => self -> IO Bool +htmlElementGetSpellcheck self + = toBool <$> + ({# call webkit_dom_html_element_get_spellcheck #} + (toHTMLElement self)) + +htmlElementSetItemScope :: + (HTMLElementClass self) => self -> Bool -> IO () +htmlElementSetItemScope self val + = {# call webkit_dom_html_element_set_item_scope #} + (toHTMLElement self) + (fromBool val) + +htmlElementGetItemScope :: + (HTMLElementClass self) => self -> IO Bool +htmlElementGetItemScope self + = toBool <$> + ({# call webkit_dom_html_element_get_item_scope #} + (toHTMLElement self)) + +htmlElementGetItemType :: + (HTMLElementClass self) => self -> IO (Maybe DOMSettableTokenList) +htmlElementGetItemType self + = maybeNull (makeNewGObject mkDOMSettableTokenList) + ({# call webkit_dom_html_element_get_item_type #} + (toHTMLElement self)) + +htmlElementSetItemId :: + (HTMLElementClass self) => self -> String -> IO () +htmlElementSetItemId self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_item_id #} (toHTMLElement self) + valPtr + +htmlElementGetItemId :: + (HTMLElementClass self) => self -> IO String +htmlElementGetItemId self + = ({# call webkit_dom_html_element_get_item_id #} + (toHTMLElement self)) + >>= + readUTFString + +htmlElementGetItemRef :: + (HTMLElementClass self) => self -> IO (Maybe DOMSettableTokenList) +htmlElementGetItemRef self + = maybeNull (makeNewGObject mkDOMSettableTokenList) + ({# call webkit_dom_html_element_get_item_ref #} + (toHTMLElement self)) + +htmlElementGetItemProp :: + (HTMLElementClass self) => self -> IO (Maybe DOMSettableTokenList) +htmlElementGetItemProp self + = maybeNull (makeNewGObject mkDOMSettableTokenList) + ({# call webkit_dom_html_element_get_item_prop #} + (toHTMLElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLEmbedElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLEmbedElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLEmbedElement.chs @@ -0,0 +1,92 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLEmbedElement + (htmlEmbedElementSetAlign, htmlEmbedElementGetAlign, + htmlEmbedElementSetHeight, htmlEmbedElementGetHeight, + htmlEmbedElementSetName, htmlEmbedElementGetName, + htmlEmbedElementSetSrc, htmlEmbedElementGetSrc, + htmlEmbedElementSetWidth, htmlEmbedElementGetWidth) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlEmbedElementSetAlign :: + (HTMLEmbedElementClass self) => self -> String -> IO () +htmlEmbedElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_embed_element_set_align #} + (toHTMLEmbedElement self) + valPtr + +htmlEmbedElementGetAlign :: + (HTMLEmbedElementClass self) => self -> IO String +htmlEmbedElementGetAlign self + = ({# call webkit_dom_html_embed_element_get_align #} + (toHTMLEmbedElement self)) + >>= + readUTFString + +htmlEmbedElementSetHeight :: + (HTMLEmbedElementClass self) => self -> Int -> IO () +htmlEmbedElementSetHeight self val + = {# call webkit_dom_html_embed_element_set_height #} + (toHTMLEmbedElement self) + (fromIntegral val) + +htmlEmbedElementGetHeight :: + (HTMLEmbedElementClass self) => self -> IO Int +htmlEmbedElementGetHeight self + = fromIntegral <$> + ({# call webkit_dom_html_embed_element_get_height #} + (toHTMLEmbedElement self)) + +htmlEmbedElementSetName :: + (HTMLEmbedElementClass self) => self -> String -> IO () +htmlEmbedElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_embed_element_set_name #} + (toHTMLEmbedElement self) + valPtr + +htmlEmbedElementGetName :: + (HTMLEmbedElementClass self) => self -> IO String +htmlEmbedElementGetName self + = ({# call webkit_dom_html_embed_element_get_name #} + (toHTMLEmbedElement self)) + >>= + readUTFString + +htmlEmbedElementSetSrc :: + (HTMLEmbedElementClass self) => self -> String -> IO () +htmlEmbedElementSetSrc self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_embed_element_set_src #} + (toHTMLEmbedElement self) + valPtr + +htmlEmbedElementGetSrc :: + (HTMLEmbedElementClass self) => self -> IO String +htmlEmbedElementGetSrc self + = ({# call webkit_dom_html_embed_element_get_src #} + (toHTMLEmbedElement self)) + >>= + readUTFString + +htmlEmbedElementSetWidth :: + (HTMLEmbedElementClass self) => self -> Int -> IO () +htmlEmbedElementSetWidth self val + = {# call webkit_dom_html_embed_element_set_width #} + (toHTMLEmbedElement self) + (fromIntegral val) + +htmlEmbedElementGetWidth :: + (HTMLEmbedElementClass self) => self -> IO Int +htmlEmbedElementGetWidth self + = fromIntegral <$> + ({# call webkit_dom_html_embed_element_get_width #} + (toHTMLEmbedElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFieldSetElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFieldSetElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFieldSetElement.chs @@ -0,0 +1,110 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLFieldSetElement + (htmlFieldSetElementCheckValidity, + htmlFieldSetElementSetCustomValidity, +#if WEBKIT_CHECK_VERSION(1,10,0) + htmlFieldSetElementSetDisabled, htmlFieldSetElementGetDisabled, +#endif + htmlFieldSetElementGetForm, +#if WEBKIT_CHECK_VERSION(1,10,0) + htmlFieldSetElementSetName, htmlFieldSetElementGetName, + htmlFieldSetElementGetElements, +#endif + htmlFieldSetElementGetWillValidate, htmlFieldSetElementGetValidity, + htmlFieldSetElementGetValidationMessage) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlFieldSetElementCheckValidity :: + (HTMLFieldSetElementClass self) => self -> IO Bool +htmlFieldSetElementCheckValidity self + = toBool <$> + ({# call webkit_dom_html_field_set_element_check_validity #} + (toHTMLFieldSetElement self)) + +htmlFieldSetElementSetCustomValidity :: + (HTMLFieldSetElementClass self) => self -> String -> IO () +htmlFieldSetElementSetCustomValidity self error + = withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_field_set_element_set_custom_validity #} + (toHTMLFieldSetElement self) + errorPtr + +#if WEBKIT_CHECK_VERSION(1,10,0) +htmlFieldSetElementSetDisabled :: + (HTMLFieldSetElementClass self) => self -> Bool -> IO () +htmlFieldSetElementSetDisabled self val + = {# call webkit_dom_html_field_set_element_set_disabled #} + (toHTMLFieldSetElement self) + (fromBool val) + +htmlFieldSetElementGetDisabled :: + (HTMLFieldSetElementClass self) => self -> IO Bool +htmlFieldSetElementGetDisabled self + = toBool <$> + ({# call webkit_dom_html_field_set_element_get_disabled #} + (toHTMLFieldSetElement self)) +#endif + +htmlFieldSetElementGetForm :: + (HTMLFieldSetElementClass self) => + self -> IO (Maybe HTMLFormElement) +htmlFieldSetElementGetForm self + = maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_field_set_element_get_form #} + (toHTMLFieldSetElement self)) + +#if WEBKIT_CHECK_VERSION(1,10,0) +htmlFieldSetElementSetName :: + (HTMLFieldSetElementClass self) => self -> String -> IO () +htmlFieldSetElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_field_set_element_set_name #} + (toHTMLFieldSetElement self) + valPtr + +htmlFieldSetElementGetName :: + (HTMLFieldSetElementClass self) => self -> IO String +htmlFieldSetElementGetName self + = ({# call webkit_dom_html_field_set_element_get_name #} + (toHTMLFieldSetElement self)) + >>= + readUTFString + +htmlFieldSetElementGetElements :: + (HTMLFieldSetElementClass self) => + self -> IO (Maybe HTMLCollection) +htmlFieldSetElementGetElements self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_field_set_element_get_elements #} + (toHTMLFieldSetElement self)) +#endif + +htmlFieldSetElementGetWillValidate :: + (HTMLFieldSetElementClass self) => self -> IO Bool +htmlFieldSetElementGetWillValidate self + = toBool <$> + ({# call webkit_dom_html_field_set_element_get_will_validate #} + (toHTMLFieldSetElement self)) + +htmlFieldSetElementGetValidity :: + (HTMLFieldSetElementClass self) => self -> IO (Maybe ValidityState) +htmlFieldSetElementGetValidity self + = maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_field_set_element_get_validity #} + (toHTMLFieldSetElement self)) + +htmlFieldSetElementGetValidationMessage :: + (HTMLFieldSetElementClass self) => self -> IO String +htmlFieldSetElementGetValidationMessage self + = ({# call webkit_dom_html_field_set_element_get_validation_message + #} + (toHTMLFieldSetElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFontElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFontElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFontElement.chs @@ -0,0 +1,62 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLFontElement + (htmlFontElementSetColor, htmlFontElementGetColor, + htmlFontElementSetFace, htmlFontElementGetFace, + htmlFontElementSetSize, htmlFontElementGetSize) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlFontElementSetColor :: + (HTMLFontElementClass self) => self -> String -> IO () +htmlFontElementSetColor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_font_element_set_color #} + (toHTMLFontElement self) + valPtr + +htmlFontElementGetColor :: + (HTMLFontElementClass self) => self -> IO String +htmlFontElementGetColor self + = ({# call webkit_dom_html_font_element_get_color #} + (toHTMLFontElement self)) + >>= + readUTFString + +htmlFontElementSetFace :: + (HTMLFontElementClass self) => self -> String -> IO () +htmlFontElementSetFace self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_font_element_set_face #} + (toHTMLFontElement self) + valPtr + +htmlFontElementGetFace :: + (HTMLFontElementClass self) => self -> IO String +htmlFontElementGetFace self + = ({# call webkit_dom_html_font_element_get_face #} + (toHTMLFontElement self)) + >>= + readUTFString + +htmlFontElementSetSize :: + (HTMLFontElementClass self) => self -> String -> IO () +htmlFontElementSetSize self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_font_element_set_size #} + (toHTMLFontElement self) + valPtr + +htmlFontElementGetSize :: + (HTMLFontElementClass self) => self -> IO String +htmlFontElementGetSize self + = ({# call webkit_dom_html_font_element_get_size #} + (toHTMLFontElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFormElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFormElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFormElement.chs @@ -0,0 +1,203 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLFormElement + (htmlFormElementSubmit, htmlFormElementReset, + htmlFormElementCheckValidity, htmlFormElementSetAcceptCharset, + htmlFormElementGetAcceptCharset, htmlFormElementSetAction, + htmlFormElementGetAction, htmlFormElementSetAutocomplete, + htmlFormElementGetAutocomplete, htmlFormElementSetEnctype, + htmlFormElementGetEnctype, htmlFormElementSetEncoding, + htmlFormElementGetEncoding, htmlFormElementSetMethod, + htmlFormElementGetMethod, htmlFormElementSetName, + htmlFormElementGetName, htmlFormElementSetNoValidate, + htmlFormElementGetNoValidate, htmlFormElementSetTarget, + htmlFormElementGetTarget, htmlFormElementGetElements, + htmlFormElementGetLength) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlFormElementSubmit :: + (HTMLFormElementClass self) => self -> IO () +htmlFormElementSubmit self + = {# call webkit_dom_html_form_element_submit #} + (toHTMLFormElement self) + +htmlFormElementReset :: + (HTMLFormElementClass self) => self -> IO () +htmlFormElementReset self + = {# call webkit_dom_html_form_element_reset #} + (toHTMLFormElement self) + +htmlFormElementCheckValidity :: + (HTMLFormElementClass self) => self -> IO Bool +htmlFormElementCheckValidity self + = toBool <$> + ({# call webkit_dom_html_form_element_check_validity #} + (toHTMLFormElement self)) + +htmlFormElementSetAcceptCharset :: + (HTMLFormElementClass self) => self -> String -> IO () +htmlFormElementSetAcceptCharset self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_accept_charset #} + (toHTMLFormElement self) + valPtr + +htmlFormElementGetAcceptCharset :: + (HTMLFormElementClass self) => self -> IO String +htmlFormElementGetAcceptCharset self + = ({# call webkit_dom_html_form_element_get_accept_charset #} + (toHTMLFormElement self)) + >>= + readUTFString + +htmlFormElementSetAction :: + (HTMLFormElementClass self) => self -> String -> IO () +htmlFormElementSetAction self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_action #} + (toHTMLFormElement self) + valPtr + +htmlFormElementGetAction :: + (HTMLFormElementClass self) => self -> IO String +htmlFormElementGetAction self + = ({# call webkit_dom_html_form_element_get_action #} + (toHTMLFormElement self)) + >>= + readUTFString + +htmlFormElementSetAutocomplete :: + (HTMLFormElementClass self) => self -> String -> IO () +htmlFormElementSetAutocomplete self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_autocomplete #} + (toHTMLFormElement self) + valPtr + +htmlFormElementGetAutocomplete :: + (HTMLFormElementClass self) => self -> IO String +htmlFormElementGetAutocomplete self + = ({# call webkit_dom_html_form_element_get_autocomplete #} + (toHTMLFormElement self)) + >>= + readUTFString + +htmlFormElementSetEnctype :: + (HTMLFormElementClass self) => self -> String -> IO () +htmlFormElementSetEnctype self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_enctype #} + (toHTMLFormElement self) + valPtr + +htmlFormElementGetEnctype :: + (HTMLFormElementClass self) => self -> IO String +htmlFormElementGetEnctype self + = ({# call webkit_dom_html_form_element_get_enctype #} + (toHTMLFormElement self)) + >>= + readUTFString + +htmlFormElementSetEncoding :: + (HTMLFormElementClass self) => self -> String -> IO () +htmlFormElementSetEncoding self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_encoding #} + (toHTMLFormElement self) + valPtr + +htmlFormElementGetEncoding :: + (HTMLFormElementClass self) => self -> IO String +htmlFormElementGetEncoding self + = ({# call webkit_dom_html_form_element_get_encoding #} + (toHTMLFormElement self)) + >>= + readUTFString + +htmlFormElementSetMethod :: + (HTMLFormElementClass self) => self -> String -> IO () +htmlFormElementSetMethod self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_method #} + (toHTMLFormElement self) + valPtr + +htmlFormElementGetMethod :: + (HTMLFormElementClass self) => self -> IO String +htmlFormElementGetMethod self + = ({# call webkit_dom_html_form_element_get_method #} + (toHTMLFormElement self)) + >>= + readUTFString + +htmlFormElementSetName :: + (HTMLFormElementClass self) => self -> String -> IO () +htmlFormElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_name #} + (toHTMLFormElement self) + valPtr + +htmlFormElementGetName :: + (HTMLFormElementClass self) => self -> IO String +htmlFormElementGetName self + = ({# call webkit_dom_html_form_element_get_name #} + (toHTMLFormElement self)) + >>= + readUTFString + +htmlFormElementSetNoValidate :: + (HTMLFormElementClass self) => self -> Bool -> IO () +htmlFormElementSetNoValidate self val + = {# call webkit_dom_html_form_element_set_no_validate #} + (toHTMLFormElement self) + (fromBool val) + +htmlFormElementGetNoValidate :: + (HTMLFormElementClass self) => self -> IO Bool +htmlFormElementGetNoValidate self + = toBool <$> + ({# call webkit_dom_html_form_element_get_no_validate #} + (toHTMLFormElement self)) + +htmlFormElementSetTarget :: + (HTMLFormElementClass self) => self -> String -> IO () +htmlFormElementSetTarget self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_target #} + (toHTMLFormElement self) + valPtr + +htmlFormElementGetTarget :: + (HTMLFormElementClass self) => self -> IO String +htmlFormElementGetTarget self + = ({# call webkit_dom_html_form_element_get_target #} + (toHTMLFormElement self)) + >>= + readUTFString + +htmlFormElementGetElements :: + (HTMLFormElementClass self) => self -> IO (Maybe HTMLCollection) +htmlFormElementGetElements self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_form_element_get_elements #} + (toHTMLFormElement self)) + +htmlFormElementGetLength :: + (HTMLFormElementClass self) => self -> IO Int +htmlFormElementGetLength self + = fromIntegral <$> + ({# call webkit_dom_html_form_element_get_length #} + (toHTMLFormElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameElement.chs @@ -0,0 +1,180 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLFrameElement + (htmlFrameElementSetFrameBorder, htmlFrameElementGetFrameBorder, + htmlFrameElementSetLongDesc, htmlFrameElementGetLongDesc, + htmlFrameElementSetMarginHeight, htmlFrameElementGetMarginHeight, + htmlFrameElementSetMarginWidth, htmlFrameElementGetMarginWidth, + htmlFrameElementSetName, htmlFrameElementGetName, + htmlFrameElementSetNoResize, htmlFrameElementGetNoResize, + htmlFrameElementSetScrolling, htmlFrameElementGetScrolling, + htmlFrameElementSetSrc, htmlFrameElementGetSrc, + htmlFrameElementGetContentDocument, + htmlFrameElementGetContentWindow, htmlFrameElementGetWidth, + htmlFrameElementGetHeight) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlFrameElementSetFrameBorder :: + (HTMLFrameElementClass self) => self -> String -> IO () +htmlFrameElementSetFrameBorder self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_frame_border #} + (toHTMLFrameElement self) + valPtr + +htmlFrameElementGetFrameBorder :: + (HTMLFrameElementClass self) => self -> IO String +htmlFrameElementGetFrameBorder self + = ({# call webkit_dom_html_frame_element_get_frame_border #} + (toHTMLFrameElement self)) + >>= + readUTFString + +htmlFrameElementSetLongDesc :: + (HTMLFrameElementClass self) => self -> String -> IO () +htmlFrameElementSetLongDesc self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_long_desc #} + (toHTMLFrameElement self) + valPtr + +htmlFrameElementGetLongDesc :: + (HTMLFrameElementClass self) => self -> IO String +htmlFrameElementGetLongDesc self + = ({# call webkit_dom_html_frame_element_get_long_desc #} + (toHTMLFrameElement self)) + >>= + readUTFString + +htmlFrameElementSetMarginHeight :: + (HTMLFrameElementClass self) => self -> String -> IO () +htmlFrameElementSetMarginHeight self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_margin_height #} + (toHTMLFrameElement self) + valPtr + +htmlFrameElementGetMarginHeight :: + (HTMLFrameElementClass self) => self -> IO String +htmlFrameElementGetMarginHeight self + = ({# call webkit_dom_html_frame_element_get_margin_height #} + (toHTMLFrameElement self)) + >>= + readUTFString + +htmlFrameElementSetMarginWidth :: + (HTMLFrameElementClass self) => self -> String -> IO () +htmlFrameElementSetMarginWidth self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_margin_width #} + (toHTMLFrameElement self) + valPtr + +htmlFrameElementGetMarginWidth :: + (HTMLFrameElementClass self) => self -> IO String +htmlFrameElementGetMarginWidth self + = ({# call webkit_dom_html_frame_element_get_margin_width #} + (toHTMLFrameElement self)) + >>= + readUTFString + +htmlFrameElementSetName :: + (HTMLFrameElementClass self) => self -> String -> IO () +htmlFrameElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_name #} + (toHTMLFrameElement self) + valPtr + +htmlFrameElementGetName :: + (HTMLFrameElementClass self) => self -> IO String +htmlFrameElementGetName self + = ({# call webkit_dom_html_frame_element_get_name #} + (toHTMLFrameElement self)) + >>= + readUTFString + +htmlFrameElementSetNoResize :: + (HTMLFrameElementClass self) => self -> Bool -> IO () +htmlFrameElementSetNoResize self val + = {# call webkit_dom_html_frame_element_set_no_resize #} + (toHTMLFrameElement self) + (fromBool val) + +htmlFrameElementGetNoResize :: + (HTMLFrameElementClass self) => self -> IO Bool +htmlFrameElementGetNoResize self + = toBool <$> + ({# call webkit_dom_html_frame_element_get_no_resize #} + (toHTMLFrameElement self)) + +htmlFrameElementSetScrolling :: + (HTMLFrameElementClass self) => self -> String -> IO () +htmlFrameElementSetScrolling self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_scrolling #} + (toHTMLFrameElement self) + valPtr + +htmlFrameElementGetScrolling :: + (HTMLFrameElementClass self) => self -> IO String +htmlFrameElementGetScrolling self + = ({# call webkit_dom_html_frame_element_get_scrolling #} + (toHTMLFrameElement self)) + >>= + readUTFString + +htmlFrameElementSetSrc :: + (HTMLFrameElementClass self) => self -> String -> IO () +htmlFrameElementSetSrc self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_src #} + (toHTMLFrameElement self) + valPtr + +htmlFrameElementGetSrc :: + (HTMLFrameElementClass self) => self -> IO String +htmlFrameElementGetSrc self + = ({# call webkit_dom_html_frame_element_get_src #} + (toHTMLFrameElement self)) + >>= + readUTFString + +htmlFrameElementGetContentDocument :: + (HTMLFrameElementClass self) => self -> IO (Maybe Document) +htmlFrameElementGetContentDocument self + = maybeNull (makeNewGObject mkDocument) + ({# call webkit_dom_html_frame_element_get_content_document #} + (toHTMLFrameElement self)) + +htmlFrameElementGetContentWindow :: + (HTMLFrameElementClass self) => self -> IO (Maybe DOMWindow) +htmlFrameElementGetContentWindow self + = maybeNull (makeNewGObject mkDOMWindow) + ({# call webkit_dom_html_frame_element_get_content_window #} + (toHTMLFrameElement self)) + +htmlFrameElementGetWidth :: + (HTMLFrameElementClass self) => self -> IO Int +htmlFrameElementGetWidth self + = fromIntegral <$> + ({# call webkit_dom_html_frame_element_get_width #} + (toHTMLFrameElement self)) + +htmlFrameElementGetHeight :: + (HTMLFrameElementClass self) => self -> IO Int +htmlFrameElementGetHeight self + = fromIntegral <$> + ({# call webkit_dom_html_frame_element_get_height #} + (toHTMLFrameElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameSetElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameSetElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameSetElement.chs @@ -0,0 +1,123 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLFrameSetElement + (htmlFrameSetElementSetCols, htmlFrameSetElementGetCols, + htmlFrameSetElementSetRows, htmlFrameSetElementGetRows, + htmlFrameSetElementOnbeforeunload, htmlFrameSetElementOnhashchange, + htmlFrameSetElementOnmessage, htmlFrameSetElementOnoffline, + htmlFrameSetElementOnonline, htmlFrameSetElementOnpopstate, + htmlFrameSetElementOnresize, htmlFrameSetElementOnstorage, + htmlFrameSetElementOnunload, + htmlFrameSetElementOnorientationchange, htmlFrameSetElementOnblur, + htmlFrameSetElementOnerror, htmlFrameSetElementOnfocus, + htmlFrameSetElementOnload) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlFrameSetElementSetCols :: + (HTMLFrameSetElementClass self) => self -> String -> IO () +htmlFrameSetElementSetCols self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_set_element_set_cols #} + (toHTMLFrameSetElement self) + valPtr + +htmlFrameSetElementGetCols :: + (HTMLFrameSetElementClass self) => self -> IO String +htmlFrameSetElementGetCols self + = ({# call webkit_dom_html_frame_set_element_get_cols #} + (toHTMLFrameSetElement self)) + >>= + readUTFString + +htmlFrameSetElementSetRows :: + (HTMLFrameSetElementClass self) => self -> String -> IO () +htmlFrameSetElementSetRows self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_set_element_set_rows #} + (toHTMLFrameSetElement self) + valPtr + +htmlFrameSetElementGetRows :: + (HTMLFrameSetElementClass self) => self -> IO String +htmlFrameSetElementGetRows self + = ({# call webkit_dom_html_frame_set_element_get_rows #} + (toHTMLFrameSetElement self)) + >>= + readUTFString + +htmlFrameSetElementOnbeforeunload :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnbeforeunload = (connect "beforeunload") + +htmlFrameSetElementOnhashchange :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnhashchange = (connect "hashchange") + +htmlFrameSetElementOnmessage :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnmessage = (connect "message") + +htmlFrameSetElementOnoffline :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnoffline = (connect "offline") + +htmlFrameSetElementOnonline :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnonline = (connect "online") + +htmlFrameSetElementOnpopstate :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnpopstate = (connect "popstate") + +htmlFrameSetElementOnresize :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnresize = (connect "resize") + +htmlFrameSetElementOnstorage :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnstorage = (connect "storage") + +htmlFrameSetElementOnunload :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnunload = (connect "unload") + +htmlFrameSetElementOnorientationchange :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnorientationchange + = (connect "orientationchange") + +htmlFrameSetElementOnblur :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnblur = (connect "blur") + +htmlFrameSetElementOnerror :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnerror = (connect "error") + +htmlFrameSetElementOnfocus :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnfocus = (connect "focus") + +htmlFrameSetElementOnload :: + (HTMLFrameSetElementClass self) => + Signal self (EventM UIEvent self ()) +htmlFrameSetElementOnload = (connect "load") diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLHRElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLHRElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLHRElement.chs @@ -0,0 +1,77 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLHRElement + (htmlhrElementSetAlign, htmlhrElementGetAlign, + htmlhrElementSetNoShade, htmlhrElementGetNoShade, + htmlhrElementSetSize, htmlhrElementGetSize, htmlhrElementSetWidth, + htmlhrElementGetWidth) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlhrElementSetAlign :: + (HTMLHRElementClass self) => self -> String -> IO () +htmlhrElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_htmlhr_element_set_align #} + (toHTMLHRElement self) + valPtr + +htmlhrElementGetAlign :: + (HTMLHRElementClass self) => self -> IO String +htmlhrElementGetAlign self + = ({# call webkit_dom_htmlhr_element_get_align #} + (toHTMLHRElement self)) + >>= + readUTFString + +htmlhrElementSetNoShade :: + (HTMLHRElementClass self) => self -> Bool -> IO () +htmlhrElementSetNoShade self val + = {# call webkit_dom_htmlhr_element_set_no_shade #} + (toHTMLHRElement self) + (fromBool val) + +htmlhrElementGetNoShade :: + (HTMLHRElementClass self) => self -> IO Bool +htmlhrElementGetNoShade self + = toBool <$> + ({# call webkit_dom_htmlhr_element_get_no_shade #} + (toHTMLHRElement self)) + +htmlhrElementSetSize :: + (HTMLHRElementClass self) => self -> String -> IO () +htmlhrElementSetSize self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_htmlhr_element_set_size #} + (toHTMLHRElement self) + valPtr + +htmlhrElementGetSize :: + (HTMLHRElementClass self) => self -> IO String +htmlhrElementGetSize self + = ({# call webkit_dom_htmlhr_element_get_size #} + (toHTMLHRElement self)) + >>= + readUTFString + +htmlhrElementSetWidth :: + (HTMLHRElementClass self) => self -> String -> IO () +htmlhrElementSetWidth self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_htmlhr_element_set_width #} + (toHTMLHRElement self) + valPtr + +htmlhrElementGetWidth :: + (HTMLHRElementClass self) => self -> IO String +htmlhrElementGetWidth self + = ({# call webkit_dom_htmlhr_element_get_width #} + (toHTMLHRElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadElement.chs @@ -0,0 +1,25 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLHeadElement + (htmlHeadElementSetProfile, htmlHeadElementGetProfile) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlHeadElementSetProfile :: + (HTMLHeadElementClass self) => self -> String -> IO () +htmlHeadElementSetProfile self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_head_element_set_profile #} + (toHTMLHeadElement self) + valPtr + +htmlHeadElementGetProfile :: + (HTMLHeadElementClass self) => self -> IO String +htmlHeadElementGetProfile self + = ({# call webkit_dom_html_head_element_get_profile #} + (toHTMLHeadElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadingElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadingElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadingElement.chs @@ -0,0 +1,25 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLHeadingElement + (htmlHeadingElementSetAlign, htmlHeadingElementGetAlign) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlHeadingElementSetAlign :: + (HTMLHeadingElementClass self) => self -> String -> IO () +htmlHeadingElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_heading_element_set_align #} + (toHTMLHeadingElement self) + valPtr + +htmlHeadingElementGetAlign :: + (HTMLHeadingElementClass self) => self -> IO String +htmlHeadingElementGetAlign self + = ({# call webkit_dom_html_heading_element_get_align #} + (toHTMLHeadingElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLHtmlElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLHtmlElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLHtmlElement.chs @@ -0,0 +1,44 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLHtmlElement + (htmlHtmlElementSetVersion, htmlHtmlElementGetVersion, + htmlHtmlElementSetManifest, htmlHtmlElementGetManifest) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlHtmlElementSetVersion :: + (HTMLHtmlElementClass self) => self -> String -> IO () +htmlHtmlElementSetVersion self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_html_element_set_version #} + (toHTMLHtmlElement self) + valPtr + +htmlHtmlElementGetVersion :: + (HTMLHtmlElementClass self) => self -> IO String +htmlHtmlElementGetVersion self + = ({# call webkit_dom_html_html_element_get_version #} + (toHTMLHtmlElement self)) + >>= + readUTFString + +htmlHtmlElementSetManifest :: + (HTMLHtmlElementClass self) => self -> String -> IO () +htmlHtmlElementSetManifest self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_html_element_set_manifest #} + (toHTMLHtmlElement self) + valPtr + +htmlHtmlElementGetManifest :: + (HTMLHtmlElementClass self) => self -> IO String +htmlHtmlElementGetManifest self + = ({# call webkit_dom_html_html_element_get_manifest #} + (toHTMLHtmlElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLIFrameElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLIFrameElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLIFrameElement.chs @@ -0,0 +1,263 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLIFrameElement + (htmliFrameElementSetAlign, htmliFrameElementGetAlign, + htmliFrameElementSetFrameBorder, htmliFrameElementGetFrameBorder, + htmliFrameElementSetHeight, htmliFrameElementGetHeight, + htmliFrameElementSetLongDesc, htmliFrameElementGetLongDesc, + htmliFrameElementSetMarginHeight, htmliFrameElementGetMarginHeight, + htmliFrameElementSetMarginWidth, htmliFrameElementGetMarginWidth, + htmliFrameElementSetName, htmliFrameElementGetName, + htmliFrameElementSetSandbox, htmliFrameElementGetSandbox, +#if WEBKIT_CHECK_VERSION(1,10,0) + htmliFrameElementSetSeamless, htmliFrameElementGetSeamless, +#endif + htmliFrameElementSetScrolling, htmliFrameElementGetScrolling, + htmliFrameElementSetSrc, htmliFrameElementGetSrc, +#if WEBKIT_CHECK_VERSION(1,10,0) + htmliFrameElementSetSrcdoc, htmliFrameElementGetSrcdoc, +#endif + htmliFrameElementSetWidth, htmliFrameElementGetWidth, + htmliFrameElementGetContentDocument, + htmliFrameElementGetContentWindow) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmliFrameElementSetAlign :: + (HTMLIFrameElementClass self) => self -> String -> IO () +htmliFrameElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_align #} + (toHTMLIFrameElement self) + valPtr + +htmliFrameElementGetAlign :: + (HTMLIFrameElementClass self) => self -> IO String +htmliFrameElementGetAlign self + = ({# call webkit_dom_html_iframe_element_get_align #} + (toHTMLIFrameElement self)) + >>= + readUTFString + +htmliFrameElementSetFrameBorder :: + (HTMLIFrameElementClass self) => self -> String -> IO () +htmliFrameElementSetFrameBorder self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_frame_border #} + (toHTMLIFrameElement self) + valPtr + +htmliFrameElementGetFrameBorder :: + (HTMLIFrameElementClass self) => self -> IO String +htmliFrameElementGetFrameBorder self + = ({# call webkit_dom_html_iframe_element_get_frame_border #} + (toHTMLIFrameElement self)) + >>= + readUTFString + +htmliFrameElementSetHeight :: + (HTMLIFrameElementClass self) => self -> String -> IO () +htmliFrameElementSetHeight self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_height #} + (toHTMLIFrameElement self) + valPtr + +htmliFrameElementGetHeight :: + (HTMLIFrameElementClass self) => self -> IO String +htmliFrameElementGetHeight self + = ({# call webkit_dom_html_iframe_element_get_height #} + (toHTMLIFrameElement self)) + >>= + readUTFString + +htmliFrameElementSetLongDesc :: + (HTMLIFrameElementClass self) => self -> String -> IO () +htmliFrameElementSetLongDesc self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_long_desc #} + (toHTMLIFrameElement self) + valPtr + +htmliFrameElementGetLongDesc :: + (HTMLIFrameElementClass self) => self -> IO String +htmliFrameElementGetLongDesc self + = ({# call webkit_dom_html_iframe_element_get_long_desc #} + (toHTMLIFrameElement self)) + >>= + readUTFString + +htmliFrameElementSetMarginHeight :: + (HTMLIFrameElementClass self) => self -> String -> IO () +htmliFrameElementSetMarginHeight self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_margin_height #} + (toHTMLIFrameElement self) + valPtr + +htmliFrameElementGetMarginHeight :: + (HTMLIFrameElementClass self) => self -> IO String +htmliFrameElementGetMarginHeight self + = ({# call webkit_dom_html_iframe_element_get_margin_height #} + (toHTMLIFrameElement self)) + >>= + readUTFString + +htmliFrameElementSetMarginWidth :: + (HTMLIFrameElementClass self) => self -> String -> IO () +htmliFrameElementSetMarginWidth self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_margin_width #} + (toHTMLIFrameElement self) + valPtr + +htmliFrameElementGetMarginWidth :: + (HTMLIFrameElementClass self) => self -> IO String +htmliFrameElementGetMarginWidth self + = ({# call webkit_dom_html_iframe_element_get_margin_width #} + (toHTMLIFrameElement self)) + >>= + readUTFString + +htmliFrameElementSetName :: + (HTMLIFrameElementClass self) => self -> String -> IO () +htmliFrameElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_name #} + (toHTMLIFrameElement self) + valPtr + +htmliFrameElementGetName :: + (HTMLIFrameElementClass self) => self -> IO String +htmliFrameElementGetName self + = ({# call webkit_dom_html_iframe_element_get_name #} + (toHTMLIFrameElement self)) + >>= + readUTFString + +htmliFrameElementSetSandbox :: + (HTMLIFrameElementClass self) => self -> String -> IO () +htmliFrameElementSetSandbox self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_sandbox #} + (toHTMLIFrameElement self) + valPtr + +htmliFrameElementGetSandbox :: + (HTMLIFrameElementClass self) => self -> IO String +htmliFrameElementGetSandbox self + = ({# call webkit_dom_html_iframe_element_get_sandbox #} + (toHTMLIFrameElement self)) + >>= + readUTFString + +#if WEBKIT_CHECK_VERSION(1,10,0) +htmliFrameElementSetSeamless :: + (HTMLIFrameElementClass self) => self -> Bool -> IO () +htmliFrameElementSetSeamless self val + = {# call webkit_dom_html_iframe_element_set_seamless #} + (toHTMLIFrameElement self) + (fromBool val) + +htmliFrameElementGetSeamless :: + (HTMLIFrameElementClass self) => self -> IO Bool +htmliFrameElementGetSeamless self + = toBool <$> + ({# call webkit_dom_html_iframe_element_get_seamless #} + (toHTMLIFrameElement self)) +#endif + +htmliFrameElementSetScrolling :: + (HTMLIFrameElementClass self) => self -> String -> IO () +htmliFrameElementSetScrolling self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_scrolling #} + (toHTMLIFrameElement self) + valPtr + +htmliFrameElementGetScrolling :: + (HTMLIFrameElementClass self) => self -> IO String +htmliFrameElementGetScrolling self + = ({# call webkit_dom_html_iframe_element_get_scrolling #} + (toHTMLIFrameElement self)) + >>= + readUTFString + +htmliFrameElementSetSrc :: + (HTMLIFrameElementClass self) => self -> String -> IO () +htmliFrameElementSetSrc self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_src #} + (toHTMLIFrameElement self) + valPtr + +htmliFrameElementGetSrc :: + (HTMLIFrameElementClass self) => self -> IO String +htmliFrameElementGetSrc self + = ({# call webkit_dom_html_iframe_element_get_src #} + (toHTMLIFrameElement self)) + >>= + readUTFString + +#if WEBKIT_CHECK_VERSION(1,10,0) +htmliFrameElementSetSrcdoc :: + (HTMLIFrameElementClass self) => self -> String -> IO () +htmliFrameElementSetSrcdoc self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_srcdoc #} + (toHTMLIFrameElement self) + valPtr + +htmliFrameElementGetSrcdoc :: + (HTMLIFrameElementClass self) => self -> IO String +htmliFrameElementGetSrcdoc self + = ({# call webkit_dom_html_iframe_element_get_srcdoc #} + (toHTMLIFrameElement self)) + >>= + readUTFString +#endif + +htmliFrameElementSetWidth :: + (HTMLIFrameElementClass self) => self -> String -> IO () +htmliFrameElementSetWidth self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_width #} + (toHTMLIFrameElement self) + valPtr + +htmliFrameElementGetWidth :: + (HTMLIFrameElementClass self) => self -> IO String +htmliFrameElementGetWidth self + = ({# call webkit_dom_html_iframe_element_get_width #} + (toHTMLIFrameElement self)) + >>= + readUTFString + +htmliFrameElementGetContentDocument :: + (HTMLIFrameElementClass self) => self -> IO (Maybe Document) +htmliFrameElementGetContentDocument self + = maybeNull (makeNewGObject mkDocument) + ({# call webkit_dom_html_iframe_element_get_content_document #} + (toHTMLIFrameElement self)) + +htmliFrameElementGetContentWindow :: + (HTMLIFrameElementClass self) => self -> IO (Maybe DOMWindow) +htmliFrameElementGetContentWindow self + = maybeNull (makeNewGObject mkDOMWindow) + ({# call webkit_dom_html_iframe_element_get_content_window #} + (toHTMLIFrameElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLImageElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLImageElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLImageElement.chs @@ -0,0 +1,283 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLImageElement + (htmlImageElementSetName, htmlImageElementGetName, + htmlImageElementSetAlign, htmlImageElementGetAlign, + htmlImageElementSetAlt, htmlImageElementGetAlt, + htmlImageElementSetBorder, htmlImageElementGetBorder, + htmlImageElementSetCrossOrigin, htmlImageElementGetCrossOrigin, + htmlImageElementSetHeight, htmlImageElementGetHeight, + htmlImageElementSetHspace, htmlImageElementGetHspace, + htmlImageElementSetIsMap, htmlImageElementGetIsMap, + htmlImageElementSetLongDesc, htmlImageElementGetLongDesc, + htmlImageElementSetSrc, htmlImageElementGetSrc, + htmlImageElementSetUseMap, htmlImageElementGetUseMap, + htmlImageElementSetVspace, htmlImageElementGetVspace, + htmlImageElementSetWidth, htmlImageElementGetWidth, + htmlImageElementGetComplete, htmlImageElementSetLowsrc, + htmlImageElementGetLowsrc, htmlImageElementGetNaturalHeight, + htmlImageElementGetNaturalWidth, htmlImageElementGetX, + htmlImageElementGetY) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlImageElementSetName :: + (HTMLImageElementClass self) => self -> String -> IO () +htmlImageElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_name #} + (toHTMLImageElement self) + valPtr + +htmlImageElementGetName :: + (HTMLImageElementClass self) => self -> IO String +htmlImageElementGetName self + = ({# call webkit_dom_html_image_element_get_name #} + (toHTMLImageElement self)) + >>= + readUTFString + +htmlImageElementSetAlign :: + (HTMLImageElementClass self) => self -> String -> IO () +htmlImageElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_align #} + (toHTMLImageElement self) + valPtr + +htmlImageElementGetAlign :: + (HTMLImageElementClass self) => self -> IO String +htmlImageElementGetAlign self + = ({# call webkit_dom_html_image_element_get_align #} + (toHTMLImageElement self)) + >>= + readUTFString + +htmlImageElementSetAlt :: + (HTMLImageElementClass self) => self -> String -> IO () +htmlImageElementSetAlt self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_alt #} + (toHTMLImageElement self) + valPtr + +htmlImageElementGetAlt :: + (HTMLImageElementClass self) => self -> IO String +htmlImageElementGetAlt self + = ({# call webkit_dom_html_image_element_get_alt #} + (toHTMLImageElement self)) + >>= + readUTFString + +htmlImageElementSetBorder :: + (HTMLImageElementClass self) => self -> String -> IO () +htmlImageElementSetBorder self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_border #} + (toHTMLImageElement self) + valPtr + +htmlImageElementGetBorder :: + (HTMLImageElementClass self) => self -> IO String +htmlImageElementGetBorder self + = ({# call webkit_dom_html_image_element_get_border #} + (toHTMLImageElement self)) + >>= + readUTFString + +htmlImageElementSetCrossOrigin :: + (HTMLImageElementClass self) => self -> String -> IO () +htmlImageElementSetCrossOrigin self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_cross_origin #} + (toHTMLImageElement self) + valPtr + +htmlImageElementGetCrossOrigin :: + (HTMLImageElementClass self) => self -> IO String +htmlImageElementGetCrossOrigin self + = ({# call webkit_dom_html_image_element_get_cross_origin #} + (toHTMLImageElement self)) + >>= + readUTFString + +htmlImageElementSetHeight :: + (HTMLImageElementClass self) => self -> Int -> IO () +htmlImageElementSetHeight self val + = {# call webkit_dom_html_image_element_set_height #} + (toHTMLImageElement self) + (fromIntegral val) + +htmlImageElementGetHeight :: + (HTMLImageElementClass self) => self -> IO Int +htmlImageElementGetHeight self + = fromIntegral <$> + ({# call webkit_dom_html_image_element_get_height #} + (toHTMLImageElement self)) + +htmlImageElementSetHspace :: + (HTMLImageElementClass self) => self -> Int -> IO () +htmlImageElementSetHspace self val + = {# call webkit_dom_html_image_element_set_hspace #} + (toHTMLImageElement self) + (fromIntegral val) + +htmlImageElementGetHspace :: + (HTMLImageElementClass self) => self -> IO Int +htmlImageElementGetHspace self + = fromIntegral <$> + ({# call webkit_dom_html_image_element_get_hspace #} + (toHTMLImageElement self)) + +htmlImageElementSetIsMap :: + (HTMLImageElementClass self) => self -> Bool -> IO () +htmlImageElementSetIsMap self val + = {# call webkit_dom_html_image_element_set_is_map #} + (toHTMLImageElement self) + (fromBool val) + +htmlImageElementGetIsMap :: + (HTMLImageElementClass self) => self -> IO Bool +htmlImageElementGetIsMap self + = toBool <$> + ({# call webkit_dom_html_image_element_get_is_map #} + (toHTMLImageElement self)) + +htmlImageElementSetLongDesc :: + (HTMLImageElementClass self) => self -> String -> IO () +htmlImageElementSetLongDesc self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_long_desc #} + (toHTMLImageElement self) + valPtr + +htmlImageElementGetLongDesc :: + (HTMLImageElementClass self) => self -> IO String +htmlImageElementGetLongDesc self + = ({# call webkit_dom_html_image_element_get_long_desc #} + (toHTMLImageElement self)) + >>= + readUTFString + +htmlImageElementSetSrc :: + (HTMLImageElementClass self) => self -> String -> IO () +htmlImageElementSetSrc self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_src #} + (toHTMLImageElement self) + valPtr + +htmlImageElementGetSrc :: + (HTMLImageElementClass self) => self -> IO String +htmlImageElementGetSrc self + = ({# call webkit_dom_html_image_element_get_src #} + (toHTMLImageElement self)) + >>= + readUTFString + +htmlImageElementSetUseMap :: + (HTMLImageElementClass self) => self -> String -> IO () +htmlImageElementSetUseMap self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_use_map #} + (toHTMLImageElement self) + valPtr + +htmlImageElementGetUseMap :: + (HTMLImageElementClass self) => self -> IO String +htmlImageElementGetUseMap self + = ({# call webkit_dom_html_image_element_get_use_map #} + (toHTMLImageElement self)) + >>= + readUTFString + +htmlImageElementSetVspace :: + (HTMLImageElementClass self) => self -> Int -> IO () +htmlImageElementSetVspace self val + = {# call webkit_dom_html_image_element_set_vspace #} + (toHTMLImageElement self) + (fromIntegral val) + +htmlImageElementGetVspace :: + (HTMLImageElementClass self) => self -> IO Int +htmlImageElementGetVspace self + = fromIntegral <$> + ({# call webkit_dom_html_image_element_get_vspace #} + (toHTMLImageElement self)) + +htmlImageElementSetWidth :: + (HTMLImageElementClass self) => self -> Int -> IO () +htmlImageElementSetWidth self val + = {# call webkit_dom_html_image_element_set_width #} + (toHTMLImageElement self) + (fromIntegral val) + +htmlImageElementGetWidth :: + (HTMLImageElementClass self) => self -> IO Int +htmlImageElementGetWidth self + = fromIntegral <$> + ({# call webkit_dom_html_image_element_get_width #} + (toHTMLImageElement self)) + +htmlImageElementGetComplete :: + (HTMLImageElementClass self) => self -> IO Bool +htmlImageElementGetComplete self + = toBool <$> + ({# call webkit_dom_html_image_element_get_complete #} + (toHTMLImageElement self)) + +htmlImageElementSetLowsrc :: + (HTMLImageElementClass self) => self -> String -> IO () +htmlImageElementSetLowsrc self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_lowsrc #} + (toHTMLImageElement self) + valPtr + +htmlImageElementGetLowsrc :: + (HTMLImageElementClass self) => self -> IO String +htmlImageElementGetLowsrc self + = ({# call webkit_dom_html_image_element_get_lowsrc #} + (toHTMLImageElement self)) + >>= + readUTFString + +htmlImageElementGetNaturalHeight :: + (HTMLImageElementClass self) => self -> IO Int +htmlImageElementGetNaturalHeight self + = fromIntegral <$> + ({# call webkit_dom_html_image_element_get_natural_height #} + (toHTMLImageElement self)) + +htmlImageElementGetNaturalWidth :: + (HTMLImageElementClass self) => self -> IO Int +htmlImageElementGetNaturalWidth self + = fromIntegral <$> + ({# call webkit_dom_html_image_element_get_natural_width #} + (toHTMLImageElement self)) + +htmlImageElementGetX :: + (HTMLImageElementClass self) => self -> IO Int +htmlImageElementGetX self + = fromIntegral <$> + ({# call webkit_dom_html_image_element_get_x #} + (toHTMLImageElement self)) + +htmlImageElementGetY :: + (HTMLImageElementClass self) => self -> IO Int +htmlImageElementGetY self + = fromIntegral <$> + ({# call webkit_dom_html_image_element_get_y #} + (toHTMLImageElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLInputElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLInputElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLInputElement.chs @@ -0,0 +1,789 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLInputElement + (htmlInputElementStepUp, htmlInputElementStepDown, + htmlInputElementCheckValidity, htmlInputElementSetCustomValidity, + htmlInputElementSelect, htmlInputElementSetValueForUser, + htmlInputElementSetAccept, htmlInputElementGetAccept, + htmlInputElementSetAlt, htmlInputElementGetAlt, + htmlInputElementSetAutocomplete, htmlInputElementGetAutocomplete, + htmlInputElementSetAutofocus, htmlInputElementGetAutofocus, + htmlInputElementSetDefaultChecked, + htmlInputElementGetDefaultChecked, htmlInputElementSetChecked, + htmlInputElementGetChecked, htmlInputElementSetDirName, + htmlInputElementGetDirName, htmlInputElementSetDisabled, + htmlInputElementGetDisabled, htmlInputElementGetForm, +#if WEBKIT_CHECK_VERSION(1,10,0) + htmlInputElementSetFiles, +#endif + htmlInputElementGetFiles, + htmlInputElementSetFormAction, htmlInputElementGetFormAction, + htmlInputElementSetFormEnctype, htmlInputElementGetFormEnctype, + htmlInputElementSetFormMethod, htmlInputElementGetFormMethod, + htmlInputElementSetFormNoValidate, + htmlInputElementGetFormNoValidate, htmlInputElementSetFormTarget, + htmlInputElementGetFormTarget, +#if WEBKIT_CHECK_VERSION(1,10,0) + htmlInputElementSetHeight, htmlInputElementGetHeight, +#endif + htmlInputElementSetIndeterminate, + htmlInputElementGetIndeterminate, htmlInputElementGetList, + htmlInputElementSetMax, htmlInputElementGetMax, + htmlInputElementSetMaxLength, htmlInputElementGetMaxLength, + htmlInputElementSetMin, htmlInputElementGetMin, + htmlInputElementSetMultiple, htmlInputElementGetMultiple, + htmlInputElementSetName, htmlInputElementGetName, + htmlInputElementSetPattern, htmlInputElementGetPattern, + htmlInputElementSetPlaceholder, htmlInputElementGetPlaceholder, + htmlInputElementSetReadOnly, htmlInputElementGetReadOnly, + htmlInputElementSetRequired, htmlInputElementGetRequired, + htmlInputElementSetSize, htmlInputElementGetSize, + htmlInputElementSetSrc, htmlInputElementGetSrc, + htmlInputElementSetStep, htmlInputElementGetStep, + htmlInputElementSetDefaultValue, htmlInputElementGetDefaultValue, + htmlInputElementSetValue, htmlInputElementGetValue, + htmlInputElementSetValueAsNumber, htmlInputElementGetValueAsNumber, +#if WEBKIT_CHECK_VERSION(1,10,0) + htmlInputElementSetWidth, htmlInputElementGetWidth, +#endif + htmlInputElementGetWillValidate, htmlInputElementGetValidity, + htmlInputElementGetValidationMessage, htmlInputElementGetLabels, + htmlInputElementSetAlign, htmlInputElementGetAlign, + htmlInputElementSetWebkitdirectory, + htmlInputElementGetWebkitdirectory, htmlInputElementSetUseMap, + htmlInputElementGetUseMap, htmlInputElementSetIncremental, + htmlInputElementGetIncremental, htmlInputElementSetWebkitSpeech, + htmlInputElementGetWebkitSpeech, htmlInputElementSetWebkitGrammar, + htmlInputElementGetWebkitGrammar, + htmlInputElementOnwebkitspeechchange +#if WEBKIT_CHECK_VERSION(1,10,0) + , htmlInputElementSetCapture, htmlInputElementGetCapture +#endif + ) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlInputElementStepUp :: + (HTMLInputElementClass self) => self -> Int -> IO () +htmlInputElementStepUp self n + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_step_up #} + (toHTMLInputElement self) + (fromIntegral n) + errorPtr_ + +htmlInputElementStepDown :: + (HTMLInputElementClass self) => self -> Int -> IO () +htmlInputElementStepDown self n + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_step_down #} + (toHTMLInputElement self) + (fromIntegral n) + errorPtr_ + +htmlInputElementCheckValidity :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementCheckValidity self + = toBool <$> + ({# call webkit_dom_html_input_element_check_validity #} + (toHTMLInputElement self)) + +htmlInputElementSetCustomValidity :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetCustomValidity self error + = withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_input_element_set_custom_validity #} + (toHTMLInputElement self) + errorPtr + +htmlInputElementSelect :: + (HTMLInputElementClass self) => self -> IO () +htmlInputElementSelect self + = {# call webkit_dom_html_input_element_select #} + (toHTMLInputElement self) + +htmlInputElementSetValueForUser :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetValueForUser self value + = withUTFString value $ + \ valuePtr -> + {# call webkit_dom_html_input_element_set_value_for_user #} + (toHTMLInputElement self) + valuePtr + +htmlInputElementSetAccept :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetAccept self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_accept #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetAccept :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetAccept self + = ({# call webkit_dom_html_input_element_get_accept #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetAlt :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetAlt self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_alt #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetAlt :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetAlt self + = ({# call webkit_dom_html_input_element_get_alt #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetAutocomplete :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetAutocomplete self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_autocomplete #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetAutocomplete :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetAutocomplete self + = ({# call webkit_dom_html_input_element_get_autocomplete #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetAutofocus :: + (HTMLInputElementClass self) => self -> Bool -> IO () +htmlInputElementSetAutofocus self val + = {# call webkit_dom_html_input_element_set_autofocus #} + (toHTMLInputElement self) + (fromBool val) + +htmlInputElementGetAutofocus :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetAutofocus self + = toBool <$> + ({# call webkit_dom_html_input_element_get_autofocus #} + (toHTMLInputElement self)) + +htmlInputElementSetDefaultChecked :: + (HTMLInputElementClass self) => self -> Bool -> IO () +htmlInputElementSetDefaultChecked self val + = {# call webkit_dom_html_input_element_set_default_checked #} + (toHTMLInputElement self) + (fromBool val) + +htmlInputElementGetDefaultChecked :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetDefaultChecked self + = toBool <$> + ({# call webkit_dom_html_input_element_get_default_checked #} + (toHTMLInputElement self)) + +htmlInputElementSetChecked :: + (HTMLInputElementClass self) => self -> Bool -> IO () +htmlInputElementSetChecked self val + = {# call webkit_dom_html_input_element_set_checked #} + (toHTMLInputElement self) + (fromBool val) + +htmlInputElementGetChecked :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetChecked self + = toBool <$> + ({# call webkit_dom_html_input_element_get_checked #} + (toHTMLInputElement self)) + +htmlInputElementSetDirName :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetDirName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_dir_name #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetDirName :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetDirName self + = ({# call webkit_dom_html_input_element_get_dir_name #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetDisabled :: + (HTMLInputElementClass self) => self -> Bool -> IO () +htmlInputElementSetDisabled self val + = {# call webkit_dom_html_input_element_set_disabled #} + (toHTMLInputElement self) + (fromBool val) + +htmlInputElementGetDisabled :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetDisabled self + = toBool <$> + ({# call webkit_dom_html_input_element_get_disabled #} + (toHTMLInputElement self)) + +htmlInputElementGetForm :: + (HTMLInputElementClass self) => self -> IO (Maybe HTMLFormElement) +htmlInputElementGetForm self + = maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_input_element_get_form #} + (toHTMLInputElement self)) + +#if WEBKIT_CHECK_VERSION(1,10,0) +htmlInputElementSetFiles :: + (FileListClass val, HTMLInputElementClass self) => + self -> Maybe val -> IO () +htmlInputElementSetFiles self val + = {# call webkit_dom_html_input_element_set_files #} + (toHTMLInputElement self) + (maybe (FileList nullForeignPtr) toFileList val) +#endif + +htmlInputElementGetFiles :: + (HTMLInputElementClass self) => self -> IO (Maybe FileList) +htmlInputElementGetFiles self + = maybeNull (makeNewGObject mkFileList) + ({# call webkit_dom_html_input_element_get_files #} + (toHTMLInputElement self)) + +htmlInputElementSetFormAction :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetFormAction self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_form_action #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetFormAction :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetFormAction self + = ({# call webkit_dom_html_input_element_get_form_action #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetFormEnctype :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetFormEnctype self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_form_enctype #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetFormEnctype :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetFormEnctype self + = ({# call webkit_dom_html_input_element_get_form_enctype #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetFormMethod :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetFormMethod self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_form_method #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetFormMethod :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetFormMethod self + = ({# call webkit_dom_html_input_element_get_form_method #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetFormNoValidate :: + (HTMLInputElementClass self) => self -> Bool -> IO () +htmlInputElementSetFormNoValidate self val + = {# call webkit_dom_html_input_element_set_form_no_validate #} + (toHTMLInputElement self) + (fromBool val) + +htmlInputElementGetFormNoValidate :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetFormNoValidate self + = toBool <$> + ({# call webkit_dom_html_input_element_get_form_no_validate #} + (toHTMLInputElement self)) + +htmlInputElementSetFormTarget :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetFormTarget self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_form_target #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetFormTarget :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetFormTarget self + = ({# call webkit_dom_html_input_element_get_form_target #} + (toHTMLInputElement self)) + >>= + readUTFString + +#if WEBKIT_CHECK_VERSION(1,10,0) +htmlInputElementSetHeight :: + (HTMLInputElementClass self) => self -> Word -> IO () +htmlInputElementSetHeight self val + = {# call webkit_dom_html_input_element_set_height #} + (toHTMLInputElement self) + (fromIntegral val) + +htmlInputElementGetHeight :: + (HTMLInputElementClass self) => self -> IO Word +htmlInputElementGetHeight self + = fromIntegral <$> + ({# call webkit_dom_html_input_element_get_height #} + (toHTMLInputElement self)) +#endif + +htmlInputElementSetIndeterminate :: + (HTMLInputElementClass self) => self -> Bool -> IO () +htmlInputElementSetIndeterminate self val + = {# call webkit_dom_html_input_element_set_indeterminate #} + (toHTMLInputElement self) + (fromBool val) + +htmlInputElementGetIndeterminate :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetIndeterminate self + = toBool <$> + ({# call webkit_dom_html_input_element_get_indeterminate #} + (toHTMLInputElement self)) + +htmlInputElementGetList :: + (HTMLInputElementClass self) => self -> IO (Maybe HTMLElement) +htmlInputElementGetList self + = maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_input_element_get_list #} + (toHTMLInputElement self)) + +htmlInputElementSetMax :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetMax self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_max #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetMax :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetMax self + = ({# call webkit_dom_html_input_element_get_max #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetMaxLength :: + (HTMLInputElementClass self) => self -> Int -> IO () +htmlInputElementSetMaxLength self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_set_max_length #} + (toHTMLInputElement self) + (fromIntegral val) + errorPtr_ + +htmlInputElementGetMaxLength :: + (HTMLInputElementClass self) => self -> IO Int +htmlInputElementGetMaxLength self + = fromIntegral <$> + ({# call webkit_dom_html_input_element_get_max_length #} + (toHTMLInputElement self)) + +htmlInputElementSetMin :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetMin self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_min #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetMin :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetMin self + = ({# call webkit_dom_html_input_element_get_min #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetMultiple :: + (HTMLInputElementClass self) => self -> Bool -> IO () +htmlInputElementSetMultiple self val + = {# call webkit_dom_html_input_element_set_multiple #} + (toHTMLInputElement self) + (fromBool val) + +htmlInputElementGetMultiple :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetMultiple self + = toBool <$> + ({# call webkit_dom_html_input_element_get_multiple #} + (toHTMLInputElement self)) + +htmlInputElementSetName :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_name #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetName :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetName self + = ({# call webkit_dom_html_input_element_get_name #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetPattern :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetPattern self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_pattern #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetPattern :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetPattern self + = ({# call webkit_dom_html_input_element_get_pattern #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetPlaceholder :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetPlaceholder self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_placeholder #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetPlaceholder :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetPlaceholder self + = ({# call webkit_dom_html_input_element_get_placeholder #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetReadOnly :: + (HTMLInputElementClass self) => self -> Bool -> IO () +htmlInputElementSetReadOnly self val + = {# call webkit_dom_html_input_element_set_read_only #} + (toHTMLInputElement self) + (fromBool val) + +htmlInputElementGetReadOnly :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetReadOnly self + = toBool <$> + ({# call webkit_dom_html_input_element_get_read_only #} + (toHTMLInputElement self)) + +htmlInputElementSetRequired :: + (HTMLInputElementClass self) => self -> Bool -> IO () +htmlInputElementSetRequired self val + = {# call webkit_dom_html_input_element_set_required #} + (toHTMLInputElement self) + (fromBool val) + +htmlInputElementGetRequired :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetRequired self + = toBool <$> + ({# call webkit_dom_html_input_element_get_required #} + (toHTMLInputElement self)) + +htmlInputElementSetSize :: (HTMLInputElementClass self) => self -> Word -> IO () +#if WEBKIT_CHECK_VERSION(2,0,0) +htmlInputElementSetSize self val = propagateGError $ \errorPtr -> + {# call webkit_dom_html_input_element_set_size #} (toHTMLInputElement self) (fromIntegral val) errorPtr +#else +htmlInputElementSetSize self val = {# call webkit_dom_html_input_element_set_size #} (toHTMLInputElement self) (fromIntegral val) +#endif + +htmlInputElementGetSize :: + (HTMLInputElementClass self) => self -> IO Word +htmlInputElementGetSize self + = fromIntegral <$> + ({# call webkit_dom_html_input_element_get_size #} + (toHTMLInputElement self)) + +htmlInputElementSetSrc :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetSrc self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_src #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetSrc :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetSrc self + = ({# call webkit_dom_html_input_element_get_src #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetStep :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetStep self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_step #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetStep :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetStep self + = ({# call webkit_dom_html_input_element_get_step #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetDefaultValue :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetDefaultValue self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_default_value #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetDefaultValue :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetDefaultValue self + = ({# call webkit_dom_html_input_element_get_default_value #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetValue :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetValue self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_value #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetValue :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetValue self + = ({# call webkit_dom_html_input_element_get_value #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetValueAsNumber :: + (HTMLInputElementClass self) => self -> Double -> IO () +htmlInputElementSetValueAsNumber self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_set_value_as_number #} + (toHTMLInputElement self) + (realToFrac val) + errorPtr_ + +htmlInputElementGetValueAsNumber :: + (HTMLInputElementClass self) => self -> IO Double +htmlInputElementGetValueAsNumber self + = realToFrac <$> + ({# call webkit_dom_html_input_element_get_value_as_number #} + (toHTMLInputElement self)) + +#if WEBKIT_CHECK_VERSION(1,10,0) +htmlInputElementSetWidth :: + (HTMLInputElementClass self) => self -> Word -> IO () +htmlInputElementSetWidth self val + = {# call webkit_dom_html_input_element_set_width #} + (toHTMLInputElement self) + (fromIntegral val) + +htmlInputElementGetWidth :: + (HTMLInputElementClass self) => self -> IO Word +htmlInputElementGetWidth self + = fromIntegral <$> + ({# call webkit_dom_html_input_element_get_width #} + (toHTMLInputElement self)) +#endif + +htmlInputElementGetWillValidate :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetWillValidate self + = toBool <$> + ({# call webkit_dom_html_input_element_get_will_validate #} + (toHTMLInputElement self)) + +htmlInputElementGetValidity :: + (HTMLInputElementClass self) => self -> IO (Maybe ValidityState) +htmlInputElementGetValidity self + = maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_input_element_get_validity #} + (toHTMLInputElement self)) + +htmlInputElementGetValidationMessage :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetValidationMessage self + = ({# call webkit_dom_html_input_element_get_validation_message #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementGetLabels :: + (HTMLInputElementClass self) => self -> IO (Maybe NodeList) +htmlInputElementGetLabels self + = maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_input_element_get_labels #} + (toHTMLInputElement self)) + +htmlInputElementSetAlign :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_align #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetAlign :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetAlign self + = ({# call webkit_dom_html_input_element_get_align #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetWebkitdirectory :: + (HTMLInputElementClass self) => self -> Bool -> IO () +htmlInputElementSetWebkitdirectory self val + = {# call webkit_dom_html_input_element_set_webkitdirectory #} + (toHTMLInputElement self) + (fromBool val) + +htmlInputElementGetWebkitdirectory :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetWebkitdirectory self + = toBool <$> + ({# call webkit_dom_html_input_element_get_webkitdirectory #} + (toHTMLInputElement self)) + +htmlInputElementSetUseMap :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetUseMap self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_use_map #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetUseMap :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetUseMap self + = ({# call webkit_dom_html_input_element_get_use_map #} + (toHTMLInputElement self)) + >>= + readUTFString + +htmlInputElementSetIncremental :: + (HTMLInputElementClass self) => self -> Bool -> IO () +htmlInputElementSetIncremental self val + = {# call webkit_dom_html_input_element_set_incremental #} + (toHTMLInputElement self) + (fromBool val) + +htmlInputElementGetIncremental :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetIncremental self + = toBool <$> + ({# call webkit_dom_html_input_element_get_incremental #} + (toHTMLInputElement self)) + +htmlInputElementSetWebkitSpeech :: + (HTMLInputElementClass self) => self -> Bool -> IO () +htmlInputElementSetWebkitSpeech self val + = {# call webkit_dom_html_input_element_set_webkit_speech #} + (toHTMLInputElement self) + (fromBool val) + +htmlInputElementGetWebkitSpeech :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetWebkitSpeech self + = toBool <$> + ({# call webkit_dom_html_input_element_get_webkit_speech #} + (toHTMLInputElement self)) + +htmlInputElementSetWebkitGrammar :: + (HTMLInputElementClass self) => self -> Bool -> IO () +htmlInputElementSetWebkitGrammar self val + = {# call webkit_dom_html_input_element_set_webkit_grammar #} + (toHTMLInputElement self) + (fromBool val) + +htmlInputElementGetWebkitGrammar :: + (HTMLInputElementClass self) => self -> IO Bool +htmlInputElementGetWebkitGrammar self + = toBool <$> + ({# call webkit_dom_html_input_element_get_webkit_grammar #} + (toHTMLInputElement self)) + +htmlInputElementOnwebkitspeechchange :: + (HTMLInputElementClass self) => + Signal self (EventM UIEvent self ()) +htmlInputElementOnwebkitspeechchange + = (connect "webkitspeechchange") + +#if WEBKIT_CHECK_VERSION(1,10,0) +htmlInputElementSetCapture :: + (HTMLInputElementClass self) => self -> String -> IO () +htmlInputElementSetCapture self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_capture #} + (toHTMLInputElement self) + valPtr + +htmlInputElementGetCapture :: + (HTMLInputElementClass self) => self -> IO String +htmlInputElementGetCapture self + = ({# call webkit_dom_html_input_element_get_capture #} + (toHTMLInputElement self)) + >>= + readUTFString +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLKeygenElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLKeygenElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLKeygenElement.chs @@ -0,0 +1,148 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLKeygenElement + (htmlKeygenElementCheckValidity, + htmlKeygenElementSetCustomValidity, htmlKeygenElementSetAutofocus, + htmlKeygenElementGetAutofocus, htmlKeygenElementSetChallenge, + htmlKeygenElementGetChallenge, htmlKeygenElementSetDisabled, + htmlKeygenElementGetDisabled, htmlKeygenElementGetForm, + htmlKeygenElementSetKeytype, htmlKeygenElementGetKeytype, + htmlKeygenElementSetName, htmlKeygenElementGetName, + htmlKeygenElementGetWillValidate, htmlKeygenElementGetValidity, + htmlKeygenElementGetValidationMessage, htmlKeygenElementGetLabels) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlKeygenElementCheckValidity :: + (HTMLKeygenElementClass self) => self -> IO Bool +htmlKeygenElementCheckValidity self + = toBool <$> + ({# call webkit_dom_html_keygen_element_check_validity #} + (toHTMLKeygenElement self)) + +htmlKeygenElementSetCustomValidity :: + (HTMLKeygenElementClass self) => self -> String -> IO () +htmlKeygenElementSetCustomValidity self error + = withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_keygen_element_set_custom_validity #} + (toHTMLKeygenElement self) + errorPtr + +htmlKeygenElementSetAutofocus :: + (HTMLKeygenElementClass self) => self -> Bool -> IO () +htmlKeygenElementSetAutofocus self val + = {# call webkit_dom_html_keygen_element_set_autofocus #} + (toHTMLKeygenElement self) + (fromBool val) + +htmlKeygenElementGetAutofocus :: + (HTMLKeygenElementClass self) => self -> IO Bool +htmlKeygenElementGetAutofocus self + = toBool <$> + ({# call webkit_dom_html_keygen_element_get_autofocus #} + (toHTMLKeygenElement self)) + +htmlKeygenElementSetChallenge :: + (HTMLKeygenElementClass self) => self -> String -> IO () +htmlKeygenElementSetChallenge self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_keygen_element_set_challenge #} + (toHTMLKeygenElement self) + valPtr + +htmlKeygenElementGetChallenge :: + (HTMLKeygenElementClass self) => self -> IO String +htmlKeygenElementGetChallenge self + = ({# call webkit_dom_html_keygen_element_get_challenge #} + (toHTMLKeygenElement self)) + >>= + readUTFString + +htmlKeygenElementSetDisabled :: + (HTMLKeygenElementClass self) => self -> Bool -> IO () +htmlKeygenElementSetDisabled self val + = {# call webkit_dom_html_keygen_element_set_disabled #} + (toHTMLKeygenElement self) + (fromBool val) + +htmlKeygenElementGetDisabled :: + (HTMLKeygenElementClass self) => self -> IO Bool +htmlKeygenElementGetDisabled self + = toBool <$> + ({# call webkit_dom_html_keygen_element_get_disabled #} + (toHTMLKeygenElement self)) + +htmlKeygenElementGetForm :: + (HTMLKeygenElementClass self) => self -> IO (Maybe HTMLFormElement) +htmlKeygenElementGetForm self + = maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_keygen_element_get_form #} + (toHTMLKeygenElement self)) + +htmlKeygenElementSetKeytype :: + (HTMLKeygenElementClass self) => self -> String -> IO () +htmlKeygenElementSetKeytype self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_keygen_element_set_keytype #} + (toHTMLKeygenElement self) + valPtr + +htmlKeygenElementGetKeytype :: + (HTMLKeygenElementClass self) => self -> IO String +htmlKeygenElementGetKeytype self + = ({# call webkit_dom_html_keygen_element_get_keytype #} + (toHTMLKeygenElement self)) + >>= + readUTFString + +htmlKeygenElementSetName :: + (HTMLKeygenElementClass self) => self -> String -> IO () +htmlKeygenElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_keygen_element_set_name #} + (toHTMLKeygenElement self) + valPtr + +htmlKeygenElementGetName :: + (HTMLKeygenElementClass self) => self -> IO String +htmlKeygenElementGetName self + = ({# call webkit_dom_html_keygen_element_get_name #} + (toHTMLKeygenElement self)) + >>= + readUTFString + +htmlKeygenElementGetWillValidate :: + (HTMLKeygenElementClass self) => self -> IO Bool +htmlKeygenElementGetWillValidate self + = toBool <$> + ({# call webkit_dom_html_keygen_element_get_will_validate #} + (toHTMLKeygenElement self)) + +htmlKeygenElementGetValidity :: + (HTMLKeygenElementClass self) => self -> IO (Maybe ValidityState) +htmlKeygenElementGetValidity self + = maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_keygen_element_get_validity #} + (toHTMLKeygenElement self)) + +htmlKeygenElementGetValidationMessage :: + (HTMLKeygenElementClass self) => self -> IO String +htmlKeygenElementGetValidationMessage self + = ({# call webkit_dom_html_keygen_element_get_validation_message #} + (toHTMLKeygenElement self)) + >>= + readUTFString + +htmlKeygenElementGetLabels :: + (HTMLKeygenElementClass self) => self -> IO (Maybe NodeList) +htmlKeygenElementGetLabels self + = maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_keygen_element_get_labels #} + (toHTMLKeygenElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLLIElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLLIElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLLIElement.chs @@ -0,0 +1,22 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLLIElement + (htmlliElementSetValue, htmlliElementGetValue) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlliElementSetValue :: + (HTMLLIElementClass self) => self -> Int -> IO () +htmlliElementSetValue self val + = {# call webkit_dom_htmlli_element_set_value #} + (toHTMLLIElement self) + (fromIntegral val) + +htmlliElementGetValue :: + (HTMLLIElementClass self) => self -> IO Int +htmlliElementGetValue self + = fromIntegral <$> + ({# call webkit_dom_htmlli_element_get_value #} + (toHTMLLIElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLLabelElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLLabelElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLLabelElement.chs @@ -0,0 +1,41 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLLabelElement + (htmlLabelElementGetForm, htmlLabelElementSetHtmlFor, + htmlLabelElementGetHtmlFor, htmlLabelElementGetControl) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlLabelElementGetForm :: + (HTMLLabelElementClass self) => self -> IO (Maybe HTMLFormElement) +htmlLabelElementGetForm self + = maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_label_element_get_form #} + (toHTMLLabelElement self)) + +htmlLabelElementSetHtmlFor :: + (HTMLLabelElementClass self) => self -> String -> IO () +htmlLabelElementSetHtmlFor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_label_element_set_html_for #} + (toHTMLLabelElement self) + valPtr + +htmlLabelElementGetHtmlFor :: + (HTMLLabelElementClass self) => self -> IO String +htmlLabelElementGetHtmlFor self + = ({# call webkit_dom_html_label_element_get_html_for #} + (toHTMLLabelElement self)) + >>= + readUTFString + +htmlLabelElementGetControl :: + (HTMLLabelElementClass self) => self -> IO (Maybe HTMLElement) +htmlLabelElementGetControl self + = maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_label_element_get_control #} + (toHTMLLabelElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLLegendElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLLegendElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLLegendElement.chs @@ -0,0 +1,34 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLLegendElement + (htmlLegendElementGetForm, htmlLegendElementSetAlign, + htmlLegendElementGetAlign) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlLegendElementGetForm :: + (HTMLLegendElementClass self) => self -> IO (Maybe HTMLFormElement) +htmlLegendElementGetForm self + = maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_legend_element_get_form #} + (toHTMLLegendElement self)) + +htmlLegendElementSetAlign :: + (HTMLLegendElementClass self) => self -> String -> IO () +htmlLegendElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_legend_element_set_align #} + (toHTMLLegendElement self) + valPtr + +htmlLegendElementGetAlign :: + (HTMLLegendElementClass self) => self -> IO String +htmlLegendElementGetAlign self + = ({# call webkit_dom_html_legend_element_get_align #} + (toHTMLLegendElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLLinkElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLLinkElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLLinkElement.chs @@ -0,0 +1,157 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLLinkElement + (htmlLinkElementSetDisabled, htmlLinkElementGetDisabled, + htmlLinkElementSetCharset, htmlLinkElementGetCharset, + htmlLinkElementSetHref, htmlLinkElementGetHref, + htmlLinkElementSetHreflang, htmlLinkElementGetHreflang, + htmlLinkElementSetMedia, htmlLinkElementGetMedia, + htmlLinkElementSetRel, htmlLinkElementGetRel, + htmlLinkElementSetRev, htmlLinkElementGetRev, + htmlLinkElementSetTarget, htmlLinkElementGetTarget, + htmlLinkElementGetSheet) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlLinkElementSetDisabled :: + (HTMLLinkElementClass self) => self -> Bool -> IO () +htmlLinkElementSetDisabled self val + = {# call webkit_dom_html_link_element_set_disabled #} + (toHTMLLinkElement self) + (fromBool val) + +htmlLinkElementGetDisabled :: + (HTMLLinkElementClass self) => self -> IO Bool +htmlLinkElementGetDisabled self + = toBool <$> + ({# call webkit_dom_html_link_element_get_disabled #} + (toHTMLLinkElement self)) + +htmlLinkElementSetCharset :: + (HTMLLinkElementClass self) => self -> String -> IO () +htmlLinkElementSetCharset self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_charset #} + (toHTMLLinkElement self) + valPtr + +htmlLinkElementGetCharset :: + (HTMLLinkElementClass self) => self -> IO String +htmlLinkElementGetCharset self + = ({# call webkit_dom_html_link_element_get_charset #} + (toHTMLLinkElement self)) + >>= + readUTFString + +htmlLinkElementSetHref :: + (HTMLLinkElementClass self) => self -> String -> IO () +htmlLinkElementSetHref self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_href #} + (toHTMLLinkElement self) + valPtr + +htmlLinkElementGetHref :: + (HTMLLinkElementClass self) => self -> IO String +htmlLinkElementGetHref self + = ({# call webkit_dom_html_link_element_get_href #} + (toHTMLLinkElement self)) + >>= + readUTFString + +htmlLinkElementSetHreflang :: + (HTMLLinkElementClass self) => self -> String -> IO () +htmlLinkElementSetHreflang self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_hreflang #} + (toHTMLLinkElement self) + valPtr + +htmlLinkElementGetHreflang :: + (HTMLLinkElementClass self) => self -> IO String +htmlLinkElementGetHreflang self + = ({# call webkit_dom_html_link_element_get_hreflang #} + (toHTMLLinkElement self)) + >>= + readUTFString + +htmlLinkElementSetMedia :: + (HTMLLinkElementClass self) => self -> String -> IO () +htmlLinkElementSetMedia self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_media #} + (toHTMLLinkElement self) + valPtr + +htmlLinkElementGetMedia :: + (HTMLLinkElementClass self) => self -> IO String +htmlLinkElementGetMedia self + = ({# call webkit_dom_html_link_element_get_media #} + (toHTMLLinkElement self)) + >>= + readUTFString + +htmlLinkElementSetRel :: + (HTMLLinkElementClass self) => self -> String -> IO () +htmlLinkElementSetRel self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_rel #} + (toHTMLLinkElement self) + valPtr + +htmlLinkElementGetRel :: + (HTMLLinkElementClass self) => self -> IO String +htmlLinkElementGetRel self + = ({# call webkit_dom_html_link_element_get_rel #} + (toHTMLLinkElement self)) + >>= + readUTFString + +htmlLinkElementSetRev :: + (HTMLLinkElementClass self) => self -> String -> IO () +htmlLinkElementSetRev self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_rev #} + (toHTMLLinkElement self) + valPtr + +htmlLinkElementGetRev :: + (HTMLLinkElementClass self) => self -> IO String +htmlLinkElementGetRev self + = ({# call webkit_dom_html_link_element_get_rev #} + (toHTMLLinkElement self)) + >>= + readUTFString + +htmlLinkElementSetTarget :: + (HTMLLinkElementClass self) => self -> String -> IO () +htmlLinkElementSetTarget self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_target #} + (toHTMLLinkElement self) + valPtr + +htmlLinkElementGetTarget :: + (HTMLLinkElementClass self) => self -> IO String +htmlLinkElementGetTarget self + = ({# call webkit_dom_html_link_element_get_target #} + (toHTMLLinkElement self)) + >>= + readUTFString + +htmlLinkElementGetSheet :: + (HTMLLinkElementClass self) => self -> IO (Maybe StyleSheet) +htmlLinkElementGetSheet self + = maybeNull (makeNewGObject mkStyleSheet) + ({# call webkit_dom_html_link_element_get_sheet #} + (toHTMLLinkElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMapElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMapElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMapElement.chs @@ -0,0 +1,34 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLMapElement + (htmlMapElementGetAreas, htmlMapElementSetName, + htmlMapElementGetName) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlMapElementGetAreas :: + (HTMLMapElementClass self) => self -> IO (Maybe HTMLCollection) +htmlMapElementGetAreas self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_map_element_get_areas #} + (toHTMLMapElement self)) + +htmlMapElementSetName :: + (HTMLMapElementClass self) => self -> String -> IO () +htmlMapElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_map_element_set_name #} + (toHTMLMapElement self) + valPtr + +htmlMapElementGetName :: + (HTMLMapElementClass self) => self -> IO String +htmlMapElementGetName self + = ({# call webkit_dom_html_map_element_get_name #} + (toHTMLMapElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMarqueeElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMarqueeElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMarqueeElement.chs @@ -0,0 +1,211 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLMarqueeElement + (htmlMarqueeElementStart, htmlMarqueeElementStop, + htmlMarqueeElementSetBehavior, htmlMarqueeElementGetBehavior, + htmlMarqueeElementSetBgColor, htmlMarqueeElementGetBgColor, + htmlMarqueeElementSetDirection, htmlMarqueeElementGetDirection, + htmlMarqueeElementSetHeight, htmlMarqueeElementGetHeight, + htmlMarqueeElementSetHspace, htmlMarqueeElementGetHspace, + htmlMarqueeElementSetLoop, htmlMarqueeElementGetLoop, + htmlMarqueeElementSetScrollAmount, + htmlMarqueeElementGetScrollAmount, + htmlMarqueeElementSetScrollDelay, htmlMarqueeElementGetScrollDelay, + htmlMarqueeElementSetTrueSpeed, htmlMarqueeElementGetTrueSpeed, + htmlMarqueeElementSetVspace, htmlMarqueeElementGetVspace, + htmlMarqueeElementSetWidth, htmlMarqueeElementGetWidth) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlMarqueeElementStart :: + (HTMLMarqueeElementClass self) => self -> IO () +htmlMarqueeElementStart self + = {# call webkit_dom_html_marquee_element_start #} + (toHTMLMarqueeElement self) + +htmlMarqueeElementStop :: + (HTMLMarqueeElementClass self) => self -> IO () +htmlMarqueeElementStop self + = {# call webkit_dom_html_marquee_element_stop #} + (toHTMLMarqueeElement self) + +htmlMarqueeElementSetBehavior :: + (HTMLMarqueeElementClass self) => self -> String -> IO () +htmlMarqueeElementSetBehavior self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_marquee_element_set_behavior #} + (toHTMLMarqueeElement self) + valPtr + +htmlMarqueeElementGetBehavior :: + (HTMLMarqueeElementClass self) => self -> IO String +htmlMarqueeElementGetBehavior self + = ({# call webkit_dom_html_marquee_element_get_behavior #} + (toHTMLMarqueeElement self)) + >>= + readUTFString + +htmlMarqueeElementSetBgColor :: + (HTMLMarqueeElementClass self) => self -> String -> IO () +htmlMarqueeElementSetBgColor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_marquee_element_set_bg_color #} + (toHTMLMarqueeElement self) + valPtr + +htmlMarqueeElementGetBgColor :: + (HTMLMarqueeElementClass self) => self -> IO String +htmlMarqueeElementGetBgColor self + = ({# call webkit_dom_html_marquee_element_get_bg_color #} + (toHTMLMarqueeElement self)) + >>= + readUTFString + +htmlMarqueeElementSetDirection :: + (HTMLMarqueeElementClass self) => self -> String -> IO () +htmlMarqueeElementSetDirection self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_marquee_element_set_direction #} + (toHTMLMarqueeElement self) + valPtr + +htmlMarqueeElementGetDirection :: + (HTMLMarqueeElementClass self) => self -> IO String +htmlMarqueeElementGetDirection self + = ({# call webkit_dom_html_marquee_element_get_direction #} + (toHTMLMarqueeElement self)) + >>= + readUTFString + +htmlMarqueeElementSetHeight :: + (HTMLMarqueeElementClass self) => self -> String -> IO () +htmlMarqueeElementSetHeight self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_marquee_element_set_height #} + (toHTMLMarqueeElement self) + valPtr + +htmlMarqueeElementGetHeight :: + (HTMLMarqueeElementClass self) => self -> IO String +htmlMarqueeElementGetHeight self + = ({# call webkit_dom_html_marquee_element_get_height #} + (toHTMLMarqueeElement self)) + >>= + readUTFString + +htmlMarqueeElementSetHspace :: + (HTMLMarqueeElementClass self) => self -> Word -> IO () +htmlMarqueeElementSetHspace self val + = {# call webkit_dom_html_marquee_element_set_hspace #} + (toHTMLMarqueeElement self) + (fromIntegral val) + +htmlMarqueeElementGetHspace :: + (HTMLMarqueeElementClass self) => self -> IO Word +htmlMarqueeElementGetHspace self + = fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_hspace #} + (toHTMLMarqueeElement self)) + +htmlMarqueeElementSetLoop :: + (HTMLMarqueeElementClass self) => self -> Int -> IO () +htmlMarqueeElementSetLoop self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_marquee_element_set_loop #} + (toHTMLMarqueeElement self) + (fromIntegral val) + errorPtr_ + +htmlMarqueeElementGetLoop :: + (HTMLMarqueeElementClass self) => self -> IO Int +htmlMarqueeElementGetLoop self + = fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_loop #} + (toHTMLMarqueeElement self)) + +htmlMarqueeElementSetScrollAmount :: + (HTMLMarqueeElementClass self) => self -> Int -> IO () +htmlMarqueeElementSetScrollAmount self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_marquee_element_set_scroll_amount #} + (toHTMLMarqueeElement self) + (fromIntegral val) + errorPtr_ + +htmlMarqueeElementGetScrollAmount :: + (HTMLMarqueeElementClass self) => self -> IO Int +htmlMarqueeElementGetScrollAmount self + = fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_scroll_amount #} + (toHTMLMarqueeElement self)) + +htmlMarqueeElementSetScrollDelay :: + (HTMLMarqueeElementClass self) => self -> Int -> IO () +htmlMarqueeElementSetScrollDelay self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_marquee_element_set_scroll_delay #} + (toHTMLMarqueeElement self) + (fromIntegral val) + errorPtr_ + +htmlMarqueeElementGetScrollDelay :: + (HTMLMarqueeElementClass self) => self -> IO Int +htmlMarqueeElementGetScrollDelay self + = fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_scroll_delay #} + (toHTMLMarqueeElement self)) + +htmlMarqueeElementSetTrueSpeed :: + (HTMLMarqueeElementClass self) => self -> Bool -> IO () +htmlMarqueeElementSetTrueSpeed self val + = {# call webkit_dom_html_marquee_element_set_true_speed #} + (toHTMLMarqueeElement self) + (fromBool val) + +htmlMarqueeElementGetTrueSpeed :: + (HTMLMarqueeElementClass self) => self -> IO Bool +htmlMarqueeElementGetTrueSpeed self + = toBool <$> + ({# call webkit_dom_html_marquee_element_get_true_speed #} + (toHTMLMarqueeElement self)) + +htmlMarqueeElementSetVspace :: + (HTMLMarqueeElementClass self) => self -> Word -> IO () +htmlMarqueeElementSetVspace self val + = {# call webkit_dom_html_marquee_element_set_vspace #} + (toHTMLMarqueeElement self) + (fromIntegral val) + +htmlMarqueeElementGetVspace :: + (HTMLMarqueeElementClass self) => self -> IO Word +htmlMarqueeElementGetVspace self + = fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_vspace #} + (toHTMLMarqueeElement self)) + +htmlMarqueeElementSetWidth :: + (HTMLMarqueeElementClass self) => self -> String -> IO () +htmlMarqueeElementSetWidth self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_marquee_element_set_width #} + (toHTMLMarqueeElement self) + valPtr + +htmlMarqueeElementGetWidth :: + (HTMLMarqueeElementClass self) => self -> IO String +htmlMarqueeElementGetWidth self + = ({# call webkit_dom_html_marquee_element_get_width #} + (toHTMLMarqueeElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMediaElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMediaElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMediaElement.chs @@ -0,0 +1,422 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLMediaElement + (htmlMediaElementLoad, htmlMediaElementCanPlayType, + htmlMediaElementPlay, htmlMediaElementPause, cNETWORK_EMPTY, + cNETWORK_IDLE, cNETWORK_LOADING, cNETWORK_NO_SOURCE, cHAVE_NOTHING, + cHAVE_METADATA, cHAVE_CURRENT_DATA, cHAVE_FUTURE_DATA, + cHAVE_ENOUGH_DATA, htmlMediaElementGetError, + htmlMediaElementSetSrc, htmlMediaElementGetSrc, + htmlMediaElementGetCurrentSrc, htmlMediaElementGetNetworkState, + htmlMediaElementSetPreload, htmlMediaElementGetPreload, + htmlMediaElementGetBuffered, htmlMediaElementGetReadyState, + htmlMediaElementGetSeeking, htmlMediaElementSetCurrentTime, + htmlMediaElementGetCurrentTime, htmlMediaElementGetInitialTime, + htmlMediaElementGetStartTime, htmlMediaElementGetDuration, + htmlMediaElementGetPaused, htmlMediaElementSetDefaultPlaybackRate, + htmlMediaElementGetDefaultPlaybackRate, + htmlMediaElementSetPlaybackRate, htmlMediaElementGetPlaybackRate, + htmlMediaElementGetPlayed, htmlMediaElementGetSeekable, + htmlMediaElementGetEnded, htmlMediaElementSetAutoplay, + htmlMediaElementGetAutoplay, htmlMediaElementSetLoop, + htmlMediaElementGetLoop, htmlMediaElementSetControls, + htmlMediaElementGetControls, htmlMediaElementSetVolume, + htmlMediaElementGetVolume, htmlMediaElementSetMuted, + htmlMediaElementGetMuted, htmlMediaElementSetDefaultMuted, + htmlMediaElementGetDefaultMuted, + htmlMediaElementSetWebkitPreservesPitch, + htmlMediaElementGetWebkitPreservesPitch, + htmlMediaElementGetWebkitHasClosedCaptions, + htmlMediaElementSetWebkitClosedCaptionsVisible, + htmlMediaElementGetWebkitClosedCaptionsVisible, + htmlMediaElementGetWebkitAudioDecodedByteCount, + htmlMediaElementGetWebkitVideoDecodedByteCount, + htmlMediaElementSetMediaGroup, htmlMediaElementGetMediaGroup) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +#if WEBKIT_CHECK_VERSION(2,0,0) +htmlMediaElementLoad :: (HTMLMediaElementClass self) => self -> IO () +htmlMediaElementLoad = {# call webkit_dom_html_media_element_load #} . toHTMLMediaElement +#else +htmlMediaElementLoad :: + (HTMLMediaElementClass self) => self -> IO () +htmlMediaElementLoad self + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_media_element_load #} + (toHTMLMediaElement self) + errorPtr_ +#endif + +htmlMediaElementCanPlayType :: + (HTMLMediaElementClass self) => self -> String -> IO String +htmlMediaElementCanPlayType self type' + = (withUTFString type' $ + \ typePtr -> + {# call webkit_dom_html_media_element_can_play_type #} + (toHTMLMediaElement self) + typePtr) + >>= + readUTFString + +htmlMediaElementPlay :: + (HTMLMediaElementClass self) => self -> IO () +htmlMediaElementPlay self + = {# call webkit_dom_html_media_element_play #} + (toHTMLMediaElement self) + +htmlMediaElementPause :: + (HTMLMediaElementClass self) => self -> IO () +htmlMediaElementPause self + = {# call webkit_dom_html_media_element_pause #} + (toHTMLMediaElement self) +cNETWORK_EMPTY = 0 +cNETWORK_IDLE = 1 +cNETWORK_LOADING = 2 +cNETWORK_NO_SOURCE = 3 +cHAVE_NOTHING = 0 +cHAVE_METADATA = 1 +cHAVE_CURRENT_DATA = 2 +cHAVE_FUTURE_DATA = 3 +cHAVE_ENOUGH_DATA = 4 + +htmlMediaElementGetError :: + (HTMLMediaElementClass self) => self -> IO (Maybe MediaError) +htmlMediaElementGetError self + = maybeNull (makeNewGObject mkMediaError) + ({# call webkit_dom_html_media_element_get_error #} + (toHTMLMediaElement self)) + +htmlMediaElementSetSrc :: + (HTMLMediaElementClass self) => self -> String -> IO () +htmlMediaElementSetSrc self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_media_element_set_src #} + (toHTMLMediaElement self) + valPtr + +htmlMediaElementGetSrc :: + (HTMLMediaElementClass self) => self -> IO String +htmlMediaElementGetSrc self + = ({# call webkit_dom_html_media_element_get_src #} + (toHTMLMediaElement self)) + >>= + readUTFString + +htmlMediaElementGetCurrentSrc :: + (HTMLMediaElementClass self) => self -> IO String +htmlMediaElementGetCurrentSrc self + = ({# call webkit_dom_html_media_element_get_current_src #} + (toHTMLMediaElement self)) + >>= + readUTFString + +htmlMediaElementGetNetworkState :: + (HTMLMediaElementClass self) => self -> IO Word +htmlMediaElementGetNetworkState self + = fromIntegral <$> + ({# call webkit_dom_html_media_element_get_network_state #} + (toHTMLMediaElement self)) + +htmlMediaElementSetPreload :: + (HTMLMediaElementClass self) => self -> String -> IO () +htmlMediaElementSetPreload self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_media_element_set_preload #} + (toHTMLMediaElement self) + valPtr + +htmlMediaElementGetPreload :: + (HTMLMediaElementClass self) => self -> IO String +htmlMediaElementGetPreload self + = ({# call webkit_dom_html_media_element_get_preload #} + (toHTMLMediaElement self)) + >>= + readUTFString + +htmlMediaElementGetBuffered :: + (HTMLMediaElementClass self) => self -> IO (Maybe TimeRanges) +htmlMediaElementGetBuffered self + = maybeNull (makeNewGObject mkTimeRanges) + ({# call webkit_dom_html_media_element_get_buffered #} + (toHTMLMediaElement self)) + +htmlMediaElementGetReadyState :: + (HTMLMediaElementClass self) => self -> IO Word +htmlMediaElementGetReadyState self + = fromIntegral <$> + ({# call webkit_dom_html_media_element_get_ready_state #} + (toHTMLMediaElement self)) + +htmlMediaElementGetSeeking :: + (HTMLMediaElementClass self) => self -> IO Bool +htmlMediaElementGetSeeking self + = toBool <$> + ({# call webkit_dom_html_media_element_get_seeking #} + (toHTMLMediaElement self)) + +htmlMediaElementSetCurrentTime :: + (HTMLMediaElementClass self) => self -> Float -> IO () +htmlMediaElementSetCurrentTime self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_media_element_set_current_time #} + (toHTMLMediaElement self) + (realToFrac val) + errorPtr_ + +htmlMediaElementGetCurrentTime :: + (HTMLMediaElementClass self) => self -> IO Float +htmlMediaElementGetCurrentTime self + = realToFrac <$> + ({# call webkit_dom_html_media_element_get_current_time #} + (toHTMLMediaElement self)) + +htmlMediaElementGetInitialTime :: + (HTMLMediaElementClass self) => self -> IO Double +htmlMediaElementGetInitialTime self + = realToFrac <$> + ({# call webkit_dom_html_media_element_get_initial_time #} + (toHTMLMediaElement self)) + +htmlMediaElementGetStartTime :: + (HTMLMediaElementClass self) => self -> IO Float +htmlMediaElementGetStartTime self + = realToFrac <$> + ({# call webkit_dom_html_media_element_get_start_time #} + (toHTMLMediaElement self)) + +htmlMediaElementGetDuration :: + (HTMLMediaElementClass self) => self -> IO Float +htmlMediaElementGetDuration self + = realToFrac <$> + ({# call webkit_dom_html_media_element_get_duration #} + (toHTMLMediaElement self)) + +htmlMediaElementGetPaused :: + (HTMLMediaElementClass self) => self -> IO Bool +htmlMediaElementGetPaused self + = toBool <$> + ({# call webkit_dom_html_media_element_get_paused #} + (toHTMLMediaElement self)) + +htmlMediaElementSetDefaultPlaybackRate :: + (HTMLMediaElementClass self) => self -> Float -> IO () +htmlMediaElementSetDefaultPlaybackRate self val + = {# call webkit_dom_html_media_element_set_default_playback_rate + #} + (toHTMLMediaElement self) + (realToFrac val) + +htmlMediaElementGetDefaultPlaybackRate :: + (HTMLMediaElementClass self) => self -> IO Float +htmlMediaElementGetDefaultPlaybackRate self + = realToFrac <$> + ({# call webkit_dom_html_media_element_get_default_playback_rate #} + (toHTMLMediaElement self)) + +htmlMediaElementSetPlaybackRate :: + (HTMLMediaElementClass self) => self -> Float -> IO () +htmlMediaElementSetPlaybackRate self val + = {# call webkit_dom_html_media_element_set_playback_rate #} + (toHTMLMediaElement self) + (realToFrac val) + +htmlMediaElementGetPlaybackRate :: + (HTMLMediaElementClass self) => self -> IO Float +htmlMediaElementGetPlaybackRate self + = realToFrac <$> + ({# call webkit_dom_html_media_element_get_playback_rate #} + (toHTMLMediaElement self)) + +htmlMediaElementGetPlayed :: + (HTMLMediaElementClass self) => self -> IO (Maybe TimeRanges) +htmlMediaElementGetPlayed self + = maybeNull (makeNewGObject mkTimeRanges) + ({# call webkit_dom_html_media_element_get_played #} + (toHTMLMediaElement self)) + +htmlMediaElementGetSeekable :: + (HTMLMediaElementClass self) => self -> IO (Maybe TimeRanges) +htmlMediaElementGetSeekable self + = maybeNull (makeNewGObject mkTimeRanges) + ({# call webkit_dom_html_media_element_get_seekable #} + (toHTMLMediaElement self)) + +htmlMediaElementGetEnded :: + (HTMLMediaElementClass self) => self -> IO Bool +htmlMediaElementGetEnded self + = toBool <$> + ({# call webkit_dom_html_media_element_get_ended #} + (toHTMLMediaElement self)) + +htmlMediaElementSetAutoplay :: + (HTMLMediaElementClass self) => self -> Bool -> IO () +htmlMediaElementSetAutoplay self val + = {# call webkit_dom_html_media_element_set_autoplay #} + (toHTMLMediaElement self) + (fromBool val) + +htmlMediaElementGetAutoplay :: + (HTMLMediaElementClass self) => self -> IO Bool +htmlMediaElementGetAutoplay self + = toBool <$> + ({# call webkit_dom_html_media_element_get_autoplay #} + (toHTMLMediaElement self)) + +htmlMediaElementSetLoop :: + (HTMLMediaElementClass self) => self -> Bool -> IO () +htmlMediaElementSetLoop self val + = {# call webkit_dom_html_media_element_set_loop #} + (toHTMLMediaElement self) + (fromBool val) + +htmlMediaElementGetLoop :: + (HTMLMediaElementClass self) => self -> IO Bool +htmlMediaElementGetLoop self + = toBool <$> + ({# call webkit_dom_html_media_element_get_loop #} + (toHTMLMediaElement self)) + +htmlMediaElementSetControls :: + (HTMLMediaElementClass self) => self -> Bool -> IO () +htmlMediaElementSetControls self val + = {# call webkit_dom_html_media_element_set_controls #} + (toHTMLMediaElement self) + (fromBool val) + +htmlMediaElementGetControls :: + (HTMLMediaElementClass self) => self -> IO Bool +htmlMediaElementGetControls self + = toBool <$> + ({# call webkit_dom_html_media_element_get_controls #} + (toHTMLMediaElement self)) + +htmlMediaElementSetVolume :: + (HTMLMediaElementClass self) => self -> Float -> IO () +htmlMediaElementSetVolume self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_media_element_set_volume #} + (toHTMLMediaElement self) + (realToFrac val) + errorPtr_ + +htmlMediaElementGetVolume :: + (HTMLMediaElementClass self) => self -> IO Float +htmlMediaElementGetVolume self + = realToFrac <$> + ({# call webkit_dom_html_media_element_get_volume #} + (toHTMLMediaElement self)) + +htmlMediaElementSetMuted :: + (HTMLMediaElementClass self) => self -> Bool -> IO () +htmlMediaElementSetMuted self val + = {# call webkit_dom_html_media_element_set_muted #} + (toHTMLMediaElement self) + (fromBool val) + +htmlMediaElementGetMuted :: + (HTMLMediaElementClass self) => self -> IO Bool +htmlMediaElementGetMuted self + = toBool <$> + ({# call webkit_dom_html_media_element_get_muted #} + (toHTMLMediaElement self)) + +htmlMediaElementSetDefaultMuted :: + (HTMLMediaElementClass self) => self -> Bool -> IO () +htmlMediaElementSetDefaultMuted self val + = {# call webkit_dom_html_media_element_set_default_muted #} + (toHTMLMediaElement self) + (fromBool val) + +htmlMediaElementGetDefaultMuted :: + (HTMLMediaElementClass self) => self -> IO Bool +htmlMediaElementGetDefaultMuted self + = toBool <$> + ({# call webkit_dom_html_media_element_get_default_muted #} + (toHTMLMediaElement self)) + +htmlMediaElementSetWebkitPreservesPitch :: + (HTMLMediaElementClass self) => self -> Bool -> IO () +htmlMediaElementSetWebkitPreservesPitch self val + = {# call webkit_dom_html_media_element_set_webkit_preserves_pitch + #} + (toHTMLMediaElement self) + (fromBool val) + +htmlMediaElementGetWebkitPreservesPitch :: + (HTMLMediaElementClass self) => self -> IO Bool +htmlMediaElementGetWebkitPreservesPitch self + = toBool <$> + ({# call webkit_dom_html_media_element_get_webkit_preserves_pitch + #} + (toHTMLMediaElement self)) + +htmlMediaElementGetWebkitHasClosedCaptions :: + (HTMLMediaElementClass self) => self -> IO Bool +htmlMediaElementGetWebkitHasClosedCaptions self + = toBool <$> + ({# call + webkit_dom_html_media_element_get_webkit_has_closed_captions + #} + (toHTMLMediaElement self)) + +htmlMediaElementSetWebkitClosedCaptionsVisible :: + (HTMLMediaElementClass self) => self -> Bool -> IO () +htmlMediaElementSetWebkitClosedCaptionsVisible self val + = {# call + webkit_dom_html_media_element_set_webkit_closed_captions_visible + #} + (toHTMLMediaElement self) + (fromBool val) + +htmlMediaElementGetWebkitClosedCaptionsVisible :: + (HTMLMediaElementClass self) => self -> IO Bool +htmlMediaElementGetWebkitClosedCaptionsVisible self + = toBool <$> + ({# call + webkit_dom_html_media_element_get_webkit_closed_captions_visible + #} + (toHTMLMediaElement self)) + +htmlMediaElementGetWebkitAudioDecodedByteCount :: + (HTMLMediaElementClass self) => self -> IO Word +htmlMediaElementGetWebkitAudioDecodedByteCount self + = fromIntegral <$> + ({# call + webkit_dom_html_media_element_get_webkit_audio_decoded_byte_count + #} + (toHTMLMediaElement self)) + +htmlMediaElementGetWebkitVideoDecodedByteCount :: + (HTMLMediaElementClass self) => self -> IO Word +htmlMediaElementGetWebkitVideoDecodedByteCount self + = fromIntegral <$> + ({# call + webkit_dom_html_media_element_get_webkit_video_decoded_byte_count + #} + (toHTMLMediaElement self)) + +htmlMediaElementSetMediaGroup :: + (HTMLMediaElementClass self) => self -> String -> IO () +htmlMediaElementSetMediaGroup self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_media_element_set_media_group #} + (toHTMLMediaElement self) + valPtr + +htmlMediaElementGetMediaGroup :: + (HTMLMediaElementClass self) => self -> IO String +htmlMediaElementGetMediaGroup self + = ({# call webkit_dom_html_media_element_get_media_group #} + (toHTMLMediaElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMenuElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMenuElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMenuElement.chs @@ -0,0 +1,22 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLMenuElement + (htmlMenuElementSetCompact, htmlMenuElementGetCompact) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlMenuElementSetCompact :: + (HTMLMenuElementClass self) => self -> Bool -> IO () +htmlMenuElementSetCompact self val + = {# call webkit_dom_html_menu_element_set_compact #} + (toHTMLMenuElement self) + (fromBool val) + +htmlMenuElementGetCompact :: + (HTMLMenuElementClass self) => self -> IO Bool +htmlMenuElementGetCompact self + = toBool <$> + ({# call webkit_dom_html_menu_element_get_compact #} + (toHTMLMenuElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMetaElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMetaElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMetaElement.chs @@ -0,0 +1,80 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLMetaElement + (htmlMetaElementSetContent, htmlMetaElementGetContent, + htmlMetaElementSetHttpEquiv, htmlMetaElementGetHttpEquiv, + htmlMetaElementSetName, htmlMetaElementGetName, + htmlMetaElementSetScheme, htmlMetaElementGetScheme) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlMetaElementSetContent :: + (HTMLMetaElementClass self) => self -> String -> IO () +htmlMetaElementSetContent self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_meta_element_set_content #} + (toHTMLMetaElement self) + valPtr + +htmlMetaElementGetContent :: + (HTMLMetaElementClass self) => self -> IO String +htmlMetaElementGetContent self + = ({# call webkit_dom_html_meta_element_get_content #} + (toHTMLMetaElement self)) + >>= + readUTFString + +htmlMetaElementSetHttpEquiv :: + (HTMLMetaElementClass self) => self -> String -> IO () +htmlMetaElementSetHttpEquiv self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_meta_element_set_http_equiv #} + (toHTMLMetaElement self) + valPtr + +htmlMetaElementGetHttpEquiv :: + (HTMLMetaElementClass self) => self -> IO String +htmlMetaElementGetHttpEquiv self + = ({# call webkit_dom_html_meta_element_get_http_equiv #} + (toHTMLMetaElement self)) + >>= + readUTFString + +htmlMetaElementSetName :: + (HTMLMetaElementClass self) => self -> String -> IO () +htmlMetaElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_meta_element_set_name #} + (toHTMLMetaElement self) + valPtr + +htmlMetaElementGetName :: + (HTMLMetaElementClass self) => self -> IO String +htmlMetaElementGetName self + = ({# call webkit_dom_html_meta_element_get_name #} + (toHTMLMetaElement self)) + >>= + readUTFString + +htmlMetaElementSetScheme :: + (HTMLMetaElementClass self) => self -> String -> IO () +htmlMetaElementSetScheme self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_meta_element_set_scheme #} + (toHTMLMetaElement self) + valPtr + +htmlMetaElementGetScheme :: + (HTMLMetaElementClass self) => self -> IO String +htmlMetaElementGetScheme self + = ({# call webkit_dom_html_meta_element_get_scheme #} + (toHTMLMetaElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLModElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLModElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLModElement.chs @@ -0,0 +1,44 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLModElement + (htmlModElementSetCite, htmlModElementGetCite, + htmlModElementSetDateTime, htmlModElementGetDateTime) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlModElementSetCite :: + (HTMLModElementClass self) => self -> String -> IO () +htmlModElementSetCite self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_mod_element_set_cite #} + (toHTMLModElement self) + valPtr + +htmlModElementGetCite :: + (HTMLModElementClass self) => self -> IO String +htmlModElementGetCite self + = ({# call webkit_dom_html_mod_element_get_cite #} + (toHTMLModElement self)) + >>= + readUTFString + +htmlModElementSetDateTime :: + (HTMLModElementClass self) => self -> String -> IO () +htmlModElementSetDateTime self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_mod_element_set_date_time #} + (toHTMLModElement self) + valPtr + +htmlModElementGetDateTime :: + (HTMLModElementClass self) => self -> IO String +htmlModElementGetDateTime self + = ({# call webkit_dom_html_mod_element_get_date_time #} + (toHTMLModElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLOListElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLOListElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLOListElement.chs @@ -0,0 +1,53 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLOListElement + (htmloListElementSetCompact, htmloListElementGetCompact, + htmloListElementSetStart, htmloListElementGetStart, + htmloListElementSetReversed, htmloListElementGetReversed) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmloListElementSetCompact :: + (HTMLOListElementClass self) => self -> Bool -> IO () +htmloListElementSetCompact self val + = {# call webkit_dom_htmlo_list_element_set_compact #} + (toHTMLOListElement self) + (fromBool val) + +htmloListElementGetCompact :: + (HTMLOListElementClass self) => self -> IO Bool +htmloListElementGetCompact self + = toBool <$> + ({# call webkit_dom_htmlo_list_element_get_compact #} + (toHTMLOListElement self)) + +htmloListElementSetStart :: + (HTMLOListElementClass self) => self -> Int -> IO () +htmloListElementSetStart self val + = {# call webkit_dom_htmlo_list_element_set_start #} + (toHTMLOListElement self) + (fromIntegral val) + +htmloListElementGetStart :: + (HTMLOListElementClass self) => self -> IO Int +htmloListElementGetStart self + = fromIntegral <$> + ({# call webkit_dom_htmlo_list_element_get_start #} + (toHTMLOListElement self)) + +htmloListElementSetReversed :: + (HTMLOListElementClass self) => self -> Bool -> IO () +htmloListElementSetReversed self val + = {# call webkit_dom_htmlo_list_element_set_reversed #} + (toHTMLOListElement self) + (fromBool val) + +htmloListElementGetReversed :: + (HTMLOListElementClass self) => self -> IO Bool +htmloListElementGetReversed self + = toBool <$> + ({# call webkit_dom_htmlo_list_element_get_reversed #} + (toHTMLOListElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLObjectElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLObjectElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLObjectElement.chs @@ -0,0 +1,326 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLObjectElement + (htmlObjectElementCheckValidity, + htmlObjectElementSetCustomValidity, htmlObjectElementGetForm, + htmlObjectElementSetCode, htmlObjectElementGetCode, + htmlObjectElementSetAlign, htmlObjectElementGetAlign, + htmlObjectElementSetArchive, htmlObjectElementGetArchive, + htmlObjectElementSetBorder, htmlObjectElementGetBorder, + htmlObjectElementSetCodeBase, htmlObjectElementGetCodeBase, + htmlObjectElementSetCodeType, htmlObjectElementGetCodeType, + htmlObjectElementSetData, htmlObjectElementGetData, + htmlObjectElementSetDeclare, htmlObjectElementGetDeclare, + htmlObjectElementSetHeight, htmlObjectElementGetHeight, + htmlObjectElementSetHspace, htmlObjectElementGetHspace, + htmlObjectElementSetName, htmlObjectElementGetName, + htmlObjectElementSetStandby, htmlObjectElementGetStandby, + htmlObjectElementSetUseMap, htmlObjectElementGetUseMap, + htmlObjectElementSetVspace, htmlObjectElementGetVspace, + htmlObjectElementSetWidth, htmlObjectElementGetWidth, + htmlObjectElementGetWillValidate, htmlObjectElementGetValidity, + htmlObjectElementGetValidationMessage, + htmlObjectElementGetContentDocument) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlObjectElementCheckValidity :: + (HTMLObjectElementClass self) => self -> IO Bool +htmlObjectElementCheckValidity self + = toBool <$> + ({# call webkit_dom_html_object_element_check_validity #} + (toHTMLObjectElement self)) + +htmlObjectElementSetCustomValidity :: + (HTMLObjectElementClass self) => self -> String -> IO () +htmlObjectElementSetCustomValidity self error + = withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_object_element_set_custom_validity #} + (toHTMLObjectElement self) + errorPtr + +htmlObjectElementGetForm :: + (HTMLObjectElementClass self) => self -> IO (Maybe HTMLFormElement) +htmlObjectElementGetForm self + = maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_object_element_get_form #} + (toHTMLObjectElement self)) + +htmlObjectElementSetCode :: + (HTMLObjectElementClass self) => self -> String -> IO () +htmlObjectElementSetCode self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_code #} + (toHTMLObjectElement self) + valPtr + +htmlObjectElementGetCode :: + (HTMLObjectElementClass self) => self -> IO String +htmlObjectElementGetCode self + = ({# call webkit_dom_html_object_element_get_code #} + (toHTMLObjectElement self)) + >>= + readUTFString + +htmlObjectElementSetAlign :: + (HTMLObjectElementClass self) => self -> String -> IO () +htmlObjectElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_align #} + (toHTMLObjectElement self) + valPtr + +htmlObjectElementGetAlign :: + (HTMLObjectElementClass self) => self -> IO String +htmlObjectElementGetAlign self + = ({# call webkit_dom_html_object_element_get_align #} + (toHTMLObjectElement self)) + >>= + readUTFString + +htmlObjectElementSetArchive :: + (HTMLObjectElementClass self) => self -> String -> IO () +htmlObjectElementSetArchive self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_archive #} + (toHTMLObjectElement self) + valPtr + +htmlObjectElementGetArchive :: + (HTMLObjectElementClass self) => self -> IO String +htmlObjectElementGetArchive self + = ({# call webkit_dom_html_object_element_get_archive #} + (toHTMLObjectElement self)) + >>= + readUTFString + +htmlObjectElementSetBorder :: + (HTMLObjectElementClass self) => self -> String -> IO () +htmlObjectElementSetBorder self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_border #} + (toHTMLObjectElement self) + valPtr + +htmlObjectElementGetBorder :: + (HTMLObjectElementClass self) => self -> IO String +htmlObjectElementGetBorder self + = ({# call webkit_dom_html_object_element_get_border #} + (toHTMLObjectElement self)) + >>= + readUTFString + +htmlObjectElementSetCodeBase :: + (HTMLObjectElementClass self) => self -> String -> IO () +htmlObjectElementSetCodeBase self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_code_base #} + (toHTMLObjectElement self) + valPtr + +htmlObjectElementGetCodeBase :: + (HTMLObjectElementClass self) => self -> IO String +htmlObjectElementGetCodeBase self + = ({# call webkit_dom_html_object_element_get_code_base #} + (toHTMLObjectElement self)) + >>= + readUTFString + +htmlObjectElementSetCodeType :: + (HTMLObjectElementClass self) => self -> String -> IO () +htmlObjectElementSetCodeType self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_code_type #} + (toHTMLObjectElement self) + valPtr + +htmlObjectElementGetCodeType :: + (HTMLObjectElementClass self) => self -> IO String +htmlObjectElementGetCodeType self + = ({# call webkit_dom_html_object_element_get_code_type #} + (toHTMLObjectElement self)) + >>= + readUTFString + +htmlObjectElementSetData :: + (HTMLObjectElementClass self) => self -> String -> IO () +htmlObjectElementSetData self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_data #} + (toHTMLObjectElement self) + valPtr + +htmlObjectElementGetData :: + (HTMLObjectElementClass self) => self -> IO String +htmlObjectElementGetData self + = ({# call webkit_dom_html_object_element_get_data #} + (toHTMLObjectElement self)) + >>= + readUTFString + +htmlObjectElementSetDeclare :: + (HTMLObjectElementClass self) => self -> Bool -> IO () +htmlObjectElementSetDeclare self val + = {# call webkit_dom_html_object_element_set_declare #} + (toHTMLObjectElement self) + (fromBool val) + +htmlObjectElementGetDeclare :: + (HTMLObjectElementClass self) => self -> IO Bool +htmlObjectElementGetDeclare self + = toBool <$> + ({# call webkit_dom_html_object_element_get_declare #} + (toHTMLObjectElement self)) + +htmlObjectElementSetHeight :: + (HTMLObjectElementClass self) => self -> String -> IO () +htmlObjectElementSetHeight self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_height #} + (toHTMLObjectElement self) + valPtr + +htmlObjectElementGetHeight :: + (HTMLObjectElementClass self) => self -> IO String +htmlObjectElementGetHeight self + = ({# call webkit_dom_html_object_element_get_height #} + (toHTMLObjectElement self)) + >>= + readUTFString + +htmlObjectElementSetHspace :: + (HTMLObjectElementClass self) => self -> Int -> IO () +htmlObjectElementSetHspace self val + = {# call webkit_dom_html_object_element_set_hspace #} + (toHTMLObjectElement self) + (fromIntegral val) + +htmlObjectElementGetHspace :: + (HTMLObjectElementClass self) => self -> IO Int +htmlObjectElementGetHspace self + = fromIntegral <$> + ({# call webkit_dom_html_object_element_get_hspace #} + (toHTMLObjectElement self)) + +htmlObjectElementSetName :: + (HTMLObjectElementClass self) => self -> String -> IO () +htmlObjectElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_name #} + (toHTMLObjectElement self) + valPtr + +htmlObjectElementGetName :: + (HTMLObjectElementClass self) => self -> IO String +htmlObjectElementGetName self + = ({# call webkit_dom_html_object_element_get_name #} + (toHTMLObjectElement self)) + >>= + readUTFString + +htmlObjectElementSetStandby :: + (HTMLObjectElementClass self) => self -> String -> IO () +htmlObjectElementSetStandby self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_standby #} + (toHTMLObjectElement self) + valPtr + +htmlObjectElementGetStandby :: + (HTMLObjectElementClass self) => self -> IO String +htmlObjectElementGetStandby self + = ({# call webkit_dom_html_object_element_get_standby #} + (toHTMLObjectElement self)) + >>= + readUTFString + +htmlObjectElementSetUseMap :: + (HTMLObjectElementClass self) => self -> String -> IO () +htmlObjectElementSetUseMap self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_use_map #} + (toHTMLObjectElement self) + valPtr + +htmlObjectElementGetUseMap :: + (HTMLObjectElementClass self) => self -> IO String +htmlObjectElementGetUseMap self + = ({# call webkit_dom_html_object_element_get_use_map #} + (toHTMLObjectElement self)) + >>= + readUTFString + +htmlObjectElementSetVspace :: + (HTMLObjectElementClass self) => self -> Int -> IO () +htmlObjectElementSetVspace self val + = {# call webkit_dom_html_object_element_set_vspace #} + (toHTMLObjectElement self) + (fromIntegral val) + +htmlObjectElementGetVspace :: + (HTMLObjectElementClass self) => self -> IO Int +htmlObjectElementGetVspace self + = fromIntegral <$> + ({# call webkit_dom_html_object_element_get_vspace #} + (toHTMLObjectElement self)) + +htmlObjectElementSetWidth :: + (HTMLObjectElementClass self) => self -> String -> IO () +htmlObjectElementSetWidth self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_width #} + (toHTMLObjectElement self) + valPtr + +htmlObjectElementGetWidth :: + (HTMLObjectElementClass self) => self -> IO String +htmlObjectElementGetWidth self + = ({# call webkit_dom_html_object_element_get_width #} + (toHTMLObjectElement self)) + >>= + readUTFString + +htmlObjectElementGetWillValidate :: + (HTMLObjectElementClass self) => self -> IO Bool +htmlObjectElementGetWillValidate self + = toBool <$> + ({# call webkit_dom_html_object_element_get_will_validate #} + (toHTMLObjectElement self)) + +htmlObjectElementGetValidity :: + (HTMLObjectElementClass self) => self -> IO (Maybe ValidityState) +htmlObjectElementGetValidity self + = maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_object_element_get_validity #} + (toHTMLObjectElement self)) + +htmlObjectElementGetValidationMessage :: + (HTMLObjectElementClass self) => self -> IO String +htmlObjectElementGetValidationMessage self + = ({# call webkit_dom_html_object_element_get_validation_message #} + (toHTMLObjectElement self)) + >>= + readUTFString + +htmlObjectElementGetContentDocument :: + (HTMLObjectElementClass self) => self -> IO (Maybe Document) +htmlObjectElementGetContentDocument self + = maybeNull (makeNewGObject mkDocument) + ({# call webkit_dom_html_object_element_get_content_document #} + (toHTMLObjectElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLOptGroupElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptGroupElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptGroupElement.chs @@ -0,0 +1,41 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLOptGroupElement + (htmlOptGroupElementSetDisabled, htmlOptGroupElementGetDisabled, + htmlOptGroupElementSetLabel, htmlOptGroupElementGetLabel) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlOptGroupElementSetDisabled :: + (HTMLOptGroupElementClass self) => self -> Bool -> IO () +htmlOptGroupElementSetDisabled self val + = {# call webkit_dom_html_opt_group_element_set_disabled #} + (toHTMLOptGroupElement self) + (fromBool val) + +htmlOptGroupElementGetDisabled :: + (HTMLOptGroupElementClass self) => self -> IO Bool +htmlOptGroupElementGetDisabled self + = toBool <$> + ({# call webkit_dom_html_opt_group_element_get_disabled #} + (toHTMLOptGroupElement self)) + +htmlOptGroupElementSetLabel :: + (HTMLOptGroupElementClass self) => self -> String -> IO () +htmlOptGroupElementSetLabel self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_opt_group_element_set_label #} + (toHTMLOptGroupElement self) + valPtr + +htmlOptGroupElementGetLabel :: + (HTMLOptGroupElementClass self) => self -> IO String +htmlOptGroupElementGetLabel self + = ({# call webkit_dom_html_opt_group_element_get_label #} + (toHTMLOptGroupElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionElement.chs @@ -0,0 +1,113 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLOptionElement + (htmlOptionElementSetDisabled, htmlOptionElementGetDisabled, + htmlOptionElementGetForm, htmlOptionElementSetLabel, + htmlOptionElementGetLabel, htmlOptionElementSetDefaultSelected, + htmlOptionElementGetDefaultSelected, htmlOptionElementSetSelected, + htmlOptionElementGetSelected, htmlOptionElementSetValue, + htmlOptionElementGetValue, htmlOptionElementGetText, + htmlOptionElementGetIndex) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlOptionElementSetDisabled :: + (HTMLOptionElementClass self) => self -> Bool -> IO () +htmlOptionElementSetDisabled self val + = {# call webkit_dom_html_option_element_set_disabled #} + (toHTMLOptionElement self) + (fromBool val) + +htmlOptionElementGetDisabled :: + (HTMLOptionElementClass self) => self -> IO Bool +htmlOptionElementGetDisabled self + = toBool <$> + ({# call webkit_dom_html_option_element_get_disabled #} + (toHTMLOptionElement self)) + +htmlOptionElementGetForm :: + (HTMLOptionElementClass self) => self -> IO (Maybe HTMLFormElement) +htmlOptionElementGetForm self + = maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_option_element_get_form #} + (toHTMLOptionElement self)) + +htmlOptionElementSetLabel :: + (HTMLOptionElementClass self) => self -> String -> IO () +htmlOptionElementSetLabel self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_option_element_set_label #} + (toHTMLOptionElement self) + valPtr + +htmlOptionElementGetLabel :: + (HTMLOptionElementClass self) => self -> IO String +htmlOptionElementGetLabel self + = ({# call webkit_dom_html_option_element_get_label #} + (toHTMLOptionElement self)) + >>= + readUTFString + +htmlOptionElementSetDefaultSelected :: + (HTMLOptionElementClass self) => self -> Bool -> IO () +htmlOptionElementSetDefaultSelected self val + = {# call webkit_dom_html_option_element_set_default_selected #} + (toHTMLOptionElement self) + (fromBool val) + +htmlOptionElementGetDefaultSelected :: + (HTMLOptionElementClass self) => self -> IO Bool +htmlOptionElementGetDefaultSelected self + = toBool <$> + ({# call webkit_dom_html_option_element_get_default_selected #} + (toHTMLOptionElement self)) + +htmlOptionElementSetSelected :: + (HTMLOptionElementClass self) => self -> Bool -> IO () +htmlOptionElementSetSelected self val + = {# call webkit_dom_html_option_element_set_selected #} + (toHTMLOptionElement self) + (fromBool val) + +htmlOptionElementGetSelected :: + (HTMLOptionElementClass self) => self -> IO Bool +htmlOptionElementGetSelected self + = toBool <$> + ({# call webkit_dom_html_option_element_get_selected #} + (toHTMLOptionElement self)) + +htmlOptionElementSetValue :: + (HTMLOptionElementClass self) => self -> String -> IO () +htmlOptionElementSetValue self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_option_element_set_value #} + (toHTMLOptionElement self) + valPtr + +htmlOptionElementGetValue :: + (HTMLOptionElementClass self) => self -> IO String +htmlOptionElementGetValue self + = ({# call webkit_dom_html_option_element_get_value #} + (toHTMLOptionElement self)) + >>= + readUTFString + +htmlOptionElementGetText :: + (HTMLOptionElementClass self) => self -> IO String +htmlOptionElementGetText self + = ({# call webkit_dom_html_option_element_get_text #} + (toHTMLOptionElement self)) + >>= + readUTFString + +htmlOptionElementGetIndex :: + (HTMLOptionElementClass self) => self -> IO Int +htmlOptionElementGetIndex self + = fromIntegral <$> + ({# call webkit_dom_html_option_element_get_index #} + (toHTMLOptionElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionsCollection.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionsCollection.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionsCollection.chs @@ -0,0 +1,24 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLOptionsCollection + (htmlOptionsCollectionSetSelectedIndex, + htmlOptionsCollectionGetSelectedIndex) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlOptionsCollectionSetSelectedIndex :: + (HTMLOptionsCollectionClass self) => self -> Int -> IO () +htmlOptionsCollectionSetSelectedIndex self val + = {# call webkit_dom_html_options_collection_set_selected_index #} + (toHTMLOptionsCollection self) + (fromIntegral val) + +htmlOptionsCollectionGetSelectedIndex :: + (HTMLOptionsCollectionClass self) => self -> IO Int +htmlOptionsCollectionGetSelectedIndex self + = fromIntegral <$> + ({# call webkit_dom_html_options_collection_get_selected_index #} + (toHTMLOptionsCollection self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLParagraphElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLParagraphElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLParagraphElement.chs @@ -0,0 +1,25 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLParagraphElement + (htmlParagraphElementSetAlign, htmlParagraphElementGetAlign) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlParagraphElementSetAlign :: + (HTMLParagraphElementClass self) => self -> String -> IO () +htmlParagraphElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_paragraph_element_set_align #} + (toHTMLParagraphElement self) + valPtr + +htmlParagraphElementGetAlign :: + (HTMLParagraphElementClass self) => self -> IO String +htmlParagraphElementGetAlign self + = ({# call webkit_dom_html_paragraph_element_get_align #} + (toHTMLParagraphElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLParamElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLParamElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLParamElement.chs @@ -0,0 +1,62 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLParamElement + (htmlParamElementSetName, htmlParamElementGetName, + htmlParamElementSetValue, htmlParamElementGetValue, + htmlParamElementSetValueType, htmlParamElementGetValueType) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlParamElementSetName :: + (HTMLParamElementClass self) => self -> String -> IO () +htmlParamElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_param_element_set_name #} + (toHTMLParamElement self) + valPtr + +htmlParamElementGetName :: + (HTMLParamElementClass self) => self -> IO String +htmlParamElementGetName self + = ({# call webkit_dom_html_param_element_get_name #} + (toHTMLParamElement self)) + >>= + readUTFString + +htmlParamElementSetValue :: + (HTMLParamElementClass self) => self -> String -> IO () +htmlParamElementSetValue self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_param_element_set_value #} + (toHTMLParamElement self) + valPtr + +htmlParamElementGetValue :: + (HTMLParamElementClass self) => self -> IO String +htmlParamElementGetValue self + = ({# call webkit_dom_html_param_element_get_value #} + (toHTMLParamElement self)) + >>= + readUTFString + +htmlParamElementSetValueType :: + (HTMLParamElementClass self) => self -> String -> IO () +htmlParamElementSetValueType self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_param_element_set_value_type #} + (toHTMLParamElement self) + valPtr + +htmlParamElementGetValueType :: + (HTMLParamElementClass self) => self -> IO String +htmlParamElementGetValueType self + = ({# call webkit_dom_html_param_element_get_value_type #} + (toHTMLParamElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLPreElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLPreElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLPreElement.chs @@ -0,0 +1,38 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLPreElement + (htmlPreElementSetWidth, htmlPreElementGetWidth, + htmlPreElementSetWrap, htmlPreElementGetWrap) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlPreElementSetWidth :: + (HTMLPreElementClass self) => self -> Int -> IO () +htmlPreElementSetWidth self val + = {# call webkit_dom_html_pre_element_set_width #} + (toHTMLPreElement self) + (fromIntegral val) + +htmlPreElementGetWidth :: + (HTMLPreElementClass self) => self -> IO Int +htmlPreElementGetWidth self + = fromIntegral <$> + ({# call webkit_dom_html_pre_element_get_width #} + (toHTMLPreElement self)) + +htmlPreElementSetWrap :: + (HTMLPreElementClass self) => self -> Bool -> IO () +htmlPreElementSetWrap self val + = {# call webkit_dom_html_pre_element_set_wrap #} + (toHTMLPreElement self) + (fromBool val) + +htmlPreElementGetWrap :: + (HTMLPreElementClass self) => self -> IO Bool +htmlPreElementGetWrap self + = toBool <$> + ({# call webkit_dom_html_pre_element_get_wrap #} + (toHTMLPreElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLQuoteElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLQuoteElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLQuoteElement.chs @@ -0,0 +1,25 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLQuoteElement + (htmlQuoteElementSetCite, htmlQuoteElementGetCite) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlQuoteElementSetCite :: + (HTMLQuoteElementClass self) => self -> String -> IO () +htmlQuoteElementSetCite self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_quote_element_set_cite #} + (toHTMLQuoteElement self) + valPtr + +htmlQuoteElementGetCite :: + (HTMLQuoteElementClass self) => self -> IO String +htmlQuoteElementGetCite self + = ({# call webkit_dom_html_quote_element_get_cite #} + (toHTMLQuoteElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLScriptElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLScriptElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLScriptElement.chs @@ -0,0 +1,169 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLScriptElement + (htmlScriptElementSetText, htmlScriptElementGetText, + htmlScriptElementSetHtmlFor, htmlScriptElementGetHtmlFor, + htmlScriptElementSetEvent, htmlScriptElementGetEvent, + htmlScriptElementSetCharset, htmlScriptElementGetCharset, + htmlScriptElementSetAsync, htmlScriptElementGetAsync, + htmlScriptElementSetDefer, htmlScriptElementGetDefer, + htmlScriptElementSetSrc, htmlScriptElementGetSrc +#if WEBKIT_CHECK_VERSION(1,10,0) + , htmlScriptElementSetCrossOrigin, htmlScriptElementGetCrossOrigin, + htmlScriptElementSetNonce, htmlScriptElementGetNonce +#endif + ) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlScriptElementSetText :: + (HTMLScriptElementClass self) => self -> String -> IO () +htmlScriptElementSetText self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_text #} + (toHTMLScriptElement self) + valPtr + +htmlScriptElementGetText :: + (HTMLScriptElementClass self) => self -> IO String +htmlScriptElementGetText self + = ({# call webkit_dom_html_script_element_get_text #} + (toHTMLScriptElement self)) + >>= + readUTFString + +htmlScriptElementSetHtmlFor :: + (HTMLScriptElementClass self) => self -> String -> IO () +htmlScriptElementSetHtmlFor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_html_for #} + (toHTMLScriptElement self) + valPtr + +htmlScriptElementGetHtmlFor :: + (HTMLScriptElementClass self) => self -> IO String +htmlScriptElementGetHtmlFor self + = ({# call webkit_dom_html_script_element_get_html_for #} + (toHTMLScriptElement self)) + >>= + readUTFString + +htmlScriptElementSetEvent :: + (HTMLScriptElementClass self) => self -> String -> IO () +htmlScriptElementSetEvent self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_event #} + (toHTMLScriptElement self) + valPtr + +htmlScriptElementGetEvent :: + (HTMLScriptElementClass self) => self -> IO String +htmlScriptElementGetEvent self + = ({# call webkit_dom_html_script_element_get_event #} + (toHTMLScriptElement self)) + >>= + readUTFString + +htmlScriptElementSetCharset :: + (HTMLScriptElementClass self) => self -> String -> IO () +htmlScriptElementSetCharset self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_charset #} + (toHTMLScriptElement self) + valPtr + +htmlScriptElementGetCharset :: + (HTMLScriptElementClass self) => self -> IO String +htmlScriptElementGetCharset self + = ({# call webkit_dom_html_script_element_get_charset #} + (toHTMLScriptElement self)) + >>= + readUTFString + +htmlScriptElementSetAsync :: + (HTMLScriptElementClass self) => self -> Bool -> IO () +htmlScriptElementSetAsync self val + = {# call webkit_dom_html_script_element_set_async #} + (toHTMLScriptElement self) + (fromBool val) + +htmlScriptElementGetAsync :: + (HTMLScriptElementClass self) => self -> IO Bool +htmlScriptElementGetAsync self + = toBool <$> + ({# call webkit_dom_html_script_element_get_async #} + (toHTMLScriptElement self)) + +htmlScriptElementSetDefer :: + (HTMLScriptElementClass self) => self -> Bool -> IO () +htmlScriptElementSetDefer self val + = {# call webkit_dom_html_script_element_set_defer #} + (toHTMLScriptElement self) + (fromBool val) + +htmlScriptElementGetDefer :: + (HTMLScriptElementClass self) => self -> IO Bool +htmlScriptElementGetDefer self + = toBool <$> + ({# call webkit_dom_html_script_element_get_defer #} + (toHTMLScriptElement self)) + +htmlScriptElementSetSrc :: + (HTMLScriptElementClass self) => self -> String -> IO () +htmlScriptElementSetSrc self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_src #} + (toHTMLScriptElement self) + valPtr + +htmlScriptElementGetSrc :: + (HTMLScriptElementClass self) => self -> IO String +htmlScriptElementGetSrc self + = ({# call webkit_dom_html_script_element_get_src #} + (toHTMLScriptElement self)) + >>= + readUTFString + +#if WEBKIT_CHECK_VERSION(1,10,0) +htmlScriptElementSetCrossOrigin :: + (HTMLScriptElementClass self) => self -> String -> IO () +htmlScriptElementSetCrossOrigin self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_cross_origin #} + (toHTMLScriptElement self) + valPtr + +htmlScriptElementGetCrossOrigin :: + (HTMLScriptElementClass self) => self -> IO String +htmlScriptElementGetCrossOrigin self + = ({# call webkit_dom_html_script_element_get_cross_origin #} + (toHTMLScriptElement self)) + >>= + readUTFString + +htmlScriptElementSetNonce :: + (HTMLScriptElementClass self) => self -> String -> IO () +htmlScriptElementSetNonce self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_nonce #} + (toHTMLScriptElement self) + valPtr + +htmlScriptElementGetNonce :: + (HTMLScriptElementClass self) => self -> IO String +htmlScriptElementGetNonce self + = ({# call webkit_dom_html_script_element_get_nonce #} + (toHTMLScriptElement self)) + >>= + readUTFString +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLSelectElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLSelectElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLSelectElement.chs @@ -0,0 +1,270 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLSelectElement + (htmlSelectElementItem, htmlSelectElementNamedItem, + htmlSelectElementAdd, htmlSelectElementRemove, + htmlSelectElementCheckValidity, htmlSelectElementSetCustomValidity, + htmlSelectElementSetAutofocus, htmlSelectElementGetAutofocus, + htmlSelectElementSetDisabled, htmlSelectElementGetDisabled, + htmlSelectElementGetForm, htmlSelectElementSetMultiple, + htmlSelectElementGetMultiple, htmlSelectElementSetName, + htmlSelectElementGetName, htmlSelectElementSetRequired, + htmlSelectElementGetRequired, htmlSelectElementSetSize, + htmlSelectElementGetSize, htmlSelectElementGetOptions, + htmlSelectElementSetLength, htmlSelectElementGetLength, +#if WEBKIT_CHECK_VERSION(1,10,0) + htmlSelectElementGetSelectedOptions, +#endif + htmlSelectElementSetSelectedIndex, + htmlSelectElementGetSelectedIndex, htmlSelectElementSetValue, + htmlSelectElementGetValue, htmlSelectElementGetWillValidate, + htmlSelectElementGetValidity, + htmlSelectElementGetValidationMessage, htmlSelectElementGetLabels) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlSelectElementItem :: + (HTMLSelectElementClass self) => self -> Word -> IO (Maybe Node) +htmlSelectElementItem self index + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_html_select_element_item #} + (toHTMLSelectElement self) + (fromIntegral index)) + +htmlSelectElementNamedItem :: + (HTMLSelectElementClass self) => self -> String -> IO (Maybe Node) +htmlSelectElementNamedItem self name + = maybeNull (makeNewGObject mkNode) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_html_select_element_named_item #} + (toHTMLSelectElement self) + namePtr) + +htmlSelectElementAdd :: + (HTMLSelectElementClass self, HTMLElementClass element, + HTMLElementClass before) => + self -> Maybe element -> Maybe before -> IO () +htmlSelectElementAdd self element before + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_select_element_add #} + (toHTMLSelectElement self) + (maybe (HTMLElement nullForeignPtr) toHTMLElement element) + (maybe (HTMLElement nullForeignPtr) toHTMLElement before) + errorPtr_ + +htmlSelectElementRemove :: + (HTMLSelectElementClass self) => self -> Int -> IO () +htmlSelectElementRemove self index + = {# call webkit_dom_html_select_element_remove #} + (toHTMLSelectElement self) + (fromIntegral index) + +htmlSelectElementCheckValidity :: + (HTMLSelectElementClass self) => self -> IO Bool +htmlSelectElementCheckValidity self + = toBool <$> + ({# call webkit_dom_html_select_element_check_validity #} + (toHTMLSelectElement self)) + +htmlSelectElementSetCustomValidity :: + (HTMLSelectElementClass self) => self -> String -> IO () +htmlSelectElementSetCustomValidity self error + = withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_select_element_set_custom_validity #} + (toHTMLSelectElement self) + errorPtr + +htmlSelectElementSetAutofocus :: + (HTMLSelectElementClass self) => self -> Bool -> IO () +htmlSelectElementSetAutofocus self val + = {# call webkit_dom_html_select_element_set_autofocus #} + (toHTMLSelectElement self) + (fromBool val) + +htmlSelectElementGetAutofocus :: + (HTMLSelectElementClass self) => self -> IO Bool +htmlSelectElementGetAutofocus self + = toBool <$> + ({# call webkit_dom_html_select_element_get_autofocus #} + (toHTMLSelectElement self)) + +htmlSelectElementSetDisabled :: + (HTMLSelectElementClass self) => self -> Bool -> IO () +htmlSelectElementSetDisabled self val + = {# call webkit_dom_html_select_element_set_disabled #} + (toHTMLSelectElement self) + (fromBool val) + +htmlSelectElementGetDisabled :: + (HTMLSelectElementClass self) => self -> IO Bool +htmlSelectElementGetDisabled self + = toBool <$> + ({# call webkit_dom_html_select_element_get_disabled #} + (toHTMLSelectElement self)) + +htmlSelectElementGetForm :: + (HTMLSelectElementClass self) => self -> IO (Maybe HTMLFormElement) +htmlSelectElementGetForm self + = maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_select_element_get_form #} + (toHTMLSelectElement self)) + +htmlSelectElementSetMultiple :: + (HTMLSelectElementClass self) => self -> Bool -> IO () +htmlSelectElementSetMultiple self val + = {# call webkit_dom_html_select_element_set_multiple #} + (toHTMLSelectElement self) + (fromBool val) + +htmlSelectElementGetMultiple :: + (HTMLSelectElementClass self) => self -> IO Bool +htmlSelectElementGetMultiple self + = toBool <$> + ({# call webkit_dom_html_select_element_get_multiple #} + (toHTMLSelectElement self)) + +htmlSelectElementSetName :: + (HTMLSelectElementClass self) => self -> String -> IO () +htmlSelectElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_select_element_set_name #} + (toHTMLSelectElement self) + valPtr + +htmlSelectElementGetName :: + (HTMLSelectElementClass self) => self -> IO String +htmlSelectElementGetName self + = ({# call webkit_dom_html_select_element_get_name #} + (toHTMLSelectElement self)) + >>= + readUTFString + +htmlSelectElementSetRequired :: + (HTMLSelectElementClass self) => self -> Bool -> IO () +htmlSelectElementSetRequired self val + = {# call webkit_dom_html_select_element_set_required #} + (toHTMLSelectElement self) + (fromBool val) + +htmlSelectElementGetRequired :: + (HTMLSelectElementClass self) => self -> IO Bool +htmlSelectElementGetRequired self + = toBool <$> + ({# call webkit_dom_html_select_element_get_required #} + (toHTMLSelectElement self)) + +htmlSelectElementSetSize :: + (HTMLSelectElementClass self) => self -> Int -> IO () +htmlSelectElementSetSize self val + = {# call webkit_dom_html_select_element_set_size #} + (toHTMLSelectElement self) + (fromIntegral val) + +htmlSelectElementGetSize :: + (HTMLSelectElementClass self) => self -> IO Int +htmlSelectElementGetSize self + = fromIntegral <$> + ({# call webkit_dom_html_select_element_get_size #} + (toHTMLSelectElement self)) + +htmlSelectElementGetOptions :: + (HTMLSelectElementClass self) => + self -> IO (Maybe HTMLOptionsCollection) +htmlSelectElementGetOptions self + = maybeNull (makeNewGObject mkHTMLOptionsCollection) + ({# call webkit_dom_html_select_element_get_options #} + (toHTMLSelectElement self)) + +htmlSelectElementSetLength :: + (HTMLSelectElementClass self) => self -> Word -> IO () +htmlSelectElementSetLength self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_select_element_set_length #} + (toHTMLSelectElement self) + (fromIntegral val) + errorPtr_ + +htmlSelectElementGetLength :: + (HTMLSelectElementClass self) => self -> IO Word +htmlSelectElementGetLength self + = fromIntegral <$> + ({# call webkit_dom_html_select_element_get_length #} + (toHTMLSelectElement self)) + +#if WEBKIT_CHECK_VERSION(1,10,0) +htmlSelectElementGetSelectedOptions :: + (HTMLSelectElementClass self) => + self -> IO (Maybe HTMLCollection) +htmlSelectElementGetSelectedOptions self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_select_element_get_selected_options #} + (toHTMLSelectElement self)) +#endif + +htmlSelectElementSetSelectedIndex :: + (HTMLSelectElementClass self) => self -> Int -> IO () +htmlSelectElementSetSelectedIndex self val + = {# call webkit_dom_html_select_element_set_selected_index #} + (toHTMLSelectElement self) + (fromIntegral val) + +htmlSelectElementGetSelectedIndex :: + (HTMLSelectElementClass self) => self -> IO Int +htmlSelectElementGetSelectedIndex self + = fromIntegral <$> + ({# call webkit_dom_html_select_element_get_selected_index #} + (toHTMLSelectElement self)) + +htmlSelectElementSetValue :: + (HTMLSelectElementClass self) => self -> String -> IO () +htmlSelectElementSetValue self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_select_element_set_value #} + (toHTMLSelectElement self) + valPtr + +htmlSelectElementGetValue :: + (HTMLSelectElementClass self) => self -> IO String +htmlSelectElementGetValue self + = ({# call webkit_dom_html_select_element_get_value #} + (toHTMLSelectElement self)) + >>= + readUTFString + +htmlSelectElementGetWillValidate :: + (HTMLSelectElementClass self) => self -> IO Bool +htmlSelectElementGetWillValidate self + = toBool <$> + ({# call webkit_dom_html_select_element_get_will_validate #} + (toHTMLSelectElement self)) + +htmlSelectElementGetValidity :: + (HTMLSelectElementClass self) => self -> IO (Maybe ValidityState) +htmlSelectElementGetValidity self + = maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_select_element_get_validity #} + (toHTMLSelectElement self)) + +htmlSelectElementGetValidationMessage :: + (HTMLSelectElementClass self) => self -> IO String +htmlSelectElementGetValidationMessage self + = ({# call webkit_dom_html_select_element_get_validation_message #} + (toHTMLSelectElement self)) + >>= + readUTFString + +htmlSelectElementGetLabels :: + (HTMLSelectElementClass self) => self -> IO (Maybe NodeList) +htmlSelectElementGetLabels self + = maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_select_element_get_labels #} + (toHTMLSelectElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLStyleElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLStyleElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLStyleElement.chs @@ -0,0 +1,64 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLStyleElement + (htmlStyleElementSetDisabled, htmlStyleElementGetDisabled, + htmlStyleElementSetScoped, htmlStyleElementGetScoped, + htmlStyleElementSetMedia, htmlStyleElementGetMedia, + htmlStyleElementGetSheet) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlStyleElementSetDisabled :: + (HTMLStyleElementClass self) => self -> Bool -> IO () +htmlStyleElementSetDisabled self val + = {# call webkit_dom_html_style_element_set_disabled #} + (toHTMLStyleElement self) + (fromBool val) + +htmlStyleElementGetDisabled :: + (HTMLStyleElementClass self) => self -> IO Bool +htmlStyleElementGetDisabled self + = toBool <$> + ({# call webkit_dom_html_style_element_get_disabled #} + (toHTMLStyleElement self)) + +htmlStyleElementSetScoped :: + (HTMLStyleElementClass self) => self -> Bool -> IO () +htmlStyleElementSetScoped self val + = {# call webkit_dom_html_style_element_set_scoped #} + (toHTMLStyleElement self) + (fromBool val) + +htmlStyleElementGetScoped :: + (HTMLStyleElementClass self) => self -> IO Bool +htmlStyleElementGetScoped self + = toBool <$> + ({# call webkit_dom_html_style_element_get_scoped #} + (toHTMLStyleElement self)) + +htmlStyleElementSetMedia :: + (HTMLStyleElementClass self) => self -> String -> IO () +htmlStyleElementSetMedia self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_style_element_set_media #} + (toHTMLStyleElement self) + valPtr + +htmlStyleElementGetMedia :: + (HTMLStyleElementClass self) => self -> IO String +htmlStyleElementGetMedia self + = ({# call webkit_dom_html_style_element_get_media #} + (toHTMLStyleElement self)) + >>= + readUTFString + +htmlStyleElementGetSheet :: + (HTMLStyleElementClass self) => self -> IO (Maybe StyleSheet) +htmlStyleElementGetSheet self + = maybeNull (makeNewGObject mkStyleSheet) + ({# call webkit_dom_html_style_element_get_sheet #} + (toHTMLStyleElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCaptionElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCaptionElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCaptionElement.chs @@ -0,0 +1,26 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLTableCaptionElement + (htmlTableCaptionElementSetAlign, htmlTableCaptionElementGetAlign) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlTableCaptionElementSetAlign :: + (HTMLTableCaptionElementClass self) => self -> String -> IO () +htmlTableCaptionElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_caption_element_set_align #} + (toHTMLTableCaptionElement self) + valPtr + +htmlTableCaptionElementGetAlign :: + (HTMLTableCaptionElementClass self) => self -> IO String +htmlTableCaptionElementGetAlign self + = ({# call webkit_dom_html_table_caption_element_get_align #} + (toHTMLTableCaptionElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCellElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCellElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCellElement.chs @@ -0,0 +1,259 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLTableCellElement + (htmlTableCellElementGetCellIndex, htmlTableCellElementSetAbbr, + htmlTableCellElementGetAbbr, htmlTableCellElementSetAlign, + htmlTableCellElementGetAlign, htmlTableCellElementSetAxis, + htmlTableCellElementGetAxis, htmlTableCellElementSetBgColor, + htmlTableCellElementGetBgColor, htmlTableCellElementSetCh, + htmlTableCellElementGetCh, htmlTableCellElementSetChOff, + htmlTableCellElementGetChOff, htmlTableCellElementSetColSpan, + htmlTableCellElementGetColSpan, htmlTableCellElementSetHeaders, + htmlTableCellElementGetHeaders, htmlTableCellElementSetHeight, + htmlTableCellElementGetHeight, htmlTableCellElementSetNoWrap, + htmlTableCellElementGetNoWrap, htmlTableCellElementSetRowSpan, + htmlTableCellElementGetRowSpan, htmlTableCellElementSetScope, + htmlTableCellElementGetScope, htmlTableCellElementSetVAlign, + htmlTableCellElementGetVAlign, htmlTableCellElementSetWidth, + htmlTableCellElementGetWidth) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlTableCellElementGetCellIndex :: + (HTMLTableCellElementClass self) => self -> IO Int +htmlTableCellElementGetCellIndex self + = fromIntegral <$> + ({# call webkit_dom_html_table_cell_element_get_cell_index #} + (toHTMLTableCellElement self)) + +htmlTableCellElementSetAbbr :: + (HTMLTableCellElementClass self) => self -> String -> IO () +htmlTableCellElementSetAbbr self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_abbr #} + (toHTMLTableCellElement self) + valPtr + +htmlTableCellElementGetAbbr :: + (HTMLTableCellElementClass self) => self -> IO String +htmlTableCellElementGetAbbr self + = ({# call webkit_dom_html_table_cell_element_get_abbr #} + (toHTMLTableCellElement self)) + >>= + readUTFString + +htmlTableCellElementSetAlign :: + (HTMLTableCellElementClass self) => self -> String -> IO () +htmlTableCellElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_align #} + (toHTMLTableCellElement self) + valPtr + +htmlTableCellElementGetAlign :: + (HTMLTableCellElementClass self) => self -> IO String +htmlTableCellElementGetAlign self + = ({# call webkit_dom_html_table_cell_element_get_align #} + (toHTMLTableCellElement self)) + >>= + readUTFString + +htmlTableCellElementSetAxis :: + (HTMLTableCellElementClass self) => self -> String -> IO () +htmlTableCellElementSetAxis self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_axis #} + (toHTMLTableCellElement self) + valPtr + +htmlTableCellElementGetAxis :: + (HTMLTableCellElementClass self) => self -> IO String +htmlTableCellElementGetAxis self + = ({# call webkit_dom_html_table_cell_element_get_axis #} + (toHTMLTableCellElement self)) + >>= + readUTFString + +htmlTableCellElementSetBgColor :: + (HTMLTableCellElementClass self) => self -> String -> IO () +htmlTableCellElementSetBgColor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_bg_color #} + (toHTMLTableCellElement self) + valPtr + +htmlTableCellElementGetBgColor :: + (HTMLTableCellElementClass self) => self -> IO String +htmlTableCellElementGetBgColor self + = ({# call webkit_dom_html_table_cell_element_get_bg_color #} + (toHTMLTableCellElement self)) + >>= + readUTFString + +htmlTableCellElementSetCh :: + (HTMLTableCellElementClass self) => self -> String -> IO () +htmlTableCellElementSetCh self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_ch #} + (toHTMLTableCellElement self) + valPtr + +htmlTableCellElementGetCh :: + (HTMLTableCellElementClass self) => self -> IO String +htmlTableCellElementGetCh self + = ({# call webkit_dom_html_table_cell_element_get_ch #} + (toHTMLTableCellElement self)) + >>= + readUTFString + +htmlTableCellElementSetChOff :: + (HTMLTableCellElementClass self) => self -> String -> IO () +htmlTableCellElementSetChOff self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_ch_off #} + (toHTMLTableCellElement self) + valPtr + +htmlTableCellElementGetChOff :: + (HTMLTableCellElementClass self) => self -> IO String +htmlTableCellElementGetChOff self + = ({# call webkit_dom_html_table_cell_element_get_ch_off #} + (toHTMLTableCellElement self)) + >>= + readUTFString + +htmlTableCellElementSetColSpan :: + (HTMLTableCellElementClass self) => self -> Int -> IO () +htmlTableCellElementSetColSpan self val + = {# call webkit_dom_html_table_cell_element_set_col_span #} + (toHTMLTableCellElement self) + (fromIntegral val) + +htmlTableCellElementGetColSpan :: + (HTMLTableCellElementClass self) => self -> IO Int +htmlTableCellElementGetColSpan self + = fromIntegral <$> + ({# call webkit_dom_html_table_cell_element_get_col_span #} + (toHTMLTableCellElement self)) + +htmlTableCellElementSetHeaders :: + (HTMLTableCellElementClass self) => self -> String -> IO () +htmlTableCellElementSetHeaders self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_headers #} + (toHTMLTableCellElement self) + valPtr + +htmlTableCellElementGetHeaders :: + (HTMLTableCellElementClass self) => self -> IO String +htmlTableCellElementGetHeaders self + = ({# call webkit_dom_html_table_cell_element_get_headers #} + (toHTMLTableCellElement self)) + >>= + readUTFString + +htmlTableCellElementSetHeight :: + (HTMLTableCellElementClass self) => self -> String -> IO () +htmlTableCellElementSetHeight self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_height #} + (toHTMLTableCellElement self) + valPtr + +htmlTableCellElementGetHeight :: + (HTMLTableCellElementClass self) => self -> IO String +htmlTableCellElementGetHeight self + = ({# call webkit_dom_html_table_cell_element_get_height #} + (toHTMLTableCellElement self)) + >>= + readUTFString + +htmlTableCellElementSetNoWrap :: + (HTMLTableCellElementClass self) => self -> Bool -> IO () +htmlTableCellElementSetNoWrap self val + = {# call webkit_dom_html_table_cell_element_set_no_wrap #} + (toHTMLTableCellElement self) + (fromBool val) + +htmlTableCellElementGetNoWrap :: + (HTMLTableCellElementClass self) => self -> IO Bool +htmlTableCellElementGetNoWrap self + = toBool <$> + ({# call webkit_dom_html_table_cell_element_get_no_wrap #} + (toHTMLTableCellElement self)) + +htmlTableCellElementSetRowSpan :: + (HTMLTableCellElementClass self) => self -> Int -> IO () +htmlTableCellElementSetRowSpan self val + = {# call webkit_dom_html_table_cell_element_set_row_span #} + (toHTMLTableCellElement self) + (fromIntegral val) + +htmlTableCellElementGetRowSpan :: + (HTMLTableCellElementClass self) => self -> IO Int +htmlTableCellElementGetRowSpan self + = fromIntegral <$> + ({# call webkit_dom_html_table_cell_element_get_row_span #} + (toHTMLTableCellElement self)) + +htmlTableCellElementSetScope :: + (HTMLTableCellElementClass self) => self -> String -> IO () +htmlTableCellElementSetScope self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_scope #} + (toHTMLTableCellElement self) + valPtr + +htmlTableCellElementGetScope :: + (HTMLTableCellElementClass self) => self -> IO String +htmlTableCellElementGetScope self + = ({# call webkit_dom_html_table_cell_element_get_scope #} + (toHTMLTableCellElement self)) + >>= + readUTFString + +htmlTableCellElementSetVAlign :: + (HTMLTableCellElementClass self) => self -> String -> IO () +htmlTableCellElementSetVAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_v_align #} + (toHTMLTableCellElement self) + valPtr + +htmlTableCellElementGetVAlign :: + (HTMLTableCellElementClass self) => self -> IO String +htmlTableCellElementGetVAlign self + = ({# call webkit_dom_html_table_cell_element_get_v_align #} + (toHTMLTableCellElement self)) + >>= + readUTFString + +htmlTableCellElementSetWidth :: + (HTMLTableCellElementClass self) => self -> String -> IO () +htmlTableCellElementSetWidth self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_width #} + (toHTMLTableCellElement self) + valPtr + +htmlTableCellElementGetWidth :: + (HTMLTableCellElementClass self) => self -> IO String +htmlTableCellElementGetWidth self + = ({# call webkit_dom_html_table_cell_element_get_width #} + (toHTMLTableCellElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableColElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableColElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableColElement.chs @@ -0,0 +1,113 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLTableColElement + (htmlTableColElementSetAlign, htmlTableColElementGetAlign, + htmlTableColElementSetCh, htmlTableColElementGetCh, + htmlTableColElementSetChOff, htmlTableColElementGetChOff, + htmlTableColElementSetSpan, htmlTableColElementGetSpan, + htmlTableColElementSetVAlign, htmlTableColElementGetVAlign, + htmlTableColElementSetWidth, htmlTableColElementGetWidth) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlTableColElementSetAlign :: + (HTMLTableColElementClass self) => self -> String -> IO () +htmlTableColElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_col_element_set_align #} + (toHTMLTableColElement self) + valPtr + +htmlTableColElementGetAlign :: + (HTMLTableColElementClass self) => self -> IO String +htmlTableColElementGetAlign self + = ({# call webkit_dom_html_table_col_element_get_align #} + (toHTMLTableColElement self)) + >>= + readUTFString + +htmlTableColElementSetCh :: + (HTMLTableColElementClass self) => self -> String -> IO () +htmlTableColElementSetCh self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_col_element_set_ch #} + (toHTMLTableColElement self) + valPtr + +htmlTableColElementGetCh :: + (HTMLTableColElementClass self) => self -> IO String +htmlTableColElementGetCh self + = ({# call webkit_dom_html_table_col_element_get_ch #} + (toHTMLTableColElement self)) + >>= + readUTFString + +htmlTableColElementSetChOff :: + (HTMLTableColElementClass self) => self -> String -> IO () +htmlTableColElementSetChOff self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_col_element_set_ch_off #} + (toHTMLTableColElement self) + valPtr + +htmlTableColElementGetChOff :: + (HTMLTableColElementClass self) => self -> IO String +htmlTableColElementGetChOff self + = ({# call webkit_dom_html_table_col_element_get_ch_off #} + (toHTMLTableColElement self)) + >>= + readUTFString + +htmlTableColElementSetSpan :: + (HTMLTableColElementClass self) => self -> Int -> IO () +htmlTableColElementSetSpan self val + = {# call webkit_dom_html_table_col_element_set_span #} + (toHTMLTableColElement self) + (fromIntegral val) + +htmlTableColElementGetSpan :: + (HTMLTableColElementClass self) => self -> IO Int +htmlTableColElementGetSpan self + = fromIntegral <$> + ({# call webkit_dom_html_table_col_element_get_span #} + (toHTMLTableColElement self)) + +htmlTableColElementSetVAlign :: + (HTMLTableColElementClass self) => self -> String -> IO () +htmlTableColElementSetVAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_col_element_set_v_align #} + (toHTMLTableColElement self) + valPtr + +htmlTableColElementGetVAlign :: + (HTMLTableColElementClass self) => self -> IO String +htmlTableColElementGetVAlign self + = ({# call webkit_dom_html_table_col_element_get_v_align #} + (toHTMLTableColElement self)) + >>= + readUTFString + +htmlTableColElementSetWidth :: + (HTMLTableColElementClass self) => self -> String -> IO () +htmlTableColElementSetWidth self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_col_element_set_width #} + (toHTMLTableColElement self) + valPtr + +htmlTableColElementGetWidth :: + (HTMLTableColElementClass self) => self -> IO String +htmlTableColElementGetWidth self + = ({# call webkit_dom_html_table_col_element_get_width #} + (toHTMLTableColElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableElement.chs @@ -0,0 +1,329 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLTableElement + (htmlTableElementCreateTHead, htmlTableElementDeleteTHead, + htmlTableElementCreateTFoot, htmlTableElementDeleteTFoot, +#if WEBKIT_CHECK_VERSION(1,10,0) + htmlTableElementCreateTBody, +#endif + htmlTableElementCreateCaption, + htmlTableElementDeleteCaption, htmlTableElementInsertRow, + htmlTableElementDeleteRow, htmlTableElementSetCaption, + htmlTableElementGetCaption, htmlTableElementSetTHead, + htmlTableElementGetTHead, htmlTableElementSetTFoot, + htmlTableElementGetTFoot, htmlTableElementGetRows, + htmlTableElementGetTBodies, htmlTableElementSetAlign, + htmlTableElementGetAlign, htmlTableElementSetBgColor, + htmlTableElementGetBgColor, htmlTableElementSetBorder, + htmlTableElementGetBorder, htmlTableElementSetCellPadding, + htmlTableElementGetCellPadding, htmlTableElementSetCellSpacing, + htmlTableElementGetCellSpacing, htmlTableElementSetFrame, + htmlTableElementGetFrame, htmlTableElementSetRules, + htmlTableElementGetRules, htmlTableElementSetSummary, + htmlTableElementGetSummary, htmlTableElementSetWidth, + htmlTableElementGetWidth) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlTableElementCreateTHead :: + (HTMLTableElementClass self) => self -> IO (Maybe HTMLElement) +htmlTableElementCreateTHead self + = maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_table_element_create_t_head #} + (toHTMLTableElement self)) + +htmlTableElementDeleteTHead :: + (HTMLTableElementClass self) => self -> IO () +htmlTableElementDeleteTHead self + = {# call webkit_dom_html_table_element_delete_t_head #} + (toHTMLTableElement self) + +htmlTableElementCreateTFoot :: + (HTMLTableElementClass self) => self -> IO (Maybe HTMLElement) +htmlTableElementCreateTFoot self + = maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_table_element_create_t_foot #} + (toHTMLTableElement self)) + +htmlTableElementDeleteTFoot :: + (HTMLTableElementClass self) => self -> IO () +htmlTableElementDeleteTFoot self + = {# call webkit_dom_html_table_element_delete_t_foot #} + (toHTMLTableElement self) + +#if WEBKIT_CHECK_VERSION(1,10,0) +htmlTableElementCreateTBody :: + (HTMLTableElementClass self) => self -> IO (Maybe HTMLElement) +htmlTableElementCreateTBody self + = maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_table_element_create_t_body #} + (toHTMLTableElement self)) +#endif + +htmlTableElementCreateCaption :: + (HTMLTableElementClass self) => self -> IO (Maybe HTMLElement) +htmlTableElementCreateCaption self + = maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_table_element_create_caption #} + (toHTMLTableElement self)) + +htmlTableElementDeleteCaption :: + (HTMLTableElementClass self) => self -> IO () +htmlTableElementDeleteCaption self + = {# call webkit_dom_html_table_element_delete_caption #} + (toHTMLTableElement self) + +htmlTableElementInsertRow :: + (HTMLTableElementClass self) => + self -> Int -> IO (Maybe HTMLElement) +htmlTableElementInsertRow self index + = maybeNull (makeNewGObject mkHTMLElement) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_element_insert_row #} + (toHTMLTableElement self) + (fromIntegral index) + errorPtr_) + +htmlTableElementDeleteRow :: + (HTMLTableElementClass self) => self -> Int -> IO () +htmlTableElementDeleteRow self index + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_element_delete_row #} + (toHTMLTableElement self) + (fromIntegral index) + errorPtr_ + +htmlTableElementSetCaption :: + (HTMLTableCaptionElementClass val, HTMLTableElementClass self) => + self -> Maybe val -> IO () +htmlTableElementSetCaption self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_element_set_caption #} + (toHTMLTableElement self) + (maybe (HTMLTableCaptionElement nullForeignPtr) + toHTMLTableCaptionElement + val) + errorPtr_ + +htmlTableElementGetCaption :: + (HTMLTableElementClass self) => + self -> IO (Maybe HTMLTableCaptionElement) +htmlTableElementGetCaption self + = maybeNull (makeNewGObject mkHTMLTableCaptionElement) + ({# call webkit_dom_html_table_element_get_caption #} + (toHTMLTableElement self)) + +htmlTableElementSetTHead :: + (HTMLTableSectionElementClass val, HTMLTableElementClass self) => + self -> Maybe val -> IO () +htmlTableElementSetTHead self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_element_set_t_head #} + (toHTMLTableElement self) + (maybe (HTMLTableSectionElement nullForeignPtr) + toHTMLTableSectionElement + val) + errorPtr_ + +htmlTableElementGetTHead :: + (HTMLTableElementClass self) => + self -> IO (Maybe HTMLTableSectionElement) +htmlTableElementGetTHead self + = maybeNull (makeNewGObject mkHTMLTableSectionElement) + ({# call webkit_dom_html_table_element_get_t_head #} + (toHTMLTableElement self)) + +htmlTableElementSetTFoot :: + (HTMLTableSectionElementClass val, HTMLTableElementClass self) => + self -> Maybe val -> IO () +htmlTableElementSetTFoot self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_element_set_t_foot #} + (toHTMLTableElement self) + (maybe (HTMLTableSectionElement nullForeignPtr) + toHTMLTableSectionElement + val) + errorPtr_ + +htmlTableElementGetTFoot :: + (HTMLTableElementClass self) => + self -> IO (Maybe HTMLTableSectionElement) +htmlTableElementGetTFoot self + = maybeNull (makeNewGObject mkHTMLTableSectionElement) + ({# call webkit_dom_html_table_element_get_t_foot #} + (toHTMLTableElement self)) + +htmlTableElementGetRows :: + (HTMLTableElementClass self) => self -> IO (Maybe HTMLCollection) +htmlTableElementGetRows self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_table_element_get_rows #} + (toHTMLTableElement self)) + +htmlTableElementGetTBodies :: + (HTMLTableElementClass self) => self -> IO (Maybe HTMLCollection) +htmlTableElementGetTBodies self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_table_element_get_t_bodies #} + (toHTMLTableElement self)) + +htmlTableElementSetAlign :: + (HTMLTableElementClass self) => self -> String -> IO () +htmlTableElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_align #} + (toHTMLTableElement self) + valPtr + +htmlTableElementGetAlign :: + (HTMLTableElementClass self) => self -> IO String +htmlTableElementGetAlign self + = ({# call webkit_dom_html_table_element_get_align #} + (toHTMLTableElement self)) + >>= + readUTFString + +htmlTableElementSetBgColor :: + (HTMLTableElementClass self) => self -> String -> IO () +htmlTableElementSetBgColor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_bg_color #} + (toHTMLTableElement self) + valPtr + +htmlTableElementGetBgColor :: + (HTMLTableElementClass self) => self -> IO String +htmlTableElementGetBgColor self + = ({# call webkit_dom_html_table_element_get_bg_color #} + (toHTMLTableElement self)) + >>= + readUTFString + +htmlTableElementSetBorder :: + (HTMLTableElementClass self) => self -> String -> IO () +htmlTableElementSetBorder self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_border #} + (toHTMLTableElement self) + valPtr + +htmlTableElementGetBorder :: + (HTMLTableElementClass self) => self -> IO String +htmlTableElementGetBorder self + = ({# call webkit_dom_html_table_element_get_border #} + (toHTMLTableElement self)) + >>= + readUTFString + +htmlTableElementSetCellPadding :: + (HTMLTableElementClass self) => self -> String -> IO () +htmlTableElementSetCellPadding self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_cell_padding #} + (toHTMLTableElement self) + valPtr + +htmlTableElementGetCellPadding :: + (HTMLTableElementClass self) => self -> IO String +htmlTableElementGetCellPadding self + = ({# call webkit_dom_html_table_element_get_cell_padding #} + (toHTMLTableElement self)) + >>= + readUTFString + +htmlTableElementSetCellSpacing :: + (HTMLTableElementClass self) => self -> String -> IO () +htmlTableElementSetCellSpacing self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_cell_spacing #} + (toHTMLTableElement self) + valPtr + +htmlTableElementGetCellSpacing :: + (HTMLTableElementClass self) => self -> IO String +htmlTableElementGetCellSpacing self + = ({# call webkit_dom_html_table_element_get_cell_spacing #} + (toHTMLTableElement self)) + >>= + readUTFString + +htmlTableElementSetFrame :: + (HTMLTableElementClass self) => self -> String -> IO () +htmlTableElementSetFrame self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_frame #} + (toHTMLTableElement self) + valPtr + +htmlTableElementGetFrame :: + (HTMLTableElementClass self) => self -> IO String +htmlTableElementGetFrame self + = ({# call webkit_dom_html_table_element_get_frame #} + (toHTMLTableElement self)) + >>= + readUTFString + +htmlTableElementSetRules :: + (HTMLTableElementClass self) => self -> String -> IO () +htmlTableElementSetRules self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_rules #} + (toHTMLTableElement self) + valPtr + +htmlTableElementGetRules :: + (HTMLTableElementClass self) => self -> IO String +htmlTableElementGetRules self + = ({# call webkit_dom_html_table_element_get_rules #} + (toHTMLTableElement self)) + >>= + readUTFString + +htmlTableElementSetSummary :: + (HTMLTableElementClass self) => self -> String -> IO () +htmlTableElementSetSummary self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_summary #} + (toHTMLTableElement self) + valPtr + +htmlTableElementGetSummary :: + (HTMLTableElementClass self) => self -> IO String +htmlTableElementGetSummary self + = ({# call webkit_dom_html_table_element_get_summary #} + (toHTMLTableElement self)) + >>= + readUTFString + +htmlTableElementSetWidth :: + (HTMLTableElementClass self) => self -> String -> IO () +htmlTableElementSetWidth self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_width #} + (toHTMLTableElement self) + valPtr + +htmlTableElementGetWidth :: + (HTMLTableElementClass self) => self -> IO String +htmlTableElementGetWidth self + = ({# call webkit_dom_html_table_element_get_width #} + (toHTMLTableElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableRowElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableRowElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableRowElement.chs @@ -0,0 +1,145 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLTableRowElement + (htmlTableRowElementInsertCell, htmlTableRowElementDeleteCell, + htmlTableRowElementGetRowIndex, + htmlTableRowElementGetSectionRowIndex, htmlTableRowElementGetCells, + htmlTableRowElementSetAlign, htmlTableRowElementGetAlign, + htmlTableRowElementSetBgColor, htmlTableRowElementGetBgColor, + htmlTableRowElementSetCh, htmlTableRowElementGetCh, + htmlTableRowElementSetChOff, htmlTableRowElementGetChOff, + htmlTableRowElementSetVAlign, htmlTableRowElementGetVAlign) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlTableRowElementInsertCell :: + (HTMLTableRowElementClass self) => + self -> Int -> IO (Maybe HTMLElement) +htmlTableRowElementInsertCell self index + = maybeNull (makeNewGObject mkHTMLElement) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_row_element_insert_cell #} + (toHTMLTableRowElement self) + (fromIntegral index) + errorPtr_) + +htmlTableRowElementDeleteCell :: + (HTMLTableRowElementClass self) => self -> Int -> IO () +htmlTableRowElementDeleteCell self index + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_row_element_delete_cell #} + (toHTMLTableRowElement self) + (fromIntegral index) + errorPtr_ + +htmlTableRowElementGetRowIndex :: + (HTMLTableRowElementClass self) => self -> IO Int +htmlTableRowElementGetRowIndex self + = fromIntegral <$> + ({# call webkit_dom_html_table_row_element_get_row_index #} + (toHTMLTableRowElement self)) + +htmlTableRowElementGetSectionRowIndex :: + (HTMLTableRowElementClass self) => self -> IO Int +htmlTableRowElementGetSectionRowIndex self + = fromIntegral <$> + ({# call webkit_dom_html_table_row_element_get_section_row_index #} + (toHTMLTableRowElement self)) + +htmlTableRowElementGetCells :: + (HTMLTableRowElementClass self) => + self -> IO (Maybe HTMLCollection) +htmlTableRowElementGetCells self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_table_row_element_get_cells #} + (toHTMLTableRowElement self)) + +htmlTableRowElementSetAlign :: + (HTMLTableRowElementClass self) => self -> String -> IO () +htmlTableRowElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_row_element_set_align #} + (toHTMLTableRowElement self) + valPtr + +htmlTableRowElementGetAlign :: + (HTMLTableRowElementClass self) => self -> IO String +htmlTableRowElementGetAlign self + = ({# call webkit_dom_html_table_row_element_get_align #} + (toHTMLTableRowElement self)) + >>= + readUTFString + +htmlTableRowElementSetBgColor :: + (HTMLTableRowElementClass self) => self -> String -> IO () +htmlTableRowElementSetBgColor self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_row_element_set_bg_color #} + (toHTMLTableRowElement self) + valPtr + +htmlTableRowElementGetBgColor :: + (HTMLTableRowElementClass self) => self -> IO String +htmlTableRowElementGetBgColor self + = ({# call webkit_dom_html_table_row_element_get_bg_color #} + (toHTMLTableRowElement self)) + >>= + readUTFString + +htmlTableRowElementSetCh :: + (HTMLTableRowElementClass self) => self -> String -> IO () +htmlTableRowElementSetCh self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_row_element_set_ch #} + (toHTMLTableRowElement self) + valPtr + +htmlTableRowElementGetCh :: + (HTMLTableRowElementClass self) => self -> IO String +htmlTableRowElementGetCh self + = ({# call webkit_dom_html_table_row_element_get_ch #} + (toHTMLTableRowElement self)) + >>= + readUTFString + +htmlTableRowElementSetChOff :: + (HTMLTableRowElementClass self) => self -> String -> IO () +htmlTableRowElementSetChOff self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_row_element_set_ch_off #} + (toHTMLTableRowElement self) + valPtr + +htmlTableRowElementGetChOff :: + (HTMLTableRowElementClass self) => self -> IO String +htmlTableRowElementGetChOff self + = ({# call webkit_dom_html_table_row_element_get_ch_off #} + (toHTMLTableRowElement self)) + >>= + readUTFString + +htmlTableRowElementSetVAlign :: + (HTMLTableRowElementClass self) => self -> String -> IO () +htmlTableRowElementSetVAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_row_element_set_v_align #} + (toHTMLTableRowElement self) + valPtr + +htmlTableRowElementGetVAlign :: + (HTMLTableRowElementClass self) => self -> IO String +htmlTableRowElementGetVAlign self + = ({# call webkit_dom_html_table_row_element_get_v_align #} + (toHTMLTableRowElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableSectionElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableSectionElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableSectionElement.chs @@ -0,0 +1,112 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLTableSectionElement + (htmlTableSectionElementInsertRow, + htmlTableSectionElementDeleteRow, htmlTableSectionElementSetAlign, + htmlTableSectionElementGetAlign, htmlTableSectionElementSetCh, + htmlTableSectionElementGetCh, htmlTableSectionElementSetChOff, + htmlTableSectionElementGetChOff, htmlTableSectionElementSetVAlign, + htmlTableSectionElementGetVAlign, htmlTableSectionElementGetRows) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlTableSectionElementInsertRow :: + (HTMLTableSectionElementClass self) => + self -> Int -> IO (Maybe HTMLElement) +htmlTableSectionElementInsertRow self index + = maybeNull (makeNewGObject mkHTMLElement) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_section_element_insert_row #} + (toHTMLTableSectionElement self) + (fromIntegral index) + errorPtr_) + +htmlTableSectionElementDeleteRow :: + (HTMLTableSectionElementClass self) => self -> Int -> IO () +htmlTableSectionElementDeleteRow self index + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_section_element_delete_row #} + (toHTMLTableSectionElement self) + (fromIntegral index) + errorPtr_ + +htmlTableSectionElementSetAlign :: + (HTMLTableSectionElementClass self) => self -> String -> IO () +htmlTableSectionElementSetAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_section_element_set_align #} + (toHTMLTableSectionElement self) + valPtr + +htmlTableSectionElementGetAlign :: + (HTMLTableSectionElementClass self) => self -> IO String +htmlTableSectionElementGetAlign self + = ({# call webkit_dom_html_table_section_element_get_align #} + (toHTMLTableSectionElement self)) + >>= + readUTFString + +htmlTableSectionElementSetCh :: + (HTMLTableSectionElementClass self) => self -> String -> IO () +htmlTableSectionElementSetCh self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_section_element_set_ch #} + (toHTMLTableSectionElement self) + valPtr + +htmlTableSectionElementGetCh :: + (HTMLTableSectionElementClass self) => self -> IO String +htmlTableSectionElementGetCh self + = ({# call webkit_dom_html_table_section_element_get_ch #} + (toHTMLTableSectionElement self)) + >>= + readUTFString + +htmlTableSectionElementSetChOff :: + (HTMLTableSectionElementClass self) => self -> String -> IO () +htmlTableSectionElementSetChOff self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_section_element_set_ch_off #} + (toHTMLTableSectionElement self) + valPtr + +htmlTableSectionElementGetChOff :: + (HTMLTableSectionElementClass self) => self -> IO String +htmlTableSectionElementGetChOff self + = ({# call webkit_dom_html_table_section_element_get_ch_off #} + (toHTMLTableSectionElement self)) + >>= + readUTFString + +htmlTableSectionElementSetVAlign :: + (HTMLTableSectionElementClass self) => self -> String -> IO () +htmlTableSectionElementSetVAlign self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_section_element_set_v_align #} + (toHTMLTableSectionElement self) + valPtr + +htmlTableSectionElementGetVAlign :: + (HTMLTableSectionElementClass self) => self -> IO String +htmlTableSectionElementGetVAlign self + = ({# call webkit_dom_html_table_section_element_get_v_align #} + (toHTMLTableSectionElement self)) + >>= + readUTFString + +htmlTableSectionElementGetRows :: + (HTMLTableSectionElementClass self) => + self -> IO (Maybe HTMLCollection) +htmlTableSectionElementGetRows self + = maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_table_section_element_get_rows #} + (toHTMLTableSectionElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTextAreaElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTextAreaElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTextAreaElement.chs @@ -0,0 +1,363 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLTextAreaElement + (htmlTextAreaElementCheckValidity, + htmlTextAreaElementSetCustomValidity, htmlTextAreaElementSelect, + htmlTextAreaElementSetSelectionRange, + htmlTextAreaElementSetAutofocus, htmlTextAreaElementGetAutofocus, + htmlTextAreaElementSetCols, htmlTextAreaElementGetCols, + htmlTextAreaElementSetDirName, htmlTextAreaElementGetDirName, + htmlTextAreaElementSetDisabled, htmlTextAreaElementGetDisabled, + htmlTextAreaElementGetForm, htmlTextAreaElementSetMaxLength, + htmlTextAreaElementGetMaxLength, htmlTextAreaElementSetName, + htmlTextAreaElementGetName, htmlTextAreaElementSetPlaceholder, + htmlTextAreaElementGetPlaceholder, htmlTextAreaElementSetReadOnly, + htmlTextAreaElementGetReadOnly, htmlTextAreaElementSetRequired, + htmlTextAreaElementGetRequired, htmlTextAreaElementSetRows, + htmlTextAreaElementGetRows, htmlTextAreaElementSetWrap, + htmlTextAreaElementGetWrap, htmlTextAreaElementSetDefaultValue, + htmlTextAreaElementGetDefaultValue, htmlTextAreaElementSetValue, + htmlTextAreaElementGetValue, htmlTextAreaElementGetTextLength, + htmlTextAreaElementGetWillValidate, htmlTextAreaElementGetValidity, + htmlTextAreaElementGetValidationMessage, + htmlTextAreaElementGetLabels, htmlTextAreaElementSetSelectionStart, + htmlTextAreaElementGetSelectionStart, + htmlTextAreaElementSetSelectionEnd, + htmlTextAreaElementGetSelectionEnd, + htmlTextAreaElementSetSelectionDirection, + htmlTextAreaElementGetSelectionDirection) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlTextAreaElementCheckValidity :: + (HTMLTextAreaElementClass self) => self -> IO Bool +htmlTextAreaElementCheckValidity self + = toBool <$> + ({# call webkit_dom_html_text_area_element_check_validity #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementSetCustomValidity :: + (HTMLTextAreaElementClass self) => self -> String -> IO () +htmlTextAreaElementSetCustomValidity self error + = withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_text_area_element_set_custom_validity #} + (toHTMLTextAreaElement self) + errorPtr + +htmlTextAreaElementSelect :: + (HTMLTextAreaElementClass self) => self -> IO () +htmlTextAreaElementSelect self + = {# call webkit_dom_html_text_area_element_select #} + (toHTMLTextAreaElement self) + +htmlTextAreaElementSetSelectionRange :: + (HTMLTextAreaElementClass self) => + self -> Int -> Int -> String -> IO () +htmlTextAreaElementSetSelectionRange self start end direction + = withUTFString direction $ + \ directionPtr -> + {# call webkit_dom_html_text_area_element_set_selection_range #} + (toHTMLTextAreaElement self) + (fromIntegral start) + (fromIntegral end) + directionPtr + +htmlTextAreaElementSetAutofocus :: + (HTMLTextAreaElementClass self) => self -> Bool -> IO () +htmlTextAreaElementSetAutofocus self val + = {# call webkit_dom_html_text_area_element_set_autofocus #} + (toHTMLTextAreaElement self) + (fromBool val) + +htmlTextAreaElementGetAutofocus :: + (HTMLTextAreaElementClass self) => self -> IO Bool +htmlTextAreaElementGetAutofocus self + = toBool <$> + ({# call webkit_dom_html_text_area_element_get_autofocus #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementSetCols :: + (HTMLTextAreaElementClass self) => self -> Int -> IO () +htmlTextAreaElementSetCols self val + = {# call webkit_dom_html_text_area_element_set_cols #} + (toHTMLTextAreaElement self) + (fromIntegral val) + +htmlTextAreaElementGetCols :: + (HTMLTextAreaElementClass self) => self -> IO Int +htmlTextAreaElementGetCols self + = fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_cols #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementSetDirName :: + (HTMLTextAreaElementClass self) => self -> String -> IO () +htmlTextAreaElementSetDirName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_dir_name #} + (toHTMLTextAreaElement self) + valPtr + +htmlTextAreaElementGetDirName :: + (HTMLTextAreaElementClass self) => self -> IO String +htmlTextAreaElementGetDirName self + = ({# call webkit_dom_html_text_area_element_get_dir_name #} + (toHTMLTextAreaElement self)) + >>= + readUTFString + +htmlTextAreaElementSetDisabled :: + (HTMLTextAreaElementClass self) => self -> Bool -> IO () +htmlTextAreaElementSetDisabled self val + = {# call webkit_dom_html_text_area_element_set_disabled #} + (toHTMLTextAreaElement self) + (fromBool val) + +htmlTextAreaElementGetDisabled :: + (HTMLTextAreaElementClass self) => self -> IO Bool +htmlTextAreaElementGetDisabled self + = toBool <$> + ({# call webkit_dom_html_text_area_element_get_disabled #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementGetForm :: + (HTMLTextAreaElementClass self) => + self -> IO (Maybe HTMLFormElement) +htmlTextAreaElementGetForm self + = maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_text_area_element_get_form #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementSetMaxLength :: + (HTMLTextAreaElementClass self) => self -> Int -> IO () +htmlTextAreaElementSetMaxLength self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_text_area_element_set_max_length #} + (toHTMLTextAreaElement self) + (fromIntegral val) + errorPtr_ + +htmlTextAreaElementGetMaxLength :: + (HTMLTextAreaElementClass self) => self -> IO Int +htmlTextAreaElementGetMaxLength self + = fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_max_length #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementSetName :: + (HTMLTextAreaElementClass self) => self -> String -> IO () +htmlTextAreaElementSetName self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_name #} + (toHTMLTextAreaElement self) + valPtr + +htmlTextAreaElementGetName :: + (HTMLTextAreaElementClass self) => self -> IO String +htmlTextAreaElementGetName self + = ({# call webkit_dom_html_text_area_element_get_name #} + (toHTMLTextAreaElement self)) + >>= + readUTFString + +htmlTextAreaElementSetPlaceholder :: + (HTMLTextAreaElementClass self) => self -> String -> IO () +htmlTextAreaElementSetPlaceholder self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_placeholder #} + (toHTMLTextAreaElement self) + valPtr + +htmlTextAreaElementGetPlaceholder :: + (HTMLTextAreaElementClass self) => self -> IO String +htmlTextAreaElementGetPlaceholder self + = ({# call webkit_dom_html_text_area_element_get_placeholder #} + (toHTMLTextAreaElement self)) + >>= + readUTFString + +htmlTextAreaElementSetReadOnly :: + (HTMLTextAreaElementClass self) => self -> Bool -> IO () +htmlTextAreaElementSetReadOnly self val + = {# call webkit_dom_html_text_area_element_set_read_only #} + (toHTMLTextAreaElement self) + (fromBool val) + +htmlTextAreaElementGetReadOnly :: + (HTMLTextAreaElementClass self) => self -> IO Bool +htmlTextAreaElementGetReadOnly self + = toBool <$> + ({# call webkit_dom_html_text_area_element_get_read_only #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementSetRequired :: + (HTMLTextAreaElementClass self) => self -> Bool -> IO () +htmlTextAreaElementSetRequired self val + = {# call webkit_dom_html_text_area_element_set_required #} + (toHTMLTextAreaElement self) + (fromBool val) + +htmlTextAreaElementGetRequired :: + (HTMLTextAreaElementClass self) => self -> IO Bool +htmlTextAreaElementGetRequired self + = toBool <$> + ({# call webkit_dom_html_text_area_element_get_required #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementSetRows :: + (HTMLTextAreaElementClass self) => self -> Int -> IO () +htmlTextAreaElementSetRows self val + = {# call webkit_dom_html_text_area_element_set_rows #} + (toHTMLTextAreaElement self) + (fromIntegral val) + +htmlTextAreaElementGetRows :: + (HTMLTextAreaElementClass self) => self -> IO Int +htmlTextAreaElementGetRows self + = fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_rows #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementSetWrap :: + (HTMLTextAreaElementClass self) => self -> String -> IO () +htmlTextAreaElementSetWrap self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_wrap #} + (toHTMLTextAreaElement self) + valPtr + +htmlTextAreaElementGetWrap :: + (HTMLTextAreaElementClass self) => self -> IO String +htmlTextAreaElementGetWrap self + = ({# call webkit_dom_html_text_area_element_get_wrap #} + (toHTMLTextAreaElement self)) + >>= + readUTFString + +htmlTextAreaElementSetDefaultValue :: + (HTMLTextAreaElementClass self) => self -> String -> IO () +htmlTextAreaElementSetDefaultValue self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_default_value #} + (toHTMLTextAreaElement self) + valPtr + +htmlTextAreaElementGetDefaultValue :: + (HTMLTextAreaElementClass self) => self -> IO String +htmlTextAreaElementGetDefaultValue self + = ({# call webkit_dom_html_text_area_element_get_default_value #} + (toHTMLTextAreaElement self)) + >>= + readUTFString + +htmlTextAreaElementSetValue :: + (HTMLTextAreaElementClass self) => self -> String -> IO () +htmlTextAreaElementSetValue self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_value #} + (toHTMLTextAreaElement self) + valPtr + +htmlTextAreaElementGetValue :: + (HTMLTextAreaElementClass self) => self -> IO String +htmlTextAreaElementGetValue self + = ({# call webkit_dom_html_text_area_element_get_value #} + (toHTMLTextAreaElement self)) + >>= + readUTFString + +htmlTextAreaElementGetTextLength :: + (HTMLTextAreaElementClass self) => self -> IO Word +htmlTextAreaElementGetTextLength self + = fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_text_length #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementGetWillValidate :: + (HTMLTextAreaElementClass self) => self -> IO Bool +htmlTextAreaElementGetWillValidate self + = toBool <$> + ({# call webkit_dom_html_text_area_element_get_will_validate #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementGetValidity :: + (HTMLTextAreaElementClass self) => self -> IO (Maybe ValidityState) +htmlTextAreaElementGetValidity self + = maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_text_area_element_get_validity #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementGetValidationMessage :: + (HTMLTextAreaElementClass self) => self -> IO String +htmlTextAreaElementGetValidationMessage self + = ({# call webkit_dom_html_text_area_element_get_validation_message + #} + (toHTMLTextAreaElement self)) + >>= + readUTFString + +htmlTextAreaElementGetLabels :: + (HTMLTextAreaElementClass self) => self -> IO (Maybe NodeList) +htmlTextAreaElementGetLabels self + = maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_text_area_element_get_labels #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementSetSelectionStart :: + (HTMLTextAreaElementClass self) => self -> Int -> IO () +htmlTextAreaElementSetSelectionStart self val + = {# call webkit_dom_html_text_area_element_set_selection_start #} + (toHTMLTextAreaElement self) + (fromIntegral val) + +htmlTextAreaElementGetSelectionStart :: + (HTMLTextAreaElementClass self) => self -> IO Int +htmlTextAreaElementGetSelectionStart self + = fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_selection_start #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementSetSelectionEnd :: + (HTMLTextAreaElementClass self) => self -> Int -> IO () +htmlTextAreaElementSetSelectionEnd self val + = {# call webkit_dom_html_text_area_element_set_selection_end #} + (toHTMLTextAreaElement self) + (fromIntegral val) + +htmlTextAreaElementGetSelectionEnd :: + (HTMLTextAreaElementClass self) => self -> IO Int +htmlTextAreaElementGetSelectionEnd self + = fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_selection_end #} + (toHTMLTextAreaElement self)) + +htmlTextAreaElementSetSelectionDirection :: + (HTMLTextAreaElementClass self) => self -> String -> IO () +htmlTextAreaElementSetSelectionDirection self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_selection_direction + #} + (toHTMLTextAreaElement self) + valPtr + +htmlTextAreaElementGetSelectionDirection :: + (HTMLTextAreaElementClass self) => self -> IO String +htmlTextAreaElementGetSelectionDirection self + = ({# call + webkit_dom_html_text_area_element_get_selection_direction + #} + (toHTMLTextAreaElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTitleElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTitleElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTitleElement.chs @@ -0,0 +1,25 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLTitleElement + (htmlTitleElementSetText, htmlTitleElementGetText) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlTitleElementSetText :: + (HTMLTitleElementClass self) => self -> String -> IO () +htmlTitleElementSetText self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_title_element_set_text #} + (toHTMLTitleElement self) + valPtr + +htmlTitleElementGetText :: + (HTMLTitleElementClass self) => self -> IO String +htmlTitleElementGetText self + = ({# call webkit_dom_html_title_element_get_text #} + (toHTMLTitleElement self)) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLUListElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLUListElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLUListElement.chs @@ -0,0 +1,22 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLUListElement + (htmluListElementSetCompact, htmluListElementGetCompact) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmluListElementSetCompact :: + (HTMLUListElementClass self) => self -> Bool -> IO () +htmluListElementSetCompact self val + = {# call webkit_dom_htmlu_list_element_set_compact #} + (toHTMLUListElement self) + (fromBool val) + +htmluListElementGetCompact :: + (HTMLUListElementClass self) => self -> IO Bool +htmluListElementGetCompact self + = toBool <$> + ({# call webkit_dom_htmlu_list_element_get_compact #} + (toHTMLUListElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLVideoElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLVideoElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLVideoElement.chs @@ -0,0 +1,145 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLVideoElement + (htmlVideoElementWebkitEnterFullscreen, + htmlVideoElementWebkitExitFullscreen, + htmlVideoElementWebkitEnterFullScreen, + htmlVideoElementWebkitExitFullScreen, htmlVideoElementSetWidth, + htmlVideoElementGetWidth, htmlVideoElementSetHeight, + htmlVideoElementGetHeight, htmlVideoElementGetVideoWidth, + htmlVideoElementGetVideoHeight, htmlVideoElementSetPoster, + htmlVideoElementGetPoster, + htmlVideoElementGetWebkitSupportsFullscreen, + htmlVideoElementGetWebkitDisplayingFullscreen, + htmlVideoElementGetWebkitDecodedFrameCount, + htmlVideoElementGetWebkitDroppedFrameCount) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +htmlVideoElementWebkitEnterFullscreen :: + (HTMLVideoElementClass self) => self -> IO () +htmlVideoElementWebkitEnterFullscreen self + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_video_element_webkit_enter_fullscreen #} + (toHTMLVideoElement self) + errorPtr_ + +htmlVideoElementWebkitExitFullscreen :: + (HTMLVideoElementClass self) => self -> IO () +htmlVideoElementWebkitExitFullscreen self + = {# call webkit_dom_html_video_element_webkit_exit_fullscreen #} + (toHTMLVideoElement self) + +htmlVideoElementWebkitEnterFullScreen :: + (HTMLVideoElementClass self) => self -> IO () +htmlVideoElementWebkitEnterFullScreen self + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_video_element_webkit_enter_full_screen #} + (toHTMLVideoElement self) + errorPtr_ + +htmlVideoElementWebkitExitFullScreen :: + (HTMLVideoElementClass self) => self -> IO () +htmlVideoElementWebkitExitFullScreen self + = {# call webkit_dom_html_video_element_webkit_exit_full_screen #} + (toHTMLVideoElement self) + +htmlVideoElementSetWidth :: + (HTMLVideoElementClass self) => self -> Word -> IO () +htmlVideoElementSetWidth self val + = {# call webkit_dom_html_video_element_set_width #} + (toHTMLVideoElement self) + (fromIntegral val) + +htmlVideoElementGetWidth :: + (HTMLVideoElementClass self) => self -> IO Word +htmlVideoElementGetWidth self + = fromIntegral <$> + ({# call webkit_dom_html_video_element_get_width #} + (toHTMLVideoElement self)) + +htmlVideoElementSetHeight :: + (HTMLVideoElementClass self) => self -> Word -> IO () +htmlVideoElementSetHeight self val + = {# call webkit_dom_html_video_element_set_height #} + (toHTMLVideoElement self) + (fromIntegral val) + +htmlVideoElementGetHeight :: + (HTMLVideoElementClass self) => self -> IO Word +htmlVideoElementGetHeight self + = fromIntegral <$> + ({# call webkit_dom_html_video_element_get_height #} + (toHTMLVideoElement self)) + +htmlVideoElementGetVideoWidth :: + (HTMLVideoElementClass self) => self -> IO Word +htmlVideoElementGetVideoWidth self + = fromIntegral <$> + ({# call webkit_dom_html_video_element_get_video_width #} + (toHTMLVideoElement self)) + +htmlVideoElementGetVideoHeight :: + (HTMLVideoElementClass self) => self -> IO Word +htmlVideoElementGetVideoHeight self + = fromIntegral <$> + ({# call webkit_dom_html_video_element_get_video_height #} + (toHTMLVideoElement self)) + +htmlVideoElementSetPoster :: + (HTMLVideoElementClass self) => self -> String -> IO () +htmlVideoElementSetPoster self val + = withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_video_element_set_poster #} + (toHTMLVideoElement self) + valPtr + +htmlVideoElementGetPoster :: + (HTMLVideoElementClass self) => self -> IO String +htmlVideoElementGetPoster self + = ({# call webkit_dom_html_video_element_get_poster #} + (toHTMLVideoElement self)) + >>= + readUTFString + +htmlVideoElementGetWebkitSupportsFullscreen :: + (HTMLVideoElementClass self) => self -> IO Bool +htmlVideoElementGetWebkitSupportsFullscreen self + = toBool <$> + ({# call + webkit_dom_html_video_element_get_webkit_supports_fullscreen + #} + (toHTMLVideoElement self)) + +htmlVideoElementGetWebkitDisplayingFullscreen :: + (HTMLVideoElementClass self) => self -> IO Bool +htmlVideoElementGetWebkitDisplayingFullscreen self + = toBool <$> + ({# call + webkit_dom_html_video_element_get_webkit_displaying_fullscreen + #} + (toHTMLVideoElement self)) + +htmlVideoElementGetWebkitDecodedFrameCount :: + (HTMLVideoElementClass self) => self -> IO Word +htmlVideoElementGetWebkitDecodedFrameCount self + = fromIntegral <$> + ({# call + webkit_dom_html_video_element_get_webkit_decoded_frame_count + #} + (toHTMLVideoElement self)) + +htmlVideoElementGetWebkitDroppedFrameCount :: + (HTMLVideoElementClass self) => self -> IO Word +htmlVideoElementGetWebkitDroppedFrameCount self + = fromIntegral <$> + ({# call + webkit_dom_html_video_element_get_webkit_dropped_frame_count + #} + (toHTMLVideoElement self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/History.chs b/Graphics/UI/Gtk/WebKit/DOM/History.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/History.chs @@ -0,0 +1,12 @@ +module Graphics.UI.Gtk.WebKit.DOM.History (historyGetLength) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +historyGetLength :: (HistoryClass self) => self -> IO Word +historyGetLength self + = fromIntegral <$> + ({# call webkit_dom_history_get_length #} (toHistory self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Location.chs b/Graphics/UI/Gtk/WebKit/DOM/Location.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Location.chs @@ -0,0 +1,26 @@ +module Graphics.UI.Gtk.WebKit.DOM.Location + (locationGetOrigin +#if WEBKIT_CHECK_VERSION(1,10,0) + , locationGetAncestorOrigins +#endif + ) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +locationGetOrigin :: (LocationClass self) => self -> IO String +locationGetOrigin self + = ({# call webkit_dom_location_get_origin #} (toLocation self)) >>= + readUTFString + +#if WEBKIT_CHECK_VERSION(1,10,0) +locationGetAncestorOrigins :: + (LocationClass self) => self -> IO (Maybe DOMStringList) +locationGetAncestorOrigins self + = maybeNull (makeNewGObject mkDOMStringList) + ({# call webkit_dom_location_get_ancestor_origins #} + (toLocation self)) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/MediaError.chs b/Graphics/UI/Gtk/WebKit/DOM/MediaError.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/MediaError.chs @@ -0,0 +1,19 @@ +module Graphics.UI.Gtk.WebKit.DOM.MediaError + (cMEDIA_ERR_ABORTED, cMEDIA_ERR_NETWORK, cMEDIA_ERR_DECODE, + cMEDIA_ERR_SRC_NOT_SUPPORTED, mediaErrorGetCode) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM +cMEDIA_ERR_ABORTED = 1 +cMEDIA_ERR_NETWORK = 2 +cMEDIA_ERR_DECODE = 3 +cMEDIA_ERR_SRC_NOT_SUPPORTED = 4 + +mediaErrorGetCode :: (MediaErrorClass self) => self -> IO Word +mediaErrorGetCode self + = fromIntegral <$> + ({# call webkit_dom_media_error_get_code #} (toMediaError self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MediaList.chs b/Graphics/UI/Gtk/WebKit/DOM/MediaList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/MediaList.chs @@ -0,0 +1,62 @@ +module Graphics.UI.Gtk.WebKit.DOM.MediaList + (mediaListItem, mediaListDeleteMedium, mediaListAppendMedium, + mediaListSetMediaText, mediaListGetMediaText, mediaListGetLength) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +mediaListItem :: (MediaListClass self) => self -> Word -> IO String +mediaListItem self index + = ({# call webkit_dom_media_list_item #} (toMediaList self) + (fromIntegral index)) + >>= + readUTFString + +mediaListDeleteMedium :: + (MediaListClass self) => self -> String -> IO () +mediaListDeleteMedium self oldMedium + = propagateGError $ + \ errorPtr_ -> + withUTFString oldMedium $ + \ oldMediumPtr -> + {# call webkit_dom_media_list_delete_medium #} (toMediaList self) + oldMediumPtr + errorPtr_ + +mediaListAppendMedium :: + (MediaListClass self) => self -> String -> IO () +mediaListAppendMedium self newMedium + = propagateGError $ + \ errorPtr_ -> + withUTFString newMedium $ + \ newMediumPtr -> + {# call webkit_dom_media_list_append_medium #} (toMediaList self) + newMediumPtr + errorPtr_ + +mediaListSetMediaText :: + (MediaListClass self) => self -> String -> IO () +mediaListSetMediaText self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_media_list_set_media_text #} (toMediaList self) + valPtr + errorPtr_ + +mediaListGetMediaText :: (MediaListClass self) => self -> IO String +mediaListGetMediaText self + = ({# call webkit_dom_media_list_get_media_text #} + (toMediaList self)) + >>= + readUTFString + +mediaListGetLength :: (MediaListClass self) => self -> IO Word +mediaListGetLength self + = fromIntegral <$> + ({# call webkit_dom_media_list_get_length #} (toMediaList self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MediaQueryList.chs b/Graphics/UI/Gtk/WebKit/DOM/MediaQueryList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/MediaQueryList.chs @@ -0,0 +1,23 @@ +module Graphics.UI.Gtk.WebKit.DOM.MediaQueryList + (mediaQueryListGetMedia, mediaQueryListGetMatches) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +mediaQueryListGetMedia :: + (MediaQueryListClass self) => self -> IO String +mediaQueryListGetMedia self + = ({# call webkit_dom_media_query_list_get_media #} + (toMediaQueryList self)) + >>= + readUTFString + +mediaQueryListGetMatches :: + (MediaQueryListClass self) => self -> IO Bool +mediaQueryListGetMatches self + = toBool <$> + ({# call webkit_dom_media_query_list_get_matches #} + (toMediaQueryList self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MemoryInfo.chs b/Graphics/UI/Gtk/WebKit/DOM/MemoryInfo.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/MemoryInfo.chs @@ -0,0 +1,31 @@ +module Graphics.UI.Gtk.WebKit.DOM.MemoryInfo + (memoryInfoGetTotalJSHeapSize, memoryInfoGetUsedJSHeapSize, + memoryInfoGetJsHeapSizeLimit) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +memoryInfoGetTotalJSHeapSize :: + (MemoryInfoClass self) => self -> IO Word +memoryInfoGetTotalJSHeapSize self + = fromIntegral <$> + ({# call webkit_dom_memory_info_get_total_js_heap_size #} + (toMemoryInfo self)) + +memoryInfoGetUsedJSHeapSize :: + (MemoryInfoClass self) => self -> IO Word +memoryInfoGetUsedJSHeapSize self + = fromIntegral <$> + ({# call webkit_dom_memory_info_get_used_js_heap_size #} + (toMemoryInfo self)) + +memoryInfoGetJsHeapSizeLimit :: + (MemoryInfoClass self) => self -> IO Word +memoryInfoGetJsHeapSizeLimit self + = fromIntegral <$> + ({# call webkit_dom_memory_info_get_js_heap_size_limit #} + (toMemoryInfo self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MouseEvent.chs b/Graphics/UI/Gtk/WebKit/DOM/MouseEvent.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/MouseEvent.chs @@ -0,0 +1,164 @@ +module Graphics.UI.Gtk.WebKit.DOM.MouseEvent + (mouseEventInitMouseEvent, mouseEventGetScreenX, + mouseEventGetScreenY, mouseEventGetClientX, mouseEventGetClientY, + mouseEventGetWebkitMovementX, mouseEventGetWebkitMovementY, + mouseEventGetCtrlKey, mouseEventGetShiftKey, mouseEventGetAltKey, + mouseEventGetMetaKey, mouseEventGetButton, + mouseEventGetRelatedTarget, mouseEventGetOffsetX, + mouseEventGetOffsetY, mouseEventGetX, mouseEventGetY, + mouseEventGetFromElement, mouseEventGetToElement) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError + +mouseEventInitMouseEvent :: + (MouseEventClass self, DOMWindowClass view, + EventTargetClass relatedTarget) => + self -> + String -> + Bool -> + Bool -> + Maybe view -> + Int -> + Int -> + Int -> + Int -> + Int -> + Bool -> + Bool -> + Bool -> + Bool -> Word -> Maybe relatedTarget -> IO () +mouseEventInitMouseEvent self type' canBubble cancelable view + detail screenX screenY clientX clientY ctrlKey altKey shiftKey + metaKey button relatedTarget + = withUTFString type' $ + \ typePtr -> + {# call webkit_dom_mouse_event_init_mouse_event #} + (toMouseEvent self) + typePtr + (fromBool canBubble) + (fromBool cancelable) + (maybe (DOMWindow nullForeignPtr) toDOMWindow view) + (fromIntegral detail) + (fromIntegral screenX) + (fromIntegral screenY) + (fromIntegral clientX) + (fromIntegral clientY) + (fromBool ctrlKey) + (fromBool altKey) + (fromBool shiftKey) + (fromBool metaKey) + (fromIntegral button) + (maybe (EventTarget nullForeignPtr) toEventTarget relatedTarget) + +mouseEventGetScreenX :: (MouseEventClass self) => self -> IO Int +mouseEventGetScreenX self + = fromIntegral <$> + ({# call webkit_dom_mouse_event_get_screen_x #} + (toMouseEvent self)) + +mouseEventGetScreenY :: (MouseEventClass self) => self -> IO Int +mouseEventGetScreenY self + = fromIntegral <$> + ({# call webkit_dom_mouse_event_get_screen_y #} + (toMouseEvent self)) + +mouseEventGetClientX :: (MouseEventClass self) => self -> IO Int +mouseEventGetClientX self + = fromIntegral <$> + ({# call webkit_dom_mouse_event_get_client_x #} + (toMouseEvent self)) + +mouseEventGetClientY :: (MouseEventClass self) => self -> IO Int +mouseEventGetClientY self + = fromIntegral <$> + ({# call webkit_dom_mouse_event_get_client_y #} + (toMouseEvent self)) + +mouseEventGetWebkitMovementX :: + (MouseEventClass self) => self -> IO Int +mouseEventGetWebkitMovementX self + = fromIntegral <$> + ({# call webkit_dom_mouse_event_get_webkit_movement_x #} + (toMouseEvent self)) + +mouseEventGetWebkitMovementY :: + (MouseEventClass self) => self -> IO Int +mouseEventGetWebkitMovementY self + = fromIntegral <$> + ({# call webkit_dom_mouse_event_get_webkit_movement_y #} + (toMouseEvent self)) + +mouseEventGetCtrlKey :: (MouseEventClass self) => self -> IO Bool +mouseEventGetCtrlKey self + = toBool <$> + ({# call webkit_dom_mouse_event_get_ctrl_key #} + (toMouseEvent self)) + +mouseEventGetShiftKey :: (MouseEventClass self) => self -> IO Bool +mouseEventGetShiftKey self + = toBool <$> + ({# call webkit_dom_mouse_event_get_shift_key #} + (toMouseEvent self)) + +mouseEventGetAltKey :: (MouseEventClass self) => self -> IO Bool +mouseEventGetAltKey self + = toBool <$> + ({# call webkit_dom_mouse_event_get_alt_key #} (toMouseEvent self)) + +mouseEventGetMetaKey :: (MouseEventClass self) => self -> IO Bool +mouseEventGetMetaKey self + = toBool <$> + ({# call webkit_dom_mouse_event_get_meta_key #} + (toMouseEvent self)) + +mouseEventGetButton :: (MouseEventClass self) => self -> IO Word +mouseEventGetButton self + = fromIntegral <$> + ({# call webkit_dom_mouse_event_get_button #} (toMouseEvent self)) + +mouseEventGetRelatedTarget :: + (MouseEventClass self) => self -> IO (Maybe EventTarget) +mouseEventGetRelatedTarget self + = maybeNull (makeNewGObject mkEventTarget) + ({# call webkit_dom_mouse_event_get_related_target #} + (toMouseEvent self)) + +mouseEventGetOffsetX :: (MouseEventClass self) => self -> IO Int +mouseEventGetOffsetX self + = fromIntegral <$> + ({# call webkit_dom_mouse_event_get_offset_x #} + (toMouseEvent self)) + +mouseEventGetOffsetY :: (MouseEventClass self) => self -> IO Int +mouseEventGetOffsetY self + = fromIntegral <$> + ({# call webkit_dom_mouse_event_get_offset_y #} + (toMouseEvent self)) + +mouseEventGetX :: (MouseEventClass self) => self -> IO Int +mouseEventGetX self + = fromIntegral <$> + ({# call webkit_dom_mouse_event_get_x #} (toMouseEvent self)) + +mouseEventGetY :: (MouseEventClass self) => self -> IO Int +mouseEventGetY self + = fromIntegral <$> + ({# call webkit_dom_mouse_event_get_y #} (toMouseEvent self)) + +mouseEventGetFromElement :: + (MouseEventClass self) => self -> IO (Maybe Node) +mouseEventGetFromElement self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_mouse_event_get_from_element #} + (toMouseEvent self)) + +mouseEventGetToElement :: + (MouseEventClass self) => self -> IO (Maybe Node) +mouseEventGetToElement self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_mouse_event_get_to_element #} + (toMouseEvent self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/NamedNodeMap.chs b/Graphics/UI/Gtk/WebKit/DOM/NamedNodeMap.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/NamedNodeMap.chs @@ -0,0 +1,104 @@ +module Graphics.UI.Gtk.WebKit.DOM.NamedNodeMap + (namedNodeMapGetNamedItem, namedNodeMapSetNamedItem, + namedNodeMapRemoveNamedItem, namedNodeMapItem, + namedNodeMapGetNamedItemNS, namedNodeMapSetNamedItemNS, + namedNodeMapRemoveNamedItemNS, namedNodeMapGetLength) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +namedNodeMapGetNamedItem :: + (NamedNodeMapClass self) => self -> String -> IO (Maybe Node) +namedNodeMapGetNamedItem self name + = maybeNull (makeNewGObject mkNode) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_named_node_map_get_named_item #} + (toNamedNodeMap self) + namePtr) + +namedNodeMapSetNamedItem :: + (NamedNodeMapClass self, NodeClass node) => + self -> Maybe node -> IO (Maybe Node) +namedNodeMapSetNamedItem self node + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_named_node_map_set_named_item #} + (toNamedNodeMap self) + (maybe (Node nullForeignPtr) toNode node) + errorPtr_) + +namedNodeMapRemoveNamedItem :: + (NamedNodeMapClass self) => self -> String -> IO (Maybe Node) +namedNodeMapRemoveNamedItem self name + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + withUTFString name $ + \ namePtr -> + {# call webkit_dom_named_node_map_remove_named_item #} + (toNamedNodeMap self) + namePtr + errorPtr_) + +namedNodeMapItem :: + (NamedNodeMapClass self) => self -> Word -> IO (Maybe Node) +namedNodeMapItem self index + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_named_node_map_item #} (toNamedNodeMap self) + (fromIntegral index)) + +namedNodeMapGetNamedItemNS :: + (NamedNodeMapClass self) => + self -> String -> String -> IO (Maybe Node) +namedNodeMapGetNamedItemNS self namespaceURI localName + = maybeNull (makeNewGObject mkNode) + (withUTFString localName $ + \ localNamePtr -> + withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_named_node_map_get_named_item_ns #} + (toNamedNodeMap self) + namespaceURIPtr + localNamePtr) + +namedNodeMapSetNamedItemNS :: + (NamedNodeMapClass self, NodeClass node) => + self -> Maybe node -> IO (Maybe Node) +namedNodeMapSetNamedItemNS self node + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_named_node_map_set_named_item_ns #} + (toNamedNodeMap self) + (maybe (Node nullForeignPtr) toNode node) + errorPtr_) + +namedNodeMapRemoveNamedItemNS :: + (NamedNodeMapClass self) => + self -> String -> String -> IO (Maybe Node) +namedNodeMapRemoveNamedItemNS self namespaceURI localName + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + withUTFString localName $ + \ localNamePtr -> + withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_named_node_map_remove_named_item_ns #} + (toNamedNodeMap self) + namespaceURIPtr + localNamePtr + errorPtr_) + +namedNodeMapGetLength :: + (NamedNodeMapClass self) => self -> IO Word +namedNodeMapGetLength self + = fromIntegral <$> + ({# call webkit_dom_named_node_map_get_length #} + (toNamedNodeMap self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Navigator.chs b/Graphics/UI/Gtk/WebKit/DOM/Navigator.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Navigator.chs @@ -0,0 +1,118 @@ +module Graphics.UI.Gtk.WebKit.DOM.Navigator + (navigatorJavaEnabled, navigatorGetStorageUpdates, + navigatorGetAppCodeName, navigatorGetAppName, + navigatorGetAppVersion, navigatorGetLanguage, + navigatorGetUserAgent, navigatorGetPlatform, navigatorGetPlugins, + navigatorGetMimeTypes, navigatorGetProduct, navigatorGetProductSub, + navigatorGetVendor, navigatorGetVendorSub, + navigatorGetCookieEnabled, navigatorGetOnLine) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +navigatorJavaEnabled :: (NavigatorClass self) => self -> IO Bool +navigatorJavaEnabled self + = toBool <$> + ({# call webkit_dom_navigator_java_enabled #} (toNavigator self)) + +navigatorGetStorageUpdates :: + (NavigatorClass self) => self -> IO () +navigatorGetStorageUpdates self + = {# call webkit_dom_navigator_get_storage_updates #} + (toNavigator self) + +navigatorGetAppCodeName :: + (NavigatorClass self) => self -> IO String +navigatorGetAppCodeName self + = ({# call webkit_dom_navigator_get_app_code_name #} + (toNavigator self)) + >>= + readUTFString + +navigatorGetAppName :: (NavigatorClass self) => self -> IO String +navigatorGetAppName self + = ({# call webkit_dom_navigator_get_app_name #} (toNavigator self)) + >>= + readUTFString + +navigatorGetAppVersion :: + (NavigatorClass self) => self -> IO String +navigatorGetAppVersion self + = ({# call webkit_dom_navigator_get_app_version #} + (toNavigator self)) + >>= + readUTFString + +navigatorGetLanguage :: (NavigatorClass self) => self -> IO String +navigatorGetLanguage self + = ({# call webkit_dom_navigator_get_language #} (toNavigator self)) + >>= + readUTFString + +navigatorGetUserAgent :: (NavigatorClass self) => self -> IO String +navigatorGetUserAgent self + = ({# call webkit_dom_navigator_get_user_agent #} + (toNavigator self)) + >>= + readUTFString + +navigatorGetPlatform :: (NavigatorClass self) => self -> IO String +navigatorGetPlatform self + = ({# call webkit_dom_navigator_get_platform #} (toNavigator self)) + >>= + readUTFString + +navigatorGetPlugins :: + (NavigatorClass self) => self -> IO (Maybe DOMPluginArray) +navigatorGetPlugins self + = maybeNull (makeNewGObject mkDOMPluginArray) + ({# call webkit_dom_navigator_get_plugins #} (toNavigator self)) + +navigatorGetMimeTypes :: + (NavigatorClass self) => self -> IO (Maybe DOMMimeTypeArray) +navigatorGetMimeTypes self + = maybeNull (makeNewGObject mkDOMMimeTypeArray) + ({# call webkit_dom_navigator_get_mime_types #} (toNavigator self)) + +navigatorGetProduct :: (NavigatorClass self) => self -> IO String +navigatorGetProduct self + = ({# call webkit_dom_navigator_get_product #} (toNavigator self)) + >>= + readUTFString + +navigatorGetProductSub :: + (NavigatorClass self) => self -> IO String +navigatorGetProductSub self + = ({# call webkit_dom_navigator_get_product_sub #} + (toNavigator self)) + >>= + readUTFString + +navigatorGetVendor :: (NavigatorClass self) => self -> IO String +navigatorGetVendor self + = ({# call webkit_dom_navigator_get_vendor #} (toNavigator self)) + >>= + readUTFString + +navigatorGetVendorSub :: (NavigatorClass self) => self -> IO String +navigatorGetVendorSub self + = ({# call webkit_dom_navigator_get_vendor_sub #} + (toNavigator self)) + >>= + readUTFString + +navigatorGetCookieEnabled :: + (NavigatorClass self) => self -> IO Bool +navigatorGetCookieEnabled self + = toBool <$> + ({# call webkit_dom_navigator_get_cookie_enabled #} + (toNavigator self)) + +navigatorGetOnLine :: (NavigatorClass self) => self -> IO Bool +navigatorGetOnLine self + = toBool <$> + ({# call webkit_dom_navigator_get_on_line #} (toNavigator self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Node.chs b/Graphics/UI/Gtk/WebKit/DOM/Node.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Node.chs @@ -0,0 +1,307 @@ +module Graphics.UI.Gtk.WebKit.DOM.Node + (nodeInsertBefore, nodeReplaceChild, nodeRemoveChild, + nodeAppendChild, nodeHasChildNodes, nodeCloneNode, nodeNormalize, + nodeIsSupported, nodeHasAttributes, nodeIsSameNode, + nodeIsEqualNode, nodeLookupPrefix, nodeIsDefaultNamespace, + nodeLookupNamespaceURI, nodeCompareDocumentPosition, nodeContains, + nodeDispatchEvent, cELEMENT_NODE, cATTRIBUTE_NODE, cTEXT_NODE, + cCDATA_SECTION_NODE, cENTITY_REFERENCE_NODE, cENTITY_NODE, + cPROCESSING_INSTRUCTION_NODE, cCOMMENT_NODE, cDOCUMENT_NODE, + cDOCUMENT_TYPE_NODE, cDOCUMENT_FRAGMENT_NODE, cNOTATION_NODE, + cDOCUMENT_POSITION_DISCONNECTED, cDOCUMENT_POSITION_PRECEDING, + cDOCUMENT_POSITION_FOLLOWING, cDOCUMENT_POSITION_CONTAINS, + cDOCUMENT_POSITION_CONTAINED_BY, + cDOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC, nodeGetNodeName, + nodeSetNodeValue, nodeGetNodeValue, nodeGetNodeType, + nodeGetParentNode, nodeGetChildNodes, nodeGetFirstChild, + nodeGetLastChild, nodeGetPreviousSibling, nodeGetNextSibling, + nodeGetAttributes, nodeGetOwnerDocument, nodeGetNamespaceURI, + nodeSetPrefix, nodeGetPrefix, nodeGetLocalName, nodeGetBaseURI, + nodeSetTextContent, nodeGetTextContent, nodeGetParentElement) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +nodeInsertBefore :: + (NodeClass self, NodeClass newChild, NodeClass refChild) => + self -> Maybe newChild -> Maybe refChild -> IO (Maybe Node) +nodeInsertBefore self newChild refChild + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_node_insert_before #} (toNode self) + (maybe (Node nullForeignPtr) toNode newChild) + (maybe (Node nullForeignPtr) toNode refChild) + errorPtr_) + +nodeReplaceChild :: + (NodeClass self, NodeClass newChild, NodeClass oldChild) => + self -> Maybe newChild -> Maybe oldChild -> IO (Maybe Node) +nodeReplaceChild self newChild oldChild + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_node_replace_child #} (toNode self) + (maybe (Node nullForeignPtr) toNode newChild) + (maybe (Node nullForeignPtr) toNode oldChild) + errorPtr_) + +nodeRemoveChild :: + (NodeClass self, NodeClass oldChild) => + self -> Maybe oldChild -> IO (Maybe Node) +nodeRemoveChild self oldChild + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_node_remove_child #} (toNode self) + (maybe (Node nullForeignPtr) toNode oldChild) + errorPtr_) + +nodeAppendChild :: + (NodeClass self, NodeClass newChild) => + self -> Maybe newChild -> IO (Maybe Node) +nodeAppendChild self newChild + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_node_append_child #} (toNode self) + (maybe (Node nullForeignPtr) toNode newChild) + errorPtr_) + +nodeHasChildNodes :: (NodeClass self) => self -> IO Bool +nodeHasChildNodes self + = toBool <$> + ({# call webkit_dom_node_has_child_nodes #} (toNode self)) + +nodeCloneNode :: + (NodeClass self) => self -> Bool -> IO (Maybe Node) +nodeCloneNode self deep + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_clone_node #} (toNode self) + (fromBool deep)) + +nodeNormalize :: (NodeClass self) => self -> IO () +nodeNormalize self + = {# call webkit_dom_node_normalize #} (toNode self) + +nodeIsSupported :: + (NodeClass self) => self -> String -> String -> IO Bool +nodeIsSupported self feature version + = toBool <$> + (withUTFString version $ + \ versionPtr -> + withUTFString feature $ + \ featurePtr -> + {# call webkit_dom_node_is_supported #} (toNode self) featurePtr + versionPtr) + +nodeHasAttributes :: (NodeClass self) => self -> IO Bool +nodeHasAttributes self + = toBool <$> + ({# call webkit_dom_node_has_attributes #} (toNode self)) + +nodeIsSameNode :: + (NodeClass self, NodeClass other) => self -> Maybe other -> IO Bool +nodeIsSameNode self other + = toBool <$> + ({# call webkit_dom_node_is_same_node #} (toNode self) + (maybe (Node nullForeignPtr) toNode other)) + +nodeIsEqualNode :: + (NodeClass self, NodeClass other) => self -> Maybe other -> IO Bool +nodeIsEqualNode self other + = toBool <$> + ({# call webkit_dom_node_is_equal_node #} (toNode self) + (maybe (Node nullForeignPtr) toNode other)) + +nodeLookupPrefix :: (NodeClass self) => self -> String -> IO String +nodeLookupPrefix self namespaceURI + = (withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_node_lookup_prefix #} (toNode self) + namespaceURIPtr) + >>= + readUTFString + +nodeIsDefaultNamespace :: + (NodeClass self) => self -> String -> IO Bool +nodeIsDefaultNamespace self namespaceURI + = toBool <$> + (withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_node_is_default_namespace #} (toNode self) + namespaceURIPtr) + +nodeLookupNamespaceURI :: + (NodeClass self) => self -> String -> IO String +nodeLookupNamespaceURI self prefix + = (withUTFString prefix $ + \ prefixPtr -> + {# call webkit_dom_node_lookup_namespace_uri #} (toNode self) + prefixPtr) + >>= + readUTFString + +nodeCompareDocumentPosition :: + (NodeClass self, NodeClass other) => self -> Maybe other -> IO Word +nodeCompareDocumentPosition self other + = fromIntegral <$> + ({# call webkit_dom_node_compare_document_position #} (toNode self) + (maybe (Node nullForeignPtr) toNode other)) + +nodeContains :: + (NodeClass self, NodeClass other) => self -> Maybe other -> IO Bool +nodeContains self other + = toBool <$> + ({# call webkit_dom_node_contains #} (toNode self) + (maybe (Node nullForeignPtr) toNode other)) + +nodeDispatchEvent :: + (NodeClass self, EventClass event) => + self -> Maybe event -> IO Bool +nodeDispatchEvent self event + = toBool <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_node_dispatch_event #} (toNode self) + (maybe (Event nullForeignPtr) toEvent event) + errorPtr_) +cELEMENT_NODE = 1 +cATTRIBUTE_NODE = 2 +cTEXT_NODE = 3 +cCDATA_SECTION_NODE = 4 +cENTITY_REFERENCE_NODE = 5 +cENTITY_NODE = 6 +cPROCESSING_INSTRUCTION_NODE = 7 +cCOMMENT_NODE = 8 +cDOCUMENT_NODE = 9 +cDOCUMENT_TYPE_NODE = 10 +cDOCUMENT_FRAGMENT_NODE = 11 +cNOTATION_NODE = 12 +cDOCUMENT_POSITION_DISCONNECTED = 1 +cDOCUMENT_POSITION_PRECEDING = 2 +cDOCUMENT_POSITION_FOLLOWING = 4 +cDOCUMENT_POSITION_CONTAINS = 8 +cDOCUMENT_POSITION_CONTAINED_BY = 16 +cDOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32 + +nodeGetNodeName :: (NodeClass self) => self -> IO String +nodeGetNodeName self + = ({# call webkit_dom_node_get_node_name #} (toNode self)) >>= + readUTFString + +nodeSetNodeValue :: (NodeClass self) => self -> String -> IO () +nodeSetNodeValue self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_node_set_node_value #} (toNode self) valPtr + errorPtr_ + +nodeGetNodeValue :: (NodeClass self) => self -> IO String +nodeGetNodeValue self + = ({# call webkit_dom_node_get_node_value #} (toNode self)) >>= + readUTFString + +nodeGetNodeType :: (NodeClass self) => self -> IO Word +nodeGetNodeType self + = fromIntegral <$> + ({# call webkit_dom_node_get_node_type #} (toNode self)) + +nodeGetParentNode :: (NodeClass self) => self -> IO (Maybe Node) +nodeGetParentNode self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_get_parent_node #} (toNode self)) + +nodeGetChildNodes :: + (NodeClass self) => self -> IO (Maybe NodeList) +nodeGetChildNodes self + = maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_node_get_child_nodes #} (toNode self)) + +nodeGetFirstChild :: (NodeClass self) => self -> IO (Maybe Node) +nodeGetFirstChild self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_get_first_child #} (toNode self)) + +nodeGetLastChild :: (NodeClass self) => self -> IO (Maybe Node) +nodeGetLastChild self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_get_last_child #} (toNode self)) + +nodeGetPreviousSibling :: + (NodeClass self) => self -> IO (Maybe Node) +nodeGetPreviousSibling self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_get_previous_sibling #} (toNode self)) + +nodeGetNextSibling :: (NodeClass self) => self -> IO (Maybe Node) +nodeGetNextSibling self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_get_next_sibling #} (toNode self)) + +nodeGetAttributes :: + (NodeClass self) => self -> IO (Maybe NamedNodeMap) +nodeGetAttributes self + = maybeNull (makeNewGObject mkNamedNodeMap) + ({# call webkit_dom_node_get_attributes #} (toNode self)) + +nodeGetOwnerDocument :: + (NodeClass self) => self -> IO (Maybe Document) +nodeGetOwnerDocument self + = maybeNull (makeNewGObject mkDocument) + ({# call webkit_dom_node_get_owner_document #} (toNode self)) + +nodeGetNamespaceURI :: (NodeClass self) => self -> IO String +nodeGetNamespaceURI self + = ({# call webkit_dom_node_get_namespace_uri #} (toNode self)) >>= + readUTFString + +nodeSetPrefix :: (NodeClass self) => self -> String -> IO () +nodeSetPrefix self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_node_set_prefix #} (toNode self) valPtr + errorPtr_ + +nodeGetPrefix :: (NodeClass self) => self -> IO String +nodeGetPrefix self + = ({# call webkit_dom_node_get_prefix #} (toNode self)) >>= + readUTFString + +nodeGetLocalName :: (NodeClass self) => self -> IO String +nodeGetLocalName self + = ({# call webkit_dom_node_get_local_name #} (toNode self)) >>= + readUTFString + +nodeGetBaseURI :: (NodeClass self) => self -> IO String +nodeGetBaseURI self + = ({# call webkit_dom_node_get_base_uri #} (toNode self)) >>= + readUTFString + +nodeSetTextContent :: (NodeClass self) => self -> String -> IO () +nodeSetTextContent self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_node_set_text_content #} (toNode self) valPtr + errorPtr_ + +nodeGetTextContent :: (NodeClass self) => self -> IO String +nodeGetTextContent self + = ({# call webkit_dom_node_get_text_content #} (toNode self)) >>= + readUTFString + +nodeGetParentElement :: + (NodeClass self) => self -> IO (Maybe Element) +nodeGetParentElement self + = maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_node_get_parent_element #} (toNode self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/NodeFilter.chs b/Graphics/UI/Gtk/WebKit/DOM/NodeFilter.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/NodeFilter.chs @@ -0,0 +1,29 @@ +module Graphics.UI.Gtk.WebKit.DOM.NodeFilter + (cFILTER_ACCEPT, cFILTER_REJECT, cFILTER_SKIP, cSHOW_ALL, + cSHOW_ELEMENT, cSHOW_ATTRIBUTE, cSHOW_TEXT, cSHOW_CDATA_SECTION, + cSHOW_ENTITY_REFERENCE, cSHOW_ENTITY, cSHOW_PROCESSING_INSTRUCTION, + cSHOW_COMMENT, cSHOW_DOCUMENT, cSHOW_DOCUMENT_TYPE, + cSHOW_DOCUMENT_FRAGMENT, cSHOW_NOTATION) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM +cFILTER_ACCEPT = 1 +cFILTER_REJECT = 2 +cFILTER_SKIP = 3 +cSHOW_ALL = 4294967295 +cSHOW_ELEMENT = 1 +cSHOW_ATTRIBUTE = 2 +cSHOW_TEXT = 4 +cSHOW_CDATA_SECTION = 8 +cSHOW_ENTITY_REFERENCE = 16 +cSHOW_ENTITY = 32 +cSHOW_PROCESSING_INSTRUCTION = 64 +cSHOW_COMMENT = 128 +cSHOW_DOCUMENT = 256 +cSHOW_DOCUMENT_TYPE = 512 +cSHOW_DOCUMENT_FRAGMENT = 1024 +cSHOW_NOTATION = 2048 diff --git a/Graphics/UI/Gtk/WebKit/DOM/NodeIterator.chs b/Graphics/UI/Gtk/WebKit/DOM/NodeIterator.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/NodeIterator.chs @@ -0,0 +1,60 @@ +module Graphics.UI.Gtk.WebKit.DOM.NodeIterator + (nodeIteratorDetach, nodeIteratorGetRoot, + nodeIteratorGetWhatToShow, nodeIteratorGetFilter, + nodeIteratorGetExpandEntityReferences, + nodeIteratorGetReferenceNode, + nodeIteratorGetPointerBeforeReferenceNode) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +nodeIteratorDetach :: (NodeIteratorClass self) => self -> IO () +nodeIteratorDetach self + = {# call webkit_dom_node_iterator_detach #} (toNodeIterator self) + +nodeIteratorGetRoot :: + (NodeIteratorClass self) => self -> IO (Maybe Node) +nodeIteratorGetRoot self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_iterator_get_root #} + (toNodeIterator self)) + +nodeIteratorGetWhatToShow :: + (NodeIteratorClass self) => self -> IO Word +nodeIteratorGetWhatToShow self + = fromIntegral <$> + ({# call webkit_dom_node_iterator_get_what_to_show #} + (toNodeIterator self)) + +nodeIteratorGetFilter :: + (NodeIteratorClass self) => self -> IO (Maybe NodeFilter) +nodeIteratorGetFilter self + = maybeNull (makeNewGObject mkNodeFilter) + ({# call webkit_dom_node_iterator_get_filter #} + (toNodeIterator self)) + +nodeIteratorGetExpandEntityReferences :: + (NodeIteratorClass self) => self -> IO Bool +nodeIteratorGetExpandEntityReferences self + = toBool <$> + ({# call webkit_dom_node_iterator_get_expand_entity_references #} + (toNodeIterator self)) + +nodeIteratorGetReferenceNode :: + (NodeIteratorClass self) => self -> IO (Maybe Node) +nodeIteratorGetReferenceNode self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_iterator_get_reference_node #} + (toNodeIterator self)) + +nodeIteratorGetPointerBeforeReferenceNode :: + (NodeIteratorClass self) => self -> IO Bool +nodeIteratorGetPointerBeforeReferenceNode self + = toBool <$> + ({# call webkit_dom_node_iterator_get_pointer_before_reference_node + #} + (toNodeIterator self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/NodeList.chs b/Graphics/UI/Gtk/WebKit/DOM/NodeList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/NodeList.chs @@ -0,0 +1,20 @@ +module Graphics.UI.Gtk.WebKit.DOM.NodeList + (nodeListItem, nodeListGetLength) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +nodeListItem :: + (NodeListClass self) => self -> Word -> IO (Maybe Node) +nodeListItem self index + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_list_item #} (toNodeList self) + (fromIntegral index)) + +nodeListGetLength :: (NodeListClass self) => self -> IO Word +nodeListGetLength self + = fromIntegral <$> + ({# call webkit_dom_node_list_get_length #} (toNodeList self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/ProcessingInstruction.chs b/Graphics/UI/Gtk/WebKit/DOM/ProcessingInstruction.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/ProcessingInstruction.chs @@ -0,0 +1,45 @@ +module Graphics.UI.Gtk.WebKit.DOM.ProcessingInstruction + (processingInstructionGetTarget, processingInstructionSetData, + processingInstructionGetData, processingInstructionGetSheet) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +processingInstructionGetTarget :: + (ProcessingInstructionClass self) => self -> IO String +processingInstructionGetTarget self + = ({# call webkit_dom_processing_instruction_get_target #} + (toProcessingInstruction self)) + >>= + readUTFString + +processingInstructionSetData :: + (ProcessingInstructionClass self) => self -> String -> IO () +processingInstructionSetData self val + = propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_processing_instruction_set_data #} + (toProcessingInstruction self) + valPtr + errorPtr_ + +processingInstructionGetData :: + (ProcessingInstructionClass self) => self -> IO String +processingInstructionGetData self + = ({# call webkit_dom_processing_instruction_get_data #} + (toProcessingInstruction self)) + >>= + readUTFString + +processingInstructionGetSheet :: + (ProcessingInstructionClass self) => self -> IO (Maybe StyleSheet) +processingInstructionGetSheet self + = maybeNull (makeNewGObject mkStyleSheet) + ({# call webkit_dom_processing_instruction_get_sheet #} + (toProcessingInstruction self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Range.chs b/Graphics/UI/Gtk/WebKit/DOM/Range.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Range.chs @@ -0,0 +1,326 @@ +module Graphics.UI.Gtk.WebKit.DOM.Range + (rangeSetStart, rangeSetEnd, rangeSetStartBefore, + rangeSetStartAfter, rangeSetEndBefore, rangeSetEndAfter, + rangeCollapse, rangeSelectNode, rangeSelectNodeContents, + rangeCompareBoundaryPoints, rangeDeleteContents, + rangeExtractContents, rangeCloneContents, rangeInsertNode, + rangeSurroundContents, rangeCloneRange, rangeToString, rangeDetach, + rangeCreateContextualFragment, rangeIntersectsNode, + rangeCompareNode, rangeComparePoint, rangeIsPointInRange, + rangeExpand, cSTART_TO_START, cSTART_TO_END, cEND_TO_END, + cEND_TO_START, cNODE_BEFORE, cNODE_AFTER, cNODE_BEFORE_AND_AFTER, + cNODE_INSIDE, rangeGetStartContainer, rangeGetStartOffset, + rangeGetEndContainer, rangeGetEndOffset, rangeGetCollapsed, + rangeGetCommonAncestorContainer, rangeGetText) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +rangeSetStart :: + (DOMRangeClass self, NodeClass refNode) => + self -> Maybe refNode -> Int -> IO () +rangeSetStart self refNode offset + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_set_start #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode refNode) + (fromIntegral offset) + errorPtr_ + +rangeSetEnd :: + (DOMRangeClass self, NodeClass refNode) => + self -> Maybe refNode -> Int -> IO () +rangeSetEnd self refNode offset + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_set_end #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode refNode) + (fromIntegral offset) + errorPtr_ + +rangeSetStartBefore :: + (DOMRangeClass self, NodeClass refNode) => + self -> Maybe refNode -> IO () +rangeSetStartBefore self refNode + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_set_start_before #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_ + +rangeSetStartAfter :: + (DOMRangeClass self, NodeClass refNode) => + self -> Maybe refNode -> IO () +rangeSetStartAfter self refNode + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_set_start_after #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_ + +rangeSetEndBefore :: + (DOMRangeClass self, NodeClass refNode) => + self -> Maybe refNode -> IO () +rangeSetEndBefore self refNode + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_set_end_before #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_ + +rangeSetEndAfter :: + (DOMRangeClass self, NodeClass refNode) => + self -> Maybe refNode -> IO () +rangeSetEndAfter self refNode + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_set_end_after #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_ + +rangeCollapse :: (DOMRangeClass self) => self -> Bool -> IO () +rangeCollapse self toStart + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_collapse #} (toDOMRange self) + (fromBool toStart) + errorPtr_ + +rangeSelectNode :: + (DOMRangeClass self, NodeClass refNode) => + self -> Maybe refNode -> IO () +rangeSelectNode self refNode + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_select_node #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_ + +rangeSelectNodeContents :: + (DOMRangeClass self, NodeClass refNode) => + self -> Maybe refNode -> IO () +rangeSelectNodeContents self refNode + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_select_node_contents #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_ + +rangeCompareBoundaryPoints :: + (DOMRangeClass self, DOMRangeClass sourceRange) => + self -> Word -> Maybe sourceRange -> IO Int +rangeCompareBoundaryPoints self how sourceRange + = fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_compare_boundary_points #} + (toDOMRange self) + (fromIntegral how) + (maybe (DOMRange nullForeignPtr) toDOMRange sourceRange) + errorPtr_) + +rangeDeleteContents :: (DOMRangeClass self) => self -> IO () +rangeDeleteContents self + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_delete_contents #} (toDOMRange self) + errorPtr_ + +rangeExtractContents :: + (DOMRangeClass self) => self -> IO (Maybe DocumentFragment) +rangeExtractContents self + = maybeNull (makeNewGObject mkDocumentFragment) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_extract_contents #} (toDOMRange self) + errorPtr_) + +rangeCloneContents :: + (DOMRangeClass self) => self -> IO (Maybe DocumentFragment) +rangeCloneContents self + = maybeNull (makeNewGObject mkDocumentFragment) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_clone_contents #} (toDOMRange self) + errorPtr_) + +rangeInsertNode :: + (DOMRangeClass self, NodeClass newNode) => + self -> Maybe newNode -> IO () +rangeInsertNode self newNode + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_insert_node #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode newNode) + errorPtr_ + +rangeSurroundContents :: + (DOMRangeClass self, NodeClass newParent) => + self -> Maybe newParent -> IO () +rangeSurroundContents self newParent + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_surround_contents #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode newParent) + errorPtr_ + +rangeCloneRange :: + (DOMRangeClass self) => self -> IO (Maybe DOMRange) +rangeCloneRange self + = maybeNull (makeNewGObject mkDOMRange) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_clone_range #} (toDOMRange self) + errorPtr_) + +rangeToString :: (DOMRangeClass self) => self -> IO String +rangeToString self + = (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_to_string #} (toDOMRange self) errorPtr_) + >>= + readUTFString + +rangeDetach :: (DOMRangeClass self) => self -> IO () +rangeDetach self + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_detach #} (toDOMRange self) errorPtr_ + +rangeCreateContextualFragment :: + (DOMRangeClass self) => + self -> String -> IO (Maybe DocumentFragment) +rangeCreateContextualFragment self html + = maybeNull (makeNewGObject mkDocumentFragment) + (propagateGError $ + \ errorPtr_ -> + withUTFString html $ + \ htmlPtr -> + {# call webkit_dom_range_create_contextual_fragment #} + (toDOMRange self) + htmlPtr + errorPtr_) + +rangeIntersectsNode :: + (DOMRangeClass self, NodeClass refNode) => + self -> Maybe refNode -> IO Bool +rangeIntersectsNode self refNode + = toBool <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_intersects_node #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_) + +rangeCompareNode :: + (DOMRangeClass self, NodeClass refNode) => + self -> Maybe refNode -> IO Int +rangeCompareNode self refNode + = fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_compare_node #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_) + +rangeComparePoint :: + (DOMRangeClass self, NodeClass refNode) => + self -> Maybe refNode -> Int -> IO Int +rangeComparePoint self refNode offset + = fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_compare_point #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode refNode) + (fromIntegral offset) + errorPtr_) + +rangeIsPointInRange :: + (DOMRangeClass self, NodeClass refNode) => + self -> Maybe refNode -> Int -> IO Bool +rangeIsPointInRange self refNode offset + = toBool <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_is_point_in_range #} (toDOMRange self) + (maybe (Node nullForeignPtr) toNode refNode) + (fromIntegral offset) + errorPtr_) + +rangeExpand :: (DOMRangeClass self) => self -> String -> IO () +rangeExpand self unit + = propagateGError $ + \ errorPtr_ -> + withUTFString unit $ + \ unitPtr -> + {# call webkit_dom_range_expand #} (toDOMRange self) unitPtr + errorPtr_ +cSTART_TO_START = 0 +cSTART_TO_END = 1 +cEND_TO_END = 2 +cEND_TO_START = 3 +cNODE_BEFORE = 0 +cNODE_AFTER = 1 +cNODE_BEFORE_AND_AFTER = 2 +cNODE_INSIDE = 3 + +rangeGetStartContainer :: + (DOMRangeClass self) => self -> IO (Maybe Node) +rangeGetStartContainer self + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_start_container #} (toDOMRange self) + errorPtr_) + +rangeGetStartOffset :: (DOMRangeClass self) => self -> IO Int +rangeGetStartOffset self + = fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_start_offset #} (toDOMRange self) + errorPtr_) + +rangeGetEndContainer :: + (DOMRangeClass self) => self -> IO (Maybe Node) +rangeGetEndContainer self + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_end_container #} (toDOMRange self) + errorPtr_) + +rangeGetEndOffset :: (DOMRangeClass self) => self -> IO Int +rangeGetEndOffset self + = fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_end_offset #} (toDOMRange self) + errorPtr_) + +rangeGetCollapsed :: (DOMRangeClass self) => self -> IO Bool +rangeGetCollapsed self + = toBool <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_collapsed #} (toDOMRange self) + errorPtr_) + +rangeGetCommonAncestorContainer :: + (DOMRangeClass self) => self -> IO (Maybe Node) +rangeGetCommonAncestorContainer self + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_common_ancestor_container #} + (toDOMRange self) + errorPtr_) + +rangeGetText :: (DOMRangeClass self) => self -> IO String +rangeGetText self + = ({# call webkit_dom_range_get_text #} (toDOMRange self)) >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/Ranges.chs b/Graphics/UI/Gtk/WebKit/DOM/Ranges.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Ranges.chs @@ -0,0 +1,8 @@ +module Graphics.UI.Gtk.WebKit.DOM.Ranges (DOMRange, DOMRangeClass) + where + +data DOMRange = DOMRange + +class DOMRangeClass a + +instance DOMRangeClass DOMRange diff --git a/Graphics/UI/Gtk/WebKit/DOM/Screen.chs b/Graphics/UI/Gtk/WebKit/DOM/Screen.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Screen.chs @@ -0,0 +1,51 @@ +module Graphics.UI.Gtk.WebKit.DOM.Screen + (screenGetHeight, screenGetWidth, screenGetColorDepth, + screenGetPixelDepth, screenGetAvailLeft, screenGetAvailTop, + screenGetAvailHeight, screenGetAvailWidth) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +screenGetHeight :: (DOMScreenClass self) => self -> IO Word +screenGetHeight self + = fromIntegral <$> + ({# call webkit_dom_screen_get_height #} (toDOMScreen self)) + +screenGetWidth :: (DOMScreenClass self) => self -> IO Word +screenGetWidth self + = fromIntegral <$> + ({# call webkit_dom_screen_get_width #} (toDOMScreen self)) + +screenGetColorDepth :: (DOMScreenClass self) => self -> IO Word +screenGetColorDepth self + = fromIntegral <$> + ({# call webkit_dom_screen_get_color_depth #} (toDOMScreen self)) + +screenGetPixelDepth :: (DOMScreenClass self) => self -> IO Word +screenGetPixelDepth self + = fromIntegral <$> + ({# call webkit_dom_screen_get_pixel_depth #} (toDOMScreen self)) + +screenGetAvailLeft :: (DOMScreenClass self) => self -> IO Int +screenGetAvailLeft self + = fromIntegral <$> + ({# call webkit_dom_screen_get_avail_left #} (toDOMScreen self)) + +screenGetAvailTop :: (DOMScreenClass self) => self -> IO Int +screenGetAvailTop self + = fromIntegral <$> + ({# call webkit_dom_screen_get_avail_top #} (toDOMScreen self)) + +screenGetAvailHeight :: (DOMScreenClass self) => self -> IO Word +screenGetAvailHeight self + = fromIntegral <$> + ({# call webkit_dom_screen_get_avail_height #} (toDOMScreen self)) + +screenGetAvailWidth :: (DOMScreenClass self) => self -> IO Word +screenGetAvailWidth self + = fromIntegral <$> + ({# call webkit_dom_screen_get_avail_width #} (toDOMScreen self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Storage.chs b/Graphics/UI/Gtk/WebKit/DOM/Storage.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Storage.chs @@ -0,0 +1,73 @@ +module Graphics.UI.Gtk.WebKit.DOM.Storage + (storageKey, storageGetItem, storageSetItem, storageRemoveItem, + storageClear, storageGetLength) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + + +storageKey :: (StorageClass self) => self -> Word -> IO String +#if WEBKIT_CHECK_VERSION(2,0,0) +storageKey self index = propagateGError $ \errorPtr -> + ({# call webkit_dom_storage_key #} (toStorage self) (fromIntegral index) errorPtr >>= readUTFString) +#else +storageKey self index = {# call webkit_dom_storage_key #} (toStorage self) (fromIntegral index) >>= readUTFString +#endif + + +storageGetItem :: (StorageClass self) => self -> String -> IO String +#if WEBKIT_CHECK_VERSION(2,0,0) +storageGetItem self key = propagateGError $ \errorPtr -> ( + (withUTFString key $ \keyPtr -> + {# call webkit_dom_storage_get_item #} (toStorage self) keyPtr errorPtr) + >>= readUTFString) +#else +storageGetItem self key = + (withUTFString key $ \keyPtr -> + {# call webkit_dom_storage_get_item #} (toStorage self) keyPtr) + >>= readUTFString +#endif + + +storageSetItem :: (StorageClass self) => self -> String -> String -> IO () +storageSetItem self key data' + = propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + withUTFString key $ + \ keyPtr -> + {# call webkit_dom_storage_set_item #} (toStorage self) keyPtr + dataPtr + errorPtr_ + + +storageRemoveItem :: (StorageClass self) => self -> String -> IO () +#if WEBKIT_CHECK_VERSION(2,0,0) +storageRemoveItem self key = propagateGError $ \errorPtr -> ( + withUTFString key $ \keyPtr -> + {# call webkit_dom_storage_remove_item #} (toStorage self) keyPtr errorPtr) +#else +storageRemoveItem self key = withUTFString key $ \keyPtr -> + {# call webkit_dom_storage_remove_item #} (toStorage self) keyPtr +#endif + + +storageClear :: (StorageClass self) => self -> IO () +#if WEBKIT_CHECK_VERSION(2,0,0) +storageClear self = propagateGError $ {# call webkit_dom_storage_clear #} (toStorage self) +#else +storageClear = {# call webkit_dom_storage_clear #} . toStorage +#endif + + +storageGetLength :: (StorageClass self) => self -> IO Word +#if WEBKIT_CHECK_VERSION(2,0,0) +storageGetLength self = fromIntegral <$> propagateGError ({# call webkit_dom_storage_get_length #} (toStorage self)) +#else +storageGetLength self = fromIntegral <$> ({# call webkit_dom_storage_get_length #} (toStorage self)) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/StorageInfo.chs b/Graphics/UI/Gtk/WebKit/DOM/StorageInfo.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/StorageInfo.chs @@ -0,0 +1,10 @@ +module Graphics.UI.Gtk.WebKit.DOM.StorageInfo + (cTEMPORARY, cPERSISTENT) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM +cTEMPORARY = 0 +cPERSISTENT = 1 diff --git a/Graphics/UI/Gtk/WebKit/DOM/StyleMedia.chs b/Graphics/UI/Gtk/WebKit/DOM/StyleMedia.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/StyleMedia.chs @@ -0,0 +1,17 @@ +module Graphics.UI.Gtk.WebKit.DOM.StyleMedia + (styleMediaMatchMedium) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +styleMediaMatchMedium :: + (StyleMediaClass self) => self -> String -> IO Bool +styleMediaMatchMedium self mediaquery + = toBool <$> + (withUTFString mediaquery $ + \ mediaqueryPtr -> + {# call webkit_dom_style_media_match_medium #} (toStyleMedia self) + mediaqueryPtr) diff --git a/Graphics/UI/Gtk/WebKit/DOM/StyleSheet.chs b/Graphics/UI/Gtk/WebKit/DOM/StyleSheet.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/StyleSheet.chs @@ -0,0 +1,56 @@ +module Graphics.UI.Gtk.WebKit.DOM.StyleSheet + (styleSheetSetDisabled, styleSheetGetDisabled, + styleSheetGetOwnerNode, styleSheetGetParentStyleSheet, + styleSheetGetHref, styleSheetGetTitle, styleSheetGetMedia) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +styleSheetSetDisabled :: + (StyleSheetClass self) => self -> Bool -> IO () +styleSheetSetDisabled self val + = {# call webkit_dom_style_sheet_set_disabled #} + (toStyleSheet self) + (fromBool val) + +styleSheetGetDisabled :: (StyleSheetClass self) => self -> IO Bool +styleSheetGetDisabled self + = toBool <$> + ({# call webkit_dom_style_sheet_get_disabled #} + (toStyleSheet self)) + +styleSheetGetOwnerNode :: + (StyleSheetClass self) => self -> IO (Maybe Node) +styleSheetGetOwnerNode self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_style_sheet_get_owner_node #} + (toStyleSheet self)) + +styleSheetGetParentStyleSheet :: + (StyleSheetClass self) => self -> IO (Maybe StyleSheet) +styleSheetGetParentStyleSheet self + = maybeNull (makeNewGObject mkStyleSheet) + ({# call webkit_dom_style_sheet_get_parent_style_sheet #} + (toStyleSheet self)) + +styleSheetGetHref :: (StyleSheetClass self) => self -> IO String +styleSheetGetHref self + = ({# call webkit_dom_style_sheet_get_href #} (toStyleSheet self)) + >>= + readUTFString + +styleSheetGetTitle :: (StyleSheetClass self) => self -> IO String +styleSheetGetTitle self + = ({# call webkit_dom_style_sheet_get_title #} (toStyleSheet self)) + >>= + readUTFString + +styleSheetGetMedia :: + (StyleSheetClass self) => self -> IO (Maybe MediaList) +styleSheetGetMedia self + = maybeNull (makeNewGObject mkMediaList) + ({# call webkit_dom_style_sheet_get_media #} (toStyleSheet self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/StyleSheetList.chs b/Graphics/UI/Gtk/WebKit/DOM/StyleSheetList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/StyleSheetList.chs @@ -0,0 +1,23 @@ +module Graphics.UI.Gtk.WebKit.DOM.StyleSheetList + (styleSheetListItem, styleSheetListGetLength) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +styleSheetListItem :: + (StyleSheetListClass self) => self -> Word -> IO (Maybe StyleSheet) +styleSheetListItem self index + = maybeNull (makeNewGObject mkStyleSheet) + ({# call webkit_dom_style_sheet_list_item #} + (toStyleSheetList self) + (fromIntegral index)) + +styleSheetListGetLength :: + (StyleSheetListClass self) => self -> IO Word +styleSheetListGetLength self + = fromIntegral <$> + ({# call webkit_dom_style_sheet_list_get_length #} + (toStyleSheetList self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Stylesheets.chs b/Graphics/UI/Gtk/WebKit/DOM/Stylesheets.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Stylesheets.chs @@ -0,0 +1,8 @@ +module Graphics.UI.Gtk.WebKit.DOM.Stylesheets + (MediaList, MediaListClass) where + +data MediaList = MediaList + +class MediaListClass a + +instance MediaListClass MediaList diff --git a/Graphics/UI/Gtk/WebKit/DOM/Text.chs b/Graphics/UI/Gtk/WebKit/DOM/Text.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Text.chs @@ -0,0 +1,35 @@ +module Graphics.UI.Gtk.WebKit.DOM.Text + (textSplitText, textReplaceWholeText, textGetWholeText) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +textSplitText :: + (TextClass self) => self -> Word -> IO (Maybe Text) +textSplitText self offset + = maybeNull (makeNewGObject mkText) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_text_split_text #} (toText self) + (fromIntegral offset) + errorPtr_) + +textReplaceWholeText :: + (TextClass self) => self -> String -> IO (Maybe Text) +textReplaceWholeText self content + = maybeNull (makeNewGObject mkText) + (propagateGError $ + \ errorPtr_ -> + withUTFString content $ + \ contentPtr -> + {# call webkit_dom_text_replace_whole_text #} (toText self) + contentPtr + errorPtr_) + +textGetWholeText :: (TextClass self) => self -> IO String +textGetWholeText self + = ({# call webkit_dom_text_get_whole_text #} (toText self)) >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/TimeRanges.chs b/Graphics/UI/Gtk/WebKit/DOM/TimeRanges.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/TimeRanges.chs @@ -0,0 +1,32 @@ +module Graphics.UI.Gtk.WebKit.DOM.TimeRanges + (timeRangesStart, timeRangesEnd, timeRangesGetLength) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +timeRangesStart :: + (TimeRangesClass self) => self -> Word -> IO Float +timeRangesStart self index + = realToFrac <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_time_ranges_start #} (toTimeRanges self) + (fromIntegral index) + errorPtr_) + +timeRangesEnd :: (TimeRangesClass self) => self -> Word -> IO Float +timeRangesEnd self index + = realToFrac <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_time_ranges_end #} (toTimeRanges self) + (fromIntegral index) + errorPtr_) + +timeRangesGetLength :: (TimeRangesClass self) => self -> IO Word +timeRangesGetLength self + = fromIntegral <$> + ({# call webkit_dom_time_ranges_get_length #} (toTimeRanges self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Traversal.chs b/Graphics/UI/Gtk/WebKit/DOM/Traversal.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Traversal.chs @@ -0,0 +1,8 @@ +module Graphics.UI.Gtk.WebKit.DOM.Traversal + (NodeFilter, NodeFilterClass) where + +data NodeFilter = NodeFilter + +class NodeFilterClass a + +instance NodeFilterClass NodeFilter diff --git a/Graphics/UI/Gtk/WebKit/DOM/TreeWalker.chs b/Graphics/UI/Gtk/WebKit/DOM/TreeWalker.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/TreeWalker.chs @@ -0,0 +1,54 @@ +module Graphics.UI.Gtk.WebKit.DOM.TreeWalker + (treeWalkerGetRoot, treeWalkerGetWhatToShow, treeWalkerGetFilter, + treeWalkerGetExpandEntityReferences, treeWalkerSetCurrentNode, + treeWalkerGetCurrentNode) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +treeWalkerGetRoot :: + (TreeWalkerClass self) => self -> IO (Maybe Node) +treeWalkerGetRoot self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_tree_walker_get_root #} (toTreeWalker self)) + +treeWalkerGetWhatToShow :: + (TreeWalkerClass self) => self -> IO Word +treeWalkerGetWhatToShow self + = fromIntegral <$> + ({# call webkit_dom_tree_walker_get_what_to_show #} + (toTreeWalker self)) + +treeWalkerGetFilter :: + (TreeWalkerClass self) => self -> IO (Maybe NodeFilter) +treeWalkerGetFilter self + = maybeNull (makeNewGObject mkNodeFilter) + ({# call webkit_dom_tree_walker_get_filter #} (toTreeWalker self)) + +treeWalkerGetExpandEntityReferences :: + (TreeWalkerClass self) => self -> IO Bool +treeWalkerGetExpandEntityReferences self + = toBool <$> + ({# call webkit_dom_tree_walker_get_expand_entity_references #} + (toTreeWalker self)) + +treeWalkerSetCurrentNode :: + (NodeClass val, TreeWalkerClass self) => self -> Maybe val -> IO () +treeWalkerSetCurrentNode self val + = propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_tree_walker_set_current_node #} + (toTreeWalker self) + (maybe (Node nullForeignPtr) toNode val) + errorPtr_ + +treeWalkerGetCurrentNode :: + (TreeWalkerClass self) => self -> IO (Maybe Node) +treeWalkerGetCurrentNode self + = maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_tree_walker_get_current_node #} + (toTreeWalker self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/UIEvent.chs b/Graphics/UI/Gtk/WebKit/DOM/UIEvent.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/UIEvent.chs @@ -0,0 +1,70 @@ +module Graphics.UI.Gtk.WebKit.DOM.UIEvent + (uiEventInitUIEvent, uiEventGetView, uiEventGetDetail, + uiEventGetKeyCode, uiEventGetCharCode, uiEventGetLayerX, + uiEventGetLayerY, uiEventGetPageX, uiEventGetPageY, + uiEventGetWhich) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError + +uiEventInitUIEvent :: + (UIEventClass self, DOMWindowClass view) => + self -> String -> Bool -> Bool -> Maybe view -> Int -> IO () +uiEventInitUIEvent self type' canBubble cancelable view detail + = withUTFString type' $ + \ typePtr -> + {# call webkit_dom_ui_event_init_ui_event #} (toUIEvent self) + typePtr + (fromBool canBubble) + (fromBool cancelable) + (maybe (DOMWindow nullForeignPtr) toDOMWindow view) + (fromIntegral detail) + +uiEventGetView :: + (UIEventClass self) => self -> IO (Maybe DOMWindow) +uiEventGetView self + = maybeNull (makeNewGObject mkDOMWindow) + ({# call webkit_dom_ui_event_get_view #} (toUIEvent self)) + +uiEventGetDetail :: (UIEventClass self) => self -> IO Int +uiEventGetDetail self + = fromIntegral <$> + ({# call webkit_dom_ui_event_get_detail #} (toUIEvent self)) + +uiEventGetKeyCode :: (UIEventClass self) => self -> IO Int +uiEventGetKeyCode self + = fromIntegral <$> + ({# call webkit_dom_ui_event_get_key_code #} (toUIEvent self)) + +uiEventGetCharCode :: (UIEventClass self) => self -> IO Int +uiEventGetCharCode self + = fromIntegral <$> + ({# call webkit_dom_ui_event_get_char_code #} (toUIEvent self)) + +uiEventGetLayerX :: (UIEventClass self) => self -> IO Int +uiEventGetLayerX self + = fromIntegral <$> + ({# call webkit_dom_ui_event_get_layer_x #} (toUIEvent self)) + +uiEventGetLayerY :: (UIEventClass self) => self -> IO Int +uiEventGetLayerY self + = fromIntegral <$> + ({# call webkit_dom_ui_event_get_layer_y #} (toUIEvent self)) + +uiEventGetPageX :: (UIEventClass self) => self -> IO Int +uiEventGetPageX self + = fromIntegral <$> + ({# call webkit_dom_ui_event_get_page_x #} (toUIEvent self)) + +uiEventGetPageY :: (UIEventClass self) => self -> IO Int +uiEventGetPageY self + = fromIntegral <$> + ({# call webkit_dom_ui_event_get_page_y #} (toUIEvent self)) + +uiEventGetWhich :: (UIEventClass self) => self -> IO Int +uiEventGetWhich self + = fromIntegral <$> + ({# call webkit_dom_ui_event_get_which #} (toUIEvent self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/ValidityState.chs b/Graphics/UI/Gtk/WebKit/DOM/ValidityState.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/ValidityState.chs @@ -0,0 +1,76 @@ +module Graphics.UI.Gtk.WebKit.DOM.ValidityState + (validityStateGetValueMissing, validityStateGetTypeMismatch, + validityStateGetPatternMismatch, validityStateGetTooLong, + validityStateGetRangeUnderflow, validityStateGetRangeOverflow, + validityStateGetStepMismatch, validityStateGetCustomError, + validityStateGetValid) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +validityStateGetValueMissing :: + (ValidityStateClass self) => self -> IO Bool +validityStateGetValueMissing self + = toBool <$> + ({# call webkit_dom_validity_state_get_value_missing #} + (toValidityState self)) + +validityStateGetTypeMismatch :: + (ValidityStateClass self) => self -> IO Bool +validityStateGetTypeMismatch self + = toBool <$> + ({# call webkit_dom_validity_state_get_type_mismatch #} + (toValidityState self)) + +validityStateGetPatternMismatch :: + (ValidityStateClass self) => self -> IO Bool +validityStateGetPatternMismatch self + = toBool <$> + ({# call webkit_dom_validity_state_get_pattern_mismatch #} + (toValidityState self)) + +validityStateGetTooLong :: + (ValidityStateClass self) => self -> IO Bool +validityStateGetTooLong self + = toBool <$> + ({# call webkit_dom_validity_state_get_too_long #} + (toValidityState self)) + +validityStateGetRangeUnderflow :: + (ValidityStateClass self) => self -> IO Bool +validityStateGetRangeUnderflow self + = toBool <$> + ({# call webkit_dom_validity_state_get_range_underflow #} + (toValidityState self)) + +validityStateGetRangeOverflow :: + (ValidityStateClass self) => self -> IO Bool +validityStateGetRangeOverflow self + = toBool <$> + ({# call webkit_dom_validity_state_get_range_overflow #} + (toValidityState self)) + +validityStateGetStepMismatch :: + (ValidityStateClass self) => self -> IO Bool +validityStateGetStepMismatch self + = toBool <$> + ({# call webkit_dom_validity_state_get_step_mismatch #} + (toValidityState self)) + +validityStateGetCustomError :: + (ValidityStateClass self) => self -> IO Bool +validityStateGetCustomError self + = toBool <$> + ({# call webkit_dom_validity_state_get_custom_error #} + (toValidityState self)) + +validityStateGetValid :: + (ValidityStateClass self) => self -> IO Bool +validityStateGetValid self + = toBool <$> + ({# call webkit_dom_validity_state_get_valid #} + (toValidityState self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/WebKitNamedFlow.chs b/Graphics/UI/Gtk/WebKit/DOM/WebKitNamedFlow.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/WebKitNamedFlow.chs @@ -0,0 +1,76 @@ +module Graphics.UI.Gtk.WebKit.DOM.WebKitNamedFlow + ( +#if WEBKIT_CHECK_VERSION(1,10,0) + webKitNamedFlowGetRegionsByContent, webKitNamedFlowGetRegions, + webKitNamedFlowGetContent, webKitNamedFlowDispatchEvent, + webKitNamedFlowGetName, webKitNamedFlowGetOverset, + webKitNamedFlowGetFirstEmptyRegionIndex +#endif + ) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +#if WEBKIT_CHECK_VERSION(1,10,0) +webKitNamedFlowGetRegionsByContent :: + (WebKitNamedFlowClass self, NodeClass contentNode) => + self -> Maybe contentNode -> IO (Maybe NodeList) +webKitNamedFlowGetRegionsByContent self contentNode + = maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_webkit_named_flow_get_regions_by_content #} + (toWebKitNamedFlow self) + (maybe (Node nullForeignPtr) toNode contentNode)) + +webKitNamedFlowGetRegions :: + (WebKitNamedFlowClass self) => self -> IO (Maybe NodeList) +webKitNamedFlowGetRegions self + = maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_webkit_named_flow_get_regions #} + (toWebKitNamedFlow self)) + +webKitNamedFlowGetContent :: + (WebKitNamedFlowClass self) => self -> IO (Maybe NodeList) +webKitNamedFlowGetContent self + = maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_webkit_named_flow_get_content #} + (toWebKitNamedFlow self)) + +webKitNamedFlowDispatchEvent :: + (WebKitNamedFlowClass self, EventClass event) => + self -> Maybe event -> IO Bool +webKitNamedFlowDispatchEvent self event + = toBool <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_webkit_named_flow_dispatch_event #} + (toWebKitNamedFlow self) + (maybe (Event nullForeignPtr) toEvent event) + errorPtr_) + +webKitNamedFlowGetName :: + (WebKitNamedFlowClass self) => self -> IO String +webKitNamedFlowGetName self + = ({# call webkit_dom_webkit_named_flow_get_name #} + (toWebKitNamedFlow self)) + >>= + readUTFString + +webKitNamedFlowGetOverset :: + (WebKitNamedFlowClass self) => self -> IO Bool +webKitNamedFlowGetOverset self + = toBool <$> + ({# call webkit_dom_webkit_named_flow_get_overset #} + (toWebKitNamedFlow self)) + +webKitNamedFlowGetFirstEmptyRegionIndex :: + (WebKitNamedFlowClass self) => self -> IO Int +webKitNamedFlowGetFirstEmptyRegionIndex self + = fromIntegral <$> + ({# call webkit_dom_webkit_named_flow_get_first_empty_region_index + #} + (toWebKitNamedFlow self)) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/WebKitPoint.chs b/Graphics/UI/Gtk/WebKit/DOM/WebKitPoint.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/WebKitPoint.chs @@ -0,0 +1,32 @@ +module Graphics.UI.Gtk.WebKit.DOM.WebKitPoint + (webKitPointSetX, webKitPointGetX, webKitPointSetY, + webKitPointGetY) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +webKitPointSetX :: + (WebKitPointClass self) => self -> Float -> IO () +webKitPointSetX self val + = {# call webkit_dom_webkit_point_set_x #} (toWebKitPoint self) + (realToFrac val) + +webKitPointGetX :: (WebKitPointClass self) => self -> IO Float +webKitPointGetX self + = realToFrac <$> + ({# call webkit_dom_webkit_point_get_x #} (toWebKitPoint self)) + +webKitPointSetY :: + (WebKitPointClass self) => self -> Float -> IO () +webKitPointSetY self val + = {# call webkit_dom_webkit_point_set_y #} (toWebKitPoint self) + (realToFrac val) + +webKitPointGetY :: (WebKitPointClass self) => self -> IO Float +webKitPointGetY self + = realToFrac <$> + ({# call webkit_dom_webkit_point_get_y #} (toWebKitPoint self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Window.chs b/Graphics/UI/Gtk/WebKit/DOM/Window.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Window.chs @@ -0,0 +1,8 @@ +module Graphics.UI.Gtk.WebKit.DOM.Window (BarInfo, BarInfoClass) + where + +data BarInfo = BarInfo + +class BarInfoClass a + +instance BarInfoClass BarInfo diff --git a/Graphics/UI/Gtk/WebKit/DOM/XPathExpression.chs b/Graphics/UI/Gtk/WebKit/DOM/XPathExpression.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/XPathExpression.chs @@ -0,0 +1,25 @@ +module Graphics.UI.Gtk.WebKit.DOM.XPathExpression + (xPathExpressionEvaluate) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +xPathExpressionEvaluate :: + (XPathExpressionClass self, NodeClass contextNode, + XPathResultClass inResult) => + self -> + Maybe contextNode -> + Word -> Maybe inResult -> IO (Maybe XPathResult) +xPathExpressionEvaluate self contextNode type' inResult + = maybeNull (makeNewGObject mkXPathResult) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_expression_evaluate #} + (toXPathExpression self) + (maybe (Node nullForeignPtr) toNode contextNode) + (fromIntegral type') + (maybe (XPathResult nullForeignPtr) toXPathResult inResult) + errorPtr_) diff --git a/Graphics/UI/Gtk/WebKit/DOM/XPathNSResolver.chs b/Graphics/UI/Gtk/WebKit/DOM/XPathNSResolver.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/XPathNSResolver.chs @@ -0,0 +1,19 @@ +module Graphics.UI.Gtk.WebKit.DOM.XPathNSResolver + (xPathNSResolverLookupNamespaceURI) where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +xPathNSResolverLookupNamespaceURI :: + (XPathNSResolverClass self) => self -> String -> IO String +xPathNSResolverLookupNamespaceURI self prefix + = (withUTFString prefix $ + \ prefixPtr -> + {# call webkit_dom_xpath_ns_resolver_lookup_namespace_uri #} + (toXPathNSResolver self) + prefixPtr) + >>= + readUTFString diff --git a/Graphics/UI/Gtk/WebKit/DOM/XPathResult.chs b/Graphics/UI/Gtk/WebKit/DOM/XPathResult.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/XPathResult.chs @@ -0,0 +1,113 @@ +module Graphics.UI.Gtk.WebKit.DOM.XPathResult + (xPathResultIterateNext, xPathResultSnapshotItem, cANY_TYPE, + cNUMBER_TYPE, cSTRING_TYPE, cBOOLEAN_TYPE, + cUNORDERED_NODE_ITERATOR_TYPE, cORDERED_NODE_ITERATOR_TYPE, + cUNORDERED_NODE_SNAPSHOT_TYPE, cORDERED_NODE_SNAPSHOT_TYPE, + cANY_UNORDERED_NODE_TYPE, cFIRST_ORDERED_NODE_TYPE, + xPathResultGetResultType, xPathResultGetNumberValue, + xPathResultGetStringValue, xPathResultGetBooleanValue, + xPathResultGetSingleNodeValue, xPathResultGetInvalidIteratorState, + xPathResultGetSnapshotLength) + where +import System.Glib.FFI +import System.Glib.UTFString +import Control.Applicative +{#import Graphics.UI.Gtk.WebKit.Types#} +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventM + +xPathResultIterateNext :: + (XPathResultClass self) => self -> IO (Maybe Node) +xPathResultIterateNext self + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_iterate_next #} + (toXPathResult self) + errorPtr_) + +xPathResultSnapshotItem :: + (XPathResultClass self) => self -> Word -> IO (Maybe Node) +xPathResultSnapshotItem self index + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_snapshot_item #} + (toXPathResult self) + (fromIntegral index) + errorPtr_) +cANY_TYPE = 0 +cNUMBER_TYPE = 1 +cSTRING_TYPE = 2 +cBOOLEAN_TYPE = 3 +cUNORDERED_NODE_ITERATOR_TYPE = 4 +cORDERED_NODE_ITERATOR_TYPE = 5 +cUNORDERED_NODE_SNAPSHOT_TYPE = 6 +cORDERED_NODE_SNAPSHOT_TYPE = 7 +cANY_UNORDERED_NODE_TYPE = 8 +cFIRST_ORDERED_NODE_TYPE = 9 + +xPathResultGetResultType :: + (XPathResultClass self) => self -> IO Word +xPathResultGetResultType self + = fromIntegral <$> + ({# call webkit_dom_xpath_result_get_result_type #} + (toXPathResult self)) + +xPathResultGetNumberValue :: + (XPathResultClass self) => self -> IO Double +xPathResultGetNumberValue self + = realToFrac <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_get_number_value #} + (toXPathResult self) + errorPtr_) + +xPathResultGetStringValue :: + (XPathResultClass self) => self -> IO String +xPathResultGetStringValue self + = (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_get_string_value #} + (toXPathResult self) + errorPtr_) + >>= + readUTFString + +xPathResultGetBooleanValue :: + (XPathResultClass self) => self -> IO Bool +xPathResultGetBooleanValue self + = toBool <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_get_boolean_value #} + (toXPathResult self) + errorPtr_) + +xPathResultGetSingleNodeValue :: + (XPathResultClass self) => self -> IO (Maybe Node) +xPathResultGetSingleNodeValue self + = maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_get_single_node_value #} + (toXPathResult self) + errorPtr_) + +xPathResultGetInvalidIteratorState :: + (XPathResultClass self) => self -> IO Bool +xPathResultGetInvalidIteratorState self + = toBool <$> + ({# call webkit_dom_xpath_result_get_invalid_iterator_state #} + (toXPathResult self)) + +xPathResultGetSnapshotLength :: + (XPathResultClass self) => self -> IO Word +xPathResultGetSnapshotLength self + = fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_get_snapshot_length #} + (toXPathResult self) + errorPtr_) diff --git a/Graphics/UI/Gtk/WebKit/DOM/hsevents.c b/Graphics/UI/Gtk/WebKit/DOM/hsevents.c new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/hsevents.c @@ -0,0 +1,67 @@ +/* WebKitGTK Gtk2Hs WebKitDOMEventTarget implementation + * + * Author : Hamish Mackenzie + * + * Created: 18 August 2012 + * + * Copyright (C) 2012 Hamish Mackenzie + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + */ + +/* GHC's semi-public Rts API */ +#include + +#include "hsgclosure.h" +#include "events.h" +#include + +#if WEBKIT_CHECK_VERSION(2,0,0) + #include +#else + #include + #include +#endif + +#ifdef DEBUG + #define WHEN_DEBUG(a) a +#else + #define WHEN_DEBUG(a) +#endif + +// Once the following bug is fixed we should revist this +// https://bugs.webkit.org/show_bug.cgi?id=77835 + +static void webkit_gtk2hs_closure_callback(GObject *target, WebKitDOMEvent *event, void *user_data) +{ + WHEN_DEBUG(g_debug("webkit_gtk2hs_closure_callback: about to run target=%p, event=%p, user_data=%p", target, event, user_data)); + // I think passing the target to the closure will allow us + // to create call backs that do not hold a reference to + // the target. + GClosure *closure = (GClosure *)user_data; + GValue params[2] = {G_VALUE_INIT, G_VALUE_INIT}; + g_value_init(¶ms[0], WEBKIT_TYPE_DOM_EVENT_TARGET); + g_value_init(¶ms[1], WEBKIT_TYPE_DOM_EVENT); + g_value_set_object(¶ms[0], WEBKIT_DOM_EVENT_TARGET (target)); + g_value_set_object(¶ms[1], event); + g_closure_invoke(closure, NULL, 2, ¶ms[0], NULL); +} + +gboolean webkit_dom_event_target_add_event_listener_closure( + WebKitDOMEventTarget *target, + const char *eventName, + GClosure *closure, + gboolean bubble) +{ + WHEN_DEBUG(g_debug("webkit_dom_event_target_add_event_listener_closure: about to run target %p, eventName=\"%s\", closure=%p", target, eventName, closure)); + return webkit_dom_event_target_add_event_listener( + WEBKIT_DOM_EVENT_TARGET (target), eventName, G_CALLBACK(webkit_gtk2hs_closure_callback), bubble, closure); +} diff --git a/Graphics/UI/Gtk/WebKit/Download.chs b/Graphics/UI/Gtk/WebKit/Download.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/Download.chs @@ -0,0 +1,310 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.Download +-- Author : Cjacker Huang +-- Copyright : (c) 2009 Cjacker Huang +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Object used to communicate with the application when downloading +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.Download ( +-- * Description +-- | WebKitDownload carries information about a download request, including a WebKitNetworkRequest +-- object. The application may use this object to control the download process, or to simply figure out +-- what is to be downloaded, and do it itself. + +-- * Types + Download, + DownloadClass, + +-- * Enums + DownloadError(..), + DownloadStatus(..), + +-- * Constructors + downloadNew, + +-- * Methods + downloadStart, + downloadCancel, + downloadGetUri, + downloadGetNetworkRequest, +#if WEBKIT_CHECK_VERSION (1,1,16) + downloadGetNetworkResponse, +#endif + downloadGetSuggestedFilename, + downloadGetDestinationUri, + downloadGetProgress, + downloadGetElapsedTime, + downloadGetTotalSize, + downloadGetCurrentSize, + downloadGetStatus, + downloadSetDestinationUri, + +-- * Attributes + currentSize, + destinationUri, + networkRequest, +#if WEBKIT_CHECK_VERSION (1,1,16) + networkResponse, +#endif + progress, + status, + suggestedFilename, + totalSize, + +-- * Signals + downloadError, +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GError +import System.Glib.Attributes +import System.Glib.Properties +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import Graphics.UI.Gtk.WebKit.Signals#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +-- * Enums + +{#enum DownloadError {underscoreToCase}#} +{#enum DownloadStatus {underscoreToCase}#} + + +------------------ +-- Constructors + + +-- | Create a new 'Download' instance for the given 'NetworkRequest' +-- +-- Object used to communicate with the application when downloading. +downloadNew :: NetworkRequestClass request => request -> IO Download +downloadNew nr = + wrapNewGObject mkDownload $ {#call download_new#} (toNetworkRequest nr) + +-- | Initiates the 'Download'. +-- +-- Notice that you must have set the destination-uri property before +-- calling this function. +downloadStart:: + DownloadClass self => self + -> IO() +downloadStart dl = + {#call download_start#} (toDownload dl) + +-- | Cancels the 'Download'. +downloadCancel:: + DownloadClass self => self + -> IO() +downloadCancel dl = + {#call download_cancel#} (toDownload dl) + +-- | Retrieves the URI from 'Download' which is being downloaded. +downloadGetUri:: + DownloadClass self => self + -> IO (Maybe String) -- ^ the uri or @Nothing@ in case of failed +downloadGetUri dl = + {#call download_get_uri#} (toDownload dl) + >>= maybePeek peekCString + +-- | Retrieves the 'NetworkRequest' that backs the download process. +downloadGetNetworkRequest :: + DownloadClass self => self + -> IO NetworkRequest +downloadGetNetworkRequest dl = + makeNewGObject mkNetworkRequest $ {#call download_get_network_request#} (toDownload dl) + +#if WEBKIT_CHECK_VERSION (1,1,16) +-- | Retrieves the 'NetworkResponse' object that backs the download process. +-- +-- * Since 1.1.16 +downloadGetNetworkResponse :: + DownloadClass self => self + -> IO NetworkResponse +downloadGetNetworkResponse dl = + makeNewGObject mkNetworkResponse $ {#call download_get_network_response#} (toDownload dl) +#endif + +-- | Retrieves the filename that was suggested by the server, +-- or the one derived from the URI. +downloadGetSuggestedFilename :: + DownloadClass self => self + -> IO (Maybe String) -- ^ the suggested filename or @Nothing@ in case of failed +downloadGetSuggestedFilename dl = + {#call download_get_suggested_filename#} (toDownload dl) >>= maybePeek peekCString + +-- | Obtains the URI to which the downloaded file will be written. +-- +-- It is set by Application before call 'downloadStart' +downloadGetDestinationUri :: + DownloadClass self => self + -> IO (Maybe String) +downloadGetDestinationUri dl = + {#call download_get_destination_uri#} (toDownload dl) >>= maybePeek peekCString + +-- | Defines the URI that should be used to save the downloaded file to. +downloadSetDestinationUri :: + DownloadClass self => self + -> String -- ^ @destination_uri@ - the destination URI + -> IO() +downloadSetDestinationUri dl dest = + withCString dest $ \destPtr -> + {#call download_set_destination_uri#} (toDownload dl) destPtr + +-- |Determines the current progress of the 'Download' +downloadGetProgress :: + DownloadClass self => self + -> IO Double -- ^ a 'Double' ranging from 0.0 to 1.0 +downloadGetProgress dl = + liftM realToFrac $ {#call download_get_progress#} (toDownload dl) + +-- |Return elapsed time for the 'Download' in seconds. +-- includeing any fractional part. +-- +-- If the 'Download' is finished, had an error or was cancelled, +-- this is the time between its start and the event. +downloadGetElapsedTime :: + DownloadClass self => self + -> IO Double -- ^ seconds since the 'Download' was started. +downloadGetElapsedTime dl = + liftM realToFrac $ {#call download_get_elapsed_time#} (toDownload dl) + +-- |Returns the excepted total size of the download. +-- +-- This is expected because the server may provide incorrect or missing +-- Content-Length. +-- +-- Notice that this may grow over time. +downloadGetTotalSize :: + DownloadClass self => self + -> IO Int -- ^ the expected total size of the downloaded file. +downloadGetTotalSize dl = + liftM fromIntegral $ {#call download_get_total_size#} (toDownload dl) + +-- | Returns the current already downleaded size +downloadGetCurrentSize :: + DownloadClass self => self + -> IO Int -- ^ the already downloaded size. +downloadGetCurrentSize dl = + liftM fromIntegral $ {#call download_get_current_size#} (toDownload dl) + +-- | Obtains the current status of the 'Download' as 'DownloadStatus' +downloadGetStatus :: + DownloadClass self => self + -> IO DownloadStatus -- ^ the current 'DownloadStatus' +downloadGetStatus dl = + liftM (toEnum . fromIntegral) $ {#call download_get_status#} (toDownload dl) + +-- * Attibutes + +-- | The length of the data already downloaded +-- +-- Default value: 0 +-- +-- * Since 1.1.2 +-- +currentSize :: DownloadClass self => ReadAttr self Int +currentSize = readAttr downloadGetCurrentSize + +-- | The URI of the save location for this download. +-- +-- Default value: \"\" +-- +-- * Since 1.1.2 +destinationUri :: DownloadClass self => Attr self (Maybe String) +destinationUri = newAttrFromMaybeStringProperty "destination-uri" + +-- | The NetworkRequest instance associated with the download. +-- +-- * Since 1.1.2 +networkRequest :: DownloadClass self => Attr self NetworkRequest +networkRequest = + newAttrFromObjectProperty "network-request" + {#call pure webkit_network_request_get_type#} + +#if WEBKIT_CHECK_VERSION (1,1,16) +-- | The NetworkResponse instance associated with the download. +-- +-- * Since 1.1.16 +networkResponse :: DownloadClass self => Attr self NetworkResponse +networkResponse = + newAttrFromObjectProperty "network-response" + {#call pure webkit_network_response_get_type#} +#endif + +-- | Determines the current progress of the download. +-- Notice that, although the progress changes are reported as soon as possible, +-- the emission of the notify signal for this property is throttled, for the benefit of download managers. +-- If you care about every update, use 'Download' : currentSize. +-- +-- Allowed values: [0,1] +-- +-- Default value: 1 +-- +-- * Since 1.1.2 +progress :: DownloadClass self => ReadAttr self Double +progress = readAttr downloadGetProgress + +-- | Determines the current status of the download. +-- +-- Default value: 'DownloadStatusCreated' +-- +-- * Since 1.1.2 +status :: DownloadClass self => ReadAttr self DownloadStatus +status = readAttr downloadGetStatus + +-- | The file name suggested as default when saving +-- +-- Default value: \"\" +-- +-- * Since 1.1.2 +suggestedFilename :: DownloadClass self => ReadAttr self (Maybe String) +suggestedFilename = readAttr downloadGetSuggestedFilename + +-- | The total size of the file +-- +-- Default value: 0 +-- +-- * Since 1.1.2 +totalSize :: DownloadClass self => ReadAttr self Int +totalSize = readAttr downloadGetTotalSize + +-- * Signals + +-- | Emitted when download is interrupted either by user action or by network errors, +-- errorDetail will take any value of 'DownloadError'. +-- +-- 'download': the object on which the signal is emitted +-- 'errorCode': the corresponding error code +-- 'errorDetail': detailed error code for the error, see 'DownloadError' +-- 'reason': a string describing the error +-- +-- Since 1.1.2 +downloadError :: DownloadClass self => Signal self (Int -> Int -> String -> IO Bool) +downloadError = Signal (connect_INT_INT_STRING__BOOL "error") diff --git a/Graphics/UI/Gtk/WebKit/GeolocationPolicyDecision.chs b/Graphics/UI/Gtk/WebKit/GeolocationPolicyDecision.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/GeolocationPolicyDecision.chs @@ -0,0 +1,77 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.GeolocationPolicyDecision +-- Author : Andy Stewart +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Object used to communicate with the application when downloading +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.GeolocationPolicyDecision ( +#if WEBKIT_CHECK_VERSION (1,1,23) +-- * Description +-- | WebKitGeolocationPolicyDecision objects are given to the application when +-- geolocation-policy-decision-requested signal is emitted. The application uses it to tell the engine +-- whether it wants to allow or deny geolocation for a given frame. + +-- * Types + GeolocationPolicyDecision, + GeolocationPolicyDecisionClass, + +-- * Methods + geolocationPolicyAllow, + geolocationPolicyDeny, +#endif +) where +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.Attributes +import System.Glib.Properties +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import Graphics.UI.Gtk.WebKit.Signals#} +{#import Graphics.UI.Gtk.WebKit.Internal#} +{#import System.Glib.GObject#} +{#import Graphics.UI.Gtk.General.Selection#} ( TargetList ) +{#import Graphics.UI.Gtk.MenuComboToolbar.Menu#} +{#import Graphics.UI.Gtk.General.Enums#} + +{#context lib="webkit" prefix ="webkit"#} + +#if WEBKIT_CHECK_VERSION (1,1,23) +-- | Will send the allow decision to the policy implementer. +-- +-- * Since 1.1.23 +geolocationPolicyAllow :: GeolocationPolicyDecisionClass decision => decision -> IO () +geolocationPolicyAllow decision = + {#call webkit_geolocation_policy_allow #} (toGeolocationPolicyDecision decision) + +-- | Will send the deny decision to the policy implementer. +-- +-- * Since 1.1.23 +geolocationPolicyDeny :: GeolocationPolicyDecisionClass decision => decision -> IO () +geolocationPolicyDeny decision = + {#call webkit_geolocation_policy_deny #} (toGeolocationPolicyDecision decision) +#endif diff --git a/Graphics/UI/Gtk/WebKit/HitTestResult.chs b/Graphics/UI/Gtk/WebKit/HitTestResult.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/HitTestResult.chs @@ -0,0 +1,51 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.HitTestResult +-- Author : Andy Stewart +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Access to the WebKit Web Resource +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.HitTestResult ( +-- * Description +-- | This class holds context information about the coordinates specified by a GDK event. + +-- * Types + HitTestResult, + HitTestResultClass, + +-- * Enums. + HitTestResultContext(..), +) where + +import System.Glib.FFI +import System.Glib.GList +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +-- * Enums. + +{#enum HitTestResultContext {underscoreToCase}#} diff --git a/Graphics/UI/Gtk/WebKit/Internal.chs b/Graphics/UI/Gtk/WebKit/Internal.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/Internal.chs @@ -0,0 +1,65 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.Internal +-- Author : Andy Stewart +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Access to the WebKit Internal +-- +-- This module contain some functions for help binding Webkit. +-- +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.Internal ( +-- * Methods +-- Below functions just help binding use in internal. +-- Don't call those functions in your code. + connect_OBJECT__OBJECTPTR, + webViewToWebViewPtr, +) where + +import System.Glib.FFI +import System.Glib.GList +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import Graphics.UI.Gtk.WebKit.Signals#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +-- | Signal helper functions. +connect_OBJECT__OBJECTPTR :: + (GObjectClass a', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> IO WebView) -> + IO (ConnectId obj) +connect_OBJECT__OBJECTPTR signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> IO (Ptr WebView) + action _ obj1 = + failOnGError $ + makeNewGObject mkGObject (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') >>= webViewToWebViewPtr + +-- | Internal helper function for convert. +webViewToWebViewPtr :: WebViewClass self => self -> IO (Ptr WebView) +webViewToWebViewPtr webview = return $ unsafeForeignPtrToPtr (unWebView (toWebView webview)) diff --git a/Graphics/UI/Gtk/WebKit/NetworkRequest.chs b/Graphics/UI/Gtk/WebKit/NetworkRequest.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/NetworkRequest.chs @@ -0,0 +1,96 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.NetworkRequest +-- Author : Cjacker Huang +-- Copyright : (c) 2009 Cjacker Huang +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- The target of a navigation request +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.NetworkRequest ( +-- * Description +-- | This class represents the network related aspects of a navigation request. It is used whenever +-- WebKit wants to provide information about a request that will be sent, or has been sent. Inside it +-- you can find the URI of the request, and, for valid URIs, a SoupMessage object, which provides +-- access to further information such as headers. + +-- * Types + NetworkRequest, + NetworkRequestClass, + +-- * Constructors + networkRequestNew, + +-- * Methods + networkRequestSetUri, + networkRequestGetUri, +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +------------------ +-- Constructors + + +-- | Create a new NetworkRequest with the given @uri@. +-- +-- It is used whenever WebKit wants to provide information +-- about a request that will be sent, or has been sent. +networkRequestNew :: + String -- ^ @uri@ - the uri of the request + -> IO NetworkRequest +networkRequestNew uri = + withCString uri $ \uriPtr -> + wrapNewGObject mkNetworkRequest $ + {#call network_request_new#} uriPtr + + +-- | Set the URI of 'NetworkRequest'. +-- +networkRequestSetUri :: + NetworkRequestClass self => self + -> String -- ^ @uri@ - the uri will be set to the request. + -> IO() +networkRequestSetUri networkrequest uri = + withCString uri $ \uriPtr -> + {#call network_request_set_uri#} + (toNetworkRequest networkrequest) + uriPtr + + +-- | Return the uri of 'NetworkRequest'. +networkRequestGetUri :: + NetworkRequestClass self => self + -> IO (Maybe String) -- ^ the URI or @Nothing@ in case failed. +networkRequestGetUri networkrequest = + {#call network_request_get_uri#} + (toNetworkRequest networkrequest) >>= + maybePeek peekCString diff --git a/Graphics/UI/Gtk/WebKit/NetworkResponse.chs b/Graphics/UI/Gtk/WebKit/NetworkResponse.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/NetworkResponse.chs @@ -0,0 +1,77 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.NetworkResponse +-- Author : Cjacker Huang +-- Copyright : (c) 2009 Cjacker Huang +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- The response given to a network request +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.NetworkResponse ( +-- * Description +-- | This class represents the network related aspects of a navigation response. + +-- * Types + NetworkResponse, + NetworkResponseClass, + +-- * Methods + networkResponseSetUri, + networkResponseGetUri, +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +------------------ +-- Constructors + +-- | Set the URI of 'NetworkResponse'. +-- +networkResponseSetUri :: + NetworkResponseClass self => self + -> String -- ^ @uri@ - the uri will be set to the response. + -> IO() +networkResponseSetUri response uri = + withCString uri $ \uriPtr -> + {#call network_response_set_uri#} + (toNetworkResponse response) + uriPtr + + +-- | Return the uri of 'NetworkResponse'. +networkResponseGetUri :: + NetworkResponseClass self => self + -> IO (Maybe String) -- ^ the URI or @Nothing@ in case failed. +networkResponseGetUri response = + {#call network_response_get_uri#} + (toNetworkResponse response) >>= + maybePeek peekCString + diff --git a/Graphics/UI/Gtk/WebKit/SecurityOrigin.chs b/Graphics/UI/Gtk/WebKit/SecurityOrigin.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/SecurityOrigin.chs @@ -0,0 +1,119 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.WebSecurityOrigin +-- Author : Andy Stewart +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Access to the WebKit Web SecurityOrigin +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.SecurityOrigin ( +-- * Desciption +-- | WebKitSecurityOrigin is a representation of a security domain defined by web sites. An origin +-- consists of a host name, a protocol, and a port number. Web sites with the same security origin can +-- access each other's resources for client-side scripting or database access. +-- +-- Use 'webFrameGetSecurityOrigin' to get the security origin of a WebKitWebFrame. +-- +-- Database quotas and usages are also defined per security origin. The cumulative disk usage of an +-- origin's databases may be retrieved with 'securityOriginGetWebDatabaseUsage'. An origin's +-- quota can be adjusted with 'securityOriginSetWebDatabaseQuota'. + +-- * Types + SecurityOrigin, + SecurityOriginClass, + +-- * Methods + securityOriginGetAllWebDatabases, + securityOriginGetHost, + securityOriginGetPort, + securityOriginGetProtocol, + securityOriginGetWebDatabaseQuota, + securityOriginSetWebDatabaseQuota, + securityOriginGetWebDatabaseUsage, +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +-- * Methods. + +-- | Returns the frame's security origin. +securityOriginGetAllWebDatabases :: + SecurityOriginClass self => self + -> IO [WebDatabase] +securityOriginGetAllWebDatabases so = do + glist <- {#call security_origin_get_all_web_databases#} (toSecurityOrigin so) + databasePtr <- fromGList glist + mapM (makeNewGObject mkWebDatabase . return) databasePtr + +-- | Returns the hostname for the security origin. +securityOriginGetHost :: + SecurityOriginClass self => self + -> IO String +securityOriginGetHost so = + {#call security_origin_get_host#} (toSecurityOrigin so) >>= peekCString + +-- | Returns the port for the security origin. +securityOriginGetPort :: + SecurityOriginClass self => self + -> IO Int +securityOriginGetPort so = + liftM fromIntegral $ {#call security_origin_get_port#} (toSecurityOrigin so) + +-- | Returns the protocol for the security origin. +securityOriginGetProtocol :: + SecurityOriginClass self => self + -> IO String +securityOriginGetProtocol so = + {#call security_origin_get_protocol#} (toSecurityOrigin so) >>= peekCString + +-- | Returns the quota for Web Database storage of the security origin in bytes. +securityOriginGetWebDatabaseQuota :: + SecurityOriginClass self => self + -> IO Int +securityOriginGetWebDatabaseQuota so = + liftM fromIntegral $ {#call security_origin_get_web_database_quota#} (toSecurityOrigin so) + +-- | Returns the usage for Web Database storage of the security origin in bytes. +securityOriginGetWebDatabaseUsage :: + SecurityOriginClass self => self + -> IO Int +securityOriginGetWebDatabaseUsage so = + liftM fromIntegral $ {#call security_origin_get_web_database_usage#} (toSecurityOrigin so) + +-- | Adjust the quota for Web Database storage of the security origin +securityOriginSetWebDatabaseQuota :: + SecurityOriginClass self => self + -> Int + -> IO () +securityOriginSetWebDatabaseQuota so quota = + {#call security_origin_set_web_database_quota#} (toSecurityOrigin so) (fromIntegral quota) + diff --git a/Graphics/UI/Gtk/WebKit/Signals.chs b/Graphics/UI/Gtk/WebKit/Signals.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/Signals.chs @@ -0,0 +1,391 @@ +{-# OPTIONS_HADDOCK hide #-} +-- -*-haskell-*- +-- -------------------- automatically generated file - do not edit ------------ +-- Callback installers for the GIMP Toolkit (GTK) Binding for Haskell +-- +-- Author : Axel Simon +-- +-- Created: 1 July 2000 +-- +-- Copyright (C) 2000-2005 Axel Simon +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- #hide + +-- These functions are used to connect signals to widgets. They are auto- +-- matically created through HookGenerator.hs which takes a list of possible +-- function signatures that are included in the GTK sources (gtkmarshal.list). +-- +-- The object system in the second version of GTK is based on GObject from +-- GLIB. This base class is rather primitive in that it only implements +-- ref and unref methods (and others that are not interesting to us). If +-- the marshall list mentions OBJECT it refers to an instance of this +-- GObject which is automatically wrapped with a ref and unref call. +-- Structures which are not derived from GObject have to be passed as +-- BOXED which gives the signal connect function a possibility to do the +-- conversion into a proper ForeignPtr type. In special cases the signal +-- connect function use a PTR type which will then be mangled in the +-- user function directly. The latter is needed if a signal delivers a +-- pointer to a string and its length in a separate integer. +-- +module Graphics.UI.Gtk.WebKit.Signals ( + module System.Glib.Signals, + + connect_PTR_PTR__NONE, + connect_OBJECT__BOOL, + connect_OBJECT_STRING_BOXED__BOOL, + connect_OBJECT__PTR, + connect_INT_INT_STRING__BOOL, + connect_STRING_STRING_INT_STRING__BOOL, + connect_OBJECT_STRING__BOOL, + connect_OBJECT_STRING_STRING__BOOL, + connect_OBJECT_OBJECT_OBJECT_OBJECT__BOOL, + connect_OBJECT_OBJECT_STRING_OBJECT__BOOL, + connect_OBJECT_OBJECT_OBJECT_OBJECT__NONE, + connect_OBJECT_OBJECT_MOBJECT_MOBJECT__NONE, + connect_ENUM_INT__BOOL, + connect_NONE__BOOL, + connect_NONE__NONE, + connect_MSTRING_MSTRING__NONE, + connect_OBJECT_STRING__NONE, + connect_OBJECT_OBJECT__NONE, + connect_STRING_STRING__NONE, + connect_OBJECT__NONE, + connect_INT__NONE, + connect_STRING__NONE, + + ) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString (peekUTFString,maybePeekUTFString) +import System.Glib.GError (failOnGError) +{#import System.Glib.Signals#} +{#import System.Glib.GObject#} +import Graphics.UI.GtkInternals + + +{#context lib="gtk" prefix="gtk" #} + + +-- Here are the generators that turn a Haskell function into +-- a C function pointer. The fist Argument is always the widget, +-- the last one is the user g_pointer. Both are ignored. + + +connect_PTR_PTR__NONE :: + GObjectClass obj => SignalName -> + ConnectAfter -> obj -> + (Ptr a -> Ptr b -> IO ()) -> + IO (ConnectId obj) +connect_PTR_PTR__NONE signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr () -> Ptr () -> IO () + action _ ptr1 ptr2 = + failOnGError $ + user (castPtr ptr1) (castPtr ptr2) + +connect_OBJECT__BOOL :: + (GObjectClass a', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> IO Bool) -> + IO (ConnectId obj) +connect_OBJECT__BOOL signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> IO Bool + action _ obj1 = + failOnGError $ + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') + +connect_OBJECT_STRING_BOXED__BOOL :: + (GObjectClass a', GObjectClass obj) => SignalName -> + (Ptr c' -> IO c) -> + ConnectAfter -> obj -> + (a' -> String -> c -> IO Bool) -> + IO (ConnectId obj) +connect_OBJECT_STRING_BOXED__BOOL signal boxedPre3 after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> CString -> Ptr () -> IO Bool + action _ obj1 str2 box3 = + failOnGError $ + boxedPre3 (castPtr box3) >>= \box3' -> + peekUTFString str2 >>= \str2' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') str2' box3' + +connect_OBJECT__PTR :: + (GObjectClass a', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> IO (Ptr b)) -> + IO (ConnectId obj) +connect_OBJECT__PTR signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> IO (Ptr ()) + action _ obj1 = + failOnGError $ + liftM castPtr $ + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') + +connect_INT_INT_STRING__BOOL :: + GObjectClass obj => SignalName -> + ConnectAfter -> obj -> + (Int -> Int -> String -> IO Bool) -> + IO (ConnectId obj) +connect_INT_INT_STRING__BOOL signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Int -> Int -> CString -> IO Bool + action _ int1 int2 str3 = + failOnGError $ + peekUTFString str3 >>= \str3' -> + user int1 int2 str3' + +connect_STRING_STRING_INT_STRING__BOOL :: + GObjectClass obj => SignalName -> + ConnectAfter -> obj -> + (String -> String -> Int -> String -> IO Bool) -> + IO (ConnectId obj) +connect_STRING_STRING_INT_STRING__BOOL signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> CString -> CString -> Int -> CString -> IO Bool + action _ str1 str2 int3 str4 = + failOnGError $ + peekUTFString str4 >>= \str4' -> + peekUTFString str2 >>= \str2' -> + peekUTFString str1 >>= \str1' -> + user str1' str2' int3 str4' + +connect_OBJECT_STRING__BOOL :: + (GObjectClass a', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> String -> IO Bool) -> + IO (ConnectId obj) +connect_OBJECT_STRING__BOOL signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> CString -> IO Bool + action _ obj1 str2 = + failOnGError $ + peekUTFString str2 >>= \str2' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') str2' + +connect_OBJECT_STRING_STRING__BOOL :: + (GObjectClass a', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> String -> String -> IO Bool) -> + IO (ConnectId obj) +connect_OBJECT_STRING_STRING__BOOL signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> CString -> CString -> IO Bool + action _ obj1 str2 str3 = + failOnGError $ + peekUTFString str3 >>= \str3' -> + peekUTFString str2 >>= \str2' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') str2' str3' + +connect_OBJECT_OBJECT_OBJECT_OBJECT__BOOL :: + (GObjectClass a', GObjectClass b', GObjectClass c', GObjectClass d', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> b' -> c' -> d' -> IO Bool) -> + IO (ConnectId obj) +connect_OBJECT_OBJECT_OBJECT_OBJECT__BOOL signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> Ptr GObject -> Ptr GObject -> Ptr GObject -> IO Bool + action _ obj1 obj2 obj3 obj4 = + failOnGError $ + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj4) >>= \obj4' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj3) >>= \obj3' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj2) >>= \obj2' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') (unsafeCastGObject obj2') (unsafeCastGObject obj3') (unsafeCastGObject obj4') + +connect_OBJECT_OBJECT_STRING_OBJECT__BOOL :: + (GObjectClass a', GObjectClass b', GObjectClass d', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> b' -> String -> d' -> IO Bool) -> + IO (ConnectId obj) +connect_OBJECT_OBJECT_STRING_OBJECT__BOOL signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> Ptr GObject -> CString -> Ptr GObject -> IO Bool + action _ obj1 obj2 str3 obj4 = + failOnGError $ + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj4) >>= \obj4' -> + peekUTFString str3 >>= \str3' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj2) >>= \obj2' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') (unsafeCastGObject obj2') str3' (unsafeCastGObject obj4') + +connect_OBJECT_OBJECT_OBJECT_OBJECT__NONE :: + (GObjectClass a', GObjectClass b', GObjectClass c', GObjectClass d', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> b' -> c' -> d' -> IO ()) -> + IO (ConnectId obj) +connect_OBJECT_OBJECT_OBJECT_OBJECT__NONE signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> Ptr GObject -> Ptr GObject -> Ptr GObject -> IO () + action _ obj1 obj2 obj3 obj4 = + failOnGError $ + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj4) >>= \obj4' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj3) >>= \obj3' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj2) >>= \obj2' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') (unsafeCastGObject obj2') (unsafeCastGObject obj3') (unsafeCastGObject obj4') + +connect_OBJECT_OBJECT_MOBJECT_MOBJECT__NONE :: + (GObjectClass a', GObjectClass b', GObjectClass c', GObjectClass d', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> b' -> Maybe c' -> Maybe d' -> IO ()) -> + IO (ConnectId obj) +connect_OBJECT_OBJECT_MOBJECT_MOBJECT__NONE signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> Ptr GObject -> Ptr GObject -> Ptr GObject -> IO () + action _ obj1 obj2 obj3 obj4 = + failOnGError $ + maybeNull (makeNewGObject (GObject, objectUnrefFromMainloop)) (return obj4) >>= \obj4' -> + maybeNull (makeNewGObject (GObject, objectUnrefFromMainloop)) (return obj3) >>= \obj3' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj2) >>= \obj2' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') (unsafeCastGObject obj2') (liftM unsafeCastGObject obj3') (liftM unsafeCastGObject obj4') + +connect_ENUM_INT__BOOL :: + (Enum a, GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a -> Int -> IO Bool) -> + IO (ConnectId obj) +connect_ENUM_INT__BOOL signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Int -> Int -> IO Bool + action _ enum1 int2 = + failOnGError $ + user (toEnum enum1) int2 + +connect_NONE__BOOL :: + GObjectClass obj => SignalName -> + ConnectAfter -> obj -> + (IO Bool) -> + IO (ConnectId obj) +connect_NONE__BOOL signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> IO Bool + action _ = + failOnGError $ + user + +connect_NONE__NONE :: + GObjectClass obj => SignalName -> + ConnectAfter -> obj -> + (IO ()) -> + IO (ConnectId obj) +connect_NONE__NONE signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> IO () + action _ = + failOnGError $ + user + +connect_MSTRING_MSTRING__NONE :: + GObjectClass obj => SignalName -> + ConnectAfter -> obj -> + (Maybe String -> Maybe String -> IO ()) -> + IO (ConnectId obj) +connect_MSTRING_MSTRING__NONE signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> CString -> CString -> IO () + action _ str1 str2 = + failOnGError $ + maybePeekUTFString str2 >>= \str2' -> + maybePeekUTFString str1 >>= \str1' -> + user str1' str2' + +connect_OBJECT_STRING__NONE :: + (GObjectClass a', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> String -> IO ()) -> + IO (ConnectId obj) +connect_OBJECT_STRING__NONE signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> CString -> IO () + action _ obj1 str2 = + failOnGError $ + peekUTFString str2 >>= \str2' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') str2' + +connect_OBJECT_OBJECT__NONE :: + (GObjectClass a', GObjectClass b', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> b' -> IO ()) -> + IO (ConnectId obj) +connect_OBJECT_OBJECT__NONE signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> Ptr GObject -> IO () + action _ obj1 obj2 = + failOnGError $ + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj2) >>= \obj2' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') (unsafeCastGObject obj2') + +connect_STRING_STRING__NONE :: + GObjectClass obj => SignalName -> + ConnectAfter -> obj -> + (String -> String -> IO ()) -> + IO (ConnectId obj) +connect_STRING_STRING__NONE signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> CString -> CString -> IO () + action _ str1 str2 = + failOnGError $ + peekUTFString str2 >>= \str2' -> + peekUTFString str1 >>= \str1' -> + user str1' str2' + +connect_OBJECT__NONE :: + (GObjectClass a', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> IO ()) -> + IO (ConnectId obj) +connect_OBJECT__NONE signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> IO () + action _ obj1 = + failOnGError $ + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') + +connect_INT__NONE :: + GObjectClass obj => SignalName -> + ConnectAfter -> obj -> + (Int -> IO ()) -> + IO (ConnectId obj) +connect_INT__NONE signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Int -> IO () + action _ int1 = + failOnGError $ + user int1 + +connect_STRING__NONE :: + GObjectClass obj => SignalName -> + ConnectAfter -> obj -> + (String -> IO ()) -> + IO (ConnectId obj) +connect_STRING__NONE signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> CString -> IO () + action _ str1 = + failOnGError $ + peekUTFString str1 >>= \str1' -> + user str1' + diff --git a/Graphics/UI/Gtk/WebKit/SoupAuthDialog.chs b/Graphics/UI/Gtk/WebKit/SoupAuthDialog.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/SoupAuthDialog.chs @@ -0,0 +1,46 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.SoupAuthDialog +-- Author : Andy Stewart +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Access to the WebKit Web Resource +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.SoupAuthDialog ( +-- * Description +-- | WebKitSoupAuthDialog is a SoupSessionFeature that you can attach to your SoupSession to provide a +-- simple authentication dialog while handling HTTP basic auth. It is built as a simple C-only module +-- to ease reuse. + +-- * Types + SoupAuthDialog, + SoupAuthDialogClass, +) where + +import System.Glib.FFI +import System.Glib.GList +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} diff --git a/Graphics/UI/Gtk/WebKit/Types.chs b/Graphics/UI/Gtk/WebKit/Types.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/Types.chs @@ -0,0 +1,4267 @@ +{-# OPTIONS_HADDOCK hide #-} +-- -*-haskell-*- +-- -------------------- automatically generated file - do not edit ---------- +-- Object hierarchy for the GIMP Toolkit (GTK) Binding for Haskell +-- +-- Author : Axel Simon +-- +-- Copyright (C) 2001-2005 Axel Simon +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- #hide + +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- This file reflects the Gtk+ object hierarchy in terms of Haskell classes. +-- +-- Note: the mk... functions were originally meant to simply be an alias +-- for the constructor. However, in order to communicate the destructor +-- of an object to objectNew, the mk... functions are now a tuple containing +-- Haskell constructor and the destructor function pointer. This hack avoids +-- changing all modules that simply pass mk... to objectNew. +-- +module Graphics.UI.Gtk.WebKit.Types ( + + module Graphics.UI.GtkInternals, + WebView(WebView), WebViewClass, + toWebView, + mkWebView, unWebView, + castToWebView, gTypeWebView, + WebFrame(WebFrame), WebFrameClass, + toWebFrame, + mkWebFrame, unWebFrame, + castToWebFrame, gTypeWebFrame, + WebSettings(WebSettings), WebSettingsClass, + toWebSettings, + mkWebSettings, unWebSettings, + castToWebSettings, gTypeWebSettings, + NetworkRequest(NetworkRequest), NetworkRequestClass, + toNetworkRequest, + mkNetworkRequest, unNetworkRequest, + castToNetworkRequest, gTypeNetworkRequest, + NetworkResponse(NetworkResponse), NetworkResponseClass, + toNetworkResponse, + mkNetworkResponse, unNetworkResponse, + castToNetworkResponse, gTypeNetworkResponse, + Download(Download), DownloadClass, + toDownload, + mkDownload, unDownload, + castToDownload, gTypeDownload, + WebBackForwardList(WebBackForwardList), WebBackForwardListClass, + toWebBackForwardList, + mkWebBackForwardList, unWebBackForwardList, + castToWebBackForwardList, gTypeWebBackForwardList, + WebHistoryItem(WebHistoryItem), WebHistoryItemClass, + toWebHistoryItem, + mkWebHistoryItem, unWebHistoryItem, + castToWebHistoryItem, gTypeWebHistoryItem, + WebInspector(WebInspector), WebInspectorClass, + toWebInspector, + mkWebInspector, unWebInspector, + castToWebInspector, gTypeWebInspector, + HitTestResult(HitTestResult), HitTestResultClass, + toHitTestResult, + mkHitTestResult, unHitTestResult, + castToHitTestResult, gTypeHitTestResult, + SecurityOrigin(SecurityOrigin), SecurityOriginClass, + toSecurityOrigin, + mkSecurityOrigin, unSecurityOrigin, + castToSecurityOrigin, gTypeSecurityOrigin, + SoupAuthDialog(SoupAuthDialog), SoupAuthDialogClass, + toSoupAuthDialog, + mkSoupAuthDialog, unSoupAuthDialog, + castToSoupAuthDialog, gTypeSoupAuthDialog, + WebDatabase(WebDatabase), WebDatabaseClass, + toWebDatabase, + mkWebDatabase, unWebDatabase, + castToWebDatabase, gTypeWebDatabase, + WebDataSource(WebDataSource), WebDataSourceClass, + toWebDataSource, + mkWebDataSource, unWebDataSource, + castToWebDataSource, gTypeWebDataSource, + WebNavigationAction(WebNavigationAction), WebNavigationActionClass, + toWebNavigationAction, + mkWebNavigationAction, unWebNavigationAction, + castToWebNavigationAction, gTypeWebNavigationAction, + WebPolicyDecision(WebPolicyDecision), WebPolicyDecisionClass, + toWebPolicyDecision, + mkWebPolicyDecision, unWebPolicyDecision, + castToWebPolicyDecision, gTypeWebPolicyDecision, + WebResource(WebResource), WebResourceClass, + toWebResource, + mkWebResource, unWebResource, + castToWebResource, gTypeWebResource, + WebWindowFeatures(WebWindowFeatures), WebWindowFeaturesClass, + toWebWindowFeatures, + mkWebWindowFeatures, unWebWindowFeatures, + castToWebWindowFeatures, gTypeWebWindowFeatures, + GeolocationPolicyDecision(GeolocationPolicyDecision), GeolocationPolicyDecisionClass, + toGeolocationPolicyDecision, + mkGeolocationPolicyDecision, unGeolocationPolicyDecision, + castToGeolocationPolicyDecision, gTypeGeolocationPolicyDecision, + BarInfo(BarInfo), BarInfoClass, + toBarInfo, + mkBarInfo, unBarInfo, + castToBarInfo, gTypeBarInfo, + Blob(Blob), BlobClass, + toBlob, + mkBlob, unBlob, + castToBlob, gTypeBlob, + File(File), FileClass, + toFile, + mkFile, unFile, + castToFile, gTypeFile, + CSSRule(CSSRule), CSSRuleClass, + toCSSRule, + mkCSSRule, unCSSRule, + castToCSSRule, gTypeCSSRule, + CSSRuleList(CSSRuleList), CSSRuleListClass, + toCSSRuleList, + mkCSSRuleList, unCSSRuleList, + castToCSSRuleList, gTypeCSSRuleList, + CSSStyleDeclaration(CSSStyleDeclaration), CSSStyleDeclarationClass, + toCSSStyleDeclaration, + mkCSSStyleDeclaration, unCSSStyleDeclaration, + castToCSSStyleDeclaration, gTypeCSSStyleDeclaration, + CSSValue(CSSValue), CSSValueClass, + toCSSValue, + mkCSSValue, unCSSValue, + castToCSSValue, gTypeCSSValue, + Console(Console), ConsoleClass, + toConsole, + mkConsole, unConsole, + castToConsole, gTypeConsole, + DOMApplicationCache(DOMApplicationCache), DOMApplicationCacheClass, + toDOMApplicationCache, + mkDOMApplicationCache, unDOMApplicationCache, + castToDOMApplicationCache, gTypeDOMApplicationCache, + DOMImplementation(DOMImplementation), DOMImplementationClass, + toDOMImplementation, + mkDOMImplementation, unDOMImplementation, + castToDOMImplementation, gTypeDOMImplementation, + DOMMimeType(DOMMimeType), DOMMimeTypeClass, + toDOMMimeType, + mkDOMMimeType, unDOMMimeType, + castToDOMMimeType, gTypeDOMMimeType, + DOMMimeTypeArray(DOMMimeTypeArray), DOMMimeTypeArrayClass, + toDOMMimeTypeArray, + mkDOMMimeTypeArray, unDOMMimeTypeArray, + castToDOMMimeTypeArray, gTypeDOMMimeTypeArray, + DOMPlugin(DOMPlugin), DOMPluginClass, + toDOMPlugin, + mkDOMPlugin, unDOMPlugin, + castToDOMPlugin, gTypeDOMPlugin, + DOMPluginArray(DOMPluginArray), DOMPluginArrayClass, + toDOMPluginArray, + mkDOMPluginArray, unDOMPluginArray, + castToDOMPluginArray, gTypeDOMPluginArray, + DOMSecurityPolicy(DOMSecurityPolicy), DOMSecurityPolicyClass, + toDOMSecurityPolicy, + mkDOMSecurityPolicy, unDOMSecurityPolicy, + castToDOMSecurityPolicy, gTypeDOMSecurityPolicy, + DOMSelection(DOMSelection), DOMSelectionClass, + toDOMSelection, + mkDOMSelection, unDOMSelection, + castToDOMSelection, gTypeDOMSelection, + DOMStringList(DOMStringList), DOMStringListClass, + toDOMStringList, + mkDOMStringList, unDOMStringList, + castToDOMStringList, gTypeDOMStringList, + DOMTokenList(DOMTokenList), DOMTokenListClass, + toDOMTokenList, + mkDOMTokenList, unDOMTokenList, + castToDOMTokenList, gTypeDOMTokenList, + DOMSettableTokenList(DOMSettableTokenList), DOMSettableTokenListClass, + toDOMSettableTokenList, + mkDOMSettableTokenList, unDOMSettableTokenList, + castToDOMSettableTokenList, gTypeDOMSettableTokenList, + DOMWindow(DOMWindow), DOMWindowClass, + toDOMWindow, + mkDOMWindow, unDOMWindow, + castToDOMWindow, gTypeDOMWindow, + Event(Event), EventClass, + toEvent, + mkEvent, unEvent, + castToEvent, gTypeEvent, + UIEvent(UIEvent), UIEventClass, + toUIEvent, + mkUIEvent, unUIEvent, + castToUIEvent, gTypeUIEvent, + MouseEvent(MouseEvent), MouseEventClass, + toMouseEvent, + mkMouseEvent, unMouseEvent, + castToMouseEvent, gTypeMouseEvent, + EventTarget(EventTarget), EventTargetClass, + toEventTarget, + mkEventTarget, unEventTarget, + castToEventTarget, gTypeEventTarget, + FileList(FileList), FileListClass, + toFileList, + mkFileList, unFileList, + castToFileList, gTypeFileList, + Geolocation(Geolocation), GeolocationClass, + toGeolocation, + mkGeolocation, unGeolocation, + castToGeolocation, gTypeGeolocation, + HTMLCollection(HTMLCollection), HTMLCollectionClass, + toHTMLCollection, + mkHTMLCollection, unHTMLCollection, + castToHTMLCollection, gTypeHTMLCollection, + HTMLOptionsCollection(HTMLOptionsCollection), HTMLOptionsCollectionClass, + toHTMLOptionsCollection, + mkHTMLOptionsCollection, unHTMLOptionsCollection, + castToHTMLOptionsCollection, gTypeHTMLOptionsCollection, + History(History), HistoryClass, + toHistory, + mkHistory, unHistory, + castToHistory, gTypeHistory, + Location(Location), LocationClass, + toLocation, + mkLocation, unLocation, + castToLocation, gTypeLocation, + MediaError(MediaError), MediaErrorClass, + toMediaError, + mkMediaError, unMediaError, + castToMediaError, gTypeMediaError, + MediaList(MediaList), MediaListClass, + toMediaList, + mkMediaList, unMediaList, + castToMediaList, gTypeMediaList, + MediaQueryList(MediaQueryList), MediaQueryListClass, + toMediaQueryList, + mkMediaQueryList, unMediaQueryList, + castToMediaQueryList, gTypeMediaQueryList, + MemoryInfo(MemoryInfo), MemoryInfoClass, + toMemoryInfo, + mkMemoryInfo, unMemoryInfo, + castToMemoryInfo, gTypeMemoryInfo, + MessagePort(MessagePort), MessagePortClass, + toMessagePort, + mkMessagePort, unMessagePort, + castToMessagePort, gTypeMessagePort, + NamedNodeMap(NamedNodeMap), NamedNodeMapClass, + toNamedNodeMap, + mkNamedNodeMap, unNamedNodeMap, + castToNamedNodeMap, gTypeNamedNodeMap, + Navigator(Navigator), NavigatorClass, + toNavigator, + mkNavigator, unNavigator, + castToNavigator, gTypeNavigator, + Node(Node), NodeClass, + toNode, + mkNode, unNode, + castToNode, gTypeNode, + DOMAttr(DOMAttr), DOMAttrClass, + toDOMAttr, + mkDOMAttr, unDOMAttr, + castToDOMAttr, gTypeDOMAttr, + CharacterData(CharacterData), CharacterDataClass, + toCharacterData, + mkCharacterData, unCharacterData, + castToCharacterData, gTypeCharacterData, + Comment(Comment), CommentClass, + toComment, + mkComment, unComment, + castToComment, gTypeComment, + Text(Text), TextClass, + toText, + mkText, unText, + castToText, gTypeText, + CDATASection(CDATASection), CDATASectionClass, + toCDATASection, + mkCDATASection, unCDATASection, + castToCDATASection, gTypeCDATASection, + Document(Document), DocumentClass, + toDocument, + mkDocument, unDocument, + castToDocument, gTypeDocument, + HTMLDocument(HTMLDocument), HTMLDocumentClass, + toHTMLDocument, + mkHTMLDocument, unHTMLDocument, + castToHTMLDocument, gTypeHTMLDocument, + DocumentFragment(DocumentFragment), DocumentFragmentClass, + toDocumentFragment, + mkDocumentFragment, unDocumentFragment, + castToDocumentFragment, gTypeDocumentFragment, + DocumentType(DocumentType), DocumentTypeClass, + toDocumentType, + mkDocumentType, unDocumentType, + castToDocumentType, gTypeDocumentType, + Element(Element), ElementClass, + toElement, + mkElement, unElement, + castToElement, gTypeElement, + HTMLElement(HTMLElement), HTMLElementClass, + toHTMLElement, + mkHTMLElement, unHTMLElement, + castToHTMLElement, gTypeHTMLElement, + HTMLAnchorElement(HTMLAnchorElement), HTMLAnchorElementClass, + toHTMLAnchorElement, + mkHTMLAnchorElement, unHTMLAnchorElement, + castToHTMLAnchorElement, gTypeHTMLAnchorElement, + HTMLAppletElement(HTMLAppletElement), HTMLAppletElementClass, + toHTMLAppletElement, + mkHTMLAppletElement, unHTMLAppletElement, + castToHTMLAppletElement, gTypeHTMLAppletElement, + HTMLAreaElement(HTMLAreaElement), HTMLAreaElementClass, + toHTMLAreaElement, + mkHTMLAreaElement, unHTMLAreaElement, + castToHTMLAreaElement, gTypeHTMLAreaElement, + HTMLBRElement(HTMLBRElement), HTMLBRElementClass, + toHTMLBRElement, + mkHTMLBRElement, unHTMLBRElement, + castToHTMLBRElement, gTypeHTMLBRElement, + HTMLBaseElement(HTMLBaseElement), HTMLBaseElementClass, + toHTMLBaseElement, + mkHTMLBaseElement, unHTMLBaseElement, + castToHTMLBaseElement, gTypeHTMLBaseElement, + HTMLBaseFontElement(HTMLBaseFontElement), HTMLBaseFontElementClass, + toHTMLBaseFontElement, + mkHTMLBaseFontElement, unHTMLBaseFontElement, + castToHTMLBaseFontElement, gTypeHTMLBaseFontElement, + HTMLBodyElement(HTMLBodyElement), HTMLBodyElementClass, + toHTMLBodyElement, + mkHTMLBodyElement, unHTMLBodyElement, + castToHTMLBodyElement, gTypeHTMLBodyElement, + HTMLButtonElement(HTMLButtonElement), HTMLButtonElementClass, + toHTMLButtonElement, + mkHTMLButtonElement, unHTMLButtonElement, + castToHTMLButtonElement, gTypeHTMLButtonElement, + HTMLCanvasElement(HTMLCanvasElement), HTMLCanvasElementClass, + toHTMLCanvasElement, + mkHTMLCanvasElement, unHTMLCanvasElement, + castToHTMLCanvasElement, gTypeHTMLCanvasElement, + HTMLDListElement(HTMLDListElement), HTMLDListElementClass, + toHTMLDListElement, + mkHTMLDListElement, unHTMLDListElement, + castToHTMLDListElement, gTypeHTMLDListElement, + HTMLDetailsElement(HTMLDetailsElement), HTMLDetailsElementClass, + toHTMLDetailsElement, + mkHTMLDetailsElement, unHTMLDetailsElement, + castToHTMLDetailsElement, gTypeHTMLDetailsElement, + HTMLDirectoryElement(HTMLDirectoryElement), HTMLDirectoryElementClass, + toHTMLDirectoryElement, + mkHTMLDirectoryElement, unHTMLDirectoryElement, + castToHTMLDirectoryElement, gTypeHTMLDirectoryElement, + HTMLDivElement(HTMLDivElement), HTMLDivElementClass, + toHTMLDivElement, + mkHTMLDivElement, unHTMLDivElement, + castToHTMLDivElement, gTypeHTMLDivElement, + HTMLEmbedElement(HTMLEmbedElement), HTMLEmbedElementClass, + toHTMLEmbedElement, + mkHTMLEmbedElement, unHTMLEmbedElement, + castToHTMLEmbedElement, gTypeHTMLEmbedElement, + HTMLFieldSetElement(HTMLFieldSetElement), HTMLFieldSetElementClass, + toHTMLFieldSetElement, + mkHTMLFieldSetElement, unHTMLFieldSetElement, + castToHTMLFieldSetElement, gTypeHTMLFieldSetElement, + HTMLFontElement(HTMLFontElement), HTMLFontElementClass, + toHTMLFontElement, + mkHTMLFontElement, unHTMLFontElement, + castToHTMLFontElement, gTypeHTMLFontElement, + HTMLFormElement(HTMLFormElement), HTMLFormElementClass, + toHTMLFormElement, + mkHTMLFormElement, unHTMLFormElement, + castToHTMLFormElement, gTypeHTMLFormElement, + HTMLFrameElement(HTMLFrameElement), HTMLFrameElementClass, + toHTMLFrameElement, + mkHTMLFrameElement, unHTMLFrameElement, + castToHTMLFrameElement, gTypeHTMLFrameElement, + HTMLFrameSetElement(HTMLFrameSetElement), HTMLFrameSetElementClass, + toHTMLFrameSetElement, + mkHTMLFrameSetElement, unHTMLFrameSetElement, + castToHTMLFrameSetElement, gTypeHTMLFrameSetElement, + HTMLHRElement(HTMLHRElement), HTMLHRElementClass, + toHTMLHRElement, + mkHTMLHRElement, unHTMLHRElement, + castToHTMLHRElement, gTypeHTMLHRElement, + HTMLHeadElement(HTMLHeadElement), HTMLHeadElementClass, + toHTMLHeadElement, + mkHTMLHeadElement, unHTMLHeadElement, + castToHTMLHeadElement, gTypeHTMLHeadElement, + HTMLHeadingElement(HTMLHeadingElement), HTMLHeadingElementClass, + toHTMLHeadingElement, + mkHTMLHeadingElement, unHTMLHeadingElement, + castToHTMLHeadingElement, gTypeHTMLHeadingElement, + HTMLHtmlElement(HTMLHtmlElement), HTMLHtmlElementClass, + toHTMLHtmlElement, + mkHTMLHtmlElement, unHTMLHtmlElement, + castToHTMLHtmlElement, gTypeHTMLHtmlElement, + HTMLIFrameElement(HTMLIFrameElement), HTMLIFrameElementClass, + toHTMLIFrameElement, + mkHTMLIFrameElement, unHTMLIFrameElement, + castToHTMLIFrameElement, gTypeHTMLIFrameElement, + HTMLImageElement(HTMLImageElement), HTMLImageElementClass, + toHTMLImageElement, + mkHTMLImageElement, unHTMLImageElement, + castToHTMLImageElement, gTypeHTMLImageElement, + HTMLInputElement(HTMLInputElement), HTMLInputElementClass, + toHTMLInputElement, + mkHTMLInputElement, unHTMLInputElement, + castToHTMLInputElement, gTypeHTMLInputElement, + HTMLKeygenElement(HTMLKeygenElement), HTMLKeygenElementClass, + toHTMLKeygenElement, + mkHTMLKeygenElement, unHTMLKeygenElement, + castToHTMLKeygenElement, gTypeHTMLKeygenElement, + HTMLLIElement(HTMLLIElement), HTMLLIElementClass, + toHTMLLIElement, + mkHTMLLIElement, unHTMLLIElement, + castToHTMLLIElement, gTypeHTMLLIElement, + HTMLLabelElement(HTMLLabelElement), HTMLLabelElementClass, + toHTMLLabelElement, + mkHTMLLabelElement, unHTMLLabelElement, + castToHTMLLabelElement, gTypeHTMLLabelElement, + HTMLLegendElement(HTMLLegendElement), HTMLLegendElementClass, + toHTMLLegendElement, + mkHTMLLegendElement, unHTMLLegendElement, + castToHTMLLegendElement, gTypeHTMLLegendElement, + HTMLLinkElement(HTMLLinkElement), HTMLLinkElementClass, + toHTMLLinkElement, + mkHTMLLinkElement, unHTMLLinkElement, + castToHTMLLinkElement, gTypeHTMLLinkElement, + HTMLMapElement(HTMLMapElement), HTMLMapElementClass, + toHTMLMapElement, + mkHTMLMapElement, unHTMLMapElement, + castToHTMLMapElement, gTypeHTMLMapElement, + HTMLMarqueeElement(HTMLMarqueeElement), HTMLMarqueeElementClass, + toHTMLMarqueeElement, + mkHTMLMarqueeElement, unHTMLMarqueeElement, + castToHTMLMarqueeElement, gTypeHTMLMarqueeElement, + HTMLMediaElement(HTMLMediaElement), HTMLMediaElementClass, + toHTMLMediaElement, + mkHTMLMediaElement, unHTMLMediaElement, + castToHTMLMediaElement, gTypeHTMLMediaElement, + HTMLAudioElement(HTMLAudioElement), HTMLAudioElementClass, + toHTMLAudioElement, + mkHTMLAudioElement, unHTMLAudioElement, + castToHTMLAudioElement, gTypeHTMLAudioElement, + HTMLVideoElement(HTMLVideoElement), HTMLVideoElementClass, + toHTMLVideoElement, + mkHTMLVideoElement, unHTMLVideoElement, + castToHTMLVideoElement, gTypeHTMLVideoElement, + HTMLMenuElement(HTMLMenuElement), HTMLMenuElementClass, + toHTMLMenuElement, + mkHTMLMenuElement, unHTMLMenuElement, + castToHTMLMenuElement, gTypeHTMLMenuElement, + HTMLMetaElement(HTMLMetaElement), HTMLMetaElementClass, + toHTMLMetaElement, + mkHTMLMetaElement, unHTMLMetaElement, + castToHTMLMetaElement, gTypeHTMLMetaElement, + HTMLModElement(HTMLModElement), HTMLModElementClass, + toHTMLModElement, + mkHTMLModElement, unHTMLModElement, + castToHTMLModElement, gTypeHTMLModElement, + HTMLOListElement(HTMLOListElement), HTMLOListElementClass, + toHTMLOListElement, + mkHTMLOListElement, unHTMLOListElement, + castToHTMLOListElement, gTypeHTMLOListElement, + HTMLObjectElement(HTMLObjectElement), HTMLObjectElementClass, + toHTMLObjectElement, + mkHTMLObjectElement, unHTMLObjectElement, + castToHTMLObjectElement, gTypeHTMLObjectElement, + HTMLOptGroupElement(HTMLOptGroupElement), HTMLOptGroupElementClass, + toHTMLOptGroupElement, + mkHTMLOptGroupElement, unHTMLOptGroupElement, + castToHTMLOptGroupElement, gTypeHTMLOptGroupElement, + HTMLOptionElement(HTMLOptionElement), HTMLOptionElementClass, + toHTMLOptionElement, + mkHTMLOptionElement, unHTMLOptionElement, + castToHTMLOptionElement, gTypeHTMLOptionElement, + HTMLParagraphElement(HTMLParagraphElement), HTMLParagraphElementClass, + toHTMLParagraphElement, + mkHTMLParagraphElement, unHTMLParagraphElement, + castToHTMLParagraphElement, gTypeHTMLParagraphElement, + HTMLParamElement(HTMLParamElement), HTMLParamElementClass, + toHTMLParamElement, + mkHTMLParamElement, unHTMLParamElement, + castToHTMLParamElement, gTypeHTMLParamElement, + HTMLPreElement(HTMLPreElement), HTMLPreElementClass, + toHTMLPreElement, + mkHTMLPreElement, unHTMLPreElement, + castToHTMLPreElement, gTypeHTMLPreElement, + HTMLQuoteElement(HTMLQuoteElement), HTMLQuoteElementClass, + toHTMLQuoteElement, + mkHTMLQuoteElement, unHTMLQuoteElement, + castToHTMLQuoteElement, gTypeHTMLQuoteElement, + HTMLScriptElement(HTMLScriptElement), HTMLScriptElementClass, + toHTMLScriptElement, + mkHTMLScriptElement, unHTMLScriptElement, + castToHTMLScriptElement, gTypeHTMLScriptElement, + HTMLSelectElement(HTMLSelectElement), HTMLSelectElementClass, + toHTMLSelectElement, + mkHTMLSelectElement, unHTMLSelectElement, + castToHTMLSelectElement, gTypeHTMLSelectElement, + HTMLStyleElement(HTMLStyleElement), HTMLStyleElementClass, + toHTMLStyleElement, + mkHTMLStyleElement, unHTMLStyleElement, + castToHTMLStyleElement, gTypeHTMLStyleElement, + HTMLTableCaptionElement(HTMLTableCaptionElement), HTMLTableCaptionElementClass, + toHTMLTableCaptionElement, + mkHTMLTableCaptionElement, unHTMLTableCaptionElement, + castToHTMLTableCaptionElement, gTypeHTMLTableCaptionElement, + HTMLTableCellElement(HTMLTableCellElement), HTMLTableCellElementClass, + toHTMLTableCellElement, + mkHTMLTableCellElement, unHTMLTableCellElement, + castToHTMLTableCellElement, gTypeHTMLTableCellElement, + HTMLTableColElement(HTMLTableColElement), HTMLTableColElementClass, + toHTMLTableColElement, + mkHTMLTableColElement, unHTMLTableColElement, + castToHTMLTableColElement, gTypeHTMLTableColElement, + HTMLTableElement(HTMLTableElement), HTMLTableElementClass, + toHTMLTableElement, + mkHTMLTableElement, unHTMLTableElement, + castToHTMLTableElement, gTypeHTMLTableElement, + HTMLTableRowElement(HTMLTableRowElement), HTMLTableRowElementClass, + toHTMLTableRowElement, + mkHTMLTableRowElement, unHTMLTableRowElement, + castToHTMLTableRowElement, gTypeHTMLTableRowElement, + HTMLTableSectionElement(HTMLTableSectionElement), HTMLTableSectionElementClass, + toHTMLTableSectionElement, + mkHTMLTableSectionElement, unHTMLTableSectionElement, + castToHTMLTableSectionElement, gTypeHTMLTableSectionElement, + HTMLTextAreaElement(HTMLTextAreaElement), HTMLTextAreaElementClass, + toHTMLTextAreaElement, + mkHTMLTextAreaElement, unHTMLTextAreaElement, + castToHTMLTextAreaElement, gTypeHTMLTextAreaElement, + HTMLTitleElement(HTMLTitleElement), HTMLTitleElementClass, + toHTMLTitleElement, + mkHTMLTitleElement, unHTMLTitleElement, + castToHTMLTitleElement, gTypeHTMLTitleElement, + HTMLUListElement(HTMLUListElement), HTMLUListElementClass, + toHTMLUListElement, + mkHTMLUListElement, unHTMLUListElement, + castToHTMLUListElement, gTypeHTMLUListElement, + EntityReference(EntityReference), EntityReferenceClass, + toEntityReference, + mkEntityReference, unEntityReference, + castToEntityReference, gTypeEntityReference, + ProcessingInstruction(ProcessingInstruction), ProcessingInstructionClass, + toProcessingInstruction, + mkProcessingInstruction, unProcessingInstruction, + castToProcessingInstruction, gTypeProcessingInstruction, + NodeFilter(NodeFilter), NodeFilterClass, + toNodeFilter, + mkNodeFilter, unNodeFilter, + castToNodeFilter, gTypeNodeFilter, + NodeIterator(NodeIterator), NodeIteratorClass, + toNodeIterator, + mkNodeIterator, unNodeIterator, + castToNodeIterator, gTypeNodeIterator, + NodeList(NodeList), NodeListClass, + toNodeList, + mkNodeList, unNodeList, + castToNodeList, gTypeNodeList, + DOMRange(DOMRange), DOMRangeClass, + toDOMRange, + mkDOMRange, unDOMRange, + castToDOMRange, gTypeDOMRange, + DOMScreen(DOMScreen), DOMScreenClass, + toDOMScreen, + mkDOMScreen, unDOMScreen, + castToDOMScreen, gTypeDOMScreen, + Storage(Storage), StorageClass, + toStorage, + mkStorage, unStorage, + castToStorage, gTypeStorage, + StorageInfo(StorageInfo), StorageInfoClass, + toStorageInfo, + mkStorageInfo, unStorageInfo, + castToStorageInfo, gTypeStorageInfo, + StyleMedia(StyleMedia), StyleMediaClass, + toStyleMedia, + mkStyleMedia, unStyleMedia, + castToStyleMedia, gTypeStyleMedia, + StyleSheet(StyleSheet), StyleSheetClass, + toStyleSheet, + mkStyleSheet, unStyleSheet, + castToStyleSheet, gTypeStyleSheet, + CSSStyleSheet(CSSStyleSheet), CSSStyleSheetClass, + toCSSStyleSheet, + mkCSSStyleSheet, unCSSStyleSheet, + castToCSSStyleSheet, gTypeCSSStyleSheet, + StyleSheetList(StyleSheetList), StyleSheetListClass, + toStyleSheetList, + mkStyleSheetList, unStyleSheetList, + castToStyleSheetList, gTypeStyleSheetList, + TimeRanges(TimeRanges), TimeRangesClass, + toTimeRanges, + mkTimeRanges, unTimeRanges, + castToTimeRanges, gTypeTimeRanges, + TreeWalker(TreeWalker), TreeWalkerClass, + toTreeWalker, + mkTreeWalker, unTreeWalker, + castToTreeWalker, gTypeTreeWalker, + ValidityState(ValidityState), ValidityStateClass, + toValidityState, + mkValidityState, unValidityState, + castToValidityState, gTypeValidityState, + WebKitNamedFlow(WebKitNamedFlow), WebKitNamedFlowClass, + toWebKitNamedFlow, + mkWebKitNamedFlow, unWebKitNamedFlow, + castToWebKitNamedFlow, gTypeWebKitNamedFlow, + WebKitPoint(WebKitPoint), WebKitPointClass, + toWebKitPoint, + mkWebKitPoint, unWebKitPoint, + castToWebKitPoint, gTypeWebKitPoint, + XPathExpression(XPathExpression), XPathExpressionClass, + toXPathExpression, + mkXPathExpression, unXPathExpression, + castToXPathExpression, gTypeXPathExpression, + XPathNSResolver(XPathNSResolver), XPathNSResolverClass, + toXPathNSResolver, + mkXPathNSResolver, unXPathNSResolver, + castToXPathNSResolver, gTypeXPathNSResolver, + XPathResult(XPathResult), XPathResultClass, + toXPathResult, + mkXPathResult, unXPathResult, + castToXPathResult, gTypeXPathResult + ) where + +import Foreign.ForeignPtr (ForeignPtr, castForeignPtr) +#if __GLASGOW_HASKELL__ >= 707 +import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr) +#else +import Foreign.ForeignPtr (unsafeForeignPtrToPtr) +#endif +import Foreign.C.Types (CULong(..), CUInt(..)) +import System.Glib.GType (GType, typeInstanceIsA) +{#import Graphics.UI.GtkInternals#} + +{# context lib="gtk" prefix="gtk" #} + +-- The usage of foreignPtrToPtr should be safe as the evaluation will only be +-- forced if the object is used afterwards +-- +castTo :: (GObjectClass obj, GObjectClass obj') => GType -> String + -> (obj -> obj') +castTo gtype objTypeName obj = + case toGObject obj of + gobj@(GObject objFPtr) + | typeInstanceIsA ((unsafeForeignPtrToPtr.castForeignPtr) objFPtr) gtype + -> unsafeCastGObject gobj + | otherwise -> error $ "Cannot cast object to " ++ objTypeName + + +-- ******************************************************************** WebView + +{#pointer *WebKitWebView as WebView foreign newtype #} deriving (Eq,Ord) + +mkWebView = (WebView, objectUnrefFromMainloop) +unWebView (WebView o) = o + +class ContainerClass o => WebViewClass o +toWebView :: WebViewClass o => o -> WebView +toWebView = unsafeCastGObject . toGObject + +instance WebViewClass WebView +instance ContainerClass WebView +instance WidgetClass WebView +instance GObjectClass WebView where + toGObject = GObject . castForeignPtr . unWebView + unsafeCastGObject = WebView . castForeignPtr . unGObject + +castToWebView :: GObjectClass obj => obj -> WebView +castToWebView = castTo gTypeWebView "WebView" + +gTypeWebView :: GType +gTypeWebView = + {# call fun unsafe webkit_web_view_get_type #} + +-- ******************************************************************* WebFrame + +{#pointer *WebKitWebFrame as WebFrame foreign newtype #} deriving (Eq,Ord) + +mkWebFrame = (WebFrame, objectUnrefFromMainloop) +unWebFrame (WebFrame o) = o + +class GObjectClass o => WebFrameClass o +toWebFrame :: WebFrameClass o => o -> WebFrame +toWebFrame = unsafeCastGObject . toGObject + +instance WebFrameClass WebFrame +instance GObjectClass WebFrame where + toGObject = GObject . castForeignPtr . unWebFrame + unsafeCastGObject = WebFrame . castForeignPtr . unGObject + +castToWebFrame :: GObjectClass obj => obj -> WebFrame +castToWebFrame = castTo gTypeWebFrame "WebFrame" + +gTypeWebFrame :: GType +gTypeWebFrame = + {# call fun unsafe webkit_web_frame_get_type #} + +-- **************************************************************** WebSettings + +{#pointer *WebKitWebSettings as WebSettings foreign newtype #} deriving (Eq,Ord) + +mkWebSettings = (WebSettings, objectUnrefFromMainloop) +unWebSettings (WebSettings o) = o + +class GObjectClass o => WebSettingsClass o +toWebSettings :: WebSettingsClass o => o -> WebSettings +toWebSettings = unsafeCastGObject . toGObject + +instance WebSettingsClass WebSettings +instance GObjectClass WebSettings where + toGObject = GObject . castForeignPtr . unWebSettings + unsafeCastGObject = WebSettings . castForeignPtr . unGObject + +castToWebSettings :: GObjectClass obj => obj -> WebSettings +castToWebSettings = castTo gTypeWebSettings "WebSettings" + +gTypeWebSettings :: GType +gTypeWebSettings = + {# call fun unsafe webkit_web_settings_get_type #} + +-- ************************************************************* NetworkRequest + +{#pointer *WebKitNetworkRequest as NetworkRequest foreign newtype #} deriving (Eq,Ord) + +mkNetworkRequest = (NetworkRequest, objectUnrefFromMainloop) +unNetworkRequest (NetworkRequest o) = o + +class GObjectClass o => NetworkRequestClass o +toNetworkRequest :: NetworkRequestClass o => o -> NetworkRequest +toNetworkRequest = unsafeCastGObject . toGObject + +instance NetworkRequestClass NetworkRequest +instance GObjectClass NetworkRequest where + toGObject = GObject . castForeignPtr . unNetworkRequest + unsafeCastGObject = NetworkRequest . castForeignPtr . unGObject + +castToNetworkRequest :: GObjectClass obj => obj -> NetworkRequest +castToNetworkRequest = castTo gTypeNetworkRequest "NetworkRequest" + +gTypeNetworkRequest :: GType +gTypeNetworkRequest = + {# call fun unsafe webkit_network_request_get_type #} + +-- ************************************************************ NetworkResponse + +{#pointer *WebKitNetworkResponse as NetworkResponse foreign newtype #} deriving (Eq,Ord) + +mkNetworkResponse = (NetworkResponse, objectUnrefFromMainloop) +unNetworkResponse (NetworkResponse o) = o + +class GObjectClass o => NetworkResponseClass o +toNetworkResponse :: NetworkResponseClass o => o -> NetworkResponse +toNetworkResponse = unsafeCastGObject . toGObject + +instance NetworkResponseClass NetworkResponse +instance GObjectClass NetworkResponse where + toGObject = GObject . castForeignPtr . unNetworkResponse + unsafeCastGObject = NetworkResponse . castForeignPtr . unGObject + +castToNetworkResponse :: GObjectClass obj => obj -> NetworkResponse +castToNetworkResponse = castTo gTypeNetworkResponse "NetworkResponse" + +gTypeNetworkResponse :: GType +gTypeNetworkResponse = + {# call fun unsafe webkit_network_response_get_type #} + +-- ******************************************************************* Download + +{#pointer *WebKitDownload as Download foreign newtype #} deriving (Eq,Ord) + +mkDownload = (Download, objectUnrefFromMainloop) +unDownload (Download o) = o + +class GObjectClass o => DownloadClass o +toDownload :: DownloadClass o => o -> Download +toDownload = unsafeCastGObject . toGObject + +instance DownloadClass Download +instance GObjectClass Download where + toGObject = GObject . castForeignPtr . unDownload + unsafeCastGObject = Download . castForeignPtr . unGObject + +castToDownload :: GObjectClass obj => obj -> Download +castToDownload = castTo gTypeDownload "Download" + +gTypeDownload :: GType +gTypeDownload = + {# call fun unsafe webkit_download_get_type #} + +-- ********************************************************* WebBackForwardList + +{#pointer *WebKitWebBackForwardList as WebBackForwardList foreign newtype #} deriving (Eq,Ord) + +mkWebBackForwardList = (WebBackForwardList, objectUnrefFromMainloop) +unWebBackForwardList (WebBackForwardList o) = o + +class GObjectClass o => WebBackForwardListClass o +toWebBackForwardList :: WebBackForwardListClass o => o -> WebBackForwardList +toWebBackForwardList = unsafeCastGObject . toGObject + +instance WebBackForwardListClass WebBackForwardList +instance GObjectClass WebBackForwardList where + toGObject = GObject . castForeignPtr . unWebBackForwardList + unsafeCastGObject = WebBackForwardList . castForeignPtr . unGObject + +castToWebBackForwardList :: GObjectClass obj => obj -> WebBackForwardList +castToWebBackForwardList = castTo gTypeWebBackForwardList "WebBackForwardList" + +gTypeWebBackForwardList :: GType +gTypeWebBackForwardList = + {# call fun unsafe webkit_web_back_forward_list_get_type #} + +-- ************************************************************* WebHistoryItem + +{#pointer *WebKitWebHistoryItem as WebHistoryItem foreign newtype #} deriving (Eq,Ord) + +mkWebHistoryItem = (WebHistoryItem, objectUnrefFromMainloop) +unWebHistoryItem (WebHistoryItem o) = o + +class GObjectClass o => WebHistoryItemClass o +toWebHistoryItem :: WebHistoryItemClass o => o -> WebHistoryItem +toWebHistoryItem = unsafeCastGObject . toGObject + +instance WebHistoryItemClass WebHistoryItem +instance GObjectClass WebHistoryItem where + toGObject = GObject . castForeignPtr . unWebHistoryItem + unsafeCastGObject = WebHistoryItem . castForeignPtr . unGObject + +castToWebHistoryItem :: GObjectClass obj => obj -> WebHistoryItem +castToWebHistoryItem = castTo gTypeWebHistoryItem "WebHistoryItem" + +gTypeWebHistoryItem :: GType +gTypeWebHistoryItem = + {# call fun unsafe webkit_web_history_item_get_type #} + +-- *************************************************************** WebInspector + +{#pointer *WebKitWebInspector as WebInspector foreign newtype #} deriving (Eq,Ord) + +mkWebInspector = (WebInspector, objectUnrefFromMainloop) +unWebInspector (WebInspector o) = o + +class GObjectClass o => WebInspectorClass o +toWebInspector :: WebInspectorClass o => o -> WebInspector +toWebInspector = unsafeCastGObject . toGObject + +instance WebInspectorClass WebInspector +instance GObjectClass WebInspector where + toGObject = GObject . castForeignPtr . unWebInspector + unsafeCastGObject = WebInspector . castForeignPtr . unGObject + +castToWebInspector :: GObjectClass obj => obj -> WebInspector +castToWebInspector = castTo gTypeWebInspector "WebInspector" + +gTypeWebInspector :: GType +gTypeWebInspector = + {# call fun unsafe webkit_web_inspector_get_type #} + +-- ************************************************************** HitTestResult + +{#pointer *WebKitHitTestResult as HitTestResult foreign newtype #} deriving (Eq,Ord) + +mkHitTestResult = (HitTestResult, objectUnrefFromMainloop) +unHitTestResult (HitTestResult o) = o + +class GObjectClass o => HitTestResultClass o +toHitTestResult :: HitTestResultClass o => o -> HitTestResult +toHitTestResult = unsafeCastGObject . toGObject + +instance HitTestResultClass HitTestResult +instance GObjectClass HitTestResult where + toGObject = GObject . castForeignPtr . unHitTestResult + unsafeCastGObject = HitTestResult . castForeignPtr . unGObject + +castToHitTestResult :: GObjectClass obj => obj -> HitTestResult +castToHitTestResult = castTo gTypeHitTestResult "HitTestResult" + +gTypeHitTestResult :: GType +gTypeHitTestResult = + {# call fun unsafe webkit_hit_test_result_get_type #} + +-- ************************************************************* SecurityOrigin + +{#pointer *WebKitSecurityOrigin as SecurityOrigin foreign newtype #} deriving (Eq,Ord) + +mkSecurityOrigin = (SecurityOrigin, objectUnrefFromMainloop) +unSecurityOrigin (SecurityOrigin o) = o + +class GObjectClass o => SecurityOriginClass o +toSecurityOrigin :: SecurityOriginClass o => o -> SecurityOrigin +toSecurityOrigin = unsafeCastGObject . toGObject + +instance SecurityOriginClass SecurityOrigin +instance GObjectClass SecurityOrigin where + toGObject = GObject . castForeignPtr . unSecurityOrigin + unsafeCastGObject = SecurityOrigin . castForeignPtr . unGObject + +castToSecurityOrigin :: GObjectClass obj => obj -> SecurityOrigin +castToSecurityOrigin = castTo gTypeSecurityOrigin "SecurityOrigin" + +gTypeSecurityOrigin :: GType +gTypeSecurityOrigin = + {# call fun unsafe webkit_security_origin_get_type #} + +-- ************************************************************* SoupAuthDialog + +{#pointer *WebKitSoupAuthDialog as SoupAuthDialog foreign newtype #} deriving (Eq,Ord) + +mkSoupAuthDialog = (SoupAuthDialog, objectUnrefFromMainloop) +unSoupAuthDialog (SoupAuthDialog o) = o + +class GObjectClass o => SoupAuthDialogClass o +toSoupAuthDialog :: SoupAuthDialogClass o => o -> SoupAuthDialog +toSoupAuthDialog = unsafeCastGObject . toGObject + +instance SoupAuthDialogClass SoupAuthDialog +instance GObjectClass SoupAuthDialog where + toGObject = GObject . castForeignPtr . unSoupAuthDialog + unsafeCastGObject = SoupAuthDialog . castForeignPtr . unGObject + +castToSoupAuthDialog :: GObjectClass obj => obj -> SoupAuthDialog +castToSoupAuthDialog = castTo gTypeSoupAuthDialog "SoupAuthDialog" + +gTypeSoupAuthDialog :: GType +gTypeSoupAuthDialog = + {# call fun unsafe webkit_soup_auth_dialog_get_type #} + +-- **************************************************************** WebDatabase + +{#pointer *WebKitWebDatabase as WebDatabase foreign newtype #} deriving (Eq,Ord) + +mkWebDatabase = (WebDatabase, objectUnrefFromMainloop) +unWebDatabase (WebDatabase o) = o + +class GObjectClass o => WebDatabaseClass o +toWebDatabase :: WebDatabaseClass o => o -> WebDatabase +toWebDatabase = unsafeCastGObject . toGObject + +instance WebDatabaseClass WebDatabase +instance GObjectClass WebDatabase where + toGObject = GObject . castForeignPtr . unWebDatabase + unsafeCastGObject = WebDatabase . castForeignPtr . unGObject + +castToWebDatabase :: GObjectClass obj => obj -> WebDatabase +castToWebDatabase = castTo gTypeWebDatabase "WebDatabase" + +gTypeWebDatabase :: GType +gTypeWebDatabase = + {# call fun unsafe webkit_web_database_get_type #} + +-- ************************************************************** WebDataSource + +{#pointer *WebKitWebDataSource as WebDataSource foreign newtype #} deriving (Eq,Ord) + +mkWebDataSource = (WebDataSource, objectUnrefFromMainloop) +unWebDataSource (WebDataSource o) = o + +class GObjectClass o => WebDataSourceClass o +toWebDataSource :: WebDataSourceClass o => o -> WebDataSource +toWebDataSource = unsafeCastGObject . toGObject + +instance WebDataSourceClass WebDataSource +instance GObjectClass WebDataSource where + toGObject = GObject . castForeignPtr . unWebDataSource + unsafeCastGObject = WebDataSource . castForeignPtr . unGObject + +castToWebDataSource :: GObjectClass obj => obj -> WebDataSource +castToWebDataSource = castTo gTypeWebDataSource "WebDataSource" + +gTypeWebDataSource :: GType +gTypeWebDataSource = + {# call fun unsafe webkit_web_data_source_get_type #} + +-- ******************************************************** WebNavigationAction + +{#pointer *WebKitWebNavigationAction as WebNavigationAction foreign newtype #} deriving (Eq,Ord) + +mkWebNavigationAction = (WebNavigationAction, objectUnrefFromMainloop) +unWebNavigationAction (WebNavigationAction o) = o + +class GObjectClass o => WebNavigationActionClass o +toWebNavigationAction :: WebNavigationActionClass o => o -> WebNavigationAction +toWebNavigationAction = unsafeCastGObject . toGObject + +instance WebNavigationActionClass WebNavigationAction +instance GObjectClass WebNavigationAction where + toGObject = GObject . castForeignPtr . unWebNavigationAction + unsafeCastGObject = WebNavigationAction . castForeignPtr . unGObject + +castToWebNavigationAction :: GObjectClass obj => obj -> WebNavigationAction +castToWebNavigationAction = castTo gTypeWebNavigationAction "WebNavigationAction" + +gTypeWebNavigationAction :: GType +gTypeWebNavigationAction = + {# call fun unsafe webkit_web_navigation_action_get_type #} + +-- ********************************************************** WebPolicyDecision + +{#pointer *WebKitWebPolicyDecision as WebPolicyDecision foreign newtype #} deriving (Eq,Ord) + +mkWebPolicyDecision = (WebPolicyDecision, objectUnrefFromMainloop) +unWebPolicyDecision (WebPolicyDecision o) = o + +class GObjectClass o => WebPolicyDecisionClass o +toWebPolicyDecision :: WebPolicyDecisionClass o => o -> WebPolicyDecision +toWebPolicyDecision = unsafeCastGObject . toGObject + +instance WebPolicyDecisionClass WebPolicyDecision +instance GObjectClass WebPolicyDecision where + toGObject = GObject . castForeignPtr . unWebPolicyDecision + unsafeCastGObject = WebPolicyDecision . castForeignPtr . unGObject + +castToWebPolicyDecision :: GObjectClass obj => obj -> WebPolicyDecision +castToWebPolicyDecision = castTo gTypeWebPolicyDecision "WebPolicyDecision" + +gTypeWebPolicyDecision :: GType +gTypeWebPolicyDecision = + {# call fun unsafe webkit_web_policy_decision_get_type #} + +-- **************************************************************** WebResource + +{#pointer *WebKitWebResource as WebResource foreign newtype #} deriving (Eq,Ord) + +mkWebResource = (WebResource, objectUnrefFromMainloop) +unWebResource (WebResource o) = o + +class GObjectClass o => WebResourceClass o +toWebResource :: WebResourceClass o => o -> WebResource +toWebResource = unsafeCastGObject . toGObject + +instance WebResourceClass WebResource +instance GObjectClass WebResource where + toGObject = GObject . castForeignPtr . unWebResource + unsafeCastGObject = WebResource . castForeignPtr . unGObject + +castToWebResource :: GObjectClass obj => obj -> WebResource +castToWebResource = castTo gTypeWebResource "WebResource" + +gTypeWebResource :: GType +gTypeWebResource = + {# call fun unsafe webkit_web_resource_get_type #} + +-- ********************************************************** WebWindowFeatures + +{#pointer *WebKitWebWindowFeatures as WebWindowFeatures foreign newtype #} deriving (Eq,Ord) + +mkWebWindowFeatures = (WebWindowFeatures, objectUnrefFromMainloop) +unWebWindowFeatures (WebWindowFeatures o) = o + +class GObjectClass o => WebWindowFeaturesClass o +toWebWindowFeatures :: WebWindowFeaturesClass o => o -> WebWindowFeatures +toWebWindowFeatures = unsafeCastGObject . toGObject + +instance WebWindowFeaturesClass WebWindowFeatures +instance GObjectClass WebWindowFeatures where + toGObject = GObject . castForeignPtr . unWebWindowFeatures + unsafeCastGObject = WebWindowFeatures . castForeignPtr . unGObject + +castToWebWindowFeatures :: GObjectClass obj => obj -> WebWindowFeatures +castToWebWindowFeatures = castTo gTypeWebWindowFeatures "WebWindowFeatures" + +gTypeWebWindowFeatures :: GType +gTypeWebWindowFeatures = + {# call fun unsafe webkit_web_window_features_get_type #} + +-- ************************************************** GeolocationPolicyDecision + +{#pointer *WebKitGeolocationPolicyDecision as GeolocationPolicyDecision foreign newtype #} deriving (Eq,Ord) + +mkGeolocationPolicyDecision = (GeolocationPolicyDecision, objectUnrefFromMainloop) +unGeolocationPolicyDecision (GeolocationPolicyDecision o) = o + +class GObjectClass o => GeolocationPolicyDecisionClass o +toGeolocationPolicyDecision :: GeolocationPolicyDecisionClass o => o -> GeolocationPolicyDecision +toGeolocationPolicyDecision = unsafeCastGObject . toGObject + +instance GeolocationPolicyDecisionClass GeolocationPolicyDecision +instance GObjectClass GeolocationPolicyDecision where + toGObject = GObject . castForeignPtr . unGeolocationPolicyDecision + unsafeCastGObject = GeolocationPolicyDecision . castForeignPtr . unGObject + +castToGeolocationPolicyDecision :: GObjectClass obj => obj -> GeolocationPolicyDecision +castToGeolocationPolicyDecision = castTo gTypeGeolocationPolicyDecision "GeolocationPolicyDecision" + +gTypeGeolocationPolicyDecision :: GType +gTypeGeolocationPolicyDecision = + {# call fun unsafe webkit_geolocation_policy_decision_get_type #} + +-- ******************************************************************** BarInfo + +{#pointer *WebKitDOMBarInfo as BarInfo foreign newtype #} deriving (Eq,Ord) + +mkBarInfo = (BarInfo, objectUnrefFromMainloop) +unBarInfo (BarInfo o) = o + +class GObjectClass o => BarInfoClass o +toBarInfo :: BarInfoClass o => o -> BarInfo +toBarInfo = unsafeCastGObject . toGObject + +instance BarInfoClass BarInfo +instance GObjectClass BarInfo where + toGObject = GObject . castForeignPtr . unBarInfo + unsafeCastGObject = BarInfo . castForeignPtr . unGObject + +castToBarInfo :: GObjectClass obj => obj -> BarInfo +castToBarInfo = castTo gTypeBarInfo "BarInfo" + +gTypeBarInfo :: GType +gTypeBarInfo = + {# call fun unsafe webkit_dom_bar_info_get_type #} + +-- *********************************************************************** Blob + +{#pointer *WebKitDOMBlob as Blob foreign newtype #} deriving (Eq,Ord) + +mkBlob = (Blob, objectUnrefFromMainloop) +unBlob (Blob o) = o + +class GObjectClass o => BlobClass o +toBlob :: BlobClass o => o -> Blob +toBlob = unsafeCastGObject . toGObject + +instance BlobClass Blob +instance GObjectClass Blob where + toGObject = GObject . castForeignPtr . unBlob + unsafeCastGObject = Blob . castForeignPtr . unGObject + +castToBlob :: GObjectClass obj => obj -> Blob +castToBlob = castTo gTypeBlob "Blob" + +gTypeBlob :: GType +gTypeBlob = + {# call fun unsafe webkit_dom_blob_get_type #} + +-- *********************************************************************** File + +{#pointer *WebKitDOMFile as File foreign newtype #} deriving (Eq,Ord) + +mkFile = (File, objectUnrefFromMainloop) +unFile (File o) = o + +class BlobClass o => FileClass o +toFile :: FileClass o => o -> File +toFile = unsafeCastGObject . toGObject + +instance FileClass File +instance BlobClass File +instance GObjectClass File where + toGObject = GObject . castForeignPtr . unFile + unsafeCastGObject = File . castForeignPtr . unGObject + +castToFile :: GObjectClass obj => obj -> File +castToFile = castTo gTypeFile "File" + +gTypeFile :: GType +gTypeFile = + {# call fun unsafe webkit_dom_file_get_type #} + +-- ******************************************************************** CSSRule + +{#pointer *WebKitDOMCSSRule as CSSRule foreign newtype #} deriving (Eq,Ord) + +mkCSSRule = (CSSRule, objectUnrefFromMainloop) +unCSSRule (CSSRule o) = o + +class GObjectClass o => CSSRuleClass o +toCSSRule :: CSSRuleClass o => o -> CSSRule +toCSSRule = unsafeCastGObject . toGObject + +instance CSSRuleClass CSSRule +instance GObjectClass CSSRule where + toGObject = GObject . castForeignPtr . unCSSRule + unsafeCastGObject = CSSRule . castForeignPtr . unGObject + +castToCSSRule :: GObjectClass obj => obj -> CSSRule +castToCSSRule = castTo gTypeCSSRule "CSSRule" + +gTypeCSSRule :: GType +gTypeCSSRule = + {# call fun unsafe webkit_dom_css_rule_get_type #} + +-- **************************************************************** CSSRuleList + +{#pointer *WebKitDOMCSSRuleList as CSSRuleList foreign newtype #} deriving (Eq,Ord) + +mkCSSRuleList = (CSSRuleList, objectUnrefFromMainloop) +unCSSRuleList (CSSRuleList o) = o + +class GObjectClass o => CSSRuleListClass o +toCSSRuleList :: CSSRuleListClass o => o -> CSSRuleList +toCSSRuleList = unsafeCastGObject . toGObject + +instance CSSRuleListClass CSSRuleList +instance GObjectClass CSSRuleList where + toGObject = GObject . castForeignPtr . unCSSRuleList + unsafeCastGObject = CSSRuleList . castForeignPtr . unGObject + +castToCSSRuleList :: GObjectClass obj => obj -> CSSRuleList +castToCSSRuleList = castTo gTypeCSSRuleList "CSSRuleList" + +gTypeCSSRuleList :: GType +gTypeCSSRuleList = + {# call fun unsafe webkit_dom_css_rule_list_get_type #} + +-- ******************************************************** CSSStyleDeclaration + +{#pointer *WebKitDOMCSSStyleDeclaration as CSSStyleDeclaration foreign newtype #} deriving (Eq,Ord) + +mkCSSStyleDeclaration = (CSSStyleDeclaration, objectUnrefFromMainloop) +unCSSStyleDeclaration (CSSStyleDeclaration o) = o + +class GObjectClass o => CSSStyleDeclarationClass o +toCSSStyleDeclaration :: CSSStyleDeclarationClass o => o -> CSSStyleDeclaration +toCSSStyleDeclaration = unsafeCastGObject . toGObject + +instance CSSStyleDeclarationClass CSSStyleDeclaration +instance GObjectClass CSSStyleDeclaration where + toGObject = GObject . castForeignPtr . unCSSStyleDeclaration + unsafeCastGObject = CSSStyleDeclaration . castForeignPtr . unGObject + +castToCSSStyleDeclaration :: GObjectClass obj => obj -> CSSStyleDeclaration +castToCSSStyleDeclaration = castTo gTypeCSSStyleDeclaration "CSSStyleDeclaration" + +gTypeCSSStyleDeclaration :: GType +gTypeCSSStyleDeclaration = + {# call fun unsafe webkit_dom_css_style_declaration_get_type #} + +-- ******************************************************************* CSSValue + +{#pointer *WebKitDOMCSSValue as CSSValue foreign newtype #} deriving (Eq,Ord) + +mkCSSValue = (CSSValue, objectUnrefFromMainloop) +unCSSValue (CSSValue o) = o + +class GObjectClass o => CSSValueClass o +toCSSValue :: CSSValueClass o => o -> CSSValue +toCSSValue = unsafeCastGObject . toGObject + +instance CSSValueClass CSSValue +instance GObjectClass CSSValue where + toGObject = GObject . castForeignPtr . unCSSValue + unsafeCastGObject = CSSValue . castForeignPtr . unGObject + +castToCSSValue :: GObjectClass obj => obj -> CSSValue +castToCSSValue = castTo gTypeCSSValue "CSSValue" + +gTypeCSSValue :: GType +gTypeCSSValue = + {# call fun unsafe webkit_dom_css_value_get_type #} + +-- ******************************************************************** Console + +{#pointer *WebKitDOMConsole as Console foreign newtype #} deriving (Eq,Ord) + +mkConsole = (Console, objectUnrefFromMainloop) +unConsole (Console o) = o + +class GObjectClass o => ConsoleClass o +toConsole :: ConsoleClass o => o -> Console +toConsole = unsafeCastGObject . toGObject + +instance ConsoleClass Console +instance GObjectClass Console where + toGObject = GObject . castForeignPtr . unConsole + unsafeCastGObject = Console . castForeignPtr . unGObject + +castToConsole :: GObjectClass obj => obj -> Console +castToConsole = castTo gTypeConsole "Console" + +gTypeConsole :: GType +gTypeConsole = + {# call fun unsafe webkit_dom_console_get_type #} + +-- ******************************************************** DOMApplicationCache + +{#pointer *WebKitDOMDOMApplicationCache as DOMApplicationCache foreign newtype #} deriving (Eq,Ord) + +mkDOMApplicationCache = (DOMApplicationCache, objectUnrefFromMainloop) +unDOMApplicationCache (DOMApplicationCache o) = o + +class GObjectClass o => DOMApplicationCacheClass o +toDOMApplicationCache :: DOMApplicationCacheClass o => o -> DOMApplicationCache +toDOMApplicationCache = unsafeCastGObject . toGObject + +instance DOMApplicationCacheClass DOMApplicationCache +instance GObjectClass DOMApplicationCache where + toGObject = GObject . castForeignPtr . unDOMApplicationCache + unsafeCastGObject = DOMApplicationCache . castForeignPtr . unGObject + +castToDOMApplicationCache :: GObjectClass obj => obj -> DOMApplicationCache +castToDOMApplicationCache = castTo gTypeDOMApplicationCache "DOMApplicationCache" + +gTypeDOMApplicationCache :: GType +gTypeDOMApplicationCache = + {# call fun unsafe webkit_dom_dom_application_cache_get_type #} + +-- ********************************************************** DOMImplementation + +{#pointer *WebKitDOMDOMImplementation as DOMImplementation foreign newtype #} deriving (Eq,Ord) + +mkDOMImplementation = (DOMImplementation, objectUnrefFromMainloop) +unDOMImplementation (DOMImplementation o) = o + +class GObjectClass o => DOMImplementationClass o +toDOMImplementation :: DOMImplementationClass o => o -> DOMImplementation +toDOMImplementation = unsafeCastGObject . toGObject + +instance DOMImplementationClass DOMImplementation +instance GObjectClass DOMImplementation where + toGObject = GObject . castForeignPtr . unDOMImplementation + unsafeCastGObject = DOMImplementation . castForeignPtr . unGObject + +castToDOMImplementation :: GObjectClass obj => obj -> DOMImplementation +castToDOMImplementation = castTo gTypeDOMImplementation "DOMImplementation" + +gTypeDOMImplementation :: GType +gTypeDOMImplementation = + {# call fun unsafe webkit_dom_dom_implementation_get_type #} + +-- **************************************************************** DOMMimeType + +{#pointer *WebKitDOMDOMMimeType as DOMMimeType foreign newtype #} deriving (Eq,Ord) + +mkDOMMimeType = (DOMMimeType, objectUnrefFromMainloop) +unDOMMimeType (DOMMimeType o) = o + +class GObjectClass o => DOMMimeTypeClass o +toDOMMimeType :: DOMMimeTypeClass o => o -> DOMMimeType +toDOMMimeType = unsafeCastGObject . toGObject + +instance DOMMimeTypeClass DOMMimeType +instance GObjectClass DOMMimeType where + toGObject = GObject . castForeignPtr . unDOMMimeType + unsafeCastGObject = DOMMimeType . castForeignPtr . unGObject + +castToDOMMimeType :: GObjectClass obj => obj -> DOMMimeType +castToDOMMimeType = castTo gTypeDOMMimeType "DOMMimeType" + +gTypeDOMMimeType :: GType +gTypeDOMMimeType = + {# call fun unsafe webkit_dom_dom_mime_type_get_type #} + +-- *********************************************************** DOMMimeTypeArray + +{#pointer *WebKitDOMDOMMimeTypeArray as DOMMimeTypeArray foreign newtype #} deriving (Eq,Ord) + +mkDOMMimeTypeArray = (DOMMimeTypeArray, objectUnrefFromMainloop) +unDOMMimeTypeArray (DOMMimeTypeArray o) = o + +class GObjectClass o => DOMMimeTypeArrayClass o +toDOMMimeTypeArray :: DOMMimeTypeArrayClass o => o -> DOMMimeTypeArray +toDOMMimeTypeArray = unsafeCastGObject . toGObject + +instance DOMMimeTypeArrayClass DOMMimeTypeArray +instance GObjectClass DOMMimeTypeArray where + toGObject = GObject . castForeignPtr . unDOMMimeTypeArray + unsafeCastGObject = DOMMimeTypeArray . castForeignPtr . unGObject + +castToDOMMimeTypeArray :: GObjectClass obj => obj -> DOMMimeTypeArray +castToDOMMimeTypeArray = castTo gTypeDOMMimeTypeArray "DOMMimeTypeArray" + +gTypeDOMMimeTypeArray :: GType +gTypeDOMMimeTypeArray = + {# call fun unsafe webkit_dom_dom_mime_type_array_get_type #} + +-- ****************************************************************** DOMPlugin + +{#pointer *WebKitDOMDOMPlugin as DOMPlugin foreign newtype #} deriving (Eq,Ord) + +mkDOMPlugin = (DOMPlugin, objectUnrefFromMainloop) +unDOMPlugin (DOMPlugin o) = o + +class GObjectClass o => DOMPluginClass o +toDOMPlugin :: DOMPluginClass o => o -> DOMPlugin +toDOMPlugin = unsafeCastGObject . toGObject + +instance DOMPluginClass DOMPlugin +instance GObjectClass DOMPlugin where + toGObject = GObject . castForeignPtr . unDOMPlugin + unsafeCastGObject = DOMPlugin . castForeignPtr . unGObject + +castToDOMPlugin :: GObjectClass obj => obj -> DOMPlugin +castToDOMPlugin = castTo gTypeDOMPlugin "DOMPlugin" + +gTypeDOMPlugin :: GType +gTypeDOMPlugin = + {# call fun unsafe webkit_dom_dom_plugin_get_type #} + +-- ************************************************************* DOMPluginArray + +{#pointer *WebKitDOMDOMPluginArray as DOMPluginArray foreign newtype #} deriving (Eq,Ord) + +mkDOMPluginArray = (DOMPluginArray, objectUnrefFromMainloop) +unDOMPluginArray (DOMPluginArray o) = o + +class GObjectClass o => DOMPluginArrayClass o +toDOMPluginArray :: DOMPluginArrayClass o => o -> DOMPluginArray +toDOMPluginArray = unsafeCastGObject . toGObject + +instance DOMPluginArrayClass DOMPluginArray +instance GObjectClass DOMPluginArray where + toGObject = GObject . castForeignPtr . unDOMPluginArray + unsafeCastGObject = DOMPluginArray . castForeignPtr . unGObject + +castToDOMPluginArray :: GObjectClass obj => obj -> DOMPluginArray +castToDOMPluginArray = castTo gTypeDOMPluginArray "DOMPluginArray" + +gTypeDOMPluginArray :: GType +gTypeDOMPluginArray = + {# call fun unsafe webkit_dom_dom_plugin_array_get_type #} + +-- ********************************************************** DOMSecurityPolicy + +{#pointer *WebKitDOMDOMSecurityPolicy as DOMSecurityPolicy foreign newtype #} deriving (Eq,Ord) + +mkDOMSecurityPolicy = (DOMSecurityPolicy, objectUnrefFromMainloop) +unDOMSecurityPolicy (DOMSecurityPolicy o) = o + +class GObjectClass o => DOMSecurityPolicyClass o +toDOMSecurityPolicy :: DOMSecurityPolicyClass o => o -> DOMSecurityPolicy +toDOMSecurityPolicy = unsafeCastGObject . toGObject + +instance DOMSecurityPolicyClass DOMSecurityPolicy +instance GObjectClass DOMSecurityPolicy where + toGObject = GObject . castForeignPtr . unDOMSecurityPolicy + unsafeCastGObject = DOMSecurityPolicy . castForeignPtr . unGObject + +castToDOMSecurityPolicy :: GObjectClass obj => obj -> DOMSecurityPolicy +castToDOMSecurityPolicy = castTo gTypeDOMSecurityPolicy "DOMSecurityPolicy" + +gTypeDOMSecurityPolicy :: GType +gTypeDOMSecurityPolicy = + {# call fun unsafe webkit_dom_dom_security_policy_get_type #} + +-- *************************************************************** DOMSelection + +{#pointer *WebKitDOMDOMSelection as DOMSelection foreign newtype #} deriving (Eq,Ord) + +mkDOMSelection = (DOMSelection, objectUnrefFromMainloop) +unDOMSelection (DOMSelection o) = o + +class GObjectClass o => DOMSelectionClass o +toDOMSelection :: DOMSelectionClass o => o -> DOMSelection +toDOMSelection = unsafeCastGObject . toGObject + +instance DOMSelectionClass DOMSelection +instance GObjectClass DOMSelection where + toGObject = GObject . castForeignPtr . unDOMSelection + unsafeCastGObject = DOMSelection . castForeignPtr . unGObject + +castToDOMSelection :: GObjectClass obj => obj -> DOMSelection +castToDOMSelection = castTo gTypeDOMSelection "DOMSelection" + +gTypeDOMSelection :: GType +gTypeDOMSelection = + {# call fun unsafe webkit_dom_dom_selection_get_type #} + +-- ************************************************************** DOMStringList + +{#pointer *WebKitDOMDOMStringList as DOMStringList foreign newtype #} deriving (Eq,Ord) + +mkDOMStringList = (DOMStringList, objectUnrefFromMainloop) +unDOMStringList (DOMStringList o) = o + +class GObjectClass o => DOMStringListClass o +toDOMStringList :: DOMStringListClass o => o -> DOMStringList +toDOMStringList = unsafeCastGObject . toGObject + +instance DOMStringListClass DOMStringList +instance GObjectClass DOMStringList where + toGObject = GObject . castForeignPtr . unDOMStringList + unsafeCastGObject = DOMStringList . castForeignPtr . unGObject + +castToDOMStringList :: GObjectClass obj => obj -> DOMStringList +castToDOMStringList = castTo gTypeDOMStringList "DOMStringList" + +gTypeDOMStringList :: GType +gTypeDOMStringList = + {# call fun unsafe webkit_dom_dom_string_list_get_type #} + +-- *************************************************************** DOMTokenList + +{#pointer *WebKitDOMDOMTokenList as DOMTokenList foreign newtype #} deriving (Eq,Ord) + +mkDOMTokenList = (DOMTokenList, objectUnrefFromMainloop) +unDOMTokenList (DOMTokenList o) = o + +class GObjectClass o => DOMTokenListClass o +toDOMTokenList :: DOMTokenListClass o => o -> DOMTokenList +toDOMTokenList = unsafeCastGObject . toGObject + +instance DOMTokenListClass DOMTokenList +instance GObjectClass DOMTokenList where + toGObject = GObject . castForeignPtr . unDOMTokenList + unsafeCastGObject = DOMTokenList . castForeignPtr . unGObject + +castToDOMTokenList :: GObjectClass obj => obj -> DOMTokenList +castToDOMTokenList = castTo gTypeDOMTokenList "DOMTokenList" + +gTypeDOMTokenList :: GType +gTypeDOMTokenList = + {# call fun unsafe webkit_dom_dom_token_list_get_type #} + +-- ******************************************************* DOMSettableTokenList + +{#pointer *WebKitDOMDOMSettableTokenList as DOMSettableTokenList foreign newtype #} deriving (Eq,Ord) + +mkDOMSettableTokenList = (DOMSettableTokenList, objectUnrefFromMainloop) +unDOMSettableTokenList (DOMSettableTokenList o) = o + +class DOMTokenListClass o => DOMSettableTokenListClass o +toDOMSettableTokenList :: DOMSettableTokenListClass o => o -> DOMSettableTokenList +toDOMSettableTokenList = unsafeCastGObject . toGObject + +instance DOMSettableTokenListClass DOMSettableTokenList +instance DOMTokenListClass DOMSettableTokenList +instance GObjectClass DOMSettableTokenList where + toGObject = GObject . castForeignPtr . unDOMSettableTokenList + unsafeCastGObject = DOMSettableTokenList . castForeignPtr . unGObject + +castToDOMSettableTokenList :: GObjectClass obj => obj -> DOMSettableTokenList +castToDOMSettableTokenList = castTo gTypeDOMSettableTokenList "DOMSettableTokenList" + +gTypeDOMSettableTokenList :: GType +gTypeDOMSettableTokenList = + {# call fun unsafe webkit_dom_dom_settable_token_list_get_type #} + +-- ****************************************************************** DOMWindow + +{#pointer *WebKitDOMDOMWindow as DOMWindow foreign newtype #} deriving (Eq,Ord) + +mkDOMWindow = (DOMWindow, objectUnrefFromMainloop) +unDOMWindow (DOMWindow o) = o + +class GObjectClass o => DOMWindowClass o +toDOMWindow :: DOMWindowClass o => o -> DOMWindow +toDOMWindow = unsafeCastGObject . toGObject + +instance DOMWindowClass DOMWindow +instance GObjectClass DOMWindow where + toGObject = GObject . castForeignPtr . unDOMWindow + unsafeCastGObject = DOMWindow . castForeignPtr . unGObject + +castToDOMWindow :: GObjectClass obj => obj -> DOMWindow +castToDOMWindow = castTo gTypeDOMWindow "DOMWindow" + +gTypeDOMWindow :: GType +gTypeDOMWindow = + {# call fun unsafe webkit_dom_dom_window_get_type #} + +-- ********************************************************************** Event + +{#pointer *WebKitDOMEvent as Event foreign newtype #} deriving (Eq,Ord) + +mkEvent = (Event, objectUnrefFromMainloop) +unEvent (Event o) = o + +class GObjectClass o => EventClass o +toEvent :: EventClass o => o -> Event +toEvent = unsafeCastGObject . toGObject + +instance EventClass Event +instance GObjectClass Event where + toGObject = GObject . castForeignPtr . unEvent + unsafeCastGObject = Event . castForeignPtr . unGObject + +castToEvent :: GObjectClass obj => obj -> Event +castToEvent = castTo gTypeEvent "Event" + +gTypeEvent :: GType +gTypeEvent = + {# call fun unsafe webkit_dom_event_get_type #} + +-- ******************************************************************** UIEvent + +{#pointer *WebKitDOMUIEvent as UIEvent foreign newtype #} deriving (Eq,Ord) + +mkUIEvent = (UIEvent, objectUnrefFromMainloop) +unUIEvent (UIEvent o) = o + +class EventClass o => UIEventClass o +toUIEvent :: UIEventClass o => o -> UIEvent +toUIEvent = unsafeCastGObject . toGObject + +instance UIEventClass UIEvent +instance EventClass UIEvent +instance GObjectClass UIEvent where + toGObject = GObject . castForeignPtr . unUIEvent + unsafeCastGObject = UIEvent . castForeignPtr . unGObject + +castToUIEvent :: GObjectClass obj => obj -> UIEvent +castToUIEvent = castTo gTypeUIEvent "UIEvent" + +gTypeUIEvent :: GType +gTypeUIEvent = + {# call fun unsafe webkit_dom_ui_event_get_type #} + +-- ***************************************************************** MouseEvent + +{#pointer *WebKitDOMMouseEvent as MouseEvent foreign newtype #} deriving (Eq,Ord) + +mkMouseEvent = (MouseEvent, objectUnrefFromMainloop) +unMouseEvent (MouseEvent o) = o + +class UIEventClass o => MouseEventClass o +toMouseEvent :: MouseEventClass o => o -> MouseEvent +toMouseEvent = unsafeCastGObject . toGObject + +instance MouseEventClass MouseEvent +instance UIEventClass MouseEvent +instance EventClass MouseEvent +instance GObjectClass MouseEvent where + toGObject = GObject . castForeignPtr . unMouseEvent + unsafeCastGObject = MouseEvent . castForeignPtr . unGObject + +castToMouseEvent :: GObjectClass obj => obj -> MouseEvent +castToMouseEvent = castTo gTypeMouseEvent "MouseEvent" + +gTypeMouseEvent :: GType +gTypeMouseEvent = + {# call fun unsafe webkit_dom_mouse_event_get_type #} + +-- **************************************************************** EventTarget + +{#pointer *WebKitDOMEventTarget as EventTarget foreign newtype #} deriving (Eq,Ord) + +mkEventTarget = (EventTarget, objectUnrefFromMainloop) +unEventTarget (EventTarget o) = o + +class GObjectClass o => EventTargetClass o +toEventTarget :: EventTargetClass o => o -> EventTarget +toEventTarget = unsafeCastGObject . toGObject + +instance EventTargetClass EventTarget +instance GObjectClass EventTarget where + toGObject = GObject . castForeignPtr . unEventTarget + unsafeCastGObject = EventTarget . castForeignPtr . unGObject + +castToEventTarget :: GObjectClass obj => obj -> EventTarget +castToEventTarget = castTo gTypeEventTarget "EventTarget" + +gTypeEventTarget :: GType +gTypeEventTarget = + {# call fun unsafe webkit_dom_event_target_get_type #} + +-- ******************************************************************* FileList + +{#pointer *WebKitDOMFileList as FileList foreign newtype #} deriving (Eq,Ord) + +mkFileList = (FileList, objectUnrefFromMainloop) +unFileList (FileList o) = o + +class GObjectClass o => FileListClass o +toFileList :: FileListClass o => o -> FileList +toFileList = unsafeCastGObject . toGObject + +instance FileListClass FileList +instance GObjectClass FileList where + toGObject = GObject . castForeignPtr . unFileList + unsafeCastGObject = FileList . castForeignPtr . unGObject + +castToFileList :: GObjectClass obj => obj -> FileList +castToFileList = castTo gTypeFileList "FileList" + +gTypeFileList :: GType +gTypeFileList = + {# call fun unsafe webkit_dom_file_list_get_type #} + +-- **************************************************************** Geolocation + +{#pointer *WebKitDOMGeolocation as Geolocation foreign newtype #} deriving (Eq,Ord) + +mkGeolocation = (Geolocation, objectUnrefFromMainloop) +unGeolocation (Geolocation o) = o + +class GObjectClass o => GeolocationClass o +toGeolocation :: GeolocationClass o => o -> Geolocation +toGeolocation = unsafeCastGObject . toGObject + +instance GeolocationClass Geolocation +instance GObjectClass Geolocation where + toGObject = GObject . castForeignPtr . unGeolocation + unsafeCastGObject = Geolocation . castForeignPtr . unGObject + +castToGeolocation :: GObjectClass obj => obj -> Geolocation +castToGeolocation = castTo gTypeGeolocation "Geolocation" + +gTypeGeolocation :: GType +gTypeGeolocation = + {# call fun unsafe webkit_dom_geolocation_get_type #} + +-- ************************************************************* HTMLCollection + +{#pointer *WebKitDOMHTMLCollection as HTMLCollection foreign newtype #} deriving (Eq,Ord) + +mkHTMLCollection = (HTMLCollection, objectUnrefFromMainloop) +unHTMLCollection (HTMLCollection o) = o + +class GObjectClass o => HTMLCollectionClass o +toHTMLCollection :: HTMLCollectionClass o => o -> HTMLCollection +toHTMLCollection = unsafeCastGObject . toGObject + +instance HTMLCollectionClass HTMLCollection +instance GObjectClass HTMLCollection where + toGObject = GObject . castForeignPtr . unHTMLCollection + unsafeCastGObject = HTMLCollection . castForeignPtr . unGObject + +castToHTMLCollection :: GObjectClass obj => obj -> HTMLCollection +castToHTMLCollection = castTo gTypeHTMLCollection "HTMLCollection" + +gTypeHTMLCollection :: GType +gTypeHTMLCollection = + {# call fun unsafe webkit_dom_html_collection_get_type #} + +-- ****************************************************** HTMLOptionsCollection + +{#pointer *WebKitDOMHTMLOptionsCollection as HTMLOptionsCollection foreign newtype #} deriving (Eq,Ord) + +mkHTMLOptionsCollection = (HTMLOptionsCollection, objectUnrefFromMainloop) +unHTMLOptionsCollection (HTMLOptionsCollection o) = o + +class HTMLCollectionClass o => HTMLOptionsCollectionClass o +toHTMLOptionsCollection :: HTMLOptionsCollectionClass o => o -> HTMLOptionsCollection +toHTMLOptionsCollection = unsafeCastGObject . toGObject + +instance HTMLOptionsCollectionClass HTMLOptionsCollection +instance HTMLCollectionClass HTMLOptionsCollection +instance GObjectClass HTMLOptionsCollection where + toGObject = GObject . castForeignPtr . unHTMLOptionsCollection + unsafeCastGObject = HTMLOptionsCollection . castForeignPtr . unGObject + +castToHTMLOptionsCollection :: GObjectClass obj => obj -> HTMLOptionsCollection +castToHTMLOptionsCollection = castTo gTypeHTMLOptionsCollection "HTMLOptionsCollection" + +gTypeHTMLOptionsCollection :: GType +gTypeHTMLOptionsCollection = + {# call fun unsafe webkit_dom_html_options_collection_get_type #} + +-- ******************************************************************** History + +{#pointer *WebKitDOMHistory as History foreign newtype #} deriving (Eq,Ord) + +mkHistory = (History, objectUnrefFromMainloop) +unHistory (History o) = o + +class GObjectClass o => HistoryClass o +toHistory :: HistoryClass o => o -> History +toHistory = unsafeCastGObject . toGObject + +instance HistoryClass History +instance GObjectClass History where + toGObject = GObject . castForeignPtr . unHistory + unsafeCastGObject = History . castForeignPtr . unGObject + +castToHistory :: GObjectClass obj => obj -> History +castToHistory = castTo gTypeHistory "History" + +gTypeHistory :: GType +gTypeHistory = + {# call fun unsafe webkit_dom_history_get_type #} + +-- ******************************************************************* Location + +{#pointer *WebKitDOMLocation as Location foreign newtype #} deriving (Eq,Ord) + +mkLocation = (Location, objectUnrefFromMainloop) +unLocation (Location o) = o + +class GObjectClass o => LocationClass o +toLocation :: LocationClass o => o -> Location +toLocation = unsafeCastGObject . toGObject + +instance LocationClass Location +instance GObjectClass Location where + toGObject = GObject . castForeignPtr . unLocation + unsafeCastGObject = Location . castForeignPtr . unGObject + +castToLocation :: GObjectClass obj => obj -> Location +castToLocation = castTo gTypeLocation "Location" + +gTypeLocation :: GType +gTypeLocation = + {# call fun unsafe webkit_dom_location_get_type #} + +-- ***************************************************************** MediaError + +{#pointer *WebKitDOMMediaError as MediaError foreign newtype #} deriving (Eq,Ord) + +mkMediaError = (MediaError, objectUnrefFromMainloop) +unMediaError (MediaError o) = o + +class GObjectClass o => MediaErrorClass o +toMediaError :: MediaErrorClass o => o -> MediaError +toMediaError = unsafeCastGObject . toGObject + +instance MediaErrorClass MediaError +instance GObjectClass MediaError where + toGObject = GObject . castForeignPtr . unMediaError + unsafeCastGObject = MediaError . castForeignPtr . unGObject + +castToMediaError :: GObjectClass obj => obj -> MediaError +castToMediaError = castTo gTypeMediaError "MediaError" + +gTypeMediaError :: GType +gTypeMediaError = + {# call fun unsafe webkit_dom_media_error_get_type #} + +-- ****************************************************************** MediaList + +{#pointer *WebKitDOMMediaList as MediaList foreign newtype #} deriving (Eq,Ord) + +mkMediaList = (MediaList, objectUnrefFromMainloop) +unMediaList (MediaList o) = o + +class GObjectClass o => MediaListClass o +toMediaList :: MediaListClass o => o -> MediaList +toMediaList = unsafeCastGObject . toGObject + +instance MediaListClass MediaList +instance GObjectClass MediaList where + toGObject = GObject . castForeignPtr . unMediaList + unsafeCastGObject = MediaList . castForeignPtr . unGObject + +castToMediaList :: GObjectClass obj => obj -> MediaList +castToMediaList = castTo gTypeMediaList "MediaList" + +gTypeMediaList :: GType +gTypeMediaList = + {# call fun unsafe webkit_dom_media_list_get_type #} + +-- ************************************************************* MediaQueryList + +{#pointer *WebKitDOMMediaQueryList as MediaQueryList foreign newtype #} deriving (Eq,Ord) + +mkMediaQueryList = (MediaQueryList, objectUnrefFromMainloop) +unMediaQueryList (MediaQueryList o) = o + +class GObjectClass o => MediaQueryListClass o +toMediaQueryList :: MediaQueryListClass o => o -> MediaQueryList +toMediaQueryList = unsafeCastGObject . toGObject + +instance MediaQueryListClass MediaQueryList +instance GObjectClass MediaQueryList where + toGObject = GObject . castForeignPtr . unMediaQueryList + unsafeCastGObject = MediaQueryList . castForeignPtr . unGObject + +castToMediaQueryList :: GObjectClass obj => obj -> MediaQueryList +castToMediaQueryList = castTo gTypeMediaQueryList "MediaQueryList" + +gTypeMediaQueryList :: GType +gTypeMediaQueryList = + {# call fun unsafe webkit_dom_media_query_list_get_type #} + +-- ***************************************************************** MemoryInfo + +{#pointer *WebKitDOMMemoryInfo as MemoryInfo foreign newtype #} deriving (Eq,Ord) + +mkMemoryInfo = (MemoryInfo, objectUnrefFromMainloop) +unMemoryInfo (MemoryInfo o) = o + +class GObjectClass o => MemoryInfoClass o +toMemoryInfo :: MemoryInfoClass o => o -> MemoryInfo +toMemoryInfo = unsafeCastGObject . toGObject + +instance MemoryInfoClass MemoryInfo +instance GObjectClass MemoryInfo where + toGObject = GObject . castForeignPtr . unMemoryInfo + unsafeCastGObject = MemoryInfo . castForeignPtr . unGObject + +castToMemoryInfo :: GObjectClass obj => obj -> MemoryInfo +castToMemoryInfo = castTo gTypeMemoryInfo "MemoryInfo" + +gTypeMemoryInfo :: GType +gTypeMemoryInfo = + {# call fun unsafe webkit_dom_memory_info_get_type #} + +-- **************************************************************** MessagePort + +{#pointer *WebKitDOMMessagePort as MessagePort foreign newtype #} deriving (Eq,Ord) + +mkMessagePort = (MessagePort, objectUnrefFromMainloop) +unMessagePort (MessagePort o) = o + +class GObjectClass o => MessagePortClass o +toMessagePort :: MessagePortClass o => o -> MessagePort +toMessagePort = unsafeCastGObject . toGObject + +instance MessagePortClass MessagePort +instance GObjectClass MessagePort where + toGObject = GObject . castForeignPtr . unMessagePort + unsafeCastGObject = MessagePort . castForeignPtr . unGObject + +castToMessagePort :: GObjectClass obj => obj -> MessagePort +castToMessagePort = castTo gTypeMessagePort "MessagePort" + +gTypeMessagePort :: GType +gTypeMessagePort = + {# call fun unsafe webkit_dom_message_port_get_type #} + +-- *************************************************************** NamedNodeMap + +{#pointer *WebKitDOMNamedNodeMap as NamedNodeMap foreign newtype #} deriving (Eq,Ord) + +mkNamedNodeMap = (NamedNodeMap, objectUnrefFromMainloop) +unNamedNodeMap (NamedNodeMap o) = o + +class GObjectClass o => NamedNodeMapClass o +toNamedNodeMap :: NamedNodeMapClass o => o -> NamedNodeMap +toNamedNodeMap = unsafeCastGObject . toGObject + +instance NamedNodeMapClass NamedNodeMap +instance GObjectClass NamedNodeMap where + toGObject = GObject . castForeignPtr . unNamedNodeMap + unsafeCastGObject = NamedNodeMap . castForeignPtr . unGObject + +castToNamedNodeMap :: GObjectClass obj => obj -> NamedNodeMap +castToNamedNodeMap = castTo gTypeNamedNodeMap "NamedNodeMap" + +gTypeNamedNodeMap :: GType +gTypeNamedNodeMap = + {# call fun unsafe webkit_dom_named_node_map_get_type #} + +-- ****************************************************************** Navigator + +{#pointer *WebKitDOMNavigator as Navigator foreign newtype #} deriving (Eq,Ord) + +mkNavigator = (Navigator, objectUnrefFromMainloop) +unNavigator (Navigator o) = o + +class GObjectClass o => NavigatorClass o +toNavigator :: NavigatorClass o => o -> Navigator +toNavigator = unsafeCastGObject . toGObject + +instance NavigatorClass Navigator +instance GObjectClass Navigator where + toGObject = GObject . castForeignPtr . unNavigator + unsafeCastGObject = Navigator . castForeignPtr . unGObject + +castToNavigator :: GObjectClass obj => obj -> Navigator +castToNavigator = castTo gTypeNavigator "Navigator" + +gTypeNavigator :: GType +gTypeNavigator = + {# call fun unsafe webkit_dom_navigator_get_type #} + +-- *********************************************************************** Node + +{#pointer *WebKitDOMNode as Node foreign newtype #} deriving (Eq,Ord) + +mkNode = (Node, objectUnrefFromMainloop) +unNode (Node o) = o + +class GObjectClass o => NodeClass o +toNode :: NodeClass o => o -> Node +toNode = unsafeCastGObject . toGObject + +instance NodeClass Node +instance GObjectClass Node where + toGObject = GObject . castForeignPtr . unNode + unsafeCastGObject = Node . castForeignPtr . unGObject + +castToNode :: GObjectClass obj => obj -> Node +castToNode = castTo gTypeNode "Node" + +gTypeNode :: GType +gTypeNode = + {# call fun unsafe webkit_dom_node_get_type #} + +-- ******************************************************************** DOMAttr + +{#pointer *WebKitDOMAttr as DOMAttr foreign newtype #} deriving (Eq,Ord) + +mkDOMAttr = (DOMAttr, objectUnrefFromMainloop) +unDOMAttr (DOMAttr o) = o + +class NodeClass o => DOMAttrClass o +toDOMAttr :: DOMAttrClass o => o -> DOMAttr +toDOMAttr = unsafeCastGObject . toGObject + +instance DOMAttrClass DOMAttr +instance NodeClass DOMAttr +instance GObjectClass DOMAttr where + toGObject = GObject . castForeignPtr . unDOMAttr + unsafeCastGObject = DOMAttr . castForeignPtr . unGObject + +castToDOMAttr :: GObjectClass obj => obj -> DOMAttr +castToDOMAttr = castTo gTypeDOMAttr "DOMAttr" + +gTypeDOMAttr :: GType +gTypeDOMAttr = + {# call fun unsafe webkit_dom_attr_get_type #} + +-- ************************************************************** CharacterData + +{#pointer *WebKitDOMCharacterData as CharacterData foreign newtype #} deriving (Eq,Ord) + +mkCharacterData = (CharacterData, objectUnrefFromMainloop) +unCharacterData (CharacterData o) = o + +class NodeClass o => CharacterDataClass o +toCharacterData :: CharacterDataClass o => o -> CharacterData +toCharacterData = unsafeCastGObject . toGObject + +instance CharacterDataClass CharacterData +instance NodeClass CharacterData +instance GObjectClass CharacterData where + toGObject = GObject . castForeignPtr . unCharacterData + unsafeCastGObject = CharacterData . castForeignPtr . unGObject + +castToCharacterData :: GObjectClass obj => obj -> CharacterData +castToCharacterData = castTo gTypeCharacterData "CharacterData" + +gTypeCharacterData :: GType +gTypeCharacterData = + {# call fun unsafe webkit_dom_character_data_get_type #} + +-- ******************************************************************** Comment + +{#pointer *WebKitDOMComment as Comment foreign newtype #} deriving (Eq,Ord) + +mkComment = (Comment, objectUnrefFromMainloop) +unComment (Comment o) = o + +class CharacterDataClass o => CommentClass o +toComment :: CommentClass o => o -> Comment +toComment = unsafeCastGObject . toGObject + +instance CommentClass Comment +instance CharacterDataClass Comment +instance NodeClass Comment +instance GObjectClass Comment where + toGObject = GObject . castForeignPtr . unComment + unsafeCastGObject = Comment . castForeignPtr . unGObject + +castToComment :: GObjectClass obj => obj -> Comment +castToComment = castTo gTypeComment "Comment" + +gTypeComment :: GType +gTypeComment = + {# call fun unsafe webkit_dom_comment_get_type #} + +-- *********************************************************************** Text + +{#pointer *WebKitDOMText as Text foreign newtype #} deriving (Eq,Ord) + +mkText = (Text, objectUnrefFromMainloop) +unText (Text o) = o + +class CharacterDataClass o => TextClass o +toText :: TextClass o => o -> Text +toText = unsafeCastGObject . toGObject + +instance TextClass Text +instance CharacterDataClass Text +instance NodeClass Text +instance GObjectClass Text where + toGObject = GObject . castForeignPtr . unText + unsafeCastGObject = Text . castForeignPtr . unGObject + +castToText :: GObjectClass obj => obj -> Text +castToText = castTo gTypeText "Text" + +gTypeText :: GType +gTypeText = + {# call fun unsafe webkit_dom_text_get_type #} + +-- *************************************************************** CDATASection + +{#pointer *WebKitDOMCDATASection as CDATASection foreign newtype #} deriving (Eq,Ord) + +mkCDATASection = (CDATASection, objectUnrefFromMainloop) +unCDATASection (CDATASection o) = o + +class TextClass o => CDATASectionClass o +toCDATASection :: CDATASectionClass o => o -> CDATASection +toCDATASection = unsafeCastGObject . toGObject + +instance CDATASectionClass CDATASection +instance TextClass CDATASection +instance CharacterDataClass CDATASection +instance NodeClass CDATASection +instance GObjectClass CDATASection where + toGObject = GObject . castForeignPtr . unCDATASection + unsafeCastGObject = CDATASection . castForeignPtr . unGObject + +castToCDATASection :: GObjectClass obj => obj -> CDATASection +castToCDATASection = castTo gTypeCDATASection "CDATASection" + +gTypeCDATASection :: GType +gTypeCDATASection = + {# call fun unsafe webkit_dom_cdata_section_get_type #} + +-- ******************************************************************* Document + +{#pointer *WebKitDOMDocument as Document foreign newtype #} deriving (Eq,Ord) + +mkDocument = (Document, objectUnrefFromMainloop) +unDocument (Document o) = o + +class NodeClass o => DocumentClass o +toDocument :: DocumentClass o => o -> Document +toDocument = unsafeCastGObject . toGObject + +instance DocumentClass Document +instance NodeClass Document +instance GObjectClass Document where + toGObject = GObject . castForeignPtr . unDocument + unsafeCastGObject = Document . castForeignPtr . unGObject + +castToDocument :: GObjectClass obj => obj -> Document +castToDocument = castTo gTypeDocument "Document" + +gTypeDocument :: GType +gTypeDocument = + {# call fun unsafe webkit_dom_document_get_type #} + +-- *************************************************************** HTMLDocument + +{#pointer *WebKitDOMHTMLDocument as HTMLDocument foreign newtype #} deriving (Eq,Ord) + +mkHTMLDocument = (HTMLDocument, objectUnrefFromMainloop) +unHTMLDocument (HTMLDocument o) = o + +class DocumentClass o => HTMLDocumentClass o +toHTMLDocument :: HTMLDocumentClass o => o -> HTMLDocument +toHTMLDocument = unsafeCastGObject . toGObject + +instance HTMLDocumentClass HTMLDocument +instance DocumentClass HTMLDocument +instance NodeClass HTMLDocument +instance GObjectClass HTMLDocument where + toGObject = GObject . castForeignPtr . unHTMLDocument + unsafeCastGObject = HTMLDocument . castForeignPtr . unGObject + +castToHTMLDocument :: GObjectClass obj => obj -> HTMLDocument +castToHTMLDocument = castTo gTypeHTMLDocument "HTMLDocument" + +gTypeHTMLDocument :: GType +gTypeHTMLDocument = + {# call fun unsafe webkit_dom_html_document_get_type #} + +-- *********************************************************** DocumentFragment + +{#pointer *WebKitDOMDocumentFragment as DocumentFragment foreign newtype #} deriving (Eq,Ord) + +mkDocumentFragment = (DocumentFragment, objectUnrefFromMainloop) +unDocumentFragment (DocumentFragment o) = o + +class NodeClass o => DocumentFragmentClass o +toDocumentFragment :: DocumentFragmentClass o => o -> DocumentFragment +toDocumentFragment = unsafeCastGObject . toGObject + +instance DocumentFragmentClass DocumentFragment +instance NodeClass DocumentFragment +instance GObjectClass DocumentFragment where + toGObject = GObject . castForeignPtr . unDocumentFragment + unsafeCastGObject = DocumentFragment . castForeignPtr . unGObject + +castToDocumentFragment :: GObjectClass obj => obj -> DocumentFragment +castToDocumentFragment = castTo gTypeDocumentFragment "DocumentFragment" + +gTypeDocumentFragment :: GType +gTypeDocumentFragment = + {# call fun unsafe webkit_dom_document_fragment_get_type #} + +-- *************************************************************** DocumentType + +{#pointer *WebKitDOMDocumentType as DocumentType foreign newtype #} deriving (Eq,Ord) + +mkDocumentType = (DocumentType, objectUnrefFromMainloop) +unDocumentType (DocumentType o) = o + +class NodeClass o => DocumentTypeClass o +toDocumentType :: DocumentTypeClass o => o -> DocumentType +toDocumentType = unsafeCastGObject . toGObject + +instance DocumentTypeClass DocumentType +instance NodeClass DocumentType +instance GObjectClass DocumentType where + toGObject = GObject . castForeignPtr . unDocumentType + unsafeCastGObject = DocumentType . castForeignPtr . unGObject + +castToDocumentType :: GObjectClass obj => obj -> DocumentType +castToDocumentType = castTo gTypeDocumentType "DocumentType" + +gTypeDocumentType :: GType +gTypeDocumentType = + {# call fun unsafe webkit_dom_document_type_get_type #} + +-- ******************************************************************** Element + +{#pointer *WebKitDOMElement as Element foreign newtype #} deriving (Eq,Ord) + +mkElement = (Element, objectUnrefFromMainloop) +unElement (Element o) = o + +class NodeClass o => ElementClass o +toElement :: ElementClass o => o -> Element +toElement = unsafeCastGObject . toGObject + +instance ElementClass Element +instance NodeClass Element +instance GObjectClass Element where + toGObject = GObject . castForeignPtr . unElement + unsafeCastGObject = Element . castForeignPtr . unGObject + +castToElement :: GObjectClass obj => obj -> Element +castToElement = castTo gTypeElement "Element" + +gTypeElement :: GType +gTypeElement = + {# call fun unsafe webkit_dom_element_get_type #} + +-- **************************************************************** HTMLElement + +{#pointer *WebKitDOMHTMLElement as HTMLElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLElement = (HTMLElement, objectUnrefFromMainloop) +unHTMLElement (HTMLElement o) = o + +class ElementClass o => HTMLElementClass o +toHTMLElement :: HTMLElementClass o => o -> HTMLElement +toHTMLElement = unsafeCastGObject . toGObject + +instance HTMLElementClass HTMLElement +instance ElementClass HTMLElement +instance NodeClass HTMLElement +instance GObjectClass HTMLElement where + toGObject = GObject . castForeignPtr . unHTMLElement + unsafeCastGObject = HTMLElement . castForeignPtr . unGObject + +castToHTMLElement :: GObjectClass obj => obj -> HTMLElement +castToHTMLElement = castTo gTypeHTMLElement "HTMLElement" + +gTypeHTMLElement :: GType +gTypeHTMLElement = + {# call fun unsafe webkit_dom_html_element_get_type #} + +-- ********************************************************** HTMLAnchorElement + +{#pointer *WebKitDOMHTMLAnchorElement as HTMLAnchorElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLAnchorElement = (HTMLAnchorElement, objectUnrefFromMainloop) +unHTMLAnchorElement (HTMLAnchorElement o) = o + +class HTMLElementClass o => HTMLAnchorElementClass o +toHTMLAnchorElement :: HTMLAnchorElementClass o => o -> HTMLAnchorElement +toHTMLAnchorElement = unsafeCastGObject . toGObject + +instance HTMLAnchorElementClass HTMLAnchorElement +instance HTMLElementClass HTMLAnchorElement +instance ElementClass HTMLAnchorElement +instance NodeClass HTMLAnchorElement +instance GObjectClass HTMLAnchorElement where + toGObject = GObject . castForeignPtr . unHTMLAnchorElement + unsafeCastGObject = HTMLAnchorElement . castForeignPtr . unGObject + +castToHTMLAnchorElement :: GObjectClass obj => obj -> HTMLAnchorElement +castToHTMLAnchorElement = castTo gTypeHTMLAnchorElement "HTMLAnchorElement" + +gTypeHTMLAnchorElement :: GType +gTypeHTMLAnchorElement = + {# call fun unsafe webkit_dom_html_anchor_element_get_type #} + +-- ********************************************************** HTMLAppletElement + +{#pointer *WebKitDOMHTMLAppletElement as HTMLAppletElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLAppletElement = (HTMLAppletElement, objectUnrefFromMainloop) +unHTMLAppletElement (HTMLAppletElement o) = o + +class HTMLElementClass o => HTMLAppletElementClass o +toHTMLAppletElement :: HTMLAppletElementClass o => o -> HTMLAppletElement +toHTMLAppletElement = unsafeCastGObject . toGObject + +instance HTMLAppletElementClass HTMLAppletElement +instance HTMLElementClass HTMLAppletElement +instance ElementClass HTMLAppletElement +instance NodeClass HTMLAppletElement +instance GObjectClass HTMLAppletElement where + toGObject = GObject . castForeignPtr . unHTMLAppletElement + unsafeCastGObject = HTMLAppletElement . castForeignPtr . unGObject + +castToHTMLAppletElement :: GObjectClass obj => obj -> HTMLAppletElement +castToHTMLAppletElement = castTo gTypeHTMLAppletElement "HTMLAppletElement" + +gTypeHTMLAppletElement :: GType +gTypeHTMLAppletElement = + {# call fun unsafe webkit_dom_html_applet_element_get_type #} + +-- ************************************************************ HTMLAreaElement + +{#pointer *WebKitDOMHTMLAreaElement as HTMLAreaElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLAreaElement = (HTMLAreaElement, objectUnrefFromMainloop) +unHTMLAreaElement (HTMLAreaElement o) = o + +class HTMLElementClass o => HTMLAreaElementClass o +toHTMLAreaElement :: HTMLAreaElementClass o => o -> HTMLAreaElement +toHTMLAreaElement = unsafeCastGObject . toGObject + +instance HTMLAreaElementClass HTMLAreaElement +instance HTMLElementClass HTMLAreaElement +instance ElementClass HTMLAreaElement +instance NodeClass HTMLAreaElement +instance GObjectClass HTMLAreaElement where + toGObject = GObject . castForeignPtr . unHTMLAreaElement + unsafeCastGObject = HTMLAreaElement . castForeignPtr . unGObject + +castToHTMLAreaElement :: GObjectClass obj => obj -> HTMLAreaElement +castToHTMLAreaElement = castTo gTypeHTMLAreaElement "HTMLAreaElement" + +gTypeHTMLAreaElement :: GType +gTypeHTMLAreaElement = + {# call fun unsafe webkit_dom_html_area_element_get_type #} + +-- ************************************************************** HTMLBRElement + +{#pointer *WebKitDOMHTMLBRElement as HTMLBRElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLBRElement = (HTMLBRElement, objectUnrefFromMainloop) +unHTMLBRElement (HTMLBRElement o) = o + +class HTMLElementClass o => HTMLBRElementClass o +toHTMLBRElement :: HTMLBRElementClass o => o -> HTMLBRElement +toHTMLBRElement = unsafeCastGObject . toGObject + +instance HTMLBRElementClass HTMLBRElement +instance HTMLElementClass HTMLBRElement +instance ElementClass HTMLBRElement +instance NodeClass HTMLBRElement +instance GObjectClass HTMLBRElement where + toGObject = GObject . castForeignPtr . unHTMLBRElement + unsafeCastGObject = HTMLBRElement . castForeignPtr . unGObject + +castToHTMLBRElement :: GObjectClass obj => obj -> HTMLBRElement +castToHTMLBRElement = castTo gTypeHTMLBRElement "HTMLBRElement" + +gTypeHTMLBRElement :: GType +gTypeHTMLBRElement = + {# call fun unsafe webkit_dom_htmlbr_element_get_type #} + +-- ************************************************************ HTMLBaseElement + +{#pointer *WebKitDOMHTMLBaseElement as HTMLBaseElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLBaseElement = (HTMLBaseElement, objectUnrefFromMainloop) +unHTMLBaseElement (HTMLBaseElement o) = o + +class HTMLElementClass o => HTMLBaseElementClass o +toHTMLBaseElement :: HTMLBaseElementClass o => o -> HTMLBaseElement +toHTMLBaseElement = unsafeCastGObject . toGObject + +instance HTMLBaseElementClass HTMLBaseElement +instance HTMLElementClass HTMLBaseElement +instance ElementClass HTMLBaseElement +instance NodeClass HTMLBaseElement +instance GObjectClass HTMLBaseElement where + toGObject = GObject . castForeignPtr . unHTMLBaseElement + unsafeCastGObject = HTMLBaseElement . castForeignPtr . unGObject + +castToHTMLBaseElement :: GObjectClass obj => obj -> HTMLBaseElement +castToHTMLBaseElement = castTo gTypeHTMLBaseElement "HTMLBaseElement" + +gTypeHTMLBaseElement :: GType +gTypeHTMLBaseElement = + {# call fun unsafe webkit_dom_html_base_element_get_type #} + +-- ******************************************************** HTMLBaseFontElement + +{#pointer *WebKitDOMHTMLBaseFontElement as HTMLBaseFontElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLBaseFontElement = (HTMLBaseFontElement, objectUnrefFromMainloop) +unHTMLBaseFontElement (HTMLBaseFontElement o) = o + +class HTMLElementClass o => HTMLBaseFontElementClass o +toHTMLBaseFontElement :: HTMLBaseFontElementClass o => o -> HTMLBaseFontElement +toHTMLBaseFontElement = unsafeCastGObject . toGObject + +instance HTMLBaseFontElementClass HTMLBaseFontElement +instance HTMLElementClass HTMLBaseFontElement +instance ElementClass HTMLBaseFontElement +instance NodeClass HTMLBaseFontElement +instance GObjectClass HTMLBaseFontElement where + toGObject = GObject . castForeignPtr . unHTMLBaseFontElement + unsafeCastGObject = HTMLBaseFontElement . castForeignPtr . unGObject + +castToHTMLBaseFontElement :: GObjectClass obj => obj -> HTMLBaseFontElement +castToHTMLBaseFontElement = castTo gTypeHTMLBaseFontElement "HTMLBaseFontElement" + +gTypeHTMLBaseFontElement :: GType +gTypeHTMLBaseFontElement = + {# call fun unsafe webkit_dom_html_base_font_element_get_type #} + +-- ************************************************************ HTMLBodyElement + +{#pointer *WebKitDOMHTMLBodyElement as HTMLBodyElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLBodyElement = (HTMLBodyElement, objectUnrefFromMainloop) +unHTMLBodyElement (HTMLBodyElement o) = o + +class HTMLElementClass o => HTMLBodyElementClass o +toHTMLBodyElement :: HTMLBodyElementClass o => o -> HTMLBodyElement +toHTMLBodyElement = unsafeCastGObject . toGObject + +instance HTMLBodyElementClass HTMLBodyElement +instance HTMLElementClass HTMLBodyElement +instance ElementClass HTMLBodyElement +instance NodeClass HTMLBodyElement +instance GObjectClass HTMLBodyElement where + toGObject = GObject . castForeignPtr . unHTMLBodyElement + unsafeCastGObject = HTMLBodyElement . castForeignPtr . unGObject + +castToHTMLBodyElement :: GObjectClass obj => obj -> HTMLBodyElement +castToHTMLBodyElement = castTo gTypeHTMLBodyElement "HTMLBodyElement" + +gTypeHTMLBodyElement :: GType +gTypeHTMLBodyElement = + {# call fun unsafe webkit_dom_html_body_element_get_type #} + +-- ********************************************************** HTMLButtonElement + +{#pointer *WebKitDOMHTMLButtonElement as HTMLButtonElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLButtonElement = (HTMLButtonElement, objectUnrefFromMainloop) +unHTMLButtonElement (HTMLButtonElement o) = o + +class HTMLElementClass o => HTMLButtonElementClass o +toHTMLButtonElement :: HTMLButtonElementClass o => o -> HTMLButtonElement +toHTMLButtonElement = unsafeCastGObject . toGObject + +instance HTMLButtonElementClass HTMLButtonElement +instance HTMLElementClass HTMLButtonElement +instance ElementClass HTMLButtonElement +instance NodeClass HTMLButtonElement +instance GObjectClass HTMLButtonElement where + toGObject = GObject . castForeignPtr . unHTMLButtonElement + unsafeCastGObject = HTMLButtonElement . castForeignPtr . unGObject + +castToHTMLButtonElement :: GObjectClass obj => obj -> HTMLButtonElement +castToHTMLButtonElement = castTo gTypeHTMLButtonElement "HTMLButtonElement" + +gTypeHTMLButtonElement :: GType +gTypeHTMLButtonElement = + {# call fun unsafe webkit_dom_html_button_element_get_type #} + +-- ********************************************************** HTMLCanvasElement + +{#pointer *WebKitDOMHTMLCanvasElement as HTMLCanvasElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLCanvasElement = (HTMLCanvasElement, objectUnrefFromMainloop) +unHTMLCanvasElement (HTMLCanvasElement o) = o + +class HTMLElementClass o => HTMLCanvasElementClass o +toHTMLCanvasElement :: HTMLCanvasElementClass o => o -> HTMLCanvasElement +toHTMLCanvasElement = unsafeCastGObject . toGObject + +instance HTMLCanvasElementClass HTMLCanvasElement +instance HTMLElementClass HTMLCanvasElement +instance ElementClass HTMLCanvasElement +instance NodeClass HTMLCanvasElement +instance GObjectClass HTMLCanvasElement where + toGObject = GObject . castForeignPtr . unHTMLCanvasElement + unsafeCastGObject = HTMLCanvasElement . castForeignPtr . unGObject + +castToHTMLCanvasElement :: GObjectClass obj => obj -> HTMLCanvasElement +castToHTMLCanvasElement = castTo gTypeHTMLCanvasElement "HTMLCanvasElement" + +gTypeHTMLCanvasElement :: GType +gTypeHTMLCanvasElement = + {# call fun unsafe webkit_dom_html_canvas_element_get_type #} + +-- *********************************************************** HTMLDListElement + +{#pointer *WebKitDOMHTMLDListElement as HTMLDListElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLDListElement = (HTMLDListElement, objectUnrefFromMainloop) +unHTMLDListElement (HTMLDListElement o) = o + +class HTMLElementClass o => HTMLDListElementClass o +toHTMLDListElement :: HTMLDListElementClass o => o -> HTMLDListElement +toHTMLDListElement = unsafeCastGObject . toGObject + +instance HTMLDListElementClass HTMLDListElement +instance HTMLElementClass HTMLDListElement +instance ElementClass HTMLDListElement +instance NodeClass HTMLDListElement +instance GObjectClass HTMLDListElement where + toGObject = GObject . castForeignPtr . unHTMLDListElement + unsafeCastGObject = HTMLDListElement . castForeignPtr . unGObject + +castToHTMLDListElement :: GObjectClass obj => obj -> HTMLDListElement +castToHTMLDListElement = castTo gTypeHTMLDListElement "HTMLDListElement" + +gTypeHTMLDListElement :: GType +gTypeHTMLDListElement = + {# call fun unsafe webkit_dom_htmld_list_element_get_type #} + +-- ********************************************************* HTMLDetailsElement + +{#pointer *WebKitDOMHTMLDetailsElement as HTMLDetailsElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLDetailsElement = (HTMLDetailsElement, objectUnrefFromMainloop) +unHTMLDetailsElement (HTMLDetailsElement o) = o + +class HTMLElementClass o => HTMLDetailsElementClass o +toHTMLDetailsElement :: HTMLDetailsElementClass o => o -> HTMLDetailsElement +toHTMLDetailsElement = unsafeCastGObject . toGObject + +instance HTMLDetailsElementClass HTMLDetailsElement +instance HTMLElementClass HTMLDetailsElement +instance ElementClass HTMLDetailsElement +instance NodeClass HTMLDetailsElement +instance GObjectClass HTMLDetailsElement where + toGObject = GObject . castForeignPtr . unHTMLDetailsElement + unsafeCastGObject = HTMLDetailsElement . castForeignPtr . unGObject + +castToHTMLDetailsElement :: GObjectClass obj => obj -> HTMLDetailsElement +castToHTMLDetailsElement = castTo gTypeHTMLDetailsElement "HTMLDetailsElement" + +gTypeHTMLDetailsElement :: GType +gTypeHTMLDetailsElement = + {# call fun unsafe webkit_dom_html_details_element_get_type #} + +-- ******************************************************* HTMLDirectoryElement + +{#pointer *WebKitDOMHTMLDirectoryElement as HTMLDirectoryElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLDirectoryElement = (HTMLDirectoryElement, objectUnrefFromMainloop) +unHTMLDirectoryElement (HTMLDirectoryElement o) = o + +class HTMLElementClass o => HTMLDirectoryElementClass o +toHTMLDirectoryElement :: HTMLDirectoryElementClass o => o -> HTMLDirectoryElement +toHTMLDirectoryElement = unsafeCastGObject . toGObject + +instance HTMLDirectoryElementClass HTMLDirectoryElement +instance HTMLElementClass HTMLDirectoryElement +instance ElementClass HTMLDirectoryElement +instance NodeClass HTMLDirectoryElement +instance GObjectClass HTMLDirectoryElement where + toGObject = GObject . castForeignPtr . unHTMLDirectoryElement + unsafeCastGObject = HTMLDirectoryElement . castForeignPtr . unGObject + +castToHTMLDirectoryElement :: GObjectClass obj => obj -> HTMLDirectoryElement +castToHTMLDirectoryElement = castTo gTypeHTMLDirectoryElement "HTMLDirectoryElement" + +gTypeHTMLDirectoryElement :: GType +gTypeHTMLDirectoryElement = + {# call fun unsafe webkit_dom_html_directory_element_get_type #} + +-- ************************************************************* HTMLDivElement + +{#pointer *WebKitDOMHTMLDivElement as HTMLDivElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLDivElement = (HTMLDivElement, objectUnrefFromMainloop) +unHTMLDivElement (HTMLDivElement o) = o + +class HTMLElementClass o => HTMLDivElementClass o +toHTMLDivElement :: HTMLDivElementClass o => o -> HTMLDivElement +toHTMLDivElement = unsafeCastGObject . toGObject + +instance HTMLDivElementClass HTMLDivElement +instance HTMLElementClass HTMLDivElement +instance ElementClass HTMLDivElement +instance NodeClass HTMLDivElement +instance GObjectClass HTMLDivElement where + toGObject = GObject . castForeignPtr . unHTMLDivElement + unsafeCastGObject = HTMLDivElement . castForeignPtr . unGObject + +castToHTMLDivElement :: GObjectClass obj => obj -> HTMLDivElement +castToHTMLDivElement = castTo gTypeHTMLDivElement "HTMLDivElement" + +gTypeHTMLDivElement :: GType +gTypeHTMLDivElement = + {# call fun unsafe webkit_dom_html_div_element_get_type #} + +-- *********************************************************** HTMLEmbedElement + +{#pointer *WebKitDOMHTMLEmbedElement as HTMLEmbedElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLEmbedElement = (HTMLEmbedElement, objectUnrefFromMainloop) +unHTMLEmbedElement (HTMLEmbedElement o) = o + +class HTMLElementClass o => HTMLEmbedElementClass o +toHTMLEmbedElement :: HTMLEmbedElementClass o => o -> HTMLEmbedElement +toHTMLEmbedElement = unsafeCastGObject . toGObject + +instance HTMLEmbedElementClass HTMLEmbedElement +instance HTMLElementClass HTMLEmbedElement +instance ElementClass HTMLEmbedElement +instance NodeClass HTMLEmbedElement +instance GObjectClass HTMLEmbedElement where + toGObject = GObject . castForeignPtr . unHTMLEmbedElement + unsafeCastGObject = HTMLEmbedElement . castForeignPtr . unGObject + +castToHTMLEmbedElement :: GObjectClass obj => obj -> HTMLEmbedElement +castToHTMLEmbedElement = castTo gTypeHTMLEmbedElement "HTMLEmbedElement" + +gTypeHTMLEmbedElement :: GType +gTypeHTMLEmbedElement = + {# call fun unsafe webkit_dom_html_embed_element_get_type #} + +-- ******************************************************** HTMLFieldSetElement + +{#pointer *WebKitDOMHTMLFieldSetElement as HTMLFieldSetElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFieldSetElement = (HTMLFieldSetElement, objectUnrefFromMainloop) +unHTMLFieldSetElement (HTMLFieldSetElement o) = o + +class HTMLElementClass o => HTMLFieldSetElementClass o +toHTMLFieldSetElement :: HTMLFieldSetElementClass o => o -> HTMLFieldSetElement +toHTMLFieldSetElement = unsafeCastGObject . toGObject + +instance HTMLFieldSetElementClass HTMLFieldSetElement +instance HTMLElementClass HTMLFieldSetElement +instance ElementClass HTMLFieldSetElement +instance NodeClass HTMLFieldSetElement +instance GObjectClass HTMLFieldSetElement where + toGObject = GObject . castForeignPtr . unHTMLFieldSetElement + unsafeCastGObject = HTMLFieldSetElement . castForeignPtr . unGObject + +castToHTMLFieldSetElement :: GObjectClass obj => obj -> HTMLFieldSetElement +castToHTMLFieldSetElement = castTo gTypeHTMLFieldSetElement "HTMLFieldSetElement" + +gTypeHTMLFieldSetElement :: GType +gTypeHTMLFieldSetElement = + {# call fun unsafe webkit_dom_html_field_set_element_get_type #} + +-- ************************************************************ HTMLFontElement + +{#pointer *WebKitDOMHTMLFontElement as HTMLFontElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFontElement = (HTMLFontElement, objectUnrefFromMainloop) +unHTMLFontElement (HTMLFontElement o) = o + +class HTMLElementClass o => HTMLFontElementClass o +toHTMLFontElement :: HTMLFontElementClass o => o -> HTMLFontElement +toHTMLFontElement = unsafeCastGObject . toGObject + +instance HTMLFontElementClass HTMLFontElement +instance HTMLElementClass HTMLFontElement +instance ElementClass HTMLFontElement +instance NodeClass HTMLFontElement +instance GObjectClass HTMLFontElement where + toGObject = GObject . castForeignPtr . unHTMLFontElement + unsafeCastGObject = HTMLFontElement . castForeignPtr . unGObject + +castToHTMLFontElement :: GObjectClass obj => obj -> HTMLFontElement +castToHTMLFontElement = castTo gTypeHTMLFontElement "HTMLFontElement" + +gTypeHTMLFontElement :: GType +gTypeHTMLFontElement = + {# call fun unsafe webkit_dom_html_font_element_get_type #} + +-- ************************************************************ HTMLFormElement + +{#pointer *WebKitDOMHTMLFormElement as HTMLFormElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFormElement = (HTMLFormElement, objectUnrefFromMainloop) +unHTMLFormElement (HTMLFormElement o) = o + +class HTMLElementClass o => HTMLFormElementClass o +toHTMLFormElement :: HTMLFormElementClass o => o -> HTMLFormElement +toHTMLFormElement = unsafeCastGObject . toGObject + +instance HTMLFormElementClass HTMLFormElement +instance HTMLElementClass HTMLFormElement +instance ElementClass HTMLFormElement +instance NodeClass HTMLFormElement +instance GObjectClass HTMLFormElement where + toGObject = GObject . castForeignPtr . unHTMLFormElement + unsafeCastGObject = HTMLFormElement . castForeignPtr . unGObject + +castToHTMLFormElement :: GObjectClass obj => obj -> HTMLFormElement +castToHTMLFormElement = castTo gTypeHTMLFormElement "HTMLFormElement" + +gTypeHTMLFormElement :: GType +gTypeHTMLFormElement = + {# call fun unsafe webkit_dom_html_form_element_get_type #} + +-- *********************************************************** HTMLFrameElement + +{#pointer *WebKitDOMHTMLFrameElement as HTMLFrameElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFrameElement = (HTMLFrameElement, objectUnrefFromMainloop) +unHTMLFrameElement (HTMLFrameElement o) = o + +class HTMLElementClass o => HTMLFrameElementClass o +toHTMLFrameElement :: HTMLFrameElementClass o => o -> HTMLFrameElement +toHTMLFrameElement = unsafeCastGObject . toGObject + +instance HTMLFrameElementClass HTMLFrameElement +instance HTMLElementClass HTMLFrameElement +instance ElementClass HTMLFrameElement +instance NodeClass HTMLFrameElement +instance GObjectClass HTMLFrameElement where + toGObject = GObject . castForeignPtr . unHTMLFrameElement + unsafeCastGObject = HTMLFrameElement . castForeignPtr . unGObject + +castToHTMLFrameElement :: GObjectClass obj => obj -> HTMLFrameElement +castToHTMLFrameElement = castTo gTypeHTMLFrameElement "HTMLFrameElement" + +gTypeHTMLFrameElement :: GType +gTypeHTMLFrameElement = + {# call fun unsafe webkit_dom_html_frame_element_get_type #} + +-- ******************************************************** HTMLFrameSetElement + +{#pointer *WebKitDOMHTMLFrameSetElement as HTMLFrameSetElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFrameSetElement = (HTMLFrameSetElement, objectUnrefFromMainloop) +unHTMLFrameSetElement (HTMLFrameSetElement o) = o + +class HTMLElementClass o => HTMLFrameSetElementClass o +toHTMLFrameSetElement :: HTMLFrameSetElementClass o => o -> HTMLFrameSetElement +toHTMLFrameSetElement = unsafeCastGObject . toGObject + +instance HTMLFrameSetElementClass HTMLFrameSetElement +instance HTMLElementClass HTMLFrameSetElement +instance ElementClass HTMLFrameSetElement +instance NodeClass HTMLFrameSetElement +instance GObjectClass HTMLFrameSetElement where + toGObject = GObject . castForeignPtr . unHTMLFrameSetElement + unsafeCastGObject = HTMLFrameSetElement . castForeignPtr . unGObject + +castToHTMLFrameSetElement :: GObjectClass obj => obj -> HTMLFrameSetElement +castToHTMLFrameSetElement = castTo gTypeHTMLFrameSetElement "HTMLFrameSetElement" + +gTypeHTMLFrameSetElement :: GType +gTypeHTMLFrameSetElement = + {# call fun unsafe webkit_dom_html_frame_set_element_get_type #} + +-- ************************************************************** HTMLHRElement + +{#pointer *WebKitDOMHTMLHRElement as HTMLHRElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLHRElement = (HTMLHRElement, objectUnrefFromMainloop) +unHTMLHRElement (HTMLHRElement o) = o + +class HTMLElementClass o => HTMLHRElementClass o +toHTMLHRElement :: HTMLHRElementClass o => o -> HTMLHRElement +toHTMLHRElement = unsafeCastGObject . toGObject + +instance HTMLHRElementClass HTMLHRElement +instance HTMLElementClass HTMLHRElement +instance ElementClass HTMLHRElement +instance NodeClass HTMLHRElement +instance GObjectClass HTMLHRElement where + toGObject = GObject . castForeignPtr . unHTMLHRElement + unsafeCastGObject = HTMLHRElement . castForeignPtr . unGObject + +castToHTMLHRElement :: GObjectClass obj => obj -> HTMLHRElement +castToHTMLHRElement = castTo gTypeHTMLHRElement "HTMLHRElement" + +gTypeHTMLHRElement :: GType +gTypeHTMLHRElement = + {# call fun unsafe webkit_dom_htmlhr_element_get_type #} + +-- ************************************************************ HTMLHeadElement + +{#pointer *WebKitDOMHTMLHeadElement as HTMLHeadElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLHeadElement = (HTMLHeadElement, objectUnrefFromMainloop) +unHTMLHeadElement (HTMLHeadElement o) = o + +class HTMLElementClass o => HTMLHeadElementClass o +toHTMLHeadElement :: HTMLHeadElementClass o => o -> HTMLHeadElement +toHTMLHeadElement = unsafeCastGObject . toGObject + +instance HTMLHeadElementClass HTMLHeadElement +instance HTMLElementClass HTMLHeadElement +instance ElementClass HTMLHeadElement +instance NodeClass HTMLHeadElement +instance GObjectClass HTMLHeadElement where + toGObject = GObject . castForeignPtr . unHTMLHeadElement + unsafeCastGObject = HTMLHeadElement . castForeignPtr . unGObject + +castToHTMLHeadElement :: GObjectClass obj => obj -> HTMLHeadElement +castToHTMLHeadElement = castTo gTypeHTMLHeadElement "HTMLHeadElement" + +gTypeHTMLHeadElement :: GType +gTypeHTMLHeadElement = + {# call fun unsafe webkit_dom_html_head_element_get_type #} + +-- ********************************************************* HTMLHeadingElement + +{#pointer *WebKitDOMHTMLHeadingElement as HTMLHeadingElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLHeadingElement = (HTMLHeadingElement, objectUnrefFromMainloop) +unHTMLHeadingElement (HTMLHeadingElement o) = o + +class HTMLElementClass o => HTMLHeadingElementClass o +toHTMLHeadingElement :: HTMLHeadingElementClass o => o -> HTMLHeadingElement +toHTMLHeadingElement = unsafeCastGObject . toGObject + +instance HTMLHeadingElementClass HTMLHeadingElement +instance HTMLElementClass HTMLHeadingElement +instance ElementClass HTMLHeadingElement +instance NodeClass HTMLHeadingElement +instance GObjectClass HTMLHeadingElement where + toGObject = GObject . castForeignPtr . unHTMLHeadingElement + unsafeCastGObject = HTMLHeadingElement . castForeignPtr . unGObject + +castToHTMLHeadingElement :: GObjectClass obj => obj -> HTMLHeadingElement +castToHTMLHeadingElement = castTo gTypeHTMLHeadingElement "HTMLHeadingElement" + +gTypeHTMLHeadingElement :: GType +gTypeHTMLHeadingElement = + {# call fun unsafe webkit_dom_html_heading_element_get_type #} + +-- ************************************************************ HTMLHtmlElement + +{#pointer *WebKitDOMHTMLHtmlElement as HTMLHtmlElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLHtmlElement = (HTMLHtmlElement, objectUnrefFromMainloop) +unHTMLHtmlElement (HTMLHtmlElement o) = o + +class HTMLElementClass o => HTMLHtmlElementClass o +toHTMLHtmlElement :: HTMLHtmlElementClass o => o -> HTMLHtmlElement +toHTMLHtmlElement = unsafeCastGObject . toGObject + +instance HTMLHtmlElementClass HTMLHtmlElement +instance HTMLElementClass HTMLHtmlElement +instance ElementClass HTMLHtmlElement +instance NodeClass HTMLHtmlElement +instance GObjectClass HTMLHtmlElement where + toGObject = GObject . castForeignPtr . unHTMLHtmlElement + unsafeCastGObject = HTMLHtmlElement . castForeignPtr . unGObject + +castToHTMLHtmlElement :: GObjectClass obj => obj -> HTMLHtmlElement +castToHTMLHtmlElement = castTo gTypeHTMLHtmlElement "HTMLHtmlElement" + +gTypeHTMLHtmlElement :: GType +gTypeHTMLHtmlElement = + {# call fun unsafe webkit_dom_html_html_element_get_type #} + +-- ********************************************************** HTMLIFrameElement + +{#pointer *WebKitDOMHTMLIFrameElement as HTMLIFrameElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLIFrameElement = (HTMLIFrameElement, objectUnrefFromMainloop) +unHTMLIFrameElement (HTMLIFrameElement o) = o + +class HTMLElementClass o => HTMLIFrameElementClass o +toHTMLIFrameElement :: HTMLIFrameElementClass o => o -> HTMLIFrameElement +toHTMLIFrameElement = unsafeCastGObject . toGObject + +instance HTMLIFrameElementClass HTMLIFrameElement +instance HTMLElementClass HTMLIFrameElement +instance ElementClass HTMLIFrameElement +instance NodeClass HTMLIFrameElement +instance GObjectClass HTMLIFrameElement where + toGObject = GObject . castForeignPtr . unHTMLIFrameElement + unsafeCastGObject = HTMLIFrameElement . castForeignPtr . unGObject + +castToHTMLIFrameElement :: GObjectClass obj => obj -> HTMLIFrameElement +castToHTMLIFrameElement = castTo gTypeHTMLIFrameElement "HTMLIFrameElement" + +gTypeHTMLIFrameElement :: GType +gTypeHTMLIFrameElement = + {# call fun unsafe webkit_dom_html_iframe_element_get_type #} + +-- *********************************************************** HTMLImageElement + +{#pointer *WebKitDOMHTMLImageElement as HTMLImageElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLImageElement = (HTMLImageElement, objectUnrefFromMainloop) +unHTMLImageElement (HTMLImageElement o) = o + +class HTMLElementClass o => HTMLImageElementClass o +toHTMLImageElement :: HTMLImageElementClass o => o -> HTMLImageElement +toHTMLImageElement = unsafeCastGObject . toGObject + +instance HTMLImageElementClass HTMLImageElement +instance HTMLElementClass HTMLImageElement +instance ElementClass HTMLImageElement +instance NodeClass HTMLImageElement +instance GObjectClass HTMLImageElement where + toGObject = GObject . castForeignPtr . unHTMLImageElement + unsafeCastGObject = HTMLImageElement . castForeignPtr . unGObject + +castToHTMLImageElement :: GObjectClass obj => obj -> HTMLImageElement +castToHTMLImageElement = castTo gTypeHTMLImageElement "HTMLImageElement" + +gTypeHTMLImageElement :: GType +gTypeHTMLImageElement = + {# call fun unsafe webkit_dom_html_image_element_get_type #} + +-- *********************************************************** HTMLInputElement + +{#pointer *WebKitDOMHTMLInputElement as HTMLInputElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLInputElement = (HTMLInputElement, objectUnrefFromMainloop) +unHTMLInputElement (HTMLInputElement o) = o + +class HTMLElementClass o => HTMLInputElementClass o +toHTMLInputElement :: HTMLInputElementClass o => o -> HTMLInputElement +toHTMLInputElement = unsafeCastGObject . toGObject + +instance HTMLInputElementClass HTMLInputElement +instance HTMLElementClass HTMLInputElement +instance ElementClass HTMLInputElement +instance NodeClass HTMLInputElement +instance GObjectClass HTMLInputElement where + toGObject = GObject . castForeignPtr . unHTMLInputElement + unsafeCastGObject = HTMLInputElement . castForeignPtr . unGObject + +castToHTMLInputElement :: GObjectClass obj => obj -> HTMLInputElement +castToHTMLInputElement = castTo gTypeHTMLInputElement "HTMLInputElement" + +gTypeHTMLInputElement :: GType +gTypeHTMLInputElement = + {# call fun unsafe webkit_dom_html_input_element_get_type #} + +-- ********************************************************** HTMLKeygenElement + +{#pointer *WebKitDOMHTMLKeygenElement as HTMLKeygenElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLKeygenElement = (HTMLKeygenElement, objectUnrefFromMainloop) +unHTMLKeygenElement (HTMLKeygenElement o) = o + +class HTMLElementClass o => HTMLKeygenElementClass o +toHTMLKeygenElement :: HTMLKeygenElementClass o => o -> HTMLKeygenElement +toHTMLKeygenElement = unsafeCastGObject . toGObject + +instance HTMLKeygenElementClass HTMLKeygenElement +instance HTMLElementClass HTMLKeygenElement +instance ElementClass HTMLKeygenElement +instance NodeClass HTMLKeygenElement +instance GObjectClass HTMLKeygenElement where + toGObject = GObject . castForeignPtr . unHTMLKeygenElement + unsafeCastGObject = HTMLKeygenElement . castForeignPtr . unGObject + +castToHTMLKeygenElement :: GObjectClass obj => obj -> HTMLKeygenElement +castToHTMLKeygenElement = castTo gTypeHTMLKeygenElement "HTMLKeygenElement" + +gTypeHTMLKeygenElement :: GType +gTypeHTMLKeygenElement = + {# call fun unsafe webkit_dom_html_keygen_element_get_type #} + +-- ************************************************************** HTMLLIElement + +{#pointer *WebKitDOMHTMLLIElement as HTMLLIElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLLIElement = (HTMLLIElement, objectUnrefFromMainloop) +unHTMLLIElement (HTMLLIElement o) = o + +class HTMLElementClass o => HTMLLIElementClass o +toHTMLLIElement :: HTMLLIElementClass o => o -> HTMLLIElement +toHTMLLIElement = unsafeCastGObject . toGObject + +instance HTMLLIElementClass HTMLLIElement +instance HTMLElementClass HTMLLIElement +instance ElementClass HTMLLIElement +instance NodeClass HTMLLIElement +instance GObjectClass HTMLLIElement where + toGObject = GObject . castForeignPtr . unHTMLLIElement + unsafeCastGObject = HTMLLIElement . castForeignPtr . unGObject + +castToHTMLLIElement :: GObjectClass obj => obj -> HTMLLIElement +castToHTMLLIElement = castTo gTypeHTMLLIElement "HTMLLIElement" + +gTypeHTMLLIElement :: GType +gTypeHTMLLIElement = + {# call fun unsafe webkit_dom_htmlli_element_get_type #} + +-- *********************************************************** HTMLLabelElement + +{#pointer *WebKitDOMHTMLLabelElement as HTMLLabelElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLLabelElement = (HTMLLabelElement, objectUnrefFromMainloop) +unHTMLLabelElement (HTMLLabelElement o) = o + +class HTMLElementClass o => HTMLLabelElementClass o +toHTMLLabelElement :: HTMLLabelElementClass o => o -> HTMLLabelElement +toHTMLLabelElement = unsafeCastGObject . toGObject + +instance HTMLLabelElementClass HTMLLabelElement +instance HTMLElementClass HTMLLabelElement +instance ElementClass HTMLLabelElement +instance NodeClass HTMLLabelElement +instance GObjectClass HTMLLabelElement where + toGObject = GObject . castForeignPtr . unHTMLLabelElement + unsafeCastGObject = HTMLLabelElement . castForeignPtr . unGObject + +castToHTMLLabelElement :: GObjectClass obj => obj -> HTMLLabelElement +castToHTMLLabelElement = castTo gTypeHTMLLabelElement "HTMLLabelElement" + +gTypeHTMLLabelElement :: GType +gTypeHTMLLabelElement = + {# call fun unsafe webkit_dom_html_label_element_get_type #} + +-- ********************************************************** HTMLLegendElement + +{#pointer *WebKitDOMHTMLLegendElement as HTMLLegendElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLLegendElement = (HTMLLegendElement, objectUnrefFromMainloop) +unHTMLLegendElement (HTMLLegendElement o) = o + +class HTMLElementClass o => HTMLLegendElementClass o +toHTMLLegendElement :: HTMLLegendElementClass o => o -> HTMLLegendElement +toHTMLLegendElement = unsafeCastGObject . toGObject + +instance HTMLLegendElementClass HTMLLegendElement +instance HTMLElementClass HTMLLegendElement +instance ElementClass HTMLLegendElement +instance NodeClass HTMLLegendElement +instance GObjectClass HTMLLegendElement where + toGObject = GObject . castForeignPtr . unHTMLLegendElement + unsafeCastGObject = HTMLLegendElement . castForeignPtr . unGObject + +castToHTMLLegendElement :: GObjectClass obj => obj -> HTMLLegendElement +castToHTMLLegendElement = castTo gTypeHTMLLegendElement "HTMLLegendElement" + +gTypeHTMLLegendElement :: GType +gTypeHTMLLegendElement = + {# call fun unsafe webkit_dom_html_legend_element_get_type #} + +-- ************************************************************ HTMLLinkElement + +{#pointer *WebKitDOMHTMLLinkElement as HTMLLinkElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLLinkElement = (HTMLLinkElement, objectUnrefFromMainloop) +unHTMLLinkElement (HTMLLinkElement o) = o + +class HTMLElementClass o => HTMLLinkElementClass o +toHTMLLinkElement :: HTMLLinkElementClass o => o -> HTMLLinkElement +toHTMLLinkElement = unsafeCastGObject . toGObject + +instance HTMLLinkElementClass HTMLLinkElement +instance HTMLElementClass HTMLLinkElement +instance ElementClass HTMLLinkElement +instance NodeClass HTMLLinkElement +instance GObjectClass HTMLLinkElement where + toGObject = GObject . castForeignPtr . unHTMLLinkElement + unsafeCastGObject = HTMLLinkElement . castForeignPtr . unGObject + +castToHTMLLinkElement :: GObjectClass obj => obj -> HTMLLinkElement +castToHTMLLinkElement = castTo gTypeHTMLLinkElement "HTMLLinkElement" + +gTypeHTMLLinkElement :: GType +gTypeHTMLLinkElement = + {# call fun unsafe webkit_dom_html_link_element_get_type #} + +-- ************************************************************* HTMLMapElement + +{#pointer *WebKitDOMHTMLMapElement as HTMLMapElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMapElement = (HTMLMapElement, objectUnrefFromMainloop) +unHTMLMapElement (HTMLMapElement o) = o + +class HTMLElementClass o => HTMLMapElementClass o +toHTMLMapElement :: HTMLMapElementClass o => o -> HTMLMapElement +toHTMLMapElement = unsafeCastGObject . toGObject + +instance HTMLMapElementClass HTMLMapElement +instance HTMLElementClass HTMLMapElement +instance ElementClass HTMLMapElement +instance NodeClass HTMLMapElement +instance GObjectClass HTMLMapElement where + toGObject = GObject . castForeignPtr . unHTMLMapElement + unsafeCastGObject = HTMLMapElement . castForeignPtr . unGObject + +castToHTMLMapElement :: GObjectClass obj => obj -> HTMLMapElement +castToHTMLMapElement = castTo gTypeHTMLMapElement "HTMLMapElement" + +gTypeHTMLMapElement :: GType +gTypeHTMLMapElement = + {# call fun unsafe webkit_dom_html_map_element_get_type #} + +-- ********************************************************* HTMLMarqueeElement + +{#pointer *WebKitDOMHTMLMarqueeElement as HTMLMarqueeElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMarqueeElement = (HTMLMarqueeElement, objectUnrefFromMainloop) +unHTMLMarqueeElement (HTMLMarqueeElement o) = o + +class HTMLElementClass o => HTMLMarqueeElementClass o +toHTMLMarqueeElement :: HTMLMarqueeElementClass o => o -> HTMLMarqueeElement +toHTMLMarqueeElement = unsafeCastGObject . toGObject + +instance HTMLMarqueeElementClass HTMLMarqueeElement +instance HTMLElementClass HTMLMarqueeElement +instance ElementClass HTMLMarqueeElement +instance NodeClass HTMLMarqueeElement +instance GObjectClass HTMLMarqueeElement where + toGObject = GObject . castForeignPtr . unHTMLMarqueeElement + unsafeCastGObject = HTMLMarqueeElement . castForeignPtr . unGObject + +castToHTMLMarqueeElement :: GObjectClass obj => obj -> HTMLMarqueeElement +castToHTMLMarqueeElement = castTo gTypeHTMLMarqueeElement "HTMLMarqueeElement" + +gTypeHTMLMarqueeElement :: GType +gTypeHTMLMarqueeElement = + {# call fun unsafe webkit_dom_html_marquee_element_get_type #} + +-- *********************************************************** HTMLMediaElement + +{#pointer *WebKitDOMHTMLMediaElement as HTMLMediaElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMediaElement = (HTMLMediaElement, objectUnrefFromMainloop) +unHTMLMediaElement (HTMLMediaElement o) = o + +class HTMLElementClass o => HTMLMediaElementClass o +toHTMLMediaElement :: HTMLMediaElementClass o => o -> HTMLMediaElement +toHTMLMediaElement = unsafeCastGObject . toGObject + +instance HTMLMediaElementClass HTMLMediaElement +instance HTMLElementClass HTMLMediaElement +instance ElementClass HTMLMediaElement +instance NodeClass HTMLMediaElement +instance GObjectClass HTMLMediaElement where + toGObject = GObject . castForeignPtr . unHTMLMediaElement + unsafeCastGObject = HTMLMediaElement . castForeignPtr . unGObject + +castToHTMLMediaElement :: GObjectClass obj => obj -> HTMLMediaElement +castToHTMLMediaElement = castTo gTypeHTMLMediaElement "HTMLMediaElement" + +gTypeHTMLMediaElement :: GType +gTypeHTMLMediaElement = + {# call fun unsafe webkit_dom_html_media_element_get_type #} + +-- *********************************************************** HTMLAudioElement + +{#pointer *WebKitDOMHTMLAudioElement as HTMLAudioElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLAudioElement = (HTMLAudioElement, objectUnrefFromMainloop) +unHTMLAudioElement (HTMLAudioElement o) = o + +class HTMLMediaElementClass o => HTMLAudioElementClass o +toHTMLAudioElement :: HTMLAudioElementClass o => o -> HTMLAudioElement +toHTMLAudioElement = unsafeCastGObject . toGObject + +instance HTMLAudioElementClass HTMLAudioElement +instance HTMLMediaElementClass HTMLAudioElement +instance HTMLElementClass HTMLAudioElement +instance ElementClass HTMLAudioElement +instance NodeClass HTMLAudioElement +instance GObjectClass HTMLAudioElement where + toGObject = GObject . castForeignPtr . unHTMLAudioElement + unsafeCastGObject = HTMLAudioElement . castForeignPtr . unGObject + +castToHTMLAudioElement :: GObjectClass obj => obj -> HTMLAudioElement +castToHTMLAudioElement = castTo gTypeHTMLAudioElement "HTMLAudioElement" + +gTypeHTMLAudioElement :: GType +gTypeHTMLAudioElement = + {# call fun unsafe webkit_dom_html_audio_element_get_type #} + +-- *********************************************************** HTMLVideoElement + +{#pointer *WebKitDOMHTMLVideoElement as HTMLVideoElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLVideoElement = (HTMLVideoElement, objectUnrefFromMainloop) +unHTMLVideoElement (HTMLVideoElement o) = o + +class HTMLMediaElementClass o => HTMLVideoElementClass o +toHTMLVideoElement :: HTMLVideoElementClass o => o -> HTMLVideoElement +toHTMLVideoElement = unsafeCastGObject . toGObject + +instance HTMLVideoElementClass HTMLVideoElement +instance HTMLMediaElementClass HTMLVideoElement +instance HTMLElementClass HTMLVideoElement +instance ElementClass HTMLVideoElement +instance NodeClass HTMLVideoElement +instance GObjectClass HTMLVideoElement where + toGObject = GObject . castForeignPtr . unHTMLVideoElement + unsafeCastGObject = HTMLVideoElement . castForeignPtr . unGObject + +castToHTMLVideoElement :: GObjectClass obj => obj -> HTMLVideoElement +castToHTMLVideoElement = castTo gTypeHTMLVideoElement "HTMLVideoElement" + +gTypeHTMLVideoElement :: GType +gTypeHTMLVideoElement = + {# call fun unsafe webkit_dom_html_video_element_get_type #} + +-- ************************************************************ HTMLMenuElement + +{#pointer *WebKitDOMHTMLMenuElement as HTMLMenuElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMenuElement = (HTMLMenuElement, objectUnrefFromMainloop) +unHTMLMenuElement (HTMLMenuElement o) = o + +class HTMLElementClass o => HTMLMenuElementClass o +toHTMLMenuElement :: HTMLMenuElementClass o => o -> HTMLMenuElement +toHTMLMenuElement = unsafeCastGObject . toGObject + +instance HTMLMenuElementClass HTMLMenuElement +instance HTMLElementClass HTMLMenuElement +instance ElementClass HTMLMenuElement +instance NodeClass HTMLMenuElement +instance GObjectClass HTMLMenuElement where + toGObject = GObject . castForeignPtr . unHTMLMenuElement + unsafeCastGObject = HTMLMenuElement . castForeignPtr . unGObject + +castToHTMLMenuElement :: GObjectClass obj => obj -> HTMLMenuElement +castToHTMLMenuElement = castTo gTypeHTMLMenuElement "HTMLMenuElement" + +gTypeHTMLMenuElement :: GType +gTypeHTMLMenuElement = + {# call fun unsafe webkit_dom_html_menu_element_get_type #} + +-- ************************************************************ HTMLMetaElement + +{#pointer *WebKitDOMHTMLMetaElement as HTMLMetaElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMetaElement = (HTMLMetaElement, objectUnrefFromMainloop) +unHTMLMetaElement (HTMLMetaElement o) = o + +class HTMLElementClass o => HTMLMetaElementClass o +toHTMLMetaElement :: HTMLMetaElementClass o => o -> HTMLMetaElement +toHTMLMetaElement = unsafeCastGObject . toGObject + +instance HTMLMetaElementClass HTMLMetaElement +instance HTMLElementClass HTMLMetaElement +instance ElementClass HTMLMetaElement +instance NodeClass HTMLMetaElement +instance GObjectClass HTMLMetaElement where + toGObject = GObject . castForeignPtr . unHTMLMetaElement + unsafeCastGObject = HTMLMetaElement . castForeignPtr . unGObject + +castToHTMLMetaElement :: GObjectClass obj => obj -> HTMLMetaElement +castToHTMLMetaElement = castTo gTypeHTMLMetaElement "HTMLMetaElement" + +gTypeHTMLMetaElement :: GType +gTypeHTMLMetaElement = + {# call fun unsafe webkit_dom_html_meta_element_get_type #} + +-- ************************************************************* HTMLModElement + +{#pointer *WebKitDOMHTMLModElement as HTMLModElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLModElement = (HTMLModElement, objectUnrefFromMainloop) +unHTMLModElement (HTMLModElement o) = o + +class HTMLElementClass o => HTMLModElementClass o +toHTMLModElement :: HTMLModElementClass o => o -> HTMLModElement +toHTMLModElement = unsafeCastGObject . toGObject + +instance HTMLModElementClass HTMLModElement +instance HTMLElementClass HTMLModElement +instance ElementClass HTMLModElement +instance NodeClass HTMLModElement +instance GObjectClass HTMLModElement where + toGObject = GObject . castForeignPtr . unHTMLModElement + unsafeCastGObject = HTMLModElement . castForeignPtr . unGObject + +castToHTMLModElement :: GObjectClass obj => obj -> HTMLModElement +castToHTMLModElement = castTo gTypeHTMLModElement "HTMLModElement" + +gTypeHTMLModElement :: GType +gTypeHTMLModElement = + {# call fun unsafe webkit_dom_html_mod_element_get_type #} + +-- *********************************************************** HTMLOListElement + +{#pointer *WebKitDOMHTMLOListElement as HTMLOListElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLOListElement = (HTMLOListElement, objectUnrefFromMainloop) +unHTMLOListElement (HTMLOListElement o) = o + +class HTMLElementClass o => HTMLOListElementClass o +toHTMLOListElement :: HTMLOListElementClass o => o -> HTMLOListElement +toHTMLOListElement = unsafeCastGObject . toGObject + +instance HTMLOListElementClass HTMLOListElement +instance HTMLElementClass HTMLOListElement +instance ElementClass HTMLOListElement +instance NodeClass HTMLOListElement +instance GObjectClass HTMLOListElement where + toGObject = GObject . castForeignPtr . unHTMLOListElement + unsafeCastGObject = HTMLOListElement . castForeignPtr . unGObject + +castToHTMLOListElement :: GObjectClass obj => obj -> HTMLOListElement +castToHTMLOListElement = castTo gTypeHTMLOListElement "HTMLOListElement" + +gTypeHTMLOListElement :: GType +gTypeHTMLOListElement = + {# call fun unsafe webkit_dom_htmlo_list_element_get_type #} + +-- ********************************************************** HTMLObjectElement + +{#pointer *WebKitDOMHTMLObjectElement as HTMLObjectElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLObjectElement = (HTMLObjectElement, objectUnrefFromMainloop) +unHTMLObjectElement (HTMLObjectElement o) = o + +class HTMLElementClass o => HTMLObjectElementClass o +toHTMLObjectElement :: HTMLObjectElementClass o => o -> HTMLObjectElement +toHTMLObjectElement = unsafeCastGObject . toGObject + +instance HTMLObjectElementClass HTMLObjectElement +instance HTMLElementClass HTMLObjectElement +instance ElementClass HTMLObjectElement +instance NodeClass HTMLObjectElement +instance GObjectClass HTMLObjectElement where + toGObject = GObject . castForeignPtr . unHTMLObjectElement + unsafeCastGObject = HTMLObjectElement . castForeignPtr . unGObject + +castToHTMLObjectElement :: GObjectClass obj => obj -> HTMLObjectElement +castToHTMLObjectElement = castTo gTypeHTMLObjectElement "HTMLObjectElement" + +gTypeHTMLObjectElement :: GType +gTypeHTMLObjectElement = + {# call fun unsafe webkit_dom_html_object_element_get_type #} + +-- ******************************************************** HTMLOptGroupElement + +{#pointer *WebKitDOMHTMLOptGroupElement as HTMLOptGroupElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLOptGroupElement = (HTMLOptGroupElement, objectUnrefFromMainloop) +unHTMLOptGroupElement (HTMLOptGroupElement o) = o + +class HTMLElementClass o => HTMLOptGroupElementClass o +toHTMLOptGroupElement :: HTMLOptGroupElementClass o => o -> HTMLOptGroupElement +toHTMLOptGroupElement = unsafeCastGObject . toGObject + +instance HTMLOptGroupElementClass HTMLOptGroupElement +instance HTMLElementClass HTMLOptGroupElement +instance ElementClass HTMLOptGroupElement +instance NodeClass HTMLOptGroupElement +instance GObjectClass HTMLOptGroupElement where + toGObject = GObject . castForeignPtr . unHTMLOptGroupElement + unsafeCastGObject = HTMLOptGroupElement . castForeignPtr . unGObject + +castToHTMLOptGroupElement :: GObjectClass obj => obj -> HTMLOptGroupElement +castToHTMLOptGroupElement = castTo gTypeHTMLOptGroupElement "HTMLOptGroupElement" + +gTypeHTMLOptGroupElement :: GType +gTypeHTMLOptGroupElement = + {# call fun unsafe webkit_dom_html_opt_group_element_get_type #} + +-- ********************************************************** HTMLOptionElement + +{#pointer *WebKitDOMHTMLOptionElement as HTMLOptionElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLOptionElement = (HTMLOptionElement, objectUnrefFromMainloop) +unHTMLOptionElement (HTMLOptionElement o) = o + +class HTMLElementClass o => HTMLOptionElementClass o +toHTMLOptionElement :: HTMLOptionElementClass o => o -> HTMLOptionElement +toHTMLOptionElement = unsafeCastGObject . toGObject + +instance HTMLOptionElementClass HTMLOptionElement +instance HTMLElementClass HTMLOptionElement +instance ElementClass HTMLOptionElement +instance NodeClass HTMLOptionElement +instance GObjectClass HTMLOptionElement where + toGObject = GObject . castForeignPtr . unHTMLOptionElement + unsafeCastGObject = HTMLOptionElement . castForeignPtr . unGObject + +castToHTMLOptionElement :: GObjectClass obj => obj -> HTMLOptionElement +castToHTMLOptionElement = castTo gTypeHTMLOptionElement "HTMLOptionElement" + +gTypeHTMLOptionElement :: GType +gTypeHTMLOptionElement = + {# call fun unsafe webkit_dom_html_option_element_get_type #} + +-- ******************************************************* HTMLParagraphElement + +{#pointer *WebKitDOMHTMLParagraphElement as HTMLParagraphElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLParagraphElement = (HTMLParagraphElement, objectUnrefFromMainloop) +unHTMLParagraphElement (HTMLParagraphElement o) = o + +class HTMLElementClass o => HTMLParagraphElementClass o +toHTMLParagraphElement :: HTMLParagraphElementClass o => o -> HTMLParagraphElement +toHTMLParagraphElement = unsafeCastGObject . toGObject + +instance HTMLParagraphElementClass HTMLParagraphElement +instance HTMLElementClass HTMLParagraphElement +instance ElementClass HTMLParagraphElement +instance NodeClass HTMLParagraphElement +instance GObjectClass HTMLParagraphElement where + toGObject = GObject . castForeignPtr . unHTMLParagraphElement + unsafeCastGObject = HTMLParagraphElement . castForeignPtr . unGObject + +castToHTMLParagraphElement :: GObjectClass obj => obj -> HTMLParagraphElement +castToHTMLParagraphElement = castTo gTypeHTMLParagraphElement "HTMLParagraphElement" + +gTypeHTMLParagraphElement :: GType +gTypeHTMLParagraphElement = + {# call fun unsafe webkit_dom_html_paragraph_element_get_type #} + +-- *********************************************************** HTMLParamElement + +{#pointer *WebKitDOMHTMLParamElement as HTMLParamElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLParamElement = (HTMLParamElement, objectUnrefFromMainloop) +unHTMLParamElement (HTMLParamElement o) = o + +class HTMLElementClass o => HTMLParamElementClass o +toHTMLParamElement :: HTMLParamElementClass o => o -> HTMLParamElement +toHTMLParamElement = unsafeCastGObject . toGObject + +instance HTMLParamElementClass HTMLParamElement +instance HTMLElementClass HTMLParamElement +instance ElementClass HTMLParamElement +instance NodeClass HTMLParamElement +instance GObjectClass HTMLParamElement where + toGObject = GObject . castForeignPtr . unHTMLParamElement + unsafeCastGObject = HTMLParamElement . castForeignPtr . unGObject + +castToHTMLParamElement :: GObjectClass obj => obj -> HTMLParamElement +castToHTMLParamElement = castTo gTypeHTMLParamElement "HTMLParamElement" + +gTypeHTMLParamElement :: GType +gTypeHTMLParamElement = + {# call fun unsafe webkit_dom_html_param_element_get_type #} + +-- ************************************************************* HTMLPreElement + +{#pointer *WebKitDOMHTMLPreElement as HTMLPreElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLPreElement = (HTMLPreElement, objectUnrefFromMainloop) +unHTMLPreElement (HTMLPreElement o) = o + +class HTMLElementClass o => HTMLPreElementClass o +toHTMLPreElement :: HTMLPreElementClass o => o -> HTMLPreElement +toHTMLPreElement = unsafeCastGObject . toGObject + +instance HTMLPreElementClass HTMLPreElement +instance HTMLElementClass HTMLPreElement +instance ElementClass HTMLPreElement +instance NodeClass HTMLPreElement +instance GObjectClass HTMLPreElement where + toGObject = GObject . castForeignPtr . unHTMLPreElement + unsafeCastGObject = HTMLPreElement . castForeignPtr . unGObject + +castToHTMLPreElement :: GObjectClass obj => obj -> HTMLPreElement +castToHTMLPreElement = castTo gTypeHTMLPreElement "HTMLPreElement" + +gTypeHTMLPreElement :: GType +gTypeHTMLPreElement = + {# call fun unsafe webkit_dom_html_pre_element_get_type #} + +-- *********************************************************** HTMLQuoteElement + +{#pointer *WebKitDOMHTMLQuoteElement as HTMLQuoteElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLQuoteElement = (HTMLQuoteElement, objectUnrefFromMainloop) +unHTMLQuoteElement (HTMLQuoteElement o) = o + +class HTMLElementClass o => HTMLQuoteElementClass o +toHTMLQuoteElement :: HTMLQuoteElementClass o => o -> HTMLQuoteElement +toHTMLQuoteElement = unsafeCastGObject . toGObject + +instance HTMLQuoteElementClass HTMLQuoteElement +instance HTMLElementClass HTMLQuoteElement +instance ElementClass HTMLQuoteElement +instance NodeClass HTMLQuoteElement +instance GObjectClass HTMLQuoteElement where + toGObject = GObject . castForeignPtr . unHTMLQuoteElement + unsafeCastGObject = HTMLQuoteElement . castForeignPtr . unGObject + +castToHTMLQuoteElement :: GObjectClass obj => obj -> HTMLQuoteElement +castToHTMLQuoteElement = castTo gTypeHTMLQuoteElement "HTMLQuoteElement" + +gTypeHTMLQuoteElement :: GType +gTypeHTMLQuoteElement = + {# call fun unsafe webkit_dom_html_quote_element_get_type #} + +-- ********************************************************** HTMLScriptElement + +{#pointer *WebKitDOMHTMLScriptElement as HTMLScriptElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLScriptElement = (HTMLScriptElement, objectUnrefFromMainloop) +unHTMLScriptElement (HTMLScriptElement o) = o + +class HTMLElementClass o => HTMLScriptElementClass o +toHTMLScriptElement :: HTMLScriptElementClass o => o -> HTMLScriptElement +toHTMLScriptElement = unsafeCastGObject . toGObject + +instance HTMLScriptElementClass HTMLScriptElement +instance HTMLElementClass HTMLScriptElement +instance ElementClass HTMLScriptElement +instance NodeClass HTMLScriptElement +instance GObjectClass HTMLScriptElement where + toGObject = GObject . castForeignPtr . unHTMLScriptElement + unsafeCastGObject = HTMLScriptElement . castForeignPtr . unGObject + +castToHTMLScriptElement :: GObjectClass obj => obj -> HTMLScriptElement +castToHTMLScriptElement = castTo gTypeHTMLScriptElement "HTMLScriptElement" + +gTypeHTMLScriptElement :: GType +gTypeHTMLScriptElement = + {# call fun unsafe webkit_dom_html_script_element_get_type #} + +-- ********************************************************** HTMLSelectElement + +{#pointer *WebKitDOMHTMLSelectElement as HTMLSelectElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLSelectElement = (HTMLSelectElement, objectUnrefFromMainloop) +unHTMLSelectElement (HTMLSelectElement o) = o + +class HTMLElementClass o => HTMLSelectElementClass o +toHTMLSelectElement :: HTMLSelectElementClass o => o -> HTMLSelectElement +toHTMLSelectElement = unsafeCastGObject . toGObject + +instance HTMLSelectElementClass HTMLSelectElement +instance HTMLElementClass HTMLSelectElement +instance ElementClass HTMLSelectElement +instance NodeClass HTMLSelectElement +instance GObjectClass HTMLSelectElement where + toGObject = GObject . castForeignPtr . unHTMLSelectElement + unsafeCastGObject = HTMLSelectElement . castForeignPtr . unGObject + +castToHTMLSelectElement :: GObjectClass obj => obj -> HTMLSelectElement +castToHTMLSelectElement = castTo gTypeHTMLSelectElement "HTMLSelectElement" + +gTypeHTMLSelectElement :: GType +gTypeHTMLSelectElement = + {# call fun unsafe webkit_dom_html_select_element_get_type #} + +-- *********************************************************** HTMLStyleElement + +{#pointer *WebKitDOMHTMLStyleElement as HTMLStyleElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLStyleElement = (HTMLStyleElement, objectUnrefFromMainloop) +unHTMLStyleElement (HTMLStyleElement o) = o + +class HTMLElementClass o => HTMLStyleElementClass o +toHTMLStyleElement :: HTMLStyleElementClass o => o -> HTMLStyleElement +toHTMLStyleElement = unsafeCastGObject . toGObject + +instance HTMLStyleElementClass HTMLStyleElement +instance HTMLElementClass HTMLStyleElement +instance ElementClass HTMLStyleElement +instance NodeClass HTMLStyleElement +instance GObjectClass HTMLStyleElement where + toGObject = GObject . castForeignPtr . unHTMLStyleElement + unsafeCastGObject = HTMLStyleElement . castForeignPtr . unGObject + +castToHTMLStyleElement :: GObjectClass obj => obj -> HTMLStyleElement +castToHTMLStyleElement = castTo gTypeHTMLStyleElement "HTMLStyleElement" + +gTypeHTMLStyleElement :: GType +gTypeHTMLStyleElement = + {# call fun unsafe webkit_dom_html_style_element_get_type #} + +-- **************************************************** HTMLTableCaptionElement + +{#pointer *WebKitDOMHTMLTableCaptionElement as HTMLTableCaptionElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableCaptionElement = (HTMLTableCaptionElement, objectUnrefFromMainloop) +unHTMLTableCaptionElement (HTMLTableCaptionElement o) = o + +class HTMLElementClass o => HTMLTableCaptionElementClass o +toHTMLTableCaptionElement :: HTMLTableCaptionElementClass o => o -> HTMLTableCaptionElement +toHTMLTableCaptionElement = unsafeCastGObject . toGObject + +instance HTMLTableCaptionElementClass HTMLTableCaptionElement +instance HTMLElementClass HTMLTableCaptionElement +instance ElementClass HTMLTableCaptionElement +instance NodeClass HTMLTableCaptionElement +instance GObjectClass HTMLTableCaptionElement where + toGObject = GObject . castForeignPtr . unHTMLTableCaptionElement + unsafeCastGObject = HTMLTableCaptionElement . castForeignPtr . unGObject + +castToHTMLTableCaptionElement :: GObjectClass obj => obj -> HTMLTableCaptionElement +castToHTMLTableCaptionElement = castTo gTypeHTMLTableCaptionElement "HTMLTableCaptionElement" + +gTypeHTMLTableCaptionElement :: GType +gTypeHTMLTableCaptionElement = + {# call fun unsafe webkit_dom_html_table_caption_element_get_type #} + +-- ******************************************************* HTMLTableCellElement + +{#pointer *WebKitDOMHTMLTableCellElement as HTMLTableCellElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableCellElement = (HTMLTableCellElement, objectUnrefFromMainloop) +unHTMLTableCellElement (HTMLTableCellElement o) = o + +class HTMLElementClass o => HTMLTableCellElementClass o +toHTMLTableCellElement :: HTMLTableCellElementClass o => o -> HTMLTableCellElement +toHTMLTableCellElement = unsafeCastGObject . toGObject + +instance HTMLTableCellElementClass HTMLTableCellElement +instance HTMLElementClass HTMLTableCellElement +instance ElementClass HTMLTableCellElement +instance NodeClass HTMLTableCellElement +instance GObjectClass HTMLTableCellElement where + toGObject = GObject . castForeignPtr . unHTMLTableCellElement + unsafeCastGObject = HTMLTableCellElement . castForeignPtr . unGObject + +castToHTMLTableCellElement :: GObjectClass obj => obj -> HTMLTableCellElement +castToHTMLTableCellElement = castTo gTypeHTMLTableCellElement "HTMLTableCellElement" + +gTypeHTMLTableCellElement :: GType +gTypeHTMLTableCellElement = + {# call fun unsafe webkit_dom_html_table_cell_element_get_type #} + +-- ******************************************************** HTMLTableColElement + +{#pointer *WebKitDOMHTMLTableColElement as HTMLTableColElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableColElement = (HTMLTableColElement, objectUnrefFromMainloop) +unHTMLTableColElement (HTMLTableColElement o) = o + +class HTMLElementClass o => HTMLTableColElementClass o +toHTMLTableColElement :: HTMLTableColElementClass o => o -> HTMLTableColElement +toHTMLTableColElement = unsafeCastGObject . toGObject + +instance HTMLTableColElementClass HTMLTableColElement +instance HTMLElementClass HTMLTableColElement +instance ElementClass HTMLTableColElement +instance NodeClass HTMLTableColElement +instance GObjectClass HTMLTableColElement where + toGObject = GObject . castForeignPtr . unHTMLTableColElement + unsafeCastGObject = HTMLTableColElement . castForeignPtr . unGObject + +castToHTMLTableColElement :: GObjectClass obj => obj -> HTMLTableColElement +castToHTMLTableColElement = castTo gTypeHTMLTableColElement "HTMLTableColElement" + +gTypeHTMLTableColElement :: GType +gTypeHTMLTableColElement = + {# call fun unsafe webkit_dom_html_table_col_element_get_type #} + +-- *********************************************************** HTMLTableElement + +{#pointer *WebKitDOMHTMLTableElement as HTMLTableElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableElement = (HTMLTableElement, objectUnrefFromMainloop) +unHTMLTableElement (HTMLTableElement o) = o + +class HTMLElementClass o => HTMLTableElementClass o +toHTMLTableElement :: HTMLTableElementClass o => o -> HTMLTableElement +toHTMLTableElement = unsafeCastGObject . toGObject + +instance HTMLTableElementClass HTMLTableElement +instance HTMLElementClass HTMLTableElement +instance ElementClass HTMLTableElement +instance NodeClass HTMLTableElement +instance GObjectClass HTMLTableElement where + toGObject = GObject . castForeignPtr . unHTMLTableElement + unsafeCastGObject = HTMLTableElement . castForeignPtr . unGObject + +castToHTMLTableElement :: GObjectClass obj => obj -> HTMLTableElement +castToHTMLTableElement = castTo gTypeHTMLTableElement "HTMLTableElement" + +gTypeHTMLTableElement :: GType +gTypeHTMLTableElement = + {# call fun unsafe webkit_dom_html_table_element_get_type #} + +-- ******************************************************** HTMLTableRowElement + +{#pointer *WebKitDOMHTMLTableRowElement as HTMLTableRowElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableRowElement = (HTMLTableRowElement, objectUnrefFromMainloop) +unHTMLTableRowElement (HTMLTableRowElement o) = o + +class HTMLElementClass o => HTMLTableRowElementClass o +toHTMLTableRowElement :: HTMLTableRowElementClass o => o -> HTMLTableRowElement +toHTMLTableRowElement = unsafeCastGObject . toGObject + +instance HTMLTableRowElementClass HTMLTableRowElement +instance HTMLElementClass HTMLTableRowElement +instance ElementClass HTMLTableRowElement +instance NodeClass HTMLTableRowElement +instance GObjectClass HTMLTableRowElement where + toGObject = GObject . castForeignPtr . unHTMLTableRowElement + unsafeCastGObject = HTMLTableRowElement . castForeignPtr . unGObject + +castToHTMLTableRowElement :: GObjectClass obj => obj -> HTMLTableRowElement +castToHTMLTableRowElement = castTo gTypeHTMLTableRowElement "HTMLTableRowElement" + +gTypeHTMLTableRowElement :: GType +gTypeHTMLTableRowElement = + {# call fun unsafe webkit_dom_html_table_row_element_get_type #} + +-- **************************************************** HTMLTableSectionElement + +{#pointer *WebKitDOMHTMLTableSectionElement as HTMLTableSectionElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableSectionElement = (HTMLTableSectionElement, objectUnrefFromMainloop) +unHTMLTableSectionElement (HTMLTableSectionElement o) = o + +class HTMLElementClass o => HTMLTableSectionElementClass o +toHTMLTableSectionElement :: HTMLTableSectionElementClass o => o -> HTMLTableSectionElement +toHTMLTableSectionElement = unsafeCastGObject . toGObject + +instance HTMLTableSectionElementClass HTMLTableSectionElement +instance HTMLElementClass HTMLTableSectionElement +instance ElementClass HTMLTableSectionElement +instance NodeClass HTMLTableSectionElement +instance GObjectClass HTMLTableSectionElement where + toGObject = GObject . castForeignPtr . unHTMLTableSectionElement + unsafeCastGObject = HTMLTableSectionElement . castForeignPtr . unGObject + +castToHTMLTableSectionElement :: GObjectClass obj => obj -> HTMLTableSectionElement +castToHTMLTableSectionElement = castTo gTypeHTMLTableSectionElement "HTMLTableSectionElement" + +gTypeHTMLTableSectionElement :: GType +gTypeHTMLTableSectionElement = + {# call fun unsafe webkit_dom_html_table_section_element_get_type #} + +-- ******************************************************** HTMLTextAreaElement + +{#pointer *WebKitDOMHTMLTextAreaElement as HTMLTextAreaElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTextAreaElement = (HTMLTextAreaElement, objectUnrefFromMainloop) +unHTMLTextAreaElement (HTMLTextAreaElement o) = o + +class HTMLElementClass o => HTMLTextAreaElementClass o +toHTMLTextAreaElement :: HTMLTextAreaElementClass o => o -> HTMLTextAreaElement +toHTMLTextAreaElement = unsafeCastGObject . toGObject + +instance HTMLTextAreaElementClass HTMLTextAreaElement +instance HTMLElementClass HTMLTextAreaElement +instance ElementClass HTMLTextAreaElement +instance NodeClass HTMLTextAreaElement +instance GObjectClass HTMLTextAreaElement where + toGObject = GObject . castForeignPtr . unHTMLTextAreaElement + unsafeCastGObject = HTMLTextAreaElement . castForeignPtr . unGObject + +castToHTMLTextAreaElement :: GObjectClass obj => obj -> HTMLTextAreaElement +castToHTMLTextAreaElement = castTo gTypeHTMLTextAreaElement "HTMLTextAreaElement" + +gTypeHTMLTextAreaElement :: GType +gTypeHTMLTextAreaElement = + {# call fun unsafe webkit_dom_html_text_area_element_get_type #} + +-- *********************************************************** HTMLTitleElement + +{#pointer *WebKitDOMHTMLTitleElement as HTMLTitleElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTitleElement = (HTMLTitleElement, objectUnrefFromMainloop) +unHTMLTitleElement (HTMLTitleElement o) = o + +class HTMLElementClass o => HTMLTitleElementClass o +toHTMLTitleElement :: HTMLTitleElementClass o => o -> HTMLTitleElement +toHTMLTitleElement = unsafeCastGObject . toGObject + +instance HTMLTitleElementClass HTMLTitleElement +instance HTMLElementClass HTMLTitleElement +instance ElementClass HTMLTitleElement +instance NodeClass HTMLTitleElement +instance GObjectClass HTMLTitleElement where + toGObject = GObject . castForeignPtr . unHTMLTitleElement + unsafeCastGObject = HTMLTitleElement . castForeignPtr . unGObject + +castToHTMLTitleElement :: GObjectClass obj => obj -> HTMLTitleElement +castToHTMLTitleElement = castTo gTypeHTMLTitleElement "HTMLTitleElement" + +gTypeHTMLTitleElement :: GType +gTypeHTMLTitleElement = + {# call fun unsafe webkit_dom_html_title_element_get_type #} + +-- *********************************************************** HTMLUListElement + +{#pointer *WebKitDOMHTMLUListElement as HTMLUListElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLUListElement = (HTMLUListElement, objectUnrefFromMainloop) +unHTMLUListElement (HTMLUListElement o) = o + +class HTMLElementClass o => HTMLUListElementClass o +toHTMLUListElement :: HTMLUListElementClass o => o -> HTMLUListElement +toHTMLUListElement = unsafeCastGObject . toGObject + +instance HTMLUListElementClass HTMLUListElement +instance HTMLElementClass HTMLUListElement +instance ElementClass HTMLUListElement +instance NodeClass HTMLUListElement +instance GObjectClass HTMLUListElement where + toGObject = GObject . castForeignPtr . unHTMLUListElement + unsafeCastGObject = HTMLUListElement . castForeignPtr . unGObject + +castToHTMLUListElement :: GObjectClass obj => obj -> HTMLUListElement +castToHTMLUListElement = castTo gTypeHTMLUListElement "HTMLUListElement" + +gTypeHTMLUListElement :: GType +gTypeHTMLUListElement = + {# call fun unsafe webkit_dom_htmlu_list_element_get_type #} + +-- ************************************************************ EntityReference + +{#pointer *WebKitDOMEntityReference as EntityReference foreign newtype #} deriving (Eq,Ord) + +mkEntityReference = (EntityReference, objectUnrefFromMainloop) +unEntityReference (EntityReference o) = o + +class NodeClass o => EntityReferenceClass o +toEntityReference :: EntityReferenceClass o => o -> EntityReference +toEntityReference = unsafeCastGObject . toGObject + +instance EntityReferenceClass EntityReference +instance NodeClass EntityReference +instance GObjectClass EntityReference where + toGObject = GObject . castForeignPtr . unEntityReference + unsafeCastGObject = EntityReference . castForeignPtr . unGObject + +castToEntityReference :: GObjectClass obj => obj -> EntityReference +castToEntityReference = castTo gTypeEntityReference "EntityReference" + +gTypeEntityReference :: GType +gTypeEntityReference = + {# call fun unsafe webkit_dom_entity_reference_get_type #} + +-- ****************************************************** ProcessingInstruction + +{#pointer *WebKitDOMProcessingInstruction as ProcessingInstruction foreign newtype #} deriving (Eq,Ord) + +mkProcessingInstruction = (ProcessingInstruction, objectUnrefFromMainloop) +unProcessingInstruction (ProcessingInstruction o) = o + +class NodeClass o => ProcessingInstructionClass o +toProcessingInstruction :: ProcessingInstructionClass o => o -> ProcessingInstruction +toProcessingInstruction = unsafeCastGObject . toGObject + +instance ProcessingInstructionClass ProcessingInstruction +instance NodeClass ProcessingInstruction +instance GObjectClass ProcessingInstruction where + toGObject = GObject . castForeignPtr . unProcessingInstruction + unsafeCastGObject = ProcessingInstruction . castForeignPtr . unGObject + +castToProcessingInstruction :: GObjectClass obj => obj -> ProcessingInstruction +castToProcessingInstruction = castTo gTypeProcessingInstruction "ProcessingInstruction" + +gTypeProcessingInstruction :: GType +gTypeProcessingInstruction = + {# call fun unsafe webkit_dom_processing_instruction_get_type #} + +-- ***************************************************************** NodeFilter + +{#pointer *WebKitDOMNodeFilter as NodeFilter foreign newtype #} deriving (Eq,Ord) + +mkNodeFilter = (NodeFilter, objectUnrefFromMainloop) +unNodeFilter (NodeFilter o) = o + +class GObjectClass o => NodeFilterClass o +toNodeFilter :: NodeFilterClass o => o -> NodeFilter +toNodeFilter = unsafeCastGObject . toGObject + +instance NodeFilterClass NodeFilter +instance GObjectClass NodeFilter where + toGObject = GObject . castForeignPtr . unNodeFilter + unsafeCastGObject = NodeFilter . castForeignPtr . unGObject + +castToNodeFilter :: GObjectClass obj => obj -> NodeFilter +castToNodeFilter = castTo gTypeNodeFilter "NodeFilter" + +gTypeNodeFilter :: GType +gTypeNodeFilter = + {# call fun unsafe webkit_dom_node_filter_get_type #} + +-- *************************************************************** NodeIterator + +{#pointer *WebKitDOMNodeIterator as NodeIterator foreign newtype #} deriving (Eq,Ord) + +mkNodeIterator = (NodeIterator, objectUnrefFromMainloop) +unNodeIterator (NodeIterator o) = o + +class GObjectClass o => NodeIteratorClass o +toNodeIterator :: NodeIteratorClass o => o -> NodeIterator +toNodeIterator = unsafeCastGObject . toGObject + +instance NodeIteratorClass NodeIterator +instance GObjectClass NodeIterator where + toGObject = GObject . castForeignPtr . unNodeIterator + unsafeCastGObject = NodeIterator . castForeignPtr . unGObject + +castToNodeIterator :: GObjectClass obj => obj -> NodeIterator +castToNodeIterator = castTo gTypeNodeIterator "NodeIterator" + +gTypeNodeIterator :: GType +gTypeNodeIterator = + {# call fun unsafe webkit_dom_node_iterator_get_type #} + +-- ******************************************************************* NodeList + +{#pointer *WebKitDOMNodeList as NodeList foreign newtype #} deriving (Eq,Ord) + +mkNodeList = (NodeList, objectUnrefFromMainloop) +unNodeList (NodeList o) = o + +class GObjectClass o => NodeListClass o +toNodeList :: NodeListClass o => o -> NodeList +toNodeList = unsafeCastGObject . toGObject + +instance NodeListClass NodeList +instance GObjectClass NodeList where + toGObject = GObject . castForeignPtr . unNodeList + unsafeCastGObject = NodeList . castForeignPtr . unGObject + +castToNodeList :: GObjectClass obj => obj -> NodeList +castToNodeList = castTo gTypeNodeList "NodeList" + +gTypeNodeList :: GType +gTypeNodeList = + {# call fun unsafe webkit_dom_node_list_get_type #} + +-- ******************************************************************* DOMRange + +{#pointer *WebKitDOMRange as DOMRange foreign newtype #} deriving (Eq,Ord) + +mkDOMRange = (DOMRange, objectUnrefFromMainloop) +unDOMRange (DOMRange o) = o + +class GObjectClass o => DOMRangeClass o +toDOMRange :: DOMRangeClass o => o -> DOMRange +toDOMRange = unsafeCastGObject . toGObject + +instance DOMRangeClass DOMRange +instance GObjectClass DOMRange where + toGObject = GObject . castForeignPtr . unDOMRange + unsafeCastGObject = DOMRange . castForeignPtr . unGObject + +castToDOMRange :: GObjectClass obj => obj -> DOMRange +castToDOMRange = castTo gTypeDOMRange "DOMRange" + +gTypeDOMRange :: GType +gTypeDOMRange = + {# call fun unsafe webkit_dom_range_get_type #} + +-- ****************************************************************** DOMScreen + +{#pointer *WebKitDOMScreen as DOMScreen foreign newtype #} deriving (Eq,Ord) + +mkDOMScreen = (DOMScreen, objectUnrefFromMainloop) +unDOMScreen (DOMScreen o) = o + +class GObjectClass o => DOMScreenClass o +toDOMScreen :: DOMScreenClass o => o -> DOMScreen +toDOMScreen = unsafeCastGObject . toGObject + +instance DOMScreenClass DOMScreen +instance GObjectClass DOMScreen where + toGObject = GObject . castForeignPtr . unDOMScreen + unsafeCastGObject = DOMScreen . castForeignPtr . unGObject + +castToDOMScreen :: GObjectClass obj => obj -> DOMScreen +castToDOMScreen = castTo gTypeDOMScreen "DOMScreen" + +gTypeDOMScreen :: GType +gTypeDOMScreen = + {# call fun unsafe webkit_dom_screen_get_type #} + +-- ******************************************************************** Storage + +{#pointer *WebKitDOMStorage as Storage foreign newtype #} deriving (Eq,Ord) + +mkStorage = (Storage, objectUnrefFromMainloop) +unStorage (Storage o) = o + +class GObjectClass o => StorageClass o +toStorage :: StorageClass o => o -> Storage +toStorage = unsafeCastGObject . toGObject + +instance StorageClass Storage +instance GObjectClass Storage where + toGObject = GObject . castForeignPtr . unStorage + unsafeCastGObject = Storage . castForeignPtr . unGObject + +castToStorage :: GObjectClass obj => obj -> Storage +castToStorage = castTo gTypeStorage "Storage" + +gTypeStorage :: GType +gTypeStorage = + {# call fun unsafe webkit_dom_storage_get_type #} + +-- **************************************************************** StorageInfo + +{#pointer *WebKitDOMStorageInfo as StorageInfo foreign newtype #} deriving (Eq,Ord) + +mkStorageInfo = (StorageInfo, objectUnrefFromMainloop) +unStorageInfo (StorageInfo o) = o + +class GObjectClass o => StorageInfoClass o +toStorageInfo :: StorageInfoClass o => o -> StorageInfo +toStorageInfo = unsafeCastGObject . toGObject + +instance StorageInfoClass StorageInfo +instance GObjectClass StorageInfo where + toGObject = GObject . castForeignPtr . unStorageInfo + unsafeCastGObject = StorageInfo . castForeignPtr . unGObject + +castToStorageInfo :: GObjectClass obj => obj -> StorageInfo +castToStorageInfo = castTo gTypeStorageInfo "StorageInfo" + +gTypeStorageInfo :: GType +gTypeStorageInfo = + {# call fun unsafe webkit_dom_storage_info_get_type #} + +-- ***************************************************************** StyleMedia + +{#pointer *WebKitDOMStyleMedia as StyleMedia foreign newtype #} deriving (Eq,Ord) + +mkStyleMedia = (StyleMedia, objectUnrefFromMainloop) +unStyleMedia (StyleMedia o) = o + +class GObjectClass o => StyleMediaClass o +toStyleMedia :: StyleMediaClass o => o -> StyleMedia +toStyleMedia = unsafeCastGObject . toGObject + +instance StyleMediaClass StyleMedia +instance GObjectClass StyleMedia where + toGObject = GObject . castForeignPtr . unStyleMedia + unsafeCastGObject = StyleMedia . castForeignPtr . unGObject + +castToStyleMedia :: GObjectClass obj => obj -> StyleMedia +castToStyleMedia = castTo gTypeStyleMedia "StyleMedia" + +gTypeStyleMedia :: GType +gTypeStyleMedia = + {# call fun unsafe webkit_dom_style_media_get_type #} + +-- ***************************************************************** StyleSheet + +{#pointer *WebKitDOMStyleSheet as StyleSheet foreign newtype #} deriving (Eq,Ord) + +mkStyleSheet = (StyleSheet, objectUnrefFromMainloop) +unStyleSheet (StyleSheet o) = o + +class GObjectClass o => StyleSheetClass o +toStyleSheet :: StyleSheetClass o => o -> StyleSheet +toStyleSheet = unsafeCastGObject . toGObject + +instance StyleSheetClass StyleSheet +instance GObjectClass StyleSheet where + toGObject = GObject . castForeignPtr . unStyleSheet + unsafeCastGObject = StyleSheet . castForeignPtr . unGObject + +castToStyleSheet :: GObjectClass obj => obj -> StyleSheet +castToStyleSheet = castTo gTypeStyleSheet "StyleSheet" + +gTypeStyleSheet :: GType +gTypeStyleSheet = + {# call fun unsafe webkit_dom_style_sheet_get_type #} + +-- ************************************************************** CSSStyleSheet + +{#pointer *WebKitDOMCSSStyleSheet as CSSStyleSheet foreign newtype #} deriving (Eq,Ord) + +mkCSSStyleSheet = (CSSStyleSheet, objectUnrefFromMainloop) +unCSSStyleSheet (CSSStyleSheet o) = o + +class StyleSheetClass o => CSSStyleSheetClass o +toCSSStyleSheet :: CSSStyleSheetClass o => o -> CSSStyleSheet +toCSSStyleSheet = unsafeCastGObject . toGObject + +instance CSSStyleSheetClass CSSStyleSheet +instance StyleSheetClass CSSStyleSheet +instance GObjectClass CSSStyleSheet where + toGObject = GObject . castForeignPtr . unCSSStyleSheet + unsafeCastGObject = CSSStyleSheet . castForeignPtr . unGObject + +castToCSSStyleSheet :: GObjectClass obj => obj -> CSSStyleSheet +castToCSSStyleSheet = castTo gTypeCSSStyleSheet "CSSStyleSheet" + +gTypeCSSStyleSheet :: GType +gTypeCSSStyleSheet = + {# call fun unsafe webkit_dom_css_style_sheet_get_type #} + +-- ************************************************************* StyleSheetList + +{#pointer *WebKitDOMStyleSheetList as StyleSheetList foreign newtype #} deriving (Eq,Ord) + +mkStyleSheetList = (StyleSheetList, objectUnrefFromMainloop) +unStyleSheetList (StyleSheetList o) = o + +class GObjectClass o => StyleSheetListClass o +toStyleSheetList :: StyleSheetListClass o => o -> StyleSheetList +toStyleSheetList = unsafeCastGObject . toGObject + +instance StyleSheetListClass StyleSheetList +instance GObjectClass StyleSheetList where + toGObject = GObject . castForeignPtr . unStyleSheetList + unsafeCastGObject = StyleSheetList . castForeignPtr . unGObject + +castToStyleSheetList :: GObjectClass obj => obj -> StyleSheetList +castToStyleSheetList = castTo gTypeStyleSheetList "StyleSheetList" + +gTypeStyleSheetList :: GType +gTypeStyleSheetList = + {# call fun unsafe webkit_dom_style_sheet_list_get_type #} + +-- ***************************************************************** TimeRanges + +{#pointer *WebKitDOMTimeRanges as TimeRanges foreign newtype #} deriving (Eq,Ord) + +mkTimeRanges = (TimeRanges, objectUnrefFromMainloop) +unTimeRanges (TimeRanges o) = o + +class GObjectClass o => TimeRangesClass o +toTimeRanges :: TimeRangesClass o => o -> TimeRanges +toTimeRanges = unsafeCastGObject . toGObject + +instance TimeRangesClass TimeRanges +instance GObjectClass TimeRanges where + toGObject = GObject . castForeignPtr . unTimeRanges + unsafeCastGObject = TimeRanges . castForeignPtr . unGObject + +castToTimeRanges :: GObjectClass obj => obj -> TimeRanges +castToTimeRanges = castTo gTypeTimeRanges "TimeRanges" + +gTypeTimeRanges :: GType +gTypeTimeRanges = + {# call fun unsafe webkit_dom_time_ranges_get_type #} + +-- ***************************************************************** TreeWalker + +{#pointer *WebKitDOMTreeWalker as TreeWalker foreign newtype #} deriving (Eq,Ord) + +mkTreeWalker = (TreeWalker, objectUnrefFromMainloop) +unTreeWalker (TreeWalker o) = o + +class GObjectClass o => TreeWalkerClass o +toTreeWalker :: TreeWalkerClass o => o -> TreeWalker +toTreeWalker = unsafeCastGObject . toGObject + +instance TreeWalkerClass TreeWalker +instance GObjectClass TreeWalker where + toGObject = GObject . castForeignPtr . unTreeWalker + unsafeCastGObject = TreeWalker . castForeignPtr . unGObject + +castToTreeWalker :: GObjectClass obj => obj -> TreeWalker +castToTreeWalker = castTo gTypeTreeWalker "TreeWalker" + +gTypeTreeWalker :: GType +gTypeTreeWalker = + {# call fun unsafe webkit_dom_tree_walker_get_type #} + +-- ************************************************************** ValidityState + +{#pointer *WebKitDOMValidityState as ValidityState foreign newtype #} deriving (Eq,Ord) + +mkValidityState = (ValidityState, objectUnrefFromMainloop) +unValidityState (ValidityState o) = o + +class GObjectClass o => ValidityStateClass o +toValidityState :: ValidityStateClass o => o -> ValidityState +toValidityState = unsafeCastGObject . toGObject + +instance ValidityStateClass ValidityState +instance GObjectClass ValidityState where + toGObject = GObject . castForeignPtr . unValidityState + unsafeCastGObject = ValidityState . castForeignPtr . unGObject + +castToValidityState :: GObjectClass obj => obj -> ValidityState +castToValidityState = castTo gTypeValidityState "ValidityState" + +gTypeValidityState :: GType +gTypeValidityState = + {# call fun unsafe webkit_dom_validity_state_get_type #} + +-- ************************************************************ WebKitNamedFlow + +{#pointer *WebKitDOMWebKitNamedFlow as WebKitNamedFlow foreign newtype #} deriving (Eq,Ord) + +mkWebKitNamedFlow = (WebKitNamedFlow, objectUnrefFromMainloop) +unWebKitNamedFlow (WebKitNamedFlow o) = o + +class GObjectClass o => WebKitNamedFlowClass o +toWebKitNamedFlow :: WebKitNamedFlowClass o => o -> WebKitNamedFlow +toWebKitNamedFlow = unsafeCastGObject . toGObject + +instance WebKitNamedFlowClass WebKitNamedFlow +instance GObjectClass WebKitNamedFlow where + toGObject = GObject . castForeignPtr . unWebKitNamedFlow + unsafeCastGObject = WebKitNamedFlow . castForeignPtr . unGObject + +castToWebKitNamedFlow :: GObjectClass obj => obj -> WebKitNamedFlow +castToWebKitNamedFlow = castTo gTypeWebKitNamedFlow "WebKitNamedFlow" + +gTypeWebKitNamedFlow :: GType +gTypeWebKitNamedFlow = + {# call fun unsafe webkit_dom_webkit_named_flow_get_type #} + +-- **************************************************************** WebKitPoint + +{#pointer *WebKitDOMWebKitPoint as WebKitPoint foreign newtype #} deriving (Eq,Ord) + +mkWebKitPoint = (WebKitPoint, objectUnrefFromMainloop) +unWebKitPoint (WebKitPoint o) = o + +class GObjectClass o => WebKitPointClass o +toWebKitPoint :: WebKitPointClass o => o -> WebKitPoint +toWebKitPoint = unsafeCastGObject . toGObject + +instance WebKitPointClass WebKitPoint +instance GObjectClass WebKitPoint where + toGObject = GObject . castForeignPtr . unWebKitPoint + unsafeCastGObject = WebKitPoint . castForeignPtr . unGObject + +castToWebKitPoint :: GObjectClass obj => obj -> WebKitPoint +castToWebKitPoint = castTo gTypeWebKitPoint "WebKitPoint" + +gTypeWebKitPoint :: GType +gTypeWebKitPoint = + {# call fun unsafe webkit_dom_webkit_point_get_type #} + +-- ************************************************************ XPathExpression + +{#pointer *WebKitDOMXPathExpression as XPathExpression foreign newtype #} deriving (Eq,Ord) + +mkXPathExpression = (XPathExpression, objectUnrefFromMainloop) +unXPathExpression (XPathExpression o) = o + +class GObjectClass o => XPathExpressionClass o +toXPathExpression :: XPathExpressionClass o => o -> XPathExpression +toXPathExpression = unsafeCastGObject . toGObject + +instance XPathExpressionClass XPathExpression +instance GObjectClass XPathExpression where + toGObject = GObject . castForeignPtr . unXPathExpression + unsafeCastGObject = XPathExpression . castForeignPtr . unGObject + +castToXPathExpression :: GObjectClass obj => obj -> XPathExpression +castToXPathExpression = castTo gTypeXPathExpression "XPathExpression" + +gTypeXPathExpression :: GType +gTypeXPathExpression = + {# call fun unsafe webkit_dom_xpath_expression_get_type #} + +-- ************************************************************ XPathNSResolver + +{#pointer *WebKitDOMXPathNSResolver as XPathNSResolver foreign newtype #} deriving (Eq,Ord) + +mkXPathNSResolver = (XPathNSResolver, objectUnrefFromMainloop) +unXPathNSResolver (XPathNSResolver o) = o + +class GObjectClass o => XPathNSResolverClass o +toXPathNSResolver :: XPathNSResolverClass o => o -> XPathNSResolver +toXPathNSResolver = unsafeCastGObject . toGObject + +instance XPathNSResolverClass XPathNSResolver +instance GObjectClass XPathNSResolver where + toGObject = GObject . castForeignPtr . unXPathNSResolver + unsafeCastGObject = XPathNSResolver . castForeignPtr . unGObject + +castToXPathNSResolver :: GObjectClass obj => obj -> XPathNSResolver +castToXPathNSResolver = castTo gTypeXPathNSResolver "XPathNSResolver" + +gTypeXPathNSResolver :: GType +gTypeXPathNSResolver = + {# call fun unsafe webkit_dom_xpath_ns_resolver_get_type #} + +-- **************************************************************** XPathResult + +{#pointer *WebKitDOMXPathResult as XPathResult foreign newtype #} deriving (Eq,Ord) + +mkXPathResult = (XPathResult, objectUnrefFromMainloop) +unXPathResult (XPathResult o) = o + +class GObjectClass o => XPathResultClass o +toXPathResult :: XPathResultClass o => o -> XPathResult +toXPathResult = unsafeCastGObject . toGObject + +instance XPathResultClass XPathResult +instance GObjectClass XPathResult where + toGObject = GObject . castForeignPtr . unXPathResult + unsafeCastGObject = XPathResult . castForeignPtr . unGObject + +castToXPathResult :: GObjectClass obj => obj -> XPathResult +castToXPathResult = castTo gTypeXPathResult "XPathResult" + +gTypeXPathResult :: GType +gTypeXPathResult = + {# call fun unsafe webkit_dom_xpath_result_get_type #} + diff --git a/Graphics/UI/Gtk/WebKit/WebBackForwardList.chs b/Graphics/UI/Gtk/WebKit/WebBackForwardList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/WebBackForwardList.chs @@ -0,0 +1,229 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.Download +-- Author : Cjacker Huang +-- Copyright : (c) 2009 Cjacker Huang +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- The history of a 'WebView' +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.WebBackForwardList ( +-- * Types + WebViewClass, + WebBackForwardList, + WebBackForwardListClass, + +-- * Constructors + webBackForwardListNewWithWebView, + +-- * Methods + webBackForwardListGoForward, + webBackForwardListGoBack, + webBackForwardListContainsItem, + webBackForwardListGoToItem, + webBackForwardListGetBackItem, + webBackForwardListGetCurrentItem, + webBackForwardListGetForwardItem, + webBackForwardListGetNthItem, + webBackForwardListGetBackLength, + webBackForwardListGetForwardLength, + webBackForwardListGetLimit, + webBackForwardListSetLimit, + webBackForwardListAddItem, + webBackForwardListGetForwardListWithLimit, + webBackForwardListGetBackListWithLimit, + +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + + +------------------ +-- Constructors + +-- | Create an WebBackForwardList with a controlling WebView. +webBackForwardListNewWithWebView :: (WebViewClass webview) => webview -> IO WebBackForwardList +webBackForwardListNewWithWebView webview = + wrapNewGObject mkWebBackForwardList $ + {#call web_back_forward_list_new_with_web_view#} + (toWebView webview) + +-- | Steps forward in the back forward list. +webBackForwardListGoForward :: + WebBackForwardListClass self => self + -> IO() +webBackForwardListGoForward webbackforwardlist = + {#call web_back_forward_list_go_forward#} (toWebBackForwardList webbackforwardlist) + +-- | Steps back in the back forward list. +webBackForwardListGoBack :: + WebBackForwardListClass self => self + -> IO() +webBackForwardListGoBack webbackforwardlist = + {#call web_back_forward_list_go_back#} (toWebBackForwardList webbackforwardlist) + +-- | Check if an history item in the back forward list. +webBackForwardListContainsItem :: + (WebBackForwardListClass self, WebHistoryItemClass item) => self + -> item + -> IO Bool +webBackForwardListContainsItem webbackforwardlist webhistoryitem = + liftM toBool $ {#call web_back_forward_list_contains_item#} + (toWebBackForwardList webbackforwardlist) + (toWebHistoryItem webhistoryitem) + +-- | Go to the specified history item in the back forward list. +webBackForwardListGoToItem :: + (WebBackForwardListClass self,WebHistoryItemClass item) => self + -> item + -> IO() +webBackForwardListGoToItem webbackforwardlist webhistoryitem = + {#call web_back_forward_list_go_to_item#} + (toWebBackForwardList webbackforwardlist) + (toWebHistoryItem webhistoryitem) + +-- | Return the history item that precedes the current history item. +webBackForwardListGetBackItem :: + WebBackForwardListClass self => self + -> IO (Maybe WebHistoryItem) -- ^ A 'WebHistoryItem' or @Nothing@ + -- if there is nothing precedes the current item. +webBackForwardListGetBackItem webbackforwardlist = + maybeNull (makeNewGObject mkWebHistoryItem) $ + {#call web_back_forward_list_get_back_item#} + (toWebBackForwardList webbackforwardlist) + +-- | Return the current history item of the back forward list +webBackForwardListGetCurrentItem :: + WebBackForwardListClass self => self + -> IO WebHistoryItem +webBackForwardListGetCurrentItem webbackforwardlist = + makeNewGObject mkWebHistoryItem $ + {#call web_back_forward_list_get_current_item#} + (toWebBackForwardList webbackforwardlist) + +-- | Return the item that succeeds the current item + +webBackForwardListGetForwardItem :: + WebBackForwardListClass self => self + -> IO (Maybe WebHistoryItem) -- ^ A 'WebHistoryItem' or @Nothing@ + -- if there is nothing succeeds the current item. +webBackForwardListGetForwardItem webbackforwardlist = + maybeNull (makeNewGObject mkWebHistoryItem) $ + {#call web_back_forward_list_get_forward_item#} + (toWebBackForwardList webbackforwardlist) + +-- | Return the history item at a given index relative to the current item. +webBackForwardListGetNthItem :: + WebBackForwardListClass self => self -- ^ @webbackforwardlist@ - a WebBackForwardList + -> Int -- ^ @index@ - the index of the item + -> IO WebHistoryItem +webBackForwardListGetNthItem webbackforwardlist index = + makeNewGObject mkWebHistoryItem $ + {#call web_back_forward_list_get_nth_item#} + (toWebBackForwardList webbackforwardlist) + (fromIntegral index) + +-- | Return the number of items that preced the current item. +webBackForwardListGetBackLength :: + WebBackForwardListClass self => self + -> IO Int +webBackForwardListGetBackLength webbackforwardlist = + liftM fromIntegral $ + {#call web_back_forward_list_get_back_length#} + (toWebBackForwardList webbackforwardlist) + +-- | Return the number of items that succeed the current item. +webBackForwardListGetForwardLength :: + WebBackForwardListClass self => self + -> IO Int +webBackForwardListGetForwardLength webbackforwardlist = + liftM fromIntegral $ + {#call web_back_forward_list_get_forward_length#} + (toWebBackForwardList webbackforwardlist) + +-- | Return the maximum limit of the back forward list. +webBackForwardListGetLimit :: + WebBackForwardListClass self => self + -> IO Int +webBackForwardListGetLimit webbackforwardlist = + liftM fromIntegral $ + {#call web_back_forward_list_get_limit#} + (toWebBackForwardList webbackforwardlist) + +-- | Set the maximum limit of the back forward list. +-- +-- if the back forward list exceeds its capacity, +-- items will be removed everytime a new item had been added. +-- +webBackForwardListSetLimit :: + WebBackForwardListClass self => self + -> Int + -> IO() +webBackForwardListSetLimit webbackforwardlist limit = + {#call web_back_forward_list_set_limit#} + (toWebBackForwardList webbackforwardlist) + (fromIntegral limit) + +-- | Add the item to the back forward list. +webBackForwardListAddItem :: + (WebBackForwardListClass self,WebHistoryItemClass item) => self + -> item + -> IO () +webBackForwardListAddItem webbackforwardlist webhistoryitem = + {#call web_back_forward_list_add_item#} + (toWebBackForwardList webbackforwardlist) + (toWebHistoryItem webhistoryitem) + +-- | Return a list of items that succeed the current item, limited by @limit@. +webBackForwardListGetForwardListWithLimit :: + WebBackForwardListClass self => self + -> Int -- ^ the number of items to retrieve + -> IO [WebHistoryItem] -- ^ a 'List' of items succeeding the current item, limited by limit. +webBackForwardListGetForwardListWithLimit webbackforwardlist limit = + {#call web_back_forward_list_get_forward_list_with_limit#} + (toWebBackForwardList webbackforwardlist) + (fromIntegral limit) + >>= fromGList + >>= mapM (makeNewGObject mkWebHistoryItem . return) + +-- | Return a list of items that preced the current item. +-- limited by limit. +webBackForwardListGetBackListWithLimit :: + WebBackForwardListClass self => self + -> Int -- ^ the number of items to retrieve + -> IO [WebHistoryItem] -- ^ a 'List' of items preceding the current item, limited by limit +webBackForwardListGetBackListWithLimit webbackforwardlist limit = + {#call web_back_forward_list_get_back_list_with_limit#} + (toWebBackForwardList webbackforwardlist) + (fromIntegral limit) + >>= fromGList + >>= mapM (makeNewGObject mkWebHistoryItem . return) + diff --git a/Graphics/UI/Gtk/WebKit/WebDataSource.chs b/Graphics/UI/Gtk/WebKit/WebDataSource.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/WebDataSource.chs @@ -0,0 +1,158 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.WebDataSource +-- Author : Andy Stewart +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Note +-- +-- Function `webkit_web_data_source_get_data` haven't binding, +-- no idea how to handle `GString` +-- +-- Access to the WebKit Web DataSource +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.WebDataSource ( +-- * Description +-- | Data source encapsulates the content of a WebKitWebFrame. A WebKitWebFrame has a main resource and +-- subresources and the data source provides access to these resources. When a request gets loaded +-- initially, it is set to a provisional state. The application can request for the request that +-- initiated the load by asking for the provisional data source and invoking the +-- 'webDataSourceGetInitialRequest' method of WebKitWebDataSource. This data source may not +-- have enough data and some methods may return empty values. To get a "full" data source with the data +-- and resources loaded, you need to get the non-provisional data source through WebKitWebFrame's +-- 'webFrameGetDataSource' method. This data source will have the data after everything was +-- loaded. Make sure that the data source was finished loading before using any of its methods. You can +-- do this via 'webDataSourceIsLoading'. + +-- * Types + WebDataSource, + WebDataSourceClass, + +-- * Constructors + webDataSourceNew, + +-- * Methods + webDataSourceGetData, + webDataSourceGetEncoding, + webDataSourceGetInitialRequest, + webDataSourceGetMainResource, + webDataSourceGetRequest, + webDataSourceGetSubresources, + webDataSourceGetUnreachableUri, + webDataSourceGetWebFrame, + webDataSourceIsLoading, +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GString +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +-- | Creates a new 'WebDataSource' instance. +-- The URL of the 'WebDataSource' will be set to "about:blank". +webDataSourceNew :: IO WebDataSource +webDataSourceNew = + wrapNewGObject mkWebDataSource $ {#call web_data_source_new#} + +-- | Returns the raw data that represents the the frame's content. The data will be incomplete until the +-- data has finished loading. Returns 'Nothing' if the web frame hasn't loaded any data. Use +-- @webkitWebDataSourceIsLoading@ to test if data source is in the process of loading. +webDataSourceGetData :: WebDataSourceClass self => self + -> IO (Maybe String) +webDataSourceGetData ds = do + gstr <- {#call webkit_web_data_source_get_data #} + (toWebDataSource ds) + readGString gstr + +-- | Returns the text encoding name as set in the 'WebView', or if not, the text encoding of the response. +webDataSourceGetEncoding :: + WebDataSourceClass self => self + -> IO String +webDataSourceGetEncoding ds = + {#call web_data_source_get_encoding#} (toWebDataSource ds) >>= peekCString + +-- | Returns a reference to the original request that was used to load the web content. +-- The NetworkRequest returned by this method is the +-- request prior to the "committed" load state. +-- See 'webDataSourceGetRequest' for getting the "committed" request. +webDataSourceGetInitialRequest :: + WebDataSourceClass self => self + -> IO NetworkRequest +webDataSourceGetInitialRequest ds = + makeNewGObject mkNetworkRequest $ {# call web_data_source_get_initial_request#} (toWebDataSource ds) + +-- | Returns the main resource of the data_source +webDataSourceGetMainResource :: + WebDataSourceClass self => self + -> IO WebResource +webDataSourceGetMainResource ds = + makeNewGObject mkWebResource $ {#call web_data_source_get_main_resource#} (toWebDataSource ds) + +-- | Returns a NetworkRequest that was used to create this 'WebDataSource'. +-- The NetworkRequest returned by this method is the request that was "committed", +-- and hence, different from the request you get from the 'webDataSourceGetInitialRequest' method. +webDataSourceGetRequest :: + WebDataSourceClass self => self + -> IO NetworkRequest +webDataSourceGetRequest ds = + makeNewGObject mkNetworkRequest $ {# call web_data_source_get_request#} (toWebDataSource ds) + +-- | Gives you a List of 'WebResource' objects that compose the 'WebView' to which this 'WebDataSource' is attached. +webDataSourceGetSubresources :: + WebDataSourceClass self => self + -> IO [WebResource] +webDataSourceGetSubresources ds = do + glist <- {#call web_data_source_get_subresources#} (toWebDataSource ds) + resourcePtr <- fromGList glist + mapM (makeNewGObject mkWebResource . return) resourcePtr + +-- | Return the unreachable URI of data_source. +-- The 'dataSource' will have an unreachable URL +-- if it was created using 'WebFrame''s +-- 'webFrameLoadAlternateHtmlString' method. +webDataSourceGetUnreachableUri :: + WebDataSourceClass self => self + -> IO String +webDataSourceGetUnreachableUri ds = + {#call web_data_source_get_unreachable_uri#} (toWebDataSource ds) >>= peekCString + +-- | Returns the 'WebFrame' that represents this data source +webDataSourceGetWebFrame :: + WebDataSourceClass self => self + -> IO WebFrame +webDataSourceGetWebFrame ds = + makeNewGObject mkWebFrame $ {#call web_data_source_get_web_frame#} (toWebDataSource ds) + +-- | Determines whether the data source is in the process of loading its content. +webDataSourceIsLoading :: + WebDataSourceClass self => self + -> IO Bool +webDataSourceIsLoading ds = + liftM toBool $ {#call web_data_source_is_loading#} (toWebDataSource ds) diff --git a/Graphics/UI/Gtk/WebKit/WebDatabase.chs b/Graphics/UI/Gtk/WebKit/WebDatabase.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/WebDatabase.chs @@ -0,0 +1,124 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.WebDatabase +-- Author : Andy Stewart +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Access to the WebKit Web Database +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.WebDatabase ( +-- * Description +-- | WebKitWebDatabase is a representation of a Web Database database. The proposed Web Database standard +-- introduces support for SQL databases that web sites can create and access on a local computer +-- through JavaScript. +-- +-- To get access to all databases defined by a security origin, use +-- 'securityOriginGetDatabases' Each database has a canonical name, as well as a user-friendly +-- display name. +-- +-- WebKit uses SQLite to create and access the local SQL databases. The location of a WebKitWebDatabase +-- can be accessed wth 'webDatabaseGetFilename' You can configure the location of all +-- databases with 'setDatabaseDirectoryPath'. +-- +-- For each database the web site can define an estimated size which can be accessed with +-- 'webDatabaseGetExpectedSize' The current size of the database in bytes is returned by +-- 'webDatabaseGetSize'. +-- +-- For more information refer to the Web Database specification proposal at +-- http://dev.w3.org/html5/webdatabase + +-- * Types + WebDatabase, + WebDatabaseClass, + +-- * Methods + webDatabaseGetDisplayName, + webDatabaseGetExpectedSize, + webDatabaseGetFilename, + webDatabaseGetName, + webDatabaseGetSecurityOrigin, + webDatabaseGetSize, + webDatabaseRemove, +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +-- | Returns the name of the 'WebDatabase' as seen by the user. +webDatabaseGetDisplayName :: + WebDatabaseClass self => self + -> IO String +webDatabaseGetDisplayName wd = + {#call web_database_get_display_name#} (toWebDatabase wd) >>= peekCString + +-- | Returns the expected size of the Database in bytes as defined by the web author. The Web Database standard allows web authors to +-- specify an expected size of the database to optimize the user experience. +webDatabaseGetExpectedSize :: + WebDatabaseClass self => self + -> IO Int +webDatabaseGetExpectedSize wd = + liftM fromIntegral $ {#call web_database_get_expected_size#} (toWebDatabase wd) + +-- | Returns the absolute filename to the WebKitWebDatabase file on disk. +webDatabaseGetFilename :: + WebDatabaseClass self => self + -> IO String +webDatabaseGetFilename wd = + {#call web_database_get_filename#} (toWebDatabase wd) >>= peekCString + +-- | Returns the canonical name of the 'WebDatabase'. +webDatabaseGetName :: + WebDatabaseClass self => self + -> IO String +webDatabaseGetName wd = + {#call web_database_get_name#} (toWebDatabase wd) >>= peekCString + +-- | Returns the security origin of the WebKitWebDatabase. +webDatabaseGetSecurityOrigin :: + WebDatabaseClass self => self + -> IO SecurityOrigin +webDatabaseGetSecurityOrigin wd = + makeNewGObject mkSecurityOrigin $ {#call web_database_get_security_origin#} (toWebDatabase wd) + +-- | Returns the actual size of the 'WebDatabase' space on disk in bytes. +webDatabaseGetSize :: + WebDatabaseClass self => self + -> IO Int +webDatabaseGetSize wd = + liftM fromIntegral $ {#call web_database_get_size#} (toWebDatabase wd) + +-- | Removes the 'WebDatabase' from its security origin and destroys all data stored in the database. +webDatabaseRemove :: + WebDatabaseClass self => self + -> IO () +webDatabaseRemove wd = + {#call web_database_remove#} (toWebDatabase wd) + diff --git a/Graphics/UI/Gtk/WebKit/WebFrame.chs b/Graphics/UI/Gtk/WebKit/WebFrame.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/WebFrame.chs @@ -0,0 +1,306 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.WebFrame +-- Author : Cjacker Huang +-- Copyright : (c) 2009 Cjacker Huang +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- The content of a 'WebView' +-- +-- Note: +-- Functon `webkit_web_frame_get_global_context` can't binding now, +-- Because it need `JSGlobalContextRef` exist in JavaScriptCore. +-- +-- Function `webkit_web_frame_print_full` can't binding now, +-- Because library `GtkPrintOperation` haven't binding. +-- +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.WebFrame ( +-- * Description +-- | A WebKitWebView contains a main WebKitWebFrame. A WebKitWebFrame contains the content of one +-- URI. The URI and name of the frame can be retrieved, the load status and progress can be observed +-- using the signals and can be controlled using the methods of the WebKitWebFrame. A WebKitWebFrame +-- can have any number of children and one child can be found by using 'webFrameFindFrame'. + +-- * Types + WebFrame, + WebFrameClass, + LoadStatus, + +-- * Constructors + webFrameNew, + +-- * Methods + webFrameGetWebView, + webFrameGetName, +#if WEBKIT_CHECK_VERSION (1,1,18) + webFrameGetNetworkResponse, +#endif + webFrameGetTitle, + webFrameGetUri, + webFrameGetParent, + webFrameGetLoadStatus, + webFrameLoadUri, + webFrameLoadString, + webFrameLoadAlternateString, + webFrameLoadRequest, + webFrameStopLoading, + webFrameReload, + webFrameFindFrame, + webFrameGetDataSource, + webFrameGetHorizontalScrollbarPolicy, + webFrameGetVerticalScrollbarPolicy, + webFrameGetProvisionalDataSource, + webFrameGetSecurityOrigin, + webFramePrint, +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events +import Graphics.UI.Gtk.General.Enums + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +-- * Enums + +{#enum LoadStatus {underscoreToCase}#} + +------------------ +-- Constructors + + +-- | Create a new 'WebFrame' instance with the given @webview@. +-- +-- A 'WebFrame' contains the content of one URI. +webFrameNew :: + WebViewClass webview => webview -- ^ @webview@ - the given webview + -> IO WebFrame +webFrameNew webview = + wrapNewGObject mkWebFrame $ {#call web_frame_new#} (toWebView webview) + +-- | Return the 'WebView' that manages the given 'WebFrame'. +webFrameGetWebView :: + WebFrameClass self => self + -> IO WebView +webFrameGetWebView webframe = + makeNewObject mkWebView $ liftM castPtr $ {#call web_frame_get_web_view#} (toWebFrame webframe) + +-- | Return the name of the given 'WebFrame'. +webFrameGetName :: + WebFrameClass self => self + -> IO (Maybe String) -- ^ the name string or @Nothing@ in case failed. +webFrameGetName webframe = + {#call web_frame_get_name#} (toWebFrame webframe) >>= maybePeek peekCString + +#if WEBKIT_CHECK_VERSION (1,1,18) +-- | Returns a WebKitNetworkResponse object representing the response that was given to the request for +-- the given frame, or 'Nothing' if the frame was not created by a load. +-- +-- * Since 1.1.18 +webFrameGetNetworkResponse :: WebFrameClass self => self -> IO (Maybe NetworkResponse) +webFrameGetNetworkResponse frame = + maybeNull (makeNewGObject mkNetworkResponse) $ + {#call webkit_web_frame_get_network_response#} (toWebFrame frame) +#endif + +-- | Return the title of the given 'WebFrame'. +webFrameGetTitle :: + WebFrameClass self => self + -> IO (Maybe String) -- ^ the title string or @Nothing@ in case failed. +webFrameGetTitle webframe = + {#call web_frame_get_title#} (toWebFrame webframe) >>= maybePeek peekCString + +-- | Return the URI of the given 'WebFrame'. +webFrameGetUri :: + WebFrameClass self => self + -> IO (Maybe String) -- ^ the URI string or @Nothing@ in case failed. +webFrameGetUri webframe = + {#call web_frame_get_uri#} (toWebFrame webframe) >>= maybePeek peekCString + +-- | Return the 'WebFrame''s parent frame if it has one, +-- Otherwise return Nothing. +webFrameGetParent :: + WebFrameClass self => self + -> IO (Maybe WebFrame) -- ^ a 'WebFrame' or @Nothing@ in case failed. +webFrameGetParent webframe = + maybeNull (makeNewGObject mkWebFrame) $ {#call web_frame_get_parent#} (toWebFrame webframe) + +-- | Determines the current status of the load. +-- +-- frame : a WebKitWebView +-- +-- * Since 1.1.7 +webFrameGetLoadStatus :: + WebFrameClass self => self + -> IO LoadStatus +webFrameGetLoadStatus ls = + liftM (toEnum . fromIntegral) $ {#call web_frame_get_load_status#} (toWebFrame ls) + +-- | Request loading of the specified URI string. +webFrameLoadUri :: + WebFrameClass self => self + -> String -- ^ @uri@ - an URI string. + -> IO () +webFrameLoadUri webframe uri = + withCString uri $ \uriPtr -> {#call web_frame_load_uri#} + (toWebFrame webframe) + uriPtr + +-- | Requests loading of the given @content@ +-- with the specified @mime_type@, @encoding@ and @base_uri@. +-- +-- If @mime_type@ is @Nothing@, \"text/html\" is assumed. +-- +-- If @encoding@ is @Nothing@, \"UTF-8\" is assumed. +webFrameLoadString :: + WebFrameClass self => self + -> String -- ^ @content@ - the content string to be loaded. + -> (Maybe String) -- ^ @mime_type@ - the MIME type or @Nothing@. + -> (Maybe String) -- ^ @encoding@ - the encoding or @Nothing@. + -> String -- ^ @base_uri@ - the base URI for relative locations. + -> IO() +webFrameLoadString webframe content mimetype encoding baseuri = + withCString content $ \contentPtr -> + maybeWith withCString mimetype $ \mimetypePtr -> + maybeWith withCString encoding $ \encodingPtr -> + withCString baseuri $ \baseuriPtr -> + {#call web_frame_load_string#} + (toWebFrame webframe) + contentPtr + mimetypePtr + encodingPtr + baseuriPtr + +-- |Request loading of an alternate content for a URL that is unreachable. +-- +-- Using this method will preserve the back-forward list. +-- The URI passed in @base_uri@ has to be an absolute URI. +webFrameLoadAlternateString :: + WebFrameClass self => self + -> String -- ^ @content@ - the alternate content to display + -- as the main page of the frame + -> String -- ^ @base_uri@ - the base URI for relative locations. + -> String -- ^ @unreachable_url@ - the URL for the alternate page content. + -> IO() +webFrameLoadAlternateString webframe content baseurl unreachableurl = + withCString content $ \contentPtr -> + withCString baseurl $ \baseurlPtr -> + withCString unreachableurl $ \unreachableurlPtr -> + {#call web_frame_load_alternate_string#} + (toWebFrame webframe) + contentPtr + baseurlPtr + unreachableurlPtr + +-- | Connects to a given URI by initiating an asynchronous client request. +-- +-- Creates a provisional data source that will transition to a committed data source once any data has been received. +-- Use 'webFrameStopLoading' to stop the load. +-- This function is typically invoked on the main frame. +webFrameLoadRequest :: + (WebFrameClass self, NetworkRequestClass requ) => self -> requ + -> IO () +webFrameLoadRequest webframe request = + {#call web_frame_load_request#} (toWebFrame webframe) (toNetworkRequest request) + +-- | Stops and pending loads on the given data source and those of its children. +webFrameStopLoading :: + WebFrameClass self => self + -> IO() +webFrameStopLoading webframe = + {#call web_frame_stop_loading#} (toWebFrame webframe) + +-- |Reloads the initial request. +webFrameReload :: + WebFrameClass self => self + -> IO() +webFrameReload webframe = + {#call web_frame_reload#} (toWebFrame webframe) + +-- |Return the 'WebFrame' associated with the given name +-- or @Nothing@ in case none if found +-- +-- For pre-defined names, return the given webframe if name is +webFrameFindFrame:: + WebFrameClass self => self + -> String -- ^ @name@ - the name of the frame to be found. + -> IO (Maybe WebFrame) +webFrameFindFrame webframe name = + withCString name $ \namePtr -> + maybeNull (makeNewGObject mkWebFrame) $ + {#call web_frame_find_frame#} (toWebFrame webframe) namePtr + +-- | Returns the committed data source. +webFrameGetDataSource :: + WebFrameClass self => self + -> IO WebDataSource +webFrameGetDataSource webframe = + makeNewGObject mkWebDataSource $ {#call web_frame_get_data_source#} (toWebFrame webframe) + +-- | Return the policy of horizontal scrollbar. +webFrameGetHorizontalScrollbarPolicy :: + WebFrameClass self => self + -> IO PolicyType +webFrameGetHorizontalScrollbarPolicy webframe = + liftM (toEnum.fromIntegral) $ + {#call web_frame_get_horizontal_scrollbar_policy#} (toWebFrame webframe) + +-- | Return the policy of vertical scrollbar. +webFrameGetVerticalScrollbarPolicy :: + WebFrameClass self => self + -> IO PolicyType +webFrameGetVerticalScrollbarPolicy webframe = + liftM (toEnum.fromIntegral) $ + {#call web_frame_get_vertical_scrollbar_policy#} (toWebFrame webframe) + +-- | You use the 'webFrameLoadRequest' method to initiate a request that creates a provisional data source. +-- The provisional data source will transition to a committed data source once any data has been received. +-- Use 'webFrameGetDataSource' to get the committed data source. +webFrameGetProvisionalDataSource :: + WebFrameClass self => self + -> IO WebDataSource +webFrameGetProvisionalDataSource webframe = + makeNewGObject mkWebDataSource $ {#call web_frame_get_provisional_data_source#} (toWebFrame webframe) + +-- | Returns the frame's security origin. +webFrameGetSecurityOrigin :: + WebFrameClass self => self + -> IO SecurityOrigin +webFrameGetSecurityOrigin webframe = + makeNewGObject mkSecurityOrigin $ {#call web_frame_get_security_origin#} (toWebFrame webframe) + +-- |Prints the given 'WebFrame'. +-- +-- by presenting a print dialog to the user. +webFramePrint:: + WebFrameClass self => self + -> IO() +webFramePrint webframe = + {#call web_frame_print#} (toWebFrame webframe) + diff --git a/Graphics/UI/Gtk/WebKit/WebHistoryItem.chs b/Graphics/UI/Gtk/WebKit/WebHistoryItem.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/WebHistoryItem.chs @@ -0,0 +1,208 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.WebHistoryItem +-- Author : Cjacker Huang +-- Copyright : (c) 2009 Cjacker Huang +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- One item of the 'WebBackForwardList' and or global history +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.WebHistoryItem ( +-- * Description +-- | A history item consists out of a title and a uri. It can be part of the WebKitWebBackForwardList and +-- the global history. The global history is used for coloring the links of visited +-- sites. WebKitWebHistoryItem's constructed with 'webHistoryItemNew' and +-- 'webHistoryItemNewWithData' are automatically added to the global history. + +-- * Types + WebHistoryItem, + WebHistoryItemClass, + +-- * Constructors + webHistoryItemNew, + webHistoryItemNewWithData, + +-- * Attributes + webHistoryItemTitle, + webHistoryItemAlternateTitle, + webHistoryItemUri, + webHistoryItemOriginalUri, + webHistoryItemLastVisitedTime, + +-- * Methods + webHistoryItemGetTitle, + webHistoryItemGetAlternateTitle, + webHistoryItemSetAlternateTitle, + webHistoryItemGetUri, + webHistoryItemGetOriginalUri, + webHistoryItemGetLastVisitedTime, +#if WEBKIT_CHECK_VERSION (1,1,18) + webHistoryItemCopy, +#endif +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GError +import System.Glib.Attributes +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +------------------ +-- Constructors + + + +-- | Create a new 'WebHistoryItem' instance. +-- +-- A history item consists out of a title and a uri, +-- it can be part of the WebBackForwardList and the global history. +-- +-- The global history is used for coloring the links of visited sites. +-- 'WebHistoryItem' constructed with 'webHistoryItemNew' are +-- automatically added to the global history. +webHistoryItemNew :: IO WebHistoryItem +webHistoryItemNew = + wrapNewGObject mkWebHistoryItem $ {#call web_history_item_new#} + + +-- | Create a new 'WebHistoryItem' instance with the given @uri@ and @title@. +-- +-- 'WebHistoryItem' constructed with 'webHistoryItemNewWithData' are +-- automatically added to the global history. +webHistoryItemNewWithData :: + String -- ^ @uri@ - the uri of the item + -> String -- ^ @title@ - the title of the item + -> IO WebHistoryItem +webHistoryItemNewWithData uri title = + withCString uri $ \uriPtr -> + withCString title $ \titlePtr -> + wrapNewGObject mkWebHistoryItem $ + {#call web_history_item_new_with_data#} + uriPtr + titlePtr + + +-- | Return the title of 'WebHistoryItem'. +webHistoryItemGetTitle :: + WebHistoryItemClass self => self + -> IO (Maybe String) -- ^ the title or @Nothing@ in case failed. +webHistoryItemGetTitle webhistoryitem = + {#call web_history_item_get_title#} + (toWebHistoryItem webhistoryitem) >>= + maybePeek peekCString + +-- | Return the alternate title of WebHistoryItem. +webHistoryItemGetAlternateTitle :: + WebHistoryItemClass self => self + -> IO (Maybe String) -- ^ the alternate title or @Nothing@ in case failed. +webHistoryItemGetAlternateTitle webhistoryitem = + {#call web_history_item_get_alternate_title#} + (toWebHistoryItem webhistoryitem) >>= + maybePeek peekCString + +-- | Set an alternate title for WebHistoryItem. +webHistoryItemSetAlternateTitle :: + WebHistoryItemClass self => self + -> (Maybe String) -- ^ @title@ - the alternate title for this history item. + -> IO() +webHistoryItemSetAlternateTitle webhistoryitem title = + maybeWith withCString title $ \titlePtr -> + {#call web_history_item_set_alternate_title#} + (toWebHistoryItem webhistoryitem) + titlePtr + +-- | Return the URI of WebHistoryItem. +webHistoryItemGetUri :: + WebHistoryItemClass self => self + -> IO (Maybe String) -- ^ the URI or @Nothing@ in case failed. +webHistoryItemGetUri webhistoryitem = + {#call web_history_item_get_uri#} + (toWebHistoryItem webhistoryitem) >>= + maybePeek peekCString + +-- | Return the original URI of WebHistoryItem. +webHistoryItemGetOriginalUri :: + WebHistoryItemClass self => self + -> IO (Maybe String) -- ^ the URI or @Nothing@ in case failed +webHistoryItemGetOriginalUri webhistoryitem = + {#call web_history_item_get_original_uri#} + (toWebHistoryItem webhistoryitem) >>= + maybePeek peekCString + +-- | Return the last visited time of WebHistoryItem. +webHistoryItemGetLastVisitedTime :: + WebHistoryItemClass self => self + -> IO Double -- ^ the last visited time of this history item. +webHistoryItemGetLastVisitedTime webhistoryitem = + liftM realToFrac $ + {#call web_history_item_get_last_visited_time#} + (toWebHistoryItem webhistoryitem) + +#if WEBKIT_CHECK_VERSION (1,1,18) +-- | Makes a copy of the item for use with other WebView objects. +-- +-- * Since 1.1.18 +webHistoryItemCopy :: WebHistoryItemClass self => self + -> IO WebHistoryItem +webHistoryItemCopy webhistoryitem = + makeNewGObject mkWebHistoryItem $ + {#call webkit_web_history_item_copy#} (toWebHistoryItem webhistoryitem) +#endif + +-- | The title of the 'WebHistoryItem' +-- +-- Default value: @Nothing@ +webHistoryItemTitle :: (WebHistoryItemClass self) => ReadAttr self (Maybe String) +webHistoryItemTitle = readAttr webHistoryItemGetTitle + +-- | The alternate title of the history item. +-- +-- Default value: @Nothing@ +webHistoryItemAlternateTitle :: (WebHistoryItemClass self) => Attr self (Maybe String) +webHistoryItemAlternateTitle = newAttr webHistoryItemGetAlternateTitle webHistoryItemSetAlternateTitle + +-- | The URI of the history item. +-- +-- Default value: @Nothing@ +webHistoryItemUri :: (WebHistoryItemClass self) => ReadAttr self (Maybe String) +webHistoryItemUri = readAttr webHistoryItemGetUri + +-- | The original URI of the history item. +-- +-- Default value: @Nothing@ +webHistoryItemOriginalUri :: (WebHistoryItemClass self) => ReadAttr self (Maybe String) +webHistoryItemOriginalUri = readAttr webHistoryItemGetOriginalUri + +-- | The time at which the history item was last visited. +-- +-- Allowed values: >= 0 +-- +-- Default value: 0 +webHistoryItemLastVisitedTime :: (WebHistoryItemClass self) => ReadAttr self Double +webHistoryItemLastVisitedTime = readAttr webHistoryItemGetLastVisitedTime + diff --git a/Graphics/UI/Gtk/WebKit/WebInspector.chs b/Graphics/UI/Gtk/WebKit/WebInspector.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/WebInspector.chs @@ -0,0 +1,205 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.WebInspector +-- Author : Cjacker Huang +-- Copyright : (c) 2009 Cjacker Huang +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Access to the WebKit Inspector +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.WebInspector ( +-- * Description +-- | The WebKit Inspector is a graphical tool to inspect and change the content of a WebKitWebView. It +-- also includes an interactive JavaScriptDebugger. Using this class one can get a 'Widget' which can +-- be embedded into an application to show the inspector. +-- +-- The inspector is available when the WebKitWebSettings of the WebKitWebView has set the +-- 'enableDeveloperExtras' to true otherwise no inspector is available. + +-- * Types + WebInspector, + WebInspectorClass, + +-- * Methods + webInspectorGetInspectedUri, + webInspectorGetWebView, +#if WEBKIT_CHECK_VERSION (1,1,17) + webInspectorInspectCoordinates, + webInspectorShow, + webInspectorClose, +#endif + +-- * Attribute + webInspectorInspectedUri, + webInspectorJSProfilingEnable, +#if WEBKIT_CHECK_VERSION (1,1,17) + webInspectorTimelineProfilingEnabled, +#endif + webInspectorWebView, + +-- * Signals + attachWindow, + detachWindow, + closeWindow, + showWindow, + finished, + inspectWebView, +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GError +import System.Glib.Attributes +import System.Glib.Properties +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import Graphics.UI.Gtk.WebKit.Internal#} +{#import Graphics.UI.Gtk.WebKit.Signals#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + + +------------------ +-- | Obtains the URI that is currently being inspected +webInspectorGetInspectedUri :: + WebInspectorClass self => self + -> IO String +webInspectorGetInspectedUri inspector = + {#call web_inspector_get_inspected_uri#} (toWebInspector inspector) >>= peekCString + +-- | Obtains the 'WebView' that is used to render the 'WebInspector'. +-- +-- The 'WebView' instance is created by the application, +-- by handling the "inspect-web-view" signal. +-- This means that it may return @Nothing@ if the user hasn't inspected anything +webInspectorGetWebView :: + WebInspectorClass self => self + -> IO (Maybe WebView) +webInspectorGetWebView inspector = + maybeNull (makeNewObject mkWebView) $ liftM castPtr $ + {#call web_inspector_get_web_view#} + (toWebInspector inspector) + +#if WEBKIT_CHECK_VERSION (1,1,17) +-- | Causes the Web Inspector to inspect the node that is located at the given coordinates of the +-- widget. The coordinates should be relative to the WebKitWebView widget, not to the scrollable +-- content, and may be obtained from a 'Event' directly. +-- +-- This means x, and y being zero doesn't guarantee you will hit the left-most top corner of the +-- content, since the contents may have been scrolled. +-- +-- * Since 1.1.17 +webInspectorInspectCoordinates :: WebInspectorClass self + => self -- ^ @webInspector@ the WebKitWebInspector that will do the inspection + -> Int -- ^ @x@ the X coordinate of the node to be inspected + -> Int -- ^ @y@ the Y coordinate of the node to be inspected + -> IO () +webInspectorInspectCoordinates inspect x y = + {#call web_inspector_inspect_coordinates#} + (toWebInspector inspect) + (fromIntegral x) + (fromIntegral y) + +-- | Causes the Web Inspector to be shown. +-- +-- * Since 1.1.17 +webInspectorShow :: WebInspectorClass self => self -> IO () +webInspectorShow inspect = + {#call webkit_web_inspector_show#} (toWebInspector inspect) + +-- | Causes the Web Inspector to be closed. +-- +-- * Since 1.1.17 +webInspectorClose :: WebInspectorClass self => self -> IO () +webInspectorClose inspect = + {#call webkit_web_inspector_close#} (toWebInspector inspect) +#endif + +-- * Attribute + +-- | The URI that is currently being inspected. +webInspectorInspectedUri :: (WebInspectorClass self) => ReadAttr self String +webInspectorInspectedUri = readAttr webInspectorGetInspectedUri + +-- | This is enabling JavaScript profiling in the Inspector. This means that Console.profiles will return the profiles. +webInspectorJSProfilingEnable :: (WebInspectorClass self) => Attr self Bool +webInspectorJSProfilingEnable = newAttrFromBoolProperty "javascript-profiling-enabled" + +#if WEBKIT_CHECK_VERSION (1,1,17) +-- | This is enabling Timeline profiling in the Inspector. +-- +-- Default value: 'False' +-- +-- * Since 1.1.17 +webInspectorTimelineProfilingEnabled :: (WebInspectorClass self) => Attr self Bool +webInspectorTimelineProfilingEnabled = newAttrFromBoolProperty "timeline-profiling-enabled" +#endif + +-- | The Web View that renders the Web Inspector itself. +webInspectorWebView :: (WebInspectorClass self) => ReadAttr self WebView +webInspectorWebView = + readAttrFromObjectProperty "web-view" + {#call pure webkit_web_view_get_type#} + +-- * Signals + +-- | Emitted when the inspector should appear in a separate window +-- +-- return True if the signal is handled +attachWindow :: WebInspectorClass self => Signal self (IO Bool) +attachWindow = Signal (connect_NONE__BOOL "attach_window") + +-- | Emitted when the inspector should appear in a separate window. +-- +-- return True if the signal has been handled +detachWindow :: WebInspectorClass self => Signal self (IO Bool) +detachWindow = Signal (connect_NONE__BOOL "detach_window") + +-- | Emitted when the inspector window should be closed. +-- +-- return True if the signal is handled. +closeWindow :: WebInspectorClass self => Signal self (IO Bool) +closeWindow = Signal (connect_NONE__BOOL "close_window") + +-- | Emitted when the inspector window should be displayed. +-- Notice that the window must have been created already by handling 'inspectWebView'. +-- +-- return True if the signal has been handled +showWindow :: WebInspectorClass self => Signal self (IO Bool) +showWindow = Signal (connect_NONE__BOOL "show_window") + +-- | Emitted when the inspection is done. You should release your references on the inspector at this time. +-- The inspected 'WebView' may no longer exist when this signal is emitted. +finished :: WebInspectorClass self => Signal self (IO ()) +finished = Signal (connect_NONE__NONE "finished") + +-- | Emitted when the user activates the 'inspect' context menu item to inspect a web view. +-- The application which is interested in the inspector should create a window, +-- or otherwise add the 'WebView' it creates to an existing window. +-- +-- You don't need to handle the reference count of the 'WebView' instance you create; +-- the widget to which you add it will do that. +inspectWebView :: WebInspectorClass self => Signal self (WebView -> IO WebView) +inspectWebView = Signal (connect_OBJECT__OBJECTPTR "inspect_web_view") diff --git a/Graphics/UI/Gtk/WebKit/WebNavigationAction.chs b/Graphics/UI/Gtk/WebKit/WebNavigationAction.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/WebNavigationAction.chs @@ -0,0 +1,125 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.WebNavigationAction +-- Author : Andy Stewart +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Access to the WebKit NavigationAction +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.WebNavigationAction ( +-- * Description +-- | 'WebNavigationAction' is used in signals to provide details about what led the navigation to +-- happen. This includes, for instance, if the user clicked a link to start that navigation, and what +-- mouse button was used. + +-- * Types + WebNavigationAction, + WebNavigationActionClass, + +-- * Enums + NavigationReason(..), + +-- * Methods + webNavigationActionGetButton, + webNavigationActionGetModifierState, + webNavigationActionGetOriginalUri, + webNavigationActionSetOriginalUri, + webNavigationActionGetReason, + webNavigationActionSetReason, + webNavigationActionGetTargetFrame, +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +-- * Enums + +{#enum WebNavigationReason as NavigationReason {underscoreToCase} deriving(Eq, Show) #} + +-- * Methods + +-- | Returns the DOM identifier for the mouse button used to click. +-- DOM button values are 1, 2 and 3 for left, middle and right buttons. +-- If the action was not initiated by a mouse click, returns -1. +webNavigationActionGetButton :: + WebNavigationActionClass self => self + -> IO Int +webNavigationActionGetButton action = + liftM fromIntegral $ {#call web_navigation_action_get_button#} (toWebNavigationAction action) + +-- | Returns a bitmask with the the state of the modifier keys. +webNavigationActionGetModifierState :: + WebNavigationActionClass self => self + -> IO Int +webNavigationActionGetModifierState action = + liftM fromIntegral $ {#call web_navigation_action_get_modifier_state#} (toWebNavigationAction action) + +-- | Returns the URI that was originally requested. +-- This may differ from the navigation target, for instance because of a redirect. +webNavigationActionGetOriginalUri :: + WebNavigationActionClass self => self + -> IO String +webNavigationActionGetOriginalUri action = + {#call web_navigation_action_get_original_uri#} (toWebNavigationAction action) >>= peekCString + +-- | Returns the reason why WebKit is requesting a navigation. +webNavigationActionGetReason :: + WebNavigationActionClass self => self + -> IO NavigationReason +webNavigationActionGetReason action = + liftM (toEnum . fromIntegral) $ {#call web_navigation_action_get_reason#} (toWebNavigationAction action) + +-- | Returns the target frame of the action. +webNavigationActionGetTargetFrame :: + WebNavigationActionClass self => self + -> IO String +webNavigationActionGetTargetFrame action = + {#call web_navigation_action_get_target_frame#} (toWebNavigationAction action) >>= peekCString + +-- | Sets the URI that was originally requested. +-- This may differ from the navigation target, for instance because of a redirect. +webNavigationActionSetOriginalUri :: + WebNavigationActionClass self => self + -> String + -> IO () +webNavigationActionSetOriginalUri action uri = + withCString uri $ \uriPtr -> + {#call web_navigation_action_set_original_uri#} + (toWebNavigationAction action) + uriPtr + +-- | Sets the reason why WebKit is requesting a navigation. +webNavigationActionSetReason :: + WebNavigationActionClass self => self + -> NavigationReason + -> IO () +webNavigationActionSetReason action reason = + {#call web_navigation_action_set_reason#} (toWebNavigationAction action) (fromIntegral (fromEnum reason)) diff --git a/Graphics/UI/Gtk/WebKit/WebPolicyDecision.chs b/Graphics/UI/Gtk/WebKit/WebPolicyDecision.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/WebPolicyDecision.chs @@ -0,0 +1,77 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.WebPolicyDecision +-- Author : Andy Stewart +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Access to the WebKit PolicyDecision +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.WebPolicyDecision ( +-- * Desciption +-- | 'WebPolicyDecision' objects are given to the application on signal emissions that deal with +-- policy decisions, such as if a new window should be opened, or if a given navigation should be +-- allowed. The application uses it to tell the engine what to do. + +-- * Types + WebPolicyDecision, + WebPolicyDecisionClass, + +-- * Methods + webPolicyDecisionDownload, + webPolicyDecisionIgnore, + webPolicyDecisionUse, +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +-- * Methods + +-- | Will send the DOWNLOAD decision to the policy implementer. +webPolicyDecisionDownload :: + WebPolicyDecisionClass self => self + -> IO () +webPolicyDecisionDownload pd = + {#call web_policy_decision_download#} (toWebPolicyDecision pd) + +-- | Will send the IGNORE decision to the policy implementer. +webPolicyDecisionIgnore :: + WebPolicyDecisionClass self => self + -> IO () +webPolicyDecisionIgnore pd = + {#call web_policy_decision_ignore#} (toWebPolicyDecision pd) + +-- | Will send the USE decision to the policy implementer. +webPolicyDecisionUse :: + WebPolicyDecisionClass self => self + -> IO () +webPolicyDecisionUse pd = + {#call web_policy_decision_use#} (toWebPolicyDecision pd) diff --git a/Graphics/UI/Gtk/WebKit/WebResource.chs b/Graphics/UI/Gtk/WebKit/WebResource.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/WebResource.chs @@ -0,0 +1,111 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.WebResource +-- Author : Andy Stewart +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Note: +-- +-- Function `webkit_web_resource_get_data` haven't binding +-- no idea how to handle `GString`. +-- +-- Access to the WebKit Web Resource +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.WebResource ( +-- * Description +-- | A web resource encapsulates the data of the download as well as the URI, MIME type and frame name of +-- the resource. + +-- * Types + WebResource, + WebResourceClass, + +-- * Constructors + webResourceNew, + +-- * Methods + webResourceGetData, + webResourceGetEncoding, + webResourceGetFrameName, + webResourceGetMimeType, + webResourceGetUri, +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GString +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +-- | Returns a new WebKitWebResource. +-- The @encoding@ can be empty. +-- The @frameName@ can be used if the resource represents contents of an +-- entire HTML frame, otherwise pass empty. +webResourceNew :: String -> Int -> String -> String -> String -> String -> IO WebResource +webResourceNew resData size uri mimeType encoding frameName = + withCString resData $ \dataPtr -> + withCString uri $ \uriPtr -> + withCString mimeType $ \mimePtr -> + withCString encoding $ \encodingPtr -> + withCString frameName $ \framePtr -> + wrapNewGObject mkWebResource $ + {#call web_resource_new#} dataPtr (fromIntegral size) uriPtr mimePtr encodingPtr framePtr + +-- | Returns the data of the WebResource. +webResourceGetData :: WebResourceClass self => self -> IO (Maybe String) +webResourceGetData wr = + {#call web_resource_get_data#} (toWebResource wr) >>= readGString + +-- | Get encoding. +webResourceGetEncoding :: + WebResourceClass self => self + -> IO (Maybe String) +webResourceGetEncoding wr = + {#call web_resource_get_encoding#} (toWebResource wr) >>= maybePeek peekCString + +-- | Get frame name. +webResourceGetFrameName :: + WebResourceClass self => self + -> IO (Maybe String) +webResourceGetFrameName wr = + {#call web_resource_get_frame_name#} (toWebResource wr) >>= maybePeek peekCString + +-- | Get mime type. +webResourceGetMimeType :: + WebResourceClass self => self + -> IO (Maybe String) +webResourceGetMimeType wr = + {#call web_resource_get_mime_type#} (toWebResource wr) >>= maybePeek peekCString + +-- | Get uri. +webResourceGetUri :: + WebResourceClass self => self + -> IO String +webResourceGetUri wr = + {#call web_resource_get_uri#} (toWebResource wr) >>= peekCString diff --git a/Graphics/UI/Gtk/WebKit/WebSettings.chs b/Graphics/UI/Gtk/WebKit/WebSettings.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/WebSettings.chs @@ -0,0 +1,411 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.WebSettings +-- Author : Cjacker Huang +-- Copyright : (c) 2009 Cjacker Huang +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Control the behaviour of a 'WebView' +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.WebSettings ( +-- * Desciption +-- | WebKitWebSettings can be applied to a WebKitWebView to control the to be used text encoding, color, +-- font sizes, printing mode, script support, loading of images and various other things. + +-- * Types + WebSettings, + WebSettingsClass, + EditingBehavior, + +-- * Constructors + webSettingsNew, + +-- * Methods + webSettingsCopy, + webSettingsGetUserAgent, + +-- * Attributes +-- ** Family + webSettingsCursiveFontFamily, + webSettingsDefaultFontFamily, + webSettingsFantasyFontFamily, + webSettingsMonospaceFontFamily, + webSettingsSansFontFamily, + webSettingsSerifFontFamily, +-- ** FontSize + webSettingsDefaultFontSize, + webSettingsDefaultMonospaceFontSize, + webSettingsMinimumFontSize, + webSettingsMinimumLogicalFontSize, +-- ** Image + webSettingsAutoLoadImages, + webSettingsAutoShrinkImages, +-- ** Encoding + webSettingsDefaultEncoding, +-- ** Other + webSettingsEditingBehavior, + webSettingsEnableCaretBrowsing, + webSettingsEnableDeveloperExtras, + webSettingsEnableHtml5Database, + webSettingsEnableHtml5LocalStorage, + webSettingsEnableOfflineWebApplicationCache, + webSettingsEnablePlugins, + webSettingsEnablePrivateBrowsing, + webSettingsEnableScripts, + webSettingsEnableSpellChecking, + webSettingsEnableUniversalAccessFromFileUris, + webSettingsEnableXssAuditor, + webSettingsEnableSiteSpecificQuirks, +#if WEBKIT_CHECK_VERSION (1,1,16) + webSettingsEnableDomPaste, +#endif +#if WEBKIT_CHECK_VERSION (1,1,18) + webSettingsEnableDefaultContextMenu, + webSettingsEnablePageCache, +#endif +#if WEBKIT_CHECK_VERSION (1,1,23) + webSettingsEnableSpatialNavigation, +#endif + webSettingsEnforce96Dpi, + webSettingsJSCanOpenWindowAuto, + webSettingsPrintBackgrounds, + webSettingsResizableTextAreas, + webSettingsSpellCheckingLang, +#if WEBKIT_CHECK_VERSION (1,1,17) + webSettingsTabKeyCyclesThroughElements, +#endif + webSettingsUserAgent, + webSettingsUserStylesheetUri, + webSettingsZoomStep, +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GError +import System.Glib.Properties +import System.Glib.Attributes +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +{#enum EditingBehavior {underscoreToCase}#} +------------------ +-- Constructors + + +-- | Create a new 'WebSettings' instance. +-- +-- A 'WebSettings' can be applied to a 'WebView' +-- to control the to be used text encoding, color, font size, +-- printing mode,script support, loading of images and various other things. +webSettingsNew :: IO WebSettings +webSettingsNew = + wrapNewGObject mkWebSettings $ {#call web_settings_new#} + + +-- | Copy an existing 'WebSettings' instance. +webSettingsCopy :: + WebSettingsClass self => self + -> IO WebSettings +webSettingsCopy websettings = + constructNewGObject mkWebSettings $ {#call web_settings_copy#} (toWebSettings websettings) + +-- | Return the User-Agent string currently used. +webSettingsGetUserAgent :: + WebSettingsClass self => self + -> IO (Maybe String) -- ^ User-Agent string or @Nothing@ in case failed. +webSettingsGetUserAgent websettings = + {#call web_settings_get_user_agent#} (toWebSettings websettings) >>= maybePeek peekCString + +-- | Load images automatically +-- +-- Default value: True +webSettingsAutoLoadImages :: (WebSettingsClass self) => Attr self Bool +webSettingsAutoLoadImages = newAttrFromBoolProperty "auto-load-images" + +-- | Automatically shrink standalone images to fit +-- +-- Default value: True +webSettingsAutoShrinkImages :: (WebSettingsClass self) => Attr self Bool +webSettingsAutoShrinkImages = newAttrFromBoolProperty "auto-shrink-images" + +-- | The default Cursive font family used to display text +-- +-- Default value "serif" +webSettingsCursiveFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsCursiveFontFamily = newAttrFromStringProperty "cursive-font-family" + +-- | The default encoding used to display text +-- +-- Default value "iso-8859-1" + +webSettingsDefaultEncoding :: (WebSettingsClass self) => Attr self String +webSettingsDefaultEncoding = newAttrFromStringProperty "default-encoding" + +-- | The default font family used to display text +-- +-- Default value: "sans-serif" + +webSettingsDefaultFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsDefaultFontFamily = newAttrFromStringProperty "default-font-family" + +-- | The default font size used to display text +-- +-- Default value: >=5 + +webSettingsDefaultFontSize :: (WebSettingsClass self) => Attr self Int +webSettingsDefaultFontSize = newAttrFromIntProperty "default-font-size" + +-- | The default font size used to display monospace text +-- +-- Allowed values: >= 5 +-- +-- Default value: 10 + +webSettingsDefaultMonospaceFontSize :: (WebSettingsClass self) => Attr self Int +webSettingsDefaultMonospaceFontSize = newAttrFromIntProperty "default-monospace-font-size" + +-- | This settings controls various editing behaviors +webSettingsEditingBehavior :: (WebSettingsClass self) => Attr self EditingBehavior +webSettingsEditingBehavior = newAttrFromEnumProperty "editing-behavior" + {#call pure unsafe webkit_editing_behavior_get_type#} +-- | Whether to enable caret browsing mode. +webSettingsEnableCaretBrowsing :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableCaretBrowsing = newAttrFromBoolProperty "enable-caret-browsing" + +-- | Whether developer extensions should be enabled. +-- +-- This enables, for now, the 'WebInspector' +webSettingsEnableDeveloperExtras :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableDeveloperExtras = newAttrFromBoolProperty "enable-developer-extras" + +#if WEBKIT_CHECK_VERSION (1,1,16) +-- | Whether to enable DOM paste. If set to 'True', document.execCommand("Paste") will correctly execute +-- and paste content of the clipboard. +-- +-- Default value: 'False' +-- +-- * Since 1.1.16 +webSettingsEnableDomPaste :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableDomPaste = newAttrFromBoolProperty "enable-dom-paste" +#endif + +-- | Whether to enable HTML5 client-side SQL database support. +webSettingsEnableHtml5Database :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableHtml5Database = newAttrFromBoolProperty "enable-html5-database" + +-- | Whether to enable HTML5 localStorage support. +webSettingsEnableHtml5LocalStorage :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableHtml5LocalStorage = newAttrFromBoolProperty "enable-html5-local-storage" + +-- | Whether to enable HTML5 offline web application cache support. +webSettingsEnableOfflineWebApplicationCache :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableOfflineWebApplicationCache = newAttrFromBoolProperty "enable-offline-web-application-cache" + +-- | Enable embedded plugin objects. +webSettingsEnablePlugins :: (WebSettingsClass self) => Attr self Bool +webSettingsEnablePlugins = newAttrFromBoolProperty "enable-plugins" + +-- | Whether to enable private browsing mode. +webSettingsEnablePrivateBrowsing :: (WebSettingsClass self) => Attr self Bool +webSettingsEnablePrivateBrowsing = newAttrFromBoolProperty "enable-private-browsing" + +-- | Enable embedded scripting languages +webSettingsEnableScripts :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableScripts = newAttrFromBoolProperty "enable-scripts" + +-- | Whether to enable speel checking while typing. +webSettingsEnableSpellChecking :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableSpellChecking = newAttrFromBoolProperty "enable-spell-checking" + +-- | Whether to allow files loaded through file:// URLs universal access to all pages. +webSettingsEnableUniversalAccessFromFileUris :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableUniversalAccessFromFileUris = newAttrFromBoolProperty "enable-universal-access-from-file-uris" + +-- | Whether to enable the XSS Auditor. +-- +-- This feature filters some kinds of reflective XSS attacks on vulnerable web sites. +webSettingsEnableXssAuditor :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableXssAuditor = newAttrFromBoolProperty "enable-xss-auditor" + +-- | Enforce a resolution of 96 DPI. +webSettingsEnforce96Dpi :: (WebSettingsClass self) => Attr self Bool +webSettingsEnforce96Dpi = newAttrFromBoolProperty "enforce-96-dpi" + +-- | The default Fantasy font family used to display text +webSettingsFantasyFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsFantasyFontFamily = newAttrFromStringProperty "fantasy-font-family" + +-- | Whether JavaScript can open popup windows automatically without user intervention. +webSettingsJSCanOpenWindowAuto :: (WebSettingsClass self) => Attr self Bool +webSettingsJSCanOpenWindowAuto = newAttrFromBoolProperty "javascript-can-open-windows-automatically" + +-- | The minimum font size used to display text. +-- +-- Allowed values: >=1 +-- +-- Default value: 5 +webSettingsMinimumFontSize :: (WebSettingsClass self) => Attr self Int +webSettingsMinimumFontSize = newAttrFromIntProperty "minimum-font-size" + +-- | The minimum logical font size used to display text +-- +-- Allowed values: >=1 +-- +-- Default value: 5 +webSettingsMinimumLogicalFontSize :: (WebSettingsClass self) => Attr self Int +webSettingsMinimumLogicalFontSize = newAttrFromIntProperty "minimum-logical-font-size" + + +-- | The default font family used to display monospace text. +-- +-- Default value: "monospace" +webSettingsMonospaceFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsMonospaceFontFamily = newAttrFromStringProperty "monospace-font-family" + +-- | Whether background images should be printed +-- +-- Default value: True +webSettingsPrintBackgrounds :: (WebSettingsClass self) => Attr self Bool +webSettingsPrintBackgrounds = newAttrFromBoolProperty "print-backgrounds" + +-- | Whether text areas are resizable +-- +-- Default value : True +webSettingsResizableTextAreas :: (WebSettingsClass self) => Attr self Bool +webSettingsResizableTextAreas = newAttrFromBoolProperty "resizable-text-areas" + +-- | The default Sans Serif font family used to display text +-- +-- Default value "sans-serif" +webSettingsSansFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsSansFontFamily = newAttrFromStringProperty "sans-serif-font-family" + + +-- | The default Serif font family used to display text +-- +-- Default value: "serif" +webSettingsSerifFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsSerifFontFamily = newAttrFromStringProperty "serif-font-family" + + +-- | The languages to be used for spell checking, separated by commas +-- +-- 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. +-- +-- If no value is specified then the value returned by gtk_get_default_language will be used. +-- +-- Default value: @Nothing@ +webSettingsSpellCheckingLang :: (WebSettingsClass self) => Attr self (Maybe String) +webSettingsSpellCheckingLang = newAttrFromMaybeStringProperty "spell-checking-languages" + +#if WEBKIT_CHECK_VERSION (1,1,17) +-- | Whether the tab key cycles through elements on the page. +-- +-- If flag is 'True', pressing the tab key will focus the next element in the @webView@. If flag is 'False', +-- the @webView@ will interpret tab key presses as normal key presses. If the selected element is +-- editable, the tab key will cause the insertion of a tab character. +-- +-- Default value: 'True' +-- +-- * Since 1.1.17 +webSettingsTabKeyCyclesThroughElements :: (WebSettingsClass self) => Attr self Bool +webSettingsTabKeyCyclesThroughElements = newAttrFromBoolProperty "tab-key-cycles-through-elements" +#endif + +#if WEBKIT_CHECK_VERSION (1,1,18) +-- | Whether right-clicks should be handled automatically to create, and display the context +-- menu. Turning this off will make WebKitGTK+ not emit the populate-popup signal. Notice that the +-- default button press event handler may still handle right clicks for other reasons, such as in-page +-- context menus, or right-clicks that are handled by the page itself. +-- +-- Default value: 'True' +-- +-- * Since 1.1.18 +webSettingsEnableDefaultContextMenu :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableDefaultContextMenu = newAttrFromBoolProperty "enable-default-context-menu" + +-- | 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/ +-- +-- Default value: 'False' +-- +-- * Since 1.1.18 +webSettingsEnablePageCache :: (WebSettingsClass self) => Attr self Bool +webSettingsEnablePageCache = newAttrFromBoolProperty "enable-page-cache" +#endif + +-- | The User-Agent string used by WebKit +-- +-- This will return a default User-Agent string if a custom string wasn't provided by the application. +-- Setting this property to a NULL value or an empty string will result in +-- the User-Agent string being reset to the default value. +-- +-- Default value: \"Mozilla/5.0 (X11; U; Linux x86_64; c) AppleWebKit/531.2+ (KHTML, like Gecko) Safari/531.2+\" + +webSettingsUserAgent :: (WebSettingsClass self) => Attr self String +webSettingsUserAgent = newAttrFromStringProperty "user-agent" + +-- | The URI of a stylesheet that is applied to every page. +-- +-- Default value: @Nothing@ + +webSettingsUserStylesheetUri :: (WebSettingsClass self) => Attr self (Maybe String) +webSettingsUserStylesheetUri = newAttrFromMaybeStringProperty "user-stylesheet-uri" + +-- | The value by which the zoom level is changed when zooming in or out +-- +-- Allowed values: >= 0 +-- +-- Default value: 0.1 +webSettingsZoomStep :: (WebSettingsClass self) => Attr self Float +webSettingsZoomStep = newAttrFromFloatProperty "zoom-step" + +-- | Enables the site-specific compatibility workarounds. +-- +-- Default value: False +webSettingsEnableSiteSpecificQuirks :: WebSettingsClass self => Attr self Bool +webSettingsEnableSiteSpecificQuirks = newAttrFromBoolProperty "enable-site-specific-quirks" + +#if WEBKIT_CHECK_VERSION (1,1,23) +-- | Whether to enable the 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 he might be trying to reach towards the right, and if there are multiple elements, +-- which element he probably wants. +-- +-- Default value: 'False' +-- +-- * Since 1.1.23 +webSettingsEnableSpatialNavigation :: WebSettingsClass self => Attr self Bool +webSettingsEnableSpatialNavigation = newAttrFromBoolProperty "enable-spatial-navigation" +#endif diff --git a/Graphics/UI/Gtk/WebKit/WebView.chs b/Graphics/UI/Gtk/WebKit/WebView.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/WebView.chs @@ -0,0 +1,1170 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.WebView +-- Author : Cjacker Huang +-- Copyright : (c) 2009 Cjacker Huang +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Note: +-- +-- Signal `window-object-cleared` can't be bound now, +-- because it needs JavaScriptCore that hasn't binding. +-- +-- Signal `create-plugin-widget` can't be bound now, +-- no idea how to bind `GHaskellTable` +-- +-- +-- * TODO: +-- +-- Binding for webkit_web_view_get_snapshot +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.WebView ( +-- * Description +-- | Cf http://webkitgtk.org/reference/webkitgtk/stable/webkitgtk-webkitwebview.html. + +-- * Types + WebView, + WebViewClass, + +-- * Enums + NavigationResponse(..), + TargetInfo(..), + LoadStatus(..), + ViewMode(..), + +-- * Constructors + webViewNew, + +-- * Methods +-- ** Load +#if WEBKIT_CHECK_VERSION(1,1,1) + webViewLoadUri, +#endif + webViewLoadHtmlString, +#if WEBKIT_CHECK_VERSION(1,1,1) + webViewLoadRequest, +#endif + webViewLoadString, +#if WEBKIT_CHECK_VERSION(1,1,7) + webViewGetLoadStatus, +#endif +-- ** Reload + webViewStopLoading, + webViewReload, + webViewReloadBypassCache, +-- ** History + webViewCanGoBack, + webViewCanGoForward, + webViewGoBack, + webViewGoForward, + webViewGetBackForwardList, + webViewSetMaintainsBackForwardList, + webViewGoToBackForwardItem, + webViewCanGoBackOrForward, + webViewGoBackOrForward, +-- ** Zoom +#if WEBKIT_CHECK_VERSION(1,0,1) + webViewGetZoomLevel, + webViewSetZoomLevel, +#endif + webViewZoomIn, + webViewZoomOut, + webViewGetFullContentZoom, +#if WEBKIT_CHECK_VERSION(1,0,1) + webViewSetFullContentZoom, +#endif +-- ** Clipboard + webViewCanCutClipboard, + webViewCanCopyClipboard, + webViewCanPasteClipboard, + webViewCutClipboard, + webViewCopyClipboard, + webViewPasteClipboard, +-- ** Undo/Redo +#if WEBKIT_CHECK_VERSION (1,1,14) + webViewCanRedo, + webViewCanUndo, + webViewRedo, + webViewUndo, +#endif +-- ** Selection + webViewDeleteSelection, + webViewHasSelection, + webViewSelectAll, +-- ** Encoding + webViewGetEncoding, +#if WEBKIT_CHECK_VERSION(1,1,1) + webViewSetCustomEncoding, +#endif + webViewGetCustomEncoding, +-- ** View Mode +#if WEBKIT_CHECK_VERSION(1,3,4) + webViewGetViewMode, + webViewSetViewMode, +#endif + webViewGetViewSourceMode, +#if WEBKIT_CHECK_VERSION(1,1,14) + webViewSetViewSourceMode, +#endif +-- ** Transparent + webViewGetTransparent, + webViewSetTransparent, +-- ** Target List + webViewGetCopyTargetList, + webViewGetPasteTargetList, +-- ** Text Match + webViewMarkTextMatches, + webViewUnMarkTextMatches, + webViewSetHighlightTextMatches, +-- ** Icon +#if WEBKIT_CHECK_VERSION (1,1,18) + webViewGetIconUri, +#endif +#if WEBKIT_CHECK_VERSION (1,3,13) + webViewTryGetFaviconPixbuf, +#endif +-- ** Other + webViewExecuteScript, + + webViewCanShowMimeType, + webViewGetEditable, + webViewSetEditable, + webViewGetInspector, + + webViewGetProgress, + + webViewSearchText, + + webViewMoveCursor, + + webViewGetMainFrame, + webViewGetFocusedFrame, + + webViewSetWebSettings, + webViewGetWebSettings, + +#if WEBKIT_CHECK_VERSION(1,0,3) + webViewGetWindowFeatures, +#endif + +#if WEBKIT_CHECK_VERSION(1,1,4) + webViewGetTitle, + webViewGetUri, +#endif + +#if WEBKIT_CHECK_VERSION (1,3,1) + webViewGetDomDocument, +#endif + +#if WEBKIT_CHECK_VERSION (1,1,15) + -- webViewGetHitTestResult, +#endif + +#if WEBKIT_CHECK_VERSION(1,3,8) + -- webViewGetViewportAttributes, +#endif + +-- * Attributes + webViewZoomLevel, + webViewFullContentZoom, + webViewEncoding, + webViewCustomEncoding, + webViewLoadStatus, + webViewProgress, + webViewTitle, + webViewInspector, + webViewWebSettings, + webViewViewSourceMode, + webViewTransparent, + webViewEditable, + webViewUri, + webViewCopyTargetList, + webViewPasteTargetList, + webViewWindowFeatures, +#if WEBKIT_CHECK_VERSION (1,1,18) + webViewIconUri, +#endif + +#if WEBKIT_CHECK_VERSION (1,1,20) + webViewImContext, +#endif + +-- * Signals +-- ** Loading + loadStarted, + loadCommitted, + progressChanged, + loadFinished, + loadError, +#if WEBKIT_CHECK_VERSION (1,1,18) + iconLoaded, +#endif + documentLoadFinished, + resourceRequestStarting, + titleChanged, +-- ** Clipboard + copyClipboard, + cutClipboard, + pasteClipboard, +-- ** Script + consoleMessage, + scriptAlert, + scriptConfirm, + scriptPrompt, + statusBarTextChanged, + populatePopup, +-- ** Selection/edition + editingBegan, + editingEnded, + selectAll, + selectionChanged, +-- ** Decision request + mimeTypePolicyDecisionRequested, + navigationPolicyDecisionRequested, + newWindowPolicyDecisionRequested, +#if WEBKIT_CHECK_VERSION (1,1,23) + geolocationPolicyDecisionCancelled, + geolocationPolicyDecisionRequested, +#endif +-- ** Display + -- enteringFullscreen, + moveCursor, + setScrollAdjustments, +-- ** Other + hoveringOverLink, + createWebView, + webViewReady, +#if WEBKIT_CHECK_VERSION(1,1,11) + closeWebView, +#endif + printRequested, + databaseQuotaExceeded, + downloadRequested, + redo, + undo, +) where + +import Control.Monad (liftM, (<=<)) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.Attributes +import System.Glib.Properties +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import Graphics.UI.Gtk.WebKit.Signals#} +{#import Graphics.UI.Gtk.WebKit.Internal#} +{#import System.Glib.GObject#} +{#import Graphics.UI.Gtk.General.Selection#} ( TargetList ) +{#import Graphics.UI.Gtk.MenuComboToolbar.Menu#} +{#import Graphics.UI.Gtk.General.Enums#} + +{#context lib="webkit" prefix="webkit"#} + +------------------ +-- Enums + +{#enum NavigationResponse {underscoreToCase} deriving(Eq, Show) #} +{#enum WebViewTargetInfo as TargetInfo {underscoreToCase} deriving(Eq, Show) #} +{#enum WebViewViewMode as ViewMode {underscoreToCase} deriving(Eq, Show) #} +{#enum LoadStatus {underscoreToCase} deriving(Eq, Show) #} + +------------------ +-- Constructors + + +-- | Create a new 'WebView' widget. +-- +-- It is a 'Widget' you can embed in a 'ScrolledWindow'. +-- +-- You can load any URI into the 'WebView' or any kind of data string. +webViewNew :: IO WebView +webViewNew = do + isGthreadInited <- liftM toBool {#call g_thread_get_initialized#} + if not isGthreadInited then {#call g_thread_init#} nullPtr + else return () + makeNewObject mkWebView $ liftM castPtr {#call web_view_new#} + + +-- | Apply 'WebSettings' to a given 'WebView' +-- +-- !!NOTE!!, currently lack of useful APIs of 'WebSettings' in webkitgtk. +-- If you want to set the encoding, font family or font size of the 'WebView', +-- please use related functions. +webViewSetWebSettings :: (WebViewClass self, WebSettingsClass settings) => self -> settings -> IO () +webViewSetWebSettings webview websettings = + {#call web_view_set_settings#} (toWebView webview) (toWebSettings websettings) + +-- | Return the 'WebSettings' currently used by 'WebView'. +webViewGetWebSettings :: WebViewClass self => self -> IO WebSettings +webViewGetWebSettings = makeNewGObject mkWebSettings . {#call web_view_get_settings#} . toWebView + +#if WEBKIT_CHECK_VERSION(1,0,3) +-- | Returns the instance of WebKitWebWindowFeatures held by the given WebKitWebView. +webViewGetWindowFeatures :: WebViewClass self => self -> IO WebWindowFeatures +webViewGetWindowFeatures = makeNewGObject mkWebWindowFeatures . {#call web_view_get_window_features#} . toWebView +#endif + +#if WEBKIT_CHECK_VERSION (1,1,18) +-- | Obtains the URI for the favicon for the given WebKitWebView, or 'Nothing' if there is none. +-- +-- * Since 1.1.18 +webViewGetIconUri :: WebViewClass self => self -> IO (Maybe String) +webViewGetIconUri webview = + {#call webkit_web_view_get_icon_uri #} (toWebView webview) + >>= maybePeek peekUTFString +#endif + +#if WEBKIT_CHECK_VERSION (1,3,13) +-- | Obtains a GdkPixbuf of the favicon for the given 'WebView'. +-- This will return @Nothing@ if there is no icon for the current 'WebView' or if the icon is in the database but not available at the moment of this call. +-- Use 'webViewGetIconUri' if you need to distinguish these cases. +-- +-- Usually you want to connect to WebKitWebView::icon-loaded and call this method in the callback. +-- +-- See also 'faviconDatabaseTryGetFaviconPixbuf'. Contrary to this function the icon database one returns the URL of the page containing the icon. +webViewTryGetFaviconPixbuf :: + WebView + -> Int -- ^ the desired width for the icon + -> Int -- ^ the desired height for the icon + -> IO (Maybe Pixbuf) -- ^ a new reference to a 'Pixbuf', or @Nothing@. +webViewTryGetFaviconPixbuf webView width length = do + faviconPtr <- {#call webkit_web_view_try_get_favicon_pixbuf#} webView (fromIntegral width) (fromIntegral length) + if faviconPtr == nullPtr then return Nothing else liftM Just . makeNewGObject mkPixbuf $ return faviconPtr +#endif + + +-- | Return the main 'WebFrame' of the given 'WebView'. +webViewGetMainFrame :: WebViewClass self => self -> IO WebFrame +webViewGetMainFrame = makeNewGObject mkWebFrame . {#call web_view_get_main_frame#} . toWebView + + +-- | Return the focused 'WebFrame' (if any) of the given 'WebView'. +webViewGetFocusedFrame :: WebViewClass self => self -> IO (Maybe WebFrame) +webViewGetFocusedFrame webView = do + framePtr <- {#call web_view_get_focused_frame#} $ toWebView webView + if framePtr == nullPtr then return Nothing else liftM Just . makeNewGObject mkWebFrame $ return framePtr + +#if WEBKIT_CHECK_VERSION(1,1,1) +-- | Requests loading of the specified URI string in a 'WebView' +webViewLoadUri :: WebViewClass self => self -> String -> IO () +webViewLoadUri webview url = withCString url $ {#call web_view_load_uri#} (toWebView webview) +#endif + +-- | Determine whether 'WebView' has a previous history item. +webViewCanGoBack :: + WebViewClass self => self + -> IO Bool -- ^ True if able to move back, False otherwise. +webViewCanGoBack webview = + liftM toBool $ {#call web_view_can_go_back#} (toWebView webview) + +-- | Determine whether 'WebView' has a next history item. +webViewCanGoForward :: + WebViewClass self => self + -> IO Bool -- ^ True if able to move forward, False otherwise. +webViewCanGoForward webview = + liftM toBool $ {#call web_view_can_go_forward#} (toWebView webview) + +-- | Loads the previous history item. +webViewGoBack :: WebViewClass self => self -> IO () +webViewGoBack = {#call web_view_go_back#} . toWebView + +-- | Loads the next history item. +webViewGoForward :: WebViewClass self => self -> IO () +webViewGoForward = {#call web_view_go_forward#} . toWebView + +-- | Set the 'WebView' to maintian a back or forward list of history items. +webViewSetMaintainsBackForwardList :: WebViewClass self => self + -> Bool -- ^ @flag@ - to tell the view to maintain a back or forward list. + -> IO() +webViewSetMaintainsBackForwardList webview flag = + {#call web_view_set_maintains_back_forward_list#} (toWebView webview) (fromBool flag) + +-- |Return the 'WebBackForwardList' +webViewGetBackForwardList :: + WebViewClass self => self + -> IO WebBackForwardList +webViewGetBackForwardList webview = + makeNewGObject mkWebBackForwardList $ + {#call web_view_get_back_forward_list#} + (toWebView webview) + +-- | Go to the specified 'WebHistoryItem' +webViewGoToBackForwardItem :: (WebViewClass self, WebHistoryItemClass item) => self + -> item + -> IO Bool -- ^ True if loading of item is successful, False if not. +webViewGoToBackForwardItem webview item = + liftM toBool $ {#call web_view_go_to_back_forward_item#} (toWebView webview) (toWebHistoryItem item) + +-- | Determines whether 'WebView' has a history item of @steps@. +-- +-- Negative values represent steps backward while positive values +-- represent steps forward +webViewCanGoBackOrForward :: WebViewClass self => self + -> Int -- ^ @steps@ - the number of steps + -> IO Bool -- ^ True if able to move back or forward the given number of steps, False otherwise +webViewCanGoBackOrForward webview steps = + liftM toBool $ + {#call web_view_can_go_back_or_forward#} + (toWebView webview) + (fromIntegral steps) + +-- | Loads the history item that is the number of @steps@ away from the current item. +-- Negative values represent steps backward while positive values represent steps forward. +webViewGoBackOrForward :: WebViewClass self => self -> Int -> IO () +webViewGoBackOrForward webview steps = {#call web_view_go_back_or_forward#} (toWebView webview) (fromIntegral steps) + +#if WEBKIT_CHECK_VERSION (1,1,14) +-- | Determines whether or not it is currently possible to redo the last editing command in the view +webViewCanRedo :: WebViewClass self => self -> IO Bool +webViewCanRedo = liftM toBool . {#call web_view_can_redo#} . toWebView + +-- | Determines whether or not it is currently possible to undo the last editing command in the view +webViewCanUndo :: WebViewClass self => self -> IO Bool +webViewCanUndo = liftM toBool . {#call web_view_can_undo#} . toWebView + +-- | Redoes the last editing command in the view, if possible. +webViewRedo :: WebViewClass self => self -> IO () +webViewRedo = {#call web_view_redo#} . toWebView + +-- | Undoes the last editing command in the view, if possible. +webViewUndo :: WebViewClass self => self -> IO () +webViewUndo = {#call web_view_undo#} . toWebView +#endif + +#if WEBKIT_CHECK_VERSION (1,0,3) +-- | Returns whether or not a @mimetype@ can be displayed using this view. +webViewCanShowMimeType :: WebViewClass self => self + -> String -- ^ @mimetype@ - a MIME type + -> IO Bool -- ^ True if the @mimetype@ can be displayed, otherwise False +webViewCanShowMimeType webview mime = withCString mime $ liftM toBool . {#call web_view_can_show_mime_type#} (toWebView webview) +#endif + +-- | Returns whether the user is allowed to edit the document. +webViewGetEditable :: WebViewClass self => self -> IO Bool +webViewGetEditable = liftM toBool . {#call web_view_get_editable#} . toWebView + +-- | Sets whether allows the user to edit its HTML document. +webViewSetEditable :: WebViewClass self => self -> Bool -> IO () +webViewSetEditable webview editable = {#call web_view_set_editable#} (toWebView webview) (fromBool editable) + +#if WEBKIT_CHECK_VERSION(1,3,4) +-- | Gets the value of the "view-mode" property of the 'WebView' +webViewGetViewMode :: WebView -> IO ViewMode +webViewGetViewMode = liftM (toEnum . fromIntegral) . {#call web_view_get_view_source_mode#} + +webViewSetViewMode :: WebView -> ViewMode -> IO () +webViewSetViewMode webView viewMode = {#call web_view_set_view_source_mode#} webView (fromIntegral . fromEnum $ viewMode) +#endif + +-- | Returns whether 'WebView' is in view source mode +webViewGetViewSourceMode :: WebViewClass self => self -> IO Bool +webViewGetViewSourceMode = liftM toBool . {#call web_view_get_view_source_mode#} . toWebView + +#if WEBKIT_CHECK_VERSION(1,1,14) +-- | Set whether the view should be in view source mode. +-- Setting this mode to TRUE before loading a URI will display +-- the source of the web page in a nice and readable format. +webViewSetViewSourceMode :: WebViewClass self => self -> Bool -> IO () +webViewSetViewSourceMode webview mode = + {#call web_view_set_view_source_mode#} (toWebView webview) (fromBool mode) +#endif + +-- | Returns whether the 'WebView' has a transparent background +webViewGetTransparent :: WebViewClass self => self -> IO Bool +webViewGetTransparent = liftM toBool . {#call web_view_get_transparent#} . toWebView + +-- | Sets whether the WebKitWebView has a transparent background. +-- +-- Pass False to have the 'WebView' draw a solid background (the default), +-- otherwise pass True. +webViewSetTransparent :: WebViewClass self => self -> Bool -> IO () +webViewSetTransparent webview trans = + {#call web_view_set_transparent#} (toWebView webview) (fromBool trans) + +-- | Obtains the 'WebInspector' associated with the 'WebView' +webViewGetInspector :: WebViewClass self => self -> IO WebInspector +webViewGetInspector = makeNewGObject mkWebInspector . {#call web_view_get_inspector#} . toWebView + + +#if WEBKIT_CHECK_VERSION(1,1,1) +-- | Requests loading of the specified asynchronous client request. +-- Creates a provisional data source that will transition to a committed data source once any data has been received. +-- Use 'webViewStopLoading' to stop the load. +webViewLoadRequest :: (WebViewClass self, NetworkRequestClass request) => self -> request -> IO() +webViewLoadRequest webview request = {#call web_view_load_request#} (toWebView webview) (toNetworkRequest request) +#endif + + +#if WEBKIT_CHECK_VERSION(1,0,1) +-- | Returns the zoom level of 'WebView' +-- i.e. the factor by which elements in the page are scaled with respect to their original size. +webViewGetZoomLevel :: WebViewClass self => self -> IO Float +webViewGetZoomLevel = liftM realToFrac . {#call web_view_get_zoom_level#} . toWebView + +-- | Sets the zoom level of 'WebView'. +webViewSetZoomLevel :: WebViewClass self => self + -> Float -- ^ @zoom_level@ - the new zoom level + -> IO () +webViewSetZoomLevel webview zlevel = + {#call web_view_set_zoom_level#} (toWebView webview) (realToFrac zlevel) +#endif + + +-- | Loading the @content@ string as html. The URI passed in base_uri has to be an absolute URI. +-- Deprecated since webkit v1.1.1, use 'webViewLoadString' instead. +webViewLoadHtmlString :: WebViewClass self => self + -> String -- ^ @content@ - the html string + -> String -- ^ @base_uri@ - the base URI + -> IO() +webViewLoadHtmlString webview htmlstr url = withCString htmlstr $ \htmlPtr -> withCString url $ \urlPtr -> + {#call web_view_load_html_string#} (toWebView webview) htmlPtr urlPtr + +-- | Requests loading of the given @content@ with the specified @mime_type@, @encoding@ and @base_uri@. +-- If @mime_type@ is @Nothing@, "text/html" is assumed. +-- If @encoding@ is @Nothing@, "UTF-8" is assumed. +webViewLoadString :: WebViewClass self => self + -> String -- ^ @content@ - the content string to be loaded. + -> (Maybe String) -- ^ @mime_type@ - the MIME type or @Nothing@. + -> (Maybe String) -- ^ @encoding@ - the encoding or @Nothing@. + -> String -- ^ @base_uri@ - the base URI for relative locations. + -> IO () +webViewLoadString webview content mimetype encoding baseuri = + withCString content $ \contentPtr -> + maybeWith withCString mimetype $ \mimetypePtr -> + maybeWith withCString encoding $ \encodingPtr -> + withCString baseuri $ \baseuriPtr -> + {#call web_view_load_string#} + (toWebView webview) + contentPtr + mimetypePtr + encodingPtr + baseuriPtr + +#if WEBKIT_CHECK_VERSION(1,1,4) +-- | Returns the title of 'WebView' document, or Nothing in case of failure +webViewGetTitle :: WebViewClass self => self -> IO (Maybe String) +webViewGetTitle = maybePeek peekUTFString <=< {#call web_view_get_title#} . toWebView + +-- | Returns the current URI of the contents displayed by the 'WebView', or Nothing in case of failure +webViewGetUri :: WebViewClass self => self -> IO (Maybe String) +webViewGetUri = maybePeek peekUTFString <=< {#call web_view_get_uri#} . toWebView +#endif + + +-- | Stops and pending loads on the given data source. +webViewStopLoading :: WebViewClass self => self -> IO () +webViewStopLoading = {#call web_view_stop_loading#} . toWebView + +-- | Reloads the 'WebView' +webViewReload :: WebViewClass self => self -> IO () +webViewReload = {#call web_view_reload#} . toWebView + +-- | Reloads the 'WebView' without using any cached data. +webViewReloadBypassCache :: WebViewClass self => self -> IO () +webViewReloadBypassCache = {#call web_view_reload_bypass_cache#} . toWebView + +-- | Increases the zoom level of 'WebView'. +webViewZoomIn :: WebViewClass self => self -> IO() +webViewZoomIn = {#call web_view_zoom_in#} . toWebView + +-- | Decreases the zoom level of 'WebView'. +webViewZoomOut :: WebViewClass self => self -> IO () +webViewZoomOut = {#call web_view_zoom_out#} . toWebView + +-- | Looks for a specified string inside 'WebView' +webViewSearchText :: WebViewClass self => self + -> String -- ^ @text@ - a string to look for + -> Bool -- ^ @case_sensitive@ - whether to respect the case of text + -> Bool -- ^ @forward@ - whether to find forward or not + -> Bool -- ^ @wrap@ - whether to continue looking at beginning after reaching the end + -> IO Bool -- ^ True on success or False on failure +webViewSearchText webview text case_sensitive forward wrap = + withCString text $ \textPtr -> + liftM toBool $ + {#call web_view_search_text#} + (toWebView webview) + textPtr + (fromBool case_sensitive) + (fromBool forward) + (fromBool wrap) + +-- | Attempts to highlight all occurances of string inside 'WebView' +webViewMarkTextMatches :: WebViewClass self => self + -> String -- ^ @string@ - a string to look for + -> Bool -- ^ @case_sensitive@ - whether to respect the case of text + -> Int -- ^ @limit@ - the maximum number of strings to look for or 0 for all + -> IO Int -- ^ the number of strings highlighted +webViewMarkTextMatches webview text case_sensitive limit = withCString text $ \textPtr -> liftM fromIntegral $ + {#call web_view_mark_text_matches#} (toWebView webview) textPtr (fromBool case_sensitive) (fromIntegral limit) + +-- | Move the cursor in view as described by step and count. +webViewMoveCursor :: WebViewClass self => self -> MovementStep -> Int -> IO () +webViewMoveCursor webview step count = + {#call web_view_move_cursor#} (toWebView webview) (fromIntegral $ fromEnum step) (fromIntegral count) + +-- | Removes highlighting previously set by 'webViewMarkTextMarches' +webViewUnMarkTextMatches :: WebViewClass self => self -> IO () +webViewUnMarkTextMatches = {#call web_view_unmark_text_matches#} . toWebView + +-- | Highlights text matches previously marked by 'webViewMarkTextMatches' +webViewSetHighlightTextMatches :: WebViewClass self => self + -> Bool -- ^ @highlight@ - whether to highlight text matches + -> IO () +webViewSetHighlightTextMatches webview highlight = + {#call web_view_set_highlight_text_matches#} (toWebView webview) (fromBool highlight) + +-- | Execute the script specified by @script@ +webViewExecuteScript :: WebViewClass self => self + -> String -- ^ @script@ - script to be executed + -> IO() +webViewExecuteScript webview script = withCString script $ {#call web_view_execute_script#} (toWebView webview) + +-- | Determines whether can cuts the current selection inside 'WebView' to the clipboard +webViewCanCutClipboard :: WebViewClass self => self -> IO Bool +webViewCanCutClipboard = liftM toBool . {#call web_view_can_cut_clipboard#} . toWebView + +-- | Determines whether can copies the current selection +-- inside 'WebView' to the clipboard +webViewCanCopyClipboard :: WebViewClass self => self -> IO Bool +webViewCanCopyClipboard webview = + liftM toBool $ {#call web_view_can_copy_clipboard#} (toWebView webview) + +-- | Determines whether can pastes the current contents of the clipboard +-- to the 'WebView' +webViewCanPasteClipboard :: WebViewClass self => self -> IO Bool +webViewCanPasteClipboard webview = + liftM toBool $ {#call web_view_can_paste_clipboard#} (toWebView webview) + +-- | Cuts the current selection inside 'WebView' to the clipboard. +webViewCutClipboard :: WebViewClass self => self -> IO() +webViewCutClipboard webview = + {#call web_view_cut_clipboard#} (toWebView webview) + +-- | Copies the current selection inside 'WebView' to the clipboard. +webViewCopyClipboard :: WebViewClass self => self -> IO() +webViewCopyClipboard webview = + {#call web_view_copy_clipboard#} (toWebView webview) + +-- | Pastes the current contents of the clipboard to the 'WebView' +webViewPasteClipboard :: WebViewClass self => self -> IO () +webViewPasteClipboard = {#call web_view_paste_clipboard#} . toWebView + +-- | Deletes the current selection inside the 'WebView' +webViewDeleteSelection :: WebViewClass self => self -> IO () +webViewDeleteSelection = {#call web_view_delete_selection#} . toWebView + +-- | Determines whether text was selected +webViewHasSelection :: WebViewClass self => self -> IO Bool +webViewHasSelection = liftM toBool . {#call web_view_has_selection#} . toWebView + +-- | Attempts to select everything inside the 'WebView' +webViewSelectAll :: WebViewClass self => self -> IO () +webViewSelectAll = {#call web_view_select_all#} . toWebView + +-- | Returns whether the zoom level affects only text or all elements. +webViewGetFullContentZoom :: WebViewClass self => self + -> IO Bool -- ^ False if only text should be scaled(the default) + -- True if the full content of the view should be scaled. +webViewGetFullContentZoom = liftM toBool . {#call web_view_get_full_content_zoom#} . toWebView + +#if WEBKIT_CHECK_VERSION(1,0,1) +-- | Sets whether the zoom level affects only text or all elements. +webViewSetFullContentZoom :: WebViewClass self => self + -> Bool -- ^ @full_content_zoom@ - False if only text should be scaled (the default) + -- True if the full content of the view should be scaled. + -> IO () +webViewSetFullContentZoom webview full = + {#call web_view_set_full_content_zoom#} (toWebView webview) (fromBool full) +#endif + +-- | Returns the default encoding of the 'WebView' +webViewGetEncoding :: WebViewClass self => self + -> IO (Maybe String) -- ^ the default encoding or @Nothing@ in case of failed +webViewGetEncoding webview = {#call web_view_get_encoding#} (toWebView webview) >>= maybePeek peekUTFString + +#if WEBKIT_CHECK_VERSION(1,1,1) +-- | Sets the current 'WebView' encoding, +-- without modifying the default one, and reloads the page +webViewSetCustomEncoding :: WebViewClass self => self + -> (Maybe String) -- ^ @encoding@ - the new encoding, or @Nothing@ to restore the default encoding. + -> IO () +webViewSetCustomEncoding webview encoding = + maybeWith withCString encoding $ \encodingPtr -> + {#call web_view_set_custom_encoding#} (toWebView webview) encodingPtr +#endif + +-- | Returns the current encoding of 'WebView',not the default encoding. +webViewGetCustomEncoding :: WebViewClass self => self + -> IO (Maybe String) -- ^ the current encoding string or @Nothing@ if there is none set. +webViewGetCustomEncoding = maybePeek peekUTFString <=< {#call web_view_get_custom_encoding#} . toWebView + +#if WEBKIT_CHECK_VERSION(1,1,7) +-- | Determines the current status of the load. +webViewGetLoadStatus :: WebViewClass self => self -> IO LoadStatus +webViewGetLoadStatus = liftM (toEnum . fromIntegral) . {#call web_view_get_load_status#} . toWebView +#endif + +-- | Determines the current progress of the load +webViewGetProgress :: WebViewClass self => self + -> IO Double -- ^ the load progress +webViewGetProgress = liftM realToFrac . {#call web_view_get_progress#} . toWebView + +-- | This function returns the list of targets this 'WebView' can provide for clipboard copying and as DND source. +-- The targets in the list are added with values from the 'WebViewTargetInfo' enum, +-- using 'targetListAdd' and 'targetListAddTextTargets'. +webViewGetCopyTargetList :: WebViewClass self => self -> IO (Maybe TargetList) +webViewGetCopyTargetList webview = do + tlPtr <- {#call web_view_get_copy_target_list#} (toWebView webview) + if tlPtr == nullPtr then return Nothing else liftM Just (mkTargetList tlPtr) + +-- | This function returns the list of targets this 'WebView' can provide for clipboard pasteing and as DND source. +-- The targets in the list are added with values from the 'WebViewTargetInfo' enum, +-- using 'targetListAdd' and 'targetListAddTextTargets'. +webViewGetPasteTargetList :: WebViewClass self => self -> IO (Maybe TargetList) +webViewGetPasteTargetList = maybePeek mkTargetList <=< {#call web_view_get_paste_target_list#} . toWebView + +-- * Attibutes + +-- | Zoom level of the 'WebView' instance +webViewZoomLevel :: WebViewClass self => Attr self Float +webViewZoomLevel = newAttr + webViewGetZoomLevel + webViewSetZoomLevel + +-- | Whether the full content is scaled when zooming +-- +-- Default value: False +webViewFullContentZoom :: WebViewClass self => Attr self Bool +webViewFullContentZoom = newAttr + webViewGetFullContentZoom + webViewSetFullContentZoom + +-- | The default encoding of the 'WebView' instance +-- +-- Default value: @Nothing@ +webViewEncoding :: WebViewClass self => ReadAttr self (Maybe String) +webViewEncoding = readAttr webViewGetEncoding + +-- | Determines the current status of the load. +-- +-- Default value: @LoadFinished@ +webViewLoadStatus :: WebViewClass self => ReadAttr self LoadStatus +webViewLoadStatus = readAttr webViewGetLoadStatus + +-- |Determines the current progress of the load +-- +-- Default Value: 1 +webViewProgress :: WebViewClass self => ReadAttr self Double +webViewProgress = readAttr webViewGetProgress + + +-- | The associated webSettings of the 'WebView' instance +webViewWebSettings :: WebViewClass self => Attr self WebSettings +webViewWebSettings = newAttr + webViewGetWebSettings + webViewSetWebSettings + + +-- | Title of the 'WebView' instance +webViewTitle :: WebViewClass self => ReadAttr self (Maybe String) +webViewTitle = readAttr webViewGetTitle + +-- | The associated webInspector instance of the 'WebView' +webViewInspector :: WebViewClass self => ReadAttr self WebInspector +webViewInspector = readAttr webViewGetInspector + + +-- | The custom encoding of the 'WebView' instance +-- +-- Default value: @Nothing@ +webViewCustomEncoding :: WebViewClass self => Attr self (Maybe String) +webViewCustomEncoding = newAttr + webViewGetCustomEncoding + webViewSetCustomEncoding + +-- | view source mode of the 'WebView' instance +webViewViewSourceMode :: WebViewClass self => Attr self Bool +webViewViewSourceMode = newAttr + webViewGetViewSourceMode + webViewSetViewSourceMode + +-- | transparent background of the 'WebView' instance +webViewTransparent :: WebViewClass self => Attr self Bool +webViewTransparent = newAttr + webViewGetTransparent + webViewSetTransparent + +-- | Whether content of the 'WebView' can be modified by the user +-- +-- Default value: @False@ +webViewEditable :: WebViewClass self => Attr self Bool +webViewEditable = newAttr + webViewGetEditable + webViewSetEditable + +-- | Returns the current URI of the contents displayed by the @web_view@. +-- +-- Default value: Nothing +webViewUri :: WebViewClass self => ReadAttr self (Maybe String) +webViewUri = readAttr webViewGetUri + +-- | The list of targets this web view supports for clipboard copying. +webViewCopyTargetList :: WebViewClass self => ReadAttr self (Maybe TargetList) +webViewCopyTargetList = readAttr webViewGetCopyTargetList + +-- | The list of targets this web view supports for clipboard pasteing. +webViewPasteTargetList :: WebViewClass self => ReadAttr self (Maybe TargetList) +webViewPasteTargetList = readAttr webViewGetPasteTargetList + +-- | An associated 'WebWindowFeatures' instance. +webViewWindowFeatures :: WebViewClass self => Attr self WebWindowFeatures +webViewWindowFeatures = + newAttrFromObjectProperty "window-features" + {#call pure webkit_web_window_features_get_type#} + +#if WEBKIT_CHECK_VERSION (1,1,18) +-- | The URI for the favicon for the WebKitWebView. +-- +-- Default value: 'Nothing' +-- +-- * Since 1.1.18 +webViewIconUri :: WebViewClass self => ReadAttr self String +webViewIconUri = readAttrFromStringProperty "icon-uri" +#endif + +#if WEBKIT_CHECK_VERSION (1,1,20) +-- | The 'IMMulticontext' for the WebKitWebView. +-- +-- This is the input method context used for all text entry widgets inside the WebKitWebView. It can be +-- used to generate context menu items for controlling the active input method. +-- +-- * Since 1.1.20 +webViewImContext :: WebViewClass self => ReadAttr self IMContext +webViewImContext = + readAttrFromObjectProperty "im-context" + {#call pure gtk_im_context_get_type #} +#endif + + +#if WEBKIT_CHECK_VERSION (1,3,1) +webViewGetDomDocument :: WebView -> IO (Maybe Document) +webViewGetDomDocument webView = do + docPtr <- {#call webkit_web_view_get_dom_document#} webView + if docPtr == nullPtr then return Nothing else liftM Just . makeNewGObject mkDocument $ return docPtr +#endif + + +-- #if WEBKIT_CHECK_VERSION (1,1,15) +-- -- | Does a "hit test" in the coordinates specified by @event@ to figure out context information about that position in the @web_view@. +-- webViewGetHitTestResult :: +-- WebView -- ^ @web_view +-- -> EventButton -- ^ @event@ +-- -> IO HitTestResult +-- webViewGetHitTestResult webView eventButton = makeNewGObject mkHitTestResult $ {#call webkit_web_view_get_hit_test_result#} webView eventButton +-- #endif + + +-- #if WEBKIT_CHECK_VERSION(1,3,8) +-- -- | Obtains the 'ViewportAttributes' associated with the 'WebView'. +-- -- Do note however that the viewport attributes object only contains valid information when the current page has a viewport meta tag. +-- -- You can check whether the data should be used by checking the "valid" property. +-- webViewGetViewportAttributes :: WebView -> IO ViewportAttributes +-- webViewGetViewportAttributes = makeNewGObject mkViewportAttributes . {#call webkit_web_view_get_viewport_attributes#} +-- #endif + + + +-- * Signals + +-- | When Document title changed, this signal is emitted. +-- +-- It can be used to set the Application 'Window' title. +-- +-- webframe - which 'WebFrame' changes the document title. +-- +-- title - current title string. +titleChanged :: WebViewClass self => Signal self ( WebFrame -> String -> IO() ) +titleChanged = Signal (connect_OBJECT_STRING__NONE "title_changed") + + +-- | When the cursor is over a link, this signal is emitted. +-- +-- title - the link's title or @Nothing@ in case of failure. +-- +-- uri - the URI the link points to or @Nothing@ in case of failure. +hoveringOverLink :: WebViewClass self => Signal self (Maybe String -> Maybe String -> IO()) +hoveringOverLink = Signal (connect_MSTRING_MSTRING__NONE "hovering_over_link") + +-- | When a 'WebFrame' begins to load, this signal is emitted +loadStarted :: WebViewClass self => Signal self (WebFrame -> IO()) +loadStarted = Signal (connect_OBJECT__NONE "load_started") + +-- | When a 'WebFrame' loaded the first data, this signal is emitted +loadCommitted :: WebViewClass self => Signal self (WebFrame -> IO()) +loadCommitted = Signal (connect_OBJECT__NONE "load_committed") + + +-- | When the global progress changed, this signal is emitted +-- +-- the global progress will be passed back to user function +progressChanged :: WebViewClass self => Signal self (Int-> IO()) +progressChanged = Signal (connect_INT__NONE "load_progress_changed") + +-- | When loading finished, this signal is emitted +loadFinished :: WebViewClass self => Signal self (WebFrame -> IO()) +loadFinished = Signal (connect_OBJECT__NONE "load_finished") + +-- | When An error occurred while loading. +-- +-- By default, if the signal is not handled, +-- the WebView will display a stock error page. +-- +-- You need to handle the signal +-- if you want to provide your own error page. +-- +-- The URI that triggered the error and the 'GError' will be passed back to user function. +loadError :: WebViewClass self => Signal self (WebFrame -> String -> GError -> IO Bool) +loadError = Signal (connect_OBJECT_STRING_BOXED__BOOL "load_error" peek) + +createWebView :: WebViewClass self => Signal self (WebFrame -> IO WebView) +createWebView = Signal (connect_OBJECT__OBJECTPTR "create_web_view") + +#if WEBKIT_CHECK_VERSION(1,1,11) +-- | Emitted when closing a WebView is requested. +-- +-- This occurs when a call is made from JavaScript's window.close function. +-- The default signal handler does not do anything. +-- It is the owner's responsibility to hide or delete the 'WebView', if necessary. +-- +-- User function should return True to stop the handlers from being invoked for the event +-- or False to propagate the event furter +closeWebView :: WebViewClass self => Signal self (IO Bool) +closeWebView = Signal (connect_NONE__BOOL "close_web_view") +#endif + +-- | A JavaScript console message was created. +consoleMessage :: WebViewClass self => Signal self (String -> String -> Int -> String -> IO Bool) +consoleMessage = Signal (connect_STRING_STRING_INT_STRING__BOOL "console_message") + +-- | The 'copyClipboard' signal is a keybinding signal which gets emitted to copy the selection to the clipboard. +-- +-- The default bindings for this signal are Ctrl-c and Ctrl-Insert. +copyClipboard :: WebViewClass self => Signal self (IO ()) +copyClipboard = Signal (connect_NONE__NONE "copy_clipboard") + +-- | The 'cutClipboard' signal is a keybinding signal which gets emitted to cut the selection to the clipboard. +-- +-- The default bindings for this signal are Ctrl-x and Shift-Delete. +cutClipboard :: WebViewClass self => Signal self (IO ()) +cutClipboard = Signal (connect_NONE__NONE "cut_clipboard") + +-- | The 'pasteClipboard' signal is a keybinding signal which gets emitted to paste the contents of the clipboard into the Web view. +-- +-- The default bindings for this signal are Ctrl-v and Shift-Insert. +pasteClipboard :: WebViewClass self => Signal self (IO ()) +pasteClipboard = Signal (connect_NONE__NONE "paste_clipboard") + +-- | When a context menu is about to be displayed this signal is emitted. +populatePopup :: WebViewClass self => Signal self (Menu -> IO ()) +populatePopup = Signal (connect_OBJECT__NONE "populate_popup") + +-- | Emitted when printing is requested by the frame, usually because of a javascript call. +-- When handling this signal you should call 'webFramePrintFull' or 'webFramePrint' to do the actual printing. +-- +-- The default handler will present a print dialog and carry a print operation. +-- Notice that this means that if you intend to ignore a print +-- request you must connect to this signal, and return True. +printRequested :: WebViewClass self => Signal self (WebFrame -> IO Bool) +printRequested = Signal (connect_OBJECT__BOOL "print_requested") + +-- | A JavaScript alert dialog was created. +scriptAlert :: WebViewClass self => Signal self (WebFrame -> String -> IO Bool) +scriptAlert = Signal (connect_OBJECT_STRING__BOOL "script_alert") + +-- | A JavaScript confirm dialog was created, providing Yes and No buttons. +scriptConfirm :: WebViewClass self => Signal self (WebFrame -> String -> IO Bool) +scriptConfirm = Signal (connect_OBJECT_STRING__BOOL "script_confirm") + +-- | A JavaScript prompt dialog was created, providing an entry to input text. +scriptPrompt :: WebViewClass self => Signal self (WebFrame -> String -> String -> IO Bool) +scriptPrompt = Signal (connect_OBJECT_STRING_STRING__BOOL "script_prompt") + +-- | When status-bar text changed, this signal will emitted. +statusBarTextChanged :: WebViewClass self => Signal self (String -> IO ()) +statusBarTextChanged = Signal (connect_STRING__NONE "status_bar_text_changed") + + +editingBegan :: WebViewClass self => Signal self (IO ()) +editingBegan = Signal (connect_NONE__NONE "editing_began") + + +editingEnded :: WebViewClass self => Signal self (IO ()) +editingEnded = Signal (connect_NONE__NONE "editing_ended") + + +-- | The 'selectAll' signal is a keybinding signal which gets emitted to select the complete contents of the text view. +-- +-- The default bindings for this signal is Ctrl-a. +selectAll :: WebViewClass self => Signal self (IO ()) +selectAll = Signal (connect_NONE__NONE "select_all") + +-- | When selection changed, this signal is emitted. +selectionChanged :: WebViewClass self => Signal self (IO ()) +selectionChanged = Signal (connect_NONE__NONE "selection_changed") + +-- | When set scroll adjustments, this signal is emitted. +setScrollAdjustments :: WebViewClass self => Signal self (Adjustment -> Adjustment -> IO ()) +setScrollAdjustments = Signal (connect_OBJECT_OBJECT__NONE "set_scroll_adjustments") + +-- | The 'databaseQuotaExceeded' signal will be emitted when a Web Database exceeds the quota of its security origin. +-- This signal may be used to increase the size of the quota before the originating operation fails. +databaseQuotaExceeded :: WebViewClass self => Signal self (WebFrame -> WebDatabase -> IO ()) +databaseQuotaExceeded = Signal (connect_OBJECT_OBJECT__NONE "database_quota_exceeded") + +-- | When document loading finished, this signal is emitted +documentLoadFinished :: WebViewClass self => Signal self (WebFrame -> IO ()) +documentLoadFinished = Signal (connect_OBJECT__NONE "document_load_finished") + + +-- | Emitted after new 'WebView' instance had been created in 'onCreateWebView' user function +-- when the new 'WebView' should be displayed to the user. +-- +-- All the information about how the window should look, +-- including size,position,whether the location, status and scroll bars should be displayed, +-- is ready set. +webViewReady:: WebViewClass self => Signal self (IO Bool) +webViewReady = + Signal (connect_NONE__BOOL "web_view_ready") + +-- | Emitted after A new 'Download' is being requested. +-- +-- By default, if the signal is not handled, the download is cancelled. +-- +-- Notice that while handling this signal you must set the target URI using 'downloadSetDestinationUri' +-- +-- If you intend to handle downloads yourself, return False in user function. +downloadRequested :: WebViewClass self => Signal self (Download -> IO Bool) +downloadRequested = + Signal (connect_OBJECT__BOOL "download_requested") + +#if WEBKIT_CHECK_VERSION (1,1,18) +-- | Emitted after Icon loaded +iconLoaded :: WebViewClass self => Signal self (String -> IO ()) +iconLoaded = + Signal (connect_STRING__NONE "icon_loaded") +#endif + +-- | The "redo" signal is a keybinding signal which gets emitted to redo the last editing command. +-- +-- The default binding for this signal is Ctrl-Shift-z +redo :: WebViewClass self => Signal self (IO ()) +redo = Signal (connect_NONE__NONE "redo") + +-- | The "undo" signal is a keybinding signal which gets emitted to undo the last editing command. +-- +-- The default binding for this signal is Ctrl-z +undo :: WebViewClass self => Signal self (IO ()) +undo = Signal (connect_NONE__NONE "undo") + +-- | Decide whether or not to display the given MIME type. +-- If this signal is not handled, the default behavior is to show the content of the +-- requested URI if WebKit can show this MIME type and the content disposition is not a download; +-- if WebKit is not able to show the MIME type nothing happens. +-- +-- Notice that if you return True, meaning that you handled the signal, +-- you are expected to be aware of the "Content-Disposition" header. +-- A value of "attachment" usually indicates a download regardless of the MIME type, +-- see also soupMessageHeadersGetContentDisposition' +-- And you must call 'webPolicyDecisionIgnore', 'webPolicyDecisionDownload', or 'webPolicyDecisionUse' +-- on the 'webPolicyDecision' object. +mimeTypePolicyDecisionRequested :: WebViewClass self => Signal self (WebFrame -> NetworkRequest -> String -> WebPolicyDecision -> IO Bool) +mimeTypePolicyDecisionRequested = Signal (connect_OBJECT_OBJECT_STRING_OBJECT__BOOL "mime_type_policy_decision_requested") + +-- | The 'moveCursor' will be emitted to apply the cursor movement described by its parameters to the view. +moveCursor :: WebViewClass self => Signal self (MovementStep -> Int -> IO Bool) +moveCursor = Signal (connect_ENUM_INT__BOOL "move_cursor") + +-- | Emitted when frame requests a navigation to another page. +-- If this signal is not handled, the default behavior is to allow the navigation. +-- +-- Notice that if you return True, meaning that you handled the signal, +-- you are expected to be aware of the "Content-Disposition" header. +-- A value of "attachment" usually indicates a download regardless of the MIME type, +-- see also soupMessageHeadersGetContentDisposition' +-- And you must call 'webPolicyDecisionIgnore', 'webPolicyDecisionDownload', or 'webPolicyDecisionUse' +-- on the 'webPolicyDecision' object. +navigationPolicyDecisionRequested :: WebViewClass self => Signal self (WebFrame -> NetworkRequest -> WebNavigationAction -> WebPolicyDecision -> IO Bool) +navigationPolicyDecisionRequested = Signal (connect_OBJECT_OBJECT_OBJECT_OBJECT__BOOL "navigation_policy_decision_requested") + +-- | Emitted when frame requests opening a new window. +-- With this signal the browser can use the context of the request to decide about the new window. +-- If the request is not handled the default behavior is to allow opening the new window to load the URI, +-- which will cause a 'createWebView' signal emission where the browser handles the new window action +-- but without information of the context that caused the navigation. +-- The following 'navigationPolicyDecisionRequested' emissions will load the page +-- after the creation of the new window just with the information of this new navigation context, +-- without any information about the action that made this new window to be opened. +-- +-- Notice that if you return True, meaning that you handled the signal, +-- you are expected to be aware of the "Content-Disposition" header. +-- A value of "attachment" usually indicates a download regardless of the MIME type, +-- see also soupMessageHeadersGetContentDisposition' +-- And you must call 'webPolicyDecisionIgnore', 'webPolicyDecisionDownload', or 'webPolicyDecisionUse' +-- on the 'webPolicyDecision' object. +newWindowPolicyDecisionRequested :: WebViewClass self => Signal self (WebFrame -> NetworkRequest -> WebNavigationAction -> WebPolicyDecision -> IO Bool) +newWindowPolicyDecisionRequested = Signal (connect_OBJECT_OBJECT_OBJECT_OBJECT__BOOL "new_window_policy_decision_requested") + +-- | Emitted when a request is about to be sent. +-- You can modify the request while handling this signal. +-- You can set the URI in the 'NetworkRequest' object itself, +-- and add/remove/replace headers using the SoupMessage object it carries, +-- if it is present. See 'networkRequestGetMessage'. +-- Setting the request URI to "about:blank" will effectively cause the request to load nothing, +-- and can be used to disable the loading of specific resources. +-- +-- Notice that information about an eventual redirect is available in response's SoupMessage, +-- not in the SoupMessage carried by the request. +-- If response is NULL, then this is not a redirected request. +-- +-- The 'WebResource' object will be the same throughout all the lifetime of the resource, +-- but the contents may change from inbetween signal emissions. +resourceRequestStarting :: WebViewClass self => Signal self (WebFrame -> WebResource -> Maybe NetworkRequest -> Maybe NetworkResponse -> IO ()) +resourceRequestStarting = Signal (connect_OBJECT_OBJECT_MOBJECT_MOBJECT__NONE "resource_request_starting") + +#if WEBKIT_CHECK_VERSION (1,1,23) +-- | When a frame wants to cancel geolocation permission it had requested before. +-- +-- * Since 1.1.23 +geolocationPolicyDecisionCancelled :: WebViewClass self => Signal self (WebFrame -> IO ()) +geolocationPolicyDecisionCancelled = Signal (connect_OBJECT__NONE "geolocation_policy_decision_cancelled") + +-- | When a frame wants to get its geolocation permission. The receiver must reply with a boolean wether +-- it handled or not the request. If the request is not handled, default behaviour is to deny +-- geolocation. +-- +-- * Since 1.1.23 +geolocationPolicyDecisionRequested :: WebViewClass self => Signal self (WebFrame -> GeolocationPolicyDecision -> IO ()) +geolocationPolicyDecisionRequested = Signal (connect_OBJECT_OBJECT__NONE "geolocation_policy_decision_requested") +#endif diff --git a/Graphics/UI/Gtk/WebKit/WebWindowFeatures.chs b/Graphics/UI/Gtk/WebKit/WebWindowFeatures.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/WebWindowFeatures.chs @@ -0,0 +1,134 @@ +{-# LANGUAGE CPP #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.WebWindowFeatures +-- Author : Andy Stewart +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Access to the WebKit Web WindowFeatures +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.WebWindowFeatures ( +-- * Description +-- | The content of a WebKitWebView can request to change certain properties of a WebKitWebView. 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, the request to show the WebKitWebView +-- fullscreen. +-- +-- In the normal case one will use 'webViewGetWindowFeatures' to get the +-- WebKitWebWindowFeatures and then monitor the property changes. Be aware that the +-- WebKitWebWindowFeatures might change change before 'webViewReady' signal is emitted. To be safe +-- listen to the 'windowFeatures' signal of the WebKitWebView and reconnect the signals whenever +-- the WebKitWebWindowFeatures of a WebKitWebView changes. + +-- * Types + WebWindowFeatures, + WebWindowFeaturesClass, + +-- * Constructors + webWindowFeaturesNew, + +-- * Methods + webWindowFeaturesEqual, + +-- * Attributes + webWindowFeaturesFullscreen, + webWindowFeaturesHeight, + webWindowFeaturesWidth, + webWindowFeaturesX, + webWindowFeaturesY, + webWindowFeaturesLocationbarVisible, + webWindowFeaturesMenubarVisible, + webWindowFeaturesScrollbarVisible, + webWindowFeaturesStatusbarVisible, + webWindowFeaturesToolbarVisible, +) where + +import Control.Monad (liftM) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.GError +import System.Glib.Attributes +import System.Glib.Properties +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import System.Glib.GObject#} + +{#context lib="webkit" prefix ="webkit"#} + +-- * Constructors + +-- | Creates a new 'WebWindowFeatures' instance with default values. +-- It must be manually attached to a WebView. +webWindowFeaturesNew :: IO WebWindowFeatures +webWindowFeaturesNew = + wrapNewGObject mkWebWindowFeatures $ {#call web_window_features_new#} + +-- | Decides if a 'WebWindowFeatures' instance equals another, as in has the same values. +webWindowFeaturesEqual :: + (WebWindowFeaturesClass winA, WebWindowFeaturesClass winB) => winA -> winB + -> IO Bool +webWindowFeaturesEqual winA winB = + liftM toBool $ {#call web_window_features_equal#} (toWebWindowFeatures winA) (toWebWindowFeatures winB) + +-- * Attributes + +-- | Controls whether window will be displayed fullscreen. +webWindowFeaturesFullscreen :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesFullscreen = newAttrFromBoolProperty "fullscreen" + +-- | The height of the window on the screen. +webWindowFeaturesHeight :: WebWindowFeaturesClass self => Attr self Int +webWindowFeaturesHeight = newAttrFromIntProperty "height" + +-- | The width of the window on the screen. +webWindowFeaturesWidth :: WebWindowFeaturesClass self => Attr self Int +webWindowFeaturesWidth = newAttrFromIntProperty "width" + +-- | Controls whether the locationbar should be visible for the window. +webWindowFeaturesLocationbarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesLocationbarVisible = newAttrFromBoolProperty "locationbar-visible" + +-- | Controls whether the menubar should be visible for the window. +webWindowFeaturesMenubarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesMenubarVisible = newAttrFromBoolProperty "menubar-visible" + +-- | Controls whether the scrollbar should be visible for the window. +webWindowFeaturesScrollbarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesScrollbarVisible = newAttrFromBoolProperty "scrollbar-visible" + +-- | Controls whether the statusbar should be visible for the window. +webWindowFeaturesStatusbarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesStatusbarVisible = newAttrFromBoolProperty "statusbar-visible" + +-- | Controls whether the toolbar should be visible for the window. +webWindowFeaturesToolbarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesToolbarVisible = newAttrFromBoolProperty "toolbar-visible" + +-- | The starting x position of the window on the screen. +webWindowFeaturesX :: WebWindowFeaturesClass self => Attr self Int +webWindowFeaturesX = newAttrFromIntProperty "x" + +-- | The starting y position of the window on the screen. +webWindowFeaturesY :: WebWindowFeaturesClass self => Attr self Int +webWindowFeaturesY = newAttrFromIntProperty "y" + diff --git a/Gtk2HsSetup.hs b/Gtk2HsSetup.hs new file mode 100644 --- /dev/null +++ b/Gtk2HsSetup.hs @@ -0,0 +1,474 @@ +{-# LANGUAGE CPP, ViewPatterns #-} + +#ifndef CABAL_VERSION_CHECK +#error This module has to be compiled via the Setup.hs program which generates the gtk2hs-macros.h file +#endif + +-- | Build a Gtk2hs package. +-- +module Gtk2HsSetup ( + gtk2hsUserHooks, + getPkgConfigPackages, + checkGtk2hsBuildtools, + typeGenProgram, + signalGenProgram, + c2hsLocal + ) where + +import Distribution.Simple +import Distribution.Simple.PreProcess +import Distribution.InstalledPackageInfo ( importDirs, + showInstalledPackageInfo, + libraryDirs, + extraLibraries, + extraGHCiLibraries ) +import Distribution.Simple.PackageIndex ( lookupInstalledPackageId ) +import Distribution.PackageDescription as PD ( PackageDescription(..), + updatePackageDescription, + BuildInfo(..), + emptyBuildInfo, allBuildInfo, + Library(..), + libModules, hasLibs) +import Distribution.Simple.LocalBuildInfo (LocalBuildInfo(withPackageDB, buildDir, localPkgDescr, installedPkgs, withPrograms), + InstallDirs(..), + componentPackageDeps, + absoluteInstallDirs) +import Distribution.Simple.Compiler ( Compiler(..) ) +import Distribution.Simple.Program ( + Program(..), ConfiguredProgram(..), + rawSystemProgramConf, rawSystemProgramStdoutConf, programName, programPath, + c2hsProgram, pkgConfigProgram, gccProgram, requireProgram, ghcPkgProgram, + simpleProgram, lookupProgram, rawSystemProgramStdout, ProgArg) +import Distribution.ModuleName ( ModuleName, components, toFilePath ) +import Distribution.Simple.Utils +import Distribution.Simple.Setup (CopyFlags(..), InstallFlags(..), CopyDest(..), + defaultCopyFlags, ConfigFlags(configVerbosity), + fromFlag, toFlag, RegisterFlags(..), flagToMaybe, + fromFlagOrDefault, defaultRegisterFlags) +import Distribution.Simple.BuildPaths ( autogenModulesDir ) +import Distribution.Simple.Install ( install ) +import Distribution.Simple.Register ( generateRegistrationInfo, registerPackage ) +import Distribution.Text ( simpleParse, display ) +import System.FilePath +import System.Exit (exitFailure) +import System.Directory ( doesFileExist, getDirectoryContents, doesDirectoryExist ) +import Distribution.Version (Version(..)) +import Distribution.Verbosity +import Control.Monad (when, unless, filterM, liftM, forM, forM_) +import Data.Maybe ( isJust, isNothing, fromMaybe, maybeToList ) +import Data.List (isPrefixOf, isSuffixOf, stripPrefix, nub) +import Data.Char (isAlpha, isNumber) +import qualified Data.Map as M +import qualified Data.Set as S +import qualified Distribution.Simple.LocalBuildInfo as LBI +import Distribution.Simple.Compiler (compilerVersion) + +import Control.Applicative ((<$>)) + +#if CABAL_VERSION_CHECK(1,17,0) +import Distribution.Simple.Program.Find ( defaultProgramSearchPath ) +onDefaultSearchPath f a b = f a b defaultProgramSearchPath +libraryConfig lbi = case [clbi | (LBI.CLibName, clbi, _) <- LBI.componentsConfigs lbi] of + [clbi] -> Just clbi + _ -> Nothing +#else +onDefaultSearchPath = id +libraryConfig = LBI.libraryConfig +#endif + +-- the name of the c2hs pre-compiled header file +precompFile = "precompchs.bin" + +gtk2hsUserHooks = simpleUserHooks { + hookedPrograms = [typeGenProgram, signalGenProgram, c2hsLocal], + hookedPreProcessors = [("chs", ourC2hs)], + confHook = \pd cf -> + (fmap adjustLocalBuildInfo (confHook simpleUserHooks pd cf)), + postConf = \args cf pd lbi -> do + genSynthezisedFiles (fromFlag (configVerbosity cf)) pd lbi + postConf simpleUserHooks args cf pd lbi, + buildHook = \pd lbi uh bf -> fixDeps pd >>= \pd -> + buildHook simpleUserHooks pd lbi uh bf, + copyHook = \pd lbi uh flags -> copyHook simpleUserHooks pd lbi uh flags >> + installCHI pd lbi (fromFlag (copyVerbosity flags)) (fromFlag (copyDest flags)), + instHook = \pd lbi uh flags -> +#if defined(mingw32_HOST_OS) || defined(__MINGW32__) + installHook pd lbi uh flags >> + installCHI pd lbi (fromFlag (installVerbosity flags)) NoCopyDest, + regHook = registerHook +#else + instHook simpleUserHooks pd lbi uh flags >> + installCHI pd lbi (fromFlag (installVerbosity flags)) NoCopyDest +#endif + } + +------------------------------------------------------------------------------ +-- Lots of stuff for windows ghci support +------------------------------------------------------------------------------ + +getDlls :: [FilePath] -> IO [FilePath] +getDlls dirs = filter ((== ".dll") . takeExtension) . concat <$> + mapM getDirectoryContents dirs + +fixLibs :: [FilePath] -> [String] -> [String] +fixLibs dlls = concatMap $ \ lib -> + case filter (isLib lib) dlls of + dll:_ -> [dropExtension dll] + _ -> if lib == "z" then [] else [lib] + where + isLib lib dll = + case stripPrefix ("lib"++lib) dll of + Just ('.':_) -> True + Just ('-':n:_) | isNumber n -> True + _ -> False + +-- The following code is a big copy-and-paste job from the sources of +-- Cabal 1.8 just to be able to fix a field in the package file. Yuck. + +installHook :: PackageDescription -> LocalBuildInfo + -> UserHooks -> InstallFlags -> IO () +installHook pkg_descr localbuildinfo _ flags = do + let copyFlags = defaultCopyFlags { + copyDistPref = installDistPref flags, + copyDest = toFlag NoCopyDest, + copyVerbosity = installVerbosity flags + } + install pkg_descr localbuildinfo copyFlags + let registerFlags = defaultRegisterFlags { + regDistPref = installDistPref flags, + regInPlace = installInPlace flags, + regPackageDB = installPackageDB flags, + regVerbosity = installVerbosity flags + } + when (hasLibs pkg_descr) $ register pkg_descr localbuildinfo registerFlags + +registerHook :: PackageDescription -> LocalBuildInfo + -> UserHooks -> RegisterFlags -> IO () +registerHook pkg_descr localbuildinfo _ flags = + if hasLibs pkg_descr + then register pkg_descr localbuildinfo flags + else setupMessage verbosity + "Package contains no library to register:" (packageId pkg_descr) + where verbosity = fromFlag (regVerbosity flags) + +register :: PackageDescription -> LocalBuildInfo + -> RegisterFlags -- ^Install in the user's database?; verbose + -> IO () +register pkg@(library -> Just lib ) + lbi@(libraryConfig -> Just clbi) regFlags + = do + + installedPkgInfoRaw <- generateRegistrationInfo + verbosity pkg lib lbi clbi inplace distPref + + dllsInScope <- getSearchPath >>= (filterM doesDirectoryExist) >>= getDlls + let libs = fixLibs dllsInScope (extraLibraries installedPkgInfoRaw) + installedPkgInfo = installedPkgInfoRaw { + extraGHCiLibraries = libs } + + -- Three different modes: + case () of + _ | modeGenerateRegFile -> die "Generate Reg File not supported" + | modeGenerateRegScript -> die "Generate Reg Script not supported" + | otherwise -> registerPackage verbosity + installedPkgInfo pkg lbi inplace +#if CABAL_VERSION_CHECK(1,10,0) + packageDbs +#else + packageDb +#endif + + where + modeGenerateRegFile = isJust (flagToMaybe (regGenPkgConf regFlags)) + modeGenerateRegScript = fromFlag (regGenScript regFlags) + inplace = fromFlag (regInPlace regFlags) + packageDbs = nub $ withPackageDB lbi + ++ maybeToList (flagToMaybe (regPackageDB regFlags)) + packageDb = registrationPackageDB packageDbs + distPref = fromFlag (regDistPref regFlags) + verbosity = fromFlag (regVerbosity regFlags) + +register _ _ regFlags = notice verbosity "No package to register" + where + verbosity = fromFlag (regVerbosity regFlags) + + +------------------------------------------------------------------------------ +-- This is a hack for Cabal-1.8, It is not needed in Cabal-1.9.1 or later +------------------------------------------------------------------------------ + +adjustLocalBuildInfo :: LocalBuildInfo -> LocalBuildInfo +adjustLocalBuildInfo lbi = + let extra = (Just libBi, []) + libBi = emptyBuildInfo { includeDirs = [ autogenModulesDir lbi + , buildDir lbi ] } + in lbi { localPkgDescr = updatePackageDescription extra (localPkgDescr lbi) } + +------------------------------------------------------------------------------ +-- Processing .chs files with our local c2hs. +------------------------------------------------------------------------------ + +ourC2hs :: BuildInfo -> LocalBuildInfo -> PreProcessor +ourC2hs bi lbi = PreProcessor { + platformIndependent = False, + runPreProcessor = runC2HS bi lbi +} + +runC2HS :: BuildInfo -> LocalBuildInfo -> + (FilePath, FilePath) -> (FilePath, FilePath) -> Verbosity -> IO () +runC2HS bi lbi (inDir, inFile) (outDir, outFile) verbosity = do + -- have the header file name if we don't have the precompiled header yet + header <- case lookup "x-c2hs-header" (customFieldsBI bi) of + Just h -> return h + Nothing -> die ("Need x-c2hs-Header definition in the .cabal Library section "++ + "that sets the C header file to process .chs.pp files.") + + -- c2hs will output files in out dir, removing any leading path of the input file. + -- Thus, append the dir of the input file to the output dir. + let (outFileDir, newOutFile) = splitFileName outFile + let newOutDir = outDir outFileDir + -- additional .chi files might be needed that other packages have installed; + -- we assume that these are installed in the same place as .hi files + let chiDirs = [ dir | + ipi <- maybe [] (map fst . componentPackageDeps) (libraryConfig lbi), + dir <- maybe [] importDirs (lookupInstalledPackageId (installedPkgs lbi) ipi) ] + (gccProg, _) <- requireProgram verbosity gccProgram (withPrograms lbi) + rawSystemProgramConf verbosity c2hsLocal (withPrograms lbi) $ + map ("--include=" ++) (outDir:chiDirs) + ++ [ "--cpp=" ++ programPath gccProg, "--cppopts=-E" ] + ++ ["--cppopts=" ++ opt | opt <- getCppOptions bi lbi] + ++ ["--output-dir=" ++ newOutDir, + "--output=" ++ newOutFile, + "--precomp=" ++ buildDir lbi precompFile, + header, inDir inFile] + +getCppOptions :: BuildInfo -> LocalBuildInfo -> [String] +getCppOptions bi lbi + = nub $ + ["-I" ++ dir | dir <- PD.includeDirs bi] + ++ [opt | opt@('-':c:_) <- PD.cppOptions bi ++ PD.ccOptions bi, c `elem` "DIU"] + ++ ["-D__GLASGOW_HASKELL__="++show (ghcDefine . versionBranch . compilerVersion $ LBI.compiler lbi)] + where + ghcDefine (v1:v2:_) = v1 * 100 + v2 + ghcDefine _ = __GLASGOW_HASKELL__ + +installCHI :: PackageDescription -- ^information from the .cabal file + -> LocalBuildInfo -- ^information from the configure step + -> Verbosity -> CopyDest -- ^flags sent to copy or install + -> IO () +installCHI pkg@PD.PackageDescription { library = Just lib } lbi verbosity copydest = do + let InstallDirs { libdir = libPref } = absoluteInstallDirs pkg lbi copydest + -- cannot use the recommended 'findModuleFiles' since it fails if there exists + -- a modules that does not have a .chi file + mFiles <- mapM (findFileWithExtension' ["chi"] [buildDir lbi] . toFilePath) + (PD.libModules lib) + + let files = [ f | Just f <- mFiles ] + installOrdinaryFiles verbosity libPref files + + +installCHI _ _ _ _ = return () + +------------------------------------------------------------------------------ +-- Generating the type hierarchy and signal callback .hs files. +------------------------------------------------------------------------------ + +typeGenProgram :: Program +typeGenProgram = simpleProgram "gtk2hsTypeGen" + +signalGenProgram :: Program +signalGenProgram = simpleProgram "gtk2hsHookGenerator" + +c2hsLocal :: Program +c2hsLocal = (simpleProgram "gtk2hsC2hs") { + programFindVersion = findProgramVersion "--version" $ \str -> + -- Invoking "gtk2hsC2hs --version" gives a string like: + -- C->Haskell Compiler, version 0.13.4 (gtk2hs branch) "Bin IO", 13 Nov 2004 + case words str of + (_:_:_:ver:_) -> ver + _ -> "" + } + + +genSynthezisedFiles :: Verbosity -> PackageDescription -> LocalBuildInfo -> IO () +genSynthezisedFiles verb pd lbi = do + cPkgs <- getPkgConfigPackages verb lbi pd + + let xList = maybe [] (customFieldsBI . libBuildInfo) (library pd) + ++customFieldsPD pd + typeOpts :: String -> [ProgArg] + typeOpts tag = concat [ map (\val -> '-':'-':drop (length tag) field ++ '=':val) (words content) + | (field,content) <- xList, + tag `isPrefixOf` field, + field /= (tag++"file")] + ++ [ "--tag=" ++ tag + | PackageIdentifier name (Version (major:minor:_) _) <- cPkgs + , let name' = filter isAlpha (display name) + , tag <- name' + :[ name' ++ "-" ++ show maj ++ "." ++ show d2 + | (maj, d2) <- [(maj, d2) | maj <- [0..(major-1)], d2 <- [0,2..20]] + ++ [(major, d2) | d2 <- [0,2..minor]] ] + ] + + signalsOpts :: [ProgArg] + signalsOpts = concat [ map (\val -> '-':'-':drop 10 field++'=':val) (words content) + | (field,content) <- xList, + "x-signals-" `isPrefixOf` field, + field /= "x-signals-file"] + + genFile :: Program -> [ProgArg] -> FilePath -> IO () + genFile prog args outFile = do + res <- rawSystemProgramStdoutConf verb prog (withPrograms lbi) args + rewriteFile outFile res + + forM_ (filter (\(tag,_) -> "x-types-" `isPrefixOf` tag && "file" `isSuffixOf` tag) xList) $ + \(fileTag, f) -> do + let tag = reverse (drop 4 (reverse fileTag)) + info verb ("Ensuring that class hierarchy in "++f++" is up-to-date.") + genFile typeGenProgram (typeOpts tag) f + + case lookup "x-signals-file" xList of + Nothing -> return () + Just f -> do + info verb ("Ensuring that callback hooks in "++f++" are up-to-date.") + genFile signalGenProgram signalsOpts f + + writeFile "gtk2hs_macros.h" $ generateMacros cPkgs + +-- Based on Cabal/Distribution/Simple/Build/Macros.hs +generateMacros :: [PackageId] -> String +generateMacros cPkgs = concat $ + "/* DO NOT EDIT: This file is automatically generated by Gtk2HsSetup.hs */\n\n" : + [ concat + ["/* package ",display pkgid," */\n" + ,"#define VERSION_",pkgname," ",show (display version),"\n" + ,"#define MIN_VERSION_",pkgname,"(major1,major2,minor) (\\\n" + ," (major1) < ",major1," || \\\n" + ," (major1) == ",major1," && (major2) < ",major2," || \\\n" + ," (major1) == ",major1," && (major2) == ",major2," && (minor) <= ",minor,")" + ,"\n\n" + ] + | pkgid@(PackageIdentifier name version) <- cPkgs + , let (major1:major2:minor:_) = map show (versionBranch version ++ repeat 0) + pkgname = map fixchar (display name) + ] + where fixchar '-' = '_' + fixchar '.' = '_' + fixchar c = c + +--FIXME: Cabal should tell us the selected pkg-config package versions in the +-- LocalBuildInfo or equivalent. +-- In the mean time, ask pkg-config again. + +getPkgConfigPackages :: Verbosity -> LocalBuildInfo -> PackageDescription -> IO [PackageId] +getPkgConfigPackages verbosity lbi pkg = + sequence + [ do version <- pkgconfig ["--modversion", display pkgname] + case simpleParse version of + Nothing -> die "parsing output of pkg-config --modversion failed" + Just v -> return (PackageIdentifier pkgname v) + | Dependency pkgname _ <- concatMap pkgconfigDepends (allBuildInfo pkg) ] + where + pkgconfig = rawSystemProgramStdoutConf verbosity + pkgConfigProgram (withPrograms lbi) + +------------------------------------------------------------------------------ +-- Dependency calculation amongst .chs files. +------------------------------------------------------------------------------ + +-- Given all files of the package, find those that end in .chs and extract the +-- .chs files they depend upon. Then return the PackageDescription with these +-- files rearranged so that they are built in a sequence that files that are +-- needed by other files are built first. +fixDeps :: PackageDescription -> IO PackageDescription +fixDeps pd@PD.PackageDescription { + PD.library = Just lib@PD.Library { + PD.exposedModules = expMods, + PD.libBuildInfo = bi@PD.BuildInfo { + PD.hsSourceDirs = srcDirs, + PD.otherModules = othMods + }}} = do + let findModule m = findFileWithExtension [".chs.pp",".chs"] srcDirs + (joinPath (components m)) + mExpFiles <- mapM findModule expMods + mOthFiles <- mapM findModule othMods + + -- tag all exposed files with True so we throw an error if we need to build + -- an exposed module before an internal modules (we cannot express this) + let modDeps = zipWith (ModDep True []) expMods mExpFiles++ + zipWith (ModDep False []) othMods mOthFiles + modDeps <- mapM extractDeps modDeps + let (expMods, othMods) = span mdExposed $ sortTopological modDeps + badOther = map (fromMaybe "" . mdLocation) $ + filter (not . mdExposed) expMods + unless (null badOther) $ + die ("internal chs modules "++intercalate "," badOther++ + " depend on exposed chs modules; cabal needs to build internal modules first") + return pd { PD.library = Just lib { + PD.exposedModules = map mdOriginal expMods, + PD.libBuildInfo = bi { PD.otherModules = map mdOriginal othMods } + }} + +data ModDep = ModDep { + mdExposed :: Bool, + mdRequires :: [ModuleName], + mdOriginal :: ModuleName, + mdLocation :: Maybe FilePath +} + +instance Show ModDep where + show x = show (mdLocation x) + +instance Eq ModDep where + ModDep { mdOriginal = m1 } == ModDep { mdOriginal = m2 } = m1==m2 +instance Ord ModDep where + compare ModDep { mdOriginal = m1 } ModDep { mdOriginal = m2 } = compare m1 m2 + +-- Extract the dependencies of this file. This is intentionally rather naive as it +-- ignores CPP conditionals. We just require everything which means that the +-- existance of a .chs module may not depend on some CPP condition. +extractDeps :: ModDep -> IO ModDep +extractDeps md@ModDep { mdLocation = Nothing } = return md +extractDeps md@ModDep { mdLocation = Just f } = withUTF8FileContents f $ \con -> do + let findImports acc (('{':'#':xs):xxs) = case (dropWhile (' ' ==) xs) of + ('i':'m':'p':'o':'r':'t':' ':ys) -> + case simpleParse (takeWhile ('#' /=) ys) of + Just m -> findImports (m:acc) xxs + Nothing -> die ("cannot parse chs import in "++f++":\n"++ + "offending line is {#"++xs) + -- no more imports after the first non-import hook + _ -> return acc + findImports acc (_:xxs) = findImports acc xxs + findImports acc [] = return acc + mods <- findImports [] (lines con) + return md { mdRequires = mods } + +-- Find a total order of the set of modules that are partially sorted by their +-- dependencies on each other. The function returns the sorted list of modules +-- together with a list of modules that are required but not supplied by this +-- in the input set of modules. +sortTopological :: [ModDep] -> [ModDep] +sortTopological ms = reverse $ fst $ foldl visit ([], S.empty) (map mdOriginal ms) + where + set = M.fromList (map (\m -> (mdOriginal m, m)) ms) + visit (out,visited) m + | m `S.member` visited = (out,visited) + | otherwise = case m `M.lookup` set of + Nothing -> (out, m `S.insert` visited) + Just md -> (md:out', visited') + where + (out',visited') = foldl visit (out, m `S.insert` visited) (mdRequires md) + +-- Check user whether install gtk2hs-buildtools correctly. +checkGtk2hsBuildtools :: [Program] -> IO () +checkGtk2hsBuildtools programs = do + programInfos <- mapM (\ prog -> do + location <- onDefaultSearchPath programFindLocation prog normal + return (programName prog, location) + ) programs + let printError name = do + putStrLn $ "Cannot find " ++ name ++ "\n" + ++ "Please install `gtk2hs-buildtools` first and check that the install directory is in your PATH (e.g. HOME/.cabal/bin)." + exitFailure + forM_ programInfos $ \ (name, location) -> + when (isNothing location) (printError name) diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,10 @@ +-- Standard setup file for a Gtk2Hs module. +-- +-- See also: +-- * SetupMain.hs : the real Setup script for this package +-- * Gtk2HsSetup.hs : Gtk2Hs-specific boilerplate +-- * SetupWrapper.hs : wrapper for compat with various ghc/cabal versions + +import SetupWrapper ( setupWrapper ) + +main = setupWrapper "SetupMain.hs" diff --git a/SetupMain.hs b/SetupMain.hs new file mode 100644 --- /dev/null +++ b/SetupMain.hs @@ -0,0 +1,13 @@ +-- The real Setup file for a Gtk2Hs package (invoked via the SetupWrapper). +-- It contains only adjustments specific to this package, +-- all Gtk2Hs-specific boilerplate is kept in Gtk2HsSetup.hs +-- which should be kept identical across all packages. +-- +import Gtk2HsSetup ( gtk2hsUserHooks, checkGtk2hsBuildtools, + typeGenProgram, signalGenProgram, c2hsLocal) +import Distribution.Simple ( defaultMainWithHooks ) + +main = do + checkGtk2hsBuildtools [typeGenProgram, signalGenProgram, c2hsLocal] + defaultMainWithHooks gtk2hsUserHooks + diff --git a/SetupWrapper.hs b/SetupWrapper.hs new file mode 100644 --- /dev/null +++ b/SetupWrapper.hs @@ -0,0 +1,164 @@ +-- A wrapper script for Cabal Setup.hs scripts. Allows compiling the real Setup +-- conditionally depending on the Cabal version. + +module SetupWrapper (setupWrapper) where + +import Distribution.Package +import Distribution.Compiler +import Distribution.Simple.Utils +import Distribution.Simple.Program +import Distribution.Simple.Compiler +import Distribution.Simple.BuildPaths (exeExtension) +import Distribution.Simple.Configure (configCompiler) +import Distribution.Simple.GHC (getInstalledPackages) +import qualified Distribution.Simple.PackageIndex as PackageIndex +import Distribution.Version +import Distribution.Verbosity +import Distribution.Text + +import System.Environment +import System.Process +import System.Exit +import System.FilePath +import System.Directory +import qualified Control.Exception as Exception +import System.IO.Error (isDoesNotExistError) + +import Data.List +import Data.Char +import Control.Monad + + +-- moreRecentFile is implemented in Distribution.Simple.Utils, but only in +-- Cabal >= 1.18. For backwards-compatibility, we implement a copy with a new +-- name here. Some desirable alternate strategies don't work: +-- * We can't use CPP to check which version of Cabal we're up against because +-- this is the file that's generating the macros for doing that. +-- * We can't use the name moreRecentFiles and use +-- import D.S.U hiding (moreRecentFiles) +-- because on old GHC's (and according to the Report) hiding a name that +-- doesn't exist is an error. +moreRecentFile' :: FilePath -> FilePath -> IO Bool +moreRecentFile' a b = do + exists <- doesFileExist b + if not exists + then return True + else do tb <- getModificationTime b + ta <- getModificationTime a + return (ta > tb) + +setupWrapper :: FilePath -> IO () +setupWrapper setupHsFile = do + args <- getArgs + createDirectoryIfMissingVerbose verbosity True setupDir + compileSetupExecutable + invokeSetupScript args + + where + setupDir = "dist/setup-wrapper" + setupVersionFile = setupDir "setup" <.> "version" + setupProgFile = setupDir "setup" <.> exeExtension + setupMacroFile = setupDir "wrapper-macros.h" + + useCabalVersion = Version [1,8] [] + usePackageDB = [GlobalPackageDB, UserPackageDB] + verbosity = normal + + cabalLibVersionToUse comp conf = do + savedVersion <- savedCabalVersion + case savedVersion of + Just version + -> return version + _ -> do version <- installedCabalVersion comp conf + writeFile setupVersionFile (show version ++ "\n") + return version + + savedCabalVersion = do + versionString <- readFile setupVersionFile + `Exception.catch` \e -> if isDoesNotExistError e + then return "" + else Exception.throwIO e + case reads versionString of + [(version,s)] | all isSpace s -> return (Just version) + _ -> return Nothing + + installedCabalVersion comp conf = do + index <- getInstalledPackages verbosity usePackageDB conf + + let cabalDep = Dependency (PackageName "Cabal") + (orLaterVersion useCabalVersion) + case PackageIndex.lookupDependency index cabalDep of + [] -> die $ "The package requires Cabal library version " + ++ display useCabalVersion + ++ " but no suitable version is installed." + pkgs -> return $ bestVersion (map fst pkgs) + where + bestVersion = maximumBy (comparing preference) + preference version = (sameVersion, sameMajorVersion + ,stableVersion, latestVersion) + where + sameVersion = version == cabalVersion + sameMajorVersion = majorVersion version == majorVersion cabalVersion + majorVersion = take 2 . versionBranch + stableVersion = case versionBranch version of + (_:x:_) -> even x + _ -> False + latestVersion = version + + -- | If the Setup.hs is out of date wrt the executable then recompile it. + -- Currently this is GHC only. It should really be generalised. + -- + compileSetupExecutable = do + setupHsNewer <- setupHsFile `moreRecentFile'` setupProgFile + cabalVersionNewer <- setupVersionFile `moreRecentFile'` setupProgFile + let outOfDate = setupHsNewer || cabalVersionNewer + when outOfDate $ do + debug verbosity "Setup script is out of date, compiling..." + + (comp, conf) <- configCompiler (Just GHC) Nothing Nothing + defaultProgramConfiguration verbosity + cabalLibVersion <- cabalLibVersionToUse comp conf + let cabalPkgid = PackageIdentifier (PackageName "Cabal") cabalLibVersion + debug verbosity $ "Using Cabal library version " ++ display cabalLibVersion + + writeFile setupMacroFile (generateVersionMacro cabalLibVersion) + + rawSystemProgramConf verbosity ghcProgram conf $ + ["--make", setupHsFile, "-o", setupProgFile] + ++ ghcPackageDbOptions usePackageDB + ++ ["-package", display cabalPkgid + ,"-cpp", "-optP-include", "-optP" ++ setupMacroFile + ,"-odir", setupDir, "-hidir", setupDir] + where + + ghcPackageDbOptions dbstack = case dbstack of + (GlobalPackageDB:UserPackageDB:dbs) -> concatMap specific dbs + (GlobalPackageDB:dbs) -> "-no-user-package-conf" + : concatMap specific dbs + _ -> ierror + where + specific (SpecificPackageDB db) = [ "-package-conf", db ] + specific _ = ierror + ierror = error "internal error: unexpected package db stack" + + generateVersionMacro :: Version -> String + generateVersionMacro version = + concat + ["/* DO NOT EDIT: This file is automatically generated by Cabal */\n\n" + ,"#define CABAL_VERSION_CHECK(major1,major2,minor) (\\\n" + ," (major1) < ",major1," || \\\n" + ," (major1) == ",major1," && (major2) < ",major2," || \\\n" + ," (major1) == ",major1," && (major2) == ",major2," && (minor) <= ",minor,")" + ,"\n\n" + ] + where + (major1:major2:minor:_) = map show (versionBranch version ++ repeat 0) + + invokeSetupScript :: [String] -> IO () + invokeSetupScript args = do + info verbosity $ unwords (setupProgFile : args) + process <- runProcess (currentDir setupProgFile) args + Nothing Nothing + Nothing Nothing Nothing + exitCode <- waitForProcess process + unless (exitCode == ExitSuccess) $ exitWith exitCode diff --git a/cbits/events.h b/cbits/events.h new file mode 100644 --- /dev/null +++ b/cbits/events.h @@ -0,0 +1,14 @@ +#include +#include + +#if WEBKIT_CHECK_VERSION(2,0,0) + #include +#else + #include +#endif + +gboolean webkit_dom_event_target_add_event_listener_closure( + WebKitDOMEventTarget *target, + const char *eventName, + GClosure *closure, + gboolean bubble); diff --git a/cbits/hsgclosure.h b/cbits/hsgclosure.h new file mode 100644 --- /dev/null +++ b/cbits/hsgclosure.h @@ -0,0 +1,22 @@ +/* GIMP Toolkit (GTK) HSGClosure interface + * + * Author : Duncan Coutts + * + * Created: 22 March 2005 + * + * Copyright (C) 2005 Duncan Coutts + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + */ + +#include + +GClosure * gtk2hs_closure_new(HsStablePtr callback); diff --git a/demo/Makefile b/demo/Makefile new file mode 100644 --- /dev/null +++ b/demo/Makefile @@ -0,0 +1,13 @@ + +PROGS = webkit +SOURCES = Webkit.hs + +all : $(PROGS) + +webkit : Webkit.hs + $(HC) --make $< -o $@ $(HCFLAGS) + +clean: + rm -f $(SOURCES:.hs=.hi) $(SOURCES:.hs=.o) $(PROGS) + +HC=ghc diff --git a/demo/Webkit.hs b/demo/Webkit.hs new file mode 100644 --- /dev/null +++ b/demo/Webkit.hs @@ -0,0 +1,95 @@ +-- | WebKit browser demo. +-- Author : Andy Stewart +-- Copyright : (c) 2010 Andy Stewart + +-- | This simple browser base on WebKit API. +-- For simple, i just make all link open in current window. +-- Of course, you can integrate signal `createWebView` with `notebook` +-- to build multi-tab browser. +-- +-- You can click right-button for forward or backward page. +-- +-- Usage: +-- webkit [uri] +-- +module Main where + +import Graphics.UI.Gtk +import Graphics.UI.Gtk.WebKit.WebView +import Graphics.UI.Gtk.WebKit.WebFrame + +import System.Process +import System.Environment + +-- | Main entry. +main :: IO () +main = do + -- Get program arguments. + args <- getArgs + case args of + -- Display help + ["--help"] -> + putStrLn $ "Welcome to Gtk2hs WebKit demo. :)\n\n" ++ + "Usage: webkit [uri]\n\n" ++ + " -- Gtk2hs Team" + -- Start program. + [arg] -> browser arg -- entry user input url + _ -> browser "http://www.google.com" -- entry default url + +-- | Internal browser fucntion. +browser :: String -> IO () +browser url = do + -- Init. + initGUI + + -- Create window. + window <- windowNew + windowSetDefaultSize window 900 600 + windowSetPosition window WinPosCenter + windowSetOpacity window 0.8 -- this function need window-manager support Alpha channel in X11 + + -- Create WebKit view. + webView <- webViewNew + + -- Create window box. + winBox <- vBoxNew False 0 + + -- Create address bar. + addressBar <- entryNew + + -- Create scroll window. + scrollWin <- scrolledWindowNew Nothing Nothing + + -- Load uri. + webViewLoadUri webView url + entrySetText addressBar url + + -- Open uri when user press `return` at address bar. + onEntryActivate addressBar $ do + uri <- entryGetText addressBar -- get uri from address bar + webViewLoadUri webView uri -- load new uri + + -- Add current uri to address bar when load start. + webView `on` loadStarted $ \frame -> do + currentUri <- webFrameGetUri frame + case currentUri of + Just uri -> entrySetText addressBar uri + Nothing -> return () + + -- Open all link in current window. + webView `on` createWebView $ \frame -> do + newUri <- webFrameGetUri frame + case newUri of + Just uri -> webViewLoadUri webView uri + Nothing -> return () + return webView + + -- Connect and show. + boxPackStart winBox addressBar PackNatural 0 + boxPackStart winBox scrollWin PackGrow 0 + window `containerAdd` winBox + scrollWin `containerAdd` webView + window `onDestroy` mainQuit + widgetShowAll window + + mainGUI diff --git a/hierarchy3.list b/hierarchy3.list new file mode 100644 --- /dev/null +++ b/hierarchy3.list @@ -0,0 +1,470 @@ +# This list is the result of a copy-and-paste from the GtkObject hierarchy +# html documentation. Deprecated widgets are uncommented. Some additional +# object have been defined at the end of the copied list. + +# The Gtk prefix of every object is removed, the other prefixes are +# kept. The indentation implies the object hierarchy. In case the +# type query function cannot be derived from the name or the type name +# is different, an alternative name and type query function can be +# specified by appending 'as typename, '. In case this +# function is not specified, the is converted to +# gtk__get_type where is where each upperscore +# letter is converted to an underscore and lowerletter. The underscore +# is omitted if an upperscore letter preceeded: GtkHButtonBox -> +# gtk_hbutton_box_get_type. The generation of a type can be +# conditional by appending 'if '. Such types are only produces if +# --tag= is given on the command line of TypeGenerator. + + + GObject + GdkDrawable + GdkWindow as DrawWindow, gdk_window_object_get_type +# GdkDrawableImplX11 +# GdkWindowImplX11 + GdkPixmap + GdkGLPixmap if gtkglext + GdkGLWindow if gtkglext + GdkColormap + GdkScreen if gtk-2.2 + GdkDisplay if gtk-2.2 + GdkVisual + GdkDevice + GtkSettings + GtkTextBuffer + GtkSourceBuffer if sourceview + GtkSourceBuffer if gtksourceview2 + GtkTextTag + GtkSourceTag if sourceview + GtkTextTagTable + GtkSourceTagTable if sourceview + GtkStyle + GtkRcStyle + GdkDragContext + GdkPixbuf + GdkPixbufAnimation + GdkPixbufSimpleAnim + GdkPixbufAnimationIter + GtkTextChildAnchor + GtkTextMark + GtkSourceMarker if sourceview + GtkSourceMark if gtksourceview2 + GtkWidget + GtkMisc + GtkLabel + GtkAccelLabel + GtkTipsQuery if deprecated + GtkArrow + GtkImage + GtkContainer + WebKitWebView as WebView, webkit_web_view_get_type if webkit + GtkBin + GtkAlignment + GtkFrame + GtkAspectFrame + GtkButton + GtkToggleButton + GtkCheckButton + GtkRadioButton + GtkColorButton if gtk-2.4 + GtkFontButton if gtk-2.4 + GtkOptionMenu if deprecated + GtkItem + GtkMenuItem + GtkCheckMenuItem + GtkRadioMenuItem + GtkTearoffMenuItem + GtkImageMenuItem + GtkSeparatorMenuItem + GtkListItem if deprecated +# GtkTreeItem + GtkWindow + GtkDialog + GtkAboutDialog if gtk-2.6 + GtkColorSelectionDialog + GtkFileSelection + GtkFileChooserDialog if gtk-2.4 + GtkFontSelectionDialog + GtkInputDialog + GtkMessageDialog + GtkPlug if plugNsocket + GtkEventBox + GtkHandleBox + GtkScrolledWindow + GtkViewport + GtkExpander if gtk-2.4 + GtkComboBox if gtk-2.4 + GtkComboBoxEntry if gtk-2.4 + GtkToolItem if gtk-2.4 + GtkToolButton if gtk-2.4 + GtkMenuToolButton if gtk-2.6 + GtkToggleToolButton if gtk-2.4 + GtkRadioToolButton if gtk-2.4 + GtkSeparatorToolItem if gtk-2.4 + GtkMozEmbed if mozembed + VteTerminal as Terminal if vte + GtkBox + GtkButtonBox + GtkHButtonBox + GtkVButtonBox + GtkVBox + GtkColorSelection + GtkFontSelection + GtkFileChooserWidget if gtk-2.4 + GtkHBox + GtkCombo if deprecated + GtkFileChooserButton if gtk-2.6 + GtkStatusbar + GtkCList if deprecated + GtkCTree if deprecated + GtkFixed + GtkPaned + GtkHPaned + GtkVPaned + GtkIconView if gtk-2.6 + GtkLayout + GtkList if deprecated + GtkMenuShell + GtkMenu + GtkMenuBar + GtkNotebook +# GtkPacker + GtkSocket if plugNsocket + GtkTable + GtkTextView + GtkSourceView if sourceview + GtkSourceView if gtksourceview2 + GtkToolbar + GtkTreeView + GtkCalendar + GtkCellView if gtk-2.6 + GtkDrawingArea + GtkEntry + GtkSpinButton + GtkRuler + GtkHRuler + GtkVRuler + GtkRange + GtkScale + GtkHScale + GtkVScale + GtkScrollbar + GtkHScrollbar + GtkVScrollbar + GtkSeparator + GtkHSeparator + GtkVSeparator + GtkInvisible +# GtkOldEditable +# GtkText + GtkPreview if deprecated +# Progress is deprecated, ProgressBar contains everything necessary +# GtkProgress + GtkProgressBar + GtkAdjustment + GtkIMContext + GtkIMMulticontext + GtkItemFactory if deprecated + GtkTooltips + +# These object were added by hand because they do not show up in the hierarchy +# chart. +# These are derived from GtkObject: + GtkTreeViewColumn + GtkCellRenderer + GtkCellRendererPixbuf + GtkCellRendererText + GtkCellRendererCombo if gtk-2.6 + GtkCellRendererToggle + GtkCellRendererProgress if gtk-2.6 + GtkFileFilter if gtk-2.4 + GtkBuilder if gtk-2.12 +# These are actually interfaces, but all objects that implement it are at +# least GObjects. + GtkCellLayout if gtk-2.4 + GtkTreeSortable if gtk-2.4 + GtkTooltip if gtk-2.12 +# These are derived from GObject: + GtkStatusIcon if gtk-2.10 + GtkTreeSelection + GtkTreeModel + GtkTreeStore + GtkListStore + GtkTreeModelSort + GtkTreeModelFilter if gtk-2.4 + GtkIconFactory + GtkIconTheme + GtkSizeGroup + GtkClipboard if gtk-2.2 + GtkAccelGroup + GtkAccelMap if gtk-2.4 + GtkEntryCompletion if gtk-2.4 + GtkAction if gtk-2.4 + GtkToggleAction if gtk-2.4 + GtkRadioAction if gtk-2.4 + GtkActionGroup if gtk-2.4 + GtkUIManager if gtk-2.4 + GtkWindowGroup + GtkSourceLanguage if sourceview + GtkSourceLanguage if gtksourceview2 + GtkSourceLanguagesManager if sourceview + GtkSourceLanguageManager if gtksourceview2 + GladeXML as GladeXML, glade_xml_get_type if libglade + GConfClient as GConf if gconf +# These ones are actualy interfaces, but interface implementations are GObjects + GtkEditable + GtkSourceStyle as SourceStyleObject if gtksourceview2 + GtkSourceStyleScheme if sourceview + GtkSourceStyleScheme if gtksourceview2 + GtkSourceStyleSchemeManager if gtksourceview2 + GtkFileChooser if gtk-2.4 +## This now became a GObject in version 2: + GdkGC as GC, gdk_gc_get_type +## These are Pango structures + PangoContext as PangoContext, pango_context_get_type if pango + PangoLayout as PangoLayoutRaw, pango_layout_get_type if pango + PangoFont as Font, pango_font_get_type if pango + PangoFontFamily as FontFamily, pango_font_family_get_type if pango + PangoFontFace as FontFace, pango_font_face_get_type if pango + PangoFontMap as FontMap, pango_font_face_get_type if pango + PangoFontset as FontSet, pango_fontset_get_type if pango +## This type is only available for PANGO_ENABLE_BACKEND compiled source +## PangoFontsetSimple as FontSetSimple, pango_fontset_simple_get_type + +## GtkGlExt classes + GdkGLContext if gtkglext + GdkGLConfig if gtkglext + GdkGLDrawable if gtkglext + +## GnomeVFS classes + GnomeVFSVolume as Volume, gnome_vfs_volume_get_type if gnomevfs + GnomeVFSDrive as Drive, gnome_vfs_drive_get_type if gnomevfs + GnomeVFSVolumeMonitor as VolumeMonitor, gnome_vfs_volume_monitor_get_type if gnomevfs + +## GIO classes +# Note on all the "as" clauses: the prefix G is unfortunate since it leads +# to two consecutive upper case letters which are not translated with an +# underscore each (e.g. GConf -> gconf, GtkHButtonBox -> gtk_hbutton_box). +# GUnixMountMonitor as UnixMountMonitor, g_unix_mount_monitor_get_type if gio + GOutputStream as OutputStream, g_output_stream_get_type if gio + GFilterOutputStream as FilterOutputStream, g_filter_output_stream_get_type if gio + GDataOutputStream as DataOutputStream, g_data_output_stream_get_type if gio + GBufferedOutputStream as BufferedOutputStream, g_buffered_output_stream_get_type if gio +# GUnixOutputStream as UnixOutputStream, g_unix_output_stream_get_type if gio + GFileOutputStream as FileOutputStream, g_file_output_stream_get_type if gio + GMemoryOutputStream as MemoryOutputStream, g_memory_output_stream_get_type if gio + GInputStream as InputStream, g_input_stream_get_type if gio +# GUnixInputStream as UnixInputStream, g_unix_input_stream_get_type if gio + GMemoryInputStream as MemoryInputStream, g_memory_input_stream_get_type if gio + GFilterInputStream as FilterInputStream, g_filter_input_stream_get_type if gio + GBufferedInputStream as BufferedInputStream, g_buffered_input_stream_get_type if gio + GDataInputStream as DataInputStream, g_data_input_stream_get_type if gio + GFileInputStream as FileInputStream, g_file_input_stream_get_type if gio +# GDesktopAppInfo as DesktopAppInfo, g_desktop_app_info_get_type if gio + GFileMonitor as FileMonitor, g_file_monitor_get_type if gio + GVfs as Vfs, g_vfs_get_type if gio + GMountOperation as MountOperation, g_mount_operation_get_type if gio + GThemedIcon as ThemedIcon, g_themed_icon_get_type if gio + GEmblem as Emblem, g_emblem_get_type if gio + GEmblemedIcon as EmblemedIcon, g_emblemed_icon_get_type if gio + GFileEnumerator as FileEnumerator, g_file_enumerator_get_type if gio + GFilenameCompleter as FilenameCompleter, g_filename_completer_get_type if gio + GFileIcon as FileIcon, g_file_icon_get_type if gio + GVolumeMonitor as VolumeMonitor, g_volume_monitor_get_type if gio + GCancellable as Cancellable, g_cancellable_get_type if gio + GSimpleAsyncResult as SimpleAsyncResult, g_async_result_get_type if gio + GFileInfo as FileInfo, g_file_info_get_type if gio + GAppLaunchContext as AppLaunchContext, g_app_launch_context_get_type if gio +## these are actually GInterfaces + GIcon as Icon, g_icon_get_type if gio + GSeekable as Seekable, g_seekable_get_type if gio + GAppInfo as AppInfo, g_app_info_get_type if gio + GVolume as Volume, g_volume_get_type if gio + GAsyncResult as AsyncResult, g_async_result_get_type if gio + GLoadableIcon as LoadableIcon, g_loadable_icon_get_type if gio + GDrive as Drive, g_drive_get_type if gio + GFile noEq as File, g_file_get_type if gio + GMount as Mount, g_mount_get_type if gio + +## GStreamer classes + GstObject as Object, gst_object_get_type if gstreamer + GstPad as Pad, gst_pad_get_type if gstreamer + GstGhostPad as GhostPad, gst_ghost_pad_get_type if gstreamer + GstPluginFeature as PluginFeature, gst_plugin_feature_get_type if gstreamer + GstElementFactory as ElementFactory, gst_element_factory_get_type if gstreamer + GstTypeFindFactory as TypeFindFactory, gst_type_find_factory_get_type if gstreamer + GstIndexFactory as IndexFactory, gst_index_factory_get_type if gstreamer + GstElement as Element, gst_element_get_type if gstreamer + GstBin as Bin, gst_bin_get_type if gstreamer + GstPipeline as Pipeline, gst_pipeline_get_type if gstreamer + GstImplementsInterface as ImplementsInterface, gst_implements_interface_get_type if gstreamer + GstTagSetter as TagSetter, gst_tag_setter_get_type if gstreamer + GstBaseSrc as BaseSrc, gst_base_src_get_type if gstreamer + GstPushSrc as PushSrc, gst_push_src_get_type if gstreamer + GstBaseSink as BaseSink, gst_base_sink_get_type if gstreamer + GstBaseTransform as BaseTransform, gst_base_transform_get_type if gstreamer + GstPlugin as Plugin, gst_plugin_get_type if gstreamer + GstRegistry as Registry, gst_registry_get_type if gstreamer + GstBus as Bus, gst_bus_get_type if gstreamer + GstClock as Clock, gst_clock_get_type if gstreamer + GstAudioClock as AudioClock, gst_audio_clock_get_type if gstreamer + GstSystemClock as SystemClock, gst_system_clock_get_type if gstreamer + GstNetClientClock as NetClientClock, gst_net_client_clock_get_type if gstreamer + GstIndex as Index, gst_index_get_type if gstreamer + GstPadTemplate as PadTemplate, gst_pad_template_get_type if gstreamer + GstTask as Task, gst_task_get_type if gstreamer + GstXML as XML, gst_xml_get_type if gstreamer + GstChildProxy as ChildProxy, gst_child_proxy_get_type if gstreamer + GstCollectPads as CollectPads, gst_collect_pads_get_type if gstreamer +## these are actually GInterfaces + GstURIHandler as URIHandler, gst_uri_handler_get_type if gstreamer + GstAdapter as Adapter, gst_adapter_get_type if gstreamer + GstController as Controller, gst_controller_get_type if gstreamer + + WebKitWebFrame as WebFrame, webkit_web_frame_get_type if webkit + WebKitWebSettings as WebSettings, webkit_web_settings_get_type if webkit + WebKitNetworkRequest as NetworkRequest, webkit_network_request_get_type if webkit + WebKitNetworkResponse as NetworkResponse, webkit_network_response_get_type if webkit + WebKitDownload as Download, webkit_download_get_type if webkit + WebKitWebBackForwardList as WebBackForwardList, webkit_web_back_forward_list_get_type if webkit + WebKitWebHistoryItem as WebHistoryItem, webkit_web_history_item_get_type if webkit + WebKitWebInspector as WebInspector, webkit_web_inspector_get_type if webkit + WebKitHitTestResult as HitTestResult, webkit_hit_test_result_get_type if webkit + WebKitSecurityOrigin as SecurityOrigin, webkit_security_origin_get_type if webkit + WebKitSoupAuthDialog as SoupAuthDialog, webkit_soup_auth_dialog_get_type if webkit + WebKitWebDatabase as WebDatabase, webkit_web_database_get_type if webkit + WebKitWebDataSource as WebDataSource, webkit_web_data_source_get_type if webkit + WebKitWebNavigationAction as WebNavigationAction, webkit_web_navigation_action_get_type if webkit + WebKitWebPolicyDecision as WebPolicyDecision, webkit_web_policy_decision_get_type if webkit + WebKitWebResource as WebResource, webkit_web_resource_get_type if webkit + WebKitWebWindowFeatures as WebWindowFeatures, webkit_web_window_features_get_type if webkit + WebKitGeolocationPolicyDecision as GeolocationPolicyDecision, webkit_geolocation_policy_decision_get_type if webkit + + WebKitDOMBarInfo as BarInfo, webkit_dom_bar_info_get_type if webkit-dom + WebKitDOMBlob as Blob, webkit_dom_blob_get_type if webkit-dom + WebKitDOMFile as File, webkit_dom_file_get_type if webkit-dom + WebKitDOMCSSRule as CSSRule, webkit_dom_css_rule_get_type if webkit-dom + WebKitDOMCSSRuleList as CSSRuleList, webkit_dom_css_rule_list_get_type if webkit-dom + WebKitDOMCSSStyleDeclaration as CSSStyleDeclaration, webkit_dom_css_style_declaration_get_type if webkit-dom + WebKitDOMCSSValue as CSSValue, webkit_dom_css_value_get_type if webkit-dom + WebKitDOMConsole as Console, webkit_dom_console_get_type if webkit-dom + WebKitDOMDOMApplicationCache as DOMApplicationCache, webkit_dom_dom_application_cache_get_type if webkit-dom + WebKitDOMDOMImplementation as DOMImplementation, webkit_dom_dom_implementation_get_type if webkit-dom + WebKitDOMDOMMimeType as DOMMimeType, webkit_dom_dom_mime_type_get_type if webkit-dom + WebKitDOMDOMMimeTypeArray as DOMMimeTypeArray, webkit_dom_dom_mime_type_array_get_type if webkit-dom + WebKitDOMDOMPlugin as DOMPlugin, webkit_dom_dom_plugin_get_type if webkit-dom + WebKitDOMDOMPluginArray as DOMPluginArray, webkit_dom_dom_plugin_array_get_type if webkit-dom + WebKitDOMDOMSecurityPolicy as DOMSecurityPolicy, webkit_dom_dom_security_policy_get_type if webkitgtk-1.10 + WebKitDOMDOMSelection as DOMSelection, webkit_dom_dom_selection_get_type if webkit-dom + WebKitDOMDOMStringList as DOMStringList, webkit_dom_dom_string_list_get_type if webkit-dom + WebKitDOMDOMTokenList as DOMTokenList, webkit_dom_dom_token_list_get_type if webkit-dom + WebKitDOMDOMSettableTokenList as DOMSettableTokenList, webkit_dom_dom_settable_token_list_get_type if webkit-dom + WebKitDOMDOMWindow as DOMWindow, webkit_dom_dom_window_get_type if webkit-dom + WebKitDOMEvent as Event, webkit_dom_event_get_type if webkit-dom + WebKitDOMUIEvent as UIEvent, webkit_dom_ui_event_get_type if webkit-dom + WebKitDOMMouseEvent as MouseEvent, webkit_dom_mouse_event_get_type if webkit-dom + WebKitDOMEventTarget as EventTarget, webkit_dom_event_target_get_type if webkit-dom + WebKitDOMFileList as FileList, webkit_dom_file_list_get_type if webkit-dom + WebKitDOMGeolocation as Geolocation, webkit_dom_geolocation_get_type if webkit-dom + WebKitDOMHTMLCollection as HTMLCollection, webkit_dom_html_collection_get_type if webkit-dom + WebKitDOMHTMLOptionsCollection as HTMLOptionsCollection, webkit_dom_html_options_collection_get_type if webkit-dom + WebKitDOMHistory as History, webkit_dom_history_get_type if webkit-dom + WebKitDOMLocation as Location, webkit_dom_location_get_type if webkit-dom + WebKitDOMMediaError as MediaError, webkit_dom_media_error_get_type if webkit-dom + WebKitDOMMediaList as MediaList, webkit_dom_media_list_get_type if webkit-dom + WebKitDOMMediaQueryList as MediaQueryList, webkit_dom_media_query_list_get_type if webkit-dom + WebKitDOMMemoryInfo as MemoryInfo, webkit_dom_memory_info_get_type if webkit-dom + WebKitDOMMessagePort as MessagePort, webkit_dom_message_port_get_type if webkit-dom + WebKitDOMNamedNodeMap as NamedNodeMap, webkit_dom_named_node_map_get_type if webkit-dom + WebKitDOMNavigator as Navigator, webkit_dom_navigator_get_type if webkit-dom + WebKitDOMNode as Node, webkit_dom_node_get_type if webkit-dom + WebKitDOMAttr as DOMAttr, webkit_dom_attr_get_type if webkit-dom + WebKitDOMCharacterData as CharacterData, webkit_dom_character_data_get_type if webkit-dom + WebKitDOMComment as Comment, webkit_dom_comment_get_type if webkit-dom + WebKitDOMText as Text, webkit_dom_text_get_type if webkit-dom + WebKitDOMCDATASection as CDATASection, webkit_dom_cdata_section_get_type if webkit-dom + WebKitDOMDocument as Document, webkit_dom_document_get_type if webkit-dom + WebKitDOMHTMLDocument as HTMLDocument, webkit_dom_html_document_get_type if webkit-dom + WebKitDOMDocumentFragment as DocumentFragment, webkit_dom_document_fragment_get_type if webkit-dom + WebKitDOMDocumentType as DocumentType, webkit_dom_document_type_get_type if webkit-dom + WebKitDOMElement as Element, webkit_dom_element_get_type if webkit-dom + WebKitDOMHTMLElement as HTMLElement, webkit_dom_html_element_get_type if webkit-dom + WebKitDOMHTMLAnchorElement as HTMLAnchorElement, webkit_dom_html_anchor_element_get_type if webkit-dom + WebKitDOMHTMLAppletElement as HTMLAppletElement, webkit_dom_html_applet_element_get_type if webkit-dom + WebKitDOMHTMLAreaElement as HTMLAreaElement, webkit_dom_html_area_element_get_type if webkit-dom + WebKitDOMHTMLBRElement as HTMLBRElement, webkit_dom_htmlbr_element_get_type if webkit-dom + WebKitDOMHTMLBaseElement as HTMLBaseElement, webkit_dom_html_base_element_get_type if webkit-dom + WebKitDOMHTMLBaseFontElement as HTMLBaseFontElement, webkit_dom_html_base_font_element_get_type if webkit-dom + WebKitDOMHTMLBodyElement as HTMLBodyElement, webkit_dom_html_body_element_get_type if webkit-dom + WebKitDOMHTMLButtonElement as HTMLButtonElement, webkit_dom_html_button_element_get_type if webkit-dom + WebKitDOMHTMLCanvasElement as HTMLCanvasElement, webkit_dom_html_canvas_element_get_type if webkit-dom + WebKitDOMHTMLDListElement as HTMLDListElement, webkit_dom_htmld_list_element_get_type if webkit-dom + WebKitDOMHTMLDetailsElement as HTMLDetailsElement, webkit_dom_html_details_element_get_type if webkit-dom + WebKitDOMHTMLDirectoryElement as HTMLDirectoryElement, webkit_dom_html_directory_element_get_type if webkit-dom + WebKitDOMHTMLDivElement as HTMLDivElement, webkit_dom_html_div_element_get_type if webkit-dom + WebKitDOMHTMLEmbedElement as HTMLEmbedElement, webkit_dom_html_embed_element_get_type if webkit-dom + WebKitDOMHTMLFieldSetElement as HTMLFieldSetElement, webkit_dom_html_field_set_element_get_type if webkit-dom + WebKitDOMHTMLFontElement as HTMLFontElement, webkit_dom_html_font_element_get_type if webkit-dom + WebKitDOMHTMLFormElement as HTMLFormElement, webkit_dom_html_form_element_get_type if webkit-dom + WebKitDOMHTMLFrameElement as HTMLFrameElement, webkit_dom_html_frame_element_get_type if webkit-dom + WebKitDOMHTMLFrameSetElement as HTMLFrameSetElement, webkit_dom_html_frame_set_element_get_type if webkit-dom + WebKitDOMHTMLHRElement as HTMLHRElement, webkit_dom_htmlhr_element_get_type if webkit-dom + WebKitDOMHTMLHeadElement as HTMLHeadElement, webkit_dom_html_head_element_get_type if webkit-dom + WebKitDOMHTMLHeadingElement as HTMLHeadingElement, webkit_dom_html_heading_element_get_type if webkit-dom + WebKitDOMHTMLHtmlElement as HTMLHtmlElement, webkit_dom_html_html_element_get_type if webkit-dom + WebKitDOMHTMLIFrameElement as HTMLIFrameElement, webkit_dom_html_iframe_element_get_type if webkit-dom + WebKitDOMHTMLImageElement as HTMLImageElement, webkit_dom_html_image_element_get_type if webkit-dom + WebKitDOMHTMLInputElement as HTMLInputElement, webkit_dom_html_input_element_get_type if webkit-dom + WebKitDOMHTMLKeygenElement as HTMLKeygenElement, webkit_dom_html_keygen_element_get_type if webkit-dom + WebKitDOMHTMLLIElement as HTMLLIElement, webkit_dom_htmlli_element_get_type if webkit-dom + WebKitDOMHTMLLabelElement as HTMLLabelElement, webkit_dom_html_label_element_get_type if webkit-dom + WebKitDOMHTMLLegendElement as HTMLLegendElement, webkit_dom_html_legend_element_get_type if webkit-dom + WebKitDOMHTMLLinkElement as HTMLLinkElement, webkit_dom_html_link_element_get_type if webkit-dom + WebKitDOMHTMLMapElement as HTMLMapElement, webkit_dom_html_map_element_get_type if webkit-dom + WebKitDOMHTMLMarqueeElement as HTMLMarqueeElement, webkit_dom_html_marquee_element_get_type if webkit-dom + WebKitDOMHTMLMediaElement as HTMLMediaElement, webkit_dom_html_media_element_get_type if webkit-dom + WebKitDOMHTMLAudioElement as HTMLAudioElement, webkit_dom_html_audio_element_get_type if webkit-dom + WebKitDOMHTMLVideoElement as HTMLVideoElement, webkit_dom_html_video_element_get_type if webkit-dom + WebKitDOMHTMLMenuElement as HTMLMenuElement, webkit_dom_html_menu_element_get_type if webkit-dom + WebKitDOMHTMLMetaElement as HTMLMetaElement, webkit_dom_html_meta_element_get_type if webkit-dom + WebKitDOMHTMLModElement as HTMLModElement, webkit_dom_html_mod_element_get_type if webkit-dom + WebKitDOMHTMLOListElement as HTMLOListElement, webkit_dom_htmlo_list_element_get_type if webkit-dom + WebKitDOMHTMLObjectElement as HTMLObjectElement, webkit_dom_html_object_element_get_type if webkit-dom + WebKitDOMHTMLOptGroupElement as HTMLOptGroupElement, webkit_dom_html_opt_group_element_get_type if webkit-dom + WebKitDOMHTMLOptionElement as HTMLOptionElement, webkit_dom_html_option_element_get_type if webkit-dom + WebKitDOMHTMLParagraphElement as HTMLParagraphElement, webkit_dom_html_paragraph_element_get_type if webkit-dom + WebKitDOMHTMLParamElement as HTMLParamElement, webkit_dom_html_param_element_get_type if webkit-dom + WebKitDOMHTMLPreElement as HTMLPreElement, webkit_dom_html_pre_element_get_type if webkit-dom + WebKitDOMHTMLQuoteElement as HTMLQuoteElement, webkit_dom_html_quote_element_get_type if webkit-dom + WebKitDOMHTMLScriptElement as HTMLScriptElement, webkit_dom_html_script_element_get_type if webkit-dom + WebKitDOMHTMLSelectElement as HTMLSelectElement, webkit_dom_html_select_element_get_type if webkit-dom + WebKitDOMHTMLStyleElement as HTMLStyleElement, webkit_dom_html_style_element_get_type if webkit-dom + WebKitDOMHTMLTableCaptionElement as HTMLTableCaptionElement, webkit_dom_html_table_caption_element_get_type if webkit-dom + WebKitDOMHTMLTableCellElement as HTMLTableCellElement, webkit_dom_html_table_cell_element_get_type if webkit-dom + WebKitDOMHTMLTableColElement as HTMLTableColElement, webkit_dom_html_table_col_element_get_type if webkit-dom + WebKitDOMHTMLTableElement as HTMLTableElement, webkit_dom_html_table_element_get_type if webkit-dom + WebKitDOMHTMLTableRowElement as HTMLTableRowElement, webkit_dom_html_table_row_element_get_type if webkit-dom + WebKitDOMHTMLTableSectionElement as HTMLTableSectionElement, webkit_dom_html_table_section_element_get_type if webkit-dom + WebKitDOMHTMLTextAreaElement as HTMLTextAreaElement, webkit_dom_html_text_area_element_get_type if webkit-dom + WebKitDOMHTMLTitleElement as HTMLTitleElement, webkit_dom_html_title_element_get_type if webkit-dom + WebKitDOMHTMLUListElement as HTMLUListElement, webkit_dom_htmlu_list_element_get_type if webkit-dom + WebKitDOMEntityReference as EntityReference, webkit_dom_entity_reference_get_type if webkit-dom + WebKitDOMProcessingInstruction as ProcessingInstruction, webkit_dom_processing_instruction_get_type if webkit-dom + WebKitDOMNodeFilter as NodeFilter, webkit_dom_node_filter_get_type if webkit-dom + WebKitDOMNodeIterator as NodeIterator, webkit_dom_node_iterator_get_type if webkit-dom + WebKitDOMNodeList as NodeList, webkit_dom_node_list_get_type if webkit-dom + WebKitDOMRange as DOMRange, webkit_dom_range_get_type if webkit-dom + WebKitDOMScreen as DOMScreen, webkit_dom_screen_get_type if webkit-dom + WebKitDOMStorage as Storage, webkit_dom_storage_get_type if webkit-dom + WebKitDOMStorageInfo as StorageInfo, webkit_dom_storage_info_get_type if webkitgtk-1.10 + WebKitDOMStyleMedia as StyleMedia, webkit_dom_style_media_get_type if webkit-dom + WebKitDOMStyleSheet as StyleSheet, webkit_dom_style_sheet_get_type if webkit-dom + WebKitDOMCSSStyleSheet as CSSStyleSheet, webkit_dom_css_style_sheet_get_type if webkit-dom + WebKitDOMStyleSheetList as StyleSheetList, webkit_dom_style_sheet_list_get_type if webkit-dom + WebKitDOMTimeRanges as TimeRanges, webkit_dom_time_ranges_get_type if webkit-dom + WebKitDOMTreeWalker as TreeWalker, webkit_dom_tree_walker_get_type if webkit-dom + WebKitDOMValidityState as ValidityState, webkit_dom_validity_state_get_type if webkit-dom + WebKitDOMWebKitNamedFlow as WebKitNamedFlow, webkit_dom_webkit_named_flow_get_type if webkit-dom + WebKitDOMWebKitPoint as WebKitPoint, webkit_dom_webkit_point_get_type if webkit-dom + WebKitDOMXPathExpression as XPathExpression, webkit_dom_xpath_expression_get_type if webkit-dom + WebKitDOMXPathNSResolver as XPathNSResolver, webkit_dom_xpath_ns_resolver_get_type if webkit-dom + WebKitDOMXPathResult as XPathResult, webkit_dom_xpath_result_get_type if webkit-dom diff --git a/hswebkit.h b/hswebkit.h new file mode 100644 --- /dev/null +++ b/hswebkit.h @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2009 Cjacker Huang . + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifndef HS_WEBKIT_H +#define HS_WEBKIT_H +/* to avoid stdbool.h error in JavaScriptCore/JSBase.h*/ +#define _Bool int + +#define WINAPI +#define CALLBACK + +/* include webkit headers*/ +#include +#include +#endif + +#include "events.h" diff --git a/marshal.list b/marshal.list new file mode 100644 --- /dev/null +++ b/marshal.list @@ -0,0 +1,67 @@ +# see glib-genmarshal(1) for a detailed description of the file format, +# possible parameter types are: +# VOID indicates no return type, or no extra +# parameters. if VOID is used as the parameter +# list, no additional parameters may be present. +# BOOLEAN for boolean types (gboolean) +# CHAR for signed char types (gchar) +# UCHAR for unsigned char types (guchar) +# INT for signed integer types (gint) +# UINT for unsigned integer types (guint) +# LONG for signed long integer types (glong) +# ULONG for unsigned long integer types (gulong) +# ENUM for enumeration types (gint) +# FLAGS for flag enumeration types (guint) +# FLOAT for single-precision float types (gfloat) +# DOUBLE for double-precision float types (gdouble) +# STRING for string types (gchar*) +# MSTRING for string types (gchar*) that could be NUL +# BOXED for boxed (anonymous but reference counted) types (GBoxed*) +# POINTER for anonymous pointer types (gpointer) +# NONE deprecated alias for VOID +# BOOL deprecated alias for BOOLEAN + +# +# One discrepancy from Gtk+ is that for signals that may pass NULL for an object +# reference, the Haskell signal should be passed a 'Maybe GObject'. +# We therefore have two variants that are marshalled as a maybe type: +# +# OBJECT for GObject or derived types (GObject*) +# MOBJECT for GObject or derived types (GObject*) that may be NULL + +# Furthermore, some objects needs to be destroyed synchronously from the main loop of +# Gtk rather than during GC. These objects need to be marshalled using TOBJECT (for thread-safe +# object). It doesn't hurt to use TOBJECT for an object that doesn't need it, except for the +# some performance. As a rule of thumb, use TOBJECT for all libraries that build on package +# 'gtk' and use OBJECT for all packages that only need packages 'glib', 'pango', 'cairo', +# 'gio'. Again both variants exist. Note that the same names will be generated for OBJECT and +# TOBJECT, so you have to remove the OBJECT handler if you need both. +# +# TOBJECT for GObject or derived types (GObject*) +# MTOBJECT for GObject or derived types (GObject*) that may be NULL + +# If you add a new signal type, please check that it actually works! +# If it is a Boxed type check that the reference counting is right. + +VOID:POINTER,POINTER +BOOLEAN:TOBJECT +BOOLEAN:TOBJECT,STRING,BOXED +POINTER:TOBJECT +BOOLEAN:INT,INT,STRING +BOOLEAN:STRING,STRING,INT,STRING +BOOLEAN:TOBJECT,STRING +BOOLEAN:TOBJECT,STRING,STRING +BOOLEAN:TOBJECT,TOBJECT,TOBJECT,TOBJECT +BOOLEAN:TOBJECT,TOBJECT,STRING,TOBJECT +NONE:TOBJECT,TOBJECT,TOBJECT,TOBJECT +NONE:TOBJECT,TOBJECT,MTOBJECT,MTOBJECT +BOOLEAN:ENUM,INT +BOOLEAN:NONE +NONE:NONE +NONE:MSTRING,MSTRING +NONE:TOBJECT,STRING +NONE:TOBJECT,TOBJECT +NONE:STRING,STRING +NONE:TOBJECT +NONE:INT +NONE:STRING diff --git a/webkitgtk3.cabal b/webkitgtk3.cabal new file mode 100644 --- /dev/null +++ b/webkitgtk3.cabal @@ -0,0 +1,228 @@ +Name: webkitgtk3 +Version: 0.12.5 +License: LGPL-2.1 +License-file: COPYING +Copyright: (c) 2001-2013 The Gtk2Hs Team +Author: Cjacker Huang, Andy Stewart, Axel Simon +Maintainer: gtk2hs-users@lists.sourceforge.net +Build-Type: Custom +Cabal-Version: >= 1.8 +Stability: provisional +homepage: http://projects.haskell.org/gtk2hs/ +bug-reports: http://hackage.haskell.org/trac/gtk2hs/ +Synopsis: Binding to the Webkit library. +Description: WebKit is a web content engine, derived from KHTML and KJS from KDE, and + used primarily in Apple's Safari browser. It is made to be embedded in + other applications, such as mail readers, or web browsers. + + It is able to display content such as HTML, SVG, XML, and others. It also + supports DOM, XMLHttpRequest, XSLT, CSS, Javascript/ECMAscript and more. + +Category: Graphics +Tested-With: GHC == 6.10.4, GHC == 6.12.3, GHC == 7.0.4, GHC == 7.2.1, GHC == 7.6.3 +Extra-Source-Files: hswebkit.h + SetupWrapper.hs SetupMain.hs Gtk2HsSetup.hs + marshal.list + hierarchy3.list + cbits/events.h + cbits/hsgclosure.h + +Data-Dir: demo +Data-Files: Webkit.hs + Makefile + +x-Types-File: Graphics/UI/Gtk/WebKit/Types.chs +x-Types-Tag: webkit webkit-dom +x-Types-ModName: Graphics.UI.Gtk.WebKit.Types +x-Types-Forward: *Graphics.UI.GtkInternals +x-Types-Destructor: objectUnrefFromMainloop +x-Types-Hierarchy: hierarchy3.list + +Source-Repository head + type: git + location: https://github.com/gtk2hs/webkit + +Library + build-depends: base >= 4 && < 5, + glib >= 0.12.1 && < 0.13, + pango >= 0.12 && < 0.13, + cairo >= 0.12 && < 0.13, + mtl + + build-tools: gtk2hsC2hs >= 0.13.8, + gtk2hsHookGenerator, gtk2hsTypeGen + c-sources: Graphics/UI/Gtk/WebKit/DOM/hsevents.c + include-dirs: cbits + + exposed-modules: + Graphics.UI.Gtk.WebKit.CacheModel + Graphics.UI.Gtk.WebKit.Download + Graphics.UI.Gtk.WebKit.GeolocationPolicyDecision + Graphics.UI.Gtk.WebKit.HitTestResult + Graphics.UI.Gtk.WebKit.NetworkRequest + Graphics.UI.Gtk.WebKit.NetworkResponse + Graphics.UI.Gtk.WebKit.SecurityOrigin + Graphics.UI.Gtk.WebKit.SoupAuthDialog + Graphics.UI.Gtk.WebKit.Types + Graphics.UI.Gtk.WebKit.WebBackForwardList + Graphics.UI.Gtk.WebKit.WebDatabase + Graphics.UI.Gtk.WebKit.WebDataSource + Graphics.UI.Gtk.WebKit.WebFrame + Graphics.UI.Gtk.WebKit.WebHistoryItem + Graphics.UI.Gtk.WebKit.WebInspector + Graphics.UI.Gtk.WebKit.WebNavigationAction + Graphics.UI.Gtk.WebKit.WebPolicyDecision + Graphics.UI.Gtk.WebKit.WebResource + Graphics.UI.Gtk.WebKit.WebSettings + Graphics.UI.Gtk.WebKit.WebView + Graphics.UI.Gtk.WebKit.WebWindowFeatures + Graphics.UI.Gtk.WebKit.DOM.Attr + Graphics.UI.Gtk.WebKit.DOM.BarInfo + Graphics.UI.Gtk.WebKit.DOM.Blob + Graphics.UI.Gtk.WebKit.DOM.CharacterData + Graphics.UI.Gtk.WebKit.DOM.Console + Graphics.UI.Gtk.WebKit.DOM.Css + Graphics.UI.Gtk.WebKit.DOM.CSSRule + Graphics.UI.Gtk.WebKit.DOM.CSSRuleList + Graphics.UI.Gtk.WebKit.DOM.CSSStyleDeclaration + Graphics.UI.Gtk.WebKit.DOM.CSSStyleSheet + Graphics.UI.Gtk.WebKit.DOM.CSSValue + Graphics.UI.Gtk.WebKit.DOM.Document + Graphics.UI.Gtk.WebKit.DOM.DocumentType + Graphics.UI.Gtk.WebKit.DOM.DOMApplicationCache + Graphics.UI.Gtk.WebKit.DOM.DOMImplementation + Graphics.UI.Gtk.WebKit.DOM.DOMMimeType + Graphics.UI.Gtk.WebKit.DOM.DOMMimeTypeArray + Graphics.UI.Gtk.WebKit.DOM.DOMPlugin + Graphics.UI.Gtk.WebKit.DOM.DOMPluginArray + Graphics.UI.Gtk.WebKit.DOM.DOMSelection + Graphics.UI.Gtk.WebKit.DOM.DOMSettableTokenList + Graphics.UI.Gtk.WebKit.DOM.DOMTokenList + Graphics.UI.Gtk.WebKit.DOM.DOMWindow + Graphics.UI.Gtk.WebKit.DOM.Element + Graphics.UI.Gtk.WebKit.DOM.Event + Graphics.UI.Gtk.WebKit.DOM.EventM + Graphics.UI.Gtk.WebKit.DOM.Events +-- Graphics.UI.Gtk.WebKit.DOM.EventTarget + Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures + Graphics.UI.Gtk.WebKit.DOM.File + Graphics.UI.Gtk.WebKit.DOM.FileList + Graphics.UI.Gtk.WebKit.DOM.History + Graphics.UI.Gtk.WebKit.DOM.HTMLAnchorElement + Graphics.UI.Gtk.WebKit.DOM.HTMLAppletElement + Graphics.UI.Gtk.WebKit.DOM.HTMLAreaElement + Graphics.UI.Gtk.WebKit.DOM.HTMLBaseElement + Graphics.UI.Gtk.WebKit.DOM.HTMLBaseFontElement + Graphics.UI.Gtk.WebKit.DOM.HTMLBodyElement + Graphics.UI.Gtk.WebKit.DOM.HTMLBRElement + Graphics.UI.Gtk.WebKit.DOM.HTMLButtonElement + Graphics.UI.Gtk.WebKit.DOM.HTMLCollection + Graphics.UI.Gtk.WebKit.DOM.HTMLDirectoryElement + Graphics.UI.Gtk.WebKit.DOM.HTMLDivElement + Graphics.UI.Gtk.WebKit.DOM.HTMLDListElement + Graphics.UI.Gtk.WebKit.DOM.HTMLDocument + Graphics.UI.Gtk.WebKit.DOM.HTMLElement + Graphics.UI.Gtk.WebKit.DOM.HTMLFieldSetElement + Graphics.UI.Gtk.WebKit.DOM.HTMLFontElement + Graphics.UI.Gtk.WebKit.DOM.HTMLFormElement + Graphics.UI.Gtk.WebKit.DOM.HTMLFrameElement + Graphics.UI.Gtk.WebKit.DOM.HTMLFrameSetElement + Graphics.UI.Gtk.WebKit.DOM.HTMLHeadElement + Graphics.UI.Gtk.WebKit.DOM.HTMLHeadingElement + Graphics.UI.Gtk.WebKit.DOM.HTMLHRElement + Graphics.UI.Gtk.WebKit.DOM.HTMLHtmlElement + Graphics.UI.Gtk.WebKit.DOM.HTMLIFrameElement + Graphics.UI.Gtk.WebKit.DOM.HTMLImageElement + Graphics.UI.Gtk.WebKit.DOM.HTMLInputElement + Graphics.UI.Gtk.WebKit.DOM.HTMLLabelElement + Graphics.UI.Gtk.WebKit.DOM.HTMLLegendElement + Graphics.UI.Gtk.WebKit.DOM.HTMLLIElement + Graphics.UI.Gtk.WebKit.DOM.HTMLLinkElement + Graphics.UI.Gtk.WebKit.DOM.HTMLMapElement + Graphics.UI.Gtk.WebKit.DOM.HTMLMenuElement + Graphics.UI.Gtk.WebKit.DOM.HTMLMetaElement + Graphics.UI.Gtk.WebKit.DOM.HTMLModElement + Graphics.UI.Gtk.WebKit.DOM.HTMLObjectElement + Graphics.UI.Gtk.WebKit.DOM.HTMLOListElement + Graphics.UI.Gtk.WebKit.DOM.HTMLOptGroupElement + Graphics.UI.Gtk.WebKit.DOM.HTMLOptionElement + Graphics.UI.Gtk.WebKit.DOM.HTMLOptionsCollection + Graphics.UI.Gtk.WebKit.DOM.HTMLParagraphElement + Graphics.UI.Gtk.WebKit.DOM.HTMLParamElement + Graphics.UI.Gtk.WebKit.DOM.HTMLPreElement + Graphics.UI.Gtk.WebKit.DOM.HTMLQuoteElement + Graphics.UI.Gtk.WebKit.DOM.HTMLScriptElement + Graphics.UI.Gtk.WebKit.DOM.HTMLSelectElement + Graphics.UI.Gtk.WebKit.DOM.HTMLStyleElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTableCaptionElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTableCellElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTableColElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTableElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTableRowElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTableSectionElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTextAreaElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTitleElement + Graphics.UI.Gtk.WebKit.DOM.HTMLUListElement + Graphics.UI.Gtk.WebKit.DOM.Location + Graphics.UI.Gtk.WebKit.DOM.MediaList + Graphics.UI.Gtk.WebKit.DOM.MediaQueryList + Graphics.UI.Gtk.WebKit.DOM.MemoryInfo + Graphics.UI.Gtk.WebKit.DOM.MouseEvent + Graphics.UI.Gtk.WebKit.DOM.NamedNodeMap + Graphics.UI.Gtk.WebKit.DOM.Navigator + Graphics.UI.Gtk.WebKit.DOM.Node + Graphics.UI.Gtk.WebKit.DOM.NodeFilter + Graphics.UI.Gtk.WebKit.DOM.NodeIterator + Graphics.UI.Gtk.WebKit.DOM.NodeList + Graphics.UI.Gtk.WebKit.DOM.ProcessingInstruction + Graphics.UI.Gtk.WebKit.DOM.Range + Graphics.UI.Gtk.WebKit.DOM.Ranges + Graphics.UI.Gtk.WebKit.DOM.Screen + Graphics.UI.Gtk.WebKit.DOM.StyleMedia + Graphics.UI.Gtk.WebKit.DOM.StyleSheet + Graphics.UI.Gtk.WebKit.DOM.StyleSheetList + Graphics.UI.Gtk.WebKit.DOM.Stylesheets + Graphics.UI.Gtk.WebKit.DOM.Storage + Graphics.UI.Gtk.WebKit.DOM.Text + Graphics.UI.Gtk.WebKit.DOM.Traversal + Graphics.UI.Gtk.WebKit.DOM.TreeWalker + Graphics.UI.Gtk.WebKit.DOM.UIEvent + Graphics.UI.Gtk.WebKit.DOM.ValidityState + Graphics.UI.Gtk.WebKit.DOM.WebKitNamedFlow + Graphics.UI.Gtk.WebKit.DOM.WebKitPoint + Graphics.UI.Gtk.WebKit.DOM.Window + Graphics.UI.Gtk.WebKit.DOM.XPathExpression + Graphics.UI.Gtk.WebKit.DOM.XPathNSResolver + Graphics.UI.Gtk.WebKit.DOM.XPathResult + Graphics.UI.Gtk.WebKit.DOM.DOMSecurityPolicy + Graphics.UI.Gtk.WebKit.DOM.DOMStringList + Graphics.UI.Gtk.WebKit.DOM.Geolocation + Graphics.UI.Gtk.WebKit.DOM.HTMLCanvasElement + Graphics.UI.Gtk.WebKit.DOM.HTMLDetailsElement + Graphics.UI.Gtk.WebKit.DOM.HTMLEmbedElement + Graphics.UI.Gtk.WebKit.DOM.HTMLKeygenElement + Graphics.UI.Gtk.WebKit.DOM.HTMLMarqueeElement + Graphics.UI.Gtk.WebKit.DOM.HTMLMediaElement + Graphics.UI.Gtk.WebKit.DOM.HTMLVideoElement + Graphics.UI.Gtk.WebKit.DOM.MediaError + Graphics.UI.Gtk.WebKit.DOM.StorageInfo + Graphics.UI.Gtk.WebKit.DOM.TimeRanges + -- Graphics.UI.Gtk.WebKit.DOM.WebKitAnimation + -- Graphics.UI.Gtk.WebKit.DOM.WebKitAnimationList + + other-modules: + Graphics.UI.Gtk.WebKit.Internal + Graphics.UI.Gtk.WebKit.Signals + + extensions: ForeignFunctionInterface + include-dirs: . + + x-Signals-File: Graphics/UI/Gtk/WebKit/Signals.chs + x-Signals-Modname: Graphics.UI.Gtk.WebKit.Signals + x-Signals-Types: marshal.list + x-Signals-Import: Graphics.UI.GtkInternals + + hs-source-dirs: . + pkgconfig-depends: webkitgtk-3.0 >= 1.8 + build-depends: gtk3 >=0.12.5.0 && <0.13 + x-c2hs-Header: hswebkit.h