packages feed

poppler (empty) → 0.11.0

raw patch · 18 files changed

+3655/−0 lines, 18 filesdep +arraydep +basedep +bytestringbuild-type:Customsetup-changed

Dependencies added: array, base, bytestring, cairo, containers, glib, gtk, haskell98, mtl

Files

+ COPYING view
@@ -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.++    <one line to give the library's name and a brief idea of what it does.>+    Copyright (C) <year>  <name of author>++    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.++  <signature of Ty Coon>, 1 April 1990+  Ty Coon, President of Vice++That's all there is to it!++
+ Graphics/UI/Gtk/Poppler/Action.chs view
@@ -0,0 +1,65 @@+{-# LANGUAGE CPP, DeriveDataTypeable #-}+--  GIMP Toolkit (GTK) Binding for Haskell: binding to poppler -*-haskell-*-+--+--  Author : Andy Stewart+--  Created: 18-Jun-2010+--+--  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 3 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 program.  If not, see+--  <http://www.gnu.org/licenses/>.+--  +--  POPPLER, the C library which this Haskell library depends on, is+--  available under LGPL Version 2. The documentation included with+--  this library is based on the original POPPLER documentation.+--  +-- | Maintainer  : gtk2hs-devel@lists.sourceforge.net+--   Stability   : alpha+--   Portability : portable (depends on GHC)+module Graphics.UI.Gtk.Poppler.Action (+-- * Types,+    Action,+    ActionClass,+    Dest,+    DestClass,++-- * Methods+    actionCopy,+    destCopy,+    ) where++import Control.Monad+import Data.Typeable+import System.Glib.FFI+import System.Glib.Flags+import System.Glib.GList+import System.Glib.GError+import System.Glib.GObject+import System.Glib.UTFString+import Graphics.UI.Gtk.Poppler.Enums+{#import Graphics.UI.Gtk.Poppler.Types#}++{# context lib="poppler" prefix="poppler" #}++-- | Copies action, creating an identical 'Action'.+actionCopy :: ActionClass action => action -> IO Action+actionCopy action =+  makeNewGObject mkAction $+  {#call poppler_action_copy #} (toAction action)++-- | Copies dest, creating an identical 'Dest'.+destCopy :: DestClass dest => dest -> IO Dest+destCopy dest =+  makeNewGObject mkDest $+  {#call poppler_dest_copy #} (toDest dest)
+ Graphics/UI/Gtk/Poppler/Attachment.chs view
@@ -0,0 +1,88 @@+{-# LANGUAGE CPP, DeriveDataTypeable #-}+--  GIMP Toolkit (GTK) Binding for Haskell: binding to poppler -*-haskell-*-+--+--  Author : Andy Stewart+--  Created: 18-Jun-2010+--+--  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 3 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 program.  If not, see+--  <http://www.gnu.org/licenses/>.+--  +--  POPPLER, the C library which this Haskell library depends on, is+--  available under LGPL Version 2. The documentation included with+--  this library is based on the original POPPLER documentation.+--  +-- | Maintainer  : gtk2hs-devel@lists.sourceforge.net+--   Stability   : alpha+--   Portability : portable (depends on GHC)+module Graphics.UI.Gtk.Poppler.Attachment (+-- * Types+    AttachmentSave,+    Attachment,+    AttachmentClass,++-- * Methods+    attachmentSave,+    attachmentSaveToCallback,+    ) where++import Control.Monad+import Data.Typeable+import System.Glib.FFI+import System.Glib.Flags+import System.Glib.GError+import System.Glib.GObject+import System.Glib.GList+import System.Glib.UTFString+import Graphics.UI.Gtk.Poppler.Enums+import Graphics.UI.Gtk.Abstract.Widget (Rectangle (..), Color (..))+{#import Graphics.UI.GtkInternals#}+{#import Graphics.Rendering.Cairo.Types#}+{#import Graphics.UI.Gtk.Poppler.Types#}+import Graphics.UI.Gtk.Poppler.Structs++{# context lib="poppler" prefix="poppler" #}++type AttachmentSave =+    String+ -> Int + -> Bool++{#pointer AttachmentSaveFunc#}++foreign import ccall "wrapper" mkAttachmentSaveFunc ::+  (Ptr Attachment -> CString -> {#type glong#} -> Ptr () -> IO {#type gboolean#})+  -> IO AttachmentSaveFunc++-- | Saves @attachment@ to a file indicated by @filename@.+-- Return 'True' if the file successfully saved+attachmentSave :: AttachmentClass attachment => attachment+ -> String -- ^ @filename@ the file name to save+ -> IO Bool+attachmentSave attachment filename = +  liftM toBool $+  withUTFString filename $ \ filenamePtr -> +      propagateGError ({#call poppler_attachment_save #} (toAttachment attachment) filenamePtr)++-- |+attachmentSaveToCallback :: AttachmentClass attachment => attachment+ -> AttachmentSave + -> IO Bool+attachmentSaveToCallback attachment fun = +  liftM toBool $ do+    funcPtr <- mkAttachmentSaveFunc $ \_ s i _ -> do+                 str <- peekUTFString s+                 return (fromBool (fun str (fromIntegral i)))+    {#call attachment_save_to_callback #} (toAttachment attachment) funcPtr (castFunPtrToPtr funcPtr) nullPtr
+ Graphics/UI/Gtk/Poppler/Document.chs view
@@ -0,0 +1,489 @@+{-# LANGUAGE CPP, DeriveDataTypeable #-}+--  GIMP Toolkit (GTK) Binding for Haskell: binding to poppler -*-haskell-*-+--+--  Author : Andy Stewart+--  Created: 18-Jun-2010+--+--  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 3 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 program.  If not, see+--  <http://www.gnu.org/licenses/>.+--  +--  POPPLER, the C library which this Haskell library depends on, is+--  available under LGPL Version 2. The documentation included with+--  this library is based on the original POPPLER documentation.+--  +-- TODO :+--      poppler_font_info_scan+-- +-- | Maintainer  : gtk2hs-devel@lists.sourceforge.net+--   Stability   : alpha+--   Portability : portable (depends on GHC)+module Graphics.UI.Gtk.Poppler.Document (+-- * Details+--+-- | The 'Document' is an object used to refer to a main document.++-- * Types+    Document,+    DocumentClass,+    Page,+    PageClass,+    IndexIter,+    IndexIterClass,+    FontsIter,+    FontsIterClass,+    FontInfo,+    FontInfoClass,+    Dest,+    DestClass,+    FormField,+    Action,+    PSFile,+    PSFileClass,++-- * Enums+    FontType (..),+    PageLayout (..),+    PageMode (..),+    Permissions (..),+    ViewerPreferences (..),++-- * Methods+    documentNewFromFile,    +    documentNewFromData,+    documentSave,+    documentGetNPages,+    documentGetPage,+    documentGetPageByLabel,+    documentFindDest,+    documentHasAttachments,+    documentGetAttachments,+    documentGetFormField,++    indexIterNew,+    indexIterCopy,+    indexIterGetChild,+    indexIterIsOpen,+    indexIterNext,+    indexIterGetAction,++    fontInfoNew,+    fontsIterCopy,+    fontsIterGetName,+    fontsIterGetFullName,+    fontsIterGetFontType,+    fontsIterIsEmbedded,+    fontsIterIsSubset,+    fontsIterNext,++    psFileNew,+    psFileSetPaperSize,+    psFileSetDuplex,++-- * Attributes+    documentAuthor,+    documentCreationDate,+    documentCreator,+    documentFormat,+    documentFormatMajor,+    documentFormatMinor,+    documentKeywords,+    documentLinearized,+    documentMetadata,+    documentModDate,+    documentPageLayout,+    documentPageMode,+    documentPermissions,+    documentProducer,+    documentSubject,+    documentTitle,+    documentViewerPreferences,+    documentLabel,+    ) where++import Control.Monad+import Data.Typeable+import System.Glib.Attributes+import System.Glib.Properties+import System.Glib.FFI+import System.Glib.Flags+import System.Glib.GList+import System.Glib.GError+import System.Glib.GObject+import System.Glib.UTFString+import Graphics.UI.Gtk.Poppler.Enums+{#import Graphics.UI.Gtk.Poppler.Types#}++{# context lib="poppler" prefix="poppler" #}++-- | Creates a new 'Document'. If 'Nothing' is returned, then error will be set. Possible errors include+-- those in the 'Error' and GFileError domains.+documentNewFromFile :: +    String  -- ^ @uri@      uri of the file to load                   + -> Maybe String  -- ^ @password@ password to unlock the file with, or 'Nothing' + -> IO (Maybe Document) -- ^ returns  A newly created 'Document', or 'Nothing'  +documentNewFromFile uri password = +  maybeNull (makeNewGObject mkDocument) $+  withUTFString uri $ \ uriPtr -> +  maybeWith withUTFString password $ \ passwordPtr -> +      propagateGError ({# call poppler_document_new_from_file #} +                       uriPtr+                       passwordPtr)++-- | Creates a new 'Document'. If 'Nothing' is returned, then error will be set. Possible errors include+-- those in the 'Error' and GFileError domains.+documentNewFromData :: +   String  -- ^ @data@     the pdf data contained in a char array    + -> Maybe String  -- ^ @password@ password to unlock the file with, or 'Nothing' + -> IO (Maybe Document) -- ^ returns  A newly created 'Document', or 'Nothing'  +documentNewFromData dat password = +  maybeNull (makeNewGObject mkDocument) $+  withUTFString dat $ \ datPtr -> +  maybeWith withUTFString password $ \ passwordPtr -> +      propagateGError ({#call poppler_document_new_from_data #}+                       datPtr+                       (fromIntegral (length dat))+                       passwordPtr)++-- | Saves document. Any change made in the document such as form fields filled by the user will be+-- saved. If error is set, 'False' will be returned. Possible errors include those in the GFileError+-- domain.+documentSave :: DocumentClass doc => doc + -> String -- ^ @uri@      uri of file to save                          + -> IO Bool -- ^ returns  'True', if the document was successfully saved +documentSave doc uri = +  liftM toBool $+  withUTFString uri $ \ uriPtr -> +      propagateGError ({#call poppler_document_save #}+                       (toDocument doc)+                       uriPtr)++-- | Returns the number of pages in a loaded document.+documentGetNPages :: DocumentClass doc => doc+ -> IO Int  -- ^ returns  Number of pages   +documentGetNPages doc = +  liftM fromIntegral $ +  {#call poppler_document_get_n_pages #} (toDocument doc)++-- | Returns the 'Page' indexed at index. This object is owned by the caller.+-- | 'Page's are indexed starting at 0.+documentGetPage :: DocumentClass doc => doc+ -> Int  -- ^ @index@    a page index             + -> IO Page -- ^ returns  The 'Page' at index +documentGetPage doc index = +  makeNewGObject mkPage $ +  {#call poppler_document_get_page#} (toDocument doc) (fromIntegral index)+  +-- | Returns the 'Page' reference by label. This object is owned by the caller. label is a+-- human-readable string representation of the page number, and can be document specific. Typically, it+-- is a value such as "iii" or "3".+-- +-- By default, "1" refers to the first page.+documentGetPageByLabel :: DocumentClass doc => doc+ -> String -- ^ @label@    a page label                         + -> IO Page -- ^ returns  The 'Page' referenced by label +documentGetPageByLabel doc label = +  makeNewGObject mkPage $ +  withUTFString label $ \ labelPtr -> +  {#call poppler_document_get_page_by_label #} (toDocument doc) labelPtr++-- | Finds named destination @linkName@ in document+documentFindDest :: DocumentClass doc => doc + -> String -- ^ @linkName@ a named destination+ -> IO (Maybe Dest) -- ^ returns   The 'Dest' destination or 'Nothing' if @linkName@ is not a destination. +documentFindDest doc linkName = +  withUTFString linkName $ \ linkNamePtr -> do+      destPtr <- {#call poppler_document_find_dest #}+                  (toDocument doc)+                  linkNamePtr+      if destPtr == nullPtr+         then return Nothing+         else do+           dest <- makeNewGObject mkDest $ return destPtr+           {#call unsafe poppler_dest_free #} dest+           return $ Just dest+           +-- | Returns 'True' of document has any attachments.+documentHasAttachments :: DocumentClass doc => doc+ -> IO Bool -- ^ returns  'True', if document has attachments. +documentHasAttachments doc = +  liftM toBool $+  {#call poppler_document_has_attachments #} (toDocument doc)++-- | Returns the 'FormField' for the given id.+documentGetFormField :: DocumentClass doc => doc+ -> Int  -- ^ @id@       an id of a 'FormField'                 + -> IO (Maybe FormField)+documentGetFormField doc id = +  maybeNull (makeNewGObject mkFormField) $+  {#call poppler_document_get_form_field #} +    (toDocument doc) +    (fromIntegral id)++-- | Create a new postscript file to render to+psFileNew :: DocumentClass doc => doc+ -> String -- ^ @filename@   the path of the output filename + -> Int -- ^ @firstPage@ the first page to print         + -> Int  -- ^ @nPages@    the number of pages to print    + -> IO PSFile+psFileNew doc filename firstPage nPages =  +  makeNewGObject mkPSFile $ +  withUTFString filename $ \ filenamePtr -> +  {#call poppler_ps_file_new #}+    (toDocument doc)+    filenamePtr+    (fromIntegral firstPage)+    (fromIntegral nPages)+  +-- | Set the output paper size. These values will end up in the DocumentMedia, the BoundingBox DSC+-- comments and other places in the generated PostScript.+psFileSetPaperSize :: PSFileClass file => + file  -- ^ @psFile@ a 'PSFile' which was not yet printed to. + -> Double -- ^ @width@   the paper width in 1/72 inch                  + -> Double -- ^ @height@  the paper height in 1/72 inch                 + -> IO () +psFileSetPaperSize psFile width height = +  {#call poppler_ps_file_set_paper_size #}+    (toPSFile psFile)+    (realToFrac width)+    (realToFrac height)++-- | Enable or disable Duplex printing.+psFileSetDuplex :: PSFileClass file => +  file -- ^ @psFile@ a 'PSFile' which was not yet printed to                     + -> Bool  -- ^ @duplex@  whether to force duplex printing (on printers which support this)+ -> IO ()+psFileSetDuplex psFile duplex =+  {#call poppler_ps_file_set_duplex#}+    (toPSFile psFile)+    (fromBool duplex)++-- | Returns a GList containing 'Attachment's.+documentGetAttachments :: DocumentClass doc => doc+ -> IO [Attachment]+documentGetAttachments doc = do+  glistPtr <- {#call poppler_document_get_attachments #} (toDocument doc)+  list <- fromGList glistPtr+  attachs <- mapM (makeNewGObject mkAttachment . return) list+  {#call unsafe g_list_free #} glistPtr+  return attachs++-- | Returns the root 'IndexIter' for document, or 'Nothing'.+indexIterNew :: DocumentClass doc => doc -> IO (Maybe IndexIter)+indexIterNew doc =+  maybeNull (makeNewGObject mkIndexIter) $+  {#call poppler_index_iter_new #} (toDocument doc)++-- | Creates a new 'IndexIter' as a copy of iter.+indexIterCopy :: IndexIterClass iter => iter -> IO IndexIter+indexIterCopy iter = +  makeNewGObject mkIndexIter $+  {#call poppler_index_iter_copy #} (toIndexIter iter)++-- | Returns a newly created child of parent, or 'Nothing' if the iter has no child. See+-- 'indexIterNew' for more information on this function.+indexIterGetChild :: IndexIterClass iter => iter -> IO (Maybe IndexIter)+indexIterGetChild iter = +  maybeNull (makeNewGObject mkIndexIter) $+  {#call poppler_index_iter_get_child #} (toIndexIter iter)++-- | Returns whether this node should be expanded by default to the user. The document can provide a hint+-- as to how the document's index should be expanded initially.+indexIterIsOpen :: IndexIterClass iter => iter+ -> IO Bool  -- ^ returns 'True', if the document wants iter to be expanded +indexIterIsOpen iter =+  liftM toBool $+  {#call poppler_index_iter_is_open #} (toIndexIter iter)++-- | Sets iter to point to the next action at the current level, if valid. See 'indexIterNew'+-- for more information.+indexIterNext :: IndexIterClass iter => iter+ -> IO Bool -- ^ returns 'True', if iter was set to the next action +indexIterNext iter =+  liftM toBool $+  {#call poppler_index_iter_next #} (toIndexIter iter)++-- | Returns the 'Action' associated with iter. +indexIterGetAction :: IndexIterClass iter => iter -> IO Action+indexIterGetAction iter =+  makeNewGObject mkAction $+  {#call poppler_index_iter_get_action #} (toIndexIter iter)++-- |+fontInfoNew :: DocumentClass doc => doc -> IO FontInfo  +fontInfoNew doc =+  makeNewGObject mkFontInfo $+  {#call poppler_font_info_new#} (toDocument doc)++-- | +fontsIterCopy :: FontsIterClass iter => iter -> IO FontsIter+fontsIterCopy iter =+  makeNewGObject mkFontsIter $+  {#call poppler_fonts_iter_copy #} (toFontsIter iter)++-- |+fontsIterGetName :: FontsIterClass iter => iter -> IO String+fontsIterGetName iter =+  {#call poppler_fonts_iter_get_name #} (toFontsIter iter)+  >>= peekUTFString++-- |+fontsIterGetFullName :: FontsIterClass iter => iter -> IO String+fontsIterGetFullName iter =+  {#call poppler_fonts_iter_get_full_name #} (toFontsIter iter)+  >>= peekUTFString++-- |+fontsIterGetFontType :: FontsIterClass iter => iter -> IO FontType+fontsIterGetFontType iter =+  liftM (toEnum . fromIntegral) $+  {#call poppler_fonts_iter_get_font_type #} (toFontsIter iter)++-- |+fontsIterIsEmbedded :: FontsIterClass iter => iter+ -> IO Bool+fontsIterIsEmbedded iter =+  liftM toBool $+  {#call poppler_fonts_iter_is_embedded #} (toFontsIter iter)++-- |+fontsIterIsSubset :: FontsIterClass iter => iter+ -> IO Bool+fontsIterIsSubset iter =+  liftM toBool $+  {#call poppler_fonts_iter_is_subset #} (toFontsIter iter)++-- | +fontsIterNext :: FontsIterClass iter => iter+ -> IO Bool -- ^ returns 'True', if iter was set to the next action +fontsIterNext iter =+  liftM toBool $+  {#call poppler_fonts_iter_next #} (toFontsIter iter)++-------------------+-- Attributes+-- | The author of the document.+-- +-- Default value: \"\"+documentAuthor :: DocumentClass doc => ReadAttr doc String +documentAuthor = readAttrFromStringProperty "author"++-- | The date and time the document was created.+-- +-- Allowed values: >= 0+-- +-- Default value: 0+documentCreationDate :: DocumentClass doc => ReadAttr doc Int+documentCreationDate = readAttrFromIntProperty "creation-date"++-- | The software that created the document.+-- +-- Default value: \"\"+documentCreator :: DocumentClass doc => ReadAttr doc String+documentCreator = readAttrFromStringProperty "creator"++-- | The PDF version of the document.+-- +-- Default value: \"\"+documentFormat :: DocumentClass doc => ReadAttr doc String+documentFormat = readAttrFromStringProperty "format"++-- | The PDF major version number of the document.+-- +-- Default value: 1+documentFormatMajor :: DocumentClass doc => ReadAttr doc String+documentFormatMajor = readAttrFromStringProperty "format-major"++-- | The PDF minor version number of the document.+-- +-- Default value: 0+documentFormatMinor :: DocumentClass doc => ReadAttr doc String+documentFormatMinor = readAttrFromStringProperty "format-minor"++-- | Keywords.+-- +-- Default value: \"\"+documentKeywords :: DocumentClass doc => ReadAttr doc String+documentKeywords = readAttrFromStringProperty "keywords"++-- | Is the document optimized for web viewing?.+-- +-- Default value: \"\"+documentLinearized :: DocumentClass doc => ReadAttr doc String+documentLinearized = readAttrFromStringProperty "linearized"++-- | Embedded XML metadata.+-- +-- Default value: \"\"+documentMetadata :: DocumentClass doc => ReadAttr doc String+documentMetadata = readAttrFromStringProperty "metadata"++-- | The date and time the document was modified.+-- +-- Allowed values: >= 0+-- +-- Default value: 0+documentModDate :: DocumentClass doc => ReadAttr doc Int+documentModDate = readAttrFromIntProperty "mod-date"++-- | Initial Page Layout.+-- +-- Default value: 'PageLayoutUnset'+documentPageLayout :: DocumentClass doc => ReadAttr doc PageLayout+documentPageLayout = readAttrFromEnumProperty "page-layout"+                     {#call pure unsafe poppler_page_layout_get_type #}++-- | Page Mode.+-- +-- Default value: 'PageModeUnset'+documentPageMode :: DocumentClass doc => ReadAttr doc PageMode+documentPageMode = readAttrFromEnumProperty "page-mode"+                   {#call pure unsafe poppler_page_mode_get_type #}++-- | Permissions.+-- +-- Default value: 'PermissionsFull'+documentPermissions :: DocumentClass doc => ReadAttr doc Permissions+documentPermissions = readAttrFromEnumProperty "permissions"+                      {#call pure unsafe poppler_permissions_get_type #}++-- | The software that converted the document.+-- +-- Default value: \"\"+documentProducer :: DocumentClass doc => ReadAttr doc String+documentProducer = readAttrFromStringProperty "producer"++-- | Subjects the document touches.+-- +-- Default value: \"\"+documentSubject :: DocumentClass doc => ReadAttr doc String+documentSubject = readAttrFromStringProperty "subject"++-- | The title of the document.+-- +-- Default value: \"\"+documentTitle :: DocumentClass doc => ReadAttr doc String+documentTitle = readAttrFromStringProperty "title"++-- | Viewer Preferences.+documentViewerPreferences :: DocumentClass doc => ReadAttr doc ViewerPreferences+documentViewerPreferences = readAttrFromEnumProperty "viewer-preferences"+                            {#call pure unsafe poppler_viewer_preferences_get_type #}++-- | The label of the page.+-- +-- Default value: \"\"+documentLabel :: DocumentClass doc => ReadAttr doc String+documentLabel = readAttrFromStringProperty "label"
+ Graphics/UI/Gtk/Poppler/Enums.chs view
@@ -0,0 +1,80 @@+{-# LANGUAGE CPP, DeriveDataTypeable #-}+--  GIMP Toolkit (GTK) Binding for Haskell: binding to poppler -*-haskell-*-+--+--  Author : Andy Stewart+--  Created: 18-Jun-2010+--+--  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 3 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 program.  If not, see+--  <http://www.gnu.org/licenses/>.+--  +--  POPPLER, the C library which this Haskell library depends on, is+--  available under LGPL Version 2. The documentation included with+--  this library is based on the original POPPLER documentation.+--  +-- | Maintainer  : gtk2hs-devel@lists.sourceforge.net+--   Stability   : alpha+--   Portability : portable (depends on GHC)+module Graphics.UI.Gtk.Poppler.Enums (+-- * Enums+    Error(..),+    Orientation(..),+    SelectionStyle(..),+    PageTransitionType(..),+    PageTransitionAlignment(..),+    PageTransitionDirection(..),+    Backend(..),+    PageLayout(..),+    PageMode(..),+    FontType(..),+    ViewerPreferences(..),+    Permissions(..),+    ActionType(..),+    DestType(..),+    FormButtonType(..),+    FormChoiceType(..),+    FormFieldType(..),+    FormTextType(..),+    ) where++import Control.Monad+import Data.Typeable+import System.Glib.FFI+import System.Glib.Flags+import System.Glib.GError+import System.Glib.GObject+import System.Glib.UTFString++{# context lib="poppler" prefix="poppler" #}++{# enum PopplerError as Error {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerOrientation as Orientation {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerSelectionStyle as SelectionStyle {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerPageTransitionType as PageTransitionType {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerPageTransitionAlignment as PageTransitionAlignment {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerPageTransitionDirection as PageTransitionDirection {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerBackend as Backend {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}++{# enum PopplerPageLayout as PageLayout {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerPageMode as PageMode {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerFontType as FontType {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerViewerPreferences as ViewerPreferences {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerPermissions as Permissions {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerActionType as ActionType {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerDestType as DestType {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerFormButtonType as FormButtonType {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerFormChoiceType as FormChoiceType {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerFormFieldType as FormFieldType {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}+{# enum PopplerFormTextType as FormTextType {underscoreToCase} with prefix = "Poppler" deriving (Eq, Ord, Bounded, Show, Typeable) #}
+ Graphics/UI/Gtk/Poppler/FormField.chs view
@@ -0,0 +1,284 @@+{-# LANGUAGE CPP, DeriveDataTypeable #-}+--  GIMP Toolkit (GTK) Binding for Haskell: binding to poppler -*-haskell-*-+--+--  Author : Andy Stewart+--  Created: 18-Jun-2010+--+--  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 3 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 program.  If not, see+--  <http://www.gnu.org/licenses/>.+--  +--  POPPLER, the C library which this Haskell library depends on, is+--  available under LGPL Version 2. The documentation included with+--  this library is based on the original POPPLER documentation.+--  +-- | Maintainer  : gtk2hs-devel@lists.sourceforge.net+--   Stability   : alpha+--   Portability : portable (depends on GHC)+module Graphics.UI.Gtk.Poppler.FormField (+-- * Types+    FormField,+    FormFieldClass,++-- * Enums+    FormFieldType (..),+    FormButtonType (..),+    FormChoiceType (..),+    FormTextType (..),++-- * Methods+    formFieldGetId,+    formFieldGetFieldType,+    formFieldIsReadOnly,+    formFieldGetFontSize,+    formFieldButtonGetButtonType,+    formFieldButtonGetState,+    formFieldButtonSetState,+    formFieldChoiceCanSelectMultiple,+    formFieldChoiceCommitOnChange,+    formFieldChoiceDoSpellCheck,+    formFieldChoiceGetChoiceType,+    formFieldChoiceGetItem,+    formFieldChoiceGetNItems,+    formFieldChoiceGetText,+    formFieldIsEditable,+    formFieldChoiceIsItemSelected,+    formFieldChoiceSelectItem,+    formFieldChoiceSetText,+    formFieldChoiceToggleItem,+    formFieldChoiceUnselectAll,+    formFieldTextDoScroll,+    formFieldTextDoSpellCheck,+    formFieldTextGetMaxLen,+    formFieldTextGetText,+    formFieldTextGetTextType,+    formFieldTextIsPassword,+    formFieldTextIsRichText,+    formFieldTextSetText,+    ) where++import Control.Monad+import Data.Typeable+import System.Glib.FFI+import System.Glib.Flags+import System.Glib.GError+import System.Glib.GObject+import System.Glib.GList+import System.Glib.UTFString+import Graphics.UI.Gtk.Poppler.Enums+import Graphics.UI.Gtk.Abstract.Widget (Rectangle (..), Color (..))+{#import Graphics.UI.GtkInternals#}+{#import Graphics.Rendering.Cairo.Types#}+{#import Graphics.UI.Gtk.Poppler.Types#}+import Graphics.UI.Gtk.Poppler.Structs++{# context lib="poppler" prefix="poppler" #}++-- | Gets the id of field+formFieldGetId :: FormFieldClass field => field + -> IO Int  -- ^ returns the id of field    +formFieldGetId field =+  liftM fromIntegral $+  {#call poppler_form_field_get_id #} (toFormField field)++-- | Gets the type of field+formFieldGetFieldType :: FormFieldClass field => field + -> IO FormFieldType -- ^ returns 'FormFieldType' of field +formFieldGetFieldType field =+  liftM (toEnum . fromIntegral) $+  {# call poppler_form_field_get_field_type #} (toFormField field)++-- | Checks whether field is read only+formFieldIsReadOnly :: FormFieldClass field => field+ -> IO Bool -- ^ returns 'True' if field is read only +formFieldIsReadOnly field =+  liftM toBool $ +  {#call poppler_form_field_is_read_only #} (toFormField field)++-- | Gets the font size of field+formFieldGetFontSize :: FormFieldClass field => field+ -> IO Double -- ^ returns the font size of field +formFieldGetFontSize field =+  liftM realToFrac $ +  {#call poppler_form_field_get_font_size #} (toFormField field)++-- | Gets the button type of field+formFieldButtonGetButtonType :: FormFieldClass field => field + -> IO FormButtonType -- ^ returns 'FormButtonType' of field +formFieldButtonGetButtonType field =+  liftM (toEnum . fromIntegral) $+  {# call poppler_form_field_button_get_button_type #} (toFormField field)++-- | Queries a 'FormField' and returns its current state. Returns 'True' if field is pressed in and+-- 'False' if it is raised.+formFieldButtonGetState :: FormFieldClass field => field+ -> IO Bool -- ^ returns current state of field +formFieldButtonGetState field =+  liftM toBool $+  {#call poppler_form_field_button_get_state #} (toFormField field)++-- | Sets the status of field. Set to 'True' if you want the 'FormField' to be 'pressed in', and 'False'+-- to raise it.+formFieldButtonSetState :: FormFieldClass field => field+ -> Bool + -> IO ()+formFieldButtonSetState field state =+  {#call poppler_form_field_button_set_state #} (toFormField field) (fromBool state)++-- | Checks whether field allows multiple choices to be selected+formFieldChoiceCanSelectMultiple :: FormFieldClass field => field+ -> IO Bool -- ^ returns 'True' if field allows multiple choices to be selected +formFieldChoiceCanSelectMultiple field =+  liftM toBool $+  {#call poppler_form_field_choice_can_select_multiple#} (toFormField field)++-- |+formFieldChoiceCommitOnChange :: FormFieldClass field => field+ -> IO Bool+formFieldChoiceCommitOnChange field =+  liftM toBool $+  {#call poppler_form_field_choice_commit_on_change #} (toFormField field)++-- | Checks whether spell checking should be done for the contents of field+formFieldChoiceDoSpellCheck :: FormFieldClass field => field+ -> IO Bool -- ^ returns 'True' if spell checking should be done for field +formFieldChoiceDoSpellCheck field =+  liftM toBool $+  {#call poppler_form_field_choice_do_spell_check #} (toFormField field)++-- | Gets the choice type of field+formFieldChoiceGetChoiceType :: FormFieldClass field => field+ -> IO FormChoiceType -- ^ returns 'FormChoiceType' of field +formFieldChoiceGetChoiceType field =+  liftM (toEnum . fromIntegral) $+  {#call poppler_form_field_choice_get_choice_type #} (toFormField field)++-- | Returns the contents of the item on field at the given index+formFieldChoiceGetItem :: FormFieldClass field => field + -> Int  -- ^ @index@   the index of the item                                            + -> IO String+formFieldChoiceGetItem field index =+  {#call poppler_form_field_choice_get_item #} (toFormField field) (fromIntegral index)+  >>= readUTFString++-- | Returns the number of items on field+formFieldChoiceGetNItems :: FormFieldClass field => field+ -> IO Int -- ^ returns the number of items on field +formFieldChoiceGetNItems field =+  liftM fromIntegral $+  {#call poppler_form_field_choice_get_n_items #} (toFormField field)++-- | Retrieves the contents of field.+formFieldChoiceGetText :: FormFieldClass field => field+ -> IO String+formFieldChoiceGetText field =+  {#call poppler_form_field_choice_get_text #} (toFormField field)+  >>= readUTFString++-- | Checks whether field is editable+formFieldIsEditable :: FormFieldClass field => field+ -> IO Bool -- ^ returns 'True' if field is editable +formFieldIsEditable field =+  liftM toBool $ +  {#call poppler_form_field_choice_is_editable #} (toFormField field)++-- | Checks whether the item at the given index on field is currently selected+formFieldChoiceIsItemSelected :: FormFieldClass field => field+ -> Int -- ^ @index@   the index of the item                       + -> IO Bool  -- ^ returns 'True' if item at index is currently selected +formFieldChoiceIsItemSelected field index =+  liftM toBool $+  {#call poppler_form_field_choice_is_item_selected #} (toFormField field) (fromIntegral index)++-- | Selects the item at the given index on field+formFieldChoiceSelectItem :: FormFieldClass field => field + -> Int -- ^ @index@ the index of the item + -> IO ()+formFieldChoiceSelectItem field index =+  {# call poppler_form_field_choice_select_item #} (toFormField field) (fromIntegral index)++-- | +formFieldChoiceSetText :: FormFieldClass field => field -> String -> IO ()+formFieldChoiceSetText field text =+  withUTFString text $ \ textPtr -> +      {#call poppler_form_field_choice_set_text #} (toFormField field) textPtr++-- | Toggles the item at the given index on field+formFieldChoiceToggleItem :: FormFieldClass field => field + -> Int -- ^ @index@ the index of the item + -> IO ()+formFieldChoiceToggleItem field index =+  {# call poppler_form_field_choice_toggle_item #} (toFormField field) (fromIntegral index)++-- | Unselects all the items on field+formFieldChoiceUnselectAll :: FormFieldClass field => field -> IO ()+formFieldChoiceUnselectAll field =+  {#call poppler_form_field_choice_unselect_all #} (toFormField field)++-- |+formFieldTextDoScroll :: FormFieldClass field => field -> IO Bool+formFieldTextDoScroll field =+  liftM toBool $+  {#call poppler_form_field_text_do_scroll #} (toFormField field)++-- | Checks whether spell checking should be done for the contents of field+formFieldTextDoSpellCheck :: FormFieldClass field => field+ -> IO Bool  -- ^ returns 'True' if spell checking should be done for field +formFieldTextDoSpellCheck field =+  liftM toBool $+  {#call poppler_form_field_text_do_spell_check #} (toFormField field)++-- | Retrieves the maximum allowed length of the text in field+formFieldTextGetMaxLen :: FormFieldClass field => field + -> IO Int -- ^ returns the maximum allowed number of characters in field, or -1 if there is no maximum.+formFieldTextGetMaxLen field = +  liftM fromIntegral $+  {#call poppler_form_field_text_get_max_len #} (toFormField field)++-- | Retrieves the contents of field.+formFieldTextGetText :: FormFieldClass field => field + -> IO String+formFieldTextGetText field =+  {#call poppler_form_field_text_get_text #} (toFormField field) +  >>= readUTFString++-- | Gets the text type of field+formFieldTextGetTextType :: FormFieldClass field => field + -> IO FormTextType -- ^ returns 'FormTextType' of field +formFieldTextGetTextType field =+  liftM (toEnum . fromIntegral) $+  {# call poppler_form_field_text_get_text_type #} (toFormField field)++-- | Checks whether content of field is a password and it must be hidden+formFieldTextIsPassword :: FormFieldClass field => field + -> IO Bool -- ^ returns 'True' if the content of field is a password +formFieldTextIsPassword field =+  liftM toBool $+  {#call poppler_form_field_text_is_password #} (toFormField field)++-- | Checks whether the contents of field are rich text+formFieldTextIsRichText :: FormFieldClass field => field + -> IO Bool -- ^ returns 'True' if the contents of field are rich text +formFieldTextIsRichText field =+  liftM toBool $+  {#call poppler_form_field_text_is_rich_text #} (toFormField field)++-- | Sets the text in field to the given value, replacing the current contents.+formFieldTextSetText :: FormFieldClass field => field + -> String -- ^ @text@  the new text       + -> IO ()+formFieldTextSetText field text =+  withUTFString text $ \ textPtr -> +  {#call poppler_form_field_text_set_text #} (toFormField field) textPtr
+ Graphics/UI/Gtk/Poppler/Layer.chs view
@@ -0,0 +1,94 @@+{-# LANGUAGE CPP, DeriveDataTypeable #-}+--  GIMP Toolkit (GTK) Binding for Haskell: binding to poppler -*-haskell-*-+--+--  Author : Andy Stewart+--  Created: 18-Jun-2010+--+--  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 3 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 program.  If not, see+--  <http://www.gnu.org/licenses/>.+--  +--  POPPLER, the C library which this Haskell library depends on, is+--  available under LGPL Version 2. The documentation included with+--  this library is based on the original POPPLER documentation.+--  +-- | Maintainer  : gtk2hs-devel@lists.sourceforge.net+--   Stability   : alpha+--   Portability : portable (depends on GHC)+module Graphics.UI.Gtk.Poppler.Layer (+-- * Types+    Layer,+    LayerClass,++-- * Methods+    layerGetTitle,+    layerIsVisible,+    layerShow,+    layerHide,+    layerIsParent,+    layerGetRadioButtonGroupId,+    ) where++import Control.Monad+import Data.Typeable+import System.Glib.FFI+import System.Glib.Flags+import System.Glib.GList+import System.Glib.GError+import System.Glib.GObject+import System.Glib.UTFString+import Graphics.UI.Gtk.Poppler.Enums+{#import Graphics.UI.Gtk.Poppler.Types#}++{# context lib="poppler" prefix="poppler" #}++-- | Returns the name of the layer suitable for presentation as a title in a viewer's GUI+layerGetTitle :: LayerClass layer => layer + -> IO String  -- ^ returns a string containing the title of the layer +layerGetTitle layer = +  {#call poppler_layer_get_title #} (toLayer layer)+  >>= peekUTFString++-- | Returns whether layer is visible+layerIsVisible :: LayerClass layer => layer + -> IO Bool  -- ^ returns 'True' if layer is visible +layerIsVisible layer =+  liftM toBool $+  {#call poppler_layer_is_visible #} (toLayer layer)++-- | Shows layer+layerShow :: LayerClass layer => layer -> IO ()+layerShow layer =+  {#call poppler_layer_show #} (toLayer layer)+  +-- | Hides layer. If layer is the parent of other nested layers, such layers will be also hidden and will+-- be blocked until layer is shown again+layerHide :: LayerClass layer => layer -> IO ()+layerHide layer =+  {#call poppler_layer_hide #} (toLayer layer)++-- | Returns whether layer is parent of other nested layers.+layerIsParent :: LayerClass layer => layer + -> IO Bool  -- ^ returns 'True' if layer is parent +layerIsParent layer =+  liftM toBool $+  {#call poppler_layer_is_parent #} (toLayer layer)++-- | Returns the numeric ID the radio button group associated with layer.+layerGetRadioButtonGroupId :: LayerClass layer => layer+ -> IO Int -- ^ returns the ID of the radio button group associated with layer, or 0 if the layer is not associated to any radio button   +layerGetRadioButtonGroupId layer =+  liftM fromIntegral $+  {#call poppler_layer_get_radio_button_group_id #} (toLayer layer)
+ Graphics/UI/Gtk/Poppler/Page.chs view
@@ -0,0 +1,311 @@+{-# LANGUAGE CPP, DeriveDataTypeable #-}+--  GIMP Toolkit (GTK) Binding for Haskell: binding to poppler -*-haskell-*-+--+--  Author : Andy Stewart+--  Created: 18-Jun-2010+--+--  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 3 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 program.  If not, see+--  <http://www.gnu.org/licenses/>.+--  +--  POPPLER, the C library which this Haskell library depends on, is+--  available under LGPL Version 2. The documentation included with+--  this library is based on the original POPPLER documentation.+--  +-- | Maintainer  : gtk2hs-devel@lists.sourceforge.net+--   Stability   : alpha+--   Portability : portable (depends on GHC)+module Graphics.UI.Gtk.Poppler.Page (+-- * Types+    Cairo,+    PopplerRectangle (..),+    PopplerColor (..),+    ImageMapping,+    ImageMappingClass,+    PageTransition,+    PageTransitionClass,+    LinkMapping,+    LinkMappingClass,+    FormFieldMapping,+    FormFieldMappingClass,++-- * Enums+    SelectionStyle (..),++-- * Methods+    pageRender,+    pageRenderToPixbuf,+    pageGetSize,+    pageGetIndex,+    pageGetThumbnail,+    pageGetThumbnailSize,+    pageRenderToPs,+    pageFindText,+    pageGetText,+    pageGetDuration,+    pageGetTransition,+    pageGetLinkMapping,+    pageGetImageMapping,+    pageGetFormFieldMapping,+    pageGetSelectionRegion,+    pageRenderSelection,+    pageRenderSelectionToPixbuf,+    ) where++import Control.Monad+import Data.Typeable+import System.Glib.FFI+import System.Glib.Flags+import System.Glib.GError+import System.Glib.GObject+import System.Glib.GList+import System.Glib.UTFString+import Graphics.UI.Gtk.Poppler.Enums+import Graphics.UI.Gtk.Abstract.Widget (Rectangle (..), Color (..))+{#import Graphics.UI.GtkInternals#}+{#import Graphics.Rendering.Cairo.Types#}+{#import Graphics.UI.Gtk.Poppler.Types#}+import Graphics.UI.Gtk.Poppler.Structs+import Control.Monad.Reader (ReaderT(runReaderT), ask, MonadIO, liftIO)++import Graphics.Rendering.Cairo.Internal (Render(..), bracketR)++{# context lib="poppler" prefix="poppler" #}++-- | Render the page to the given cairo context. This function is for rendering a page that will be+-- displayed. If you want to render a page that will be printed use 'pageRenderForPrinting'+-- instead+pageRender :: PageClass page => page+ -> Render ()+pageRender page = do+  cairo <- ask+  liftIO $ {#call poppler_page_render #} (toPage page) cairo++-- | First scale the document to match the specified pixels per point, then render the rectangle given by+-- the upper left corner at (@srcX@, @srcY@) and @srcWidth@ and @srcHeight@. This function is for rendering+-- a page that will be displayed. If you want to render a page that will be printed use+-- 'pageRenderToPixbufForPrinting' instead+pageRenderToPixbuf :: PageClass page => page+ -> Rectangle -- ^ @rect@      rectangle to render+ -> Double -- ^ @scale@      scale specified as pixels per point         + -> Int -- ^ @rotation@   rotate the document by the specified degree + -> Pixbuf -- ^ @pixbuf@     pixbuf to render into                       + -> IO ()+pageRenderToPixbuf page (Rectangle x y width height) scale rotation pixbuf =+  {#call poppler_page_render_to_pixbuf #}+    (toPage page)+    (fromIntegral x)+    (fromIntegral y)+    (fromIntegral width)+    (fromIntegral height)+    (realToFrac scale)+    (fromIntegral rotation)+    pixbuf++-- | Gets the size of page at the current scale and rotation.+pageGetSize :: PageClass page => page + -> IO (Double, Double)+pageGetSize page =+  alloca $ \ widthPtr -> +  alloca $ \ heightPtr -> do+      {#call poppler_page_get_size #}+        (toPage page)+        widthPtr+        heightPtr+      width <- peek widthPtr+      height <- peek heightPtr+      return (realToFrac width, realToFrac height)+  +-- | Returns the index of page+pageGetIndex :: PageClass page => page+ -> IO Int  -- ^ returns index value of page +pageGetIndex page =+  liftM fromIntegral $ +  {#call poppler_page_get_index #} (toPage page)+  +-- | Get the embedded thumbnail for the specified page. If the document doesn't have an embedded+-- thumbnail for the page, this function returns 'Nothing'.+pageGetThumbnail :: PageClass page => page+ -> IO (Maybe Surface) -- ^ returns the tumbnail as a @cairoSurfaceT@ or 'Nothing' if the document doesn't have a thumbnail for this page.+pageGetThumbnail page = do+  surfacePtr <- {#call poppler_page_get_thumbnail #} (toPage page)+  if surfacePtr == nullPtr+     then return Nothing+     else liftM Just (mkSurface surfacePtr)++-- | Returns 'True' if page has a thumbnail associated with it. It also fills in width and height with the+-- width and height of the thumbnail. The values of width and height are not changed if no appropriate+-- thumbnail exists.+pageGetThumbnailSize :: PageClass page => page+ -> IO (Maybe (Int, Int))+pageGetThumbnailSize page = +  alloca $ \ widthPtr -> +  alloca $ \ heightPtr -> do+    success <- liftM toBool $+                {#call poppler_page_get_thumbnail_size #}+                  (toPage page)+                  widthPtr+                  heightPtr+    if success +       then do+         width  <- peek widthPtr+         height <- peek heightPtr+         return $ Just (fromIntegral width, fromIntegral height)+       else return Nothing+  +-- | Render the page on a postscript file+pageRenderToPs :: (PageClass page, PSFileClass psFile) => page -> psFile -> IO ()+pageRenderToPs page psFile = +  {#call poppler_page_render_to_ps #} (toPage page) (toPSFile psFile)++-- | A GList of rectangles for each occurance of the text on the page. The coordinates are in PDF points.+pageFindText :: PageClass page => page+ -> String  -- ^ @text@    the text to search for (UTF-8 encoded) + -> IO [PopplerRectangle]+pageFindText page text = +  withUTFString text $ \ textPtr -> do+    glistPtr <- {#call poppler_page_find_text #} (toPage page) textPtr+    list <- fromGList glistPtr+    mapM peekPopplerRectangle list+    +-- | Retrieves the contents of the specified selection as text.+pageGetText :: PageClass page => page -> SelectionStyle -> PopplerRectangle+ -> IO String  -- ^ returns selection string+pageGetText page style rect = +  with rect $ \ rectPtr ->+  {#call poppler_page_get_text #} (toPage page) ((fromIntegral . fromEnum) style) (castPtr rectPtr)+  >>= peekUTFString+  +-- | Returns the duration of page+pageGetDuration :: PageClass page => page+ -> IO Double  -- ^ returns duration in seconds of page or -1. +pageGetDuration page =+  liftM realToFrac $+  {#call poppler_page_get_duration #} (toPage page)++-- | Returns the transition effect of page+pageGetTransition :: PageClass page => page+ -> IO (Maybe PageTransition) -- ^ returns a 'PageTransition' or 'Nothing'. +pageGetTransition page =+  maybeNull (makeNewGObject mkPageTransition) $ +  {#call poppler_page_get_transition #} (toPage page)++-- | Returns a list of 'LinkMapping' items that map from a location on page to a 'Action'. +pageGetLinkMapping :: PageClass page => page+ -> IO [LinkMapping]+pageGetLinkMapping page = do+  glistPtr <- {#call poppler_page_get_link_mapping #} (toPage page)+  list <- fromGList glistPtr+  mappings <- mapM (makeNewGObject mkLinkMapping . return) list+  {#call unsafe poppler_page_free_link_mapping #} (castPtr glistPtr)+  return mappings++-- | Returns a list of 'ImageMapping' items that map from a location on page to a 'Action'. +pageGetImageMapping :: PageClass page => page+ -> IO [ImageMapping]+pageGetImageMapping page = do+  glistPtr <- {#call poppler_page_get_image_mapping #} (toPage page)+  list <- fromGList glistPtr+  mappings <- mapM (makeNewGObject mkImageMapping . return) list+  {#call unsafe poppler_page_free_image_mapping #} (castPtr glistPtr)+  return mappings++-- | Returns a list of 'FormFieldMapping' items that map from a location on page to a 'Action'. +pageGetFormFieldMapping :: PageClass page => page+ -> IO [FormFieldMapping]+pageGetFormFieldMapping page = do+  glistPtr <- {#call poppler_page_get_form_field_mapping #} (toPage page)+  list <- fromGList glistPtr+  mappings <- mapM (makeNewGObject mkFormFieldMapping . return) list+  {#call unsafe poppler_page_free_image_mapping #} (castPtr glistPtr)+  return mappings++-- | Returns a region containing the area that would be rendered by 'pageRenderSelection' or+-- 'pageRenderSelectionToPixbuf' as a GList of PopplerRectangle.+pageGetSelectionRegion :: PageClass page => page+ -> Double -- ^ @scale@     scale specified as pixels per point             + -> SelectionStyle -- ^ @style@     a 'SelectionStyle'                         + -> PopplerRectangle -- ^ @selection@ start and end point of selection as a rectangle + -> IO [PopplerRectangle]+pageGetSelectionRegion page scale style selection = +  with selection $ \ selectionPtr -> do+    glistPtr <- {#call poppler_page_get_selection_region #} +                 (toPage page)+                 (realToFrac scale)+                 ((fromIntegral . fromEnum) style)+                 (castPtr selectionPtr)+    list <- fromGList glistPtr+    rectangles <- mapM peekPopplerRectangle list+    {#call unsafe poppler_page_selection_region_free #} (castPtr glistPtr)+    return rectangles++-- | Render the selection specified by selection for page to the given cairo context. The selection will+-- be rendered, using @glyphColor@ for the glyphs and @backgroundColor@ for the selection background.+-- +-- If non-'Nothing', @oldSelection@ specifies the selection that is already rendered to cairo, in which case+-- this function will (some day) only render the changed part of the selection.+pageRenderSelection :: PageClass page => page + -> PopplerRectangle -- ^ @selection@        start and end point of selection as a rectangle + -> PopplerRectangle -- ^ @oldSelection@    previous selection                              + -> SelectionStyle -- ^ @style@            a 'SelectionStyle'                         + -> PopplerColor -- ^ @glyphColor@      color to use for drawing glyphs                 + -> PopplerColor -- ^ @backgroundColor@ color to use for the selection background       + -> Render ()+pageRenderSelection page selection oldSelection style glyphColor backgroundColor = do+  cairo <- ask+  liftIO $ +         with selection $ \ selectionPtr -> +         with oldSelection $ \ oldSelectionPtr -> +         with glyphColor $ \ glyphColorPtr -> +         with backgroundColor $ \ backgroundColorPtr -> +              {#call poppler_page_render_selection #}+                  (toPage page)+                  cairo+                  (castPtr selectionPtr)+                  (castPtr oldSelectionPtr)+                  ((fromIntegral . fromEnum) style)+                  (castPtr glyphColorPtr)+                  (castPtr backgroundColorPtr)+        +-- | Render the selection specified by selection for page into pixbuf. The selection will be rendered at+-- scale, using @glyphColor@ for the glyphs and @backgroundColor@ for the selection background.+-- +-- If non-'Nothing', @oldSelection@ specifies the selection that is already rendered in pixbuf, in which case+-- this function will (some day) only render the changed part of the selection.+pageRenderSelectionToPixbuf :: PageClass page => page  + -> Double -- ^ @scale@            scale specified as pixels per point             + -> Int -- ^ @rotation@         rotate the document by the specified degree     + -> Pixbuf -- ^ @pixbuf@           pixbuf to render to                             + -> PopplerRectangle -- ^ @selection@        start and end point of selection as a rectangle + -> PopplerRectangle -- ^ @oldSelection@    previous selection                              + -> SelectionStyle -- ^ @style@            a 'SelectionStyle'                         + -> Color -- ^ @glyphColor@      color to use for drawing glyphs                 + -> Color -- ^ @backgroundColor@ color to use for the selection background       + -> IO ()+pageRenderSelectionToPixbuf page scale rotation pixbuf selection oldSelection style glyphColor backgroundColor = +  with selection $ \ selectionPtr -> +  with oldSelection $ \ oldSelectionPtr -> +  with glyphColor $ \ glyphColorPtr -> +  with backgroundColor $ \ backgroundColorPtr -> +      {#call poppler_page_render_selection_to_pixbuf #}+        (toPage page)+        (realToFrac scale)+        (fromIntegral rotation)+        pixbuf+        (castPtr selectionPtr)+        (castPtr oldSelectionPtr)+        ((fromIntegral . fromEnum) style)+        (castPtr glyphColorPtr)+        (castPtr backgroundColorPtr)
+ Graphics/UI/Gtk/Poppler/Poppler.chs view
@@ -0,0 +1,58 @@+{-# LANGUAGE CPP, DeriveDataTypeable #-}+--  GIMP Toolkit (GTK) Binding for Haskell: binding to poppler -*-haskell-*-+--+--  Author : Andy Stewart+--  Created: 18-Jun-2010+--+--  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 3 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 program.  If not, see+--  <http://www.gnu.org/licenses/>.+--  +--  POPPLER, the C library which this Haskell library depends on, is+--  available under LGPL Version 2. The documentation included with+--  this library is based on the original POPPLER documentation.+--  +-- | Maintainer  : gtk2hs-devel@lists.sourceforge.net+--   Stability   : alpha+--   Portability : portable (depends on GHC)+module Graphics.UI.Gtk.Poppler.Poppler (+-- * Types+    Backend(..),++-- * Methods+    getBackend,+    getVersion,+    ) where++import Control.Monad+import Data.Typeable+import System.Glib.FFI+import System.Glib.Flags+import System.Glib.GError+import System.Glib.GObject+import System.Glib.UTFString+import Graphics.UI.Gtk.Poppler.Enums++{# context lib="poppler" prefix="poppler" #}++-- | Returns the backend compiled into the poppler library.+getBackend :: IO Backend+getBackend = +  liftM (toEnum . fromIntegral) $ {#call get_backend #}+  +-- | Returns the version of poppler in use. This result is not to be freed.+getVersion :: IO String  +getVersion =+   {#call get_version #} >>= peekUTFString
+ Graphics/UI/Gtk/Poppler/Structs.hsc view
@@ -0,0 +1,95 @@+{-# LANGUAGE CPP, ScopedTypeVariables #-}+{-# OPTIONS_HADDOCK hide #-}+-- -*-haskell-*-+--  GIMP Toolkit (GTK) Structures for Pango+--+--  Author : Axel Simon+--+--  Created: 2 March 2008+--+--  Copyright (C) 2008 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++#include <glib-2.0/glib.h>+#include <glib/poppler.h>+#include "template-hsc-gtk2hs.h"++-- |+-- Maintainer  : gtk2hs-users@lists.sourceforge.net+-- Stability   : provisional+-- Portability : portable (depends on GHC)+--+module Graphics.UI.Gtk.Poppler.Structs (+    PopplerRectangle(..),+    peekPopplerRectangle,                    +    PopplerColor(..),+    peekPopplerColor,                +    ) where+    +import Control.Monad		(liftM)+import Data.IORef+import Control.Exception++import System.Glib.FFI+import System.Glib.UTFString ( peekUTFString, UTFCorrection,+                               ofsToUTF, ofsFromUTF )+import System.Glib.GObject (makeNewGObject)++-- | Rectangles describing an area in 'Double's.+--+-- * Specifies x, y, width and height+--+data PopplerRectangle = PopplerRectangle Double Double Double Double+		      deriving Show++instance Storable PopplerRectangle where+  sizeOf _ = #{const sizeof(PopplerRectangle)}+  alignment _ = alignment (undefined:: #gtk2hs_type gdouble)+  peek ptr = do+    (PopplerRectangle x1_ y1_ x2_ y2_) <- peekPopplerRectangle ptr+    return $ PopplerRectangle (realToFrac x1_) (realToFrac y1_)+                              (realToFrac x2_) (realToFrac y2_)+  poke ptr (PopplerRectangle x1 y1 x2 y2) = do+    #{poke PopplerRectangle, x1} ptr (x1::#gtk2hs_type gdouble)+    #{poke PopplerRectangle, y1} ptr (y1::#gtk2hs_type gdouble)+    #{poke PopplerRectangle, x2} ptr (x2::#gtk2hs_type gdouble)+    #{poke PopplerRectangle, y2} ptr (y2::#gtk2hs_type gdouble)++peekPopplerRectangle :: Ptr PopplerRectangle -> IO PopplerRectangle+peekPopplerRectangle ptr = do+    (x1_ ::#gtk2hs_type gdouble)	<- #{peek PopplerRectangle, x1} ptr+    (y1_ ::#gtk2hs_type gdouble)	<- #{peek PopplerRectangle, y1} ptr+    (x2_ ::#gtk2hs_type gdouble)	<- #{peek PopplerRectangle, x2} ptr+    (y2_ ::#gtk2hs_type gdouble)	<- #{peek PopplerRectangle, y2} ptr+    return (PopplerRectangle (realToFrac x1_) (realToFrac y1_)+                             (realToFrac x2_) (realToFrac y2_))+      +data PopplerColor = PopplerColor (#gtk2hs_type guint16) (#gtk2hs_type guint16) (#gtk2hs_type guint16)+             deriving (Eq,Show)+      +instance Storable PopplerColor where+  sizeOf _ = #{const sizeof(PopplerColor)}+  alignment _ = alignment (undefined::#gtk2hs_type guint16)+  peek ptr = peekPopplerColor ptr+  poke ptr (PopplerColor red green blue) = do+    #{poke PopplerColor, red}   ptr red+    #{poke PopplerColor, green} ptr green+    #{poke PopplerColor, blue}  ptr blue+     +peekPopplerColor :: Ptr PopplerColor -> IO PopplerColor+peekPopplerColor ptr = do+    red	   <- #{peek PopplerColor, red} ptr+    green  <- #{peek PopplerColor, green} ptr+    blue   <- #{peek PopplerColor, blue} ptr+    return $ PopplerColor red green blue
+ Graphics/UI/Gtk/Poppler/Types.chs view
@@ -0,0 +1,652 @@+{-# 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.Poppler.Types (++  PangoContext(PangoContext), PangoContextClass,+  toPangoContext, +  mkPangoContext, unPangoContext,+  castToPangoContext, gTypePangoContext,+  PangoLayoutRaw(PangoLayoutRaw), PangoLayoutRawClass,+  toPangoLayoutRaw, +  mkPangoLayoutRaw, unPangoLayoutRaw,+  castToPangoLayoutRaw, gTypePangoLayoutRaw,+  Font(Font), FontClass,+  toFont, +  mkFont, unFont,+  castToFont, gTypeFont,+  FontFamily(FontFamily), FontFamilyClass,+  toFontFamily, +  mkFontFamily, unFontFamily,+  castToFontFamily, gTypeFontFamily,+  FontFace(FontFace), FontFaceClass,+  toFontFace, +  mkFontFace, unFontFace,+  castToFontFace, gTypeFontFace,+  FontMap(FontMap), FontMapClass,+  toFontMap, +  mkFontMap, unFontMap,+  castToFontMap, gTypeFontMap,+  FontSet(FontSet), FontSetClass,+  toFontSet, +  mkFontSet, unFontSet,+  castToFontSet, gTypeFontSet,+  Document(Document), DocumentClass,+  toDocument, +  mkDocument, unDocument,+  castToDocument, gTypeDocument,+  IndexIter(IndexIter), IndexIterClass,+  toIndexIter, +  mkIndexIter, unIndexIter,+  castToIndexIter, gTypeIndexIter,+  FontsIter(FontsIter), FontsIterClass,+  toFontsIter, +  mkFontsIter, unFontsIter,+  castToFontsIter, gTypeFontsIter,+  Page(Page), PageClass,+  toPage, +  mkPage, unPage,+  castToPage, gTypePage,+  Dest(Dest), DestClass,+  toDest, +  mkDest, unDest,+  castToDest, gTypeDest,+  FormField(FormField), FormFieldClass,+  toFormField, +  mkFormField, unFormField,+  castToFormField, gTypeFormField,+  PSFile(PSFile), PSFileClass,+  toPSFile, +  mkPSFile, unPSFile,+  castToPSFile, gTypePSFile,+  PageTransition(PageTransition), PageTransitionClass,+  toPageTransition, +  mkPageTransition, unPageTransition,+  castToPageTransition, gTypePageTransition,+  LinkMapping(LinkMapping), LinkMappingClass,+  toLinkMapping, +  mkLinkMapping, unLinkMapping,+  castToLinkMapping, gTypeLinkMapping,+  ImageMapping(ImageMapping), ImageMappingClass,+  toImageMapping, +  mkImageMapping, unImageMapping,+  castToImageMapping, gTypeImageMapping,+  FormFieldMapping(FormFieldMapping), FormFieldMappingClass,+  toFormFieldMapping, +  mkFormFieldMapping, unFormFieldMapping,+  castToFormFieldMapping, gTypeFormFieldMapping,+  FontInfo(FontInfo), FontInfoClass,+  toFontInfo, +  mkFontInfo, unFontInfo,+  castToFontInfo, gTypeFontInfo,+  Attachment(Attachment), AttachmentClass,+  toAttachment, +  mkAttachment, unAttachment,+  castToAttachment, gTypeAttachment,+  Action(Action), ActionClass,+  toAction, +  mkAction, unAction,+  castToAction, gTypeAction,+  Layer(Layer), LayerClass,+  toLayer, +  mkLayer, unLayer,+  castToLayer, gTypeLayer+  ) where++import Foreign.ForeignPtr (ForeignPtr, castForeignPtr, unsafeForeignPtrToPtr)+import Foreign.C.Types    (CULong, CUInt)+import System.Glib.GType	(GType, typeInstanceIsA)+import System.Glib.GObject++{# context lib="poppler" prefix="poppler" #}++-- 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+++-- *************************************************************** PangoContext++{#pointer *PangoContext foreign newtype #} deriving (Eq,Ord)++mkPangoContext = (PangoContext, objectUnref)+unPangoContext (PangoContext o) = o++class GObjectClass o => PangoContextClass o+toPangoContext :: PangoContextClass o => o -> PangoContext+toPangoContext = unsafeCastGObject . toGObject++instance PangoContextClass PangoContext+instance GObjectClass PangoContext where+  toGObject = GObject . castForeignPtr . unPangoContext+  unsafeCastGObject = PangoContext . castForeignPtr . unGObject++castToPangoContext :: GObjectClass obj => obj -> PangoContext+castToPangoContext = castTo gTypePangoContext "PangoContext"++gTypePangoContext :: GType+gTypePangoContext =+  {# call fun unsafe pango_context_get_type #}++-- ************************************************************* PangoLayoutRaw++{#pointer *PangoLayout as PangoLayoutRaw foreign newtype #} deriving (Eq,Ord)++mkPangoLayoutRaw = (PangoLayoutRaw, objectUnref)+unPangoLayoutRaw (PangoLayoutRaw o) = o++class GObjectClass o => PangoLayoutRawClass o+toPangoLayoutRaw :: PangoLayoutRawClass o => o -> PangoLayoutRaw+toPangoLayoutRaw = unsafeCastGObject . toGObject++instance PangoLayoutRawClass PangoLayoutRaw+instance GObjectClass PangoLayoutRaw where+  toGObject = GObject . castForeignPtr . unPangoLayoutRaw+  unsafeCastGObject = PangoLayoutRaw . castForeignPtr . unGObject++castToPangoLayoutRaw :: GObjectClass obj => obj -> PangoLayoutRaw+castToPangoLayoutRaw = castTo gTypePangoLayoutRaw "PangoLayoutRaw"++gTypePangoLayoutRaw :: GType+gTypePangoLayoutRaw =+  {# call fun unsafe pango_layout_get_type #}++-- *********************************************************************** Font++{#pointer *PangoFont as Font foreign newtype #} deriving (Eq,Ord)++mkFont = (Font, objectUnref)+unFont (Font o) = o++class GObjectClass o => FontClass o+toFont :: FontClass o => o -> Font+toFont = unsafeCastGObject . toGObject++instance FontClass Font+instance GObjectClass Font where+  toGObject = GObject . castForeignPtr . unFont+  unsafeCastGObject = Font . castForeignPtr . unGObject++castToFont :: GObjectClass obj => obj -> Font+castToFont = castTo gTypeFont "Font"++gTypeFont :: GType+gTypeFont =+  {# call fun unsafe pango_font_get_type #}++-- ***************************************************************** FontFamily++{#pointer *PangoFontFamily as FontFamily foreign newtype #} deriving (Eq,Ord)++mkFontFamily = (FontFamily, objectUnref)+unFontFamily (FontFamily o) = o++class GObjectClass o => FontFamilyClass o+toFontFamily :: FontFamilyClass o => o -> FontFamily+toFontFamily = unsafeCastGObject . toGObject++instance FontFamilyClass FontFamily+instance GObjectClass FontFamily where+  toGObject = GObject . castForeignPtr . unFontFamily+  unsafeCastGObject = FontFamily . castForeignPtr . unGObject++castToFontFamily :: GObjectClass obj => obj -> FontFamily+castToFontFamily = castTo gTypeFontFamily "FontFamily"++gTypeFontFamily :: GType+gTypeFontFamily =+  {# call fun unsafe pango_font_family_get_type #}++-- ******************************************************************* FontFace++{#pointer *PangoFontFace as FontFace foreign newtype #} deriving (Eq,Ord)++mkFontFace = (FontFace, objectUnref)+unFontFace (FontFace o) = o++class GObjectClass o => FontFaceClass o+toFontFace :: FontFaceClass o => o -> FontFace+toFontFace = unsafeCastGObject . toGObject++instance FontFaceClass FontFace+instance GObjectClass FontFace where+  toGObject = GObject . castForeignPtr . unFontFace+  unsafeCastGObject = FontFace . castForeignPtr . unGObject++castToFontFace :: GObjectClass obj => obj -> FontFace+castToFontFace = castTo gTypeFontFace "FontFace"++gTypeFontFace :: GType+gTypeFontFace =+  {# call fun unsafe pango_font_face_get_type #}++-- ******************************************************************** FontMap++{#pointer *PangoFontMap as FontMap foreign newtype #} deriving (Eq,Ord)++mkFontMap = (FontMap, objectUnref)+unFontMap (FontMap o) = o++class GObjectClass o => FontMapClass o+toFontMap :: FontMapClass o => o -> FontMap+toFontMap = unsafeCastGObject . toGObject++instance FontMapClass FontMap+instance GObjectClass FontMap where+  toGObject = GObject . castForeignPtr . unFontMap+  unsafeCastGObject = FontMap . castForeignPtr . unGObject++castToFontMap :: GObjectClass obj => obj -> FontMap+castToFontMap = castTo gTypeFontMap "FontMap"++gTypeFontMap :: GType+gTypeFontMap =+  {# call fun unsafe pango_font_face_get_type #}++-- ******************************************************************** FontSet++{#pointer *PangoFontset as FontSet foreign newtype #} deriving (Eq,Ord)++mkFontSet = (FontSet, objectUnref)+unFontSet (FontSet o) = o++class GObjectClass o => FontSetClass o+toFontSet :: FontSetClass o => o -> FontSet+toFontSet = unsafeCastGObject . toGObject++instance FontSetClass FontSet+instance GObjectClass FontSet where+  toGObject = GObject . castForeignPtr . unFontSet+  unsafeCastGObject = FontSet . castForeignPtr . unGObject++castToFontSet :: GObjectClass obj => obj -> FontSet+castToFontSet = castTo gTypeFontSet "FontSet"++gTypeFontSet :: GType+gTypeFontSet =+  {# call fun unsafe pango_fontset_get_type #}++-- ******************************************************************* Document++{#pointer *Document foreign newtype #} deriving (Eq,Ord)++mkDocument = (Document, objectUnref)+unDocument (Document o) = o++class GObjectClass o => DocumentClass o+toDocument :: DocumentClass o => o -> Document+toDocument = unsafeCastGObject . toGObject++instance DocumentClass 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 poppler_document_get_type #}++-- ****************************************************************** IndexIter++{#pointer *IndexIter foreign newtype #} deriving (Eq,Ord)++mkIndexIter = (IndexIter, objectUnref)+unIndexIter (IndexIter o) = o++class GObjectClass o => IndexIterClass o+toIndexIter :: IndexIterClass o => o -> IndexIter+toIndexIter = unsafeCastGObject . toGObject++instance IndexIterClass IndexIter+instance GObjectClass IndexIter where+  toGObject = GObject . castForeignPtr . unIndexIter+  unsafeCastGObject = IndexIter . castForeignPtr . unGObject++castToIndexIter :: GObjectClass obj => obj -> IndexIter+castToIndexIter = castTo gTypeIndexIter "IndexIter"++gTypeIndexIter :: GType+gTypeIndexIter =+  {# call fun unsafe poppler_index_iter_get_type #}++-- ****************************************************************** FontsIter++{#pointer *FontsIter foreign newtype #} deriving (Eq,Ord)++mkFontsIter = (FontsIter, objectUnref)+unFontsIter (FontsIter o) = o++class GObjectClass o => FontsIterClass o+toFontsIter :: FontsIterClass o => o -> FontsIter+toFontsIter = unsafeCastGObject . toGObject++instance FontsIterClass FontsIter+instance GObjectClass FontsIter where+  toGObject = GObject . castForeignPtr . unFontsIter+  unsafeCastGObject = FontsIter . castForeignPtr . unGObject++castToFontsIter :: GObjectClass obj => obj -> FontsIter+castToFontsIter = castTo gTypeFontsIter "FontsIter"++gTypeFontsIter :: GType+gTypeFontsIter =+  {# call fun unsafe poppler_fonts_iter_get_type #}++-- *********************************************************************** Page++{#pointer *Page foreign newtype #} deriving (Eq,Ord)++mkPage = (Page, objectUnref)+unPage (Page o) = o++class GObjectClass o => PageClass o+toPage :: PageClass o => o -> Page+toPage = unsafeCastGObject . toGObject++instance PageClass Page+instance GObjectClass Page where+  toGObject = GObject . castForeignPtr . unPage+  unsafeCastGObject = Page . castForeignPtr . unGObject++castToPage :: GObjectClass obj => obj -> Page+castToPage = castTo gTypePage "Page"++gTypePage :: GType+gTypePage =+  {# call fun unsafe poppler_page_get_type #}++-- *********************************************************************** Dest++{#pointer *Dest foreign newtype #} deriving (Eq,Ord)++mkDest = (Dest, objectUnref)+unDest (Dest o) = o++class GObjectClass o => DestClass o+toDest :: DestClass o => o -> Dest+toDest = unsafeCastGObject . toGObject++instance DestClass Dest+instance GObjectClass Dest where+  toGObject = GObject . castForeignPtr . unDest+  unsafeCastGObject = Dest . castForeignPtr . unGObject++castToDest :: GObjectClass obj => obj -> Dest+castToDest = castTo gTypeDest "Dest"++gTypeDest :: GType+gTypeDest =+  {# call fun unsafe poppler_dest_get_type #}++-- ****************************************************************** FormField++{#pointer *FormField foreign newtype #} deriving (Eq,Ord)++mkFormField = (FormField, objectUnref)+unFormField (FormField o) = o++class GObjectClass o => FormFieldClass o+toFormField :: FormFieldClass o => o -> FormField+toFormField = unsafeCastGObject . toGObject++instance FormFieldClass FormField+instance GObjectClass FormField where+  toGObject = GObject . castForeignPtr . unFormField+  unsafeCastGObject = FormField . castForeignPtr . unGObject++castToFormField :: GObjectClass obj => obj -> FormField+castToFormField = castTo gTypeFormField "FormField"++gTypeFormField :: GType+gTypeFormField =+  {# call fun unsafe poppler_form_field_get_type #}++-- ********************************************************************* PSFile++{#pointer *PSFile foreign newtype #} deriving (Eq,Ord)++mkPSFile = (PSFile, objectUnref)+unPSFile (PSFile o) = o++class GObjectClass o => PSFileClass o+toPSFile :: PSFileClass o => o -> PSFile+toPSFile = unsafeCastGObject . toGObject++instance PSFileClass PSFile+instance GObjectClass PSFile where+  toGObject = GObject . castForeignPtr . unPSFile+  unsafeCastGObject = PSFile . castForeignPtr . unGObject++castToPSFile :: GObjectClass obj => obj -> PSFile+castToPSFile = castTo gTypePSFile "PSFile"++gTypePSFile :: GType+gTypePSFile =+  {# call fun unsafe poppler_ps_file_get_type #}++-- ************************************************************* PageTransition++{#pointer *PageTransition foreign newtype #} deriving (Eq,Ord)++mkPageTransition = (PageTransition, objectUnref)+unPageTransition (PageTransition o) = o++class GObjectClass o => PageTransitionClass o+toPageTransition :: PageTransitionClass o => o -> PageTransition+toPageTransition = unsafeCastGObject . toGObject++instance PageTransitionClass PageTransition+instance GObjectClass PageTransition where+  toGObject = GObject . castForeignPtr . unPageTransition+  unsafeCastGObject = PageTransition . castForeignPtr . unGObject++castToPageTransition :: GObjectClass obj => obj -> PageTransition+castToPageTransition = castTo gTypePageTransition "PageTransition"++gTypePageTransition :: GType+gTypePageTransition =+  {# call fun unsafe poppler_page_transition_get_type #}++-- **************************************************************** LinkMapping++{#pointer *LinkMapping foreign newtype #} deriving (Eq,Ord)++mkLinkMapping = (LinkMapping, objectUnref)+unLinkMapping (LinkMapping o) = o++class GObjectClass o => LinkMappingClass o+toLinkMapping :: LinkMappingClass o => o -> LinkMapping+toLinkMapping = unsafeCastGObject . toGObject++instance LinkMappingClass LinkMapping+instance GObjectClass LinkMapping where+  toGObject = GObject . castForeignPtr . unLinkMapping+  unsafeCastGObject = LinkMapping . castForeignPtr . unGObject++castToLinkMapping :: GObjectClass obj => obj -> LinkMapping+castToLinkMapping = castTo gTypeLinkMapping "LinkMapping"++gTypeLinkMapping :: GType+gTypeLinkMapping =+  {# call fun unsafe poppler_link_mapping_get_type #}++-- *************************************************************** ImageMapping++{#pointer *ImageMapping foreign newtype #} deriving (Eq,Ord)++mkImageMapping = (ImageMapping, objectUnref)+unImageMapping (ImageMapping o) = o++class GObjectClass o => ImageMappingClass o+toImageMapping :: ImageMappingClass o => o -> ImageMapping+toImageMapping = unsafeCastGObject . toGObject++instance ImageMappingClass ImageMapping+instance GObjectClass ImageMapping where+  toGObject = GObject . castForeignPtr . unImageMapping+  unsafeCastGObject = ImageMapping . castForeignPtr . unGObject++castToImageMapping :: GObjectClass obj => obj -> ImageMapping+castToImageMapping = castTo gTypeImageMapping "ImageMapping"++gTypeImageMapping :: GType+gTypeImageMapping =+  {# call fun unsafe poppler_image_mapping_get_type #}++-- *********************************************************** FormFieldMapping++{#pointer *FormFieldMapping foreign newtype #} deriving (Eq,Ord)++mkFormFieldMapping = (FormFieldMapping, objectUnref)+unFormFieldMapping (FormFieldMapping o) = o++class GObjectClass o => FormFieldMappingClass o+toFormFieldMapping :: FormFieldMappingClass o => o -> FormFieldMapping+toFormFieldMapping = unsafeCastGObject . toGObject++instance FormFieldMappingClass FormFieldMapping+instance GObjectClass FormFieldMapping where+  toGObject = GObject . castForeignPtr . unFormFieldMapping+  unsafeCastGObject = FormFieldMapping . castForeignPtr . unGObject++castToFormFieldMapping :: GObjectClass obj => obj -> FormFieldMapping+castToFormFieldMapping = castTo gTypeFormFieldMapping "FormFieldMapping"++gTypeFormFieldMapping :: GType+gTypeFormFieldMapping =+  {# call fun unsafe poppler_form_field_mapping_get_type #}++-- ******************************************************************* FontInfo++{#pointer *FontInfo foreign newtype #} deriving (Eq,Ord)++mkFontInfo = (FontInfo, objectUnref)+unFontInfo (FontInfo o) = o++class GObjectClass o => FontInfoClass o+toFontInfo :: FontInfoClass o => o -> FontInfo+toFontInfo = unsafeCastGObject . toGObject++instance FontInfoClass FontInfo+instance GObjectClass FontInfo where+  toGObject = GObject . castForeignPtr . unFontInfo+  unsafeCastGObject = FontInfo . castForeignPtr . unGObject++castToFontInfo :: GObjectClass obj => obj -> FontInfo+castToFontInfo = castTo gTypeFontInfo "FontInfo"++gTypeFontInfo :: GType+gTypeFontInfo =+  {# call fun unsafe poppler_font_info_get_type #}++-- ***************************************************************** Attachment++{#pointer *Attachment foreign newtype #} deriving (Eq,Ord)++mkAttachment = (Attachment, objectUnref)+unAttachment (Attachment o) = o++class GObjectClass o => AttachmentClass o+toAttachment :: AttachmentClass o => o -> Attachment+toAttachment = unsafeCastGObject . toGObject++instance AttachmentClass Attachment+instance GObjectClass Attachment where+  toGObject = GObject . castForeignPtr . unAttachment+  unsafeCastGObject = Attachment . castForeignPtr . unGObject++castToAttachment :: GObjectClass obj => obj -> Attachment+castToAttachment = castTo gTypeAttachment "Attachment"++gTypeAttachment :: GType+gTypeAttachment =+  {# call fun unsafe poppler_attachment_get_type #}++-- ********************************************************************* Action++{#pointer *Action foreign newtype #} deriving (Eq,Ord)++mkAction = (Action, objectUnref)+unAction (Action o) = o++class GObjectClass o => ActionClass o+toAction :: ActionClass o => o -> Action+toAction = unsafeCastGObject . toGObject++instance ActionClass Action+instance GObjectClass Action where+  toGObject = GObject . castForeignPtr . unAction+  unsafeCastGObject = Action . castForeignPtr . unGObject++castToAction :: GObjectClass obj => obj -> Action+castToAction = castTo gTypeAction "Action"++gTypeAction :: GType+gTypeAction =+  {# call fun unsafe poppler_action_get_type #}++-- ********************************************************************** Layer++{#pointer *Layer foreign newtype #} deriving (Eq,Ord)++mkLayer = (Layer, objectUnref)+unLayer (Layer o) = o++class GObjectClass o => LayerClass o+toLayer :: LayerClass o => o -> Layer+toLayer = unsafeCastGObject . toGObject++instance LayerClass Layer+instance GObjectClass Layer where+  toGObject = GObject . castForeignPtr . unLayer+  unsafeCastGObject = Layer . castForeignPtr . unGObject++castToLayer :: GObjectClass obj => obj -> Layer+castToLayer = castTo gTypeLayer "Layer"++gTypeLayer :: GType+gTypeLayer =+  {# call fun unsafe poppler_layer_get_type #}+
+ Gtk2HsSetup.hs view
@@ -0,0 +1,339 @@+{-# LANGUAGE CPP #-}++#define CABAL_VERSION_ENCODE(major, minor, micro) (     \+          ((major) * 10000)                             \+        + ((minor) *   100)                             \+        + ((micro) *     1))++#define CABAL_VERSION_CHECK(major,minor,micro)    \+        (CABAL_VERSION >= CABAL_VERSION_ENCODE(major,minor,micro))++-- now, this is bad, but Cabal doesn't seem to actually pass any information about+-- its version to CPP, so guess the version depending on the version of GHC+#ifdef CABAL_VERSION_MINOR+#ifndef CABAL_VERSION_MAJOR+#define CABAL_VERSION_MAJOR 1+#endif+#ifndef CABAL_VERSION_MICRO+#define CABAL_VERSION_MICRO 0+#endif+#define CABAL_VERSION CABAL_VERSION_ENCODE(     \+        CABAL_VERSION_MAJOR,                    \+        CABAL_VERSION_MINOR,                    \+        CABAL_VERSION_MICRO)+#else+#warning Setup.hs is guessing the version of Cabal. If compilation of Setup.hs fails use -DCABAL_VERSION_MINOR=x for Cabal version 1.x.0 when building (prefixed by --ghc-option= when using the 'cabal' command)+#if (__GLASGOW_HASKELL__ >= 612)+#define CABAL_VERSION CABAL_VERSION_ENCODE(1,8,0)+#else+#define CABAL_VERSION CABAL_VERSION_ENCODE(1,6,0)+#endif+#endif++-- | Build a Gtk2hs package.+--+module Gtk2HsSetup ( gtk2hsUserHooks, getPkgConfigPackages ) where++import Distribution.Simple+import Distribution.Simple.PreProcess+import Distribution.InstalledPackageInfo ( importDirs )+import Distribution.Simple.PackageIndex (+#if CABAL_VERSION_CHECK(1,8,0)+  lookupInstalledPackageId+#else+  lookupPackageId+#endif+  )+import Distribution.PackageDescription as PD ( PackageDescription(..),+                                               updatePackageDescription,+                                               BuildInfo(..),+                                               emptyBuildInfo, allBuildInfo,+                                               Library(..),+                                               libModules)+import Distribution.Simple.LocalBuildInfo (LocalBuildInfo(..),+                                           InstallDirs(..),+#if CABAL_VERSION_CHECK(1,8,0)+                                           componentPackageDeps,+#else+                                           packageDeps,+#endif+                                           absoluteInstallDirs)+import Distribution.Simple.Compiler  ( Compiler(..) )+import Distribution.Simple.Program (+  Program(..), ConfiguredProgram(..),+  rawSystemProgramConf, rawSystemProgramStdoutConf,+  c2hsProgram, pkgConfigProgram,+  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)+import Distribution.Simple.BuildPaths ( autogenModulesDir )+import Distribution.Text ( simpleParse, display )+import System.FilePath+import System.Directory ( doesFileExist )+import Distribution.Version (Version(..))+import Distribution.Verbosity+import Control.Monad (unless)+import Data.Maybe (fromMaybe)+import Data.List (isPrefixOf, isSuffixOf, nub)+import Data.Char (isAlpha)+import qualified Data.Map as M+import qualified Data.Set as S+++-- the name of the c2hs pre-compiled header file+precompFile = "precompchs.bin"++gtk2hsUserHooks = simpleUserHooks {+    hookedPrograms = [typeGenProgram, signalGenProgram, c2hsLocal],+    hookedPreProcessors = [("chs", ourC2hs)],+    confHook = \pd cf ->+      confHook simpleUserHooks pd cf >>= return . adjustLocalBuildInfo,+    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 -> (instHook simpleUserHooks) pd lbi uh flags >>+      installCHI pd lbi (fromFlag (installVerbosity flags)) NoCopyDest+  }++-- 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) }++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 |+#if CABAL_VERSION_CHECK(1,8,0)+                  ipi <- maybe [] (map fst . componentPackageDeps) (libraryConfig lbi),+                  dir <- maybe [] importDirs (lookupInstalledPackageId (installedPkgs lbi) ipi) ]+#else+                  ipi <- packageDeps lbi,+                  dir <- maybe [] importDirs (lookupPackageId (installedPkgs lbi) ipi) ]+#endif+  rawSystemProgramConf verbosity c2hsLocal (withPrograms lbi) $+       map ("--include=" ++) (outDir:chiDirs)+    ++ ["--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"]++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])+                 (map toFilePath+#if CABAL_VERSION_CHECK(1,8,0)+                   (PD.libModules lib)+#else+                   (PD.libModules pkg)+#endif+                 )+  let files = [ f | Just f <- mFiles ]+#if CABAL_VERSION_CHECK(1,8,0)+  installOrdinaryFiles verbosity libPref files+#else+  copyFiles verbosity libPref files+#endif++  +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")++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 major ++ "." ++ show digit+                          | digit <- [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++  (flip mapM_) (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++--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 "<no file>" . 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)
+ Setup.hs view
@@ -0,0 +1,7 @@+-- Setup file for a Gtk2Hs module. Contains only adjustments specific to this module,+-- all Gtk2Hs-specific boilerplate is stored in Gtk2HsSetup.hs which should be kept+-- identical across all modules.+import Gtk2HsSetup ( gtk2hsUserHooks )+import Distribution.Simple ( defaultMainWithHooks )++main = defaultMainWithHooks gtk2hsUserHooks
+ demo/Makefile view
@@ -0,0 +1,13 @@++PROGS  = pdfviewer+SOURCES = PdfViewer.hs++all : $(PROGS)++pdfviewer : PdfViewer.hs+	$(HC) --make $< -o $@ $(HCFLAGS)++clean:+	rm -f $(SOURCES:.hs=.hi) $(SOURCES:.hs=.o) $(PROGS)++HC=ghc
+ demo/PdfViewer.hs view
@@ -0,0 +1,138 @@+-- | PDF viewer demo+--  Author      :  Andy Stewart+--  Copyright   :  (c) 2010 Andy Stewart <lazycat.manatee@gmail.com>++-- | The PDF viewer base on poppler library.+--+-- Usage:+--      pdfviewer file+--++module Main where++import Control.Applicative+import Control.Concurrent.STM+import Control.Monad+import Data.Maybe+import Graphics.Rendering.Cairo+import Graphics.UI.Gtk+import Graphics.UI.Gtk.Gdk.EventM+import Graphics.UI.Gtk.Poppler.Document+import Graphics.UI.Gtk.Poppler.Page+import System.Environment +import System.Process++data Viewer =+    Viewer {viewerArea          :: DrawingArea+           ,viewerDocument      :: Document+           ,viewerScrolledWindow:: ScrolledWindow+           ,viewerPage          :: TVar Int}++-- | Main entry.+main :: IO ()+main = do+  -- Get program arguments.+  args <- getArgs+  case args of+    -- Display help+    ["--help"] -> +       putStrLn $ "PDF viewer demo. \n\n" ++ +                  "Usage: pdfviewer file\n\n"+    -- Start program.+    [arg]    -> viewerMain arg+    _        -> putStrLn "Usage: pdfviewer file"++-- | Internal browser fucntion.+viewerMain :: FilePath -> IO ()+viewerMain file = do+  -- Init.+  initGUI+  +  -- Create window.+  window <- windowNew+  windowSetDefaultSize window 600 780+  windowSetPosition window WinPosCenter++  -- Create window box.+  windowBox <- vBoxNew False 0+  window `containerAdd` windowBox++  -- Create viewer.+  viewer <- viewerNew file+  let area = viewerArea viewer+      doc  = viewerDocument viewer+      sWin = viewerScrolledWindow viewer++  -- Set title.+  title <- get doc documentTitle +  windowSetTitle window ("PdfViewer " ++ title)++  -- Create spin button to select page.+  pages <- documentGetNPages doc -- get maximum page+  spinButton <- spinButtonNewWithRange 0 (integralToDouble pages) 1.0++  -- Redraw viewer after change value of spin button.+  afterValueSpinned spinButton $ do+    page <- spinButtonGetValue spinButton+    writeTVarIO (viewerPage viewer) (truncate page)+    widgetQueueDraw area++  -- Show.+  boxPackStart windowBox sWin PackGrow 0+  boxPackStart windowBox spinButton PackNatural 0+  window `onDestroy` mainQuit+  widgetShowAll window++  mainGUI++viewerNew :: FilePath -> IO Viewer+viewerNew file = do+  area <- drawingAreaNew+  doc  <- liftM (fromMaybe (error "Error when open pdf file.")) (documentNewFromFile ("file://" ++ file) Nothing)+  sWin <- scrolledWindowNew Nothing Nothing+  page <- newTVarIO 0++  let viewer = Viewer area doc sWin page++  scrolledWindowAddWithViewport sWin area+  scrolledWindowSetPolicy sWin PolicyAutomatic PolicyAutomatic++  area `on` exposeEvent $ tryEvent $ viewerDraw viewer                    ++  return viewer++viewerDraw :: Viewer -> EventM EExpose ()+viewerDraw viewer = do+  let doc = viewerDocument viewer+      area = viewerArea viewer+  (winWidth, winHeight) <- eventWindowSize                    +  liftIO $ do+    pageNumber <- readTVarIO $ viewerPage viewer+    page       <- documentGetPage doc pageNumber+    frameWin   <- widgetGetDrawWindow area+    (docWidth, docHeight) <- pageGetSize page+    widgetSetSizeRequest area (truncate docWidth) (truncate docHeight)++    renderWithDrawable frameWin $ do +      setSourceRGB 1.0 1.0 1.0+      rectangle 0.0 0.0 winWidth winHeight+      fill+      let scaleX = winWidth / docWidth +      scale scaleX scaleX+      pageRender page++eventWindowSize :: EventM EExpose (Double, Double)      +eventWindowSize = do+    dr    <- eventWindow+    (w,h) <- liftIO $ drawableGetSize dr+    return $ if w * h > 1+               then (fromIntegral w, fromIntegral h)+               else (1,1)++-- | Transform Int to Doube+integralToDouble :: Integral a => a -> Double+integralToDouble v = fromIntegral v :: Double++-- | The IO version of `writeTVar`.+writeTVarIO :: TVar a -> a -> IO ()+writeTVarIO a b = atomically $ writeTVar a b
+ hierarchy.list view
@@ -0,0 +1,357 @@+# 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, <query_func>'.  In case this+# function is not specified, the <name> is converted to+# gtk_<name'>_get_type where <name'> is <name> 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 <tag>'. Such types are only produces if+# --tag=<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+        GtkObject+            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++# For poppler+        PopplerDocument as Document, poppler_document_get_type if poppler+        PopplerIndexIter as IndexIter, poppler_index_iter_get_type if poppler+        PopplerFontsIter as FontsIter, poppler_fonts_iter_get_type if poppler+        PopplerPage as Page, poppler_page_get_type if poppler+        PopplerDest as Dest, poppler_dest_get_type if poppler+        PopplerFormField as FormField, poppler_form_field_get_type if poppler+        PopplerPSFile as PSFile, poppler_ps_file_get_type if poppler+        PopplerPageTransition as PageTransition, poppler_page_transition_get_type if poppler+        PopplerLinkMapping as LinkMapping, poppler_link_mapping_get_type if poppler+        PopplerImageMapping as ImageMapping, poppler_image_mapping_get_type if poppler+        PopplerFormFieldMapping as FormFieldMapping, poppler_form_field_mapping_get_type if poppler+        PopplerFontInfo as FontInfo, poppler_font_info_get_type if poppler+        PopplerAttachment as Attachment, poppler_attachment_get_type if poppler+        PopplerAction as Action, poppler_action_get_type if poppler+        PopplerLayer as Layer, poppler_layer_get_type if poppler
+ poppler.cabal view
@@ -0,0 +1,64 @@+Name:           poppler+Version:        0.11.0+License:        GPL-2+License-file:   COPYING+Copyright:      (c) 2001-2010 The Gtk2Hs Team+Author:         Andy Stewart+Maintainer:     gtk2hs-users@sourceforge.net+Build-Type:     Custom+Cabal-Version:  >= 1.6+Stability:      stable+homepage:       http://www.haskell.org/gtk2hs/+bug-reports:    http://hackage.haskell.org/trac/gtk2hs/+Synopsis:       Binding to the Poppler.+Description:    Poppler is a fork of the xpdf PDF viewer, to provide PDF rendering functionality as a shared+                library, to centralize the maintenance effort.+				And move to forward in a number of areas that don't fit within the goals of xpdf.+Category:       Graphics+Tested-With:    GHC == 6.12.3+Extra-Source-Files: Gtk2HsSetup.hs+					hierarchy.list+					template-hsc-gtk2hs.h++x-Types-File:      Graphics/UI/Gtk/Poppler/Types.chs+x-Types-ModName:   Graphics.UI.Gtk.Poppler.Types+x-Types-Import:    System.Glib.GObject+x-Types-Lib:       poppler+x-Types-Prefix:    poppler+x-Types-Tag:       poppler+x-Types-Hierarchy: hierarchy.list++Data-Dir:		demo+Data-Files:		PdfViewer.hs+                Makefile++Source-Repository head+  type:         darcs+  location:     http://patch-tag.com/r/AndyStewart/poppler++Library+        build-depends:  base >= 4 && < 5, array, containers, haskell98, mtl, bytestring,+                        glib >= 0.11 && < 0.12,+                        cairo >= 0.11 && < 0.12,+                        gtk >= 0.11 && < 0.12+						+        build-tools:    gtk2hsC2hs, gtk2hsHookGenerator, gtk2hsTypeGen+						+        exposed-modules:+          Graphics.UI.Gtk.Poppler.Action+          Graphics.UI.Gtk.Poppler.Attachment+          Graphics.UI.Gtk.Poppler.Document+          Graphics.UI.Gtk.Poppler.FormField+          Graphics.UI.Gtk.Poppler.Layer+          Graphics.UI.Gtk.Poppler.Page+          Graphics.UI.Gtk.Poppler.Poppler+        other-modules:+          Graphics.UI.Gtk.Poppler.Enums+          Graphics.UI.Gtk.Poppler.Structs+          Graphics.UI.Gtk.Poppler.Types++        extensions:     ForeignFunctionInterface+		+        include-dirs:   .+        x-c2hs-Header:  glib/poppler.h+        pkgconfig-depends: poppler-glib >= 0.14.0, gobject-2.0, glib-2.0, cairo >= 1.2.0, gdk-2.0, gdk-pixbuf-2.0, pango
+ template-hsc-gtk2hs.h view
@@ -0,0 +1,17 @@+#ifndef _TEMPLATE_HSC_GTK2HS_H_+#define _TEMPLATE_HSC_GTK2HS_H_++#include <glib.h>++#define hsc_gtk2hs_type(t)                        \+  if ((t)(int)(t)1.4 == (t)1.4)                   \+    printf ("%s%" G_GSIZE_FORMAT,                 \+      (t)(-1) < (t)0 ? "Int" : "Word",            \+            sizeof (t) * 8);                      \+  else                                            \+    printf ("%s",                                 \+      sizeof (t) >  sizeof (double) ? "LDouble" : \+      sizeof (t) == sizeof (double) ? "Double"  : \+            "Float");++#endif