From 2156684ec24e53717016fffa2963631ce75b6b9c Mon Sep 17 00:00:00 2001 From: Taybin Rutkin Date: Sat, 3 Feb 2007 04:18:37 +0000 Subject: [PATCH] Added cairomm-1.2.4. git-svn-id: svn://localhost/ardour2/branches/2.1-staging@1417 d708f5d6-7413-0410-9779-e7cbd77b26cf --- libs/cairomm/AUTHORS | 10 + libs/cairomm/COPYING | 481 +++++++++++++ libs/cairomm/ChangeLog | 724 ++++++++++++++++++++ libs/cairomm/MAINTAINERS | 8 + libs/cairomm/NEWS | 81 +++ libs/cairomm/README | 13 + libs/cairomm/SConscript | 22 + libs/cairomm/cairomm-1.0.pc.in | 12 + libs/cairomm/cairomm/cairomm.h | 43 ++ libs/cairomm/cairomm/context.cc | 669 ++++++++++++++++++ libs/cairomm/cairomm/context.h | 931 ++++++++++++++++++++++++++ libs/cairomm/cairomm/enums.h | 201 ++++++ libs/cairomm/cairomm/exception.cc | 49 ++ libs/cairomm/cairomm/exception.h | 46 ++ libs/cairomm/cairomm/fontface.cc | 74 ++ libs/cairomm/cairomm/fontface.h | 79 +++ libs/cairomm/cairomm/fontoptions.cc | 159 +++++ libs/cairomm/cairomm/fontoptions.h | 81 +++ libs/cairomm/cairomm/path.cc | 98 +++ libs/cairomm/cairomm/path.h | 72 ++ libs/cairomm/cairomm/pattern.cc | 219 ++++++ libs/cairomm/cairomm/pattern.h | 189 ++++++ libs/cairomm/cairomm/private.cc | 76 +++ libs/cairomm/cairomm/private.h | 50 ++ libs/cairomm/cairomm/refptr.h | 391 +++++++++++ libs/cairomm/cairomm/scaledfont.cc | 104 +++ libs/cairomm/cairomm/scaledfont.h | 153 +++++ libs/cairomm/cairomm/surface.cc | 382 +++++++++++ libs/cairomm/cairomm/surface.h | 631 +++++++++++++++++ libs/cairomm/cairomm/win32_surface.cc | 59 ++ libs/cairomm/cairomm/win32_surface.h | 96 +++ libs/cairomm/cairomm/xlib_surface.cc | 137 ++++ libs/cairomm/cairomm/xlib_surface.h | 148 ++++ 33 files changed, 6488 insertions(+) create mode 100644 libs/cairomm/AUTHORS create mode 100644 libs/cairomm/COPYING create mode 100644 libs/cairomm/ChangeLog create mode 100644 libs/cairomm/MAINTAINERS create mode 100644 libs/cairomm/NEWS create mode 100644 libs/cairomm/README create mode 100644 libs/cairomm/SConscript create mode 100644 libs/cairomm/cairomm-1.0.pc.in create mode 100644 libs/cairomm/cairomm/cairomm.h create mode 100644 libs/cairomm/cairomm/context.cc create mode 100644 libs/cairomm/cairomm/context.h create mode 100644 libs/cairomm/cairomm/enums.h create mode 100644 libs/cairomm/cairomm/exception.cc create mode 100644 libs/cairomm/cairomm/exception.h create mode 100644 libs/cairomm/cairomm/fontface.cc create mode 100644 libs/cairomm/cairomm/fontface.h create mode 100644 libs/cairomm/cairomm/fontoptions.cc create mode 100644 libs/cairomm/cairomm/fontoptions.h create mode 100644 libs/cairomm/cairomm/path.cc create mode 100644 libs/cairomm/cairomm/path.h create mode 100644 libs/cairomm/cairomm/pattern.cc create mode 100644 libs/cairomm/cairomm/pattern.h create mode 100644 libs/cairomm/cairomm/private.cc create mode 100644 libs/cairomm/cairomm/private.h create mode 100644 libs/cairomm/cairomm/refptr.h create mode 100644 libs/cairomm/cairomm/scaledfont.cc create mode 100644 libs/cairomm/cairomm/scaledfont.h create mode 100644 libs/cairomm/cairomm/surface.cc create mode 100644 libs/cairomm/cairomm/surface.h create mode 100644 libs/cairomm/cairomm/win32_surface.cc create mode 100644 libs/cairomm/cairomm/win32_surface.h create mode 100644 libs/cairomm/cairomm/xlib_surface.cc create mode 100644 libs/cairomm/cairomm/xlib_surface.h diff --git a/libs/cairomm/AUTHORS b/libs/cairomm/AUTHORS new file mode 100644 index 0000000000..2c4d00679a --- /dev/null +++ b/libs/cairomm/AUTHORS @@ -0,0 +1,10 @@ +Please do not email us directly - use the mailing list. +See http://cairographics.org/lists + +Maintainers: +---------- +Murray Cumming +Jonathon Jongsma + +Based on code from Leonard Ritter. + diff --git a/libs/cairomm/COPYING b/libs/cairomm/COPYING new file mode 100644 index 0000000000..f5030495bf --- /dev/null +++ b/libs/cairomm/COPYING @@ -0,0 +1,481 @@ + GNU LIBRARY GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 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 library GPL. It is + numbered 2 because it goes with version 2 of the ordinary GPL.] + + 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 Library General Public License, applies to some +specially designated Free Software Foundation software, and to any +other libraries whose authors decide to use it. You can use it for +your libraries, too. + + When we speak of free software, we are referring to freedom, 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 or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the 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 a program 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. + + Our method of protecting your rights has two steps: (1) copyright +the library, and (2) offer you this license which gives you legal +permission to copy, distribute and/or modify the library. + + Also, for each distributor's protection, we want to make certain +that everyone understands that there is no warranty for this free +library. If the library is modified by someone else and passed on, we +want its recipients to know that what they have is not the original +version, so that any problems introduced by others will not reflect on +the original authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that companies distributing free +software will individually obtain patent licenses, thus in effect +transforming the program into proprietary software. To prevent this, +we have made it clear that any patent must be licensed for everyone's +free use or not licensed at all. + + Most GNU software, including some libraries, is covered by the ordinary +GNU General Public License, which was designed for utility programs. This +license, the GNU Library General Public License, applies to certain +designated libraries. This license is quite different from the ordinary +one; be sure to read it in full, and don't assume that anything in it is +the same as in the ordinary license. + + The reason we have a separate public license for some libraries is that +they blur the distinction we usually make between modifying or adding to a +program and simply using it. Linking a program with a library, without +changing the library, is in some sense simply using the library, and is +analogous to running a utility program or application program. However, in +a textual and legal sense, the linked executable is a combined work, a +derivative of the original library, and the ordinary General Public License +treats it as such. + + Because of this blurred distinction, using the ordinary General +Public License for libraries did not effectively promote software +sharing, because most developers did not use the libraries. We +concluded that weaker conditions might promote sharing better. + + However, unrestricted linking of non-free programs would deprive the +users of those programs of all benefit from the free status of the +libraries themselves. This Library General Public License is intended to +permit developers of non-free programs to use free libraries, while +preserving your freedom as a user of such programs to change the free +libraries that are incorporated in them. (We have not seen how to achieve +this as regards changes in header files, but we have achieved it as regards +changes in the actual functions of the Library.) The hope is that this +will lead to faster development of free libraries. + + 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, while the latter only +works together with the library. + + Note that it is possible for a library to be covered by the ordinary +General Public License rather than by this special one. + + GNU LIBRARY GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library which +contains a notice placed by the copyright holder or other authorized +party saying it may be distributed under the terms of this Library +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 compile 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) 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. + + c) 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. + + d) 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 source code 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 to +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 Library General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/libs/cairomm/ChangeLog b/libs/cairomm/ChangeLog new file mode 100644 index 0000000000..c78ed89c0a --- /dev/null +++ b/libs/cairomm/ChangeLog @@ -0,0 +1,724 @@ +1.2.4: + +2007-01-17 Jonathon Jongsma + + * NEWS: updated news for 1.2.4 release + * configure.in: bumped version to 1.2.4 + +2006-09-27 Murray Cumming + + * cairomm/refptr.h: cast_static() and cast_dynamic(): + Use the refcount_() accessor instead of the member variable, + to avoid compilation errors, as we already do in the + templated copy constructor. + +1.2.2: + +2006-08-21 Jonathon Jongsma + + * NEWS: update for 1.2.2 + * configure.in: bump to next even number (1.2.2) + +2006-08-21 Cedric Gustin + + * cairomm/win32_surface.cc: Explicitly cast Cairo::Format to + cairo_format_t. + +2006-08-20 Jonathon Jongsma + + * Makefile.am: fix up the release announcement template to explain what + cairomm is at the top of the email before telling where to get it. + * configure.in: post-release bump (1.2.1) + +1.2.0: + +2006-08-20 Jonathon Jongsma + + * NEWS: Update information about new stuff in 1.2.0 + * configure.in: bump the release version number to 1.2.0 and the shared + library version number to 1:0:0 since interfaces were changed and added and + we're now guaranteeing API/ABI stability + +2006-08-20 Jonathon Jongsma + + * examples/pdf-surface/.cvsignore: + * examples/png_file/.cvsignore: + * examples/ps-surface/.cvsignore: + * examples/svg-surface/.cvsignore: added image files produced by the example + programs to .cvsignore + +2006-08-19 Jonathon Jongsma + + * Makefile.am: get rid of the concept of a snapshot. It doesn't really make + that much sense for cairomm, honestly, since we're just a simple wrapper + library. + +2006-08-19 Jonathon Jongsma + + * MSVC/examples/.cvsignore: + * MSVC/examples/Makefile.am: + * MSVC/examples/pdf-surface/.cvsignore: + * MSVC/examples/pdf-surface/Makefile.am: + * MSVC/examples/pdf-surface/pdf-surface.vcproj: + * MSVC/examples/png_file/.cvsignore: + * MSVC/examples/png_file/Makefile.am: + * MSVC/examples/png_file/png_file.vcproj: + * MSVC/examples/ps-surface/.cvsignore: + * MSVC/examples/ps-surface/Makefile.am: + * MSVC/examples/ps-surface/ps-surface.vcproj: + * MSVC/examples/svg-surface/.cvsignore: + * MSVC/examples/svg-surface/Makefile.am: + * MSVC/examples/svg-surface/svg-surface.vcproj: + * MSVC/examples/text-rotate/.cvsignore: + * MSVC/examples/text-rotate/Makefile.am: + * MSVC/examples/text-rotate/text-rotate.vcproj: + * MSVC/gendef/.cvsignore: + * MSVC/gendef/Makefile.am: + * MSVC/gendef/gendef.cc: + * MSVC/gendef/gendef.vcproj: added a bunch of MSVC / windows-specific things + that got missed last time. + +2006-08-18 Jonathon Jongsma + + * cairomm/win32_surface.cc: + * cairomm/win32_surface.h: add some missing win32 API that I had overlooked: + cairo_win32_surface_get_dc() and cairo_win32_surface_create_with_dib(), + updated documentation for standard Win32Surface::create() function. + +2006-08-18 Cedric Gustin + + * cairomm/context.cc: Define M_PI for MSVC. + * cairomm/scaledfont.cc: Allocate glyph_array as a synamic array + as MSVC does not like non-const arguments as array size. + * examples/pdf-surface/main.cc, examples/png_file/main.cc, + examples/ps-surface/main.cc, examples/svg-surface/main.cc, + examples/text-rotate/text-rotate.cc: Define M_PI for MSVC. + * configure.in, Makefile.am: Generate Makefiles in the MSVC + subdirectories. + * .cvsignore: Added Eclipse .project to the list of ignored files. + * MSVC/*: Added project and resource files for Visual Studio 2005. + +2006-08-18 Jonathon Jongsma + + * cairomm/context.cc: + * cairomm/context.h: API CHANGE: some API was changed to maintain a closer + similarity to the underlying cairo API (while also attempting to avoid + confusion with the C++ 'new' keyword) in preparation for freezing the + cairomm API. Two functions are affected: + - Context::clear_path() -> Context::begin_new_path() + - Context::new_sub_path() -> Context::begin_new_sub_path() + * configure.in: bump the libtool version to indicate API change + +2006-08-15 Jonathon Jongsma + + * cairomm/context.cc: remove another TODO. I looked at cairo_append_path, + and it just copies the data from the supplied path and appends that to the + current path -- it doesn't modify the passed in path -- so it can stay + const. + +2006-08-15 Jonathon Jongsma + + * cairomm/context.h: remove a FIXME that was resolved on the mailing list + +2006-07-11 Murray Cumming + + * cairomm/refptr.h: unref(): Only delete the refcount int when the refcount has + reached 0, instead of deleting it every time. Thanks valgrind. + +2006-07-11 Murray Cumming + + * cairomm/refptr.h: From-C-object Constructor: Added documentation explaining + how/when to use it and when to do an extra reference(). This will help us, + though it should rarely be necessary for an application developer to understand + it. + Made pCppRefcount_ mutable, so that refcount_() can be a const method so that + the templated constructor compiles. + Added class documentation to explain why we even want to use this class. + +2006-07-05 Jonathon Jongsma + + * cairomm/refptr.h: copy constructors: initialize the pCppRefcount_ member + variable, using a public refcount_() method when necessary to access a + different RefPtr<> specialization. + +2006-07-11 Murray Cumming + + * cairomm/refptr.h: Use an int to reference-count the C++ object, and + only reference/unreference the object (and hence the underlying C object) + when receiving/deleting the C++ object. Without this, we never delete + the C++ object. Fixes bug #7442. + +2006-07-09 Jonathon Jongsma + + * NEWS: add NEWS for 1.1.10 release + * configure.in: bump version to 1.1.12 + +2006-07-05 Jonathon Jongsma + + * Makefile.am: Ooops, I had accidentally removed dependency info for + release-publish target + +2006-07-05 Murray Cumming + + * cairomm/context.h: + * cairomm/fontface.h: + * cairomm/pattern.h: + * cairomm/surface.cc: + * cairomm/surface.h: + * cairomm/xlib_surface.cc: + * cairomm/xlib_surface.h: Fix the generic text about reference-counted + objects, because we no longer use copy constructors for this. And some + pedantic white space changes. + +2006-07-05 Murray Cumming + + * cairomm/scaledfont.cc: + * cairomm/scaledfont.h: create(): Make the font_matrix and ctm + parameters const (they are now const in the C API too). Maybe the font + parameter should be const, but maybe there is a reason that it is not + const in the C API. Pass FontOptions by const reference instead of + by value. + glyph_extents(): Pass the vector by const reference instead of by + value. + I would prefere to make all the extents() functions use return values + instead of output parameters, but I suppose this might be slightly + less efficient in some circumstances. + +2006-07-05 Murray Cumming + + * cairomm/cairomm.h: + * cairomm/context.h: + * cairomm/path.h: + * cairomm/scaledfont.h: + * cairomm/surface.h: + * cairomm/win32_surface.h: + * cairomm/xlib_surface.h: Use @ instead of \ for doxygen + commands, to be consistent with gtkmm, which uses it because it is the + same as JavaDoc, with which some people are already familiar. + +2006-07-04 Jonathon Jongsma + + * Makefile.am: add ability to do snapshot releases to the + cairographics.org/snapshots/ directory in addition to official releases + * configure.in: bumped the revision to 1.1.10 in preparation for a snapshot + release of the 1.2 API + * docs/reference/Makefile.am: fixed some distcheck errors + +2006-07-04 Jonathon Jongsma + + * .cvsignore, cairomm/.cvsignore: ignore some autotools files and *.swp + files (from vim) + +2006-07-04 Jonathon Jongsma + + * cairomm/scaledfont.cc, cairomm/scaledfont.h: wrap ScaledFont, including + new API for cairo 1.2 + * cairomm/Makefile.am: add scaledfont.* to list of sources + +2006-07-04 Jonathon Jongsma + + * cairomm/surface.h: Remove comments stating that PDF, PS, and SVG are + experimental surfaces. As of 1.2.0, these three surfaces are officially + supported by the cairo library. + +2006-07-04 Jonathon Jongsma + + * cairomm/xlib_surface.h: add a bit more documentation for the new + XlibSurface API + +2006-07-04 Jonathon Jongsma + + * cairomm/surface.cc, cairomm/surface.h: added SvgSurface::get_versions() + and SvgSurface::version_to_string() API. They're implemented as static + members right now. + +2006-06-30 Jonathon Jongsma + + * configure.in: bumped cairomm version to 0.7.0 and bumped cairo requirement + to 1.2.0 + +2006-06-30 Jonathon Jongsma + + * cairomm/xlib_surface.cc, cairomm/xlib_surface.h: add new get_height() and + get_width() API to XlibSurface + +2006-06-27 Jonathon Jongsma + + * cairomm/enums.h: Added enum types to support the new get_type() and SVG + Version API + * cairomm/fontface.cc, cairomm/fontface.h: add new get_type() API + * cairomm/pattern.cc, cairomm/pattern.h: add new get_type() API + * cairomm/surface.cc, cairomm/surface.h: add new get_type() API and + SvgSurface::restrict_to_version() API + +2006-06-26 Jonathon Jongsma + + * cairomm/surface.cc, cairomm/surface.h: add new PsSurface and PdfSurface + API: set_size, dsc_comment, dsc_begin_setup, dsc_begin_page_setup + * cairomm/xlib_surface.cc, cairomm/xlib_surface.h: add new XlibSurface API: + get_display, get_drawable, get_screen, get_visual, get_depth + +2006-06-26 Jonathon Jongsma + + * cairomm/surface.cc: + * cairomm/surface.h: Added new Surface and ImageSurface API from 1.1.x + snapshots + +2006-06-23 Jonathon Jongsma + + * cairomm/context.cc: + * cairomm/context.h: added Context::new_sub_path() and new push/pop group + API. + +2006-06-23 Jonathon Jongsma + + * cairomm/enums.h: fix stupid error from last commit + +2006-06-23 Jonathon Jongsma + + * cairomm/enums.h: add new FORMAT_RGB16_565 format + +2006-06-12 Jonathon Jongsma + + * configure.in: bump required cairo version to >= 1.1.7 + * cairomm/surface.cc, cairomm/surface.h: update to new cairo API + cairo_surface_set_fallback_resolution + +2006-05-10 Jonathon Jongsma + + * docs/reference/cairomm.css: minor documentation stylesheet fix + +2006-05-08 Jonathon Jongsma + + * cairomm/context.h: + * cairomm/path.h: added some preliminary documentation explaining that the + caller is responsible for freeing Path objects returned from + Context::copy_path() and Context::copy_path_flat(). + +2006-05-08 Jonathon Jongsma + + * cairomm/cairomm.h: Add doxygen API introduction test here. + * docs/reference/Doxyfile.in: + * docs/reference/Makefile.am: + * docs/reference/cairomm-header.html: + * docs/reference/cairomm.css: + * docs/reference/introduction.h: fix up some documentation presentation + issues that turned up with newer versions of doxygen. + +2006-05-08 Jonathon Jongsma + + * configure.in: remove check for perl since we're not using any of the + gmmproc stuff for cairomm + * docs/reference/Makefile.am: add documentation dependency on all of the + headers in the cairomm/ directory so that if a header changes the + documentation will be rebuilt. + +2006-04-20 Murray Cumming + + * cairomm/context.cc: + * cairomm/context.h: mask(pattern) and mask(surface): Make the parameter + const, because I am fairly sure that the C function does not change it. + +2006-04-06 Jonathon Jongsma + + * Makefile.am: Add a brief description of cairomm to the release + announcement template + +2006-04-04 Jonathon Jongsma + + * docs/reference/Doxyfile.in: + * docs/reference/Makefile.am: A couple minor build fixes to make distcheck + happy + +2006-04-04 Jonathon Jongsma + + * NEWS: add news for 0.6.0 release + * configure.in: bump version to 0.6.0 + +2006-04-03 Jonathon Jongsma + + * examples/text-rotate/text-rotate.cc: protect PNG functions with #ifdef in + case cairo wasn't compiled with PNG support + +2006-03-31 Danilo Piazzalunga + + * Makefile.am: + * docs/Makefile.am: + * docs/reference/Makefile.am: add convenience targets for cleaning and + rebuilding documentation (doc-clean and doc-rebuild). + +2006-03-30 Danilo Piazzalunga + + * configure.in: enable documentation even if doxygen and/or graphviz + are missing, so the docs will be installed when building a release. + * docs/reference/Makefile.am: don't remove html directory with `make clean`, + so that users of the tarball releases don't destroy the pre-built + documentation when running make clean. Change to maintainer-clean + +2006-03-29 Jonathon Jongsma + + * configure.in: added tests for doxygen and graphviz which displays a + warning if the user has --enable-docs set but doesn't have doxygen or + graphviz installed. + +2006-03-28 Danilo Piazzalunga + + * cairomm/enums.h: Stop using CAIRO_EXTEND_PAD, as it only exists + in the 1.1.1 development branch. + +2006-03-14 Jonathon Jongsma + + * configure.in: + * examples/Makefile.am: + * examples/text-rotate/.cvsignore: + * examples/text-rotate/Makefile.am: + * examples/text-rotate/text-rotate.cc: Added another basic example, + borrowed from a test-case in cairo. This one is just a simple example of + using text in cairomm + +2006-03-14 Jonathon Jongsma + + * cairomm/fontface.h: + * cairomm/fontoptions.h: + * cairomm/path.h: + * cairomm/pattern.h: include instead of since it + didn't want to compile on windows without these + * cairomm/win32_surface.cc: + * cairomm/win32_surface.h: Move the include of cairo-win32.h from the + source file to the header since the declaration of create() needs the HDC + type definition. + With these changes, cairomm should compile the Win32Surface cleanly with + mingw on Microsoft Windows + +2006-03-12 Danilo Piazzalunga + + * autogen.sh: Allow overriding aclocal, automake, autoconf and libtoolize + using environment variables. Taken from cairo's autogen.sh. + +2006-03-06 Jonathon Jongsma + + * cairomm/*.cc, *.h: add vim modelines to set proper indentation for + cairomm when using vim + +2006-02-28 Jonathon Jongsma + + * cairomm/context.cc: + * cairomm/context.h: + * cairomm/enums.h: + * cairomm/fontoptions.cc: + * cairomm/fontoptions.h: + * cairomm/pattern.cc: + * cairomm/pattern.h: + * cairomm/surface.h: wrapped all of the enum types with cairomm + types within the Cairo namespace, so now (for example) the values for + Cairo::Format are something like Cairo::FORMAT_ARGB32 instead of the base + cairo types like CAIRO_FORMAT_ARGB_32. + * examples/png_file/main.cc: fixed example to work with the new namespaced + enum types + +2006-02-27 Jonathon Jongsma + + * cairomm/exception.h: + * docs/reference/Doxyfile.in: + * docs/reference/Makefile.am: hide some of the private types and functions + from the Doxygen API reference documentation + +2006-02-27 Stefan Kersten + + * cairomm/surface.cc: fix an extra trailing parentheses in + GlitzSurface::create() + +2006-02-22 Danilo Piazzalunga + + * examples/README: Write some basic information about each example + +2006-02-22 Jonathon Jongsma + + * docs/reference/Makefile.am: add target for publishing the API reference + to cairographics.org + +2006-02-20 Danilo Piazzalunga + + * Makefile.am: Include MAINTAINERS in distribution. Fixes Bug #5982 + +2006-02-17 Danilo Piazzalunga + + * COPYING: Use the text from the Library GPL 2.0, which is the actual + license of cairomm. Fixes Bug #5934 + +2006-02-17 Danilo Piazzalunga + + * autogen.sh: + * cairomm/cairomm.h: + * cairomm/context.cc: + * cairomm/context.h: + * cairomm/enums.h: + * cairomm/exception.cc: + * cairomm/exception.h: + * cairomm/fontface.cc: + * cairomm/fontface.h: + * cairomm/fontoptions.cc: + * cairomm/fontoptions.h: + * cairomm/path.cc: + * cairomm/path.h: + * cairomm/pattern.cc: + * cairomm/pattern.h: + * cairomm/private.cc: + * cairomm/private.h: + * cairomm/refptr.h: + * cairomm/surface.cc: + * cairomm/surface.h: + * cairomm/win32_surface.cc: + * cairomm/win32_surface.h: + * cairomm/xlib_surface.cc: + * cairomm/xlib_surface.h: Update FSF's postal address in GPL/LGPL + comment headings. Fixes Bug #5933 + +2006-02-17 Danilo Piazzalunga + + * examples/*/.cvsignore: Bug #5927: added .cvsignore files to examples + directories + +2006-02-17 Danilo Piazzalunga + + * AUTHORS: + * INSTALL: + * README: + * cairomm/exception.cc: + * cairomm/exception.h: Remove lingering references to libxml++ + +2006-02-17 Danilo Piazzalunga + + * configure.in: Bug #5929: Output files in docs subdir only if + --enable-docs is set. This prevents configure from generating files which + are not cleaned up when --disable-docs is used. + Use AC_CONFIG_FILES and AC_OUTPUT as recommended. + +2006-02-16 Jonathon Jongsma + + * docs/reference/Doxyfile.in: + * docs/reference/cairomm.css: added some style customisations to the API + doc so that it fits in with the overall Cairo style a bit better + +2006-02-16 Jonathon Jongsma + + * AUTHORS: + * MAINTAINERS: Add my information to the Maintainers and authors file + +0.5.0: + +2006-02-09 Jonathon Jongsma + + * docs/reference/Makefile.am: added a 'html' target to satisfy the dist + rule + +2006-02-08 Jonathon Jongsma + + * cairomm/context.h: Added a lot of documentation for the Cairo::Context + class taken from the cairo docs. It's not complete, but the basics are all + covered now. + * docs/reference/Makefile.am: make use of existing Makefile variable + * NEWS: update for 0.5.0 release + +2006-02-07 Jonathon Jongsma + + * Makefile.am: add docs/ subdir + * configure.in: added an --enable-docs switch to the configure script + (enabled by default), and added AC_OUTPUT directives for the documentation + Makefiles, etc. + * docs/.cvsignore: + * docs/Makefile.am: + * docs/reference/.cvsignore: + * docs/reference/Doxyfile.in: + * docs/reference/Makefile.am: + * docs/reference/introduction.h: Added infrastructure to build and install + the API documentation for cairomm (based on libxml++ makefiles). + +2006-01-27 Jonathon Jongsma + + * .cvsignore: + * cairomm/.cvsignore: update .cvsignore files + * cairomm/surface.cc: + * cairomm/surface.h: change Surface::create function to take a + RefPtr instead of Surface& + +2006-01-27 Murray Cumming + + * examples/pdf-surface/Makefile.am: Remove extra LDADD that was breaking + the distcheck. + +2006-01-26 Murray Cumming + + * examples/ps-surface/main.cc: + * examples/svg-surface/main.cc: Correct the text of the messages. + +2006-01-25 Jonathon Jongsma + + * configure.in: + * examples/Makefile.am: + * examples/pdf-surface/: + * examples/ps-surface/: + * examples/svg-surface/: add examples for additional surfaces + +2006-01-24 Murray Cumming + + * cairomm/Makefile.am: + * cairomm/surface.cc: + * cairomm/surface.h: + * cairomm/xlib_surface.cc: + * cairomm/xlib_surface.h: + * cairomm/win32_surface.cc: + * cairomm/win32_surface.h: Moved XlibSurface and + Win32Surface into separate files, not #included by + the main cairomm.h file, so that developers do not need to + suffer the Xlib.h or Windows namespace pollution unless they really need to. + For instance, this fixes the gtkmm 2.9 build which was broken by the + Display struct in Xlib.h. + +2006-01-15 Jonathon Jongsma + + * cairomm/surface.cc: + * cairomm/surface.h: backwards-incompatible API change for the Surface + types. Cairo::Surface is now a base class for all of the other surface + types, and should not be used directly. New Surface types include + ImageSurface, XlibSurface, Win32Surface, PdfSurface, PsSurface, + SvgSurface, and GlitzSurface. + Modified Surface::write_to_png() and Surface::write_to_png_stream() so + that they throw exceptions like the other functions instead of returning a + cairo_status_t value. + Added API documentation for all Surface classes and all member functions + of the Surface class heirarchy. + * examples/png_file/Makefile.am: added generated PNG file to CLEANFILES + * examples/png_file/main.cc: updated the PNG example to use the new + ImageSurface class instead of using the Surface class directly. + * cairomm/*: Renamed the Cairo::Status type to Cairo::ErrorStatus since it + conflicts with a #define Status in XLib and is not used exposed in the API + anyway. + +2006-01-06 Jonathon Jongsma + + * cairomm/surface.cc: + * cairomm/surface.h: Added implementation of write_to_png() and + write_to_png_stream() when PNG support is available in the base cairo + library + * examples/png_file/*: Added an example of creating an image surface and + saving it to a png image file + * examples/Makefile.am: add new example directory to SUBDIRS list + * configure.in: added output declaration for examples/png_file/Makefile + * examples/makefile.am_fragment: fix leftover libxml boilerplate + +2006-01-03 Jonathon Jongsma + + * cairomm/surface.cc: added missing implementations for reference() and + unreference() functions + +0.4.0: + +2005-12-17 Murray Cumming + + * cairomm/Makefile.am: + * cairomm/refptr.h: Add shared + reference-counting smartpointer, using + the reference-count in the object. A copy + of the tried and tested glibmm RefPtr. + * cairomm/context.cc: + * cairomm/context.h: + * cairomm/fontface.cc: + * cairomm/fontface.h: + * cairomm/pattern.cc: + * cairomm/pattern.h: + * cairomm/surface.cc: + * cairomm/surface.h: Make constructors protected + and add public static create() methods that return + instances in RefPtr<>s. This allows reference-counted + objects to be clearly const or non-const, and allows + casting between related types. + +2005-12-17 Murray Cumming + + * cairomm/context.cc: + * cairomm/context.h: Change set_dash(void) to + unset_dash(). Change rotate_deg() to + rotate_degrees(). Change identity_matrix() to + set_identity_matrix(). Change new_path() to + clear_path(). + * cairomm/fontface.cc: + * cairomm/fontface.h: Comment-out + get/set_user_data(), because it seems useless. + +0.3.0: + +2005-12-08 Murray Cumming + + * cairomm/pattern.cc: + * cairomm/pattern.h: Create a hierarchy of pattern + classes, as suggested by the C documentation, because + not all functions are meaningful for all pattern types. + +2005-12-07 Murray Cumming + + * cairomm/context.cc: + * cairomm/context.h: font_extents(), stroke_extents(), + glyph_extents(), fill_extents(): Add get_ prefix and + make them const. + +2005-12-07 Murray Cumming + + * cairomm/context.cc: + * cairomm/context.h: Add typedef for Matrix, though we + probably want to derive a class with a C++-like matrix + API, with operator overloading. + +2005-12-07 Murray Cumming + + * cairomm/exception.cc: + * cairomm/exception.h: Rename to logic_error, because + the cairo documentation says that most of them are + programming errors, not runtime errors. Derive from + std::logic_error because of this. + * cairomm/private.cc: + * cairomm/private.h: Throw std::bad_alloc for memory + errors, and std::io_base::failure for read/write runtime + errors, as suggested by the cairo language-binding + documentation. + +2005-12-07 Murray Cumming + + * cairomm/context.cc: + * cairomm/fontoptions.cc: + * cairomm/surface.cc: Check for errors in + constructors, as per the error-handling advice in the + language bindings section of the cairo documentation. + +2005-12-07 Murray Cumming + + * cairomm/context.cc: + * cairomm/context.h: Change mask_surface() to + mask() and set_source_surface() to set_source(), + as per the method overloading advice in the + language bindings section of the cairo documentation. + +0.2.0: + +2005-12-02 Murray Cumming + + * cairomm/cairomm.h: Put sensible stuff in here, + instead of my copy/paste stuff from libxml++. + * cairomm/context.cc: + * cairomm/context.h: + * cairomm/enums.h: + * cairomm/exception.cc: + * cairomm/exception.h: + * cairomm/fontface.cc: + * cairomm/fontface.h: + * cairomm/fontoptions.cc: + * cairomm/fontoptions.h: + * cairomm/path.cc: + * cairomm/path.h: + * cairomm/pattern.cc: + * cairomm/pattern.h: + * cairomm/private.cc: + * cairomm/private.h: + * cairomm/surface.cc: + * cairomm/surface.h: Add LGPL comment headings. + diff --git a/libs/cairomm/MAINTAINERS b/libs/cairomm/MAINTAINERS new file mode 100644 index 0000000000..54d06c9176 --- /dev/null +++ b/libs/cairomm/MAINTAINERS @@ -0,0 +1,8 @@ +Please use the mailing list (cairo@cairographics.org) rather than emailing +developers directly. + +Murray Cumming +Email: murrayc@murrayc.com + +Jonathon Jongsma +Email: jonathon.jongsma@gmail.com diff --git a/libs/cairomm/NEWS b/libs/cairomm/NEWS new file mode 100644 index 0000000000..f30a2c5a9e --- /dev/null +++ b/libs/cairomm/NEWS @@ -0,0 +1,81 @@ +1.2.4: + + * Fixed an error that prevented Cairo::RefPtr<>::cast_static() and + Cairo::RefPtr<>::cast_dynamic() from compiling. + +1.2.2: + +* Fixed an issue when compiling on windows with MSVC + +1.2.0: + +* This is the first release that guarantees API and ABI stability +* Changed API: + - Context::clear_path() is now Context::begin_new_path() + - Context::new_sub_path() is now Context::begin_new_sub_path() +* new API: + - Win32Surface::get_dc() + - Win32Surface::create() for device-independent bitmaps +* Bugfixes + - fixed a memory leak where C++ wrapper objects were not being destroyed +* Fixes for compiling with MSVC (also includes project and resource files for + Visual Studio 2005. See the MSVC/ directory) + +1.1.10: + +* API: + - Wrap new API from cairo 1.2 + - Wrap ScaledFont +* Improved Documentation +* Build fixes + +0.6.0: + +* API: + - enumerations are now wrapped within the Cairo namespace. So, for example, + CAIRO_FORMAT_ARGB32 becomes Cairo::FORMAT_ARGB32 +* Examples: added simple text example translated from Cairo. +* Bugfixes for the Glitz and Windows backends. +* Build and installation improvements (Danilo Piazzalunga) + +0.5.0: + +* Surface: + - Created derived classes for PDF, PS, SVG, Glitz, + X11 and Win32 surfaces, which are only available if your copy + of cairo supports those surfaces. The X11 and Win32 Surface headers + must be #included explicitly. + (Jonathon Jongsma) + - Added write_to_png() and write_to_png_stream(), available when PNG + support is available in Cairo. + (Jonathon Jongsma) +* Examples: Added PNG, PDF, PS, and SVG Surface examples. + (Jonathon Jongsma) +* Added API documentation generation with doxygen (Jonathon Jongsma) + +0.4.0: + +* Add Cairo::RefPtr<> and use all reference-counted + objects via it. Use the static create() methods + instead of new for these classes. +* Context: + - Change set_dash(void) to unset_dash(). + - Change rotate_deg() to rotate_degrees(). + - Change identity_matrix() to set_identity_matrix().\ + - Change new_path() to clear_path(). +* FontFace: Remove get/set_user_data(), because it seems useless. + +0.3.0: + +* Context: + - Change mask_surface() to mask() and + set_source_surface() to set_source(). + - Add typedef for Matrix, but a real Matrix + class would be nice. +* Pattern: Created hierarchy of classes. +* Check for errors in constructors. +* Exception: Rename to logic_error, and throw + std::bad_alloc or std::io_base::failure instead + when appropriate. + (Murray Cumming) + diff --git a/libs/cairomm/README b/libs/cairomm/README new file mode 100644 index 0000000000..6605a4e338 --- /dev/null +++ b/libs/cairomm/README @@ -0,0 +1,13 @@ +cairomm +------------- + +This library provides a C++ interface to cairo. + +Read the file 'INSTALL' for instructions to compile and install the library. + +See the examples directory for example code. + +Use pkg-config to discover the necessary include and linker arguments. For instance, + pkg-config cairomm-1.0 --cflags --libs +Ideally you would use PKG_CHECK_MODULES in your configure.ac file. +See http://www.openismus.com for generic help with that. diff --git a/libs/cairomm/SConscript b/libs/cairomm/SConscript new file mode 100644 index 0000000000..88b8b2ab06 --- /dev/null +++ b/libs/cairomm/SConscript @@ -0,0 +1,22 @@ +# -*- python -*- + +import os +import os.path +import glob + +cairomm_files = glob.glob('cairomm/*.cc') + +Import('env libraries install_prefix') +cairomm = env.Copy() +cairomm.Merge([libraries['cairo']]) + +libcairomm = cairomm.SharedLibrary('cairomm', cairomm_files) +Default(libcairomm) + +env.Alias('install', env.Install(os.path.join(install_prefix, env['LIBDIR'], 'ardour2'), libcairomm)) + +env.Alias('tarball', env.Distribute (env['DISTTREE'], + [ 'SConscript'] + + cairomm_files + + glob.glob('cairomm/*.h') + )) diff --git a/libs/cairomm/cairomm-1.0.pc.in b/libs/cairomm/cairomm-1.0.pc.in new file mode 100644 index 0000000000..c2832250fb --- /dev/null +++ b/libs/cairomm/cairomm-1.0.pc.in @@ -0,0 +1,12 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: cairomm +Description: C++ wrapper for cairo +Requires: cairo +Version: @VERSION@ +Libs: -L${libdir} -lcairomm-1.0 +Cflags: -I${includedir}/cairomm-1.0 + diff --git a/libs/cairomm/cairomm/cairomm.h b/libs/cairomm/cairomm/cairomm.h new file mode 100644 index 0000000000..7f78a79a66 --- /dev/null +++ b/libs/cairomm/cairomm/cairomm.h @@ -0,0 +1,43 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __CAIROMM_H +#define __CAIROMM_H + +/** @mainpage Cairomm: A C++ wrapper for the cairo graphics library + * + * @section License + * Cairomm is available under the terms of the LGPL license + * + * @section Introduction + * If you're just beginning to learn cairomm, a good place to start is with the + * Cairo::Surface and Cairo::Context classes. In general terms, you draw onto + * a Surface using the graphics settings specified in your Context. + * + */ + +#include +#include +#include +#include +#include +#include + +#endif //__CAIROMM_H + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/context.cc b/libs/cairomm/cairomm/context.cc new file mode 100644 index 0000000000..5f502c5f57 --- /dev/null +++ b/libs/cairomm/cairomm/context.cc @@ -0,0 +1,669 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#include +#include + +/* M_PI is defined in math.h in the case of Microsoft Visual C++ */ +#if defined(_MSC_VER) +#define _USE_MATH_DEFINES +#include +#endif + +namespace Cairo +{ + +Context::Context(const RefPtr& target) +: m_cobject(0) +{ + m_cobject = cairo_create(target->cobj()); + check_object_status_and_throw_exception(*this); +} + +RefPtr Context::create(const RefPtr& target) +{ + return RefPtr(new Context(target)); +} + +Context::Context(cairo_t* cobject, bool has_reference) +: m_cobject(0) +{ + if(has_reference) + m_cobject = cobject; + else + m_cobject = cairo_reference(cobject); +} + +Context::~Context() +{ + if(m_cobject) + cairo_destroy(m_cobject); +} + + +void Context::reference() const +{ + cairo_reference(m_cobject); +} + +void Context::unreference() const +{ + cairo_destroy(m_cobject); +} + +void Context::save() +{ + cairo_save(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::restore() +{ + cairo_restore(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::set_operator(Operator op) +{ + cairo_set_operator(m_cobject, static_cast(op)); + check_object_status_and_throw_exception(*this); +} + +void Context::set_source(const RefPtr& source) +{ + cairo_set_source(m_cobject, const_cast(source->cobj())); + check_object_status_and_throw_exception(*this); +} + +void Context::set_source_rgb(double red, double green, double blue) +{ + cairo_set_source_rgb(m_cobject, red, green, blue); + check_object_status_and_throw_exception(*this); +} + +void Context::set_source_rgba(double red, double green, double blue, +double alpha) +{ + cairo_set_source_rgba(m_cobject, red, green, blue, alpha); + check_object_status_and_throw_exception(*this); +} + +void Context::set_source(const RefPtr& surface, double x, double y) +{ + cairo_set_source_surface(m_cobject, surface->cobj(), x, y); + check_object_status_and_throw_exception(*this); +} + +void Context::set_tolerance(double tolerance) +{ + cairo_set_tolerance(m_cobject, tolerance); + check_object_status_and_throw_exception(*this); +} + +void Context::set_antialias(Antialias antialias) +{ + cairo_set_antialias(m_cobject, static_cast(antialias)); + check_object_status_and_throw_exception(*this); +} + +void Context::set_fill_rule(FillRule fill_rule) +{ + cairo_set_fill_rule(m_cobject, static_cast(fill_rule)); + check_object_status_and_throw_exception(*this); +} + +void Context::set_line_width(double width) +{ + cairo_set_line_width(m_cobject, width); + check_object_status_and_throw_exception(*this); +} + +void Context::set_line_cap(LineCap line_cap) +{ + cairo_set_line_cap(m_cobject, static_cast(line_cap)); + check_object_status_and_throw_exception(*this); +} + +void Context::set_line_join(LineJoin line_join) +{ + cairo_set_line_join(m_cobject, static_cast(line_join)); + check_object_status_and_throw_exception(*this); +} + +void Context::set_dash(std::valarray& dashes, double offset) +{ + cairo_set_dash(m_cobject, &dashes[0], dashes.size(), offset); + check_object_status_and_throw_exception(*this); +} + +void Context::unset_dash() +{ + cairo_set_dash(m_cobject, NULL, 0, 0.0); + check_object_status_and_throw_exception(*this); +} + +void Context::set_miter_limit(double limit) +{ + cairo_set_miter_limit(m_cobject, limit); + check_object_status_and_throw_exception(*this); +} + +void Context::translate(double tx, double ty) +{ + cairo_translate(m_cobject, tx, ty); + check_object_status_and_throw_exception(*this); +} + +void Context::scale(double sx, double sy) +{ + cairo_scale(m_cobject, sx, sy); + check_object_status_and_throw_exception(*this); +} + +void Context::rotate(double angle_radians) +{ + cairo_rotate(m_cobject, angle_radians); + check_object_status_and_throw_exception(*this); +} + +void Context::rotate_degrees(double angle_degrees) +{ + cairo_rotate(m_cobject, angle_degrees * M_PI/180.0); + check_object_status_and_throw_exception(*this); +} + +void Context::transform(const Matrix& matrix) +{ + cairo_transform(m_cobject, &matrix); + check_object_status_and_throw_exception(*this); +} + +void Context::set_matrix(const Matrix& matrix) +{ + cairo_set_matrix(m_cobject, &matrix); + check_object_status_and_throw_exception(*this); +} + +void Context::set_identity_matrix() +{ + cairo_identity_matrix(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::user_to_device(double& x, double& y) +{ + cairo_user_to_device(m_cobject, &x, &y); + check_object_status_and_throw_exception(*this); +} + +void Context::user_to_device_distance(double& dx, double& dy) +{ + cairo_user_to_device_distance(m_cobject, &dx, &dy); + check_object_status_and_throw_exception(*this); +} + +void Context::device_to_user(double& x, double& y) +{ + cairo_device_to_user(m_cobject, &x, &y); + check_object_status_and_throw_exception(*this); +} + +void Context::device_to_user_distance(double& dx, double& dy) +{ + cairo_device_to_user_distance(m_cobject, &dx, &dy); + check_object_status_and_throw_exception(*this); +} + +void Context::begin_new_path() +{ + cairo_new_path(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::begin_new_sub_path() +{ + cairo_new_sub_path(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::move_to(double x, double y) +{ + cairo_move_to(m_cobject, x, y); + check_object_status_and_throw_exception(*this); +} + +void Context::line_to(double x, double y) +{ + cairo_line_to(m_cobject, x, y); + check_object_status_and_throw_exception(*this); +} + +void Context::curve_to(double x1, double y1, double x2, double y2, double x3, double y3) +{ + cairo_curve_to(m_cobject, x1, y1, x2, y2, x3, y3); + check_object_status_and_throw_exception(*this); +} + +void Context::arc(double xc, double yc, double radius, double angle1, double angle2) +{ + cairo_arc(m_cobject, xc, yc, radius, angle1, angle2); + check_object_status_and_throw_exception(*this); +} + +void Context::arc_negative(double xc, double yc, double radius, double angle1, double angle2) +{ + cairo_arc_negative(m_cobject, xc, yc, radius, angle1, angle2); + check_object_status_and_throw_exception(*this); +} + +void Context::rel_move_to(double dx, double dy) +{ + cairo_rel_move_to(m_cobject, dx, dy); + check_object_status_and_throw_exception(*this); +} + +void Context::rel_line_to(double dx, double dy) +{ + cairo_rel_line_to(m_cobject, dx, dy); + check_object_status_and_throw_exception(*this); +} + +void Context::rel_curve_to(double dx1, double dy1, double dx2, double dy2, double dx3, double dy3) +{ + cairo_rel_curve_to(m_cobject, dx1, dy1, dx2, dy2, dx3, dy3); + check_object_status_and_throw_exception(*this); +} + +void Context::rectangle(double x, double y, double width, double height) +{ + cairo_rectangle(m_cobject, x, y, width, height); + check_object_status_and_throw_exception(*this); +} + +void Context::close_path() +{ + cairo_close_path(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::paint() +{ + cairo_paint(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::paint_with_alpha(double alpha) +{ + cairo_paint_with_alpha(m_cobject, alpha); + check_object_status_and_throw_exception(*this); +} + +void Context::mask(const RefPtr& pattern) +{ + cairo_mask(m_cobject, const_cast(pattern->cobj())); + check_object_status_and_throw_exception(*this); +} + +void Context::mask(const RefPtr& surface, double surface_x, double surface_y) +{ + cairo_mask_surface(m_cobject, const_cast(surface->cobj()), surface_x, surface_y); + check_object_status_and_throw_exception(*this); +} + +void Context::stroke() +{ + cairo_stroke(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::stroke_preserve() +{ + cairo_stroke_preserve(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::fill() +{ + cairo_fill(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::fill_preserve() +{ + cairo_fill_preserve(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::copy_page() +{ + cairo_copy_page(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::show_page() +{ + cairo_show_page(m_cobject); + check_object_status_and_throw_exception(*this); +} + +bool Context::in_stroke(double x, double y) const +{ + const bool result = cairo_in_stroke(m_cobject, x, y); + check_object_status_and_throw_exception(*this); + return result; +} + +bool Context::in_fill(double x, double y) const +{ + const bool result = cairo_in_fill(m_cobject, x, y); + check_object_status_and_throw_exception(*this); + return result; +} + +void Context::get_stroke_extents(double& x1, double& y1, double& x2, double& y2) const +{ + cairo_stroke_extents(m_cobject, &x1, &y1, &x2, &y2); + check_object_status_and_throw_exception(*this); +} + +void Context::get_fill_extents(double& x1, double& y1, double& x2, double& y2) const +{ + cairo_fill_extents(m_cobject, &x1, &y1, &x2, &y2); + check_object_status_and_throw_exception(*this); +} + +void Context::reset_clip() +{ + cairo_reset_clip(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::clip() +{ + cairo_clip(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::clip_preserve() +{ + cairo_clip_preserve(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::select_font_face(const std::string& family, FontSlant slant, FontWeight weight) +{ + cairo_select_font_face (m_cobject, family.c_str(), + static_cast(slant), + static_cast(weight)); + check_object_status_and_throw_exception(*this); +} + +void Context::set_font_size(double size) +{ + cairo_set_font_size(m_cobject, size); + check_object_status_and_throw_exception(*this); +} + +void Context::set_font_matrix(const Matrix& matrix) +{ + cairo_set_font_matrix(m_cobject, &matrix); + check_object_status_and_throw_exception(*this); +} + +void Context::get_font_matrix(Matrix& matrix) const +{ + cairo_get_font_matrix(m_cobject, &matrix); + check_object_status_and_throw_exception(*this); +} + +void Context::set_font_options(const FontOptions& options) +{ + cairo_set_font_options(m_cobject, options.cobj()); + check_object_status_and_throw_exception(*this); +} + +void Context::show_text(const std::string& utf8) +{ + cairo_show_text(m_cobject, utf8.c_str()); + check_object_status_and_throw_exception(*this); +} + +void Context::show_glyphs(const std::vector& glyphs) +{ + cairo_show_glyphs(m_cobject, const_cast(&glyphs[0]), glyphs.size()); + check_object_status_and_throw_exception(*this); +} + +RefPtr Context::get_font_face() +{ + cairo_font_face_t* cfontface = cairo_get_font_face(m_cobject); + check_object_status_and_throw_exception(*this); + return RefPtr(new FontFace(cfontface, false /* does not have reference */)); +} + +RefPtr Context::get_font_face() const +{ + cairo_font_face_t* cfontface = cairo_get_font_face(m_cobject); + check_object_status_and_throw_exception(*this); + return RefPtr(new FontFace(cfontface, false /* does not have reference */)); +} + +void Context::get_font_extents(FontExtents& extents) const +{ + cairo_font_extents(m_cobject, &extents); + check_object_status_and_throw_exception(*this); +} + +void Context::set_font_face(const RefPtr& font_face) +{ + cairo_set_font_face(m_cobject, const_cast(font_face->cobj())); + check_object_status_and_throw_exception(*this); +} + +void Context::get_text_extents(const std::string& utf8, TextExtents& extents) const +{ + cairo_text_extents(m_cobject, utf8.c_str(), &extents); + check_object_status_and_throw_exception(*this); +} + +void Context::get_glyph_extents(const std::vector& glyphs, TextExtents& extents) const +{ + cairo_glyph_extents(m_cobject, const_cast(&glyphs[0]), glyphs.size(), &extents); + check_object_status_and_throw_exception(*this); +} + +void Context::text_path(const std::string& utf8) +{ + cairo_text_path(m_cobject, utf8.c_str()); + check_object_status_and_throw_exception(*this); +} + +void Context::glyph_path(const std::vector& glyphs) +{ + cairo_glyph_path(m_cobject, const_cast(&glyphs[0]), glyphs.size()); + check_object_status_and_throw_exception(*this); +} + +Operator Context::get_operator() const +{ + const Operator result = static_cast(cairo_get_operator(m_cobject)); + check_object_status_and_throw_exception(*this); + return result; +} + +RefPtr Context::get_source() +{ + cairo_pattern_t* pattern = cairo_get_source(m_cobject); + check_object_status_and_throw_exception(*this); + return RefPtr(new Pattern(pattern, false /* does not have reference */)); +} + +RefPtr Context::get_source() const +{ + cairo_pattern_t* pattern = cairo_get_source(m_cobject); + check_object_status_and_throw_exception(*this); + return RefPtr(new Pattern(pattern, false /* does not have reference */)); +} + +double Context::get_tolerance() const +{ + const double result = cairo_get_tolerance(m_cobject); + check_object_status_and_throw_exception(*this); + return result; +} + +Antialias Context::get_antialias() const +{ + const Antialias result = static_cast(cairo_get_antialias(m_cobject)); + check_object_status_and_throw_exception(*this); + return result; +} + +void Context::get_current_point(double& x, double& y) const +{ + cairo_get_current_point(m_cobject, &x, &y); + check_object_status_and_throw_exception(*this); +} + +FillRule Context::get_fill_rule() const +{ + const FillRule result = static_cast(cairo_get_fill_rule(m_cobject)); + check_object_status_and_throw_exception(*this); + return result; +} + +double Context::get_line_width() const +{ + const double result = cairo_get_line_width(m_cobject); + check_object_status_and_throw_exception(*this); + return result; +} + +LineCap Context::get_line_cap() const +{ + const LineCap result = static_cast(cairo_get_line_cap(m_cobject)); + check_object_status_and_throw_exception(*this); + return result; +} + +LineJoin Context::get_line_join() const +{ + const LineJoin result = static_cast(cairo_get_line_join(m_cobject)); + check_object_status_and_throw_exception(*this); + return result; +} + +double Context::get_miter_limit() const +{ + const double result = cairo_get_miter_limit(m_cobject); + check_object_status_and_throw_exception(*this); + return result; +} + +void Context::get_matrix(Matrix& matrix) +{ + cairo_get_matrix(m_cobject, &matrix); + check_object_status_and_throw_exception(*this); +} + +RefPtr Context::get_target() +{ + cairo_surface_t* surface = cairo_get_target(const_cast(m_cobject)); + check_object_status_and_throw_exception(*this); + return RefPtr(new Surface(surface, false /* does not have reference */)); +} + +RefPtr Context::get_target() const +{ + cairo_surface_t* surface = cairo_get_target(const_cast(m_cobject)); + check_object_status_and_throw_exception(*this); + return RefPtr(new Surface(surface, false /* does not have reference */)); +} + +Path* Context::copy_path() const +{ + cairo_path_t* cresult = cairo_copy_path(const_cast(m_cobject)); + check_object_status_and_throw_exception(*this); + return new Path(cresult, true /* take ownership */); //The caller must delete it. +} + +Path* Context::copy_path_flat() const +{ + cairo_path_t* cresult = cairo_copy_path_flat(const_cast(m_cobject)); + check_object_status_and_throw_exception(*this); + return new Path(cresult, true /* take ownership */); //The caller must delete it. +} + +void Context::append_path(const Path& path) +{ + cairo_append_path(m_cobject, const_cast(path.cobj())); + check_object_status_and_throw_exception(*this); +} + +void Context::push_group() +{ + cairo_push_group(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Context::push_group_with_content(Content content) +{ + cairo_push_group_with_content(m_cobject, static_cast(content)); + check_object_status_and_throw_exception(*this); +} + +RefPtr Context::pop_group() +{ + cairo_pattern_t* pattern = cairo_pop_group(m_cobject); + check_object_status_and_throw_exception(*this); + return RefPtr(new Pattern(pattern)); +} + +void Context::pop_group_to_source() +{ + cairo_pop_group_to_source(m_cobject); + check_object_status_and_throw_exception(*this); +} + +RefPtr Context::get_group_target() +{ + cairo_surface_t* surface = cairo_get_group_target(m_cobject); + // surface can be NULL if you're not between push/pop group calls + if (surface == NULL) + { + // FIXME: is this really the right way to handle this? + throw_exception(CAIRO_STATUS_NULL_POINTER); + } + return RefPtr(new Surface(surface, false)); +} + +RefPtr Context::get_group_target() const +{ + cairo_surface_t* surface = cairo_get_group_target(m_cobject); + // surface can be NULL if you're not between push/pop group calls + if (surface == NULL) + { + // FIXME: is this really the right way to handle this? + throw_exception(CAIRO_STATUS_NULL_POINTER); + } + return RefPtr(new Surface(surface, false)); +} + +} //namespace Cairo + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/context.h b/libs/cairomm/cairomm/context.h new file mode 100644 index 0000000000..dcd3d833a6 --- /dev/null +++ b/libs/cairomm/cairomm/context.h @@ -0,0 +1,931 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __CAIROMM_CONTEXT_H +#define __CAIROMM_CONTEXT_H + +#include +#include +#include +#include +#include +#include +#include + + +namespace Cairo +{ + +typedef cairo_glyph_t Glyph; //A simple struct. +typedef cairo_font_extents_t FontExtents; //A simple struct. +typedef cairo_text_extents_t TextExtents; //A simple struct. +typedef cairo_matrix_t Matrix; //A simple struct. //TODO: Derive and add operator[] and operator. matrix multiplication? + +/** Context is the main class used to draw in cairomm. + * In the simplest case, create a Context with its target Surface, set its + * drawing options (line width, color, etc), create shapes with methods like + * move_to() and line_to(), and then draw the shapes to the Surface using + * methods such as stroke() or fill(). + * + * Context is a reference-counted object that should be used via Cairo::RefPtr. + */ +class Context +{ +protected: + explicit Context(const RefPtr& target); + +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be + * given to a RefPtr. + * + * @param cobject The C instance. + * @param has_reference Whether we already have a reference. Otherwise, the + * constructor will take an extra reference. + */ + explicit Context(cairo_t* cobject, bool has_reference = false); + + static RefPtr create(const RefPtr& target); + + virtual ~Context(); + + /** Makes a copy of the current state of the Context and saves it on an + * internal stack of saved states. When restore() is called, it will be + * restored to the saved state. Multiple calls to save() and restore() can be + * nested; each call to restore() restores the state from the matching paired + * save(). + * + * It isn't necessary to clear all saved states before a cairo_t is freed. + * Any saved states will be freed when the Context is destroyed. + * + * @sa restore() + */ + void save(); + + /** Restores cr to the state saved by a preceding call to save() and removes + * that state from the stack of saved states. + * + * @sa save() + */ + void restore(); + + /** Sets the compositing operator to be used for all drawing operations. See + * Operator for details on the semantics of each available compositing + * operator. + * + * @param op a compositing operator, specified as a Operator + */ + void set_operator(Operator op); + + /** Sets the source pattern within the Context to source. This Pattern will + * then be used for any subsequent drawing operation until a new source + * pattern is set. + * + * Note: The Pattern's transformation matrix will be locked to the user space + * in effect at the time of set_source(). This means that further + * modifications of the current transformation matrix will not affect the + * source pattern. + * + * @param source a Pattern to be used as the source for subsequent drawing + * operations. + * + * @sa Pattern::set_matrix() + * @sa set_source_rgb() + * @sa set_source_rgba() + * @sa set_source(const RefPtr& surface, double x, double y) + */ + void set_source(const RefPtr& source); + + /** Sets the source pattern within the Context to an opaque color. This + * opaque color will then be used for any subsequent drawing operation until + * a new source pattern is set. + * + * The color components are floating point numbers in the range 0 to 1. If + * the values passed in are outside that range, they will be clamped. + * + * @param red red component of color + * @param green green component of color + * @param blue blue component of color + * + * @sa set_source_rgba() + * @sa set_source() + */ + void set_source_rgb(double red, double green, double blue); + + /** Sets the source pattern within the Context to a translucent color. This + * color will then be used for any subsequent drawing operation until a new + * source pattern is set. + * + * The color and alpha components are floating point numbers in the range 0 + * to 1. If the values passed in are outside that range, they will be + * clamped. + * + * @param red red component of color + * @param green green component of color + * @param blue blue component of color + * @param alpha alpha component of color + * + * @sa set_source_rgb() + * @sa set_source() + */ + void set_source_rgba(double red, double green, double blue, double alpha); + + /** This is a convenience function for creating a pattern from a Surface and + * setting it as the source + * + * The x and y parameters give the user-space coordinate at which the Surface + * origin should appear. (The Surface origin is its upper-left corner before + * any transformation has been applied.) The x and y patterns are negated and + * then set as translation values in the pattern matrix. + * + * Other than the initial translation pattern matrix, as described above, all + * other pattern attributes, (such as its extend mode), are set to the + * default values as in Context::create(const RefPtr& target). The + * resulting pattern can be queried with get_source() so that these + * attributes can be modified if desired, (eg. to create a repeating pattern + * with Pattern::set_extend()). + * + * @param surface : a Surface to be used to set the source pattern + * @param x : User-space X coordinate for surface origin + * @param y : User-space Y coordinate for surface origin + */ + void set_source(const RefPtr& surface, double x, double y); + + /** Sets the tolerance used when converting paths into trapezoids. Curved + * segments of the path will be subdivided until the maximum deviation + * between the original path and the polygonal approximation is less than + * tolerance. The default value is 0.1. A larger value will give better + * performance, a smaller value, better appearance. (Reducing the value from + * the default value of 0.1 is unlikely to improve appearance significantly.) + * + * @param tolerance the tolerance, in device units (typically pixels) + */ + void set_tolerance(double tolerance); + + /** Set the antialiasing mode of the rasterizer used for drawing shapes. This + * value is a hint, and a particular backend may or may not support a + * particular value. At the current time, no backend supports + * CAIRO_ANTIALIAS_SUBPIXEL when drawing shapes. + * + * Note that this option does not affect text rendering, instead see + * FontOptions::set_antialias(). + * + * @param antialias the new antialiasing mode + */ + void set_antialias(Antialias antialias); + + /** Set the current fill rule within the cairo Context. The fill rule is used + * to determine which regions are inside or outside a complex (potentially + * self-intersecting) path. The current fill rule affects both fill() and + * clip(). See FillRule for details on the semantics of each available fill + * rule. + * + * @param fill_rule a fill rule, specified as a FillRule + */ + void set_fill_rule(FillRule fill_rule); + + /** Sets the current line width within the cairo Context. The line width + * specifies the diameter of a pen that is circular in user-space. + * + * As with the other stroke parameters, the current line cap style is + * examined by stroke(), stroke_extents(), and stroke_to_path(), but does not + * have any effect during path construction. + * + * @param width a line width, as a user-space value + */ + void set_line_width(double width); + + /** Sets the current line cap style within the cairo Context. See + * LineCap for details about how the available line cap styles are drawn. + * + * As with the other stroke parameters, the current line cap style is + * examined by stroke(), stroke_extents(), and stroke_to_path(), but does not + * have any effect during path construction. + * + * @param line_cap a line cap style, as a LineCap + */ + void set_line_cap(LineCap line_cap); + + /** Sets the current line join style within the cairo Context. See LineJoin + * for details about how the available line join styles are drawn. + * + * As with the other stroke parameters, the current line join style is + * examined by stroke(), stroke_extents(), and stroke_to_path(), but does not + * have any effect during path construction. + * + * @param line_join a line joint style, as a LineJoin + */ + void set_line_join(LineJoin line_join); + + /** Sets the dash pattern to be used by stroke(). A dash pattern is specified + * by dashes, an array of positive values. Each value provides the user-space + * length of altenate "on" and "off" portions of the stroke. The offset + * specifies an offset into the pattern at which the stroke begins. + * + * If dashes is empty dashing is disabled. If the size of dashes is 1, a + * symmetric pattern is assumed with alternating on and off portions of the + * size specified by the single value in dashes. + * + * It is invalid for any value in dashes to be negative, or for all values to + * be 0. If this is the case, an exception will be thrown + * + * @param dashes an array specifying alternate lengths of on and off portions + * @param offset an offset into the dash pattern at which the stroke should start + * + * @exception + */ + void set_dash(std::valarray& dashes, double offset); + + /** This function disables a dash pattern that was set with set_dash() + */ + void unset_dash(); + void set_miter_limit(double limit); + + /** Modifies the current transformation matrix (CTM) by translating the + * user-space origin by (tx, ty). This offset is interpreted as a user-space + * coordinate according to the CTM in place before the new call to + * cairo_translate. In other words, the translation of the user-space origin + * takes place after any existing transformation. + * + * @param tx amount to translate in the X direction + * @param ty amount to translate in the Y direction + */ + void translate(double tx, double ty); + + /** Modifies the current transformation matrix (CTM) by scaling the X and Y + * user-space axes by sx and sy respectively. The scaling of the axes takes + * place after any existing transformation of user space. + * + * @param sx scale factor for the X dimension + * @param sy scale factor for the Y dimension + */ + void scale(double sx, double sy); + + /** Modifies the current transformation matrix (CTM) by rotating the + * user-space axes by angle radians. The rotation of the axes takes places + * after any existing transformation of user space. The rotation direction + * for positive angles is from the positive X axis toward the positive Y + * axis. + * + * @param angle angle (in radians) by which the user-space axes will be + * rotated + */ + void rotate(double angle_radians); + + /** A convenience wrapper around rotate() that accepts angles in degrees + * + * @param angle_degrees angle (in degrees) by which the user-space axes + * should be rotated + */ + void rotate_degrees(double angle_degres); + + /** Modifies the current transformation matrix (CTM) by applying matrix as an + * additional transformation. The new transformation of user space takes + * place after any existing transformation. + * + * @param matrix a transformation to be applied to the user-space axes + */ + void transform(const Matrix& matrix); + + /** Modifies the current transformation matrix (CTM) by setting it equal to + * matrix. + * + * @param matrix a transformation matrix from user space to device space + */ + void set_matrix(const Matrix& matrix); + + /** Resets the current transformation matrix (CTM) by setting it equal to the + * identity matrix. That is, the user-space and device-space axes will be + * aligned and one user-space unit will transform to one device-space unit. + */ + void set_identity_matrix(); + + /** Transform a coordinate from user space to device space by multiplying the + * given point by the current transformation matrix (CTM). + * + * @param x X value of coordinate (in/out parameter) + * @param y Y value of coordinate (in/out parameter) + */ + void user_to_device(double& x, double& y); + + /** Transform a distance vector from user space to device space. This + * function is similar to user_to_device() except that the translation + * components of the CTM will be ignored when transforming (dx,dy). + * + * @param dx X component of a distance vector (in/out parameter) + * @param dy Y component of a distance vector (in/out parameter) + */ + void user_to_device_distance(double& dx, double& dy); + + /** Transform a coordinate from device space to user space by multiplying the + * given point by the inverse of the current transformation matrix (CTM). + * + * @param x X value of coordinate (in/out parameter) + * @param y Y value of coordinate (in/out parameter) + */ + void device_to_user(double& x, double& y); + + /** Transform a distance vector from device space to user space. This + * function is similar to device_to_user() except that the translation + * components of the inverse CTM will be ignored when transforming (dx,dy). + * + * @param dx X component of a distance vector (in/out parameter) + * @param dy Y component of a distance vector (in/out parameter) + */ + void device_to_user_distance(double& dx, double& dy); + + /** Clears the current path. After this call there will be no current point. + */ + void begin_new_path(); + + /** Begin a new subpath. Note that the existing path is not affected. After + * this call there will be no current point. + * + * In many cases, this call is not needed since new subpaths are frequently + * started with move_to(). + * + * A call to begin_new_sub_path() is particularly useful when beginning a new + * subpath with one of the arc() calls. This makes things easier as it is no + * longer necessary to manually compute the arc's initial coordinates for a + * call to move_to(). + */ + void begin_new_sub_path(); + + /** If the current subpath is not empty, begin a new subpath. After this call + * the current point will be (x, y). + * + * @param x the X coordinate of the new position + * @param y the Y coordinate of the new position + */ + void move_to(double x, double y); + + /** Adds a line to the path from the current point to position (x, y) in + * user-space coordinates. After this call the current point will be (x, y). + * + * @param x the X coordinate of the end of the new line + * @param y the Y coordinate of the end of the new line + */ + void line_to(double x, double y); + + /** Adds a cubic Bezier spline to the path from the current point to position + * (x3, y3) in user-space coordinates, using (x1, y1) and (x2, y2) as the + * control points. After this call the current point will be (x3, y3). + * + * @param x1 the X coordinate of the first control point + * @param y1 the Y coordinate of the first control point + * @param x2 the X coordinate of the second control point + * @param y2 the Y coordinate of the second control point + * @param x3 the X coordinate of the end of the curve + * @param y3 the Y coordinate of the end of the curve + */ + void curve_to(double x1, double y1, double x2, double y2, double x3, double y3); + + /** Adds a circular arc of the given radius to the current path. The arc is + * centered at (xc, yc), begins at angle1 and proceeds in the direction of + * increasing angles to end at angle2. If angle2 is less than angle1 it will + * be progressively increased by 2*M_PI until it is greater than angle1. + * + * If there is a current point, an initial line segment will be added to the + * path to connect the current point to the beginning of the arc. + * + * Angles are measured in radians. An angle of 0 is in the direction of the + * positive X axis (in user-space). An angle of M_PI radians (90 degrees) is + * in the direction of the positive Y axis (in user-space). Angles increase + * in the direction from the positive X axis toward the positive Y axis. So + * with the default transformation matrix, angles increase in a clockwise + * direction. + * + * (To convert from degrees to radians, use degrees * (M_PI / 180.).) + * + * This function gives the arc in the direction of increasing angles; see + * arc_negative() to get the arc in the direction of decreasing angles. + * + * The arc is circular in user-space. To achieve an elliptical arc, you can + * scale the current transformation matrix by different amounts in the X and + * Y directions. For example, to draw an ellipse in the box given by x, y, + * width, height: + * + * @code + * context->save(); + * context->translate(x, y); + * context->scale(width / 2.0, height / 2.0); + * context->arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI); + * context->restore(); + * @endcode + * + * @param xc X position of the center of the arc + * @param yc Y position of the center of the arc + * @param radius the radius of the arc + * @param angle1 the start angle, in radians + * @param angle2 the end angle, in radians + */ + void arc(double xc, double yc, double radius, double angle1, double angle2); + + /** Adds a circular arc of the given radius to the current path. The arc is + * centered at (xc, yc), begins at angle1 and proceeds in the direction of + * decreasing angles to end at angle2. If angle2 is greater than angle1 it + * will be progressively decreased by 2*M_PI until it is greater than angle1. + * + * See arc() for more details. This function differs only in the direction of + * the arc between the two angles. + * + * @param xc X position of the center of the arc + * @param yc Y position of the center of the arc + * @param radius the radius of the arc + * @param angle1 the start angle, in radians + * @param angle2 the end angle, in radians + */ + void arc_negative(double xc, double yc, double radius, double angle1, double angle2); + + /** If the current subpath is not empty, begin a new subpath. After this call + * the current point will offset by (x, y). + * + * Given a current point of (x, y), + * @code + * rel_move_to(dx, dy) + * @endcode + * is logically equivalent to + * @code + * move_to(x + dx, y + dy) + * @endcode + * + * @param dx the X offset + * @param dy the Y offset + */ + void rel_move_to(double dx, double dy); + + /** Relative-coordinate version of line_to(). Adds a line to the path from + * the current point to a point that is offset from the current point by (dx, + * dy) in user space. After this call the current point will be offset by + * (dx, dy). + * + * Given a current point of (x, y), + * @code + * rel_line_to(dx, dy) + * @endcode + * is logically equivalent to + * @code + * line_to(x + dx, y + dy). + * @endcode + * + * @param dx the X offset to the end of the new line + * @param dy the Y offset to the end of the new line + */ + void rel_line_to(double dx, double dy); + + /** Relative-coordinate version of curve_to(). All offsets are relative to + * the current point. Adds a cubic Bezier spline to the path from the current + * point to a point offset from the current point by (dx3, dy3), using points + * offset by (dx1, dy1) and (dx2, dy2) as the control points. After this + * call the current point will be offset by (dx3, dy3). + * + * Given a current point of (x, y), + * @code + * rel_curve_to(dx1, dy1, dx2, dy2, dx3, dy3) + * @endcode + * is logically equivalent to + * @code + * curve_to(x + dx1, y + dy1, x + dx2, y + dy2, x + dx3, y + dy3). + * @endcode + * + * @param dx1 the X offset to the first control point + * @param dy1 the Y offset to the first control point + * @param dx2 the X offset to the second control point + * @param dy2 the Y offset to the second control point + * @param dx3 the X offset to the end of the curve + * @param dy3 the Y offset to the end of the curve + */ + void rel_curve_to(double dx1, double dy1, double dx2, double dy2, double dx3, double dy3); + + /** Adds a closed-subpath rectangle of the given size to the current path at + * position (x, y) in user-space coordinates. + * + * This function is logically equivalent to: + * + * @code + * context->move_to(x, y); + * context->rel_line_to(width, 0); + * context->rel_line_to(0, height); + * context->rel_line_to(-width, 0); + * context->close_path(); + * @endcode + * + * @param x the X coordinate of the top left corner of the rectangle + * @param y the Y coordinate to the top left corner of the rectangle + * @param width the width of the rectangle + * @param height the height of the rectangle + */ + void rectangle(double x, double y, double width, double height); + + /** Adds a line segment to the path from the current point to the beginning + * of the current subpath, (the most recent point passed to move_to()), and + * closes this subpath. + * + * The behavior of close_path() is distinct from simply calling line_to() + * with the equivalent coordinate in the case of stroking. When a closed + * subpath is stroked, there are no caps on the ends of the subpath. Instead, + * there is a line join connecting the final and initial segments of the + * subpath. + */ + void close_path(); + + /** A drawing operator that paints the current source everywhere within the + * current clip region. + */ + void paint(); + + /** A drawing operator that paints the current source everywhere within the + * current clip region using a mask of constant alpha value alpha. The effect + * is similar to paint(), but the drawing is faded out using the alpha + * value. + * + * @param alpha an alpha value, between 0 (transparent) and 1 (opaque) + */ + void paint_with_alpha(double alpha); + + /** A drawing operator that paints the current source using the alpha channel + * of pattern as a mask. (Opaque areas of mask are painted with the source, + * transparent areas are not painted.) + * + * @param pattern a Pattern + */ + void mask(const RefPtr& pattern); + + /** A drawing operator that paints the current source using the alpha channel + * of surface as a mask. (Opaque areas of surface are painted with the + * source, transparent areas are not painted.) + * + * @param surface a Surface + * @param surface_x X coordinate at which to place the origin of surface + * @param surface_y Y coordinate at which to place the origin of surface + */ + void mask(const RefPtr& surface, double surface_x, double surface_y); + + /** A drawing operator that strokes the current Path according to the current + * line width, line join, line cap, and dash settings. After stroke(), + * the current Path will be cleared from the cairo Context. + * + * @sa set_line_width() + * @sa set_line_join() + * @sa set_line_cap() + * @sa set_dash() + * @sa stroke_preserve(). + */ + void stroke(); + + /** A drawing operator that strokes the current Path according to the current + * line width, line join, line cap, and dash settings. Unlike stroke(), + * stroke_preserve() preserves the Path within the cairo Context. + * + * @sa set_line_width() + * @sa set_line_join() + * @sa set_line_cap() + * @sa set_dash() + * @sa stroke_preserve(). + */ + void stroke_preserve(); + + /** A drawing operator that fills the current path according to the current + * fill rule, (each sub-path is implicitly closed before being filled). After + * fill(), the current path will be cleared from the cairo context. + * + * @sa set_fill_rule() + * @sa fill_preserve() + */ + void fill(); + + /** A drawing operator that fills the current path according to the current + * fill rule, (each sub-path is implicitly closed before being filled). + * Unlike fill(), fill_preserve() preserves the path within the + * cairo Context. + * + * @sa set_fill_rule() + * @sa fill(). + */ + void fill_preserve(); + void copy_page(); + void show_page(); + bool in_stroke(double x, double y) const; + bool in_fill(double x, double y) const; + void get_stroke_extents(double& x1, double& y1, double& x2, double& y2) const; + void get_fill_extents(double& x1, double& y1, double& x2, double& y2) const; + + /** Reset the current clip region to its original, unrestricted state. That + * is, set the clip region to an infinitely large shape containing the target + * surface. Equivalently, if infinity is too hard to grasp, one can imagine + * the clip region being reset to the exact bounds of the target surface. + * + * Note that code meant to be reusable should not call reset_clip() as it + * will cause results unexpected by higher-level code which calls clip(). + * Consider using save() and restore() around clip() as a more robust means + * of temporarily restricting the clip region. + */ + void reset_clip(); + + /** Establishes a new clip region by intersecting the current clip region + * with the current Path as it would be filled by fill() and according to the + * current fill rule. + * + * After clip(), the current path will be cleared from the cairo Context. + * + * The current clip region affects all drawing operations by effectively + * masking out any changes to the surface that are outside the current clip + * region. + * + * Calling clip() can only make the clip region smaller, never larger. But + * the current clip is part of the graphics state, so a temporary restriction + * of the clip region can be achieved by calling cairo_clip() within a + * save()/restore() pair. The only other means of increasing the size of the + * clip region is reset_clip(). + * + * @sa set_fill_rule() + */ + void clip(); + + /** Establishes a new clip region by intersecting the current clip region + * with the current path as it would be filled by fill() and according to the + * current fill rule. + * + * Unlike clip(), cairo_clip_preserve preserves the path within the cairo + * Context. + * + * @sa clip() + * @sa set_fill_rule() + */ + void clip_preserve(); + void select_font_face(const std::string& family, FontSlant slant, FontWeight weight); + void set_font_size(double size); + void set_font_matrix(const Matrix& matrix); + void get_font_matrix(Matrix& matrix) const; + void set_font_options(const FontOptions& options); + void show_text(const std::string& utf8); + void show_glyphs(const std::vector& glyphs); + RefPtr get_font_face(); + RefPtr get_font_face() const; + void get_font_extents(FontExtents& extents) const; + void set_font_face(const RefPtr& font_face); + void get_text_extents(const std::string& utf8, TextExtents& extents) const; + void get_glyph_extents(const std::vector& glyphs, TextExtents& extents) const; + void text_path(const std::string& utf8); + void glyph_path(const std::vector& glyphs); + + /** Gets the current compositing operator for a cairo Context + */ + Operator get_operator() const; + + /** Gets the current source pattern for the Context + */ + RefPtr get_source(); + RefPtr get_source() const; + + /** Gets the current tolerance value, as set by set_tolerance() + */ + double get_tolerance() const; + + /** Gets the current shape antialiasing mode, as set by set_antialias() + */ + Antialias get_antialias() const; + + /** Gets the current point of the current path, which is conceptually the + * final point reached by the path so far. + * + * The current point is returned in the user-space coordinate system. If + * there is no defined current point then x and y will both be set to 0.0. + * + * Most path construction functions alter the current point. See the + * following for details on how they affect the current point: clear_path(), + * move_to(), line_to(), curve_to(), arc(), rel_move_to(), rel_line_to(), + * rel_curve_to(), arc(), and text_path() + * + * @param x return value for X coordinate of the current point + * @param y return value for Y coordinate of the current point + */ + void get_current_point (double& x, double& y) const; + + /** Gets the current fill rule, as set by set_fill_rule(). + */ + FillRule get_fill_rule() const; + + /** Gets the current line width, as set by set_line_width() + */ + double get_line_width() const; + + /** Gets the current line cap style, as set by set_line_cap() + */ + LineCap get_line_cap() const; + + /** Gets the current line join style, as set by set_line_join() + */ + LineJoin get_line_join() const; + + /** Gets the current miter limit, as set by set_miter_limit() + */ + double get_miter_limit() const; + + /** Stores the current transformation matrix (CTM) into matrix. + * + * @param matrix return value for the matrix + */ + void get_matrix(Matrix& matrix); + + /** Gets the target surface associated with this Context. + * + * @exception + */ + RefPtr get_target(); + + /** Gets the target surface associated with this Context. + * + * @exception + */ + RefPtr get_target() const; + + //TODO: Copy or reference-count a Path somethow instead of asking the caller to delete it? + /** Creates a copy of the current path and returns it to the user. + * + * @todo See cairo_path_data_t for hints on how to iterate over the returned + * data structure. + * + * @note The caller owns the Path object returned from this function. The + * Path object must be freed when you are finished with it. + */ + Path* copy_path() const; + + /** Gets a flattened copy of the current path and returns it to the user + * + * @todo See cairo_path_data_t for hints on how to iterate over the returned + * data structure. + * + * This function is like copy_path() except that any curves in the path will + * be approximated with piecewise-linear approximations, (accurate to within + * the current tolerance value). That is, the result is guaranteed to not have + * any elements of type CAIRO_PATH_CURVE_TO which will instead be + * replaced by a series of CAIRO_PATH_LINE_TO elements. + * + * @note The caller owns the Path object returned from this function. The + * Path object must be freed when you are finished with it. + */ + Path* copy_path_flat() const; + + /** Append the path onto the current path. The path may be either the return + * value from one of copy_path() or copy_path_flat() or it may be constructed + * manually. + * + * @param path path to be appended + */ + void append_path(const Path& path); + + /** Temporarily redirects drawing to an intermediate surface known as a group. + * The redirection lasts until the group is completed by a call to pop_group() + * or pop_group_to_source(). These calls provide the result of any drawing to + * the group as a pattern, (either as an explicit object, or set as the source + * pattern). + * + * This group functionality can be convenient for performing intermediate + * compositing. One common use of a group is to render objects as opaque + * within the group, (so that they occlude each other), and then blend the + * result with translucence onto the destination. + * + * Groups can be nested arbitrarily deep by making balanced calls to + * push_group()/pop_group(). Each call pushes/pops the new target group + * onto/from a stack. + * + * The push_group() function calls save() so that any changes to the graphics + * state will not be visible outside the group, (the pop_group functions call + * restore()). + * + * By default the intermediate group will have a content type of + * CONTENT_COLOR_ALPHA. Other content types can be chosen for the group by + * using push_group_with_content() instead. + * + * As an example, here is how one might fill and stroke a path with + * translucence, but without any portion of the fill being visible under the + * stroke: + * + * @code + * cr->push_group(); + * cr->set_source(fill_pattern); + * cr->fill_preserve(); + * cr->set_source(stroke_pattern); + * cr->stroke(); + * cr->pop_group_to_source(); + * cr->paint_with_alpha(alpha); + * @endcode + */ + void push_group(); + + /** + * Temporarily redirects drawing to an intermediate surface known as a + * group. The redirection lasts until the group is completed by a call + * to pop_group() or pop_group_to_source(). These calls provide the result of + * any drawing to the group as a pattern, (either as an explicit object, or set + * as the source pattern). + * + * The group will have a content type of @content. The ability to control this + * content type is the only distinction between this function and push_group() + * which you should see for a more detailed description of group rendering. + * + * @param content: indicates the type of group that will be created + */ + void push_group_with_content(Content content); + + /** + * Terminates the redirection begun by a call to push_group() or + * push_group_with_content() and returns a new pattern containing the results + * of all drawing operations performed to the group. + * + * The pop_group() function calls restore(), (balancing a call to save() by + * the push_group function), so that any changes to the graphics state will + * not be visible outside the group. + * + * @return a (surface) pattern containing the results of all drawing + * operations performed to the group. + **/ + RefPtr pop_group(); + + /** + * Terminates the redirection begun by a call to push_group() or + * push_group_with_content() and installs the resulting pattern as the source + * pattern in the given cairo Context. + * + * The behavior of this function is equivalent to the sequence of operations: + * + * @code + * RefPtr group = cr->pop_group(); + * cr->set_source(group); + * @endcode + * + * but is more convenient as their is no need for a variable to store + * the short-lived pointer to the pattern. + * + * The pop_group() function calls restore(), (balancing a call to save() by + * the push_group function), so that any changes to the graphics state will + * not be visible outside the group. + **/ + void pop_group_to_source(); + + /** + * Gets the target surface for the current group as started by the most recent + * call to push_group() or push_group_with_content(). + * + * This function will return NULL if called "outside" of any group rendering + * blocks, (that is, after the last balancing call to pop_group() or + * pop_group_to_source()). + * + * @exception + * + **/ + RefPtr get_group_target(); + + /** + * Same as the non-const version but returns a reference to a const Surface + */ + RefPtr get_group_target() const; + + /** The base cairo C type that is wrapped by Cairo::Context + */ + typedef cairo_t cobject; + + /** Gets a pointer to the base C type that is wrapped by the Context + */ + inline cobject* cobj() { return m_cobject; } + + /** Gets a pointer to the base C type that is wrapped by the Context + */ + inline const cobject* cobj() const { return m_cobject; } + + #ifndef DOXYGEN_IGNORE_THIS + ///For use only by the cairomm implementation. + inline ErrorStatus get_status() const + { return cairo_status(const_cast(cobj())); } + + void reference() const; + void unreference() const; + #endif //DOXYGEN_IGNORE_THIS + +protected: + + + cobject* m_cobject; +}; + +} // namespace Cairo + +#endif //__CAIROMM_CONTEXT_H + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/enums.h b/libs/cairomm/cairomm/enums.h new file mode 100644 index 0000000000..e2023ed265 --- /dev/null +++ b/libs/cairomm/cairomm/enums.h @@ -0,0 +1,201 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __CAIROMM_ENUMS_H +#define __CAIROMM_ENUMS_H + +#include + +namespace Cairo +{ + +#ifndef DOXYGEN_IGNORE_THIS +//This is only used internally, but it must be in a public header because we inline some methods. +typedef cairo_status_t ErrorStatus; +#endif //DOXYGEN_IGNORE_THIS + + +typedef enum +{ + OPERATOR_CLEAR = CAIRO_OPERATOR_CLEAR, + + OPERATOR_SOURCE = CAIRO_OPERATOR_SOURCE, + OPERATOR_OVER = CAIRO_OPERATOR_OVER, + OPERATOR_IN = CAIRO_OPERATOR_IN, + OPERATOR_OUT = CAIRO_OPERATOR_OUT, + OPERATOR_ATOP = CAIRO_OPERATOR_ATOP, + + OPERATOR_DEST = CAIRO_OPERATOR_DEST, + OPERATOR_DEST_OVER = CAIRO_OPERATOR_DEST_OVER, + OPERATOR_DEST_IN = CAIRO_OPERATOR_DEST_IN, + OPERATOR_DEST_OUT = CAIRO_OPERATOR_DEST_OUT, + OPERATOR_DEST_ATOP = CAIRO_OPERATOR_DEST_ATOP, + + OPERATOR_XOR = CAIRO_OPERATOR_XOR, + OPERATOR_ADD = CAIRO_OPERATOR_ADD, + OPERATOR_SATURATE = CAIRO_OPERATOR_SATURATE +} Operator; + + +typedef enum +{ + ANTIALIAS_DEFAULT = CAIRO_ANTIALIAS_DEFAULT, + ANTIALIAS_NONE = CAIRO_ANTIALIAS_NONE, + ANTIALIAS_GRAY = CAIRO_ANTIALIAS_GRAY, + ANTIALIAS_SUBPIXEL = CAIRO_ANTIALIAS_SUBPIXEL +} Antialias; + +typedef enum +{ + FILL_RULE_WINDING = CAIRO_FILL_RULE_WINDING, + FILL_RULE_EVEN_ODD = CAIRO_FILL_RULE_EVEN_ODD +} FillRule; + + +typedef enum +{ + LINE_CAP_BUTT = CAIRO_LINE_CAP_BUTT, + LINE_CAP_ROUND = CAIRO_LINE_CAP_ROUND, + LINE_CAP_SQUARE = CAIRO_LINE_CAP_SQUARE +} LineCap; + + +typedef enum +{ + LINE_JOIN_MITER = CAIRO_LINE_JOIN_MITER, + LINE_JOIN_ROUND = CAIRO_LINE_JOIN_ROUND, + LINE_JOIN_BEVEL = CAIRO_LINE_JOIN_BEVEL +} LineJoin; + + +typedef enum +{ + FONT_SLANT_NORMAL = CAIRO_FONT_SLANT_NORMAL, + FONT_SLANT_ITALIC = CAIRO_FONT_SLANT_ITALIC, + FONT_SLANT_OBLIQUE = CAIRO_FONT_SLANT_OBLIQUE +} FontSlant; + +typedef enum +{ + FONT_WEIGHT_NORMAL = CAIRO_FONT_WEIGHT_NORMAL, + FONT_WEIGHT_BOLD = CAIRO_FONT_WEIGHT_BOLD +} FontWeight; + + +typedef enum +{ + CONTENT_COLOR = CAIRO_CONTENT_COLOR, + CONTENT_ALPHA = CAIRO_CONTENT_ALPHA, + CONTENT_COLOR_ALPHA = CAIRO_CONTENT_COLOR_ALPHA +} Content; + + +typedef enum +{ + FORMAT_ARGB32 = CAIRO_FORMAT_ARGB32, + FORMAT_RGB24 = CAIRO_FORMAT_RGB24, + FORMAT_A8 = CAIRO_FORMAT_A8, + FORMAT_A1 = CAIRO_FORMAT_A1, + FORMAT_RGB16_565 = CAIRO_FORMAT_RGB16_565 +} Format; + + +typedef enum +{ + EXTEND_NONE = CAIRO_EXTEND_NONE, + EXTEND_REPEAT = CAIRO_EXTEND_REPEAT, + EXTEND_REFLECT = CAIRO_EXTEND_REFLECT, +#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1,1,1) + EXTEND_PAD = CAIRO_EXTEND_PAD +#endif /* CAIRO_VERSION > CAIRO_VERSION_ENCODE(1,1,1) */ +} Extend; + + +typedef enum +{ + FILTER_FAST = CAIRO_FILTER_FAST, + FILTER_GOOD = CAIRO_FILTER_GOOD, + FILTER_BEST = CAIRO_FILTER_BEST, + FILTER_NEAREST = CAIRO_FILTER_NEAREST, + FILTER_BILINEAR = CAIRO_FILTER_BILINEAR, + FILTER_GAUSSIAN = CAIRO_FILTER_GAUSSIAN +} Filter; + +typedef enum +{ + SUBPIXEL_ORDER_DEFAULT = CAIRO_SUBPIXEL_ORDER_DEFAULT, + SUBPIXEL_ORDER_RGB = CAIRO_SUBPIXEL_ORDER_RGB, + SUBPIXEL_ORDER_BGR = CAIRO_SUBPIXEL_ORDER_BGR, + SUBPIXEL_ORDER_VRGB = CAIRO_SUBPIXEL_ORDER_VRGB, + SUBPIXEL_ORDER_VBGR = CAIRO_SUBPIXEL_ORDER_VBGR +} SubpixelOrder; + + +typedef enum +{ + HINT_STYLE_DEFAULT = CAIRO_HINT_STYLE_DEFAULT, + HINT_STYLE_NONE = CAIRO_HINT_STYLE_NONE, + HINT_STYLE_SLIGHT = CAIRO_HINT_STYLE_SLIGHT, + HINT_STYLE_MEDIUM = CAIRO_HINT_STYLE_MEDIUM, + HINT_STYLE_FULL = CAIRO_HINT_STYLE_FULL +} HintStyle; + + +typedef enum +{ + HINT_METRICS_DEFAULT = CAIRO_HINT_METRICS_DEFAULT, + HINT_METRICS_OFF = CAIRO_HINT_METRICS_OFF, + HINT_METRICS_ON = CAIRO_HINT_METRICS_ON +} HintMetrics; + +typedef enum +{ + SURFACE_TYPE_IMAGE = CAIRO_SURFACE_TYPE_IMAGE, + SURFACE_TYPE_PDF = CAIRO_SURFACE_TYPE_PDF, + SURFACE_TYPE_PS = CAIRO_SURFACE_TYPE_PS, + SURFACE_TYPE_XLIB = CAIRO_SURFACE_TYPE_XLIB, + SURFACE_TYPE_XCB = CAIRO_SURFACE_TYPE_XCB, + SURFACE_TYPE_GLITZ = CAIRO_SURFACE_TYPE_GLITZ, + SURFACE_TYPE_QUARTZ = CAIRO_SURFACE_TYPE_QUARTZ, + SURFACE_TYPE_WIN32 = CAIRO_SURFACE_TYPE_WIN32, + SURFACE_TYPE_BEOS = CAIRO_SURFACE_TYPE_BEOS, + SURFACE_TYPE_DIRECTFB = CAIRO_SURFACE_TYPE_DIRECTFB, + SURFACE_TYPE_SVG = CAIRO_SURFACE_TYPE_SVG +} SurfaceType; + +typedef enum +{ + PATTERN_TYPE_SOLID = CAIRO_PATTERN_TYPE_SOLID, + PATTERN_TYPE_SURFACE = CAIRO_PATTERN_TYPE_SURFACE, + PATTERN_TYPE_LINEAR = CAIRO_PATTERN_TYPE_LINEAR, + PATTERN_TYPE_RADIAL = CAIRO_PATTERN_TYPE_RADIAL +} PatternType; + +typedef enum +{ + FONT_TYPE_TOY = CAIRO_FONT_TYPE_TOY, + FONT_TYPE_FT = CAIRO_FONT_TYPE_FT, + FONT_TYPE_WIN32 = CAIRO_FONT_TYPE_WIN32, + FONT_TYPE_ATSUI = CAIRO_FONT_TYPE_ATSUI +} FontType; + +} // namespace Cairo + +#endif //__CAIROMM_ENUMS_H + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/exception.cc b/libs/cairomm/cairomm/exception.cc new file mode 100644 index 0000000000..0144f08a0b --- /dev/null +++ b/libs/cairomm/cairomm/exception.cc @@ -0,0 +1,49 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#include + +namespace Cairo +{ + +inline static const char* string_or_empty(const char* text) +{ + return (text ? text : ""); +} + +//TODO: Is it wise to assume that the string is ASCII, as expected by std::logic_error? +logic_error::logic_error(ErrorStatus status) +: std::logic_error( string_or_empty(cairo_status_to_string((cairo_status_t)m_status)) ), + m_status(status) +{ +} + +logic_error::~logic_error() throw() +{} + +/* +const char* logic_error::what() const throw() +{ + //Hopefully this is a const char* to a static string. + return cairo_status_to_string((cairo_status_t)m_status); +} +*/ + +} //namespace Cairo + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/exception.h b/libs/cairomm/cairomm/exception.h new file mode 100644 index 0000000000..6205a84c16 --- /dev/null +++ b/libs/cairomm/cairomm/exception.h @@ -0,0 +1,46 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __CAIRO_EXCEPTION_H +#define __CAIRO_EXCEPTION_H + +#include +#include + +namespace Cairo +{ + +/** + */ +class logic_error: public std::logic_error +{ +public: + explicit logic_error(ErrorStatus status); + virtual ~logic_error() throw(); + + //virtual const char* what() const throw(); + +private: + ErrorStatus m_status; +}; + +} // namespace Cairo + +#endif // __CAIRO_EXCEPTION_H + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/fontface.cc b/libs/cairomm/cairomm/fontface.cc new file mode 100644 index 0000000000..0e1642a45a --- /dev/null +++ b/libs/cairomm/cairomm/fontface.cc @@ -0,0 +1,74 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#include +#include + +namespace Cairo +{ + +FontFace::FontFace(cairo_font_face_t* cobject, bool has_reference) +: m_cobject(0) +{ + if(has_reference) + m_cobject = cobject; + else + m_cobject = cairo_font_face_reference(cobject); +} + +FontFace::~FontFace() +{ + if(m_cobject) + cairo_font_face_destroy(m_cobject); +} + +void FontFace::reference() const +{ + cairo_font_face_reference(m_cobject); +} + +void FontFace::unreference() const +{ + cairo_font_face_destroy(m_cobject); +} + +/* +void* FontFace::get_user_data(const cairo_user_data_key_t *key) +{ + void* result = cairo_font_face_get_user_data(m_cobject, key); + check_object_status_and_throw_exception(*this); + return result; +} + +void FontFace::set_user_data(const cairo_user_data_key_t* key, void *user_data, cairo_destroy_func_t destroy) +{ + const ErrorStatus status = (ErrorStatus)cairo_font_face_set_user_data(m_cobject, key, user_data, destroy); + check_status_and_throw_exception(status); +} +*/ + +FontType FontFace::get_type() const +{ + cairo_font_type_t font_type = cairo_font_face_get_type(m_cobject); + check_object_status_and_throw_exception(*this); + return static_cast(font_type); +} + +} //namespace Cairo + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/fontface.h b/libs/cairomm/cairomm/fontface.h new file mode 100644 index 0000000000..612820cc8b --- /dev/null +++ b/libs/cairomm/cairomm/fontface.h @@ -0,0 +1,79 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __CAIROMM_FONTFACE_H +#define __CAIROMM_FONTFACE_H + +#include +#include + + +namespace Cairo +{ + +/** + * This is a reference-counted object that should be used via Cairo::RefPtr. + */ +class FontFace +{ +protected: + + //TODO?: FontFace(cairo_font_face_t *target); + +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be given to a RefPtr. + * @param cobject The C instance. + * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference. + */ + explicit FontFace(cairo_font_face_t* cobject, bool has_reference = false); + + + virtual ~FontFace(); + + /* Don't wrap these until we know what they are good for. + void* get_user_data(const cairo_user_data_key_t *key); + + void set_user_data(const cairo_user_data_key_t *key, void *user_data, cairo_destroy_func_t destroy); + */ + + FontType get_type() const; + + typedef cairo_font_face_t cobject; + inline cobject* cobj() { return m_cobject; } + inline const cobject* cobj() const { return m_cobject; } + + #ifndef DOXYGEN_IGNORE_THIS + ///For use only by the cairomm implementation. + inline ErrorStatus get_status() const + { return cairo_font_face_status(const_cast(cobj())); } + #endif //DOXYGEN_IGNORE_THIS + + void reference() const; + void unreference() const; + +protected: + + cobject* m_cobject; +}; + +} // namespace Cairo + +#endif //__CAIROMM_FONTFACE_H + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/fontoptions.cc b/libs/cairomm/cairomm/fontoptions.cc new file mode 100644 index 0000000000..864037c8fb --- /dev/null +++ b/libs/cairomm/cairomm/fontoptions.cc @@ -0,0 +1,159 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#include +#include + +namespace Cairo +{ + +FontOptions::FontOptions() +: m_cobject(0) +{ + m_cobject = cairo_font_options_create(); + check_object_status_and_throw_exception(*this); +} + +FontOptions::FontOptions(cairo_font_options_t* cobject, bool take_ownership) +: m_cobject(0) +{ + if(take_ownership) + m_cobject = cobject; + else + m_cobject = cairo_font_options_copy(cobject); + + check_object_status_and_throw_exception(*this); +} + +FontOptions::FontOptions(const FontOptions& src) +{ + //Reference-counting, instead of copying by value: + if(!src.m_cobject) + m_cobject = 0; + else + m_cobject = cairo_font_options_copy(src.m_cobject); + + check_object_status_and_throw_exception(*this); +} + +FontOptions::~FontOptions() +{ + if(m_cobject) + cairo_font_options_destroy(m_cobject); +} + + +FontOptions& FontOptions::operator=(const FontOptions& src) +{ + //Reference-counting, instead of copying by value: + + if(this == &src) + return *this; + + if(m_cobject == src.m_cobject) + return *this; + + if(m_cobject) + { + cairo_font_options_destroy(m_cobject); + m_cobject = 0; + } + + if(!src.m_cobject) + return *this; + + m_cobject = cairo_font_options_copy(src.m_cobject); + + return *this; +} + +bool FontOptions::operator==(const FontOptions& src) const +{ + return cairo_font_options_equal(m_cobject, src.cobj()); +} + +void FontOptions::merge(const FontOptions& src) +{ + cairo_font_options_merge(m_cobject, src.cobj()); + check_object_status_and_throw_exception(*this); +} + +unsigned long FontOptions::hash() const +{ + const unsigned long result = cairo_font_options_hash(m_cobject); + check_object_status_and_throw_exception(*this); + return result; +} + +void FontOptions::set_antialias(Antialias antialias) +{ + cairo_font_options_set_antialias(m_cobject, static_cast(antialias)); + check_object_status_and_throw_exception(*this); +} + +Antialias FontOptions::get_antialias() const +{ + const Antialias result = static_cast(cairo_font_options_get_antialias(m_cobject)); + check_object_status_and_throw_exception(*this); + return result; +} + +void FontOptions::set_subpixel_order(SubpixelOrder subpixel_order) +{ + cairo_font_options_set_subpixel_order(m_cobject, static_cast(subpixel_order)); + check_object_status_and_throw_exception(*this); +} + +SubpixelOrder FontOptions::get_subpixel_order() const +{ + const SubpixelOrder result = static_cast(cairo_font_options_get_subpixel_order(m_cobject)); + check_object_status_and_throw_exception(*this); + return result; +} + +void FontOptions::set_hint_style(HintStyle hint_style) +{ + cairo_font_options_set_hint_style(m_cobject, static_cast(hint_style)); + check_object_status_and_throw_exception(*this); +} + +HintStyle FontOptions::get_hint_style() const +{ + const HintStyle result = static_cast(cairo_font_options_get_hint_style(m_cobject)); + check_object_status_and_throw_exception(*this); + return result; +} + +void FontOptions::set_hint_metrics(HintMetrics hint_metrics) +{ + cairo_font_options_set_hint_metrics(m_cobject, + static_cast(hint_metrics)); + check_object_status_and_throw_exception(*this); +} + +HintMetrics FontOptions::get_hint_metrics() const +{ + const HintMetrics result = + static_cast(cairo_font_options_get_hint_metrics(m_cobject)); + check_object_status_and_throw_exception(*this); + return result; +} + +} //namespace Cairo + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/fontoptions.h b/libs/cairomm/cairomm/fontoptions.h new file mode 100644 index 0000000000..3c35176121 --- /dev/null +++ b/libs/cairomm/cairomm/fontoptions.h @@ -0,0 +1,81 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __CAIROMM_FONTOPTIONS_H +#define __CAIROMM_FONTOPTIONS_H + +#include +#include +#include + + +namespace Cairo +{ + +/** How a font should be rendered. + */ +class FontOptions +{ +public: + FontOptions(); + explicit FontOptions(cairo_font_options_t* cobject, bool take_ownership = false); + FontOptions(const FontOptions& src); + + virtual ~FontOptions(); + + FontOptions& operator=(const FontOptions& src); + + bool operator ==(const FontOptions& src) const; + //bool operator !=(const FontOptions& src) const; + + void merge(const FontOptions& other); + + unsigned long hash() const; + + void set_antialias(Antialias antialias); + Antialias get_antialias() const; + + void set_subpixel_order(SubpixelOrder subpixel_order); + SubpixelOrder get_subpixel_order() const; + + void set_hint_style(HintStyle hint_style); + HintStyle get_hint_style() const; + + void set_hint_metrics(HintMetrics hint_metrics); + HintMetrics get_hint_metrics() const; + + typedef cairo_font_options_t cobject; + inline cobject* cobj() { return m_cobject; } + inline const cobject* cobj() const { return m_cobject; } + + #ifndef DOXYGEN_IGNORE_THIS + ///For use only by the cairomm implementation. + inline ErrorStatus get_status() const + { return cairo_font_options_status(const_cast(cobj())); } + #endif //DOXYGEN_IGNORE_THIS + +protected: + + cobject* m_cobject; +}; + +} // namespace Cairo + +#endif //__CAIROMM_FONTOPTIONS_H + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/path.cc b/libs/cairomm/cairomm/path.cc new file mode 100644 index 0000000000..8040aa3e6b --- /dev/null +++ b/libs/cairomm/cairomm/path.cc @@ -0,0 +1,98 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#include +#include +#include + +namespace Cairo +{ + +/* +Path::Path() +: m_cobject(0) +{ + m_cobject = cairo_path_create(); +} +*/ + +Path::Path(cairo_path_t* cobject, bool take_ownership) +: m_cobject(0) +{ + if(take_ownership) + m_cobject = cobject; + else + { + std::cerr << "cairomm: Path::Path(): copying of the underlying cairo_path_t* is not yet implemented." << std::endl; + //m_cobject = cairo_path_copy(cobject); + } +} + +/* +Path::Path(const Path& src) +{ + //Reference-counting, instead of copying by value: + if(!src.m_cobject) + m_cobject = 0; + else + m_cobject = cairo_path_copy(src.m_cobject); +} +*/ + +Path::~Path() +{ + if(m_cobject) + cairo_path_destroy(m_cobject); +} + +/* +Path& Path::operator=(const Path& src) +{ + //Reference-counting, instead of copying by value: + + if(this == &src) + return *this; + + if(m_cobject == src.m_cobject) + return *this; + + if(m_cobject) + { + cairo_path_destroy(m_cobject); + m_cobject = 0; + } + + if(!src.m_cobject) + return *this; + + m_cobject = cairo_path_copy(src.m_cobject); + + return *this; +} +*/ + +/* +bool Path::operator==(const Path& src) const +{ + return cairo_path_equal(m_cobject, src.cobj()); +} +*/ + +} //namespace Cairo + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/path.h b/libs/cairomm/cairomm/path.h new file mode 100644 index 0000000000..f5f7480908 --- /dev/null +++ b/libs/cairomm/cairomm/path.h @@ -0,0 +1,72 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __CAIROMM_PATH_H +#define __CAIROMM_PATH_H + +#include +#include +#include + + +namespace Cairo +{ + +/** A data structure for holding a path. + * Use Context::copy_path() or Context::copy_path_flat() to instantiate a new + * Path. The application is responsible for freeing the Path object when it is + * no longer needed. + * + * @todo There's currently no way to access the path data without reverting to + * the C object (see cobj()) + */ +class Path +{ +public: + //Path(); + explicit Path(cairo_path_t* cobject, bool take_ownership = false); + //Path(const Path& src); + + virtual ~Path(); + + //Path& operator=(const Path& src); + + //bool operator ==(const Path& src) const; + //bool operator !=(const Path& src) const; + + typedef cairo_path_t cobject; + inline cobject* cobj() { return m_cobject; } + inline const cobject* cobj() const { return m_cobject; } + + #ifndef DOXYGEN_IGNORE_THIS + ///For use only by the cairomm implementation. + //There is no *_status() function for this object: + //inline ErrorStatus get_status() const + //{ return cairo_path_status(const_cast(cobj())); } + #endif //DOXYGEN_IGNORE_THIS + +protected: + + cobject* m_cobject; +}; + +} // namespace Cairo + +#endif //__CAIROMM_PATH_H + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/pattern.cc b/libs/cairomm/cairomm/pattern.cc new file mode 100644 index 0000000000..27638cd400 --- /dev/null +++ b/libs/cairomm/cairomm/pattern.cc @@ -0,0 +1,219 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#include +#include + +namespace Cairo +{ + +Pattern::Pattern() +: m_cobject(0) +{ +} + +Pattern::Pattern(cairo_pattern_t* cobject, bool has_reference) +: m_cobject(0) +{ + if(has_reference) + m_cobject = cobject; + else + m_cobject = cairo_pattern_reference(cobject); +} + +Pattern::~Pattern() +{ + if(m_cobject) + cairo_pattern_destroy(m_cobject); +} + +void Pattern::reference() const +{ + cairo_pattern_reference(m_cobject); +} + +void Pattern::unreference() const +{ + cairo_pattern_destroy(m_cobject); +} + +void Pattern::set_matrix(const cairo_matrix_t &matrix) +{ + cairo_pattern_set_matrix(m_cobject, &matrix); + check_object_status_and_throw_exception(*this); +} + +void Pattern::get_matrix(cairo_matrix_t &matrix) const +{ + cairo_pattern_get_matrix(m_cobject, &matrix); + check_object_status_and_throw_exception(*this); +} + +PatternType Pattern::get_type() const +{ + cairo_pattern_type_t pattern_type = cairo_pattern_get_type(m_cobject); + check_object_status_and_throw_exception(*this); + return static_cast(pattern_type); +} + + + +SolidPattern::SolidPattern(cairo_pattern_t* cobject, bool has_reference) +: Pattern(cobject, has_reference) +{ +} + +SolidPattern::~SolidPattern() +{ +} + +RefPtr SolidPattern::create_rgb(double red, double green, double blue) +{ + cairo_pattern_t* cobject = cairo_pattern_create_rgb(red, green, blue); + check_status_and_throw_exception(cairo_pattern_status(cobject)); + return RefPtr(new SolidPattern(cobject, true /* has reference */)); +} + +RefPtr SolidPattern::create_rgba(double red, double green, double blue, double alpha) +{ + cairo_pattern_t* cobject = cairo_pattern_create_rgba(red, green, blue, alpha); + check_status_and_throw_exception(cairo_pattern_status(cobject)); + return RefPtr(new SolidPattern(cobject, true /* has reference */)); +} + + +SurfacePattern::SurfacePattern(const RefPtr& surface) +{ + m_cobject = cairo_pattern_create_for_surface(surface->cobj()); + check_object_status_and_throw_exception(*this); +} + +RefPtr SurfacePattern::create(const RefPtr& surface) +{ + return RefPtr(new SurfacePattern(surface)); +} + +SurfacePattern::SurfacePattern(cairo_pattern_t* cobject, bool has_reference) +: Pattern(cobject, has_reference) +{ +} + +SurfacePattern::~SurfacePattern() +{ +} + +void SurfacePattern::set_extend(Extend extend) +{ + cairo_pattern_set_extend(m_cobject, (cairo_extend_t)extend); + check_object_status_and_throw_exception(*this); +} + +Extend SurfacePattern::get_extend() const +{ + const Extend result = static_cast(cairo_pattern_get_extend(m_cobject)); + check_object_status_and_throw_exception(*this); + return result; +} + +void SurfacePattern::set_filter(Filter filter) +{ + cairo_pattern_set_filter(m_cobject, (cairo_filter_t)filter); + check_object_status_and_throw_exception(*this); +} + +Filter SurfacePattern::get_filter() const +{ + Filter result = static_cast(cairo_pattern_get_filter(m_cobject)); + check_object_status_and_throw_exception(*this); + return result; +} + + + +Gradient::Gradient() +{ +} + +Gradient::Gradient(cairo_pattern_t* cobject, bool has_reference) +: Pattern(cobject, has_reference) +{ +} + +Gradient::~Gradient() +{ +} + +void Gradient::add_color_stop_rgb(double offset, double red, double green, double blue) +{ + cairo_pattern_add_color_stop_rgb(m_cobject, offset, red, green, blue); + check_object_status_and_throw_exception(*this); +} + +void Gradient::add_color_stop_rgba(double offset, double red, double green, double blue, double alpha) +{ + cairo_pattern_add_color_stop_rgba(m_cobject, offset, red, green, blue, alpha); + check_object_status_and_throw_exception(*this); +} + + + +LinearGradient::LinearGradient(double x0, double y0, double x1, double y1) +{ + m_cobject = cairo_pattern_create_linear(x0, y0, x1, y1); + check_object_status_and_throw_exception(*this); +} + +RefPtr LinearGradient::create(double x0, double y0, double x1, double y1) +{ + return RefPtr(new LinearGradient(x0, y0, x1, y1)); +} + +LinearGradient::LinearGradient(cairo_pattern_t* cobject, bool has_reference) +: Gradient(cobject, has_reference) +{ +} + +LinearGradient::~LinearGradient() +{ +} + + +RadialGradient::RadialGradient(double cx0, double cy0, double radius0, double cx1, double cy1, double radius1) +{ + m_cobject = cairo_pattern_create_radial(cx0, cy0, radius0, cx1, cy1, radius1); + check_object_status_and_throw_exception(*this); +} + +RefPtr RadialGradient::create(double cx0, double cy0, double radius0, double cx1, double cy1, double radius1) +{ + return RefPtr(new RadialGradient(cx0, cy0, radius0, cx1, cy1, radius1)); +} + +RadialGradient::RadialGradient(cairo_pattern_t* cobject, bool has_reference) +: Gradient(cobject, has_reference) +{ +} + +RadialGradient::~RadialGradient() +{ +} + + +} //namespace Cairo + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/pattern.h b/libs/cairomm/cairomm/pattern.h new file mode 100644 index 0000000000..2624d7a5d9 --- /dev/null +++ b/libs/cairomm/cairomm/pattern.h @@ -0,0 +1,189 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __CAIROMM_PATTERN_H +#define __CAIROMM_PATTERN_H + +#include +#include +#include + + +namespace Cairo +{ + +/** + * This is a reference-counted object that should be used via Cairo::RefPtr. + */ +class Pattern +{ +protected: + //Use derived constructors. + + //TODO?: Pattern(cairo_pattern_t *target); + +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be given to a RefPtr. + * @param cobject The C instance. + * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference. + */ + explicit Pattern(cairo_pattern_t* cobject, bool has_reference = false); + + virtual ~Pattern(); + + void set_matrix(const cairo_matrix_t &matrix); + void get_matrix(cairo_matrix_t &matrix) const; + PatternType get_type() const; + + typedef cairo_pattern_t cobject; + inline cobject* cobj() { return m_cobject; } + inline const cobject* cobj() const { return m_cobject; } + + #ifndef DOXYGEN_IGNORE_THIS + ///For use only by the cairomm implementation. + inline ErrorStatus get_status() const + { return cairo_pattern_status(const_cast(cobj())); } + #endif //DOXYGEN_IGNORE_THIS + + void reference() const; + void unreference() const; + +protected: + //Used by derived types only. + Pattern(); + + cobject* m_cobject; +}; + +class SolidPattern : public Pattern +{ +protected: + +public: + + /** Create a C++ wrapper for the C instance. + * @param cobject The C instance. + * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference. + */ + explicit SolidPattern(cairo_pattern_t* cobject, bool has_reference = false); + + static RefPtr create_rgb(double red, double green, double blue); + static RefPtr create_rgba(double red, double green, double blue, double alpha); + + //TODO?: SolidPattern(cairo_pattern_t *target); + virtual ~SolidPattern(); +}; + +class SurfacePattern : public Pattern +{ +protected: + + explicit SurfacePattern(const RefPtr& surface); + + //TODO?: SurfacePattern(cairo_pattern_t *target); + +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be given to a RefPtr. + * @param cobject The C instance. + * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference. + */ + explicit SurfacePattern(cairo_pattern_t* cobject, bool has_reference = false); + + + virtual ~SurfacePattern(); + + static RefPtr create(const RefPtr& surface); + + void set_extend(Extend extend); + Extend get_extend() const; + void set_filter(Filter filter); + Filter get_filter() const; +}; + +class Gradient : public Pattern +{ +protected: + //Use derived constructors. + + //TODO?: Gradient(cairo_pattern_t *target); + +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be given to a RefPtr. + * @param cobject The C instance. + * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference. + */ + explicit Gradient(cairo_pattern_t* cobject, bool has_reference = false); + + virtual ~Gradient(); + + void add_color_stop_rgb(double offset, double red, double green, double blue); + void add_color_stop_rgba(double offset, double red, double green, double blue, double alpha); + +protected: + Gradient(); +}; + +class LinearGradient : public Gradient +{ +protected: + + LinearGradient(double x0, double y0, double x1, double y1); + +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be given to a RefPtr. + * @param cobject The C instance. + * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference. + */ + explicit LinearGradient(cairo_pattern_t* cobject, bool has_reference = false); + + //TODO?: LinearGradient(cairo_pattern_t *target); + virtual ~LinearGradient(); + + static RefPtr create(double x0, double y0, double x1, double y1); +}; + +class RadialGradient : public Gradient +{ +protected: + + RadialGradient(double cx0, double cy0, double radius0, double cx1, double cy1, double radius1); + +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be given to a RefPtr. + * @param cobject The C instance. + * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference. + */ + explicit RadialGradient(cairo_pattern_t* cobject, bool has_reference = false); + + + //TODO?: RadialGradient(cairo_pattern_t *target); + virtual ~RadialGradient(); + + static RefPtr create(double cx0, double cy0, double radius0, double cx1, double cy1, double radius1); +}; + +} // namespace Cairo + +#endif //__CAIROMM_PATTERN_H + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/private.cc b/libs/cairomm/cairomm/private.cc new file mode 100644 index 0000000000..68d09f9562 --- /dev/null +++ b/libs/cairomm/cairomm/private.cc @@ -0,0 +1,76 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#include +#include +#include +#include + +namespace Cairo +{ + +void throw_exception(ErrorStatus status) +{ + switch(status) + { + case CAIRO_STATUS_SUCCESS: + // we should never get here, but just in case + break; + + case CAIRO_STATUS_NO_MEMORY: + throw std::bad_alloc(); + break; + + // Programmer error + case CAIRO_STATUS_INVALID_RESTORE: + case CAIRO_STATUS_INVALID_POP_GROUP: + case CAIRO_STATUS_NO_CURRENT_POINT: + case CAIRO_STATUS_INVALID_MATRIX: + //No longer in API?: case CAIRO_STATUS_NO_TARGET_SURFACE: + case CAIRO_STATUS_INVALID_STRING: + case CAIRO_STATUS_SURFACE_FINISHED: + //No longer in API?: case CAIRO_STATUS_BAD_NESTING: + throw Cairo::logic_error(status); + break; + + // Language binding implementation: + case CAIRO_STATUS_NULL_POINTER: + case CAIRO_STATUS_INVALID_PATH_DATA: + case CAIRO_STATUS_SURFACE_TYPE_MISMATCH: + throw Cairo::logic_error(status); + break; + + // Other + case CAIRO_STATUS_READ_ERROR: + case CAIRO_STATUS_WRITE_ERROR: + { + //The Cairo language binding advice suggests that these are stream errors + //that should be mapped to their C++ equivalents. + const char* error_message = cairo_status_to_string(status); + throw std::ios_base::failure( error_message ? error_message : std::string() ); + } + + default: + throw Cairo::logic_error(status); + break; + } +} + +} //namespace Cairo + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/private.h b/libs/cairomm/cairomm/private.h new file mode 100644 index 0000000000..7b18c5bc21 --- /dev/null +++ b/libs/cairomm/cairomm/private.h @@ -0,0 +1,50 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __CAIROMM_PRIVATE_H +#define __CAIROMM_PRIVATE_H + +#include +#include +#include + + +namespace Cairo +{ + +void throw_exception(ErrorStatus status); + +//We inline this because it is called so often. +inline void check_status_and_throw_exception(ErrorStatus status) +{ + if(status != CAIRO_STATUS_SUCCESS) + throw_exception(status); //This part doesn't need to be inline because it would rarely be called. +} + +template +void check_object_status_and_throw_exception(const T& object) +{ + //get_status() is normally an inlined member method. + check_status_and_throw_exception(object.get_status()); +} + +} // namespace Cairo + +#endif //__CAIROMM_PRIVATE_H + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/refptr.h b/libs/cairomm/cairomm/refptr.h new file mode 100644 index 0000000000..c346fe0001 --- /dev/null +++ b/libs/cairomm/cairomm/refptr.h @@ -0,0 +1,391 @@ +// -*- c++ -*- +#ifndef _cairo_REFPTR_H +#define _cairo_REFPTR_H + +/* $Id: refptr.h,v 1.6 2006/09/27 18:38:57 murrayc Exp $ */ + +/* Copyright 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + + +namespace Cairo +{ + +/** RefPtr<> is a reference-counting shared smartpointer. + * + * Reference counting means that a shared reference count is incremented each + * time a RefPtr is copied, and decremented each time a RefPtr is destroyed, + * for instance when it leaves its scope. When the reference count reaches + * zero, the contained object is deleted + * + * cairomm uses RefPtr so that you don't need to remember + * to delete the object explicitly, or know when a method expects you to delete + * the object that it returns, and to prevent any need to manually reference + * and unreference() cairo objects. + */ +template +class RefPtr +{ +public: + /** Default constructor + * + * Afterwards it will be null and use of -> will cause a segmentation fault. + */ + inline RefPtr(); + + /// Destructor - decrements reference count. + inline ~RefPtr(); + + /** For use only in the internal implementation of cairomm, gtkmm, etc. + * + * This takes ownership of @a pCppObject, so it will be deleted when the + * last RefPtr is deleted, for instance when it goes out of scope. + * + * This assumes that @a pCppObject already has a starting reference for its underlying cairo object, + * so that destruction of @a @pCppObject will cause a corresponding unreference of its underlying + * cairo object. For instance, a cairo_*_create() function usually provides a starting reference, + * but a cairo_*_get_*() function requires the caller to manually reference the returned object. + * In this case, you should call reference() on @a pCppObject before passing it to this constructor. + */ + explicit inline RefPtr(T_CppObject* pCppObject); + + /** Copy constructor + * + * This increments the shared reference count. + */ + inline RefPtr(const RefPtr& src); + + /** Copy constructor (from different, but castable type). + * + * Increments the reference count. + */ + template + inline RefPtr(const RefPtr& src); + + /** Swap the contents of two RefPtr<>. + * This method swaps the internal pointers to T_CppObject. This can be + * done safely without involving a reference/unreference cycle and is + * therefore highly efficient. + */ + inline void swap(RefPtr& other); + + /// Copy from another RefPtr: + inline RefPtr& operator=(const RefPtr& src); + + /** Copy from different, but castable type). + * + * Increments the reference count. + */ + template + inline RefPtr& operator=(const RefPtr& src); + + /// Tests whether the RefPtr<> point to the same underlying instance. + inline bool operator==(const RefPtr& src) const; + + /// See operator==(). + inline bool operator!=(const RefPtr& src) const; + + /** Dereferencing. + * + * Use the methods of the underlying instance like so: + * refptr->memberfun(). + */ + inline T_CppObject* operator->() const; + + /** Test whether the RefPtr<> points to any underlying instance. + * + * Mimics usage of ordinary pointers: + * @code + * if (ptr) + * do_something(); + * @endcode + */ + inline operator bool() const; + + /// Set underlying instance to 0, decrementing reference count of existing instance appropriately. + inline void clear(); + + + /** Dynamic cast to derived class. + * + * The RefPtr can't be cast with the usual notation so instead you can use + * @code + * ptr_derived = RefPtr::cast_dynamic(ptr_base); + * @endcode + */ + template + static inline RefPtr cast_dynamic(const RefPtr& src); + + /** Static cast to derived class. + * + * Like the dynamic cast; the notation is + * @code + * ptr_derived = RefPtr::cast_static(ptr_base); + * @endcode + */ + template + static inline RefPtr cast_static(const RefPtr& src); + + /** Cast to non-const. + * + * The RefPtr can't be cast with the usual notation so instead you can use + * @code + * ptr_unconst = RefPtr::cast_const(ptr_const); + * @endcode + */ + template + static inline RefPtr cast_const(const RefPtr& src); + + +#ifndef DOXYGEN_IGNORE_THIS + + // Warning: This is for internal use only. Do not manually modify the + // reference count with this pointer. + inline int* refcount_() const { return pCppRefcount_; } + +#endif // DOXYGEN_IGNORE_THIS + +private: + void unref(); + + T_CppObject* pCppObject_; + mutable int* pCppRefcount_; +}; + + +#ifndef DOXYGEN_IGNORE_THIS + +// RefPtr<>::operator->() comes first here since it's used by other methods. +// If it would come after them it wouldn't be inlined. + +template inline +T_CppObject* RefPtr::operator->() const +{ + return pCppObject_; +} + +template inline +RefPtr::RefPtr() +: + pCppObject_(0), + pCppRefcount_(0) +{} + +template inline +RefPtr::~RefPtr() +{ + unref(); +} + +template inline +void RefPtr::unref() +{ + if(pCppRefcount_) + { + --(*pCppRefcount_); + + if(*pCppRefcount_ == 0) + { + if(pCppObject_) + { + delete pCppObject_; + pCppObject_ = 0; + } + + delete pCppRefcount_; + pCppRefcount_ = 0; + } + } +} + + +template inline +RefPtr::RefPtr(T_CppObject* pCppObject) +: + pCppObject_(pCppObject), + pCppRefcount_(0) +{ + if(pCppObject) + { + pCppRefcount_ = new int; + *pCppRefcount_ = 1; //This will be decremented in the destructor. + } +} + +template inline +RefPtr::RefPtr(const RefPtr& src) +: + pCppObject_ (src.pCppObject_), + pCppRefcount_(src.pCppRefcount_) +{ + if(pCppObject_ && pCppRefcount_) + ++(*pCppRefcount_); +} + +// The templated ctor allows copy construction from any object that's +// castable. Thus, it does downcasts: +// base_ref = derived_ref +template + template +inline +RefPtr::RefPtr(const RefPtr& src) +: + // A different RefPtr<> will not allow us access to pCppObject_. We need + // to add a get_underlying() for this, but that would encourage incorrect + // use, so we use the less well-known operator->() accessor: + pCppObject_ (src.operator->()), + pCppRefcount_(src.refcount_()) +{ + if(pCppObject_ && pCppRefcount_) + ++(*pCppRefcount_); +} + +template inline +void RefPtr::swap(RefPtr& other) +{ + T_CppObject *const temp = pCppObject_; + int* temp_count = pCppRefcount_; + + pCppObject_ = other.pCppObject_; + pCppRefcount_ = other.pCppRefcount_; + + other.pCppObject_ = temp; + other.pCppRefcount_ = temp_count; +} + +template inline +RefPtr& RefPtr::operator=(const RefPtr& src) +{ + // In case you haven't seen the swap() technique to implement copy + // assignment before, here's what it does: + // + // 1) Create a temporary RefPtr<> instance via the copy ctor, thereby + // increasing the reference count of the source object. + // + // 2) Swap the internal object pointers of *this and the temporary + // RefPtr<>. After this step, *this already contains the new pointer, + // and the old pointer is now managed by temp. + // + // 3) The destructor of temp is executed, thereby unreferencing the + // old object pointer. + // + // This technique is described in Herb Sutter's "Exceptional C++", and + // has a number of advantages over conventional approaches: + // + // - Code reuse by calling the copy ctor. + // - Strong exception safety for free. + // - Self assignment is handled implicitely. + // - Simplicity. + // - It just works and is hard to get wrong; i.e. you can use it without + // even thinking about it to implement copy assignment whereever the + // object data is managed indirectly via a pointer, which is very common. + + RefPtr temp (src); + this->swap(temp); + return *this; +} + +template + template +inline +RefPtr& RefPtr::operator=(const RefPtr& src) +{ + RefPtr temp (src); + this->swap(temp); + return *this; +} + +template inline +bool RefPtr::operator==(const RefPtr& src) const +{ + return (pCppObject_ == src.pCppObject_); +} + +template inline +bool RefPtr::operator!=(const RefPtr& src) const +{ + return (pCppObject_ != src.pCppObject_); +} + +template inline +RefPtr::operator bool() const +{ + return (pCppObject_ != 0); +} + +template inline +void RefPtr::clear() +{ + RefPtr temp; // swap with an empty RefPtr<> to clear *this + this->swap(temp); +} + +template + template +inline +RefPtr RefPtr::cast_dynamic(const RefPtr& src) +{ + T_CppObject *const pCppObject = dynamic_cast(src.operator->()); + + if(pCppObject && src.refcount_()) + ++(*(src.refcount_())); + + return RefPtr(pCppObject); //TODO: Does an unnecessary extra reference() on the C object. +} + +template + template +inline +RefPtr RefPtr::cast_static(const RefPtr& src) +{ + T_CppObject *const pCppObject = static_cast(src.operator->()); + + if(pCppObject && src.refcount_()) + ++(*(src.refcount_())); + + return RefPtr(pCppObject); //TODO: Does an unnecessary extra reference() on the C object. +} + +template + template +inline +RefPtr RefPtr::cast_const(const RefPtr& src) +{ + T_CppObject *const pCppObject = const_cast(src.operator->()); + + if(pCppObject && src.refcount_()) + ++(*(src.refcount_())); + + return RefPtr(pCppObject); //TODO: Does an unnecessary extra reference() on the C object. +} + +#endif /* DOXYGEN_IGNORE_THIS */ + +/** @relates Glib::RefPtr */ +template inline +void swap(RefPtr& lhs, RefPtr& rhs) +{ + lhs.swap(rhs); +} + +} // namespace Cairo + + +#endif /* _cairo_REFPTR_H */ + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/scaledfont.cc b/libs/cairomm/cairomm/scaledfont.cc new file mode 100644 index 0000000000..02fb11c567 --- /dev/null +++ b/libs/cairomm/cairomm/scaledfont.cc @@ -0,0 +1,104 @@ +/* Copyright (C) 2006 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#include +#include // for check_status_and_throw_exception + +namespace Cairo +{ + +ScaledFont::ScaledFont(cobject* cobj, bool has_reference) +{ + if(has_reference) + m_cobject = cobj; + else + m_cobject = cairo_scaled_font_reference(cobj); +} + +RefPtr ScaledFont::create(FontFace& font_face, const Matrix& font_matrix, + const Matrix& ctm, const FontOptions& options) +{ + cairo_scaled_font_t* cobj = cairo_scaled_font_create(font_face.cobj(), &font_matrix, &ctm, options.cobj()); + check_status_and_throw_exception(cairo_scaled_font_status(cobj)); + return RefPtr(new ScaledFont(cobj, false)); +} + +void ScaledFont::extents(FontExtents& extents) const +{ + cairo_scaled_font_extents(m_cobject, static_cast(&extents)); + check_object_status_and_throw_exception(*this); +} + +void ScaledFont::text_extents(const std::string& utf8, TextExtents& extents) const +{ + cairo_scaled_font_text_extents(m_cobject, utf8.c_str(), static_cast(&extents)); + check_object_status_and_throw_exception(*this); +} + +void ScaledFont::glyph_extents(const std::vector& glyphs, TextExtents& extents) +{ + // copy the data from the vector to a standard C array. I don't believe + // this will be a frequently used function so I think the performance hit is + // more than offset by the increased flexibility of the STL interface. + + // Use new to allocate memory as MSCV complains about non-const array size with + // Glyph glyph_array[glyphs.size()] + Glyph* glyph_array= new Glyph[glyphs.size()]; + std::copy(glyphs.begin(), glyphs.end(), glyph_array); + + cairo_scaled_font_glyph_extents(m_cobject, glyph_array, glyphs.size(), + static_cast(&extents)); + check_object_status_and_throw_exception(*this); + delete[] glyph_array; +} + +RefPtr ScaledFont::get_font_face() const +{ + cairo_font_face_t* face = cairo_scaled_font_get_font_face(m_cobject); + check_object_status_and_throw_exception(*this); + return RefPtr(new FontFace(face, true)); +} + +void ScaledFont::get_font_options(FontOptions& options) const +{ + cairo_scaled_font_get_font_options(m_cobject, options.cobj()); + check_object_status_and_throw_exception(*this); +} + +void ScaledFont::get_font_matrix(Matrix& font_matrix) const +{ + cairo_scaled_font_get_font_matrix(m_cobject, + static_cast(&font_matrix)); + check_object_status_and_throw_exception(*this); +} + +void ScaledFont::get_ctm(Matrix& ctm) const +{ + cairo_scaled_font_get_ctm(m_cobject, static_cast(&ctm)); + check_object_status_and_throw_exception(*this); +} + +FontType ScaledFont::get_type() const +{ + cairo_font_type_t font_type = cairo_scaled_font_get_type(m_cobject); + check_object_status_and_throw_exception(*this); + return static_cast(font_type); +} + +} // namespace Cairo +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/scaledfont.h b/libs/cairomm/cairomm/scaledfont.h new file mode 100644 index 0000000000..9ad077c7d5 --- /dev/null +++ b/libs/cairomm/cairomm/scaledfont.h @@ -0,0 +1,153 @@ +/* Copyright (C) 2006 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __CAIROMM_SCALEDFONT_H +#define __CAIROMM_SCALEDFONT_H + +#include +#include + +namespace Cairo +{ + +typedef enum +{ +} ScaledFontType; + +/** A ScaledFont is a font scaled to a particular size and device resolution. It + * is most useful for low-level font usage where a library or application wants + * to cache a reference to a scaled font to speed up the computation of metrics. + */ +class ScaledFont +{ + +public: + /** The underlying C cairo object type */ + typedef cairo_scaled_font_t cobject; + + /** Provides acces to the underlying C cairo object */ + inline cobject* cobj() { return m_cobject; } + + /** Provides acces to the underlying C cairo object */ + inline const cobject* cobj() const { return m_cobject; } + +#ifndef DOXYGEN_IGNORE_THIS + // For use only by the cairomm implementation. + inline ErrorStatus get_status() const + { return cairo_scaled_font_status(const_cast(cobj())); } + + // for RefPtr + void reference() const { cairo_scaled_font_reference(m_cobject); } + void unreference() const { cairo_scaled_font_destroy(m_cobject); } +#endif //DOXYGEN_IGNORE_THIS + + /** Createa C++ wrapper object from the C instance. This C++ object should + * then be given to a RefPtr. + */ + explicit ScaledFont(cobject* cobj, bool has_reference = false); + + /** Creates a ScaledFont object from a font face and matrices that describe + * the size of the font and the environment in which it will be used. + * + * @param font_face A font face. + * @param font_matrix font space to user space transformation matrix for the + * font. In the simplest case of a N point font, this matrix is just a scale + * by N, but it can also be used to shear the font or stretch it unequally + * along the two axes. See Context::set_font_matrix(). + * @param ctm user to device transformation matrix with which the font will be + * used. + * @param options: options to use when getting metrics for the font and + * rendering with it. + */ + static RefPtr create(FontFace& font_face, const Matrix& font_matrix, + const Matrix& ctm, const FontOptions& options); + + /** Gets the metrics for a ScaledFont */ + void extents(FontExtents& extents) const; + + /** Gets the extents for a string of text. The extents describe a user-space + * rectangle that encloses the "inked" portion of the text drawn at the origin + * (0,0) (as it would be drawn by Context::show_text() if the cairo graphics + * state were set to the same font_face, font_matrix, ctm, and font_options as + * the ScaledFont object). Additionally, the x_advance and y_advance values + * indicate the amount by which the current point would be advanced by + * Context::show_text(). + * + * Note that whitespace characters do not directly contribute to the size of + * the rectangle (extents.width and extents.height). They do contribute + * indirectly by changing the position of non-whitespace characters. In + * particular, trailing whitespace characters are likely to not affect the + * size of the rectangle, though they will affect the x_advance and y_advance + * values. + * + * @param utf8 a string of text, encoded in UTF-8 + * @param extents Returns the extents of the given string + * + * @since 1.2 + */ + void text_extents(const std::string& utf8, TextExtents& extents) const; + + /** Gets the extents for an array of glyphs. The extents describe a user-space + * rectangle that encloses the "inked" portion of the glyphs, (as they would + * be drawn by Context::show_glyphs() if the cairo graphics state were set to the + * same font_face, font_matrix, ctm, and font_options as the ScaledFont + * object). Additionally, the x_advance and y_advance values indicate the + * amount by which the current point would be advanced by Context::show_glyphs(). + * + * Note that whitespace glyphs do not contribute to the size of the rectangle + * (extents.width and extents.height). + * + * @param glyphs A vector of glyphs to calculate the extents of + * @param extents Returns the extents for the array of glyphs + **/ + void glyph_extents(const std::vector& glyphs, TextExtents& extents); + + /** The FontFace with which this ScaledFont was created. + * @since 1.2 + */ + RefPtr get_font_face() const; + + /** Gets the FontOptions with which the ScaledFont was created. + * @since 1.2 + */ + void get_font_options(FontOptions& options) const; + + /** Gets the font matrix with which the ScaledFont was created. + * @since 1.2 + */ + void get_font_matrix(Matrix& font_matrix) const; + + /** Gets the CTM with which the ScaledFont was created. + * @since 1.2 + */ + void get_ctm(Matrix& ctm) const; + + /** Gets the type of scaled Font + * @since 1.2 + */ + FontType get_type() const; + + protected: + /** The underlying C cairo object that is wrapped by this ScaledFont */ + cobject* m_cobject; +}; + +} + +#endif // __CAIROMM_SCALEDFONT_H +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/surface.cc b/libs/cairomm/cairomm/surface.cc new file mode 100644 index 0000000000..90cc303f05 --- /dev/null +++ b/libs/cairomm/cairomm/surface.cc @@ -0,0 +1,382 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#include +#include + +namespace Cairo +{ + +Surface::Surface(cairo_surface_t* cobject, bool has_reference) +: m_cobject(0) +{ + if(has_reference) + m_cobject = cobject; + else + m_cobject = cairo_surface_reference(cobject); +} + +Surface::~Surface() +{ + if(m_cobject) + cairo_surface_destroy(m_cobject); +} + +void Surface::finish() +{ + cairo_surface_finish(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Surface::get_font_options(FontOptions& options) const +{ + cairo_font_options_t* cfontoptions = cairo_font_options_create(); + cairo_surface_get_font_options(m_cobject, cfontoptions); + options = FontOptions(cfontoptions); + cairo_font_options_destroy(cfontoptions); + check_object_status_and_throw_exception(*this); +} + +void Surface::flush() +{ + cairo_surface_flush(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Surface::mark_dirty() +{ + cairo_surface_mark_dirty(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void Surface::mark_dirty(int x, int y, int width, int height) +{ + cairo_surface_mark_dirty_rectangle(m_cobject, x, y, width, height); + check_object_status_and_throw_exception(*this); +} + +void Surface::set_device_offset(double x_offset, double y_offset) +{ + cairo_surface_set_device_offset(m_cobject, x_offset, y_offset); + check_object_status_and_throw_exception(*this); +} + +void Surface::get_device_offset(double& x_offset, double& y_offset) const +{ + cairo_surface_get_device_offset(const_cast(m_cobject), &x_offset, &y_offset); +} + +void Surface::set_fallback_resolution(double x_pixels_per_inch, double y_pixels_per_inch) +{ + cairo_surface_set_fallback_resolution(m_cobject, x_pixels_per_inch, y_pixels_per_inch); + check_object_status_and_throw_exception(*this); +} + +SurfaceType Surface::get_type() const +{ + cairo_surface_type_t surface_type = cairo_surface_get_type(m_cobject); + check_object_status_and_throw_exception(*this); + return static_cast(surface_type); +} + +#ifdef CAIRO_HAS_PNG_FUNCTIONS +void Surface::write_to_png(const std::string& filename) +{ + ErrorStatus status = cairo_surface_write_to_png(m_cobject, filename.c_str()); + check_status_and_throw_exception(status); +} + +void Surface::write_to_png(cairo_write_func_t write_func, void *closure) +{ + ErrorStatus status = cairo_surface_write_to_png_stream(m_cobject, write_func, closure); + check_status_and_throw_exception(status); +} +#endif + +void Surface::reference() const +{ + cairo_surface_reference(m_cobject); +} + +void Surface::unreference() const +{ + cairo_surface_destroy(m_cobject); +} + +RefPtr Surface::create(const RefPtr other, Content content, int width, int height) +{ + cairo_surface_t* cobject = cairo_surface_create_similar(other->m_cobject, (cairo_content_t)content, width, height); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new Surface(cobject, true /* has reference */)); +} + + + +ImageSurface::ImageSurface(cairo_surface_t* cobject, bool has_reference) +: Surface(cobject, has_reference) +{ } + +ImageSurface::~ImageSurface() +{ + // surface is destroyed in base class +} + +RefPtr ImageSurface::create(Format format, int width, int height) +{ + cairo_surface_t* cobject = cairo_image_surface_create((cairo_format_t)format, width, height); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new ImageSurface(cobject, true /* has reference */)); +} + +RefPtr ImageSurface::create(unsigned char* data, Format format, int width, int height, int stride) +{ + cairo_surface_t* cobject = cairo_image_surface_create_for_data(data, (cairo_format_t)format, width, height, stride); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new ImageSurface(cobject, true /* has reference */)); +} + +#ifdef CAIRO_HAS_PNG_FUNCTIONS + +RefPtr ImageSurface::create_from_png(std::string filename) +{ + cairo_surface_t* cobject = cairo_image_surface_create_from_png(filename.c_str()); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new ImageSurface(cobject, true /* has reference */)); +} + +RefPtr ImageSurface::create_from_png(cairo_read_func_t read_func, void *closure) +{ + cairo_surface_t* cobject = cairo_image_surface_create_from_png_stream(read_func, closure); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new ImageSurface(cobject, true /* has reference */)); +} + +#endif // CAIRO_HAS_PNG_FUNCTIONS + +int ImageSurface::get_width() const +{ + const int result = cairo_image_surface_get_width(m_cobject); + check_object_status_and_throw_exception(*this); + return result; +} + +int ImageSurface::get_height() const +{ + const int result = cairo_image_surface_get_height(m_cobject); + check_object_status_and_throw_exception(*this); + return result; +} + +unsigned char* ImageSurface::get_data() +{ + return cairo_image_surface_get_data(m_cobject); +} + +const unsigned char* ImageSurface::get_data() const +{ + return cairo_image_surface_get_data(m_cobject); +} + +Format ImageSurface::get_format() const +{ + return static_cast(cairo_image_surface_get_format(m_cobject)); +} + +int ImageSurface::get_stride() const +{ + return cairo_image_surface_get_stride(m_cobject); +} + + +/******************************************************************************* + * THE FOLLOWING SURFACE TYPES ARE EXPERIMENTAL AND NOT FULLY SUPPORTED + ******************************************************************************/ + +#ifdef CAIRO_HAS_PDF_SURFACE + +PdfSurface::PdfSurface(cairo_surface_t* cobject, bool has_reference) : + Surface(cobject, has_reference) +{} + +PdfSurface::~PdfSurface() +{ + // surface is destroyed in base class +} + +RefPtr PdfSurface::create(std::string filename, double width_in_points, double height_in_points) +{ + cairo_surface_t* cobject = cairo_pdf_surface_create(filename.c_str(), width_in_points, height_in_points); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new PdfSurface(cobject, true /* has reference */)); +} + +RefPtr PdfSurface::create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points) +{ + cairo_surface_t* cobject = cairo_pdf_surface_create_for_stream(write_func, closure, width_in_points, height_in_points); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new PdfSurface(cobject, true /* has reference */)); +} + +void PdfSurface::set_size(double width_in_points, double height_in_points) +{ + cairo_pdf_surface_set_size(m_cobject, width_in_points, height_in_points); + check_object_status_and_throw_exception(*this); +} + +#endif // CAIRO_HAS_PDF_SURFACE + + + + +#ifdef CAIRO_HAS_PS_SURFACE + +PsSurface::PsSurface(cairo_surface_t* cobject, bool has_reference) : + Surface(cobject, has_reference) +{} + +PsSurface::~PsSurface() +{ + // surface is destroyed in base class +} + +RefPtr PsSurface::create(std::string filename, double width_in_points, double height_in_points) +{ + cairo_surface_t* cobject = cairo_ps_surface_create(filename.c_str(), width_in_points, height_in_points); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new PsSurface(cobject, true /* has reference */)); +} + +RefPtr PsSurface::create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points) +{ + cairo_surface_t* cobject = cairo_ps_surface_create_for_stream(write_func, closure, width_in_points, height_in_points); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new PsSurface(cobject, true /* has reference */)); +} + +void PsSurface::set_size(double width_in_points, double height_in_points) +{ + cairo_ps_surface_set_size(m_cobject, width_in_points, height_in_points); + check_object_status_and_throw_exception(*this); +} + + +void PsSurface::dsc_comment(std::string comment) +{ + cairo_ps_surface_dsc_comment(m_cobject, comment.c_str()); + check_object_status_and_throw_exception(*this); +} + +void PsSurface::dsc_begin_setup() +{ + cairo_ps_surface_dsc_begin_setup(m_cobject); + check_object_status_and_throw_exception(*this); +} + +void PsSurface::dsc_begin_page_setup() +{ + cairo_ps_surface_dsc_begin_page_setup(m_cobject); + check_object_status_and_throw_exception(*this); +} + + +#endif // CAIRO_HAS_PS_SURFACE + + + + +#ifdef CAIRO_HAS_SVG_SURFACE + +SvgSurface::SvgSurface(cairo_surface_t* cobject, bool has_reference) : + Surface(cobject, has_reference) +{} + +SvgSurface::~SvgSurface() +{ + // surface is destroyed in base class +} + +RefPtr SvgSurface::create(std::string filename, double width_in_points, double height_in_points) +{ + cairo_surface_t* cobject = cairo_svg_surface_create(filename.c_str(), width_in_points, height_in_points); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new SvgSurface(cobject, true /* has reference */)); +} + +RefPtr SvgSurface::create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points) +{ + cairo_surface_t* cobject = cairo_svg_surface_create_for_stream(write_func, closure, width_in_points, height_in_points); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new SvgSurface(cobject, true /* has reference */)); +} + +void SvgSurface::restrict_to_version(SvgVersion version) +{ + cairo_svg_surface_restrict_to_version(m_cobject, static_cast(version)); + check_object_status_and_throw_exception(*this); +} + +const std::vector SvgSurface::get_versions() +{ + cairo_svg_version_t const *versions; + int num_versions; + cairo_svg_get_versions(&versions, &num_versions); + + // Just copy the version array out into a std::vector. This is a rarely used + // function and the array of versions is going to be very small, so there's no + // real performance hit. + std::vector vec; + for (int i = 0; i < num_versions; ++i) + { + vec.push_back(static_cast(versions[i])); + } + return vec; +} + +std::string SvgSurface::version_to_string(SvgVersion version) +{ + return std::string(cairo_svg_version_to_string(static_cast(version))); +} + +#endif // CAIRO_HAS_SVG_SURFACE + + + + +#ifdef CAIRO_HAS_GLITZ_SURFACE + +GlitzSurface::GlitzSurface(cairo_surface_t* cobject, bool has_reference) +: Surface(cobject, has_reference) +{ } + +GlitzSurface::~GlitzSurface() +{ + // surface is destroyed in base class +} + +RefPtr GlitzSurface::create(glitz_surface_t *surface) +{ + cairo_surface_t* cobject = cairo_glitz_surface_create(surface); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new GlitzSurface(cobject, true /* has reference */)); +} + +#endif // CAIRO_HAS_GLITZ_SURFACE + +} //namespace Cairo + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/surface.h b/libs/cairomm/cairomm/surface.h new file mode 100644 index 0000000000..001f754a79 --- /dev/null +++ b/libs/cairomm/cairomm/surface.h @@ -0,0 +1,631 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __CAIROMM_SURFACE_H +#define __CAIROMM_SURFACE_H + +#include +#include +#include +#include +#include +#include + +//See xlib_surface.h for XlibSurface. +//See win32_surface.h for Win32Surface. + +#ifdef CAIRO_HAS_PDF_SURFACE +#include +#endif // CAIRO_HAS_PDF_SURFACE +#ifdef CAIRO_HAS_PS_SURFACE +#include +#endif // CAIRO_HAS_PS_SURFACE +#ifdef CAIRO_HAS_SVG_SURFACE +#include +#endif // CAIRO_HAS_SVG_SURFACE + +// Experimental surfaces +#ifdef CAIRO_HAS_GLITZ_SURFACE +#include +#endif // CAIRO_HAS_GLITZ_SURFACE + + +namespace Cairo +{ + +/** A cairo surface represents an image, either as the destination of a drawing + * operation or as source when drawing onto another surface. There are + * different subtypes of cairo surface for different drawing backends. This + * class is a base class for all subtypes and should not be used directly + * + * Surfaces are reference-counted objects that should be used via Cairo::RefPtr. + */ +class Surface +{ +public: + /** Create a C++ wrapper for the C instance. This C++ instance should then be + * given to a RefPtr. + * + * @param cobject The C instance. + * @param has_reference Whether we already have a reference. Otherwise, the + * constructor will take an extra reference. + */ + explicit Surface(cairo_surface_t* cobject, bool has_reference = false); + + virtual ~Surface(); + + /** Retrieves the default font rendering options for the surface. This allows + * display surfaces to report the correct subpixel order for rendering on + * them, print surfaces to disable hinting of metrics and so forth. The + * result can then be used with cairo_scaled_font_create(). + * + * @param options a FontOptions object into which to store the retrieved + * options. All existing values are overwritten + */ + void get_font_options(FontOptions& options) const; + + /** This function finishes the surface and drops all references to external + * resources. For example, for the Xlib backend it means that cairo will no + * longer access the drawable, which can be freed. After calling + * finish() the only valid operations on a surface are getting and setting + * user data and referencing and destroying it. Further drawing to the + * surface will not affect the surface but will instead trigger a + * CAIRO_STATUS_SURFACE_FINISHED error. + * + * When the Surface is destroyed, cairo will call finish() if it hasn't been + * called already, before freeing the resources associated with the Surface. + */ + void finish(); + + /** Do any pending drawing for the surface and also restore any temporary + * modifications cairo has made to the surface's state. This function must + * be called before switching from drawing on the surface with cairo to + * drawing on it directly with native APIs. If the surface doesn't support + * direct access, then this function does nothing. + */ + void flush(); + + /** Tells cairo to consider the data buffer dirty. + * + * In particular, if you've created an ImageSurface with a data buffer that + * you've allocated yourself and you draw to that data buffer using means + * other than cairo, you must call mark_dirty() before doing any additional + * drawing to that surface with cairo. + * + * Note that if you do draw to the Surface outside of cairo, you must call + * flush() before doing the drawing. + */ + void mark_dirty(); + + /** Marks a rectangular area of the given surface dirty. + * + * @param x X coordinate of dirty rectangle + * @param y Y coordinate of dirty rectangle + * @param width width of dirty rectangle + * @param height height of dirty rectangle + */ + void mark_dirty(int x, int y, int width, int height); + + /** Sets an offset that is added to the device coordinates determined by the + * CTM when drawing to surface. One use case for this function is when we + * want to create a Surface that redirects drawing for a portion of + * an onscreen surface to an offscreen surface in a way that is completely + * invisible to the user of the cairo API. Setting a transformation via + * cairo_translate() isn't sufficient to do this, since functions like + * Cairo::Context::device_to_user() will expose the hidden offset. + * + * Note that the offset only affects drawing to the surface, not using the + * surface in a surface pattern. + * + * @param x_offset the offset in the X direction, in device units + * @param y_offset the offset in the Y direction, in device units + */ + void set_device_offset(double x_offset, double y_offset); + + /** Returns a previous device offset set by set_device_offset(). + */ + void get_device_offset(double& x_offset, double& y_offset) const; + + /** Sets the fallback resolution of the image in dots per inch + * + * @param x_pixels_per_inch Pixels per inch in the x direction + * @param y_pixels_per_inch Pixels per inch in the y direction + */ + void set_fallback_resolution(double x_pixels_per_inch, double y_pixels_per_inch); + + SurfaceType get_type() const; + +#ifdef CAIRO_HAS_PNG_FUNCTIONS + + /** Writes the contents of surface to a new file filename as a PNG image. + * + * @note For this function to be available, cairo must have been compiled + * with PNG support + * + * @param filename the name of a file to write to + */ + void write_to_png(const std::string& filename); + + /** Writes the Surface to the write function. + * + * @note For this function to be available, cairo must have been compiled + * with PNG support + * + * @param write_func The function to be called when the backend needs to + * write data to an output stream + * @param closure closure data for the write function + */ + void write_to_png(cairo_write_func_t write_func, void *closure); //TODO: Use a sigc::slot? + +#endif // CAIRO_HAS_PNG_FUNCTIONS + + + /** The underlying C cairo surface type + */ + typedef cairo_surface_t cobject; + /** Provides acces to the underlying C cairo surface + */ + inline cobject* cobj() { return m_cobject; } + /** Provides acces to the underlying C cairo surface + */ + inline const cobject* cobj() const { return m_cobject; } + + #ifndef DOXYGEN_IGNORE_THIS + ///For use only by the cairomm implementation. + inline ErrorStatus get_status() const + { return cairo_surface_status(const_cast(cobj())); } + + void reference() const; + void unreference() const; + #endif //DOXYGEN_IGNORE_THIS + + /** Create a new surface that is as compatible as possible with an existing + * surface. The new surface will use the same backend as other unless that is + * not possible for some reason. + * + * @param other an existing surface used to select the backend of the new surface + * @param content the content for the new surface + * @param width width of the new surface, (in device-space units) + * @param height height of the new surface (in device-space units) + * @return a RefPtr to the newly allocated surface. + */ + static RefPtr create(const RefPtr other, Content content, int width, int height); + +protected: + /** The underlying C cairo surface type that is wrapped by this Surface + */ + cobject* m_cobject; +}; + + +/** Image surfaces provide the ability to render to memory buffers either + * allocated by cairo or by the calling code. The supported image formats are + * those defined in Cairo::Format + * + * An ImageSurface is the most generic type of Surface and the only one that is + * available by default. You can either create an ImageSurface whose data is + * managed by Cairo, or you can create an ImageSurface with a data buffer that + * you allocated yourself so that you can have full access to the data. + * + * When you create an ImageSurface with your own data buffer, you are free to + * examine the results at any point and do whatever you want with it. Note that + * if you modify anything and later want to continue to draw to the surface + * with cairo, you must let cairo know via Cairo::Surface::mark_dirty() + * + * Note that like all surfaces, an ImageSurface is a reference-counted object that should be used via Cairo::RefPtr. + */ +class ImageSurface : public Surface +{ +protected: + //TODO?: Surface(cairo_surface_t *target); + +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be + * given to a RefPtr. + * @param cobject The C instance. + * @param has_reference Whether we already have a reference. Otherwise, the + * constructor will take an extra reference. + */ + explicit ImageSurface(cairo_surface_t* cobject, bool has_reference = false); + + virtual ~ImageSurface(); + + /** Gets the width of the ImageSurface in pixels + */ + int get_width() const; + + /** Gets the height of the ImageSurface in pixels + */ + int get_height() const; + + /** + * Get a pointer to the data of the image surface, for direct + * inspection or modification. + * + * Return value: a pointer to the image data of this surface or NULL + * if @surface is not an image surface. + */ + unsigned char* get_data(); + const unsigned char* get_data() const; + + /** gets the format of the surface + */ + Format get_format() const; + + /** + * Return value: the stride of the image surface in bytes (or 0 if + * @surface is not an image surface). The stride is the distance in + * bytes from the beginning of one row of the image data to the + * beginning of the next row. + */ + int get_stride() const; + + + /** Creates an image surface of the specified format and dimensions. The + * initial contents of the surface is undefined; you must explicitely clear + * the buffer, using, for example, Cairo::Context::rectangle() and + * Cairo::Context::fill() if you want it cleared. + * + * Use this function to create the surface if you don't need access to the + * internal data and want cairo to manage it for you. Since you don't have + * access to the internal data, the resulting surface can only be saved to a + * PNG image file (if cairo has been compiled with PNG support) or as a + * source surface (see Cairo::SurfacePattern). + * + * @param format format of pixels in the surface to create + * @param width width of the surface, in pixels + * @param height height of the surface, in pixels + * @return a RefPtr to the newly created surface. + */ + static RefPtr create(Format format, int width, int height); + + /** Creates an image surface for the provided pixel data. The output buffer + * must be kept around until the Surface is destroyed or finish() is called + * on the surface. The initial contents of buffer will be used as the inital + * image contents; you must explicitely clear the buffer, using, for example, + * Cairo::Context::rectangle() and Cairo::Context::fill() if you want it + * cleared. + * + * If you want to be able to manually manipulate or extract the data after + * drawing to the surface with Cairo, you should use this function to create + * the Surface. Since you own the internal data, you can do anything you + * want with it. + * + * @param data a pointer to a buffer supplied by the application in which + * to write contents. + * @param format the format of pixels in the buffer + * @param width the width of the image to be stored in the buffer + * @param height the height of the image to be stored in the buffer + * @param stride the number of bytes between the start of rows in the + * buffer. Having this be specified separate from width allows for padding at + * the end of rows, or for writing to a subportion of a larger image. + * @return a RefPtr to the newly created surface. + */ + static RefPtr create(unsigned char* data, Format format, int width, int height, int stride); + +#ifdef CAIRO_HAS_PNG_FUNCTIONS + + /** Creates a new image surface and initializes the contents to the given PNG + * file. + * + * @note For this function to be available, cairo must have been compiled + * with PNG support. + * + * @param filename name of PNG file to load + * @return a RefPtr to the new cairo_surface_t initialized with the + * contents of the PNG image file. + */ + static RefPtr create_from_png(std::string filename); + + /** Creates a new image surface from PNG data read incrementally via the + * read_func function. + * + * @note For this function to be available, cairo must have been compiled + * with PNG support. + * + * @param read_func function called to read the data of the file + * @param closure data to pass to read_func. + * @return a RefPtr to the new cairo_surface_t initialized with the + * contents of the PNG image file. + */ + static RefPtr create_from_png(cairo_read_func_t read_func, void *closure); + +#endif // CAIRO_HAS_PNG_FUNCTIONS + +}; + + +#ifdef CAIRO_HAS_PDF_SURFACE + +/** A PdfSurface provides a way to render PDF documents from cairo. This + * surface is not rendered to the screen but instead renders the drawing to a + * PDF file on disk. + * + * @note For this Surface to be available, cairo must have been compiled with + * PDF support + */ +class PdfSurface : public Surface +{ +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be + * given to a RefPtr. + * + * @param cobject The C instance. + * @param has_reference whether we already have a reference. Otherwise, the + * constructor will take an extra reference. + */ + explicit PdfSurface(cairo_surface_t* cobject, bool has_reference = false); + virtual ~PdfSurface(); + + /** Creates a PdfSurface with a specified dimensions that will be saved as + * the given filename + * + * @param filename The name of the PDF file to save the surface to + * @param width_in_points The width of the PDF document in points + * @param height_in_points The height of the PDF document in points + */ + static RefPtr create(std::string filename, double width_in_points, double height_in_points); + + /** Creates a PdfSurface with a specified dimensions that will be written to + * the given write function instead of saved directly to disk + * + * @param write_func The function to be called when the backend needs to + * write data to an output stream + * @param closure closure data for the write function + * @param width_in_points The width of the PDF document in points + * @param height_in_points The height of the PDF document in points + */ + static RefPtr create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points); + +/** + * Changes the size of a PDF surface for the current (and subsequent) pages. + * + * This function should only be called before any drawing operations have been + * performed on the current page. The simplest way to do this is to call this + * function immediately after creating the surface or immediately after + * completing a page with either Context::show_page() or Context::copy_page(). + * + * @param width_in_points new surface width, in points (1 point == 1/72.0 inch) + * @param height_in_points new surface height, in points (1 point == 1/72.0 inch) + **/ + void set_size(double width_in_points, double height_in_points); + +}; + +#endif // CAIRO_HAS_PDF_SURFACE + + +#ifdef CAIRO_HAS_PS_SURFACE + +/** A PsSurface provides a way to render PostScript documents from cairo. This + * surface is not rendered to the screen but instead renders the drawing to a + * PostScript file on disk. + * + * @note For this Surface to be available, cairo must have been compiled with + * PostScript support + */ +class PsSurface : public Surface +{ +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be + * given to a RefPtr. + * + * @param cobject The C instance. + * @param has_reference whether we already have a reference. Otherwise, the + * constructor will take an extra reference. + */ + explicit PsSurface(cairo_surface_t* cobject, bool has_reference = false); + virtual ~PsSurface(); + + /** Creates a PsSurface with a specified dimensions that will be saved as the + * given filename + * + * @param filename The name of the PostScript file to save the surface to + * @param width_in_points The width of the PostScript document in points + * @param height_in_points The height of the PostScript document in points + */ + static RefPtr create(std::string filename, double width_in_points, double height_in_points); + + /** Creates a PsSurface with a specified dimensions that will be written to + * the given write function instead of saved directly to disk + * + * @param write_func The function to be called when the backend needs to + * write data to an output stream + * @param closure closure data for the write function + * @param width_in_points The width of the PostScript document in points + * @param height_in_points The height of the PostScript document in points + */ + static RefPtr create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points); + + /** + * Changes the size of a PostScript surface for the current (and + * subsequent) pages. + * + * This function should only be called before any drawing operations have been + * performed on the current page. The simplest way to do this is to call this + * function immediately after creating the surface or immediately after + * completing a page with either Context::show_page() or Context::copy_page(). + * + * @param width_in_points new surface width, in points (1 point == 1/72.0 inch) + * @param height_in_points new surface height, in points (1 point == 1/72.0 inch) + */ + void set_size(double width_in_points, double height_in_points); + + /** Emit a comment into the PostScript output for the given surface. See the + * cairo reference documentation for more information. + * + * @param comment a comment string to be emitted into the PostScript output + */ + void dsc_comment(std::string comment); + + /** + * This function indicates that subsequent calls to dsc_comment() should direct + * comments to the Setup section of the PostScript output. + * + * This function should be called at most once per surface, and must be called + * before any call to dsc_begin_page_setup() and before any drawing is performed + * to the surface. + */ + void dsc_begin_setup(); + + /** This function indicates that subsequent calls to dsc_comment() should + * direct comments to the PageSetup section of the PostScript output. + * + * This function call is only needed for the first page of a surface. It + * should be called after any call to dsc_begin_setup() and before any drawing + * is performed to the surface. + */ + void dsc_begin_page_setup(); + +}; + +#endif // CAIRO_HAS_PS_SURFACE + + +#ifdef CAIRO_HAS_SVG_SURFACE + +typedef enum +{ + SVG_VERSION_1_1 = CAIRO_SVG_VERSION_1_1, + SVG_VERSION_1_2 = CAIRO_SVG_VERSION_1_2 +} SvgVersion; + +/** A SvgSurface provides a way to render Scalable Vector Graphics (SVG) images + * from cairo. This surface is not rendered to the screen but instead renders + * the drawing to an SVG file on disk. + * + * @note For this Surface to be available, cairo must have been compiled with + * SVG support + */ +class SvgSurface : public Surface +{ +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be + * given to a RefPtr. + * + * @param cobject The C instance. + * @param has_reference whether we already have a reference. Otherwise, the + * constructor will take an extra reference. + */ + explicit SvgSurface(cairo_surface_t* cobject, bool has_reference = false); + virtual ~SvgSurface(); + + + /** Creates a SvgSurface with a specified dimensions that will be saved as the + * given filename + * + * @param filename The name of the SVG file to save the surface to + * @param width_in_points The width of the SVG document in points + * @param height_in_points The height of the SVG document in points + */ + static RefPtr create(std::string filename, double width_in_points, double height_in_points); + + /** Creates a SvgSurface with a specified dimensions that will be written to + * the given write function instead of saved directly to disk + * + * @param write_func The function to be called when the backend needs to + * write data to an output stream + * @param closure closure data for the write function + * @param width_in_points The width of the SVG document in points + * @param height_in_points The height of the SVG document in points + */ + static RefPtr create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points); + + /** + * Restricts the generated SVG file to the given version. See get_versions() + * for a list of available version values that can be used here. + * + * This function should only be called before any drawing operations have been + * performed on the given surface. The simplest way to do this is to call this + * function immediately after creating the surface. + * + * @since 1.2 + */ + void restrict_to_version(SvgVersion version); + + /** Retrieves the list of SVG versions supported by cairo. See + * restrict_to_version(). + * + * @since 1.2 + */ + static const std::vector get_versions(); + + /** Get the string representation of the given version id. The returned string + * will be empty if version isn't valid. See get_versions() for a way to get + * the list of valid version ids. + * + * Since: 1.2 + */ + static std::string version_to_string(SvgVersion version); +}; + +#endif // CAIRO_HAS_SVG_SURFACE + + +/******************************************************************************* + * THE FOLLOWING SURFACE TYPES ARE EXPERIMENTAL AND NOT FULLY SUPPORTED + ******************************************************************************/ + +#ifdef CAIRO_HAS_GLITZ_SURFACE + +/** A GlitzSurface provides a way to render to the X Window System using Glitz. + * This provides a way to use OpenGL-accelerated graphics from cairo. If you + * want to use hardware-accelerated graphics within the X Window system, you + * should use this Surface type. + * + * @note For this Surface to be available, cairo must have been compiled with + * Glitz support + * + * @warning This is an experimental surface. It is not yet marked as a fully + * supported surface by the cairo library + */ +class GlitzSurface : public Surface +{ + +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be + * given to a RefPtr. + * + * @param cobject The C instance. + * @param has_reference whether we already have a reference. Otherwise, the + * constructor will take an extra reference. + */ + explicit GlitzSurface(cairo_surface_t* cobject, bool has_reference = false); + + virtual ~GlitzSurface(); + + /** Creates a new GlitzSurface + * + * @param surface a glitz surface type + */ + static RefPtr create(glitz_surface_t *surface); + +}; + +#endif // CAIRO_HAS_GLITZ_SURFACE + +} // namespace Cairo + +#endif //__CAIROMM_SURFACE_H + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/win32_surface.cc b/libs/cairomm/cairomm/win32_surface.cc new file mode 100644 index 0000000000..e0e388721b --- /dev/null +++ b/libs/cairomm/cairomm/win32_surface.cc @@ -0,0 +1,59 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#include +#include + +namespace Cairo +{ + +#ifdef CAIRO_HAS_WIN32_SURFACE + +Win32Surface::Win32Surface(cairo_surface_t* cobject, bool has_reference) : + Surface(cobject, has_reference) +{} + +Win32Surface::~Win32Surface() +{ + // surface is destroyed in base class +} + +HDC Win32Surface::get_dc() const +{ + return cairo_win32_surface_get_dc(m_cobject); +} + +RefPtr Win32Surface::create(HDC hdc) +{ + cairo_surface_t* cobject = cairo_win32_surface_create(hdc); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new Win32Surface(cobject, true /* has reference */)); +} + +RefPtr Win32Surface::create(Format format, int width, int height) +{ + cairo_surface_t* cobject = cairo_win32_surface_create_with_dib((cairo_format_t)format, width, height); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new Win32Surface(cobject, true /* has reference */)); +} + +#endif // CAIRO_HAS_WIN32_SURFACE + +} //namespace Cairo + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/win32_surface.h b/libs/cairomm/cairomm/win32_surface.h new file mode 100644 index 0000000000..2c9e6a7242 --- /dev/null +++ b/libs/cairomm/cairomm/win32_surface.h @@ -0,0 +1,96 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __CAIROMM_WIN32_SURFACE_H +#define __CAIROMM_WIN32_SURFACE_H + +#include +#include + +#ifdef CAIRO_HAS_WIN32_SURFACE +#include +#endif + +// This header is not included by cairomm.h because it requires Windows headers that +// tend to pollute the namespace with non-prefixed #defines and typedefs. +// You may include it directly if you need to use this API. + +namespace Cairo +{ + +#ifdef CAIRO_HAS_WIN32_SURFACE + +/** A Win32Surface provides a way to render within Microsoft Windows. If you + * want to draw to the screen within a Microsoft Windows application, you + * should use this Surface type. + * + * @note For this Surface to be available, cairo must have been compiled with + * Win32 support + */ +class Win32Surface : public Surface +{ +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be + * given to a RefPtr. + * + * @param cobject The C instance. + * @param has_reference whether we already have a reference. Otherwise, the + * constructor will take an extra reference. + */ + explicit Win32Surface(cairo_surface_t* cobject, bool has_reference = false); + virtual ~Win32Surface(); + + /** Returns the HDC associated with this surface, or NULL if none. Also + * returns NULL if the surface is not a win32 surface. + * + * @return HDC or NULL if no HDC available. + */ + HDC get_dc() const; + + /** Creates a cairo surface that targets the given DC. The DC will be queried + * for its initial clip extents, and this will be used as the size of the + * cairo surface. Also, if the DC is a raster DC, it will be queried for its + * pixel format and the cairo surface format will be set appropriately. + * + * @param hdc the DC to create a surface for + * @return the newly created surface + */ + static RefPtr create(HDC hdc); + + /** Creates a device-independent-bitmap surface not associated with any + * particular existing surface or device context. The created bitmap will be + * unititialized. + * + * @param format format of pixels in the surface to create + * @param width width of the surface, in pixels + * @param height height of the surface, in pixels + * @return the newly created surface + */ + static RefPtr create(Format format, int width, int height); + +}; + +#endif // CAIRO_HAS_WIN32_SURFACE + + +} // namespace Cairo + +#endif //__CAIROMM_WIN32_SURFACE_H + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/xlib_surface.cc b/libs/cairomm/cairomm/xlib_surface.cc new file mode 100644 index 0000000000..8320521927 --- /dev/null +++ b/libs/cairomm/cairomm/xlib_surface.cc @@ -0,0 +1,137 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#include +#include + + +namespace Cairo +{ + +#ifdef CAIRO_HAS_XLIB_SURFACE + +XlibSurface::XlibSurface(cairo_surface_t* cobject, bool has_reference) : + Surface(cobject, has_reference) +{} + +XlibSurface::~XlibSurface() +{ + // surface is destroyed in base class +} + +RefPtr XlibSurface::create(Display* dpy, Drawable drawable, Visual* visual, int width, int height) +{ + cairo_surface_t* cobject = cairo_xlib_surface_create(dpy, drawable, visual, width, height); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new XlibSurface(cobject, true /* has reference */)); +} + +RefPtr XlibSurface::create(Display* dpy, Pixmap bitmap, Screen* screen, int width, int height) +{ + cairo_surface_t* cobject = cairo_xlib_surface_create_for_bitmap(dpy, bitmap, screen, width, height); + check_status_and_throw_exception(cairo_surface_status(cobject)); + return RefPtr(new XlibSurface(cobject, true /* has reference */)); +} + +void XlibSurface::set_size(int width, int height) +{ + cairo_xlib_surface_set_size(m_cobject, width, height); + check_object_status_and_throw_exception(*this); +} + +void XlibSurface::set_drawable(Drawable drawable, int width, int height) +{ + cairo_xlib_surface_set_drawable(m_cobject, drawable, width, height); + check_object_status_and_throw_exception(*this); +} + +Drawable XlibSurface::get_drawable() const +{ + Drawable drawable = cairo_xlib_surface_get_drawable(m_cobject); + check_object_status_and_throw_exception(*this); + return drawable; +} + +const Display* XlibSurface::get_display() const +{ + const Display* dpy = cairo_xlib_surface_get_display(m_cobject); + check_object_status_and_throw_exception(*this); + return dpy; +} + +Display* XlibSurface::get_display() +{ + Display* dpy = cairo_xlib_surface_get_display(m_cobject); + check_object_status_and_throw_exception(*this); + return dpy; +} + +Screen* XlibSurface::get_screen() +{ + Screen* screen = cairo_xlib_surface_get_screen(m_cobject); + check_object_status_and_throw_exception(*this); + return screen; +} + +const Screen* XlibSurface::get_screen() const +{ + const Screen* screen = cairo_xlib_surface_get_screen(m_cobject); + check_object_status_and_throw_exception(*this); + return screen; +} + +Visual* XlibSurface::get_visual() +{ + Visual* visual = cairo_xlib_surface_get_visual(m_cobject); + check_object_status_and_throw_exception(*this); + return visual; +} + +const Visual* XlibSurface::get_visual() const +{ + const Visual* visual = cairo_xlib_surface_get_visual(m_cobject); + check_object_status_and_throw_exception(*this); + return visual; +} + +int XlibSurface::get_depth() const +{ + int depth = cairo_xlib_surface_get_depth(m_cobject); + check_object_status_and_throw_exception(*this); + return depth; +} + +int XlibSurface::get_height() const +{ + int h = cairo_xlib_surface_get_height(m_cobject); + check_object_status_and_throw_exception(*this); + return h; +} + +int XlibSurface::get_width() const +{ + int w = cairo_xlib_surface_get_width(m_cobject); + check_object_status_and_throw_exception(*this); + return w; +} + +#endif // CAIRO_HAS_XLIB_SURFACE + +} //namespace Cairo + +// vim: ts=2 sw=2 et diff --git a/libs/cairomm/cairomm/xlib_surface.h b/libs/cairomm/cairomm/xlib_surface.h new file mode 100644 index 0000000000..cddd8806ac --- /dev/null +++ b/libs/cairomm/cairomm/xlib_surface.h @@ -0,0 +1,148 @@ +/* Copyright (C) 2005 The cairomm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#ifndef __CAIROMM_XLIB_SURFACE_H +#define __CAIROMM_XLIB_SURFACE_H + +#include + +// This header is not included by cairomm.h because it requires X headers that +// tend to pollute the namespace with non-prefixed #defines and typedefs. +// You may include it directly if you need to use this API. + +#ifdef CAIRO_HAS_XLIB_SURFACE +#include //Needed for the X11 "Display" struct (which pollutes the namespace because it has no prefix.) +#endif + + +namespace Cairo +{ + +#ifdef CAIRO_HAS_XLIB_SURFACE + +/** An XlibSurface provides a way to render to the X Window System using XLib. + * If you want to draw to the screen within an application that uses the X + * Window system, you should use this Surface type. + * + * @note For this surface to be availabe, cairo must have been compiled with + * support for XLib Surfaces + */ +class XlibSurface : public Surface +{ +public: + + /** Create a C++ wrapper for the C instance. This C++ instance should then be + * given to a RefPtr. + * + * @param cobject The C instance. + * @param has_reference whether we already have a reference. Otherwise, the + * constructor will take an extra reference. + */ + explicit XlibSurface(cairo_surface_t* cobject, bool has_reference = false); + virtual ~XlibSurface(); + + /** Creates an Xlib surface that draws to the given drawable. The way that + * colors are represented in the drawable is specified by the provided + * visual. + * + * @note If drawable is a Window, then the function + * cairo_xlib_surface_set_size must be called whenever the size of the window + * changes. + * + * @param dpy an X Display + * @param drawable an X Drawable, (a Pixmap or a Window) + * @param visual the visual to use for drawing to drawable. The depth of the visual must match the depth of the drawable. Currently, only TrueColor visuals are fully supported. + * @param width the current width of drawable. + * @param height the current height of drawable. + * @return A RefPtr to the newly created surface + */ + static RefPtr create(Display* dpy, Drawable drawable, Visual* visual, int width, int height); + + /** Creates an Xlib surface that draws to the given bitmap. This will be + * drawn to as a CAIRO_FORMAT_A1 object. + * + * @param dpy an X Display + * @param bitmap an X Drawable, (a depth-1 Pixmap) + * @param screen the X Screen associated with bitmap + * @param width the current width of bitmap. + * @param height the current height of bitmap. + * @return A RefPtr to the newly created surface + */ + static RefPtr create(Display *dpy, Pixmap bitmap, Screen *screen, int width, int height); + + /** Informs cairo of the new size of the X Drawable underlying the surface. + * For a surface created for a Window (rather than a Pixmap), this function + * must be called each time the size of the window changes. (For a subwindow, + * you are normally resizing the window yourself, but for a toplevel window, + * it is necessary to listen for ConfigureNotify events.) + * + * A Pixmap can never change size, so it is never necessary to call this + * function on a surface created for a Pixmap. + * + * @param width the new width of the surface + * @param height the new height of the surface + */ + void set_size(int width, int height); + + /** Informs cairo of a new X Drawable underlying the surface. The drawable + * must match the display, screen and format of the existing drawable or the + * application will get X protocol errors and will probably terminate. No + * checks are done by this function to ensure this compatibility. + * + * @param drawable the new drawable for the surface + * @param width the width of the new drawable + * @param height the height of the new drawable + */ + void set_drawable(Drawable drawable, int width, int height); + + /** gets the Drawable object associated with this surface */ + Drawable get_drawable() const; + + /** Get the X Display for the underlying X Drawable. */ + const Display* get_display() const; + /** Get the X Display for the underlying X Drawable. */ + Display* get_display(); + + /** Get the X Screen for the underlying X Drawable */ + Screen* get_screen(); + /** Get the X Screen for the underlying X Drawable */ + const Screen* get_screen() const; + + /** Get the X Visual for the underlying X Drawable */ + Visual* get_visual(); + /** Get the X Visual for the underlying X Drawable */ + const Visual* get_visual() const; + + /** Get the number of bits used to represent each pixel value. */ + int get_depth() const; + + /** Get the height in pixels of the X Drawable underlying the surface */ + int get_height() const; + + /** Get the width in pixels of the X Drawable underlying the surface */ + int get_width() const; + +}; + +#endif // CAIRO_HAS_XLIB_SURFACE + +} // namespace Cairo + +#endif //__CAIROMM_XLIB_SURFACE_H + +// vim: ts=2 sw=2 et