commit 498fa50f2948f00e7afeb3470548e2d1eee8a7b9 Author: David Benjamin Date: Sat Mar 5 22:41:13 2011 -0500 nspluginwrapper-0.9.91.1 Taken from Wayback machine. diff --git a/COPYING b/COPYING new file mode 100644 index 0000000..d60c31a --- /dev/null +++ b/COPYING @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 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. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, 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 software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, 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 redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +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 give any other recipients of the Program a copy of this License +along with the Program. + +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 Program or any portion +of it, thus forming a work based on the Program, 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) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +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 Program, 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 Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) 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; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, 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 executable. 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. + +If distribution of executable or 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 counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program 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. + + 5. 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 Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program 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. + + 7. 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 Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program 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 Program. + +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. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program 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. + + 9. The Free Software Foundation may publish revised and/or new versions +of the 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 Program +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 Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, 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 + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "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 PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. 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 PROGRAM 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 PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), 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 Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. 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 program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; 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. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/ChangeLog b/ChangeLog new file mode 100644 index 0000000..6183077 --- /dev/null +++ b/ChangeLog @@ -0,0 +1,750 @@ +2006-12-27 00:41 Gwenole Beauchesne + + * src/debug.h: Include . + +2006-12-27 00:31 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl. + +2006-12-27 00:30 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl. + +2006-12-26 10:45 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl. + +2006-12-26 10:40 Gwenole Beauchesne + + * Makefile: Fix make changelog (again). + +2006-12-26 10:39 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl. + +2006-12-26 10:38 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl. + +2006-12-26 10:36 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl. + +2006-12-26 10:34 Gwenole Beauchesne + + * NEWS, nspluginwrapper.spec: 0.9.91.1 + +2006-12-26 10:33 Gwenole Beauchesne + + * src/debug.c, src/debug.h, src/utils.c, src/utils.h: Move logging + functions to debug.c. + +2006-12-25 07:46 Gwenole Beauchesne + + * src/debug.c, src/utils.c, src/utils.h: NPW_LOG applies to all + outputs, not only the debug ones. + +2006-12-25 00:00 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl. + +2006-12-24 23:58 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl. + * NEWS, README: Updates for new release. + +2006-12-24 23:51 Gwenole Beauchesne + + * tests/test-plugins.html: Add Tcl & Squeak plugins demos. + +2006-12-24 23:11 Gwenole Beauchesne + + * src/npw-viewer.c, src/npw-wrapper.c: Actually, NPP_NewStream() + can alter the notifyData pointer. + +2006-12-24 23:05 Gwenole Beauchesne + + * src/npruntime.c: Missed migrations to npw_perror(). + +2006-12-24 18:53 Gwenole Beauchesne + + * src/npw-rpc.c: Fix marshaling of NP_NOTIFY_DATA, don't use + id_create() from plugin-side as + this is a browser-side specific function. Simply pass the + notifyData pointer. + +2006-12-24 15:59 Gwenole Beauchesne + + * src/npw-rpc.c, src/npw-rpc.h, src/npw-viewer.c, + src/npw-wrapper.c: Handle notifyData as plugin-side opaque + pointers, i.e. browser-side doesn't + need to know what they represent so they can be single IDs + there. Shorten + NPP_NewStream() to have stype as output only (not for input, + it's initialized + in the plug-in side prior to calling the plugin NPP_NewStream()). + +2006-12-24 12:37 Gwenole Beauchesne + + * src/npw-wrapper.c: Split RPC / NPAPI level routines. + +2006-12-24 11:47 Gwenole Beauchesne + + * src/npw-viewer.c, src/npw-wrapper.c: Always return a value for + NP{P,N}_GetValue(). + +2006-12-24 11:03 Gwenole Beauchesne + + * src/rpc.c: Fix buffered RPC transactions. + +2006-12-24 10:14 Gwenole Beauchesne + + * src/npw-viewer.c, src/npw-wrapper.c: Propagate NPSavedData data + to the plugin, though Firefox doesn't handle this. + It may work with Mozilla or Konqueror though. + +2006-12-24 08:17 Gwenole Beauchesne + + * src/npruntime.c, src/npw-viewer.c, src/npw-wrapper.c, src/rpc.c, + src/rpc.h, src/utils.c, src/utils.h: Improve error messages. + +2006-12-24 07:23 Gwenole Beauchesne + + * src/npruntime.c, src/npw-viewer.c, src/npw-wrapper.c: Mark + g_rpc_connection as hidden until it is made PluginInstance + specific. + +2006-12-24 00:09 Gwenole Beauchesne + + * src/npw-viewer.c: Fix NPP_New() for null arguments. + +2006-12-24 00:08 Gwenole Beauchesne + + * src/rpc.c: Fix marshaling of empty strings (not null). + +2006-12-23 19:01 Gwenole Beauchesne + + * NEWS, src/npw-rpc.c, src/rpc.c: Fix marshaling of arrays of data + passed by value (NPIdentifiers for the VLC + plug-in). Adjust message descriptors to reflect proper array + base type. + +2006-12-23 15:03 Gwenole Beauchesne + + * src/npw-viewer.c: Fix NPN_GetStringIdentifiers(). + +2006-12-23 11:55 Gwenole Beauchesne + + * NEWS: Updates. + +2006-12-23 08:38 Gwenole Beauchesne + + * src/npw-wrapper.c: id_init() now returns a boolean value. + * src/npw-config.c: Fix mkdir -p as NetBSD can generate EISDIR if + a directory already exists. + +2006-12-23 08:32 Gwenole Beauchesne + + * src/npw-config.c: Avoid use of , thus alloca(). Use + ISO C VLA instead. + +2006-12-22 08:18 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl. + * src/npw-viewer.c: Delay execution of NPN_PostURL{,Notify}() + functions. + +2006-12-22 07:56 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl. + * src/npw-wrapper.c: Fix regression in NPN_GetValue(), a NULL + instance is allowed. + +2006-12-22 07:21 Gwenole Beauchesne + + * README: Updates. + +2006-12-22 07:05 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl. + +2006-12-22 07:02 Gwenole Beauchesne + + * src/npw-viewer.c: Reject Flash Player 9 beta 1. + +2006-12-22 06:48 Gwenole Beauchesne + + * src/npw-viewer.c: Allow user to disable npruntime with the + NPW_DISABLE_NPRUNTIME env var. + +2006-12-22 00:32 Gwenole Beauchesne + + * Makefile: Fix generation of devel/release svndate in tarball's + nspluginwrapper.spec. + +2006-12-22 00:12 Gwenole Beauchesne + + * configure: Allow for a different installation root with + --pkglibdir=ROOT. + +2006-12-22 00:00 Gwenole Beauchesne + + * src/npruntime-impl.h, src/npruntime.c, src/npw-viewer.c, + src/npw-wrapper.c: Add dummy npruntime functions for browsers + that don't support that API. + Always return NPERR_MODULE_LOAD_FAILED_ERROR in NP_Initialize() + on error. + +2006-12-21 18:47 Gwenole Beauchesne + + * Makefile: Simplify ChangeLog commit string. + +2006-12-21 18:43 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl the 21_Dec + * NEWS, nspluginwrapper.spec: 0.9.91 + +2006-12-21 18:34 Gwenole Beauchesne + + * Makefile, src/npruntime-impl.h, src/npruntime.c, src/npw-rpc.c, + src/npw-rpc.h, src/npw-viewer.c, src/npw-wrapper.c: Add + npruntime support. + +2006-12-21 18:28 Gwenole Beauchesne + + * src/utils.c, src/utils.h: Add ID lookup by value. + +2006-12-21 17:56 Gwenole Beauchesne + + * src/npw-viewer.c, src/npw-wrapper.c: Fix NPN_GetValue() to + return a value even on error. + +2006-12-21 17:42 Gwenole Beauchesne + + * src/utils.c: Fix typo. + +2006-12-20 23:36 Gwenole Beauchesne + + * Makefile: Fix ChangeLog generation (strip off-project path + components). + +2006-12-20 23:35 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl the 21_Dec + +2006-12-20 10:49 Gwenole Beauchesne + + * nspluginwrapper.spec: Update for new snapshot. + +2006-12-20 10:40 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl the 20_déc + * Makefile: Add missing files for tarball generation. + +2006-12-20 10:28 Gwenole Beauchesne + + * Makefile, configure, nspluginwrapper.spec, src/npw-config.c: + Improve support for development snapshots. + +2006-12-20 07:16 Gwenole Beauchesne + + * TODO: Add note about communication stream to be flushed on error. + * src/npw-rpc.h, src/npw-viewer.c, src/npw-wrapper.c: Implement + NPN_RequestRead(). + +2006-12-20 07:14 Gwenole Beauchesne + + * src/npw-rpc.c, src/npw-rpc.h: Handle NPByteRange objects. + +2006-12-20 07:12 Gwenole Beauchesne + + * src/rpc.h: Add RPC_ERROR_MESSAGE_ARGUMENT_INVALID. + +2006-12-19 08:47 Gwenole Beauchesne + + * src/debug.c, src/npw-rpc.c, src/npw-viewer.c: Use the new + rpc_method_invoke_delayed() method. + +2006-12-19 08:46 Gwenole Beauchesne + + * TODO, src/rpc.c, src/rpc.h: Add a means to delay calls until + incoming requests are processed. + +2006-12-19 08:41 Gwenole Beauchesne + + * src/sysdeps.h: Fix NPW_COMPONENT_NAME definitions. + +2006-12-18 10:33 Gwenole Beauchesne + + * npapi/nspr/prcpucfg.h: Fix ppc64 host support (32-bit types were + mis-defined). + +2006-12-18 08:01 Gwenole Beauchesne + + * Makefile, configure, src/cxxabi-compat.cpp, src/npw-viewer.c: + Merge more complete libg++ compat code from Mozilla + (__pure_virtual). + +2006-12-17 21:56 Gwenole Beauchesne + + * configure, src/rpc.c, src/rpc.h: Add support for 64-bit integers + and double values. + +2006-12-17 17:16 Gwenole Beauchesne + + * src/npw-viewer.c, src/npw-wrapper.c: Use new NPP and NPStream + marshalers. Use NPERR_OUT_OF_MEMORY_ERROR where + necessary instead of RPC_ERROR_NO_MEMORY. Use a single + instance_id for NPP + instances, but note their IDs are allocated in the browser-side + only. + +2006-12-17 16:58 Gwenole Beauchesne + + * src/utils.c, src/utils.h: Re-work ID accessors to match + GHashTable ones better. + +2006-12-17 16:54 Gwenole Beauchesne + + * TODO: Updates. + +2006-12-17 16:38 Gwenole Beauchesne + + * src/npw-rpc.c, src/npw-rpc.h: Marshal NPP instances & NPStream + objects, based on their generated ID. + +2006-12-17 16:34 Gwenole Beauchesne + + * Makefile, src/sysdeps.h: Define specific + BUILD_{XPCOM,WRAPPER,VIEWER} macros. + +2006-12-15 16:54 Gwenole Beauchesne + + * ChangeLog: Generated by svn2cl the 15_déc + +2006-12-15 16:52 Gwenole Beauchesne + + * src/npw-config.c: Create user Mozilla plugin dir if it doesn't + exist yet. + +2006-12-15 10:41 Gwenole Beauchesne + + * Makefile: Fix bi-arch build on ppc64. + +2006-12-15 10:23 Gwenole Beauchesne + + * configure: Fix ppc64 / ppc32 support. + +2006-12-15 10:14 Gwenole Beauchesne + + * src/npw-config.c: Force ELF_CLASS redefinition. + +2006-12-13 09:52 Gwenole Beauchesne + + * tests/test-plugins.html: Add tests for mplayer plug-in. + +2006-12-13 09:51 Gwenole Beauchesne + + * Makefile, src/libxpcom.c: Add dummy XPCOM library. + +2006-12-12 23:41 Gwenole Beauchesne + + * src/npw-rpc.c, src/npw-rpc.h, src/npw-viewer.c, + src/npw-wrapper.c: Add XEMBED support. + +2006-12-11 23:43 Gwenole Beauchesne + + * tests/test-plugins.html: Add VRML Samples page. + +2006-11-30 00:05 Gwenole Beauchesne + + * src/npw-viewer.c: Initial fix for focus problems. + +2006-11-29 22:24 Gwenole Beauchesne + + * src/npw-wrapper.c: Allocate a PlugInstance to hold private data + in the wrapper plugin too. + +2006-11-27 22:40 Gwenole Beauchesne + + * src/npw-viewer.sh: Expand PATH for RealPlayer package on NetBSD + (reaplay executable). + +2006-11-27 22:39 Gwenole Beauchesne + + * Makefile, configure, src/npw-config.c: NetBSD 3.1 host support. + Auto-detect Linux/i386 plugins installed there. + +2006-11-27 10:00 Gwenole Beauchesne + + * src/npw-config.c, src/sysdeps.h: Don't try to update old-style + npwrapper.so plugin. + +2006-11-27 07:00 Gwenole Beauchesne + + * src/npw-wrapper.c: Improve plugin description. + +2006-11-27 06:54 Gwenole Beauchesne + + * src/npw-viewer.c: Print help if plugin path is not specified. + +2006-11-27 06:44 Gwenole Beauchesne + + * src/npw-config.c: Only skip target ARCH that is not available, + don't pair it with target OS. Also + skip viewers that match host OS/ARCH pairs. + +2006-11-27 00:11 Gwenole Beauchesne + + * nspluginwrapper.spec: Drop runtime subpackage. Update for 0.9.91 + (ABI change). + +2006-11-27 00:10 Gwenole Beauchesne + + * Makefile, configure, src/npw-config.c: Lowercase OS defines. + +2006-11-26 23:49 Gwenole Beauchesne + + * Makefile, configure, src/npw-config.c, src/npw-viewer.sh, + src/npw-wrapper.c, src/sysdeps.h: Move files to + NPW_LIBDIR/ARCH/OS directory where appropriate. This is necessary + to differentiate the viewers per ARCH/OS as there is no reliable + way to detect + an ELF object is for a specific OS (is e_ident[EI_OSABI] is not + filled in). + i.e. is_compatible_plugin() will actually execute npviewer + --test. Also fix + wrapped plugin installation so that it doesn't generate empty + files on failure. + +2006-11-26 17:26 Gwenole Beauchesne + + * src/npw-viewer.c, src/npw-wrapper.c: Improve arguments handling, + this should fix processing of GTK arguments. + +2006-11-25 15:52 Gwenole Beauchesne + + * Makefile, src/npw-config.c: Fix build on Linux. + +2006-11-25 15:40 Gwenole Beauchesne + + * configure, src/npw-config.c: Auto-detect Linux plugins on + FreeBSD platforms. + +2006-11-25 12:51 Gwenole Beauchesne + + * Makefile, configure: Only build the viewer on Linux platforms. + +2006-11-25 10:38 Gwenole Beauchesne + + * src/sysdeps.h: Define _XOPEN_SOURCE to 600 to use POSIX + 1003.1-2001 (with C99 elements) + +2006-11-25 10:31 Gwenole Beauchesne + + * src/npw-config.c: Embed necessary ELF definitions. + +2006-11-25 09:55 Gwenole Beauchesne + + * Makefile, configure: Detect X11 base dir, -ldl is a Linux + specific library. + +2006-11-25 09:51 Gwenole Beauchesne + + * src/npw-viewer.c: strcasecmp() is in + +2006-11-19 23:28 Gwenole Beauchesne + + * src/npw-config.c: Re-add 64-bit plugin paths, they are necessary + to get correct upgrades. + FIXME: probably split into "host" and "target" plugin dirs? + +2006-11-19 23:08 Gwenole Beauchesne + + * nspluginwrapper.spec: Fix biarch/no-biarch builds. + +2006-11-19 23:04 Gwenole Beauchesne + + * configure, nspluginwrapper.spec: Default to biarch builds on + x86-64. Make sure to report prerelease versions + so that to have a different version tag for upgrades to work. + +2006-11-19 22:58 Gwenole Beauchesne + + * src/npw-wrapper.c: Update project URL. + +2006-11-19 22:34 Gwenole Beauchesne + + * Makefile, configure, lsb-build/stub_libs/libc_nonshared.c, + src/sysdeps.h: Add checks for + __attribute__((visibility("hidden"))) and .{init,fini}_array + support. + +2006-11-19 22:32 Gwenole Beauchesne + + * Makefile: Make changelog. Clean lsb-build objdir. Cleanups. + +2006-11-19 17:43 Gwenole Beauchesne + + * README: Document simplified build on x86-64 (LSB Desktop stubs). + +2006-11-19 17:24 Gwenole Beauchesne + + * configure, src/npw-config.c: Update SUSE firefox paths. Add + Debian/Ubuntu and Gentoo plugins path. Remove + lib64 paths from mozilla since it's unlikely we need to wrap + 64-bit plugins. + +2006-11-19 15:17 Gwenole Beauchesne + + * Makefile, configure, lsb-build, lsb-build/headers, + lsb-build/headers/atk-1.0, lsb-build/headers/atk-1.0/atk, + lsb-build/headers/atk-1.0/atk/atk-enum-types.h, + lsb-build/headers/atk-1.0/atk/atk.h, + lsb-build/headers/core_filelist, + lsb-build/headers/desktop_filelist, lsb-build/headers/dlfcn.h, + lsb-build/headers/errno.h, lsb-build/headers/fcntl.h, + lsb-build/headers/fontconfig, + lsb-build/headers/fontconfig/fcfreetype.h, + lsb-build/headers/fontconfig/fcprivate.h, + lsb-build/headers/fontconfig/fontconfig.h, + lsb-build/headers/glib-2.0, lsb-build/headers/glib-2.0/glib, + lsb-build/headers/glib-2.0/glib-object.h, + lsb-build/headers/glib-2.0/glib.h, + lsb-build/headers/glib-2.0/glib/gprintf.h, + lsb-build/headers/glib-2.0/glib/gstdio.h, + lsb-build/headers/glib-2.0/gmodule.h, + lsb-build/headers/glib-2.0/gobject, + lsb-build/headers/glib-2.0/gobject/gvaluecollector.h, + lsb-build/headers/gtk-2.0, lsb-build/headers/gtk-2.0/gdk, + lsb-build/headers/gtk-2.0/gdk-pixbuf, + lsb-build/headers/gtk-2.0/gdk-pixbuf-xlib, + lsb-build/headers/gtk-2.0/gdk-pixbuf-xlib/gdk-pixbuf-xlib.h, + lsb-build/headers/gtk-2.0/gdk-pixbuf/gdk-pixbuf.h, + lsb-build/headers/gtk-2.0/gdk-pixbuf/gdk-pixdata.h, + lsb-build/headers/gtk-2.0/gdk/gdk.h, + lsb-build/headers/gtk-2.0/gdk/gdkkeysyms.h, + lsb-build/headers/gtk-2.0/gdk/gdkx.h, + lsb-build/headers/gtk-2.0/gtk, + lsb-build/headers/gtk-2.0/gtk/gtk.h, lsb-build/headers/limits.h, + lsb-build/headers/pango-1.0, lsb-build/headers/pango-1.0/pango, + lsb-build/headers/pango-1.0/pango/pango-utils.h, + lsb-build/headers/pango-1.0/pango/pango.h, + lsb-build/headers/pango-1.0/pango/pangofc-decoder.h, + lsb-build/headers/pango-1.0/pango/pangofc-fontmap.h, + lsb-build/headers/pango-1.0/pango/pangoft2.h, + lsb-build/headers/pango-1.0/pango/pangoxft.h, + lsb-build/headers/stddef.h, lsb-build/headers/stdio.h, + lsb-build/headers/stdlib.h, lsb-build/headers/string.h, + lsb-build/headers/sys, lsb-build/headers/sys/resource.h, + lsb-build/headers/sys/select.h, lsb-build/headers/sys/time.h, + lsb-build/headers/sys/types.h, lsb-build/headers/sys/wait.h, + lsb-build/headers/time.h, lsb-build/headers/unistd.h, + lsb-build/headers/wctype.h, lsb-build/stub_libs, + lsb-build/stub_libs/LibNameMap.txt, + lsb-build/stub_libs/core_filelist, + lsb-build/stub_libs/core_static_filelist, + lsb-build/stub_libs/desktop_filelist, + lsb-build/stub_libs/libX11.Version, + lsb-build/stub_libs/libX11.c, + lsb-build/stub_libs/libXext.Version, + lsb-build/stub_libs/libXext.c, + lsb-build/stub_libs/libXt.Version, lsb-build/stub_libs/libXt.c, + lsb-build/stub_libs/libc_main.Version, + lsb-build/stub_libs/libc_main.c, + lsb-build/stub_libs/libc_nonshared.c, + lsb-build/stub_libs/libdl.Version, lsb-build/stub_libs/libdl.c, + lsb-build/stub_libs/libgcc_s.Version, + lsb-build/stub_libs/libgcc_s.c, + lsb-build/stub_libs/libgdk-x11-2.0.Version, + lsb-build/stub_libs/libgdk-x11-2.0.c, + lsb-build/stub_libs/libglib-2.0.Version, + lsb-build/stub_libs/libglib-2.0.c, + lsb-build/stub_libs/libgobject-2.0.Version, + lsb-build/stub_libs/libgobject-2.0.c, + lsb-build/stub_libs/libgthread-2.0.Version, + lsb-build/stub_libs/libgthread-2.0.c, + lsb-build/stub_libs/libgtk-x11-2.0.Version, + lsb-build/stub_libs/libgtk-x11-2.0.c, + lsb-build/stub_libs/libpthread.Version, + lsb-build/stub_libs/libpthread.c, src/utils.c: Import (minimal) + LSB Desktop build environment so that to help non-multiarch + capable x86-64 distributions to build the 32-bit viewer. + +2006-11-17 16:47 Gwenole Beauchesne + + * configure, src/npw-config.c, src/sysdeps.h: bswap_*() functions + were only used in npw-config.c + +2006-11-17 15:41 Gwenole Beauchesne + + * ChangeLog: updates + +2006-11-17 15:40 Gwenole Beauchesne + + * NEWS, nspluginwrapper.spec: 0.9.90.4 + +2006-11-17 15:38 Gwenole Beauchesne + + * README: Document --with-biarch, minor updates. + +2006-11-17 09:58 Gwenole Beauchesne + + * nspluginwrapper.spec: update to use %_with_biarch directly + +2006-11-17 08:01 Gwenole Beauchesne + + * src/npw-viewer.c, src/npw-wrapper.c, src/utils.c, src/utils.h: + Use optimized hash tables from GLib. + +2006-11-16 06:07 Gwenole Beauchesne + + * src/npw-viewer.c: Only print message with dimensions are still + null... + +2006-11-15 12:52 Gwenole Beauchesne + + * ChangeLog, Makefile: Add missing files for tarball generation. + * NEWS, nspluginwrapper.spec: 0.9.90.4 + +2006-11-15 11:16 Gwenole Beauchesne + + * src/npw-viewer.c: Fixup NPWindow size hints. Flash Player + doesn't like null dimensions and + Konqueror is actually passing that through + NPP_SetWindow()->NPWindow. + +2006-11-15 11:13 Gwenole Beauchesne + + * src/npw-wrapper.c: Add support for Konqueror (not GTK based + toolkit) + +2006-11-15 10:35 Gwenole Beauchesne + + * src/npw-viewer.c: Avoid an NPWindow->ws_info double free. + Comment implementation choices. + +2006-11-15 10:31 Gwenole Beauchesne + + * src/npw-rpc.h: Warning fixes (use uint8_t[] for NPPrintData + buffer) + +2006-11-15 08:05 Gwenole Beauchesne + + * src/npw-rpc.c, src/npw-rpc.h, src/npw-viewer.c, + src/npw-wrapper.c: Add printing support (implement NPP_Print) + +2006-11-14 21:16 Gwenole Beauchesne + + * src/npw-rpc.c, src/npw-rpc.h, src/npw-viewer.c, + src/npw-wrapper.c: Use dedicated marshaler for NPWindow & NPRect + structures. Rework NPP_SetWindow + to support NULL window arguments. Don't realize the top_widget, + only the form. + +2006-11-13 22:07 Gwenole Beauchesne + + * src/npw-wrapper.c: use g_source_add_poll + +2006-11-13 08:10 Gwenole Beauchesne + + * src/npw-wrapper.c: _Exit(255) after a failed fork()+execv() + (original patch by Darryl L. Miles) + +2006-11-12 22:08 Gwenole Beauchesne + + * Makefile, src/npw-viewer.c, src/npw-viewer.map: use a version + script for RP8 compatibility glue (export __pure_virtual) + +2006-11-12 20:41 Gwenole Beauchesne + + * src/npw-viewer.c: fix XEvent polling, don't use deprecated gtk + polling routine, use g_source + polling functions + +2006-11-12 20:06 Gwenole Beauchesne + + * Makefile: use RP8 hack while building 32-bit viewer on x86_64 + +2006-11-11 17:03 Gwenole Beauchesne + + * src/npw-viewer.c: Remove useless (and actually problematic) + XInitThreads() call + +2006-11-11 16:40 Gwenole Beauchesne + + * Makefile, configure, nspluginwrapper.spec: install + nspluginwrapper symlink + +2006-11-11 15:21 Gwenole Beauchesne + + * src/npw-viewer.c: headers cleanup + +2006-11-11 15:18 Gwenole Beauchesne + + * src/npw-viewer.c: use XtResizeWidget() to resize the plugin + window + +2006-11-11 09:46 Gwenole Beauchesne + + * src/npw-rpc.h, src/npw-viewer.c, src/npw-wrapper.c: Implement + NPN_PostURL() and NPN_PostURLNotify() + +2006-11-08 08:11 Gwenole Beauchesne + + * Makefile, configure, nspluginwrapper.spec: handle bi-arch builds + (original patch by Darryl L. Miles) + +2006-11-08 06:38 Gwenole Beauchesne + + * nspluginwrapper.spec: don't override compile flags, the default + should be good enough and + distribution-specific packages are expected to be better + +2006-11-08 06:37 Gwenole Beauchesne + + * configure: there is no C++ in nspluginwrapper + +2006-10-27 04:36 Gwenole Beauchesne + + * Makefile: fix make uninstall target (reported by stranche) + +2006-09-25 22:42 Gwenole Beauchesne + + * nspluginwrapper.spec: use plain make command not the %make macro + (Thibaut Cousin) + +2006-09-24 16:11 Gwenole Beauchesne + + * NEWS, nspluginwrapper.spec, src/npw-viewer.c: fix acrobat reader + 7 plugin + +2006-09-24 16:07 Gwenole Beauchesne + + * nspluginwrapper.spec: add specfile %changelog missed in initial + tarball + +2006-09-24 16:06 Gwenole Beauchesne + + * NEWS, nspluginwrapper.spec, src/debug.c, src/npw-viewer.c, + src/npw-wrapper.c, src/rpc.c, src/rpc.h: use a bidirectional + communication channel + +2006-09-24 15:49 Gwenole Beauchesne + + * gwenole, gwenole/projects, gwenole/projects/nspluginwrapper, + gwenole/projects/nspluginwrapper/branches, + gwenole/projects/nspluginwrapper/tags, ., COPYING, Makefile, + NEWS, README, TODO, configure, npapi, npapi/jni.h, + npapi/jni_md.h, npapi/jri.h, npapi/jri_md.h, npapi/jritypes.h, + npapi/npapi.h, npapi/npruntime.h, npapi/nptypes.h, + npapi/npupp.h, npapi/nspr, npapi/nspr/obsolete, + npapi/nspr/obsolete/protypes.h, npapi/nspr/prcpucfg.h, + npapi/nspr/prtypes.h, nspluginwrapper.spec, src, src/debug.c, + src/debug.h, src/npw-config.c, src/npw-rpc.c, src/npw-rpc.h, + src/npw-viewer.c, src/npw-viewer.sh, src/npw-wrapper.c, + src/rpc.c, src/rpc.h, src/sysdeps.h, src/utils.c, src/utils.h, + tests, tests/test-plugins.html, utils, utils/getdeps.sh, + utils/mkruntime.sh, utils/npw-shadow.c, utils/repackage.sh, + utils/xtrace.c: initial import + diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..2f4eb7b --- /dev/null +++ b/Makefile @@ -0,0 +1,322 @@ +#!/bin/sh +# +# nspluginwrapper Makefile (C) 2005-2006 Gwenole Beauchesne +# +-include config.mak + +CFLAGS += -Wall + +ifeq ($(SRC_PATH),) +SRC_PATH = . +endif + +PACKAGE = nspluginwrapper +ifeq ($(VERSION),) +VERSION := $(shell sed < $(SRC_PATH)/$(PACKAGE).spec -n '/^\%define version[ ]*/s///p') +endif +ifeq ($(RELEASE),) +RELEASE := $(shell sed < $(SRC_PATH)/$(PACKAGE).spec -n '/^\%define release[ ]*/s///p') +endif +ifeq ($(SVNDATE),) +SVNDATE := $(shell sed < $(SRC_PATH)/$(PACKAGE).spec -n '/^\%define svndate[ ]*/s///p') +endif +ifeq ($(SVNDATE),) +SVNDATE := $(shell date '+%Y%m%d') +endif +ifeq ($(SNAPSHOT),) +SNAPSHOT := $(shell echo "$(RELEASE)" | grep "^0") +ifeq ($(SNAPSHOT),$(RELEASE)) +SNAPSHOT := 1 +endif +endif +ifeq ($(SNAPSHOT),1) +VERSION_SUFFIX = -$(SVNDATE) +endif + +ifneq ($(DONT_STRIP), yes) +STRIP_OPT = -s +endif + +ifneq (,$(findstring $(OS),linux)) +libdl_LDFLAGS = -ldl +endif + +X_CFLAGS = -I$(x11prefix)/include +X_LDFLAGS = -L$(x11prefix)/$(lib64) -lX11 -lXt +ifeq ($(OS),netbsd) +X_LDFLAGS += -Wl,--rpath,$(x11prefix)/$(lib64) +endif + +ARCH_32 = $(ARCH) +ifeq ($(biarch), yes) +ARCH_32 = $(TARGET_ARCH) +LSB_LIBS = $(LSB_OBJ_DIR)/libc.so $(LSB_OBJ_DIR)/libgcc_s_32.so +LSB_LIBS += $(LSB_CORE_STUBS:%=$(LSB_OBJ_DIR)/%.so) +LSB_LIBS += $(LSB_CORE_STATIC_STUBS:%=$(LSB_OBJ_DIR)/%.a) +LSB_LIBS += $(LSB_DESKTOP_STUBS:%=$(LSB_OBJ_DIR)/%.so) +endif + +LSB_TOP_DIR = $(SRC_PATH)/lsb-build +LSB_INC_DIR = $(LSB_TOP_DIR)/headers +LSB_SRC_DIR = $(LSB_TOP_DIR)/stub_libs +LSB_OBJ_DIR = lsb-build-$(ARCH_32) +LSB_CORE_STUBS = $(shell cat $(LSB_SRC_DIR)/core_filelist) +LSB_CORE_STATIC_STUBS = $(shell cat $(LSB_SRC_DIR)/core_static_filelist) +LSB_DESKTOP_STUBS = $(shell cat $(LSB_SRC_DIR)/desktop_filelist) + +ifeq (i386,$(TARGET_ARCH)) +TARGET_ELF_ARCH = elf32-i386 +endif +ifeq (ppc,$(TARGET_ARCH)) +TARGET_ELF_ARCH = elf32-powerpc +endif + +MOZILLA_CFLAGS = -I$(SRC_PATH)/npapi -I$(SRC_PATH)/npapi/nspr + +npwrapper_LIBRARY = npwrapper.so +npwrapper_RAWSRCS = npw-wrapper.c npw-rpc.c rpc.c debug.c utils.c npruntime.c +npwrapper_SOURCES = $(npwrapper_RAWSRCS:%.c=$(SRC_PATH)/src/%.c) +npwrapper_OBJECTS = $(npwrapper_RAWSRCS:%.c=npwrapper-%.os) +npwrapper_CFLAGS = $(CFLAGS) $(X_CFLAGS) $(MOZILLA_CFLAGS) $(GLIB_CFLAGS) +npwrapper_LDFLAGS = $(X_LDFLAGS) -lpthread +npwrapper_LDFLAGS += $(GLIB_LDFLAGS) + +npviewer_PROGRAM = npviewer.bin +npviewer_RAWSRCS = npw-viewer.c npw-rpc.c rpc.c debug.c utils.c npruntime.c +npviewer_SOURCES = $(npviewer_RAWSRCS:%.c=$(SRC_PATH)/src/%.c) +npviewer_OBJECTS = $(npviewer_RAWSRCS:%.c=npviewer-%.o) +ifeq ($(biarch),yes) +npviewer_CFLAGS = $(CFLAGS_32) +npviewer_CFLAGS += -I$(LSB_INC_DIR) +npviewer_CFLAGS += -I$(LSB_INC_DIR)/glib-2.0 +npviewer_CFLAGS += -I$(LSB_INC_DIR)/gtk-2.0 +npviewer_LDFLAGS = $(LDFLAGS_32) -L$(LSB_OBJ_DIR) +npviewer_LDFLAGS += -lgtk-x11-2.0 -lgdk-x11-2.0 -lgobject-2.0 -ldl -lglib-2.0 -lX11 -lXt +else +npviewer_CFLAGS += $(GTK_CFLAGS) +npviewer_LDFLAGS = $(GTK_LDFLAGS) $(X_LDFLAGS) +endif +npviewer_CFLAGS += $(MOZILLA_CFLAGS) +npviewer_LDFLAGS += $(libdl_LDFLAGS) -lpthread +ifeq ($(TARGET_ARCH),i386) +npviewer_MAPFILE = $(SRC_PATH)/src/npw-viewer.map +endif +ifneq ($(npviewer_MAPFILE),) +npviewer_LDFLAGS += -Wl,--export-dynamic +npviewer_LDFLAGS += -Wl,--version-script,$(npviewer_MAPFILE) +endif +ifeq ($(OS):$(TARGET_ARCH),linux:i386) +npviewer_SOURCES += $(SRC_PATH)/src/cxxabi-compat.cpp +npviewer_OBJECTS += npviewer-cxxabi-compat.o +npviewer_LDFLAGS += -lsupc++ +endif + +libxpcom_LIBRARY = libxpcom.so +libxpcom_RAWSRCS = libxpcom.c debug.c +libxpcom_SOURCES = $(libxpcom_RAWSRCS:%.c=$(SRC_PATH)/src/%.c) +libxpcom_OBJECTS = $(libxpcom_RAWSRCS:%.c=libxpcom-%.o) +libxpcom_CFLAGS = -fPIC + +npconfig_PROGRAM = npconfig +npconfig_RAWSRCS = npw-config.c +npconfig_SOURCES = $(npconfig_RAWSRCS:%.c=$(SRC_PATH)/src/%.c) +npconfig_OBJECTS = $(npconfig_RAWSRCS:%.c=npconfig-%.o) +npconfig_LDFLAGS = $(libdl_LDFLAGS) +ifeq ($(OS),netbsd) +# We will try to dlopen() the native plugin library. If that lib is +# linked against libpthread, then so must our program too. +# XXX use the ELF decoder for native plugins too? +npconfig_LDFLAGS += -lpthread +endif + +nploader_PROGRAM = npviewer +nploader_RAWSRCS = npw-viewer.sh +nploader_SOURCES = $(nploader_RAWSRCS:%.sh=$(SRC_PATH)/src/%.sh) + +CPPFLAGS = -I. -I$(SRC_PATH) +TARGETS = $(npconfig_PROGRAM) +TARGETS += $(nploader_PROGRAM) +TARGETS += $(npwrapper_LIBRARY) +ifeq ($(build_viewer),yes) +TARGETS += $(npviewer_PROGRAM) +TARGETS += $(libxpcom_LIBRARY) +endif + +archivedir = files/ +SRCARCHIVE = $(PACKAGE)-$(VERSION)$(VERSION_SUFFIX).tar +FILES = configure Makefile nspluginwrapper.spec +FILES += README NEWS TODO COPYING ChangeLog +FILES += $(wildcard utils/*.sh) +FILES += $(wildcard utils/*.c) +FILES += $(wildcard src/*.c) +FILES += $(wildcard src/*.cpp) +FILES += $(wildcard src/*.h) +FILES += $(wildcard src/*.sh) +FILES += $(wildcard src/*.map) +FILES += $(wildcard tests/*.html) +FILES += $(wildcard npapi/*.h npapi/nspr/*.h npapi/nspr/obsolete/*.h) +FILES += $(LSB_TOP_DIR)/headers/core_filelist +FILES += $(addprefix $(LSB_TOP_DIR)/headers/,$(shell cat $(LSB_TOP_DIR)/headers/core_filelist)) +FILES += $(LSB_TOP_DIR)/headers/desktop_filelist +FILES += $(addprefix $(LSB_TOP_DIR)/headers/,$(shell cat $(LSB_TOP_DIR)/headers/desktop_filelist)) +FILES += $(LSB_SRC_DIR)/LibNameMap.txt +FILES += $(LSB_SRC_DIR)/core_filelist +FILES += $(LSB_SRC_DIR)/core_static_filelist +FILES += $(LSB_SRC_DIR)/desktop_filelist +FILES += $(patsubst %,$(LSB_SRC_DIR)/%.c,$(LSB_CORE_STUBS)) +FILES += $(patsubst %,$(LSB_SRC_DIR)/%.Version,$(LSB_CORE_STUBS)) +FILES += $(patsubst %,$(LSB_SRC_DIR)/%.c,$(LSB_CORE_STATIC_STUBS)) +FILES += $(patsubst %,$(LSB_SRC_DIR)/%.c,$(LSB_DESKTOP_STUBS)) +FILES += $(patsubst %,$(LSB_SRC_DIR)/%.Version,$(LSB_DESKTOP_STUBS)) + +all: $(TARGETS) + +clean: + rm -f $(TARGETS) *.o *.os + rm -rf $(LSB_OBJ_DIR) + +distclean: clean + rm -f config-host.* config.* + +uninstall: uninstall.wrapper uninstall.viewer uninstall.libxpcom uninstall.loader uninstall.config uninstall.mkruntime uninstall.dirs +uninstall.dirs: + rmdir $(DESTDIR)$(pkglibdir)/noarch + rmdir $(DESTDIR)$(pkglibdir)/$(ARCH)/$(OS) + rmdir $(DESTDIR)$(pkglibdir)/$(ARCH) +ifneq ($(ARCH),$(ARCH_32)) + rmdir $(DESTDIR)$(pkglibdir)/$(ARCH_32)/$(TARGET_OS) + rmdir $(DESTDIR)$(pkglibdir)/$(ARCH_32) +endif +uninstall.wrapper: + rm -f $(DESTDIR)$(pkglibdir)/$(ARCH)/$(OS)/$(npwrapper_LIBRARY) +uninstall.viewer: + rm -f $(DESTDIR)$(pkglibdir)/$(ARCH_32)/$(TARGET_OS)/$(npviewer_PROGRAM) + rm -f $(DESTDIR)$(pkglibdir)/$(ARCH_32)/$(TARGET_OS)/$(npviewer_PROGRAM:%.bin=%) +uninstall.libxpcom: + rm -f $(DESTDIR)$(pkglibdir)/$(ARCH_32)/$(TARGET_OS)/$(libxpcom_LIBRARY) +uninstall.loader: + rm -f $(DESTDIR)$(pkglibdir)/noarch/$(nploader_PROGRAM) +uninstall.config: + rm -f $(DESTDIR)$(bindir)/nspluginwrapper + rm -f $(DESTDIR)$(pkglibdir)/$(ARCH)/$(OS)/$(npconfig_PROGRAM) +uninstall.mkruntime: + rm -f $(DESTDIR)$(pkglibdir)/noarch/mkruntime + +install: install.dirs install.wrapper install.viewer install.libxpcom install.loader install.config install.mkruntime +install.dirs: + mkdir -p $(DESTDIR)$(pkglibdir)/noarch + mkdir -p $(DESTDIR)$(pkglibdir)/$(ARCH) + mkdir -p $(DESTDIR)$(pkglibdir)/$(ARCH)/$(OS) +ifneq ($(ARCH),$(ARCH_32)) + mkdir -p $(DESTDIR)$(pkglibdir)/$(ARCH_32) + mkdir -p $(DESTDIR)$(pkglibdir)/$(ARCH_32)/$(TARGET_OS) +endif +install.wrapper: $(npwrapper_LIBRARY) + install -m 755 $(STRIP_OPT) $(npwrapper_LIBRARY) $(DESTDIR)$(pkglibdir)/$(ARCH)/$(OS)/$(npwrapper_LIBRARY) +ifeq ($(build_viewer),yes) +install.viewer: install.viewer.bin install.viewer.glue +install.libxpcom: do.install.libxpcom +else +install.viewer: +install.libxpcom: +endif +install.viewer.bin: $(npviewer_PROGRAM) + install -m 755 $(STRIP_OPT) $(npviewer_PROGRAM) $(DESTDIR)$(pkglibdir)/$(ARCH_32)/$(TARGET_OS)/$(npviewer_PROGRAM) +install.viewer.glue:: + p=$(DESTDIR)$(pkglibdir)/$(ARCH_32)/$(TARGET_OS)/$(npviewer_PROGRAM:%.bin=%); \ + echo "#!/bin/sh" > $$p; \ + echo "TARGET_OS=$(TARGET_OS)" >> $$p; \ + echo "TARGET_ARCH=$(TARGET_ARCH)" >> $$p; \ + echo ". $(pkglibdir)/noarch/$(nploader_PROGRAM)" >> $$p; \ + chmod 755 $$p +do.install.libxpcom: $(libxpcom_LIBRARY) + install -m 755 $(STRIP_OPT) $(libxpcom_LIBRARY) $(DESTDIR)$(pkglibdir)/$(ARCH_32)/$(TARGET_OS)/$(libxpcom_LIBRARY) +install.config: $(npconfig_PROGRAM) + install -m 755 $(STRIP_OPT) $(npconfig_PROGRAM) $(DESTDIR)$(pkglibdir)/$(ARCH)/$(OS)/$(npconfig_PROGRAM) + mkdir -p $(DESTDIR)$(bindir) + ln -s $(pkglibdir)/$(ARCH)/$(OS)/$(npconfig_PROGRAM) $(DESTDIR)$(bindir)/nspluginwrapper +install.loader: $(nploader_PROGRAM) + install -m 755 $(nploader_PROGRAM) $(DESTDIR)$(pkglibdir)/noarch/$(nploader_PROGRAM) +install.mkruntime: $(SRC_PATH)/utils/mkruntime.sh + install -m 755 $< $(DESTDIR)$(pkglibdir)/noarch/mkruntime + +$(archivedir):: + [ -d $(archivedir) ] || mkdir $(archivedir) > /dev/null 2>&1 + +tarball: + $(MAKE) -C $(SRC_PATH) do_tarball +do_tarball: $(archivedir) $(archivedir)$(SRCARCHIVE).bz2 + +$(archivedir)$(SRCARCHIVE): $(archivedir) $(FILES) + BUILDDIR=`mktemp -d /tmp/buildXXXXXXXX` ; \ + mkdir -p $$BUILDDIR/$(PACKAGE)-$(VERSION) ; \ + (cd $(SRC_PATH) && tar c $(FILES)) | tar x -C $$BUILDDIR/$(PACKAGE)-$(VERSION) ; \ + [ "$(SNAPSHOT)" = "1" ] && svndate_def="%" || svndate_def="#" ; \ + sed -e "s/^[%#]define svndate.*/$${svndate_def}define svndate $(SVNDATE)/" \ + < $(SRC_PATH)/nspluginwrapper.spec \ + > $$BUILDDIR/$(PACKAGE)-$(VERSION)/nspluginwrapper.spec ; \ + (cd $$BUILDDIR && tar cvf $(SRCARCHIVE) $(PACKAGE)-$(VERSION)) ; \ + mv -f $$BUILDDIR/$(SRCARCHIVE) $(archivedir) ; \ + rm -rf $$BUILDDIR +$(archivedir)$(SRCARCHIVE).bz2: $(archivedir)$(SRCARCHIVE) + bzip2 -9vf $(archivedir)$(SRCARCHIVE) + +localrpm: $(archivedir)$(SRCARCHIVE).bz2 + rpm -ta $< + +changelog: ../common/authors.xml + svn_prefix=`svn info .|sed -n '/^URL *: .*\/svn\/\(.*\)$$/s//\1\//p'`; \ + svn2cl --strip-prefix=$$svn_prefix --authors=../common/authors.xml || : + svn commit -m "Generated by svn2cl." ChangeLog + +$(npwrapper_LIBRARY): $(npwrapper_OBJECTS) + $(CC) -o $@ -shared $(npwrapper_OBJECTS) $(npwrapper_LDFLAGS) + +npwrapper-%.os: $(SRC_PATH)/src/%.c + $(CC) -o $@ -c $< -fPIC $(CPPFLAGS) $(npwrapper_CFLAGS) -DBUILD_WRAPPER + +$(npviewer_PROGRAM): $(npviewer_OBJECTS) $(npviewer_MAPFILE) $(LSB_OBJ_DIR) $(LSB_LIBS) + $(CC) $(LDFLAGS_32) -o $@ $(npviewer_OBJECTS) $(npviewer_LDFLAGS) + +npviewer-%.o: $(SRC_PATH)/src/%.c + $(CC) $(CFLAGS_32) -o $@ -c $< $(CPPFLAGS) $(npviewer_CFLAGS) -DBUILD_VIEWER + +npviewer-%.o: $(SRC_PATH)/src/%.cpp + $(CXX) $(CFLAGS_32) -o $@ -c $< $(CPPFLAGS) $(npviewer_CFLAGS) -DBUILD_VIEWER + +$(libxpcom_LIBRARY): $(libxpcom_OBJECTS) $(LSB_OBJ_DIR) $(LSB_LIBS) + $(CC) $(LDFLAGS_32) -shared -o $@ $(libxpcom_OBJECTS) $(libxpcom_LDFLAGS) -Wl,--soname,libxpcom.so + +libxpcom-%.o: $(SRC_PATH)/src/%.c + $(CC) $(CFLAGS_32) -o $@ -c $< $(CPPFLAGS) $(libxpcom_CFLAGS) -DBUILD_XPCOM + +$(npconfig_PROGRAM): $(npconfig_OBJECTS) + $(CC) -o $@ $(npconfig_OBJECTS) $(npconfig_LDFLAGS) + +npconfig-%.o: $(SRC_PATH)/src/%.c + $(CC) -o $@ -c $< $(CPPFLAGS) $(CFLAGS) + +$(nploader_PROGRAM): $(nploader_SOURCES) + sed -e "s|%NPW_LIBDIR%|$(pkglibdir)|" $< > $@ + chmod 755 $@ + +$(LSB_OBJ_DIR):: + @[ -d $(LSB_OBJ_DIR) ] || mkdir $(LSB_OBJ_DIR) > /dev/null 2>&1 + +$(LSB_OBJ_DIR)/%.o: $(LSB_SRC_DIR)/%.c + $(CC) $(CFLAGS_32) -nostdinc -fno-builtin -I. -I$(LSB_INC_DIR) -c $< -o $@ + +$(LSB_OBJ_DIR)/%.a: $(LSB_OBJ_DIR)/%.o + $(AR) rc $@ $< + +$(LSB_OBJ_DIR)/libc.so: $(LSB_OBJ_DIR)/libc_main.so $(LSB_OBJ_DIR)/libc_nonshared.a + @echo "OUTPUT_FORMAT($(TARGET_ELF_ARCH))" > $@ + @echo "GROUP ( $(LSB_OBJ_DIR)/libc_main.so $(LSB_OBJ_DIR)/libc_nonshared.a )" >> $@ + +$(LSB_OBJ_DIR)/libgcc_s_32.so: $(LSB_OBJ_DIR)/libgcc_s.so + ln -s libgcc_s.so $@ + +$(LSB_OBJ_DIR)/%.so: $(LSB_OBJ_DIR)/%.o + $(CC) $(LDFLAGS_32) -nostdlib -shared $< -o $@ \ + -Wl,--version-script,$(patsubst $(LSB_OBJ_DIR)/%.o,$(LSB_SRC_DIR)/%.Version,$<) \ + -Wl,-soname,`grep "$(patsubst $(LSB_OBJ_DIR)/%.o,%,$<) " $(LSB_SRC_DIR)/LibNameMap.txt | cut -f2 -d' '` diff --git a/NEWS b/NEWS new file mode 100644 index 0000000..f175b83 --- /dev/null +++ b/NEWS @@ -0,0 +1,38 @@ +nspluginwrapper NEWS -- history of user-visible changes. 2006-12-26 +Copyright (C) 2006 Gwenole Beauchesne + +Version 0.9.91.1 (BETA) - 26.Dec.2006 +* Fix NPRuntime bridge (VLC plugin) +* Fix Mozilla plugins dir creation on NetBSD and FreeBSD hosts +* Fix potential buffer overflow in RPC marshalers +* Handle empty args for plugin creation (flasharcade.com) + +Version 0.9.91 (BETA) - 22.Dec.2006 +* Add scripting support through the NPRuntime API +* Add XEMBED support for e.g. MPlayer plug-in +* Add support for NetBSD, FreeBSD and non-x86 Linux platforms +* Fix focus problems +* Fix some rare hangs +* Create Mozilla plugins dir if it does not exist yet + +Version 0.9.90.4 (BETA) - 18.Nov.2006 +* Robustify error condition (Darryl L. Miles) +* Reduce plugin load times +* Fix post data to a URL +* Add printing support +* Add Konqueror browser support + +Version 0.9.90.3 (BETA) - 19.Sep.2006 +* Fix acrobat reader 7 plugin + +Version 0.9.90.2 (BETA) - 15.Sep.2006 +* Use a bidirectional communication channel rather than two channels + + a "delayed" execution engine + +Version 0.9.90.1 (BETA) - 05.Jun.2006 +* Handle SuSE Linux Mozilla paths +* Don't use QEMU on IA-64 platforms +* Portability fixes to non-Linux platforms + +Version 0.9.90 (BETA) - 25.Oct.2005 +* First public beta that has decent Flash Player support diff --git a/README b/README new file mode 100644 index 0000000..ed84a1c --- /dev/null +++ b/README @@ -0,0 +1,99 @@ + + nspluginwrapper + A cross-platform NPAPI plugin viewer + + Copyright (C) 2005-2006 Gwenole Beauchesne + + +License +------- + +nspluginwrapper is available under the terms of the GNU General Public License. +See the file "COPYING" that is included in the distribution for details. + + +Overview +-------- + +nspluginwrapper consists in a proxy plugin and a viewer for NPAPI +compatible plugins. It makes it possible to use 32-bit x86 plugins +like Adobe Flash Player on other platforms like Linux/x86_64, *BSD and +even Linux/ppc. + + +Quick build notes +----------------- + +To simplify the build of the 32-bit viewer, a minimal subset of LSB +Desktop 3.1 is included in this distribution. Hence, you only have +to proceed as follows: + +$ ./configure +$ make +# make install + +Or, if you prefer from a source package: +$ rpm --rebuild nspluginwrapper.src.rpm + + +Requirements and Installation +----------------------------- + +A Mozilla based browser built with GTK 2 support is currently required +for proper operation. An alternative is Konqueror but it does not yet +support the npruntime scripting API. + +On package installation, 32-bit plugins are automatically recognized +provided they are available in the /usr/lib/mozilla/plugins directory. + +You can manually install/remove/update plugins with "nspluginwrapper". + + usage: nspluginwrapper [flags] [command [plugin(s)]] + + -h --help print this message + -a --auto set automatic mode for plugins discovery + -l --list list plugins currently installed + -u --update update plugin(s) currently installed + -i --install [FILE(S)] install plugin(s) + -r --remove [FILE(S)] remove plugin(s) + +[plugin(s)] are full paths to actual plugin binaries (e.g. nppdf.so +for Acrobat Reader, libflashplayer.so for Flash). + + +Compatibility List +------------------ + +Please bear in mind this is *BETA* software. + +The following plugins work reasonnably well: +- Acrobat Reader 5.0.9 +- Acrobat Reader 7.0.1 +- DejaVu Libre 3.5.14 +- Flash Player 7.0 +- Flash Player 9.0b2 +- Linux J2K 0.0.2 +- Mplayerplug-in 2.80 +- Mplayerplug-in 3.25 +- Real Player 8.0 +- Real Player 10.0.5 +- Tcl plugin 3.1 +- Squeak VM plugin 3.7 + +Broken or partially working: +- Real Player 8.0 +- Adobe SVG 3.01x88 + + +History +------- + +Please consult the file "NEWS" for the release history. +An auto-generated "ChangeLog" is also available in this distribution. + + +Author +------ + +Gwenole Beauchesne, + diff --git a/TODO b/TODO new file mode 100644 index 0000000..d9ce9d2 --- /dev/null +++ b/TODO @@ -0,0 +1,15 @@ +- Clean-ups + * Re-indent -gnu -br -brs + * Better split for RPC / NAPI level routines + * Empty communication stream on RPC error so that next request can work +- Write the testsuite + * RPC tests, basic types + * RPC tests, NPAPI types (including NPVariant) + * NPAPI plugins (compliance checks, error recovery, async requests) +- XPCOM support + * Parse XPT files? + * Mix native / marshaled components? +- Windows plugins support + * Import minimal GLib functions (hashes, etc.) + * Split toolkit specific code (npviewer-{x11,gtk,win}.c) + * Use winelib + override win32 socket to support AF_UNIX (Linux "native") diff --git a/configure b/configure new file mode 100755 index 0000000..3ae3207 --- /dev/null +++ b/configure @@ -0,0 +1,602 @@ +#!/bin/sh +# +# nspluginwrapper configure script (C) 2005-2006 Gwenole Beauchesne +# derived from qemu configure script, (C) 2003 Fabrice Bellard +# +PACKAGE=nspluginwrapper + +# set temporary file name +if test ! -z "$TMPDIR" ; then + TMPDIR1="${TMPDIR}" +elif test ! -z "$TEMPDIR" ; then + TMPDIR1="${TEMPDIR}" +else + TMPDIR1="/tmp" +fi + +TMPC="${TMPDIR1}/npw-conf-${RANDOM}-$$-${RANDOM}.c" +TMPO="${TMPDIR1}/npw-conf-${RANDOM}-$$-${RANDOM}.o" +TMPE="${TMPDIR1}/npw-conf-${RANDOM}-$$-${RANDOM}" +TMPS="${TMPDIR1}/npw-conf-${RANDOM}-$$-${RANDOM}.S" + +# default parameters +prefix="/usr" +lib32="" +lib64="" +biarch="guess" +build_viewer="guess" +cc="gcc -std=c99" +cxx="g++" +host_os=`uname -s | tr '[A-Z]' '[a-z]'` +host_cpu=`uname -m` +target_os="linux" +target_cpu="i386" +case "$host_cpu" in +i386|i486|i586|i686|i86pc|BePC) + host_cpu="i386" + ;; +ia64) + host_cpu="ia64" + ;; +"Power Macintosh"|ppc) + host_cpu="ppc" + ;; +ppc64) + host_cpu="ppc64" + ;; +sparc) + host_cpu="sparc" + ;; +sparc64) + host_cpu="sparc64" + ;; +x86_64|amd64) + host_cpu="x86_64" + ;; +*) + host_cpu="unknown" + ;; +esac +bigendian="no" + +# find source path +# XXX: we assume an absolute path is given when launching configure, +# except in './configure' case. +source_path=${0%configure} +source_path=${source_path%/} +source_path_used="yes" +if test -z "$source_path" -o "$source_path" = "." ; then + source_path=`pwd` + source_path_used="no" +fi + +for opt do +case "$opt" in +--prefix=*) + prefix=`echo $opt | cut -d '=' -f 2` + ;; +--pkglibdir=*) + pkglibdir=`echo $opt | cut -d '=' -f 2` + ;; +--target-os=*) + target_os=`echo $opt | cut -d '=' -f 2 | tr '[A-Z]' '[a-z]'` + ;; +--target-cpu=*) + target_cpu=`echo $opt | cut -d '=' -f 2 | sed -e 's/^i.86$/i386/'` + ;; +--with-biarch) + biarch="yes" + ;; +--without-biarch) + biarch="no" + ;; +--with-viewer) + build_viewer="yes" + ;; +--without-viewer) + build_viewer="no" + ;; +--with-lib32=*) + lib32=`echo $opt | cut -d '=' -f 2` + ;; +--with-lib64=*) + lib64=`echo $opt | cut -d '=' -f 2` + ;; +--with-cc=*) + cc=`echo $opt | cut -d '=' -f 2` + ;; +--with-cxx=*) + cxx=`echo $opt | cut -d '=' -f 2` + ;; +esac +done + +# check for biarch build +if test "$biarch" = "guess"; then + case $host_cpu:$target_cpu in + x86_64:i386 | ppc64:ppc) + biarch="yes" + ;; + *) + biarch="no" + ;; + esac +fi + +# check for viewer builds +if test "$build_viewer" = "guess"; then + build_viewer="no" + case $host_os in + linux) + if test "$host_cpu" = "$target_cpu" -o "$biarch" = "yes"; then + build_viewer="yes" + fi + ;; + esac +fi + +# check for libdir name +if test -z "$lib64"; then + case $host_os in + linux) + # test if the compiler is 64bit + echo 'int i;' > $TMPC + nspluginwrapper_64bit_output=no + if $cc -o $TMPO -c $TMPC; then + case `/usr/bin/file $TMPO` in + *"ELF 64"*) + nspluginwrapper_64bit_output=yes + ;; + esac + fi + rm -f $TMPC $TMPO + ;; + esac + case $host_cpu:$nspluginwrapper_64bit_output in + ppc64:yes | s390x:yes | sparc64:yes | x86_64:yes) + lib64="lib64" + ;; + *) + lib64="lib" + ;; + esac +fi +if test -z "$lib32"; then + lib32="lib" +fi + +# check for installation root +if test -z "$pkglibdir"; then + pkglibdir="$prefix/lib/$PACKAGE" +fi + +# check for __attribute__((visibility())) support +cat > $TMPC << EOF +int foo __attribute__((visibility("hidden"))) = 1; +int bar __attribute__((visibility("protected"))) = 1; +EOF +has_visibility_attribute=no +if $cc -Werror -S $TMPC -o $TMPS >/dev/null 2>&1; then + if grep '\.hidden.*foo' $TMPS >/dev/null; then + if grep '\.protected.*bar' $TMPS >/dev/null; then + has_visibility_attribute=yes + fi + fi +fi +rm -f $TMPC $TMPS + +# check for .init_array/.fini_array support +cat > $TMPC << EOF +static int x = -1; +int main(void) { return x; } +int foo(void) { x = 0; } +int (*fp)(void) __attribute__((section(".init_array"))) = foo; +EOF +has_initfini_array=no +if $cc -Werror $TMPC -o $TMPE >/dev/null 2>&1; then + if $TMPE; then + has_initfini_array=yes + fi +fi +rm -f $TMPC $TMPE + +# check for compiler flag +check_cc_option() { + echo "int i;" > $TMPC + if $cc $* -c $TMPC -o $TMPO > /dev/null 2>&1; then + rm -f $TMPC $TMPO + return 0 + fi + rm -f $TMPC + return 1 +} + +# check for CFLAGS +if test -z "$CFLAGS"; then + CFLAGS="-O2 -g" + if check_cc_option -mtune=generic $CFLAGS; then + CFLAGS="$CFLAGS -mtune=generic" + fi +fi +if test "$biarch" = "yes" -a -z "$CFLAGS_32"; then + CFLAGS_32="-m32 -O2 -g" + if check_cc_option -mtune=generic $CFLAGS_32; then + CFLAGS_32="$CFLAGS_32 -mtune=generic" + fi +fi + +# check for pkg-config +pkgconfig=`which pkg-config` +if test -z "$pkgconfig"; then + echo "pkg-config not found" + exit 1 +fi + +# check for Glib 2.0 compile CFLAGS +if $pkgconfig --exists glib-2.0; then + GLIB_CFLAGS=`$pkgconfig --cflags glib-2.0` + GLIB_LDFLAGS=`$pkgconfig --libs glib-2.0` +else + echo "GLIB 2.0 environment not found" + exit 1 +fi +cat > $TMPC << EOF +#include +int main(void) { + (void) g_main_pending(); + return 0; +} +EOF +if ! $cc $CFLAGS $GLIB_CFLAGS $GLIB_LDFLAGS $TMPC -o $TMPE > /dev/null 2>&1; then + echo "GLIB 2.0 environment not usable" + rm -f $TMPC + exit 1 +fi +rm -f $TMPC $TMPE + +# check for GTK+ 2.0 compile CFLAGS +if $pkgconfig --exists gtk+-2.0; then + GTK_CFLAGS=`$pkgconfig --cflags gtk+-2.0` + GTK_LDFLAGS=`$pkgconfig --libs gtk+-2.0` +else + echo "GTK+ 2.0 environment not found" + exit 1 +fi +cat > $TMPC << EOF +#include +int main(void) { + gtk_main_quit(); + return 0; +} +EOF +if ! $cc $CFLAGS $GTK_CFLAGS $GTK_LDFLAGS $TMPC -o $TMPE > /dev/null 2>&1; then + echo "GTK+ 2.0 environment not usable" + rm -f $TMPC + exit 1 +fi +rm -f $TMPC $TMPE + +# check for X11 base dir +x_base_dirs=' +/usr +/usr/X11R6 +/usr/local/X11R6' +for dir in $x_base_dirs; do + x_include_dir="$dir/include" + if test -f $x_include_dir/X11/Intrinsic.h; then + x_lib_dir="$dir/$lib64" + if test -f $x_lib_dir/libX11.so; then + x_base_dir=$dir + break + fi + fi +done +if test -z "$x_base_dir"; then + echo "X11 environment not found" + exit 1 +fi + +# big/little endian test +cat > $TMPC << EOF +#include +int main(int argc, char ** argv){ + volatile uint32_t i=0x01234567; + return (*((uint8_t*)(&i))) == 0x67; +} +EOF + +if $cc -o $TMPE $TMPC 2>/dev/null ; then + $TMPE && bigendian="yes" +else + echo "big/little test failed" +fi + +rm -f $TMPO $TMPC $TMPE $TMPS + +# floating point endian test +cat > $TMPC << EOF +/* This will not work unless sizeof(double) == 8. */ +extern char sizeof_double_must_be_8 [sizeof(double) == 8 ? 1 : -1]; + +/* This structure must have no internal padding. */ +struct possibility { + char prefix[8]; + double candidate; + char postfix[8]; +}; + +#define C(cand) { "\nformat:", cand, ":tamrof\n" } +struct possibility table [] = +{ + C( 3.25724264705901305206e+01), /* @@IEEEFP - IEEE 754 */ + C( 3.53802595280598432000e+18), /* D__float - VAX */ + C( 5.32201830133125317057e-19), /* D.PDP-10 - PDP-10 - the dot is 0x13a */ + C( 1.77977764695171661377e+10), /* IBMHEXFP - s/390 format, ascii */ + C(-5.22995989424860458374e+10) /* IBMHEXFP - s/390 format, EBCDIC */ +}; +EOF + +if $cc -o $TMPO -c $TMPC 2>/dev/null; then + od -c $TMPO | + sed 's/^[0-7]*[ ]*/ / + s/\*/./g + s/ \\n/*/g + s/ [0-9][0-9][0-9]/./g + s/ \\[^ ]/./g' | + tr -d ' + ' | tr -s '*' ' +' | fold | sed '$a\ +' > $TMPE + + if grep 'format:.@IEEEF.:tamrof' $TMPE >/dev/null 2>&1; then + float_format='IEEE (big-endian)' + elif grep 'format:.I@@PFE.:tamrof' $TMPE >/dev/null 2>&1; then + float_format='IEEE (big-endian)' + elif grep 'format:.FEEEI@.:tamrof' $TMPE >/dev/null 2>&1; then + float_format='IEEE (little-endian)' + elif grep 'format:.EFP@@I.:tamrof' $TMPE >/dev/null 2>&1; then + float_format='IEEE (little-endian)' + elif grep 'format:.__floa.:tamrof' $TMPE >/dev/null 2>&1; then + float_format='VAX D-float' + elif grep 'format:..PDP-1.:tamrof' $TMPE >/dev/null 2>&1; then + float_format='PDP-10' + elif grep 'format:.BMHEXF.:tamrof' $TMPE >/dev/null 2>&1; then + float_format='IBM 370 hex' + else + echo "unknown floating point format" + exit 1 + fi + + fbigendian= + case $float_format in + 'IEEE (big-endian)') + if test "$bigendian" = "no"; then + fbigendian=1 + fi + ;; + 'IEEE (little-endian)') + if test "$bigendian" = "yes"; then + fbigendian=0 + fi + ;; + *) + echo "unsupported floating point format $float_format" + exit 1 + ;; + esac +else + echo "floating point endian test failed" +fi + +rm -f $TMPO $TMPC $TMPE + +# print configure help +if test x"$1" = x"-h" -o x"$1" = x"--help" ; then +cat << EOF + +Usage: configure [options] +Options: [defaults in brackets after descriptions] + +EOF +echo "Standard options:" +echo " --help print this message" +echo " --prefix=PREFIX install in PREFIX [$prefix]" +echo " --pkglibdir=ROOT install private files in ROOT [$pkglibdir]" +echo " --target-os=OS build plugin support for target OS [$target_os]" +echo " --target-cpu=CPU build plugin support for target CPU [$target_cpu]" +echo " --with-viewer build viewer [$build_viewer]" +echo "" +echo "Advanced options (experts only):" +echo " --source-path=PATH path of source code [$source_path]" +echo " --with-lib32=NAME use NAME as the 32-bit library dir name [$lib32]" +echo " --with-lib64=NAME use NAME as the 64-bit library dir name [$lib64]" +echo " --with-biarch build both 32-bit and 64-bit components at once" +echo " --with-cc=CC use C compiler CC [$cc]" +echo " --with-cxx=CXX use C++ compiler CXX [$cxx]" +echo "" +echo "NOTE: The object files are built at the place where configure is launched" +exit 1 +fi + +echo "Install prefix $prefix" +echo "nspluginwrapper root dir $pkglibdir" +echo "Bi-arch build $biarch" +echo "Build viewer $build_viewer" +echo "32-bit library dir name $lib32" +echo "64-bit library dir name $lib64" +echo "Source path $source_path" +echo "C compiler $cc" +echo "C++ compiler $cxx" +echo "host OS $host_os" +echo "host CPU $host_cpu" +echo "host big endian $bigendian" +echo "target OS $target_os" +echo "target CPU $target_cpu" + +config_mak="config-host.mak" +echo "# Automatically generated by configure - do not modify" > $config_mak + +config_h="config-host.h" +echo "/* Automatically generated by configure - do not modify */" > $config_h + +echo "CC=$cc" >> $config_mak +echo "CXX=$cxx" >> $config_mak +echo "CFLAGS=$CFLAGS" >> $config_mak +echo "GLIB_CFLAGS=$GLIB_CFLAGS" >> $config_mak +echo "GLIB_LDFLAGS=$GLIB_LDFLAGS" >> $config_mak +echo "GTK_CFLAGS=$GTK_CFLAGS" >> $config_mak +echo "GTK_LDFLAGS=$GTK_LDFLAGS" >> $config_mak +if test "$biarch" = "yes"; then +echo "LDFLAGS_32=-m32" >> $config_mak +echo "CFLAGS_32=$CFLAGS_32" >> $config_mak +else +echo 'CFLAGS_32=$(CFLAGS)' >> $config_mak +fi +if test "$host_os" = "linux"; then + echo "OS=linux" >> $config_mak + echo "#define HOST_LINUX 1" >> $config_h + echo "#define HOST_OS \"linux\"" >> $config_h +elif test "$host_os" = "freebsd"; then + echo "OS=freebsd" >> $config_mak + echo "#define HOST_FREEBSD 1" >> $config_h + echo "#define HOST_OS \"freebsd\"" >> $config_h +elif test "$host_os" = "netbsd"; then + echo "OS=netbsd" >> $config_mak + echo "#define HOST_NETBSD 1" >> $config_h + echo "#define HOST_OS \"netbsd\"" >> $config_h +else + echo "Unsupported OS" + exit 1 +fi +if test "$host_cpu" = "i386" ; then + echo "ARCH=i386" >> $config_mak + echo "#define HOST_I386 1" >> $config_h + echo "#define HOST_ARCH \"i386\"" >> $config_h +elif test "$host_cpu" = "x86_64" ; then + echo "ARCH=x86_64" >> $config_mak + echo "#define HOST_X86_64 1" >> $config_h + echo "#define HOST_ARCH \"x86_64\"" >> $config_h +elif test "$host_cpu" = "ppc" ; then + echo "ARCH=ppc" >> $config_mak + echo "#define HOST_PPC 1" >> $config_h + echo "#define HOST_ARCH \"ppc\"" >> $config_h +elif test "$host_cpu" = "ppc64" ; then + echo "ARCH=ppc64" >> $config_mak + echo "#define HOST_PPC64 1" >> $config_h + echo "#define HOST_ARCH \"ppc64\"" >> $config_h +elif test "$host_cpu" = "sparc" ; then + echo "ARCH=sparc" >> $config_mak + echo "#define HOST_SPARC 1" >> $config_h + echo "#define HOST_ARCH \"sparc\"" >> $config_h +elif test "$host_cpu" = "sparc64" ; then + echo "ARCH=sparc64" >> $config_mak + echo "#define HOST_SPARC64 1" >> $config_h + echo "#define HOST_ARCH \"sparc64\"" >> $config_h +elif test "$host_cpu" = "ia64" ; then + echo "ARCH=ia64" >> $config_mak + echo "#define HOST_IA64 1" >> $config_h + echo "#define HOST_ARCH \"ia64\"" >> $config_h +else + echo "Unsupported CPU" + exit 1 +fi +if test "$bigendian" = "yes" ; then + echo "WORDS_BIGENDIAN=yes" >> $config_mak + echo "#define WORDS_BIGENDIAN 1" >> $config_h +fi +if test -n "$fbigendian" ; then + echo "#define FLOAT_WORDS_BIGENDIAN $fbigendian" >> $config_h +fi + +echo "SRC_PATH=$source_path" >> $config_mak +echo "build_viewer=$build_viewer" >> $config_mak +echo "biarch=$biarch" >> $config_mak +echo "lib32=$lib32" >> $config_mak +echo "lib64=$lib64" >> $config_mak +echo "prefix=$prefix" >> $config_mak +echo "bindir=$prefix/bin" >> $config_mak +libdir="$prefix/$lib64" +echo "libdir=$libdir" >> $config_mak +echo "#define LIB \"$lib64\"" >> $config_h +echo "#define LIBDIR \"$libdir\"" >> $config_h +echo "x11prefix=$x_base_dir" >> $config_mak + +VERSION=`sed < $source_path/$PACKAGE.spec -n '/^\%define version[ ]*/s///p'` +RELEASE=`sed < $source_path/$PACKAGE.spec -n '/^\%define release[ ]*/s///p'` +SVNDATE=`sed < $source_path/$PACKAGE.spec -n '/^\%define svndate[ ]*/s///p'` +if test -z "$SVNDATE"; then + SVNDATE=`date '+%Y%m%d'` +fi +SNAPSHOT=0 +if echo "$RELEASE" | grep -q ^0; then + SNAPSHOT=1 +fi +echo "VERSION=$VERSION" >> $config_mak +echo "SVNDATE=$SVNDATE" >> $config_mak +echo "SNAPSHOT=$SNAPSHOT" >> $config_mak +echo "#define NPW_SNAPSHOT $SNAPSHOT" >> $config_h +if test "$SNAPSHOT" = "1"; then + echo "#define NPW_VERSION \"$VERSION-Pre ($SVNDATE)\"" >> $config_h +else + echo "#define NPW_VERSION \"$VERSION\"" >> $config_h +fi + +echo "pkglibdir=$pkglibdir" >> $config_mak +echo "#define NPW_LIBDIR \"$pkglibdir\"" >> $config_h + +if test "$has_visibility_attribute" = "yes"; then + echo "#define attribute_hidden __attribute__((visibility(\"hidden\")))" >> $config_h + echo "#define attribute_protected __attribute__((visibility(\"protected\")))" >> $config_h +else + echo "#define attribute_hidden" >> $config_h + echo "#define attribute_protected" >> $config_h +fi +if test "$has_initfini_array" = "yes"; then + echo "#define HAVE_INITFINI_ARRAY 1" >> $config_h +else + echo "#undef HAVE_INITFINI_ARRAY" >> $config_h +fi + +config_mak="config.mak" +echo "# Automatically generated by configure - do not modify" > $config_mak +echo "include config-host.mak" >> $config_mak + +config_h="config.h" +echo "/* Automatically generated by configure - do not modify */" > $config_h +echo "#include \"config-host.h\"" >> $config_h + +if test "$target_os" = "linux"; then + echo "TARGET_OS=linux" >> $config_mak + echo "#define TARGET_OS \"linux\"" >> $config_h + echo "#define TARGET_LINUX 1" >> $config_h +elif test "$target_os" = "solaris"; then + echo "TARGET_OS=solaris" >> $config_mak + echo "#define TARGET_OS \"solaris\"" >> $config_h + echo "#define TARGET_SOLARIS 1" >> $config_h +else + echo "Unsupported target OS" + exit 1 +fi + +if test "$target_cpu" = "i386" ; then + echo "TARGET_ARCH=i386" >> $config_mak + echo "#define TARGET_ARCH \"i386\"" >> $config_h + echo "#define TARGET_I386 1" >> $config_h +elif test "$target_cpu" = "ppc" ; then + echo "TARGET_ARCH=ppc" >> $config_mak + echo "#define TARGET_ARCH \"ppc\"" >> $config_h + echo "#define TARGET_PPC 1" >> $config_h +else + echo "Unsupported target CPU" + exit 1 +fi + +# build tree in object directory if source path is different from current one +if test "$source_path_used" = "yes" ; then + case $source_path in + ..*) + sp1=.. + ;; + esac + ln -sf $source_path/Makefile Makefile +fi diff --git a/lsb-build/headers/atk-1.0/atk/atk-enum-types.h b/lsb-build/headers/atk-1.0/atk/atk-enum-types.h new file mode 100644 index 0000000..73c128f --- /dev/null +++ b/lsb-build/headers/atk-1.0/atk/atk-enum-types.h @@ -0,0 +1,39 @@ +#ifndef _ATK_1_0_ATK_ATK_ENUM_TYPES_H_ +#define _ATK_1_0_ATK_ATK_ENUM_TYPES_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define ATK_TYPE_HYPERLINK_STATE_FLAGS \ + (atk_hyperlink_state_flags_get_type()) +#define ATK_TYPE_COORD_TYPE (atk_coord_type_get_type()) +#define ATK_TYPE_KEY_EVENT_TYPE (atk_key_event_type_get_type()) +#define ATK_TYPE_LAYER (atk_layer_get_type()) +#define ATK_TYPE_RELATION_TYPE (atk_relation_type_get_type()) +#define ATK_TYPE_ROLE (atk_role_get_type()) +#define ATK_TYPE_STATE_TYPE (atk_state_type_get_type()) +#define ATK_TYPE_TEXT_ATTRIBUTE (atk_text_attribute_get_type()) +#define ATK_TYPE_TEXT_BOUNDARY (atk_text_boundary_get_type()) +#define ATK_TYPE_TEXT_CLIP_TYPE (atk_text_clip_type_get_type()) + + + + extern GType atk_state_type_get_type(void); + extern GType atk_role_get_type(void); + extern GType atk_text_boundary_get_type(void); + extern GType atk_relation_type_get_type(void); + extern GType atk_layer_get_type(void); + extern GType atk_hyperlink_state_flags_get_type(void); + extern GType atk_text_clip_type_get_type(void); + extern GType atk_key_event_type_get_type(void); + extern GType atk_coord_type_get_type(void); + extern GType atk_text_attribute_get_type(void); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/atk-1.0/atk/atk.h b/lsb-build/headers/atk-1.0/atk/atk.h new file mode 100644 index 0000000..b92715f --- /dev/null +++ b/lsb-build/headers/atk-1.0/atk/atk.h @@ -0,0 +1,1366 @@ +#ifndef _ATK_1_0_ATK_ATK_H_ +#define _ATK_1_0_ATK_ATK_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define _TYPEDEF_ATK_ACTION_ +#define _TYPEDEF_ATK_COMPONENT_ +#define _TYPEDEF_ATK_DOCUMENT_ +#define _TYPEDEF_ATK_EDITABLE_TEXT_ +#define _TYPEDEF_ATK_HYPERTEXT_ +#define _TYPEDEF_ATK_IMAGE_ +#define _TYPEDEF_ATK_SELECTION_ +#define _TYPEDEF_ATK_STREAMABLE_CONTENT +#define _TYPEDEF_ATK_TABLE_ +#define _TYPEDEF_ATK_TEXT_ +#define _TYPEDEF_ATK_UTIL_ +#define _TYPEDEF_ATK_VALUE__ +#define ATK_TYPE_NO_OP_OBJECT_FACTORY \ + (atk_no_op_object_factory_get_type ()) +#define ATK_GOBJECT_ACCESSIBLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_GOBJECT_ACCESSIBLE, \ + AtkGObjectAccessibleClass)) +#define ATK_HYPERLINK_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_HYPERLINK, \ + AtkHyperlinkClass)) +#define ATK_NO_OP_OBJECT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_NO_OP_OBJECT, \ + AtkNoOpObjectClass)) +#define ATK_NO_OP_OBJECT_FACTORY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_NO_OP_OBJECT_FACTORY, \ + AtkNoOpObjectFactoryClass)) +#define ATK_OBJECT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_OBJECT, AtkObjectClass)) +#define ATK_OBJECT_FACTORY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_OBJECT_FACTORY, \ + AtkObjectFactoryClass)) +#define ATK_REGISTRY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_REGISTRY, \ + AtkRegistryClass)) +#define ATK_RELATION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_RELATION, \ + AtkRelationClass)) +#define ATK_RELATION_SET_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_RELATION_SET, \ + AtkRelationSetClass)) +#define ATK_STATE_SET_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_STATE_SET, \ + AtkStateSetClass)) +#define ATK_UTIL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_UTIL, AtkUtilClass)) +#define ATK_IS_GOBJECT_ACCESSIBLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_GOBJECT_ACCESSIBLE)) +#define ATK_IS_HYPERLINK_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_HYPERLINK)) +#define ATK_IS_NO_OP_OBJECT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_NO_OP_OBJECT)) +#define ATK_IS_NO_OP_OBJECT_FACTORY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_NO_OP_OBJECT_FACTORY)) +#define ATK_IS_OBJECT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_OBJECT)) +#define ATK_IS_OBJECT_FACTORY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_OBJECT_FACTORY)) +#define ATK_IS_REGISTRY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_REGISTRY)) +#define ATK_IS_RELATION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_RELATION)) +#define ATK_IS_RELATION_SET_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_RELATION_SET)) +#define ATK_IS_STATE_SET_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_STATE_SET)) +#define ATK_IS_UTIL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_UTIL)) +#define ATK_GOBJECT_ACCESSIBLE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_GOBJECT_ACCESSIBLE, \ + AtkGObjectAccessible)) +#define ATK_HYPERLINK(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_HYPERLINK, \ + AtkHyperlink)) +#define ATK_NO_OP_OBJECT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_NO_OP_OBJECT, \ + AtkNoOpObject)) +#define ATK_NO_OP_OBJECT_FACTORY(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_NO_OP_OBJECT_FACTORY, \ + AtkNoOpObjectFactory)) +#define ATK_OBJECT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_OBJECT, AtkObject)) +#define ATK_OBJECT_FACTORY(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_OBJECT_FACTORY, \ + AtkObjectFactory)) +#define ATK_REGISTRY(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_REGISTRY, AtkRegistry)) +#define ATK_RELATION(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_RELATION, AtkRelation)) +#define ATK_RELATION_SET(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_RELATION_SET, \ + AtkRelationSet)) +#define ATK_STATE_SET(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_STATE_SET, AtkStateSet)) +#define ATK_IS_GOBJECT_ACCESSIBLE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_GOBJECT_ACCESSIBLE)) +#define ATK_IS_HYPERLINK(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_HYPERLINK)) +#define ATK_IS_NO_OP_OBJECT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_NO_OP_OBJECT)) +#define ATK_IS_NO_OP_OBJECT_FACTORY(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_NO_OP_OBJECT_FACTORY)) +#define ATK_IS_OBJECT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_OBJECT)) +#define ATK_IS_OBJECT_FACTORY(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_OBJECT_FACTORY)) +#define ATK_IS_REGISTRY(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_REGISTRY)) +#define ATK_IS_RELATION(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_RELATION)) +#define ATK_IS_RELATION_SET(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_RELATION_SET)) +#define ATK_IS_STATE_SET(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_STATE_SET)) +#define ATK_NO_OP_OBJECT_FACTORY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ( (obj), ATK_TYPE_NO_OP_OBJECT_FACTORY, \ + AtkNoOpObjectFactoryClass)) +#define ATK_GOBJECT_ACCESSIBLE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_GOBJECT_ACCESSIBLE, \ + AtkGObjectAccessibleClass)) +#define ATK_HYPERLINK_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_HYPERLINK, \ + AtkHyperlinkClass)) +#define ATK_NO_OP_OBJECT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_NO_OP_OBJECT, \ + AtkNoOpObjectClass)) +#define ATK_OBJECT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_OBJECT, AtkObjectClass)) +#define ATK_OBJECT_FACTORY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_OBJECT_FACTORY, \ + AtkObjectFactoryClass)) +#define ATK_REGISTRY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_REGISTRY, \ + AtkRegistryClass)) +#define ATK_RELATION_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_RELATION, \ + AtkRelationClass)) +#define ATK_RELATION_SET_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_RELATION_SET, \ + AtkRelationSetClass)) +#define ATK_STATE_SET_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_STATE_SET, \ + AtkStateSetClass)) +#define ATK_UTIL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_UTIL, AtkUtilClass)) +#define ATK_ACTION_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_ACTION, \ + AtkActionIface)) +#define ATK_COMPONENT_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_COMPONENT, \ + AtkComponentIface)) +#define ATK_DOCUMENT_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_DOCUMENT, \ + AtkDocumentIface)) +#define ATK_EDITABLE_TEXT_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_EDITABLE_TEXT, \ + AtkEditableTextIface)) +#define ATK_HYPERTEXT_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_HYPERTEXT, \ + AtkHypertextIface)) +#define ATK_IMAGE_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_IMAGE, \ + AtkImageIface)) +#define ATK_IMPLEMENTOR_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_IMPLEMENTOR, \ + AtkImplementorIface)) +#define ATK_SELECTION_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_SELECTION, \ + AtkSelectionIface)) +#define ATK_STREAMABLE_CONTENT_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_STREAMABLE_CONTENT, \ + AtkStreamableContentIface)) +#define ATK_TABLE_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_TABLE, \ + AtkTableIface)) +#define ATK_TEXT_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_TEXT, AtkTextIface)) +#define ATK_VALUE_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_VALUE, \ + AtkValueIface)) +#define ATK_ACTION(obj) \ + G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_ACTION, AtkAction) +#define ATK_COMPONENT(obj) \ + G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_COMPONENT, AtkComponent) +#define ATK_DOCUMENT(obj) \ + G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_DOCUMENT, AtkDocument) +#define ATK_EDITABLE_TEXT(obj) \ + G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_EDITABLE_TEXT, \ + AtkEditableText) +#define ATK_HYPERTEXT(obj) \ + G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_HYPERTEXT, AtkHypertext) +#define ATK_IMAGE(obj) \ + G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_IMAGE, AtkImage) +#define ATK_IMPLEMENTOR(obj) \ + G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_IMPLEMENTOR, \ + AtkImplementor) +#define ATK_SELECTION(obj) \ + G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_SELECTION, AtkSelection) +#define ATK_STREAMABLE_CONTENT(obj) \ + G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_STREAMABLE_CONTENT, \ + AtkStreamableContent) +#define ATK_TABLE(obj) \ + G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_TABLE, AtkTable) +#define ATK_TEXT(obj) \ + G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_TEXT, AtkText) +#define ATK_UTIL(obj) \ + G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_UTIL, AtkUtil) +#define ATK_VALUE(obj) \ + G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_VALUE, AtkValue) +#define ATK_IS_ACTION(obj) \ + G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_ACTION) +#define ATK_IS_COMPONENT(obj) \ + G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_COMPONENT) +#define ATK_IS_DOCUMENT(obj) \ + G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_DOCUMENT) +#define ATK_IS_EDITABLE_TEXT(obj) \ + G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_EDITABLE_TEXT) +#define ATK_IS_HYPERTEXT(obj) \ + G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_HYPERTEXT) +#define ATK_IS_IMAGE(obj) \ + G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_IMAGE) +#define ATK_IS_IMPLEMENTOR(obj) \ + G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_IMPLEMENTOR) +#define ATK_IS_SELECTION(obj) \ + G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_SELECTION) +#define ATK_IS_STREAMABLE_CONTENT(obj) \ + G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_STREAMABLE_CONTENT) +#define ATK_IS_TABLE(obj) \ + G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_TABLE) +#define ATK_IS_VALUE(obj) \ + G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_VALUE) +#define ATK_TYPE_ACTION (atk_action_get_type ()) +#define ATK_TYPE_COMPONENT (atk_component_get_type ()) +#define ATK_TYPE_DOCUMENT (atk_document_get_type ()) +#define ATK_TYPE_EDITABLE_TEXT (atk_editable_text_get_type ()) +#define ATK_TYPE_GOBJECT_ACCESSIBLE (atk_gobject_accessible_get_type ()) +#define ATK_TYPE_HYPERLINK (atk_hyperlink_get_type ()) +#define ATK_TYPE_HYPERTEXT (atk_hypertext_get_type ()) +#define ATK_TYPE_IMAGE (atk_image_get_type ()) +#define ATK_TYPE_IMPLEMENTOR (atk_implementor_get_type ()) +#define ATK_TYPE_NO_OP_OBJECT (atk_no_op_object_get_type ()) +#define ATK_TYPE_OBJECT_FACTORY (atk_object_factory_get_type ()) +#define ATK_TYPE_OBJECT (atk_object_get_type ()) +#define ATK_TYPE_RECTANGLE (atk_rectangle_get_type ()) +#define ATK_TYPE_REGISTRY (atk_registry_get_type ()) +#define ATK_TYPE_RELATION (atk_relation_get_type ()) +#define ATK_TYPE_RELATION_SET (atk_relation_set_get_type ()) +#define ATK_TYPE_SELECTION (atk_selection_get_type ()) +#define ATK_TYPE_STATE_SET (atk_state_set_get_type ()) +#define ATK_TYPE_STREAMABLE_CONTENT (atk_streamable_content_get_type ()) +#define ATK_TYPE_TABLE (atk_table_get_type ()) +#define ATK_TYPE_TEXT (atk_text_get_type ()) +#define ATK_TYPE_UTIL (atk_util_get_type ()) +#define ATK_TYPE_VALUE (atk_value_get_type ()) +#define ATK_IS_TEXT(obj) G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_TEXT) +#define ATK_IS_UTIL(obj) G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_UTIL) + + + typedef struct _AtkText AtkText; + + typedef struct _AtkObject AtkObject; + + typedef enum { + ATK_ROLE_INVALID = 0, + ATK_ROLE_ACCEL_LABEL = 1, + ATK_ROLE_ALERT = 2, + ATK_ROLE_ANIMATION = 3, + ATK_ROLE_ARROW = 4, + ATK_ROLE_CALENDAR = 5, + ATK_ROLE_CANVAS = 6, + ATK_ROLE_CHECK_BOX = 7, + ATK_ROLE_CHECK_MENU_ITEM = 8, + ATK_ROLE_COLOR_CHOOSER = 9, + ATK_ROLE_COLUMN_HEADER = 10, + ATK_ROLE_COMBO_BOX = 11, + ATK_ROLE_DATE_EDITOR = 12, + ATK_ROLE_DESKTOP_ICON = 13, + ATK_ROLE_DESKTOP_FRAME = 14, + ATK_ROLE_DIAL = 15, + ATK_ROLE_DIALOG = 16, + ATK_ROLE_DIRECTORY_PANE = 17, + ATK_ROLE_DRAWING_AREA = 18, + ATK_ROLE_FILE_CHOOSER = 19, + ATK_ROLE_FILLER = 20, + ATK_ROLE_FONT_CHOOSER = 21, + ATK_ROLE_FRAME = 22, + ATK_ROLE_GLASS_PANE = 23, + ATK_ROLE_HTML_CONTAINER = 24, + ATK_ROLE_ICON = 25, + ATK_ROLE_IMAGE = 26, + ATK_ROLE_INTERNAL_FRAME = 27, + ATK_ROLE_LABEL = 28, + ATK_ROLE_LAYERED_PANE = 29, + ATK_ROLE_LIST = 30, + ATK_ROLE_LIST_ITEM = 31, + ATK_ROLE_MENU = 32, + ATK_ROLE_MENU_BAR = 33, + ATK_ROLE_MENU_ITEM = 34, + ATK_ROLE_OPTION_PANE = 35, + ATK_ROLE_PAGE_TAB = 36, + ATK_ROLE_PAGE_TAB_LIST = 37, + ATK_ROLE_PANEL = 38, + ATK_ROLE_PASSWORD_TEXT = 39, + ATK_ROLE_POPUP_MENU = 40, + ATK_ROLE_PROGRESS_BAR = 41, + ATK_ROLE_PUSH_BUTTON = 42, + ATK_ROLE_RADIO_BUTTON = 43, + ATK_ROLE_RADIO_MENU_ITEM = 44, + ATK_ROLE_ROOT_PANE = 45, + ATK_ROLE_ROW_HEADER = 46, + ATK_ROLE_SCROLL_BAR = 47, + ATK_ROLE_SCROLL_PANE = 48, + ATK_ROLE_SEPARATOR = 49, + ATK_ROLE_SLIDER = 50, + ATK_ROLE_SPLIT_PANE = 51, + ATK_ROLE_SPIN_BUTTON = 52, + ATK_ROLE_STATUSBAR = 53, + ATK_ROLE_TABLE = 54, + ATK_ROLE_TABLE_CELL = 55, + ATK_ROLE_TABLE_COLUMN_HEADER = 56, + ATK_ROLE_TABLE_ROW_HEADER = 57, + ATK_ROLE_TEAR_OFF_MENU_ITEM = 58, + ATK_ROLE_TERMINAL = 59, + ATK_ROLE_TEXT = 60, + ATK_ROLE_TOGGLE_BUTTON = 61, + ATK_ROLE_TOOL_BAR = 62, + ATK_ROLE_TOOL_TIP = 63, + ATK_ROLE_TREE = 64, + ATK_ROLE_TREE_TABLE = 65, + ATK_ROLE_UNKNOWN = 66, + ATK_ROLE_VIEWPORT = 67, + ATK_ROLE_WINDOW = 68, + ATK_ROLE_HEADER = 69, + ATK_ROLE_FOOTER = 70, + ATK_ROLE_PARAGRAPH = 71, + ATK_ROLE_RULER = 72, + ATK_ROLE_APPLICATION = 73, + ATK_ROLE_AUTOCOMPLETE = 74, + ATK_ROLE_EDITBAR = 75, + ATK_ROLE_EMBEDDED = 76, + ATK_ROLE_LAST_DEFINED = 77 + } AtkRole; + + typedef struct _AtkRelationSet AtkRelationSet; + + typedef enum { + ATK_LAYER_INVALID = 0, + ATK_LAYER_BACKGROUND = 1, + ATK_LAYER_CANVAS = 2, + ATK_LAYER_WIDGET = 3, + ATK_LAYER_MDI = 4, + ATK_LAYER_POPUP = 5, + ATK_LAYER_OVERLAY = 6, + ATK_LAYER_WINDOW = 7 + } AtkLayer; + + typedef struct _AtkPropertyValues AtkPropertyValues; + + typedef void (*AtkPropertyChangeHandler) (AtkObject *, + AtkPropertyValues *); + + typedef struct _AtkImage AtkImage; + + typedef enum { + ATK_XY_SCREEN = 0, + ATK_XY_WINDOW = 1 + } AtkCoordType; + + typedef enum { + ATK_RELATION_NULL = 0, + ATK_RELATION_CONTROLLED_BY = 1, + ATK_RELATION_CONTROLLER_FOR = 2, + ATK_RELATION_LABEL_FOR = 3, + ATK_RELATION_LABELLED_BY = 4, + ATK_RELATION_MEMBER_OF = 5, + ATK_RELATION_NODE_CHILD_OF = 6, + ATK_RELATION_FLOWS_TO = 7, + ATK_RELATION_FLOWS_FROM = 8, + ATK_RELATION_SUBWINDOW_OF = 9, + ATK_RELATION_EMBEDS = 10, + ATK_RELATION_EMBEDDED_BY = 11, + ATK_RELATION_POPUP_FOR = 12, + ATK_RELATION_PARENT_WINDOW_OF = 13, + ATK_RELATION_LAST_DEFINED = 14 + } AtkRelationType; + + typedef struct _AtkRelation AtkRelation; + + typedef struct _AtkDocument AtkDocument; + + typedef struct _AtkTable AtkTable; + + typedef struct _AtkHyperlink AtkHyperlink; + + typedef struct _AtkStateSet AtkStateSet; + + typedef struct _AtkObjectFactory AtkObjectFactory; + + typedef struct _AtkRegistry AtkRegistry; + + typedef struct _AtkEditableText AtkEditableText; + + typedef GSList AtkAttributeSet; + + typedef struct _AtkHypertext AtkHypertext; + + typedef struct _AtkSelection AtkSelection; + + typedef struct _AtkAction AtkAction; + + typedef struct _AtkComponent AtkComponent; + + typedef struct _AtkValue AtkValue; + + typedef struct _AtkStreamableContent AtkStreamableContent; + + typedef void (*AtkEventListenerInit) (void); + + typedef enum { + ATK_TEXT_ATTR_INVALID = 0, + ATK_TEXT_ATTR_LEFT_MARGIN = 1, + ATK_TEXT_ATTR_RIGHT_MARGIN = 2, + ATK_TEXT_ATTR_INDENT = 3, + ATK_TEXT_ATTR_INVISIBLE = 4, + ATK_TEXT_ATTR_EDITABLE = 5, + ATK_TEXT_ATTR_PIXELS_ABOVE_LINES = 6, + ATK_TEXT_ATTR_PIXELS_BELOW_LINES = 7, + ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP = 8, + ATK_TEXT_ATTR_BG_FULL_HEIGHT = 9, + ATK_TEXT_ATTR_RISE = 10, + ATK_TEXT_ATTR_UNDERLINE = 11, + ATK_TEXT_ATTR_STRIKETHROUGH = 12, + ATK_TEXT_ATTR_SIZE = 13, + ATK_TEXT_ATTR_SCALE = 14, + ATK_TEXT_ATTR_WEIGHT = 15, + ATK_TEXT_ATTR_LANGUAGE = 16, + ATK_TEXT_ATTR_FAMILY_NAME = 17, + ATK_TEXT_ATTR_BG_COLOR = 18, + ATK_TEXT_ATTR_FG_COLOR = 19, + ATK_TEXT_ATTR_BG_STIPPLE = 20, + ATK_TEXT_ATTR_FG_STIPPLE = 21, + ATK_TEXT_ATTR_WRAP_MODE = 22, + ATK_TEXT_ATTR_DIRECTION = 23, + ATK_TEXT_ATTR_JUSTIFICATION = 24, + ATK_TEXT_ATTR_STRETCH = 25, + ATK_TEXT_ATTR_VARIANT = 26, + ATK_TEXT_ATTR_STYLE = 27, + ATK_TEXT_ATTR_LAST_DEFINED = 28 + } AtkTextAttribute; + + typedef enum { + ATK_TEXT_BOUNDARY_CHAR = 0, + ATK_TEXT_BOUNDARY_WORD_START = 1, + ATK_TEXT_BOUNDARY_WORD_END = 2, + ATK_TEXT_BOUNDARY_SENTENCE_START = 3, + ATK_TEXT_BOUNDARY_SENTENCE_END = 4, + ATK_TEXT_BOUNDARY_LINE_START = 5, + ATK_TEXT_BOUNDARY_LINE_END = 6 + } AtkTextBoundary; + + typedef enum { + ATK_STATE_INVALID = 0, + ATK_STATE_ACTIVE = 1, + ATK_STATE_ARMED = 2, + ATK_STATE_BUSY = 3, + ATK_STATE_CHECKED = 4, + ATK_STATE_DEFUNCT = 5, + ATK_STATE_EDITABLE = 6, + ATK_STATE_ENABLED = 7, + ATK_STATE_EXPANDABLE = 8, + ATK_STATE_EXPANDED = 9, + ATK_STATE_FOCUSABLE = 10, + ATK_STATE_FOCUSED = 11, + ATK_STATE_HORIZONTAL = 12, + ATK_STATE_ICONIFIED = 13, + ATK_STATE_MODAL = 14, + ATK_STATE_MULTI_LINE = 15, + ATK_STATE_MULTISELECTABLE = 16, + ATK_STATE_OPAQUE = 17, + ATK_STATE_PRESSED = 18, + ATK_STATE_RESIZABLE = 19, + ATK_STATE_SELECTABLE = 20, + ATK_STATE_SELECTED = 21, + ATK_STATE_SENSITIVE = 22, + ATK_STATE_SHOWING = 23, + ATK_STATE_SINGLE_LINE = 24, + ATK_STATE_STALE = 25, + ATK_STATE_TRANSIENT = 26, + ATK_STATE_VERTICAL = 27, + ATK_STATE_VISIBLE = 28, + ATK_STATE_MANAGES_DESCENDANTS = 29, + ATK_STATE_INDETERMINATE = 30, + ATK_STATE_TRUNCATED = 31, + ATK_STATE_LAST_DEFINED = 32 + } AtkStateType; + + typedef struct _AtkGObjectAccessible AtkGObjectAccessible; + + typedef guint64 AtkState; + + typedef void (*AtkFocusHandler) (AtkObject *, gboolean); + + typedef struct _AtkKeyEventStruct AtkKeyEventStruct; + + typedef gint(*AtkKeySnoopFunc) (AtkKeyEventStruct *, gpointer); + + typedef struct _AtkTextRectangle AtkTextRectangle; + + typedef struct _AtkTextRange AtkTextRange; + + typedef enum { + ATK_TEXT_CLIP_NONE = 0, + ATK_TEXT_CLIP_MIN = 1, + ATK_TEXT_CLIP_MAX = 2, + ATK_TEXT_CLIP_BOTH = 3 + } AtkTextClipType; + + typedef struct _AtkImplementor AtkImplementor; + + typedef void (*AtkEventListener) (AtkObject *); + + typedef gboolean(*AtkFunction) (gpointer); + + typedef struct _AtkImplementorIface AtkImplementorIface; + + typedef struct _AtkRegistryClass AtkRegistryClass; + + typedef struct _AtkHypertextIface AtkHypertextIface; + + typedef struct _AtkStreamableContentIface AtkStreamableContentIface; + + typedef struct _AtkRectangle AtkRectangle; + + typedef struct _AtkStateSetClass AtkStateSetClass; + + typedef struct _AtkAttribute AtkAttribute; + + typedef struct _AtkObjectClass AtkObjectClass; + + typedef struct _AtkGObjectAccessibleClass AtkGObjectAccessibleClass; + + typedef struct _AtkObjectFactoryClass AtkObjectFactoryClass; + + typedef struct _AtkNoOpObjectFactoryClass AtkNoOpObjectFactoryClass; + + typedef struct _AtkActionIface AtkActionIface; + + typedef struct _AtkTableIface AtkTableIface; + + typedef struct _AtkValueIface AtkValueIface; + + typedef struct _AtkRelationClass AtkRelationClass; + + typedef struct _AtkTextIface AtkTextIface; + + typedef struct _AtkRelationSetClass AtkRelationSetClass; + + typedef struct _AtkSelectionIface AtkSelectionIface; + + typedef struct _AtkUtilClass AtkUtilClass; + + typedef struct _AtkNoOpObjectClass AtkNoOpObjectClass; + + typedef struct _AtkImageIface AtkImageIface; + + typedef struct _AtkComponentIface AtkComponentIface; + + typedef struct _AtkEditableTextIface AtkEditableTextIface; + + typedef struct _AtkDocumentIface AtkDocumentIface; + + typedef struct _AtkHyperlinkClass AtkHyperlinkClass; + + typedef enum { + ATK_KEY_EVENT_PRESS, + ATK_KEY_EVENT_RELEASE, + ATK_KEY_EVENT_LAST_DEFINED + } AtkKeyEventType; + + typedef struct _AtkUtil AtkUtil; + + typedef enum { + ATK_HYPERLINK_IS_INLINE = 1 << 0 + } AtkHyperlinkStateFlags; + + typedef struct _AtkNoOpObjectFactory AtkNoOpObjectFactory; + + typedef struct _AtkNoOpObject AtkNoOpObject; + + + + + + struct _AtkObject { + GObject parent; + gchar *description; + gchar *name; + AtkObject *accessible_parent; + AtkRole role; + AtkRelationSet *relation_set; + AtkLayer layer; + }; + + + struct _AtkRelationSet { + GObject parent; + GPtrArray *relations; + }; + + + struct _AtkPropertyValues { + const gchar *property_name; + GValue old_value; + GValue new_value; + }; + + + + + + struct _AtkRelation { + GObject parent; + GPtrArray *target; + AtkRelationType relationship; + }; + + + + + + + + + struct _AtkHyperlink { + GObject parent; + }; + + + struct _AtkStateSet { + GObject parent; + }; + + + struct _AtkObjectFactory { + GObject parent; + }; + + + struct _AtkRegistry { + GObject parent; + GHashTable *factory_type_registry; + GHashTable *factory_singleton_cache; + }; + + + + + + + + + + + + + + + + + + + + + + + + struct _AtkGObjectAccessible { + AtkObject parent; + }; + + + struct _AtkKeyEventStruct { + gint type; + guint state; + guint keyval; + gint length; + gchar *string; + guint16 keycode; + guint32 timestamp; + }; + + + struct _AtkTextRectangle { + gint x; + gint y; + gint width; + gint height; + }; + + + struct _AtkTextRange { + AtkTextRectangle bounds; + gint start_offset; + gint end_offset; + gchar *content; + }; + + + + + + struct _AtkImplementorIface { + GTypeInterface parent; + AtkObject *(*ref_accessible) (AtkImplementor *); + }; + + + struct _AtkRegistryClass { + GObjectClass parent_class; + }; + + + struct _AtkHypertextIface { + GTypeInterface parent; + AtkHyperlink *(*get_link) (AtkHypertext *, gint); + gint(*get_n_links) (AtkHypertext *); + gint(*get_link_index) (AtkHypertext *, gint); + void (*link_selected) (AtkHypertext *, gint); + AtkFunction pad1; + AtkFunction pad2; + AtkFunction pad3; + }; + + + struct _AtkStreamableContentIface { + GTypeInterface parent; + gint(*get_n_mime_types) (AtkStreamableContent *); + const gchar *(*get_mime_type) (AtkStreamableContent *, gint); + GIOChannel *(*get_stream) (AtkStreamableContent *, const gchar *); + AtkFunction pad1; + AtkFunction pad2; + AtkFunction pad3; + AtkFunction pad4; + }; + + + struct _AtkRectangle { + gint x; + gint y; + gint width; + gint height; + }; + + + struct _AtkStateSetClass { + GObjectClass parent; + }; + + + struct _AtkAttribute { + gchar *name; + gchar *value; + }; + + + struct _AtkObjectClass { + GObjectClass parent; + const gchar *(*get_name) (AtkObject *); + const gchar *(*get_description) (AtkObject *); + AtkObject *(*get_parent) (AtkObject *); + gint(*get_n_children) (AtkObject *); + AtkObject *(*ref_child) (AtkObject *, gint); + gint(*get_index_in_parent) (AtkObject *); + AtkRelationSet *(*ref_relation_set) (AtkObject *); + AtkRole(*get_role) (AtkObject *); + AtkLayer(*get_layer) (AtkObject *); + gint(*get_mdi_zorder) (AtkObject *); + AtkStateSet *(*ref_state_set) (AtkObject *); + void (*set_name) (AtkObject *, const gchar *); + void (*set_description) (AtkObject *, const gchar *); + void (*set_parent) (AtkObject *, AtkObject *); + void (*set_role) (AtkObject *, AtkRole); + guint(*connect_property_change_handler) (AtkObject *, + AtkPropertyChangeHandler + *); + void (*remove_property_change_handler) (AtkObject *, guint); + void (*initialize) (AtkObject *, gpointer); + void (*children_changed) (AtkObject *, guint, gpointer); + void (*focus_event) (AtkObject *, gboolean); + void (*property_change) (AtkObject *, AtkPropertyValues *); + void (*state_change) (AtkObject *, const gchar *, gboolean); + void (*visible_data_changed) (AtkObject *); + void (*active_descendant_changed) (AtkObject *, gpointer *); + AtkFunction pad1; + AtkFunction pad2; + AtkFunction pad3; + }; + + + struct _AtkGObjectAccessibleClass { + AtkObjectClass parent_class; + AtkFunction pad1; + AtkFunction pad2; + }; + + + struct _AtkObjectFactoryClass { + GObjectClass parent_class; + AtkObject *(*create_accessible) (GObject *); + void (*invalidate) (AtkObjectFactory *); + GType(*get_accessible_type) (void); + AtkFunction pad1; + AtkFunction pad2; + }; + + + struct _AtkNoOpObjectFactoryClass { + AtkObjectFactoryClass parent_class; + }; + + + struct _AtkActionIface { + GTypeInterface parent; + gboolean(*do_action) (AtkAction *, gint); + gint(*get_n_actions) (AtkAction *); + const gchar *(*get_description) (AtkAction *, gint); + const gchar *(*get_name) (AtkAction *, gint); + const gchar *(*get_keybinding) (AtkAction *, gint); + gboolean(*set_description) (AtkAction *, gint, const gchar *); + const gchar *(*get_localized_name) (AtkAction *, gint); + AtkFunction pad2; + }; + + + struct _AtkTableIface { + GTypeInterface parent; + AtkObject *(*ref_at) (AtkTable *, gint, gint); + gint(*get_index_at) (AtkTable *, gint, gint); + gint(*get_column_at_index) (AtkTable *, gint); + gint(*get_row_at_index) (AtkTable *, gint); + gint(*get_n_columns) (AtkTable *); + gint(*get_n_rows) (AtkTable *); + gint(*get_column_extent_at) (AtkTable *, gint, gint); + gint(*get_row_extent_at) (AtkTable *, gint, gint); + AtkObject *(*get_caption) (AtkTable *); + const gchar *(*get_column_description) (AtkTable *, gint); + AtkObject *(*get_column_header) (AtkTable *, gint); + const gchar *(*get_row_description) (AtkTable *, gint); + AtkObject *(*get_row_header) (AtkTable *, gint); + AtkObject *(*get_summary) (AtkTable *); + void (*set_caption) (AtkTable *, AtkObject *); + void (*set_column_description) (AtkTable *, gint, const gchar *); + void (*set_column_header) (AtkTable *, gint, AtkObject *); + void (*set_row_description) (AtkTable *, gint, const gchar *); + void (*set_row_header) (AtkTable *, gint, AtkObject *); + void (*set_summary) (AtkTable *, AtkObject *); + gint(*get_selected_columns) (AtkTable *, gint * *); + gint(*get_selected_rows) (AtkTable *, gint * *); + gboolean(*is_column_selected) (AtkTable *, gint); + gboolean(*is_row_selected) (AtkTable *, gint); + gboolean(*is_selected) (AtkTable *, gint, gint); + gboolean(*add_row_selection) (AtkTable *, gint); + gboolean(*remove_row_selection) (AtkTable *, gint); + gboolean(*add_column_selection) (AtkTable *, gint); + gboolean(*remove_column_selection) (AtkTable *, gint); + void (*row_inserted) (AtkTable *, gint, gint); + void (*column_inserted) (AtkTable *, gint, gint); + void (*row_deleted) (AtkTable *, gint, gint); + void (*column_deleted) (AtkTable *, gint, gint); + void (*row_reordered) (AtkTable *); + void (*column_reordered) (AtkTable *); + void (*model_changed) (AtkTable *); + AtkFunction pad1; + AtkFunction pad2; + AtkFunction pad3; + AtkFunction pad4; + }; + + + struct _AtkValueIface { + GTypeInterface parent; + void (*get_current_value) (AtkValue *, GValue *); + void (*get_maximum_value) (AtkValue *, GValue *); + void (*get_minimum_value) (AtkValue *, GValue *); + gboolean(*set_current_value) (AtkValue *, const GValue *); + AtkFunction pad1; + AtkFunction pad2; + }; + + + struct _AtkRelationClass { + GObjectClass parent; + }; + + + struct _AtkTextIface { + GTypeInterface parent; + gchar *(*get_text) (AtkText *, gint, gint); + gchar *(*get_text_after_offset) (AtkText *, gint, AtkTextBoundary, + gint *, gint *); + gchar *(*get_text_at_offset) (AtkText *, gint, AtkTextBoundary, + gint *, gint *); + gunichar(*get_character_at_offset) (AtkText *, gint); + gchar *(*get_text_before_offset) (AtkText *, gint, AtkTextBoundary, + gint *, gint *); + gint(*get_caret_offset) (AtkText *); + AtkAttributeSet *(*get_run_attributes) (AtkText *, gint, gint *, + gint *); + AtkAttributeSet *(*get_default_attributes) (AtkText *); + void (*get_character_extents) (AtkText *, gint, gint *, gint *, + gint *, gint *, AtkCoordType); + gint(*get_character_count) (AtkText *); + gint(*get_offset_at_point) (AtkText *, gint, gint, AtkCoordType); + gint(*get_n_selections) (AtkText *); + gchar *(*get_selection) (AtkText *, gint, gint *, gint *); + gboolean(*add_selection) (AtkText *, gint, gint); + gboolean(*remove_selection) (AtkText *, gint); + gboolean(*set_selection) (AtkText *, gint, gint, gint); + gboolean(*set_caret_offset) (AtkText *, gint); + void (*text_changed) (AtkText *, gint, gint); + void (*text_caret_moved) (AtkText *, gint); + void (*text_selection_changed) (AtkText *); + void (*text_attributes_changed) (AtkText *); + void (*get_range_extents) (AtkText *, gint, gint, AtkCoordType, + AtkTextRectangle *); + AtkTextRange **(*get_bounded_ranges) (AtkText *, + AtkTextRectangle *, + AtkCoordType, + AtkTextClipType, + AtkTextClipType); + AtkFunction pad4; + }; + + + struct _AtkRelationSetClass { + GObjectClass parent; + AtkFunction pad1; + AtkFunction pad2; + }; + + + struct _AtkSelectionIface { + GTypeInterface parent; + gboolean(*add_selection) (AtkSelection *, gint); + gboolean(*clear_selection) (AtkSelection *); + AtkObject *(*ref_selection) (AtkSelection *, gint); + gint(*get_selection_count) (AtkSelection *); + gboolean(*is_child_selected) (AtkSelection *, gint); + gboolean(*remove_selection) (AtkSelection *, gint); + gboolean(*select_all_selection) (AtkSelection *); + void (*selection_changed) (AtkSelection *); + AtkFunction pad1; + AtkFunction pad2; + }; + + + struct _AtkUtilClass { + GObjectClass parent; + guint(*add_global_event_listener) (GSignalEmissionHook, + const gchar *); + void (*remove_global_event_listener) (guint); + guint(*add_key_event_listener) (AtkKeySnoopFunc, gpointer); + void (*remove_key_event_listener) (guint); + AtkObject *(*get_root) (void); + const gchar *(*get_toolkit_name) (void); + const gchar *(*get_toolkit_version) (void); + }; + + + struct _AtkNoOpObjectClass { + AtkObjectClass parent_class; + }; + + + struct _AtkImageIface { + GTypeInterface parent; + void (*get_image_position) (AtkImage *, gint *, gint *, + AtkCoordType); + const gchar *(*get_image_description) (AtkImage *); + void (*get_image_size) (AtkImage *, gint *, gint *); + gboolean(*set_image_description) (AtkImage *, const gchar *); + AtkFunction pad1; + AtkFunction pad2; + }; + + + struct _AtkComponentIface { + GTypeInterface parent; + guint(*add_focus_handler) (AtkComponent *, AtkFocusHandler); + gboolean(*contains) (AtkComponent *, gint, gint, AtkCoordType); + AtkObject *(*ref_accessible_at_point) (AtkComponent *, gint, gint, + AtkCoordType); + void (*get_extents) (AtkComponent *, gint *, gint *, gint *, + gint *, AtkCoordType); + void (*get_position) (AtkComponent *, gint *, gint *, + AtkCoordType); + void (*get_size) (AtkComponent *, gint *, gint *); + gboolean(*grab_focus) (AtkComponent *); + void (*remove_focus_handler) (AtkComponent *, guint); + gboolean(*set_extents) (AtkComponent *, gint, gint, gint, gint, + AtkCoordType); + gboolean(*set_position) (AtkComponent *, gint, gint, + AtkCoordType); + gboolean(*set_size) (AtkComponent *, gint, gint); + AtkLayer(*get_layer) (AtkComponent *); + gint(*get_mdi_zorder) (AtkComponent *); + void (*bounds_changed) (AtkComponent *, AtkRectangle *); + AtkFunction pad2; + }; + + + struct _AtkEditableTextIface { + GTypeInterface parent_interface; + gboolean(*set_run_attributes) (AtkEditableText *, + AtkAttributeSet *, gint, gint); + void (*set_text_contents) (AtkEditableText *, const gchar *); + void (*insert_text) (AtkEditableText *, const gchar *, gint, + gint *); + void (*copy_text) (AtkEditableText *, gint, gint); + void (*cut_text) (AtkEditableText *, gint, gint); + void (*delete_text) (AtkEditableText *, gint, gint); + void (*paste_text) (AtkEditableText *, gint); + AtkFunction pad1; + AtkFunction pad2; + }; + + + struct _AtkDocumentIface { + GTypeInterface parent; + const gchar *(*get_document_type) (AtkDocument *); + gpointer(*get_document) (AtkDocument *); + AtkFunction pad1; + AtkFunction pad2; + AtkFunction pad3; + AtkFunction pad4; + AtkFunction pad5; + AtkFunction pad6; + AtkFunction pad7; + AtkFunction pad8; + }; + + + struct _AtkHyperlinkClass { + GObjectClass parent; + gchar *(*get_uri) (AtkHyperlink *, gint); + AtkObject *(*get_object) (AtkHyperlink *, gint); + gint(*get_end_index) (AtkHyperlink *); + gint(*get_start_index) (AtkHyperlink *); + gboolean(*is_valid) (AtkHyperlink *); + gint(*get_n_anchors) (AtkHyperlink *); + guint(*link_state) (AtkHyperlink *); + gboolean(*is_selected_link) (AtkHyperlink *); + void (*link_activated) (AtkHyperlink *); + AtkFunction pad1; + }; + + + struct _AtkUtil { + GObject parent; + }; + + + struct _AtkNoOpObjectFactory { + AtkObjectFactory parent; + }; + + + struct _AtkNoOpObject { + AtkObject parent; + }; + + + extern gchar *atk_text_get_selection(AtkText *, gint, gint *, gint *); + extern guint atk_object_connect_property_change_handler(AtkObject *, + AtkPropertyChangeHandler + *); + extern void atk_image_get_image_position(AtkImage *, gint *, gint *, + AtkCoordType); + extern AtkRelationType atk_relation_get_relation_type(AtkRelation *); + extern const gchar *atk_role_get_localized_name(AtkRole); + extern GType atk_hyperlink_get_type(void); + extern const gchar *atk_document_get_document_type(AtkDocument *); + extern AtkObject *atk_table_get_caption(AtkTable *); + extern gint atk_hyperlink_get_start_index(AtkHyperlink *); + extern gpointer atk_document_get_document(AtkDocument *); + extern AtkStateSet *atk_state_set_or_sets(AtkStateSet *, + AtkStateSet *); + extern AtkObjectFactory *atk_no_op_object_factory_new(void); + extern AtkObject *atk_table_get_column_header(AtkTable *, gint); + extern const gchar *atk_object_get_name(AtkObject *); + extern void atk_registry_set_factory_type(AtkRegistry *, GType, GType); + extern gboolean atk_editable_text_set_run_attributes(AtkEditableText *, + AtkAttributeSet *, + gint, gint); + extern GType atk_object_factory_get_type(void); + extern void atk_object_remove_property_change_handler(AtkObject *, + guint); + extern gboolean atk_image_set_image_description(AtkImage *, + const gchar *); + extern GType atk_gobject_accessible_get_type(void); + extern AtkHyperlink *atk_hypertext_get_link(AtkHypertext *, gint); + extern void atk_attribute_set_free(AtkAttributeSet *); + extern void atk_focus_tracker_notify(AtkObject *); + extern void atk_relation_set_remove(AtkRelationSet *, AtkRelation *); + extern void atk_editable_text_cut_text(AtkEditableText *, gint, gint); + extern void atk_remove_key_event_listener(guint); + extern gboolean atk_selection_add_selection(AtkSelection *, gint); + extern gint atk_action_get_n_actions(AtkAction *); + extern gboolean atk_component_set_extents(AtkComponent *, gint, gint, + gint, gint, AtkCoordType); + extern void atk_editable_text_set_text_contents(AtkEditableText *, + const gchar *); + extern AtkObject *atk_table_get_summary(AtkTable *); + extern AtkRole atk_role_register(const gchar *); + extern void atk_component_remove_focus_handler(AtkComponent *, guint); + extern gint atk_hyperlink_get_n_anchors(AtkHyperlink *); + extern gboolean atk_value_set_current_value(AtkValue *, + const GValue *); + extern gint + atk_streamable_content_get_n_mime_types(AtkStreamableContent *); + extern void atk_table_set_caption(AtkTable *, AtkObject *); + extern void atk_focus_tracker_init(AtkEventListenerInit); + extern void atk_relation_set_add(AtkRelationSet *, AtkRelation *); + extern GType atk_text_get_type(void); + extern void atk_object_initialize(AtkObject *, gpointer); + extern void atk_object_set_role(AtkObject *, AtkRole); + extern void atk_table_set_row_header(AtkTable *, gint, AtkObject *); + extern const gchar + *atk_streamable_content_get_mime_type(AtkStreamableContent *, + gint); + extern const gchar *atk_text_attribute_get_value(AtkTextAttribute, + gint); + extern gboolean atk_table_add_column_selection(AtkTable *, gint); + extern AtkLayer atk_component_get_layer(AtkComponent *); + extern AtkObject *atk_selection_ref_selection(AtkSelection *, gint); + extern gboolean atk_hyperlink_is_selected_link(AtkHyperlink *); + extern gboolean atk_relation_set_contains(AtkRelationSet *, + AtkRelationType); + extern void atk_image_get_image_size(AtkImage *, int *, int *); + extern gchar *atk_text_get_text_before_offset(AtkText *, gint, + AtkTextBoundary, gint *, + gint *); + extern GType atk_action_get_type(void); + extern void atk_text_get_character_extents(AtkText *, gint, gint *, + gint *, gint *, gint *, + AtkCoordType); + extern const gchar *atk_action_get_localized_name(AtkAction *, gint); + extern void atk_state_set_clear_states(AtkStateSet *); + extern GType atk_relation_set_get_type(void); + extern gboolean atk_state_set_contains_state(AtkStateSet *, + AtkStateType); + extern GIOChannel + *atk_streamable_content_get_stream(AtkStreamableContent *, + const gchar *); + extern AtkStateSet *atk_state_set_and_sets(AtkStateSet *, + AtkStateSet *); + extern gboolean atk_table_remove_column_selection(AtkTable *, gint); + extern GType atk_streamable_content_get_type(void); + extern void atk_object_set_name(AtkObject *, const gchar *); + extern void atk_relation_set_add_relation_by_type(AtkRelationSet *, + AtkRelationType, + AtkObject *); + extern void atk_remove_global_event_listener(guint); + extern gchar *atk_text_get_text(AtkText *, gint, gint); + extern void atk_editable_text_copy_text(AtkEditableText *, gint, gint); + extern GObject *atk_gobject_accessible_get_object(AtkGObjectAccessible + *); + extern AtkRole atk_role_for_name(const gchar *); + extern const gchar *atk_table_get_column_description(AtkTable *, gint); + extern const gchar *atk_role_get_name(AtkRole); + extern gint atk_table_get_n_rows(AtkTable *); + extern void atk_object_factory_invalidate(AtkObjectFactory *); + extern void atk_object_notify_state_change(AtkObject *, AtkState, + gboolean); + extern AtkRelation + *atk_relation_set_get_relation_by_type(AtkRelationSet *, + AtkRelationType); + extern gint atk_relation_set_get_n_relations(AtkRelationSet *); + extern gint atk_object_get_n_accessible_children(AtkObject *); + extern void atk_table_set_row_description(AtkTable *, gint, + const gchar *); + extern GType atk_state_set_get_type(void); + extern AtkRelation *atk_relation_set_get_relation(AtkRelationSet *, + gint); + extern AtkObject *atk_get_focus_object(void); + extern gunichar atk_text_get_character_at_offset(AtkText *, gint); + extern AtkRelation *atk_relation_new(AtkObject * *, gint, + AtkRelationType); + extern void atk_object_set_parent(AtkObject *, AtkObject *); + extern AtkAttributeSet *atk_text_get_run_attributes(AtkText *, gint, + gint *, gint *); + extern gboolean atk_object_remove_relationship(AtkObject *, + AtkRelationType, + AtkObject *); + extern gboolean atk_selection_remove_selection(AtkSelection *, gint); + extern guint atk_component_add_focus_handler(AtkComponent *, + AtkFocusHandler); + extern gint atk_table_get_index_at(AtkTable *, gint, gint); + extern AtkRelationSet *atk_relation_set_new(void); + extern AtkObjectFactory *atk_registry_get_factory(AtkRegistry *, + GType); + extern const gchar *atk_get_toolkit_version(void); + extern const gchar *atk_text_attribute_get_name(AtkTextAttribute); + extern GType atk_image_get_type(void); + extern AtkRelationSet *atk_object_ref_relation_set(AtkObject *); + extern AtkStateSet *atk_state_set_new(void); + extern AtkStateSet *atk_state_set_xor_sets(AtkStateSet *, + AtkStateSet *); + extern AtkObject *atk_hyperlink_get_object(AtkHyperlink *, gint); + extern gint atk_object_get_index_in_parent(AtkObject *); + extern gboolean atk_text_set_caret_offset(AtkText *, gint); + extern GType atk_registry_get_type(void); + extern AtkRelationType atk_relation_type_for_name(const gchar *); + extern const gchar *atk_get_toolkit_name(void); + extern gboolean atk_state_set_add_state(AtkStateSet *, AtkStateType); + extern AtkStateSet *atk_object_ref_state_set(AtkObject *); + extern const gchar *atk_image_get_image_description(AtkImage *); + extern gboolean atk_text_add_selection(AtkText *, gint, gint); + extern GType atk_registry_get_factory_type(AtkRegistry *, GType); + extern gboolean atk_selection_clear_selection(AtkSelection *); + extern const gchar *atk_action_get_name(AtkAction *, gint); + extern void atk_relation_add_target(AtkRelation *, AtkObject *); + extern AtkTextAttribute atk_text_attribute_register(const gchar *); + extern gboolean atk_hyperlink_is_valid(AtkHyperlink *); + extern GType atk_implementor_get_type(void); + extern gboolean atk_object_add_relationship(AtkObject *, + AtkRelationType, + AtkObject *); + extern GType atk_hypertext_get_type(void); + extern void atk_table_set_column_header(AtkTable *, gint, AtkObject *); + extern gboolean atk_table_add_row_selection(AtkTable *, gint); + extern gint atk_selection_get_selection_count(AtkSelection *); + extern guint atk_add_key_event_listener(AtkKeySnoopFunc, gpointer); + extern gboolean atk_table_is_row_selected(AtkTable *, gint); + extern GPtrArray *atk_relation_get_target(AtkRelation *); + extern AtkAttributeSet *atk_text_get_default_attributes(AtkText *); + extern void atk_editable_text_insert_text(AtkEditableText *, + const gchar *, gint, gint *); + extern gint atk_hypertext_get_link_index(AtkHypertext *, gint); + extern const gchar *atk_table_get_row_description(AtkTable *, gint); + extern GType atk_table_get_type(void); + extern const gchar *atk_state_type_get_name(AtkStateType); + extern AtkObject *atk_no_op_object_new(GObject *); + extern gint atk_table_get_column_extent_at(AtkTable *, gint, gint); + extern gint atk_hyperlink_get_end_index(AtkHyperlink *); + extern void atk_editable_text_delete_text(AtkEditableText *, gint, + gint); + extern void atk_editable_text_paste_text(AtkEditableText *, gint); + extern AtkTextRange **atk_text_get_bounded_ranges(AtkText *, + AtkTextRectangle *, + AtkCoordType, + AtkTextClipType, + AtkTextClipType); + extern void atk_component_get_position(AtkComponent *, gint *, gint *, + AtkCoordType); + extern GType atk_value_get_type(void); + extern const gchar *atk_object_get_description(AtkObject *); + extern gint atk_table_get_selected_columns(AtkTable *, gint * *); + extern gint atk_table_get_column_at_index(AtkTable *, gint); + extern void atk_value_get_maximum_value(AtkValue *, GValue *); + extern GType atk_selection_get_type(void); + extern GType atk_rectangle_get_type(void); + extern GType atk_object_factory_get_accessible_type(AtkObjectFactory + *); + extern GType atk_relation_get_type(void); + extern gboolean atk_action_do_action(AtkAction *, gint); + extern void atk_state_set_add_states(AtkStateSet *, AtkStateType *, + gint); + extern GType atk_util_get_type(void); + extern AtkObject *atk_component_ref_accessible_at_point(AtkComponent *, + gint, gint, + AtkCoordType); + extern gchar *atk_text_get_text_after_offset(AtkText *, gint, + AtkTextBoundary, gint *, + gint *); + extern gint atk_table_get_row_extent_at(AtkTable *, gint, gint); + extern guint atk_add_global_event_listener(GSignalEmissionHook, + const gchar *); + extern gboolean atk_state_set_remove_state(AtkStateSet *, + AtkStateType); + extern gboolean atk_table_remove_row_selection(AtkTable *, gint); + extern AtkObject *atk_table_ref_at(AtkTable *, gint, gint); + extern void atk_object_set_description(AtkObject *, const gchar *); + extern GType atk_no_op_object_factory_get_type(void); + extern AtkRole atk_object_get_role(AtkObject *); + extern void atk_table_set_column_description(AtkTable *, gint, + const gchar *); + extern gchar *atk_text_get_text_at_offset(AtkText *, gint, + AtkTextBoundary, gint *, + gint *); + extern AtkRelationType atk_relation_type_register(const gchar *); + extern void atk_component_get_extents(AtkComponent *, gint *, gint *, + gint *, gint *, AtkCoordType); + extern void atk_text_get_range_extents(AtkText *, gint, gint, + AtkCoordType, + AtkTextRectangle *); + extern const gchar *atk_relation_type_get_name(AtkRelationType); + extern void atk_component_get_size(AtkComponent *, gint *, gint *); + extern AtkObject *atk_object_factory_create_accessible(AtkObjectFactory + *, GObject *); + extern void atk_value_get_minimum_value(AtkValue *, GValue *); + extern GType atk_document_get_type(void); + extern AtkStateType atk_state_type_for_name(const gchar *); + extern gboolean atk_state_set_contains_states(AtkStateSet *, + AtkStateType *, gint); + extern gint atk_text_get_caret_offset(AtkText *); + extern const gchar *atk_action_get_description(AtkAction *, gint); + extern gint atk_text_get_offset_at_point(AtkText *, gint, gint, + AtkCoordType); + extern AtkObject *atk_gobject_accessible_for_object(GObject *); + extern gboolean atk_action_set_description(AtkAction *, gint, + const gchar *); + extern gboolean atk_text_set_selection(AtkText *, gint, gint, gint); + extern gint atk_table_get_selected_rows(AtkTable *, gint * *); + extern AtkObject *atk_implementor_ref_accessible(AtkImplementor *); + extern gint atk_text_get_n_selections(AtkText *); + extern gint atk_component_get_mdi_zorder(AtkComponent *); + extern gchar *atk_hyperlink_get_uri(AtkHyperlink *, gint); + extern void atk_value_get_current_value(AtkValue *, GValue *); + extern AtkRegistry *atk_get_default_registry(void); + extern gboolean atk_component_set_position(AtkComponent *, gint, gint, + AtkCoordType); + extern void atk_remove_focus_tracker(guint); + extern GType atk_no_op_object_get_type(void); + extern gboolean atk_component_grab_focus(AtkComponent *); + extern gint atk_table_get_n_columns(AtkTable *); + extern gboolean atk_hyperlink_is_inline(AtkHyperlink *); + extern gboolean atk_table_is_column_selected(AtkTable *, gint); + extern AtkObject *atk_table_get_row_header(AtkTable *, gint); + extern gboolean atk_text_remove_selection(AtkText *, gint); + extern AtkTextAttribute atk_text_attribute_for_name(const gchar *); + extern void atk_table_set_summary(AtkTable *, AtkObject *); + extern gboolean atk_selection_is_child_selected(AtkSelection *, gint); + extern gboolean atk_table_is_selected(AtkTable *, gint, gint); + extern guint atk_add_focus_tracker(AtkEventListener); + extern GType atk_component_get_type(void); + extern gboolean atk_component_contains(AtkComponent *, gint, gint, + AtkCoordType); + extern gint atk_text_get_character_count(AtkText *); + extern gint atk_table_get_row_at_index(AtkTable *, gint); + extern gboolean atk_selection_select_all_selection(AtkSelection *); + extern gint atk_hypertext_get_n_links(AtkHypertext *); + extern const gchar *atk_action_get_keybinding(AtkAction *, gint); + extern void atk_text_free_ranges(AtkTextRange * *); + extern gboolean atk_component_set_size(AtkComponent *, gint, gint); + extern AtkStateType atk_state_type_register(const gchar *); + extern AtkObject *atk_get_root(void); + extern AtkObject *atk_object_get_parent(AtkObject *); + extern GType atk_editable_text_get_type(void); + extern gboolean atk_state_set_is_empty(AtkStateSet *); + extern GType atk_object_get_type(void); + extern AtkObject *atk_object_ref_accessible_child(AtkObject *, gint); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/core_filelist b/lsb-build/headers/core_filelist new file mode 100644 index 0000000..0794eea --- /dev/null +++ b/lsb-build/headers/core_filelist @@ -0,0 +1,16 @@ +dlfcn.h +errno.h +fcntl.h +limits.h +stddef.h +stdio.h +stdlib.h +string.h +sys/resource.h +sys/select.h +sys/time.h +sys/types.h +sys/wait.h +time.h +unistd.h +wctype.h diff --git a/lsb-build/headers/desktop_filelist b/lsb-build/headers/desktop_filelist new file mode 100644 index 0000000..85795a0 --- /dev/null +++ b/lsb-build/headers/desktop_filelist @@ -0,0 +1,24 @@ +fontconfig/fontconfig.h +fontconfig/fcfreetype.h +fontconfig/fcprivate.h +glib-2.0/glib.h +glib-2.0/glib/gprintf.h +glib-2.0/glib/gstdio.h +glib-2.0/glib-object.h +glib-2.0/gobject/gvaluecollector.h +glib-2.0/gmodule.h +atk-1.0/atk/atk.h +atk-1.0/atk/atk-enum-types.h +pango-1.0/pango/pango.h +pango-1.0/pango/pango-utils.h +pango-1.0/pango/pangoxft.h +pango-1.0/pango/pangoft2.h +pango-1.0/pango/pangofc-decoder.h +pango-1.0/pango/pangofc-fontmap.h +gtk-2.0/gdk-pixbuf/gdk-pixbuf.h +gtk-2.0/gdk-pixbuf/gdk-pixdata.h +gtk-2.0/gdk-pixbuf-xlib/gdk-pixbuf-xlib.h +gtk-2.0/gdk/gdk.h +gtk-2.0/gdk/gdkkeysyms.h +gtk-2.0/gdk/gdkx.h +gtk-2.0/gtk/gtk.h diff --git a/lsb-build/headers/dlfcn.h b/lsb-build/headers/dlfcn.h new file mode 100644 index 0000000..2101ea9 --- /dev/null +++ b/lsb-build/headers/dlfcn.h @@ -0,0 +1,33 @@ +#ifndef _DLFCN_H_ +#define _DLFCN_H_ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#define RTLD_NEXT ((void *) -1l) +#define RTLD_LOCAL 0 +#define RTLD_LAZY 0x00001 +#define RTLD_NOW 0x00002 +#define RTLD_GLOBAL 0x00100 + + + typedef struct { + char *dli_fname; + void *dli_fbase; + char *dli_sname; + void *dli_saddr; + } Dl_info; + + + extern int dladdr(const void *, Dl_info *); + extern int dlclose(void *); + extern char *dlerror(void); + extern void *dlopen(const char *, int); + extern void *dlsym(void *, const char *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/errno.h b/lsb-build/headers/errno.h new file mode 100644 index 0000000..d573808 --- /dev/null +++ b/lsb-build/headers/errno.h @@ -0,0 +1,163 @@ +#ifndef _ERRNO_H_ +#define _ERRNO_H_ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#define errno (*__errno_location()) + + + +/* errno values*/ +#define EPERM 1 +#define ECHILD 10 +#define ENETDOWN 100 +#define ENETUNREACH 101 +#define ENETRESET 102 +#define ECONNABORTED 103 +#define ECONNRESET 104 +#define ENOBUFS 105 +#define EISCONN 106 +#define ENOTCONN 107 +#define ESHUTDOWN 108 +#define ETOOMANYREFS 109 +#define EAGAIN 11 +#define ETIMEDOUT 110 +#define ECONNREFUSED 111 +#define EHOSTDOWN 112 +#define EHOSTUNREACH 113 +#define EALREADY 114 +#define EINPROGRESS 115 +#define ESTALE 116 +#define EUCLEAN 117 +#define ENOTNAM 118 +#define ENAVAIL 119 +#define ENOMEM 12 +#define EISNAM 120 +#define EREMOTEIO 121 +#define EDQUOT 122 +#define ENOMEDIUM 123 +#define EMEDIUMTYPE 124 +#define ECANCELED 125 +#define EACCES 13 +#define EFAULT 14 +#define ENOTBLK 15 +#define EBUSY 16 +#define EEXIST 17 +#define EXDEV 18 +#define ENODEV 19 +#define ENOENT 2 +#define ENOTDIR 20 +#define EISDIR 21 +#define EINVAL 22 +#define ENFILE 23 +#define EMFILE 24 +#define ENOTTY 25 +#define ETXTBSY 26 +#define EFBIG 27 +#define ENOSPC 28 +#define ESPIPE 29 +#define ESRCH 3 +#define EROFS 30 +#define EMLINK 31 +#define EPIPE 32 +#define EDOM 33 +#define ERANGE 34 +#define EDEADLK 35 +#if __s390x__ +#define EDEADLOCK 35 +#endif +#define ENAMETOOLONG 36 +#define ENOLCK 37 +#define ENOSYS 38 +#define ENOTEMPTY 39 +#define EINTR 4 +#define ELOOP 40 +#define ENOMSG 42 +#define EIDRM 43 +#define ECHRNG 44 +#define EL2NSYNC 45 +#define EL3HLT 46 +#define EL3RST 47 +#define ELNRNG 48 +#define EUNATCH 49 +#define EIO 5 +#define ENOANO 55 +#define EBADRQC 56 +#define EBADSLT 57 +#if __powerpc__ && !__powerpc64__ +#define EDEADLOCK 58 +#endif +#if __powerpc64__ +#define EDEADLOCK 58 +#endif +#define EBFONT 59 +#define ENXIO 6 +#define ENOSTR 60 +#define ENODATA 61 +#define ETIME 62 +#define ENOSR 63 +#define ENONET 64 +#define ENOPKG 65 +#define EREMOTE 66 +#define ENOLINK 67 +#define EADV 68 +#define ESRMNT 69 +#define E2BIG 7 +#define ECOMM 70 +#define EPROTO 71 +#define EMULTIHOP 72 +#define EDOTDOT 73 +#define EBADMSG 74 +#define EOVERFLOW 75 +#define ENOTUNIQ 76 +#define EBADFD 77 +#define EREMCHG 78 +#define ELIBACC 79 +#define ENOEXEC 8 +#define ELIBBAD 80 +#define ELIBSCN 81 +#define ELIBMAX 82 +#define ELIBEXEC 83 +#define EILSEQ 84 +#define ERESTART 85 +#define ESTRPIPE 86 +#define EUSERS 87 +#define ENOTSOCK 88 +#define EDESTADDRREQ 89 +#define EBADF 9 +#define EMSGSIZE 90 +#define EPROTOTYPE 91 +#define ENOPROTOOPT 92 +#define EPROTONOSUPPORT 93 +#define ESOCKTNOSUPPORT 94 +#define EOPNOTSUPP 95 +#define EPFNOSUPPORT 96 +#define EAFNOSUPPORT 97 +#define EADDRINUSE 98 +#define EADDRNOTAVAIL 99 +#define EWOULDBLOCK EAGAIN +#if __i386__ +#define EDEADLOCK EDEADLK +#endif +#if __ia64__ +#define EDEADLOCK EDEADLK +#endif +#if __s390__ && !__s390x__ +#define EDEADLOCK EDEADLK +#endif +#if __x86_64__ +#define EDEADLOCK EDEADLK +#endif +#define ENOTSUP EOPNOTSUPP + + + + extern int *__errno_location(void); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/fcntl.h b/lsb-build/headers/fcntl.h new file mode 100644 index 0000000..77407bc --- /dev/null +++ b/lsb-build/headers/fcntl.h @@ -0,0 +1,138 @@ +#ifndef _FCNTL_H_ +#define _FCNTL_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define O_RDONLY 00 +#define O_ACCMODE 0003 +#define O_WRONLY 01 +#define O_CREAT 0100 +#define O_TRUNC 01000 +#define O_SYNC 010000 +#define O_RDWR 02 +#define O_EXCL 0200 +#define O_APPEND 02000 +#define O_ASYNC 020000 +#define O_NOCTTY 0400 +#define O_NDELAY 04000 +#define O_NONBLOCK 04000 +#define FD_CLOEXEC 1 + + + struct flock { + short l_type; + short l_whence; + off_t l_start; + off_t l_len; + pid_t l_pid; + }; + + struct flock64 { + short l_type; + short l_whence; + loff_t l_start; + loff_t l_len; + pid_t l_pid; + }; + + +/* flags for open(2)*/ + + + +/* flags for access(2)*/ + + + +/* Constants used for fcntl(2)*/ +#define F_DUPFD 0 +#define F_RDLCK 0 +#define F_GETFD 1 +#define F_WRLCK 1 +#if __i386__ +#define F_GETLK64 12 +#endif +#if __powerpc__ && !__powerpc64__ +#define F_GETLK64 12 +#endif +#if __powerpc64__ +#define F_GETLK64 12 +#endif +#if __s390__ && !__s390x__ +#define F_GETLK64 12 +#endif +#if __i386__ +#define F_SETLK64 13 +#endif +#if __powerpc__ && !__powerpc64__ +#define F_SETLK64 13 +#endif +#if __powerpc64__ +#define F_SETLK64 13 +#endif +#if __s390__ && !__s390x__ +#define F_SETLK64 13 +#endif +#if __i386__ +#define F_SETLKW64 14 +#endif +#if __powerpc__ && !__powerpc64__ +#define F_SETLKW64 14 +#endif +#if __powerpc64__ +#define F_SETLKW64 14 +#endif +#if __s390__ && !__s390x__ +#define F_SETLKW64 14 +#endif +#define F_SETFD 2 +#define F_UNLCK 2 +#define F_GETFL 3 +#define F_SETFL 4 +#define F_GETLK 5 +#if __ia64__ +#define F_GETLK64 5 +#endif +#if __x86_64__ +#define F_GETLK64 5 +#endif +#if __s390x__ +#define F_GETLK64 5 +#endif +#define F_SETLK 6 +#if __ia64__ +#define F_SETLK64 6 +#endif +#if __x86_64__ +#define F_SETLK64 6 +#endif +#if __s390x__ +#define F_SETLK64 6 +#endif +#define F_SETLKW 7 +#if __ia64__ +#define F_SETLKW64 7 +#endif +#if __x86_64__ +#define F_SETLKW64 7 +#endif +#if __s390x__ +#define F_SETLKW64 7 +#endif +#define F_SETOWN 8 +#define F_GETOWN 9 + + + + extern int lockf64(int, int, off64_t); + extern int fcntl(int, int, ...); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/fontconfig/fcfreetype.h b/lsb-build/headers/fontconfig/fcfreetype.h new file mode 100644 index 0000000..f7d071a --- /dev/null +++ b/lsb-build/headers/fontconfig/fcfreetype.h @@ -0,0 +1,25 @@ +#ifndef _FONTCONFIG_FCFREETYPE_H_ +#define _FONTCONFIG_FCFREETYPE_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + + + + + extern FcResult FcPatternGetFTFace(const FcPattern *, const char *, + int, FT_Face *); + extern FcBool FcPatternAddFTFace(FcPattern *, const char *, + const FT_Face); + extern FT_UInt FcFreeTypeCharIndex(FT_Face, FcChar32); + extern FcCharSet *FcFreeTypeCharSet(FT_Face, FcBlanks *); + extern FcCharSet *FcFreeTypeCharSetAndSpacing(FT_Face, FcBlanks *, + int *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/fontconfig/fcprivate.h b/lsb-build/headers/fontconfig/fcprivate.h new file mode 100644 index 0000000..5a93114 --- /dev/null +++ b/lsb-build/headers/fontconfig/fcprivate.h @@ -0,0 +1,42 @@ +#ifndef _FONTCONFIG_FCPRIVATE_H_ +#define _FONTCONFIG_FCPRIVATE_H_ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#define FcObjectSetVapBuild(__ret__,__first__,__va__) \ + { FcObjectSet *__os__; const char *__ob__; __ret__ = 0; __os__ = \ + FcObjectSetCreate (); if (!__os__) goto _FcObjectSetVapBuild_bail0; \ + __ob__ = __first__; while (__ob__) { if (!FcObjectSetAdd (__os__, \ + __ob__)) goto _FcObjectSetVapBuild_bail1; __ob__ = va_arg (__va__, \ + const char *); } __ret__ = __os__; _FcObjectSetVapBuild_bail1: if \ + (!__ret__ && __os__) FcObjectSetDestroy (__os__); \ + _FcObjectSetVapBuild_bail0: ; } +#define FcPatternVapBuild(result,orig,va) \ + { FcPattern *__p__ = (orig); const char *__o__; FcValue __v__; if \ + (!__p__) { __p__ = FcPatternCreate (); if (!__p__) goto \ + _FcPatternVapBuild_bail0; } for (;;) { __o__ = va_arg (va, const char \ + *); if (!__o__) break; __v__.type = va_arg (va, FcType); switch \ + (__v__.type) { case FcTypeVoid: goto _FcPatternVapBuild_bail1; case \ + FcTypeInteger: __v__.u.i = va_arg (va, int); break; case FcTypeDouble: \ + __v__.u.d = va_arg (va, double); break; case FcTypeString: __v__.u.s = \ + va_arg (va, FcChar8 *); break; case FcTypeBool: __v__.u.b = va_arg \ + (va, FcBool); break; case FcTypeMatrix: __v__.u.m = va_arg (va, \ + FcMatrix *); break; case FcTypeCharSet: __v__.u.c = va_arg (va, \ + FcCharSet *); break; case FcTypeFTFace: __v__.u.f = va_arg (va, \ + FT_Face); break; case FcTypeLangSet: __v__.u.l = va_arg (va, FcLangSet \ + *); break; } if (!FcPatternAdd (__p__, __o__, __v__, FcTrue)) goto \ + _FcPatternVapBuild_bail1; } result = __p__; goto \ + _FcPatternVapBuild_return; _FcPatternVapBuild_bail1: if (!orig) \ + FcPatternDestroy (__p__); _FcPatternVapBuild_bail0: result = (void*)0; \ + _FcPatternVapBuild_return: ; } + + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/fontconfig/fontconfig.h b/lsb-build/headers/fontconfig/fontconfig.h new file mode 100644 index 0000000..786a633 --- /dev/null +++ b/lsb-build/headers/fontconfig/fontconfig.h @@ -0,0 +1,463 @@ +#ifndef _FONTCONFIG_FONTCONFIG_H_ +#define _FONTCONFIG_FONTCONFIG_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define _FCFUNCPROTOBEGIN +#define _FCFUNCPROTOEND +#define FC_USER_CACHE_FILE ".fonts.cache-"FC_CACHE_VERSION +#define FC_DIR_CACHE_FILE "fonts.cache-"FC_CACHE_VERSION +#define FcIsUpper(c) ((0101 <= (c) && (c) <= 0132)) +#define FcIsLower(c) ((0141 <= (c) && (c) <= 0172)) +#define FC_CHARSET_DONE ((FcChar32) -1) +#define FC_VERSION ((FC_MAJOR * 10000) + (FC_MINOR * 100) + (FC_REVISION)) +#define FcMatrixInit(m) ((m)->xx = (m)->yy = 1, (m)->xy = (m)->yx = 0) +#define FC_CHARSET_MAP_SIZE (256/32) +#define FcToLower(c) (FcIsUpper(c) ? (c) - 0101 + 0141 : (c)) +#define FC_HINT_NONE 0 +#define FC_PROPORTIONAL 0 +#define FC_RGBA_UNKNOWN 0 +#define FC_SLANT_ROMAN 0 +#define FC_WEIGHT_THIN 0 +#define FcFalse 0 +#define FC_CACHE_VERSION "1" +#define FC_HINT_SLIGHT 1 +#define FC_RGBA_RGB 1 +#define FcTrue 1 +#define FC_MONO 100 +#define FC_SLANT_ITALIC 100 +#define FC_WEIGHT_MEDIUM 100 +#define FC_WIDTH_NORMAL 100 +#define FC_CHARCELL 110 +#define FC_SLANT_OBLIQUE 110 +#define FC_WIDTH_SEMIEXPANDED 113 +#define FC_WIDTH_EXPANDED 125 +#define FC_WIDTH_EXTRAEXPANDED 150 +#define FC_WEIGHT_DEMIBOLD 180 +#define FC_HINT_MEDIUM 2 +#define FC_MAJOR 2 +#define FC_REVISION 2 +#define FC_RGBA_BGR 2 +#define FC_WEIGHT_BOLD 200 +#define FC_WIDTH_ULTRAEXPANDED 200 +#define FC_WEIGHT_EXTRABOLD 205 +#define FC_WEIGHT_BLACK 210 +#define FC_HINT_FULL 3 +#define FC_MINOR 3 +#define FC_RGBA_VRGB 3 +#define FC_RGBA_VBGR 4 +#define FC_WEIGHT_EXTRALIGHT 40 +#define FC_RGBA_NONE 5 +#define FC_WEIGHT_LIGHT 50 +#define FC_WIDTH_ULTRACONDENSED 50 +#define FC_UTF8_MAX_LEN 6 +#define FC_WIDTH_EXTRACONDENSED 63 +#define FC_WEIGHT_BOOK 75 +#define FC_WIDTH_CONDENSED 75 +#define FC_WEIGHT_REGULAR 80 +#define FC_WIDTH_SEMICONDENSED 87 +#define FC_DUAL 90 +#define FC_ANTIALIAS "antialias" +#define FC_ASPECT "aspect" +#define FC_AUTOHINT "autohint" +#define FC_CAPABILITY "capability" +#define FC_CHAR_HEIGHT "charheight" +#define FC_CHARSET "charset" +#define FC_CHAR_WIDTH "charwidth" +#define FC_DPI "dpi" +#define FC_EMBOLDEN "embolden" +#define FC_FAMILY "family" +#define FC_FAMILYLANG "familylang" +#define FC_WEIGHT_HEAVY FC_WEIGHT_BLACK +#define FC_WEIGHT_SEMIBOLD FC_WEIGHT_DEMIBOLD +#define FC_WEIGHT_ULTRABOLD FC_WEIGHT_EXTRABOLD +#define FC_WEIGHT_ULTRALIGHT FC_WEIGHT_EXTRALIGHT +#define FC_WEIGHT_NORMAL FC_WEIGHT_REGULAR +#define FC_FILE "file" +#define FC_FONTFORMAT "fontformat" +#define FC_FONTVERSION "fontversion" +#define FC_FOUNDRY "foundry" +#define FC_FT_FACE "ftface" +#define FC_FULLNAME "fullname" +#define FC_FULLNAMELANG "fullnamelang" +#define FC_GLOBAL_ADVANCE "globaladvance" +#define FC_HINTING "hinting" +#define FC_HINT_STYLE "hintstyle" +#define FC_INDEX "index" +#define FC_LANG "lang" +#define FC_MATRIX "matrix" +#define FC_MINSPACE "minspace" +#define FC_OUTLINE "outline" +#define FC_PIXEL_SIZE "pixelsize" +#define FC_RASTERIZER "rasterizer" +#define FC_RGBA "rgba" +#define FC_SCALABLE "scalable" +#define FC_SCALE "scale" +#define FC_SIZE "size" +#define FC_SLANT "slant" +#define FC_SOURCE "source" +#define FC_SPACING "spacing" +#define FC_STYLE "style" +#define FC_STYLELANG "stylelang" +#define FC_VERTICAL_LAYOUT "verticallayout" +#define FC_WEIGHT "weight" +#define FC_WIDTH "width" + + + typedef int FcBool; + + typedef struct _FcPattern FcPattern; + + typedef enum _FcType { + FcTypeVoid = 0, + FcTypeInteger = 1, + FcTypeDouble = 2, + FcTypeString = 3, + FcTypeBool = 4, + FcTypeMatrix = 5, + FcTypeCharSet = 6, + FcTypeFTFace = 7, + FcTypeLangSet = 8 + } FcType; + + typedef unsigned char FcChar8; + + typedef struct _FcMatrix FcMatrix; + + typedef struct _FcCharSet FcCharSet; + + typedef struct _FcLangSet FcLangSet; + + typedef struct _FcValue FcValue; + + typedef struct _FcStrList FcStrList; + + typedef struct _FcConfig FcConfig; + + typedef struct _FcStrSet FcStrSet; + + typedef unsigned int FcChar32; + + typedef enum _FcMatchKind { + FcMatchPattern = 0, + FcMatchFont = 1 + } FcMatchKind; + + typedef struct _FcObjectSet FcObjectSet; + + typedef enum { + FcEndianBig = 0, + FcEndianLittle = 1 + } FcEndian; + + typedef struct _FcAtomic FcAtomic; + + typedef struct _FcConstant FcConstant; + + typedef struct _FcFontSet FcFontSet; + + typedef enum _FcSetName { + FcSetSystem = 0, + FcSetApplication = 1 + } FcSetName; + + typedef struct _FcBlanks FcBlanks; + + typedef enum _FcResult { + FcResultMatch = 0, + FcResultNoMatch = 1, + FcResultTypeMismatch = 2, + FcResultNoId = 3, + FcResultOutOfMemory = 4 + } FcResult; + + typedef struct _FcObjectType FcObjectType; + + typedef struct _FcGlobalCache FcGlobalCache; + + typedef enum _FcLangResult { + FcLangEqual = 0, + FcLangDifferentCountry = 1, + FcLangDifferentLang = 2 + } FcLangResult; + + typedef short unsigned int FcChar16; + + + + + + struct _FcMatrix { + double xx; + double xy; + double yx; + double yy; + }; + + + + + + + + + struct _FcValue { + FcType type; + union { + const FcChar8 *s; + int i; + FcBool b; + double d; + const FcMatrix *m; + const FcCharSet *c; + void *f; + const FcPattern *p; + const FcLangSet *l; + } u; + }; + + + + + + + + + + + + struct _FcObjectSet { + int nobject; + int sobject; + const char **objects; + }; + + + + + + struct _FcConstant { + const FcChar8 *name; + const char *object; + int value; + }; + + + struct _FcFontSet { + int nfont; + int sfont; + FcPattern **fonts; + }; + + + + + + struct _FcObjectType { + const char *object; + FcType type; + }; + + + + + + extern FcBool FcPatternAdd(FcPattern *, const char *, FcValue, FcBool); + extern FcStrList *FcConfigGetConfigFiles(FcConfig *); + extern FcBool FcStrSetAdd(FcStrSet *, const FcChar8 *); + extern FcBool FcCharSetIsSubset(const FcCharSet *, const FcCharSet *); + extern void FcDefaultSubstitute(FcPattern *); + extern FcChar32 FcCharSetIntersectCount(const FcCharSet *, + const FcCharSet *); + extern FcBool FcConfigUptoDate(FcConfig *); + extern void FcPatternDestroy(FcPattern *); + extern FcLangSet *FcLangSetCopy(const FcLangSet *); + extern FcBool FcPatternAddCharSet(FcPattern *, const char *, + const FcCharSet *); + extern FcBool FcPatternAddLangSet(FcPattern *, const char *, + const FcLangSet *); + extern void FcConfigAppFontClear(FcConfig *); + extern int FcConfigGetRescanInverval(FcConfig *); + extern FcBool FcConfigSubstitute(FcConfig *, FcPattern *, FcMatchKind); + extern FcObjectSet *FcObjectSetBuild(const char *, ...); + extern FcBool FcObjectSetAdd(FcObjectSet *, const char *); + extern FcChar32 FcCharSetSubtractCount(const FcCharSet *, + const FcCharSet *); + extern FcBool FcUtf16Len(const FcChar8 *, FcEndian, int, int *, int *); + extern FcBool FcConfigBuildFonts(FcConfig *); + extern FcChar8 *FcAtomicOrigFile(FcAtomic *); + extern FcBool FcNameUnregisterConstants(const FcConstant *, int); + extern FcBool FcConfigSetRescanInverval(FcConfig *, int); + extern FcBool FcAtomicLock(FcAtomic *); + extern FcPattern *FcPatternBuild(FcPattern *, ...); + extern FcFontSet *FcConfigGetFonts(FcConfig *, FcSetName); + extern void FcStrListDone(FcStrList *); + extern FcBool FcLangSetEqual(const FcLangSet *, const FcLangSet *); + extern const FcConstant *FcNameGetConstant(FcChar8 *); + extern void FcMatrixShear(FcMatrix *, double, double); + extern FcMatrix *FcMatrixCopy(const FcMatrix *); + extern FcStrList *FcConfigGetConfigDirs(FcConfig *); + extern FcBool FcStrSetDel(FcStrSet *, const FcChar8 *); + extern FcBool FcConfigEnableHome(FcBool); + extern FcStrSet *FcStrSetCreate(void); + extern int FcStrCmpIgnoreCase(const FcChar8 *, const FcChar8 *); + extern FcCharSet *FcCharSetUnion(const FcCharSet *, const FcCharSet *); + extern FcObjectSet *FcObjectSetCreate(void); + extern FcBlanks *FcBlanksCreate(void); + extern void FcBlanksDestroy(FcBlanks *); + extern FcBool FcNameConstant(FcChar8 *, int *); + extern void FcMatrixRotate(FcMatrix *, double, double); + extern FcPattern *FcNameParse(const FcChar8 *); + extern void FcMatrixMultiply(FcMatrix *, const FcMatrix *, + const FcMatrix *); + extern FcResult FcPatternGetLangSet(const FcPattern *, const char *, + int, FcLangSet * *); + extern FcValue FcValueSave(FcValue); + extern void FcAtomicDestroy(FcAtomic *); + extern FcBool FcPatternEqual(const FcPattern *, const FcPattern *); + extern FcBool FcNameRegisterObjectTypes(const FcObjectType *, int); + extern FcChar32 FcCharSetNextPage(const FcCharSet *, FcChar32 *, + FcChar32 *); + extern FcBool FcConfigSetCurrent(FcConfig *); + extern FcPattern *FcFreeTypeQuery(const FcChar8 *, int, FcBlanks *, + int *); + extern FcChar8 *FcStrListNext(FcStrList *); + extern FcBool FcNameRegisterConstants(const FcConstant *, int); + extern void FcValueDestroy(FcValue); + extern FcBool FcFileScan(FcFontSet *, FcStrSet *, FcGlobalCache *, + FcBlanks *, const FcChar8 *, FcBool); + extern FcFontSet *FcFontSetSort(FcConfig *, FcFontSet * *, int, + FcPattern *, FcBool, FcCharSet * *, + FcResult *); + extern FcResult FcPatternGetString(const FcPattern *, const char *, + int, FcChar8 * *); + extern FcChar8 *FcStrCopy(const FcChar8 *); + extern FcBool FcPatternEqualSubset(const FcPattern *, + const FcPattern *, + const FcObjectSet *); + extern FcConfig *FcInitLoadConfig(void); + extern FcStrList *FcStrListCreate(FcStrSet *); + extern FcResult FcPatternGetCharSet(const FcPattern *, const char *, + int, FcCharSet * *); + extern FcPattern *FcPatternCreate(void); + extern FcChar32 FcPatternHash(const FcPattern *); + extern FcChar8 *FcConfigFilename(const FcChar8 *); + extern FcBool FcPatternDel(FcPattern *, const char *); + extern FcCharSet *FcCharSetCopy(FcCharSet *); + extern FcBool FcInitReinitialize(void); + extern FcFontSet *FcFontList(FcConfig *, FcPattern *, FcObjectSet *); + extern int FcUcs4ToUtf8(FcChar32, FcChar8 *); + extern FcBool FcAtomicReplaceOrig(FcAtomic *); + extern FcObjectSet *FcObjectSetVaBuild(const char *, va_list); + extern FcBool FcInitBringUptoDate(void); + extern FcResult FcPatternGetDouble(const FcPattern *, const char *, + int, double *); + extern int FcStrCmp(const FcChar8 *, const FcChar8 *); + extern FcChar8 *FcConfigGetCache(FcConfig *); + extern FcAtomic *FcAtomicCreate(const FcChar8 *); + extern FcPattern *FcPatternDuplicate(const FcPattern *); + extern FcChar8 *FcStrDirname(const FcChar8 *); + extern FcBool FcConfigSubstituteWithPat(FcConfig *, FcPattern *, + FcPattern *, FcMatchKind); + extern FcBool FcDirScan(FcFontSet *, FcStrSet *, FcGlobalCache *, + FcBlanks *, const FcChar8 *, FcBool); + extern FcChar8 *FcStrCopyFilename(const FcChar8 *); + extern FcBool FcLangSetAdd(FcLangSet *, const FcChar8 *); + extern FcResult FcPatternGetInteger(const FcPattern *, const char *, + int, int *); + extern FcBool FcConfigParseAndLoad(FcConfig *, const FcChar8 *, + FcBool); + extern FcBool FcStrSetEqual(FcStrSet *, FcStrSet *); + extern FcBool FcConfigAppFontAddFile(FcConfig *, const FcChar8 *); + extern FcPattern *FcFontSetMatch(FcConfig *, FcFontSet * *, int, + FcPattern *, FcResult *); + extern FcBool FcStrSetAddFilename(FcStrSet *, const FcChar8 *); + extern FcChar8 *FcNameUnparse(FcPattern *); + extern FcChar32 FcCharSetFirstPage(const FcCharSet *, FcChar32 *, + FcChar32 *); + extern void FcFontSetPrint(const FcFontSet *); + extern FcPattern *FcPatternVaBuild(FcPattern *, va_list); + extern FcChar8 *FcConfigHome(void); + extern FcBool FcBlanksAdd(FcBlanks *, FcChar32); + extern FcBool FcBlanksIsMember(FcBlanks *, FcChar32); + extern FcBool FcNameUnregisterObjectTypes(const FcObjectType *, int); + extern FcLangResult FcLangSetHasLang(const FcLangSet *, + const FcChar8 *); + extern FcChar8 *FcStrBasename(const FcChar8 *); + extern FcPattern *FcFontMatch(FcConfig *, FcPattern *, FcResult *); + extern void FcValuePrint(const FcValue); + extern FcLangSet *FcLangSetCreate(void); + extern FcStrList *FcConfigGetFontDirs(FcConfig *); + extern FcBool FcCharSetAddChar(FcCharSet *, FcChar32); + extern FcCharSet *FcCharSetIntersect(const FcCharSet *, + const FcCharSet *); + extern void FcMatrixScale(FcMatrix *, double, double); + extern void FcPatternReference(FcPattern *); + extern FcBool FcCharSetEqual(const FcCharSet *, const FcCharSet *); + extern FcBool FcFontSetAdd(FcFontSet *, FcPattern *); + extern FcChar8 *FcAtomicNewFile(FcAtomic *); + extern FcFontSet *FcFontSetList(FcConfig *, FcFontSet * *, int, + FcPattern *, FcObjectSet *); + extern void FcFontSetSortDestroy(FcFontSet *); + extern FcBool FcPatternAddMatrix(FcPattern *, const char *, + const FcMatrix *); + extern FcChar32 FcCharSetCount(const FcCharSet *); + extern FcBool FcPatternAddString(FcPattern *, const char *, + const FcChar8 *); + extern void FcStrSetDestroy(FcStrSet *); + extern FcConfig *FcConfigGetCurrent(void); + extern FcBool FcPatternAddInteger(FcPattern *, const char *, int); + extern FcResult FcPatternGetMatrix(const FcPattern *, const char *, + int, FcMatrix * *); + extern int FcGetVersion(void); + extern FcBool FcCharSetHasChar(const FcCharSet *, FcChar32); + extern FcBool FcPatternAddBool(FcPattern *, const char *, FcBool); + extern const FcObjectType *FcNameGetObjectType(const char *); + extern FcBool FcDirCacheValid(const FcChar8 *); + extern FcBool FcUtf8Len(const FcChar8 *, int, int *, int *); + extern FcConfig *FcInitLoadConfigAndFonts(void); + extern FcResult FcPatternGetBool(const FcPattern *, const char *, int, + FcBool *); + extern void FcFontSetDestroy(FcFontSet *); + extern FcBool FcConfigAppFontAddDir(FcConfig *, const FcChar8 *); + extern int FcUtf16ToUcs4(const FcChar8 *, FcEndian, FcChar32 *, int); + extern int FcUtf8ToUcs4(const FcChar8 *, FcChar32 *, int); + extern FcFontSet *FcFontSetCreate(void); + extern FcBool FcDirSave(FcFontSet *, FcStrSet *, const FcChar8 *); + extern void FcConfigDestroy(FcConfig *); + extern FcBool FcPatternAddDouble(FcPattern *, const char *, double); + extern FcFontSet *FcFontSort(FcConfig *, FcPattern *, FcBool, + FcCharSet * *, FcResult *); + extern FcPattern *FcFontRenderPrepare(FcConfig *, FcPattern *, + FcPattern *); + extern void FcLangSetDestroy(FcLangSet *); + extern void FcCharSetDestroy(FcCharSet *); + extern FcBool FcValueEqual(FcValue, FcValue); + extern FcBool FcPatternAddWeak(FcPattern *, const char *, FcValue, + FcBool); + extern FcBool FcLangSetContains(const FcLangSet *, const FcLangSet *); + extern void FcObjectSetDestroy(FcObjectSet *); + extern FcCharSet *FcCharSetCreate(void); + extern FcLangResult FcLangSetCompare(const FcLangSet *, + const FcLangSet *); + extern FcBool FcMatrixEqual(const FcMatrix *, const FcMatrix *); + extern void FcAtomicUnlock(FcAtomic *); + extern FcBool FcStrSetMember(FcStrSet *, const FcChar8 *); + extern FcChar32 FcLangSetHash(const FcLangSet *); + extern void FcAtomicDeleteNew(FcAtomic *); + extern FcCharSet *FcCharSetSubtract(const FcCharSet *, + const FcCharSet *); + extern FcBool FcInit(void); + extern FcResult FcPatternGet(const FcPattern *, const char *, int, + FcValue *); + extern void FcPatternPrint(const FcPattern *); + extern FcBlanks *FcConfigGetBlanks(FcConfig *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/glib-2.0/glib-object.h b/lsb-build/headers/glib-2.0/glib-object.h new file mode 100644 index 0000000..67b0929 --- /dev/null +++ b/lsb-build/headers/glib-2.0/glib-object.h @@ -0,0 +1,1592 @@ +#ifndef _GLIB_2_0_GLIB_OBJECT_H_ +#define _GLIB_2_0_GLIB_OBJECT_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define G_CCLOSURE_SWAP_DATA(cclosure) \ + (((GClosure*) (closure))->derivative_flag) +#define G_CLOSURE_NEEDS_MARSHAL(closure) \ + (((GClosure*) (closure))->marshal == NULL) +#define G_TYPE_FROM_INTERFACE(g_iface) \ + (((GTypeInterface*) (g_iface))->g_type) +#define G_CLOSURE_N_NOTIFIERS(cl) \ + ((cl)->meta_marshal + ((cl)->n_guards << 1L) + (cl)->n_fnotifiers + \ + (cl)->n_inotifiers) +#define _G_TYPE_CCC(cp,gt,ct) \ + ((ct*) g_type_check_class_cast ((GTypeClass*) cp, gt)) +#define _G_TYPE_CIC(ip,gt,ct) \ + ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) +#define _G_TYPE_IGI(ip,gt,ct) \ + ((ct*) g_type_interface_peek (((GTypeInstance*) ip)->g_class, gt)) +#define G_TYPE_INSTANCE_GET_PRIVATE(instance,g_type,c_type) \ + ((c_type*) g_type_instance_get_private ((GTypeInstance*) (instance), \ + (g_type))) +#define G_TYPE_MAKE_FUNDAMENTAL(x) \ + ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) +#define _G_TYPE_CCT(cp,gt) \ + (G_GNUC_EXTENSION ({ GTypeClass *__class = (GTypeClass*) cp; GType \ + __t = gt; gboolean __r; if (__class && __class->g_type == __t) __r = \ + TRUE; else __r = g_type_check_class_is_a (__class, __t); __r; })) +#define _G_TYPE_CIT(ip,gt) \ + (G_GNUC_EXTENSION ({ GTypeInstance *__inst = (GTypeInstance*) ip; \ + GType __t = gt; gboolean __r; if (__inst && __inst->g_class && \ + __inst->g_class->g_type == __t) __r = TRUE; else __r = \ + g_type_check_instance_is_a (__inst, __t); __r; })) +#define _G_TYPE_CVH(vl,gt) \ + (G_GNUC_EXTENSION ({ GValue *__val = (GValue*) vl; GType __t = gt; \ + gboolean __r; if (__val && __val->g_type == __t) __r = TRUE; else __r \ + = g_type_check_value_holds (__val, __t); __r; })) +#define G_ENUM_CLASS(class) \ + (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_ENUM, GEnumClass)) +#define G_FLAGS_CLASS(class) \ + (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_FLAGS, GFlagsClass)) +#define G_OBJECT_CLASS(class) \ + (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass)) +#define G_TYPE_MODULE_CLASS(class) \ + (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_TYPE_MODULE, \ + GTypeModuleClass)) +#define G_PARAM_SPEC_CLASS(pclass) \ + (G_TYPE_CHECK_CLASS_CAST ((pclass), G_TYPE_PARAM, GParamSpecClass)) +#define G_TYPE_PLUGIN_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_CAST ((vtable), G_TYPE_TYPE_PLUGIN, \ + GTypePluginClass)) +#define G_IS_ENUM_CLASS(class) \ + (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_ENUM)) +#define G_IS_FLAGS_CLASS(class) \ + (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_FLAGS)) +#define G_IS_OBJECT_CLASS(class) \ + (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_OBJECT)) +#define G_IS_TYPE_MODULE_CLASS(class) \ + (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_TYPE_MODULE)) +#define G_IS_PARAM_SPEC_CLASS(pclass) \ + (G_TYPE_CHECK_CLASS_TYPE ((pclass), G_TYPE_PARAM)) +#define G_IS_TYPE_PLUGIN_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_TYPE ((vtable), G_TYPE_TYPE_PLUGIN)) +#define G_TYPE_PLUGIN(inst) \ + (G_TYPE_CHECK_INSTANCE_CAST ((inst), G_TYPE_TYPE_PLUGIN, \ + GTypePlugin)) +#define G_TYPE_MODULE(module) \ + (G_TYPE_CHECK_INSTANCE_CAST ((module), G_TYPE_TYPE_MODULE, \ + GTypeModule)) +#define G_OBJECT(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), G_TYPE_OBJECT, GObject)) +#define G_PARAM_SPEC(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM, GParamSpec)) +#define G_PARAM_SPEC_BOOLEAN(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_BOOLEAN, \ + GParamSpecBoolean)) +#define G_PARAM_SPEC_BOXED(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_BOXED, \ + GParamSpecBoxed)) +#define G_PARAM_SPEC_CHAR(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_CHAR, \ + GParamSpecChar)) +#define G_PARAM_SPEC_DOUBLE(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_DOUBLE, \ + GParamSpecDouble)) +#define G_PARAM_SPEC_ENUM(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_ENUM, \ + GParamSpecEnum)) +#define G_PARAM_SPEC_FLAGS(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_FLAGS, \ + GParamSpecFlags)) +#define G_PARAM_SPEC_FLOAT(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_FLOAT, \ + GParamSpecFloat)) +#define G_PARAM_SPEC_INT(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_INT, \ + GParamSpecInt)) +#define G_PARAM_SPEC_INT64(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_INT64, \ + GParamSpecInt64)) +#define G_PARAM_SPEC_LONG(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_LONG, \ + GParamSpecLong)) +#define G_PARAM_SPEC_OBJECT(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_OBJECT, \ + GParamSpecObject)) +#define G_PARAM_SPEC_OVERRIDE(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_OVERRIDE, \ + GParamSpecOverride)) +#define G_PARAM_SPEC_PARAM(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_PARAM, \ + GParamSpecParam)) +#define G_PARAM_SPEC_POINTER(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_POINTER, \ + GParamSpecPointer)) +#define G_PARAM_SPEC_STRING(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_STRING, \ + GParamSpecString)) +#define G_PARAM_SPEC_UCHAR(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UCHAR, \ + GParamSpecUChar)) +#define G_PARAM_SPEC_UINT(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UINT, \ + GParamSpecUInt)) +#define G_PARAM_SPEC_UINT64(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UINT64, \ + GParamSpecUInt64)) +#define G_PARAM_SPEC_ULONG(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_ULONG, \ + GParamSpecULong)) +#define G_PARAM_SPEC_UNICHAR(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UNICHAR, \ + GParamSpecUnichar)) +#define G_PARAM_SPEC_VALUE_ARRAY(pspec) \ + (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_VALUE_ARRAY, \ + GParamSpecValueArray)) +#define G_IS_TYPE_PLUGIN(inst) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((inst), G_TYPE_TYPE_PLUGIN)) +#define G_IS_TYPE_MODULE(module) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((module), G_TYPE_TYPE_MODULE)) +#define G_IS_OBJECT(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), G_TYPE_OBJECT)) +#define G_IS_PARAM_SPEC(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM)) +#define G_IS_PARAM_SPEC_BOOLEAN(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_BOOLEAN)) +#define G_IS_PARAM_SPEC_BOXED(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_BOXED)) +#define G_IS_PARAM_SPEC_CHAR(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_CHAR)) +#define G_IS_PARAM_SPEC_DOUBLE(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_DOUBLE)) +#define G_IS_PARAM_SPEC_ENUM(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_ENUM)) +#define G_IS_PARAM_SPEC_FLAGS(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_FLAGS)) +#define G_IS_PARAM_SPEC_FLOAT(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_FLOAT)) +#define G_IS_PARAM_SPEC_INT(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_INT)) +#define G_IS_PARAM_SPEC_INT64(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_INT64)) +#define G_IS_PARAM_SPEC_LONG(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_LONG)) +#define G_IS_PARAM_SPEC_OBJECT(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_OBJECT)) +#define G_IS_PARAM_SPEC_OVERRIDE(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_OVERRIDE)) +#define G_IS_PARAM_SPEC_PARAM(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_PARAM)) +#define G_IS_PARAM_SPEC_POINTER(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_POINTER)) +#define G_IS_PARAM_SPEC_STRING(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_STRING)) +#define G_IS_PARAM_SPEC_UCHAR(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UCHAR)) +#define G_IS_PARAM_SPEC_UINT(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UINT)) +#define G_IS_PARAM_SPEC_UINT64(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UINT64)) +#define G_IS_PARAM_SPEC_ULONG(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_ULONG)) +#define G_IS_PARAM_SPEC_UNICHAR(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UNICHAR)) +#define G_IS_PARAM_SPEC_VALUE_ARRAY(pspec) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_VALUE_ARRAY)) +#define G_VALUE_HOLDS(value,type) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), (type))) +#define G_VALUE_HOLDS_BOOLEAN(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_BOOLEAN)) +#define G_VALUE_HOLDS_BOXED(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_BOXED)) +#define G_VALUE_HOLDS_CHAR(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_CHAR)) +#define G_VALUE_HOLDS_DOUBLE(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_DOUBLE)) +#define G_VALUE_HOLDS_ENUM(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_ENUM)) +#define G_VALUE_HOLDS_FLAGS(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_FLAGS)) +#define G_VALUE_HOLDS_FLOAT(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_FLOAT)) +#define G_VALUE_HOLDS_INT(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_INT)) +#define G_VALUE_HOLDS_INT64(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_INT64)) +#define G_VALUE_HOLDS_LONG(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_LONG)) +#define G_VALUE_HOLDS_OBJECT(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_OBJECT)) +#define G_VALUE_HOLDS_PARAM(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_PARAM)) +#define G_VALUE_HOLDS_POINTER(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_POINTER)) +#define G_VALUE_HOLDS_STRING(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_STRING)) +#define G_VALUE_HOLDS_UCHAR(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UCHAR)) +#define G_VALUE_HOLDS_UINT(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UINT)) +#define G_VALUE_HOLDS_UINT64(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UINT64)) +#define G_VALUE_HOLDS_ULONG(value) \ + (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_ULONG)) +#define G_TYPE_FROM_INSTANCE(instance) \ + (G_TYPE_FROM_CLASS (((GTypeInstance*) (instance))->g_class)) +#define G_TYPE_IS_INTERFACE(type) \ + (G_TYPE_FUNDAMENTAL (type) == G_TYPE_INTERFACE) +#define G_TYPE_IS_OBJECT(type) \ + (G_TYPE_FUNDAMENTAL (type) == G_TYPE_OBJECT) +#define G_TYPE_MODULE_GET_CLASS(module) \ + (G_TYPE_INSTANCE_GET_CLASS ((module), G_TYPE_TYPE_MODULE, \ + GTypeModuleClass)) +#define G_OBJECT_GET_CLASS(object) \ + (G_TYPE_INSTANCE_GET_CLASS ((object), G_TYPE_OBJECT, GObjectClass)) +#define G_PARAM_SPEC_GET_CLASS(pspec) \ + (G_TYPE_INSTANCE_GET_CLASS ((pspec), G_TYPE_PARAM, GParamSpecClass)) +#define G_TYPE_PLUGIN_GET_CLASS(inst) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((inst), G_TYPE_TYPE_PLUGIN, \ + GTypePluginClass)) +#define G_ENUM_CLASS_TYPE_NAME(class) \ + (g_type_name (G_ENUM_CLASS_TYPE (class))) +#define G_FLAGS_CLASS_TYPE_NAME(class) \ + (g_type_name (G_FLAGS_TYPE (class))) +#define G_OBJECT_CLASS_NAME(class) \ + (g_type_name (G_OBJECT_CLASS_TYPE (class))) +#define G_PARAM_SPEC_TYPE_NAME(pspec) \ + (g_type_name (G_PARAM_SPEC_TYPE (pspec))) +#define G_TYPE_IS_ABSTRACT(type) \ + (g_type_test_flags ((type), G_TYPE_FLAG_ABSTRACT)) +#define G_TYPE_IS_CLASSED(type) \ + (g_type_test_flags ((type), G_TYPE_FLAG_CLASSED)) +#define G_TYPE_IS_DEEP_DERIVABLE(type) \ + (g_type_test_flags ((type), G_TYPE_FLAG_DEEP_DERIVABLE)) +#define G_TYPE_IS_DERIVABLE(type) \ + (g_type_test_flags ((type), G_TYPE_FLAG_DERIVABLE)) +#define G_TYPE_IS_INSTANTIATABLE(type) \ + (g_type_test_flags ((type), G_TYPE_FLAG_INSTANTIATABLE)) +#define G_TYPE_IS_VALUE_ABSTRACT(type) \ + (g_type_test_flags ((type), G_TYPE_FLAG_VALUE_ABSTRACT)) +#define G_TYPE_HAS_VALUE_TABLE(type) \ + (g_type_value_table_peek (type) != NULL) +#define G_TYPE_CHECK_CLASS_CAST(g_class,g_type,c_type) \ + (_G_TYPE_CCC ((g_class), (g_type), c_type)) +#define G_TYPE_CHECK_CLASS_TYPE(g_class,g_type) \ + (_G_TYPE_CCT ((g_class), (g_type))) +#define G_TYPE_CHECK_INSTANCE(instance) \ + (_G_TYPE_CHI ((GTypeInstance*) (instance))) +#define G_TYPE_CHECK_INSTANCE_CAST(instance,g_type,c_type) \ + (_G_TYPE_CIC ((instance), (g_type), c_type)) +#define G_TYPE_CHECK_INSTANCE_TYPE(instance,g_type) \ + (_G_TYPE_CIT ((instance), (g_type))) +#define G_TYPE_CHECK_VALUE_TYPE(value,g_type) \ + (_G_TYPE_CVH ((value), (g_type))) +#define G_TYPE_INSTANCE_GET_CLASS(instance,g_type,c_type) \ + (_G_TYPE_IGC ((instance), (g_type), c_type)) +#define G_TYPE_INSTANCE_GET_INTERFACE(instance,g_type,c_type) \ + (_G_TYPE_IGI ((instance), (g_type), c_type)) +#define G_DEFINE_TYPE_WITH_CODE(TN,t_n,T_P,_C_) \ + G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, 0, _C_) +#define G_DEFINE_TYPE(TN,t_n,T_P) \ + G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, 0, {}) +#define G_DEFINE_ABSTRACT_TYPE_WITH_CODE(TN,t_n,T_P,_C_) \ + G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, G_TYPE_FLAG_ABSTRACT, _C_) +#define G_DEFINE_ABSTRACT_TYPE(TN,t_n,T_P) \ + G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, G_TYPE_FLAG_ABSTRACT, {}) +#define G_OBJECT_WARN_INVALID_PROPERTY_ID(object,property_id,pspec) \ + G_OBJECT_WARN_INVALID_PSPEC ((object), "property", (property_id), \ + (pspec)) +#define g_signal_connect(instance,detailed_signal,c_handler,data) \ + g_signal_connect_data ((instance), (detailed_signal), (c_handler), \ + (data), NULL, (GConnectFlags) 0) +#define g_signal_connect_after(instance,detailed_signal,c_handler,data) \ + g_signal_connect_data ((instance), (detailed_signal), (c_handler), \ + (data), NULL, G_CONNECT_AFTER) +#define g_signal_connect_swapped(instance,detailed_signal,c_handler,data) \ + g_signal_connect_data ((instance), (detailed_signal), (c_handler), \ + (data), NULL, G_CONNECT_SWAPPED) +#define g_signal_handlers_block_by_func(instance,func,data) \ + g_signal_handlers_block_matched ((instance), (GSignalMatchType) \ + (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, NULL, (func), \ + (data)) +#define g_signal_handlers_disconnect_by_func(instance,func,data) \ + g_signal_handlers_disconnect_matched ((instance), (GSignalMatchType) \ + (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, NULL, (func), \ + (data)) +#define g_signal_handlers_unblock_by_func(instance,func,data) \ + g_signal_handlers_unblock_matched ((instance), (GSignalMatchType) \ + (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, NULL, (func), \ + (data)) +#define G_OBJECT_WARN_INVALID_PSPEC(object,pname,property_id,pspec) \ + G_STMT_START { GObject *_object = (GObject*) (object); GParamSpec \ + *_pspec = (GParamSpec*) (pspec); guint _property_id = (property_id); \ + g_warning ("%s: invalid %s id %u for \"%s\" of type `%s' in `%s'", \ + G_STRLOC, (pname), _property_id, _pspec->name, g_type_name \ + (G_PARAM_SPEC_TYPE (_pspec)), G_OBJECT_TYPE_NAME (_object)); } \ + G_STMT_END +#define G_DEFINE_TYPE_EXTENDED(TypeName,type_name,TYPE_PARENT,flags,CODE) \ + static void type_name ##_init (TypeName *self); static void type_name \ + ##_class_init (TypeName ##Class *klass); static gpointer type_name \ + ##_parent_class = NULL; static void type_name ##_class_intern_init \ + (gpointer klass) { type_name ##_parent_class = \ + g_type_class_peek_parent (klass); type_name ##_class_init ((TypeName \ + ##Class*) klass); } GType type_name ##_get_type (void) { static GType \ + g_define_type_id = 0; if (G_UNLIKELY (g_define_type_id == 0)) { static \ + const GTypeInfo g_define_type_info = { sizeof (TypeName ##Class), \ + (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) \ + type_name ##_class_intern_init, (GClassFinalizeFunc) NULL, NULL, \ + sizeof (TypeName), 0, (GInstanceInitFunc) type_name ##_init, NULL }; \ + g_define_type_id = g_type_register_static (TYPE_PARENT, #TypeName, \ + &g_define_type_info, (GTypeFlags) flags); { CODE ; } } return \ + g_define_type_id; } +#define G_IMPLEMENT_INTERFACE(TYPE_IFACE,iface_init) \ + { static const GInterfaceInfo g_implement_interface_info = { \ + (GInterfaceInitFunc) iface_init }; g_type_add_interface_static \ + (g_define_type_id, TYPE_IFACE, &g_implement_interface_info); } +#define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type) +#define G_VALUE_TYPE(value) (((GValue*) (value))->g_type) +#define _G_TYPE_IGC(ip,gt,ct) ((ct*) (((GTypeInstance*) ip)->g_class)) +#define G_CALLBACK(f) ((GCallback) (f)) +#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) +#define G_TYPE_IS_FUNDAMENTAL(type) ((type) <= G_TYPE_FUNDAMENTAL_MAX) +#define G_TYPE_IS_DERIVED(type) ((type) > G_TYPE_FUNDAMENTAL_MAX) +#define G_PARAM_MASK (0x000000ff) +#define G_VALUE_NOCOPY_CONTENTS (1 << 27) +#define G_TYPE_FUNDAMENTAL_SHIFT (2) +#define G_TYPE_RESERVED_GLIB_FIRST (21) +#define G_TYPE_FUNDAMENTAL_MAX (255 << G_TYPE_FUNDAMENTAL_SHIFT) +#define G_TYPE_RESERVED_GLIB_LAST (31) +#define G_TYPE_RESERVED_BSE_FIRST (32) +#define G_TYPE_RESERVED_BSE_LAST (48) +#define G_TYPE_RESERVED_USER_FIRST (49) +#define G_PARAM_USER_SHIFT (8) +#define G_TYPE_CLOSURE (g_closure_get_type ()) +#define G_TYPE_GSTRING (g_gstring_get_type ()) +#define G_TYPE_IO_CHANNEL (g_io_channel_get_type ()) +#define G_TYPE_IO_CONDITION (g_io_condition_get_type ()) +#define G_PARAM_READWRITE (G_PARAM_READABLE | G_PARAM_WRITABLE) +#define G_PARAM_SPEC_VALUE_TYPE(pspec) (G_PARAM_SPEC (pspec)->value_type) +#define G_TYPE_PARAM_CHAR (g_param_spec_types[0]) +#define G_TYPE_PARAM_ENUM (g_param_spec_types[10]) +#define G_TYPE_PARAM_FLAGS (g_param_spec_types[11]) +#define G_TYPE_PARAM_FLOAT (g_param_spec_types[12]) +#define G_TYPE_PARAM_DOUBLE (g_param_spec_types[13]) +#define G_TYPE_PARAM_STRING (g_param_spec_types[14]) +#define G_TYPE_PARAM_PARAM (g_param_spec_types[15]) +#define G_TYPE_PARAM_BOXED (g_param_spec_types[16]) +#define G_TYPE_PARAM_POINTER (g_param_spec_types[17]) +#define G_TYPE_PARAM_VALUE_ARRAY (g_param_spec_types[18]) +#define G_TYPE_PARAM_OBJECT (g_param_spec_types[19]) +#define G_TYPE_PARAM_UCHAR (g_param_spec_types[1]) +#define G_TYPE_PARAM_OVERRIDE (g_param_spec_types[20]) +#define G_TYPE_PARAM_BOOLEAN (g_param_spec_types[2]) +#define G_TYPE_PARAM_INT (g_param_spec_types[3]) +#define G_TYPE_PARAM_UINT (g_param_spec_types[4]) +#define G_TYPE_PARAM_LONG (g_param_spec_types[5]) +#define G_TYPE_PARAM_ULONG (g_param_spec_types[6]) +#define G_TYPE_PARAM_INT64 (g_param_spec_types[7]) +#define G_TYPE_PARAM_UINT64 (g_param_spec_types[8]) +#define G_TYPE_PARAM_UNICHAR (g_param_spec_types[9]) +#define G_TYPE_STRV (g_strv_get_type ()) +#define _G_TYPE_CHI(ip) (g_type_check_instance ((GTypeInstance*) ip)) +#define G_TYPE_IS_VALUE(type) (g_type_check_is_value_type (type)) +#define G_TYPE_IS_VALUE_TYPE(type) (g_type_check_is_value_type (type)) +#define _G_TYPE_CHV(vl) (g_type_check_value ((GValue*) vl)) +#define G_IS_VALUE(value) (G_TYPE_CHECK_VALUE (value)) +#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) +#define G_ENUM_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class)) +#define G_FLAGS_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class)) +#define G_OBJECT_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class)) +#define G_OBJECT_TYPE(object) (G_TYPE_FROM_INSTANCE (object)) +#define G_PARAM_SPEC_TYPE(pspec) (G_TYPE_FROM_INSTANCE (pspec)) +#define G_TYPE_IS_BOXED(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_BOXED) +#define G_TYPE_IS_ENUM(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_ENUM) +#define G_TYPE_IS_FLAGS(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_FLAGS) +#define G_TYPE_IS_PARAM(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_PARAM) +#define G_TYPE_FUNDAMENTAL(type) (g_type_fundamental (type)) +#define G_TYPE_TYPE_MODULE (g_type_module_get_type ()) +#define G_OBJECT_TYPE_NAME(object) (g_type_name (G_OBJECT_TYPE (object))) +#define G_VALUE_TYPE_NAME(value) (g_type_name (G_VALUE_TYPE (value))) +#define G_TYPE_TYPE_PLUGIN (g_type_plugin_get_type ()) +#define G_TYPE_VALUE_ARRAY (g_value_array_get_type ()) +#define G_TYPE_VALUE (g_value_get_type ()) +#define G_TYPE_CHECK_VALUE(value) (_G_TYPE_CHV ((value))) +#define G_SIGNAL_MATCH_MASK 0x3f +#define G_SIGNAL_FLAGS_MASK 0x7f +#define GOBJECT_VAR extern +#define g_cclosure_marshal_BOOL__FLAGS g_cclosure_marshal_BOOLEAN__FLAGS +#define G_TYPE_INVALID G_TYPE_MAKE_FUNDAMENTAL (0) +#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) +#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) +#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) +#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) +#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) +#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) +#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) +#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) +#define G_TYPE_POINTER G_TYPE_MAKE_FUNDAMENTAL (17) +#define G_TYPE_BOXED G_TYPE_MAKE_FUNDAMENTAL (18) +#define G_TYPE_PARAM G_TYPE_MAKE_FUNDAMENTAL (19) +#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) +#define G_TYPE_OBJECT G_TYPE_MAKE_FUNDAMENTAL (20) +#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) +#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) +#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) +#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) +#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) +#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) +#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) + + + typedef gulong GType; + + typedef struct _GTypeClass GTypeClass; + + typedef struct _GTypeInstance GTypeInstance; + + typedef struct _GObject GObject; + + typedef float gfloat; + + typedef struct _GValue GValue; + + typedef enum { + G_PARAM_READABLE = 1, + G_PARAM_WRITABLE = 2, + G_PARAM_CONSTRUCT = 4, + G_PARAM_CONSTRUCT_ONLY = 8, + G_PARAM_LAX_VALIDATION = 16, + G_PARAM_PRIVATE = 32 + } GParamFlags; + + typedef struct _GParamSpec GParamSpec; + + typedef struct _GObjectConstructParam GObjectConstructParam; + + typedef struct _GObjectClass GObjectClass; + + typedef struct _GClosure GClosure; + + typedef void (*GClosureNotify) (gpointer, GClosure *); + + typedef struct _GClosureNotifyData GClosureNotifyData; + + typedef void (*GTypeInterfaceCheckFunc) (gpointer, gpointer); + + typedef struct _GValueArray GValueArray; + + typedef struct _GEnumValue GEnumValue; + + typedef struct _GEnumClass GEnumClass; + + typedef struct _GParamSpecPool GParamSpecPool; + + typedef enum { + G_TYPE_DEBUG_NONE = 0, + G_TYPE_DEBUG_OBJECTS = 1, + G_TYPE_DEBUG_SIGNALS = 2, + G_TYPE_DEBUG_MASK = 3 + } GTypeDebugFlags; + + typedef struct _GTypePlugin GTypePlugin; + + typedef enum { + G_SIGNAL_MATCH_ID = 1, + G_SIGNAL_MATCH_DETAIL = 2, + G_SIGNAL_MATCH_CLOSURE = 4, + G_SIGNAL_MATCH_FUNC = 8, + G_SIGNAL_MATCH_DATA = 16, + G_SIGNAL_MATCH_UNBLOCKED = 32 + } GSignalMatchType; + + typedef struct _GFlagsValue GFlagsValue; + + typedef void (*GClosureMarshal) (GClosure *, GValue *, guint, + const GValue *, gpointer, gpointer); + + typedef void (*GCallback) (void); + + typedef struct _GFlagsClass GFlagsClass; + + typedef gboolean(*GTypeClassCacheFunc) (gpointer, GTypeClass *); + + typedef enum { + G_SIGNAL_RUN_FIRST = 1, + G_SIGNAL_RUN_LAST = 2, + G_SIGNAL_RUN_CLEANUP = 4, + G_SIGNAL_NO_RECURSE = 8, + G_SIGNAL_DETAILED = 16, + G_SIGNAL_ACTION = 32, + G_SIGNAL_NO_HOOKS = 64 + } GSignalFlags; + + typedef struct _GSignalInvocationHint GSignalInvocationHint; + + typedef void (*GWeakNotify) (gpointer, GObject *); + + typedef void (*GBaseInitFunc) (gpointer); + + typedef void (*GBaseFinalizeFunc) (gpointer); + + typedef void (*GClassInitFunc) (gpointer, gpointer); + + typedef void (*GClassFinalizeFunc) (gpointer, gpointer); + + typedef void (*GInstanceInitFunc) (GTypeInstance *, gpointer); + + typedef union _GTypeCValue GTypeCValue; + + typedef struct _GTypeValueTable GTypeValueTable; + + typedef struct _GTypeInfo GTypeInfo; + + typedef enum { + G_TYPE_FLAG_ABSTRACT = 16, + G_TYPE_FLAG_VALUE_ABSTRACT = 32 + } GTypeFlags; + + typedef struct _GTypeModule GTypeModule; + + typedef void (*GInterfaceInitFunc) (gpointer, gpointer); + + typedef void (*GInterfaceFinalizeFunc) (gpointer, gpointer); + + typedef struct _GInterfaceInfo GInterfaceInfo; + + typedef gboolean(*GSignalAccumulator) (GSignalInvocationHint *, + GValue *, const GValue *, + gpointer); + + typedef GClosureMarshal GSignalCMarshaller; + + typedef enum { + G_CONNECT_AFTER = 1, + G_CONNECT_SWAPPED = 2 + } GConnectFlags; + + typedef enum { + G_TYPE_FLAG_CLASSED = 1, + G_TYPE_FLAG_INSTANTIATABLE = 2, + G_TYPE_FLAG_DERIVABLE = 4, + G_TYPE_FLAG_DEEP_DERIVABLE = 8 + } GTypeFundamentalFlags; + + typedef struct _GTypeFundamentalInfo GTypeFundamentalInfo; + + typedef struct _GTypeQuery GTypeQuery; + + typedef gboolean(*GSignalEmissionHook) (GSignalInvocationHint *, guint, + const GValue *, gpointer); + + typedef void (*GValueTransform) (const GValue *, GValue *); + + typedef struct _GParameter GParameter; + + typedef struct _GParamSpecTypeInfo GParamSpecTypeInfo; + + typedef gpointer(*GBoxedCopyFunc) (gpointer); + + typedef void (*GBoxedFreeFunc) (gpointer); + + typedef struct _GSignalQuery GSignalQuery; + + typedef struct _GTypeInterface GTypeInterface; + + typedef void (*GTypePluginCompleteInterfaceInfo) (GTypePlugin *, GType, + GType, + GInterfaceInfo *); + + typedef struct _GParamSpecObject GParamSpecObject; + + typedef void (*GTypePluginUnuse) (GTypePlugin *); + + typedef void (*GTypePluginUse) (GTypePlugin *); + + typedef void (*GTypePluginCompleteTypeInfo) (GTypePlugin *, GType, + GTypeInfo *, + GTypeValueTable *); + + typedef struct _GTypePluginClass GTypePluginClass; + + typedef struct _GCClosure GCClosure; + + typedef struct _GParamSpecUnichar GParamSpecUnichar; + + typedef struct _GParamSpecUInt64 GParamSpecUInt64; + + typedef struct _GParamSpecBoxed GParamSpecBoxed; + + typedef struct _GParamSpecOverride GParamSpecOverride; + + typedef struct _GParamSpecClass GParamSpecClass; + + typedef struct _GParamSpecLong GParamSpecLong; + + typedef struct _GParamSpecEnum GParamSpecEnum; + + typedef struct _GParamSpecFloat GParamSpecFloat; + + typedef struct _GParamSpecString GParamSpecString; + + typedef struct _GParamSpecDouble GParamSpecDouble; + + typedef struct _GParamSpecParam GParamSpecParam; + + typedef struct _GParamSpecValueArray GParamSpecValueArray; + + typedef struct _GParamSpecFlags GParamSpecFlags; + + typedef struct _GParamSpecInt64 GParamSpecInt64; + + typedef struct _GParamSpecPointer GParamSpecPointer; + + typedef struct _GParamSpecInt GParamSpecInt; + + typedef struct _GTypeModuleClass GTypeModuleClass; + + typedef struct _GParamSpecUInt GParamSpecUInt; + + typedef struct _GParamSpecUChar GParamSpecUChar; + + typedef struct _GParamSpecULong GParamSpecULong; + + typedef struct _GParamSpecChar GParamSpecChar; + + typedef struct _GParamSpecBoolean GParamSpecBoolean; + + typedef void (*GObjectFinalizeFunc) (GObject *); + + typedef void (*GObjectGetPropertyFunc) (GObject *, guint, GValue *, + GParamSpec *); + + typedef void (*GObjectSetPropertyFunc) (GObject *, guint, + const GValue *, GParamSpec *); + + typedef gchar *gchararray; + + typedef gchar **GStrv; + + + struct _GTypeClass { + GType g_type; + }; + + + struct _GTypeInstance { + GTypeClass *g_class; + }; + + + struct _GObject { + GTypeInstance g_type_instance; + guint ref_count; + GData *qdata; + }; + + + struct _GValue { + GType g_type; + union { + gint v_int; + guint v_uint; + glong v_long; + gulong v_ulong; + gint64 v_int64; + guint64 v_uint64; + gfloat v_float; + gdouble v_double; + gpointer v_pointer; + } data[2]; + }; + + + struct _GParamSpec { + GTypeInstance g_type_instance; + gchar *name; + GParamFlags flags; + GType value_type; + GType owner_type; + gchar *_nick; + gchar *_blurb; + GData *qdata; + guint ref_count; + guint param_id; + }; + + + struct _GObjectConstructParam { + GParamSpec *pspec; + GValue *value; + }; + + + struct _GObjectClass { + GTypeClass g_type_class; + GSList *construct_properties; + GObject *(*constructor) (GType, guint, GObjectConstructParam *); + void (*set_property) (GObject *, guint, const GValue *, + GParamSpec *); + void (*get_property) (GObject *, guint, GValue *, GParamSpec *); + void (*dispose) (GObject *); + void (*finalize) (GObject *); + void (*dispatch_properties_changed) (GObject *, guint, + GParamSpec * *); + void (*notify) (GObject *, GParamSpec *); + gpointer pdummy[8]; + }; + + + struct _GClosure { + guint ref_count:15; + guint meta_marshal:1; + guint n_guards:1; + guint n_fnotifiers:2; + guint n_inotifiers:8; + guint in_inotify:1; + guint floating:1; + guint derivative_flag:1; + guint in_marshal:1; + guint is_invalid:1; + void (*marshal) (GClosure *, GValue *, guint, const GValue *, + gpointer, gpointer); + gpointer data; + GClosureNotifyData *notifiers; + }; + + + struct _GClosureNotifyData { + gpointer data; + GClosureNotify notify; + }; + + + struct _GValueArray { + guint n_values; + GValue *values; + guint n_prealloced; + }; + + + struct _GEnumValue { + gint value; + gchar *value_name; + gchar *value_nick; + }; + + + struct _GEnumClass { + GTypeClass g_type_class; + gint minimum; + gint maximum; + guint n_values; + GEnumValue *values; + }; + + + + + + + + + struct _GFlagsValue { + guint value; + gchar *value_name; + gchar *value_nick; + }; + + + struct _GFlagsClass { + GTypeClass g_type_class; + guint mask; + guint n_values; + GFlagsValue *values; + }; + + + struct _GSignalInvocationHint { + guint signal_id; + GQuark detail; + GSignalFlags run_type; + }; + + + + + + struct _GTypeValueTable { + void (*value_init) (GValue *); + void (*value_free) (GValue *); + void (*value_copy) (const GValue *, GValue *); + gpointer(*value_peek_pointer) (const GValue *); + gchar *collect_format; + gchar *(*collect_value) (GValue *, guint, GTypeCValue *, guint); + gchar *lcopy_format; + gchar *(*lcopy_value) (const GValue *, guint, GTypeCValue *, + guint); + }; + + + struct _GTypeInfo { + guint16 class_size; + GBaseInitFunc base_init; + GBaseFinalizeFunc base_finalize; + GClassInitFunc class_init; + GClassFinalizeFunc class_finalize; + gconstpointer class_data; + guint16 instance_size; + guint16 n_preallocs; + GInstanceInitFunc instance_init; + const GTypeValueTable *value_table; + }; + + + struct _GTypeModule { + GObject parent_instance; + guint use_count; + GSList *type_infos; + GSList *interface_infos; + gchar *name; + }; + + + struct _GInterfaceInfo { + GInterfaceInitFunc interface_init; + GInterfaceFinalizeFunc interface_finalize; + gpointer interface_data; + }; + + + struct _GTypeFundamentalInfo { + GTypeFundamentalFlags type_flags; + }; + + + struct _GTypeQuery { + GType type; + const gchar *type_name; + guint class_size; + guint instance_size; + }; + + + struct _GParameter { + const gchar *name; + GValue value; + }; + + + struct _GParamSpecTypeInfo { + guint16 instance_size; + guint16 n_preallocs; + void (*instance_init) (GParamSpec *); + GType value_type; + void (*finalize) (GParamSpec *); + void (*value_set_default) (GParamSpec *, GValue *); + gboolean(*value_validate) (GParamSpec *, GValue *); + gint(*values_cmp) (GParamSpec *, const GValue *, const GValue *); + }; + + + struct _GSignalQuery { + guint signal_id; + const gchar *signal_name; + GType itype; + GSignalFlags signal_flags; + GType return_type; + guint n_params; + const GType *param_types; + }; + + + struct _GTypeInterface { + GType g_type; + GType g_instance_type; + }; + + + struct _GParamSpecObject { + GParamSpec parent_instance; + }; + + + struct _GTypePluginClass { + GTypeInterface base_iface; + GTypePluginUse use_plugin; + GTypePluginUnuse unuse_plugin; + GTypePluginCompleteTypeInfo complete_type_info; + GTypePluginCompleteInterfaceInfo complete_interface_info; + }; + + + struct _GCClosure { + GClosure closure; + gpointer callback; + }; + + + struct _GParamSpecUnichar { + GParamSpec parent_instance; + gunichar default_value; + }; + + + struct _GParamSpecUInt64 { + GParamSpec parent_instance; + guint64 minimum; + guint64 maximum; + guint64 default_value; + }; + + + struct _GParamSpecBoxed { + GParamSpec parent_instance; + }; + + + struct _GParamSpecOverride { + GParamSpec parent_instance; + GParamSpec *overridden; + }; + + + struct _GParamSpecClass { + GTypeClass g_type_class; + GType value_type; + void (*finalize) (GParamSpec *); + void (*value_set_default) (GParamSpec *, GValue *); + gboolean(*value_validate) (GParamSpec *, GValue *); + gint(*values_cmp) (GParamSpec *, const GValue *, const GValue *); + gpointer dummy[4]; + }; + + + struct _GParamSpecLong { + GParamSpec parent_instance; + glong minimum; + glong maximum; + glong default_value; + }; + + + struct _GParamSpecEnum { + GParamSpec parent_instance; + GEnumClass *enum_class; + gint default_value; + }; + + + struct _GParamSpecFloat { + GParamSpec parent_instance; + gfloat minimum; + gfloat maximum; + gfloat default_value; + gfloat epsilon; + }; + + + struct _GParamSpecString { + GParamSpec parent_instance; + gchar *default_value; + gchar *cset_first; + gchar *cset_nth; + gchar substitutor; + guint null_fold_if_empty:1; + guint ensure_non_null:1; + }; + + + struct _GParamSpecDouble { + GParamSpec parent_instance; + gdouble minimum; + gdouble maximum; + gdouble default_value; + gdouble epsilon; + }; + + + struct _GParamSpecParam { + GParamSpec parent_instance; + }; + + + struct _GParamSpecValueArray { + GParamSpec parent_instance; + GParamSpec *element_spec; + guint fixed_n_elements; + }; + + + struct _GParamSpecFlags { + GParamSpec parent_instance; + GFlagsClass *flags_class; + guint default_value; + }; + + + struct _GParamSpecInt64 { + GParamSpec parent_instance; + gint64 minimum; + gint64 maximum; + gint64 default_value; + }; + + + struct _GParamSpecPointer { + GParamSpec parent_instance; + }; + + + struct _GParamSpecInt { + GParamSpec parent_instance; + gint minimum; + gint maximum; + gint default_value; + }; + + + struct _GTypeModuleClass { + GObjectClass parent_class; + gboolean(*load) (GTypeModule *); + void (*unload) (GTypeModule *); + void (*reserved1) (void); + void (*reserved2) (void); + void (*reserved3) (void); + void (*reserved4) (void); + }; + + + struct _GParamSpecUInt { + GParamSpec parent_instance; + guint minimum; + guint maximum; + guint default_value; + }; + + + struct _GParamSpecUChar { + GParamSpec parent_instance; + guint8 minimum; + guint8 maximum; + guint8 default_value; + }; + + + struct _GParamSpecULong { + GParamSpec parent_instance; + gulong minimum; + gulong maximum; + gulong default_value; + }; + + + struct _GParamSpecChar { + GParamSpec parent_instance; + gint8 minimum; + gint8 maximum; + gint8 default_value; + }; + + + struct _GParamSpecBoolean { + GParamSpec parent_instance; + gboolean default_value; + }; + + + extern void g_object_set_property(GObject *, const gchar *, + const GValue *); + extern void g_value_set_param(GValue *, GParamSpec *); + extern gpointer g_object_steal_qdata(GObject *, GQuark); + extern void g_object_class_override_property(GObjectClass *, guint, + const gchar *); + extern void g_cclosure_marshal_VOID__INT(GClosure *, GValue *, guint, + const GValue *, gpointer, + gpointer); + extern void g_closure_sink(GClosure *); + extern gboolean g_type_check_value_holds(GValue *, GType); + extern void g_type_remove_interface_check(gpointer, + GTypeInterfaceCheckFunc); + extern GValueArray *g_value_array_remove(GValueArray *, guint); + extern gboolean g_param_value_defaults(GParamSpec *, GValue *); + extern GParamSpec *g_param_spec_long(const gchar *, const gchar *, + const gchar *, glong, glong, + glong, GParamFlags); + extern gpointer g_param_spec_internal(GType, const gchar *, + const gchar *, const gchar *, + GParamFlags); + extern void g_cclosure_marshal_VOID__LONG(GClosure *, GValue *, guint, + const GValue *, gpointer, + gpointer); + extern GType g_io_channel_get_type(void); + extern GEnumValue *g_enum_get_value(GEnumClass *, gint); + extern GParamSpec *g_param_spec_boolean(const gchar *, const gchar *, + const gchar *, gboolean, + GParamFlags); + extern GParamSpec *g_param_spec_pointer(const gchar *, const gchar *, + const gchar *, GParamFlags); + extern GClosure *g_closure_new_object(guint, GObject *); + extern void g_param_spec_pool_insert(GParamSpecPool *, GParamSpec *, + GType); + extern void g_type_init_with_debug_flags(GTypeDebugFlags); + extern GType *g_type_interfaces(GType, guint *); + extern GClosure *g_closure_new_simple(guint, gpointer); + extern GParamSpec *g_param_spec_string(const gchar *, const gchar *, + const gchar *, const gchar *, + GParamFlags); + extern GValueArray *g_value_array_copy(const GValueArray *); + extern gpointer g_type_instance_get_private(GTypeInstance *, GType); + extern void g_cclosure_marshal_VOID__FLAGS(GClosure *, GValue *, guint, + const GValue *, gpointer, + gpointer); + extern GTypePlugin *g_type_get_plugin(GType); + extern void g_param_spec_unref(GParamSpec *); + extern gint g_param_values_cmp(GParamSpec *, const GValue *, + const GValue *); + extern void g_value_set_object(GValue *, gpointer); + extern GParamSpec *g_param_spec_boxed(const gchar *, const gchar *, + const gchar *, GType, + GParamFlags); + extern void g_value_set_int(GValue *, gint); + extern gboolean g_signal_parse_name(const gchar *, GType, guint *, + GQuark *, gboolean); + extern GParamSpec *g_param_spec_pool_lookup(GParamSpecPool *, + const gchar *, GType, + gboolean); + extern GTypeInstance *g_type_create_instance(GType); + extern void g_signal_override_class_closure(guint, GType, GClosure *); + extern gboolean g_param_value_validate(GParamSpec *, GValue *); + extern void g_closure_add_invalidate_notifier(GClosure *, gpointer, + GClosureNotify); + extern gpointer g_type_interface_peek(gpointer, GType); + extern gboolean g_type_test_flags(GType, guint); + extern void g_signal_emit_by_name(gpointer, const gchar *, ...); + extern void g_value_set_int64(GValue *, gint64); + extern void g_cclosure_marshal_VOID__UINT(GClosure *, GValue *, guint, + const GValue *, gpointer, + gpointer); + extern GType g_enum_register_static(const gchar *, const GEnumValue *); + extern guint g_signal_handlers_disconnect_matched(gpointer, + GSignalMatchType, + guint, GQuark, + GClosure *, gpointer, + gpointer); + extern gpointer g_value_get_pointer(const GValue *); + extern GType g_flags_register_static(const gchar *, + const GFlagsValue *); + extern gboolean g_value_fits_pointer(const GValue *); + extern void g_closure_set_marshal(GClosure *, GClosureMarshal); + extern void g_value_set_float(GValue *, gfloat); + extern void g_signal_emit(gpointer, guint, GQuark, ...); + extern GParamSpec *g_param_spec_uint(const gchar *, const gchar *, + const gchar *, guint, guint, + guint, GParamFlags); + extern GClosure *g_cclosure_new_object_swap(GCallback, GObject *); + extern void g_param_spec_set_qdata(GParamSpec *, GQuark, gpointer); + extern guint *g_signal_list_ids(GType, guint *); + extern GFlagsValue *g_flags_get_first_value(GFlagsClass *, guint); + extern void g_type_add_class_cache_func(gpointer, GTypeClassCacheFunc); + extern void g_object_unref(gpointer); + extern GParamSpec *g_value_dup_param(const GValue *); + extern void g_object_get(gpointer, const gchar *, ...); + extern void g_value_set_uint64(GValue *, guint64); + extern void g_cclosure_marshal_VOID__OBJECT(GClosure *, GValue *, + guint, const GValue *, + gpointer, gpointer); + extern guint64 g_value_get_uint64(const GValue *); + extern GType *g_type_children(GType, guint *); + extern const gchar *g_type_name(GType); + extern GTypeClass *g_type_check_class_cast(GTypeClass *, GType); + extern void g_cclosure_marshal_VOID__UCHAR(GClosure *, GValue *, guint, + const GValue *, gpointer, + gpointer); + extern gpointer g_object_new(GType, const gchar *, ...); + extern void g_type_class_unref_uncached(gpointer); + extern const gchar *g_type_name_from_class(GTypeClass *); + extern void g_object_set(gpointer, const gchar *, ...); + extern void g_signal_emit_valist(gpointer, guint, GQuark, va_list); + extern GSignalInvocationHint *g_signal_get_invocation_hint(gpointer); + extern void g_closure_invalidate(GClosure *); + extern void g_cclosure_marshal_VOID__FLOAT(GClosure *, GValue *, guint, + const GValue *, gpointer, + gpointer); + extern void g_object_weak_unref(GObject *, GWeakNotify, gpointer); + extern GParamSpec *g_param_spec_int(const gchar *, const gchar *, + const gchar *, gint, gint, gint, + GParamFlags); + extern void g_value_set_char(GValue *, gchar); + extern gpointer g_type_default_interface_ref(GType); + extern GValueArray *g_value_array_sort(GValueArray *, GCompareFunc); + extern void g_cclosure_marshal_VOID__VOID(GClosure *, GValue *, guint, + const GValue *, gpointer, + gpointer); + extern GType *g_param_spec_types; + extern GClosure *g_cclosure_new_object(GCallback, GObject *); + extern GType g_type_register_static(GType, const gchar *, + const GTypeInfo *, GTypeFlags); + extern GEnumValue *g_enum_get_value_by_name(GEnumClass *, + const gchar *); + extern GFlagsValue *g_flags_get_value_by_nick(GFlagsClass *, + const gchar *); + extern guint g_type_depth(GType); + extern void g_object_class_install_property(GObjectClass *, guint, + GParamSpec *); + extern void g_type_plugin_unuse(GTypePlugin *); + extern void g_type_module_unuse(GTypeModule *); + extern GParamSpec *g_param_spec_flags(const gchar *, const gchar *, + const gchar *, GType, guint, + GParamFlags); + extern GParamSpec *g_param_spec_char(const gchar *, const gchar *, + const gchar *, gint8, gint8, + gint8, GParamFlags); + extern void g_closure_remove_invalidate_notifier(GClosure *, gpointer, + GClosureNotify); + extern gint g_value_get_enum(const GValue *); + extern GParamSpec *g_object_interface_find_property(gpointer, + const gchar *); + extern void g_value_copy(const GValue *, GValue *); + extern gpointer g_type_get_qdata(GType, GQuark); + extern void g_cclosure_marshal_VOID__DOUBLE(GClosure *, GValue *, + guint, const GValue *, + gpointer, gpointer); + extern gboolean g_value_type_compatible(GType, GType); + extern void g_object_set_data_full(GObject *, const gchar *, gpointer, + GDestroyNotify); + extern guint g_signal_handlers_block_matched(gpointer, + GSignalMatchType, guint, + GQuark, GClosure *, + gpointer, gpointer); + extern gpointer g_boxed_copy(GType, gconstpointer); + extern const gchar *g_value_get_string(const GValue *); + extern void g_object_thaw_notify(GObject *); + extern void g_signal_handler_block(gpointer, gulong); + extern void g_type_plugin_complete_type_info(GTypePlugin *, GType, + GTypeInfo *, + GTypeValueTable *); + extern GTypeInstance *g_type_check_instance_cast(GTypeInstance *, + GType); + extern GEnumValue *g_enum_get_value_by_nick(GEnumClass *, + const gchar *); + extern GType g_type_from_name(const gchar *); + extern gboolean g_signal_accumulator_true_handled(GSignalInvocationHint + *, GValue *, + const GValue *, + gpointer); + extern GType g_type_module_register_enum(GTypeModule *, const gchar *, + const GEnumValue *); + extern void g_closure_unref(GClosure *); + extern void g_signal_chain_from_overridden(const GValue *, GValue *); + extern gboolean g_param_value_convert(GParamSpec *, const GValue *, + GValue *, gboolean); + extern void g_type_class_add_private(gpointer, gsize); + extern gpointer g_type_interface_peek_parent(gpointer); + extern void g_type_add_interface_check(gpointer, + GTypeInterfaceCheckFunc); + extern void g_cclosure_marshal_VOID__POINTER(GClosure *, GValue *, + guint, const GValue *, + gpointer, gpointer); + extern void g_cclosure_marshal_VOID__CHAR(GClosure *, GValue *, guint, + const GValue *, gpointer, + gpointer); + extern GParamSpec *g_param_spec_float(const gchar *, const gchar *, + const gchar *, gfloat, gfloat, + gfloat, GParamFlags); + extern gboolean g_type_is_a(GType, GType); + extern GParamSpec *g_param_spec_object(const gchar *, const gchar *, + const gchar *, GType, + GParamFlags); + extern gpointer g_type_class_peek_parent(gpointer); + extern GType g_io_condition_get_type(void); + extern guchar g_value_get_uchar(const GValue *); + extern GParamSpec *g_param_spec_double(const gchar *, const gchar *, + const gchar *, gdouble, gdouble, + gdouble, GParamFlags); + extern GType g_strv_get_type(void); + extern void g_cclosure_marshal_STRING__OBJECT_POINTER(GClosure *, + GValue *, guint, + const GValue *, + gpointer, + gpointer); + extern gulong g_signal_handler_find(gpointer, GSignalMatchType, guint, + GQuark, GClosure *, gpointer, + gpointer); + extern GParamSpec *g_param_spec_ref(GParamSpec *); + extern gboolean g_value_transform(const GValue *, GValue *); + extern gpointer g_type_class_peek_static(GType); + extern GObject *g_object_new_valist(GType, const gchar *, va_list); + extern void g_value_unset(GValue *); + extern gpointer g_value_dup_boxed(const GValue *); + extern void g_cclosure_marshal_VOID__STRING(GClosure *, GValue *, + guint, const GValue *, + gpointer, gpointer); + extern void g_param_spec_sink(GParamSpec *); + extern void g_object_run_dispose(GObject *); + extern GParamSpec *g_param_spec_override(const gchar *, GParamSpec *); + extern void g_value_set_instance(GValue *, gpointer); + extern gpointer g_value_peek_pointer(const GValue *); + extern GType g_type_module_register_type(GTypeModule *, GType, + const gchar *, + const GTypeInfo *, + GTypeFlags); + extern void g_signal_handlers_destroy(gpointer); + extern void g_value_set_boolean(GValue *, gboolean); + extern void g_type_plugin_complete_interface_info(GTypePlugin *, GType, + GType, + GInterfaceInfo *); + extern GParamSpec *g_param_spec_get_redirect_target(GParamSpec *); + extern GParamSpec **g_object_interface_list_properties(gpointer, + guint *); + extern gint64 g_value_get_int64(const GValue *); + extern GType g_type_module_register_flags(GTypeModule *, const gchar *, + const GFlagsValue *); + extern void g_cclosure_marshal_BOOLEAN__FLAGS(GClosure *, GValue *, + guint, const GValue *, + gpointer, gpointer); + extern gpointer g_param_spec_get_qdata(GParamSpec *, GQuark); + extern void g_type_init(void); + extern gulong g_value_get_ulong(const GValue *); + extern gchar *g_strdup_value_contents(const GValue *); + extern guint g_signal_new_valist(const gchar *, GType, GSignalFlags, + GClosure *, GSignalAccumulator, + gpointer, GSignalCMarshaller, GType, + guint, va_list); + extern void g_object_disconnect(gpointer, const gchar *, ...); + extern void g_object_add_weak_pointer(GObject *, gpointer *); + extern GParamSpec *g_param_spec_param(const gchar *, const gchar *, + const gchar *, GType, + GParamFlags); + extern void g_signal_stop_emission_by_name(gpointer, const gchar *); + extern GValueArray *g_value_array_sort_with_data(GValueArray *, + GCompareDataFunc, + gpointer); + extern GType g_value_array_get_type(void); + extern void g_value_take_string(GValue *, gchar *); + extern GType g_closure_get_type(void); + extern void g_signal_stop_emission(gpointer, guint, GQuark); + extern void g_object_notify(GObject *, const gchar *); + extern gfloat g_value_get_float(const GValue *); + extern gchar g_value_get_char(const GValue *); + extern void g_value_take_boxed(GValue *, gconstpointer); + extern void g_cclosure_marshal_VOID__BOOLEAN(GClosure *, GValue *, + guint, const GValue *, + gpointer, gpointer); + extern gulong g_signal_connect_data(gpointer, const gchar *, GCallback, + gpointer, GClosureNotify, + GConnectFlags); + extern void g_object_set_data(GObject *, const gchar *, gpointer); + extern GType g_type_register_fundamental(GType, const gchar *, + const GTypeInfo *, + const GTypeFundamentalInfo *, + GTypeFlags); + extern GParamSpec **g_object_class_list_properties(GObjectClass *, + guint *); + extern void g_cclosure_marshal_VOID__UINT_POINTER(GClosure *, GValue *, + guint, + const GValue *, + gpointer, gpointer); + extern void g_type_class_unref(gpointer); + extern void g_cclosure_marshal_VOID__BOXED(GClosure *, GValue *, guint, + const GValue *, gpointer, + gpointer); + extern gboolean g_value_type_transformable(GType, GType); + extern void g_signal_handler_unblock(gpointer, gulong); + extern GValue *g_value_init(GValue *, GType); + extern gpointer g_object_ref(gpointer); + extern void g_object_get_valist(GObject *, const gchar *, va_list); + extern gboolean g_value_get_boolean(const GValue *); + extern void g_type_query(GType, GTypeQuery *); + extern void g_type_interface_add_prerequisite(GType, GType); + extern gint g_value_get_int(const GValue *); + extern void g_cclosure_marshal_VOID__ENUM(GClosure *, GValue *, guint, + const GValue *, gpointer, + gpointer); + extern GType g_type_fundamental_next(void); + extern gboolean g_type_check_value(GValue *); + extern gpointer g_value_get_boxed(const GValue *); + extern GClosure *g_signal_type_cclosure_new(GType, guint); + extern void g_value_set_static_boxed(GValue *, gconstpointer); + extern GType g_type_plugin_get_type(void); + extern GType *g_type_interface_prerequisites(GType, guint *); + extern void g_boxed_free(GType, gpointer); + extern GParamSpec *g_param_spec_uint64(const gchar *, const gchar *, + const gchar *, guint64, guint64, + guint64, GParamFlags); + extern GType g_type_next_base(GType, GType); + extern const gchar *g_type_name_from_instance(GTypeInstance *); + extern const gchar *g_param_spec_get_name(GParamSpec *); + extern gulong g_signal_add_emission_hook(guint, GQuark, + GSignalEmissionHook, gpointer, + GDestroyNotify); + extern GParamSpec *g_object_class_find_property(GObjectClass *, + const gchar *); + extern void g_value_set_long(GValue *, glong); + extern void g_param_spec_pool_remove(GParamSpecPool *, GParamSpec *); + extern void g_signal_emitv(const GValue *, guint, GQuark, GValue *); + extern GType g_type_module_get_type(void); + extern GObject *g_value_dup_object(const GValue *); + extern void g_flags_complete_type_info(GType, GTypeInfo *, + const GFlagsValue *); + extern gulong g_signal_connect_closure_by_id(gpointer, guint, GQuark, + GClosure *, gboolean); + extern GType g_value_get_type(void); + extern gulong g_signal_connect_closure(gpointer, const gchar *, + GClosure *, gboolean); + extern gulong g_signal_connect_object(gpointer, const gchar *, + GCallback, gpointer, + GConnectFlags); + extern void g_value_take_param(GValue *, GParamSpec *); + extern void g_value_set_ulong(GValue *, gulong); + extern void g_value_register_transform_func(GType, GType, + GValueTransform); + extern GType g_type_parent(GType); + extern void g_type_plugin_use(GTypePlugin *); + extern GType g_type_register_dynamic(GType, const gchar *, + GTypePlugin *, GTypeFlags); + extern GType g_pointer_type_register_static(const gchar *); + extern void g_closure_add_finalize_notifier(GClosure *, gpointer, + GClosureNotify); + extern GFlagsValue *g_flags_get_value_by_name(GFlagsClass *, + const gchar *); + extern void g_cclosure_marshal_VOID__PARAM(GClosure *, GValue *, guint, + const GValue *, gpointer, + gpointer); + extern gboolean g_signal_handler_is_connected(gpointer, gulong); + extern void g_closure_set_meta_marshal(GClosure *, gpointer, + GClosureMarshal); + extern void g_value_set_uchar(GValue *, guchar); + extern GValueArray *g_value_array_prepend(GValueArray *, + const GValue *); + extern void g_source_set_closure(GSource *, GClosure *); + extern GParamSpec **g_param_spec_pool_list(GParamSpecPool *, GType, + guint *); + extern GQuark g_type_qname(GType); + extern gboolean g_type_module_use(GTypeModule *); + extern void g_type_add_interface_dynamic(GType, GType, GTypePlugin *); + extern gpointer g_type_class_ref(GType); + extern void g_closure_remove_finalize_notifier(GClosure *, gpointer, + GClosureNotify); + extern gpointer g_object_connect(gpointer, const gchar *, ...); + extern void g_type_remove_class_cache_func(gpointer, + GTypeClassCacheFunc); + extern gpointer g_object_newv(GType, guint, GParameter *); + extern GValueArray *g_value_array_insert(GValueArray *, guint, + const GValue *); + extern gboolean g_signal_has_handler_pending(gpointer, guint, GQuark, + gboolean); + extern guint g_signal_lookup(const gchar *, GType); + extern void g_type_free_instance(GTypeInstance *); + extern void g_closure_invoke(GClosure *, GValue *, guint, + const GValue *, gpointer); + extern GType g_type_fundamental(GType); + extern GTypeValueTable *g_type_value_table_peek(GType); + extern GList *g_param_spec_pool_list_owned(GParamSpecPool *, GType); + extern void g_value_set_enum(GValue *, gint); + extern gchar *g_value_dup_string(const GValue *); + extern void g_signal_handler_disconnect(gpointer, gulong); + extern GType g_param_type_register_static(const gchar *, + const GParamSpecTypeInfo *); + extern void g_object_remove_weak_pointer(GObject *, gpointer *); + extern glong g_value_get_long(const GValue *); + extern gboolean g_type_check_is_value_type(GType); + extern void g_value_set_double(GValue *, gdouble); + extern void g_value_set_static_string(GValue *, const gchar *); + extern const gchar *g_param_spec_get_nick(GParamSpec *); + extern GClosure *g_cclosure_new(GCallback, gpointer, GClosureNotify); + extern guint g_value_get_uint(const GValue *); + extern GClosure *g_cclosure_new_swap(GCallback, gpointer, + GClosureNotify); + extern GValue *g_value_reset(GValue *); + extern void g_object_set_qdata(GObject *, GQuark, gpointer); + extern gpointer g_object_get_data(GObject *, const gchar *); + extern gpointer g_object_get_qdata(GObject *, GQuark); + extern void g_object_set_valist(GObject *, const gchar *, va_list); + extern void g_object_freeze_notify(GObject *); + extern void g_value_set_pointer(GValue *, gpointer); + extern gpointer g_object_steal_data(GObject *, const gchar *); + extern void g_object_interface_install_property(gpointer, + GParamSpec *); + extern void g_object_watch_closure(GObject *, GClosure *); + extern void g_value_take_object(GValue *, gpointer); + extern GValueArray *g_value_array_new(guint); + extern GParamSpec *g_value_get_param(const GValue *); + extern void g_param_value_set_default(GParamSpec *, GValue *); + extern void g_closure_add_marshal_guards(GClosure *, gpointer, + GClosureNotify, gpointer, + GClosureNotify); + extern gdouble g_value_get_double(const GValue *); + extern GValue *g_value_array_get_nth(GValueArray *, guint); + extern GTypePlugin *g_type_interface_get_plugin(GType, GType); + extern void g_object_weak_ref(GObject *, GWeakNotify, gpointer); + extern GType g_gstring_get_type(void); + extern void g_value_set_flags(GValue *, guint); + extern void g_object_get_property(GObject *, const gchar *, GValue *); + extern GParamSpec *g_param_spec_unichar(const gchar *, const gchar *, + const gchar *, gunichar, + GParamFlags); + extern void g_type_default_interface_unref(gpointer); + extern GParamSpec *g_param_spec_uchar(const gchar *, const gchar *, + const gchar *, guint8, guint8, + guint8, GParamFlags); + extern void g_object_set_qdata_full(GObject *, GQuark, gpointer, + GDestroyNotify); + extern void g_type_set_qdata(GType, GQuark, gpointer); + extern void g_value_set_string(GValue *, const gchar *); + extern gpointer g_type_class_peek(GType); + extern void g_value_set_boxed(GValue *, gconstpointer); + extern void g_type_module_set_name(GTypeModule *, const gchar *); + extern GClosure *g_closure_ref(GClosure *); + extern guint g_signal_handlers_unblock_matched(gpointer, + GSignalMatchType, guint, + GQuark, GClosure *, + gpointer, gpointer); + extern GParamSpec *g_param_spec_value_array(const gchar *, + const gchar *, + const gchar *, + GParamSpec *, GParamFlags); + extern GParamSpec *g_param_spec_enum(const gchar *, const gchar *, + const gchar *, GType, gint, + GParamFlags); + extern void g_param_spec_set_qdata_full(GParamSpec *, GQuark, gpointer, + GDestroyNotify); + extern GParamSpec *g_param_spec_ulong(const gchar *, const gchar *, + const gchar *, gulong, gulong, + gulong, GParamFlags); + extern guint g_value_get_flags(const GValue *); + extern void g_type_module_add_interface(GTypeModule *, GType, GType, + const GInterfaceInfo *); + extern gboolean g_type_check_instance(GTypeInstance *); + extern GValueArray *g_value_array_append(GValueArray *, + const GValue *); + extern void g_type_add_interface_static(GType, GType, + const GInterfaceInfo *); + extern gpointer g_param_spec_steal_qdata(GParamSpec *, GQuark); + extern gboolean g_type_check_class_is_a(GTypeClass *, GType); + extern const gchar *g_param_spec_get_blurb(GParamSpec *); + extern void g_value_set_uint(GValue *, guint); + extern GParamSpecPool *g_param_spec_pool_new(gboolean); + extern const gchar *g_signal_name(guint); + extern GParamSpec *g_param_spec_int64(const gchar *, const gchar *, + const gchar *, gint64, gint64, + gint64, GParamFlags); + extern guint g_signal_newv(const gchar *, GType, GSignalFlags, + GClosure *, GSignalAccumulator, gpointer, + GSignalCMarshaller, GType, guint, GType *); + extern guint g_signal_new(const gchar *, GType, GSignalFlags, guint, + GSignalAccumulator, gpointer, + GSignalCMarshaller, GType, guint, ...); + extern GType g_boxed_type_register_static(const gchar *, + GBoxedCopyFunc, + GBoxedFreeFunc); + extern void g_value_array_free(GValueArray *); + extern void g_cclosure_marshal_VOID__ULONG(GClosure *, GValue *, guint, + const GValue *, gpointer, + gpointer); + extern void g_signal_remove_emission_hook(guint, gulong); + extern void g_enum_complete_type_info(GType, GTypeInfo *, + const GEnumValue *); + extern gpointer g_value_get_object(const GValue *); + extern gpointer g_type_default_interface_peek(GType); + extern void g_signal_query(guint, GSignalQuery *); + extern gboolean g_type_check_instance_is_a(GTypeInstance *, GType); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/glib-2.0/glib.h b/lsb-build/headers/glib-2.0/glib.h new file mode 100644 index 0000000..e351b3b --- /dev/null +++ b/lsb-build/headers/glib-2.0/glib.h @@ -0,0 +1,3296 @@ +#ifndef _GLIB_2_0_GLIB_H_ +#define _GLIB_2_0_GLIB_H_ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define GLIB_HAVE_ALLOCA_H +#define GLIB_HAVE_SYS_POLL_H +#define G_GINT32_MODIFIER "" +#define G_GNUC_FUNCTION "" +#define G_GNUC_PRETTY_FUNCTION "" +#if __i386__ +#define G_GSIZE_MODIFIER "" +#endif +#if __powerpc__ && !__powerpc64__ +#define G_GSIZE_MODIFIER "" +#endif +#if __s390__ && !__s390x__ +#define G_GSIZE_MODIFIER "" +#endif +#define G_OPTION_REMAINING "" +#define G_OS_UNIX +#define G_THREADS_ENABLED +#define G_THREADS_IMPL_POSIX +#define G_WIN32_DLLMAIN_FOR_DLL_NAME(static,dll_name) +#define G_CSET_LATINC \ + "\300\301\302\303\304\305\306" \ + "\307\310\311\312\313\314\315\316\317\320" "\321\322\323\324\325\326" \ + "\330\331\332\333\334\335\336" +#define G_CSET_LATINS \ + "\337\340\341\342\343\344\345\346" \ + "\347\350\351\352\353\354\355\356\357\360" "\361\362\363\364\365\366" \ + "\370\371\372\373\374\375\376\377" +#define g_mem_chunk_create(type,pre_alloc,alloc_type) \ + ( g_mem_chunk_new (#type " mem chunks (" #pre_alloc ")", sizeof \ + (type), sizeof (type) * (pre_alloc), (alloc_type)) ) +#define G_NODE_IS_ROOT(node) \ + (((GNode*) (node))->parent == NULL && ((GNode*) (node))->prev == NULL \ + && ((GNode*) (node))->next == NULL) +#define g_once(once,func,arg) \ + (((once)->status == G_ONCE_STATUS_READY) ? (once)->retval : \ + g_once_impl ((once), (func), (arg))) +#define CLAMP(x,low,high) \ + (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x))) +#define G_STRUCT_OFFSET(struct_type,member) \ + ((glong) ((guint8*) &((struct_type*) 0)->member)) +#define G_STRUCT_MEMBER_P(struct_p,struct_offset) \ + ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) +#define GUINT16_SWAP_LE_BE_CONSTANT(val) \ + ((guint16) ( (guint16) ((guint16) (val) >> 8) | (guint16) ((guint16) \ + (val) << 8))) +#define GUINT32_SWAP_LE_BE_CONSTANT(val) \ + ((guint32) ( (((guint32) (val) & (guint32) 0x000000ffU) << 24) | \ + (((guint32) (val) & (guint32) 0x0000ff00U) << 8) | (((guint32) (val) & \ + (guint32) 0x00ff0000U) >> 8) | (((guint32) (val) & (guint32) \ + 0xff000000U) >> 24))) +#define GUINT32_SWAP_LE_PDP(val) \ + ((guint32) ( (((guint32) (val) & (guint32) 0x0000ffffU) << 16) | \ + (((guint32) (val) & (guint32) 0xffff0000U) >> 16))) +#define GUINT32_SWAP_BE_PDP(val) \ + ((guint32) ( (((guint32) (val) & (guint32) 0x00ff00ffU) << 8) | \ + (((guint32) (val) & (guint32) 0xff00ff00U) >> 8))) +#define GUINT64_SWAP_LE_BE_CONSTANT(val) \ + ((guint64) ( (((guint64) (val) & (guint64) G_GINT64_CONSTANT \ + (0x00000000000000ffU)) << 56) | (((guint64) (val) & (guint64) \ + G_GINT64_CONSTANT (0x000000000000ff00U)) << 40) | (((guint64) (val) & \ + (guint64) G_GINT64_CONSTANT (0x0000000000ff0000U)) << 24) | \ + (((guint64) (val) & (guint64) G_GINT64_CONSTANT (0x00000000ff000000U)) \ + << 8) | (((guint64) (val) & (guint64) G_GINT64_CONSTANT \ + (0x000000ff00000000U)) >> 8) | (((guint64) (val) & (guint64) \ + G_GINT64_CONSTANT (0x0000ff0000000000U)) >> 24) | (((guint64) (val) & \ + (guint64) G_GINT64_CONSTANT (0x00ff000000000000U)) >> 40) | \ + (((guint64) (val) & (guint64) G_GINT64_CONSTANT (0xff00000000000000U)) \ + >> 56))) +#define g_ascii_isalnum(c) \ + ((g_ascii_table[(guchar) (c)] & G_ASCII_ALNUM) != 0) +#define g_ascii_isalpha(c) \ + ((g_ascii_table[(guchar) (c)] & G_ASCII_ALPHA) != 0) +#define g_ascii_iscntrl(c) \ + ((g_ascii_table[(guchar) (c)] & G_ASCII_CNTRL) != 0) +#define g_ascii_isdigit(c) \ + ((g_ascii_table[(guchar) (c)] & G_ASCII_DIGIT) != 0) +#define g_ascii_isgraph(c) \ + ((g_ascii_table[(guchar) (c)] & G_ASCII_GRAPH) != 0) +#define g_ascii_islower(c) \ + ((g_ascii_table[(guchar) (c)] & G_ASCII_LOWER) != 0) +#define g_ascii_isprint(c) \ + ((g_ascii_table[(guchar) (c)] & G_ASCII_PRINT) != 0) +#define g_ascii_ispunct(c) \ + ((g_ascii_table[(guchar) (c)] & G_ASCII_PUNCT) != 0) +#define g_ascii_isspace(c) \ + ((g_ascii_table[(guchar) (c)] & G_ASCII_SPACE) != 0) +#define g_ascii_isupper(c) \ + ((g_ascii_table[(guchar) (c)] & G_ASCII_UPPER) != 0) +#define g_ascii_isxdigit(c) \ + ((g_ascii_table[(guchar) (c)] & G_ASCII_XDIGIT) != 0) +#define G_HOOK_ACTIVE(hook) \ + ((G_HOOK_FLAGS (hook) & G_HOOK_FLAG_ACTIVE) != 0) +#define G_HOOK_IN_CALL(hook) \ + ((G_HOOK_FLAGS (hook) & G_HOOK_FLAG_IN_CALL) != 0) +#define g_node_first_child(node) \ + ((node) ? ((GNode*) (node))->children : NULL) +#define g_node_next_sibling(node) \ + ((node) ? ((GNode*) (node))->next : NULL) +#define g_node_prev_sibling(node) \ + ((node) ? ((GNode*) (node))->prev : NULL) +#define g_new(struct_type,n_structs) \ + ((struct_type *) g_malloc (((gsize) sizeof (struct_type)) * ((gsize) \ + (n_structs)))) +#define g_new0(struct_type,n_structs) \ + ((struct_type *) g_malloc0 (((gsize) sizeof (struct_type)) * ((gsize) \ + (n_structs)))) +#define g_renew(struct_type,mem,n_structs) \ + ((struct_type *) g_realloc ((mem), ((gsize) sizeof (struct_type)) * \ + ((gsize) (n_structs)))) +#define g_newa(struct_type,n_structs) \ + ((struct_type*) g_alloca (sizeof (struct_type) * (gsize) \ + (n_structs))) +#define G_STRUCT_MEMBER(member_type,struct_p,struct_offset) \ + (*(member_type*) G_STRUCT_MEMBER_P ((struct_p), (struct_offset))) +#define G_THREAD_UF(op,arglist) \ + (*g_thread_functions_for_glib_use . op) arglist +#define GLIB_CHECK_VERSION(major,minor,micro) \ + (GLIB_MAJOR_VERSION > (major) || (GLIB_MAJOR_VERSION == (major) && \ + GLIB_MINOR_VERSION > (minor)) || (GLIB_MAJOR_VERSION == (major) && \ + GLIB_MINOR_VERSION == (minor) && GLIB_MICRO_VERSION >= (micro))) +#define g_atomic_int_dec_and_test(atomic) \ + (g_atomic_int_exchange_and_add ((atomic), -1) == 1) +#define g_static_mutex_get_mutex_impl_shortcut(mutex) \ + (g_atomic_pointer_get ((gpointer*)mutex) ? *(mutex) : \ + g_static_mutex_get_mutex_impl (mutex)) +#define g_datalist_get_data(dl,k) \ + (g_datalist_id_get_data ((dl), g_quark_try_string (k))) +#define g_dataset_get_data(l,k) \ + (g_dataset_id_get_data ((l), g_quark_try_string (k))) +#define G_HOOK_IS_VALID(hook) \ + (G_HOOK (hook)->hook_id != 0 && (G_HOOK_FLAGS (hook) & \ + G_HOOK_FLAG_ACTIVE)) +#define G_HOOK_IS_UNLINKED(hook) \ + (G_HOOK (hook)->next == NULL && G_HOOK (hook)->prev == NULL && G_HOOK \ + (hook)->hook_id == 0 && G_HOOK (hook)->ref_count == 0) +#define g_thread_create(func,data,joinable,error) \ + (g_thread_create_full (func, data, 0, joinable, FALSE, \ + G_THREAD_PRIORITY_NORMAL, error)) +#define G_THREAD_ECF(op,fail,mutex,type) \ + (g_thread_supported () ? ((type(*)(GMutex*, gulong, gchar*)) \ + (*g_thread_functions_for_glib_use . op)) (mutex, G_MUTEX_DEBUG_MAGIC, \ + G_STRLOC) : (fail)) +#define G_THREAD_CF(op,fail,arg) \ + (g_thread_supported () ? G_THREAD_UF (op, arg) : (fail)) +#define g_static_mutex_get_mutex(mutex) \ + (g_thread_use_default_impl ? ((GMutex*) &((mutex)->static_mutex)) : \ + g_static_mutex_get_mutex_impl_shortcut (&((mutex)->runtime_mutex))) +#define G_LOCK_DEFINE(name) \ + GStaticMutex G_LOCK_NAME (name) = G_STATIC_MUTEX_INIT +#define g_datalist_remove_no_notify(dl,k) \ + g_datalist_id_remove_no_notify ((dl), g_quark_try_string (k)) +#define g_datalist_id_remove_data(dl,q) \ + g_datalist_id_set_data ((dl), (q), NULL) +#define g_datalist_remove_data(dl,k) \ + g_datalist_id_set_data ((dl), g_quark_try_string (k), NULL) +#define g_datalist_id_set_data(dl,q,d) \ + g_datalist_id_set_data_full ((dl), (q), (d), NULL) +#define g_datalist_set_data_full(dl,k,d,f) \ + g_datalist_id_set_data_full ((dl), g_quark_from_string (k), (d), (f)) +#define g_datalist_set_data(dl,k,d) \ + g_datalist_set_data_full ((dl), (k), (d), NULL) +#define g_dataset_remove_no_notify(l,k) \ + g_dataset_id_remove_no_notify ((l), g_quark_try_string (k)) +#define g_dataset_id_remove_data(l,k) \ + g_dataset_id_set_data ((l), (k), NULL) +#define g_dataset_remove_data(l,k) \ + g_dataset_id_set_data ((l), g_quark_try_string (k), NULL) +#define g_dataset_id_set_data(l,k,d) \ + g_dataset_id_set_data_full ((l), (k), (d), NULL) +#define g_dataset_set_data_full(l,k,d,f) \ + g_dataset_id_set_data_full ((l), g_quark_from_string (k), (d), (f)) +#define g_dataset_set_data(l,k,d) \ + g_dataset_set_data_full ((l), (k), (d), NULL) +#define g_hook_append(hook_list,hook) \ + g_hook_insert_before ((hook_list), NULL, (hook)) +#define g_critical(...) \ + g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, __VA_ARGS__) +#define g_message(...) \ + g_log (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, __VA_ARGS__) +#define g_warning(...) \ + g_log (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, __VA_ARGS__) +#define g_static_mutex_lock(mutex) \ + g_mutex_lock (g_static_mutex_get_mutex (mutex)) +#define g_static_mutex_trylock(mutex) \ + g_mutex_trylock (g_static_mutex_get_mutex (mutex)) +#define g_static_mutex_unlock(mutex) \ + g_mutex_unlock (g_static_mutex_get_mutex (mutex)) +#define g_node_insert_data(parent,position,data) \ + g_node_insert ((parent), (position), g_node_new (data)) +#define g_node_insert_data_before(parent,sibling,data) \ + g_node_insert_before ((parent), (sibling), g_node_new (data)) +#define g_node_append(parent,node) \ + g_node_insert_before ((parent), NULL, (node)) +#define g_node_append_data(parent,data) \ + g_node_insert_before ((parent), NULL, g_node_new (data)) +#define g_node_prepend_data(parent,data) \ + g_node_prepend ((parent), g_node_new (data)) +#define g_chunk_free(mem,mem_chunk) \ + G_STMT_START { g_mem_chunk_free ((mem_chunk), (mem)); } G_STMT_END +#define g_memmove(d,s,n) \ + G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END +#define g_assert_not_reached() \ + G_STMT_START{ g_assert_warning (G_LOG_DOMAIN, __FILE__, __LINE__, \ + __PRETTY_FUNCTION__, NULL); }G_STMT_END +#define g_return_val_if_reached(val) \ + G_STMT_START{ g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "file %s: \ + line %d (%s): should not be reached", __FILE__, __LINE__, \ + __PRETTY_FUNCTION__); return (val); }G_STMT_END +#define g_return_if_reached() \ + G_STMT_START{ g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "file %s: \ + line %d (%s): should not be reached", __FILE__, __LINE__, \ + __PRETTY_FUNCTION__); return; }G_STMT_END +#define g_assert(expr) \ + G_STMT_START{ if G_LIKELY(expr) { } else g_assert_warning \ + (G_LOG_DOMAIN, __FILE__, __LINE__, __PRETTY_FUNCTION__, #expr); \ + }G_STMT_END +#define g_return_val_if_fail(expr,val) \ + G_STMT_START{ if G_LIKELY(expr) { } else { g_return_if_fail_warning \ + (G_LOG_DOMAIN, __PRETTY_FUNCTION__, #expr); return (val); }; \ + }G_STMT_END +#define g_return_if_fail(expr) \ + G_STMT_START{ if G_LIKELY(expr) { } else { g_return_if_fail_warning \ + (G_LOG_DOMAIN, __PRETTY_FUNCTION__, #expr); return; }; }G_STMT_END +#define G_BREAKPOINT() \ + G_STMT_START{ __asm__ __volatile__ ("int $03"); }G_STMT_END +#define g_cond_broadcast(cond) \ + G_THREAD_CF (cond_broadcast, (void)0, (cond)) +#define g_cond_timed_wait(cond,mutex,abs_time) \ + G_THREAD_CF (cond_timed_wait, TRUE, (cond, mutex, abs_time)) +#define g_cond_wait(cond,mutex) \ + G_THREAD_CF (cond_wait, (void)0, (cond, mutex)) +#define g_private_get(private_key) \ + G_THREAD_CF (private_get, ((gpointer)private_key), (private_key)) +#define g_private_set(private_key,value) \ + G_THREAD_CF (private_set, (void) (private_key = (GPrivate*) (value)), \ + (private_key, value)) +#define G_GNUC_PRINTF(format_idx,arg_idx) \ + __attribute__((__format__ (__printf__, format_idx, arg_idx))) +#define G_GNUC_SCANF(format_idx,arg_idx) \ + __attribute__((__format__ (__scanf__, format_idx, arg_idx))) +#define G_STATIC_RW_LOCK_INIT \ + { G_STATIC_MUTEX_INIT, NULL, NULL, 0, FALSE, 0, 0 } +#if __ia64__ +#define G_STATIC_MUTEX_INIT \ + { NULL, { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} } } +#endif +#if __powerpc64__ +#define G_STATIC_MUTEX_INIT \ + { NULL, { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} } } +#endif +#if __x86_64__ +#define G_STATIC_MUTEX_INIT \ + { NULL, { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} } } +#endif +#if __s390x__ +#define G_STATIC_MUTEX_INIT \ + { NULL, { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} } } +#endif +#if __i386__ +#define G_STATIC_MUTEX_INIT \ + { NULL, { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} } } +#endif +#if __powerpc__ && !__powerpc64__ +#define G_STATIC_MUTEX_INIT \ + { NULL, { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} } } +#endif +#if __s390__ && !__s390x__ +#define G_STATIC_MUTEX_INIT \ + { NULL, { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} } } +#endif +#define G_STRINGIFY_ARG(contents) #contents +#define G_DIR_SEPARATOR '/' +#define g_chunk_new(type,chunk) ( (type *) g_mem_chunk_alloc (chunk) ) +#define g_chunk_new0(type,chunk) ( (type *) g_mem_chunk_alloc0 (chunk) ) +#define MIN(a,b) (((a) < (b)) ? (a) : (b)) +#define ABS(a) (((a) < 0) ? -(a) : (a)) +#define MAX(a,b) (((a) > (b)) ? (a) : (b)) +#define G_NODE_IS_LEAF(node) (((GNode*) (node))->children == NULL) +#define g_array_index(a,t,i) (((t*) (a)->data) [(i)]) +#define g_ptr_array_index(array,index_) ((array)->pdata)[index_] +#define G_IS_DIR_SEPARATOR(c) ((c) == G_DIR_SEPARATOR) +#define G_STRFUNC ((const char*) (__PRETTY_FUNCTION__)) +#define G_LOG_DOMAIN ((gchar*) 0) +#define G_HOOK(hook) ((GHook*) (hook)) +#if __i386__ +#define GPOINTER_TO_INT(p) ((gint) (p)) +#endif +#if __powerpc__ && !__powerpc64__ +#define GPOINTER_TO_INT(p) ((gint) (p)) +#endif +#if __s390__ && !__s390x__ +#define GPOINTER_TO_INT(p) ((gint) (p)) +#endif +#define GINT_TO_BE(val) ((gint) GINT32_TO_BE (val)) +#define GINT_TO_LE(val) ((gint) GINT32_TO_LE (val)) +#define GINT16_TO_LE(val) ((gint16) (val)) +#define G_MAXINT16 ((gint16) 0x7fff) +#define G_MININT16 ((gint16) 0x8000) +#define GINT16_TO_BE(val) ((gint16) GUINT16_SWAP_LE_BE (val)) +#define GINT32_TO_LE(val) ((gint32) (val)) +#define G_MAXINT32 ((gint32) 0x7fffffff) +#define G_MININT32 ((gint32) 0x80000000) +#define GINT32_TO_BE(val) ((gint32) GUINT32_SWAP_LE_BE (val)) +#define GINT64_TO_LE(val) ((gint64) (val)) +#define GINT64_TO_BE(val) ((gint64) GUINT64_SWAP_LE_BE (val)) +#define G_MAXINT8 ((gint8) 0x7f) +#define G_MININT8 ((gint8) 0x80) +#if __ia64__ +#define GPOINTER_TO_INT(p) ((glong) (p)) +#endif +#if __powerpc64__ +#define GPOINTER_TO_INT(p) ((glong) (p)) +#endif +#if __x86_64__ +#define GPOINTER_TO_INT(p) ((glong) (p)) +#endif +#if __s390x__ +#define GPOINTER_TO_INT(p) ((glong) (p)) +#endif +#if __i386__ +#define GLONG_TO_BE(val) ((glong) GINT32_TO_BE (val)) +#endif +#if __powerpc__ && !__powerpc64__ +#define GLONG_TO_BE(val) ((glong) GINT32_TO_BE (val)) +#endif +#if __s390__ && !__s390x__ +#define GLONG_TO_BE(val) ((glong) GINT32_TO_BE (val)) +#endif +#if __i386__ +#define GLONG_TO_LE(val) ((glong) GINT32_TO_LE (val)) +#endif +#if __powerpc__ && !__powerpc64__ +#define GLONG_TO_LE(val) ((glong) GINT32_TO_LE (val)) +#endif +#if __s390__ && !__s390x__ +#define GLONG_TO_LE(val) ((glong) GINT32_TO_LE (val)) +#endif +#if __ia64__ +#define GLONG_TO_BE(val) ((glong) GINT64_TO_BE (val)) +#endif +#if __powerpc64__ +#define GLONG_TO_BE(val) ((glong) GINT64_TO_BE (val)) +#endif +#if __x86_64__ +#define GLONG_TO_BE(val) ((glong) GINT64_TO_BE (val)) +#endif +#if __s390x__ +#define GLONG_TO_BE(val) ((glong) GINT64_TO_BE (val)) +#endif +#if __ia64__ +#define GLONG_TO_LE(val) ((glong) GINT64_TO_LE (val)) +#endif +#if __powerpc64__ +#define GLONG_TO_LE(val) ((glong) GINT64_TO_LE (val)) +#endif +#if __x86_64__ +#define GLONG_TO_LE(val) ((glong) GINT64_TO_LE (val)) +#endif +#if __s390x__ +#define GLONG_TO_LE(val) ((glong) GINT64_TO_LE (val)) +#endif +#if __ia64__ +#define GINT_TO_POINTER(i) ((gpointer) (glong) (i)) +#endif +#if __powerpc64__ +#define GINT_TO_POINTER(i) ((gpointer) (glong) (i)) +#endif +#if __x86_64__ +#define GINT_TO_POINTER(i) ((gpointer) (glong) (i)) +#endif +#if __s390x__ +#define GINT_TO_POINTER(i) ((gpointer) (glong) (i)) +#endif +#define GSIZE_TO_POINTER(s) ((gpointer) (gsize) (s)) +#if __ia64__ +#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) +#endif +#if __powerpc64__ +#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) +#endif +#if __x86_64__ +#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) +#endif +#if __s390x__ +#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) +#endif +#if __i386__ +#define GINT_TO_POINTER(i) ((gpointer) (i)) +#endif +#if __powerpc__ && !__powerpc64__ +#define GINT_TO_POINTER(i) ((gpointer) (i)) +#endif +#if __s390__ && !__s390x__ +#define GINT_TO_POINTER(i) ((gpointer) (i)) +#endif +#if __i386__ +#define GUINT_TO_POINTER(u) ((gpointer) (u)) +#endif +#if __powerpc__ && !__powerpc64__ +#define GUINT_TO_POINTER(u) ((gpointer) (u)) +#endif +#if __s390__ && !__s390x__ +#define GUINT_TO_POINTER(u) ((gpointer) (u)) +#endif +#define GPOINTER_TO_SIZE(p) ((gsize) (p)) +#if __i386__ +#define GPOINTER_TO_UINT(p) ((guint) (p)) +#endif +#if __powerpc__ && !__powerpc64__ +#define GPOINTER_TO_UINT(p) ((guint) (p)) +#endif +#if __s390__ && !__s390x__ +#define GPOINTER_TO_UINT(p) ((guint) (p)) +#endif +#define GUINT_TO_BE(val) ((guint) GUINT32_TO_BE (val)) +#define GUINT_TO_LE(val) ((guint) GUINT32_TO_LE (val)) +#define GUINT16_SWAP_LE_PDP(val) ((guint16) (val)) +#define GUINT16_TO_LE(val) ((guint16) (val)) +#define G_MAXUINT16 ((guint16) 0xffff) +#define GUINT32_TO_LE(val) ((guint32) (val)) +#define G_MAXUINT32 ((guint32) 0xffffffff) +#define GUINT64_TO_LE(val) ((guint64) (val)) +#define G_MAXUINT8 ((guint8) 0xff) +#if __ia64__ +#define GPOINTER_TO_UINT(p) ((gulong) (p)) +#endif +#if __powerpc64__ +#define GPOINTER_TO_UINT(p) ((gulong) (p)) +#endif +#if __x86_64__ +#define GPOINTER_TO_UINT(p) ((gulong) (p)) +#endif +#if __s390x__ +#define GPOINTER_TO_UINT(p) ((gulong) (p)) +#endif +#if __i386__ +#define GULONG_TO_BE(val) ((gulong) GUINT32_TO_BE (val)) +#endif +#if __powerpc__ && !__powerpc64__ +#define GULONG_TO_BE(val) ((gulong) GUINT32_TO_BE (val)) +#endif +#if __s390__ && !__s390x__ +#define GULONG_TO_BE(val) ((gulong) GUINT32_TO_BE (val)) +#endif +#if __i386__ +#define GULONG_TO_LE(val) ((gulong) GUINT32_TO_LE (val)) +#endif +#if __powerpc__ && !__powerpc64__ +#define GULONG_TO_LE(val) ((gulong) GUINT32_TO_LE (val)) +#endif +#if __s390__ && !__s390x__ +#define GULONG_TO_LE(val) ((gulong) GUINT32_TO_LE (val)) +#endif +#if __ia64__ +#define GULONG_TO_BE(val) ((gulong) GUINT64_TO_BE (val)) +#endif +#if __powerpc64__ +#define GULONG_TO_BE(val) ((gulong) GUINT64_TO_BE (val)) +#endif +#if __x86_64__ +#define GULONG_TO_BE(val) ((gulong) GUINT64_TO_BE (val)) +#endif +#if __s390x__ +#define GULONG_TO_BE(val) ((gulong) GUINT64_TO_BE (val)) +#endif +#if __ia64__ +#define GULONG_TO_LE(val) ((gulong) GUINT64_TO_LE (val)) +#endif +#if __powerpc64__ +#define GULONG_TO_LE(val) ((gulong) GUINT64_TO_LE (val)) +#endif +#if __x86_64__ +#define GULONG_TO_LE(val) ((gulong) GUINT64_TO_LE (val)) +#endif +#if __s390x__ +#define GULONG_TO_LE(val) ((gulong) GUINT64_TO_LE (val)) +#endif +#define g_random_boolean() ((g_random_int () & (1 << 15)) != 0) +#define g_rand_boolean(rand_) ((g_rand_int (rand_) & (1 << 15)) != 0) +#define g_list_next(list) ((list) ? (((GList *)(list))->next) : NULL) +#define g_list_previous(list) ((list) ? (((GList *)(list))->prev) : NULL) +#define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL) +#define g_atomic_int_get(atomic) (*(atomic)) +#define g_atomic_pointer_get(atomic) (*(atomic)) +#define G_LOG_2_BASE_10 (0.30102999566398119521) +#define G_ALLOCATOR_LIST (1) +#define G_IEEE754_DOUBLE_BIAS (1023) +#define G_IEEE754_FLOAT_BIAS (127) +#define G_ALLOCATOR_SLIST (2) +#define G_ASCII_DTOSTR_BUF_SIZE (29 + 10) +#define G_ALLOCATOR_NODE (3) +#define G_HOOK_FLAG_USER_SHIFT (4) +#define G_LOG_LEVEL_USER_SHIFT (8) +#define g_ATEXIT(proc) (atexit (proc)) +#define g_utf8_next_char(p) (char *)((p) + g_utf8_skip[*(guchar *)(p)]) +#define G_LIKELY(expr) (expr) +#define G_UNLIKELY(expr) (expr) +#define GINT16_FROM_BE(val) (GINT16_TO_BE (val)) +#define GINT16_FROM_LE(val) (GINT16_TO_LE (val)) +#define GINT32_FROM_BE(val) (GINT32_TO_BE (val)) +#define GINT32_FROM_LE(val) (GINT32_TO_LE (val)) +#define GINT64_FROM_BE(val) (GINT64_TO_BE (val)) +#define GINT64_FROM_LE(val) (GINT64_TO_LE (val)) +#define GINT_FROM_BE(val) (GINT_TO_BE (val)) +#define GINT_FROM_LE(val) (GINT_TO_LE (val)) +#define GLONG_FROM_BE(val) (GLONG_TO_BE (val)) +#define GLONG_FROM_LE(val) (GLONG_TO_LE (val)) +#define g_ntohs(val) (GUINT16_FROM_BE (val)) +#define GUINT16_SWAP_BE_PDP(val) (GUINT16_SWAP_LE_BE (val)) +#define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val)) +#define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val)) +#define GUINT16_FROM_BE(val) (GUINT16_TO_BE (val)) +#define g_htons(val) (GUINT16_TO_BE (val)) +#define GUINT16_FROM_LE(val) (GUINT16_TO_LE (val)) +#define g_ntohl(val) (GUINT32_FROM_BE (val)) +#define GUINT32_TO_BE(val) (GUINT32_SWAP_LE_BE (val)) +#define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_CONSTANT (val)) +#define GUINT32_FROM_BE(val) (GUINT32_TO_BE (val)) +#define g_htonl(val) (GUINT32_TO_BE (val)) +#define GUINT32_FROM_LE(val) (GUINT32_TO_LE (val)) +#define GUINT64_TO_BE(val) (GUINT64_SWAP_LE_BE (val)) +#define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_CONSTANT (val)) +#define GUINT64_FROM_BE(val) (GUINT64_TO_BE (val)) +#define GUINT64_FROM_LE(val) (GUINT64_TO_LE (val)) +#define GUINT_FROM_BE(val) (GUINT_TO_BE (val)) +#define GUINT_FROM_LE(val) (GUINT_TO_LE (val)) +#define GULONG_FROM_BE(val) (GULONG_TO_BE (val)) +#define GULONG_FROM_LE(val) (GULONG_TO_LE (val)) +#define g_atomic_int_inc(atomic) (g_atomic_int_add ((atomic), 1)) +#if __ia64__ +#define G_GINT64_CONSTANT(val) (G_GNUC_EXTENSION (val ##L)) +#endif +#if __powerpc64__ +#define G_GINT64_CONSTANT(val) (G_GNUC_EXTENSION (val ##L)) +#endif +#if __x86_64__ +#define G_GINT64_CONSTANT(val) (G_GNUC_EXTENSION (val ##L)) +#endif +#if __s390x__ +#define G_GINT64_CONSTANT(val) (G_GNUC_EXTENSION (val ##L)) +#endif +#if __i386__ +#define G_GINT64_CONSTANT(val) (G_GNUC_EXTENSION (val ##LL)) +#endif +#if __powerpc__ && !__powerpc64__ +#define G_GINT64_CONSTANT(val) (G_GNUC_EXTENSION (val ##LL)) +#endif +#if __s390__ && !__s390x__ +#define G_GINT64_CONSTANT(val) (G_GNUC_EXTENSION (val ##LL)) +#endif +#define G_HOOK_FLAGS(hook) (G_HOOK (hook)->flags) +#define G_LOG_FATAL_MASK (G_LOG_FLAG_RECURSION | G_LOG_LEVEL_ERROR) +#define G_OPTION_ERROR (g_option_error_quark ()) +#define g_thread_supported() (g_threads_got_initialized) +#define G_N_ELEMENTS(arr) (sizeof (arr) / sizeof ((arr)[0])) +#define G_STMT_START (void) __extension__ ( +#define G_STMT_END ) +#define G_PRIORITY_HIGH -100 +#define G_DIR_SEPARATOR_S "/" +#define G_HAVE_GROWING_STACK 0 +#define G_PRIORITY_DEFAULT 0 +#define G_LN2 0.69314718055994530941723212145817656807550013436026 +#define G_PI_4 0.78539816339744830961566084581987572104929234984378 +#define G_CSET_DIGITS "0123456789" +#define G_DATE_BAD_DAY 0U +#define G_DATE_BAD_JULIAN 0U +#define G_DATE_BAD_YEAR 0U +#define G_MUTEX_DEBUG_MAGIC 0xf8e18ad7 +#define G_ALLOC_ONLY 1 +#define G_CAN_INLINE 1 +#define G_HAVE_GINT64 1 +#define G_HAVE_GNUC_VARARGS 1 +#define G_HAVE_GNUC_VISIBILITY 1 +#define G_HAVE_INLINE 1 +#define G_HAVE_ISO_VARARGS 1 +#define G_HAVE___INLINE 1 +#define G_HAVE___INLINE__ 1 +#if __ia64__ +#define G_VA_COPY_AS_ARRAY 1 +#endif +#if __powerpc__ && !__powerpc64__ +#define G_VA_COPY_AS_ARRAY 1 +#endif +#if __powerpc64__ +#define G_VA_COPY_AS_ARRAY 1 +#endif +#if __s390__ && !__s390x__ +#define G_VA_COPY_AS_ARRAY 1 +#endif +#if __x86_64__ +#define G_VA_COPY_AS_ARRAY 1 +#endif +#if __s390x__ +#define G_VA_COPY_AS_ARRAY 1 +#endif +#define G_SQRT2 1.4142135623730950488016887242096980785696718753769 +#define G_PI_2 1.5707963267948966192313216916397514420985846996876 +#define G_PRIORITY_HIGH_IDLE 100 +#define G_USEC_PER_SEC 1000000 +#define G_LITTLE_ENDIAN 1234 +#define GLIB_MAJOR_VERSION 2 +#define G_ALLOC_AND_FREE 2 +#define G_LN10 2.3025850929940456840179914546843642076011014886288 +#define G_E 2.7182818284590452353602874713526624977572470937000 +#define G_PRIORITY_DEFAULT_IDLE 200 +#if __i386__ +#define GLIB_LSB_PADDING_SIZE 24 +#endif +#if __powerpc__ && !__powerpc64__ +#define GLIB_LSB_PADDING_SIZE 24 +#endif +#if __s390__ && !__s390x__ +#define GLIB_LSB_PADDING_SIZE 24 +#endif +#define G_PI 3.1415926535897932384626433832795028841971693993751 +#define G_PRIORITY_LOW 300 +#define G_PDP_ENDIAN 3412 +#if __i386__ +#define GLIB_LSB_DATA_SIZE 4 +#endif +#if __powerpc__ && !__powerpc64__ +#define GLIB_LSB_DATA_SIZE 4 +#endif +#if __s390__ && !__s390x__ +#define GLIB_LSB_DATA_SIZE 4 +#endif +#if __i386__ +#define GLIB_SIZEOF_LONG 4 +#endif +#if __powerpc__ && !__powerpc64__ +#define GLIB_SIZEOF_LONG 4 +#endif +#if __s390__ && !__s390x__ +#define GLIB_SIZEOF_LONG 4 +#endif +#if __i386__ +#define GLIB_SIZEOF_SIZE_T 4 +#endif +#if __powerpc__ && !__powerpc64__ +#define GLIB_SIZEOF_SIZE_T 4 +#endif +#if __s390__ && !__s390x__ +#define GLIB_SIZEOF_SIZE_T 4 +#endif +#if __i386__ +#define GLIB_SIZEOF_VOID_P 4 +#endif +#if __powerpc__ && !__powerpc64__ +#define GLIB_SIZEOF_VOID_P 4 +#endif +#if __s390__ && !__s390x__ +#define GLIB_SIZEOF_VOID_P 4 +#endif +#if __ia64__ +#define GLIB_LSB_PADDING_SIZE 40 +#endif +#if __powerpc64__ +#define GLIB_LSB_PADDING_SIZE 40 +#endif +#if __x86_64__ +#define GLIB_LSB_PADDING_SIZE 40 +#endif +#if __s390x__ +#define GLIB_LSB_PADDING_SIZE 40 +#endif +#define G_BIG_ENDIAN 4321 +#define GLIB_MICRO_VERSION 6 +#define GLIB_MINOR_VERSION 6 +#if __ia64__ +#define GLIB_LSB_DATA_SIZE 8 +#endif +#if __powerpc64__ +#define GLIB_LSB_DATA_SIZE 8 +#endif +#if __x86_64__ +#define GLIB_LSB_DATA_SIZE 8 +#endif +#if __s390x__ +#define GLIB_LSB_DATA_SIZE 8 +#endif +#if __ia64__ +#define GLIB_SIZEOF_LONG 8 +#endif +#if __powerpc64__ +#define GLIB_SIZEOF_LONG 8 +#endif +#if __x86_64__ +#define GLIB_SIZEOF_LONG 8 +#endif +#if __s390x__ +#define GLIB_SIZEOF_LONG 8 +#endif +#if __ia64__ +#define GLIB_SIZEOF_SIZE_T 8 +#endif +#if __powerpc64__ +#define GLIB_SIZEOF_SIZE_T 8 +#endif +#if __x86_64__ +#define GLIB_SIZEOF_SIZE_T 8 +#endif +#if __s390x__ +#define GLIB_SIZEOF_SIZE_T 8 +#endif +#if __ia64__ +#define GLIB_SIZEOF_VOID_P 8 +#endif +#if __powerpc64__ +#define GLIB_SIZEOF_VOID_P 8 +#endif +#if __x86_64__ +#define GLIB_SIZEOF_VOID_P 8 +#endif +#if __s390x__ +#define GLIB_SIZEOF_VOID_P 8 +#endif +#define G_SEARCHPATH_SEPARATOR : +#define G_SEARCHPATH_SEPARATOR_S ":" +#define GLIB_SYSDEF_POLLIN =1 +#define GLIB_SYSDEF_POLLHUP =16 +#define GLIB_SYSDEF_POLLPRI =2 +#define GLIB_SYSDEF_POLLNVAL =32 +#define GLIB_SYSDEF_POLLOUT =4 +#define GLIB_SYSDEF_POLLERR =8 +#define G_CSET_A_2_Z "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +#define G_CSET_a_2_z "abcdefghijklmnopqrstuvwxyz" +#define g_alloca(size) alloca (size) +#define G_CONST_RETURN const +#define G_MAXDOUBLE DBL_MAX +#define G_MINDOUBLE DBL_MIN +#define GLIB_VAR extern +#define G_LOCK_EXTERN(name) extern GStaticMutex G_LOCK_NAME (name) +#define G_INLINE_FUNC extern inline +#define G_MAXFLOAT FLT_MAX +#define G_MINFLOAT FLT_MIN +#define G_MEM_ALIGN GLIB_SIZEOF_LONG +#define g_array_append_val(a,v) g_array_append_vals (a, &(v), 1) +#define g_array_insert_val(a,i,v) g_array_insert_vals (a, i, &(v), 1) +#define g_array_prepend_val(a,v) g_array_prepend_vals (a, &(v), 1) +#define ATEXIT(proc) g_ATEXIT(proc) +#if __powerpc__ && !__powerpc64__ +#define G_BYTE_ORDER G_BIG_ENDIAN +#endif +#if __powerpc64__ +#define G_BYTE_ORDER G_BIG_ENDIAN +#endif +#if __s390__ && !__s390x__ +#define G_BYTE_ORDER G_BIG_ENDIAN +#endif +#if __s390x__ +#define G_BYTE_ORDER G_BIG_ENDIAN +#endif +#define G_CONVERT_ERROR g_convert_error_quark() +#define g_date_day g_date_get_day +#define g_date_days_in_month g_date_get_days_in_month +#define g_date_day_of_year g_date_get_day_of_year +#define g_date_julian g_date_get_julian +#define g_date_monday_weeks_in_year g_date_get_monday_weeks_in_year +#define g_date_monday_week_of_year g_date_get_monday_week_of_year +#define g_date_month g_date_get_month +#define g_date_sunday_weeks_in_year g_date_get_sunday_weeks_in_year +#define g_date_sunday_week_of_year g_date_get_sunday_week_of_year +#define g_date_weekday g_date_get_weekday +#define g_date_year g_date_get_year +#define G_FILE_ERROR g_file_error_quark () +#define G_MAXINT64 G_GINT64_CONSTANT(0x7fffffffffffffff) +#define G_MININT64 G_GINT64_CONSTANT(0x8000000000000000) +#define G_MAXUINT64 G_GINT64_CONSTANT(0xffffffffffffffffU) +#define G_IO_CHANNEL_ERROR g_io_channel_error_quark() +#define G_KEY_FILE_ERROR g_key_file_error_quark() +#if __i386__ +#define G_BYTE_ORDER G_LITTLE_ENDIAN +#endif +#if __ia64__ +#define G_BYTE_ORDER G_LITTLE_ENDIAN +#endif +#if __x86_64__ +#define G_BYTE_ORDER G_LITTLE_ENDIAN +#endif +#define g_debug(...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, __VA_ARGS__) +#define g_error(...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, __VA_ARGS__) +#define G_MARKUP_ERROR g_markup_error_quark () +#if __i386__ +#define G_MAXSIZE G_MAXUINT +#endif +#if __powerpc__ && !__powerpc64__ +#define G_MAXSIZE G_MAXUINT +#endif +#if __s390__ && !__s390x__ +#define G_MAXSIZE G_MAXUINT +#endif +#if __ia64__ +#define G_MAXSIZE G_MAXULONG +#endif +#if __powerpc64__ +#define G_MAXSIZE G_MAXULONG +#endif +#if __x86_64__ +#define G_MAXSIZE G_MAXULONG +#endif +#if __s390x__ +#define G_MAXSIZE G_MAXULONG +#endif +#define G_SHELL_ERROR g_shell_error_quark () +#define G_SPAWN_ERROR g_spawn_error_quark () +#define G_LOCK(name) g_static_mutex_lock (&G_LOCK_NAME (name)) +#define G_TRYLOCK(name) g_static_mutex_trylock (&G_LOCK_NAME (name)) +#define G_UNLOCK(name) g_static_mutex_unlock (&G_LOCK_NAME (name)) +#define g_strstrip(string) g_strchomp (g_strchug (string)) +#define G_STRINGIFY(macro_or_string) G_STRINGIFY_ARG (macro_or_string) +#define g_cond_free(cond) G_THREAD_CF (cond_free, (void)0, (cond)) +#define g_cond_signal(cond) G_THREAD_CF (cond_signal, (void)0, (cond)) +#define g_mutex_free(mutex) G_THREAD_CF (mutex_free, (void)0, (mutex)) +#define g_mutex_lock(mutex) G_THREAD_CF (mutex_lock, (void)0, (mutex)) +#define g_mutex_trylock(mutex) G_THREAD_CF (mutex_trylock, TRUE, (mutex)) +#define g_mutex_unlock(mutex) G_THREAD_CF (mutex_unlock, (void)0, (mutex)) +#define g_thread_yield() G_THREAD_CF (thread_yield, (void)0, ()) +#define G_THREAD_ERROR g_thread_error_quark () +#define g_cond_new() G_THREAD_UF (cond_new, ()) +#define g_mutex_new() G_THREAD_UF (mutex_new, ()) +#define g_private_new(destructor) G_THREAD_UF (private_new, (destructor)) +#define G_LOCK_NAME(name) g__ ## name ## _lock +#define G_GINT16_MODIFIER "h" +#define G_GINT16_FORMAT "hi" +#define G_GUINT16_FORMAT "hu" +#define G_GINT32_FORMAT "i" +#if __i386__ +#define G_GSSIZE_FORMAT "i" +#endif +#if __powerpc__ && !__powerpc64__ +#define G_GSSIZE_FORMAT "i" +#endif +#if __s390__ && !__s390x__ +#define G_GSSIZE_FORMAT "i" +#endif +#define G_MAXINT INT_MAX +#define G_MININT INT_MIN +#if __ia64__ +#define G_GINT64_MODIFIER "l" +#endif +#if __powerpc64__ +#define G_GINT64_MODIFIER "l" +#endif +#if __x86_64__ +#define G_GINT64_MODIFIER "l" +#endif +#if __s390x__ +#define G_GINT64_MODIFIER "l" +#endif +#if __ia64__ +#define G_GSIZE_MODIFIER "l" +#endif +#if __powerpc64__ +#define G_GSIZE_MODIFIER "l" +#endif +#if __x86_64__ +#define G_GSIZE_MODIFIER "l" +#endif +#if __s390x__ +#define G_GSIZE_MODIFIER "l" +#endif +#if __ia64__ +#define G_GINT64_FORMAT "li" +#endif +#if __powerpc64__ +#define G_GINT64_FORMAT "li" +#endif +#if __x86_64__ +#define G_GINT64_FORMAT "li" +#endif +#if __s390x__ +#define G_GINT64_FORMAT "li" +#endif +#if __ia64__ +#define G_GSSIZE_FORMAT "li" +#endif +#if __powerpc64__ +#define G_GSSIZE_FORMAT "li" +#endif +#if __x86_64__ +#define G_GSSIZE_FORMAT "li" +#endif +#if __s390x__ +#define G_GSSIZE_FORMAT "li" +#endif +#if __i386__ +#define G_GINT64_MODIFIER "ll" +#endif +#if __powerpc__ && !__powerpc64__ +#define G_GINT64_MODIFIER "ll" +#endif +#if __s390__ && !__s390x__ +#define G_GINT64_MODIFIER "ll" +#endif +#if __i386__ +#define G_GINT64_FORMAT "lli" +#endif +#if __powerpc__ && !__powerpc64__ +#define G_GINT64_FORMAT "lli" +#endif +#if __s390__ && !__s390x__ +#define G_GINT64_FORMAT "lli" +#endif +#if __i386__ +#define G_GUINT64_FORMAT "llu" +#endif +#if __powerpc__ && !__powerpc64__ +#define G_GUINT64_FORMAT "llu" +#endif +#if __s390__ && !__s390x__ +#define G_GUINT64_FORMAT "llu" +#endif +#define G_MAXLONG LONG_MAX +#define G_MINLONG LONG_MIN +#if __ia64__ +#define G_GSIZE_FORMAT "lu" +#endif +#if __powerpc64__ +#define G_GSIZE_FORMAT "lu" +#endif +#if __x86_64__ +#define G_GSIZE_FORMAT "lu" +#endif +#if __s390x__ +#define G_GSIZE_FORMAT "lu" +#endif +#if __ia64__ +#define G_GUINT64_FORMAT "lu" +#endif +#if __powerpc64__ +#define G_GUINT64_FORMAT "lu" +#endif +#if __x86_64__ +#define G_GUINT64_FORMAT "lu" +#endif +#if __s390x__ +#define G_GUINT64_FORMAT "lu" +#endif +#define G_MAXSHORT SHRT_MAX +#define G_MINSHORT SHRT_MIN +#define G_MODULE_SUFFIX "so" +#define G_LOCK_DEFINE_STATIC(name) static G_LOCK_DEFINE (name) +#if __i386__ +#define G_GSIZE_FORMAT "u" +#endif +#if __powerpc__ && !__powerpc64__ +#define G_GSIZE_FORMAT "u" +#endif +#if __s390__ && !__s390x__ +#define G_GSIZE_FORMAT "u" +#endif +#define G_GUINT32_FORMAT "u" +#define G_MAXUINT UINT_MAX +#define G_MAXULONG ULONG_MAX +#define G_MAXUSHORT USHRT_MAX +#define G_VA_COPY va_copy +#define G_STR_DELIMITERS "_-|> <." +#define G_GNUC_INTERNAL __attribute__((visibility("hidden"))) +#define G_GNUC_CONST __attribute__((__const__)) +#define G_GNUC_DEPRECATED __attribute__((__deprecated__)) +#define G_GNUC_FORMAT(arg_idx) __attribute__((__format_arg__ (arg_idx))) +#define G_GNUC_MALLOC __attribute__((__malloc__)) +#define G_GNUC_NORETURN __attribute__((__noreturn__)) +#define G_GNUC_NO_INSTRUMENT __attribute__((__no_instrument_function__)) +#define G_GNUC_PURE __attribute__((__pure__)) +#define G_GNUC_UNUSED __attribute__((__unused__)) +#define alloca(size) __builtin_alloca (size) +#define G_GNUC_EXTENSION __extension__ +#define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__) +#define G_STATIC_PRIVATE_INIT { 0 } +#define G_ONCE_INIT { G_ONCE_STATUS_NOTCALLED, NULL } +#define G_STATIC_REC_MUTEX_INIT { G_STATIC_MUTEX_INIT } + + + +/* Arch Specific HeaderGroup for glib-2.0/glib.h*/ + + +#if __i386__ +/* IA32 */ + typedef int gssize; + +#endif +#if __i386__ +/* IA32 */ + typedef long long int gint64; + +#endif +#if __i386__ +/* IA32 */ + typedef long long unsigned int guint64; + +#endif +#if __ia64__ +/* IA64 */ + typedef long int gint64; + +#endif +#if __powerpc__ && !__powerpc64__ +/* PPC32 */ + typedef long long int gint64; + +#endif +#if __powerpc64__ +/* PPC64 */ + typedef long int gint64; + +#endif +#if __s390__ && !__s390x__ +/* S390 */ + typedef long long int gint64; + +#endif +#if __x86_64__ +/* x86-64 */ + typedef long int gint64; + +#endif +#if __s390x__ +/* S390X */ + typedef long int gint64; + +#endif +#if __ia64__ +/* IA64 */ + typedef unsigned long int guint64; + +#endif +#if __powerpc__ && !__powerpc64__ +/* PPC32 */ + typedef long long unsigned int guint64; + +#endif +#if __powerpc64__ +/* PPC64 */ + typedef unsigned long int guint64; + +#endif +#if __s390__ && !__s390x__ +/* S390 */ + typedef long long unsigned int guint64; + +#endif +#if __x86_64__ +/* x86-64 */ + typedef unsigned long int guint64; + +#endif +#if __s390x__ +/* S390X */ + typedef unsigned long int guint64; + +#endif +#if __ia64__ +/* IA64 */ + typedef long int gssize; + +#endif +#if __powerpc__ && !__powerpc64__ +/* PPC32 */ + typedef int gssize; + +#endif +#if __powerpc64__ +/* PPC64 */ + typedef long int gssize; + +#endif +#if __s390__ && !__s390x__ +/* S390 */ + typedef int gssize; + +#endif +#if __x86_64__ +/* x86-64 */ + typedef long int gssize; + +#endif +#if __s390x__ +/* S390X */ + typedef long int gssize; + +#endif +#if __ia64__ +/* IA64 */ + typedef unsigned long int gsize; + +#endif +#if __powerpc__ && !__powerpc64__ +/* PPC32 */ + typedef unsigned int gsize; + +#endif +#if __powerpc64__ +/* PPC64 */ + typedef unsigned long int gsize; + +#endif +#if __s390__ && !__s390x__ +/* S390 */ + typedef unsigned int gsize; + +#endif +#if __x86_64__ +/* x86-64 */ + typedef unsigned long int gsize; + +#endif +#if __s390x__ +/* S390X */ + typedef unsigned long int gsize; + +#endif + +/* Default HeaderGroup for glib-2.0/glib.h*/ + + + typedef short unsigned int guint16; + + typedef int gint; + + typedef gint gboolean; + + typedef unsigned int guint; + + typedef void *gpointer; + + typedef gpointer(*GThreadFunc) (gpointer); + + typedef enum { + G_THREAD_PRIORITY_LOW = 0, + G_THREAD_PRIORITY_NORMAL = 1, + G_THREAD_PRIORITY_HIGH = 2, + G_THREAD_PRIORITY_URGENT = 3 + } GThreadPriority; + + typedef struct _GThread GThread; + + typedef unsigned int guint32; + + typedef guint32 GQuark; + + typedef char gchar; + + typedef struct _GError GError; + + typedef void (*GPrintFunc) (const gchar *); + + typedef struct _GMemChunk GMemChunk; + + typedef long unsigned int gulong; + + typedef struct _GList GList; + + typedef struct _GMainLoop GMainLoop; + + typedef struct _GHook GHook; + + typedef void (*GDestroyNotify) (gpointer); + + typedef struct _GHookList GHookList; + + typedef void (*GHookFinalizeFunc) (GHookList *, GHook *); + + typedef struct _GQueue GQueue; + + typedef struct _GSList GSList; + +#if __i386__ +/* IA32 */ + typedef unsigned int gsize; + +#endif + typedef struct _GString GString; + + typedef struct _GPtrArray GPtrArray; + + typedef struct _GRand GRand; + + typedef struct _GDir GDir; + + typedef struct _GRelation GRelation; + + typedef struct _GOptionContext GOptionContext; + + typedef struct _GKeyFile GKeyFile; + + typedef struct _GPatternSpec GPatternSpec; + + typedef guint32 gunichar; + + typedef gchar *(*GCompletionFunc) (gpointer); + + typedef gint(*GCompletionStrncmpFunc) (const gchar *, const gchar *, + gsize); + + typedef struct _GCompletion GCompletion; + + typedef struct _GTimer GTimer; + + typedef struct _GHashTable GHashTable; + + typedef const void *gconstpointer; + + typedef guint(*GHashFunc) (gconstpointer); + + typedef gboolean(*GEqualFunc) (gconstpointer, gconstpointer); + + typedef struct _GStaticMutex GStaticMutex; + + typedef union _GSystemThread GSystemThread; + + typedef struct _GStaticRecMutex GStaticRecMutex; + + typedef struct _GMarkupParseContext GMarkupParseContext; + + typedef struct _GData GData; + + typedef enum { + G_IO_STATUS_ERROR = 0, + G_IO_STATUS_NORMAL = 1, + G_IO_STATUS_EOF = 2, + G_IO_STATUS_AGAIN = 3 + } GIOStatus; + + typedef struct _GIOChannel GIOChannel; + + typedef enum { + G_SEEK_CUR = 0, + G_SEEK_SET = 1, + G_SEEK_END = 2 + } GSeekType; + + typedef struct _GSource GSource; + + typedef gboolean(*GSourceFunc) (gpointer); + + typedef struct _GSourceCallbackFuncs GSourceCallbackFuncs; + + typedef void (*GSourceDummyMarshal) (void); + + typedef struct _GSourceFuncs GSourceFuncs; + + typedef struct _GMainContext GMainContext; + + typedef enum { + G_IO_IN = 1, + G_IO_OUT = 4, + G_IO_PRI = 2, + G_IO_ERR = 8, + G_IO_HUP = 16, + G_IO_NVAL = 32 + } GIOCondition; + + typedef enum { + G_IO_FLAG_APPEND = 1, + G_IO_FLAG_NONBLOCK = 2, + G_IO_FLAG_IS_READABLE = 4, + G_IO_FLAG_IS_WRITEABLE = 8, + G_IO_FLAG_IS_SEEKABLE = 16, + G_IO_FLAG_MASK = 31, + G_IO_FLAG_GET_MASK = 31, + G_IO_FLAG_SET_MASK = 3 + } GIOFlags; + + typedef struct _GIOFuncs GIOFuncs; + + typedef struct _GIConv *GIConv; + + typedef struct _GOptionGroup GOptionGroup; + + typedef enum { + G_SPAWN_LEAVE_DESCRIPTORS_OPEN = 1, + G_SPAWN_DO_NOT_REAP_CHILD = 2, + G_SPAWN_SEARCH_PATH = 4, + G_SPAWN_STDOUT_TO_DEV_NULL = 8, + G_SPAWN_STDERR_TO_DEV_NULL = 16, + G_SPAWN_CHILD_INHERITS_STDIN = 32, + G_SPAWN_FILE_AND_ARGV_ZERO = 64 + } GSpawnFlags; + + typedef void (*GSpawnChildSetupFunc) (gpointer); + + typedef int GPid; + + typedef void (*GFunc) (gpointer, gpointer); + + typedef struct _GThreadPool GThreadPool; + + typedef struct _GDate GDate; + + typedef enum { + G_DATE_BAD_MONTH = 0, + G_DATE_JANUARY = 1, + G_DATE_FEBRUARY = 2, + G_DATE_MARCH = 3, + G_DATE_APRIL = 4, + G_DATE_MAY = 5, + G_DATE_JUNE = 6, + G_DATE_JULY = 7, + G_DATE_AUGUST = 8, + G_DATE_SEPTEMBER = 9, + G_DATE_OCTOBER = 10, + G_DATE_NOVEMBER = 11, + G_DATE_DECEMBER = 12 + } GDateMonth; + + typedef struct _GAsyncQueue GAsyncQueue; + + typedef short unsigned int gushort; + + typedef struct _GPollFD GPollFD; + + typedef double gdouble; + + typedef struct _GTree GTree; + + typedef gint(*GCompareDataFunc) (gconstpointer, gconstpointer, + gpointer); + + typedef unsigned char guint8; + + typedef guint16 GDateYear; + + typedef struct _GCache GCache; + + typedef void (*GHFunc) (gpointer, gpointer, gpointer); + + typedef struct _GScannerConfig GScannerConfig; + + typedef enum { + G_TOKEN_EOF = 0, + G_TOKEN_LEFT_PAREN = 40, + G_TOKEN_RIGHT_PAREN = 41, + G_TOKEN_LEFT_CURLY = 123, + G_TOKEN_RIGHT_CURLY = 125, + G_TOKEN_LEFT_BRACE = 91, + G_TOKEN_RIGHT_BRACE = 93, + G_TOKEN_EQUAL_SIGN = 61, + G_TOKEN_COMMA = 44, + G_TOKEN_NONE = 256, + G_TOKEN_ERROR = 257, + G_TOKEN_CHAR = 258, + G_TOKEN_BINARY = 259, + G_TOKEN_OCTAL = 260, + G_TOKEN_INT = 261, + G_TOKEN_HEX = 262, + G_TOKEN_FLOAT = 263, + G_TOKEN_STRING = 264, + G_TOKEN_SYMBOL = 265, + G_TOKEN_IDENTIFIER = 266, + G_TOKEN_IDENTIFIER_NULL = 267, + G_TOKEN_COMMENT_SINGLE = 268, + G_TOKEN_COMMENT_MULTI = 269, + G_TOKEN_LAST = 270 + } GTokenType; + + typedef unsigned char guchar; + + typedef union _GTokenValue GTokenValue; + + typedef struct _GScanner GScanner; + + typedef void (*GScannerMsgFunc) (GScanner *, gchar *, gboolean); + + typedef struct _GByteArray GByteArray; + + typedef enum { + G_KEY_FILE_NONE = 0, + G_KEY_FILE_KEEP_COMMENTS = 1, + G_KEY_FILE_KEEP_TRANSLATIONS = 2 + } GKeyFileFlags; + + typedef struct _GTrashStack GTrashStack; + + typedef guint16 gunichar2; + + typedef long int glong; + + typedef struct _GArray GArray; + + typedef struct _GNode GNode; + + typedef gboolean(*GHRFunc) (gpointer, gpointer, gpointer); + + typedef gint(*GCompareFunc) (gconstpointer, gconstpointer); + + typedef int gint32; + + typedef gint32 GTime; + + typedef gint(*GPollFunc) (GPollFD *, guint, gint); + + typedef guint8 GDateDay; + + typedef enum { + G_UNICODE_BREAK_MANDATORY = 0, + G_UNICODE_BREAK_CARRIAGE_RETURN = 1, + G_UNICODE_BREAK_LINE_FEED = 2, + G_UNICODE_BREAK_COMBINING_MARK = 3, + G_UNICODE_BREAK_SURROGATE = 4, + G_UNICODE_BREAK_ZERO_WIDTH_SPACE = 5, + G_UNICODE_BREAK_INSEPARABLE = 6, + G_UNICODE_BREAK_NON_BREAKING_GLUE = 7, + G_UNICODE_BREAK_CONTINGENT = 8, + G_UNICODE_BREAK_SPACE = 9, + G_UNICODE_BREAK_AFTER = 10, + G_UNICODE_BREAK_BEFORE = 11, + G_UNICODE_BREAK_BEFORE_AND_AFTER = 12, + G_UNICODE_BREAK_HYPHEN = 13, + G_UNICODE_BREAK_NON_STARTER = 14, + G_UNICODE_BREAK_OPEN_PUNCTUATION = 15, + G_UNICODE_BREAK_CLOSE_PUNCTUATION = 16, + G_UNICODE_BREAK_QUOTATION = 17, + G_UNICODE_BREAK_EXCLAMATION = 18, + G_UNICODE_BREAK_IDEOGRAPHIC = 19, + G_UNICODE_BREAK_NUMERIC = 20, + G_UNICODE_BREAK_INFIX_SEPARATOR = 21, + G_UNICODE_BREAK_SYMBOL = 22, + G_UNICODE_BREAK_ALPHABETIC = 23, + G_UNICODE_BREAK_PREFIX = 24, + G_UNICODE_BREAK_POSTFIX = 25, + G_UNICODE_BREAK_COMPLEX_CONTEXT = 26, + G_UNICODE_BREAK_AMBIGUOUS = 27, + G_UNICODE_BREAK_UNKNOWN = 28, + G_UNICODE_BREAK_NEXT_LINE = 29, + G_UNICODE_BREAK_WORD_JOINER = 30 + } GUnicodeBreakType; + + typedef struct _GStringChunk GStringChunk; + + typedef struct _GCond GCond; + + typedef struct _GStaticRWLock GStaticRWLock; + + typedef void (*GChildWatchFunc) (GPid, gint, gpointer); + + typedef struct _GTimeVal GTimeVal; + + typedef enum { + G_LOG_FLAG_RECURSION = 1, + G_LOG_FLAG_FATAL = 2, + G_LOG_LEVEL_ERROR = 4, + G_LOG_LEVEL_CRITICAL = 8, + G_LOG_LEVEL_WARNING = 16, + G_LOG_LEVEL_MESSAGE = 32, + G_LOG_LEVEL_INFO = 64, + G_LOG_LEVEL_DEBUG = 128, + G_LOG_LEVEL_MASK = -4 + } GLogLevelFlags; + + typedef enum { + G_DATE_BAD_WEEKDAY = 0, + G_DATE_MONDAY = 1, + G_DATE_TUESDAY = 2, + G_DATE_WEDNESDAY = 3, + G_DATE_THURSDAY = 4, + G_DATE_FRIDAY = 5, + G_DATE_SATURDAY = 6, + G_DATE_SUNDAY = 7 + } GDateWeekday; + + typedef enum { + G_IN_ORDER = 0, + G_PRE_ORDER = 1, + G_POST_ORDER = 2, + G_LEVEL_ORDER = 3 + } GTraverseType; + + typedef enum { + G_TRAVERSE_LEAVES = 1, + G_TRAVERSE_NON_LEAVES = 2, + G_TRAVERSE_ALL = 3, + G_TRAVERSE_MASK = 3, + G_TRAVERSE_LEAFS = 1, + G_TRAVERSE_NON_LEAFS = 2 + } GTraverseFlags; + + typedef struct _GMarkupParser GMarkupParser; + + typedef enum { + G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1 + } GMarkupParseFlags; + + typedef gboolean(*GHookCheckMarshaller) (GHook *, gpointer); + + typedef gboolean(*GNodeTraverseFunc) (GNode *, gpointer); + + typedef enum { + G_NORMALIZE_DEFAULT = 0, + G_NORMALIZE_NFD = 0, + G_NORMALIZE_DEFAULT_COMPOSE = 1, + G_NORMALIZE_NFC = 1, + G_NORMALIZE_ALL = 2, + G_NORMALIZE_NFKD = 2, + G_NORMALIZE_ALL_COMPOSE = 3, + G_NORMALIZE_NFKC = 3 + } GNormalizeMode; + + typedef struct _GMutex GMutex; + + typedef struct _GStaticPrivate GStaticPrivate; + + typedef enum { + G_FILE_ERROR_EXIST = 0, + G_FILE_ERROR_ISDIR = 1, + G_FILE_ERROR_ACCES = 2, + G_FILE_ERROR_NAMETOOLONG = 3, + G_FILE_ERROR_NOENT = 4, + G_FILE_ERROR_NOTDIR = 5, + G_FILE_ERROR_NXIO = 6, + G_FILE_ERROR_NODEV = 7, + G_FILE_ERROR_ROFS = 8, + G_FILE_ERROR_TXTBSY = 9, + G_FILE_ERROR_FAULT = 10, + G_FILE_ERROR_LOOP = 11, + G_FILE_ERROR_NOSPC = 12, + G_FILE_ERROR_NOMEM = 13, + G_FILE_ERROR_MFILE = 14, + G_FILE_ERROR_NFILE = 15, + G_FILE_ERROR_BADF = 16, + G_FILE_ERROR_INVAL = 17, + G_FILE_ERROR_PIPE = 18, + G_FILE_ERROR_AGAIN = 19, + G_FILE_ERROR_INTR = 20, + G_FILE_ERROR_IO = 21, + G_FILE_ERROR_PERM = 22, + G_FILE_ERROR_NOSYS = 23, + G_FILE_ERROR_FAILED = 24 + } GFileError; + + typedef void (*GDataForeachFunc) (GQuark, gpointer, gpointer); + + typedef struct _GMemVTable GMemVTable; + + typedef enum { + G_OPTION_ARG_NONE = 0, + G_OPTION_ARG_STRING = 1, + G_OPTION_ARG_INT = 2, + G_OPTION_ARG_CALLBACK = 3, + G_OPTION_ARG_FILENAME = 4, + G_OPTION_ARG_STRING_ARRAY = 5, + G_OPTION_ARG_FILENAME_ARRAY = 6 + } GOptionArg; + + typedef struct _GOptionEntry GOptionEntry; + + typedef enum { + G_UNICODE_CONTROL = 0, + G_UNICODE_FORMAT = 1, + G_UNICODE_UNASSIGNED = 2, + G_UNICODE_PRIVATE_USE = 3, + G_UNICODE_SURROGATE = 4, + G_UNICODE_LOWERCASE_LETTER = 5, + G_UNICODE_MODIFIER_LETTER = 6, + G_UNICODE_OTHER_LETTER = 7, + G_UNICODE_TITLECASE_LETTER = 8, + G_UNICODE_UPPERCASE_LETTER = 9, + G_UNICODE_COMBINING_MARK = 10, + G_UNICODE_ENCLOSING_MARK = 11, + G_UNICODE_NON_SPACING_MARK = 12, + G_UNICODE_DECIMAL_NUMBER = 13, + G_UNICODE_LETTER_NUMBER = 14, + G_UNICODE_OTHER_NUMBER = 15, + G_UNICODE_CONNECT_PUNCTUATION = 16, + G_UNICODE_DASH_PUNCTUATION = 17, + G_UNICODE_CLOSE_PUNCTUATION = 18, + G_UNICODE_FINAL_PUNCTUATION = 19, + G_UNICODE_INITIAL_PUNCTUATION = 20, + G_UNICODE_OTHER_PUNCTUATION = 21, + G_UNICODE_OPEN_PUNCTUATION = 22, + G_UNICODE_CURRENCY_SYMBOL = 23, + G_UNICODE_MODIFIER_SYMBOL = 24, + G_UNICODE_MATH_SYMBOL = 25, + G_UNICODE_OTHER_SYMBOL = 26, + G_UNICODE_LINE_SEPARATOR = 27, + G_UNICODE_PARAGRAPH_SEPARATOR = 28, + G_UNICODE_SPACE_SEPARATOR = 29 + } GUnicodeType; + + typedef void (*GLogFunc) (const gchar *, GLogLevelFlags, const gchar *, + gpointer); + + typedef struct _GAllocator GAllocator; + + typedef const gchar *(*GTranslateFunc) (const gchar *, gpointer); + + typedef gboolean(*GOptionParseFunc) (GOptionContext *, GOptionGroup *, + gpointer, GError * *); + + typedef void (*GVoidFunc) (void); + + typedef gboolean(*GHookFindFunc) (GHook *, gpointer); + + typedef struct _GTuples GTuples; + + typedef gpointer(*GCopyFunc) (gconstpointer, gpointer); + + typedef void (*GOptionErrorFunc) (GOptionContext *, GOptionGroup *, + gpointer, GError * *); + + typedef gpointer(*GCacheNewFunc) (gpointer); + + typedef void (*GCacheDestroyFunc) (gpointer); + + typedef gpointer(*GCacheDupFunc) (gpointer); + + typedef enum { + G_FILE_TEST_IS_REGULAR = 1, + G_FILE_TEST_IS_SYMLINK = 2, + G_FILE_TEST_IS_DIR = 4, + G_FILE_TEST_IS_EXECUTABLE = 8, + G_FILE_TEST_EXISTS = 16 + } GFileTest; + + typedef enum { + G_ONCE_STATUS_NOTCALLED = 0, + G_ONCE_STATUS_PROGRESS = 1, + G_ONCE_STATUS_READY = 2 + } GOnceStatus; + + typedef struct _GOnce GOnce; + + typedef gboolean(*GTraverseFunc) (gpointer, gpointer, gpointer); + + typedef gint(*GHookCompareFunc) (GHook *, GHook *); + + typedef void (*GNodeForeachFunc) (GNode *, gpointer); + + typedef struct _GDebugKey GDebugKey; + + typedef struct _GPrivate GPrivate; + + typedef struct _GThreadFunctions GThreadFunctions; + + typedef void (*GHookMarshaller) (GHook *, gpointer); + + typedef enum { + G_IO_CHANNEL_ERROR_FBIG = 0, + G_IO_CHANNEL_ERROR_INVAL = 1, + G_IO_CHANNEL_ERROR_IO = 2, + G_IO_CHANNEL_ERROR_ISDIR = 3, + G_IO_CHANNEL_ERROR_NOSPC = 4, + G_IO_CHANNEL_ERROR_NXIO = 5, + G_IO_CHANNEL_ERROR_OVERFLOW = 6, + G_IO_CHANNEL_ERROR_PIPE = 7, + G_IO_CHANNEL_ERROR_FAILED = 8 + } GIOChannelError; + + typedef gboolean(*GIOFunc) (GIOChannel *, GIOCondition, gpointer); + + typedef void (*GFreeFunc) (gpointer); + + typedef gboolean(*GHookCheckFunc) (gpointer); + + typedef void (*GHookFunc) (gpointer); + + typedef short int gint16; + + typedef enum { + G_DATE_DAY = 0, + G_DATE_MONTH = 1, + G_DATE_YEAR = 2 + } GDateDMY; + + typedef signed char gint8; + + typedef enum { + G_MARKUP_ERROR_BAD_UTF8 = 0, + G_MARKUP_ERROR_EMPTY = 1, + G_MARKUP_ERROR_PARSE = 2, + G_MARKUP_ERROR_UNKNOWN_ELEMENT = 3, + G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE = 4, + G_MARKUP_ERROR_INVALID_CONTENT = 5 + } GMarkupError; + + typedef enum { + G_IO_ERROR_NONE = 0, + G_IO_ERROR_AGAIN = 1, + G_IO_ERROR_INVAL = 2, + G_IO_ERROR_UNKNOWN = 3 + } GIOError; + + typedef gboolean(*GOptionArgFunc) (const gchar *, const gchar *, + gpointer, GError * *); + + typedef enum { + G_OPTION_FLAG_HIDDEN = 1 << 0, + G_OPTION_FLAG_IN_MAIN = 1 << 1, + G_OPTION_FLAG_REVERSE = 1 << 2 + } GOptionFlags; + + typedef enum { + G_CONVERT_ERROR_NO_CONVERSION, + G_CONVERT_ERROR_ILLEGAL_SEQUENCE, + G_CONVERT_ERROR_FAILED, + G_CONVERT_ERROR_PARTIAL_INPUT, + G_CONVERT_ERROR_BAD_URI, + G_CONVERT_ERROR_NOT_ABSOLUTE_PATH + } GConvertError; + + typedef enum { + G_ERR_UNKNOWN, + G_ERR_UNEXP_EOF, + G_ERR_UNEXP_EOF_IN_STRING, + G_ERR_UNEXP_EOF_IN_COMMENT, + G_ERR_NON_DIGIT_IN_CONST, + G_ERR_DIGIT_RADIX, + G_ERR_FLOAT_RADIX, + G_ERR_FLOAT_MALFORMED + } GErrorType; + + typedef enum { + G_KEY_FILE_ERROR_UNKNOWN_ENCODING, + G_KEY_FILE_ERROR_PARSE, + G_KEY_FILE_ERROR_NOT_FOUND, + G_KEY_FILE_ERROR_KEY_NOT_FOUND, + G_KEY_FILE_ERROR_GROUP_NOT_FOUND, + G_KEY_FILE_ERROR_INVALID_VALUE + } GKeyFileError; + + typedef enum { + G_SPAWN_ERROR_FORK, + G_SPAWN_ERROR_READ, + G_SPAWN_ERROR_CHDIR, + G_SPAWN_ERROR_ACCES, + G_SPAWN_ERROR_PERM, + G_SPAWN_ERROR_2BIG, + G_SPAWN_ERROR_NOEXEC, + G_SPAWN_ERROR_NAMETOOLONG, + G_SPAWN_ERROR_NOENT, + G_SPAWN_ERROR_NOMEM, + G_SPAWN_ERROR_NOTDIR, + G_SPAWN_ERROR_LOOP, + G_SPAWN_ERROR_TXTBUSY, + G_SPAWN_ERROR_IO, + G_SPAWN_ERROR_NFILE, + G_SPAWN_ERROR_MFILE, + G_SPAWN_ERROR_INVAL, + G_SPAWN_ERROR_ISDIR, + G_SPAWN_ERROR_LIBBAD, + G_SPAWN_ERROR_FAILED + } GSpawnError; + + typedef enum { + G_HOOK_FLAG_ACTIVE = 1 << 0, + G_HOOK_FLAG_IN_CALL = 1 << 1, + G_HOOK_FLAG_MASK = 0x0f + } GHookFlagMask; + + typedef enum { + G_THREAD_ERROR_AGAIN + } GThreadError; + + typedef enum { + G_OPTION_ERROR_UNKNOWN_OPTION, + G_OPTION_ERROR_BAD_VALUE, + G_OPTION_ERROR_FAILED + } GOptionError; + + typedef enum { + G_ASCII_ALNUM = 1 << 0, + G_ASCII_ALPHA = 1 << 1, + G_ASCII_CNTRL = 1 << 2, + G_ASCII_DIGIT = 1 << 3, + G_ASCII_GRAPH = 1 << 4, + G_ASCII_LOWER = 1 << 5, + G_ASCII_PRINT = 1 << 6, + G_ASCII_PUNCT = 1 << 7, + G_ASCII_SPACE = 1 << 8, + G_ASCII_UPPER = 1 << 9, + G_ASCII_XDIGIT = 1 << 10 + } GAsciiType; + + typedef enum { + G_SHELL_ERROR_BAD_QUOTING, + G_SHELL_ERROR_EMPTY_STRING, + G_SHELL_ERROR_FAILED + } GShellError; + + + struct _GThread { + GThreadFunc func; + gpointer data; + gboolean joinable; + GThreadPriority priority; + }; + + + struct _GError { + GQuark domain; + gint code; + gchar *message; + }; + + + + + + struct _GList { + gpointer data; + GList *next; + GList *prev; + }; + + + + + + struct _GHook { + gpointer data; + GHook *next; + GHook *prev; + guint ref_count; + gulong hook_id; + guint flags; + gpointer func; + GDestroyNotify destroy; + }; + + + struct _GHookList { + gulong seq_id; + guint hook_size:16; + guint is_setup:1; + GHook *hooks; + GMemChunk *hook_memchunk; + GHookFinalizeFunc finalize_hook; + gpointer dummy[2]; + }; + + + struct _GQueue { + GList *head; + GList *tail; + guint length; + }; + + + struct _GSList { + gpointer data; + GSList *next; + }; + + + struct _GString { + gchar *str; + gsize len; + gsize allocated_len; + }; + + + struct _GPtrArray { + gpointer *pdata; + guint len; + }; + + + + + + + + + + + + + + + + + + + + + struct _GCompletion { + GList *items; + GCompletionFunc func; + gchar *prefix; + GList *cache; + GCompletionStrncmpFunc strncmp_func; + }; + + + + + + + + + struct _GStaticMutex { + struct _GMutex *runtime_mutex; + union { + char pad[GLIB_LSB_PADDING_SIZE]; + double dummy_double; + void *dummy_pointer; + long int dummy_long; + } static_mutex; + }; + + union _GSystemThread { + char data[GLIB_LSB_DATA_SIZE]; + double dummy_double; + void *dummy_pointer; + long int dummy_long; + }; + + + struct _GStaticRecMutex { + GStaticMutex mutex; + guint depth; + GSystemThread owner; + }; + + + + + + + + + struct _GIOChannel { + guint ref_count; + GIOFuncs *funcs; + gchar *encoding; + GIConv read_cd; + GIConv write_cd; + gchar *line_term; + guint line_term_len; + gsize buf_size; + GString *read_buf; + GString *encoded_read_buf; + GString *write_buf; + gchar partial_write_buf[6]; + guint use_buffer:1; + guint do_encode:1; + guint close_on_unref:1; + guint is_readable:1; + guint is_writeable:1; + guint is_seekable:1; + gpointer reserved1; + gpointer reserved2; + }; + + + struct _GSource { + gpointer callback_data; + GSourceCallbackFuncs *callback_funcs; + GSourceFuncs *source_funcs; + guint ref_count; + GMainContext *context; + gint priority; + guint flags; + guint source_id; + GSList *poll_fds; + GSource *prev; + GSource *next; + gpointer reserved1; + gpointer reserved2; + }; + + + struct _GSourceCallbackFuncs { + void (*ref) (gpointer); + void (*unref) (gpointer); + void (*get) (gpointer, GSource *, GSourceFunc *, gpointer *); + }; + + + struct _GSourceFuncs { + gboolean(*prepare) (GSource *, gint *); + gboolean(*check) (GSource *); + gboolean(*dispatch) (GSource *, GSourceFunc, gpointer); + void (*finalize) (GSource *); + GSourceFunc closure_callback; + GSourceDummyMarshal closure_marshal; + }; + + + + + + struct _GIOFuncs { + GIOStatus(*io_read) (GIOChannel *, gchar *, gsize, gsize *, + GError * *); + GIOStatus(*io_write) (GIOChannel *, const gchar *, gsize, gsize *, + GError * *); + GIOStatus(*io_seek) (GIOChannel *, gint64, GSeekType, GError * *); + GIOStatus(*io_close) (GIOChannel *, GError * *); + GSource *(*io_create_watch) (GIOChannel *, GIOCondition); + void (*io_free) (GIOChannel *); + GIOStatus(*io_set_flags) (GIOChannel *, GIOFlags, GError * *); + GIOFlags(*io_get_flags) (GIOChannel *); + }; + + + + + + struct _GThreadPool { + GFunc func; + gpointer user_data; + gboolean exclusive; + }; + + + struct _GDate { + guint julian_days:32; + guint julian:1; + guint dmy:1; + guint day:6; + guint month:4; + guint year:16; + }; + + + + + + struct _GPollFD { + gint fd; + gushort events; + gushort revents; + }; + + + + + + + + + struct _GScannerConfig { + gchar *cset_skip_characters; + gchar *cset_identifier_first; + gchar *cset_identifier_nth; + gchar *cpair_comment_single; + guint case_sensitive:1; + guint skip_comment_multi:1; + guint skip_comment_single:1; + guint scan_comment_multi:1; + guint scan_identifier:1; + guint scan_identifier_1char:1; + guint scan_identifier_NULL:1; + guint scan_symbols:1; + guint scan_binary:1; + guint scan_octal:1; + guint scan_float:1; + guint scan_hex:1; + guint scan_hex_dollar:1; + guint scan_string_sq:1; + guint scan_string_dq:1; + guint numbers_2_int:1; + guint int_2_float:1; + guint identifier_2_string:1; + guint char_2_token:1; + guint symbol_2_token:1; + guint scope_0_fallback:1; + guint store_int64:1; + guint padding_dummy; + }; + + union _GTokenValue { + gpointer v_symbol; + gchar *v_identifier; + gulong v_binary; + gulong v_octal; + gulong v_int; + guint64 v_int64; + gdouble v_float; + gulong v_hex; + gchar *v_string; + gchar *v_comment; + guchar v_char; + guint v_error; + }; + + + struct _GScanner { + gpointer user_data; + guint max_parse_errors; + guint parse_errors; + const gchar *input_name; + GData *qdata; + GScannerConfig *config; + GTokenType token; + GTokenValue value; + guint line; + guint position; + GTokenType next_token; + GTokenValue next_value; + guint next_line; + guint next_position; + GHashTable *symbol_table; + gint input_fd; + const gchar *text; + const gchar *text_end; + gchar *buffer; + guint scope_id; + GScannerMsgFunc msg_handler; + }; + + + struct _GByteArray { + guint8 *data; + guint len; + }; + + + struct _GTrashStack { + GTrashStack *next; + }; + + + struct _GArray { + gchar *data; + guint len; + }; + + + struct _GNode { + gpointer data; + GNode *next; + GNode *prev; + GNode *parent; + GNode *children; + }; + + + + + + + + + struct _GStaticRWLock { + GStaticMutex mutex; + GCond *read_cond; + GCond *write_cond; + guint read_counter; + gboolean have_writer; + guint want_to_read; + guint want_to_write; + }; + + + struct _GTimeVal { + glong tv_sec; + glong tv_usec; + }; + + + struct _GMarkupParser { + void (*start_element) (GMarkupParseContext *, const gchar *, + const gchar * *, const gchar * *, gpointer, + GError * *); + void (*end_element) (GMarkupParseContext *, const gchar *, + gpointer, GError * *); + void (*text) (GMarkupParseContext *, const gchar *, gsize, + gpointer, GError * *); + void (*passthrough) (GMarkupParseContext *, const gchar *, gsize, + gpointer, GError * *); + void (*error) (GMarkupParseContext *, GError *, gpointer); + }; + + + + + + struct _GStaticPrivate { + guint index; + }; + + + struct _GMemVTable { + gpointer(*malloc) (gsize); + gpointer(*realloc) (gpointer, gsize); + void (*free) (gpointer); + gpointer(*calloc) (gsize, gsize); + gpointer(*try_malloc) (gsize); + gpointer(*try_realloc) (gpointer, gsize); + }; + + + struct _GOptionEntry { + const gchar *long_name; + gchar short_name; + gint flags; + GOptionArg arg; + gpointer arg_data; + const gchar *description; + const gchar *arg_description; + }; + + + + + + struct _GTuples { + guint len; + }; + + + struct _GOnce { + volatile GOnceStatus status; + volatile gpointer retval; + }; + + + struct _GDebugKey { + gchar *key; + guint value; + }; + + + + + + struct _GThreadFunctions { + GMutex *(*mutex_new) (void); + void (*mutex_lock) (GMutex *); + gboolean(*mutex_trylock) (GMutex *); + void (*mutex_unlock) (GMutex *); + void (*mutex_free) (GMutex *); + GCond *(*cond_new) (void); + void (*cond_signal) (GCond *); + void (*cond_broadcast) (GCond *); + void (*cond_wait) (GCond *, GMutex *); + gboolean(*cond_timed_wait) (GCond *, GMutex *, GTimeVal *); + void (*cond_free) (GCond *); + GPrivate *(*private_new) (GDestroyNotify); + gpointer(*private_get) (GPrivate *); + void (*private_set) (GPrivate *, gpointer); + void (*thread_create) (GThreadFunc, gpointer, gulong, gboolean, + gboolean, GThreadPriority, gpointer, + GError * *); + void (*thread_yield) (void); + void (*thread_join) (gpointer); + void (*thread_exit) (void); + void (*thread_set_priority) (gpointer, GThreadPriority); + void (*thread_self) (gpointer); + gboolean(*thread_equal) (gpointer, gpointer); + }; + + + extern const guint16 *const g_ascii_table; + extern gboolean g_source_remove(guint); + extern void g_thread_set_priority(GThread *, GThreadPriority); + extern GError *g_error_copy(const GError *); + extern gchar *g_utf8_prev_char(const gchar *); + extern void g_node_pop_allocator(void); + extern GPrintFunc g_set_printerr_handler(GPrintFunc); + extern GMemChunk *g_mem_chunk_new(const gchar *, gint, gulong, gint); + extern void g_on_error_stack_trace(const gchar *); + extern void g_mem_chunk_print(GMemChunk *); + extern guint g_list_length(GList *); + extern void g_main_loop_quit(GMainLoop *); + extern void g_hook_insert_before(GHookList *, GHook *, GHook *); + extern gboolean g_get_filename_charsets(const gchar * **); + extern GList *g_queue_pop_nth_link(GQueue *, guint); + extern GSList *g_slist_copy(GSList *); + extern gint g_mkstemp(gchar *); + extern GError *g_error_new(GQuark, gint, const gchar *, ...); + extern GString *g_string_set_size(GString *, gsize); + extern gchar *g_get_prgname(void); + extern gpointer g_ptr_array_remove_index_fast(GPtrArray *, guint); + extern GRand *g_rand_new_with_seed_array(const guint32 *, guint); + extern void g_dir_close(GDir *); + extern const gchar *const *g_get_system_config_dirs(void); + extern void g_relation_insert(GRelation *, ...); + extern void g_option_context_free(GOptionContext *); + extern gchar *g_strcanon(gchar *, const gchar *, gchar); + extern guint g_slist_length(GSList *); + extern gchar *g_key_file_to_data(GKeyFile *, gsize *, GError * *); + extern GPatternSpec *g_pattern_spec_new(const gchar *); + extern gchar **g_strdupv(gchar * *); + extern gboolean g_unichar_isupper(gunichar); + extern void g_completion_free(GCompletion *); + extern void g_timer_reset(GTimer *); + extern GHashTable *g_hash_table_new_full(GHashFunc, GEqualFunc, + GDestroyNotify, + GDestroyNotify); + extern void g_static_rec_mutex_init(GStaticRecMutex *); + extern gint g_atomic_int_exchange_and_add(gint *, gint); + extern gchar *g_strjoin(const gchar *, ...); + extern GSList *g_slist_last(GSList *); + extern void g_key_file_set_string(GKeyFile *, const gchar *, + const gchar *, const gchar *); + extern GPtrArray *g_ptr_array_new(void); + extern gboolean g_markup_parse_context_end_parse(GMarkupParseContext *, + GError * *); + extern gboolean g_key_file_get_boolean(GKeyFile *, const gchar *, + const gchar *, GError * *); + extern gchar *g_strrstr_len(const gchar *, gssize, const gchar *); + extern gint g_hook_compare_ids(GHook *, GHook *); + extern gchar *g_utf8_strup(const gchar *, gssize); + extern gchar *g_build_filename(const gchar *, ...); + extern void g_datalist_init(GData * *); + extern GIOStatus g_io_channel_set_flags(GIOChannel *, GIOFlags, + GError * *); + extern const gchar *const g_utf8_skip; + extern void g_option_group_free(GOptionGroup *); + extern void g_completion_clear_items(GCompletion *); + extern gboolean g_hash_table_steal(GHashTable *, gconstpointer); + extern gboolean g_spawn_async_with_pipes(const gchar *, gchar * *, + gchar * *, GSpawnFlags, + GSpawnChildSetupFunc, + gpointer, GPid *, gint *, + gint *, gint *, GError * *); + extern void g_clear_error(GError * *); + extern gpointer g_queue_pop_head(GQueue *); + extern GThreadPool *g_thread_pool_new(GFunc, gpointer, gint, gboolean, + GError * *); + extern void g_static_rec_mutex_lock(GStaticRecMutex *); + extern guint g_thread_pool_get_num_threads(GThreadPool *); + extern void g_date_set_month(GDate *, GDateMonth); + extern gchar *g_filename_to_uri(const gchar *, const gchar *, + GError * *); + extern gboolean g_date_valid_julian(guint32); + extern GQuark g_option_error_quark(void); + extern gchar **g_key_file_get_keys(GKeyFile *, const gchar *, gsize *, + GError * *); + extern gchar g_ascii_tolower(gchar); + extern GMainLoop *g_main_loop_new(GMainContext *, gboolean); + extern gint g_relation_count(GRelation *, gconstpointer, gint); + extern void g_ptr_array_add(GPtrArray *, gpointer); + extern void g_async_queue_unlock(GAsyncQueue *); + extern gboolean g_pattern_match_string(GPatternSpec *, const gchar *); + extern void g_key_file_free(GKeyFile *); + extern GMainContext *g_main_context_default(void); + extern GIOStatus g_io_channel_read_line_string(GIOChannel *, GString *, + gsize *, GError * *); + extern GSource *g_source_ref(GSource *); + extern gint g_slist_index(GSList *, gconstpointer); + extern GSList *g_slist_find(GSList *, gconstpointer); + extern gboolean g_main_context_prepare(GMainContext *, gint *); + extern char *g_markup_vprintf_escaped(const char *, va_list); + extern void g_ptr_array_set_size(GPtrArray *, gint); + extern void g_set_application_name(const gchar *); + extern gint g_main_context_query(GMainContext *, gint, gint *, + GPollFD *, gint); + extern void g_rand_set_seed(GRand *, guint32); + extern GList *g_list_last(GList *); + extern gchar *g_ascii_dtostr(gchar *, gint, gdouble); + extern gboolean g_main_loop_is_running(GMainLoop *); + extern void g_pattern_spec_free(GPatternSpec *); + extern GTree *g_tree_new_full(GCompareDataFunc, gpointer, + GDestroyNotify, GDestroyNotify); + extern guint8 g_date_get_monday_weeks_in_year(GDateYear); + extern guint g_idle_add(GSourceFunc, gpointer); + extern void g_main_context_release(GMainContext *); + extern int g_main_depth(void); + extern void g_cache_key_foreach(GCache *, GHFunc, gpointer); + extern void g_static_rec_mutex_free(GStaticRecMutex *); + extern guint g_date_get_monday_week_of_year(const GDate *); + extern const gchar *g_io_channel_get_line_term(GIOChannel *, gint *); + extern guint g_scanner_set_scope(GScanner *, guint); + extern gchar *g_string_free(GString *, gboolean); + extern void g_source_set_priority(GSource *, gint); + extern void g_async_queue_unref(GAsyncQueue *); + extern void g_hook_prepend(GHookList *, GHook *); + extern gpointer g_queue_peek_head(GQueue *); + extern void g_byte_array_sort_with_data(GByteArray *, GCompareDataFunc, + gpointer); + extern gboolean g_key_file_load_from_data_dirs(GKeyFile *, + const gchar *, + gchar * *, + GKeyFileFlags, + GError * *); + extern guint g_trash_stack_height(GTrashStack * *); + extern void g_markup_parse_context_free(GMarkupParseContext *); + extern GString *g_string_append_len(GString *, const gchar *, gssize); + extern const gchar *g_getenv(const gchar *); + extern gint *g_key_file_get_integer_list(GKeyFile *, const gchar *, + const gchar *, gsize *, + GError * *); + extern gunichar2 *g_ucs4_to_utf16(const gunichar *, glong, glong *, + glong *, GError * *); + extern GList *g_list_remove(GList *, gconstpointer); + extern gboolean g_hook_destroy(GHookList *, gulong); + extern GRand *g_rand_copy(GRand *); + extern GString *g_string_ascii_up(GString *); + extern const gchar *g_io_channel_get_encoding(GIOChannel *); + extern void g_random_set_seed(guint32); + extern GOptionGroup *g_option_context_get_main_group(GOptionContext *); + extern guint g_idle_add_full(gint, GSourceFunc, gpointer, + GDestroyNotify); + extern GArray *g_array_append_vals(GArray *, gconstpointer, guint); + extern GHook *g_hook_next_valid(GHookList *, GHook *, gboolean); + extern gchar *g_path_get_basename(const gchar *); + extern gchar *g_key_file_get_value(GKeyFile *, const gchar *, + const gchar *, GError * *); + extern void g_slist_pop_allocator(void); + extern void g_node_unlink(GNode *); + extern gpointer g_hash_table_find(GHashTable *, GHRFunc, gpointer); + extern GList *g_list_sort(GList *, GCompareFunc); + extern void g_date_set_time(GDate *, GTime); + extern GPollFunc g_main_context_get_poll_func(GMainContext *); + extern gchar *g_strndup(const gchar *, gsize); + extern GSList *g_slist_remove(GSList *, gconstpointer); + extern void g_date_order(GDate *, GDate *); + extern gdouble g_timer_elapsed(GTimer *, gulong *); + extern gchar *g_strchug(gchar *); + extern GQuark g_io_channel_error_quark(void); + extern void g_cache_remove(GCache *, gconstpointer); + extern GArray *g_array_remove_index_fast(GArray *, guint); + extern GAsyncQueue *g_async_queue_ref(GAsyncQueue *); + extern GQuark g_key_file_error_quark(void); + extern gboolean g_atomic_pointer_compare_and_exchange(gpointer *, + gpointer, + gpointer); + extern gboolean g_date_valid_dmy(GDateDay, GDateMonth, GDateYear); + extern gpointer g_mem_chunk_alloc0(GMemChunk *); + extern gint g_async_queue_length_unlocked(GAsyncQueue *); + extern GUnicodeBreakType g_unichar_break_type(gunichar); + extern gboolean g_date_valid_year(GDateYear); + extern void g_thread_pool_set_max_unused_threads(gint); + extern GArray *g_array_remove_index(GArray *, guint); + extern void g_key_file_remove_group(GKeyFile *, const gchar *, + GError * *); + extern gchar *g_key_file_get_comment(GKeyFile *, const gchar *, + const gchar *, GError * *); + extern gboolean g_io_channel_get_buffered(GIOChannel *); + extern GList *g_list_delete_link(GList *, GList *); + extern GList *g_completion_complete(GCompletion *, const gchar *, + gchar * *); + extern gboolean g_unichar_isdigit(gunichar); + extern void g_date_subtract_years(GDate *, guint); + extern gchar *g_utf8_strchr(const char *, gssize, gunichar); + extern void g_queue_push_head(GQueue *, gpointer); + extern guint g_queue_get_length(GQueue *); + extern gchar *g_string_chunk_insert_const(GStringChunk *, + const gchar *); + extern void g_static_rw_lock_init(GStaticRWLock *); + extern guint g_bit_storage(gulong); + extern GSList *g_slist_sort(GSList *, GCompareFunc); + extern gint g_relation_delete(GRelation *, gconstpointer, gint); + extern GIOStatus g_io_channel_write_chars(GIOChannel *, const gchar *, + gssize, gsize *, GError * *); + extern GList *g_list_find(GList *, gconstpointer); + extern gpointer g_queue_peek_tail(GQueue *); + extern GIOStatus g_io_channel_write_unichar(GIOChannel *, gunichar, + GError * *); + extern void g_hook_list_clear(GHookList *); + extern guint g_child_watch_add(GPid, GChildWatchFunc, gpointer); + extern void g_hook_list_init(GHookList *, guint); + extern gpointer g_realloc(gpointer, gulong); + extern void g_queue_push_nth(GQueue *, gpointer, gint); + extern gpointer g_trash_stack_peek(GTrashStack * *); + extern const gchar *g_get_application_name(void); + extern gint g_main_context_check(GMainContext *, gint, GPollFD *, + gint); + extern gunichar *g_unicode_canonical_decomposition(gunichar, gsize *); + extern gpointer g_async_queue_timed_pop_unlocked(GAsyncQueue *, + GTimeVal *); + extern gboolean g_option_context_get_help_enabled(GOptionContext *); + extern void g_log_default_handler(const gchar *, GLogLevelFlags, + const gchar *, gpointer); + extern gpointer g_async_queue_try_pop(GAsyncQueue *); + extern void g_option_group_set_translation_domain(GOptionGroup *, + const gchar *); + extern void g_source_destroy(GSource *); + extern gchar *g_filename_to_utf8(const gchar *, gssize, gsize *, + gsize *, GError * *); + extern gboolean g_key_file_load_from_data(GKeyFile *, const gchar *, + gsize, GKeyFileFlags, + GError * *); + extern GKeyFile *g_key_file_new(void); + extern GDateYear g_date_get_year(const GDate *); + extern const gchar *g_get_user_config_dir(void); + extern gint g_slist_position(GSList *, GSList *); + extern const guint glib_minor_version; + extern GSList *g_slist_delete_link(GSList *, GSList *); + extern GDateWeekday g_date_get_weekday(const GDate *); + extern gchar *g_convert_with_iconv(const gchar *, gssize, GIConv, + gsize *, gsize *, GError * *); + extern GNode *g_node_insert(GNode *, gint, GNode *); + extern void g_source_set_callback(GSource *, GSourceFunc, gpointer, + GDestroyNotify); + extern void g_source_add_poll(GSource *, GPollFD *); + extern void g_slist_free_1(GSList *); + extern GByteArray *g_byte_array_remove_index_fast(GByteArray *, guint); + extern GHook *g_hook_find_data(GHookList *, gboolean, gpointer); + extern void g_ptr_array_foreach(GPtrArray *, GFunc, gpointer); + extern void g_scanner_scope_add_symbol(GScanner *, guint, + const gchar *, gpointer); + extern GMainContext *g_main_context_ref(GMainContext *); + extern void g_hook_list_invoke(GHookList *, gboolean); + extern gint g_source_get_priority(GSource *); + extern void g_list_free_1(GList *); + extern gint g_key_file_get_integer(GKeyFile *, const gchar *, + const gchar *, GError * *); + extern GSList *g_slist_nth(GSList *, guint); + extern gchar *g_shell_unquote(const gchar *, GError * *); + extern void g_option_context_add_group(GOptionContext *, + GOptionGroup *); + extern gboolean g_unichar_isprint(gunichar); + extern GList *g_list_copy(GList *); + extern void g_cache_value_foreach(GCache *, GHFunc, gpointer); + extern void g_key_file_set_comment(GKeyFile *, const gchar *, + const gchar *, const gchar *, + GError * *); + extern gint g_ascii_digit_value(gchar); + extern void g_main_context_dispatch(GMainContext *); + extern GIOChannel *g_io_channel_new_file(const gchar *, const gchar *, + GError * *); + extern gint g_unichar_digit_value(gunichar); + extern void g_source_set_can_recurse(GSource *, gboolean); + extern void g_main_loop_unref(GMainLoop *); + extern GNode *g_node_first_sibling(GNode *); + extern gint g_date_days_between(const GDate *, const GDate *); + extern void g_mem_chunk_free(GMemChunk *, gpointer); + extern gchar *g_markup_escape_text(const gchar *, gssize); + extern gunichar g_unichar_tolower(gunichar); + extern void g_queue_push_nth_link(GQueue *, gint, GList *); + extern char *g_markup_printf_escaped(const char *, ...); + extern void g_hook_unref(GHookList *, GHook *); + extern GNode *g_node_find(GNode *, GTraverseType, GTraverseFlags, + gpointer); + extern gchar *g_ascii_formatd(gchar *, gint, const gchar *, gdouble); + extern gpointer g_scanner_scope_lookup_symbol(GScanner *, guint, + const gchar *); + extern gpointer g_dataset_id_remove_no_notify(gconstpointer, GQuark); + extern GQueue *g_queue_new(void); + extern GQuark g_markup_error_quark(void); + extern void g_option_context_set_ignore_unknown_options(GOptionContext + *, gboolean); + extern void g_completion_remove_items(GCompletion *, GList *); + extern void g_datalist_id_set_data_full(GData * *, GQuark, gpointer, + GDestroyNotify); + extern void g_trash_stack_push(GTrashStack * *, gpointer); + extern void g_async_queue_lock(GAsyncQueue *); + extern void g_ptr_array_sort(GPtrArray *, GCompareFunc); + extern void g_queue_free(GQueue *); + extern void g_array_sort_with_data(GArray *, GCompareDataFunc, + gpointer); + extern gboolean g_relation_exists(GRelation *, ...); + extern gboolean g_utf8_validate(const char *, gssize, const gchar * *); + extern void g_static_rw_lock_writer_unlock(GStaticRWLock *); + extern GByteArray *g_byte_array_remove_index(GByteArray *, guint); + extern guint g_hash_table_foreach_remove(GHashTable *, GHRFunc, + gpointer); + extern GString *g_string_insert_unichar(GString *, gssize, gunichar); + extern GSList *g_slist_prepend(GSList *, gpointer); + extern GList *g_list_first(GList *); + extern GMarkupParseContext *g_markup_parse_context_new(const + GMarkupParser *, + GMarkupParseFlags, + gpointer, + GDestroyNotify); + extern void g_io_channel_init(GIOChannel *); + extern GQuark g_convert_error_quark(void); + extern GNode *g_node_get_root(GNode *); + extern gchar *g_filename_display_name(const gchar *); + extern gint g_io_channel_unix_get_fd(GIOChannel *); + extern gboolean g_int_equal(gconstpointer, gconstpointer); + extern void g_hook_list_marshal_check(GHookList *, gboolean, + GHookCheckMarshaller, gpointer); + extern void g_static_mutex_init(GStaticMutex *); + extern GString *g_string_prepend_unichar(GString *, gunichar); + extern GList *g_queue_find_custom(GQueue *, gconstpointer, + GCompareFunc); + extern void g_key_file_set_string_list(GKeyFile *, const gchar *, + const gchar *, + const gchar * const *, gsize); + extern const guint glib_micro_version; + extern guint32 g_date_get_julian(const GDate *); + extern gpointer g_dataset_id_get_data(gconstpointer, GQuark); + extern gboolean g_date_valid_day(GDateDay); + extern GHook *g_hook_first_valid(GHookList *, gboolean); + extern GIOStatus g_io_channel_read_to_end(GIOChannel *, gchar * *, + gsize *, GError * *); + extern void g_scanner_destroy(GScanner *); + extern GString *g_string_insert_c(GString *, gssize, gchar); + extern void g_queue_push_head_link(GQueue *, GList *); + extern GIOChannel *g_io_channel_ref(GIOChannel *); + extern gpointer g_try_realloc(gpointer, gulong); + extern GRelation *g_relation_new(gint); + extern GNode *g_node_nth_child(GNode *, guint); + extern GByteArray *g_byte_array_sized_new(guint); + extern void g_queue_push_tail(GQueue *, gpointer); + extern gboolean g_unichar_validate(gunichar); + extern GSource *g_idle_source_new(void); + extern gchar **g_key_file_get_groups(GKeyFile *, gsize *); + extern void g_scanner_sync_file_offset(GScanner *); + extern GLogLevelFlags g_log_set_always_fatal(GLogLevelFlags); + extern gpointer *g_ptr_array_free(GPtrArray *, gboolean); + extern gint g_utf8_collate(const gchar *, const gchar *); + extern GPrintFunc g_set_print_handler(GPrintFunc); + extern const guint glib_interface_age; + extern void g_hook_list_invoke_check(GHookList *, gboolean); + extern gchar *g_utf8_offset_to_pointer(const gchar *, glong); + extern void g_scanner_input_file(GScanner *, gint); + extern gboolean g_source_get_can_recurse(GSource *); + extern GHook *g_hook_find_func_data(GHookList *, gboolean, gpointer, + gpointer); + extern void g_logv(const gchar *, GLogLevelFlags, const gchar *, + va_list); + extern gboolean g_error_matches(const GError *, GQuark, gint); + extern gpointer g_async_queue_pop(GAsyncQueue *); + extern gchar **g_uri_list_extract_uris(const gchar *); + extern gboolean g_static_rw_lock_writer_trylock(GStaticRWLock *); + extern void g_date_add_months(GDate *, guint); + extern void g_date_add_days(GDate *, guint); + extern gchar **g_strsplit(const gchar *, const gchar *, gint); + extern GSList *g_slist_remove_all(GSList *, gconstpointer); + extern gdouble g_random_double(void); + extern gdouble g_strtod(const gchar *, gchar * *); + extern void g_queue_sort(GQueue *, GCompareDataFunc, gpointer); + extern gboolean g_str_has_suffix(const gchar *, const gchar *); + extern GList *g_queue_pop_head_link(GQueue *); + extern gint32 g_rand_int_range(GRand *, gint32, gint32); + extern gint g_unichar_to_utf8(gunichar, gchar *); + extern gchar *g_strnfill(gsize, gchar); + extern void g_relation_print(GRelation *); + extern void g_key_file_set_integer_list(GKeyFile *, const gchar *, + const gchar *, gint *, gsize); + extern GSource + *g_main_context_find_source_by_funcs_user_data(GMainContext *, + GSourceFuncs *, + gpointer); + extern GDate *g_date_new_julian(guint32); + extern void g_node_traverse(GNode *, GTraverseType, GTraverseFlags, + gint, GNodeTraverseFunc, gpointer); + extern gchar *g_key_file_get_start_group(GKeyFile *); + extern void g_key_file_set_locale_string(GKeyFile *, const gchar *, + const gchar *, const gchar *, + const gchar *); + extern GHashTable *g_hash_table_new(GHashFunc, GEqualFunc); + extern const gchar *g_dir_read_name(GDir *); + extern gboolean g_hash_table_remove(GHashTable *, gconstpointer); + extern gchar *g_utf8_strdown(const gchar *, gssize); + extern GIOCondition g_io_channel_get_buffer_condition(GIOChannel *); + extern GSource *g_child_watch_source_new(GPid); + extern void g_static_rec_mutex_unlock(GStaticRecMutex *); + extern glong g_utf8_strlen(const gchar *, gssize); + extern GSList *g_slist_insert(GSList *, gpointer, gint); + extern GNode *g_node_prepend(GNode *, GNode *); + extern void g_propagate_error(GError * *, GError *); + extern GTokenType g_scanner_peek_next_token(GScanner *); + extern GArray *g_array_set_size(GArray *, guint); + extern GString *g_string_erase(GString *, gssize, gssize); + extern gchar *g_strcompress(const gchar *); + extern gint g_async_queue_length(GAsyncQueue *); + extern gboolean g_unichar_isdefined(gunichar); + extern GString *g_string_prepend(GString *, const gchar *); + extern guint32 g_rand_int(GRand *); + extern void g_set_error(GError * *, GQuark, gint, const gchar *, ...); + extern gboolean g_markup_parse_context_parse(GMarkupParseContext *, + const gchar *, gssize, + GError * *); + extern gboolean g_main_context_pending(GMainContext *); + extern gint g_tree_nnodes(GTree *); + extern gpointer g_datalist_id_get_data(GData * *, GQuark); + extern void g_ptr_array_sort_with_data(GPtrArray *, GCompareDataFunc, + gpointer); + extern void g_queue_unlink(GQueue *, GList *); + extern guint g_source_get_id(GSource *); + extern void g_thread_pool_set_max_threads(GThreadPool *, gint, + GError * *); + extern gchar *g_utf8_normalize(const gchar *, gssize, GNormalizeMode); + extern GTree *g_tree_new_with_data(GCompareDataFunc, gpointer); + extern gchar *g_path_get_dirname(const gchar *); + extern gint g_thread_pool_get_max_threads(GThreadPool *); + extern GArray *g_array_sized_new(gboolean, gboolean, guint, guint); + extern gboolean g_unichar_islower(gunichar); + extern GString *g_string_assign(GString *, const gchar *); + extern gchar *g_strstr_len(const gchar *, gssize, const gchar *); + extern GArray *g_array_prepend_vals(GArray *, gconstpointer, guint); + extern gdouble g_rand_double_range(GRand *, gdouble, gdouble); + extern void g_key_file_set_list_separator(GKeyFile *, gchar); + extern gboolean g_atomic_int_compare_and_exchange(gint *, gint, gint); + extern void g_mem_profile(void); + extern void g_io_channel_set_buffered(GIOChannel *, gboolean); + extern GMutex *g_static_mutex_get_mutex_impl(GMutex * *); + extern GList *g_list_remove_all(GList *, gconstpointer); + extern void g_static_private_set(GStaticPrivate *, gpointer, + GDestroyNotify); + extern void g_timer_start(GTimer *); + extern void g_array_sort(GArray *, GCompareFunc); + extern gchar *g_build_path(const gchar *, const gchar *, ...); + extern gchar *g_key_file_get_string(GKeyFile *, const gchar *, + const gchar *, GError * *); + extern void g_return_if_fail_warning(const char *, const char *, + const char *); + extern GAsyncQueue *g_async_queue_new(void); + extern GTokenType g_scanner_get_next_token(GScanner *); + extern gchar *g_strescape(const gchar *, const gchar *); + extern void g_tree_remove(GTree *, gconstpointer); + extern GFileError g_file_error_from_errno(gint); + extern GByteArray *g_byte_array_set_size(GByteArray *, guint); + extern GSList *g_slist_insert_before(GSList *, GSList *, gpointer); + extern void g_main_context_unref(GMainContext *); + extern void g_on_error_query(const gchar *); + extern gchar *g_find_program_in_path(const gchar *); + extern GNode *g_node_insert_before(GNode *, GNode *, GNode *); + extern void g_key_file_set_boolean(GKeyFile *, const gchar *, + const gchar *, gboolean); + extern void g_key_file_remove_key(GKeyFile *, const gchar *, + const gchar *, GError * *); + extern void g_dataset_foreach(gconstpointer, GDataForeachFunc, + gpointer); + extern const gchar *g_get_user_data_dir(void); + extern void g_date_subtract_months(GDate *, guint); + extern gboolean g_unichar_iscntrl(gunichar); + extern guint g_timeout_add_full(gint, guint, GSourceFunc, gpointer, + GDestroyNotify); + extern GIOStatus g_io_channel_read_chars(GIOChannel *, gchar *, gsize, + gsize *, GError * *); + extern gint g_bit_nth_msf(gulong, gint); + extern void g_tree_steal(GTree *, gconstpointer); + extern gboolean g_date_valid(const GDate *); + extern void g_io_channel_set_close_on_unref(GIOChannel *, gboolean); + extern void g_tree_replace(GTree *, gpointer, gpointer); + extern void g_async_queue_push_unlocked(GAsyncQueue *, gpointer); + extern GNode *g_node_new(gpointer); + extern void g_mem_set_vtable(GMemVTable *); + extern void g_option_context_add_main_entries(GOptionContext *, + const GOptionEntry *, + const gchar *); + extern void g_hash_table_foreach(GHashTable *, GHFunc, gpointer); + extern GUnicodeType g_unichar_type(gunichar); + extern GPtrArray *g_ptr_array_sized_new(guint); + extern GList *g_list_insert_sorted(GList *, gpointer, GCompareFunc); + extern GLogFunc g_log_set_default_handler(GLogFunc, gpointer); + extern gsize g_date_strftime(gchar *, gsize, const gchar *, + const GDate *); + extern gboolean + g_option_context_get_ignore_unknown_options(GOptionContext *); + extern gpointer g_static_private_get(GStaticPrivate *); + extern void g_completion_add_items(GCompletion *, GList *); + extern gchar *g_stpcpy(gchar *, const gchar *); + extern gchar *g_utf8_find_prev_char(const char *, const char *); + extern GOptionContext *g_option_context_new(const gchar *); + extern gchar *g_locale_to_utf8(const gchar *, gssize, gsize *, gsize *, + GError * *); + extern gint g_ascii_strncasecmp(const gchar *, const gchar *, gsize); + extern void g_slist_push_allocator(GAllocator *); + extern gboolean g_main_context_acquire(GMainContext *); + extern GSourceFuncs g_idle_funcs; + extern guint g_thread_pool_get_num_unused_threads(void); + extern void g_thread_pool_free(GThreadPool *, gboolean, gboolean); + extern guint g_date_get_sunday_week_of_year(const GDate *); + extern gdouble g_rand_double(GRand *); + extern gint g_ascii_strcasecmp(const gchar *, const gchar *); + extern void g_string_printf(GString *, const gchar *, ...); + extern GQuark g_quark_from_string(const gchar *); + extern void g_hash_table_replace(GHashTable *, gpointer, gpointer); + extern const gchar *g_strip_context(const gchar *, const gchar *); + extern const gchar *g_strerror(gint); + extern void g_mem_chunk_clean(GMemChunk *); + extern GString *g_string_prepend_len(GString *, const gchar *, gssize); + extern GArray *g_array_remove_range(GArray *, guint, guint); + extern void g_queue_remove_all(GQueue *, gconstpointer); + extern gint g_file_open_tmp(const gchar *, gchar * *, GError * *); + extern const gchar *g_get_user_name(void); + extern void g_timer_continue(GTimer *); + extern void g_main_context_set_poll_func(GMainContext *, GPollFunc); + extern void g_timer_destroy(GTimer *); + extern void g_main_context_add_poll(GMainContext *, GPollFD *, gint); + extern GSList *g_slist_alloc(void); + extern GSList *g_slist_reverse(GSList *); + extern GList *g_list_concat(GList *, GList *); + extern gunichar g_utf8_get_char(const gchar *); + extern gchar *g_shell_quote(const gchar *); + extern void g_get_current_time(GTimeVal *); + extern void g_option_group_set_translate_func(GOptionGroup *, + GTranslateFunc, gpointer, + GDestroyNotify); + extern gunichar g_unichar_totitle(gunichar); + extern gboolean g_spawn_async(const gchar *, gchar * *, gchar * *, + GSpawnFlags, GSpawnChildSetupFunc, + gpointer, GPid *, GError * *); + extern gchar *g_utf16_to_utf8(const gunichar2 *, glong, glong *, + glong *, GError * *); + extern void g_queue_insert_before(GQueue *, GList *, gpointer); + extern GSource *g_main_context_find_source_by_id(GMainContext *, + guint); + extern void g_mem_chunk_destroy(GMemChunk *); + extern void g_thread_exit(gpointer); + extern void g_option_group_set_parse_hooks(GOptionGroup *, + GOptionParseFunc, + GOptionParseFunc); + extern GSList *g_slist_insert_sorted(GSList *, gpointer, GCompareFunc); + extern void g_source_set_callback_indirect(GSource *, gpointer, + GSourceCallbackFuncs *); + extern GSList *g_slist_sort_with_data(GSList *, GCompareDataFunc, + gpointer); + extern void g_node_reverse_children(GNode *); + extern gpointer g_queue_peek_nth(GQueue *, guint); + extern void g_list_free(GList *); + extern GList *g_list_nth_prev(GList *, guint); + extern void g_strfreev(gchar * *); + extern gboolean g_ptr_array_remove(GPtrArray *, gpointer); + extern const guint glib_major_version; + extern glong g_utf8_pointer_to_offset(const gchar *, const gchar *); + extern gpointer g_tree_lookup(GTree *, gconstpointer); + extern gchar *g_strdup_printf(const gchar *, ...); + extern gboolean g_source_remove_by_user_data(gpointer); + extern gunichar2 *g_utf8_to_utf16(const gchar *, glong, glong *, + glong *, GError * *); + extern gunichar *g_utf8_to_ucs4(const gchar *, glong, glong *, glong *, + GError * *); + extern void g_date_set_day(GDate *, GDateDay); + extern gsize g_io_channel_get_buffer_size(GIOChannel *); + extern void g_hash_table_insert(GHashTable *, gpointer, gpointer); + extern guint g_spaced_primes_closest(guint); + extern void g_option_group_add_entries(GOptionGroup *, + const GOptionEntry *); + extern gboolean g_key_file_load_from_file(GKeyFile *, const gchar *, + GKeyFileFlags, GError * *); + extern gint32 g_random_int_range(gint32, gint32); + extern gpointer g_hash_table_lookup(GHashTable *, gconstpointer); + extern void g_relation_index(GRelation *, gint, GHashFunc, GEqualFunc); + extern GByteArray *g_byte_array_remove_range(GByteArray *, guint, + guint); + extern gchar *g_filename_from_utf8(const gchar *, gssize, gsize *, + gsize *, GError * *); + extern GQuark g_thread_error_quark(void); + extern void g_hook_destroy_link(GHookList *, GHook *); + extern gdouble g_random_double_range(gdouble, gdouble); + extern gchar *g_filename_from_uri(const gchar *, gchar * *, + GError * *); + extern gboolean g_tree_lookup_extended(GTree *, gconstpointer, + gpointer *, gpointer *); + extern gboolean g_unichar_iswide(gunichar); + extern gboolean g_unichar_isxdigit(gunichar); + extern void g_queue_push_tail_link(GQueue *, GList *); + extern void g_spawn_close_pid(GPid); + extern GRand *g_rand_new(void); + extern void g_date_set_julian(GDate *, guint32); + extern GNode *g_node_insert_after(GNode *, GNode *, GNode *); + extern const guint glib_binary_age; + extern void g_static_rec_mutex_lock_full(GStaticRecMutex *, guint); + extern GString *g_string_append_unichar(GString *, gunichar); + extern GStringChunk *g_string_chunk_new(gsize); + extern void g_atexit(GVoidFunc); + extern void g_scanner_scope_remove_symbol(GScanner *, guint, + const gchar *); + extern void g_main_context_remove_poll(GMainContext *, GPollFD *); + extern gchar *g_locale_from_utf8(const gchar *, gssize, gsize *, + gsize *, GError * *); + extern GMainContext *g_source_get_context(GSource *); + extern GSourceFuncs g_io_watch_funcs; + extern gint g_thread_pool_get_max_unused_threads(void); + extern gboolean g_unichar_isspace(gunichar); + extern GList *g_list_alloc(void); + extern gpointer g_queue_pop_tail(GQueue *); + extern gpointer g_thread_join(GThread *); + extern GSList *g_slist_append(GSList *, gpointer); + extern GNode *g_node_copy(GNode *); + extern void g_time_val_add(GTimeVal *, glong); + extern gboolean g_pattern_match(GPatternSpec *, guint, const gchar *, + const gchar *); + extern void g_source_remove_poll(GSource *, GPollFD *); + extern gsize g_printf_string_upper_bound(const gchar *, va_list); + extern GCompletion *g_completion_new(GCompletionFunc); + extern gboolean g_date_is_last_of_month(const GDate *); + extern GHook *g_hook_find(GHookList *, gboolean, GHookFindFunc, + gpointer); + extern gboolean g_static_rec_mutex_trylock(GStaticRecMutex *); + extern GError *g_error_new_literal(GQuark, gint, const gchar *); + extern void g_date_set_dmy(GDate *, GDateDay, GDateMonth, GDateYear); + extern guint g_node_max_height(GNode *); + extern gboolean g_unichar_isgraph(gunichar); + extern gint g_list_position(GList *, GList *); + extern gboolean g_pattern_match_simple(const gchar *, const gchar *); + extern const gchar *g_get_real_name(void); + extern void g_string_append_printf(GString *, const gchar *, ...); + extern void g_static_private_init(GStaticPrivate *); + extern gunichar *g_utf16_to_ucs4(const gunichar2 *, glong, glong *, + glong *, GError * *); + extern void g_rand_free(GRand *); + extern GList *g_queue_peek_tail_link(GQueue *); + extern gchar *g_convert_with_fallback(const gchar *, gssize, + const gchar *, const gchar *, + gchar *, gsize *, gsize *, + GError * *); + extern GSource *g_timeout_source_new(guint); + extern guint g_child_watch_add_full(gint, GPid, GChildWatchFunc, + gpointer, GDestroyNotify); + extern void g_node_push_allocator(GAllocator *); + extern void g_queue_foreach(GQueue *, GFunc, gpointer); + extern gchar *g_strdup(const gchar *); + extern gint g_queue_index(GQueue *, gconstpointer); + extern gpointer g_datalist_id_remove_no_notify(GData * *, GQuark); + extern guint8 *g_byte_array_free(GByteArray *, gboolean); + extern void g_date_clamp(GDate *, const GDate *, const GDate *); + extern void g_list_push_allocator(GAllocator *); + extern void g_queue_insert_after(GQueue *, GList *, gpointer); + extern gpointer g_try_malloc(gulong); + extern GIOFlags g_io_channel_get_flags(GIOChannel *); + extern gchar *g_filename_display_basename(const gchar *); + extern GList *g_list_append(GList *, gpointer); + extern gchar *g_utf8_strncpy(gchar *, const gchar *, gsize); + extern gchar **g_key_file_get_string_list(GKeyFile *, const gchar *, + const gchar *, gsize *, + GError * *); + extern guint g_log_set_handler(const gchar *, GLogLevelFlags, GLogFunc, + gpointer); + extern gboolean g_queue_is_empty(GQueue *); + extern GList *g_queue_peek_nth_link(GQueue *, guint); + extern void g_list_foreach(GList *, GFunc, gpointer); + extern gint g_ascii_xdigit_value(gchar); + extern GQuark g_shell_error_quark(void); + extern gpointer g_ptr_array_remove_index(GPtrArray *, guint); + extern GList *g_list_insert(GList *, gpointer, gint); + extern void g_log(const gchar *, GLogLevelFlags, const gchar *, ...); + extern gchar *g_utf8_strrchr(const char *, gssize, gunichar); + extern guint g_string_hash(const GString *); + extern gchar **g_key_file_get_locale_string_list(GKeyFile *, + const gchar *, + const gchar *, + const gchar *, + gsize *, GError * *); + extern void g_queue_insert_sorted(GQueue *, gpointer, GCompareDataFunc, + gpointer); + extern void g_hook_free(GHookList *, GHook *); + extern gpointer g_tree_search(GTree *, GCompareFunc, gconstpointer); + extern void g_scanner_scope_foreach_symbol(GScanner *, guint, GHFunc, + gpointer); + extern GDir *g_dir_open(const gchar *, guint, GError * *); + extern gchar *g_utf8_casefold(const gchar *, gssize); + extern void g_rand_set_seed_array(GRand *, const guint32 *, guint); + extern void g_date_to_struct_tm(const GDate *, struct tm *); + extern gboolean g_key_file_has_group(GKeyFile *, const gchar *); + extern GList *g_list_remove_link(GList *, GList *); + extern gboolean g_date_valid_month(GDateMonth); + extern gboolean g_spawn_command_line_sync(const gchar *, gchar * *, + gchar * *, gint *, + GError * *); + extern gpointer g_slist_nth_data(GSList *, guint); + extern gchar *g_convert(const gchar *, gssize, const gchar *, + const gchar *, gsize *, gsize *, GError * *); + extern void g_io_channel_unref(GIOChannel *); + extern void g_markup_parse_context_get_position(GMarkupParseContext *, + gint *, gint *); + extern void g_datalist_foreach(GData * *, GDataForeachFunc, gpointer); + extern void g_tuples_destroy(GTuples *); + extern guint g_strv_length(gchar * *); + extern gunichar g_unichar_toupper(gunichar); + extern void g_tree_insert(GTree *, gpointer, gpointer); + extern GNode *g_node_copy_deep(GNode *, GCopyFunc, gpointer); + extern gint g_node_child_position(GNode *, GNode *); + extern void g_list_pop_allocator(void); + extern gboolean g_mem_is_system_malloc(void); + extern const gchar *g_get_home_dir(void); + extern void g_async_queue_push(GAsyncQueue *, gpointer); + extern gboolean g_key_file_has_key(GKeyFile *, const gchar *, + const gchar *, GError * *); + extern gboolean g_file_get_contents(const gchar *, gchar * *, gsize *, + GError * *); + extern gboolean g_path_is_absolute(const gchar *); + extern void g_printerr(const gchar *, ...); + extern void g_completion_set_compare(GCompletion *, + GCompletionStrncmpFunc); + extern guint g_timeout_add(guint32, GSourceFunc, gpointer); + extern void g_slist_foreach(GSList *, GFunc, gpointer); + extern GArray *g_array_insert_vals(GArray *, guint, gconstpointer, + guint); + extern gchar *g_utf8_collate_key(const gchar *, gssize); + extern void g_static_rw_lock_reader_lock(GStaticRWLock *); + extern void g_mem_chunk_info(void); + extern gchar *g_utf8_strreverse(const gchar *, gssize); + extern GByteArray *g_byte_array_new(void); + extern gboolean g_setenv(const gchar *, const gchar *, gboolean); + extern gchar *g_get_current_dir(void); + extern GTree *g_tree_new(GCompareFunc); + extern gboolean g_unichar_isalpha(gunichar); + extern gsize g_strlcat(gchar *, const gchar *, gsize); + extern gboolean g_main_context_iteration(GMainContext *, gboolean); + extern GHook *g_hook_ref(GHookList *, GHook *); + extern GNode *g_node_find_child(GNode *, GTraverseFlags, gpointer); + extern void g_option_group_set_error_hook(GOptionGroup *, + GOptionErrorFunc); + extern gint g_bit_nth_lsf(gulong, gint); + extern gpointer g_async_queue_try_pop_unlocked(GAsyncQueue *); + extern GCache *g_cache_new(GCacheNewFunc, GCacheDestroyFunc, + GCacheDupFunc, GCacheDestroyFunc, GHashFunc, + GHashFunc, GEqualFunc); + extern void g_print(const gchar *, ...); + extern gint g_unichar_xdigit_value(gunichar); + extern GTimer *g_timer_new(void); + extern gchar *g_string_chunk_insert(GStringChunk *, const gchar *); + extern gchar *g_file_read_link(const gchar *, GError * *); + extern void g_assert_warning(const char *, const char *, const int, + const char *, const char *); + extern guint g_str_hash(gconstpointer); + extern void g_key_file_set_locale_string_list(GKeyFile *, + const gchar *, + const gchar *, + const gchar *, + const gchar * const *, + gsize); + extern GString *g_string_sized_new(gsize); + extern void g_hash_table_destroy(GHashTable *); + extern void g_static_mutex_free(GStaticMutex *); + extern gchar *g_ascii_strup(const gchar *, gssize); + extern gchar g_ascii_toupper(gchar); + extern guint g_date_get_iso8601_week_of_year(const GDate *); + extern void g_slist_free(GSList *); + extern gboolean g_string_equal(const GString *, const GString *); + extern guint g_scanner_cur_line(GScanner *); + extern gint g_date_compare(const GDate *, const GDate *); + extern GString *g_string_insert_len(GString *, gssize, const gchar *, + gssize); + extern gchar *g_strdelimit(gchar *, const gchar *, gchar); + extern guint g_node_n_children(GNode *); + extern GNode *g_node_last_sibling(GNode *); + extern const gchar *const *g_get_language_names(void); + extern GHook *g_hook_alloc(GHookList *); + extern GDateMonth g_date_get_month(const GDate *); + extern gboolean g_date_is_leap_year(GDateYear); + extern gpointer g_queue_pop_nth(GQueue *, guint); + extern gchar *g_strreverse(gchar *); + extern guint g_hash_table_size(GHashTable *); + extern gpointer g_mem_chunk_alloc(GMemChunk *); + extern GList *g_queue_peek_head_link(GQueue *); + extern GList *g_queue_find(GQueue *, gconstpointer); + extern void g_dataset_id_set_data_full(gconstpointer, GQuark, gpointer, + GDestroyNotify); + extern void g_unsetenv(const gchar *); + extern guint64 g_ascii_strtoull(const gchar *, gchar * *, guint); + extern gboolean g_spawn_command_line_async(const gchar *, GError * *); + extern GHook *g_hook_find_func(GHookList *, gboolean, gpointer); + extern gchar *g_array_free(GArray *, gboolean); + extern gpointer g_malloc0(gulong); + extern gint g_node_child_index(GNode *, gpointer); + extern GIOStatus g_io_channel_shutdown(GIOChannel *, gboolean, + GError * *); + extern GQuark g_quark_try_string(const gchar *); + extern GIOStatus g_io_channel_set_encoding(GIOChannel *, const gchar *, + GError * *); + extern gboolean g_scanner_eof(GScanner *); + extern void g_cache_destroy(GCache *); + extern gboolean g_spawn_sync(const gchar *, gchar * *, gchar * *, + GSpawnFlags, GSpawnChildSetupFunc, + gpointer, gchar * *, gchar * *, gint *, + GError * *); + extern gboolean g_static_rw_lock_reader_trylock(GStaticRWLock *); + extern void g_byte_array_sort(GByteArray *, GCompareFunc); + extern void g_atomic_int_add(gint *, gint); + extern gpointer g_async_queue_timed_pop(GAsyncQueue *, GTimeVal *); + extern GHook *g_hook_get(GHookList *, gulong); + extern void g_option_context_set_help_enabled(GOptionContext *, + gboolean); + extern guint g_static_rec_mutex_unlock_full(GStaticRecMutex *); + extern gboolean g_hash_table_lookup_extended(GHashTable *, + gconstpointer, gpointer *, + gpointer *); + extern void g_date_add_years(GDate *, guint); + extern void g_static_private_free(GStaticPrivate *); + extern const gchar *g_quark_to_string(GQuark); + extern GList *g_list_prepend(GList *, gpointer); + extern gchar *g_utf8_find_next_char(const gchar *, const gchar *); + extern void g_static_rw_lock_writer_lock(GStaticRWLock *); + extern GIOStatus g_io_channel_read_line(GIOChannel *, gchar * *, + gsize *, gsize *, GError * *); + extern void g_thread_pool_stop_unused_threads(void); + extern const gchar *const *g_get_system_data_dirs(void); + extern GLogLevelFlags g_log_set_fatal_mask(const gchar *, + GLogLevelFlags); + extern GMainContext *g_main_loop_get_context(GMainLoop *); + extern gpointer g_malloc(gulong); + extern GIOStatus g_io_channel_flush(GIOChannel *, GError * *); + extern gboolean g_file_test(const gchar *, GFileTest); + extern void g_key_file_set_integer(GKeyFile *, const gchar *, + const gchar *, gint); + extern void g_date_set_year(GDate *, GDateYear); + extern gpointer g_once_impl(GOnce *, GThreadFunc, gpointer); + extern void g_usleep(gulong); + extern void g_thread_pool_push(GThreadPool *, gpointer, GError * *); + extern void g_key_file_remove_comment(GKeyFile *, const gchar *, + const gchar *, GError * *); + extern GTuples *g_relation_select(GRelation *, gconstpointer, gint); + extern gboolean g_unichar_istitle(gunichar); + extern gchar *g_strrstr(const gchar *, const gchar *); + extern GQuark g_spawn_error_quark(void); + extern GTokenType g_scanner_cur_token(GScanner *); + extern void g_date_free(GDate *); + extern gboolean g_io_channel_get_close_on_unref(GIOChannel *); + extern GScanner *g_scanner_new(const GScannerConfig *); + extern guint g_node_n_nodes(GNode *, GTraverseFlags); + extern gint g_tree_height(GTree *); + extern gboolean g_str_has_prefix(const gchar *, const gchar *); + extern gunichar g_utf8_get_char_validated(const gchar *, gssize); + extern void g_scanner_unexp_token(GScanner *, GTokenType, + const gchar *, const gchar *, + const gchar *, const gchar *, gint); + extern GString *g_string_prepend_c(GString *, gchar); + extern void g_relation_destroy(GRelation *); + extern guint g_hash_table_foreach_steal(GHashTable *, GHRFunc, + gpointer); + extern void g_free(gpointer); + extern guint g_int_hash(gconstpointer); + extern gboolean g_threads_got_initialized; + extern void g_source_get_current_time(GSource *, GTimeVal *); + extern GList *g_queue_pop_tail_link(GQueue *); + extern GString *g_string_new(const gchar *); + extern void g_key_file_set_boolean_list(GKeyFile *, const gchar *, + const gchar *, gboolean *, + gsize); + extern GString *g_string_append(GString *, const gchar *); + extern GByteArray *g_byte_array_append(GByteArray *, const guint8 *, + guint); + extern void g_key_file_set_value(GKeyFile *, const gchar *, + const gchar *, const gchar *); + extern gboolean g_pattern_spec_equal(GPatternSpec *, GPatternSpec *); + extern GMainContext *g_main_context_new(void); + extern gboolean g_unichar_ispunct(gunichar); + extern guint8 g_date_get_sunday_weeks_in_year(GDateYear); + extern void g_date_subtract_days(GDate *, guint); + extern gboolean g_date_valid_weekday(GDateWeekday); + extern gchar **g_strsplit_set(const gchar *, const gchar *, gint); + extern void g_dataset_destroy(gconstpointer); + extern gpointer g_async_queue_pop_unlocked(GAsyncQueue *); + extern guint g_scanner_cur_position(GScanner *); + extern guint g_date_get_day_of_year(const GDate *); + extern GList *g_list_find_custom(GList *, gconstpointer, GCompareFunc); + extern void g_source_unref(GSource *); + extern GSList *g_slist_remove_link(GSList *, GSList *); + extern GDateDay g_date_get_day(const GDate *); + extern gboolean g_option_context_parse(GOptionContext *, gint *, + gchar * **, GError * *); + extern void g_tree_foreach(GTree *, GTraverseFunc, gpointer); + extern void g_string_chunk_free(GStringChunk *); + extern gchar *g_strjoinv(const gchar *, gchar * *); + extern GString *g_string_append_c(GString *, gchar); + extern GString *g_string_truncate(GString *, gsize); + extern const gchar *g_get_tmp_dir(void); + extern void g_scanner_input_text(GScanner *, const gchar *, guint); + extern gpointer g_list_nth_data(GList *, guint); + extern GNode *g_node_last_child(GNode *); + extern gboolean g_node_is_ancestor(GNode *, GNode *); + extern GString *g_string_ascii_down(GString *); + extern void g_blow_chunks(void); + extern gboolean g_unichar_get_mirror_char(gunichar, gunichar *); + extern GOptionGroup *g_option_group_new(const gchar *, const gchar *, + const gchar *, gpointer, + GDestroyNotify); + extern const gchar *g_get_user_cache_dir(void); + extern gboolean *g_key_file_get_boolean_list(GKeyFile *, const gchar *, + const gchar *, gsize *, + GError * *); + extern void g_scanner_warn(GScanner *, const gchar *, ...); + extern void g_queue_delete_link(GQueue *, GList *); + extern guint g_direct_hash(gconstpointer); + extern GSList *g_slist_find_custom(GSList *, gconstpointer, + GCompareFunc); + extern GTokenValue g_scanner_cur_value(GScanner *); + extern guint8 g_date_get_days_in_month(GDateMonth, GDateYear); + extern gboolean g_get_charset(const char **); + extern gboolean g_unichar_isalnum(gunichar); + extern GList *g_list_reverse(GList *); + extern void g_hook_insert_sorted(GHookList *, GHook *, + GHookCompareFunc); + extern guint g_source_attach(GSource *, GMainContext *); + extern gchar *g_strconcat(const gchar *, ...); + extern void g_nullify_pointer(gpointer *); + extern void g_ptr_array_remove_range(GPtrArray *, guint, guint); + extern void g_static_rw_lock_free(GStaticRWLock *); + extern GString *g_string_new_len(const gchar *, gssize); + extern GList *g_list_insert_before(GList *, GList *, gpointer); + extern void g_date_set_parse(GDate *, const gchar *); + extern void g_log_remove_handler(const gchar *, guint); + extern gboolean g_str_equal(gconstpointer, gconstpointer); + extern GMainLoop *g_main_loop_ref(GMainLoop *); + extern gchar *g_ucs4_to_utf8(const gunichar *, glong, glong *, glong *, + GError * *); + extern gpointer g_memdup(gconstpointer, guint); + extern GAllocator *g_allocator_new(const gchar *, guint); + extern GList *g_completion_complete_utf8(GCompletion *, const gchar *, + gchar * *); + extern void g_main_loop_run(GMainLoop *); + extern void g_scanner_error(GScanner *, const gchar *, ...); + extern void g_mem_chunk_reset(GMemChunk *); + extern GThread *g_thread_create_full(GThreadFunc, gpointer, gulong, + gboolean, gboolean, + GThreadPriority, GError * *); + extern gboolean g_date_is_first_of_month(const GDate *); + extern gunichar *g_utf8_to_ucs4_fast(const gchar *, glong, glong *); + extern void g_queue_reverse(GQueue *); + extern void g_node_children_foreach(GNode *, GTraverseFlags, + GNodeForeachFunc, gpointer); + extern void g_timer_stop(GTimer *); + extern GSourceFuncs g_timeout_funcs; + extern gboolean g_main_context_wait(GMainContext *, GCond *, GMutex *); + extern void g_set_prgname(const gchar *); + extern void g_allocator_free(GAllocator *); + extern const gchar + *g_markup_parse_context_get_element(GMarkupParseContext *); + extern guint g_parse_debug_string(const gchar *, const GDebugKey *, + guint); + extern void g_error_free(GError *); + extern gchar *g_string_chunk_insert_len(GStringChunk *, const gchar *, + gssize); + extern GArray *g_array_new(gboolean, gboolean, guint); + extern GDate *g_date_new_dmy(GDateDay, GDateMonth, GDateYear); + extern GMemVTable *glib_mem_profiler_table; + extern void g_qsort_with_data(gconstpointer, gint, gsize, + GCompareDataFunc, gpointer); + extern gboolean g_shell_parse_argv(const gchar *, gint *, gchar * **, + GError * *); + extern gchar *g_strchomp(gchar *); + extern guint32 g_random_int(void); + extern void g_option_context_set_main_group(GOptionContext *, + GOptionGroup *); + extern void g_date_clear(GDate *, guint); + extern GIOStatus g_io_channel_read_unichar(GIOChannel *, gunichar *, + GError * *); + extern GList *g_list_nth(GList *, guint); + extern void g_node_destroy(GNode *); + extern const gchar *glib_check_version(guint, guint, guint); + extern GThread *g_thread_self(void); + extern GList *g_list_sort_with_data(GList *, GCompareDataFunc, + gpointer); + extern void g_io_channel_set_line_term(GIOChannel *, const gchar *, + gint); + extern GIOChannel *g_io_channel_unix_new(gint); + extern GThreadFunctions g_thread_functions_for_glib_use; + extern GString *g_string_insert(GString *, gssize, const gchar *); + extern gpointer g_trash_stack_pop(GTrashStack * *); + extern void g_hook_list_marshal(GHookList *, gboolean, GHookMarshaller, + gpointer); + extern size_t g_iconv(GIConv, gchar * *, gsize *, gchar * *, gsize *); + extern void g_queue_remove(GQueue *, gconstpointer); + extern const gchar *g_path_skip_root(const gchar *); + extern gint g_queue_link_index(GQueue *, GList *); + extern gpointer g_tuples_index(GTuples *, gint, gint); + extern GIOChannelError g_io_channel_error_from_errno(gint); + extern void g_main_context_wakeup(GMainContext *); + extern gboolean g_direct_equal(gconstpointer, gconstpointer); + extern GSource *g_source_new(GSourceFuncs *, guint); + extern gboolean g_idle_remove_by_data(gpointer); + extern void g_io_channel_set_buffer_size(GIOChannel *, gsize); + extern guint g_io_add_watch_full(GIOChannel *, gint, GIOCondition, + GIOFunc, gpointer, GDestroyNotify); + extern void g_dir_rewind(GDir *); + extern GSourceFuncs g_child_watch_funcs; + extern gint g_iconv_close(GIConv); + extern gchar *g_ascii_strdown(const gchar *, gssize); + extern gchar *g_key_file_get_locale_string(GKeyFile *, const gchar *, + const gchar *, + const gchar *, GError * *); + extern GQueue *g_queue_copy(GQueue *); + extern guint g_node_depth(GNode *); + extern const gchar *g_strsignal(gint); + extern GSList *g_slist_concat(GSList *, GSList *); + extern gboolean g_source_remove_by_funcs_user_data(GSourceFuncs *, + gpointer); + extern GSource *g_io_create_watch(GIOChannel *, GIOCondition); + extern gpointer g_cache_insert(GCache *, gpointer); + extern gpointer g_scanner_lookup_symbol(GScanner *, const gchar *); + extern GIOStatus g_io_channel_seek_position(GIOChannel *, gint64, + GSeekType, GError * *); + extern gboolean g_thread_use_default_impl; + extern guint g_io_add_watch(GIOChannel *, GIOCondition, GIOFunc, + gpointer); + extern GSource *g_main_context_find_source_by_user_data(GMainContext *, + gpointer); + extern GIConv g_iconv_open(const gchar *, const gchar *); + extern gchar *g_strdup_vprintf(const gchar *, va_list); + extern void g_datalist_clear(GData * *); + extern void g_static_rw_lock_reader_unlock(GStaticRWLock *); + extern gsize g_strlcpy(gchar *, const gchar *, gsize); + extern GRand *g_rand_new_with_seed(guint32); + extern guint g_thread_pool_unprocessed(GThreadPool *); + extern GQuark g_file_error_quark(void); + extern gdouble g_ascii_strtod(const gchar *, gchar * *); + extern GByteArray *g_byte_array_prepend(GByteArray *, const guint8 *, + guint); + extern GQuark g_quark_from_static_string(const gchar *); + extern void g_unicode_canonical_ordering(gunichar *, gsize); + extern gboolean g_ptr_array_remove_fast(GPtrArray *, gpointer); + extern gint g_list_index(GList *, gconstpointer); + extern void g_tree_destroy(GTree *); + extern GDate *g_date_new(void); + extern void g_thread_init_with_errorcheck_mutexes(GThreadFunctions *); + extern void g_thread_init(GThreadFunctions *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/glib-2.0/glib/gprintf.h b/lsb-build/headers/glib-2.0/glib/gprintf.h new file mode 100644 index 0000000..62babc8 --- /dev/null +++ b/lsb-build/headers/glib-2.0/glib/gprintf.h @@ -0,0 +1,28 @@ +#ifndef _GLIB_2_0_GLIB_GPRINTF_H_ +#define _GLIB_2_0_GLIB_GPRINTF_H_ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + + + + + extern gint g_sprintf(gchar *, const gchar *, ...); + extern gint g_fprintf(FILE *, const gchar *, ...); + extern gint g_vasprintf(gchar * *, const gchar *, va_list); + extern gint g_vprintf(const gchar *, va_list); + extern gint g_printf(const gchar *, ...); + extern gint g_vfprintf(FILE *, const gchar *, va_list); + extern gint g_vsnprintf(gchar *, gulong, const gchar *, va_list); + extern gint g_vsprintf(gchar *, const gchar *, va_list); + extern gint g_snprintf(gchar *, gulong, const gchar *, ...); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/glib-2.0/glib/gstdio.h b/lsb-build/headers/glib-2.0/glib/gstdio.h new file mode 100644 index 0000000..7f1467a --- /dev/null +++ b/lsb-build/headers/glib-2.0/glib/gstdio.h @@ -0,0 +1,26 @@ +#ifndef _GLIB_2_0_GLIB_GSTDIO_H_ +#define _GLIB_2_0_GLIB_GSTDIO_H_ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#define g_fopen fopen +#define g_freopen freopen +#define g_lstat lstat +#define g_mkdir mkdir +#define g_open open +#define g_remove remove +#define g_rename rename +#define g_rmdir rmdir +#define g_stat stat +#define g_unlink unlink + + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/glib-2.0/gmodule.h b/lsb-build/headers/glib-2.0/gmodule.h new file mode 100644 index 0000000..d8e0225 --- /dev/null +++ b/lsb-build/headers/glib-2.0/gmodule.h @@ -0,0 +1,42 @@ +#ifndef _GLIB_2_0_GMODULE_H_ +#define _GLIB_2_0_GMODULE_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define G_MODULE_EXPORT +#define G_MODULE_IMPORT extern + + + typedef struct _GModule GModule; + + typedef enum { + G_MODULE_BIND_LAZY = 1, + G_MODULE_BIND_LOCAL = 2, + G_MODULE_BIND_MASK = 3 + } GModuleFlags; + + typedef void (*GModuleUnload) (GModule *); + + typedef const gchar *(*GModuleCheckInit) (GModule *); + + + + + + extern void g_module_make_resident(GModule *); + extern gchar *g_module_build_path(const gchar *, const gchar *); + extern gboolean g_module_close(GModule *); + extern GModule *g_module_open(const gchar *, GModuleFlags); + extern gboolean g_module_symbol(GModule *, const gchar *, gpointer *); + extern const gchar *g_module_error(void); + extern const gchar *g_module_name(GModule *); + extern gboolean g_module_supported(void); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/glib-2.0/gobject/gvaluecollector.h b/lsb-build/headers/glib-2.0/gobject/gvaluecollector.h new file mode 100644 index 0000000..2284003 --- /dev/null +++ b/lsb-build/headers/glib-2.0/gobject/gvaluecollector.h @@ -0,0 +1,61 @@ +#ifndef _GLIB_2_0_GOBJECT_GVALUECOLLECTOR_H_ +#define _GLIB_2_0_GOBJECT_GVALUECOLLECTOR_H_ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#define G_VALUE_LCOPY(value,var_args,flags,__error) \ + G_STMT_START { const GValue *_value = (value); guint _flags = \ + (flags); GType _value_type = G_VALUE_TYPE (_value); GTypeValueTable \ + *_vtable = g_type_value_table_peek (_value_type); gchar *_lcopy_format \ + = _vtable->lcopy_format; GTypeCValue \ + _cvalues[G_VALUE_COLLECT_FORMAT_MAX_LENGTH] = { { 0, }, }; guint \ + _n_values = 0; while (*_lcopy_format) { GTypeCValue *_cvalue = \ + _cvalues + _n_values++; switch (*_lcopy_format++) { case \ + G_VALUE_COLLECT_INT: _cvalue->v_int = va_arg ((var_args), gint); \ + break; case G_VALUE_COLLECT_LONG: _cvalue->v_long = va_arg \ + ((var_args), glong); break; case G_VALUE_COLLECT_INT64: \ + _cvalue->v_int64 = va_arg ((var_args), gint64); break; case \ + G_VALUE_COLLECT_DOUBLE: _cvalue->v_double = va_arg ((var_args), \ + gdouble); break; case G_VALUE_COLLECT_POINTER: _cvalue->v_pointer = \ + va_arg ((var_args), gpointer); break; default: g_assert_not_reached \ + (); } } *(__error) = _vtable->lcopy_value (_value, _n_values, \ + _cvalues, _flags); } G_STMT_END +#define G_VALUE_COLLECT(value,var_args,flags,__error) \ + G_STMT_START { GValue *_value = (value); guint _flags = (flags); \ + GType _value_type = G_VALUE_TYPE (_value); GTypeValueTable *_vtable = \ + g_type_value_table_peek (_value_type); gchar *_collect_format = \ + _vtable->collect_format; GTypeCValue \ + _cvalues[G_VALUE_COLLECT_FORMAT_MAX_LENGTH] = { { 0, }, }; guint \ + _n_values = 0; if (_vtable->value_free) _vtable->value_free (_value); \ + _value->g_type = _value_type; memset (_value->data, 0, sizeof \ + (_value->data)); while (*_collect_format) { GTypeCValue *_cvalue = \ + _cvalues + _n_values++; switch (*_collect_format++) { case \ + G_VALUE_COLLECT_INT: _cvalue->v_int = va_arg ((var_args), gint); \ + break; case G_VALUE_COLLECT_LONG: _cvalue->v_long = va_arg \ + ((var_args), glong); break; case G_VALUE_COLLECT_INT64: \ + _cvalue->v_int64 = va_arg ((var_args), gint64); break; case \ + G_VALUE_COLLECT_DOUBLE: _cvalue->v_double = va_arg ((var_args), \ + gdouble); break; case G_VALUE_COLLECT_POINTER: _cvalue->v_pointer = \ + va_arg ((var_args), gpointer); break; default: g_assert_not_reached \ + (); } } *(__error) = _vtable->collect_value (_value, _n_values, \ + _cvalues, _flags); } G_STMT_END +#define G_VALUE_COLLECT_FORMAT_MAX_LENGTH (8) + + + enum { + G_VALUE_COLLECT_INT = 'i', + G_VALUE_COLLECT_LONG = 'l', + G_VALUE_COLLECT_INT64 = 'q', + G_VALUE_COLLECT_DOUBLE = 'd', + G_VALUE_COLLECT_POINTER = 'p' + }; + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/gtk-2.0/gdk-pixbuf-xlib/gdk-pixbuf-xlib.h b/lsb-build/headers/gtk-2.0/gdk-pixbuf-xlib/gdk-pixbuf-xlib.h new file mode 100644 index 0000000..6542147 --- /dev/null +++ b/lsb-build/headers/gtk-2.0/gdk-pixbuf-xlib/gdk-pixbuf-xlib.h @@ -0,0 +1,91 @@ +#ifndef _GTK_2_0_GDK_PIXBUF_XLIB_GDK_PIXBUF_XLIB_H_ +#define _GTK_2_0_GDK_PIXBUF_XLIB_GDK_PIXBUF_XLIB_H_ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + + + + typedef enum { + XLIB_RGB_DITHER_NONE = 0, + XLIB_RGB_DITHER_NORMAL = 1, + XLIB_RGB_DITHER_MAX = 2 + } XlibRgbDither; + + typedef struct _XlibRgbCmap XlibRgbCmap; + + + struct _XlibRgbCmap { + unsigned int colors[256]; + unsigned char lut[256]; + }; + + + extern void gdk_pixbuf_xlib_init_with_depth(Display *, int, int); + extern Visual *xlib_rgb_get_visual(void); + extern void gdk_pixbuf_xlib_render_to_drawable(GdkPixbuf *, Drawable, + GC, int, int, int, int, + int, int, XlibRgbDither, + int, int); + extern GdkPixbuf *gdk_pixbuf_xlib_get_from_drawable(GdkPixbuf *, + Drawable, Colormap, + Visual *, int, int, + int, int, int, + int); + extern XVisualInfo *xlib_rgb_get_visual_info(void); + extern void xlib_rgb_set_install(int); + extern void xlib_rgb_cmap_free(XlibRgbCmap *); + extern int xlib_rgb_get_depth(void); + extern long unsigned int xlib_rgb_xpixel_from_rgb(guint32); + extern void xlib_rgb_gc_set_foreground(GC, guint32); + extern void xlib_rgb_set_verbose(int); + extern int xlib_rgb_ditherable(void); + extern void xlib_rgb_set_min_colors(int); + extern void gdk_pixbuf_xlib_render_threshold_alpha(GdkPixbuf *, Pixmap, + int, int, int, int, + int, int, int); + extern Display *xlib_rgb_get_display(void); + extern void xlib_rgb_init(Display *, Screen *); + extern void gdk_pixbuf_xlib_init(Display *, int); + extern Screen *xlib_rgb_get_screen(void); + extern Colormap xlib_rgb_get_cmap(void); + extern void xlib_draw_gray_image(Drawable, GC, int, int, int, int, + XlibRgbDither, unsigned char *, int); + extern void xlib_draw_indexed_image(Drawable, GC, int, int, int, int, + XlibRgbDither, unsigned char *, + int, XlibRgbCmap *); + extern XlibRgbCmap *xlib_rgb_cmap_new(guint32 *, int); + extern void xlib_draw_rgb_32_image(Drawable, GC, int, int, int, int, + XlibRgbDither, unsigned char *, + int); + extern void xlib_draw_rgb_image_dithalign(Drawable, GC, int, int, int, + int, XlibRgbDither, + unsigned char *, int, int, + int); + extern void xlib_rgb_gc_set_background(GC, guint32); + extern void gdk_pixbuf_xlib_render_pixmap_and_mask(GdkPixbuf *, + Pixmap *, Pixmap *, + int); + extern void gdk_pixbuf_xlib_render_to_drawable_alpha(GdkPixbuf *, + Drawable, int, + int, int, int, + int, int, + GdkPixbufAlphaMode, + int, + XlibRgbDither, + int, int); + extern void xlib_draw_rgb_image(Drawable, GC, int, int, int, int, + XlibRgbDither, unsigned char *, int); + extern void xlib_rgb_init_with_depth(Display *, Screen *, int); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/gtk-2.0/gdk-pixbuf/gdk-pixbuf.h b/lsb-build/headers/gtk-2.0/gdk-pixbuf/gdk-pixbuf.h new file mode 100644 index 0000000..45d5bb1 --- /dev/null +++ b/lsb-build/headers/gtk-2.0/gdk-pixbuf/gdk-pixbuf.h @@ -0,0 +1,284 @@ +#ifndef _GTK_2_0_GDK_PIXBUF_GDK_PIXBUF_H_ +#define _GTK_2_0_GDK_PIXBUF_GDK_PIXBUF_H_ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define GDK_TYPE_PIXBUF_ANIMATION_ITER \ + (gdk_pixbuf_animation_iter_get_type ()) +#define GDK_PIXBUF_LOADER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_LOADER, \ + GdkPixbufLoaderClass)) +#define GDK_IS_PIXBUF_LOADER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_LOADER)) +#define GDK_PIXBUF_LOADER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_PIXBUF_LOADER, \ + GdkPixbufLoader)) +#define GDK_PIXBUF(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF, GdkPixbuf)) +#define GDK_PIXBUF_ANIMATION(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_ANIMATION, \ + GdkPixbufAnimation)) +#define GDK_PIXBUF_ANIMATION_ITER(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), \ + GDK_TYPE_PIXBUF_ANIMATION_ITER, GdkPixbufAnimationIter)) +#define GDK_IS_PIXBUF_LOADER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_PIXBUF_LOADER)) +#define GDK_IS_PIXBUF(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF)) +#define GDK_IS_PIXBUF_ANIMATION(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_ANIMATION)) +#define GDK_IS_PIXBUF_ANIMATION_ITER(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), \ + GDK_TYPE_PIXBUF_ANIMATION_ITER)) +#define GDK_PIXBUF_LOADER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_LOADER, \ + GdkPixbufLoaderClass)) +#define GDK_PIXBUF_MICRO (10) +#define GDK_PIXBUF_MAJOR (2) +#define GDK_PIXBUF_MINOR (6) +#define GDK_TYPE_COLORSPACE (gdk_colorspace_get_type()) +#define GDK_TYPE_INTERP_TYPE (gdk_interp_type_get_type()) +#define GDK_TYPE_PIXBUF_ALPHA_MODE (gdk_pixbuf_alpha_mode_get_type()) +#define GDK_TYPE_PIXBUF_ANIMATION (gdk_pixbuf_animation_get_type ()) +#define GDK_TYPE_PIXBUF_ERROR (gdk_pixbuf_error_get_type()) +#define GDK_TYPE_PIXBUF (gdk_pixbuf_get_type ()) +#define GDK_TYPE_PIXBUF_LOADER (gdk_pixbuf_loader_get_type ()) +#define GDK_TYPE_PIXBUF_ROTATION (gdk_pixbuf_rotation_get_type()) +#define GDK_PIXBUF_VERSION "2.6.10" +#define GDK_PIXBUF_VAR extern +#define GDK_PIXBUF_ERROR gdk_pixbuf_error_quark () + + + typedef struct _GdkPixbuf GdkPixbuf; + + typedef gboolean(*GdkPixbufSaveFunc) (const gchar *, gsize, GError * *, + gpointer); + + typedef struct _GdkPixbufLoader GdkPixbufLoader; + + typedef struct _GdkPixbufFormat GdkPixbufFormat; + + typedef enum { + GDK_INTERP_NEAREST = 0, + GDK_INTERP_TILES = 1, + GDK_INTERP_BILINEAR = 2, + GDK_INTERP_HYPER = 3 + } GdkInterpType; + + typedef enum { + GDK_COLORSPACE_RGB = 0 + } GdkColorspace; + + typedef void (*GdkPixbufDestroyNotify) (guchar *, gpointer); + + typedef struct _GdkPixbufAnimationIter GdkPixbufAnimationIter; + + typedef struct _GdkPixbufAnimation GdkPixbufAnimation; + + typedef enum { + GDK_PIXBUF_ROTATE_NONE = 0, + GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE = 90, + GDK_PIXBUF_ROTATE_UPSIDEDOWN = 180, + GDK_PIXBUF_ROTATE_CLOCKWISE = 270 + } GdkPixbufRotation; + + typedef struct _GdkPixbufLoaderClass GdkPixbufLoaderClass; + + typedef enum { + GDK_PIXBUF_ERROR_CORRUPT_IMAGE, + GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, + GDK_PIXBUF_ERROR_BAD_OPTION, + GDK_PIXBUF_ERROR_UNKNOWN_TYPE, + GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION, + GDK_PIXBUF_ERROR_FAILED + } GdkPixbufError; + + typedef enum { + GDK_PIXBUF_ALPHA_BILEVEL, + GDK_PIXBUF_ALPHA_FULL + } GdkPixbufAlphaMode; + + + + + + struct _GdkPixbufLoader { + GObject parent_instance; + gpointer priv; + }; + + + + + + + + + + + + struct _GdkPixbufLoaderClass { + GObjectClass parent_class; + void (*size_prepared) (GdkPixbufLoader *, int, int); + void (*area_prepared) (GdkPixbufLoader *); + void (*area_updated) (GdkPixbufLoader *, int, int, int, int); + void (*closed) (GdkPixbufLoader *); + }; + + + extern gboolean gdk_pixbuf_save_to_callbackv(GdkPixbuf *, + GdkPixbufSaveFunc, + gpointer, const char *, + char **, char **, + GError * *); + extern gboolean gdk_pixbuf_save_to_bufferv(GdkPixbuf *, gchar * *, + gsize *, const char *, + char **, char **, + GError * *); + extern GdkPixbuf *gdk_pixbuf_new_from_file_at_scale(const char *, int, + int, gboolean, + GError * *); + extern GdkPixbufLoader *gdk_pixbuf_loader_new_with_type(const char *, + GError * *); + extern GSList *gdk_pixbuf_get_formats(void); + extern guchar *gdk_pixbuf_get_pixels(const GdkPixbuf *); + extern const guint gdk_pixbuf_minor_version; + extern void gdk_pixbuf_format_set_disabled(GdkPixbufFormat *, + gboolean); + extern gboolean gdk_pixbuf_format_is_scalable(GdkPixbufFormat *); + extern int gdk_pixbuf_get_n_channels(const GdkPixbuf *); + extern GdkPixbuf *gdk_pixbuf_scale_simple(const GdkPixbuf *, int, int, + GdkInterpType); + extern GdkPixbuf *gdk_pixbuf_new_from_data(const guchar *, + GdkColorspace, gboolean, + int, int, int, int, + GdkPixbufDestroyNotify, + gpointer); + extern gboolean gdk_pixbuf_loader_close(GdkPixbufLoader *, GError * *); + extern GType gdk_pixbuf_animation_get_type(void); + extern gboolean gdk_pixbuf_save_to_buffer(GdkPixbuf *, gchar * *, + gsize *, const char *, + GError * *, ...); + extern GType gdk_interp_type_get_type(void); + extern GdkPixbuf *gdk_pixbuf_new_from_file_at_size(const char *, int, + int, GError * *); + extern GdkPixbuf *gdk_pixbuf_new_from_xpm_data(const char **); + extern GdkPixbufLoader *gdk_pixbuf_loader_new(void); + extern gboolean gdk_pixbuf_save_to_callback(GdkPixbuf *, + GdkPixbufSaveFunc, + gpointer, const char *, + GError * *, ...); + extern GdkPixbuf *gdk_pixbuf_add_alpha(const GdkPixbuf *, gboolean, + guchar, guchar, guchar); + extern gboolean + gdk_pixbuf_animation_iter_advance(GdkPixbufAnimationIter *, + const GTimeVal *); + extern void gdk_pixbuf_saturate_and_pixelate(const GdkPixbuf *, + GdkPixbuf *, gfloat, + gboolean); + extern GType gdk_pixbuf_animation_iter_get_type(void); + extern int gdk_pixbuf_get_bits_per_sample(const GdkPixbuf *); + extern GdkPixbuf *gdk_pixbuf_new_from_inline(gint, const guint8 *, + gboolean, GError * *); + extern const guint gdk_pixbuf_major_version; + extern GdkPixbuf + *gdk_pixbuf_animation_get_static_image(GdkPixbufAnimation *); + extern const guint gdk_pixbuf_micro_version; + extern int gdk_pixbuf_get_height(const GdkPixbuf *); + extern GdkPixbuf *gdk_pixbuf_flip(const GdkPixbuf *, gboolean); + extern GdkPixbufAnimationIter + *gdk_pixbuf_animation_get_iter(GdkPixbufAnimation *, + const GTimeVal *); + extern gboolean + gdk_pixbuf_animation_iter_on_currently_loading_frame + (GdkPixbufAnimationIter *); + extern GdkPixbufAnimation + *gdk_pixbuf_loader_get_animation(GdkPixbufLoader *); + extern int gdk_pixbuf_get_rowstride(const GdkPixbuf *); + extern GdkPixbuf *gdk_pixbuf_new_from_file(const char *, GError * *); + extern void gdk_pixbuf_loader_set_size(GdkPixbufLoader *, gint, gint); + extern GType gdk_pixbuf_loader_get_type(void); + extern GdkPixbuf *gdk_pixbuf_composite_color_simple(const GdkPixbuf *, + int, int, + GdkInterpType, int, + int, guint32, + guint32); + extern gboolean gdk_pixbuf_save(GdkPixbuf *, const char *, + const char *, GError * *, ...); + extern GdkPixbuf *gdk_pixbuf_new_subpixbuf(GdkPixbuf *, int, int, int, + int); + extern gchar *gdk_pixbuf_format_get_license(GdkPixbufFormat *); + extern GdkPixbufAnimation *gdk_pixbuf_animation_new_from_file(const + char *, + GError * + *); + extern void gdk_pixbuf_fill(GdkPixbuf *, guint32); + extern void gdk_pixbuf_composite_color(const GdkPixbuf *, GdkPixbuf *, + int, int, int, int, double, + double, double, double, + GdkInterpType, int, int, int, + int, guint32, guint32); + extern void gdk_pixbuf_composite(const GdkPixbuf *, GdkPixbuf *, int, + int, int, int, double, double, double, + double, GdkInterpType, int); + extern int gdk_pixbuf_animation_get_width(GdkPixbufAnimation *); + extern gboolean gdk_pixbuf_animation_is_static_image(GdkPixbufAnimation + *); + extern void gdk_pixbuf_scale(const GdkPixbuf *, GdkPixbuf *, int, int, + int, int, double, double, double, double, + GdkInterpType); + extern GdkPixbuf + *gdk_pixbuf_animation_iter_get_pixbuf(GdkPixbufAnimationIter *); + extern const char *gdk_pixbuf_version; + extern gchar *gdk_pixbuf_format_get_name(GdkPixbufFormat *); + extern gchar **gdk_pixbuf_format_get_mime_types(GdkPixbufFormat *); + extern GType gdk_pixbuf_rotation_get_type(void); + extern GType gdk_colorspace_get_type(void); + extern GdkPixbufFormat *gdk_pixbuf_loader_get_format(GdkPixbufLoader + *); + extern GType gdk_pixbuf_alpha_mode_get_type(void); + extern gboolean gdk_pixbuf_format_is_disabled(GdkPixbufFormat *); + extern GdkPixbuf *gdk_pixbuf_rotate_simple(const GdkPixbuf *, + GdkPixbufRotation); + extern void gdk_pixbuf_copy_area(const GdkPixbuf *, int, int, int, int, + GdkPixbuf *, int, int); + extern GQuark gdk_pixbuf_error_quark(void); + extern gboolean gdk_pixbuf_format_is_writable(GdkPixbufFormat *); + extern GType gdk_pixbuf_get_type(void); + extern GdkPixbufFormat *gdk_pixbuf_get_file_info(const gchar *, gint *, + gint *); + extern GdkPixbuf *gdk_pixbuf_copy(const GdkPixbuf *); + extern gboolean gdk_pixbuf_savev(GdkPixbuf *, const char *, + const char *, char **, char **, + GError * *); + extern gchar *gdk_pixbuf_format_get_description(GdkPixbufFormat *); + extern GdkPixbuf *gdk_pixbuf_loader_get_pixbuf(GdkPixbufLoader *); + extern gboolean gdk_pixbuf_loader_write(GdkPixbufLoader *, + const guchar *, gsize, + GError * *); + extern int gdk_pixbuf_animation_get_height(GdkPixbufAnimation *); + extern int gdk_pixbuf_get_width(const GdkPixbuf *); + extern GdkPixbuf *gdk_pixbuf_new(GdkColorspace, gboolean, int, int, + int); + extern gchar **gdk_pixbuf_format_get_extensions(GdkPixbufFormat *); + extern GdkColorspace gdk_pixbuf_get_colorspace(const GdkPixbuf *); + extern GdkPixbufLoader *gdk_pixbuf_loader_new_with_mime_type(const char + *, + GError * + *); + extern GType gdk_pixbuf_error_get_type(void); + extern gboolean gdk_pixbuf_get_has_alpha(const GdkPixbuf *); + extern const gchar *gdk_pixbuf_get_option(GdkPixbuf *, const gchar *); + extern int + gdk_pixbuf_animation_iter_get_delay_time(GdkPixbufAnimationIter *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/gtk-2.0/gdk-pixbuf/gdk-pixdata.h b/lsb-build/headers/gtk-2.0/gdk-pixbuf/gdk-pixdata.h new file mode 100644 index 0000000..18d21ef --- /dev/null +++ b/lsb-build/headers/gtk-2.0/gdk-pixbuf/gdk-pixdata.h @@ -0,0 +1,65 @@ +#ifndef _GTK_2_0_GDK_PIXBUF_GDK_PIXDATA_H_ +#define _GTK_2_0_GDK_PIXBUF_GDK_PIXDATA_H_ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define GDK_PIXBUF_MAGIC_NUMBER (0x47646b50) +#define GDK_PIXDATA_HEADER_LENGTH (4 + 4 + 4 + 4 + 4 + 4) + + + typedef struct _GdkPixdata GdkPixdata; + + typedef enum { + GDK_PIXDATA_DUMP_PIXDATA_STREAM = 0, + GDK_PIXDATA_DUMP_PIXDATA_STRUCT = 1, + GDK_PIXDATA_DUMP_MACROS = 2, + GDK_PIXDATA_DUMP_GTYPES = 0, + GDK_PIXDATA_DUMP_CTYPES = 256, + GDK_PIXDATA_DUMP_STATIC = 512, + GDK_PIXDATA_DUMP_CONST = 1024, + GDK_PIXDATA_DUMP_RLE_DECODER = 65536 + } GdkPixdataDumpType; + + typedef enum { + GDK_PIXDATA_COLOR_TYPE_RGB = 0x01, + GDK_PIXDATA_COLOR_TYPE_RGBA = 0x02, + GDK_PIXDATA_COLOR_TYPE_MASK = 0xff, + GDK_PIXDATA_SAMPLE_WIDTH_8 = 0x01 << 16, + GDK_PIXDATA_SAMPLE_WIDTH_MASK = 0x0f << 16, + GDK_PIXDATA_ENCODING_RAW = 0x01 << 24, + GDK_PIXDATA_ENCODING_RLE = 0x02 << 24, + GDK_PIXDATA_ENCODING_MASK = 0x0f << 24 + } GdkPixdataType; + + + struct _GdkPixdata { + guint32 magic; + gint32 length; + guint32 pixdata_type; + guint32 rowstride; + guint32 width; + guint32 height; + guint8 *pixel_data; + }; + + + extern gboolean gdk_pixdata_deserialize(GdkPixdata *, guint, + const guint8 *, GError * *); + extern gpointer gdk_pixdata_from_pixbuf(GdkPixdata *, + const GdkPixbuf *, gboolean); + extern guint8 *gdk_pixdata_serialize(const GdkPixdata *, guint *); + extern GString *gdk_pixdata_to_csource(GdkPixdata *, const gchar *, + GdkPixdataDumpType); + extern GdkPixbuf *gdk_pixbuf_from_pixdata(const GdkPixdata *, gboolean, + GError * *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/gtk-2.0/gdk/gdk.h b/lsb-build/headers/gtk-2.0/gdk/gdk.h new file mode 100644 index 0000000..9ca8cc8 --- /dev/null +++ b/lsb-build/headers/gtk-2.0/gdk/gdk.h @@ -0,0 +1,2402 @@ +#ifndef _GTK_2_0_GDK_GDK_H_ +#define _GTK_2_0_GDK_GDK_H_ + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define GDK_WINDOWING_X11 +#define GDK_PIXMAP_OBJECT(object) \ + ((GdkPixmapObject *) GDK_PIXMAP (object)) +#define GDK_WINDOW_OBJECT(object) \ + ((GdkWindowObject *) GDK_WINDOW (object)) +#define GDK_TYPE_WINDOW_ATTRIBUTES_TYPE \ + (gdk_window_attributes_type_get_type()) +#define GDK_COLORMAP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_COLORMAP, \ + GdkColormapClass)) +#define GDK_DEVICE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DEVICE, GdkDeviceClass)) +#define GDK_DISPLAY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DISPLAY, \ + GdkDisplayClass)) +#define GDK_DISPLAY_MANAGER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DISPLAY_MANAGER, \ + GdkDisplayManagerClass)) +#define GDK_DRAG_CONTEXT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DRAG_CONTEXT, \ + GdkDragContextClass)) +#define GDK_DRAWABLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DRAWABLE, \ + GdkDrawableClass)) +#define GDK_GC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_GC, GdkGCClass)) +#define GDK_IMAGE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_IMAGE, GdkImageClass)) +#define GDK_KEYMAP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_KEYMAP, GdkKeymapClass)) +#define GDK_PANGO_RENDERER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PANGO_RENDERER, \ + GdkPangoRendererClass)) +#define GDK_PIXMAP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXMAP, \ + GdkPixmapObjectClass)) +#define GDK_SCREEN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_SCREEN, GdkScreenClass)) +#define GDK_VISUAL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_VISUAL, GdkVisualClass)) +#define GDK_WINDOW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW, \ + GdkWindowObjectClass)) +#define GDK_IS_COLORMAP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_COLORMAP)) +#define GDK_IS_DEVICE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DEVICE)) +#define GDK_IS_DISPLAY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DISPLAY)) +#define GDK_IS_DISPLAY_MANAGER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DISPLAY_MANAGER)) +#define GDK_IS_DRAG_CONTEXT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DRAG_CONTEXT)) +#define GDK_IS_DRAWABLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DRAWABLE)) +#define GDK_IS_GC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_GC)) +#define GDK_IS_IMAGE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_IMAGE)) +#define GDK_IS_KEYMAP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_KEYMAP)) +#define GDK_IS_PANGO_RENDERER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PANGO_RENDERER)) +#define GDK_IS_PIXMAP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXMAP)) +#define GDK_IS_SCREEN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_SCREEN)) +#define GDK_IS_VISUAL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_VISUAL)) +#define GDK_IS_WINDOW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW)) +#define GDK_COLORMAP(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_COLORMAP, \ + GdkColormap)) +#define GDK_DEVICE(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DEVICE, GdkDevice)) +#define GDK_DISPLAY_OBJECT(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY, GdkDisplay)) +#define GDK_DISPLAY_MANAGER(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY_MANAGER, \ + GdkDisplayManager)) +#define GDK_DRAG_CONTEXT(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAG_CONTEXT, \ + GdkDragContext)) +#define GDK_DRAWABLE(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAWABLE, \ + GdkDrawable)) +#define GDK_GC(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_GC, GdkGC)) +#define GDK_IMAGE(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_IMAGE, GdkImage)) +#define GDK_KEYMAP(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_KEYMAP, GdkKeymap)) +#define GDK_PANGO_RENDERER(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PANGO_RENDERER, \ + GdkPangoRenderer)) +#define GDK_PIXMAP(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXMAP, GdkPixmap)) +#define GDK_SCREEN(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_SCREEN, GdkScreen)) +#define GDK_VISUAL(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_VISUAL, GdkVisual)) +#define GDK_WINDOW(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW, GdkWindow)) +#define GDK_IS_COLORMAP(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_COLORMAP)) +#define GDK_IS_DEVICE(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DEVICE)) +#define GDK_IS_DISPLAY(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DISPLAY)) +#define GDK_IS_DISPLAY_MANAGER(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DISPLAY_MANAGER)) +#define GDK_IS_DRAG_CONTEXT(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAG_CONTEXT)) +#define GDK_IS_DRAWABLE(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAWABLE)) +#define GDK_IS_GC(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_GC)) +#define GDK_IS_IMAGE(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_IMAGE)) +#define GDK_IS_KEYMAP(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_KEYMAP)) +#define GDK_IS_PANGO_RENDERER(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PANGO_RENDERER)) +#define GDK_IS_PIXMAP(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXMAP)) +#define GDK_IS_SCREEN(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_SCREEN)) +#define GDK_IS_VISUAL(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_VISUAL)) +#define GDK_IS_WINDOW(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW)) +#define GDK_COLORMAP_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_COLORMAP, \ + GdkColormapClass)) +#define GDK_DEVICE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DEVICE, GdkDeviceClass)) +#define GDK_DISPLAY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DISPLAY, \ + GdkDisplayClass)) +#define GDK_DISPLAY_MANAGER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DISPLAY_MANAGER, \ + GdkDisplayManagerClass)) +#define GDK_DRAG_CONTEXT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DRAG_CONTEXT, \ + GdkDragContextClass)) +#define GDK_DRAWABLE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DRAWABLE, \ + GdkDrawableClass)) +#define GDK_GC_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_GC, GdkGCClass)) +#define GDK_IMAGE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_IMAGE, GdkImageClass)) +#define GDK_KEYMAP_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_KEYMAP, GdkKeymapClass)) +#define GDK_PANGO_RENDERER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PANGO_RENDERER, \ + GdkPangoRendererClass)) +#define GDK_PIXMAP_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXMAP, \ + GdkPixmapObjectClass)) +#define GDK_SCREEN_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_SCREEN, GdkScreenClass)) +#define GDK_VISUAL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_VISUAL, GdkVisualClass)) +#define GDK_WINDOW_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW, \ + GdkWindowObjectClass)) +#define GDK_THREADS_ENTER() \ + G_STMT_START { if (gdk_threads_lock) (*gdk_threads_lock) (); } \ + G_STMT_END +#define GDK_THREADS_LEAVE() \ + G_STMT_START { if (gdk_threads_unlock) (*gdk_threads_unlock) (); } \ + G_STMT_END +#define GDK_POINTER_TO_ATOM(ptr) ((GdkAtom)(ptr)) +#define _GDK_MAKE_ATOM(val) ((GdkAtom)GUINT_TO_POINTER(val)) +#define GDK_ATOM_TO_POINTER(atom) (atom) +#define GDK_TYPE_AXIS_USE (gdk_axis_use_get_type()) +#define GDK_TYPE_BYTE_ORDER (gdk_byte_order_get_type()) +#define GDK_TYPE_CAP_STYLE (gdk_cap_style_get_type()) +#define GDK_TYPE_COLORMAP (gdk_colormap_get_type ()) +#define GDK_TYPE_COLOR (gdk_color_get_type ()) +#define GDK_TYPE_CROSSING_MODE (gdk_crossing_mode_get_type()) +#define GDK_TYPE_CURSOR (gdk_cursor_get_type ()) +#define GDK_TYPE_CURSOR_TYPE (gdk_cursor_type_get_type()) +#define GDK_TYPE_DEVICE (gdk_device_get_type ()) +#define GDK_TYPE_DISPLAY (gdk_display_get_type ()) +#define GDK_TYPE_DISPLAY_MANAGER (gdk_display_manager_get_type ()) +#define GDK_TYPE_DRAG_ACTION (gdk_drag_action_get_type()) +#define GDK_TYPE_DRAG_CONTEXT (gdk_drag_context_get_type ()) +#define GDK_TYPE_DRAG_PROTOCOL (gdk_drag_protocol_get_type()) +#define GDK_TYPE_DRAWABLE (gdk_drawable_get_type ()) +#define GDK_TYPE_EVENT (gdk_event_get_type ()) +#define GDK_TYPE_EVENT_MASK (gdk_event_mask_get_type()) +#define GDK_TYPE_EVENT_TYPE (gdk_event_type_get_type()) +#define GDK_TYPE_EXTENSION_MODE (gdk_extension_mode_get_type()) +#define GDK_TYPE_FILL (gdk_fill_get_type()) +#define GDK_TYPE_FILL_RULE (gdk_fill_rule_get_type()) +#define GDK_TYPE_FILTER_RETURN (gdk_filter_return_get_type()) +#define GDK_TYPE_FONT_TYPE (gdk_font_type_get_type()) +#define GDK_TYPE_FUNCTION (gdk_function_get_type()) +#define GDK_TYPE_GC (gdk_gc_get_type ()) +#define GDK_TYPE_GC_VALUES_MASK (gdk_gc_values_mask_get_type()) +#define GDK_TYPE_GRAB_STATUS (gdk_grab_status_get_type()) +#define GDK_TYPE_GRAVITY (gdk_gravity_get_type()) +#define GDK_TYPE_IMAGE (gdk_image_get_type ()) +#define GDK_TYPE_IMAGE_TYPE (gdk_image_type_get_type()) +#define GDK_TYPE_INPUT_CONDITION (gdk_input_condition_get_type()) +#define GDK_TYPE_INPUT_MODE (gdk_input_mode_get_type()) +#define GDK_TYPE_INPUT_SOURCE (gdk_input_source_get_type()) +#define GDK_TYPE_JOIN_STYLE (gdk_join_style_get_type()) +#define GDK_TYPE_KEYMAP (gdk_keymap_get_type ()) +#define GDK_TYPE_LINE_STYLE (gdk_line_style_get_type()) +#define GDK_TYPE_MODIFIER_TYPE (gdk_modifier_type_get_type()) +#define GDK_TYPE_NOTIFY_TYPE (gdk_notify_type_get_type()) +#define GDK_TYPE_OVERLAP_TYPE (gdk_overlap_type_get_type()) +#define GDK_TYPE_OWNER_CHANGE (gdk_owner_change_get_type()) +#define GDK_TYPE_PANGO_RENDERER (gdk_pango_renderer_get_type()) +#define GDK_TYPE_PIXMAP (gdk_pixmap_get_type ()) +#define GDK_TYPE_PROPERTY_STATE (gdk_property_state_get_type()) +#define GDK_TYPE_PROP_MODE (gdk_prop_mode_get_type()) +#define GDK_TYPE_RECTANGLE (gdk_rectangle_get_type ()) +#define GDK_TYPE_RGB_DITHER (gdk_rgb_dither_get_type()) +#define GDK_TYPE_SCREEN (gdk_screen_get_type ()) +#define GDK_TYPE_SCROLL_DIRECTION (gdk_scroll_direction_get_type()) +#define GDK_TYPE_SETTING_ACTION (gdk_setting_action_get_type()) +#define GDK_TYPE_STATUS (gdk_status_get_type()) +#define GDK_TYPE_SUBWINDOW_MODE (gdk_subwindow_mode_get_type()) +#define GDK_TYPE_VISIBILITY_STATE (gdk_visibility_state_get_type()) +#define GDK_TYPE_VISUAL (gdk_visual_get_type ()) +#define GDK_TYPE_VISUAL_TYPE (gdk_visual_type_get_type()) +#define GDK_TYPE_WINDOW_CLASS (gdk_window_class_get_type()) +#define GDK_TYPE_WINDOW_EDGE (gdk_window_edge_get_type()) +#define GDK_TYPE_WINDOW_HINTS (gdk_window_hints_get_type()) +#define GDK_TYPE_WINDOW (gdk_window_object_get_type ()) +#define GDK_TYPE_WINDOW_STATE (gdk_window_state_get_type()) +#define GDK_TYPE_WINDOW_TYPE (gdk_window_type_get_type()) +#define GDK_TYPE_WINDOW_TYPE_HINT (gdk_window_type_hint_get_type()) +#define GDK_TYPE_WM_DECORATION (gdk_wm_decoration_get_type()) +#define GDK_TYPE_WM_FUNCTION (gdk_wm_function_get_type()) +#define GDK_PRIORITY_EVENTS (G_PRIORITY_DEFAULT) +#define GDK_PRIORITY_REDRAW (G_PRIORITY_HIGH_IDLE + 20) +#define GDK_CURRENT_TIME 0L +#define GDK_HAVE_WCHAR_H 1 +#define GDK_HAVE_WCTYPE_H 1 +#define GDK_MAX_TIMECOORD_AXES 128 +#define GDK_PARENT_RELATIVE 1L +#define GDKVAR extern +#define gdk_draw_bitmap gdk_draw_drawable +#define GDK_NONE _GDK_MAKE_ATOM (0) +#define GDK_SELECTION_PRIMARY _GDK_MAKE_ATOM (1) +#define GDK_SELECTION_TYPE_DRAWABLE _GDK_MAKE_ATOM (17) +#define GDK_TARGET_DRAWABLE _GDK_MAKE_ATOM (17) +#define GDK_SELECTION_TYPE_INTEGER _GDK_MAKE_ATOM (19) +#define GDK_SELECTION_SECONDARY _GDK_MAKE_ATOM (2) +#define GDK_SELECTION_TYPE_PIXMAP _GDK_MAKE_ATOM (20) +#define GDK_TARGET_PIXMAP _GDK_MAKE_ATOM (20) +#define GDK_SELECTION_TYPE_STRING _GDK_MAKE_ATOM (31) +#define GDK_TARGET_STRING _GDK_MAKE_ATOM (31) +#define GDK_SELECTION_TYPE_WINDOW _GDK_MAKE_ATOM (33) +#define GDK_SELECTION_TYPE_ATOM _GDK_MAKE_ATOM (4) +#define GDK_SELECTION_TYPE_BITMAP _GDK_MAKE_ATOM (5) +#define GDK_TARGET_BITMAP _GDK_MAKE_ATOM (5) +#define GDK_SELECTION_CLIPBOARD _GDK_MAKE_ATOM (69) +#define GDK_SELECTION_TYPE_COLORMAP _GDK_MAKE_ATOM (7) +#define GDK_TARGET_COLORMAP _GDK_MAKE_ATOM (7) + + + typedef struct _GdkDrawable GdkWindow; + + typedef struct _GdkColor GdkColor; + + typedef enum { + GDK_VISUAL_STATIC_GRAY = 0, + GDK_VISUAL_GRAYSCALE = 1, + GDK_VISUAL_STATIC_COLOR = 2, + GDK_VISUAL_PSEUDO_COLOR = 3, + GDK_VISUAL_TRUE_COLOR = 4, + GDK_VISUAL_DIRECT_COLOR = 5 + } GdkVisualType; + + typedef enum { + GDK_LSB_FIRST = 0, + GDK_MSB_FIRST = 1 + } GdkByteOrder; + + typedef struct _GdkVisual GdkVisual; + + typedef struct _GdkColormap GdkColormap; + + typedef struct _GdkGC GdkGC; + + typedef struct _GdkDrawable GdkDrawable; + + typedef enum { + GDK_SOURCE_MOUSE = 0, + GDK_SOURCE_PEN = 1, + GDK_SOURCE_ERASER = 2, + GDK_SOURCE_CURSOR = 3 + } GdkInputSource; + + typedef enum { + GDK_MODE_DISABLED = 0, + GDK_MODE_SCREEN = 1, + GDK_MODE_WINDOW = 2 + } GdkInputMode; + + typedef enum { + GDK_AXIS_IGNORE = 0, + GDK_AXIS_X = 1, + GDK_AXIS_Y = 2, + GDK_AXIS_PRESSURE = 3, + GDK_AXIS_XTILT = 4, + GDK_AXIS_YTILT = 5, + GDK_AXIS_WHEEL = 6, + GDK_AXIS_LAST = 7 + } GdkAxisUse; + + typedef struct _GdkDeviceAxis GdkDeviceAxis; + + typedef enum { + GDK_SHIFT_MASK = 1, + GDK_LOCK_MASK = 2, + GDK_CONTROL_MASK = 4, + GDK_MOD1_MASK = 8, + GDK_MOD2_MASK = 16, + GDK_MOD3_MASK = 32, + GDK_MOD4_MASK = 64, + GDK_MOD5_MASK = 128, + GDK_BUTTON1_MASK = 256, + GDK_BUTTON2_MASK = 512, + GDK_BUTTON3_MASK = 1024, + GDK_BUTTON4_MASK = 2048, + GDK_BUTTON5_MASK = 4096, + GDK_RELEASE_MASK = 1073741824, + GDK_MODIFIER_MASK = 1073750015 + } GdkModifierType; + + typedef struct _GdkDeviceKey GdkDeviceKey; + + typedef struct _GdkDevice GdkDevice; + + typedef struct _GdkDisplay GdkDisplay; + + typedef struct _GdkScreen GdkScreen; + + typedef struct _GdkDisplayPointerHooks GdkDisplayPointerHooks; + + typedef enum { + GDK_EXPOSURE_MASK = 2, + GDK_POINTER_MOTION_MASK = 4, + GDK_POINTER_MOTION_HINT_MASK = 8, + GDK_BUTTON_MOTION_MASK = 16, + GDK_BUTTON1_MOTION_MASK = 32, + GDK_BUTTON2_MOTION_MASK = 64, + GDK_BUTTON3_MOTION_MASK = 128, + GDK_BUTTON_PRESS_MASK = 256, + GDK_BUTTON_RELEASE_MASK = 512, + GDK_KEY_PRESS_MASK = 1024, + GDK_KEY_RELEASE_MASK = 2048, + GDK_ENTER_NOTIFY_MASK = 4096, + GDK_LEAVE_NOTIFY_MASK = 8192, + GDK_FOCUS_CHANGE_MASK = 16384, + GDK_STRUCTURE_MASK = 32768, + GDK_PROPERTY_CHANGE_MASK = 65536, + GDK_VISIBILITY_NOTIFY_MASK = 131072, + GDK_PROXIMITY_IN_MASK = 262144, + GDK_PROXIMITY_OUT_MASK = 524288, + GDK_SUBSTRUCTURE_MASK = 1048576, + GDK_SCROLL_MASK = 2097152, + GDK_ALL_EVENTS_MASK = 4194302 + } GdkEventMask; + + typedef enum { + GDK_X_CURSOR = 0, + GDK_ARROW = 2, + GDK_BASED_ARROW_DOWN = 4, + GDK_BASED_ARROW_UP = 6, + GDK_BOAT = 8, + GDK_BOGOSITY = 10, + GDK_BOTTOM_LEFT_CORNER = 12, + GDK_BOTTOM_RIGHT_CORNER = 14, + GDK_BOTTOM_SIDE = 16, + GDK_BOTTOM_TEE = 18, + GDK_BOX_SPIRAL = 20, + GDK_CENTER_PTR = 22, + GDK_CIRCLE = 24, + GDK_CLOCK = 26, + GDK_COFFEE_MUG = 28, + GDK_CROSS = 30, + GDK_CROSS_REVERSE = 32, + GDK_CROSSHAIR = 34, + GDK_DIAMOND_CROSS = 36, + GDK_DOT = 38, + GDK_DOTBOX = 40, + GDK_DOUBLE_ARROW = 42, + GDK_DRAFT_LARGE = 44, + GDK_DRAFT_SMALL = 46, + GDK_DRAPED_BOX = 48, + GDK_EXCHANGE = 50, + GDK_FLEUR = 52, + GDK_GOBBLER = 54, + GDK_GUMBY = 56, + GDK_HAND1 = 58, + GDK_HAND2 = 60, + GDK_HEART = 62, + GDK_ICON = 64, + GDK_IRON_CROSS = 66, + GDK_LEFT_PTR = 68, + GDK_LEFT_SIDE = 70, + GDK_LEFT_TEE = 72, + GDK_LEFTBUTTON = 74, + GDK_LL_ANGLE = 76, + GDK_LR_ANGLE = 78, + GDK_MAN = 80, + GDK_MIDDLEBUTTON = 82, + GDK_MOUSE = 84, + GDK_PENCIL = 86, + GDK_PIRATE = 88, + GDK_PLUS = 90, + GDK_QUESTION_ARROW = 92, + GDK_RIGHT_PTR = 94, + GDK_RIGHT_SIDE = 96, + GDK_RIGHT_TEE = 98, + GDK_RIGHTBUTTON = 100, + GDK_RTL_LOGO = 102, + GDK_SAILBOAT = 104, + GDK_SB_DOWN_ARROW = 106, + GDK_SB_H_DOUBLE_ARROW = 108, + GDK_SB_LEFT_ARROW = 110, + GDK_SB_RIGHT_ARROW = 112, + GDK_SB_UP_ARROW = 114, + GDK_SB_V_DOUBLE_ARROW = 116, + GDK_SHUTTLE = 118, + GDK_SIZING = 120, + GDK_SPIDER = 122, + GDK_SPRAYCAN = 124, + GDK_STAR = 126, + GDK_TARGET = 128, + GDK_TCROSS = 130, + GDK_TOP_LEFT_ARROW = 132, + GDK_TOP_LEFT_CORNER = 134, + GDK_TOP_RIGHT_CORNER = 136, + GDK_TOP_SIDE = 138, + GDK_TOP_TEE = 140, + GDK_TREK = 142, + GDK_UL_ANGLE = 144, + GDK_UMBRELLA = 146, + GDK_UR_ANGLE = 148, + GDK_WATCH = 150, + GDK_XTERM = 152, + GDK_LAST_CURSOR = 153, + GDK_CURSOR_IS_PIXMAP = -1 + } GdkCursorType; + + typedef struct _GdkCursor GdkCursor; + + typedef struct _GdkKeymap GdkKeymap; + + typedef struct _GdkAtom *GdkAtom; + + typedef enum { + GDK_FILTER_CONTINUE = 0, + GDK_FILTER_TRANSLATE = 1, + GDK_FILTER_REMOVE = 2 + } GdkFilterReturn; + + typedef void GdkXEvent; + + typedef enum { + GDK_NOTHING = -1, + GDK_DELETE = 0, + GDK_DESTROY = 1, + GDK_EXPOSE = 2, + GDK_MOTION_NOTIFY = 3, + GDK_BUTTON_PRESS = 4, + GDK_2BUTTON_PRESS = 5, + GDK_3BUTTON_PRESS = 6, + GDK_BUTTON_RELEASE = 7, + GDK_KEY_PRESS = 8, + GDK_KEY_RELEASE = 9, + GDK_ENTER_NOTIFY = 10, + GDK_LEAVE_NOTIFY = 11, + GDK_FOCUS_CHANGE = 12, + GDK_CONFIGURE = 13, + GDK_MAP = 14, + GDK_UNMAP = 15, + GDK_PROPERTY_NOTIFY = 16, + GDK_SELECTION_CLEAR = 17, + GDK_SELECTION_REQUEST = 18, + GDK_SELECTION_NOTIFY = 19, + GDK_PROXIMITY_IN = 20, + GDK_PROXIMITY_OUT = 21, + GDK_DRAG_ENTER = 22, + GDK_DRAG_LEAVE = 23, + GDK_DRAG_MOTION = 24, + GDK_DRAG_STATUS = 25, + GDK_DROP_START = 26, + GDK_DROP_FINISHED = 27, + GDK_CLIENT_EVENT = 28, + GDK_VISIBILITY_NOTIFY = 29, + GDK_NO_EXPOSE = 30, + GDK_SCROLL = 31, + GDK_WINDOW_STATE = 32, + GDK_SETTING = 33, + GDK_OWNER_CHANGE = 34 + } GdkEventType; + + typedef struct _GdkEventAny GdkEventAny; + + typedef struct _GdkRectangle GdkRectangle; + + typedef struct _GdkRegion GdkRegion; + + typedef struct _GdkEventExpose GdkEventExpose; + + typedef struct _GdkEventNoExpose GdkEventNoExpose; + + typedef enum { + GDK_VISIBILITY_UNOBSCURED = 0, + GDK_VISIBILITY_PARTIAL = 1, + GDK_VISIBILITY_FULLY_OBSCURED = 2 + } GdkVisibilityState; + + typedef struct _GdkEventVisibility GdkEventVisibility; + + typedef struct _GdkEventMotion GdkEventMotion; + + typedef struct _GdkEventButton GdkEventButton; + + typedef enum { + GDK_SCROLL_UP = 0, + GDK_SCROLL_DOWN = 1, + GDK_SCROLL_LEFT = 2, + GDK_SCROLL_RIGHT = 3 + } GdkScrollDirection; + + typedef struct _GdkEventScroll GdkEventScroll; + + typedef struct _GdkEventKey GdkEventKey; + + typedef enum { + GDK_CROSSING_NORMAL = 0, + GDK_CROSSING_GRAB = 1, + GDK_CROSSING_UNGRAB = 2 + } GdkCrossingMode; + + typedef enum { + GDK_NOTIFY_ANCESTOR = 0, + GDK_NOTIFY_VIRTUAL = 1, + GDK_NOTIFY_INFERIOR = 2, + GDK_NOTIFY_NONLINEAR = 3, + GDK_NOTIFY_NONLINEAR_VIRTUAL = 4, + GDK_NOTIFY_UNKNOWN = 5 + } GdkNotifyType; + + typedef struct _GdkEventCrossing GdkEventCrossing; + + typedef struct _GdkEventFocus GdkEventFocus; + + typedef struct _GdkEventConfigure GdkEventConfigure; + + typedef struct _GdkEventProperty GdkEventProperty; + + typedef guint32 GdkNativeWindow; + + typedef struct _GdkEventSelection GdkEventSelection; + + typedef enum { + GDK_OWNER_CHANGE_NEW_OWNER = 0, + GDK_OWNER_CHANGE_DESTROY = 1, + GDK_OWNER_CHANGE_CLOSE = 2 + } GdkOwnerChange; + + typedef struct _GdkEventOwnerChange GdkEventOwnerChange; + + typedef struct _GdkEventProximity GdkEventProximity; + + typedef struct _GdkEventClient GdkEventClient; + + typedef enum { + GDK_DRAG_PROTO_MOTIF = 0, + GDK_DRAG_PROTO_XDND = 1, + GDK_DRAG_PROTO_ROOTWIN = 2, + GDK_DRAG_PROTO_NONE = 3, + GDK_DRAG_PROTO_WIN32_DROPFILES = 4, + GDK_DRAG_PROTO_OLE2 = 5, + GDK_DRAG_PROTO_LOCAL = 6 + } GdkDragProtocol; + + typedef enum { + GDK_ACTION_DEFAULT = 1, + GDK_ACTION_COPY = 2, + GDK_ACTION_MOVE = 4, + GDK_ACTION_LINK = 8, + GDK_ACTION_PRIVATE = 16, + GDK_ACTION_ASK = 32 + } GdkDragAction; + + typedef struct _GdkDragContext GdkDragContext; + + typedef short int gshort; + + typedef struct _GdkEventDND GdkEventDND; + + typedef enum { + GDK_WINDOW_STATE_WITHDRAWN = 1, + GDK_WINDOW_STATE_ICONIFIED = 2, + GDK_WINDOW_STATE_MAXIMIZED = 4, + GDK_WINDOW_STATE_STICKY = 8, + GDK_WINDOW_STATE_FULLSCREEN = 16, + GDK_WINDOW_STATE_ABOVE = 32, + GDK_WINDOW_STATE_BELOW = 64 + } GdkWindowState; + + typedef struct _GdkEventWindowState GdkEventWindowState; + + typedef enum { + GDK_SETTING_ACTION_NEW = 0, + GDK_SETTING_ACTION_CHANGED = 1, + GDK_SETTING_ACTION_DELETED = 2 + } GdkSettingAction; + + typedef struct _GdkEventSetting GdkEventSetting; + + typedef union _GdkEvent GdkEvent; + + typedef GdkFilterReturn(*GdkFilterFunc) (GdkXEvent *, GdkEvent *, + gpointer); + + typedef struct _GdkDrawable GdkPixmap; + + typedef struct _GdkDrawable GdkBitmap; + + typedef struct _GdkDisplayManager GdkDisplayManager; + + typedef enum { + GDK_CLIP_BY_CHILDREN = 0, + GDK_INCLUDE_INFERIORS = 1 + } GdkSubwindowMode; + + typedef enum { + GDK_WINDOW_EDGE_NORTH_WEST = 0, + GDK_WINDOW_EDGE_NORTH = 1, + GDK_WINDOW_EDGE_NORTH_EAST = 2, + GDK_WINDOW_EDGE_WEST = 3, + GDK_WINDOW_EDGE_EAST = 4, + GDK_WINDOW_EDGE_SOUTH_WEST = 5, + GDK_WINDOW_EDGE_SOUTH = 6, + GDK_WINDOW_EDGE_SOUTH_EAST = 7 + } GdkWindowEdge; + + typedef enum { + GDK_IMAGE_NORMAL = 0, + GDK_IMAGE_SHARED = 1, + GDK_IMAGE_FASTEST = 2 + } GdkImageType; + + typedef struct _GdkImage GdkImage; + + typedef struct _GdkPangoRendererPrivate GdkPangoRendererPrivate; + + typedef struct _GdkPangoRenderer GdkPangoRenderer; + + typedef enum { + GDK_GRAB_SUCCESS = 0, + GDK_GRAB_ALREADY_GRABBED = 1, + GDK_GRAB_INVALID_TIME = 2, + GDK_GRAB_NOT_VIEWABLE = 3, + GDK_GRAB_FROZEN = 4 + } GdkGrabStatus; + + typedef enum { + GDK_SOLID = 0, + GDK_TILED = 1, + GDK_STIPPLED = 2, + GDK_OPAQUE_STIPPLED = 3 + } GdkFill; + + typedef enum { + GDK_WINDOW_TYPE_HINT_NORMAL = 0, + GDK_WINDOW_TYPE_HINT_DIALOG = 1, + GDK_WINDOW_TYPE_HINT_MENU = 2, + GDK_WINDOW_TYPE_HINT_TOOLBAR = 3, + GDK_WINDOW_TYPE_HINT_SPLASHSCREEN = 4, + GDK_WINDOW_TYPE_HINT_UTILITY = 5, + GDK_WINDOW_TYPE_HINT_DOCK = 6, + GDK_WINDOW_TYPE_HINT_DESKTOP = 7 + } GdkWindowTypeHint; + + typedef struct _GdkTimeCoord GdkTimeCoord; + + typedef struct _GdkPoint GdkPoint; + + typedef struct _GdkFont GdkFont; + + typedef enum { + GDK_DECOR_ALL = 1, + GDK_DECOR_BORDER = 2, + GDK_DECOR_RESIZEH = 4, + GDK_DECOR_TITLE = 8, + GDK_DECOR_MENU = 16, + GDK_DECOR_MINIMIZE = 32, + GDK_DECOR_MAXIMIZE = 64 + } GdkWMDecoration; + + typedef enum { + GDK_FUNC_ALL = 1, + GDK_FUNC_RESIZE = 2, + GDK_FUNC_MOVE = 4, + GDK_FUNC_MINIMIZE = 8, + GDK_FUNC_MAXIMIZE = 16, + GDK_FUNC_CLOSE = 32 + } GdkWMFunction; + + typedef struct _GdkKeymapKey GdkKeymapKey; + + typedef enum { + GDK_RGB_DITHER_NONE = 0, + GDK_RGB_DITHER_NORMAL = 1, + GDK_RGB_DITHER_MAX = 2 + } GdkRgbDither; + + typedef struct _GdkRgbCmap GdkRgbCmap; + + typedef enum { + GDK_COPY = 0, + GDK_INVERT = 1, + GDK_XOR = 2, + GDK_CLEAR = 3, + GDK_AND = 4, + GDK_AND_REVERSE = 5, + GDK_AND_INVERT = 6, + GDK_NOOP = 7, + GDK_OR = 8, + GDK_EQUIV = 9, + GDK_OR_REVERSE = 10, + GDK_COPY_INVERT = 11, + GDK_OR_INVERT = 12, + GDK_NAND = 13, + GDK_NOR = 14, + GDK_SET = 15 + } GdkFunction; + + typedef enum { + GDK_LINE_SOLID = 0, + GDK_LINE_ON_OFF_DASH = 1, + GDK_LINE_DOUBLE_DASH = 2 + } GdkLineStyle; + + typedef enum { + GDK_CAP_NOT_LAST = 0, + GDK_CAP_BUTT = 1, + GDK_CAP_ROUND = 2, + GDK_CAP_PROJECTING = 3 + } GdkCapStyle; + + typedef enum { + GDK_JOIN_MITER = 0, + GDK_JOIN_ROUND = 1, + GDK_JOIN_BEVEL = 2 + } GdkJoinStyle; + + typedef struct _GdkGCValues GdkGCValues; + + typedef enum { + GDK_GC_FOREGROUND = 1, + GDK_GC_BACKGROUND = 2, + GDK_GC_FONT = 4, + GDK_GC_FUNCTION = 8, + GDK_GC_FILL = 16, + GDK_GC_TILE = 32, + GDK_GC_STIPPLE = 64, + GDK_GC_CLIP_MASK = 128, + GDK_GC_SUBWINDOW = 256, + GDK_GC_TS_X_ORIGIN = 512, + GDK_GC_TS_Y_ORIGIN = 1024, + GDK_GC_CLIP_X_ORIGIN = 2048, + GDK_GC_CLIP_Y_ORIGIN = 4096, + GDK_GC_EXPOSURES = 8192, + GDK_GC_LINE_WIDTH = 16384, + GDK_GC_LINE_STYLE = 32768, + GDK_GC_CAP_STYLE = 65536, + GDK_GC_JOIN_STYLE = 131072 + } GdkGCValuesMask; + + typedef enum { + GDK_WINDOW_ROOT = 0, + GDK_WINDOW_TOPLEVEL = 1, + GDK_WINDOW_CHILD = 2, + GDK_WINDOW_DIALOG = 3, + GDK_WINDOW_TEMP = 4, + GDK_WINDOW_FOREIGN = 5 + } GdkWindowType; + + typedef struct _GdkSpan GdkSpan; + + typedef void (*GdkSpanFunc) (GdkSpan *, gpointer); + + typedef enum { + GDK_GRAVITY_NORTH_WEST = 1, + GDK_GRAVITY_NORTH = 2, + GDK_GRAVITY_NORTH_EAST = 3, + GDK_GRAVITY_WEST = 4, + GDK_GRAVITY_CENTER = 5, + GDK_GRAVITY_EAST = 6, + GDK_GRAVITY_SOUTH_WEST = 7, + GDK_GRAVITY_SOUTH = 8, + GDK_GRAVITY_SOUTH_EAST = 9, + GDK_GRAVITY_STATIC = 10 + } GdkGravity; + + typedef struct _GdkGeometry GdkGeometry; + + typedef enum { + GDK_HINT_POS = 1, + GDK_HINT_MIN_SIZE = 2, + GDK_HINT_MAX_SIZE = 4, + GDK_HINT_BASE_SIZE = 8, + GDK_HINT_ASPECT = 16, + GDK_HINT_RESIZE_INC = 32, + GDK_HINT_WIN_GRAVITY = 64, + GDK_HINT_USER_POS = 128, + GDK_HINT_USER_SIZE = 256 + } GdkWindowHints; + + typedef void (*GdkEventFunc) (GdkEvent *, gpointer); + + typedef enum { + GDK_OVERLAP_RECTANGLE_IN = 0, + GDK_OVERLAP_RECTANGLE_OUT = 1, + GDK_OVERLAP_RECTANGLE_PART = 2 + } GdkOverlapType; + + typedef struct _GdkSegment GdkSegment; + + typedef enum { + GDK_PROP_MODE_REPLACE = 0, + GDK_PROP_MODE_PREPEND = 1, + GDK_PROP_MODE_APPEND = 2 + } GdkPropMode; + + typedef enum { + GDK_INPUT_OUTPUT = 0, + GDK_INPUT_ONLY = 1 + } GdkWindowClass; + + typedef struct _GdkWindowAttr GdkWindowAttr; + + typedef struct _GdkTrapezoid GdkTrapezoid; + + typedef enum { + GDK_EVEN_ODD_RULE = 0, + GDK_WINDING_RULE = 1 + } GdkFillRule; + + typedef struct _GdkPointerHooks GdkPointerHooks; + + typedef enum { + GDK_EXTENSION_EVENTS_NONE = 0, + GDK_EXTENSION_EVENTS_ALL = 1, + GDK_EXTENSION_EVENTS_CURSOR = 2 + } GdkExtensionMode; + + typedef struct _GdkWindowObject GdkWindowObject; + + typedef struct _GdkScreenClass GdkScreenClass; + + typedef guint32 GdkWChar; + + typedef struct _GdkPixmapObject GdkPixmapObject; + + typedef enum { + GDK_INPUT_READ = 1, + GDK_INPUT_WRITE = 2, + GDK_INPUT_EXCEPTION = 4 + } GdkInputCondition; + + typedef void (*GdkInputFunction) (gpointer, gint, GdkInputCondition); + + typedef struct _GdkImageClass GdkImageClass; + + typedef void (*GdkDestroyNotify) (gpointer); + + typedef struct _GdkKeymapClass GdkKeymapClass; + + typedef struct _GdkDrawableClass GdkDrawableClass; + + typedef struct _GdkPangoAttrEmbossed GdkPangoAttrEmbossed; + + typedef struct _GdkDisplayManagerClass GdkDisplayManagerClass; + + typedef struct _GdkPixmapObjectClass GdkPixmapObjectClass; + + typedef struct _GdkPangoRendererClass GdkPangoRendererClass; + + typedef struct _GdkDisplayClass GdkDisplayClass; + + typedef struct _GdkPangoAttrStipple GdkPangoAttrStipple; + + typedef struct _GdkColormapClass GdkColormapClass; + + typedef struct _GdkDragContextClass GdkDragContextClass; + + typedef struct _GdkWindowObjectClass GdkWindowObjectClass; + + typedef struct _GdkGCClass GdkGCClass; + + typedef struct _GdkDeviceClass GdkDeviceClass; + + typedef struct _GdkVisualClass GdkVisualClass; + + typedef enum { + GDK_OK = 0, + GDK_ERROR = -1, + GDK_ERROR_PARAM = -2, + GDK_ERROR_FILE = -3, + GDK_ERROR_MEM = -4 + } GdkStatus; + + typedef enum { + GDK_PROPERTY_NEW_VALUE, + GDK_PROPERTY_DELETE + } GdkPropertyState; + + typedef enum { + GDK_WA_TITLE = 1 << 1, + GDK_WA_X = 1 << 2, + GDK_WA_Y = 1 << 3, + GDK_WA_CURSOR = 1 << 4, + GDK_WA_COLORMAP = 1 << 5, + GDK_WA_VISUAL = 1 << 6, + GDK_WA_WMCLASS = 1 << 7, + GDK_WA_NOREDIR = 1 << 8 + } GdkWindowAttributesType; + + + struct _GdkDrawable { + GObject parent_instance; + }; + + + struct _GdkColor { + guint32 pixel; + guint16 red; + guint16 green; + guint16 blue; + }; + + + struct _GdkVisual { + GObject parent_instance; + GdkVisualType type; + gint depth; + GdkByteOrder byte_order; + gint colormap_size; + gint bits_per_rgb; + guint32 red_mask; + gint red_shift; + gint red_prec; + guint32 green_mask; + gint green_shift; + gint green_prec; + guint32 blue_mask; + gint blue_shift; + gint blue_prec; + }; + + + struct _GdkColormap { + GObject parent_instance; + gint size; + GdkColor *colors; + GdkVisual *visual; + gpointer windowing_data; + }; + + + struct _GdkGC { + GObject parent_instance; + gint clip_x_origin; + gint clip_y_origin; + gint ts_x_origin; + gint ts_y_origin; + GdkColormap *colormap; + }; + + + struct _GdkDeviceAxis { + GdkAxisUse use; + gdouble min; + gdouble max; + }; + + + struct _GdkDeviceKey { + guint keyval; + GdkModifierType modifiers; + }; + + + struct _GdkDevice { + GObject parent_instance; + gchar *name; + GdkInputSource source; + GdkInputMode mode; + gboolean has_cursor; + gint num_axes; + GdkDeviceAxis *axes; + gint num_keys; + GdkDeviceKey *keys; + }; + + + struct _GdkDisplay { + GObject parent_instance; + GList *queued_events; + GList *queued_tail; + guint32 button_click_time[2]; + GdkWindow *button_window[2]; + gint button_number[2]; + guint double_click_time; + GdkDevice *core_pointer; + const GdkDisplayPointerHooks *pointer_hooks; + guint closed:1; + guint double_click_distance; + gint button_x[2]; + gint button_y[2]; + }; + + + struct _GdkScreen { + GObject parent_instance; + guint closed:1; + GdkGC *normal_gcs[32]; + GdkGC *exposure_gcs[32]; + }; + + + struct _GdkDisplayPointerHooks { + void (*get_pointer) (GdkDisplay *, GdkScreen * *, gint *, gint *, + GdkModifierType *); + GdkWindow *(*window_get_pointer) (GdkDisplay *, GdkWindow *, + gint *, gint *, + GdkModifierType *); + GdkWindow *(*window_at_pointer) (GdkDisplay *, gint *, gint *); + }; + + + struct _GdkCursor { + GdkCursorType type; + guint ref_count; + }; + + + struct _GdkKeymap { + GObject parent_instance; + GdkDisplay *display; + }; + + + struct _GdkEventAny { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + }; + + + struct _GdkRectangle { + gint x; + gint y; + gint width; + gint height; + }; + + + + + + struct _GdkEventExpose { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkRectangle area; + GdkRegion *region; + gint count; + }; + + + struct _GdkEventNoExpose { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + }; + + + struct _GdkEventVisibility { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkVisibilityState state; + }; + + + struct _GdkEventMotion { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + gdouble x; + gdouble y; + gdouble *axes; + guint state; + gint16 is_hint; + GdkDevice *device; + gdouble x_root; + gdouble y_root; + }; + + + struct _GdkEventButton { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + gdouble x; + gdouble y; + gdouble *axes; + guint state; + guint button; + GdkDevice *device; + gdouble x_root; + gdouble y_root; + }; + + + struct _GdkEventScroll { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + gdouble x; + gdouble y; + guint state; + GdkScrollDirection direction; + GdkDevice *device; + gdouble x_root; + gdouble y_root; + }; + + + struct _GdkEventKey { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + guint state; + guint keyval; + gint length; + gchar *string; + guint16 hardware_keycode; + guint8 group; + }; + + + struct _GdkEventCrossing { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkWindow *subwindow; + guint32 time; + gdouble x; + gdouble y; + gdouble x_root; + gdouble y_root; + GdkCrossingMode mode; + GdkNotifyType detail; + gboolean focus; + guint state; + }; + + + struct _GdkEventFocus { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + gint16 in; + }; + + + struct _GdkEventConfigure { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + gint x; + gint y; + gint width; + gint height; + }; + + + struct _GdkEventProperty { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkAtom atom; + guint32 time; + guint state; + }; + + + struct _GdkEventSelection { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkAtom selection; + GdkAtom target; + GdkAtom property; + guint32 time; + GdkNativeWindow requestor; + }; + + + struct _GdkEventOwnerChange { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkNativeWindow owner; + GdkOwnerChange reason; + GdkAtom selection; + guint32 time; + guint32 selection_time; + }; + + + struct _GdkEventProximity { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + GdkDevice *device; + }; + + + struct _GdkEventClient { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkAtom message_type; + gushort data_format; + union { + char b[20]; + short int s[10]; + long int l[5]; + } data; + }; + + + struct _GdkDragContext { + GObject parent_instance; + GdkDragProtocol protocol; + gboolean is_source; + GdkWindow *source_window; + GdkWindow *dest_window; + GList *targets; + GdkDragAction actions; + GdkDragAction suggested_action; + GdkDragAction action; + guint32 start_time; + gpointer windowing_data; + }; + + + struct _GdkEventDND { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkDragContext *context; + guint32 time; + gshort x_root; + gshort y_root; + }; + + + struct _GdkEventWindowState { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkWindowState changed_mask; + GdkWindowState new_window_state; + }; + + + struct _GdkEventSetting { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkSettingAction action; + char *name; + }; + + union _GdkEvent { + GdkEventType type; + GdkEventAny any; + GdkEventExpose expose; + GdkEventNoExpose no_expose; + GdkEventVisibility visibility; + GdkEventMotion motion; + GdkEventButton button; + GdkEventScroll scroll; + GdkEventKey key; + GdkEventCrossing crossing; + GdkEventFocus focus_change; + GdkEventConfigure configure; + GdkEventProperty property; + GdkEventSelection selection; + GdkEventOwnerChange owner_change; + GdkEventProximity proximity; + GdkEventClient client; + GdkEventDND dnd; + GdkEventWindowState window_state; + GdkEventSetting setting; + }; + + + + + + struct _GdkImage { + GObject parent_instance; + GdkImageType type; + GdkVisual *visual; + GdkByteOrder byte_order; + gint width; + gint height; + guint16 depth; + guint16 bpp; + guint16 bpl; + guint16 bits_per_pixel; + gpointer mem; + GdkColormap *colormap; + gpointer windowing_data; + }; + + + + + + struct _GdkPangoRenderer { + PangoRenderer parent_instance; + GdkPangoRendererPrivate *priv; + }; + + + struct _GdkTimeCoord { + guint32 time; + gdouble axes[128]; + }; + + + struct _GdkPoint { + gint x; + gint y; + }; + + + + + + struct _GdkKeymapKey { + guint keycode; + gint group; + gint level; + }; + + + struct _GdkRgbCmap { + guint32 colors[256]; + gint n_colors; + GSList *info_list; + }; + + + struct _GdkGCValues { + GdkColor foreground; + GdkColor background; + GdkFont *font; + GdkFunction function; + GdkFill fill; + GdkPixmap *tile; + GdkPixmap *stipple; + GdkPixmap *clip_mask; + GdkSubwindowMode subwindow_mode; + gint ts_x_origin; + gint ts_y_origin; + gint clip_x_origin; + gint clip_y_origin; + gint graphics_exposures; + gint line_width; + GdkLineStyle line_style; + GdkCapStyle cap_style; + GdkJoinStyle join_style; + }; + + + struct _GdkSpan { + gint x; + gint y; + gint width; + }; + + + struct _GdkGeometry { + gint min_width; + gint min_height; + gint max_width; + gint max_height; + gint base_width; + gint base_height; + gint width_inc; + gint height_inc; + gdouble min_aspect; + gdouble max_aspect; + GdkGravity win_gravity; + }; + + + struct _GdkSegment { + gint x1; + gint y1; + gint x2; + gint y2; + }; + + + struct _GdkWindowAttr { + gchar *title; + gint event_mask; + gint x; + gint y; + gint width; + gint height; + GdkWindowClass wclass; + GdkVisual *visual; + GdkColormap *colormap; + GdkWindowType window_type; + GdkCursor *cursor; + gchar *wmclass_name; + gchar *wmclass_class; + gboolean override_redirect; + }; + + + struct _GdkTrapezoid { + double y1; + double x11; + double x21; + double y2; + double x12; + double x22; + }; + + + struct _GdkPointerHooks { + GdkWindow *(*get_pointer) (GdkWindow *, gint *, gint *, + GdkModifierType *); + GdkWindow *(*window_at_pointer) (GdkScreen *, gint *, gint *); + }; + + + struct _GdkWindowObject { + GdkDrawable parent_instance; + GdkDrawable *impl; + GdkWindowObject *parent; + gpointer user_data; + gint x; + gint y; + gint extension_events; + GList *filters; + GList *children; + GdkColor bg_color; + GdkPixmap *bg_pixmap; + GSList *paint_stack; + GdkRegion *update_area; + guint update_freeze_count; + guint8 window_type; + guint8 depth; + guint8 resize_count; + GdkWindowState state; + guint guffaw_gravity:1; + guint input_only:1; + guint modal_hint:1; + guint destroyed:2; + guint accept_focus:1; + guint focus_on_map:1; + GdkEventMask event_mask; + }; + + + struct _GdkScreenClass { + GObjectClass parent_class; + void (*size_changed) (GdkScreen *); + }; + + + struct _GdkPixmapObject { + GdkDrawable parent_instance; + GdkDrawable *impl; + gint depth; + }; + + + struct _GdkImageClass { + GObjectClass parent_class; + }; + + + struct _GdkKeymapClass { + GObjectClass parent_class; + void (*direction_changed) (GdkKeymap *); + void (*keys_changed) (GdkKeymap *); + }; + + + struct _GdkDrawableClass { + GObjectClass parent_class; + GdkGC *(*create_gc) (GdkDrawable *, GdkGCValues *, + GdkGCValuesMask); + void (*draw_rectangle) (GdkDrawable *, GdkGC *, gboolean, gint, + gint, gint, gint); + void (*draw_arc) (GdkDrawable *, GdkGC *, gboolean, gint, gint, + gint, gint, gint, gint); + void (*draw_polygon) (GdkDrawable *, GdkGC *, gboolean, GdkPoint *, + gint); + void (*draw_text) (GdkDrawable *, GdkFont *, GdkGC *, gint, gint, + const gchar *, gint); + void (*draw_text_wc) (GdkDrawable *, GdkFont *, GdkGC *, gint, + gint, const GdkWChar *, gint); + void (*draw_drawable) (GdkDrawable *, GdkGC *, GdkDrawable *, gint, + gint, gint, gint, gint, gint); + void (*draw_points) (GdkDrawable *, GdkGC *, GdkPoint *, gint); + void (*draw_segments) (GdkDrawable *, GdkGC *, GdkSegment *, gint); + void (*draw_lines) (GdkDrawable *, GdkGC *, GdkPoint *, gint); + void (*draw_glyphs) (GdkDrawable *, GdkGC *, PangoFont *, gint, + gint, PangoGlyphString *); + void (*draw_image) (GdkDrawable *, GdkGC *, GdkImage *, gint, gint, + gint, gint, gint, gint); + gint(*get_depth) (GdkDrawable *); + void (*get_size) (GdkDrawable *, gint *, gint *); + void (*set_colormap) (GdkDrawable *, GdkColormap *); + GdkColormap *(*get_colormap) (GdkDrawable *); + GdkVisual *(*get_visual) (GdkDrawable *); + GdkScreen *(*get_screen) (GdkDrawable *); + GdkImage *(*get_image) (GdkDrawable *, gint, gint, gint, gint); + GdkRegion *(*get_clip_region) (GdkDrawable *); + GdkRegion *(*get_visible_region) (GdkDrawable *); + GdkDrawable *(*get_composite_drawable) (GdkDrawable *, gint, gint, + gint, gint, gint *, + gint *); + void (*draw_pixbuf) (GdkDrawable *, GdkGC *, GdkPixbuf *, gint, + gint, gint, gint, gint, gint, GdkRgbDither, + gint, gint); + GdkImage *(*_copy_to_image) (GdkDrawable *, GdkImage *, gint, gint, + gint, gint, gint, gint); + void (*draw_glyphs_transformed) (GdkDrawable *, GdkGC *, + PangoMatrix *, PangoFont *, gint, + gint, PangoGlyphString *); + void (*draw_trapezoids) (GdkDrawable *, GdkGC *, GdkTrapezoid *, + gint); + void (*_gdk_reserved3) (void); + void (*_gdk_reserved4) (void); + void (*_gdk_reserved5) (void); + void (*_gdk_reserved6) (void); + void (*_gdk_reserved7) (void); + void (*_gdk_reserved9) (void); + void (*_gdk_reserved10) (void); + void (*_gdk_reserved11) (void); + void (*_gdk_reserved12) (void); + void (*_gdk_reserved13) (void); + void (*_gdk_reserved14) (void); + void (*_gdk_reserved15) (void); + void (*_gdk_reserved16) (void); + }; + + + struct _GdkPangoAttrEmbossed { + PangoAttribute attr; + gboolean embossed; + }; + + + struct _GdkDisplayManagerClass { + GObjectClass parent_class; + void (*display_opened) (GdkDisplayManager *, GdkDisplay *); + }; + + + struct _GdkPixmapObjectClass { + GdkDrawableClass parent_class; + }; + + + struct _GdkPangoRendererClass { + PangoRendererClass parent_class; + }; + + + struct _GdkDisplayClass { + GObjectClass parent_class; + const gchar *(*get_display_name) (GdkDisplay *); + gint(*get_n_screens) (GdkDisplay *); + GdkScreen *(*get_screen) (GdkDisplay *, gint); + GdkScreen *(*get_default_screen) (GdkDisplay *); + void (*closed) (GdkDisplay *, gboolean); + }; + + + struct _GdkPangoAttrStipple { + PangoAttribute attr; + GdkBitmap *stipple; + }; + + + struct _GdkColormapClass { + GObjectClass parent_class; + }; + + + struct _GdkDragContextClass { + GObjectClass parent_class; + }; + + + struct _GdkWindowObjectClass { + GdkDrawableClass parent_class; + }; + + + struct _GdkGCClass { + GObjectClass parent_class; + void (*get_values) (GdkGC *, GdkGCValues *); + void (*set_values) (GdkGC *, GdkGCValues *, GdkGCValuesMask); + void (*set_dashes) (GdkGC *, gint, gint8 *, gint); + void (*_gdk_reserved1) (void); + void (*_gdk_reserved2) (void); + void (*_gdk_reserved3) (void); + void (*_gdk_reserved4) (void); + }; + + + + + + + + + extern void gdk_window_deiconify(GdkWindow *); + extern GType gdk_device_get_type(void); + extern void gdk_gc_set_clip_origin(GdkGC *, gint, gint); + extern GdkColormap *gdk_drawable_get_colormap(GdkDrawable *); + extern void gdk_flush(void); + extern gint gdk_screen_height_mm(void); + extern void gdk_display_get_pointer(GdkDisplay *, GdkScreen * *, + gint *, gint *, GdkModifierType *); + extern GdkEventMask gdk_window_get_events(GdkWindow *); + extern void gdk_window_scroll(GdkWindow *, gint, gint); + extern GType gdk_window_object_get_type(void); + extern GdkCursor *gdk_cursor_new_from_pixbuf(GdkDisplay *, GdkPixbuf *, + gint, gint); + extern GType gdk_axis_use_get_type(void); + extern GType gdk_fill_get_type(void); + extern void gdk_window_resize(GdkWindow *, gint, gint); + extern GdkKeymap *gdk_keymap_get_for_display(GdkDisplay *); + extern void gdk_display_add_client_message_filter(GdkDisplay *, + GdkAtom, + GdkFilterFunc, + gpointer); + extern GdkPixmap *gdk_pixmap_create_from_xpm_d(GdkDrawable *, + GdkBitmap * *, + const GdkColor *, + gchar * *); + extern gboolean gdk_display_supports_selection_notification(GdkDisplay + *); + extern GSList *gdk_display_manager_list_displays(GdkDisplayManager *); + extern void gdk_gc_set_subwindow(GdkGC *, GdkSubwindowMode); + extern void gdk_gc_set_colormap(GdkGC *, GdkColormap *); + extern GType gdk_grab_status_get_type(void); + extern GType gdk_visual_get_type(void); + extern GdkVisual *gdk_rgb_get_visual(void); + extern GType gdk_event_get_type(void); + extern void gdk_display_set_double_click_time(GdkDisplay *, guint); + extern GList *gdk_devices_list(void); + extern void gdk_draw_layout_line(GdkDrawable *, GdkGC *, gint, gint, + PangoLayoutLine *); + extern gboolean gdk_init_check(int *, char ***); + extern gboolean gdk_event_get_root_coords(GdkEvent *, gdouble *, + gdouble *); + extern void gdk_window_begin_resize_drag(GdkWindow *, GdkWindowEdge, + gint, gint, gint, guint32); + extern guint gdk_keyval_from_name(const gchar *); + extern gboolean gdk_display_request_selection_notification(GdkDisplay + *, GdkAtom); + extern void gdk_window_raise(GdkWindow *); + extern GdkImage *gdk_image_new(GdkImageType, GdkVisual *, gint, gint); + extern GdkAtom gdk_atom_intern(const gchar *, gboolean); + extern void gdk_window_get_frame_extents(GdkWindow *, GdkRectangle *); + extern gboolean gdk_rectangle_intersect(GdkRectangle *, GdkRectangle *, + GdkRectangle *); + extern GdkWindow *gdk_selection_owner_get_for_display(GdkDisplay *, + GdkAtom); + extern PangoRenderer *gdk_pango_renderer_get_default(GdkScreen *); + extern gchar *gdk_get_display(void); + extern void gdk_gc_set_dashes(GdkGC *, gint, gint8 *, gint); + extern void gdk_device_set_key(GdkDevice *, guint, guint, + GdkModifierType); + extern void gdk_pango_renderer_set_override_color(GdkPangoRenderer *, + PangoRenderPart, + const GdkColor *); + extern void gdk_window_iconify(GdkWindow *); + extern void gdk_display_set_double_click_distance(GdkDisplay *, guint); + extern GdkWindow *gdk_window_get_group(GdkWindow *); + extern GdkDevice *gdk_device_get_core_pointer(void); + extern guint gdk_color_hash(const GdkColor *); + extern void gdk_screen_get_monitor_geometry(GdkScreen *, gint, + GdkRectangle *); + extern void gdk_device_set_source(GdkDevice *, GdkInputSource); + extern GType gdk_input_mode_get_type(void); + extern GdkWindow *gdk_get_default_root_window(void); + extern gchar *gdk_screen_make_display_name(GdkScreen *); + extern GdkGrabStatus gdk_pointer_grab(GdkWindow *, gboolean, + GdkEventMask, GdkWindow *, + GdkCursor *, guint32); + extern void gdk_window_set_title(GdkWindow *, const gchar *); + extern void gdk_property_delete(GdkWindow *, GdkAtom); + extern GdkColormap *gdk_rgb_get_colormap(void); + extern void gdk_free_text_list(gchar * *); + extern gint gdk_colormap_alloc_colors(GdkColormap *, GdkColor *, gint, + gboolean, gboolean, gboolean *); + extern void gdk_window_process_all_updates(void); + extern guint32 gdk_event_get_time(GdkEvent *); + extern gint gdk_text_property_to_text_list_for_display(GdkDisplay *, + GdkAtom, gint, + const guchar *, + gint, + gchar * **); + extern GdkAtom gdk_drag_get_selection(GdkDragContext *); + extern GdkScreen *gdk_screen_get_default(void); + extern void gdk_window_set_skip_pager_hint(GdkWindow *, gboolean); + extern GdkPixmap *gdk_pixmap_foreign_new(GdkNativeWindow); + extern GType gdk_window_hints_get_type(void); + extern void gdk_drag_drop(GdkDragContext *, guint32); + extern void gdk_gc_set_fill(GdkGC *, GdkFill); + extern void gdk_init(int *, char ***); + extern gboolean gdk_property_get(GdkWindow *, GdkAtom, GdkAtom, gulong, + gulong, gint, GdkAtom *, gint *, + gint *, guchar * *); + extern void gdk_gc_set_rgb_fg_color(GdkGC *, const GdkColor *); + extern void gdk_window_set_transient_for(GdkWindow *, GdkWindow *); + extern GdkRegion *gdk_pango_layout_line_get_clip_region(PangoLayoutLine + *, gint, gint, + gint *, gint); + extern GdkVisual *gdk_screen_get_system_visual(GdkScreen *); + extern GdkDisplay + *gdk_display_manager_get_default_display(GdkDisplayManager *); + extern gint gdk_text_property_to_utf8_list(GdkAtom, gint, + const guchar *, gint, + gchar * **); + extern void gdk_window_set_type_hint(GdkWindow *, GdkWindowTypeHint); + extern void gdk_parse_args(int *, char ***); + extern GdkPixmap *gdk_pixmap_create_from_xpm(GdkDrawable *, + GdkBitmap * *, + const GdkColor *, + const gchar *); + extern void gdk_window_set_group(GdkWindow *, GdkWindow *); + extern void gdk_window_focus(GdkWindow *, guint32); + extern void gdk_event_set_screen(GdkEvent *, GdkScreen *); + extern void gdk_display_flush(GdkDisplay *); + extern GType gdk_owner_change_get_type(void); + extern void gdk_region_subtract(GdkRegion *, GdkRegion *); + extern GType gdk_cap_style_get_type(void); + extern void gdk_window_unstick(GdkWindow *); + extern void gdk_draw_glyphs(GdkDrawable *, GdkGC *, PangoFont *, gint, + gint, PangoGlyphString *); + extern gint gdk_text_property_to_utf8_list_for_display(GdkDisplay *, + GdkAtom, gint, + const guchar *, + gint, + gchar * **); + extern void gdk_drag_abort(GdkDragContext *, guint32); + extern GdkWindow *gdk_display_get_window_at_pointer(GdkDisplay *, + gint *, gint *); + extern GdkDisplayPointerHooks *gdk_display_set_pointer_hooks(GdkDisplay + *, + const + GdkDisplayPointerHooks + *); + extern void gdk_window_set_debug_updates(gboolean); + extern gboolean gdk_spawn_command_line_on_screen(GdkScreen *, + const gchar *, + GError * *); + extern GdkRegion *gdk_region_copy(GdkRegion *); + extern GdkEvent *gdk_display_peek_event(GdkDisplay *); + extern GdkColormap *gdk_gc_get_colormap(GdkGC *); + extern void gdk_selection_send_notify(guint32, GdkAtom, GdkAtom, + GdkAtom, guint32); + extern const char *gdk_get_program_class(void); + extern GType gdk_filter_return_get_type(void); + extern void gdk_drop_reply(GdkDragContext *, gboolean, guint32); + extern void gdk_threads_enter(void); + extern void gdk_device_free_history(GdkTimeCoord * *, gint); + extern GdkImage *gdk_drawable_get_image(GdkDrawable *, gint, gint, + gint, gint); + extern GType gdk_event_mask_get_type(void); + extern void gdk_set_program_class(const char *); + extern void gdk_draw_polygon(GdkDrawable *, GdkGC *, gboolean, + GdkPoint *, gint); + extern GType gdk_function_get_type(void); + extern void gdk_display_close(GdkDisplay *); + extern gint gdk_screen_get_n_monitors(GdkScreen *); + extern gboolean gdk_keymap_translate_keyboard_state(GdkKeymap *, guint, + GdkModifierType, + gint, guint *, + gint *, gint *, + GdkModifierType *); + extern GType gdk_rectangle_get_type(void); + extern GdkDisplay *gdk_screen_get_display(GdkScreen *); + extern GList *gdk_window_get_toplevels(void); + extern GdkVisual *gdk_visual_get_best_with_depth(gint); + extern gboolean gdk_display_supports_cursor_alpha(GdkDisplay *); + extern void gdk_window_set_decorations(GdkWindow *, GdkWMDecoration); + extern PangoContext *gdk_pango_context_get_for_screen(GdkScreen *); + extern GdkVisual *gdk_colormap_get_visual(GdkColormap *); + extern void gdk_error_trap_push(void); + extern void gdk_display_beep(GdkDisplay *); + extern gboolean gdk_spawn_on_screen(GdkScreen *, const gchar *, + gchar * *, gchar * *, GSpawnFlags, + GSpawnChildSetupFunc, gpointer, + gint *, GError * *); + extern void gdk_add_client_message_filter(GdkAtom, GdkFilterFunc, + gpointer); + extern PangoDirection gdk_keymap_get_direction(GdkKeymap *); + extern PangoAttribute *gdk_pango_attr_stipple_new(GdkBitmap *); + extern void gdk_window_lower(GdkWindow *); + extern gboolean gdk_rgb_ditherable(void); + extern gboolean gdk_colormap_alloc_color(GdkColormap *, GdkColor *, + gboolean, gboolean); + extern GdkWindow *gdk_display_get_default_group(GdkDisplay *); + extern GType gdk_event_type_get_type(void); + extern GType gdk_color_get_type(void); + extern GType gdk_drag_protocol_get_type(void); + extern GType gdk_gravity_get_type(void); + extern gboolean gdk_events_pending(void); + extern GType gdk_input_condition_get_type(void); + extern GType gdk_input_source_get_type(void); + extern gchar *gdk_utf8_to_string_target(const gchar *); + extern void gdk_threads_init(void); + extern void gdk_gc_set_foreground(GdkGC *, const GdkColor *); + extern gint gdk_string_to_compound_text_for_display(GdkDisplay *, + const gchar *, + GdkAtom *, gint *, + guchar * *, + gint *); + extern GdkWindow *gdk_window_get_toplevel(GdkWindow *); + extern void gdk_drop_finish(GdkDragContext *, gboolean, guint32); + extern void gdk_window_set_functions(GdkWindow *, GdkWMFunction); + extern void gdk_window_invalidate_maybe_recurse(GdkWindow *, + GdkRegion *, + gboolean(*)(GdkWindow + *, + gpointer) + , gpointer); + extern gint gdk_screen_get_height(GdkScreen *); + extern gboolean gdk_keymap_get_entries_for_keyval(GdkKeymap *, guint, + GdkKeymapKey * *, + gint *); + extern GdkDragContext *gdk_drag_context_new(void); + extern void gdk_colormap_query_color(GdkColormap *, gulong, + GdkColor *); + extern void gdk_pixbuf_render_pixmap_and_mask_for_colormap(GdkPixbuf *, + GdkColormap + *, + GdkPixmap * + *, + GdkBitmap * + *, int); + extern void gdk_region_intersect(GdkRegion *, GdkRegion *); + extern GdkWindow *gdk_selection_owner_get(GdkAtom); + extern void gdk_draw_pixbuf(GdkDrawable *, GdkGC *, GdkPixbuf *, gint, + gint, gint, gint, gint, gint, GdkRgbDither, + gint, gint); + extern void gdk_rgb_cmap_free(GdkRgbCmap *); + extern GdkDisplay *gdk_display_open(const gchar *); + extern GdkPixmap *gdk_pixmap_colormap_create_from_xpm_d(GdkDrawable *, + GdkColormap *, + GdkBitmap * *, + const GdkColor + *, gchar * *); + extern gboolean gdk_keyval_is_lower(guint); + extern GCallback gdk_threads_unlock; + extern GType gdk_modifier_type_get_type(void); + extern gint gdk_visual_get_best_depth(void); + extern gboolean gdk_setting_get(const gchar *, GValue *); + extern GType gdk_screen_get_type(void); + extern guint32 gdk_drag_get_protocol_for_display(GdkDisplay *, guint32, + GdkDragProtocol *); + extern GList *gdk_screen_get_toplevel_windows(GdkScreen *); + extern GdkGC *gdk_gc_new_with_values(GdkDrawable *, GdkGCValues *, + GdkGCValuesMask); + extern GdkScreen *gdk_display_get_default_screen(GdkDisplay *); + extern gboolean gdk_drag_motion(GdkDragContext *, GdkWindow *, + GdkDragProtocol, gint, gint, + GdkDragAction, GdkDragAction, guint32); + extern GdkRegion *gdk_drawable_get_visible_region(GdkDrawable *); + extern void gdk_pango_renderer_set_stipple(GdkPangoRenderer *, + PangoRenderPart, + GdkBitmap *); + extern void gdk_display_get_maximal_cursor_size(GdkDisplay *, guint *, + guint *); + extern GdkRegion *gdk_window_get_update_area(GdkWindow *); + extern void gdk_drag_status(GdkDragContext *, GdkDragAction, guint32); + extern gboolean gdk_keyval_is_upper(guint); + extern void gdk_window_begin_paint_region(GdkWindow *, GdkRegion *); + extern void gdk_pango_renderer_set_drawable(GdkPangoRenderer *, + GdkDrawable *); + extern gint gdk_screen_get_monitor_at_point(GdkScreen *, gint, gint); + extern gboolean gdk_utf8_to_compound_text_for_display(GdkDisplay *, + const gchar *, + GdkAtom *, + gint *, + guchar * *, + gint *); + extern GdkColormap *gdk_image_get_colormap(GdkImage *); + extern gint gdk_window_get_origin(GdkWindow *, gint *, gint *); + extern void gdk_set_double_click_time(guint); + extern void gdk_gc_get_values(GdkGC *, GdkGCValues *); + extern GdkColor *gdk_color_copy(const GdkColor *); + extern void gdk_gc_set_tile(GdkGC *, GdkPixmap *); + extern gboolean gdk_event_get_coords(GdkEvent *, gdouble *, gdouble *); + extern void gdk_gc_set_ts_origin(GdkGC *, gint, gint); + extern GdkWindowType gdk_window_get_window_type(GdkWindow *); + extern void gdk_window_set_focus_on_map(GdkWindow *, gboolean); + extern void gdk_region_union_with_rect(GdkRegion *, GdkRectangle *); + extern gboolean gdk_keymap_get_entries_for_keycode(GdkKeymap *, guint, + GdkKeymapKey * *, + guint * *, gint *); + extern gboolean gdk_selection_property_get(GdkWindow *, guchar * *, + GdkAtom *, gint *); + extern void gdk_display_keyboard_ungrab(GdkDisplay *, guint32); + extern GdkDisplay *gdk_drawable_get_display(GdkDrawable *); + extern void gdk_gc_set_stipple(GdkGC *, GdkPixmap *); + extern void gdk_window_clear_area_e(GdkWindow *, gint, gint, gint, + gint); + extern void gdk_window_set_keep_below(GdkWindow *, gboolean); + extern GType gdk_font_type_get_type(void); + extern GType gdk_visual_type_get_type(void); + extern GdkEvent *gdk_display_get_event(GdkDisplay *); + extern void gdk_pixbuf_render_pixmap_and_mask(GdkPixbuf *, + GdkPixmap * *, + GdkBitmap * *, int); + extern GdkVisual *gdk_drawable_get_visual(GdkDrawable *); + extern void gdk_image_set_colormap(GdkImage *, GdkColormap *); + extern guint gdk_keyval_to_upper(guint); + extern void gdk_set_show_events(gboolean); + extern GdkWindow *gdk_window_lookup_for_display(GdkDisplay *, + GdkNativeWindow); + extern GdkPixmap *gdk_pixmap_new(GdkDrawable *, gint, gint, gint); + extern GdkColormap *gdk_screen_get_rgb_colormap(GdkScreen *); + extern void gdk_rgb_find_color(GdkColormap *, GdkColor *); + extern void gdk_window_set_override_redirect(GdkWindow *, gboolean); + extern void gdk_window_set_accept_focus(GdkWindow *, gboolean); + extern GdkEvent *gdk_event_peek(void); + extern void gdk_window_show(GdkWindow *); + extern GType gdk_overlap_type_get_type(void); + extern void gdk_window_show_unraised(GdkWindow *); + extern GType gdk_gc_values_mask_get_type(void); + extern void gdk_screen_broadcast_client_message(GdkScreen *, + GdkEvent *); + extern void gdk_window_set_events(GdkWindow *, GdkEventMask); + extern void gdk_window_set_icon(GdkWindow *, GdkWindow *, GdkPixmap *, + GdkBitmap *); + extern GType gdk_join_style_get_type(void); + extern gboolean gdk_utf8_to_compound_text(const gchar *, GdkAtom *, + gint *, guchar * *, gint *); + extern void gdk_display_put_event(GdkDisplay *, GdkEvent *); + extern GList *gdk_window_peek_children(GdkWindow *); + extern void gdk_window_enable_synchronized_configure(GdkWindow *); + extern void gdk_window_set_role(GdkWindow *, const gchar *); + extern GdkDisplay *gdk_display_get_default(void); + extern void gdk_window_remove_filter(GdkWindow *, GdkFilterFunc, + gpointer); + extern void gdk_gc_set_function(GdkGC *, GdkFunction); + extern GList *gdk_list_visuals(void); + extern void gdk_pixbuf_render_threshold_alpha(GdkPixbuf *, GdkBitmap *, + int, int, int, int, int, + int, int); + extern void gdk_region_spans_intersect_foreach(GdkRegion *, GdkSpan *, + int, gboolean, + GdkSpanFunc, gpointer); + extern void gdk_display_pointer_ungrab(GdkDisplay *, guint32); + extern GdkColormap *gdk_screen_get_default_colormap(GdkScreen *); + extern gboolean gdk_rgb_colormap_ditherable(GdkColormap *); + extern void gdk_window_move(GdkWindow *, gint, gint); + extern GdkImage *gdk_drawable_copy_to_image(GdkDrawable *, GdkImage *, + gint, gint, gint, gint, + gint, gint); + extern void gdk_window_reparent(GdkWindow *, GdkWindow *, gint, gint); + extern GList *gdk_display_list_devices(GdkDisplay *); + extern GdkVisual *gdk_screen_get_rgb_visual(GdkScreen *); + extern void gdk_set_sm_client_id(const gchar *); + extern void gdk_region_destroy(GdkRegion *); + extern void gdk_display_manager_set_default_display(GdkDisplayManager + *, GdkDisplay *); + extern void gdk_beep(void); + extern GdkColormap *gdk_colormap_get_system(void); + extern void gdk_display_store_clipboard(GdkDisplay *, GdkWindow *, + guint32, GdkAtom *, gint); + extern gint gdk_error_trap_pop(void); + extern PangoAttribute *gdk_pango_attr_embossed_new(gboolean); + extern void gdk_drawable_set_colormap(GdkDrawable *, GdkColormap *); + extern GdkDisplay *gdk_cursor_get_display(GdkCursor *); + extern void gdk_window_add_filter(GdkWindow *, GdkFilterFunc, + gpointer); + extern void gdk_draw_line(GdkDrawable *, GdkGC *, gint, gint, gint, + gint); + extern gboolean gdk_event_send_client_message(GdkEvent *, + GdkNativeWindow); + extern void gdk_window_set_geometry_hints(GdkWindow *, GdkGeometry *, + GdkWindowHints); + extern GType gdk_window_class_get_type(void); + extern guint gdk_unicode_to_keyval(guint32); + extern void gdk_draw_arc(GdkDrawable *, GdkGC *, gboolean, gint, gint, + gint, gint, gint, gint); + extern void gdk_event_handler_set(GdkEventFunc, gpointer, + GDestroyNotify); + extern void gdk_region_get_clipbox(GdkRegion *, GdkRectangle *); + extern GType gdk_drawable_get_type(void); + extern void gdk_window_clear_area(GdkWindow *, gint, gint, gint, gint); + extern void gdk_draw_layout(GdkDrawable *, GdkGC *, int, int, + PangoLayout *); + extern void gdk_window_get_root_origin(GdkWindow *, gint *, gint *); + extern gint gdk_color_parse(const gchar *, GdkColor *); + extern void gdk_window_set_skip_taskbar_hint(GdkWindow *, gboolean); + extern GType gdk_gc_get_type(void); + extern GdkRegion *gdk_pango_layout_get_clip_region(PangoLayout *, gint, + gint, gint *, gint); + extern void gdk_window_fullscreen(GdkWindow *); + extern gchar *gdk_keyval_name(guint); + extern GdkCursor *gdk_cursor_new(GdkCursorType); + extern PangoContext *gdk_pango_context_get(void); + extern GType gdk_rgb_dither_get_type(void); + extern void gdk_window_hide(GdkWindow *); + extern void gdk_window_register_dnd(GdkWindow *); + extern GType gdk_notify_type_get_type(void); + extern void gdk_window_invalidate_rect(GdkWindow *, GdkRectangle *, + gboolean); + extern void gdk_window_unmaximize(GdkWindow *); + extern void gdk_gc_copy(GdkGC *, GdkGC *); + extern guint gdk_display_get_default_cursor_size(GdkDisplay *); + extern void gdk_window_set_cursor(GdkWindow *, GdkCursor *); + extern void gdk_keyval_convert_case(guint, guint *, guint *); + extern GdkVisual *gdk_visual_get_best_with_type(GdkVisualType); + extern void gdk_gc_set_exposures(GdkGC *, gboolean); + extern GdkDisplayManager *gdk_display_manager_get(void); + extern void gdk_gc_set_background(GdkGC *, const GdkColor *); + extern void gdk_draw_point(GdkDrawable *, GdkGC *, gint, gint); + extern GdkVisual *gdk_visual_get_best(void); + extern GList *gdk_window_get_children(GdkWindow *); + extern gint gdk_screen_height(void); + extern void gdk_selection_convert(GdkWindow *, GdkAtom, GdkAtom, + guint32); + extern GdkWindow *gdk_window_get_pointer(GdkWindow *, gint *, gint *, + GdkModifierType *); + extern void gdk_window_end_paint(GdkWindow *); + extern GType gdk_pixmap_get_type(void); + extern GType gdk_property_state_get_type(void); + extern void gdk_window_maximize(GdkWindow *); + extern void gdk_window_get_user_data(GdkWindow *, gpointer *); + extern GdkGrabStatus gdk_keyboard_grab(GdkWindow *, gboolean, guint32); + extern GType gdk_visibility_state_get_type(void); + extern void gdk_draw_indexed_image(GdkDrawable *, GdkGC *, gint, gint, + gint, gint, GdkRgbDither, guchar *, + gint, GdkRgbCmap *); + extern gboolean gdk_color_equal(const GdkColor *, const GdkColor *); + extern gboolean gdk_region_empty(GdkRegion *); + extern void gdk_region_offset(GdkRegion *, gint, gint); + extern gint gdk_string_to_compound_text(const gchar *, GdkAtom *, + gint *, guchar * *, gint *); + extern GdkScreen *gdk_gc_get_screen(GdkGC *); + extern GdkOverlapType gdk_region_rect_in(GdkRegion *, GdkRectangle *); + extern GType gdk_cursor_type_get_type(void); + extern gboolean gdk_window_set_static_gravities(GdkWindow *, gboolean); + extern gint gdk_screen_get_number(GdkScreen *); + extern void gdk_draw_segments(GdkDrawable *, GdkGC *, GdkSegment *, + gint); + extern guint32 gdk_keyval_to_unicode(guint); + extern void gdk_draw_layout_line_with_colors(GdkDrawable *, GdkGC *, + gint, gint, + PangoLayoutLine *, + const GdkColor *, + const GdkColor *); + extern void gdk_property_change(GdkWindow *, GdkAtom, GdkAtom, gint, + GdkPropMode, const guchar *, gint); + extern gboolean gdk_event_send_client_message_for_display(GdkDisplay *, + GdkEvent *, + GdkNativeWindow); + extern gboolean gdk_screen_get_setting(GdkScreen *, const gchar *, + GValue *); + extern GList *gdk_screen_list_visuals(GdkScreen *); + extern GType gdk_window_attributes_type_get_type(void); + extern GdkWindow *gdk_window_new(GdkWindow *, GdkWindowAttr *, gint); + extern void gdk_window_begin_move_drag(GdkWindow *, gint, gint, gint, + guint32); + extern void gdk_device_get_state(GdkDevice *, GdkWindow *, gdouble *, + GdkModifierType *); + extern void gdk_window_set_modal_hint(GdkWindow *, gboolean); + extern GdkEvent *gdk_event_new(GdkEventType); + extern void gdk_window_destroy(GdkWindow *); + extern GType gdk_wm_function_get_type(void); + extern GdkColormap *gdk_colormap_new(GdkVisual *, gboolean); + extern void gdk_draw_rgb_32_image(GdkDrawable *, GdkGC *, gint, gint, + gint, gint, GdkRgbDither, guchar *, + gint); + extern void gdk_window_set_background(GdkWindow *, const GdkColor *); + extern void gdk_window_stick(GdkWindow *); + extern GType gdk_pango_renderer_get_type(void); + extern void gdk_window_set_back_pixmap(GdkWindow *, GdkPixmap *, + gboolean); + extern gboolean gdk_display_supports_cursor_color(GdkDisplay *); + extern GdkDragContext *gdk_drag_begin(GdkWindow *, GList *); + extern void gdk_notify_startup_complete(void); + extern void gdk_display_sync(GdkDisplay *); + extern gboolean gdk_event_get_state(GdkEvent *, GdkModifierType *); + extern void gdk_gc_set_values(GdkGC *, GdkGCValues *, GdkGCValuesMask); + extern GdkEvent *gdk_event_get_graphics_expose(GdkWindow *); + extern void gdk_color_free(GdkColor *); + extern void gdk_rectangle_union(GdkRectangle *, GdkRectangle *, + GdkRectangle *); + extern void gdk_window_configure_finished(GdkWindow *); + extern gboolean gdk_drag_drop_succeeded(GdkDragContext *); + extern gint gdk_display_get_n_screens(GdkDisplay *); + extern void gdk_draw_layout_with_colors(GdkDrawable *, GdkGC *, int, + int, PangoLayout *, + const GdkColor *, + const GdkColor *); + extern gint gdk_drawable_get_depth(GdkDrawable *); + extern GdkPixmap *gdk_pixmap_foreign_new_for_display(GdkDisplay *, + GdkNativeWindow); + extern void gdk_event_send_clientmessage_toall(GdkEvent *); + extern GdkPixbuf *gdk_pixbuf_get_from_drawable(GdkPixbuf *, + GdkDrawable *, + GdkColormap *, int, int, + int, int, int, int); + extern void gdk_draw_gray_image(GdkDrawable *, GdkGC *, gint, gint, + gint, gint, GdkRgbDither, guchar *, + gint); + extern gint gdk_text_property_to_text_list(GdkAtom, gint, + const guchar *, gint, + gchar * **); + extern GCallback gdk_threads_lock; + extern gboolean gdk_region_equal(GdkRegion *, GdkRegion *); + extern GdkEvent *gdk_event_get(void); + extern void gdk_window_freeze_updates(GdkWindow *); + extern GdkScreen *gdk_visual_get_screen(GdkVisual *); + extern gboolean gdk_device_get_history(GdkDevice *, GdkWindow *, + guint32, guint32, + GdkTimeCoord * **, gint *); + extern void gdk_image_put_pixel(GdkImage *, gint, gint, guint32); + extern void gdk_screen_set_default_colormap(GdkScreen *, + GdkColormap *); + extern GType gdk_wm_decoration_get_type(void); + extern void gdk_draw_image(GdkDrawable *, GdkGC *, GdkImage *, gint, + gint, gint, gint, gint, gint); + extern void gdk_window_shape_combine_region(GdkWindow *, GdkRegion *, + gint, gint); + extern GdkGC *gdk_gc_new(GdkDrawable *); + extern GType gdk_status_get_type(void); + extern void gdk_window_set_keep_above(GdkWindow *, gboolean); + extern gboolean gdk_selection_owner_set_for_display(GdkDisplay *, + GdkWindow *, + GdkAtom, guint32, + gboolean); + extern GdkDevice *gdk_display_get_core_pointer(GdkDisplay *); + extern void gdk_cursor_unref(GdkCursor *); + extern GType gdk_display_manager_get_type(void); + extern const gchar *gdk_get_display_arg_name(void); + extern gboolean gdk_window_is_visible(GdkWindow *); + extern void gdk_region_union(GdkRegion *, GdkRegion *); + extern gint gdk_screen_get_width_mm(GdkScreen *); + extern void gdk_draw_lines(GdkDrawable *, GdkGC *, GdkPoint *, gint); + extern GType gdk_colormap_get_type(void); + extern guint32 gdk_drag_get_protocol(guint32, GdkDragProtocol *); + extern gint gdk_screen_get_width(GdkScreen *); + extern void gdk_selection_send_notify_for_display(GdkDisplay *, + guint32, GdkAtom, + GdkAtom, GdkAtom, + guint32); + extern gchar *gdk_set_locale(void); + extern GdkKeymap *gdk_keymap_get_default(void); + extern GdkScreen *gdk_colormap_get_screen(GdkColormap *); + extern GType gdk_byte_order_get_type(void); + extern void gdk_window_constrain_size(GdkGeometry *, guint, gint, gint, + gint *, gint *); + extern GdkWindow *gdk_screen_get_root_window(GdkScreen *); + extern void gdk_window_set_user_data(GdkWindow *, gpointer); + extern void gdk_colormap_free_colors(GdkColormap *, GdkColor *, gint); + extern void gdk_window_get_internal_paint_info(GdkWindow *, + GdkDrawable * *, gint *, + gint *); + extern gboolean gdk_window_is_viewable(GdkWindow *); + extern struct _GdkDrawable *gdk_bitmap_create_from_data(GdkDrawable *, + const gchar *, + gint, gint); + extern void gdk_window_unfullscreen(GdkWindow *); + extern void gdk_drag_find_window(GdkDragContext *, GdkWindow *, gint, + gint, GdkWindow * *, + GdkDragProtocol *); + extern GType gdk_keymap_get_type(void); + extern GType gdk_window_type_hint_get_type(void); + extern void gdk_gc_set_clip_mask(GdkGC *, GdkBitmap *); + extern gchar *gdk_atom_name(GdkAtom); + extern void gdk_rgb_set_verbose(gboolean); + extern void gdk_draw_rgb_image(GdkDrawable *, GdkGC *, gint, gint, + gint, gint, GdkRgbDither, guchar *, + gint); + extern void gdk_query_visual_types(GdkVisualType * *, gint *); + extern GType gdk_crossing_mode_get_type(void); + extern void gdk_draw_trapezoids(GdkDrawable *, GdkGC *, GdkTrapezoid *, + gint); + extern GdkPixmap *gdk_pixmap_create_from_data(GdkDrawable *, + const gchar *, gint, + gint, gint, + const GdkColor *, + const GdkColor *); + extern GType gdk_line_style_get_type(void); + extern gboolean gdk_window_get_decorations(GdkWindow *, + GdkWMDecoration *); + extern GType gdk_window_state_get_type(void); + extern void gdk_gc_offset(GdkGC *, gint, gint); + extern void gdk_event_free(GdkEvent *); + extern void gdk_gc_set_clip_region(GdkGC *, GdkRegion *); + extern gboolean gdk_device_set_mode(GdkDevice *, GdkInputMode); + extern void gdk_query_depths(gint * *, gint *); + extern void gdk_draw_rgb_32_image_dithalign(GdkDrawable *, GdkGC *, + gint, gint, gint, gint, + GdkRgbDither, guchar *, + gint, gint, gint); + extern GType gdk_subwindow_mode_get_type(void); + extern void gdk_rgb_set_install(gboolean); + extern guint gdk_keyval_to_lower(guint); + extern GType gdk_window_edge_get_type(void); + extern GdkPixmap *gdk_pixmap_lookup_for_display(GdkDisplay *, + GdkNativeWindow); + extern gboolean gdk_display_pointer_is_grabbed(GdkDisplay *); + extern GType gdk_prop_mode_get_type(void); + extern void gdk_window_withdraw(GdkWindow *); + extern void gdk_drawable_get_size(GdkDrawable *, gint *, gint *); + extern void gdk_window_merge_child_shapes(GdkWindow *); + extern guint gdk_keymap_lookup_key(GdkKeymap *, const GdkKeymapKey *); + extern GdkRegion *gdk_region_polygon(GdkPoint *, gint, GdkFillRule); + extern void gdk_window_clear(GdkWindow *); + extern const gchar *gdk_display_get_name(GdkDisplay *); + extern void gdk_pango_renderer_set_gc(GdkPangoRenderer *, GdkGC *); + extern gboolean gdk_spawn_on_screen_with_pipes(GdkScreen *, + const gchar *, + gchar * *, gchar * *, + GSpawnFlags, + GSpawnChildSetupFunc, + gpointer, gint *, + gint *, gint *, gint *, + GError * *); + extern void gdk_event_put(GdkEvent *); + extern GType gdk_window_type_get_type(void); + extern GdkScreen *gdk_event_get_screen(GdkEvent *); + extern GdkPointerHooks *gdk_set_pointer_hooks(const GdkPointerHooks *); + extern void gdk_draw_glyphs_transformed(GdkDrawable *, GdkGC *, + PangoMatrix *, PangoFont *, + gint, gint, + PangoGlyphString *); + extern void gdk_draw_rgb_image_dithalign(GdkDrawable *, GdkGC *, gint, + gint, gint, gint, + GdkRgbDither, guchar *, gint, + gint, gint); + extern void gdk_window_process_updates(GdkWindow *, gboolean); + extern GType gdk_extension_mode_get_type(void); + extern gboolean gdk_event_get_axis(GdkEvent *, GdkAxisUse, gdouble *); + extern void gdk_gc_set_clip_rectangle(GdkGC *, GdkRectangle *); + extern void gdk_gc_set_rgb_bg_color(GdkGC *, const GdkColor *); + extern void gdk_region_xor(GdkRegion *, GdkRegion *); + extern GdkCursor *gdk_cursor_ref(GdkCursor *); + extern GdkVisual *gdk_visual_get_best_with_both(gint, GdkVisualType); + extern GType gdk_scroll_direction_get_type(void); + extern void gdk_draw_points(GdkDrawable *, GdkGC *, GdkPoint *, gint); + extern GdkRgbCmap *gdk_rgb_cmap_new(guint32 *, gint); + extern GdkWindow *gdk_window_foreign_new(GdkNativeWindow); + extern GdkWindow *gdk_window_get_parent(GdkWindow *); + extern void gdk_draw_drawable(GdkDrawable *, GdkGC *, GdkDrawable *, + gint, gint, gint, gint, gint, gint); + extern void gdk_threads_set_lock_functions(GCallback, GCallback); + extern gint gdk_screen_get_height_mm(GdkScreen *); + extern gboolean gdk_device_get_axis(GdkDevice *, gdouble *, GdkAxisUse, + gdouble *); + extern gboolean gdk_get_show_events(void); + extern void gdk_window_begin_paint_rect(GdkWindow *, GdkRectangle *); + extern void gdk_pointer_ungrab(guint32); + extern GdkPixmap *gdk_pixmap_lookup(GdkNativeWindow); + extern void gdk_threads_leave(void); + extern gboolean gdk_pointer_is_grabbed(void); + extern gboolean gdk_region_point_in(GdkRegion *, int, int); + extern GdkWindowState gdk_window_get_state(GdkWindow *); + extern void gdk_region_get_rectangles(GdkRegion *, GdkRectangle * *, + gint *); + extern void gdk_draw_rectangle(GdkDrawable *, GdkGC *, gboolean, gint, + gint, gint, gint); + extern void gdk_gc_set_line_attributes(GdkGC *, gint, GdkLineStyle, + GdkCapStyle, GdkJoinStyle); + extern void gdk_window_get_geometry(GdkWindow *, gint *, gint *, + gint *, gint *, gint *); + extern void gdk_rgb_set_min_colors(gint); + extern gint gdk_screen_get_monitor_at_window(GdkScreen *, GdkWindow *); + extern GdkWindow *gdk_window_foreign_new_for_display(GdkDisplay *, + GdkNativeWindow); + extern GdkRegion *gdk_region_rectangle(GdkRectangle *); + extern void gdk_window_set_icon_list(GdkWindow *, GList *); + extern GdkPixbuf *gdk_pixbuf_get_from_image(GdkPixbuf *, GdkImage *, + GdkColormap *, int, int, + int, int, int, int); + extern void gdk_device_set_axis_use(GdkDevice *, guint, GdkAxisUse); + extern void gdk_keyboard_ungrab(guint32); + extern GdkWindow *gdk_window_at_pointer(gint *, gint *); + extern GdkVisual *gdk_visual_get_system(void); + extern void gdk_drag_find_window_for_screen(GdkDragContext *, + GdkWindow *, GdkScreen *, + gint, gint, GdkWindow * *, + GdkDragProtocol *); + extern GdkRegion *gdk_region_new(void); + extern GType gdk_image_type_get_type(void); + extern GType gdk_image_get_type(void); + extern gboolean gdk_display_supports_clipboard_persistence(GdkDisplay + *); + extern gint gdk_screen_width(void); + extern void gdk_input_set_extension_events(GdkWindow *, gint, + GdkExtensionMode); + extern GType gdk_display_get_type(void); + extern GdkCursor *gdk_cursor_new_for_display(GdkDisplay *, + GdkCursorType); + extern GdkRegion *gdk_drawable_get_clip_region(GdkDrawable *); + extern GdkScreen *gdk_display_get_screen(GdkDisplay *, gint); + extern GdkColormap *gdk_screen_get_system_colormap(GdkScreen *); + extern GdkVisualType gdk_visual_get_best_type(void); + extern GType gdk_setting_action_get_type(void); + extern GdkCursor *gdk_cursor_new_from_pixmap(GdkPixmap *, GdkPixmap *, + const GdkColor *, + const GdkColor *, gint, + gint); + extern GType gdk_fill_rule_get_type(void); + extern void gdk_window_invalidate_region(GdkWindow *, GdkRegion *, + gboolean); + extern gint gdk_screen_width_mm(void); + extern void gdk_window_set_child_shapes(GdkWindow *); + extern void gdk_window_move_resize(GdkWindow *, gint, gint, gint, + gint); + extern GType gdk_cursor_get_type(void); + extern void gdk_free_compound_text(guchar *); + extern PangoRenderer *gdk_pango_renderer_new(GdkScreen *); + extern GdkScreen *gdk_drawable_get_screen(GdkDrawable *); + extern GdkWindow *gdk_window_lookup(GdkNativeWindow); + extern void gdk_window_set_icon_name(GdkWindow *, const gchar *); + extern GType gdk_drag_context_get_type(void); + extern void gdk_window_thaw_updates(GdkWindow *); + extern GdkPixmap *gdk_pixmap_colormap_create_from_xpm(GdkDrawable *, + GdkColormap *, + GdkBitmap * *, + const GdkColor *, + const gchar *); + extern GdkEvent *gdk_event_copy(GdkEvent *); + extern gboolean gdk_selection_owner_set(GdkWindow *, GdkAtom, guint32, + gboolean); + extern void gdk_window_get_position(GdkWindow *, gint *, gint *); + extern GType gdk_drag_action_get_type(void); + extern guint32 gdk_image_get_pixel(GdkImage *, gint, gint); + extern void gdk_window_shape_combine_mask(GdkWindow *, GdkBitmap *, + gint, gint); + extern void gdk_region_shrink(GdkRegion *, int, int); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/gtk-2.0/gdk/gdkkeysyms.h b/lsb-build/headers/gtk-2.0/gdk/gdkkeysyms.h new file mode 100644 index 0000000..b2b151e --- /dev/null +++ b/lsb-build/headers/gtk-2.0/gdk/gdkkeysyms.h @@ -0,0 +1,1356 @@ +#ifndef _GTK_2_0_GDK_GDKKEYSYMS_H_ +#define _GTK_2_0_GDK_GDKKEYSYMS_H_ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#define GDK_space 0x020 +#define GDK_exclam 0x021 +#define GDK_quotedbl 0x022 +#define GDK_numbersign 0x023 +#define GDK_dollar 0x024 +#define GDK_percent 0x025 +#define GDK_ampersand 0x026 +#define GDK_apostrophe 0x027 +#define GDK_quoteright 0x027 +#define GDK_parenleft 0x028 +#define GDK_parenright 0x029 +#define GDK_asterisk 0x02a +#define GDK_plus 0x02b +#define GDK_comma 0x02c +#define GDK_minus 0x02d +#define GDK_period 0x02e +#define GDK_slash 0x02f +#define GDK_0 0x030 +#define GDK_1 0x031 +#define GDK_2 0x032 +#define GDK_3 0x033 +#define GDK_4 0x034 +#define GDK_5 0x035 +#define GDK_6 0x036 +#define GDK_7 0x037 +#define GDK_8 0x038 +#define GDK_9 0x039 +#define GDK_colon 0x03a +#define GDK_semicolon 0x03b +#define GDK_less 0x03c +#define GDK_equal 0x03d +#define GDK_greater 0x03e +#define GDK_question 0x03f +#define GDK_at 0x040 +#define GDK_A 0x041 +#define GDK_B 0x042 +#define GDK_C 0x043 +#define GDK_D 0x044 +#define GDK_E 0x045 +#define GDK_F 0x046 +#define GDK_G 0x047 +#define GDK_H 0x048 +#define GDK_I 0x049 +#define GDK_J 0x04a +#define GDK_K 0x04b +#define GDK_L 0x04c +#define GDK_M 0x04d +#define GDK_N 0x04e +#define GDK_O 0x04f +#define GDK_P 0x050 +#define GDK_Q 0x051 +#define GDK_R 0x052 +#define GDK_S 0x053 +#define GDK_T 0x054 +#define GDK_U 0x055 +#define GDK_V 0x056 +#define GDK_W 0x057 +#define GDK_X 0x058 +#define GDK_Y 0x059 +#define GDK_Z 0x05a +#define GDK_bracketleft 0x05b +#define GDK_backslash 0x05c +#define GDK_bracketright 0x05d +#define GDK_asciicircum 0x05e +#define GDK_underscore 0x05f +#define GDK_grave 0x060 +#define GDK_quoteleft 0x060 +#define GDK_a 0x061 +#define GDK_b 0x062 +#define GDK_c 0x063 +#define GDK_d 0x064 +#define GDK_e 0x065 +#define GDK_f 0x066 +#define GDK_g 0x067 +#define GDK_h 0x068 +#define GDK_i 0x069 +#define GDK_j 0x06a +#define GDK_k 0x06b +#define GDK_l 0x06c +#define GDK_m 0x06d +#define GDK_n 0x06e +#define GDK_o 0x06f +#define GDK_p 0x070 +#define GDK_q 0x071 +#define GDK_r 0x072 +#define GDK_s 0x073 +#define GDK_t 0x074 +#define GDK_u 0x075 +#define GDK_v 0x076 +#define GDK_w 0x077 +#define GDK_x 0x078 +#define GDK_y 0x079 +#define GDK_z 0x07a +#define GDK_braceleft 0x07b +#define GDK_bar 0x07c +#define GDK_braceright 0x07d +#define GDK_asciitilde 0x07e +#define GDK_nobreakspace 0x0a0 +#define GDK_exclamdown 0x0a1 +#define GDK_cent 0x0a2 +#define GDK_sterling 0x0a3 +#define GDK_currency 0x0a4 +#define GDK_yen 0x0a5 +#define GDK_brokenbar 0x0a6 +#define GDK_section 0x0a7 +#define GDK_diaeresis 0x0a8 +#define GDK_copyright 0x0a9 +#define GDK_ordfeminine 0x0aa +#define GDK_guillemotleft 0x0ab +#define GDK_notsign 0x0ac +#define GDK_hyphen 0x0ad +#define GDK_registered 0x0ae +#define GDK_macron 0x0af +#define GDK_degree 0x0b0 +#define GDK_plusminus 0x0b1 +#define GDK_twosuperior 0x0b2 +#define GDK_threesuperior 0x0b3 +#define GDK_acute 0x0b4 +#define GDK_mu 0x0b5 +#define GDK_paragraph 0x0b6 +#define GDK_periodcentered 0x0b7 +#define GDK_cedilla 0x0b8 +#define GDK_onesuperior 0x0b9 +#define GDK_masculine 0x0ba +#define GDK_guillemotright 0x0bb +#define GDK_onequarter 0x0bc +#define GDK_onehalf 0x0bd +#define GDK_threequarters 0x0be +#define GDK_questiondown 0x0bf +#define GDK_Agrave 0x0c0 +#define GDK_Aacute 0x0c1 +#define GDK_Acircumflex 0x0c2 +#define GDK_Atilde 0x0c3 +#define GDK_Adiaeresis 0x0c4 +#define GDK_Aring 0x0c5 +#define GDK_AE 0x0c6 +#define GDK_Ccedilla 0x0c7 +#define GDK_Egrave 0x0c8 +#define GDK_Eacute 0x0c9 +#define GDK_Ecircumflex 0x0ca +#define GDK_Ediaeresis 0x0cb +#define GDK_Igrave 0x0cc +#define GDK_Iacute 0x0cd +#define GDK_Icircumflex 0x0ce +#define GDK_Idiaeresis 0x0cf +#define GDK_ETH 0x0d0 +#define GDK_Eth 0x0d0 +#define GDK_Ntilde 0x0d1 +#define GDK_Ograve 0x0d2 +#define GDK_Oacute 0x0d3 +#define GDK_Ocircumflex 0x0d4 +#define GDK_Otilde 0x0d5 +#define GDK_Odiaeresis 0x0d6 +#define GDK_multiply 0x0d7 +#define GDK_Ooblique 0x0d8 +#define GDK_Ugrave 0x0d9 +#define GDK_Uacute 0x0da +#define GDK_Ucircumflex 0x0db +#define GDK_Udiaeresis 0x0dc +#define GDK_Yacute 0x0dd +#define GDK_THORN 0x0de +#define GDK_Thorn 0x0de +#define GDK_ssharp 0x0df +#define GDK_agrave 0x0e0 +#define GDK_aacute 0x0e1 +#define GDK_acircumflex 0x0e2 +#define GDK_atilde 0x0e3 +#define GDK_adiaeresis 0x0e4 +#define GDK_aring 0x0e5 +#define GDK_ae 0x0e6 +#define GDK_ccedilla 0x0e7 +#define GDK_egrave 0x0e8 +#define GDK_eacute 0x0e9 +#define GDK_ecircumflex 0x0ea +#define GDK_ediaeresis 0x0eb +#define GDK_igrave 0x0ec +#define GDK_iacute 0x0ed +#define GDK_icircumflex 0x0ee +#define GDK_idiaeresis 0x0ef +#define GDK_eth 0x0f0 +#define GDK_ntilde 0x0f1 +#define GDK_ograve 0x0f2 +#define GDK_oacute 0x0f3 +#define GDK_ocircumflex 0x0f4 +#define GDK_otilde 0x0f5 +#define GDK_odiaeresis 0x0f6 +#define GDK_division 0x0f7 +#define GDK_oslash 0x0f8 +#define GDK_ugrave 0x0f9 +#define GDK_uacute 0x0fa +#define GDK_ucircumflex 0x0fb +#define GDK_udiaeresis 0x0fc +#define GDK_yacute 0x0fd +#define GDK_thorn 0x0fe +#define GDK_ydiaeresis 0x0ff +#define GDK_OE 0x13bc +#define GDK_oe 0x13bd +#define GDK_Ydiaeresis 0x13be +#define GDK_Aogonek 0x1a1 +#define GDK_breve 0x1a2 +#define GDK_Lstroke 0x1a3 +#define GDK_Lcaron 0x1a5 +#define GDK_Sacute 0x1a6 +#define GDK_Scaron 0x1a9 +#define GDK_Scedilla 0x1aa +#define GDK_Tcaron 0x1ab +#define GDK_Zacute 0x1ac +#define GDK_Zcaron 0x1ae +#define GDK_Zabovedot 0x1af +#define GDK_aogonek 0x1b1 +#define GDK_ogonek 0x1b2 +#define GDK_lstroke 0x1b3 +#define GDK_lcaron 0x1b5 +#define GDK_sacute 0x1b6 +#define GDK_caron 0x1b7 +#define GDK_scaron 0x1b9 +#define GDK_scedilla 0x1ba +#define GDK_tcaron 0x1bb +#define GDK_zacute 0x1bc +#define GDK_doubleacute 0x1bd +#define GDK_zcaron 0x1be +#define GDK_zabovedot 0x1bf +#define GDK_Racute 0x1c0 +#define GDK_Abreve 0x1c3 +#define GDK_Lacute 0x1c5 +#define GDK_Cacute 0x1c6 +#define GDK_Ccaron 0x1c8 +#define GDK_Eogonek 0x1ca +#define GDK_Ecaron 0x1cc +#define GDK_Dcaron 0x1cf +#define GDK_Dstroke 0x1d0 +#define GDK_Nacute 0x1d1 +#define GDK_Ncaron 0x1d2 +#define GDK_Odoubleacute 0x1d5 +#define GDK_Rcaron 0x1d8 +#define GDK_Uring 0x1d9 +#define GDK_Udoubleacute 0x1db +#define GDK_Tcedilla 0x1de +#define GDK_racute 0x1e0 +#define GDK_abreve 0x1e3 +#define GDK_lacute 0x1e5 +#define GDK_cacute 0x1e6 +#define GDK_ccaron 0x1e8 +#define GDK_eogonek 0x1ea +#define GDK_ecaron 0x1ec +#define GDK_dcaron 0x1ef +#define GDK_dstroke 0x1f0 +#define GDK_nacute 0x1f1 +#define GDK_ncaron 0x1f2 +#define GDK_odoubleacute 0x1f5 +#define GDK_rcaron 0x1f8 +#define GDK_uring 0x1f9 +#define GDK_udoubleacute 0x1fb +#define GDK_tcedilla 0x1fe +#define GDK_abovedot 0x1ff +#define GDK_EcuSign 0x20a0 +#define GDK_ColonSign 0x20a1 +#define GDK_CruzeiroSign 0x20a2 +#define GDK_FFrancSign 0x20a3 +#define GDK_LiraSign 0x20a4 +#define GDK_MillSign 0x20a5 +#define GDK_NairaSign 0x20a6 +#define GDK_PesetaSign 0x20a7 +#define GDK_RupeeSign 0x20a8 +#define GDK_WonSign 0x20a9 +#define GDK_NewSheqelSign 0x20aa +#define GDK_DongSign 0x20ab +#define GDK_EuroSign 0x20ac +#define GDK_Hstroke 0x2a1 +#define GDK_Hcircumflex 0x2a6 +#define GDK_Iabovedot 0x2a9 +#define GDK_Gbreve 0x2ab +#define GDK_Jcircumflex 0x2ac +#define GDK_hstroke 0x2b1 +#define GDK_hcircumflex 0x2b6 +#define GDK_idotless 0x2b9 +#define GDK_gbreve 0x2bb +#define GDK_jcircumflex 0x2bc +#define GDK_Cabovedot 0x2c5 +#define GDK_Ccircumflex 0x2c6 +#define GDK_Gabovedot 0x2d5 +#define GDK_Gcircumflex 0x2d8 +#define GDK_Ubreve 0x2dd +#define GDK_Scircumflex 0x2de +#define GDK_cabovedot 0x2e5 +#define GDK_ccircumflex 0x2e6 +#define GDK_gabovedot 0x2f5 +#define GDK_gcircumflex 0x2f8 +#define GDK_ubreve 0x2fd +#define GDK_scircumflex 0x2fe +#define GDK_kappa 0x3a2 +#define GDK_kra 0x3a2 +#define GDK_Rcedilla 0x3a3 +#define GDK_Itilde 0x3a5 +#define GDK_Lcedilla 0x3a6 +#define GDK_Emacron 0x3aa +#define GDK_Gcedilla 0x3ab +#define GDK_Tslash 0x3ac +#define GDK_rcedilla 0x3b3 +#define GDK_itilde 0x3b5 +#define GDK_lcedilla 0x3b6 +#define GDK_emacron 0x3ba +#define GDK_gcedilla 0x3bb +#define GDK_tslash 0x3bc +#define GDK_ENG 0x3bd +#define GDK_eng 0x3bf +#define GDK_Amacron 0x3c0 +#define GDK_Iogonek 0x3c7 +#define GDK_Eabovedot 0x3cc +#define GDK_Imacron 0x3cf +#define GDK_Ncedilla 0x3d1 +#define GDK_Omacron 0x3d2 +#define GDK_Kcedilla 0x3d3 +#define GDK_Uogonek 0x3d9 +#define GDK_Utilde 0x3dd +#define GDK_Umacron 0x3de +#define GDK_amacron 0x3e0 +#define GDK_iogonek 0x3e7 +#define GDK_eabovedot 0x3ec +#define GDK_imacron 0x3ef +#define GDK_ncedilla 0x3f1 +#define GDK_omacron 0x3f2 +#define GDK_kcedilla 0x3f3 +#define GDK_uogonek 0x3f9 +#define GDK_utilde 0x3fd +#define GDK_umacron 0x3fe +#define GDK_overline 0x47e +#define GDK_kana_fullstop 0x4a1 +#define GDK_kana_openingbracket 0x4a2 +#define GDK_kana_closingbracket 0x4a3 +#define GDK_kana_comma 0x4a4 +#define GDK_kana_conjunctive 0x4a5 +#define GDK_kana_middledot 0x4a5 +#define GDK_kana_WO 0x4a6 +#define GDK_kana_a 0x4a7 +#define GDK_kana_i 0x4a8 +#define GDK_kana_u 0x4a9 +#define GDK_kana_e 0x4aa +#define GDK_kana_o 0x4ab +#define GDK_kana_ya 0x4ac +#define GDK_kana_yu 0x4ad +#define GDK_kana_yo 0x4ae +#define GDK_kana_tsu 0x4af +#define GDK_kana_tu 0x4af +#define GDK_prolongedsound 0x4b0 +#define GDK_kana_A 0x4b1 +#define GDK_kana_I 0x4b2 +#define GDK_kana_U 0x4b3 +#define GDK_kana_E 0x4b4 +#define GDK_kana_O 0x4b5 +#define GDK_kana_KA 0x4b6 +#define GDK_kana_KI 0x4b7 +#define GDK_kana_KU 0x4b8 +#define GDK_kana_KE 0x4b9 +#define GDK_kana_KO 0x4ba +#define GDK_kana_SA 0x4bb +#define GDK_kana_SHI 0x4bc +#define GDK_kana_SU 0x4bd +#define GDK_kana_SE 0x4be +#define GDK_kana_SO 0x4bf +#define GDK_kana_TA 0x4c0 +#define GDK_kana_CHI 0x4c1 +#define GDK_kana_TI 0x4c1 +#define GDK_kana_TSU 0x4c2 +#define GDK_kana_TU 0x4c2 +#define GDK_kana_TE 0x4c3 +#define GDK_kana_TO 0x4c4 +#define GDK_kana_NA 0x4c5 +#define GDK_kana_NI 0x4c6 +#define GDK_kana_NU 0x4c7 +#define GDK_kana_NE 0x4c8 +#define GDK_kana_NO 0x4c9 +#define GDK_kana_HA 0x4ca +#define GDK_kana_HI 0x4cb +#define GDK_kana_FU 0x4cc +#define GDK_kana_HU 0x4cc +#define GDK_kana_HE 0x4cd +#define GDK_kana_HO 0x4ce +#define GDK_kana_MA 0x4cf +#define GDK_kana_MI 0x4d0 +#define GDK_kana_MU 0x4d1 +#define GDK_kana_ME 0x4d2 +#define GDK_kana_MO 0x4d3 +#define GDK_kana_YA 0x4d4 +#define GDK_kana_YU 0x4d5 +#define GDK_kana_YO 0x4d6 +#define GDK_kana_RA 0x4d7 +#define GDK_kana_RI 0x4d8 +#define GDK_kana_RU 0x4d9 +#define GDK_kana_RE 0x4da +#define GDK_kana_RO 0x4db +#define GDK_kana_WA 0x4dc +#define GDK_kana_N 0x4dd +#define GDK_voicedsound 0x4de +#define GDK_semivoicedsound 0x4df +#define GDK_Arabic_comma 0x5ac +#define GDK_Arabic_semicolon 0x5bb +#define GDK_Arabic_question_mark 0x5bf +#define GDK_Arabic_hamza 0x5c1 +#define GDK_Arabic_maddaonalef 0x5c2 +#define GDK_Arabic_hamzaonalef 0x5c3 +#define GDK_Arabic_hamzaonwaw 0x5c4 +#define GDK_Arabic_hamzaunderalef 0x5c5 +#define GDK_Arabic_hamzaonyeh 0x5c6 +#define GDK_Arabic_alef 0x5c7 +#define GDK_Arabic_beh 0x5c8 +#define GDK_Arabic_tehmarbuta 0x5c9 +#define GDK_Arabic_teh 0x5ca +#define GDK_Arabic_theh 0x5cb +#define GDK_Arabic_jeem 0x5cc +#define GDK_Arabic_hah 0x5cd +#define GDK_Arabic_khah 0x5ce +#define GDK_Arabic_dal 0x5cf +#define GDK_Arabic_thal 0x5d0 +#define GDK_Arabic_ra 0x5d1 +#define GDK_Arabic_zain 0x5d2 +#define GDK_Arabic_seen 0x5d3 +#define GDK_Arabic_sheen 0x5d4 +#define GDK_Arabic_sad 0x5d5 +#define GDK_Arabic_dad 0x5d6 +#define GDK_Arabic_tah 0x5d7 +#define GDK_Arabic_zah 0x5d8 +#define GDK_Arabic_ain 0x5d9 +#define GDK_Arabic_ghain 0x5da +#define GDK_Arabic_tatweel 0x5e0 +#define GDK_Arabic_feh 0x5e1 +#define GDK_Arabic_qaf 0x5e2 +#define GDK_Arabic_kaf 0x5e3 +#define GDK_Arabic_lam 0x5e4 +#define GDK_Arabic_meem 0x5e5 +#define GDK_Arabic_noon 0x5e6 +#define GDK_Arabic_ha 0x5e7 +#define GDK_Arabic_heh 0x5e7 +#define GDK_Arabic_waw 0x5e8 +#define GDK_Arabic_alefmaksura 0x5e9 +#define GDK_Arabic_yeh 0x5ea +#define GDK_Arabic_fathatan 0x5eb +#define GDK_Arabic_dammatan 0x5ec +#define GDK_Arabic_kasratan 0x5ed +#define GDK_Arabic_fatha 0x5ee +#define GDK_Arabic_damma 0x5ef +#define GDK_Arabic_kasra 0x5f0 +#define GDK_Arabic_shadda 0x5f1 +#define GDK_Arabic_sukun 0x5f2 +#define GDK_Serbian_dje 0x6a1 +#define GDK_Macedonia_gje 0x6a2 +#define GDK_Cyrillic_io 0x6a3 +#define GDK_Ukrainian_ie 0x6a4 +#define GDK_Ukranian_je 0x6a4 +#define GDK_Macedonia_dse 0x6a5 +#define GDK_Ukrainian_i 0x6a6 +#define GDK_Ukranian_i 0x6a6 +#define GDK_Ukrainian_yi 0x6a7 +#define GDK_Ukranian_yi 0x6a7 +#define GDK_Cyrillic_je 0x6a8 +#define GDK_Serbian_je 0x6a8 +#define GDK_Cyrillic_lje 0x6a9 +#define GDK_Serbian_lje 0x6a9 +#define GDK_Cyrillic_nje 0x6aa +#define GDK_Serbian_nje 0x6aa +#define GDK_Serbian_tshe 0x6ab +#define GDK_Macedonia_kje 0x6ac +#define GDK_Ukrainian_ghe_with_upturn 0x6ad +#define GDK_Byelorussian_shortu 0x6ae +#define GDK_Cyrillic_dzhe 0x6af +#define GDK_Serbian_dze 0x6af +#define GDK_numerosign 0x6b0 +#define GDK_Serbian_DJE 0x6b1 +#define GDK_Macedonia_GJE 0x6b2 +#define GDK_Cyrillic_IO 0x6b3 +#define GDK_Ukrainian_IE 0x6b4 +#define GDK_Ukranian_JE 0x6b4 +#define GDK_Macedonia_DSE 0x6b5 +#define GDK_Ukrainian_I 0x6b6 +#define GDK_Ukranian_I 0x6b6 +#define GDK_Ukrainian_YI 0x6b7 +#define GDK_Ukranian_YI 0x6b7 +#define GDK_Cyrillic_JE 0x6b8 +#define GDK_Serbian_JE 0x6b8 +#define GDK_Cyrillic_LJE 0x6b9 +#define GDK_Serbian_LJE 0x6b9 +#define GDK_Cyrillic_NJE 0x6ba +#define GDK_Serbian_NJE 0x6ba +#define GDK_Serbian_TSHE 0x6bb +#define GDK_Macedonia_KJE 0x6bc +#define GDK_Ukrainian_GHE_WITH_UPTURN 0x6bd +#define GDK_Byelorussian_SHORTU 0x6be +#define GDK_Cyrillic_DZHE 0x6bf +#define GDK_Serbian_DZE 0x6bf +#define GDK_Cyrillic_yu 0x6c0 +#define GDK_Cyrillic_a 0x6c1 +#define GDK_Cyrillic_be 0x6c2 +#define GDK_Cyrillic_tse 0x6c3 +#define GDK_Cyrillic_de 0x6c4 +#define GDK_Cyrillic_ie 0x6c5 +#define GDK_Cyrillic_ef 0x6c6 +#define GDK_Cyrillic_ghe 0x6c7 +#define GDK_Cyrillic_ha 0x6c8 +#define GDK_Cyrillic_i 0x6c9 +#define GDK_Cyrillic_shorti 0x6ca +#define GDK_Cyrillic_ka 0x6cb +#define GDK_Cyrillic_el 0x6cc +#define GDK_Cyrillic_em 0x6cd +#define GDK_Cyrillic_en 0x6ce +#define GDK_Cyrillic_o 0x6cf +#define GDK_Cyrillic_pe 0x6d0 +#define GDK_Cyrillic_ya 0x6d1 +#define GDK_Cyrillic_er 0x6d2 +#define GDK_Cyrillic_es 0x6d3 +#define GDK_Cyrillic_te 0x6d4 +#define GDK_Cyrillic_u 0x6d5 +#define GDK_Cyrillic_zhe 0x6d6 +#define GDK_Cyrillic_ve 0x6d7 +#define GDK_Cyrillic_softsign 0x6d8 +#define GDK_Cyrillic_yeru 0x6d9 +#define GDK_Cyrillic_ze 0x6da +#define GDK_Cyrillic_sha 0x6db +#define GDK_Cyrillic_e 0x6dc +#define GDK_Cyrillic_shcha 0x6dd +#define GDK_Cyrillic_che 0x6de +#define GDK_Cyrillic_hardsign 0x6df +#define GDK_Cyrillic_YU 0x6e0 +#define GDK_Cyrillic_A 0x6e1 +#define GDK_Cyrillic_BE 0x6e2 +#define GDK_Cyrillic_TSE 0x6e3 +#define GDK_Cyrillic_DE 0x6e4 +#define GDK_Cyrillic_IE 0x6e5 +#define GDK_Cyrillic_EF 0x6e6 +#define GDK_Cyrillic_GHE 0x6e7 +#define GDK_Cyrillic_HA 0x6e8 +#define GDK_Cyrillic_I 0x6e9 +#define GDK_Cyrillic_SHORTI 0x6ea +#define GDK_Cyrillic_KA 0x6eb +#define GDK_Cyrillic_EL 0x6ec +#define GDK_Cyrillic_EM 0x6ed +#define GDK_Cyrillic_EN 0x6ee +#define GDK_Cyrillic_O 0x6ef +#define GDK_Cyrillic_PE 0x6f0 +#define GDK_Cyrillic_YA 0x6f1 +#define GDK_Cyrillic_ER 0x6f2 +#define GDK_Cyrillic_ES 0x6f3 +#define GDK_Cyrillic_TE 0x6f4 +#define GDK_Cyrillic_U 0x6f5 +#define GDK_Cyrillic_ZHE 0x6f6 +#define GDK_Cyrillic_VE 0x6f7 +#define GDK_Cyrillic_SOFTSIGN 0x6f8 +#define GDK_Cyrillic_YERU 0x6f9 +#define GDK_Cyrillic_ZE 0x6fa +#define GDK_Cyrillic_SHA 0x6fb +#define GDK_Cyrillic_E 0x6fc +#define GDK_Cyrillic_SHCHA 0x6fd +#define GDK_Cyrillic_CHE 0x6fe +#define GDK_Cyrillic_HARDSIGN 0x6ff +#define GDK_Greek_ALPHAaccent 0x7a1 +#define GDK_Greek_EPSILONaccent 0x7a2 +#define GDK_Greek_ETAaccent 0x7a3 +#define GDK_Greek_IOTAaccent 0x7a4 +#define GDK_Greek_IOTAdieresis 0x7a5 +#define GDK_Greek_OMICRONaccent 0x7a7 +#define GDK_Greek_UPSILONaccent 0x7a8 +#define GDK_Greek_UPSILONdieresis 0x7a9 +#define GDK_Greek_OMEGAaccent 0x7ab +#define GDK_Greek_accentdieresis 0x7ae +#define GDK_Greek_horizbar 0x7af +#define GDK_Greek_alphaaccent 0x7b1 +#define GDK_Greek_epsilonaccent 0x7b2 +#define GDK_Greek_etaaccent 0x7b3 +#define GDK_Greek_iotaaccent 0x7b4 +#define GDK_Greek_iotadieresis 0x7b5 +#define GDK_Greek_iotaaccentdieresis 0x7b6 +#define GDK_Greek_omicronaccent 0x7b7 +#define GDK_Greek_upsilonaccent 0x7b8 +#define GDK_Greek_upsilondieresis 0x7b9 +#define GDK_Greek_upsilonaccentdieresis 0x7ba +#define GDK_Greek_omegaaccent 0x7bb +#define GDK_Greek_ALPHA 0x7c1 +#define GDK_Greek_BETA 0x7c2 +#define GDK_Greek_GAMMA 0x7c3 +#define GDK_Greek_DELTA 0x7c4 +#define GDK_Greek_EPSILON 0x7c5 +#define GDK_Greek_ZETA 0x7c6 +#define GDK_Greek_ETA 0x7c7 +#define GDK_Greek_THETA 0x7c8 +#define GDK_Greek_IOTA 0x7c9 +#define GDK_Greek_KAPPA 0x7ca +#define GDK_Greek_LAMBDA 0x7cb +#define GDK_Greek_LAMDA 0x7cb +#define GDK_Greek_MU 0x7cc +#define GDK_Greek_NU 0x7cd +#define GDK_Greek_XI 0x7ce +#define GDK_Greek_OMICRON 0x7cf +#define GDK_Greek_PI 0x7d0 +#define GDK_Greek_RHO 0x7d1 +#define GDK_Greek_SIGMA 0x7d2 +#define GDK_Greek_TAU 0x7d4 +#define GDK_Greek_UPSILON 0x7d5 +#define GDK_Greek_PHI 0x7d6 +#define GDK_Greek_CHI 0x7d7 +#define GDK_Greek_PSI 0x7d8 +#define GDK_Greek_OMEGA 0x7d9 +#define GDK_Greek_alpha 0x7e1 +#define GDK_Greek_beta 0x7e2 +#define GDK_Greek_gamma 0x7e3 +#define GDK_Greek_delta 0x7e4 +#define GDK_Greek_epsilon 0x7e5 +#define GDK_Greek_zeta 0x7e6 +#define GDK_Greek_eta 0x7e7 +#define GDK_Greek_theta 0x7e8 +#define GDK_Greek_iota 0x7e9 +#define GDK_Greek_kappa 0x7ea +#define GDK_Greek_lambda 0x7eb +#define GDK_Greek_lamda 0x7eb +#define GDK_Greek_mu 0x7ec +#define GDK_Greek_nu 0x7ed +#define GDK_Greek_xi 0x7ee +#define GDK_Greek_omicron 0x7ef +#define GDK_Greek_pi 0x7f0 +#define GDK_Greek_rho 0x7f1 +#define GDK_Greek_sigma 0x7f2 +#define GDK_Greek_finalsmallsigma 0x7f3 +#define GDK_Greek_tau 0x7f4 +#define GDK_Greek_upsilon 0x7f5 +#define GDK_Greek_phi 0x7f6 +#define GDK_Greek_chi 0x7f7 +#define GDK_Greek_psi 0x7f8 +#define GDK_Greek_omega 0x7f9 +#define GDK_leftradical 0x8a1 +#define GDK_topleftradical 0x8a2 +#define GDK_horizconnector 0x8a3 +#define GDK_topintegral 0x8a4 +#define GDK_botintegral 0x8a5 +#define GDK_vertconnector 0x8a6 +#define GDK_topleftsqbracket 0x8a7 +#define GDK_botleftsqbracket 0x8a8 +#define GDK_toprightsqbracket 0x8a9 +#define GDK_botrightsqbracket 0x8aa +#define GDK_topleftparens 0x8ab +#define GDK_botleftparens 0x8ac +#define GDK_toprightparens 0x8ad +#define GDK_botrightparens 0x8ae +#define GDK_leftmiddlecurlybrace 0x8af +#define GDK_rightmiddlecurlybrace 0x8b0 +#define GDK_topleftsummation 0x8b1 +#define GDK_botleftsummation 0x8b2 +#define GDK_topvertsummationconnector 0x8b3 +#define GDK_botvertsummationconnector 0x8b4 +#define GDK_toprightsummation 0x8b5 +#define GDK_botrightsummation 0x8b6 +#define GDK_rightmiddlesummation 0x8b7 +#define GDK_lessthanequal 0x8bc +#define GDK_notequal 0x8bd +#define GDK_greaterthanequal 0x8be +#define GDK_integral 0x8bf +#define GDK_therefore 0x8c0 +#define GDK_variation 0x8c1 +#define GDK_infinity 0x8c2 +#define GDK_nabla 0x8c5 +#define GDK_approximate 0x8c8 +#define GDK_similarequal 0x8c9 +#define GDK_ifonlyif 0x8cd +#define GDK_implies 0x8ce +#define GDK_identical 0x8cf +#define GDK_radical 0x8d6 +#define GDK_includedin 0x8da +#define GDK_includes 0x8db +#define GDK_intersection 0x8dc +#define GDK_union 0x8dd +#define GDK_logicaland 0x8de +#define GDK_logicalor 0x8df +#define GDK_partialderivative 0x8ef +#define GDK_function 0x8f6 +#define GDK_leftarrow 0x8fb +#define GDK_uparrow 0x8fc +#define GDK_rightarrow 0x8fd +#define GDK_downarrow 0x8fe +#define GDK_blank 0x9df +#define GDK_soliddiamond 0x9e0 +#define GDK_checkerboard 0x9e1 +#define GDK_ht 0x9e2 +#define GDK_ff 0x9e3 +#define GDK_cr 0x9e4 +#define GDK_lf 0x9e5 +#define GDK_nl 0x9e8 +#define GDK_vt 0x9e9 +#define GDK_lowrightcorner 0x9ea +#define GDK_uprightcorner 0x9eb +#define GDK_upleftcorner 0x9ec +#define GDK_lowleftcorner 0x9ed +#define GDK_crossinglines 0x9ee +#define GDK_horizlinescan1 0x9ef +#define GDK_horizlinescan3 0x9f0 +#define GDK_horizlinescan5 0x9f1 +#define GDK_horizlinescan7 0x9f2 +#define GDK_horizlinescan9 0x9f3 +#define GDK_leftt 0x9f4 +#define GDK_rightt 0x9f5 +#define GDK_bott 0x9f6 +#define GDK_topt 0x9f7 +#define GDK_vertbar 0x9f8 +#define GDK_emspace 0xaa1 +#define GDK_enspace 0xaa2 +#define GDK_em3space 0xaa3 +#define GDK_em4space 0xaa4 +#define GDK_digitspace 0xaa5 +#define GDK_punctspace 0xaa6 +#define GDK_thinspace 0xaa7 +#define GDK_hairspace 0xaa8 +#define GDK_emdash 0xaa9 +#define GDK_endash 0xaaa +#define GDK_signifblank 0xaac +#define GDK_ellipsis 0xaae +#define GDK_doubbaselinedot 0xaaf +#define GDK_onethird 0xab0 +#define GDK_twothirds 0xab1 +#define GDK_onefifth 0xab2 +#define GDK_twofifths 0xab3 +#define GDK_threefifths 0xab4 +#define GDK_fourfifths 0xab5 +#define GDK_onesixth 0xab6 +#define GDK_fivesixths 0xab7 +#define GDK_careof 0xab8 +#define GDK_figdash 0xabb +#define GDK_leftanglebracket 0xabc +#define GDK_decimalpoint 0xabd +#define GDK_rightanglebracket 0xabe +#define GDK_marker 0xabf +#define GDK_oneeighth 0xac3 +#define GDK_threeeighths 0xac4 +#define GDK_fiveeighths 0xac5 +#define GDK_seveneighths 0xac6 +#define GDK_trademark 0xac9 +#define GDK_signaturemark 0xaca +#define GDK_trademarkincircle 0xacb +#define GDK_leftopentriangle 0xacc +#define GDK_rightopentriangle 0xacd +#define GDK_emopencircle 0xace +#define GDK_emopenrectangle 0xacf +#define GDK_leftsinglequotemark 0xad0 +#define GDK_rightsinglequotemark 0xad1 +#define GDK_leftdoublequotemark 0xad2 +#define GDK_rightdoublequotemark 0xad3 +#define GDK_prescription 0xad4 +#define GDK_minutes 0xad6 +#define GDK_seconds 0xad7 +#define GDK_latincross 0xad9 +#define GDK_hexagram 0xada +#define GDK_filledrectbullet 0xadb +#define GDK_filledlefttribullet 0xadc +#define GDK_filledrighttribullet 0xadd +#define GDK_emfilledcircle 0xade +#define GDK_emfilledrect 0xadf +#define GDK_enopencircbullet 0xae0 +#define GDK_enopensquarebullet 0xae1 +#define GDK_openrectbullet 0xae2 +#define GDK_opentribulletup 0xae3 +#define GDK_opentribulletdown 0xae4 +#define GDK_openstar 0xae5 +#define GDK_enfilledcircbullet 0xae6 +#define GDK_enfilledsqbullet 0xae7 +#define GDK_filledtribulletup 0xae8 +#define GDK_filledtribulletdown 0xae9 +#define GDK_leftpointer 0xaea +#define GDK_rightpointer 0xaeb +#define GDK_club 0xaec +#define GDK_diamond 0xaed +#define GDK_heart 0xaee +#define GDK_maltesecross 0xaf0 +#define GDK_dagger 0xaf1 +#define GDK_doubledagger 0xaf2 +#define GDK_checkmark 0xaf3 +#define GDK_ballotcross 0xaf4 +#define GDK_musicalsharp 0xaf5 +#define GDK_musicalflat 0xaf6 +#define GDK_malesymbol 0xaf7 +#define GDK_femalesymbol 0xaf8 +#define GDK_telephone 0xaf9 +#define GDK_telephonerecorder 0xafa +#define GDK_phonographcopyright 0xafb +#define GDK_caret 0xafc +#define GDK_singlelowquotemark 0xafd +#define GDK_doublelowquotemark 0xafe +#define GDK_cursor 0xaff +#define GDK_leftcaret 0xba3 +#define GDK_rightcaret 0xba6 +#define GDK_downcaret 0xba8 +#define GDK_upcaret 0xba9 +#define GDK_overbar 0xbc0 +#define GDK_downtack 0xbc2 +#define GDK_upshoe 0xbc3 +#define GDK_downstile 0xbc4 +#define GDK_underbar 0xbc6 +#define GDK_jot 0xbca +#define GDK_quad 0xbcc +#define GDK_uptack 0xbce +#define GDK_circle 0xbcf +#define GDK_upstile 0xbd3 +#define GDK_downshoe 0xbd6 +#define GDK_rightshoe 0xbd8 +#define GDK_leftshoe 0xbda +#define GDK_lefttack 0xbdc +#define GDK_righttack 0xbfc +#define GDK_hebrew_doublelowline 0xcdf +#define GDK_hebrew_aleph 0xce0 +#define GDK_hebrew_bet 0xce1 +#define GDK_hebrew_beth 0xce1 +#define GDK_hebrew_gimel 0xce2 +#define GDK_hebrew_gimmel 0xce2 +#define GDK_hebrew_dalet 0xce3 +#define GDK_hebrew_daleth 0xce3 +#define GDK_hebrew_he 0xce4 +#define GDK_hebrew_waw 0xce5 +#define GDK_hebrew_zain 0xce6 +#define GDK_hebrew_zayin 0xce6 +#define GDK_hebrew_chet 0xce7 +#define GDK_hebrew_het 0xce7 +#define GDK_hebrew_tet 0xce8 +#define GDK_hebrew_teth 0xce8 +#define GDK_hebrew_yod 0xce9 +#define GDK_hebrew_finalkaph 0xcea +#define GDK_hebrew_kaph 0xceb +#define GDK_hebrew_lamed 0xcec +#define GDK_hebrew_finalmem 0xced +#define GDK_hebrew_mem 0xcee +#define GDK_hebrew_finalnun 0xcef +#define GDK_hebrew_nun 0xcf0 +#define GDK_hebrew_samech 0xcf1 +#define GDK_hebrew_samekh 0xcf1 +#define GDK_hebrew_ayin 0xcf2 +#define GDK_hebrew_finalpe 0xcf3 +#define GDK_hebrew_pe 0xcf4 +#define GDK_hebrew_finalzade 0xcf5 +#define GDK_hebrew_finalzadi 0xcf5 +#define GDK_hebrew_zade 0xcf6 +#define GDK_hebrew_zadi 0xcf6 +#define GDK_hebrew_kuf 0xcf7 +#define GDK_hebrew_qoph 0xcf7 +#define GDK_hebrew_resh 0xcf8 +#define GDK_hebrew_shin 0xcf9 +#define GDK_hebrew_taf 0xcfa +#define GDK_hebrew_taw 0xcfa +#define GDK_Thai_kokai 0xda1 +#define GDK_Thai_khokhai 0xda2 +#define GDK_Thai_khokhuat 0xda3 +#define GDK_Thai_khokhwai 0xda4 +#define GDK_Thai_khokhon 0xda5 +#define GDK_Thai_khorakhang 0xda6 +#define GDK_Thai_ngongu 0xda7 +#define GDK_Thai_chochan 0xda8 +#define GDK_Thai_choching 0xda9 +#define GDK_Thai_chochang 0xdaa +#define GDK_Thai_soso 0xdab +#define GDK_Thai_chochoe 0xdac +#define GDK_Thai_yoying 0xdad +#define GDK_Thai_dochada 0xdae +#define GDK_Thai_topatak 0xdaf +#define GDK_Thai_thothan 0xdb0 +#define GDK_Thai_thonangmontho 0xdb1 +#define GDK_Thai_thophuthao 0xdb2 +#define GDK_Thai_nonen 0xdb3 +#define GDK_Thai_dodek 0xdb4 +#define GDK_Thai_totao 0xdb5 +#define GDK_Thai_thothung 0xdb6 +#define GDK_Thai_thothahan 0xdb7 +#define GDK_Thai_thothong 0xdb8 +#define GDK_Thai_nonu 0xdb9 +#define GDK_Thai_bobaimai 0xdba +#define GDK_Thai_popla 0xdbb +#define GDK_Thai_phophung 0xdbc +#define GDK_Thai_fofa 0xdbd +#define GDK_Thai_phophan 0xdbe +#define GDK_Thai_fofan 0xdbf +#define GDK_Thai_phosamphao 0xdc0 +#define GDK_Thai_moma 0xdc1 +#define GDK_Thai_yoyak 0xdc2 +#define GDK_Thai_rorua 0xdc3 +#define GDK_Thai_ru 0xdc4 +#define GDK_Thai_loling 0xdc5 +#define GDK_Thai_lu 0xdc6 +#define GDK_Thai_wowaen 0xdc7 +#define GDK_Thai_sosala 0xdc8 +#define GDK_Thai_sorusi 0xdc9 +#define GDK_Thai_sosua 0xdca +#define GDK_Thai_hohip 0xdcb +#define GDK_Thai_lochula 0xdcc +#define GDK_Thai_oang 0xdcd +#define GDK_Thai_honokhuk 0xdce +#define GDK_Thai_paiyannoi 0xdcf +#define GDK_Thai_saraa 0xdd0 +#define GDK_Thai_maihanakat 0xdd1 +#define GDK_Thai_saraaa 0xdd2 +#define GDK_Thai_saraam 0xdd3 +#define GDK_Thai_sarai 0xdd4 +#define GDK_Thai_saraii 0xdd5 +#define GDK_Thai_saraue 0xdd6 +#define GDK_Thai_sarauee 0xdd7 +#define GDK_Thai_sarau 0xdd8 +#define GDK_Thai_sarauu 0xdd9 +#define GDK_Thai_phinthu 0xdda +#define GDK_Thai_maihanakat_maitho 0xdde +#define GDK_Thai_baht 0xddf +#define GDK_Thai_sarae 0xde0 +#define GDK_Thai_saraae 0xde1 +#define GDK_Thai_sarao 0xde2 +#define GDK_Thai_saraaimaimuan 0xde3 +#define GDK_Thai_saraaimaimalai 0xde4 +#define GDK_Thai_lakkhangyao 0xde5 +#define GDK_Thai_maiyamok 0xde6 +#define GDK_Thai_maitaikhu 0xde7 +#define GDK_Thai_maiek 0xde8 +#define GDK_Thai_maitho 0xde9 +#define GDK_Thai_maitri 0xdea +#define GDK_Thai_maichattawa 0xdeb +#define GDK_Thai_thanthakhat 0xdec +#define GDK_Thai_nikhahit 0xded +#define GDK_Thai_leksun 0xdf0 +#define GDK_Thai_leknung 0xdf1 +#define GDK_Thai_leksong 0xdf2 +#define GDK_Thai_leksam 0xdf3 +#define GDK_Thai_leksi 0xdf4 +#define GDK_Thai_lekha 0xdf5 +#define GDK_Thai_lekhok 0xdf6 +#define GDK_Thai_lekchet 0xdf7 +#define GDK_Thai_lekpaet 0xdf8 +#define GDK_Thai_lekkao 0xdf9 +#define GDK_Hangul_Kiyeog 0xea1 +#define GDK_Hangul_SsangKiyeog 0xea2 +#define GDK_Hangul_KiyeogSios 0xea3 +#define GDK_Hangul_Nieun 0xea4 +#define GDK_Hangul_NieunJieuj 0xea5 +#define GDK_Hangul_NieunHieuh 0xea6 +#define GDK_Hangul_Dikeud 0xea7 +#define GDK_Hangul_SsangDikeud 0xea8 +#define GDK_Hangul_Rieul 0xea9 +#define GDK_Hangul_RieulKiyeog 0xeaa +#define GDK_Hangul_RieulMieum 0xeab +#define GDK_Hangul_RieulPieub 0xeac +#define GDK_Hangul_RieulSios 0xead +#define GDK_Hangul_RieulTieut 0xeae +#define GDK_Hangul_RieulPhieuf 0xeaf +#define GDK_Hangul_RieulHieuh 0xeb0 +#define GDK_Hangul_Mieum 0xeb1 +#define GDK_Hangul_Pieub 0xeb2 +#define GDK_Hangul_SsangPieub 0xeb3 +#define GDK_Hangul_PieubSios 0xeb4 +#define GDK_Hangul_Sios 0xeb5 +#define GDK_Hangul_SsangSios 0xeb6 +#define GDK_Hangul_Ieung 0xeb7 +#define GDK_Hangul_Jieuj 0xeb8 +#define GDK_Hangul_SsangJieuj 0xeb9 +#define GDK_Hangul_Cieuc 0xeba +#define GDK_Hangul_Khieuq 0xebb +#define GDK_Hangul_Tieut 0xebc +#define GDK_Hangul_Phieuf 0xebd +#define GDK_Hangul_Hieuh 0xebe +#define GDK_Hangul_A 0xebf +#define GDK_Hangul_AE 0xec0 +#define GDK_Hangul_YA 0xec1 +#define GDK_Hangul_YAE 0xec2 +#define GDK_Hangul_EO 0xec3 +#define GDK_Hangul_E 0xec4 +#define GDK_Hangul_YEO 0xec5 +#define GDK_Hangul_YE 0xec6 +#define GDK_Hangul_O 0xec7 +#define GDK_Hangul_WA 0xec8 +#define GDK_Hangul_WAE 0xec9 +#define GDK_Hangul_OE 0xeca +#define GDK_Hangul_YO 0xecb +#define GDK_Hangul_U 0xecc +#define GDK_Hangul_WEO 0xecd +#define GDK_Hangul_WE 0xece +#define GDK_Hangul_WI 0xecf +#define GDK_Hangul_YU 0xed0 +#define GDK_Hangul_EU 0xed1 +#define GDK_Hangul_YI 0xed2 +#define GDK_Hangul_I 0xed3 +#define GDK_Hangul_J_Kiyeog 0xed4 +#define GDK_Hangul_J_SsangKiyeog 0xed5 +#define GDK_Hangul_J_KiyeogSios 0xed6 +#define GDK_Hangul_J_Nieun 0xed7 +#define GDK_Hangul_J_NieunJieuj 0xed8 +#define GDK_Hangul_J_NieunHieuh 0xed9 +#define GDK_Hangul_J_Dikeud 0xeda +#define GDK_Hangul_J_Rieul 0xedb +#define GDK_Hangul_J_RieulKiyeog 0xedc +#define GDK_Hangul_J_RieulMieum 0xedd +#define GDK_Hangul_J_RieulPieub 0xede +#define GDK_Hangul_J_RieulSios 0xedf +#define GDK_Hangul_J_RieulTieut 0xee0 +#define GDK_Hangul_J_RieulPhieuf 0xee1 +#define GDK_Hangul_J_RieulHieuh 0xee2 +#define GDK_Hangul_J_Mieum 0xee3 +#define GDK_Hangul_J_Pieub 0xee4 +#define GDK_Hangul_J_PieubSios 0xee5 +#define GDK_Hangul_J_Sios 0xee6 +#define GDK_Hangul_J_SsangSios 0xee7 +#define GDK_Hangul_J_Ieung 0xee8 +#define GDK_Hangul_J_Jieuj 0xee9 +#define GDK_Hangul_J_Cieuc 0xeea +#define GDK_Hangul_J_Khieuq 0xeeb +#define GDK_Hangul_J_Tieut 0xeec +#define GDK_Hangul_J_Phieuf 0xeed +#define GDK_Hangul_J_Hieuh 0xeee +#define GDK_Hangul_RieulYeorinHieuh 0xeef +#define GDK_Hangul_SunkyeongeumMieum 0xef0 +#define GDK_Hangul_SunkyeongeumPieub 0xef1 +#define GDK_Hangul_PanSios 0xef2 +#define GDK_Hangul_KkogjiDalrinIeung 0xef3 +#define GDK_Hangul_SunkyeongeumPhieuf 0xef4 +#define GDK_Hangul_YeorinHieuh 0xef5 +#define GDK_Hangul_AraeA 0xef6 +#define GDK_Hangul_AraeAE 0xef7 +#define GDK_Hangul_J_PanSios 0xef8 +#define GDK_Hangul_J_KkogjiDalrinIeung 0xef9 +#define GDK_Hangul_J_YeorinHieuh 0xefa +#define GDK_Korean_Won 0xeff +#define GDK_3270_Duplicate 0xFD01 +#define GDK_3270_FieldMark 0xFD02 +#define GDK_3270_Right2 0xFD03 +#define GDK_3270_Left2 0xFD04 +#define GDK_3270_BackTab 0xFD05 +#define GDK_3270_EraseEOF 0xFD06 +#define GDK_3270_EraseInput 0xFD07 +#define GDK_3270_Reset 0xFD08 +#define GDK_3270_Quit 0xFD09 +#define GDK_3270_PA1 0xFD0A +#define GDK_3270_PA2 0xFD0B +#define GDK_3270_PA3 0xFD0C +#define GDK_3270_Test 0xFD0D +#define GDK_3270_Attn 0xFD0E +#define GDK_3270_CursorBlink 0xFD0F +#define GDK_3270_AltCursor 0xFD10 +#define GDK_3270_KeyClick 0xFD11 +#define GDK_3270_Jump 0xFD12 +#define GDK_3270_Ident 0xFD13 +#define GDK_3270_Rule 0xFD14 +#define GDK_3270_Copy 0xFD15 +#define GDK_3270_Play 0xFD16 +#define GDK_3270_Setup 0xFD17 +#define GDK_3270_Record 0xFD18 +#define GDK_3270_ChangeScreen 0xFD19 +#define GDK_3270_DeleteWord 0xFD1A +#define GDK_3270_ExSelect 0xFD1B +#define GDK_3270_CursorSelect 0xFD1C +#define GDK_3270_PrintScreen 0xFD1D +#define GDK_3270_Enter 0xFD1E +#define GDK_ISO_Lock 0xFE01 +#define GDK_ISO_Level2_Latch 0xFE02 +#define GDK_ISO_Level3_Shift 0xFE03 +#define GDK_ISO_Level3_Latch 0xFE04 +#define GDK_ISO_Level3_Lock 0xFE05 +#define GDK_ISO_Group_Latch 0xFE06 +#define GDK_ISO_Group_Lock 0xFE07 +#define GDK_ISO_Next_Group 0xFE08 +#define GDK_ISO_Next_Group_Lock 0xFE09 +#define GDK_ISO_Prev_Group 0xFE0A +#define GDK_ISO_Prev_Group_Lock 0xFE0B +#define GDK_ISO_First_Group 0xFE0C +#define GDK_ISO_First_Group_Lock 0xFE0D +#define GDK_ISO_Last_Group 0xFE0E +#define GDK_ISO_Last_Group_Lock 0xFE0F +#define GDK_ISO_Left_Tab 0xFE20 +#define GDK_ISO_Move_Line_Up 0xFE21 +#define GDK_ISO_Move_Line_Down 0xFE22 +#define GDK_ISO_Partial_Line_Up 0xFE23 +#define GDK_ISO_Partial_Line_Down 0xFE24 +#define GDK_ISO_Partial_Space_Left 0xFE25 +#define GDK_ISO_Partial_Space_Right 0xFE26 +#define GDK_ISO_Set_Margin_Left 0xFE27 +#define GDK_ISO_Set_Margin_Right 0xFE28 +#define GDK_ISO_Release_Margin_Left 0xFE29 +#define GDK_ISO_Release_Margin_Right 0xFE2A +#define GDK_ISO_Release_Both_Margins 0xFE2B +#define GDK_ISO_Fast_Cursor_Left 0xFE2C +#define GDK_ISO_Fast_Cursor_Right 0xFE2D +#define GDK_ISO_Fast_Cursor_Up 0xFE2E +#define GDK_ISO_Fast_Cursor_Down 0xFE2F +#define GDK_ISO_Continuous_Underline 0xFE30 +#define GDK_ISO_Discontinuous_Underline 0xFE31 +#define GDK_ISO_Emphasize 0xFE32 +#define GDK_ISO_Center_Object 0xFE33 +#define GDK_ISO_Enter 0xFE34 +#define GDK_dead_grave 0xFE50 +#define GDK_dead_acute 0xFE51 +#define GDK_dead_circumflex 0xFE52 +#define GDK_dead_tilde 0xFE53 +#define GDK_dead_macron 0xFE54 +#define GDK_dead_breve 0xFE55 +#define GDK_dead_abovedot 0xFE56 +#define GDK_dead_diaeresis 0xFE57 +#define GDK_dead_abovering 0xFE58 +#define GDK_dead_doubleacute 0xFE59 +#define GDK_dead_caron 0xFE5A +#define GDK_dead_cedilla 0xFE5B +#define GDK_dead_ogonek 0xFE5C +#define GDK_dead_iota 0xFE5D +#define GDK_dead_voiced_sound 0xFE5E +#define GDK_dead_semivoiced_sound 0xFE5F +#define GDK_dead_belowdot 0xFE60 +#define GDK_dead_hook 0xFE61 +#define GDK_dead_horn 0xFE62 +#define GDK_AccessX_Enable 0xFE70 +#define GDK_AccessX_Feedback_Enable 0xFE71 +#define GDK_RepeatKeys_Enable 0xFE72 +#define GDK_SlowKeys_Enable 0xFE73 +#define GDK_BounceKeys_Enable 0xFE74 +#define GDK_StickyKeys_Enable 0xFE75 +#define GDK_MouseKeys_Enable 0xFE76 +#define GDK_MouseKeys_Accel_Enable 0xFE77 +#define GDK_Overlay1_Enable 0xFE78 +#define GDK_Overlay2_Enable 0xFE79 +#define GDK_AudibleBell_Enable 0xFE7A +#define GDK_First_Virtual_Screen 0xFED0 +#define GDK_Prev_Virtual_Screen 0xFED1 +#define GDK_Next_Virtual_Screen 0xFED2 +#define GDK_Last_Virtual_Screen 0xFED4 +#define GDK_Terminate_Server 0xFED5 +#define GDK_Pointer_Left 0xFEE0 +#define GDK_Pointer_Right 0xFEE1 +#define GDK_Pointer_Up 0xFEE2 +#define GDK_Pointer_Down 0xFEE3 +#define GDK_Pointer_UpLeft 0xFEE4 +#define GDK_Pointer_UpRight 0xFEE5 +#define GDK_Pointer_DownLeft 0xFEE6 +#define GDK_Pointer_DownRight 0xFEE7 +#define GDK_Pointer_Button_Dflt 0xFEE8 +#define GDK_Pointer_Button1 0xFEE9 +#define GDK_Pointer_Button2 0xFEEA +#define GDK_Pointer_Button3 0xFEEB +#define GDK_Pointer_Button4 0xFEEC +#define GDK_Pointer_Button5 0xFEED +#define GDK_Pointer_DblClick_Dflt 0xFEEE +#define GDK_Pointer_DblClick1 0xFEEF +#define GDK_Pointer_DblClick2 0xFEF0 +#define GDK_Pointer_DblClick3 0xFEF1 +#define GDK_Pointer_DblClick4 0xFEF2 +#define GDK_Pointer_DblClick5 0xFEF3 +#define GDK_Pointer_Drag_Dflt 0xFEF4 +#define GDK_Pointer_Drag1 0xFEF5 +#define GDK_Pointer_Drag2 0xFEF6 +#define GDK_Pointer_Drag3 0xFEF7 +#define GDK_Pointer_Drag4 0xFEF8 +#define GDK_Pointer_EnableKeys 0xFEF9 +#define GDK_Pointer_Accelerate 0xFEFA +#define GDK_Pointer_DfltBtnNext 0xFEFB +#define GDK_Pointer_DfltBtnPrev 0xFEFC +#define GDK_Pointer_Drag5 0xFEFD +#define GDK_BackSpace 0xFF08 +#define GDK_Tab 0xFF09 +#define GDK_Linefeed 0xFF0A +#define GDK_Clear 0xFF0B +#define GDK_Return 0xFF0D +#define GDK_Pause 0xFF13 +#define GDK_Scroll_Lock 0xFF14 +#define GDK_Sys_Req 0xFF15 +#define GDK_Escape 0xFF1B +#define GDK_Multi_key 0xFF20 +#define GDK_Kanji 0xFF21 +#define GDK_Muhenkan 0xFF22 +#define GDK_Henkan 0xFF23 +#define GDK_Henkan_Mode 0xFF23 +#define GDK_Romaji 0xFF24 +#define GDK_Hiragana 0xFF25 +#define GDK_Katakana 0xFF26 +#define GDK_Hiragana_Katakana 0xFF27 +#define GDK_Zenkaku 0xFF28 +#define GDK_Hankaku 0xFF29 +#define GDK_Zenkaku_Hankaku 0xFF2A +#define GDK_Touroku 0xFF2B +#define GDK_Massyo 0xFF2C +#define GDK_Kana_Lock 0xFF2D +#define GDK_Kana_Shift 0xFF2E +#define GDK_Eisu_Shift 0xFF2F +#define GDK_Eisu_toggle 0xFF30 +#define GDK_Hangul 0xff31 +#define GDK_Hangul_Start 0xff32 +#define GDK_Hangul_End 0xff33 +#define GDK_Hangul_Hanja 0xff34 +#define GDK_Hangul_Jamo 0xff35 +#define GDK_Hangul_Romaja 0xff36 +#define GDK_Codeinput 0xFF37 +#define GDK_Hangul_Codeinput 0xff37 +#define GDK_Kanji_Bangou 0xFF37 +#define GDK_Hangul_Jeonja 0xff38 +#define GDK_Hangul_Banja 0xff39 +#define GDK_Hangul_PreHanja 0xff3a +#define GDK_Hangul_PostHanja 0xff3b +#define GDK_Hangul_SingleCandidate 0xff3c +#define GDK_SingleCandidate 0xFF3C +#define GDK_Hangul_MultipleCandidate 0xff3d +#define GDK_MultipleCandidate 0xFF3D +#define GDK_Zen_Koho 0xFF3D +#define GDK_Hangul_PreviousCandidate 0xff3e +#define GDK_Mae_Koho 0xFF3E +#define GDK_PreviousCandidate 0xFF3E +#define GDK_Hangul_Special 0xff3f +#define GDK_Home 0xFF50 +#define GDK_Left 0xFF51 +#define GDK_Up 0xFF52 +#define GDK_Right 0xFF53 +#define GDK_Down 0xFF54 +#define GDK_Page_Up 0xFF55 +#define GDK_Prior 0xFF55 +#define GDK_Next 0xFF56 +#define GDK_Page_Down 0xFF56 +#define GDK_End 0xFF57 +#define GDK_Begin 0xFF58 +#define GDK_Select 0xFF60 +#define GDK_Print 0xFF61 +#define GDK_Execute 0xFF62 +#define GDK_Insert 0xFF63 +#define GDK_Undo 0xFF65 +#define GDK_Redo 0xFF66 +#define GDK_Menu 0xFF67 +#define GDK_Find 0xFF68 +#define GDK_Cancel 0xFF69 +#define GDK_Help 0xFF6A +#define GDK_Break 0xFF6B +#define GDK_Arabic_switch 0xFF7E +#define GDK_Greek_switch 0xFF7E +#define GDK_Hangul_switch 0xFF7E +#define GDK_Hebrew_switch 0xFF7E +#define GDK_ISO_Group_Shift 0xFF7E +#define GDK_Mode_switch 0xFF7E +#define GDK_kana_switch 0xFF7E +#define GDK_script_switch 0xFF7E +#define GDK_Num_Lock 0xFF7F +#define GDK_KP_Space 0xFF80 +#define GDK_KP_Tab 0xFF89 +#define GDK_KP_Enter 0xFF8D +#define GDK_KP_F1 0xFF91 +#define GDK_KP_F2 0xFF92 +#define GDK_KP_F3 0xFF93 +#define GDK_KP_F4 0xFF94 +#define GDK_KP_Home 0xFF95 +#define GDK_KP_Left 0xFF96 +#define GDK_KP_Up 0xFF97 +#define GDK_KP_Right 0xFF98 +#define GDK_KP_Down 0xFF99 +#define GDK_KP_Page_Up 0xFF9A +#define GDK_KP_Prior 0xFF9A +#define GDK_KP_Next 0xFF9B +#define GDK_KP_Page_Down 0xFF9B +#define GDK_KP_End 0xFF9C +#define GDK_KP_Begin 0xFF9D +#define GDK_KP_Insert 0xFF9E +#define GDK_KP_Delete 0xFF9F +#define GDK_KP_Multiply 0xFFAA +#define GDK_KP_Add 0xFFAB +#define GDK_KP_Separator 0xFFAC +#define GDK_KP_Subtract 0xFFAD +#define GDK_KP_Decimal 0xFFAE +#define GDK_KP_Divide 0xFFAF +#define GDK_KP_0 0xFFB0 +#define GDK_KP_1 0xFFB1 +#define GDK_KP_2 0xFFB2 +#define GDK_KP_3 0xFFB3 +#define GDK_KP_4 0xFFB4 +#define GDK_KP_5 0xFFB5 +#define GDK_KP_6 0xFFB6 +#define GDK_KP_7 0xFFB7 +#define GDK_KP_8 0xFFB8 +#define GDK_KP_9 0xFFB9 +#define GDK_KP_Equal 0xFFBD +#define GDK_F1 0xFFBE +#define GDK_F2 0xFFBF +#define GDK_F3 0xFFC0 +#define GDK_F4 0xFFC1 +#define GDK_F5 0xFFC2 +#define GDK_F6 0xFFC3 +#define GDK_F7 0xFFC4 +#define GDK_F8 0xFFC5 +#define GDK_F9 0xFFC6 +#define GDK_F10 0xFFC7 +#define GDK_F11 0xFFC8 +#define GDK_L1 0xFFC8 +#define GDK_F12 0xFFC9 +#define GDK_L2 0xFFC9 +#define GDK_F13 0xFFCA +#define GDK_L3 0xFFCA +#define GDK_F14 0xFFCB +#define GDK_L4 0xFFCB +#define GDK_F15 0xFFCC +#define GDK_L5 0xFFCC +#define GDK_F16 0xFFCD +#define GDK_L6 0xFFCD +#define GDK_F17 0xFFCE +#define GDK_L7 0xFFCE +#define GDK_F18 0xFFCF +#define GDK_L8 0xFFCF +#define GDK_F19 0xFFD0 +#define GDK_L9 0xFFD0 +#define GDK_F20 0xFFD1 +#define GDK_L10 0xFFD1 +#define GDK_F21 0xFFD2 +#define GDK_R1 0xFFD2 +#define GDK_F22 0xFFD3 +#define GDK_R2 0xFFD3 +#define GDK_F23 0xFFD4 +#define GDK_R3 0xFFD4 +#define GDK_F24 0xFFD5 +#define GDK_R4 0xFFD5 +#define GDK_F25 0xFFD6 +#define GDK_R5 0xFFD6 +#define GDK_F26 0xFFD7 +#define GDK_R6 0xFFD7 +#define GDK_F27 0xFFD8 +#define GDK_R7 0xFFD8 +#define GDK_F28 0xFFD9 +#define GDK_R8 0xFFD9 +#define GDK_F29 0xFFDA +#define GDK_R9 0xFFDA +#define GDK_F30 0xFFDB +#define GDK_R10 0xFFDB +#define GDK_F31 0xFFDC +#define GDK_R11 0xFFDC +#define GDK_F32 0xFFDD +#define GDK_R12 0xFFDD +#define GDK_F33 0xFFDE +#define GDK_R13 0xFFDE +#define GDK_F34 0xFFDF +#define GDK_R14 0xFFDF +#define GDK_F35 0xFFE0 +#define GDK_R15 0xFFE0 +#define GDK_Shift_L 0xFFE1 +#define GDK_Shift_R 0xFFE2 +#define GDK_Control_L 0xFFE3 +#define GDK_Control_R 0xFFE4 +#define GDK_Caps_Lock 0xFFE5 +#define GDK_Shift_Lock 0xFFE6 +#define GDK_Meta_L 0xFFE7 +#define GDK_Meta_R 0xFFE8 +#define GDK_Alt_L 0xFFE9 +#define GDK_Alt_R 0xFFEA +#define GDK_Super_L 0xFFEB +#define GDK_Super_R 0xFFEC +#define GDK_Hyper_L 0xFFED +#define GDK_Hyper_R 0xFFEE +#define GDK_Delete 0xFFFF +#define GDK_VoidSymbol 0xFFFFFF +#define GDK_Greek_IOTAdiaeresis GDK_Greek_IOTAdieresis + + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/gtk-2.0/gdk/gdkx.h b/lsb-build/headers/gtk-2.0/gdk/gdkx.h new file mode 100644 index 0000000..b1a1e58 --- /dev/null +++ b/lsb-build/headers/gtk-2.0/gdk/gdkx.h @@ -0,0 +1,105 @@ +#ifndef _GTK_2_0_GDK_GDKX_H_ +#define _GTK_2_0_GDK_GDKX_H_ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define GDK_WINDOW_DESTROYED(d) \ + (((GdkWindowObject*)(GDK_WINDOW (d)))->destroyed) +#define GDK_WINDOW_TYPE(d) \ + (((GdkWindowObject*)(GDK_WINDOW (d)))->window_type) +#define GDK_COLORMAP_XCOLORMAP(cmap) \ + (gdk_x11_colormap_get_xcolormap (cmap)) +#define GDK_DISPLAY_XDISPLAY(display) \ + (gdk_x11_display_get_xdisplay (display)) +#define GDK_SCREEN_XDISPLAY(screen) \ + (gdk_x11_display_get_xdisplay (gdk_screen_get_display (screen))) +#define GDK_PIXMAP_XDISPLAY(win) \ + (gdk_x11_drawable_get_xdisplay (((GdkPixmapObject *)win)->impl)) +#define GDK_WINDOW_XDISPLAY(win) \ + (gdk_x11_drawable_get_xdisplay (((GdkWindowObject *)win)->impl)) +#define GDK_SCREEN_XNUMBER(screen) \ + (gdk_x11_screen_get_screen_number (screen)) +#define GDK_PARENT_RELATIVE_BG ((GdkPixmap *)1L) +#define GDK_NO_BG ((GdkPixmap *)2L) +#define GDK_COLORMAP_XDISPLAY(cmap) (gdk_x11_colormap_get_xdisplay (cmap)) +#define GDK_CURSOR_XCURSOR(cursor) (gdk_x11_cursor_get_xcursor (cursor)) +#define GDK_CURSOR_XDISPLAY(cursor) (gdk_x11_cursor_get_xdisplay (cursor)) +#define GDK_DRAWABLE_XDISPLAY(win) (gdk_x11_drawable_get_xdisplay (win)) +#define GDK_DRAWABLE_XID(win) (gdk_x11_drawable_get_xid (win)) +#define GDK_PIXMAP_XID(win) (gdk_x11_drawable_get_xid (win)) +#define GDK_WINDOW_XID(win) (gdk_x11_drawable_get_xid (win)) +#define GDK_WINDOW_XWINDOW(win) (gdk_x11_drawable_get_xid (win)) +#define GDK_GC_XDISPLAY(gc) (gdk_x11_gc_get_xdisplay (gc)) +#define GDK_GC_XGC(gc) (gdk_x11_gc_get_xgc (gc)) +#define GDK_ROOT_WINDOW() (gdk_x11_get_default_root_xwindow ()) +#define GDK_IMAGE_XDISPLAY(image) (gdk_x11_image_get_xdisplay (image)) +#define GDK_IMAGE_XIMAGE(image) (gdk_x11_image_get_ximage (image)) +#define GDK_SCREEN_XSCREEN(screen) (gdk_x11_screen_get_xscreen (screen)) +#define GDK_VISUAL_XVISUAL(visual) (gdk_x11_visual_get_xvisual (visual)) +#define GDK_DISPLAY() gdk_display + + + + extern guint32 gdk_x11_get_server_time(GdkWindow *); + extern gpointer gdk_xid_table_lookup_for_display(GdkDisplay *, XID); + extern GdkVisual *gdk_x11_screen_lookup_visual(GdkScreen *, VisualID); + extern Window gdk_x11_get_default_root_xwindow(void); + extern Visual *gdk_x11_visual_get_xvisual(GdkVisual *); + extern void gdk_x11_display_ungrab(GdkDisplay *); + extern void gdk_x11_register_standard_event_type(GdkDisplay *, gint, + gint); + extern void gdk_window_destroy_notify(GdkWindow *); + extern const gchar *gdk_x11_get_xatom_name(Atom); + extern Atom gdk_x11_get_xatom_by_name_for_display(GdkDisplay *, + const gchar *); + extern GdkColormap *gdk_x11_colormap_foreign_new(GdkVisual *, + Colormap); + extern gboolean gdk_net_wm_supports(GdkAtom); + extern const gchar *gdk_x11_get_xatom_name_for_display(GdkDisplay *, + Atom); + extern GdkVisual *gdkx_visual_get(VisualID); + extern Atom gdk_x11_get_xatom_by_name(const gchar *); + extern gpointer gdk_xid_table_lookup(XID); + extern XID gdk_x11_drawable_get_xid(GdkDrawable *); + extern Display *gdk_x11_gc_get_xdisplay(GdkGC *); + extern Colormap gdk_x11_colormap_get_xcolormap(GdkColormap *); + extern GdkDisplay *gdk_x11_lookup_xdisplay(Display *); + extern GC gdk_x11_gc_get_xgc(GdkGC *); + extern void gdk_x11_grab_server(void); + extern int gdk_x11_screen_get_screen_number(GdkScreen *); + extern const char *gdk_x11_screen_get_window_manager_name(GdkScreen *); + extern GdkAtom gdk_x11_xatom_to_atom_for_display(GdkDisplay *, Atom); + extern Screen *gdk_x11_screen_get_xscreen(GdkScreen *); + extern void gdk_x11_ungrab_server(void); + extern gint gdk_x11_get_default_screen(void); + extern Display *gdk_x11_drawable_get_xdisplay(GdkDrawable *); + extern GdkAtom gdk_x11_xatom_to_atom(Atom); + extern Display *gdk_x11_colormap_get_xdisplay(GdkColormap *); + extern void gdk_x11_window_set_user_time(GdkWindow *, guint32); + extern Atom gdk_x11_atom_to_xatom(GdkAtom); + extern XImage *gdk_x11_image_get_ximage(GdkImage *); + extern Display *gdk_x11_cursor_get_xdisplay(GdkCursor *); + extern void gdk_x11_display_grab(GdkDisplay *); + extern Display *gdk_display; + extern Display *gdk_x11_image_get_xdisplay(GdkImage *); + extern Display *gdk_x11_get_default_xdisplay(void); + extern gboolean gdk_x11_screen_supports_net_wm_hint(GdkScreen *, + GdkAtom); + extern void gdk_synthesize_window_state(GdkWindow *, GdkWindowState, + GdkWindowState); + extern Display *gdk_x11_display_get_xdisplay(GdkDisplay *); + extern Atom gdk_x11_atom_to_xatom_for_display(GdkDisplay *, GdkAtom); + extern Cursor gdk_x11_cursor_get_xcursor(GdkCursor *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/gtk-2.0/gtk/gtk.h b/lsb-build/headers/gtk-2.0/gtk/gtk.h new file mode 100644 index 0000000..bdaf345 --- /dev/null +++ b/lsb-build/headers/gtk-2.0/gtk/gtk.h @@ -0,0 +1,10792 @@ +#ifndef _GTK_2_0_GTK_GTK_H_ +#define _GTK_2_0_GTK_GTK_H_ + +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define GTK_NOTE(type,action) +#define GTK_OBJECT_FLOATING(obj) \ + ((GTK_OBJECT_FLAGS (obj) & GTK_FLOATING) != 0) +#define GTK_WIDGET_APP_PAINTABLE(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_APP_PAINTABLE) != 0) +#define GTK_WIDGET_CAN_DEFAULT(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_CAN_DEFAULT) != 0) +#define GTK_WIDGET_CAN_FOCUS(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_CAN_FOCUS) != 0) +#define GTK_WIDGET_COMPOSITE_CHILD(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_COMPOSITE_CHILD) != 0) +#define GTK_WIDGET_DOUBLE_BUFFERED(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_DOUBLE_BUFFERED) != 0) +#define GTK_WIDGET_HAS_DEFAULT(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_DEFAULT) != 0) +#define GTK_WIDGET_HAS_FOCUS(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_FOCUS) != 0) +#define GTK_WIDGET_HAS_GRAB(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_GRAB) != 0) +#define GTK_WIDGET_MAPPED(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_MAPPED) != 0) +#define GTK_WIDGET_NO_WINDOW(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_NO_WINDOW) != 0) +#define GTK_WIDGET_PARENT_SENSITIVE(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_PARENT_SENSITIVE) != 0) +#define GTK_WIDGET_RC_STYLE(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_RC_STYLE) != 0) +#define GTK_WIDGET_REALIZED(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_REALIZED) != 0) +#define GTK_WIDGET_RECEIVES_DEFAULT(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_RECEIVES_DEFAULT) != 0) +#define GTK_WIDGET_SENSITIVE(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_SENSITIVE) != 0) +#define GTK_WIDGET_TOPLEVEL(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_TOPLEVEL) != 0) +#define GTK_WIDGET_VISIBLE(wid) \ + ((GTK_WIDGET_FLAGS (wid) & GTK_VISIBLE) != 0) +#define GTK_TYPE_CALENDAR_DISPLAY_OPTIONS \ + (gtk_calendar_display_options_get_type()) +#define GTK_TYPE_CELL_RENDERER_PIXBUF \ + (gtk_cell_renderer_pixbuf_get_type ()) +#define GTK_TYPE_CELL_RENDERER_PROGRESS \ + (gtk_cell_renderer_progress_get_type ()) +#define GTK_TYPE_CELL_RENDERER_TOGGLE \ + (gtk_cell_renderer_toggle_get_type ()) +#define GTK_ICON_VIEW(obj) \ + (GTK_CHECK_CAST ((obj), GTK_TYPE_ICON_VIEW, GtkIconView)) +#define GTK_OBJECT(object) \ + (GTK_CHECK_CAST ((object), GTK_TYPE_OBJECT, GtkObject)) +#define GTK_ICON_VIEW_CLASS(klass) \ + (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_ICON_VIEW, \ + GtkIconViewClass)) +#define GTK_LIST_CLASS(klass) \ + (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_LIST, GtkListClass)) +#define GTK_OBJECT_CLASS(klass) \ + (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_OBJECT, GtkObjectClass)) +#define GTK_IS_ICON_VIEW_CLASS(klass) \ + (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ICON_VIEW)) +#define GTK_IS_LIST_CLASS(klass) \ + (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LIST)) +#define GTK_IS_OBJECT_CLASS(klass) \ + (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_OBJECT)) +#define GTK_ICON_VIEW_GET_CLASS(obj) \ + (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_ICON_VIEW, GtkIconViewClass)) +#define GTK_LIST_GET_CLASS(obj) \ + (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_LIST, GtkListClass)) +#define GTK_OBJECT_GET_CLASS(object) \ + (GTK_CHECK_GET_CLASS ((object), GTK_TYPE_OBJECT, GtkObjectClass)) +#define GTK_TYPE_COLOR_SELECTION_DIALOG \ + (gtk_color_selection_dialog_get_type ()) +#define GTK_TYPE_FONT_SELECTION_DIALOG \ + (gtk_font_selection_dialog_get_type ()) +#define GTK_IS_RESIZE_CONTAINER(widget) \ + (GTK_IS_CONTAINER (widget) && ((GtkContainer*) (widget))->resize_mode \ + != GTK_RESIZE_PARENT) +#define GTK_CHECK_VERSION(major,minor,micro) \ + (GTK_MAJOR_VERSION > (major) || (GTK_MAJOR_VERSION == (major) && \ + GTK_MINOR_VERSION > (minor)) || (GTK_MAJOR_VERSION == (major) && \ + GTK_MINOR_VERSION == (minor) && GTK_MICRO_VERSION >= (micro))) +#define GTK_TYPE_PROGRESS_BAR_ORIENTATION \ + (gtk_progress_bar_orientation_get_type()) +#define GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY \ + (gtk_spin_button_update_policy_get_type()) +#define GTK_TYPE_TREE_VIEW_COLUMN_SIZING \ + (gtk_tree_view_column_sizing_get_type()) +#define GTK_TYPE_TREE_VIEW_DROP_POSITION \ + (gtk_tree_view_drop_position_get_type()) +#define GTK_TYPE_UI_MANAGER_ITEM_TYPE \ + (gtk_ui_manager_item_type_get_type()) +#define GTK_WIDGET_IS_SENSITIVE(wid) \ + (GTK_WIDGET_SENSITIVE (wid) && GTK_WIDGET_PARENT_SENSITIVE (wid)) +#define GTK_WIDGET_DRAWABLE(wid) \ + (GTK_WIDGET_VISIBLE (wid) && GTK_WIDGET_MAPPED (wid)) +#define GTK_ABOUT_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ABOUT_DIALOG, \ + GtkAboutDialogClass)) +#define GTK_ACCEL_GROUP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCEL_GROUP, \ + GtkAccelGroupClass)) +#define GTK_ACCEL_LABEL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCEL_LABEL, \ + GtkAccelLabelClass)) +#define GTK_ACCEL_MAP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCEL_MAP, \ + GtkAccelMapClass)) +#define GTK_ACCESSIBLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCESSIBLE, \ + GtkAccessibleClass)) +#define GTK_ACTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACTION, GtkActionClass)) +#define GTK_ADJUSTMENT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ADJUSTMENT, \ + GtkAdjustmentClass)) +#define GTK_ALIGNMENT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ALIGNMENT, \ + GtkAlignmentClass)) +#define GTK_ARROW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ARROW, GtkArrowClass)) +#define GTK_ASPECT_FRAME_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ASPECT_FRAME, \ + GtkAspectFrameClass)) +#define GTK_BIN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BIN, GtkBinClass)) +#define GTK_BOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BOX, GtkBoxClass)) +#define GTK_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BUTTON, GtkButtonClass)) +#define GTK_BUTTON_BOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BUTTON_BOX, \ + GtkButtonBoxClass)) +#define GTK_CALENDAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CALENDAR, \ + GtkCalendarClass)) +#define GTK_CELL_RENDERER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER, \ + GtkCellRendererClass)) +#define GTK_CELL_RENDERER_COMBO_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_COMBO, \ + GtkCellRendererComboClass)) +#define GTK_CELL_RENDERER_PIXBUF_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_PIXBUF, \ + GtkCellRendererPixbufClass)) +#define GTK_CELL_RENDERER_PROGRESS_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_PROGRESS, \ + GtkCellRendererProgressClass)) +#define GTK_CELL_RENDERER_TEXT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_TEXT, \ + GtkCellRendererTextClass)) +#define GTK_CELL_RENDERER_TOGGLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_TOGGLE, \ + GtkCellRendererToggleClass)) +#define GTK_CHECK_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CHECK_BUTTON, \ + GtkCheckButtonClass)) +#define GTK_CHECK_MENU_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CHECK_MENU_ITEM, \ + GtkCheckMenuItemClass)) +#define GTK_COLOR_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COLOR_BUTTON, \ + GtkColorButtonClass)) +#define GTK_COLOR_SELECTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COLOR_SELECTION, \ + GtkColorSelectionClass)) +#define GTK_COLOR_SELECTION_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COLOR_SELECTION_DIALOG, \ + GtkColorSelectionDialogClass)) +#define GTK_CONTAINER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CONTAINER, \ + GtkContainerClass)) +#define GTK_CURVE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CURVE, GtkCurveClass)) +#define GTK_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_DIALOG, GtkDialogClass)) +#define GTK_DRAWING_AREA_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_DRAWING_AREA, \ + GtkDrawingAreaClass)) +#define GTK_ENTRY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ENTRY, GtkEntryClass)) +#define GTK_ENTRY_COMPLETION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ENTRY_COMPLETION, \ + GtkEntryCompletionClass)) +#define GTK_EVENT_BOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_EVENT_BOX, \ + GtkEventBoxClass)) +#define GTK_EXPANDER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_EXPANDER, \ + GtkExpanderClass)) +#define GTK_FILE_CHOOSER_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_CHOOSER_BUTTON, \ + GtkFileChooserButtonClass)) +#define GTK_FILE_CHOOSER_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_CHOOSER_DIALOG, \ + GtkFileChooserDialogClass)) +#define GTK_FILE_CHOOSER_WIDGET_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_CHOOSER_WIDGET, \ + GtkFileChooserWidgetClass)) +#define GTK_FILE_SELECTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_SELECTION, \ + GtkFileSelectionClass)) +#define GTK_FIXED_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FIXED, GtkFixedClass)) +#define GTK_FONT_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FONT_BUTTON, \ + GtkFontButtonClass)) +#define GTK_FONT_SELECTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FONT_SELECTION, \ + GtkFontSelectionClass)) +#define GTK_FONT_SELECTION_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FONT_SELECTION_DIALOG, \ + GtkFontSelectionDialogClass)) +#define GTK_FRAME_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FRAME, GtkFrameClass)) +#define GTK_GAMMA_CURVE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_GAMMA_CURVE, \ + GtkGammaCurveClass)) +#define GTK_HANDLE_BOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_HANDLE_BOX, \ + GtkHandleBoxClass)) +#define GTK_HBOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_HBOX, GtkHBoxClass)) +#define GTK_HBUTTON_BOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_HBUTTON_BOX, \ + GtkHButtonBoxClass)) +#define GTK_HPANED_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_HPANED, GtkHPanedClass)) +#define GTK_HRULER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_HRULER, GtkHRulerClass)) +#define GTK_HSCALE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_HSCALE, GtkHScaleClass)) +#define GTK_HSCROLLBAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_HSCROLLBAR, \ + GtkHScrollbarClass)) +#define GTK_HSEPARATOR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_HSEPARATOR, \ + GtkHSeparatorClass)) +#define GTK_ICON_FACTORY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ICON_FACTORY, \ + GtkIconFactoryClass)) +#define GTK_ICON_THEME_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ICON_THEME, \ + GtkIconThemeClass)) +#define GTK_IMAGE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IMAGE, GtkImageClass)) +#define GTK_IMAGE_MENU_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IMAGE_MENU_ITEM, \ + GtkImageMenuItemClass)) +#define GTK_IM_CONTEXT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IM_CONTEXT, \ + GtkIMContextClass)) +#define GTK_IM_CONTEXT_SIMPLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IM_CONTEXT_SIMPLE, \ + GtkIMContextSimpleClass)) +#define GTK_IM_MULTICONTEXT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IM_MULTICONTEXT, \ + GtkIMMulticontextClass)) +#define GTK_INPUT_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_INPUT_DIALOG, \ + GtkInputDialogClass)) +#define GTK_INVISIBLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_INVISIBLE, \ + GtkInvisibleClass)) +#define GTK_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ITEM, GtkItemClass)) +#define GTK_LABEL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LABEL, GtkLabelClass)) +#define GTK_LAYOUT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LAYOUT, GtkLayoutClass)) +#define GTK_LIST_STORE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LIST_STORE, \ + GtkListStoreClass)) +#define GTK_MENU_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU, GtkMenuClass)) +#define GTK_MENU_BAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_BAR, \ + GtkMenuBarClass)) +#define GTK_MENU_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_ITEM, \ + GtkMenuItemClass)) +#define GTK_MENU_SHELL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_SHELL, \ + GtkMenuShellClass)) +#define GTK_MESSAGE_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MESSAGE_DIALOG, \ + GtkMessageDialogClass)) +#define GTK_MISC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MISC, GtkMiscClass)) +#define GTK_NOTEBOOK_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_NOTEBOOK, \ + GtkNotebookClass)) +#define GTK_PANED_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PANED, GtkPanedClass)) +#define GTK_PLUG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PLUG, GtkPlugClass)) +#define GTK_PROGRESS_BAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PROGRESS_BAR, \ + GtkProgressBarClass)) +#define GTK_RADIO_ACTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_ACTION, \ + GtkRadioActionClass)) +#define GTK_RADIO_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_BUTTON, \ + GtkRadioButtonClass)) +#define GTK_RADIO_MENU_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_MENU_ITEM, \ + GtkRadioMenuItemClass)) +#define GTK_RADIO_TOOL_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_TOOL_BUTTON, \ + GtkRadioToolButtonClass)) +#define GTK_RANGE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RANGE, GtkRangeClass)) +#define GTK_RC_STYLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RC_STYLE, \ + GtkRcStyleClass)) +#define GTK_RULER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RULER, GtkRulerClass)) +#define GTK_SCALE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCALE, GtkScaleClass)) +#define GTK_SCROLLBAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLBAR, \ + GtkScrollbarClass)) +#define GTK_SCROLLED_WINDOW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLED_WINDOW, \ + GtkScrolledWindowClass)) +#define GTK_SEPARATOR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEPARATOR, \ + GtkSeparatorClass)) +#define GTK_SEPARATOR_MENU_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEPARATOR_MENU_ITEM, \ + GtkSeparatorMenuItemClass)) +#define GTK_SEPARATOR_TOOL_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEPARATOR_TOOL_ITEM, \ + GtkSeparatorToolItemClass)) +#define GTK_SETTINGS_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SETTINGS, \ + GtkSettingsClass)) +#define GTK_SIZE_GROUP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SIZE_GROUP, \ + GtkSizeGroupClass)) +#define GTK_SOCKET_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SOCKET, GtkSocketClass)) +#define GTK_SPIN_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SPIN_BUTTON, \ + GtkSpinButtonClass)) +#define GTK_STATUSBAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STATUSBAR, \ + GtkStatusbarClass)) +#define GTK_STYLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STYLE, GtkStyleClass)) +#define GTK_TABLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TABLE, GtkTableClass)) +#define GTK_TEAROFF_MENU_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEAROFF_MENU_ITEM, \ + GtkTearoffMenuItemClass)) +#define GTK_TEXT_BUFFER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_BUFFER, \ + GtkTextBufferClass)) +#define GTK_TEXT_CHILD_ANCHOR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_CHILD_ANCHOR, \ + GtkTextChildAnchorClass)) +#define GTK_TEXT_MARK_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_MARK, \ + GtkTextMarkClass)) +#define GTK_TEXT_TAG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_TAG, \ + GtkTextTagClass)) +#define GTK_TEXT_TAG_TABLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_TAG_TABLE, \ + GtkTextTagTableClass)) +#define GTK_TEXT_VIEW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_VIEW, \ + GtkTextViewClass)) +#define GTK_TOGGLE_ACTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOGGLE_ACTION, \ + GtkToggleActionClass)) +#define GTK_TOGGLE_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOGGLE_BUTTON, \ + GtkToggleButtonClass)) +#define GTK_TOGGLE_TOOL_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOGGLE_TOOL_BUTTON, \ + GtkToggleToolButtonClass)) +#define GTK_TOOLBAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOLBAR, \ + GtkToolbarClass)) +#define GTK_TOOLTIPS_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOLTIPS, \ + GtkTooltipsClass)) +#define GTK_TOOL_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOL_BUTTON, \ + GtkToolButtonClass)) +#define GTK_TOOL_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOL_ITEM, \ + GtkToolItemClass)) +#define GTK_TREE_MODEL_SORT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_MODEL_SORT, \ + GtkTreeModelSortClass)) +#define GTK_TREE_SELECTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_SELECTION, \ + GtkTreeSelectionClass)) +#define GTK_TREE_STORE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_STORE, \ + GtkTreeStoreClass)) +#define GTK_TREE_VIEW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_VIEW, \ + GtkTreeViewClass)) +#define GTK_TREE_VIEW_COLUMN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_VIEW_COLUMN, \ + GtkTreeViewColumnClass)) +#define GTK_UI_MANAGER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_UI_MANAGER, \ + GtkUIManagerClass)) +#define GTK_VBOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_VBOX, GtkVBoxClass)) +#define GTK_VBUTTON_BOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_VBUTTON_BOX, \ + GtkVButtonBoxClass)) +#define GTK_VIEWPORT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_VIEWPORT, \ + GtkViewportClass)) +#define GTK_VPANED_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_VPANED, GtkVPanedClass)) +#define GTK_VRULER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_VRULER, GtkVRulerClass)) +#define GTK_VSCALE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_VSCALE, GtkVScaleClass)) +#define GTK_VSCROLLBAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_VSCROLLBAR, \ + GtkVScrollbarClass)) +#define GTK_VSEPARATOR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_VSEPARATOR, \ + GtkVSeparatorClass)) +#define GTK_WIDGET_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WIDGET, GtkWidgetClass)) +#define GTK_WINDOW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WINDOW, GtkWindowClass)) +#define GTK_WINDOW_GROUP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WINDOW_GROUP, \ + GtkWindowGroupClass)) +#define GTK_CELL_EDITABLE_CLASS(obj) \ + (G_TYPE_CHECK_CLASS_CAST ((obj), GTK_TYPE_CELL_EDITABLE, \ + GtkCellEditableIface)) +#define GTK_TREE_SORTABLE_CLASS(obj) \ + (G_TYPE_CHECK_CLASS_CAST ((obj), GTK_TYPE_TREE_SORTABLE, \ + GtkTreeSortableIface)) +#define GTK_ACTION_GROUP_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_CAST ((vtable), GTK_TYPE_ACTION_GROUP, \ + GtkActionGroupClass)) +#define GTK_CELL_VIEW_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_CAST ((vtable), GTK_TYPE_CELL_VIEW, \ + GtkCellViewClass)) +#define GTK_COMBO_BOX_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_CAST ((vtable), GTK_TYPE_COMBO_BOX, \ + GtkComboBoxClass)) +#define GTK_COMBO_BOX_ENTRY_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_CAST ((vtable), GTK_TYPE_COMBO_BOX_ENTRY, \ + GtkComboBoxEntryClass)) +#define GTK_EDITABLE_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_CAST ((vtable), GTK_TYPE_EDITABLE, \ + GtkEditableClass)) +#define GTK_TREE_MODEL_FILTER_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_CAST ((vtable), GTK_TYPE_TREE_MODEL_FILTER, \ + GtkTreeModelFilterClass)) +#define GTK_MENU_TOOL_BUTTON_CLASS(k) \ + (G_TYPE_CHECK_CLASS_CAST((k), GTK_TYPE_MENU_TOOL_BUTTON, \ + GtkMenuToolButtonClass)) +#define GTK_IS_MENU_TOOL_BUTTON_CLASS(k) \ + (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_MENU_TOOL_BUTTON)) +#define GTK_IS_ABOUT_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ABOUT_DIALOG)) +#define GTK_IS_ACCEL_GROUP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACCEL_GROUP)) +#define GTK_IS_ACCEL_LABEL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACCEL_LABEL)) +#define GTK_IS_ACCEL_MAP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACCEL_MAP)) +#define GTK_IS_ACCESSIBLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACCESSIBLE)) +#define GTK_IS_ACTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACTION)) +#define GTK_IS_ADJUSTMENT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ADJUSTMENT)) +#define GTK_IS_ALIGNMENT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ALIGNMENT)) +#define GTK_IS_ARROW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ARROW)) +#define GTK_IS_ASPECT_FRAME_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ASPECT_FRAME)) +#define GTK_IS_BIN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BIN)) +#define GTK_IS_BOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BOX)) +#define GTK_IS_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BUTTON)) +#define GTK_IS_BUTTON_BOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BUTTON_BOX)) +#define GTK_IS_CALENDAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CALENDAR)) +#define GTK_IS_CELL_RENDERER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER)) +#define GTK_IS_CELL_RENDERER_COMBO_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_COMBO)) +#define GTK_IS_CELL_RENDERER_PIXBUF_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_PIXBUF)) +#define GTK_IS_CELL_RENDERER_PROGRESS_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_PROGRESS)) +#define GTK_IS_CELL_RENDERER_TEXT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_TEXT)) +#define GTK_IS_CELL_RENDERER_TOGGLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_TOGGLE)) +#define GTK_IS_CHECK_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CHECK_BUTTON)) +#define GTK_IS_CHECK_MENU_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CHECK_MENU_ITEM)) +#define GTK_IS_COLOR_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_COLOR_BUTTON)) +#define GTK_IS_COLOR_SELECTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_COLOR_SELECTION)) +#define GTK_IS_COLOR_SELECTION_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_COLOR_SELECTION_DIALOG)) +#define GTK_IS_CONTAINER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CONTAINER)) +#define GTK_IS_CURVE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CURVE)) +#define GTK_IS_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_DIALOG)) +#define GTK_IS_DRAWING_AREA_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_DRAWING_AREA)) +#define GTK_IS_ENTRY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ENTRY)) +#define GTK_IS_ENTRY_COMPLETION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ENTRY_COMPLETION)) +#define GTK_IS_EVENT_BOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_EVENT_BOX)) +#define GTK_IS_EXPANDER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_EXPANDER)) +#define GTK_IS_FILE_CHOOSER_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_CHOOSER_BUTTON)) +#define GTK_IS_FILE_CHOOSER_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_CHOOSER_DIALOG)) +#define GTK_IS_FILE_CHOOSER_WIDGET_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_CHOOSER_WIDGET)) +#define GTK_IS_FILE_SELECTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_SELECTION)) +#define GTK_IS_FIXED_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FIXED)) +#define GTK_IS_FONT_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FONT_BUTTON)) +#define GTK_IS_FONT_SELECTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FONT_SELECTION)) +#define GTK_IS_FONT_SELECTION_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FONT_SELECTION_DIALOG)) +#define GTK_IS_FRAME_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FRAME)) +#define GTK_IS_GAMMA_CURVE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_GAMMA_CURVE)) +#define GTK_IS_HANDLE_BOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HANDLE_BOX)) +#define GTK_IS_HBOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HBOX)) +#define GTK_IS_HBUTTON_BOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HBUTTON_BOX)) +#define GTK_IS_HPANED_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HPANED)) +#define GTK_IS_HRULER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HRULER)) +#define GTK_IS_HSCALE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HSCALE)) +#define GTK_IS_HSCROLLBAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HSCROLLBAR)) +#define GTK_IS_HSEPARATOR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HSEPARATOR)) +#define GTK_IS_ICON_FACTORY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ICON_FACTORY)) +#define GTK_IS_ICON_THEME_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ICON_THEME)) +#define GTK_IS_IMAGE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IMAGE)) +#define GTK_IS_IMAGE_MENU_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IMAGE_MENU_ITEM)) +#define GTK_IS_IM_CONTEXT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IM_CONTEXT)) +#define GTK_IS_IM_CONTEXT_SIMPLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IM_CONTEXT_SIMPLE)) +#define GTK_IS_IM_MULTICONTEXT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IM_MULTICONTEXT)) +#define GTK_IS_INPUT_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_INPUT_DIALOG)) +#define GTK_IS_INVISIBLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_INVISIBLE)) +#define GTK_IS_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ITEM)) +#define GTK_IS_LABEL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LABEL)) +#define GTK_IS_LAYOUT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LAYOUT)) +#define GTK_IS_LIST_STORE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LIST_STORE)) +#define GTK_IS_MENU_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU)) +#define GTK_IS_MENU_BAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU_BAR)) +#define GTK_IS_MENU_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU_ITEM)) +#define GTK_IS_MENU_SHELL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU_SHELL)) +#define GTK_IS_MESSAGE_DIALOG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MESSAGE_DIALOG)) +#define GTK_IS_MISC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MISC)) +#define GTK_IS_NOTEBOOK_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_NOTEBOOK)) +#define GTK_IS_PANED_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PANED)) +#define GTK_IS_PLUG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PLUG)) +#define GTK_IS_PROGRESS_BAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PROGRESS_BAR)) +#define GTK_IS_RADIO_ACTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RADIO_ACTION)) +#define GTK_IS_RADIO_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RADIO_BUTTON)) +#define GTK_IS_RADIO_MENU_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RADIO_MENU_ITEM)) +#define GTK_IS_RADIO_TOOL_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RADIO_TOOL_BUTTON)) +#define GTK_IS_RANGE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RANGE)) +#define GTK_IS_RC_STYLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RC_STYLE)) +#define GTK_IS_RULER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RULER)) +#define GTK_IS_SCALE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCALE)) +#define GTK_IS_SCROLLBAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCROLLBAR)) +#define GTK_IS_SCROLLED_WINDOW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCROLLED_WINDOW)) +#define GTK_IS_SEPARATOR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEPARATOR)) +#define GTK_IS_SEPARATOR_MENU_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEPARATOR_MENU_ITEM)) +#define GTK_IS_SEPARATOR_TOOL_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEPARATOR_TOOL_ITEM)) +#define GTK_IS_SETTINGS_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SETTINGS)) +#define GTK_IS_SIZE_GROUP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SIZE_GROUP)) +#define GTK_IS_SOCKET_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SOCKET)) +#define GTK_IS_SPIN_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SPIN_BUTTON)) +#define GTK_IS_STATUSBAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STATUSBAR)) +#define GTK_IS_STYLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STYLE)) +#define GTK_IS_TABLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TABLE)) +#define GTK_IS_TEAROFF_MENU_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEAROFF_MENU_ITEM)) +#define GTK_IS_TEXT_BUFFER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_BUFFER)) +#define GTK_IS_TEXT_CHILD_ANCHOR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_CHILD_ANCHOR)) +#define GTK_IS_TEXT_MARK_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_MARK)) +#define GTK_IS_TEXT_TAG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_TAG)) +#define GTK_IS_TEXT_TAG_TABLE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_TAG_TABLE)) +#define GTK_IS_TEXT_VIEW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_VIEW)) +#define GTK_IS_TOGGLE_ACTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOGGLE_ACTION)) +#define GTK_IS_TOGGLE_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOGGLE_BUTTON)) +#define GTK_IS_TOGGLE_TOOL_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOGGLE_TOOL_BUTTON)) +#define GTK_IS_TOOLBAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOOLBAR)) +#define GTK_IS_TOOLTIPS_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOOLTIPS)) +#define GTK_IS_TOOL_BUTTON_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOOL_BUTTON)) +#define GTK_IS_TOOL_ITEM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOOL_ITEM)) +#define GTK_IS_TREE_MODEL_SORT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_MODEL_SORT)) +#define GTK_IS_TREE_SELECTION_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_SELECTION)) +#define GTK_IS_TREE_STORE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_STORE)) +#define GTK_IS_TREE_VIEW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_VIEW)) +#define GTK_IS_TREE_VIEW_COLUMN_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_VIEW_COLUMN)) +#define GTK_IS_UI_MANAGER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_UI_MANAGER)) +#define GTK_IS_VBOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VBOX)) +#define GTK_IS_VBUTTON_BOX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VBUTTON_BOX)) +#define GTK_IS_VIEWPORT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VIEWPORT)) +#define GTK_IS_VPANED_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VPANED)) +#define GTK_IS_VRULER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VRULER)) +#define GTK_IS_VSCALE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VSCALE)) +#define GTK_IS_VSCROLLBAR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VSCROLLBAR)) +#define GTK_IS_VSEPARATOR_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VSEPARATOR)) +#define GTK_IS_WIDGET_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WIDGET)) +#define GTK_IS_WINDOW_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WINDOW)) +#define GTK_IS_WINDOW_GROUP_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WINDOW_GROUP)) +#define GTK_IS_ACTION_GROUP_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_TYPE ((vtable), GTK_TYPE_ACTION_GROUP)) +#define GTK_IS_CELL_VIEW_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_TYPE ((vtable), GTK_TYPE_CELL_VIEW)) +#define GTK_IS_COMBO_BOX_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_TYPE ((vtable), GTK_TYPE_COMBO_BOX)) +#define GTK_IS_COMBO_BOX_ENTRY_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_TYPE ((vtable), GTK_TYPE_COMBO_BOX_ENTRY)) +#define GTK_IS_EDITABLE_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_TYPE ((vtable), GTK_TYPE_EDITABLE)) +#define GTK_IS_TREE_MODEL_FILTER_CLASS(vtable) \ + (G_TYPE_CHECK_CLASS_TYPE ((vtable), GTK_TYPE_TREE_MODEL_FILTER)) +#define GTK_ACCEL_MAP(accel_map) \ + (G_TYPE_CHECK_INSTANCE_CAST ((accel_map), GTK_TYPE_ACCEL_MAP, \ + GtkAccelMap)) +#define GTK_MENU_TOOL_BUTTON(o) \ + (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_MENU_TOOL_BUTTON, \ + GtkMenuToolButton)) +#define GTK_TOOL_ITEM(o) \ + (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_TOOL_ITEM, GtkToolItem)) +#define GTK_ACCEL_LABEL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ACCEL_LABEL, \ + GtkAccelLabel)) +#define GTK_ACCESSIBLE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ACCESSIBLE, \ + GtkAccessible)) +#define GTK_ACTION(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ACTION, GtkAction)) +#define GTK_ACTION_GROUP(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ACTION_GROUP, \ + GtkActionGroup)) +#define GTK_ADJUSTMENT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ADJUSTMENT, \ + GtkAdjustment)) +#define GTK_ALIGNMENT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ALIGNMENT, \ + GtkAlignment)) +#define GTK_ARROW(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ARROW, GtkArrow)) +#define GTK_ASPECT_FRAME(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ASPECT_FRAME, \ + GtkAspectFrame)) +#define GTK_BIN(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BIN, GtkBin)) +#define GTK_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BOX, GtkBox)) +#define GTK_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BUTTON, GtkButton)) +#define GTK_BUTTON_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BUTTON_BOX, \ + GtkButtonBox)) +#define GTK_CALENDAR(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CALENDAR, GtkCalendar)) +#define GTK_CELL_EDITABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_EDITABLE, \ + GtkCellEditable)) +#define GTK_CELL_LAYOUT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_LAYOUT, \ + GtkCellLayout)) +#define GTK_CELL_RENDERER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER, \ + GtkCellRenderer)) +#define GTK_CELL_RENDERER_COMBO(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_COMBO, \ + GtkCellRendererCombo)) +#define GTK_CELL_RENDERER_PIXBUF(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_PIXBUF, \ + GtkCellRendererPixbuf)) +#define GTK_CELL_RENDERER_PROGRESS(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_PROGRESS, \ + GtkCellRendererProgress)) +#define GTK_CELL_RENDERER_TEXT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_TEXT, \ + GtkCellRendererText)) +#define GTK_CELL_RENDERER_TOGGLE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_TOGGLE, \ + GtkCellRendererToggle)) +#define GTK_CELL_VIEW(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_VIEW, GtkCellView)) +#define GTK_CHECK_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CHECK_BUTTON, \ + GtkCheckButton)) +#define GTK_CHECK_MENU_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CHECK_MENU_ITEM, \ + GtkCheckMenuItem)) +#define GTK_CLIPBOARD(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CLIPBOARD, \ + GtkClipboard)) +#define GTK_COLOR_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COLOR_BUTTON, \ + GtkColorButton)) +#define GTK_COLOR_SELECTION(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COLOR_SELECTION, \ + GtkColorSelection)) +#define GTK_COLOR_SELECTION_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COLOR_SELECTION_DIALOG, \ + GtkColorSelectionDialog)) +#define GTK_COMBO_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COMBO_BOX, GtkComboBox)) +#define GTK_COMBO_BOX_ENTRY(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COMBO_BOX_ENTRY, \ + GtkComboBoxEntry)) +#define GTK_CONTAINER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CONTAINER, \ + GtkContainer)) +#define GTK_CURVE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CURVE, GtkCurve)) +#define GTK_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_DIALOG, GtkDialog)) +#define GTK_DRAWING_AREA(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_DRAWING_AREA, \ + GtkDrawingArea)) +#define GTK_EDITABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_EDITABLE, GtkEditable)) +#define GTK_ENTRY(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ENTRY, GtkEntry)) +#define GTK_ENTRY_COMPLETION(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ENTRY_COMPLETION, \ + GtkEntryCompletion)) +#define GTK_EVENT_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_EVENT_BOX, GtkEventBox)) +#define GTK_EXPANDER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_EXPANDER, GtkExpander)) +#define GTK_FILE_CHOOSER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER, \ + GtkFileChooser)) +#define GTK_FILE_CHOOSER_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER_DIALOG, \ + GtkFileChooserDialog)) +#define GTK_FILE_CHOOSER_WIDGET(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER_WIDGET, \ + GtkFileChooserWidget)) +#define GTK_FILE_FILTER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_FILTER, \ + GtkFileFilter)) +#define GTK_FILE_SELECTION(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_SELECTION, \ + GtkFileSelection)) +#define GTK_FIXED(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FIXED, GtkFixed)) +#define GTK_FONT_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FONT_BUTTON, \ + GtkFontButton)) +#define GTK_FONT_SELECTION(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FONT_SELECTION, \ + GtkFontSelection)) +#define GTK_FONT_SELECTION_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FONT_SELECTION_DIALOG, \ + GtkFontSelectionDialog)) +#define GTK_FRAME(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FRAME, GtkFrame)) +#define GTK_GAMMA_CURVE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_GAMMA_CURVE, \ + GtkGammaCurve)) +#define GTK_HANDLE_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HANDLE_BOX, \ + GtkHandleBox)) +#define GTK_HBOX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HBOX, GtkHBox)) +#define GTK_HBUTTON_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HBUTTON_BOX, \ + GtkHButtonBox)) +#define GTK_HPANED(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HPANED, GtkHPaned)) +#define GTK_HRULER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HRULER, GtkHRuler)) +#define GTK_HSCALE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HSCALE, GtkHScale)) +#define GTK_HSCROLLBAR(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HSCROLLBAR, \ + GtkHScrollbar)) +#define GTK_HSEPARATOR(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HSEPARATOR, \ + GtkHSeparator)) +#define GTK_ICON_THEME(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ICON_THEME, \ + GtkIconTheme)) +#define GTK_IMAGE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IMAGE, GtkImage)) +#define GTK_IMAGE_MENU_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IMAGE_MENU_ITEM, \ + GtkImageMenuItem)) +#define GTK_IM_CONTEXT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IM_CONTEXT, \ + GtkIMContext)) +#define GTK_IM_CONTEXT_SIMPLE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IM_CONTEXT_SIMPLE, \ + GtkIMContextSimple)) +#define GTK_IM_MULTICONTEXT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IM_MULTICONTEXT, \ + GtkIMMulticontext)) +#define GTK_INPUT_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_INPUT_DIALOG, \ + GtkInputDialog)) +#define GTK_INVISIBLE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_INVISIBLE, \ + GtkInvisible)) +#define GTK_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ITEM, GtkItem)) +#define GTK_LABEL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LABEL, GtkLabel)) +#define GTK_LAYOUT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LAYOUT, GtkLayout)) +#define GTK_LIST_STORE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LIST_STORE, \ + GtkListStore)) +#define GTK_MENU(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU, GtkMenu)) +#define GTK_MENU_BAR(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_BAR, GtkMenuBar)) +#define GTK_MENU_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_ITEM, GtkMenuItem)) +#define GTK_MENU_SHELL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_SHELL, \ + GtkMenuShell)) +#define GTK_MESSAGE_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MESSAGE_DIALOG, \ + GtkMessageDialog)) +#define GTK_MISC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MISC, GtkMisc)) +#define GTK_NOTEBOOK(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_NOTEBOOK, GtkNotebook)) +#define GTK_PANED(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PANED, GtkPaned)) +#define GTK_PLUG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PLUG, GtkPlug)) +#define GTK_PROGRESS_BAR(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PROGRESS_BAR, \ + GtkProgressBar)) +#define GTK_RADIO_ACTION(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_ACTION, \ + GtkRadioAction)) +#define GTK_RADIO_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_BUTTON, \ + GtkRadioButton)) +#define GTK_RADIO_MENU_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_MENU_ITEM, \ + GtkRadioMenuItem)) +#define GTK_RADIO_TOOL_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_TOOL_BUTTON, \ + GtkRadioToolButton)) +#define GTK_RANGE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RANGE, GtkRange)) +#define GTK_RULER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RULER, GtkRuler)) +#define GTK_SCALE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCALE, GtkScale)) +#define GTK_SCROLLBAR(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCROLLBAR, \ + GtkScrollbar)) +#define GTK_SCROLLED_WINDOW(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCROLLED_WINDOW, \ + GtkScrolledWindow)) +#define GTK_SEPARATOR(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEPARATOR, \ + GtkSeparator)) +#define GTK_SEPARATOR_MENU_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEPARATOR_MENU_ITEM, \ + GtkSeparatorMenuItem)) +#define GTK_SEPARATOR_TOOL_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEPARATOR_TOOL_ITEM, \ + GtkSeparatorToolItem)) +#define GTK_SETTINGS(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SETTINGS, GtkSettings)) +#define GTK_SIZE_GROUP(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SIZE_GROUP, \ + GtkSizeGroup)) +#define GTK_SOCKET(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SOCKET, GtkSocket)) +#define GTK_SPIN_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SPIN_BUTTON, \ + GtkSpinButton)) +#define GTK_STATUSBAR(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_STATUSBAR, \ + GtkStatusbar)) +#define GTK_TABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TABLE, GtkTable)) +#define GTK_TEAROFF_MENU_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEAROFF_MENU_ITEM, \ + GtkTearoffMenuItem)) +#define GTK_TEXT_BUFFER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_BUFFER, \ + GtkTextBuffer)) +#define GTK_TEXT_TAG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_TAG, GtkTextTag)) +#define GTK_TEXT_TAG_TABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_TAG_TABLE, \ + GtkTextTagTable)) +#define GTK_TEXT_VIEW(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_VIEW, GtkTextView)) +#define GTK_TOGGLE_ACTION(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOGGLE_ACTION, \ + GtkToggleAction)) +#define GTK_TOGGLE_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOGGLE_BUTTON, \ + GtkToggleButton)) +#define GTK_TOGGLE_TOOL_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOGGLE_TOOL_BUTTON, \ + GtkToggleToolButton)) +#define GTK_TOOLBAR(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOOLBAR, GtkToolbar)) +#define GTK_TOOLTIPS(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOOLTIPS, GtkTooltips)) +#define GTK_TOOL_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOOL_BUTTON, \ + GtkToolButton)) +#define GTK_TREE_DRAG_DEST(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_DRAG_DEST, \ + GtkTreeDragDest)) +#define GTK_TREE_DRAG_SOURCE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_DRAG_SOURCE, \ + GtkTreeDragSource)) +#define GTK_TREE_MODEL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_MODEL, \ + GtkTreeModel)) +#define GTK_TREE_MODEL_FILTER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_MODEL_FILTER, \ + GtkTreeModelFilter)) +#define GTK_TREE_MODEL_SORT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_MODEL_SORT, \ + GtkTreeModelSort)) +#define GTK_TREE_SELECTION(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_SELECTION, \ + GtkTreeSelection)) +#define GTK_TREE_SORTABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_SORTABLE, \ + GtkTreeSortable)) +#define GTK_TREE_STORE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_STORE, \ + GtkTreeStore)) +#define GTK_TREE_VIEW(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_VIEW, GtkTreeView)) +#define GTK_TREE_VIEW_COLUMN(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_VIEW_COLUMN, \ + GtkTreeViewColumn)) +#define GTK_UI_MANAGER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_UI_MANAGER, \ + GtkUIManager)) +#define GTK_VBOX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_VBOX, GtkVBox)) +#define GTK_VBUTTON_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_VBUTTON_BOX, \ + GtkVButtonBox)) +#define GTK_VIEWPORT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_VIEWPORT, GtkViewport)) +#define GTK_VPANED(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_VPANED, GtkVPaned)) +#define GTK_VRULER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_VRULER, GtkVRuler)) +#define GTK_VSCALE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_VSCALE, GtkVScale)) +#define GTK_VSCROLLBAR(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_VSCROLLBAR, \ + GtkVScrollbar)) +#define GTK_VSEPARATOR(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_VSEPARATOR, \ + GtkVSeparator)) +#define GTK_WINDOW(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WINDOW, GtkWindow)) +#define GTK_ABOUT_DIALOG(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_ABOUT_DIALOG, \ + GtkAboutDialog)) +#define GTK_ACCEL_GROUP(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_ACCEL_GROUP, \ + GtkAccelGroup)) +#define GTK_FILE_CHOOSER_BUTTON(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_FILE_CHOOSER_BUTTON, \ + GtkFileChooserButton)) +#define GTK_ICON_FACTORY(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_ICON_FACTORY, \ + GtkIconFactory)) +#define GTK_RC_STYLE(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_RC_STYLE, \ + GtkRcStyle)) +#define GTK_STYLE(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_STYLE, GtkStyle)) +#define GTK_TEXT_CHILD_ANCHOR(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_TEXT_CHILD_ANCHOR, \ + GtkTextChildAnchor)) +#define GTK_TEXT_MARK(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_TEXT_MARK, \ + GtkTextMark)) +#define GTK_WINDOW_GROUP(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_WINDOW_GROUP, \ + GtkWindowGroup)) +#define GTK_WIDGET(widget) \ + (G_TYPE_CHECK_INSTANCE_CAST ((widget), GTK_TYPE_WIDGET, GtkWidget)) +#define GTK_IS_ACCEL_MAP(accel_map) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((accel_map), GTK_TYPE_ACCEL_MAP)) +#define GTK_IS_MENU_TOOL_BUTTON(o) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_MENU_TOOL_BUTTON)) +#define GTK_IS_TOOL_ITEM(o) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_TOOL_ITEM)) +#define GTK_IS_ACCEL_LABEL(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ACCEL_LABEL)) +#define GTK_IS_ACCESSIBLE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ACCESSIBLE)) +#define GTK_IS_ACTION(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ACTION)) +#define GTK_IS_ACTION_GROUP(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ACTION_GROUP)) +#define GTK_IS_ADJUSTMENT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ADJUSTMENT)) +#define GTK_IS_ALIGNMENT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ALIGNMENT)) +#define GTK_IS_ARROW(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ARROW)) +#define GTK_IS_ASPECT_FRAME(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ASPECT_FRAME)) +#define GTK_IS_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BUTTON)) +#define GTK_IS_BUTTON_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BUTTON_BOX)) +#define GTK_IS_CALENDAR(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CALENDAR)) +#define GTK_IS_CELL_EDITABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_EDITABLE)) +#define GTK_IS_CELL_LAYOUT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_LAYOUT)) +#define GTK_IS_CELL_RENDERER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER)) +#define GTK_IS_CELL_RENDERER_COMBO(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_COMBO)) +#define GTK_IS_CELL_RENDERER_PIXBUF(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_PIXBUF)) +#define GTK_IS_CELL_RENDERER_PROGRESS(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_PROGRESS)) +#define GTK_IS_CELL_RENDERER_TEXT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_TEXT)) +#define GTK_IS_CELL_RENDERER_TOGGLE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_TOGGLE)) +#define GTK_IS_CELL_VIEW(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_VIEW)) +#define GTK_IS_CHECK_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CHECK_BUTTON)) +#define GTK_IS_CHECK_MENU_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CHECK_MENU_ITEM)) +#define GTK_IS_CLIPBOARD(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CLIPBOARD)) +#define GTK_IS_COLOR_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COLOR_BUTTON)) +#define GTK_IS_COLOR_SELECTION(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COLOR_SELECTION)) +#define GTK_IS_COLOR_SELECTION_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COLOR_SELECTION_DIALOG)) +#define GTK_IS_COMBO_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COMBO_BOX)) +#define GTK_IS_COMBO_BOX_ENTRY(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COMBO_BOX_ENTRY)) +#define GTK_IS_CONTAINER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CONTAINER)) +#define GTK_IS_CURVE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CURVE)) +#define GTK_IS_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_DIALOG)) +#define GTK_IS_DRAWING_AREA(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_DRAWING_AREA)) +#define GTK_IS_EDITABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_EDITABLE)) +#define GTK_IS_ENTRY(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ENTRY)) +#define GTK_IS_ENTRY_COMPLETION(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ENTRY_COMPLETION)) +#define GTK_IS_EVENT_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_EVENT_BOX)) +#define GTK_IS_EXPANDER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_EXPANDER)) +#define GTK_IS_FILE_CHOOSER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_CHOOSER)) +#define GTK_IS_FILE_CHOOSER_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_CHOOSER_DIALOG)) +#define GTK_IS_FILE_CHOOSER_WIDGET(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_CHOOSER_WIDGET)) +#define GTK_IS_FILE_FILTER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_FILTER)) +#define GTK_IS_FILE_SELECTION(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_SELECTION)) +#define GTK_IS_FIXED(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FIXED)) +#define GTK_IS_FONT_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FONT_BUTTON)) +#define GTK_IS_FONT_SELECTION(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FONT_SELECTION)) +#define GTK_IS_FONT_SELECTION_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FONT_SELECTION_DIALOG)) +#define GTK_IS_FRAME(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FRAME)) +#define GTK_IS_GAMMA_CURVE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_GAMMA_CURVE)) +#define GTK_IS_HANDLE_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_HANDLE_BOX)) +#define GTK_IS_HBOX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_HBOX)) +#define GTK_IS_HBUTTON_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_HBUTTON_BOX)) +#define GTK_IS_HPANED(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_HPANED)) +#define GTK_IS_HRULER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_HRULER)) +#define GTK_IS_HSCALE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_HSCALE)) +#define GTK_IS_HSCROLLBAR(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_HSCROLLBAR)) +#define GTK_IS_HSEPARATOR(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_HSEPARATOR)) +#define GTK_IS_ICON_THEME(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ICON_THEME)) +#define GTK_IS_IMAGE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IMAGE)) +#define GTK_IS_IMAGE_MENU_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IMAGE_MENU_ITEM)) +#define GTK_IS_IM_CONTEXT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IM_CONTEXT)) +#define GTK_IS_IM_CONTEXT_SIMPLE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IM_CONTEXT_SIMPLE)) +#define GTK_IS_IM_MULTICONTEXT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IM_MULTICONTEXT)) +#define GTK_IS_INPUT_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_INPUT_DIALOG)) +#define GTK_IS_INVISIBLE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_INVISIBLE)) +#define GTK_IS_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ITEM)) +#define GTK_IS_LABEL(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LABEL)) +#define GTK_IS_LAYOUT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LAYOUT)) +#define GTK_IS_LIST_STORE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LIST_STORE)) +#define GTK_IS_MENU(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU)) +#define GTK_IS_MENU_BAR(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_BAR)) +#define GTK_IS_MENU_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_ITEM)) +#define GTK_IS_MENU_SHELL(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_SHELL)) +#define GTK_IS_MESSAGE_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MESSAGE_DIALOG)) +#define GTK_IS_MISC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MISC)) +#define GTK_IS_NOTEBOOK(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_NOTEBOOK)) +#define GTK_IS_PANED(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PANED)) +#define GTK_IS_PLUG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PLUG)) +#define GTK_IS_PROGRESS_BAR(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PROGRESS_BAR)) +#define GTK_IS_RADIO_ACTION(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_ACTION)) +#define GTK_IS_RADIO_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_BUTTON)) +#define GTK_IS_RADIO_MENU_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_MENU_ITEM)) +#define GTK_IS_RADIO_TOOL_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_TOOL_BUTTON)) +#define GTK_IS_RANGE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RANGE)) +#define GTK_IS_RULER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RULER)) +#define GTK_IS_SCALE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCALE)) +#define GTK_IS_SCROLLBAR(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCROLLBAR)) +#define GTK_IS_SCROLLED_WINDOW(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCROLLED_WINDOW)) +#define GTK_IS_SEPARATOR(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEPARATOR)) +#define GTK_IS_SEPARATOR_MENU_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEPARATOR_MENU_ITEM)) +#define GTK_IS_SEPARATOR_TOOL_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEPARATOR_TOOL_ITEM)) +#define GTK_IS_SETTINGS(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SETTINGS)) +#define GTK_IS_SIZE_GROUP(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SIZE_GROUP)) +#define GTK_IS_SOCKET(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SOCKET)) +#define GTK_IS_SPIN_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SPIN_BUTTON)) +#define GTK_IS_STATUSBAR(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_STATUSBAR)) +#define GTK_IS_TABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TABLE)) +#define GTK_IS_TEAROFF_MENU_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEAROFF_MENU_ITEM)) +#define GTK_IS_TEXT_BUFFER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_BUFFER)) +#define GTK_IS_TEXT_TAG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_TAG)) +#define GTK_IS_TEXT_TAG_TABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_TAG_TABLE)) +#define GTK_IS_TEXT_VIEW(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_VIEW)) +#define GTK_IS_TOGGLE_ACTION(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOGGLE_ACTION)) +#define GTK_IS_TOGGLE_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOGGLE_BUTTON)) +#define GTK_IS_TOGGLE_TOOL_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOGGLE_TOOL_BUTTON)) +#define GTK_IS_TOOLBAR(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOOLBAR)) +#define GTK_IS_TOOLTIPS(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOOLTIPS)) +#define GTK_IS_TOOL_BUTTON(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOOL_BUTTON)) +#define GTK_IS_TREE_DRAG_DEST(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_DRAG_DEST)) +#define GTK_IS_TREE_DRAG_SOURCE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_DRAG_SOURCE)) +#define GTK_IS_TREE_MODEL(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_MODEL)) +#define GTK_IS_TREE_MODEL_FILTER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_MODEL_FILTER)) +#define GTK_IS_TREE_MODEL_SORT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_MODEL_SORT)) +#define GTK_IS_TREE_SELECTION(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_SELECTION)) +#define GTK_IS_TREE_SORTABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_SORTABLE)) +#define GTK_IS_TREE_STORE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_STORE)) +#define GTK_IS_TREE_VIEW(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_VIEW)) +#define GTK_IS_TREE_VIEW_COLUMN(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_VIEW_COLUMN)) +#define GTK_IS_UI_MANAGER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_UI_MANAGER)) +#define GTK_IS_VBOX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_VBOX)) +#define GTK_IS_VBUTTON_BOX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_VBUTTON_BOX)) +#define GTK_IS_VIEWPORT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_VIEWPORT)) +#define GTK_IS_VPANED(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_VPANED)) +#define GTK_IS_VRULER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_VRULER)) +#define GTK_IS_VSCALE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_VSCALE)) +#define GTK_IS_VSCROLLBAR(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_VSCROLLBAR)) +#define GTK_IS_VSEPARATOR(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_VSEPARATOR)) +#define GTK_IS_WINDOW(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WINDOW)) +#define GTK_IS_ABOUT_DIALOG(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_ABOUT_DIALOG)) +#define GTK_IS_ACCEL_GROUP(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_ACCEL_GROUP)) +#define GTK_IS_FILE_CHOOSER_BUTTON(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_FILE_CHOOSER_BUTTON)) +#define GTK_IS_ICON_FACTORY(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_ICON_FACTORY)) +#define GTK_IS_RC_STYLE(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_RC_STYLE)) +#define GTK_IS_STYLE(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_STYLE)) +#define GTK_IS_TEXT_CHILD_ANCHOR(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_TEXT_CHILD_ANCHOR)) +#define GTK_IS_TEXT_MARK(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_TEXT_MARK)) +#define GTK_IS_WINDOW_GROUP(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_WINDOW_GROUP)) +#define GTK_IS_WIDGET(widget) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((widget), GTK_TYPE_WIDGET)) +#define GTK_ACTION_GROUP_GET_CLASS(inst) \ + (G_TYPE_INSTANCE_GET_CLASS ((inst), GTK_TYPE_ACTION_GROUP, \ + GtkActionGroupClass)) +#define GTK_CELL_VIEW_GET_CLASS(inst) \ + (G_TYPE_INSTANCE_GET_CLASS ((inst), GTK_TYPE_CELL_VIEW, \ + GtkCellViewClass)) +#define GTK_COMBO_BOX_GET_CLASS(inst) \ + (G_TYPE_INSTANCE_GET_CLASS ((inst), GTK_TYPE_COMBO_BOX, \ + GtkComboBoxClass)) +#define GTK_COMBO_BOX_ENTRY_GET_CLASS(inst) \ + (G_TYPE_INSTANCE_GET_CLASS ((inst), GTK_TYPE_COMBO_BOX_ENTRY, \ + GtkComboBoxEntryClass)) +#define GTK_MENU_TOOL_BUTTON_GET_CLASS(o) \ + (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_MENU_TOOL_BUTTON, \ + GtkMenuToolButtonClass)) +#define GTK_ABOUT_DIALOG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ABOUT_DIALOG, \ + GtkAboutDialogClass)) +#define GTK_ACCEL_GROUP_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACCEL_GROUP, \ + GtkAccelGroupClass)) +#define GTK_ACCEL_LABEL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACCEL_LABEL, \ + GtkAccelLabelClass)) +#define GTK_ACCEL_MAP_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACCEL_MAP, \ + GtkAccelMapClass)) +#define GTK_ACCESSIBLE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACCESSIBLE, \ + GtkAccessibleClass)) +#define GTK_ADJUSTMENT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ADJUSTMENT, \ + GtkAdjustmentClass)) +#define GTK_ALIGNMENT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ALIGNMENT, \ + GtkAlignmentClass)) +#define GTK_ARROW_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ARROW, GtkArrowClass)) +#define GTK_ASPECT_FRAME_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ASPECT_FRAME, \ + GtkAspectFrameClass)) +#define GTK_BIN_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BIN, GtkBinClass)) +#define GTK_BOX_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BOX, GtkBoxClass)) +#define GTK_BUTTON_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BUTTON, GtkButtonClass)) +#define GTK_BUTTON_BOX_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BUTTON_BOX, \ + GtkButtonBoxClass)) +#define GTK_CALENDAR_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CALENDAR, \ + GtkCalendarClass)) +#define GTK_CELL_RENDERER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER, \ + GtkCellRendererClass)) +#define GTK_CELL_RENDERER_COMBO_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_COMBO, \ + GtkCellRendererTextClass)) +#define GTK_CELL_RENDERER_PIXBUF_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_PIXBUF, \ + GtkCellRendererPixbufClass)) +#define GTK_CELL_RENDERER_PROGRESS_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_PROGRESS, \ + GtkCellRendererProgressClass)) +#define GTK_CELL_RENDERER_TEXT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_TEXT, \ + GtkCellRendererTextClass)) +#define GTK_CELL_RENDERER_TOGGLE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_TOGGLE, \ + GtkCellRendererToggleClass)) +#define GTK_CHECK_BUTTON_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CHECK_BUTTON, \ + GtkCheckButtonClass)) +#define GTK_CHECK_MENU_ITEM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CHECK_MENU_ITEM, \ + GtkCheckMenuItemClass)) +#define GTK_COLOR_BUTTON_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_COLOR_BUTTON, \ + GtkColorButtonClass)) +#define GTK_COLOR_SELECTION_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_COLOR_SELECTION, \ + GtkColorSelectionClass)) +#define GTK_COLOR_SELECTION_DIALOG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_COLOR_SELECTION_DIALOG, \ + GtkColorSelectionDialogClass)) +#define GTK_CONTAINER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CONTAINER, \ + GtkContainerClass)) +#define GTK_CURVE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CURVE, GtkCurveClass)) +#define GTK_DIALOG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_DIALOG, GtkDialogClass)) +#define GTK_DRAWING_AREA_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_DRAWING_AREA, \ + GtkDrawingAreaClass)) +#define GTK_ENTRY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ENTRY, GtkEntryClass)) +#define GTK_ENTRY_COMPLETION_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ENTRY_COMPLETION, \ + GtkEntryCompletionClass)) +#define GTK_EVENT_BOX_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_EVENT_BOX, \ + GtkEventBoxClass)) +#define GTK_EXPANDER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_EXPANDER, \ + GtkExpanderClass)) +#define GTK_FILE_CHOOSER_DIALOG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_CHOOSER_DIALOG, \ + GtkFileChooserDialogClass)) +#define GTK_FILE_CHOOSER_WIDGET_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_CHOOSER_WIDGET, \ + GtkFileChooserWidgetClass)) +#define GTK_FILE_SELECTION_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_SELECTION, \ + GtkFileSelectionClass)) +#define GTK_FIXED_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FIXED, GtkFixedClass)) +#define GTK_FONT_BUTTON_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FONT_BUTTON, \ + GtkFontButtonClass)) +#define GTK_FONT_SELECTION_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FONT_SELECTION, \ + GtkFontSelectionClass)) +#define GTK_FONT_SELECTION_DIALOG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FONT_SELECTION_DIALOG, \ + GtkFontSelectionDialogClass)) +#define GTK_FRAME_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FRAME, GtkFrameClass)) +#define GTK_GAMMA_CURVE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_GAMMA_CURVE, \ + GtkGammaCurveClass)) +#define GTK_HANDLE_BOX_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HANDLE_BOX, \ + GtkHandleBoxClass)) +#define GTK_HBOX_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HBOX, GtkHBoxClass)) +#define GTK_HBUTTON_BOX_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HBUTTON_BOX, \ + GtkHButtonBoxClass)) +#define GTK_HPANED_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HPANED, GtkHPanedClass)) +#define GTK_HRULER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HRULER, GtkHRulerClass)) +#define GTK_HSCALE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HSCALE, GtkHScaleClass)) +#define GTK_HSCROLLBAR_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HSCROLLBAR, \ + GtkHScrollbarClass)) +#define GTK_HSEPARATOR_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HSEPARATOR, \ + GtkHSeparatorClass)) +#define GTK_ICON_FACTORY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ICON_FACTORY, \ + GtkIconFactoryClass)) +#define GTK_ICON_THEME_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ICON_THEME, \ + GtkIconThemeClass)) +#define GTK_IMAGE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IMAGE, GtkImageClass)) +#define GTK_IMAGE_MENU_ITEM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IMAGE_MENU_ITEM, \ + GtkImageMenuItemClass)) +#define GTK_IM_CONTEXT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IM_CONTEXT, \ + GtkIMContextClass)) +#define GTK_IM_CONTEXT_SIMPLE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IM_CONTEXT_SIMPLE, \ + GtkIMContextSimpleClass)) +#define GTK_IM_MULTICONTEXT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IM_MULTICONTEXT, \ + GtkIMMulticontextClass)) +#define GTK_INPUT_DIALOG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_INPUT_DIALOG, \ + GtkInputDialogClass)) +#define GTK_INVISIBLE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_INVISIBLE, \ + GtkInvisibleClass)) +#define GTK_ITEM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ITEM, GtkItemClass)) +#define GTK_LABEL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LABEL, GtkLabelClass)) +#define GTK_LAYOUT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LAYOUT, GtkLayoutClass)) +#define GTK_LIST_STORE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LIST_STORE, \ + GtkListStoreClass)) +#define GTK_MENU_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU, GtkMenuClass)) +#define GTK_MENU_BAR_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU_BAR, \ + GtkMenuBarClass)) +#define GTK_MENU_ITEM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU_ITEM, \ + GtkMenuItemClass)) +#define GTK_MENU_SHELL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU_SHELL, \ + GtkMenuShellClass)) +#define GTK_MESSAGE_DIALOG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MESSAGE_DIALOG, \ + GtkMessageDialogClass)) +#define GTK_MISC_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MISC, GtkMiscClass)) +#define GTK_NOTEBOOK_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_NOTEBOOK, \ + GtkNotebookClass)) +#define GTK_PANED_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PANED, GtkPanedClass)) +#define GTK_PLUG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PLUG, GtkPlugClass)) +#define GTK_PROGRESS_BAR_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PROGRESS_BAR, \ + GtkProgressBarClass)) +#define GTK_RADIO_BUTTON_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RADIO_BUTTON, \ + GtkRadioButtonClass)) +#define GTK_RADIO_MENU_ITEM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RADIO_MENU_ITEM, \ + GtkRadioMenuItemClass)) +#define GTK_RANGE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RANGE, GtkRangeClass)) +#define GTK_RC_STYLE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RC_STYLE, \ + GtkRcStyleClass)) +#define GTK_RULER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RULER, GtkRulerClass)) +#define GTK_SCALE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCALE, GtkScaleClass)) +#define GTK_SCROLLBAR_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCROLLBAR, \ + GtkScrollbarClass)) +#define GTK_SCROLLED_WINDOW_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCROLLED_WINDOW, \ + GtkScrolledWindowClass)) +#define GTK_SEPARATOR_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEPARATOR, \ + GtkSeparatorClass)) +#define GTK_SEPARATOR_MENU_ITEM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEPARATOR_MENU_ITEM, \ + GtkSeparatorMenuItemClass)) +#define GTK_SETTINGS_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SETTINGS, \ + GtkSettingsClass)) +#define GTK_SIZE_GROUP_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SIZE_GROUP, \ + GtkSizeGroupClass)) +#define GTK_SOCKET_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SOCKET, GtkSocketClass)) +#define GTK_SPIN_BUTTON_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SPIN_BUTTON, \ + GtkSpinButtonClass)) +#define GTK_STATUSBAR_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STATUSBAR, \ + GtkStatusbarClass)) +#define GTK_STYLE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STYLE, GtkStyleClass)) +#define GTK_TABLE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TABLE, GtkTableClass)) +#define GTK_TEAROFF_MENU_ITEM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEAROFF_MENU_ITEM, \ + GtkTearoffMenuItemClass)) +#define GTK_TEXT_BUFFER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_BUFFER, \ + GtkTextBufferClass)) +#define GTK_TEXT_CHILD_ANCHOR_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_CHILD_ANCHOR, \ + GtkTextChildAnchorClass)) +#define GTK_TEXT_MARK_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_MARK, \ + GtkTextMarkClass)) +#define GTK_TEXT_TAG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_TAG, \ + GtkTextTagClass)) +#define GTK_TEXT_TAG_TABLE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_TAG_TABLE, \ + GtkTextTagTableClass)) +#define GTK_TEXT_VIEW_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_VIEW, \ + GtkTextViewClass)) +#define GTK_TOGGLE_BUTTON_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TOGGLE_BUTTON, \ + GtkToggleButtonClass)) +#define GTK_TOOLBAR_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TOOLBAR, \ + GtkToolbarClass)) +#define GTK_TOOLTIPS_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TOOLTIPS, \ + GtkTooltipsClass)) +#define GTK_TREE_MODEL_FILTER_GET_CLASS(inst) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_MODEL_FILTER, \ + GtkTreeModelFilterClass)) +#define GTK_TREE_MODEL_SORT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_MODEL_SORT, \ + GtkTreeModelSortClass)) +#define GTK_TREE_SELECTION_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_SELECTION, \ + GtkTreeSelectionClass)) +#define GTK_TREE_STORE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_STORE, \ + GtkTreeStoreClass)) +#define GTK_TREE_VIEW_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_VIEW, \ + GtkTreeViewClass)) +#define GTK_TREE_VIEW_COLUMN_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_VIEW_COLUMN, \ + GtkTreeViewColumnClass)) +#define GTK_VBOX_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_VBOX, GtkVBoxClass)) +#define GTK_VBUTTON_BOX_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_VBUTTON_BOX, \ + GtkVButtonBoxClass)) +#define GTK_VIEWPORT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_VIEWPORT, \ + GtkViewportClass)) +#define GTK_VPANED_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_VPANED, GtkVPanedClass)) +#define GTK_VRULER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_VRULER, GtkVRulerClass)) +#define GTK_VSCALE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_VSCALE, GtkVScaleClass)) +#define GTK_VSCROLLBAR_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_VSCROLLBAR, \ + GtkVScrollbarClass)) +#define GTK_VSEPARATOR_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_VSEPARATOR, \ + GtkVSeparatorClass)) +#define GTK_WIDGET_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WIDGET, GtkWidgetClass)) +#define GTK_WINDOW_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WINDOW, GtkWindowClass)) +#define GTK_WINDOW_GROUP_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WINDOW_GROUP, \ + GtkWindowGroupClass)) +#define GTK_FILE_CHOOSER_BUTTON_GET_CLASS(object) \ + (G_TYPE_INSTANCE_GET_CLASS ((object), GTK_TYPE_FILE_CHOOSER_BUTTON, \ + GtkFileChooserButtonClass)) +#define GTK_TOOL_ITEM_GET_CLASS(o) \ + (G_TYPE_INSTANCE_GET_CLASS((o), GTK_TYPE_TOOL_ITEM, \ + GtkToolItemClass)) +#define GTK_ACTION_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_ACTION, GtkActionClass)) +#define GTK_RADIO_ACTION_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_RADIO_ACTION, \ + GtkRadioActionClass)) +#define GTK_RADIO_TOOL_BUTTON_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_RADIO_TOOL_BUTTON, \ + GtkRadioToolButtonClass)) +#define GTK_SEPARATOR_TOOL_ITEM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_SEPARATOR_TOOL_ITEM, \ + GtkSeparatorToolItemClass)) +#define GTK_TOGGLE_ACTION_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_TOGGLE_ACTION, \ + GtkToggleActionClass)) +#define GTK_TOGGLE_TOOL_BUTTON_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_TOGGLE_TOOL_BUTTON, \ + GtkToggleToolButtonClass)) +#define GTK_TOOL_BUTTON_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_TOOL_BUTTON, \ + GtkToolButtonClass)) +#define GTK_UI_MANAGER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_UI_MANAGER, \ + GtkUIManagerClass)) +#define GTK_EDITABLE_GET_CLASS(inst) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GTK_TYPE_EDITABLE, \ + GtkEditableClass)) +#define GTK_CELL_EDITABLE_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_CELL_EDITABLE, \ + GtkCellEditableIface)) +#define GTK_CELL_LAYOUT_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_CELL_LAYOUT, \ + GtkCellLayoutIface)) +#define GTK_TREE_DRAG_DEST_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_TREE_DRAG_DEST, \ + GtkTreeDragDestIface)) +#define GTK_TREE_DRAG_SOURCE_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_TREE_DRAG_SOURCE, \ + GtkTreeDragSourceIface)) +#define GTK_TREE_MODEL_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_TREE_MODEL, \ + GtkTreeModelIface)) +#define GTK_TREE_SORTABLE_GET_IFACE(obj) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_TREE_SORTABLE, \ + GtkTreeSortableIface)) +#define GTK_OBJECT_TYPE_NAME(object) \ + (g_type_name (GTK_OBJECT_TYPE (object))) +#define GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID(object,property_id,pspec) \ + G_OBJECT_WARN_INVALID_PSPEC ((object), "child property id", \ + (property_id), (pspec)) +#define GTK_OBJECT_UNSET_FLAGS(obj,flag) \ + G_STMT_START{ (GTK_OBJECT_FLAGS (obj) &= ~(flag)); }G_STMT_END +#define GTK_OBJECT_SET_FLAGS(obj,flag) \ + G_STMT_START{ (GTK_OBJECT_FLAGS (obj) |= (flag)); }G_STMT_END +#define GTK_WIDGET_UNSET_FLAGS(wid,flag) \ + G_STMT_START{ (GTK_WIDGET_FLAGS (wid) &= ~(flag)); }G_STMT_END +#define GTK_WIDGET_SET_FLAGS(wid,flag) \ + G_STMT_START{ (GTK_WIDGET_FLAGS (wid) |= (flag)); }G_STMT_END +#define GTK_SIGNAL_FUNC(f) ((GtkSignalFunc) (f)) +#define GTK_INTERFACE_AGE (10) +#define GTK_MICRO_VERSION (10) +#define GTK_MAJOR_VERSION (2) +#define GTK_MINOR_VERSION (6) +#define GTK_BINARY_AGE (610) +#define GTK_TEXT_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5) +#define GTK_TYPE_ABOUT_DIALOG (gtk_about_dialog_get_type ()) +#define GTK_TYPE_ACCEL_FLAGS (gtk_accel_flags_get_type()) +#define GTK_TYPE_ACCEL_GROUP (gtk_accel_group_get_type ()) +#define GTK_TYPE_ACCEL_LABEL (gtk_accel_label_get_type ()) +#define GTK_TYPE_ACCEL_MAP (gtk_accel_map_get_type ()) +#define GTK_TYPE_ACCESSIBLE (gtk_accessible_get_type ()) +#define GTK_TYPE_ACTION (gtk_action_get_type ()) +#define GTK_TYPE_ACTION_GROUP (gtk_action_group_get_type ()) +#define GTK_TYPE_ADJUSTMENT (gtk_adjustment_get_type ()) +#define GTK_TYPE_ALIGNMENT (gtk_alignment_get_type ()) +#define GTK_TYPE_ANCHOR_TYPE (gtk_anchor_type_get_type()) +#define GTK_TYPE_ARG_FLAGS (gtk_arg_flags_get_type()) +#define GTK_ARG_READWRITE (GTK_ARG_READABLE | GTK_ARG_WRITABLE) +#define GTK_TYPE_ARROW (gtk_arrow_get_type ()) +#define GTK_TYPE_ARROW_TYPE (gtk_arrow_type_get_type()) +#define GTK_TYPE_ASPECT_FRAME (gtk_aspect_frame_get_type ()) +#define GTK_TYPE_ATTACH_OPTIONS (gtk_attach_options_get_type()) +#define GTK_TYPE_BIN (gtk_bin_get_type ()) +#define GTK_TYPE_BORDER (gtk_border_get_type ()) +#define GTK_TYPE_BOX (gtk_box_get_type ()) +#define GTK_TYPE_BUTTONS_TYPE (gtk_buttons_type_get_type()) +#define GTK_TYPE_BUTTON_BOX (gtk_button_box_get_type ()) +#define GTK_TYPE_BUTTON_BOX_STYLE (gtk_button_box_style_get_type()) +#define GTK_TYPE_BUTTON (gtk_button_get_type ()) +#define GTK_TYPE_CALENDAR (gtk_calendar_get_type ()) +#define GTK_TYPE_CELL_EDITABLE (gtk_cell_editable_get_type ()) +#define GTK_TYPE_CELL_LAYOUT (gtk_cell_layout_get_type ()) +#define GTK_TYPE_CELL_RENDERER_COMBO (gtk_cell_renderer_combo_get_type ()) +#define GTK_TYPE_CELL_RENDERER (gtk_cell_renderer_get_type ()) +#define GTK_TYPE_CELL_RENDERER_MODE (gtk_cell_renderer_mode_get_type()) +#define GTK_TYPE_CELL_RENDERER_STATE (gtk_cell_renderer_state_get_type()) +#define GTK_TYPE_CELL_RENDERER_TEXT (gtk_cell_renderer_text_get_type ()) +#define GTK_TYPE_CELL_VIEW (gtk_cell_view_get_type ()) +#define GTK_TYPE_CHECK_BUTTON (gtk_check_button_get_type ()) +#define GTK_LIST(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_LIST, GtkList)) +#define GTK_TYPE_CHECK_MENU_ITEM (gtk_check_menu_item_get_type ()) +#define GTK_IS_ICON_VIEW(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_ICON_VIEW)) +#define GTK_IS_LIST(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_LIST)) +#define GTK_IS_OBJECT(object) (GTK_CHECK_TYPE ((object), GTK_TYPE_OBJECT)) +#define GTK_TYPE_CLIPBOARD (gtk_clipboard_get_type ()) +#define GTK_TYPE_COLOR_BUTTON (gtk_color_button_get_type ()) +#define GTK_TYPE_COLOR_SELECTION (gtk_color_selection_get_type ()) +#define GTK_TYPE_COMBO_BOX_ENTRY (gtk_combo_box_entry_get_type ()) +#define GTK_TYPE_COMBO_BOX (gtk_combo_box_get_type ()) +#define GTK_TYPE_CONTAINER (gtk_container_get_type ()) +#define GTK_TYPE_CORNER_TYPE (gtk_corner_type_get_type()) +#define GTK_TYPE_CURVE (gtk_curve_get_type ()) +#define GTK_TYPE_CURVE_TYPE (gtk_curve_type_get_type()) +#define GTK_TYPE_DEBUG_FLAG (gtk_debug_flag_get_type()) +#define GTK_TYPE_DELETE_TYPE (gtk_delete_type_get_type()) +#define GTK_TYPE_DEST_DEFAULTS (gtk_dest_defaults_get_type()) +#define GTK_TYPE_DIALOG_FLAGS (gtk_dialog_flags_get_type()) +#define GTK_TYPE_DIALOG (gtk_dialog_get_type ()) +#define GTK_TYPE_DIRECTION_TYPE (gtk_direction_type_get_type()) +#define GTK_TYPE_DRAWING_AREA (gtk_drawing_area_get_type ()) +#define GTK_TYPE_EDITABLE (gtk_editable_get_type ()) +#define GTK_TYPE_ENTRY_COMPLETION (gtk_entry_completion_get_type ()) +#define GTK_TYPE_ENTRY (gtk_entry_get_type ()) +#define GTK_TYPE_EVENT_BOX (gtk_event_box_get_type ()) +#define GTK_TYPE_EXPANDER (gtk_expander_get_type ()) +#define GTK_TYPE_EXPANDER_STYLE (gtk_expander_style_get_type()) +#define GTK_TYPE_FILE_CHOOSER_ACTION (gtk_file_chooser_action_get_type()) +#define GTK_TYPE_FILE_CHOOSER_BUTTON (gtk_file_chooser_button_get_type ()) +#define GTK_TYPE_FILE_CHOOSER_DIALOG (gtk_file_chooser_dialog_get_type ()) +#define GTK_TYPE_FILE_CHOOSER_ERROR (gtk_file_chooser_error_get_type()) +#define GTK_FILE_CHOOSER_ERROR (gtk_file_chooser_error_quark ()) +#define GTK_TYPE_FILE_CHOOSER (gtk_file_chooser_get_type ()) +#define GTK_TYPE_FILE_CHOOSER_WIDGET (gtk_file_chooser_widget_get_type ()) +#define GTK_TYPE_FILE_FILTER_FLAGS (gtk_file_filter_flags_get_type()) +#define GTK_TYPE_FILE_FILTER (gtk_file_filter_get_type ()) +#define GTK_TYPE_FILE_SELECTION (gtk_file_selection_get_type ()) +#define GTK_TYPE_FIXED (gtk_fixed_get_type ()) +#define GTK_TYPE_FONT_BUTTON (gtk_font_button_get_type ()) +#define GTK_TYPE_FONT_SELECTION (gtk_font_selection_get_type ()) +#define GTK_TYPE_FRAME (gtk_frame_get_type ()) +#define GTK_TYPE_GAMMA_CURVE (gtk_gamma_curve_get_type ()) +#define GTK_TYPE_HANDLE_BOX (gtk_handle_box_get_type ()) +#define GTK_TYPE_HBOX (gtk_hbox_get_type ()) +#define GTK_TYPE_HBUTTON_BOX (gtk_hbutton_box_get_type ()) +#define GTK_TYPE_HPANED (gtk_hpaned_get_type ()) +#define GTK_TYPE_HRULER (gtk_hruler_get_type ()) +#define GTK_TYPE_HSCALE (gtk_hscale_get_type ()) +#define GTK_TYPE_HSCROLLBAR (gtk_hscrollbar_get_type ()) +#define GTK_TYPE_HSEPARATOR (gtk_hseparator_get_type ()) +#define GTK_TYPE_ICON_FACTORY (gtk_icon_factory_get_type ()) +#define GTK_TYPE_ICON_INFO (gtk_icon_info_get_type ()) +#define GTK_TYPE_ICON_LOOKUP_FLAGS (gtk_icon_lookup_flags_get_type()) +#define GTK_TYPE_ICON_SET (gtk_icon_set_get_type ()) +#define GTK_TYPE_ICON_SIZE (gtk_icon_size_get_type()) +#define GTK_TYPE_ICON_SOURCE (gtk_icon_source_get_type ()) +#define GTK_TYPE_ICON_THEME_ERROR (gtk_icon_theme_error_get_type()) +#define GTK_TYPE_ICON_THEME (gtk_icon_theme_get_type ()) +#define GTK_TYPE_ICON_VIEW (gtk_icon_view_get_type ()) +#define GTK_TYPE_IDENTIFIER (gtk_identifier_get_type ()) +#define GTK_TYPE_IMAGE (gtk_image_get_type ()) +#define GTK_TYPE_IMAGE_MENU_ITEM (gtk_image_menu_item_get_type ()) +#define GTK_TYPE_IMAGE_TYPE (gtk_image_type_get_type()) +#define GTK_TYPE_IM_CONTEXT (gtk_im_context_get_type ()) +#define GTK_TYPE_IM_CONTEXT_SIMPLE (gtk_im_context_simple_get_type ()) +#define GTK_TYPE_IM_MULTICONTEXT (gtk_im_multicontext_get_type ()) +#define GTK_TYPE_IM_PREEDIT_STYLE (gtk_im_preedit_style_get_type()) +#define GTK_TYPE_IM_STATUS_STYLE (gtk_im_status_style_get_type()) +#define GTK_TYPE_INPUT_DIALOG (gtk_input_dialog_get_type ()) +#define GTK_TYPE_INVISIBLE (gtk_invisible_get_type ()) +#define GTK_TYPE_ITEM (gtk_item_get_type ()) +#define GTK_TYPE_JUSTIFICATION (gtk_justification_get_type()) +#define GTK_TYPE_LABEL (gtk_label_get_type ()) +#define GTK_TYPE_LAYOUT (gtk_layout_get_type ()) +#define GTK_TYPE_LIST (gtk_list_get_type ()) +#define GTK_TYPE_LIST_STORE (gtk_list_store_get_type ()) +#define GTK_TYPE_MATCH_TYPE (gtk_match_type_get_type()) +#define GTK_TYPE_MENU_BAR (gtk_menu_bar_get_type ()) +#define GTK_TYPE_MENU_DIRECTION_TYPE (gtk_menu_direction_type_get_type()) +#define GTK_TYPE_MENU (gtk_menu_get_type ()) +#define GTK_TYPE_MENU_ITEM (gtk_menu_item_get_type ()) +#define GTK_TYPE_MENU_SHELL (gtk_menu_shell_get_type ()) +#define GTK_TYPE_MENU_TOOL_BUTTON (gtk_menu_tool_button_get_type ()) +#define GTK_TYPE_MESSAGE_DIALOG (gtk_message_dialog_get_type ()) +#define GTK_TYPE_MESSAGE_TYPE (gtk_message_type_get_type()) +#define GTK_TYPE_METRIC_TYPE (gtk_metric_type_get_type()) +#define GTK_TYPE_MISC (gtk_misc_get_type ()) +#define GTK_TYPE_MOVEMENT_STEP (gtk_movement_step_get_type()) +#define GTK_TYPE_NOTEBOOK (gtk_notebook_get_type ()) +#define GTK_TYPE_NOTEBOOK_TAB (gtk_notebook_tab_get_type()) +#define GTK_OBJECT_FLAGS(obj) (GTK_OBJECT (obj)->flags) +#define GTK_WIDGET_FLAGS(wid) (GTK_OBJECT_FLAGS (wid)) +#define GTK_TYPE_OBJECT_FLAGS (gtk_object_flags_get_type()) +#define GTK_TYPE_OBJECT (gtk_object_get_type ()) +#define GTK_WIDGET_TYPE(wid) (GTK_OBJECT_TYPE (wid)) +#define GTK_TYPE_ORIENTATION (gtk_orientation_get_type()) +#define GTK_TYPE_PACK_TYPE (gtk_pack_type_get_type()) +#define GTK_TYPE_PANED (gtk_paned_get_type ()) +#define GTK_TYPE_PATH_PRIORITY_TYPE (gtk_path_priority_type_get_type()) +#define GTK_TYPE_PATH_TYPE (gtk_path_type_get_type()) +#define GTK_TYPE_PLUG (gtk_plug_get_type ()) +#define GTK_TYPE_POLICY_TYPE (gtk_policy_type_get_type()) +#define GTK_TYPE_POSITION_TYPE (gtk_position_type_get_type()) +#define GTK_TYPE_PROGRESS_BAR (gtk_progress_bar_get_type ()) +#define GTK_TYPE_PROGRESS_BAR_STYLE (gtk_progress_bar_style_get_type()) +#define GTK_TYPE_RADIO_ACTION (gtk_radio_action_get_type ()) +#define GTK_TYPE_RADIO_BUTTON (gtk_radio_button_get_type ()) +#define GTK_TYPE_RADIO_MENU_ITEM (gtk_radio_menu_item_get_type ()) +#define GTK_TYPE_RADIO_TOOL_BUTTON (gtk_radio_tool_button_get_type ()) +#define GTK_TYPE_RANGE (gtk_range_get_type ()) +#define GTK_TYPE_RC_FLAGS (gtk_rc_flags_get_type()) +#define GTK_TYPE_RC_STYLE (gtk_rc_style_get_type ()) +#define GTK_TYPE_RC_TOKEN_TYPE (gtk_rc_token_type_get_type()) +#define GTK_TYPE_RELIEF_STYLE (gtk_relief_style_get_type()) +#define GTK_TYPE_REQUISITION (gtk_requisition_get_type ()) +#define GTK_TYPE_RESIZE_MODE (gtk_resize_mode_get_type()) +#define GTK_TYPE_RESPONSE_TYPE (gtk_response_type_get_type()) +#define GTK_TYPE_RULER (gtk_ruler_get_type ()) +#define GTK_TYPE_SCALE (gtk_scale_get_type ()) +#define GTK_TYPE_SCROLLBAR (gtk_scrollbar_get_type ()) +#define GTK_TYPE_SCROLLED_WINDOW (gtk_scrolled_window_get_type ()) +#define GTK_TYPE_SCROLL_STEP (gtk_scroll_step_get_type()) +#define GTK_TYPE_SCROLL_TYPE (gtk_scroll_type_get_type()) +#define GTK_TYPE_SELECTION_DATA (gtk_selection_data_get_type ()) +#define GTK_TYPE_SELECTION_MODE (gtk_selection_mode_get_type()) +#define GTK_TYPE_SEPARATOR (gtk_separator_get_type ()) +#define GTK_TYPE_SEPARATOR_MENU_ITEM (gtk_separator_menu_item_get_type ()) +#define GTK_TYPE_SEPARATOR_TOOL_ITEM (gtk_separator_tool_item_get_type ()) +#define GTK_TYPE_SETTINGS (gtk_settings_get_type ()) +#define GTK_TYPE_SHADOW_TYPE (gtk_shadow_type_get_type()) +#define GTK_TYPE_SIDE_TYPE (gtk_side_type_get_type()) +#define GTK_TYPE_SIGNAL_RUN_TYPE (gtk_signal_run_type_get_type()) +#define GTK_TYPE_SIZE_GROUP (gtk_size_group_get_type ()) +#define GTK_TYPE_SIZE_GROUP_MODE (gtk_size_group_mode_get_type()) +#define GTK_TYPE_SOCKET (gtk_socket_get_type ()) +#define GTK_TYPE_SORT_TYPE (gtk_sort_type_get_type()) +#define GTK_TYPE_SPIN_BUTTON (gtk_spin_button_get_type ()) +#define GTK_TYPE_SPIN_TYPE (gtk_spin_type_get_type()) +#define GTK_TYPE_STATE_TYPE (gtk_state_type_get_type()) +#define GTK_TYPE_STATUSBAR (gtk_statusbar_get_type ()) +#define GTK_STYLE_ATTACHED(style) (GTK_STYLE (style)->attach_count > 0) +#define GTK_TYPE_STYLE (gtk_style_get_type ()) +#define GTK_TYPE_SUBMENU_DIRECTION (gtk_submenu_direction_get_type()) +#define GTK_TYPE_SUBMENU_PLACEMENT (gtk_submenu_placement_get_type()) +#define GTK_TYPE_TABLE (gtk_table_get_type ()) +#define GTK_TYPE_TARGET_FLAGS (gtk_target_flags_get_type()) +#define GTK_TYPE_TEAROFF_MENU_ITEM (gtk_tearoff_menu_item_get_type ()) +#define GTK_TYPE_TEXT_ATTRIBUTES (gtk_text_attributes_get_type ()) +#define GTK_TYPE_TEXT_BUFFER (gtk_text_buffer_get_type ()) +#define GTK_TYPE_TEXT_CHILD_ANCHOR (gtk_text_child_anchor_get_type ()) +#define GTK_TYPE_TEXT_DIRECTION (gtk_text_direction_get_type()) +#define GTK_TYPE_TEXT_ITER (gtk_text_iter_get_type ()) +#define GTK_TYPE_TEXT_MARK (gtk_text_mark_get_type ()) +#define GTK_TYPE_TEXT_SEARCH_FLAGS (gtk_text_search_flags_get_type()) +#define GTK_TYPE_TEXT_TAG (gtk_text_tag_get_type ()) +#define GTK_TYPE_TEXT_TAG_TABLE (gtk_text_tag_table_get_type ()) +#define GTK_TYPE_TEXT_VIEW (gtk_text_view_get_type ()) +#define GTK_TYPE_TEXT_WINDOW_TYPE (gtk_text_window_type_get_type()) +#define GTK_TYPE_TOGGLE_ACTION (gtk_toggle_action_get_type ()) +#define GTK_TYPE_TOGGLE_BUTTON (gtk_toggle_button_get_type ()) +#define GTK_TYPE_TOGGLE_TOOL_BUTTON (gtk_toggle_tool_button_get_type ()) +#define GTK_TYPE_TOOLBAR_CHILD_TYPE (gtk_toolbar_child_type_get_type()) +#define GTK_TYPE_TOOLBAR (gtk_toolbar_get_type ()) +#define GTK_TYPE_TOOLBAR_SPACE_STYLE (gtk_toolbar_space_style_get_type()) +#define GTK_TYPE_TOOLBAR_STYLE (gtk_toolbar_style_get_type()) +#define GTK_TYPE_TOOLTIPS (gtk_tooltips_get_type ()) +#define GTK_TYPE_TOOL_BUTTON (gtk_tool_button_get_type ()) +#define GTK_TYPE_TOOL_ITEM (gtk_tool_item_get_type ()) +#define GTK_TYPE_TREE_DRAG_DEST (gtk_tree_drag_dest_get_type ()) +#define GTK_TYPE_TREE_DRAG_SOURCE (gtk_tree_drag_source_get_type ()) +#define GTK_TYPE_TREE_ITER (gtk_tree_iter_get_type ()) +#define GTK_TYPE_TREE_MODEL_FILTER (gtk_tree_model_filter_get_type ()) +#define GTK_TYPE_TREE_MODEL_FLAGS (gtk_tree_model_flags_get_type()) +#define GTK_TYPE_TREE_MODEL (gtk_tree_model_get_type ()) +#define GTK_TYPE_TREE_MODEL_SORT (gtk_tree_model_sort_get_type ()) +#define GTK_TYPE_TREE_PATH (gtk_tree_path_get_type ()) +#define GTK_TYPE_TREE_ROW_REFERENCE (gtk_tree_row_reference_get_type ()) +#define GTK_TYPE_TREE_SELECTION (gtk_tree_selection_get_type ()) +#define GTK_TYPE_TREE_SORTABLE (gtk_tree_sortable_get_type ()) +#define GTK_TYPE_TREE_STORE (gtk_tree_store_get_type ()) +#define GTK_TYPE_TREE_VIEW_COLUMN (gtk_tree_view_column_get_type ()) +#define GTK_TYPE_TREE_VIEW (gtk_tree_view_get_type ()) +#define GTK_TYPE_TREE_VIEW_MODE (gtk_tree_view_mode_get_type()) +#define GTK_TYPE_UI_MANAGER (gtk_ui_manager_get_type ()) +#define GTK_TYPE_UPDATE_TYPE (gtk_update_type_get_type()) +#define GTK_TYPE_VBOX (gtk_vbox_get_type ()) +#define GTK_TYPE_VBUTTON_BOX (gtk_vbutton_box_get_type ()) +#define GTK_TYPE_VIEWPORT (gtk_viewport_get_type ()) +#define GTK_TYPE_VISIBILITY (gtk_visibility_get_type()) +#define GTK_TYPE_VPANED (gtk_vpaned_get_type ()) +#define GTK_TYPE_VRULER (gtk_vruler_get_type ()) +#define GTK_TYPE_VSCALE (gtk_vscale_get_type ()) +#define GTK_TYPE_VSCROLLBAR (gtk_vscrollbar_get_type ()) +#define GTK_TYPE_VSEPARATOR (gtk_vseparator_get_type ()) +#define GTK_WIDGET_SAVED_STATE(wid) (GTK_WIDGET (wid)->saved_state) +#define GTK_WIDGET_STATE(wid) (GTK_WIDGET (wid)->state) +#define GTK_TYPE_WIDGET_FLAGS (gtk_widget_flags_get_type()) +#define GTK_TYPE_WIDGET (gtk_widget_get_type ()) +#define GTK_TYPE_WIDGET_HELP_TYPE (gtk_widget_help_type_get_type()) +#define GTK_TYPE_WINDOW (gtk_window_get_type ()) +#define GTK_TYPE_WINDOW_GROUP (gtk_window_group_get_type ()) +#define GTK_TYPE_WINDOW_POSITION (gtk_window_position_get_type()) +#define GTK_TYPE_WINDOW_TYPE (gtk_window_type_get_type()) +#define GTK_TYPE_WRAP_MODE (gtk_wrap_mode_get_type()) +#define GTK_PRIORITY_RESIZE (G_PRIORITY_HIGH_IDLE + 10) +#define GTK_IS_BIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BIN)) +#define GTK_IS_BOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BOX)) +#define GTK_OBJECT_TYPE(object) (G_TYPE_FROM_INSTANCE (object)) +#define GTK_BUTTONBOX_DEFAULT -1 +#define GTK_INPUT_ERROR -1 +#define GTK_PATH_PRIO_MASK 0x0f +#define GTK_MAX_COMPOSE_LEN 7 +#define GTKMAIN_C_VAR extern +#define GTKVAR extern +#define GTK_STOCK_ABOUT "gtk-about" +#define GTK_STOCK_ADD "gtk-add" +#define GTK_STOCK_APPLY "gtk-apply" +#define GTK_STOCK_BOLD "gtk-bold" +#define GTK_STOCK_CANCEL "gtk-cancel" +#define GTK_STOCK_CDROM "gtk-cdrom" +#define GTK_STOCK_CLEAR "gtk-clear" +#define GTK_STOCK_CLOSE "gtk-close" +#define GTK_STOCK_COLOR_PICKER "gtk-color-picker" +#define GTK_STOCK_CONNECT "gtk-connect" +#define GTK_STOCK_CONVERT "gtk-convert" +#define GTK_STOCK_COPY "gtk-copy" +#define GTK_STOCK_CUT "gtk-cut" +#define GTK_STOCK_DELETE "gtk-delete" +#define GTK_STOCK_DIALOG_AUTHENTICATION "gtk-dialog-authentication" +#define GTK_STOCK_DIALOG_ERROR "gtk-dialog-error" +#define GTK_STOCK_DIALOG_INFO "gtk-dialog-info" +#define GTK_STOCK_DIALOG_QUESTION "gtk-dialog-question" +#define GTK_STOCK_DIALOG_WARNING "gtk-dialog-warning" +#define GTK_STOCK_DIRECTORY "gtk-directory" +#define GTK_STOCK_DISCONNECT "gtk-disconnect" +#define GTK_STOCK_DND "gtk-dnd" +#define GTK_STOCK_DND_MULTIPLE "gtk-dnd-multiple" +#define GTK_STOCK_EDIT "gtk-edit" +#define GTK_STOCK_EXECUTE "gtk-execute" +#define GTK_STOCK_FILE "gtk-file" +#define GTK_STOCK_FIND "gtk-find" +#define GTK_STOCK_FIND_AND_REPLACE "gtk-find-and-replace" +#define GTK_STOCK_FLOPPY "gtk-floppy" +#define GTK_STOCK_GO_BACK "gtk-go-back" +#define GTK_STOCK_GO_DOWN "gtk-go-down" +#define GTK_STOCK_GO_FORWARD "gtk-go-forward" +#define GTK_STOCK_GO_UP "gtk-go-up" +#define GTK_STOCK_GOTO_BOTTOM "gtk-goto-bottom" +#define GTK_STOCK_GOTO_FIRST "gtk-goto-first" +#define GTK_STOCK_GOTO_LAST "gtk-goto-last" +#define GTK_STOCK_GOTO_TOP "gtk-goto-top" +#define GTK_STOCK_HARDDISK "gtk-harddisk" +#define GTK_STOCK_HELP "gtk-help" +#define GTK_STOCK_HOME "gtk-home" +#define GTK_STOCK_INDENT "gtk-indent" +#define GTK_STOCK_INDEX "gtk-index" +#define GTK_STOCK_ITALIC "gtk-italic" +#define GTK_STOCK_JUMP_TO "gtk-jump-to" +#define GTK_STOCK_JUSTIFY_CENTER "gtk-justify-center" +#define GTK_STOCK_JUSTIFY_FILL "gtk-justify-fill" +#define GTK_STOCK_JUSTIFY_LEFT "gtk-justify-left" +#define GTK_STOCK_JUSTIFY_RIGHT "gtk-justify-right" +#define GTK_STOCK_MEDIA_FORWARD "gtk-media-forward" +#define GTK_STOCK_MEDIA_NEXT "gtk-media-next" +#define GTK_STOCK_MEDIA_PAUSE "gtk-media-pause" +#define GTK_STOCK_MEDIA_PLAY "gtk-media-play" +#define GTK_STOCK_MEDIA_PREVIOUS "gtk-media-previous" +#define GTK_STOCK_MEDIA_RECORD "gtk-media-record" +#define GTK_STOCK_MEDIA_REWIND "gtk-media-rewind" +#define GTK_STOCK_MEDIA_STOP "gtk-media-stop" +#define GTK_STOCK_MISSING_IMAGE "gtk-missing-image" +#define GTK_STOCK_NETWORK "gtk-network" +#define GTK_STOCK_NEW "gtk-new" +#define GTK_STOCK_NO "gtk-no" +#define GTK_STOCK_OK "gtk-ok" +#define GTK_STOCK_OPEN "gtk-open" +#define GTK_STOCK_PASTE "gtk-paste" +#define GTK_STOCK_PREFERENCES "gtk-preferences" +#define GTK_STOCK_PRINT "gtk-print" +#define GTK_STOCK_PRINT_PREVIEW "gtk-print-preview" +#define GTK_STOCK_PROPERTIES "gtk-properties" +#define GTK_STOCK_QUIT "gtk-quit" +#define GTK_STOCK_REDO "gtk-redo" +#define GTK_STOCK_REFRESH "gtk-refresh" +#define GTK_STOCK_REMOVE "gtk-remove" +#define GTK_STOCK_REVERT_TO_SAVED "gtk-revert-to-saved" +#define GTK_STOCK_SAVE "gtk-save" +#define GTK_STOCK_SAVE_AS "gtk-save-as" +#define GTK_STOCK_SELECT_COLOR "gtk-select-color" +#define GTK_STOCK_SELECT_FONT "gtk-select-font" +#define GTK_STOCK_SORT_ASCENDING "gtk-sort-ascending" +#define GTK_STOCK_SORT_DESCENDING "gtk-sort-descending" +#define GTK_STOCK_SPELL_CHECK "gtk-spell-check" +#define GTK_STOCK_STOP "gtk-stop" +#define GTK_STOCK_STRIKETHROUGH "gtk-strikethrough" +#define GTK_STOCK_UNDELETE "gtk-undelete" +#define GTK_STOCK_UNDERLINE "gtk-underline" +#define GTK_STOCK_UNDO "gtk-undo" +#define GTK_STOCK_UNINDENT "gtk-unindent" +#define GTK_STOCK_YES "gtk-yes" +#define GTK_STOCK_ZOOM_100 "gtk-zoom-100" +#define GTK_STOCK_ZOOM_FIT "gtk-zoom-fit" +#define GTK_STOCK_ZOOM_IN "gtk-zoom-in" +#define GTK_STOCK_ZOOM_OUT "gtk-zoom-out" +#define gtk_accel_label_accelerator_width gtk_accel_label_get_accel_width +#define gtk_binding_entry_add gtk_binding_entry_clear +#define GTK_ICON_THEME_ERROR gtk_icon_theme_error_quark () +#define GTK_CHECK_CLASS_CAST G_TYPE_CHECK_CLASS_CAST +#define GTK_CHECK_CLASS_TYPE G_TYPE_CHECK_CLASS_TYPE +#define GTK_CHECK_CAST G_TYPE_CHECK_INSTANCE_CAST +#define GTK_CHECK_TYPE G_TYPE_CHECK_INSTANCE_TYPE +#define GTK_CHECK_GET_CLASS G_TYPE_INSTANCE_GET_CLASS + + + typedef struct _GtkIconSet GtkIconSet; + + typedef struct _GtkObject GtkObject; + + typedef enum { + GTK_RC_FG = 1, + GTK_RC_BG = 2, + GTK_RC_TEXT = 4, + GTK_RC_BASE = 8 + } GtkRcFlags; + + typedef struct _GtkRcStyle GtkRcStyle; + + typedef struct _GtkStyle GtkStyle; + + typedef struct _GtkRequisition GtkRequisition; + + typedef GdkRectangle GtkAllocation; + + typedef struct _GtkWidget GtkWidget; + + typedef struct _GtkAdjustment GtkAdjustment; + + typedef struct _GtkProgress GtkProgress; + + typedef enum { + GTK_PROGRESS_CONTINUOUS = 0, + GTK_PROGRESS_DISCRETE = 1 + } GtkProgressBarStyle; + + typedef enum { + GTK_PROGRESS_LEFT_TO_RIGHT = 0, + GTK_PROGRESS_RIGHT_TO_LEFT = 1, + GTK_PROGRESS_BOTTOM_TO_TOP = 2, + GTK_PROGRESS_TOP_TO_BOTTOM = 3 + } GtkProgressBarOrientation; + + typedef struct _GtkProgressBar GtkProgressBar; + + typedef struct _GtkTextTagTable GtkTextTagTable; + + typedef struct _GtkTextBTree GtkTextBTree; + + typedef struct _GtkTextLogAttrCache GtkTextLogAttrCache; + + typedef struct _GtkTextBuffer GtkTextBuffer; + + typedef struct _GtkTextIter GtkTextIter; + + typedef GType GtkType; + + typedef struct _GtkContainer GtkContainer; + + typedef struct _GtkBin GtkBin; + + typedef struct _GtkComboBoxPrivate GtkComboBoxPrivate; + + typedef struct _GtkComboBox GtkComboBox; + + typedef struct _GtkMisc GtkMisc; + + typedef struct _GtkBox GtkBox; + + typedef struct _GtkHBox GtkHBox; + + typedef struct _GtkStatusbar GtkStatusbar; + + typedef struct _GtkTargetList GtkTargetList; + + typedef struct _GtkWindow GtkWindow; + + typedef struct _GtkWindowGeometryInfo GtkWindowGeometryInfo; + + typedef struct _GtkWindowGroup GtkWindowGroup; + + typedef enum { + GTK_STATE_NORMAL = 0, + GTK_STATE_ACTIVE = 1, + GTK_STATE_PRELIGHT = 2, + GTK_STATE_SELECTED = 3, + GTK_STATE_INSENSITIVE = 4 + } GtkStateType; + + typedef struct _GtkTreeRowReference GtkTreeRowReference; + + typedef enum { + GTK_TREE_MODEL_ITERS_PERSIST = 1, + GTK_TREE_MODEL_LIST_ONLY = 2 + } GtkTreeModelFlags; + + typedef struct _GtkTreeModel GtkTreeModel; + + typedef struct _GtkTargetEntry GtkTargetEntry; + + typedef struct _GtkIMContext GtkIMContext; + + typedef struct _GtkEntry GtkEntry; + + typedef struct _GtkComboBoxEntryPrivate GtkComboBoxEntryPrivate; + + typedef struct _GtkComboBoxEntry GtkComboBoxEntry; + + typedef struct _GtkLayout GtkLayout; + + typedef enum { + GTK_SORT_ASCENDING = 0, + GTK_SORT_DESCENDING = 1 + } GtkSortType; + + typedef struct _GtkTreeIter GtkTreeIter; + + typedef gint(*GtkTreeIterCompareFunc) (GtkTreeModel *, GtkTreeIter *, + GtkTreeIter *, gpointer); + + typedef void (*GtkDestroyNotify) (gpointer); + + typedef struct _GtkTreeStore GtkTreeStore; + + typedef struct _GtkDialog GtkDialog; + + typedef struct _GtkAboutDialog GtkAboutDialog; + + typedef void (*GtkAboutDialogActivateLinkFunc) (GtkAboutDialog *, + const gchar *, + gpointer); + + typedef struct _GtkTreeSortable GtkTreeSortable; + + typedef enum { + GTK_UPDATE_CONTINUOUS = 0, + GTK_UPDATE_DISCONTINUOUS = 1, + GTK_UPDATE_DELAYED = 2 + } GtkUpdateType; + + typedef enum { + GTK_ORIENTATION_HORIZONTAL = 0, + GTK_ORIENTATION_VERTICAL = 1 + } GtkOrientation; + + typedef struct _GtkRangeLayout GtkRangeLayout; + + typedef struct _GtkRangeStepTimer GtkRangeStepTimer; + + typedef struct _GtkRange GtkRange; + + typedef struct _GtkAccelKey GtkAccelKey; + + typedef struct _GtkAccelGroupEntry GtkAccelGroupEntry; + + typedef struct _GtkAccelGroup GtkAccelGroup; + + typedef struct _GtkSocket GtkSocket; + + typedef struct _GtkCellEditable GtkCellEditable; + + typedef enum { + GTK_TREE_VIEW_COLUMN_GROW_ONLY = 0, + GTK_TREE_VIEW_COLUMN_AUTOSIZE = 1, + GTK_TREE_VIEW_COLUMN_FIXED = 2 + } GtkTreeViewColumnSizing; + + typedef struct _GtkTreeViewColumn GtkTreeViewColumn; + + typedef struct _GtkCellRenderer GtkCellRenderer; + + typedef enum { + GTK_BUTTONBOX_DEFAULT_STYLE = 0, + GTK_BUTTONBOX_SPREAD = 1, + GTK_BUTTONBOX_EDGE = 2, + GTK_BUTTONBOX_START = 3, + GTK_BUTTONBOX_END = 4 + } GtkButtonBoxStyle; + + typedef struct _GtkButtonBox GtkButtonBox; + + typedef struct _GtkActionPrivate GtkActionPrivate; + + typedef struct _GtkAction GtkAction; + + typedef struct _GtkToggleActionPrivate GtkToggleActionPrivate; + + typedef struct _GtkToggleAction GtkToggleAction; + + typedef struct _GtkTextAppearance GtkTextAppearance; + + typedef enum { + GTK_JUSTIFY_LEFT = 0, + GTK_JUSTIFY_RIGHT = 1, + GTK_JUSTIFY_CENTER = 2, + GTK_JUSTIFY_FILL = 3 + } GtkJustification; + + typedef enum { + GTK_TEXT_DIR_NONE = 0, + GTK_TEXT_DIR_LTR = 1, + GTK_TEXT_DIR_RTL = 2 + } GtkTextDirection; + + typedef enum { + GTK_WRAP_NONE = 0, + GTK_WRAP_CHAR = 1, + GTK_WRAP_WORD = 2, + GTK_WRAP_WORD_CHAR = 3 + } GtkWrapMode; + + typedef struct _GtkTextAttributes GtkTextAttributes; + + typedef struct _GtkTextTag GtkTextTag; + + typedef struct _GtkFileFilter GtkFileFilter; + + typedef enum { + GTK_FILE_FILTER_FILENAME = 1, + GTK_FILE_FILTER_URI = 2, + GTK_FILE_FILTER_DISPLAY_NAME = 4, + GTK_FILE_FILTER_MIME_TYPE = 8 + } GtkFileFilterFlags; + + typedef struct _GtkFileFilterInfo GtkFileFilterInfo; + + typedef struct _GtkIconSource GtkIconSource; + + typedef struct _GtkToolItemPrivate GtkToolItemPrivate; + + typedef struct _GtkToolItem GtkToolItem; + + typedef struct _GtkToolButtonPrivate GtkToolButtonPrivate; + + typedef struct _GtkToolButton GtkToolButton; + + typedef struct _GtkIconViewPrivate GtkIconViewPrivate; + + typedef struct _GtkIconView GtkIconView; + + typedef struct _GtkLabelSelectionInfo GtkLabelSelectionInfo; + + typedef struct _GtkLabel GtkLabel; + + typedef struct _GtkSettingsPropertyValue GtkSettingsPropertyValue; + + typedef struct _GtkRcContext GtkRcContext; + + typedef struct _GtkSettings GtkSettings; + + typedef struct _GtkUIManagerPrivate GtkUIManagerPrivate; + + typedef struct _GtkUIManager GtkUIManager; + + typedef struct _GtkItem GtkItem; + + typedef struct _GtkMenuItem GtkMenuItem; + + typedef struct _GtkCheckMenuItem GtkCheckMenuItem; + + typedef struct _GtkRadioMenuItem GtkRadioMenuItem; + + typedef struct _GtkCellViewPrivate GtkCellViewPrivate; + + typedef struct _GtkCellView GtkCellView; + + typedef struct _GtkSelectionData GtkSelectionData; + + typedef struct _GtkFileChooser GtkFileChooser; + + typedef struct _GtkDrawingArea GtkDrawingArea; + + typedef enum { + GTK_CURVE_TYPE_LINEAR = 0, + GTK_CURVE_TYPE_SPLINE = 1, + GTK_CURVE_TYPE_FREE = 2 + } GtkCurveType; + + typedef struct _GtkCurve GtkCurve; + + typedef struct _GtkNotebookPage GtkNotebookPage; + + typedef struct _GtkNotebook GtkNotebook; + + typedef struct _GtkIconFactory GtkIconFactory; + + typedef struct _GtkRadioActionPrivate GtkRadioActionPrivate; + + typedef struct _GtkRadioAction GtkRadioAction; + + typedef struct _GtkTextMark GtkTextMark; + + typedef enum { + GTK_PACK_START = 0, + GTK_PACK_END = 1 + } GtkPackType; + + typedef struct _GtkVBox GtkVBox; + + typedef struct _GtkColorSelection GtkColorSelection; + + typedef enum { + GTK_CALENDAR_SHOW_HEADING = 1, + GTK_CALENDAR_SHOW_DAY_NAMES = 2, + GTK_CALENDAR_NO_MONTH_CHANGE = 4, + GTK_CALENDAR_SHOW_WEEK_NUMBERS = 8, + GTK_CALENDAR_WEEK_START_MONDAY = 16 + } GtkCalendarDisplayOptions; + + typedef struct _GtkCalendar GtkCalendar; + + typedef struct _GtkIconInfo GtkIconInfo; + + typedef struct _GtkTreePath GtkTreePath; + + typedef struct _GtkTreeDragSource GtkTreeDragSource; + + typedef struct _GtkTableRowCol GtkTableRowCol; + + typedef struct _GtkTable GtkTable; + + typedef gboolean(*GtkFunction) (gpointer); + + typedef void (*GtkSignalFunc) (void); + + typedef struct _GtkArg GtkArg; + + typedef void (*GtkCallbackMarshal) (GtkObject *, gpointer, guint, + GtkArg *); + + typedef struct _GtkMenuShell GtkMenuShell; + + typedef struct _GtkMenu GtkMenu; + + typedef void (*GtkMenuPositionFunc) (GtkMenu *, gint *, gint *, + gboolean *, gpointer); + + typedef struct _GtkButton GtkButton; + + typedef struct _GtkToggleButton GtkToggleButton; + + typedef struct _GtkIconThemePrivate GtkIconThemePrivate; + + typedef struct _GtkIconTheme GtkIconTheme; + + typedef enum { + GTK_ARROW_UP = 0, + GTK_ARROW_DOWN = 1, + GTK_ARROW_LEFT = 2, + GTK_ARROW_RIGHT = 3 + } GtkArrowType; + + typedef enum { + GTK_SHADOW_NONE = 0, + GTK_SHADOW_IN = 1, + GTK_SHADOW_OUT = 2, + GTK_SHADOW_ETCHED_IN = 3, + GTK_SHADOW_ETCHED_OUT = 4 + } GtkShadowType; + + typedef struct _GtkTextWindow GtkTextWindow; + + typedef struct _GtkTextPendingScroll GtkTextPendingScroll; + + typedef struct _GtkTextView GtkTextView; + + typedef enum { + GTK_TEXT_WINDOW_PRIVATE = 0, + GTK_TEXT_WINDOW_WIDGET = 1, + GTK_TEXT_WINDOW_TEXT = 2, + GTK_TEXT_WINDOW_LEFT = 3, + GTK_TEXT_WINDOW_RIGHT = 4, + GTK_TEXT_WINDOW_TOP = 5, + GTK_TEXT_WINDOW_BOTTOM = 6 + } GtkTextWindowType; + + typedef struct _GtkObjectClass GtkObjectClass; + + typedef enum { + GTK_DIR_TAB_FORWARD = 0, + GTK_DIR_TAB_BACKWARD = 1, + GTK_DIR_UP = 2, + GTK_DIR_DOWN = 3, + GTK_DIR_LEFT = 4, + GTK_DIR_RIGHT = 5 + } GtkDirectionType; + + typedef enum { + GTK_WIDGET_HELP_TOOLTIP = 0, + GTK_WIDGET_HELP_WHATS_THIS = 1 + } GtkWidgetHelpType; + + typedef struct _GtkWidgetClass GtkWidgetClass; + + typedef gboolean(*GtkRcPropertyParser) (const GParamSpec *, + const GString *, GValue *); + + typedef enum { + GTK_IMAGE_EMPTY = 0, + GTK_IMAGE_PIXMAP = 1, + GTK_IMAGE_IMAGE = 2, + GTK_IMAGE_PIXBUF = 3, + GTK_IMAGE_STOCK = 4, + GTK_IMAGE_ICON_SET = 5, + GTK_IMAGE_ANIMATION = 6, + GTK_IMAGE_ICON_NAME = 7 + } GtkImageType; + + typedef struct _GtkImagePixmapData GtkImagePixmapData; + + typedef struct _GtkImageImageData GtkImageImageData; + + typedef struct _GtkImagePixbufData GtkImagePixbufData; + + typedef struct _GtkImageStockData GtkImageStockData; + + typedef struct _GtkImageIconSetData GtkImageIconSetData; + + typedef struct _GtkImageAnimationData GtkImageAnimationData; + + typedef struct _GtkImageIconNameData GtkImageIconNameData; + + typedef enum { + GTK_ICON_SIZE_INVALID = 0, + GTK_ICON_SIZE_MENU = 1, + GTK_ICON_SIZE_SMALL_TOOLBAR = 2, + GTK_ICON_SIZE_LARGE_TOOLBAR = 3, + GTK_ICON_SIZE_BUTTON = 4, + GTK_ICON_SIZE_DND = 5, + GTK_ICON_SIZE_DIALOG = 6 + } GtkIconSize; + + typedef struct _GtkImage GtkImage; + + typedef struct _GtkTreeViewPrivate GtkTreeViewPrivate; + + typedef struct _GtkTreeView GtkTreeView; + + typedef enum { + GTK_UPDATE_ALWAYS = 0, + GTK_UPDATE_IF_VALID = 1 + } GtkSpinButtonUpdatePolicy; + + typedef struct _GtkSpinButton GtkSpinButton; + + typedef struct _GtkCellLayout GtkCellLayout; + + typedef struct _GtkFileSelection GtkFileSelection; + + typedef struct _GtkTooltips GtkTooltips; + + typedef struct _GtkTooltipsData GtkTooltipsData; + + typedef gboolean(*GtkTreeViewRowSeparatorFunc) (GtkTreeModel *, + GtkTreeIter *, + gpointer); + + typedef struct _GtkEntryCompletionPrivate GtkEntryCompletionPrivate; + + typedef struct _GtkEntryCompletion GtkEntryCompletion; + + typedef struct _GtkClipboard GtkClipboard; + + typedef struct _GtkTreeModelFilterPrivate GtkTreeModelFilterPrivate; + + typedef struct _GtkTreeModelFilter GtkTreeModelFilter; + + typedef struct _GtkTreeModelSort GtkTreeModelSort; + + typedef void (*GtkTreeCellDataFunc) (GtkTreeViewColumn *, + GtkCellRenderer *, GtkTreeModel *, + GtkTreeIter *, gpointer); + + typedef struct _GtkColorButtonPrivate GtkColorButtonPrivate; + + typedef struct _GtkColorButton GtkColorButton; + + typedef enum { + GTK_FILE_CHOOSER_ACTION_OPEN = 0, + GTK_FILE_CHOOSER_ACTION_SAVE = 1, + GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER = 2, + GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER = 3 + } GtkFileChooserAction; + + typedef void (*GtkCallback) (GtkWidget *, gpointer); + + typedef struct _GtkHandleBox GtkHandleBox; + + typedef enum { + GTK_SELECTION_NONE = 0, + GTK_SELECTION_SINGLE = 1, + GTK_SELECTION_BROWSE = 2, + GTK_SELECTION_MULTIPLE = 3, + GTK_SELECTION_EXTENDED = 3 + } GtkSelectionMode; + + typedef struct _GtkActionGroupPrivate GtkActionGroupPrivate; + + typedef struct _GtkActionGroup GtkActionGroup; + + typedef struct _GtkBindingSet GtkBindingSet; + + typedef struct _GtkBindingEntry GtkBindingEntry; + + typedef struct _GtkBindingSignal GtkBindingSignal; + + typedef struct _GtkBindingArg GtkBindingArg; + + typedef struct _GtkScrolledWindow GtkScrolledWindow; + + typedef enum { + GTK_CORNER_TOP_LEFT = 0, + GTK_CORNER_BOTTOM_LEFT = 1, + GTK_CORNER_TOP_RIGHT = 2, + GTK_CORNER_BOTTOM_RIGHT = 3 + } GtkCornerType; + + typedef struct _GtkFrame GtkFrame; + + typedef struct _GtkTextChildAnchor GtkTextChildAnchor; + + typedef struct _GtkSeparatorToolItemPrivate + GtkSeparatorToolItemPrivate; + + typedef struct _GtkSeparatorToolItem GtkSeparatorToolItem; + + typedef struct _GtkTreeSelection GtkTreeSelection; + + typedef gboolean(*GtkTreeSelectionFunc) (GtkTreeSelection *, + GtkTreeModel *, GtkTreePath *, + gboolean, gpointer); + + typedef struct _GtkExpanderPrivate GtkExpanderPrivate; + + typedef struct _GtkExpander GtkExpander; + + typedef enum { + GTK_POS_LEFT = 0, + GTK_POS_RIGHT = 1, + GTK_POS_TOP = 2, + GTK_POS_BOTTOM = 3 + } GtkPositionType; + + typedef enum { + GTK_UI_MANAGER_AUTO = 0, + GTK_UI_MANAGER_MENUBAR = 1, + GTK_UI_MANAGER_MENU = 2, + GTK_UI_MANAGER_TOOLBAR = 4, + GTK_UI_MANAGER_PLACEHOLDER = 8, + GTK_UI_MANAGER_POPUP = 16, + GTK_UI_MANAGER_MENUITEM = 32, + GTK_UI_MANAGER_TOOLITEM = 64, + GTK_UI_MANAGER_SEPARATOR = 128, + GTK_UI_MANAGER_ACCELERATOR = 256 + } GtkUIManagerItemType; + + typedef struct _GtkFontSelectionDialog GtkFontSelectionDialog; + + typedef struct _GtkPanedPrivate GtkPanedPrivate; + + typedef struct _GtkPaned GtkPaned; + + typedef struct _GtkViewport GtkViewport; + + typedef struct _GtkScale GtkScale; + + typedef struct _GtkListStore GtkListStore; + + typedef struct _GtkEditable GtkEditable; + + typedef void (*GtkClipboardGetFunc) (GtkClipboard *, + GtkSelectionData *, guint, + gpointer); + + typedef void (*GtkClipboardClearFunc) (GtkClipboard *, gpointer); + + typedef struct _GtkRadioActionEntry GtkRadioActionEntry; + + typedef gboolean(*GtkTreeViewColumnDropFunc) (GtkTreeView *, + GtkTreeViewColumn *, + GtkTreeViewColumn *, + GtkTreeViewColumn *, + gpointer); + + typedef struct _GtkEventBox GtkEventBox; + + typedef struct _GtkTreeDragDest GtkTreeDragDest; + + typedef struct _GtkToggleActionEntry GtkToggleActionEntry; + + typedef struct _GtkAccelLabel GtkAccelLabel; + + typedef struct _GtkImageMenuItem GtkImageMenuItem; + + typedef struct _GtkPlug GtkPlug; + + typedef struct _GtkFileChooserButtonPrivate + GtkFileChooserButtonPrivate; + + typedef struct _GtkFileChooserButton GtkFileChooserButton; + + typedef struct _GtkStockItem GtkStockItem; + + typedef gchar *(*GtkTranslateFunc) (const gchar *, gpointer); + + typedef enum { + GTK_TOOLBAR_ICONS = 0, + GTK_TOOLBAR_TEXT = 1, + GTK_TOOLBAR_BOTH = 2, + GTK_TOOLBAR_BOTH_HORIZ = 3 + } GtkToolbarStyle; + + typedef struct _GtkToolbar GtkToolbar; + + typedef void (*GtkCellLayoutDataFunc) (GtkCellLayout *, + GtkCellRenderer *, + GtkTreeModel *, GtkTreeIter *, + gpointer); + + typedef struct _GtkCellRendererToggle GtkCellRendererToggle; + + typedef enum { + GTK_RELIEF_NORMAL = 0, + GTK_RELIEF_HALF = 1, + GTK_RELIEF_NONE = 2 + } GtkReliefStyle; + + typedef void (*GtkClipboardImageReceivedFunc) (GtkClipboard *, + GdkPixbuf *, gpointer); + + typedef enum { + GTK_CELL_RENDERER_SELECTED = 1, + GTK_CELL_RENDERER_PRELIT = 2, + GTK_CELL_RENDERER_INSENSITIVE = 4, + GTK_CELL_RENDERER_SORTED = 8, + GTK_CELL_RENDERER_FOCUSED = 16 + } GtkCellRendererState; + + typedef struct _GtkActionEntry GtkActionEntry; + + typedef struct _GtkCheckButton GtkCheckButton; + + typedef struct _GtkRadioButton GtkRadioButton; + + typedef struct _GtkAlignment GtkAlignment; + + typedef struct _GtkContainerClass GtkContainerClass; + + typedef struct _GtkFontButtonPrivate GtkFontButtonPrivate; + + typedef struct _GtkFontButton GtkFontButton; + + typedef struct _GtkBorder GtkBorder; + + typedef struct _GtkMessageDialog GtkMessageDialog; + + typedef struct _GtkRulerMetric GtkRulerMetric; + + typedef struct _GtkRuler GtkRuler; + + typedef enum { + GTK_ACCEL_VISIBLE = 1, + GTK_ACCEL_LOCKED = 2, + GTK_ACCEL_MASK = 7 + } GtkAccelFlags; + + typedef gboolean(*GtkTextCharPredicate) (gunichar, gpointer); + + typedef struct _GtkMenuToolButtonPrivate GtkMenuToolButtonPrivate; + + typedef struct _GtkMenuToolButton GtkMenuToolButton; + + typedef struct _GtkToggleToolButtonPrivate GtkToggleToolButtonPrivate; + + typedef struct _GtkToggleToolButton GtkToggleToolButton; + + typedef struct _GtkRadioToolButton GtkRadioToolButton; + + typedef struct _GtkSizeGroup GtkSizeGroup; + + typedef enum { + GTK_SIZE_GROUP_NONE = 0, + GTK_SIZE_GROUP_HORIZONTAL = 1, + GTK_SIZE_GROUP_VERTICAL = 2, + GTK_SIZE_GROUP_BOTH = 3 + } GtkSizeGroupMode; + + typedef enum { + GTK_DIALOG_MODAL = 1, + GTK_DIALOG_DESTROY_WITH_PARENT = 2, + GTK_DIALOG_NO_SEPARATOR = 4 + } GtkDialogFlags; + + typedef void (*GtkTreeSelectionForeachFunc) (GtkTreeModel *, + GtkTreePath *, + GtkTreeIter *, gpointer); + + typedef enum { + GTK_ICON_LOOKUP_NO_SVG = 1, + GTK_ICON_LOOKUP_FORCE_SVG = 2, + GTK_ICON_LOOKUP_USE_BUILTIN = 4 + } GtkIconLookupFlags; + + typedef gboolean(*GtkTreeViewSearchEqualFunc) (GtkTreeModel *, gint, + const gchar *, + GtkTreeIter *, + gpointer); + + typedef enum { + GTK_PIXELS = 0, + GTK_INCHES = 1, + GTK_CENTIMETERS = 2 + } GtkMetricType; + + typedef struct _GtkIMContextSimple GtkIMContextSimple; + + typedef void (*GtkClipboardTargetsReceivedFunc) (GtkClipboard *, + GdkAtom *, gint, + gpointer); + + typedef enum { + GTK_EXPAND = 1, + GTK_SHRINK = 2, + GTK_FILL = 4 + } GtkAttachOptions; + + typedef struct _GtkFontSelection GtkFontSelection; + + typedef void (*GtkClipboardTextReceivedFunc) (GtkClipboard *, + const gchar *, gpointer); + + typedef gboolean(*GtkAccelGroupFindFunc) (GtkAccelKey *, GClosure *, + gpointer); + + typedef void (*GtkTreeDestroyCountFunc) (GtkTreeView *, GtkTreePath *, + gint, gpointer); + + typedef enum { + GTK_TREE_VIEW_DROP_BEFORE = 0, + GTK_TREE_VIEW_DROP_AFTER = 1, + GTK_TREE_VIEW_DROP_INTO_OR_BEFORE = 2, + GTK_TREE_VIEW_DROP_INTO_OR_AFTER = 3 + } GtkTreeViewDropPosition; + + typedef struct _GtkAspectFrame GtkAspectFrame; + + typedef gboolean(*GtkFileFilterFunc) (const GtkFileFilterInfo *, + gpointer); + + typedef struct _GtkIMMulticontextPrivate GtkIMMulticontextPrivate; + + typedef struct _GtkIMMulticontext GtkIMMulticontext; + + typedef enum { + GTK_MESSAGE_INFO = 0, + GTK_MESSAGE_WARNING = 1, + GTK_MESSAGE_QUESTION = 2, + GTK_MESSAGE_ERROR = 3 + } GtkMessageType; + + typedef enum { + GTK_BUTTONS_NONE = 0, + GTK_BUTTONS_OK = 1, + GTK_BUTTONS_CLOSE = 2, + GTK_BUTTONS_CANCEL = 3, + GTK_BUTTONS_YES_NO = 4, + GTK_BUTTONS_OK_CANCEL = 5 + } GtkButtonsType; + + typedef void (*GtkAccelMapForeach) (gpointer, const gchar *, guint, + GdkModifierType, gboolean); + + typedef enum { + GTK_POLICY_ALWAYS = 0, + GTK_POLICY_AUTOMATIC = 1, + GTK_POLICY_NEVER = 2 + } GtkPolicyType; + + typedef enum { + GTK_RESIZE_PARENT = 0, + GTK_RESIZE_QUEUE = 1, + GTK_RESIZE_IMMEDIATE = 2 + } GtkResizeMode; + + typedef void (*GtkColorSelectionChangePaletteWithScreenFunc) (GdkScreen + *, + const + GdkColor + *, gint); + + typedef void (*GtkClipboardReceivedFunc) (GtkClipboard *, + GtkSelectionData *, + gpointer); + + typedef void (*GtkTreeViewMappingFunc) (GtkTreeView *, GtkTreePath *, + gpointer); + + typedef gboolean(*GtkTreeModelFilterVisibleFunc) (GtkTreeModel *, + GtkTreeIter *, + gpointer); + + typedef enum { + GTK_TEXT_SEARCH_VISIBLE_ONLY = 1, + GTK_TEXT_SEARCH_TEXT_ONLY = 2 + } GtkTextSearchFlags; + + typedef struct _GtkFixed GtkFixed; + + typedef enum { + GTK_DEST_DEFAULT_MOTION = 1, + GTK_DEST_DEFAULT_HIGHLIGHT = 2, + GTK_DEST_DEFAULT_DROP = 4, + GTK_DEST_DEFAULT_ALL = 7 + } GtkDestDefaults; + + typedef gint(*GtkKeySnoopFunc) (GtkWidget *, GdkEventKey *, gpointer); + + typedef enum { + GTK_SPIN_STEP_FORWARD = 0, + GTK_SPIN_STEP_BACKWARD = 1, + GTK_SPIN_PAGE_FORWARD = 2, + GTK_SPIN_PAGE_BACKWARD = 3, + GTK_SPIN_HOME = 4, + GTK_SPIN_END = 5, + GTK_SPIN_USER_DEFINED = 6 + } GtkSpinType; + + typedef enum { + GTK_WINDOW_TOPLEVEL = 0, + GTK_WINDOW_POPUP = 1 + } GtkWindowType; + + typedef void (*GtkMenuDetachFunc) (GtkWidget *, GtkMenu *); + + typedef struct _GtkInvisible GtkInvisible; + + typedef enum { + GTK_WIN_POS_NONE = 0, + GTK_WIN_POS_CENTER = 1, + GTK_WIN_POS_MOUSE = 2, + GTK_WIN_POS_CENTER_ALWAYS = 3, + GTK_WIN_POS_CENTER_ON_PARENT = 4 + } GtkWindowPosition; + + typedef void (*GtkTextTagTableForeach) (GtkTextTag *, gpointer); + + typedef gboolean(*GtkEntryCompletionMatchFunc) (GtkEntryCompletion *, + const gchar *, + GtkTreeIter *, + gpointer); + + typedef struct _GtkAccessible GtkAccessible; + + typedef enum { + GTK_EXPANDER_COLLAPSED = 0, + GTK_EXPANDER_SEMI_COLLAPSED = 1, + GTK_EXPANDER_SEMI_EXPANDED = 2, + GTK_EXPANDER_EXPANDED = 3 + } GtkExpanderStyle; + + typedef enum { + GTK_PATH_PRIO_LOWEST = 0, + GTK_PATH_PRIO_GTK = 4, + GTK_PATH_PRIO_APPLICATION = 8, + GTK_PATH_PRIO_THEME = 10, + GTK_PATH_PRIO_RC = 12, + GTK_PATH_PRIO_HIGHEST = 15 + } GtkPathPriorityType; + + typedef struct _GtkArrow GtkArrow; + + typedef void (*GtkIconViewForeachFunc) (GtkIconView *, GtkTreePath *, + gpointer); + + typedef void (*GtkTreeModelFilterModifyFunc) (GtkTreeModel *, + GtkTreeIter *, GValue *, + gint, gpointer); + + typedef struct _GtkCellRendererText GtkCellRendererText; + + typedef gboolean(*GtkTreeModelForeachFunc) (GtkTreeModel *, + GtkTreePath *, + GtkTreeIter *, gpointer); + + typedef struct _GtkSettingsValue GtkSettingsValue; + + typedef enum { + GTK_PATH_WIDGET = 0, + GTK_PATH_WIDGET_CLASS = 1, + GTK_PATH_CLASS = 2 + } GtkPathType; + + typedef struct _GtkAccelMap GtkAccelMap; + + typedef struct _GtkBinClass GtkBinClass; + + typedef struct _GtkWindowClass GtkWindowClass; + + typedef enum { + GTK_SCROLL_NONE = 0, + GTK_SCROLL_JUMP = 1, + GTK_SCROLL_STEP_BACKWARD = 2, + GTK_SCROLL_STEP_FORWARD = 3, + GTK_SCROLL_PAGE_BACKWARD = 4, + GTK_SCROLL_PAGE_FORWARD = 5, + GTK_SCROLL_STEP_UP = 6, + GTK_SCROLL_STEP_DOWN = 7, + GTK_SCROLL_PAGE_UP = 8, + GTK_SCROLL_PAGE_DOWN = 9, + GTK_SCROLL_STEP_LEFT = 10, + GTK_SCROLL_STEP_RIGHT = 11, + GTK_SCROLL_PAGE_LEFT = 12, + GTK_SCROLL_PAGE_RIGHT = 13, + GTK_SCROLL_START = 14, + GTK_SCROLL_END = 15 + } GtkScrollType; + + typedef struct _GtkRangeClass GtkRangeClass; + + typedef struct _GtkScaleClass GtkScaleClass; + + typedef struct _GtkBoxClass GtkBoxClass; + + typedef struct _GtkMiscClass GtkMiscClass; + + typedef struct _GtkHRuler GtkHRuler; + + typedef struct _GtkHBoxClass GtkHBoxClass; + + typedef struct _GtkPanedClass GtkPanedClass; + + typedef struct _GtkHPanedClass GtkHPanedClass; + + typedef struct _GtkSizeGroupClass GtkSizeGroupClass; + + typedef struct _GtkViewportClass GtkViewportClass; + + typedef enum { + GTK_MOVEMENT_LOGICAL_POSITIONS = 0, + GTK_MOVEMENT_VISUAL_POSITIONS = 1, + GTK_MOVEMENT_WORDS = 2, + GTK_MOVEMENT_DISPLAY_LINES = 3, + GTK_MOVEMENT_DISPLAY_LINE_ENDS = 4, + GTK_MOVEMENT_PARAGRAPHS = 5, + GTK_MOVEMENT_PARAGRAPH_ENDS = 6, + GTK_MOVEMENT_PAGES = 7, + GTK_MOVEMENT_BUFFER_ENDS = 8, + GTK_MOVEMENT_HORIZONTAL_PAGES = 9 + } GtkMovementStep; + + typedef struct _GtkEditableClass GtkEditableClass; + + typedef enum { + GTK_NOTEBOOK_TAB_FIRST = 0, + GTK_NOTEBOOK_TAB_LAST = 1 + } GtkNotebookTab; + + typedef struct _GtkDialogClass GtkDialogClass; + + typedef struct _GtkCellRendererPixbuf GtkCellRendererPixbuf; + + typedef struct _GtkTreeViewColumnClass GtkTreeViewColumnClass; + + typedef struct _GtkRulerClass GtkRulerClass; + + typedef struct _GtkHRulerClass GtkHRulerClass; + + typedef struct _GtkAccelMapClass GtkAccelMapClass; + + typedef struct _GtkInvisibleClass GtkInvisibleClass; + + typedef struct _GtkVRulerClass GtkVRulerClass; + + typedef struct _GtkToolItemClass GtkToolItemClass; + + typedef struct _GtkWindowGroupClass GtkWindowGroupClass; + + typedef struct _GtkWidgetAuxInfo GtkWidgetAuxInfo; + + typedef struct _GtkItemClass GtkItemClass; + + typedef struct _GtkMenuItemClass GtkMenuItemClass; + + typedef struct _GtkCheckMenuItemClass GtkCheckMenuItemClass; + + typedef struct _GtkRcProperty GtkRcProperty; + + typedef struct _GtkFontSelectionDialogClass + GtkFontSelectionDialogClass; + + typedef struct _GtkFileChooserDialogPrivate + GtkFileChooserDialogPrivate; + + typedef struct _GtkFileChooserDialog GtkFileChooserDialog; + + typedef struct _GtkActionClass GtkActionClass; + + typedef struct _GtkToggleActionClass GtkToggleActionClass; + + typedef struct _GtkVBoxClass GtkVBoxClass; + + typedef struct _GtkButtonBoxClass GtkButtonBoxClass; + + typedef struct _GtkHButtonBoxClass GtkHButtonBoxClass; + + typedef struct _GtkThemeEngine GtkThemeEngine; + + typedef struct _GtkTreeStoreClass GtkTreeStoreClass; + + typedef struct _GtkBoxChild GtkBoxChild; + + typedef struct _GtkHButtonBox GtkHButtonBox; + + typedef struct _GtkAccelGroupClass GtkAccelGroupClass; + + typedef struct _GtkSeparator GtkSeparator; + + typedef struct _GtkButtonClass GtkButtonClass; + + typedef void (*GtkWindowKeysForeachFunc) (GtkWindow *, guint, + GdkModifierType, gboolean, + gpointer); + + typedef struct _GtkIconFactoryClass GtkIconFactoryClass; + + typedef struct _GtkTreeSelectionClass GtkTreeSelectionClass; + + typedef enum { + GTK_MENU_DIR_PARENT = 0, + GTK_MENU_DIR_CHILD = 1, + GTK_MENU_DIR_NEXT = 2, + GTK_MENU_DIR_PREV = 3 + } GtkMenuDirectionType; + + typedef struct _GtkMenuShellClass GtkMenuShellClass; + + typedef struct _GtkTreeDragSourceIface GtkTreeDragSourceIface; + + typedef struct _GtkLabelClass GtkLabelClass; + + typedef struct _GtkScrollbar GtkScrollbar; + + typedef struct _GtkWidgetShapeInfo GtkWidgetShapeInfo; + + typedef struct _GtkActionGroupClass GtkActionGroupClass; + + typedef struct _GtkSettingsClass GtkSettingsClass; + + typedef struct _GtkIMContextClass GtkIMContextClass; + + typedef struct _GtkCellRendererClass GtkCellRendererClass; + + typedef struct _GtkToolButtonClass GtkToolButtonClass; + + typedef struct _GtkMenuToolButtonClass GtkMenuToolButtonClass; + + typedef struct _GtkVSeparator GtkVSeparator; + + typedef struct _GtkDrawingAreaClass GtkDrawingAreaClass; + + typedef struct _GtkTargetPair GtkTargetPair; + + typedef struct _GtkCellViewClass GtkCellViewClass; + + typedef struct _GtkCellLayoutIface GtkCellLayoutIface; + + typedef struct _GtkAlignmentPrivate GtkAlignmentPrivate; + + typedef struct _GtkFixedClass GtkFixedClass; + + typedef struct _GtkHScaleClass GtkHScaleClass; + + typedef struct _GtkScrollbarClass GtkScrollbarClass; + + typedef struct _GtkAccelLabelClass GtkAccelLabelClass; + + typedef void (*GtkModuleDisplayInitFunc) (GdkDisplay *); + + typedef struct _GtkTextBufferClass GtkTextBufferClass; + + typedef struct _GtkVRuler GtkVRuler; + + typedef struct _GtkSocketClass GtkSocketClass; + + typedef struct _GtkIconThemeClass GtkIconThemeClass; + + typedef struct _GtkVPaned GtkVPaned; + + typedef struct _GtkTableChild GtkTableChild; + + typedef struct _GtkArrowClass GtkArrowClass; + + typedef struct _GtkHScrollbar GtkHScrollbar; + + typedef struct _GtkFileChooserWidgetPrivate + GtkFileChooserWidgetPrivate; + + typedef struct _GtkFileChooserWidget GtkFileChooserWidget; + + typedef struct _GtkPlugClass GtkPlugClass; + + typedef struct _GtkCellRendererPixbufClass GtkCellRendererPixbufClass; + + typedef struct _GtkVButtonBoxClass GtkVButtonBoxClass; + + typedef struct _GtkTextChildAnchorClass GtkTextChildAnchorClass; + + typedef struct _GtkCellRendererCombo GtkCellRendererCombo; + + typedef struct _GtkTreeModelIface GtkTreeModelIface; + + typedef struct _GtkAccessibleClass GtkAccessibleClass; + + typedef struct _GtkCellRendererTextClass GtkCellRendererTextClass; + + typedef struct _GtkVScaleClass GtkVScaleClass; + + typedef struct _GtkCurveClass GtkCurveClass; + + typedef struct _GtkSeparatorToolItemClass GtkSeparatorToolItemClass; + + typedef struct _GtkStyleClass GtkStyleClass; + + typedef struct _GtkSeparatorMenuItemClass GtkSeparatorMenuItemClass; + + typedef struct _GtkIMMulticontextClass GtkIMMulticontextClass; + + typedef struct _GtkToggleToolButtonClass GtkToggleToolButtonClass; + + typedef struct _GtkRadioToolButtonClass GtkRadioToolButtonClass; + + typedef struct _GtkCellRendererProgressClass + GtkCellRendererProgressClass; + + typedef struct _GtkVScrollbar GtkVScrollbar; + + typedef struct _GtkVPanedClass GtkVPanedClass; + + typedef enum { + GTK_SCROLL_STEPS = 0, + GTK_SCROLL_PAGES = 1, + GTK_SCROLL_ENDS = 2, + GTK_SCROLL_HORIZONTAL_STEPS = 3, + GTK_SCROLL_HORIZONTAL_PAGES = 4, + GTK_SCROLL_HORIZONTAL_ENDS = 5 + } GtkScrollStep; + + typedef struct _GtkToggleButtonClass GtkToggleButtonClass; + + typedef struct _GtkCellRendererToggleClass GtkCellRendererToggleClass; + + typedef struct _GtkVButtonBox GtkVButtonBox; + + typedef struct _GtkTreeDragDestIface GtkTreeDragDestIface; + + typedef struct _GtkColorSelectionClass GtkColorSelectionClass; + + typedef struct _GtkCellRendererProgressPrivate + GtkCellRendererProgressPrivate; + + typedef struct _GtkCellRendererProgress GtkCellRendererProgress; + + typedef struct _GtkImageClass GtkImageClass; + + typedef struct _GtkMessageDialogClass GtkMessageDialogClass; + + typedef enum { + GTK_DELETE_CHARS = 0, + GTK_DELETE_WORD_ENDS = 1, + GTK_DELETE_WORDS = 2, + GTK_DELETE_DISPLAY_LINES = 3, + GTK_DELETE_DISPLAY_LINE_ENDS = 4, + GTK_DELETE_PARAGRAPH_ENDS = 5, + GTK_DELETE_PARAGRAPHS = 6, + GTK_DELETE_WHITESPACE = 7 + } GtkDeleteType; + + typedef struct _GtkTreeSortableIface GtkTreeSortableIface; + + typedef struct _GtkCalendarClass GtkCalendarClass; + + typedef struct _GtkEntryClass GtkEntryClass; + + typedef struct _GtkSpinButtonClass GtkSpinButtonClass; + + typedef struct _GtkInputDialog GtkInputDialog; + + typedef struct _GtkInputDialogClass GtkInputDialogClass; + + typedef struct _GtkEntryCompletionClass GtkEntryCompletionClass; + + typedef struct _GtkAlignmentClass GtkAlignmentClass; + + typedef struct _GtkTreeModelFilterClass GtkTreeModelFilterClass; + + typedef struct _GtkRcStyleClass GtkRcStyleClass; + + typedef struct _GtkUIManagerClass GtkUIManagerClass; + + typedef struct _GtkSeparatorClass GtkSeparatorClass; + + typedef struct _GtkVSeparatorClass GtkVSeparatorClass; + + typedef struct _GtkCheckButtonClass GtkCheckButtonClass; + + typedef enum { + GTK_VISIBILITY_NONE = 0, + GTK_VISIBILITY_PARTIAL = 1, + GTK_VISIBILITY_FULL = 2 + } GtkVisibility; + + typedef struct _GtkRadioMenuItemClass GtkRadioMenuItemClass; + + typedef struct _GtkTextViewClass GtkTextViewClass; + + typedef void (*GtkColorSelectionChangePaletteFunc) (const GdkColor *, + gint); + + typedef struct _GtkTreeModelSortClass GtkTreeModelSortClass; + + typedef struct _GtkCellEditableIface GtkCellEditableIface; + + typedef struct _GtkToolbarClass GtkToolbarClass; + + typedef struct _GtkHandleBoxClass GtkHandleBoxClass; + + typedef struct _GtkHSeparator GtkHSeparator; + + typedef struct _GtkTextTagTableClass GtkTextTagTableClass; + + typedef struct _GtkComboBoxClass GtkComboBoxClass; + + typedef struct _GtkComboBoxEntryClass GtkComboBoxEntryClass; + + typedef struct _GtkFontSelectionClass GtkFontSelectionClass; + + typedef struct _GtkFrameClass GtkFrameClass; + + typedef struct _GtkHScrollbarClass GtkHScrollbarClass; + + typedef struct _GtkFileSelectionClass GtkFileSelectionClass; + + typedef struct _GtkScrolledWindowClass GtkScrolledWindowClass; + + typedef struct _GtkTextMarkClass GtkTextMarkClass; + + typedef struct _GtkToolbarPrivate GtkToolbarPrivate; + + typedef struct _GtkVScale GtkVScale; + + typedef struct _GtkFixedChild GtkFixedChild; + + typedef struct _GtkLayoutClass GtkLayoutClass; + + typedef struct _GtkEventBoxClass GtkEventBoxClass; + + typedef struct _GtkIMContextSimpleClass GtkIMContextSimpleClass; + + typedef struct _GtkExpanderClass GtkExpanderClass; + + typedef struct _GtkProgressClass GtkProgressClass; + + typedef void (*GtkModuleInitFunc) (gint *, gchar * **); + + typedef struct _GtkFileChooserDialogClass GtkFileChooserDialogClass; + + typedef struct _GtkVScrollbarClass GtkVScrollbarClass; + + typedef struct _GtkTableClass GtkTableClass; + + typedef struct _GtkFontButtonClass GtkFontButtonClass; + + typedef struct _GtkHSeparatorClass GtkHSeparatorClass; + + typedef struct _GtkColorSelectionDialogClass + GtkColorSelectionDialogClass; + + typedef struct _GtkColorButtonClass GtkColorButtonClass; + + typedef struct _GtkMenuBar GtkMenuBar; + + typedef struct _GtkMenuBarClass GtkMenuBarClass; + + typedef struct _GtkColorSelectionDialog GtkColorSelectionDialog; + + typedef struct _GtkStatusbarClass GtkStatusbarClass; + + typedef struct _GtkSeparatorMenuItem GtkSeparatorMenuItem; + + typedef struct _GtkAboutDialogClass GtkAboutDialogClass; + + typedef struct _GtkListStoreClass GtkListStoreClass; + + typedef struct _GtkFileChooserButtonClass GtkFileChooserButtonClass; + + typedef enum { + GTK_TOOLBAR_SPACE_EMPTY = 0, + GTK_TOOLBAR_SPACE_LINE = 1 + } GtkToolbarSpaceStyle; + + typedef struct _GtkMenuClass GtkMenuClass; + + typedef struct _GtkHScale GtkHScale; + + typedef struct _GtkGammaCurveClass GtkGammaCurveClass; + + typedef struct _GtkCellRendererComboClass GtkCellRendererComboClass; + + typedef struct _GtkTearoffMenuItem GtkTearoffMenuItem; + + typedef struct _GtkNotebookClass GtkNotebookClass; + + typedef struct _GtkImageMenuItemClass GtkImageMenuItemClass; + + typedef struct _GtkTooltipsClass GtkTooltipsClass; + + typedef struct _GtkTreeViewClass GtkTreeViewClass; + + typedef struct _GtkFileChooserWidgetClass GtkFileChooserWidgetClass; + + typedef struct _GtkTearoffMenuItemClass GtkTearoffMenuItemClass; + + typedef struct _GtkRadioButtonClass GtkRadioButtonClass; + + typedef struct _GtkAdjustmentClass GtkAdjustmentClass; + + typedef struct _GtkHPaned GtkHPaned; + + typedef struct _GtkRadioActionClass GtkRadioActionClass; + + typedef struct _GtkTextTagClass GtkTextTagClass; + + typedef struct _GtkIconViewClass GtkIconViewClass; + + typedef struct _GtkProgressBarClass GtkProgressBarClass; + + typedef struct _GtkAspectFrameClass GtkAspectFrameClass; + + typedef struct _GtkGammaCurve GtkGammaCurve; + + typedef gboolean(*GtkAccelGroupActivate) (GtkAccelGroup *, GObject *, + guint, GdkModifierType); + + typedef enum { + GTK_IM_PREEDIT_NOTHING, + GTK_IM_PREEDIT_CALLBACK, + GTK_IM_PREEDIT_NONE + } GtkIMPreeditStyle; + + typedef enum { + GTK_DEBUG_MISC = 1 << 0, + GTK_DEBUG_PLUGSOCKET = 1 << 1, + GTK_DEBUG_TEXT = 1 << 2, + GTK_DEBUG_TREE = 1 << 3, + GTK_DEBUG_UPDATES = 1 << 4, + GTK_DEBUG_KEYBINDINGS = 1 << 5, + GTK_DEBUG_MULTIHEAD = 1 << 6, + GTK_DEBUG_MODULES = 1 << 7, + GTK_DEBUG_GEOMETRY = 1 << 8, + GTK_DEBUG_ICONTHEME = 1 << 9 + } GtkDebugFlag; + + typedef enum { + GTK_CELL_RENDERER_MODE_INERT, + GTK_CELL_RENDERER_MODE_ACTIVATABLE, + GTK_CELL_RENDERER_MODE_EDITABLE + } GtkCellRendererMode; + + typedef enum { + GTK_ICON_THEME_NOT_FOUND, + GTK_ICON_THEME_FAILED + } GtkIconThemeError; + + typedef enum { + GTK_RESPONSE_NONE = -1, + GTK_RESPONSE_REJECT = -2, + GTK_RESPONSE_ACCEPT = -3, + GTK_RESPONSE_DELETE_EVENT = -4, + GTK_RESPONSE_OK = -5, + GTK_RESPONSE_CANCEL = -6, + GTK_RESPONSE_CLOSE = -7, + GTK_RESPONSE_YES = -8, + GTK_RESPONSE_NO = -9, + GTK_RESPONSE_APPLY = -10, + GTK_RESPONSE_HELP = -11 + } GtkResponseType; + + typedef enum { + GTK_TARGET_SAME_APP = 1 << 0, + GTK_TARGET_SAME_WIDGET = 1 << 1 + } GtkTargetFlags; + + typedef enum { + GTK_ANCHOR_CENTER, + GTK_ANCHOR_NORTH, + GTK_ANCHOR_NORTH_WEST, + GTK_ANCHOR_NORTH_EAST, + GTK_ANCHOR_SOUTH, + GTK_ANCHOR_SOUTH_WEST, + GTK_ANCHOR_SOUTH_EAST, + GTK_ANCHOR_WEST, + GTK_ANCHOR_EAST, + GTK_ANCHOR_N = GTK_ANCHOR_NORTH, + GTK_ANCHOR_NW = GTK_ANCHOR_NORTH_WEST, + GTK_ANCHOR_NE = GTK_ANCHOR_NORTH_EAST, + GTK_ANCHOR_S = GTK_ANCHOR_SOUTH, + GTK_ANCHOR_SW = GTK_ANCHOR_SOUTH_WEST, + GTK_ANCHOR_SE = GTK_ANCHOR_SOUTH_EAST, + GTK_ANCHOR_W = GTK_ANCHOR_WEST, + GTK_ANCHOR_E = GTK_ANCHOR_EAST + } GtkAnchorType; + + typedef enum { + GTK_IM_STATUS_NOTHING, + GTK_IM_STATUS_CALLBACK, + GTK_IM_STATUS_NONE + } GtkIMStatusStyle; + + typedef enum { + GTK_FILE_CHOOSER_ERROR_NONEXISTENT, + GTK_FILE_CHOOSER_ERROR_BAD_FILENAME + } GtkFileChooserError; + + typedef enum { + GTK_IN_DESTRUCTION = 1 << 0, + GTK_FLOATING = 1 << 1, + GTK_RESERVED_1 = 1 << 2, + GTK_RESERVED_2 = 1 << 3 + } GtkObjectFlags; + + typedef enum { + GTK_RC_TOKEN_INVALID = G_TOKEN_LAST, + GTK_RC_TOKEN_INCLUDE, + GTK_RC_TOKEN_NORMAL, + GTK_RC_TOKEN_ACTIVE, + GTK_RC_TOKEN_PRELIGHT, + GTK_RC_TOKEN_SELECTED, + GTK_RC_TOKEN_INSENSITIVE, + GTK_RC_TOKEN_FG, + GTK_RC_TOKEN_BG, + GTK_RC_TOKEN_TEXT, + GTK_RC_TOKEN_BASE, + GTK_RC_TOKEN_XTHICKNESS, + GTK_RC_TOKEN_YTHICKNESS, + GTK_RC_TOKEN_FONT, + GTK_RC_TOKEN_FONTSET, + GTK_RC_TOKEN_FONT_NAME, + GTK_RC_TOKEN_BG_PIXMAP, + GTK_RC_TOKEN_PIXMAP_PATH, + GTK_RC_TOKEN_STYLE, + GTK_RC_TOKEN_BINDING, + GTK_RC_TOKEN_BIND, + GTK_RC_TOKEN_WIDGET, + GTK_RC_TOKEN_WIDGET_CLASS, + GTK_RC_TOKEN_CLASS, + GTK_RC_TOKEN_LOWEST, + GTK_RC_TOKEN_GTK, + GTK_RC_TOKEN_APPLICATION, + GTK_RC_TOKEN_THEME, + GTK_RC_TOKEN_RC, + GTK_RC_TOKEN_HIGHEST, + GTK_RC_TOKEN_ENGINE, + GTK_RC_TOKEN_MODULE_PATH, + GTK_RC_TOKEN_IM_MODULE_PATH, + GTK_RC_TOKEN_IM_MODULE_FILE, + GTK_RC_TOKEN_STOCK, + GTK_RC_TOKEN_LTR, + GTK_RC_TOKEN_RTL, + GTK_RC_TOKEN_LAST + } GtkRcTokenType; + + typedef enum { + GTK_TOPLEVEL = 1 << 4, + GTK_NO_WINDOW = 1 << 5, + GTK_REALIZED = 1 << 6, + GTK_MAPPED = 1 << 7, + GTK_VISIBLE = 1 << 8, + GTK_SENSITIVE = 1 << 9, + GTK_PARENT_SENSITIVE = 1 << 10, + GTK_CAN_FOCUS = 1 << 11, + GTK_HAS_FOCUS = 1 << 12, + GTK_CAN_DEFAULT = 1 << 13, + GTK_HAS_DEFAULT = 1 << 14, + GTK_HAS_GRAB = 1 << 15, + GTK_RC_STYLE = 1 << 16, + GTK_COMPOSITE_CHILD = 1 << 17, + GTK_NO_REPARENT = 1 << 18, + GTK_APP_PAINTABLE = 1 << 19, + GTK_RECEIVES_DEFAULT = 1 << 20, + GTK_DOUBLE_BUFFERED = 1 << 21, + GTK_NO_SHOW_ALL = 1 << 22 + } GtkWidgetFlags; + + enum { + GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID = -1, + GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID = -2 + }; + + + + + + struct _GtkObject { + GObject parent_instance; + guint32 flags; + }; + + + struct _GtkRcStyle { + GObject parent_instance; + gchar *name; + gchar *bg_pixmap_name[5]; + PangoFontDescription *font_desc; + GtkRcFlags color_flags[5]; + GdkColor fg[5]; + GdkColor bg[5]; + GdkColor text[5]; + GdkColor base[5]; + gint xthickness; + gint ythickness; + GArray *rc_properties; + GSList *rc_style_lists; + GSList *icon_factories; + guint engine_specified:1; + }; + + + struct _GtkStyle { + GObject parent_instance; + GdkColor fg[5]; + GdkColor bg[5]; + GdkColor light[5]; + GdkColor dark[5]; + GdkColor mid[5]; + GdkColor text[5]; + GdkColor base[5]; + GdkColor text_aa[5]; + GdkColor black; + GdkColor white; + PangoFontDescription *font_desc; + gint xthickness; + gint ythickness; + GdkGC *fg_gc[5]; + GdkGC *bg_gc[5]; + GdkGC *light_gc[5]; + GdkGC *dark_gc[5]; + GdkGC *mid_gc[5]; + GdkGC *text_gc[5]; + GdkGC *base_gc[5]; + GdkGC *text_aa_gc[5]; + GdkGC *black_gc; + GdkGC *white_gc; + GdkPixmap *bg_pixmap[5]; + gint attach_count; + gint depth; + GdkColormap *colormap; + GdkFont *private_font; + PangoFontDescription *private_font_desc; + GtkRcStyle *rc_style; + GSList *styles; + GArray *property_cache; + GSList *icon_factories; + }; + + + struct _GtkRequisition { + gint width; + gint height; + }; + + + struct _GtkWidget { + GtkObject object; + guint16 private_flags; + guint8 state; + guint8 saved_state; + gchar *name; + GtkStyle *style; + GtkRequisition requisition; + GtkAllocation allocation; + GdkWindow *window; + GtkWidget *parent; + }; + + + struct _GtkAdjustment { + GtkObject parent_instance; + gdouble lower; + gdouble upper; + gdouble value; + gdouble step_increment; + gdouble page_increment; + gdouble page_size; + }; + + + struct _GtkProgress { + GtkWidget widget; + GtkAdjustment *adjustment; + GdkPixmap *offscreen_pixmap; + gchar *format; + gfloat x_align; + gfloat y_align; + guint show_text:1; + guint activity_mode:1; + guint use_text_format:1; + }; + + + struct _GtkProgressBar { + GtkProgress progress; + GtkProgressBarStyle bar_style; + GtkProgressBarOrientation orientation; + guint blocks; + gint in_block; + gint activity_pos; + guint activity_step; + guint activity_blocks; + gdouble pulse_fraction; + guint activity_dir:1; + guint ellipsize:3; + }; + + + struct _GtkTextTagTable { + GObject parent_instance; + GHashTable *hash; + GSList *anonymous; + gint anon_count; + GSList *buffers; + }; + + + + + + + + + struct _GtkTextBuffer { + GObject parent_instance; + GtkTextTagTable *tag_table; + GtkTextBTree *btree; + GSList *clipboard_contents_buffers; + GSList *selection_clipboards; + GtkTextLogAttrCache *log_attr_cache; + guint user_action_count; + guint modified:1; + }; + + + struct _GtkTextIter { + gpointer dummy1; + gpointer dummy2; + gint dummy3; + gint dummy4; + gint dummy5; + gint dummy6; + gint dummy7; + gint dummy8; + gpointer dummy9; + gpointer dummy10; + gint dummy11; + gint dummy12; + gint dummy13; + gpointer dummy14; + }; + + + struct _GtkContainer { + GtkWidget widget; + GtkWidget *focus_child; + guint border_width:16; + guint need_resize:1; + guint resize_mode:2; + guint reallocate_redraws:1; + guint has_focus_chain:1; + }; + + + struct _GtkBin { + GtkContainer container; + GtkWidget *child; + }; + + + + + + struct _GtkComboBox { + GtkBin parent_instance; + GtkComboBoxPrivate *priv; + }; + + + struct _GtkMisc { + GtkWidget widget; + gfloat xalign; + gfloat yalign; + guint16 xpad; + guint16 ypad; + }; + + + struct _GtkBox { + GtkContainer container; + GList *children; + gint16 spacing; + guint homogeneous:1; + }; + + + struct _GtkHBox { + GtkBox box; + }; + + + struct _GtkStatusbar { + GtkHBox parent_widget; + GtkWidget *frame; + GtkWidget *label; + GSList *messages; + GSList *keys; + guint seq_context_id; + guint seq_message_id; + GdkWindow *grip_window; + guint has_resize_grip:1; + }; + + + struct _GtkTargetList { + GList *list; + guint ref_count; + }; + + + struct _GtkWindow { + GtkBin bin; + gchar *title; + gchar *wmclass_name; + gchar *wmclass_class; + gchar *wm_role; + GtkWidget *focus_widget; + GtkWidget *default_widget; + GtkWindow *transient_parent; + GtkWindowGeometryInfo *geometry_info; + GdkWindow *frame; + GtkWindowGroup *group; + guint16 configure_request_count; + guint allow_shrink:1; + guint allow_grow:1; + guint configure_notify_received:1; + guint need_default_position:1; + guint need_default_size:1; + guint position:3; + guint type:4; + guint has_user_ref_count:1; + guint has_focus:1; + guint modal:1; + guint destroy_with_parent:1; + guint has_frame:1; + guint iconify_initially:1; + guint stick_initially:1; + guint maximize_initially:1; + guint decorated:1; + guint type_hint:3; + guint gravity:5; + guint is_active:1; + guint has_toplevel_focus:1; + guint frame_left; + guint frame_top; + guint frame_right; + guint frame_bottom; + guint keys_changed_handler; + GdkModifierType mnemonic_modifier; + GdkScreen *screen; + }; + + + + + + struct _GtkWindowGroup { + GObject parent_instance; + GSList *grabs; + }; + + + + + + + + + struct _GtkTargetEntry { + gchar *target; + guint flags; + guint info; + }; + + + struct _GtkIMContext { + GObject parent_instance; + }; + + + struct _GtkEntry { + GtkWidget widget; + gchar *text; + guint editable:1; + guint visible:1; + guint overwrite_mode:1; + guint in_drag:1; + guint16 text_length; + guint16 text_max_length; + GdkWindow *text_area; + GtkIMContext *im_context; + GtkWidget *popup_menu; + gint current_pos; + gint selection_bound; + PangoLayout *cached_layout; + guint cache_includes_preedit:1; + guint need_im_reset:1; + guint has_frame:1; + guint activates_default:1; + guint cursor_visible:1; + guint in_click:1; + guint is_cell_renderer:1; + guint editing_canceled:1; + guint mouse_cursor_obscured:1; + guint select_words:1; + guint select_lines:1; + guint resolved_dir:4; + guint button; + guint blink_timeout; + guint recompute_idle; + gint scroll_offset; + gint ascent; + gint descent; + guint16 text_size; + guint16 n_bytes; + guint16 preedit_length; + guint16 preedit_cursor; + gint dnd_position; + gint drag_start_x; + gint drag_start_y; + gunichar invisible_char; + gint width_chars; + }; + + + + + + struct _GtkComboBoxEntry { + GtkComboBox parent_instance; + GtkComboBoxEntryPrivate *priv; + }; + + + struct _GtkLayout { + GtkContainer container; + GList *children; + guint width; + guint height; + GtkAdjustment *hadjustment; + GtkAdjustment *vadjustment; + GdkWindow *bin_window; + GdkVisibilityState visibility; + gint scroll_x; + gint scroll_y; + guint freeze_count; + }; + + + struct _GtkTreeIter { + gint stamp; + gpointer user_data; + gpointer user_data2; + gpointer user_data3; + }; + + + struct _GtkTreeStore { + GObject parent; + gint stamp; + gpointer root; + gpointer last; + gint n_columns; + gint sort_column_id; + GList *sort_list; + GtkSortType order; + GType *column_headers; + GtkTreeIterCompareFunc default_sort_func; + gpointer default_sort_data; + GtkDestroyNotify default_sort_destroy; + guint columns_dirty:1; + }; + + + struct _GtkDialog { + GtkWindow window; + GtkWidget *vbox; + GtkWidget *action_area; + GtkWidget *separator; + }; + + + struct _GtkAboutDialog { + GtkDialog parent_instance; + gpointer private_data; + }; + + + + + + + + + + + + struct _GtkRange { + GtkWidget widget; + GtkAdjustment *adjustment; + GtkUpdateType update_policy; + guint inverted:1; + guint flippable:1; + guint has_stepper_a:1; + guint has_stepper_b:1; + guint has_stepper_c:1; + guint has_stepper_d:1; + guint need_recalc:1; + guint slider_size_fixed:1; + gint min_slider_size; + GtkOrientation orientation; + GdkRectangle range_rect; + gint slider_start; + gint slider_end; + gint round_digits; + guint trough_click_forward:1; + guint update_pending:1; + GtkRangeLayout *layout; + GtkRangeStepTimer *timer; + gint slide_initial_slider_position; + gint slide_initial_coordinate; + guint update_timeout_id; + GdkWindow *event_window; + }; + + + struct _GtkAccelKey { + guint accel_key; + GdkModifierType accel_mods; + guint accel_flags:16; + }; + + + struct _GtkAccelGroupEntry { + GtkAccelKey key; + GClosure *closure; + GQuark accel_path_quark; + }; + + + struct _GtkAccelGroup { + GObject parent; + guint lock_count; + GdkModifierType modifier_mask; + GSList *acceleratables; + guint n_accels; + GtkAccelGroupEntry *priv_accels; + }; + + + struct _GtkSocket { + GtkContainer container; + guint16 request_width; + guint16 request_height; + guint16 current_width; + guint16 current_height; + GdkWindow *plug_window; + GtkWidget *plug_widget; + gshort xembed_version; + guint same_app:1; + guint focus_in:1; + guint have_size:1; + guint need_map:1; + guint is_mapped:1; + guint active:1; + GtkAccelGroup *accel_group; + GtkWidget *toplevel; + }; + + + + + + struct _GtkTreeViewColumn { + GtkObject parent; + GtkWidget *tree_view; + GtkWidget *button; + GtkWidget *child; + GtkWidget *arrow; + GtkWidget *alignment; + GdkWindow *window; + GtkCellEditable *editable_widget; + gfloat xalign; + guint property_changed_signal; + gint spacing; + GtkTreeViewColumnSizing column_type; + gint requested_width; + gint button_request; + gint resized_width; + gint width; + gint fixed_width; + gint min_width; + gint max_width; + gint drag_x; + gint drag_y; + gchar *title; + GList *cell_list; + guint sort_clicked_signal; + guint sort_column_changed_signal; + gint sort_column_id; + GtkSortType sort_order; + guint visible:1; + guint resizable:1; + guint clickable:1; + guint dirty:1; + guint show_sort_indicator:1; + guint maybe_reordered:1; + guint reorderable:1; + guint use_resized_width:1; + guint expand:1; + }; + + + struct _GtkCellRenderer { + GtkObject parent; + gfloat xalign; + gfloat yalign; + gint width; + gint height; + guint16 xpad; + guint16 ypad; + guint mode:2; + guint visible:1; + guint is_expander:1; + guint is_expanded:1; + guint cell_background_set:1; + guint sensitive:1; + guint editing:1; + }; + + + struct _GtkButtonBox { + GtkBox box; + gint child_min_width; + gint child_min_height; + gint child_ipad_x; + gint child_ipad_y; + GtkButtonBoxStyle layout_style; + }; + + + + + + struct _GtkAction { + GObject object; + GtkActionPrivate *private_data; + }; + + + + + + struct _GtkToggleAction { + GtkAction parent; + GtkToggleActionPrivate *private_data; + }; + + + struct _GtkTextAppearance { + GdkColor bg_color; + GdkColor fg_color; + GdkBitmap *bg_stipple; + GdkBitmap *fg_stipple; + gint rise; + gpointer padding1; + guint underline:4; + guint strikethrough:1; + guint draw_bg:1; + guint inside_selection:1; + guint is_text:1; + guint pad1:1; + guint pad2:1; + guint pad3:1; + guint pad4:1; + }; + + + struct _GtkTextAttributes { + guint refcount; + GtkTextAppearance appearance; + GtkJustification justification; + GtkTextDirection direction; + PangoFontDescription *font; + gdouble font_scale; + gint left_margin; + gint indent; + gint right_margin; + gint pixels_above_lines; + gint pixels_below_lines; + gint pixels_inside_wrap; + PangoTabArray *tabs; + GtkWrapMode wrap_mode; + PangoLanguage *language; + gpointer padding1; + guint invisible:1; + guint bg_full_height:1; + guint editable:1; + guint realized:1; + guint pad1:1; + guint pad2:1; + guint pad3:1; + guint pad4:1; + }; + + + struct _GtkTextTag { + GObject parent_instance; + GtkTextTagTable *table; + char *name; + int priority; + GtkTextAttributes *values; + guint bg_color_set:1; + guint bg_stipple_set:1; + guint fg_color_set:1; + guint scale_set:1; + guint fg_stipple_set:1; + guint justification_set:1; + guint left_margin_set:1; + guint indent_set:1; + guint rise_set:1; + guint strikethrough_set:1; + guint right_margin_set:1; + guint pixels_above_lines_set:1; + guint pixels_below_lines_set:1; + guint pixels_inside_wrap_set:1; + guint tabs_set:1; + guint underline_set:1; + guint wrap_mode_set:1; + guint bg_full_height_set:1; + guint invisible_set:1; + guint editable_set:1; + guint language_set:1; + guint pad1:1; + guint pad2:1; + guint pad3:1; + }; + + + + + + struct _GtkFileFilterInfo { + GtkFileFilterFlags contains; + const gchar *filename; + const gchar *uri; + const gchar *display_name; + const gchar *mime_type; + }; + + + + + + + + + struct _GtkToolItem { + GtkBin parent; + GtkToolItemPrivate *priv; + }; + + + + + + struct _GtkToolButton { + GtkToolItem parent; + GtkToolButtonPrivate *priv; + }; + + + + + + struct _GtkIconView { + GtkContainer parent; + GtkIconViewPrivate *priv; + }; + + + + + + struct _GtkLabel { + GtkMisc misc; + gchar *label; + guint jtype:2; + guint wrap:1; + guint use_underline:1; + guint use_markup:1; + guint ellipsize:3; + guint mnemonic_keyval; + gchar *text; + PangoAttrList *attrs; + PangoAttrList *effective_attrs; + PangoLayout *layout; + GtkWidget *mnemonic_widget; + GtkWindow *mnemonic_window; + GtkLabelSelectionInfo *select_info; + }; + + + + + + + + + struct _GtkSettings { + GObject parent_instance; + GData *queued_settings; + GtkSettingsPropertyValue *property_values; + GtkRcContext *rc_context; + GdkScreen *screen; + }; + + + + + + struct _GtkUIManager { + GObject parent; + GtkUIManagerPrivate *private_data; + }; + + + struct _GtkItem { + GtkBin bin; + }; + + + struct _GtkMenuItem { + GtkItem item; + GtkWidget *submenu; + GdkWindow *event_window; + guint16 toggle_size; + guint16 accelerator_width; + gchar *accel_path; + guint show_submenu_indicator:1; + guint submenu_placement:1; + guint submenu_direction:1; + guint right_justify:1; + guint timer_from_keypress:1; + guint timer; + }; + + + struct _GtkCheckMenuItem { + GtkMenuItem menu_item; + guint active:1; + guint always_show_toggle:1; + guint inconsistent:1; + guint draw_as_radio:1; + }; + + + struct _GtkRadioMenuItem { + GtkCheckMenuItem check_menu_item; + GSList *group; + }; + + + + + + struct _GtkCellView { + GtkWidget parent_instance; + GtkCellViewPrivate *priv; + }; + + + struct _GtkSelectionData { + GdkAtom selection; + GdkAtom target; + GdkAtom type; + gint format; + guchar *data; + gint length; + GdkDisplay *display; + }; + + + + + + struct _GtkDrawingArea { + GtkWidget widget; + gpointer draw_data; + }; + + + struct _GtkCurve { + GtkDrawingArea graph; + gint cursor_type; + gfloat min_x; + gfloat max_x; + gfloat min_y; + gfloat max_y; + GdkPixmap *pixmap; + GtkCurveType curve_type; + gint height; + gint grab_point; + gint last; + gint num_points; + GdkPoint *point; + gint num_ctlpoints; + gfloat *ctlpoint; + }; + + + + + + struct _GtkNotebook { + GtkContainer container; + GtkNotebookPage *cur_page; + GList *children; + GList *first_tab; + GList *focus_tab; + GtkWidget *menu; + GdkWindow *event_window; + guint32 timer; + guint16 tab_hborder; + guint16 tab_vborder; + guint show_tabs:1; + guint homogeneous:1; + guint show_border:1; + guint tab_pos:2; + guint scrollable:1; + guint in_child:3; + guint click_child:3; + guint button:2; + guint need_timer:1; + guint child_has_focus:1; + guint have_visible_child:1; + guint focus_out:1; + guint has_before_previous:1; + guint has_before_next:1; + guint has_after_previous:1; + guint has_after_next:1; + }; + + + struct _GtkIconFactory { + GObject parent_instance; + GHashTable *icons; + }; + + + + + + struct _GtkRadioAction { + GtkToggleAction parent; + GtkRadioActionPrivate *private_data; + }; + + + struct _GtkTextMark { + GObject parent_instance; + gpointer segment; + }; + + + struct _GtkVBox { + GtkBox box; + }; + + + struct _GtkColorSelection { + GtkVBox parent_instance; + gpointer private_data; + }; + + + struct _GtkCalendar { + GtkWidget widget; + GtkStyle *header_style; + GtkStyle *label_style; + gint month; + gint year; + gint selected_day; + gint day_month[6][7]; + gint day[6][7]; + gint num_marked_dates; + gint marked_date[31]; + GtkCalendarDisplayOptions display_flags; + GdkColor marked_date_color[31]; + GdkGC *gc; + GdkGC *xor_gc; + gint focus_row; + gint focus_col; + gint highlight_row; + gint highlight_col; + gpointer private_data; + gchar grow_space[32]; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + + + + + + + + + + struct _GtkTableRowCol { + guint16 requisition; + guint16 allocation; + guint16 spacing; + guint need_expand:1; + guint need_shrink:1; + guint expand:1; + guint shrink:1; + guint empty:1; + }; + + + struct _GtkTable { + GtkContainer container; + GList *children; + GtkTableRowCol *rows; + GtkTableRowCol *cols; + guint16 nrows; + guint16 ncols; + guint16 column_spacing; + guint16 row_spacing; + guint homogeneous:1; + }; + + + + + + struct _GtkMenuShell { + GtkContainer container; + GList *children; + GtkWidget *active_menu_item; + GtkWidget *parent_menu_shell; + guint button; + guint32 activate_time; + guint active:1; + guint have_grab:1; + guint have_xgrab:1; + guint ignore_leave:1; + guint menu_flag:1; + guint ignore_enter:1; + }; + + + struct _GtkMenu { + GtkMenuShell menu_shell; + GtkWidget *parent_menu_item; + GtkWidget *old_active_menu_item; + GtkAccelGroup *accel_group; + gchar *accel_path; + GtkMenuPositionFunc position_func; + gpointer position_func_data; + guint toggle_size; + GtkWidget *toplevel; + GtkWidget *tearoff_window; + GtkWidget *tearoff_hbox; + GtkWidget *tearoff_scrollbar; + GtkAdjustment *tearoff_adjustment; + GdkWindow *view_window; + GdkWindow *bin_window; + gint scroll_offset; + gint saved_scroll_offset; + gint scroll_step; + guint timeout_id; + GdkRegion *navigation_region; + guint navigation_timeout; + guint needs_destruction_ref_count:1; + guint torn_off:1; + guint tearoff_active:1; + guint scroll_fast:1; + guint upper_arrow_visible:1; + guint lower_arrow_visible:1; + guint upper_arrow_prelight:1; + guint lower_arrow_prelight:1; + }; + + + struct _GtkButton { + GtkBin bin; + GdkWindow *event_window; + gchar *label_text; + guint activate_timeout; + guint constructed:1; + guint in_button:1; + guint button_down:1; + guint relief:2; + guint use_underline:1; + guint use_stock:1; + guint depressed:1; + guint depress_on_activate:1; + guint focus_on_click:1; + }; + + + struct _GtkToggleButton { + GtkButton button; + guint active:1; + guint draw_indicator:1; + guint inconsistent:1; + }; + + + + + + struct _GtkIconTheme { + GObject parent_instance; + GtkIconThemePrivate *priv; + }; + + + + + + + + + struct _GtkTextView { + GtkContainer parent_instance; + struct _GtkTextLayout *layout; + GtkTextBuffer *buffer; + guint selection_drag_handler; + guint scroll_timeout; + gint pixels_above_lines; + gint pixels_below_lines; + gint pixels_inside_wrap; + GtkWrapMode wrap_mode; + GtkJustification justify; + gint left_margin; + gint right_margin; + gint indent; + PangoTabArray *tabs; + guint editable:1; + guint overwrite_mode:1; + guint cursor_visible:1; + guint need_im_reset:1; + guint accepts_tab:1; + guint reserved:1; + guint onscreen_validated:1; + guint mouse_cursor_obscured:1; + GtkTextWindow *text_window; + GtkTextWindow *left_window; + GtkTextWindow *right_window; + GtkTextWindow *top_window; + GtkTextWindow *bottom_window; + GtkAdjustment *hadjustment; + GtkAdjustment *vadjustment; + gint xoffset; + gint yoffset; + gint width; + gint height; + gint virtual_cursor_x; + gint virtual_cursor_y; + GtkTextMark *first_para_mark; + gint first_para_pixels; + GtkTextMark *dnd_mark; + guint blink_timeout; + guint first_validate_idle; + guint incremental_validate_idle; + GtkIMContext *im_context; + GtkWidget *popup_menu; + gint drag_start_x; + gint drag_start_y; + GSList *children; + GtkTextPendingScroll *pending_scroll; + gint pending_place_cursor_button; + }; + + + struct _GtkObjectClass { + GObjectClass parent_class; + void (*set_arg) (GtkObject *, GtkArg *, guint); + void (*get_arg) (GtkObject *, GtkArg *, guint); + void (*destroy) (GtkObject *); + }; + + + struct _GtkWidgetClass { + GtkObjectClass parent_class; + guint activate_signal; + guint set_scroll_adjustments_signal; + void (*dispatch_child_properties_changed) (GtkWidget *, guint, + GParamSpec * *); + void (*show) (GtkWidget *); + void (*show_all) (GtkWidget *); + void (*hide) (GtkWidget *); + void (*hide_all) (GtkWidget *); + void (*map) (GtkWidget *); + void (*unmap) (GtkWidget *); + void (*realize) (GtkWidget *); + void (*unrealize) (GtkWidget *); + void (*size_request) (GtkWidget *, GtkRequisition *); + void (*size_allocate) (GtkWidget *, GtkAllocation *); + void (*state_changed) (GtkWidget *, GtkStateType); + void (*parent_set) (GtkWidget *, GtkWidget *); + void (*hierarchy_changed) (GtkWidget *, GtkWidget *); + void (*style_set) (GtkWidget *, GtkStyle *); + void (*direction_changed) (GtkWidget *, GtkTextDirection); + void (*grab_notify) (GtkWidget *, gboolean); + void (*child_notify) (GtkWidget *, GParamSpec *); + gboolean(*mnemonic_activate) (GtkWidget *, gboolean); + void (*grab_focus) (GtkWidget *); + gboolean(*focus) (GtkWidget *, GtkDirectionType); + gboolean(*event) (GtkWidget *, GdkEvent *); + gboolean(*button_press_event) (GtkWidget *, GdkEventButton *); + gboolean(*button_release_event) (GtkWidget *, GdkEventButton *); + gboolean(*scroll_event) (GtkWidget *, GdkEventScroll *); + gboolean(*motion_notify_event) (GtkWidget *, GdkEventMotion *); + gboolean(*delete_event) (GtkWidget *, GdkEventAny *); + gboolean(*destroy_event) (GtkWidget *, GdkEventAny *); + gboolean(*expose_event) (GtkWidget *, GdkEventExpose *); + gboolean(*key_press_event) (GtkWidget *, GdkEventKey *); + gboolean(*key_release_event) (GtkWidget *, GdkEventKey *); + gboolean(*enter_notify_event) (GtkWidget *, GdkEventCrossing *); + gboolean(*leave_notify_event) (GtkWidget *, GdkEventCrossing *); + gboolean(*configure_event) (GtkWidget *, GdkEventConfigure *); + gboolean(*focus_in_event) (GtkWidget *, GdkEventFocus *); + gboolean(*focus_out_event) (GtkWidget *, GdkEventFocus *); + gboolean(*map_event) (GtkWidget *, GdkEventAny *); + gboolean(*unmap_event) (GtkWidget *, GdkEventAny *); + gboolean(*property_notify_event) (GtkWidget *, + GdkEventProperty *); + gboolean(*selection_clear_event) (GtkWidget *, + GdkEventSelection *); + gboolean(*selection_request_event) (GtkWidget *, + GdkEventSelection *); + gboolean(*selection_notify_event) (GtkWidget *, + GdkEventSelection *); + gboolean(*proximity_in_event) (GtkWidget *, GdkEventProximity *); + gboolean(*proximity_out_event) (GtkWidget *, GdkEventProximity *); + gboolean(*visibility_notify_event) (GtkWidget *, + GdkEventVisibility *); + gboolean(*client_event) (GtkWidget *, GdkEventClient *); + gboolean(*no_expose_event) (GtkWidget *, GdkEventAny *); + gboolean(*window_state_event) (GtkWidget *, + GdkEventWindowState *); + void (*selection_get) (GtkWidget *, GtkSelectionData *, guint, + guint); + void (*selection_received) (GtkWidget *, GtkSelectionData *, + guint); + void (*drag_begin) (GtkWidget *, GdkDragContext *); + void (*drag_end) (GtkWidget *, GdkDragContext *); + void (*drag_data_get) (GtkWidget *, GdkDragContext *, + GtkSelectionData *, guint, guint); + void (*drag_data_delete) (GtkWidget *, GdkDragContext *); + void (*drag_leave) (GtkWidget *, GdkDragContext *, guint); + gboolean(*drag_motion) (GtkWidget *, GdkDragContext *, gint, gint, + guint); + gboolean(*drag_drop) (GtkWidget *, GdkDragContext *, gint, gint, + guint); + void (*drag_data_received) (GtkWidget *, GdkDragContext *, gint, + gint, GtkSelectionData *, guint, + guint); + gboolean(*popup_menu) (GtkWidget *); + gboolean(*show_help) (GtkWidget *, GtkWidgetHelpType); + AtkObject *(*get_accessible) (GtkWidget *); + void (*screen_changed) (GtkWidget *, GdkScreen *); + gboolean(*can_activate_accel) (GtkWidget *, guint); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + void (*_gtk_reserved5) (void); + void (*_gtk_reserved6) (void); + void (*_gtk_reserved7) (void); + }; + + + struct _GtkImagePixmapData { + GdkPixmap *pixmap; + }; + + + struct _GtkImageImageData { + GdkImage *image; + }; + + + struct _GtkImagePixbufData { + GdkPixbuf *pixbuf; + }; + + + struct _GtkImageStockData { + gchar *stock_id; + }; + + + struct _GtkImageIconSetData { + GtkIconSet *icon_set; + }; + + + struct _GtkImageAnimationData { + GdkPixbufAnimation *anim; + GdkPixbufAnimationIter *iter; + guint frame_timeout; + }; + + + struct _GtkImageIconNameData { + gchar *icon_name; + GdkPixbuf *pixbuf; + guint theme_change_id; + }; + + + struct _GtkImage { + GtkMisc misc; + GtkImageType storage_type; + union { + GtkImagePixmapData pixmap; + GtkImageImageData image; + GtkImagePixbufData pixbuf; + GtkImageStockData stock; + GtkImageIconSetData icon_set; + GtkImageAnimationData anim; + GtkImageIconNameData name; + } data; + GdkBitmap *mask; + GtkIconSize icon_size; + }; + + + + + + struct _GtkTreeView { + GtkContainer parent; + GtkTreeViewPrivate *priv; + }; + + + struct _GtkSpinButton { + GtkEntry entry; + GtkAdjustment *adjustment; + GdkWindow *panel; + guint32 timer; + gdouble climb_rate; + gdouble timer_step; + GtkSpinButtonUpdatePolicy update_policy; + guint in_child:2; + guint click_child:2; + guint button:2; + guint need_timer:1; + guint timer_calls:3; + guint digits:10; + guint numeric:1; + guint wrap:1; + guint snap_to_ticks:1; + }; + + + + + + struct _GtkFileSelection { + GtkDialog parent_instance; + GtkWidget *dir_list; + GtkWidget *file_list; + GtkWidget *selection_entry; + GtkWidget *selection_text; + GtkWidget *main_vbox; + GtkWidget *ok_button; + GtkWidget *cancel_button; + GtkWidget *help_button; + GtkWidget *history_pulldown; + GtkWidget *history_menu; + GList *history_list; + GtkWidget *fileop_dialog; + GtkWidget *fileop_entry; + gchar *fileop_file; + gpointer cmpl_state; + GtkWidget *fileop_c_dir; + GtkWidget *fileop_del_file; + GtkWidget *fileop_ren_file; + GtkWidget *button_area; + GtkWidget *action_area; + GPtrArray *selected_names; + gchar *last_selected; + }; + + + struct _GtkTooltips { + GtkObject parent_instance; + GtkWidget *tip_window; + GtkWidget *tip_label; + GtkTooltipsData *active_tips_data; + GList *tips_data_list; + guint delay:30; + guint enabled:1; + guint have_grab:1; + guint use_sticky_delay:1; + gint timer_tag; + GTimeVal last_popdown; + }; + + + struct _GtkTooltipsData { + GtkTooltips *tooltips; + GtkWidget *widget; + gchar *tip_text; + gchar *tip_private; + }; + + + + + + struct _GtkEntryCompletion { + GObject parent_instance; + GtkEntryCompletionPrivate *priv; + }; + + + + + + + + + struct _GtkTreeModelFilter { + GObject parent; + GtkTreeModelFilterPrivate *priv; + }; + + + struct _GtkTreeModelSort { + GObject parent; + gpointer root; + gint stamp; + guint child_flags; + GtkTreeModel *child_model; + gint zero_ref_count; + GList *sort_list; + gint sort_column_id; + GtkSortType order; + GtkTreeIterCompareFunc default_sort_func; + gpointer default_sort_data; + GtkDestroyNotify default_sort_destroy; + guint changed_id; + guint inserted_id; + guint has_child_toggled_id; + guint deleted_id; + guint reordered_id; + }; + + + + + + struct _GtkColorButton { + GtkButton button; + GtkColorButtonPrivate *priv; + }; + + + struct _GtkHandleBox { + GtkBin bin; + GdkWindow *bin_window; + GdkWindow *float_window; + GtkShadowType shadow_type; + guint handle_position:2; + guint float_window_mapped:1; + guint child_detached:1; + guint in_drag:1; + guint shrink_on_detach:1; + int snap_edge:3; + gint deskoff_x; + gint deskoff_y; + GtkAllocation attach_allocation; + GtkAllocation float_allocation; + }; + + + + + + struct _GtkActionGroup { + GObject parent; + GtkActionGroupPrivate *private_data; + }; + + + struct _GtkBindingSet { + gchar *set_name; + gint priority; + GSList *widget_path_pspecs; + GSList *widget_class_pspecs; + GSList *class_branch_pspecs; + GtkBindingEntry *entries; + GtkBindingEntry *current; + guint parsed:1; + }; + + + struct _GtkBindingEntry { + guint keyval; + GdkModifierType modifiers; + GtkBindingSet *binding_set; + guint destroyed:1; + guint in_emission:1; + GtkBindingEntry *set_next; + GtkBindingEntry *hash_next; + GtkBindingSignal *signals; + }; + + + struct _GtkBindingSignal { + GtkBindingSignal *next; + gchar *signal_name; + guint n_args; + GtkBindingArg *args; + }; + + + struct _GtkBindingArg { + GType arg_type; + union { + glong long_data; + gdouble double_data; + gchar *string_data; + } d; + }; + + + struct _GtkScrolledWindow { + GtkBin container; + GtkWidget *hscrollbar; + GtkWidget *vscrollbar; + guint hscrollbar_policy:2; + guint vscrollbar_policy:2; + guint hscrollbar_visible:1; + guint vscrollbar_visible:1; + guint window_placement:2; + guint focus_out:1; + guint16 shadow_type; + }; + + + struct _GtkFrame { + GtkBin bin; + GtkWidget *label_widget; + gint16 shadow_type; + gfloat label_xalign; + gfloat label_yalign; + GtkAllocation child_allocation; + }; + + + struct _GtkTextChildAnchor { + GObject parent_instance; + gpointer segment; + }; + + + + + + struct _GtkSeparatorToolItem { + GtkToolItem parent; + GtkSeparatorToolItemPrivate *priv; + }; + + + struct _GtkTreeSelection { + GObject parent; + GtkTreeView *tree_view; + GtkSelectionMode type; + GtkTreeSelectionFunc user_func; + gpointer user_data; + GtkDestroyNotify destroy; + }; + + + + + + struct _GtkExpander { + GtkBin bin; + GtkExpanderPrivate *priv; + }; + + + struct _GtkFontSelectionDialog { + GtkDialog parent_instance; + GtkWidget *fontsel; + GtkWidget *main_vbox; + GtkWidget *action_area; + GtkWidget *ok_button; + GtkWidget *apply_button; + GtkWidget *cancel_button; + gint dialog_width; + gboolean auto_resize; + }; + + + + + + struct _GtkPaned { + GtkContainer container; + GtkWidget *child1; + GtkWidget *child2; + GdkWindow *handle; + GdkGC *xor_gc; + GdkCursorType cursor_type; + GdkRectangle handle_pos; + gint child1_size; + gint last_allocation; + gint min_position; + gint max_position; + guint position_set:1; + guint in_drag:1; + guint child1_shrink:1; + guint child1_resize:1; + guint child2_shrink:1; + guint child2_resize:1; + guint orientation:1; + guint in_recursion:1; + guint handle_prelit:1; + GtkWidget *last_child1_focus; + GtkWidget *last_child2_focus; + GtkPanedPrivate *priv; + gint drag_pos; + gint original_position; + }; + + + struct _GtkViewport { + GtkBin bin; + GtkShadowType shadow_type; + GdkWindow *view_window; + GdkWindow *bin_window; + GtkAdjustment *hadjustment; + GtkAdjustment *vadjustment; + }; + + + struct _GtkScale { + GtkRange range; + gint digits; + guint draw_value:1; + guint value_pos:2; + }; + + + struct _GtkListStore { + GObject parent; + gint stamp; + gpointer seq; + gpointer _gtk_reserved1; + GList *sort_list; + gint n_columns; + gint sort_column_id; + GtkSortType order; + GType *column_headers; + gint length; + GtkTreeIterCompareFunc default_sort_func; + gpointer default_sort_data; + GtkDestroyNotify default_sort_destroy; + guint columns_dirty:1; + }; + + + + + + struct _GtkRadioActionEntry { + const gchar *name; + const gchar *stock_id; + const gchar *label; + const gchar *accelerator; + const gchar *tooltip; + gint value; + }; + + + struct _GtkEventBox { + GtkBin bin; + }; + + + + + + struct _GtkToggleActionEntry { + const gchar *name; + const gchar *stock_id; + const gchar *label; + const gchar *accelerator; + const gchar *tooltip; + GCallback callback; + gboolean is_active; + }; + + + struct _GtkAccelLabel { + GtkLabel label; + guint gtk_reserved; + guint accel_padding; + GtkWidget *accel_widget; + GClosure *accel_closure; + GtkAccelGroup *accel_group; + gchar *accel_string; + guint16 accel_string_width; + }; + + + struct _GtkImageMenuItem { + GtkMenuItem menu_item; + GtkWidget *image; + }; + + + struct _GtkPlug { + GtkWindow window; + GdkWindow *socket_window; + GtkWidget *modality_window; + GtkWindowGroup *modality_group; + GHashTable *grabbed_keys; + guint same_app:1; + }; + + + + + + struct _GtkFileChooserButton { + GtkHBox parent; + GtkFileChooserButtonPrivate *priv; + }; + + + struct _GtkStockItem { + gchar *stock_id; + gchar *label; + GdkModifierType modifier; + guint keyval; + gchar *translation_domain; + }; + + + struct _GtkToolbar { + GtkContainer container; + gint num_children; + GList *children; + GtkOrientation orientation; + GtkToolbarStyle style; + GtkIconSize icon_size; + GtkTooltips *tooltips; + gint button_maxw; + gint button_maxh; + guint style_set_connection; + guint icon_size_connection; + guint style_set:1; + guint icon_size_set:1; + }; + + + struct _GtkCellRendererToggle { + GtkCellRenderer parent; + guint active:1; + guint activatable:1; + guint radio:1; + }; + + + struct _GtkActionEntry { + const gchar *name; + const gchar *stock_id; + const gchar *label; + const gchar *accelerator; + const gchar *tooltip; + GCallback callback; + }; + + + struct _GtkCheckButton { + GtkToggleButton toggle_button; + }; + + + struct _GtkRadioButton { + GtkCheckButton check_button; + GSList *group; + }; + + + struct _GtkAlignment { + GtkBin bin; + gfloat xalign; + gfloat yalign; + gfloat xscale; + gfloat yscale; + }; + + + struct _GtkContainerClass { + GtkWidgetClass parent_class; + void (*add) (GtkContainer *, GtkWidget *); + void (*remove) (GtkContainer *, GtkWidget *); + void (*check_resize) (GtkContainer *); + void (*forall) (GtkContainer *, gboolean, GtkCallback, gpointer); + void (*set_focus_child) (GtkContainer *, GtkWidget *); + GType(*child_type) (GtkContainer *); + gchar *(*composite_name) (GtkContainer *, GtkWidget *); + void (*set_child_property) (GtkContainer *, GtkWidget *, guint, + const GValue *, GParamSpec *); + void (*get_child_property) (GtkContainer *, GtkWidget *, guint, + GValue *, GParamSpec *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + + + + struct _GtkFontButton { + GtkButton button; + GtkFontButtonPrivate *priv; + }; + + + struct _GtkBorder { + gint left; + gint right; + gint top; + gint bottom; + }; + + + struct _GtkMessageDialog { + GtkDialog parent_instance; + GtkWidget *image; + GtkWidget *label; + }; + + + struct _GtkRulerMetric { + gchar *metric_name; + gchar *abbrev; + gdouble pixels_per_unit; + gdouble ruler_scale[10]; + gint subdivide[5]; + }; + + + struct _GtkRuler { + GtkWidget widget; + GdkPixmap *backing_store; + GdkGC *non_gr_exp_gc; + GtkRulerMetric *metric; + gint xsrc; + gint ysrc; + gint slider_size; + gdouble lower; + gdouble upper; + gdouble position; + gdouble max_size; + }; + + + + + + struct _GtkMenuToolButton { + GtkToolButton parent; + GtkMenuToolButtonPrivate *priv; + }; + + + + + + struct _GtkToggleToolButton { + GtkToolButton parent; + GtkToggleToolButtonPrivate *priv; + }; + + + struct _GtkRadioToolButton { + GtkToggleToolButton parent; + }; + + + struct _GtkSizeGroup { + GObject parent_instance; + GSList *widgets; + guint8 mode; + guint have_width:1; + guint have_height:1; + GtkRequisition requisition; + }; + + + struct _GtkIMContextSimple { + GtkIMContext object; + GSList *tables; + guint compose_buffer[8]; + gunichar tentative_match; + gint tentative_match_len; + guint in_hex_sequence:1; + }; + + + struct _GtkFontSelection { + GtkVBox parent_instance; + GtkWidget *font_entry; + GtkWidget *family_list; + GtkWidget *font_style_entry; + GtkWidget *face_list; + GtkWidget *size_entry; + GtkWidget *size_list; + GtkWidget *pixels_button; + GtkWidget *points_button; + GtkWidget *filter_button; + GtkWidget *preview_entry; + PangoFontFamily *family; + PangoFontFace *face; + gint size; + GdkFont *font; + }; + + + struct _GtkAspectFrame { + GtkFrame frame; + gfloat xalign; + gfloat yalign; + gfloat ratio; + gboolean obey_child; + GtkAllocation center_allocation; + }; + + + + + + struct _GtkIMMulticontext { + GtkIMContext object; + GtkIMContext *slave; + GtkIMMulticontextPrivate *priv; + const gchar *context_id; + }; + + + struct _GtkFixed { + GtkContainer container; + GList *children; + }; + + + struct _GtkInvisible { + GtkWidget widget; + gboolean has_user_ref_count; + GdkScreen *screen; + }; + + + struct _GtkAccessible { + AtkObject parent; + GtkWidget *widget; + }; + + + struct _GtkArrow { + GtkMisc misc; + gint16 arrow_type; + gint16 shadow_type; + }; + + + struct _GtkCellRendererText { + GtkCellRenderer parent; + gchar *text; + PangoFontDescription *font; + gdouble font_scale; + PangoColor foreground; + PangoColor background; + PangoAttrList *extra_attrs; + PangoUnderline underline_style; + gint rise; + gint fixed_height_rows; + guint strikethrough:1; + guint editable:1; + guint scale_set:1; + guint foreground_set:1; + guint background_set:1; + guint underline_set:1; + guint rise_set:1; + guint strikethrough_set:1; + guint editable_set:1; + guint calc_fixed_height:1; + }; + + + struct _GtkSettingsValue { + gchar *origin; + GValue value; + }; + + + + + + struct _GtkBinClass { + GtkContainerClass parent_class; + }; + + + struct _GtkWindowClass { + GtkBinClass parent_class; + void (*set_focus) (GtkWindow *, GtkWidget *); + gboolean(*frame_event) (GtkWindow *, GdkEvent *); + void (*activate_focus) (GtkWindow *); + void (*activate_default) (GtkWindow *); + void (*move_focus) (GtkWindow *, GtkDirectionType); + void (*keys_changed) (GtkWindow *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkRangeClass { + GtkWidgetClass parent_class; + gchar *slider_detail; + gchar *stepper_detail; + void (*value_changed) (GtkRange *); + void (*adjust_bounds) (GtkRange *, gdouble); + void (*move_slider) (GtkRange *, GtkScrollType); + void (*get_range_border) (GtkRange *, GtkBorder *); + gboolean(*change_value) (GtkRange *, GtkScrollType, gdouble); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + }; + + + struct _GtkScaleClass { + GtkRangeClass parent_class; + gchar *(*format_value) (GtkScale *, gdouble); + void (*draw_value) (GtkScale *); + void (*get_layout_offsets) (GtkScale *, gint *, gint *); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkBoxClass { + GtkContainerClass parent_class; + }; + + + struct _GtkMiscClass { + GtkWidgetClass parent_class; + }; + + + struct _GtkHRuler { + GtkRuler ruler; + }; + + + struct _GtkHBoxClass { + GtkBoxClass parent_class; + }; + + + struct _GtkPanedClass { + GtkContainerClass parent_class; + gboolean(*cycle_child_focus) (GtkPaned *, gboolean); + gboolean(*toggle_handle_focus) (GtkPaned *); + gboolean(*move_handle) (GtkPaned *, GtkScrollType); + gboolean(*cycle_handle_focus) (GtkPaned *, gboolean); + gboolean(*accept_position) (GtkPaned *); + gboolean(*cancel_position) (GtkPaned *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkHPanedClass { + GtkPanedClass parent_class; + }; + + + struct _GtkSizeGroupClass { + GObjectClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkViewportClass { + GtkBinClass parent_class; + void (*set_scroll_adjustments) (GtkViewport *, GtkAdjustment *, + GtkAdjustment *); + }; + + + struct _GtkEditableClass { + GTypeInterface base_iface; + void (*insert_text) (GtkEditable *, const gchar *, gint, gint *); + void (*delete_text) (GtkEditable *, gint, gint); + void (*changed) (GtkEditable *); + void (*do_insert_text) (GtkEditable *, const gchar *, gint, + gint *); + void (*do_delete_text) (GtkEditable *, gint, gint); + gchar *(*get_chars) (GtkEditable *, gint, gint); + void (*set_selection_bounds) (GtkEditable *, gint, gint); + gboolean(*get_selection_bounds) (GtkEditable *, gint *, gint *); + void (*set_position) (GtkEditable *, gint); + gint(*get_position) (GtkEditable *); + }; + + + struct _GtkDialogClass { + GtkWindowClass parent_class; + void (*response) (GtkDialog *, gint); + void (*close) (GtkDialog *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkCellRendererPixbuf { + GtkCellRenderer parent; + GdkPixbuf *pixbuf; + GdkPixbuf *pixbuf_expander_open; + GdkPixbuf *pixbuf_expander_closed; + }; + + + struct _GtkTreeViewColumnClass { + GtkObjectClass parent_class; + void (*clicked) (GtkTreeViewColumn *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkRulerClass { + GtkWidgetClass parent_class; + void (*draw_ticks) (GtkRuler *); + void (*draw_pos) (GtkRuler *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkHRulerClass { + GtkRulerClass parent_class; + }; + + + + + + struct _GtkInvisibleClass { + GtkWidgetClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkVRulerClass { + GtkRulerClass parent_class; + }; + + + struct _GtkToolItemClass { + GtkBinClass parent_class; + gboolean(*create_menu_proxy) (GtkToolItem *); + void (*toolbar_reconfigured) (GtkToolItem *); + gboolean(*set_tooltip) (GtkToolItem *, GtkTooltips *, + const gchar *, const gchar *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkWindowGroupClass { + GObjectClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkWidgetAuxInfo { + gint x; + gint y; + gint width; + gint height; + guint x_set:1; + guint y_set:1; + }; + + + struct _GtkItemClass { + GtkBinClass parent_class; + void (*select) (GtkItem *); + void (*deselect) (GtkItem *); + void (*toggle) (GtkItem *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkMenuItemClass { + GtkItemClass parent_class; + guint hide_on_activate:1; + void (*activate) (GtkMenuItem *); + void (*activate_item) (GtkMenuItem *); + void (*toggle_size_request) (GtkMenuItem *, gint *); + void (*toggle_size_allocate) (GtkMenuItem *, gint); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkCheckMenuItemClass { + GtkMenuItemClass parent_class; + void (*toggled) (GtkCheckMenuItem *); + void (*draw_indicator) (GtkCheckMenuItem *, GdkRectangle *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkRcProperty { + GQuark type_name; + GQuark property_name; + gchar *origin; + GValue value; + }; + + + struct _GtkFontSelectionDialogClass { + GtkDialogClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + + + + struct _GtkFileChooserDialog { + GtkDialog parent_instance; + GtkFileChooserDialogPrivate *priv; + }; + + + struct _GtkActionClass { + GObjectClass parent_class; + void (*activate) (GtkAction *); + GType menu_item_type; + GType toolbar_item_type; + GtkWidget *(*create_menu_item) (GtkAction *); + GtkWidget *(*create_tool_item) (GtkAction *); + void (*connect_proxy) (GtkAction *, GtkWidget *); + void (*disconnect_proxy) (GtkAction *, GtkWidget *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkToggleActionClass { + GtkActionClass parent_class; + void (*toggled) (GtkToggleAction *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkVBoxClass { + GtkBoxClass parent_class; + }; + + + struct _GtkButtonBoxClass { + GtkBoxClass parent_class; + }; + + + struct _GtkHButtonBoxClass { + GtkButtonBoxClass parent_class; + }; + + + + + + struct _GtkTreeStoreClass { + GObjectClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkBoxChild { + GtkWidget *widget; + guint16 padding; + guint expand:1; + guint fill:1; + guint pack:1; + guint is_secondary:1; + }; + + + struct _GtkHButtonBox { + GtkButtonBox button_box; + }; + + + struct _GtkAccelGroupClass { + GObjectClass parent_class; + void (*accel_changed) (GtkAccelGroup *, guint, GdkModifierType, + GClosure *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkSeparator { + GtkWidget widget; + }; + + + struct _GtkButtonClass { + GtkBinClass parent_class; + void (*pressed) (GtkButton *); + void (*released) (GtkButton *); + void (*clicked) (GtkButton *); + void (*enter) (GtkButton *); + void (*leave) (GtkButton *); + void (*activate) (GtkButton *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkIconFactoryClass { + GObjectClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkTreeSelectionClass { + GObjectClass parent_class; + void (*changed) (GtkTreeSelection *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkMenuShellClass { + GtkContainerClass parent_class; + guint submenu_placement:1; + void (*deactivate) (GtkMenuShell *); + void (*selection_done) (GtkMenuShell *); + void (*move_current) (GtkMenuShell *, GtkMenuDirectionType); + void (*activate_current) (GtkMenuShell *, gboolean); + void (*cancel) (GtkMenuShell *); + void (*select_item) (GtkMenuShell *, GtkWidget *); + void (*insert) (GtkMenuShell *, GtkWidget *, gint); + gint(*get_popup_delay) (GtkMenuShell *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + }; + + + struct _GtkTreeDragSourceIface { + GTypeInterface g_iface; + gboolean(*row_draggable) (GtkTreeDragSource *, GtkTreePath *); + gboolean(*drag_data_get) (GtkTreeDragSource *, GtkTreePath *, + GtkSelectionData *); + gboolean(*drag_data_delete) (GtkTreeDragSource *, GtkTreePath *); + }; + + + struct _GtkLabelClass { + GtkMiscClass parent_class; + void (*move_cursor) (GtkLabel *, GtkMovementStep, gint, gboolean); + void (*copy_clipboard) (GtkLabel *); + void (*populate_popup) (GtkLabel *, GtkMenu *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkScrollbar { + GtkRange range; + }; + + + struct _GtkWidgetShapeInfo { + gint16 offset_x; + gint16 offset_y; + GdkBitmap *shape_mask; + }; + + + struct _GtkActionGroupClass { + GObjectClass parent_class; + GtkAction *(*get_action) (GtkActionGroup *, const gchar *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkSettingsClass { + GObjectClass parent_class; + }; + + + struct _GtkIMContextClass { + GtkObjectClass parent_class; + void (*preedit_start) (GtkIMContext *); + void (*preedit_end) (GtkIMContext *); + void (*preedit_changed) (GtkIMContext *); + void (*commit) (GtkIMContext *, const gchar *); + gboolean(*retrieve_surrounding) (GtkIMContext *); + gboolean(*delete_surrounding) (GtkIMContext *, gint, gint); + void (*set_client_window) (GtkIMContext *, GdkWindow *); + void (*get_preedit_string) (GtkIMContext *, gchar * *, + PangoAttrList * *, gint *); + gboolean(*filter_keypress) (GtkIMContext *, GdkEventKey *); + void (*focus_in) (GtkIMContext *); + void (*focus_out) (GtkIMContext *); + void (*reset) (GtkIMContext *); + void (*set_cursor_location) (GtkIMContext *, GdkRectangle *); + void (*set_use_preedit) (GtkIMContext *, gboolean); + void (*set_surrounding) (GtkIMContext *, const gchar *, gint, + gint); + gboolean(*get_surrounding) (GtkIMContext *, gchar * *, gint *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + void (*_gtk_reserved5) (void); + void (*_gtk_reserved6) (void); + }; + + + struct _GtkCellRendererClass { + GtkObjectClass parent_class; + void (*get_size) (GtkCellRenderer *, GtkWidget *, GdkRectangle *, + gint *, gint *, gint *, gint *); + void (*render) (GtkCellRenderer *, GdkDrawable *, GtkWidget *, + GdkRectangle *, GdkRectangle *, GdkRectangle *, + GtkCellRendererState); + gboolean(*activate) (GtkCellRenderer *, GdkEvent *, GtkWidget *, + const gchar *, GdkRectangle *, + GdkRectangle *, GtkCellRendererState); + GtkCellEditable *(*start_editing) (GtkCellRenderer *, GdkEvent *, + GtkWidget *, const gchar *, + GdkRectangle *, GdkRectangle *, + GtkCellRendererState); + void (*editing_canceled) (GtkCellRenderer *); + void (*editing_started) (GtkCellRenderer *, GtkCellEditable *, + const gchar *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + }; + + + struct _GtkToolButtonClass { + GtkToolItemClass parent_class; + GType button_type; + void (*clicked) (GtkToolButton *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkMenuToolButtonClass { + GtkToolButtonClass parent_class; + void (*show_menu) (GtkMenuToolButton *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkVSeparator { + GtkSeparator separator; + }; + + + struct _GtkDrawingAreaClass { + GtkWidgetClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkTargetPair { + GdkAtom target; + guint flags; + guint info; + }; + + + struct _GtkCellViewClass { + GtkWidgetClass parent_class; + }; + + + struct _GtkCellLayoutIface { + GTypeInterface g_iface; + void (*pack_start) (GtkCellLayout *, GtkCellRenderer *, gboolean); + void (*pack_end) (GtkCellLayout *, GtkCellRenderer *, gboolean); + void (*clear) (GtkCellLayout *); + void (*add_attribute) (GtkCellLayout *, GtkCellRenderer *, + const gchar *, gint); + void (*set_cell_data_func) (GtkCellLayout *, GtkCellRenderer *, + GtkCellLayoutDataFunc, gpointer, + GDestroyNotify); + void (*clear_attributes) (GtkCellLayout *, GtkCellRenderer *); + void (*reorder) (GtkCellLayout *, GtkCellRenderer *, gint); + }; + + + + + + struct _GtkFixedClass { + GtkContainerClass parent_class; + }; + + + struct _GtkHScaleClass { + GtkScaleClass parent_class; + }; + + + struct _GtkScrollbarClass { + GtkRangeClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkAccelLabelClass { + GtkLabelClass parent_class; + gchar *signal_quote1; + gchar *signal_quote2; + gchar *mod_name_shift; + gchar *mod_name_control; + gchar *mod_name_alt; + gchar *mod_separator; + gchar *accel_seperator; + guint latin1_to_char:1; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkTextBufferClass { + GObjectClass parent_class; + void (*insert_text) (GtkTextBuffer *, GtkTextIter *, const gchar *, + gint); + void (*insert_pixbuf) (GtkTextBuffer *, GtkTextIter *, + GdkPixbuf *); + void (*insert_child_anchor) (GtkTextBuffer *, GtkTextIter *, + GtkTextChildAnchor *); + void (*delete_range) (GtkTextBuffer *, GtkTextIter *, + GtkTextIter *); + void (*changed) (GtkTextBuffer *); + void (*modified_changed) (GtkTextBuffer *); + void (*mark_set) (GtkTextBuffer *, const GtkTextIter *, + GtkTextMark *); + void (*mark_deleted) (GtkTextBuffer *, GtkTextMark *); + void (*apply_tag) (GtkTextBuffer *, GtkTextTag *, + const GtkTextIter *, const GtkTextIter *); + void (*remove_tag) (GtkTextBuffer *, GtkTextTag *, + const GtkTextIter *, const GtkTextIter *); + void (*begin_user_action) (GtkTextBuffer *); + void (*end_user_action) (GtkTextBuffer *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + void (*_gtk_reserved5) (void); + void (*_gtk_reserved6) (void); + }; + + + struct _GtkVRuler { + GtkRuler ruler; + }; + + + struct _GtkSocketClass { + GtkContainerClass parent_class; + void (*plug_added) (GtkSocket *); + gboolean(*plug_removed) (GtkSocket *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkIconThemeClass { + GObjectClass parent_class; + void (*changed) (GtkIconTheme *); + }; + + + struct _GtkVPaned { + GtkPaned paned; + }; + + + struct _GtkTableChild { + GtkWidget *widget; + guint16 left_attach; + guint16 right_attach; + guint16 top_attach; + guint16 bottom_attach; + guint16 xpadding; + guint16 ypadding; + guint xexpand:1; + guint yexpand:1; + guint xshrink:1; + guint yshrink:1; + guint xfill:1; + guint yfill:1; + }; + + + struct _GtkArrowClass { + GtkMiscClass parent_class; + }; + + + struct _GtkHScrollbar { + GtkScrollbar scrollbar; + }; + + + + + + struct _GtkFileChooserWidget { + GtkVBox parent_instance; + GtkFileChooserWidgetPrivate *priv; + }; + + + struct _GtkPlugClass { + GtkWindowClass parent_class; + void (*embedded) (GtkPlug *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkCellRendererPixbufClass { + GtkCellRendererClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkVButtonBoxClass { + GtkButtonBoxClass parent_class; + }; + + + struct _GtkTextChildAnchorClass { + GObjectClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkCellRendererCombo { + GtkCellRendererText parent; + GtkTreeModel *model; + gint text_column; + gboolean has_entry; + guint focus_out_id; + }; + + + struct _GtkTreeModelIface { + GTypeInterface g_iface; + void (*row_changed) (GtkTreeModel *, GtkTreePath *, GtkTreeIter *); + void (*row_inserted) (GtkTreeModel *, GtkTreePath *, + GtkTreeIter *); + void (*row_has_child_toggled) (GtkTreeModel *, GtkTreePath *, + GtkTreeIter *); + void (*row_deleted) (GtkTreeModel *, GtkTreePath *); + void (*rows_reordered) (GtkTreeModel *, GtkTreePath *, + GtkTreeIter *, gint *); + GtkTreeModelFlags(*get_flags) (GtkTreeModel *); + gint(*get_n_columns) (GtkTreeModel *); + GType(*get_column_type) (GtkTreeModel *, gint); + gboolean(*get_iter) (GtkTreeModel *, GtkTreeIter *, + GtkTreePath *); + GtkTreePath *(*get_path) (GtkTreeModel *, GtkTreeIter *); + void (*get_value) (GtkTreeModel *, GtkTreeIter *, gint, GValue *); + gboolean(*iter_next) (GtkTreeModel *, GtkTreeIter *); + gboolean(*iter_children) (GtkTreeModel *, GtkTreeIter *, + GtkTreeIter *); + gboolean(*iter_has_child) (GtkTreeModel *, GtkTreeIter *); + gint(*iter_n_children) (GtkTreeModel *, GtkTreeIter *); + gboolean(*iter_nth_child) (GtkTreeModel *, GtkTreeIter *, + GtkTreeIter *, gint); + gboolean(*iter_parent) (GtkTreeModel *, GtkTreeIter *, + GtkTreeIter *); + void (*ref_node) (GtkTreeModel *, GtkTreeIter *); + void (*unref_node) (GtkTreeModel *, GtkTreeIter *); + }; + + + struct _GtkAccessibleClass { + AtkObjectClass parent_class; + void (*connect_widget_destroyed) (GtkAccessible *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkCellRendererTextClass { + GtkCellRendererClass parent_class; + void (*edited) (GtkCellRendererText *, const gchar *, + const gchar *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkVScaleClass { + GtkScaleClass parent_class; + }; + + + struct _GtkCurveClass { + GtkDrawingAreaClass parent_class; + void (*curve_type_changed) (GtkCurve *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkSeparatorToolItemClass { + GtkToolItemClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkStyleClass { + GObjectClass parent_class; + void (*realize) (GtkStyle *); + void (*unrealize) (GtkStyle *); + void (*copy) (GtkStyle *, GtkStyle *); + GtkStyle *(*clone) (GtkStyle *); + void (*init_from_rc) (GtkStyle *, GtkRcStyle *); + void (*set_background) (GtkStyle *, GdkWindow *, GtkStateType); + GdkPixbuf *(*render_icon) (GtkStyle *, const GtkIconSource *, + GtkTextDirection, GtkStateType, + GtkIconSize, GtkWidget *, + const gchar *); + void (*draw_hline) (GtkStyle *, GdkWindow *, GtkStateType, + GdkRectangle *, GtkWidget *, const gchar *, + gint, gint, gint); + void (*draw_vline) (GtkStyle *, GdkWindow *, GtkStateType, + GdkRectangle *, GtkWidget *, const gchar *, + gint, gint, gint); + void (*draw_shadow) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint); + void (*draw_polygon) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, GdkPoint *, gint, gboolean); + void (*draw_arrow) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, GtkArrowType, gboolean, gint, + gint, gint, gint); + void (*draw_diamond) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint); + void (*draw_string) (GtkStyle *, GdkWindow *, GtkStateType, + GdkRectangle *, GtkWidget *, const gchar *, + gint, gint, const gchar *); + void (*draw_box) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint); + void (*draw_flat_box) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint); + void (*draw_check) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint); + void (*draw_option) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint); + void (*draw_tab) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint); + void (*draw_shadow_gap) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, + GtkWidget *, const gchar *, gint, gint, + gint, gint, GtkPositionType, gint, gint); + void (*draw_box_gap) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint, + GtkPositionType, gint, gint); + void (*draw_extension) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint, + GtkPositionType); + void (*draw_focus) (GtkStyle *, GdkWindow *, GtkStateType, + GdkRectangle *, GtkWidget *, const gchar *, + gint, gint, gint, gint); + void (*draw_slider) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint, + GtkOrientation); + void (*draw_handle) (GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint, + GtkOrientation); + void (*draw_expander) (GtkStyle *, GdkWindow *, GtkStateType, + GdkRectangle *, GtkWidget *, const gchar *, + gint, gint, GtkExpanderStyle); + void (*draw_layout) (GtkStyle *, GdkWindow *, GtkStateType, + gboolean, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, PangoLayout *); + void (*draw_resize_grip) (GtkStyle *, GdkWindow *, GtkStateType, + GdkRectangle *, GtkWidget *, + const gchar *, GdkWindowEdge, gint, gint, + gint, gint); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + void (*_gtk_reserved5) (void); + void (*_gtk_reserved6) (void); + void (*_gtk_reserved7) (void); + void (*_gtk_reserved8) (void); + void (*_gtk_reserved9) (void); + void (*_gtk_reserved10) (void); + void (*_gtk_reserved11) (void); + void (*_gtk_reserved12) (void); + }; + + + struct _GtkSeparatorMenuItemClass { + GtkMenuItemClass parent_class; + }; + + + struct _GtkIMMulticontextClass { + GtkIMContextClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkToggleToolButtonClass { + GtkToolButtonClass parent_class; + void (*toggled) (GtkToggleToolButton *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkRadioToolButtonClass { + GtkToggleToolButtonClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkCellRendererProgressClass { + GtkCellRendererClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkVScrollbar { + GtkScrollbar scrollbar; + }; + + + struct _GtkVPanedClass { + GtkPanedClass parent_class; + }; + + + struct _GtkToggleButtonClass { + GtkButtonClass parent_class; + void (*toggled) (GtkToggleButton *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkCellRendererToggleClass { + GtkCellRendererClass parent_class; + void (*toggled) (GtkCellRendererToggle *, const gchar *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkVButtonBox { + GtkButtonBox button_box; + }; + + + struct _GtkTreeDragDestIface { + GTypeInterface g_iface; + gboolean(*drag_data_received) (GtkTreeDragDest *, GtkTreePath *, + GtkSelectionData *); + gboolean(*row_drop_possible) (GtkTreeDragDest *, GtkTreePath *, + GtkSelectionData *); + }; + + + struct _GtkColorSelectionClass { + GtkVBoxClass parent_class; + void (*color_changed) (GtkColorSelection *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + + + + struct _GtkCellRendererProgress { + GtkCellRenderer parent_instance; + GtkCellRendererProgressPrivate *priv; + }; + + + struct _GtkImageClass { + GtkMiscClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkMessageDialogClass { + GtkDialogClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkTreeSortableIface { + GTypeInterface g_iface; + void (*sort_column_changed) (GtkTreeSortable *); + gboolean(*get_sort_column_id) (GtkTreeSortable *, gint *, + GtkSortType *); + void (*set_sort_column_id) (GtkTreeSortable *, gint, GtkSortType); + void (*set_sort_func) (GtkTreeSortable *, gint, + GtkTreeIterCompareFunc, gpointer, + GtkDestroyNotify); + void (*set_default_sort_func) (GtkTreeSortable *, + GtkTreeIterCompareFunc, gpointer, + GtkDestroyNotify); + gboolean(*has_default_sort_func) (GtkTreeSortable *); + }; + + + struct _GtkCalendarClass { + GtkWidgetClass parent_class; + void (*month_changed) (GtkCalendar *); + void (*day_selected) (GtkCalendar *); + void (*day_selected_double_click) (GtkCalendar *); + void (*prev_month) (GtkCalendar *); + void (*next_month) (GtkCalendar *); + void (*prev_year) (GtkCalendar *); + void (*next_year) (GtkCalendar *); + }; + + + struct _GtkEntryClass { + GtkWidgetClass parent_class; + void (*populate_popup) (GtkEntry *, GtkMenu *); + void (*activate) (GtkEntry *); + void (*move_cursor) (GtkEntry *, GtkMovementStep, gint, gboolean); + void (*insert_at_cursor) (GtkEntry *, const gchar *); + void (*delete_from_cursor) (GtkEntry *, GtkDeleteType, gint); + void (*backspace) (GtkEntry *); + void (*cut_clipboard) (GtkEntry *); + void (*copy_clipboard) (GtkEntry *); + void (*paste_clipboard) (GtkEntry *); + void (*toggle_overwrite) (GtkEntry *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + }; + + + struct _GtkSpinButtonClass { + GtkEntryClass parent_class; + gint(*input) (GtkSpinButton *, gdouble *); + gint(*output) (GtkSpinButton *); + void (*value_changed) (GtkSpinButton *); + void (*change_value) (GtkSpinButton *, GtkScrollType); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkInputDialog { + GtkDialog dialog; + GtkWidget *axis_list; + GtkWidget *axis_listbox; + GtkWidget *mode_optionmenu; + GtkWidget *close_button; + GtkWidget *save_button; + GtkWidget *axis_items[7]; + GdkDevice *current_device; + GtkWidget *keys_list; + GtkWidget *keys_listbox; + }; + + + struct _GtkInputDialogClass { + GtkDialogClass parent_class; + void (*enable_device) (GtkInputDialog *, GdkDevice *); + void (*disable_device) (GtkInputDialog *, GdkDevice *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkEntryCompletionClass { + GObjectClass parent_class; + gboolean(*match_selected) (GtkEntryCompletion *, GtkTreeModel *, + GtkTreeIter *); + void (*action_activated) (GtkEntryCompletion *, gint); + gboolean(*insert_prefix) (GtkEntryCompletion *, const gchar *); + void (*_gtk_reserved0) (void); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + }; + + + struct _GtkAlignmentClass { + GtkBinClass parent_class; + }; + + + struct _GtkTreeModelFilterClass { + GObjectClass parent_class; + void (*_gtk_reserved0) (void); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + }; + + + struct _GtkRcStyleClass { + GObjectClass parent_class; + GtkRcStyle *(*create_rc_style) (GtkRcStyle *); + guint(*parse) (GtkRcStyle *, GtkSettings *, GScanner *); + void (*merge) (GtkRcStyle *, GtkRcStyle *); + GtkStyle *(*create_style) (GtkRcStyle *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkUIManagerClass { + GObjectClass parent_class; + void (*add_widget) (GtkUIManager *, GtkWidget *); + void (*actions_changed) (GtkUIManager *); + void (*connect_proxy) (GtkUIManager *, GtkAction *, GtkWidget *); + void (*disconnect_proxy) (GtkUIManager *, GtkAction *, + GtkWidget *); + void (*pre_activate) (GtkUIManager *, GtkAction *); + void (*post_activate) (GtkUIManager *, GtkAction *); + GtkWidget *(*get_widget) (GtkUIManager *, const gchar *); + GtkAction *(*get_action) (GtkUIManager *, const gchar *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + }; + + + struct _GtkSeparatorClass { + GtkWidgetClass parent_class; + }; + + + struct _GtkVSeparatorClass { + GtkSeparatorClass parent_class; + }; + + + struct _GtkCheckButtonClass { + GtkToggleButtonClass parent_class; + void (*draw_indicator) (GtkCheckButton *, GdkRectangle *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkRadioMenuItemClass { + GtkCheckMenuItemClass parent_class; + void (*group_changed) (GtkRadioMenuItem *); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkTextViewClass { + GtkContainerClass parent_class; + void (*set_scroll_adjustments) (GtkTextView *, GtkAdjustment *, + GtkAdjustment *); + void (*populate_popup) (GtkTextView *, GtkMenu *); + void (*move_cursor) (GtkTextView *, GtkMovementStep, gint, + gboolean); + void (*page_horizontally) (GtkTextView *, gint, gboolean); + void (*set_anchor) (GtkTextView *); + void (*insert_at_cursor) (GtkTextView *, const gchar *); + void (*delete_from_cursor) (GtkTextView *, GtkDeleteType, gint); + void (*backspace) (GtkTextView *); + void (*cut_clipboard) (GtkTextView *); + void (*copy_clipboard) (GtkTextView *); + void (*paste_clipboard) (GtkTextView *); + void (*toggle_overwrite) (GtkTextView *); + void (*move_focus) (GtkTextView *, GtkDirectionType); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + void (*_gtk_reserved5) (void); + void (*_gtk_reserved6) (void); + void (*_gtk_reserved7) (void); + }; + + + struct _GtkTreeModelSortClass { + GObjectClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkCellEditableIface { + GTypeInterface g_iface; + void (*editing_done) (GtkCellEditable *); + void (*remove_widget) (GtkCellEditable *); + void (*start_editing) (GtkCellEditable *, GdkEvent *); + }; + + + struct _GtkToolbarClass { + GtkContainerClass parent_class; + void (*orientation_changed) (GtkToolbar *, GtkOrientation); + void (*style_changed) (GtkToolbar *, GtkToolbarStyle); + gboolean(*popup_context_menu) (GtkToolbar *, gint, gint, gint); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + }; + + + struct _GtkHandleBoxClass { + GtkBinClass parent_class; + void (*child_attached) (GtkHandleBox *, GtkWidget *); + void (*child_detached) (GtkHandleBox *, GtkWidget *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkHSeparator { + GtkSeparator separator; + }; + + + struct _GtkTextTagTableClass { + GObjectClass parent_class; + void (*tag_changed) (GtkTextTagTable *, GtkTextTag *, gboolean); + void (*tag_added) (GtkTextTagTable *, GtkTextTag *); + void (*tag_removed) (GtkTextTagTable *, GtkTextTag *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkComboBoxClass { + GtkBinClass parent_class; + void (*changed) (GtkComboBox *); + gchar *(*get_active_text) (GtkComboBox *); + void (*_gtk_reserved0) (void); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + }; + + + struct _GtkComboBoxEntryClass { + GtkComboBoxClass parent_class; + void (*_gtk_reserved0) (void); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + }; + + + struct _GtkFontSelectionClass { + GtkVBoxClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkFrameClass { + GtkBinClass parent_class; + void (*compute_child_allocation) (GtkFrame *, GtkAllocation *); + }; + + + struct _GtkHScrollbarClass { + GtkScrollbarClass parent_class; + }; + + + struct _GtkFileSelectionClass { + GtkDialogClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkScrolledWindowClass { + GtkBinClass parent_class; + gint scrollbar_spacing; + void (*scroll_child) (GtkScrolledWindow *, GtkScrollType, + gboolean); + void (*move_focus_out) (GtkScrolledWindow *, GtkDirectionType); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkTextMarkClass { + GObjectClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + + + + struct _GtkVScale { + GtkScale scale; + }; + + + struct _GtkFixedChild { + GtkWidget *widget; + gint x; + gint y; + }; + + + struct _GtkLayoutClass { + GtkContainerClass parent_class; + void (*set_scroll_adjustments) (GtkLayout *, GtkAdjustment *, + GtkAdjustment *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkEventBoxClass { + GtkBinClass parent_class; + }; + + + struct _GtkIMContextSimpleClass { + GtkIMContextClass parent_class; + }; + + + struct _GtkExpanderClass { + GtkBinClass parent_class; + void (*activate) (GtkExpander *); + }; + + + struct _GtkProgressClass { + GtkWidgetClass parent_class; + void (*paint) (GtkProgress *); + void (*update) (GtkProgress *); + void (*act_mode_enter) (GtkProgress *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkFileChooserDialogClass { + GtkDialogClass parent_class; + }; + + + struct _GtkVScrollbarClass { + GtkScrollbarClass parent_class; + }; + + + struct _GtkTableClass { + GtkContainerClass parent_class; + }; + + + struct _GtkFontButtonClass { + GtkButtonClass parent_class; + void (*font_set) (GtkFontButton *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkHSeparatorClass { + GtkSeparatorClass parent_class; + }; + + + struct _GtkColorSelectionDialogClass { + GtkDialogClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkColorButtonClass { + GtkButtonClass parent_class; + void (*color_set) (GtkColorButton *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkMenuBar { + GtkMenuShell menu_shell; + }; + + + struct _GtkMenuBarClass { + GtkMenuShellClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkColorSelectionDialog { + GtkDialog parent_instance; + GtkWidget *colorsel; + GtkWidget *ok_button; + GtkWidget *cancel_button; + GtkWidget *help_button; + }; + + + struct _GtkStatusbarClass { + GtkHBoxClass parent_class; + GMemChunk *messages_mem_chunk; + void (*text_pushed) (GtkStatusbar *, guint, const gchar *); + void (*text_popped) (GtkStatusbar *, guint, const gchar *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkSeparatorMenuItem { + GtkMenuItem menu_item; + }; + + + struct _GtkAboutDialogClass { + GtkDialogClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkListStoreClass { + GObjectClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkFileChooserButtonClass { + GtkHBoxClass parent_class; + void *__gtk_reserved1; + void *__gtk_reserved2; + void *__gtk_reserved3; + void *__gtk_reserved4; + void *__gtk_reserved5; + void *__gtk_reserved6; + void *__gtk_reserved7; + void *__gtk_reserved8; + }; + + + struct _GtkMenuClass { + GtkMenuShellClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkHScale { + GtkScale scale; + }; + + + struct _GtkGammaCurveClass { + GtkVBoxClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkCellRendererComboClass { + GtkCellRendererTextClass parent; + }; + + + struct _GtkTearoffMenuItem { + GtkMenuItem menu_item; + guint torn_off:1; + }; + + + struct _GtkNotebookClass { + GtkContainerClass parent_class; + void (*switch_page) (GtkNotebook *, GtkNotebookPage *, guint); + gboolean(*select_page) (GtkNotebook *, gboolean); + gboolean(*focus_tab) (GtkNotebook *, GtkNotebookTab); + void (*change_current_page) (GtkNotebook *, gint); + void (*move_focus_out) (GtkNotebook *, GtkDirectionType); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkImageMenuItemClass { + GtkMenuItemClass parent_class; + }; + + + struct _GtkTooltipsClass { + GtkObjectClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkTreeViewClass { + GtkContainerClass parent_class; + void (*set_scroll_adjustments) (GtkTreeView *, GtkAdjustment *, + GtkAdjustment *); + void (*row_activated) (GtkTreeView *, GtkTreePath *, + GtkTreeViewColumn *); + gboolean(*test_expand_row) (GtkTreeView *, GtkTreeIter *, + GtkTreePath *); + gboolean(*test_collapse_row) (GtkTreeView *, GtkTreeIter *, + GtkTreePath *); + void (*row_expanded) (GtkTreeView *, GtkTreeIter *, GtkTreePath *); + void (*row_collapsed) (GtkTreeView *, GtkTreeIter *, + GtkTreePath *); + void (*columns_changed) (GtkTreeView *); + void (*cursor_changed) (GtkTreeView *); + gboolean(*move_cursor) (GtkTreeView *, GtkMovementStep, gint); + gboolean(*select_all) (GtkTreeView *); + gboolean(*unselect_all) (GtkTreeView *); + gboolean(*select_cursor_row) (GtkTreeView *, gboolean); + gboolean(*toggle_cursor_row) (GtkTreeView *); + gboolean(*expand_collapse_cursor_row) (GtkTreeView *, gboolean, + gboolean, gboolean); + gboolean(*select_cursor_parent) (GtkTreeView *); + gboolean(*start_interactive_search) (GtkTreeView *); + void (*_gtk_reserved0) (void); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkFileChooserWidgetClass { + GtkVBoxClass parent_class; + }; + + + struct _GtkTearoffMenuItemClass { + GtkMenuItemClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkRadioButtonClass { + GtkCheckButtonClass parent_class; + void (*group_changed) (GtkRadioButton *); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkAdjustmentClass { + GtkObjectClass parent_class; + void (*changed) (GtkAdjustment *); + void (*value_changed) (GtkAdjustment *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkHPaned { + GtkPaned paned; + }; + + + struct _GtkRadioActionClass { + GtkToggleActionClass parent_class; + void (*changed) (GtkRadioAction *, GtkRadioAction *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkTextTagClass { + GObjectClass parent_class; + gboolean(*event) (GtkTextTag *, GObject *, GdkEvent *, + const GtkTextIter *); + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkIconViewClass { + GtkContainerClass parent_class; + void (*set_scroll_adjustments) (GtkIconView *, GtkAdjustment *, + GtkAdjustment *); + void (*item_activated) (GtkIconView *, GtkTreePath *); + void (*selection_changed) (GtkIconView *); + void (*select_all) (GtkIconView *); + void (*unselect_all) (GtkIconView *); + void (*select_cursor_item) (GtkIconView *); + void (*toggle_cursor_item) (GtkIconView *); + gboolean(*move_cursor) (GtkIconView *, GtkMovementStep, gint); + gboolean(*activate_cursor_item) (GtkIconView *); + }; + + + struct _GtkProgressBarClass { + GtkProgressClass parent_class; + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); + }; + + + struct _GtkAspectFrameClass { + GtkFrameClass parent_class; + }; + + + struct _GtkGammaCurve { + GtkVBox vbox; + GtkWidget *table; + GtkWidget *curve; + GtkWidget *button[5]; + gfloat gamma; + GtkWidget *gamma_dialog; + GtkWidget *gamma_text; + }; + + + extern GtkIconSet *gtk_icon_set_new(void); + extern GType gtk_cell_editable_get_type(void); + extern void gtk_widget_get_pointer(GtkWidget *, gint *, gint *); + extern void gtk_progress_bar_set_fraction(GtkProgressBar *, gdouble); + extern GType gtk_file_chooser_action_get_type(void); + extern void gtk_text_buffer_get_start_iter(GtkTextBuffer *, + GtkTextIter *); + extern gint gtk_combo_box_get_column_span_column(GtkComboBox *); + extern void gtk_misc_set_padding(GtkMisc *, gint, gint); + extern guint gtk_statusbar_push(GtkStatusbar *, guint, const gchar *); + extern GdkAtom gtk_drag_dest_find_target(GtkWidget *, GdkDragContext *, + GtkTargetList *); + extern void gtk_window_get_default_size(GtkWindow *, gint *, gint *); + extern void gtk_widget_modify_base(GtkWidget *, GtkStateType, + const GdkColor *); + extern void gtk_tree_row_reference_free(GtkTreeRowReference *); + extern GtkTreeModelFlags gtk_tree_model_get_flags(GtkTreeModel *); + extern void gtk_drag_source_set(GtkWidget *, GdkModifierType, + const GtkTargetEntry *, gint, + GdkDragAction); + extern void gtk_entry_get_layout_offsets(GtkEntry *, gint *, gint *); + extern GdkColormap *gtk_widget_get_default_colormap(void); + extern GType gtk_submenu_placement_get_type(void); + extern const guint gtk_binary_age; + extern GtkRequisition *gtk_requisition_copy(const GtkRequisition *); + extern void gtk_combo_box_entry_set_text_column(GtkComboBoxEntry *, + gint); + extern GtkAdjustment *gtk_layout_get_vadjustment(GtkLayout *); + extern void gtk_tree_store_append(GtkTreeStore *, GtkTreeIter *, + GtkTreeIter *); + extern GtkAboutDialogActivateLinkFunc + gtk_about_dialog_set_email_hook(GtkAboutDialogActivateLinkFunc, + gpointer, GDestroyNotify); + extern GType gtk_adjustment_get_type(void); + extern gboolean gtk_tree_sortable_get_sort_column_id(GtkTreeSortable *, + gint *, + GtkSortType *); + extern void gtk_range_set_range(GtkRange *, gdouble, gdouble); + extern gboolean gtk_text_iter_backward_sentence_starts(GtkTextIter *, + gint); + extern gboolean gtk_window_propagate_key_event(GtkWindow *, + GdkEventKey *); + extern void gtk_dialog_add_action_widget(GtkDialog *, GtkWidget *, + gint); + extern GdkNativeWindow gtk_socket_get_id(GtkSocket *); + extern const gchar *gtk_window_get_role(GtkWindow *); + extern void gtk_tree_view_column_clear_attributes(GtkTreeViewColumn *, + GtkCellRenderer *); + extern guint gtk_binding_parse_binding(GScanner *); + extern GtkWidget *gtk_input_dialog_new(void); + extern gint gtk_text_buffer_get_char_count(GtkTextBuffer *); + extern GtkButtonBoxStyle gtk_button_box_get_layout(GtkButtonBox *); + extern void gtk_toggle_action_toggled(GtkToggleAction *); + extern gboolean gtk_text_iter_begins_tag(const GtkTextIter *, + GtkTextTag *); + extern void gtk_widget_reparent(GtkWidget *, GtkWidget *); + extern gboolean + gtk_text_iter_backward_visible_cursor_position(GtkTextIter *); + extern GType gtk_spin_button_get_type(void); + extern void gtk_text_buffer_get_iter_at_line(GtkTextBuffer *, + GtkTextIter *, gint); + extern gboolean gtk_file_filter_filter(GtkFileFilter *, + const GtkFileFilterInfo *); + extern void gtk_text_iter_set_visible_line_index(GtkTextIter *, gint); + extern GtkTextDirection gtk_icon_source_get_direction(const + GtkIconSource *); + extern void gtk_layout_get_size(GtkLayout *, guint *, guint *); + extern void gtk_widget_set_direction(GtkWidget *, GtkTextDirection); + extern gint gtk_text_iter_compare(const GtkTextIter *, + const GtkTextIter *); + extern void gtk_drag_source_add_text_targets(GtkWidget *); + extern GType gtk_file_chooser_widget_get_type(void); + extern void gtk_tool_button_set_label_widget(GtkToolButton *, + GtkWidget *); + extern gint gtk_icon_view_get_text_column(GtkIconView *); + extern gboolean gtk_label_get_use_markup(GtkLabel *); + extern GtkAdjustment *gtk_container_get_focus_hadjustment(GtkContainer + *); + extern void gtk_text_buffer_set_modified(GtkTextBuffer *, gboolean); + extern void gtk_drag_source_unset(GtkWidget *); + extern void gtk_combo_box_set_add_tearoffs(GtkComboBox *, gboolean); + extern GtkWidget *gtk_text_view_new_with_buffer(GtkTextBuffer *); + extern void gtk_settings_set_string_property(GtkSettings *, + const gchar *, + const gchar *, + const gchar *); + extern guint gtk_ui_manager_add_ui_from_file(GtkUIManager *, + const gchar *, + GError * *); + extern GtkWidget + *gtk_radio_menu_item_new_with_label_from_widget(GtkRadioMenuItem *, + const gchar *); + extern void gtk_widget_push_colormap(GdkColormap *); + extern GtkWidget *gtk_vbox_new(gboolean, gint); + extern void gtk_cell_view_set_background_color(GtkCellView *, + const GdkColor *); + extern gboolean + gtk_selection_data_targets_include_text(GtkSelectionData *); + extern GType gtk_cell_renderer_get_type(void); + extern void gtk_container_check_resize(GtkContainer *); + extern guint gtk_label_get_mnemonic_keyval(GtkLabel *); + extern void gtk_file_chooser_unselect_filename(GtkFileChooser *, + const char *); + extern void gtk_curve_reset(GtkCurve *); + extern const gchar *gtk_notebook_get_menu_label_text(GtkNotebook *, + GtkWidget *); + extern GtkIconSet *gtk_icon_factory_lookup(GtkIconFactory *, + const gchar *); + extern GtkWidget *gtk_accel_label_new(const gchar *); + extern void gtk_widget_size_allocate(GtkWidget *, GtkAllocation *); + extern void gtk_icon_view_unselect_all(GtkIconView *); + extern void gtk_drag_set_icon_default(GdkDragContext *); + extern void gtk_layout_move(GtkLayout *, GtkWidget *, gint, gint); + extern void gtk_drag_set_icon_widget(GdkDragContext *, GtkWidget *, + gint, gint); + extern GType gtk_shadow_type_get_type(void); + extern GtkWidget *gtk_tool_item_get_proxy_menu_item(GtkToolItem *, + const gchar *); + extern GdkPixbuf *gtk_about_dialog_get_logo(GtkAboutDialog *); + extern void gtk_widget_set_colormap(GtkWidget *, GdkColormap *); + extern GdkExtensionMode gtk_widget_get_extension_events(GtkWidget *); + extern GtkRadioAction *gtk_radio_action_new(const gchar *, + const gchar *, + const gchar *, + const gchar *, gint); + extern GtkTextMark *gtk_text_buffer_get_selection_bound(GtkTextBuffer + *); + extern void gtk_box_set_child_packing(GtkBox *, GtkWidget *, gboolean, + gboolean, guint, GtkPackType); + extern guint16 gtk_color_selection_get_current_alpha(GtkColorSelection + *); + extern void gtk_calendar_get_date(GtkCalendar *, guint *, guint *, + guint *); + extern GType gtk_selection_data_get_type(void); + extern GType gtk_submenu_direction_get_type(void); + extern GType gtk_icon_set_get_type(void); + extern GType gtk_cell_renderer_text_get_type(void); + extern void gtk_icon_info_free(GtkIconInfo *); + extern void gtk_window_set_focus_on_map(GtkWindow *, gboolean); + extern void gtk_window_set_transient_for(GtkWindow *, GtkWindow *); + extern void gtk_widget_class_path(GtkWidget *, guint *, gchar * *, + gchar * *); + extern void gtk_tree_model_row_changed(GtkTreeModel *, GtkTreePath *, + GtkTreeIter *); + extern gboolean gtk_tree_drag_source_drag_data_delete(GtkTreeDragSource + *, + GtkTreePath *); + extern GType gtk_tree_model_get_column_type(GtkTreeModel *, gint); + extern void gtk_icon_view_set_columns(GtkIconView *, gint); + extern void gtk_container_child_get_valist(GtkContainer *, GtkWidget *, + const gchar *, va_list); + extern guchar *gtk_selection_data_get_text(GtkSelectionData *); + extern void gtk_window_resize(GtkWindow *, gint, gint); + extern void gtk_table_set_homogeneous(GtkTable *, gboolean); + extern guint gtk_quit_add_full(guint, GtkFunction, GtkCallbackMarshal, + gpointer, GtkDestroyNotify); + extern gboolean gtk_action_is_visible(GtkAction *); + extern GtkTextBuffer *gtk_text_iter_get_buffer(const GtkTextIter *); + extern void gtk_menu_set_screen(GtkMenu *, GdkScreen *); + extern void gtk_color_selection_set_previous_alpha(GtkColorSelection *, + guint16); + extern void gtk_toggle_button_set_active(GtkToggleButton *, gboolean); + extern void gtk_target_list_add_text_targets(GtkTargetList *, guint); + extern GdkEvent *gtk_get_current_event(void); + extern GType gtk_update_type_get_type(void); + extern const gchar *gtk_icon_source_get_filename(const GtkIconSource + *); + extern GtkIconTheme *gtk_icon_theme_get_for_screen(GdkScreen *); + extern GtkWidget *gtk_arrow_new(GtkArrowType, GtkShadowType); + extern void gtk_text_view_buffer_to_window_coords(GtkTextView *, + GtkTextWindowType, + gint, gint, gint *, + gint *); + extern GType gtk_style_get_type(void); + extern void + gtk_widget_class_install_style_property_parser(GtkWidgetClass *, + GParamSpec *, + GtkRcPropertyParser); + extern GType gtk_toolbar_child_type_get_type(void); + extern GtkToolItem *gtk_toggle_tool_button_new(void); + extern GdkPixbufAnimation *gtk_image_get_animation(GtkImage *); + extern gint gtk_tree_view_column_get_spacing(GtkTreeViewColumn *); + extern GdkPixmap *gtk_tree_view_create_row_drag_icon(GtkTreeView *, + GtkTreePath *); + extern void gtk_file_chooser_unselect_all(GtkFileChooser *); + extern gint gtk_icon_view_get_column_spacing(GtkIconView *); + extern GtkTreeViewColumn *gtk_tree_view_get_expander_column(GtkTreeView + *); + extern guint gtk_main_level(void); + extern void gtk_icon_set_add_source(GtkIconSet *, + const GtkIconSource *); + extern void gtk_window_set_title(GtkWindow *, const gchar *); + extern gchar *gtk_rc_find_module_in_path(const gchar *); + extern gint gtk_text_view_get_pixels_above_lines(GtkTextView *); + extern gboolean gtk_widget_remove_accelerator(GtkWidget *, + GtkAccelGroup *, guint, + GdkModifierType); + extern PangoLayout *gtk_widget_create_pango_layout(GtkWidget *, + const gchar *); + extern GtkIconSet *gtk_style_lookup_icon_set(GtkStyle *, const char *); + extern GType gtk_scrollbar_get_type(void); + extern gint gtk_box_get_spacing(GtkBox *); + extern void gtk_window_get_position(GtkWindow *, gint *, gint *); + extern GdkPixbuf *gtk_style_render_icon(GtkStyle *, + const GtkIconSource *, + GtkTextDirection, GtkStateType, + GtkIconSize, GtkWidget *, + const gchar *); + extern void gtk_icon_view_set_row_spacing(GtkIconView *, gint); + extern void gtk_quit_add_destroy(guint, GtkObject *); + extern GType gtk_color_selection_get_type(void); + extern gint gtk_spin_button_get_value_as_int(GtkSpinButton *); + extern gboolean gtk_label_get_single_line_mode(GtkLabel *); + extern void gtk_tool_item_set_homogeneous(GtkToolItem *, gboolean); + extern void gtk_cell_layout_pack_end(GtkCellLayout *, + GtkCellRenderer *, gboolean); + extern GtkWidget *gtk_file_chooser_get_preview_widget(GtkFileChooser + *); + extern void gtk_window_set_resizable(GtkWindow *, gboolean); + extern void gtk_text_buffer_insert_with_tags(GtkTextBuffer *, + GtkTextIter *, + const gchar *, gint, + GtkTextTag *, ...); + extern void gtk_tree_path_down(GtkTreePath *); + extern void gtk_file_selection_complete(GtkFileSelection *, + const gchar *); + extern void gtk_tool_item_set_tooltip(GtkToolItem *, GtkTooltips *, + const gchar *, const gchar *); + extern void gtk_text_buffer_insert_range(GtkTextBuffer *, + GtkTextIter *, + const GtkTextIter *, + const GtkTextIter *); + extern GType gtk_menu_get_type(void); + extern GtkTreeViewRowSeparatorFunc + gtk_tree_view_get_row_separator_func(GtkTreeView *); + extern gboolean gtk_text_view_get_overwrite(GtkTextView *); + extern void gtk_icon_theme_set_custom_theme(GtkIconTheme *, + const gchar *); + extern GdkGC *gtk_gc_get(gint, GdkColormap *, GdkGCValues *, + GdkGCValuesMask); + extern void gtk_cell_editable_editing_done(GtkCellEditable *); + extern void gtk_combo_box_append_text(GtkComboBox *, const gchar *); + extern gboolean gtk_tree_view_get_headers_visible(GtkTreeView *); + extern gboolean gtk_window_set_default_icon_from_file(const gchar *, + GError * *); + extern GtkWidget *gtk_widget_ref(GtkWidget *); + extern void gtk_text_buffer_delete(GtkTextBuffer *, GtkTextIter *, + GtkTextIter *); + extern void gtk_tree_view_set_rules_hint(GtkTreeView *, gboolean); + extern gint gtk_text_iter_get_bytes_in_line(const GtkTextIter *); + extern void gtk_icon_theme_get_search_path(GtkIconTheme *, gchar * **, + gint *); + extern gchar *gtk_file_chooser_get_current_folder_uri(GtkFileChooser + *); + extern void gtk_entry_completion_set_text_column(GtkEntryCompletion *, + gint); + extern GSList *gtk_action_get_proxies(GtkAction *); + extern GType gtk_tree_view_column_sizing_get_type(void); + extern void gtk_label_get_layout_offsets(GtkLabel *, gint *, gint *); + extern gboolean gtk_box_get_homogeneous(GtkBox *); + extern void gtk_text_view_set_left_margin(GtkTextView *, gint); + extern GType gtk_item_get_type(void); + extern gint gtk_entry_text_index_to_layout_index(GtkEntry *, gint); + extern void gtk_tree_view_get_visible_rect(GtkTreeView *, + GdkRectangle *); + extern gboolean gtk_tree_model_iter_next(GtkTreeModel *, + GtkTreeIter *); + extern void gtk_tree_store_move_before(GtkTreeStore *, GtkTreeIter *, + GtkTreeIter *); + extern void gtk_clipboard_set_text(GtkClipboard *, const gchar *, + gint); + extern GList *gtk_window_list_toplevels(void); + extern void gtk_tree_model_filter_clear_cache(GtkTreeModelFilter *); + extern void gtk_notebook_prev_page(GtkNotebook *); + extern GType gtk_widget_get_type(void); + extern GType gtk_vpaned_get_type(void); + extern gint gtk_tree_view_column_get_sort_column_id(GtkTreeViewColumn + *); + extern GtkTreePath + *gtk_tree_model_sort_convert_child_path_to_path(GtkTreeModelSort *, + GtkTreePath *); + extern void gtk_tool_item_set_is_important(GtkToolItem *, gboolean); + extern GType gtk_menu_bar_get_type(void); + extern GtkTreeViewColumnSizing + gtk_tree_view_column_get_sizing(GtkTreeViewColumn *); + extern void gtk_text_attributes_copy_values(GtkTextAttributes *, + GtkTextAttributes *); + extern GType gtk_calendar_display_options_get_type(void); + extern void gtk_tree_view_column_set_cell_data_func(GtkTreeViewColumn + *, + GtkCellRenderer *, + GtkTreeCellDataFunc, + gpointer, + GtkDestroyNotify); + extern void gtk_color_button_get_color(GtkColorButton *, GdkColor *); + extern GType gtk_notebook_get_type(void); + extern GtkWidget *gtk_file_chooser_dialog_new_with_backend(const gchar + *, + GtkWindow *, + GtkFileChooserAction, + const gchar + *, + const gchar + *, ...); + extern void gtk_container_forall(GtkContainer *, GtkCallback, + gpointer); + extern void gtk_text_buffer_add_selection_clipboard(GtkTextBuffer *, + GtkClipboard *); + extern GSList *gtk_accel_groups_from_object(GObject *); + extern GtkSortType + gtk_tree_view_column_get_sort_order(GtkTreeViewColumn *); + extern gint gtk_notebook_insert_page(GtkNotebook *, GtkWidget *, + GtkWidget *, gint); + extern GType gtk_table_get_type(void); + extern GtkWidget *gtk_menu_item_get_submenu(GtkMenuItem *); + extern gboolean gtk_text_view_scroll_to_iter(GtkTextView *, + GtkTextIter *, gdouble, + gboolean, gdouble, + gdouble); + extern void gtk_window_set_icon_list(GtkWindow *, GList *); + extern gboolean gtk_window_get_destroy_with_parent(GtkWindow *); + extern void gtk_container_add(GtkContainer *, GtkWidget *); + extern GtkShadowType gtk_handle_box_get_shadow_type(GtkHandleBox *); + extern GtkWidget *gtk_text_view_new(void); + extern void gtk_window_add_embedded_xid(GtkWindow *, guint); + extern gboolean gtk_label_get_use_underline(GtkLabel *); + extern gboolean gtk_text_view_starts_display_line(GtkTextView *, + const GtkTextIter *); + extern gdouble gtk_spin_button_get_value(GtkSpinButton *); + extern void gtk_tree_view_get_background_area(GtkTreeView *, + GtkTreePath *, + GtkTreeViewColumn *, + GdkRectangle *); + extern void gtk_color_selection_get_previous_color(GtkColorSelection *, + GdkColor *); + extern void gtk_file_chooser_set_action(GtkFileChooser *, + GtkFileChooserAction); + extern GtkWidget *gtk_dialog_add_button(GtkDialog *, const gchar *, + gint); + extern GType gtk_label_get_type(void); + extern GType gtk_accel_group_get_type(void); + extern GtkSelectionMode gtk_icon_view_get_selection_mode(GtkIconView + *); + extern GtkStyle *gtk_style_attach(GtkStyle *, GdkWindow *); + extern void gtk_item_select(GtkItem *); + extern void gtk_combo_box_set_column_span_column(GtkComboBox *, gint); + extern GtkWidget *gtk_file_selection_new(const gchar *); + extern GtkWidget *gtk_plug_new_for_display(GdkDisplay *, + GdkNativeWindow); + extern GtkAccelGroup *gtk_accel_group_new(void); + extern void gtk_grab_add(GtkWidget *); + extern const gchar *gtk_about_dialog_get_logo_icon_name(GtkAboutDialog + *); + extern GtkWidget *gtk_radio_menu_item_new_with_mnemonic(GSList *, + const gchar *); + extern gboolean gtk_window_get_focus_on_map(GtkWindow *); + extern GType gtk_radio_menu_item_get_type(void); + extern const gchar *gtk_entry_get_text(GtkEntry *); + extern GtkUIManager *gtk_ui_manager_new(void); + extern gboolean gtk_action_group_get_visible(GtkActionGroup *); + extern gboolean gtk_tree_store_iter_is_valid(GtkTreeStore *, + GtkTreeIter *); + extern void gtk_container_child_set(GtkContainer *, GtkWidget *, + const gchar *, ...); + extern gboolean gtk_rc_property_parse_border(const GParamSpec *, + const GString *, + GValue *); + extern void gtk_binding_entry_clear(GtkBindingSet *, guint, + GdkModifierType); + extern void gtk_menu_shell_select_first(GtkMenuShell *, gboolean); + extern void gtk_scrolled_window_set_placement(GtkScrolledWindow *, + GtkCornerType); + extern void gtk_frame_set_label_align(GtkFrame *, gfloat, gfloat); + extern GtkWidget *gtk_combo_box_new_text(void); + extern void gtk_text_view_add_child_at_anchor(GtkTextView *, + GtkWidget *, + GtkTextChildAnchor *); + extern GtkWidget *gtk_vscrollbar_new(GtkAdjustment *); + extern void gtk_separator_tool_item_set_draw(GtkSeparatorToolItem *, + gboolean); + extern gboolean gtk_toggle_button_get_active(GtkToggleButton *); + extern void gtk_clipboard_store(GtkClipboard *); + extern const gchar *const *gtk_about_dialog_get_authors(GtkAboutDialog + *); + extern GType gtk_vbutton_box_get_type(void); + extern void gtk_tree_view_column_cell_set_cell_data(GtkTreeViewColumn + *, GtkTreeModel *, + GtkTreeIter *, + gboolean, + gboolean); + extern GType gtk_im_context_get_type(void); + extern gboolean gtk_icon_size_lookup(GtkIconSize, gint *, gint *); + extern GtkTreeView *gtk_tree_selection_get_tree_view(GtkTreeSelection + *); + extern void gtk_expander_set_use_underline(GtkExpander *, gboolean); + extern GtkBindingSet *gtk_binding_set_new(const gchar *); + extern gchar *gtk_accelerator_name(guint, GdkModifierType); + extern gboolean gtk_expander_get_use_underline(GtkExpander *); + extern GtkPositionType gtk_handle_box_get_handle_position(GtkHandleBox + *); + extern GSList *gtk_ui_manager_get_toplevels(GtkUIManager *, + GtkUIManagerItemType); + extern gboolean gtk_im_context_filter_keypress(GtkIMContext *, + GdkEventKey *); + extern void gtk_range_set_value(GtkRange *, gdouble); + extern gboolean + gtk_font_selection_dialog_set_font_name(GtkFontSelectionDialog *, + const gchar *); + extern GtkStateType gtk_icon_source_get_state(const GtkIconSource *); + extern GType gtk_spin_button_update_policy_get_type(void); + extern void gtk_drag_dest_add_image_targets(GtkWidget *); + extern GtkAdjustment *gtk_layout_get_hadjustment(GtkLayout *); + extern gint gtk_notebook_page_num(GtkNotebook *, GtkWidget *); + extern void gtk_window_add_mnemonic(GtkWindow *, guint, GtkWidget *); + extern gboolean + gtk_tree_view_column_get_sort_indicator(GtkTreeViewColumn *); + extern void gtk_tree_model_filter_set_visible_column(GtkTreeModelFilter + *, gint); + extern void gtk_menu_shell_append(GtkMenuShell *, GtkWidget *); + extern GType gtk_image_menu_item_get_type(void); + extern void gtk_text_tag_table_add(GtkTextTagTable *, GtkTextTag *); + extern guint16 gtk_color_button_get_alpha(GtkColorButton *); + extern void gtk_action_set_accel_path(GtkAction *, const gchar *); + extern GtkTextChildAnchor *gtk_text_child_anchor_new(void); + extern void gtk_file_chooser_set_select_multiple(GtkFileChooser *, + gboolean); + extern GType gtk_action_group_get_type(void); + extern void gtk_tree_view_column_pack_end(GtkTreeViewColumn *, + GtkCellRenderer *, gboolean); + extern const gchar *gtk_menu_get_title(GtkMenu *); + extern GtkWidget *gtk_icon_view_new(void); + extern gboolean gtk_color_selection_is_adjusting(GtkColorSelection *); + extern void gtk_tree_view_set_row_separator_func(GtkTreeView *, + GtkTreeViewRowSeparatorFunc, + gpointer, + GtkDestroyNotify); + extern void gtk_adjustment_set_value(GtkAdjustment *, gdouble); + extern gboolean gtk_file_chooser_get_local_only(GtkFileChooser *); + extern gboolean gtk_tree_view_get_hover_expand(GtkTreeView *); + extern gboolean gtk_combo_box_get_focus_on_click(GtkComboBox *); + extern void gtk_paned_add2(GtkPaned *, GtkWidget *); + extern GdkVisual *gtk_widget_get_visual(GtkWidget *); + extern GType gtk_tree_store_get_type(void); + extern GtkIconInfo *gtk_icon_info_copy(GtkIconInfo *); + extern void gtk_icon_set_get_sizes(GtkIconSet *, GtkIconSize * *, + gint *); + extern GtkAdjustment *gtk_viewport_get_hadjustment(GtkViewport *); + extern void gtk_combo_box_insert_text(GtkComboBox *, gint, + const gchar *); + extern void + gtk_tree_model_sort_convert_iter_to_child_iter(GtkTreeModelSort *, + GtkTreeIter *, + GtkTreeIter *); + extern gboolean gtk_scale_get_draw_value(GtkScale *); + extern gint gtk_combo_box_entry_get_text_column(GtkComboBoxEntry *); + extern GType gtk_about_dialog_get_type(void); + extern void gtk_im_context_set_use_preedit(GtkIMContext *, gboolean); + extern void gtk_list_store_insert_with_valuesv(GtkListStore *, + GtkTreeIter *, gint, + gint *, GValue *, gint); + extern void gtk_notebook_set_scrollable(GtkNotebook *, gboolean); + extern void gtk_frame_set_shadow_type(GtkFrame *, GtkShadowType); + extern gchar *gtk_editable_get_chars(GtkEditable *, gint, gint); + extern gboolean gtk_text_view_backward_display_line(GtkTextView *, + GtkTextIter *); + extern GType gtk_icon_theme_error_get_type(void); + extern gint gtk_paned_get_position(GtkPaned *); + extern void gtk_widget_set_extension_events(GtkWidget *, + GdkExtensionMode); + extern GtkTargetList *gtk_drag_dest_get_target_list(GtkWidget *); + extern void gtk_main(void); + extern gboolean gtk_toggle_button_get_inconsistent(GtkToggleButton *); + extern gboolean gtk_alternative_dialog_button_order(GdkScreen *); + extern void gtk_window_set_mnemonic_modifier(GtkWindow *, + GdkModifierType); + extern void gtk_widget_set_default_colormap(GdkColormap *); + extern gboolean gtk_accel_map_lookup_entry(const gchar *, + GtkAccelKey *); + extern GtkWidget *gtk_about_dialog_new(void); + extern gboolean gtk_clipboard_set_with_data(GtkClipboard *, + const GtkTargetEntry *, + guint, GtkClipboardGetFunc, + GtkClipboardClearFunc, + gpointer); + extern GtkWidget *gtk_button_new(void); + extern GList *gtk_tree_selection_get_selected_rows(GtkTreeSelection *, + GtkTreeModel * *); + extern void gtk_tree_selection_select_all(GtkTreeSelection *); + extern GType gtk_menu_direction_type_get_type(void); + extern void gtk_action_set_visible(GtkAction *, gboolean); + extern GtkTooltipsData *gtk_tooltips_data_get(GtkWidget *); + extern void gtk_tree_store_move_after(GtkTreeStore *, GtkTreeIter *, + GtkTreeIter *); + extern void gtk_text_buffer_insert_with_tags_by_name(GtkTextBuffer *, + GtkTextIter *, + const gchar *, + gint, + const gchar *, + ...); + extern gboolean gtk_statusbar_get_has_resize_grip(GtkStatusbar *); + extern GdkGravity gtk_window_get_gravity(GtkWindow *); + extern GtkWidget *gtk_image_menu_item_new(void); + extern void gtk_button_leave(GtkButton *); + extern void gtk_text_buffer_insert_pixbuf(GtkTextBuffer *, + GtkTextIter *, GdkPixbuf *); + extern void gtk_action_group_add_radio_actions(GtkActionGroup *, + const + GtkRadioActionEntry *, + guint, gint, GCallback, + gpointer); + extern GtkWidget *gtk_vscale_new_with_range(gdouble, gdouble, gdouble); + extern void gtk_text_buffer_delete_mark(GtkTextBuffer *, + GtkTextMark *); + extern GType gtk_viewport_get_type(void); + extern void gtk_notebook_set_current_page(GtkNotebook *, gint); + extern void gtk_text_view_get_line_yrange(GtkTextView *, + const GtkTextIter *, gint *, + gint *); + extern gint gtk_combo_box_get_wrap_width(GtkComboBox *); + extern void gtk_image_get_pixmap(GtkImage *, GdkPixmap * *, + GdkBitmap * *); + extern void gtk_show_about_dialog(GtkWindow *, const gchar *, ...); + extern gint gtk_tree_view_column_get_min_width(GtkTreeViewColumn *); + extern GtkWidget *gtk_toggle_button_new(void); + extern void gtk_drag_dest_add_uri_targets(GtkWidget *); + extern void gtk_scrolled_window_set_shadow_type(GtkScrolledWindow *, + GtkShadowType); + extern GtkTextAttributes *gtk_text_attributes_copy(GtkTextAttributes + *); + extern void gtk_combo_box_set_active_iter(GtkComboBox *, + GtkTreeIter *); + extern void gtk_table_resize(GtkTable *, guint, guint); + extern GtkWidget *gtk_aspect_frame_new(const gchar *, gfloat, gfloat, + gfloat, gboolean); + extern gint gtk_tree_view_insert_column(GtkTreeView *, + GtkTreeViewColumn *, gint); + extern void gtk_image_get_stock(GtkImage *, gchar * *, GtkIconSize *); + extern void gtk_label_select_region(GtkLabel *, gint, gint); + extern void gtk_tree_selection_unselect_all(GtkTreeSelection *); + extern void gtk_curve_set_gamma(GtkCurve *, gfloat); + extern void gtk_window_unfullscreen(GtkWindow *); + extern GtkWidget *gtk_button_new_with_label(const gchar *); + extern const gchar *gtk_label_get_text(GtkLabel *); + extern GtkWidget *gtk_frame_get_label_widget(GtkFrame *); + extern GtkStyle *gtk_widget_get_style(GtkWidget *); + extern GtkToolItem *gtk_tool_button_new(GtkWidget *, const gchar *); + extern void gtk_menu_item_select(GtkMenuItem *); + extern void gtk_tree_view_set_column_drag_function(GtkTreeView *, + GtkTreeViewColumnDropFunc, + gpointer, + GtkDestroyNotify); + extern void gtk_paint_vline(GtkStyle *, GdkWindow *, GtkStateType, + GdkRectangle *, GtkWidget *, const gchar *, + gint, gint, gint); + extern gboolean gtk_event_box_get_visible_window(GtkEventBox *); + extern gboolean gtk_tree_drag_dest_row_drop_possible(GtkTreeDragDest *, + GtkTreePath *, + GtkSelectionData + *); + extern gboolean gtk_tool_item_get_is_important(GtkToolItem *); + extern void gtk_key_snooper_remove(guint); + extern void gtk_settings_set_long_property(GtkSettings *, + const gchar *, glong, + const gchar *); + extern void gtk_action_group_add_toggle_actions(GtkActionGroup *, + const + GtkToggleActionEntry *, + guint, gpointer); + extern void gtk_frame_set_label(GtkFrame *, const gchar *); + extern guint gtk_accel_label_get_accel_width(GtkAccelLabel *); + extern GtkTreeModel *gtk_tree_model_sort_get_model(GtkTreeModelSort *); + extern void gtk_image_menu_item_set_image(GtkImageMenuItem *, + GtkWidget *); + extern GtkWidget *gtk_image_menu_item_new_with_mnemonic(const gchar *); + extern void gtk_label_set_markup_with_mnemonic(GtkLabel *, + const gchar *); + extern void gtk_tooltips_disable(GtkTooltips *); + extern GType gtk_cell_renderer_pixbuf_get_type(void); + extern GtkWidget *gtk_widget_get_ancestor(GtkWidget *, GType); + extern gboolean gtk_widget_intersect(GtkWidget *, GdkRectangle *, + GdkRectangle *); + extern GtkWidget *gtk_toolbar_new(void); + extern void gtk_text_view_set_pixels_inside_wrap(GtkTextView *, gint); + extern void gtk_container_child_get_property(GtkContainer *, + GtkWidget *, + const gchar *, GValue *); + extern void gtk_text_view_get_visible_rect(GtkTextView *, + GdkRectangle *); + extern void gtk_cell_layout_reorder(GtkCellLayout *, GtkCellRenderer *, + gint); + extern GtkWidget *gtk_menu_bar_new(void); + extern GType gtk_separator_tool_item_get_type(void); + extern void gtk_button_pressed(GtkButton *); + extern gint gtk_combo_box_get_row_span_column(GtkComboBox *); + extern gboolean gtk_text_tag_event(GtkTextTag *, GObject *, GdkEvent *, + const GtkTextIter *); + extern GtkWidget *gtk_gamma_curve_new(void); + extern gboolean gtk_calendar_select_month(GtkCalendar *, guint, guint); + extern void gtk_window_deiconify(GtkWindow *); + extern void gtk_plug_construct(GtkPlug *, GdkNativeWindow); + extern gboolean gtk_text_iter_backward_word_starts(GtkTextIter *, + gint); + extern const gchar + *gtk_file_chooser_button_get_title(GtkFileChooserButton *); + extern gchar *gtk_text_iter_get_slice(const GtkTextIter *, + const GtkTextIter *); + extern guint gtk_spin_button_get_digits(GtkSpinButton *); + extern void gtk_image_set_from_icon_set(GtkImage *, GtkIconSet *, + GtkIconSize); + extern gboolean gtk_file_chooser_select_uri(GtkFileChooser *, + const char *); + extern void gtk_container_set_focus_chain(GtkContainer *, GList *); + extern void gtk_stock_item_free(GtkStockItem *); + extern void gtk_menu_popup(GtkMenu *, GtkWidget *, GtkWidget *, + GtkMenuPositionFunc, gpointer, guint, + guint32); + extern GtkProgressBarOrientation + gtk_progress_bar_get_orientation(GtkProgressBar *); + extern void gtk_list_store_set(GtkListStore *, GtkTreeIter *, ...); + extern void gtk_action_group_set_translate_func(GtkActionGroup *, + GtkTranslateFunc, + gpointer, + GtkDestroyNotify); + extern GtkWidget *gtk_image_new_from_stock(const gchar *, GtkIconSize); + extern void gtk_box_pack_end_defaults(GtkBox *, GtkWidget *); + extern void gtk_toolbar_set_style(GtkToolbar *, GtkToolbarStyle); + extern GtkAccelGroup *gtk_accel_group_from_accel_closure(GClosure *); + extern GType gtk_container_get_type(void); + extern void gtk_about_dialog_set_version(GtkAboutDialog *, + const gchar *); + extern gboolean gtk_file_chooser_set_uri(GtkFileChooser *, + const char *); + extern void gtk_tree_model_filter_refilter(GtkTreeModelFilter *); + extern void gtk_tooltips_force_window(GtkTooltips *); + extern GtkWidget *gtk_tree_view_new_with_model(GtkTreeModel *); + extern void gtk_tree_model_row_inserted(GtkTreeModel *, GtkTreePath *, + GtkTreeIter *); + extern GdkModifierType gtk_window_get_mnemonic_modifier(GtkWindow *); + extern void gtk_tooltips_set_tip(GtkTooltips *, GtkWidget *, + const gchar *, const gchar *); + extern void gtk_cell_layout_set_cell_data_func(GtkCellLayout *, + GtkCellRenderer *, + GtkCellLayoutDataFunc, + gpointer, + GDestroyNotify); + extern gboolean gtk_selection_data_set_text(GtkSelectionData *, + const gchar *, gint); + extern GtkTreeRowReference *gtk_tree_row_reference_new(GtkTreeModel *, + GtkTreePath *); + extern void gtk_widget_set_double_buffered(GtkWidget *, gboolean); + extern gint gtk_combo_box_get_active(GtkComboBox *); + extern void gtk_tool_button_set_label(GtkToolButton *, const gchar *); + extern gboolean gtk_text_iter_forward_to_line_end(GtkTextIter *); + extern gboolean gtk_clipboard_wait_for_targets(GtkClipboard *, + GdkAtom * *, gint *); + extern gboolean gtk_text_buffer_delete_selection(GtkTextBuffer *, + gboolean, gboolean); + extern void gtk_spin_button_set_wrap(GtkSpinButton *, gboolean); + extern GType gtk_input_dialog_get_type(void); + extern const gchar *gtk_file_selection_get_filename(GtkFileSelection + *); + extern gboolean gtk_tree_set_row_drag_data(GtkSelectionData *, + GtkTreeModel *, + GtkTreePath *); + extern GtkWidget *gtk_widget_get_toplevel(GtkWidget *); + extern void gtk_menu_set_accel_group(GtkMenu *, GtkAccelGroup *); + extern GType gtk_socket_get_type(void); + extern gboolean gtk_widget_set_scroll_adjustments(GtkWidget *, + GtkAdjustment *, + GtkAdjustment *); + extern void gtk_selection_data_free(GtkSelectionData *); + extern gboolean gtk_selection_data_set_uris(GtkSelectionData *, + gchar * *); + extern GType gtk_text_tag_table_get_type(void); + extern void gtk_entry_completion_insert_prefix(GtkEntryCompletion *); + extern GType gtk_window_group_get_type(void); + extern void gtk_action_set_sensitive(GtkAction *, gboolean); + extern GtkTextBuffer *gtk_text_view_get_buffer(GtkTextView *); + extern gboolean gtk_icon_theme_has_icon(GtkIconTheme *, const char *); + extern void gtk_label_set_selectable(GtkLabel *, gboolean); + extern gboolean gtk_file_chooser_set_current_folder_uri(GtkFileChooser + *, + const gchar *); + extern gdouble gtk_label_get_angle(GtkLabel *); + extern GtkSettings *gtk_widget_get_settings(GtkWidget *); + extern GSList *gtk_text_iter_get_tags(const GtkTextIter *); + extern void gtk_tree_view_column_add_attribute(GtkTreeViewColumn *, + GtkCellRenderer *, + const gchar *, gint); + extern void gtk_menu_popdown(GtkMenu *); + extern void + gtk_tree_model_sort_reset_default_sort_func(GtkTreeModelSort *); + extern void gtk_tooltips_enable(GtkTooltips *); + extern void gtk_expander_set_spacing(GtkExpander *, gint); + extern gint gtk_entry_layout_index_to_text_index(GtkEntry *, gint); + extern gdouble gtk_progress_bar_get_pulse_step(GtkProgressBar *); + extern gboolean gtk_text_iter_backward_visible_word_start(GtkTextIter + *); + extern void gtk_expander_set_label(GtkExpander *, const gchar *); + extern void gtk_text_buffer_get_iter_at_line_index(GtkTextBuffer *, + GtkTextIter *, gint, + gint); + extern guint gtk_ui_manager_add_ui_from_string(GtkUIManager *, + const gchar *, gssize, + GError * *); + extern gboolean gtk_icon_info_get_embedded_rect(GtkIconInfo *, + GdkRectangle *); + extern void gtk_widget_queue_resize(GtkWidget *); + extern GType gtk_tree_path_get_type(void); + extern void gtk_notebook_set_tab_label_text(GtkNotebook *, GtkWidget *, + const gchar *); + extern GtkWidget *gtk_dialog_new(void); + extern GtkIconSize gtk_toolbar_get_icon_size(GtkToolbar *); + extern void gtk_widget_hide(GtkWidget *); + extern GtkIconSet *gtk_icon_factory_lookup_default(const gchar *); + extern GtkWidget *gtk_tree_view_new(void); + extern gboolean + gtk_text_iter_forward_visible_cursor_position(GtkTextIter *); + extern void gtk_paint_layout(GtkStyle *, GdkWindow *, GtkStateType, + gboolean, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, PangoLayout *); + extern gboolean gtk_button_get_use_stock(GtkButton *); + extern void gtk_list_store_clear(GtkListStore *); + extern void gtk_widget_set_app_paintable(GtkWidget *, gboolean); + extern void gtk_gc_release(GdkGC *); + extern void gtk_text_view_get_iter_at_location(GtkTextView *, + GtkTextIter *, gint, + gint); + extern gboolean gtk_text_view_backward_display_line_start(GtkTextView + *, + GtkTextIter + *); + extern void gtk_text_mark_set_visible(GtkTextMark *, gboolean); + extern gint + gtk_file_chooser_button_get_width_chars(GtkFileChooserButton *); + extern GType gtk_anchor_type_get_type(void); + extern gboolean gtk_tree_view_get_reorderable(GtkTreeView *); + extern GType gtk_hruler_get_type(void); + extern void gtk_icon_source_set_icon_name(GtkIconSource *, + const gchar *); + extern gboolean gtk_init_with_args(int *, char ***, char *, + GOptionEntry *, char *, GError * *); + extern void gtk_cell_renderer_toggle_set_radio(GtkCellRendererToggle *, + gboolean); + extern void gtk_window_set_destroy_with_parent(GtkWindow *, gboolean); + extern gboolean gtk_entry_get_visibility(GtkEntry *); + extern GtkTreePath *gtk_tree_path_new_from_indices(gint, ...); + extern PangoEllipsizeMode gtk_progress_bar_get_ellipsize(GtkProgressBar + *); + extern void gtk_list_store_insert_with_values(GtkListStore *, + GtkTreeIter *, gint, + ...); + extern void gtk_color_button_set_color(GtkColorButton *, + const GdkColor *); + extern gboolean gtk_tree_path_is_ancestor(GtkTreePath *, + GtkTreePath *); + extern guint gtk_table_get_default_row_spacing(GtkTable *); + extern GtkWidget *gtk_entry_completion_get_entry(GtkEntryCompletion *); + extern GType gtk_progress_bar_get_type(void); + extern gunichar gtk_text_iter_get_char(const GtkTextIter *); + extern const gchar *gtk_color_button_get_title(GtkColorButton *); + extern GtkTargetList *gtk_drag_source_get_target_list(GtkWidget *); + extern gboolean gtk_text_iter_ends_tag(const GtkTextIter *, + GtkTextTag *); + extern void gtk_cell_layout_clear(GtkCellLayout *); + extern gboolean gtk_binding_set_activate(GtkBindingSet *, guint, + GdkModifierType, GtkObject *); + extern void gtk_toolbar_set_drop_highlight_item(GtkToolbar *, + GtkToolItem *, gint); + extern void gtk_curve_set_range(GtkCurve *, gfloat, gfloat, gfloat, + gfloat); + extern void gtk_accel_group_unlock(GtkAccelGroup *); + extern void gtk_combo_box_remove_text(GtkComboBox *, gint); + extern GType gtk_message_dialog_get_type(void); + extern void gtk_button_set_relief(GtkButton *, GtkReliefStyle); + extern void gtk_file_filter_add_pattern(GtkFileFilter *, + const gchar *); + extern void gtk_widget_map(GtkWidget *); + extern void gtk_container_child_get(GtkContainer *, GtkWidget *, + const gchar *, ...); + extern GType gtk_policy_type_get_type(void); + extern void gtk_ui_manager_ensure_update(GtkUIManager *); + extern gint gtk_notebook_insert_page_menu(GtkNotebook *, GtkWidget *, + GtkWidget *, GtkWidget *, + gint); + extern gboolean + gtk_tree_view_column_cell_get_position(GtkTreeViewColumn *, + GtkCellRenderer *, gint *, + gint *); + extern gboolean gtk_toolbar_get_show_arrow(GtkToolbar *); + extern gboolean gtk_cell_view_get_size_of_row(GtkCellView *, + GtkTreePath *, + GtkRequisition *); + extern void gtk_curve_get_vector(GtkCurve *, int, gfloat *); + extern void gtk_drag_source_set_icon_pixbuf(GtkWidget *, GdkPixbuf *); + extern GType gtk_file_filter_get_type(void); + extern void gtk_clipboard_set_can_store(GtkClipboard *, + const GtkTargetEntry *, gint); + extern void gtk_tree_view_tree_to_widget_coords(GtkTreeView *, gint, + gint, gint *, gint *); + extern void gtk_tree_view_enable_model_drag_dest(GtkTreeView *, + const GtkTargetEntry + *, gint, + GdkDragAction); + extern void gtk_clipboard_request_image(GtkClipboard *, + GtkClipboardImageReceivedFunc, + gpointer); + extern const gchar *gtk_about_dialog_get_version(GtkAboutDialog *); + extern GtkTreeModel *gtk_combo_box_get_model(GtkComboBox *); + extern GtkWidget *gtk_tool_item_retrieve_proxy_menu_item(GtkToolItem + *); + extern void gtk_action_activate(GtkAction *); + extern GtkWidget *gtk_vpaned_new(void); + extern GType gtk_curve_get_type(void); + extern const gchar *gtk_label_get_label(GtkLabel *); + extern GType gtk_toggle_button_get_type(void); + extern void gtk_cell_layout_set_attributes(GtkCellLayout *, + GtkCellRenderer *, ...); + extern void gtk_tree_view_set_cursor_on_cell(GtkTreeView *, + GtkTreePath *, + GtkTreeViewColumn *, + GtkCellRenderer *, + gboolean); + extern GType gtk_file_filter_flags_get_type(void); + extern void gtk_tree_model_ref_node(GtkTreeModel *, GtkTreeIter *); + extern gchar *gtk_tree_path_to_string(GtkTreePath *); + extern gboolean gtk_rc_property_parse_enum(const GParamSpec *, + const GString *, GValue *); + extern void gtk_file_chooser_set_use_preview_label(GtkFileChooser *, + gboolean); + extern GType gtk_icon_size_get_type(void); + extern void gtk_statusbar_set_has_resize_grip(GtkStatusbar *, + gboolean); + extern GtkTreeModel *gtk_entry_completion_get_model(GtkEntryCompletion + *); + extern GtkPositionType gtk_notebook_get_tab_pos(GtkNotebook *); + extern GtkTreeViewRowSeparatorFunc + gtk_combo_box_get_row_separator_func(GtkComboBox *); + extern void gtk_accel_map_save(const gchar *); + extern GtkCellRenderer *gtk_cell_renderer_text_new(void); + extern void gtk_menu_set_title(GtkMenu *, const gchar *); + extern GType gtk_tool_item_get_type(void); + extern GdkWindow *gtk_text_view_get_window(GtkTextView *, + GtkTextWindowType); + extern void gtk_spin_button_set_update_policy(GtkSpinButton *, + GtkSpinButtonUpdatePolicy); + extern guint gtk_rc_parse_color(GScanner *, GdkColor *); + extern void + gtk_font_selection_dialog_set_preview_text(GtkFontSelectionDialog + *, const gchar *); + extern GtkAdjustment + *gtk_scrolled_window_get_vadjustment(GtkScrolledWindow *); + extern void gtk_menu_shell_deactivate(GtkMenuShell *); + extern char *gtk_icon_theme_get_example_icon_name(GtkIconTheme *); + extern const guint gtk_micro_version; + extern gint gtk_text_view_get_pixels_below_lines(GtkTextView *); + extern GType gtk_path_priority_type_get_type(void); + extern void gtk_window_set_accept_focus(GtkWindow *, gboolean); + extern void gtk_text_buffer_get_iter_at_offset(GtkTextBuffer *, + GtkTextIter *, gint); + extern void gtk_statusbar_remove(GtkStatusbar *, guint, guint); + extern gboolean gtk_menu_item_get_right_justified(GtkMenuItem *); + extern gboolean gtk_separator_tool_item_get_draw(GtkSeparatorToolItem + *); + extern GtkWidget *gtk_calendar_new(void); + extern void gtk_entry_completion_set_model(GtkEntryCompletion *, + GtkTreeModel *); + extern void gtk_text_buffer_place_cursor(GtkTextBuffer *, + const GtkTextIter *); + extern void gtk_list_store_insert(GtkListStore *, GtkTreeIter *, gint); + extern gboolean gtk_events_pending(void); + extern GtkCellEditable *gtk_cell_renderer_start_editing(GtkCellRenderer + *, GdkEvent *, + GtkWidget *, + const gchar *, + GdkRectangle *, + GdkRectangle *, + GtkCellRendererState); + extern void gtk_cell_editable_remove_widget(GtkCellEditable *); + extern GList *gtk_widget_list_accel_closures(GtkWidget *); + extern gint *gtk_icon_theme_get_icon_sizes(GtkIconTheme *, + const char *); + extern void gtk_action_group_add_actions_full(GtkActionGroup *, + const GtkActionEntry *, + guint, gpointer, + GDestroyNotify); + extern void gtk_spin_button_set_adjustment(GtkSpinButton *, + GtkAdjustment *); + extern void + gtk_tree_model_sort_convert_child_iter_to_iter(GtkTreeModelSort *, + GtkTreeIter *, + GtkTreeIter *); + extern GtkWidget *gtk_image_menu_item_get_image(GtkImageMenuItem *); + extern void gtk_main_quit(void); + extern void gtk_widget_size_request(GtkWidget *, GtkRequisition *); + extern void gtk_window_set_default_icon_list(GList *); + extern void gtk_widget_push_composite_child(void); + extern void gtk_paned_add1(GtkPaned *, GtkWidget *); + extern gboolean gtk_selection_data_get_targets(GtkSelectionData *, + GdkAtom * *, gint *); + extern GtkTextAttributes + *gtk_text_view_get_default_attributes(GtkTextView *); + extern GtkTreeModel *gtk_tree_model_sort_new_with_model(GtkTreeModel + *); + extern GSList *gtk_radio_button_get_group(GtkRadioButton *); + extern GType gtk_sort_type_get_type(void); + extern gboolean gtk_tool_item_get_use_drag_window(GtkToolItem *); + extern gint gtk_notebook_prepend_page_menu(GtkNotebook *, GtkWidget *, + GtkWidget *, GtkWidget *); + extern GType gtk_tree_model_get_type(void); + extern void gtk_check_menu_item_set_inconsistent(GtkCheckMenuItem *, + gboolean); + extern GType gtk_tree_drag_dest_get_type(void); + extern GtkWidget *gtk_hscale_new(GtkAdjustment *); + extern void gtk_tree_view_column_set_min_width(GtkTreeViewColumn *, + gint); + extern GtkAdjustment + *gtk_scrolled_window_get_hadjustment(GtkScrolledWindow *); + extern gboolean gtk_text_buffer_backspace(GtkTextBuffer *, + GtkTextIter *, gboolean, + gboolean); + extern void gtk_tool_item_set_expand(GtkToolItem *, gboolean); + extern GType gtk_icon_info_get_type(void); + extern gint gtk_tree_model_iter_n_children(GtkTreeModel *, + GtkTreeIter *); + extern GtkReliefStyle gtk_toolbar_get_relief_style(GtkToolbar *); + extern void gtk_button_set_image(GtkButton *, GtkWidget *); + extern void gtk_paint_shadow_gap(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, + GtkWidget *, gchar *, gint, gint, + gint, gint, GtkPositionType, gint, + gint); + extern void gtk_window_set_modal(GtkWindow *, gboolean); + extern void gtk_spin_button_get_range(GtkSpinButton *, gdouble *, + gdouble *); + extern gint gtk_image_get_pixel_size(GtkImage *); + extern void gtk_text_view_get_iter_location(GtkTextView *, + const GtkTextIter *, + GdkRectangle *); + extern void gtk_tree_view_row_activated(GtkTreeView *, GtkTreePath *, + GtkTreeViewColumn *); + extern void gtk_container_set_focus_child(GtkContainer *, GtkWidget *); + extern gboolean gtk_accel_groups_activate(GObject *, guint, + GdkModifierType); + extern GtkTextIter *gtk_text_iter_copy(const GtkTextIter *); + extern gboolean gtk_action_is_sensitive(GtkAction *); + extern void gtk_tree_store_set_valist(GtkTreeStore *, GtkTreeIter *, + va_list); + extern void gtk_radio_button_set_group(GtkRadioButton *, GSList *); + extern void gtk_alignment_get_padding(GtkAlignment *, guint *, guint *, + guint *, guint *); + extern gboolean gtk_text_iter_starts_word(const GtkTextIter *); + extern void gtk_calendar_clear_marks(GtkCalendar *); + extern GType gtk_box_get_type(void); + extern void gtk_widget_path(GtkWidget *, guint *, gchar * *, + gchar * *); + extern gboolean gtk_menu_get_tearoff_state(GtkMenu *); + extern void gtk_window_stick(GtkWindow *); + extern gint gtk_widget_get_events(GtkWidget *); + extern GType gtk_cell_renderer_state_get_type(void); + extern void gtk_text_attributes_unref(GtkTextAttributes *); + extern gboolean gtk_tree_view_column_get_resizable(GtkTreeViewColumn + *); + extern void + gtk_entry_completion_insert_action_markup(GtkEntryCompletion *, + gint, const gchar *); + extern GType gtk_ruler_get_type(void); + extern GType gtk_wrap_mode_get_type(void); + extern GType gtk_paned_get_type(void); + extern void gtk_text_view_set_cursor_visible(GtkTextView *, gboolean); + extern gboolean gtk_target_list_find(GtkTargetList *, GdkAtom, + guint *); + extern GtkWidget *gtk_cell_view_new_with_text(const gchar *); + extern void gtk_editable_select_region(GtkEditable *, gint, gint); + extern gchar *gtk_clipboard_wait_for_text(GtkClipboard *); + extern gboolean gtk_color_selection_get_has_palette(GtkColorSelection + *); + extern GType gtk_text_search_flags_get_type(void); + extern gint gtk_tree_view_insert_column_with_data_func(GtkTreeView *, + gint, + const gchar *, + GtkCellRenderer + *, + GtkTreeCellDataFunc, + gpointer, + GDestroyNotify); + extern GtkTextTagTable *gtk_text_tag_table_new(void); + extern gboolean gtk_notebook_get_show_border(GtkNotebook *); + extern void + gtk_container_class_install_child_property(GtkContainerClass *, + guint, GParamSpec *); + extern void gtk_font_button_set_show_style(GtkFontButton *, gboolean); + extern void gtk_cell_layout_pack_start(GtkCellLayout *, + GtkCellRenderer *, gboolean); + extern GtkAction *gtk_action_group_get_action(GtkActionGroup *, + const gchar *); + extern GtkWidget *gtk_color_selection_dialog_new(const gchar *); + extern GtkEntryCompletion *gtk_entry_get_completion(GtkEntry *); + extern GtkToggleAction *gtk_toggle_action_new(const gchar *, + const gchar *, + const gchar *, + const gchar *); + extern void gtk_file_chooser_set_filter(GtkFileChooser *, + GtkFileFilter *); + extern gint gtk_text_iter_get_line_offset(const GtkTextIter *); + extern void gtk_text_view_set_indent(GtkTextView *, gint); + extern void gtk_widget_set_style(GtkWidget *, GtkStyle *); + extern void gtk_toolbar_unset_style(GtkToolbar *); + extern GType gtk_hbutton_box_get_type(void); + extern GtkWidget *gtk_file_chooser_button_new(const gchar *, + GtkFileChooserAction); + extern void gtk_combo_box_popup(GtkComboBox *); + extern void gtk_border_free(GtkBorder *); + extern void gtk_message_dialog_format_secondary_text(GtkMessageDialog + *, const gchar *, + ...); + extern GtkListStore *gtk_list_store_new(gint, ...); + extern void gtk_rc_style_ref(GtkRcStyle *); + extern guint32 gtk_get_current_event_time(void); + extern void gtk_container_unset_focus_chain(GtkContainer *); + extern void gtk_text_iter_set_offset(GtkTextIter *, gint); + extern void gtk_container_set_border_width(GtkContainer *, guint); + extern void gtk_selection_remove_all(GtkWidget *); + extern GtkReliefStyle gtk_tool_item_get_relief_style(GtkToolItem *); + extern void gtk_toggle_button_toggled(GtkToggleButton *); + extern void gtk_adjustment_value_changed(GtkAdjustment *); + extern gboolean gtk_widget_hide_on_delete(GtkWidget *); + extern GType gtk_container_child_type(GtkContainer *); + extern void gtk_ruler_set_range(GtkRuler *, gdouble, gdouble, gdouble, + gdouble); + extern PangoLayout *gtk_entry_get_layout(GtkEntry *); + extern void gtk_tree_sortable_sort_column_changed(GtkTreeSortable *); + extern void gtk_menu_shell_cancel(GtkMenuShell *); + extern guint gtk_table_get_col_spacing(GtkTable *, guint); + extern const gchar *gtk_button_get_label(GtkButton *); + extern GList *gtk_ui_manager_get_action_groups(GtkUIManager *); + extern void gtk_action_group_set_sensitive(GtkActionGroup *, gboolean); + extern GtkWidget *gtk_check_button_new_with_mnemonic(const gchar *); + extern void gtk_widget_unparent(GtkWidget *); + extern void gtk_widget_add_accelerator(GtkWidget *, const gchar *, + GtkAccelGroup *, guint, + GdkModifierType, GtkAccelFlags); + extern guint gtk_ui_manager_new_merge_id(GtkUIManager *); + extern gboolean gtk_text_iter_backward_find_char(GtkTextIter *, + GtkTextCharPredicate, + gpointer, + const GtkTextIter *); + extern gboolean gtk_file_chooser_get_select_multiple(GtkFileChooser *); + extern gboolean gtk_event_box_get_above_child(GtkEventBox *); + extern void gtk_widget_queue_draw(GtkWidget *); + extern gboolean + gtk_text_buffer_insert_interactive_at_cursor(GtkTextBuffer *, + const gchar *, gint, + gboolean); + extern gboolean + gtk_selection_data_targets_include_image(GtkSelectionData *, + gboolean); + extern GtkWidget *gtk_separator_menu_item_new(void); + extern gboolean gtk_widget_mnemonic_activate(GtkWidget *, gboolean); + extern void gtk_tree_selection_select_range(GtkTreeSelection *, + GtkTreePath *, + GtkTreePath *); + extern void gtk_file_chooser_unselect_uri(GtkFileChooser *, + const char *); + extern void gtk_style_detach(GtkStyle *); + extern gboolean gtk_accel_group_disconnect_key(GtkAccelGroup *, guint, + GdkModifierType); + extern gboolean gtk_notebook_get_show_tabs(GtkNotebook *); + extern void gtk_file_chooser_set_preview_widget_active(GtkFileChooser + *, gboolean); + extern GList *gtk_window_get_default_icon_list(void); + extern gboolean gtk_text_iter_backward_lines(GtkTextIter *, gint); + extern void gtk_notebook_popup_disable(GtkNotebook *); + extern GtkTreeModel *gtk_tree_model_filter_get_model(GtkTreeModelFilter + *); + extern gdouble gtk_adjustment_get_value(GtkAdjustment *); + extern GtkWidget *gtk_curve_new(void); + extern void gtk_widget_get_child_requisition(GtkWidget *, + GtkRequisition *); + extern gchar *gtk_rc_get_im_module_path(void); + extern void gtk_window_set_default(GtkWindow *, GtkWidget *); + extern void gtk_entry_set_text(GtkEntry *, const gchar *); + extern gboolean gtk_true(void); + extern void gtk_box_set_homogeneous(GtkBox *, gboolean); + extern void gtk_text_buffer_apply_tag(GtkTextBuffer *, GtkTextTag *, + const GtkTextIter *, + const GtkTextIter *); + extern void gtk_expander_set_use_markup(GtkExpander *, gboolean); + extern GtkWidget *gtk_tearoff_menu_item_new(void); + extern GtkImageType gtk_image_get_storage_type(GtkImage *); + extern GType gtk_text_window_type_get_type(void); + extern void gtk_text_buffer_remove_selection_clipboard(GtkTextBuffer *, + GtkClipboard *); + extern gboolean gtk_ui_manager_get_add_tearoffs(GtkUIManager *); + extern GtkPositionType gtk_handle_box_get_snap_edge(GtkHandleBox *); + extern void gtk_widget_get_size_request(GtkWidget *, gint *, gint *); + extern GType gtk_action_get_type(void); + extern gboolean gtk_window_get_accept_focus(GtkWindow *); + extern void gtk_spin_button_set_digits(GtkSpinButton *, guint); + extern void gtk_window_group_remove_window(GtkWindowGroup *, + GtkWindow *); + extern gpointer gtk_type_class(GtkType); + extern void gtk_color_selection_set_current_color(GtkColorSelection *, + const GdkColor *); + extern GtkSpinButtonUpdatePolicy + gtk_spin_button_get_update_policy(GtkSpinButton *); + extern void gtk_dialog_set_default_response(GtkDialog *, gint); + extern gboolean gtk_font_button_set_font_name(GtkFontButton *, + const gchar *); + extern void gtk_tree_row_reference_inserted(GObject *, GtkTreePath *); + extern const gchar *gtk_tool_button_get_label(GtkToolButton *); + extern GtkWidget *gtk_menu_tool_button_get_menu(GtkMenuToolButton *); + extern void gtk_tree_view_set_headers_visible(GtkTreeView *, gboolean); + extern GList *gtk_text_child_anchor_get_widgets(GtkTextChildAnchor *); + extern gint gtk_toolbar_get_drop_index(GtkToolbar *, gint, gint); + extern void gtk_progress_bar_set_orientation(GtkProgressBar *, + GtkProgressBarOrientation); + extern void gtk_window_set_geometry_hints(GtkWindow *, GtkWidget *, + GdkGeometry *, + GdkWindowHints); + extern GType gtk_progress_bar_orientation_get_type(void); + extern GtkReliefStyle gtk_button_get_relief(GtkButton *); + extern gboolean gtk_bindings_activate(GtkObject *, guint, + GdkModifierType); + extern GType gtk_toolbar_style_get_type(void); + extern void gtk_menu_set_accel_path(GtkMenu *, const gchar *); + extern void gtk_alignment_set_padding(GtkAlignment *, guint, guint, + guint, guint); + extern GtkTreeRowReference + *gtk_tree_row_reference_copy(GtkTreeRowReference *); + extern GtkToolItem + *gtk_radio_tool_button_new_from_widget(GtkRadioToolButton *); + extern GType gtk_tree_model_sort_get_type(void); + extern GdkWindow *gtk_tree_view_get_bin_window(GtkTreeView *); + extern GtkToolbarStyle gtk_toolbar_get_style(GtkToolbar *); + extern void gtk_size_group_set_mode(GtkSizeGroup *, GtkSizeGroupMode); + extern GtkWidget *gtk_dialog_new_with_buttons(const gchar *, + GtkWindow *, + GtkDialogFlags, + const gchar *, ...); + extern void gtk_about_dialog_set_name(GtkAboutDialog *, const gchar *); + extern void gtk_drag_source_add_image_targets(GtkWidget *); + extern void gtk_notebook_set_menu_label(GtkNotebook *, GtkWidget *, + GtkWidget *); + extern const gchar *gtk_action_group_get_name(GtkActionGroup *); + extern gboolean gtk_text_buffer_insert_interactive(GtkTextBuffer *, + GtkTextIter *, + const gchar *, gint, + gboolean); + extern void gtk_table_attach_defaults(GtkTable *, GtkWidget *, guint, + guint, guint, guint); + extern void gtk_notebook_reorder_child(GtkNotebook *, GtkWidget *, + gint); + extern void gtk_icon_source_set_state(GtkIconSource *, GtkStateType); + extern GType gtk_tree_model_filter_get_type(void); + extern void gtk_window_add_accel_group(GtkWindow *, GtkAccelGroup *); + extern void gtk_ruler_draw_ticks(GtkRuler *); + extern GtkIconSize gtk_icon_size_from_name(const gchar *); + extern void gtk_combo_box_set_model(GtkComboBox *, GtkTreeModel *); + extern GdkPixbuf *gtk_icon_set_render_icon(GtkIconSet *, GtkStyle *, + GtkTextDirection, + GtkStateType, GtkIconSize, + GtkWidget *, const char *); + extern void gtk_tree_selection_selected_foreach(GtkTreeSelection *, + GtkTreeSelectionForeachFunc, + gpointer); + extern GType gtk_cell_layout_get_type(void); + extern void gtk_text_iter_set_visible_line_offset(GtkTextIter *, gint); + extern gboolean gtk_rc_property_parse_requisition(const GParamSpec *, + const GString *, + GValue *); + extern GType gtk_combo_box_get_type(void); + extern GtkFileFilter *gtk_file_filter_new(void); + extern gdouble gtk_range_get_value(GtkRange *); + extern GtkWidget *gtk_event_box_new(void); + extern gboolean gtk_list_store_iter_is_valid(GtkListStore *, + GtkTreeIter *); + extern GtkIconInfo *gtk_icon_theme_lookup_icon(GtkIconTheme *, + const gchar *, gint, + GtkIconLookupFlags); + extern GType gtk_tree_model_flags_get_type(void); + extern void gtk_draw_insertion_cursor(GtkWidget *, GdkDrawable *, + GdkRectangle *, GdkRectangle *, + gboolean, GtkTextDirection, + gboolean); + extern GtkWindowGroup *gtk_window_group_new(void); + extern GtkFileFilter *gtk_file_chooser_get_filter(GtkFileChooser *); + extern void gtk_label_set_use_underline(GtkLabel *, gboolean); + extern gboolean gtk_tree_view_column_cell_is_visible(GtkTreeViewColumn + *); + extern gint gtk_tree_model_get_n_columns(GtkTreeModel *); + extern GtkTreeStore *gtk_tree_store_new(gint, ...); + extern GType gtk_frame_get_type(void); + extern gboolean + gtk_file_chooser_remove_shortcut_folder_uri(GtkFileChooser *, + const char *, + GError * *); + extern gboolean gtk_text_iter_backward_sentence_start(GtkTextIter *); + extern void gtk_text_view_set_wrap_mode(GtkTextView *, GtkWrapMode); + extern gboolean gtk_accelerator_valid(guint, GdkModifierType); + extern void gtk_text_buffer_end_user_action(GtkTextBuffer *); + extern GtkToolItem *gtk_toolbar_get_nth_item(GtkToolbar *, gint); + extern gboolean gtk_file_chooser_select_filename(GtkFileChooser *, + const gchar *); + extern void gtk_combo_box_set_row_span_column(GtkComboBox *, gint); + extern GType gtk_relief_style_get_type(void); + extern gboolean gtk_tree_path_is_descendant(GtkTreePath *, + GtkTreePath *); + extern void gtk_drag_highlight(GtkWidget *); + extern gboolean gtk_file_selection_get_select_multiple(GtkFileSelection + *); + extern gboolean gtk_toggle_action_get_draw_as_radio(GtkToggleAction *); + extern void gtk_icon_view_select_all(GtkIconView *); + extern void gtk_button_get_alignment(GtkButton *, gfloat *, gfloat *); + extern void gtk_spin_button_set_range(GtkSpinButton *, gdouble, + gdouble); + extern gint gtk_tree_view_append_column(GtkTreeView *, + GtkTreeViewColumn *); + extern void gtk_quit_remove_by_data(gpointer); + extern const gchar *gtk_about_dialog_get_website_label(GtkAboutDialog + *); + extern void gtk_list_store_insert_before(GtkListStore *, GtkTreeIter *, + GtkTreeIter *); + extern const guint gtk_minor_version; + extern void gtk_statusbar_pop(GtkStatusbar *, guint); + extern gboolean gtk_tree_selection_get_selected(GtkTreeSelection *, + GtkTreeModel * *, + GtkTreeIter *); + extern void gtk_drag_get_data(GtkWidget *, GdkDragContext *, GdkAtom, + guint32); + extern const gchar *gtk_frame_get_label(GtkFrame *); + extern GtkWidget + *gtk_radio_button_new_with_label_from_widget(GtkRadioButton *, + const gchar *); + extern void gtk_text_view_get_iter_at_position(GtkTextView *, + GtkTextIter *, gint *, + gint, gint); + extern GtkTreeViewSearchEqualFunc + gtk_tree_view_get_search_equal_func(GtkTreeView *); + extern gboolean gtk_selection_data_set_pixbuf(GtkSelectionData *, + GdkPixbuf *); + extern GtkMetricType gtk_ruler_get_metric(GtkRuler *); + extern void gtk_window_set_keep_above(GtkWindow *, gboolean); + extern void gtk_im_context_simple_add_table(GtkIMContextSimple *, + guint16 *, gint, gint); + extern PangoLayout *gtk_scale_get_layout(GtkScale *); + extern AtkObject *gtk_combo_box_get_popup_accessible(GtkComboBox *); + extern GType gtk_radio_button_get_type(void); + extern gint gtk_notebook_prepend_page(GtkNotebook *, GtkWidget *, + GtkWidget *); + extern gint gtk_text_view_get_indent(GtkTextView *); + extern gint gtk_text_view_get_border_window_size(GtkTextView *, + GtkTextWindowType); + extern GdkPixbuf *gtk_text_iter_get_pixbuf(const GtkTextIter *); + extern const gchar *gtk_notebook_get_tab_label_text(GtkNotebook *, + GtkWidget *); + extern GtkFileChooserAction gtk_file_chooser_get_action(GtkFileChooser + *); + extern void gtk_frame_get_label_align(GtkFrame *, gfloat *, gfloat *); + extern GtkIconSet *gtk_icon_set_ref(GtkIconSet *); + extern GType gtk_hpaned_get_type(void); + extern void gtk_about_dialog_set_website_label(GtkAboutDialog *, + const gchar *); + extern GtkIconFactory *gtk_icon_factory_new(void); + extern GtkCellRenderer *gtk_cell_renderer_combo_new(void); + extern GtkTreeModel *gtk_tree_model_filter_new(GtkTreeModel *, + GtkTreePath *); + extern GtkTargetList *gtk_target_list_new(const GtkTargetEntry *, + guint); + extern gboolean gtk_text_view_move_visually(GtkTextView *, + GtkTextIter *, gint); + extern GList *gtk_container_get_children(GtkContainer *); + extern GType gtk_tree_iter_get_type(void); + extern GType gtk_toggle_action_get_type(void); + extern void gtk_check_menu_item_set_draw_as_radio(GtkCheckMenuItem *, + gboolean); + extern void gtk_clipboard_request_targets(GtkClipboard *, + GtkClipboardTargetsReceivedFunc, + gpointer); + extern void gtk_icon_view_set_item_width(GtkIconView *, gint); + extern void gtk_tree_view_set_headers_clickable(GtkTreeView *, + gboolean); + extern GtkCornerType + gtk_scrolled_window_get_placement(GtkScrolledWindow *); + extern void gtk_text_view_set_tabs(GtkTextView *, PangoTabArray *); + extern void gtk_menu_tool_button_set_menu(GtkMenuToolButton *, + GtkWidget *); + extern void gtk_window_unmaximize(GtkWindow *); + extern void gtk_widget_modify_font(GtkWidget *, + PangoFontDescription *); + extern void gtk_toggle_tool_button_set_active(GtkToggleToolButton *, + gboolean); + extern GtkTreePath + *gtk_tree_model_filter_convert_path_to_child_path + (GtkTreeModelFilter *, GtkTreePath *); + extern GObject *gtk_clipboard_get_owner(GtkClipboard *); + extern void gtk_text_view_set_pixels_below_lines(GtkTextView *, gint); + extern void gtk_text_view_set_pixels_above_lines(GtkTextView *, gint); + extern void gtk_font_button_set_show_size(GtkFontButton *, gboolean); + extern void gtk_paint_resize_grip(GtkStyle *, GdkWindow *, + GtkStateType, GdkRectangle *, + GtkWidget *, const gchar *, + GdkWindowEdge, gint, gint, gint, + gint); + extern void gtk_widget_show_all(GtkWidget *); + extern void gtk_widget_set_name(GtkWidget *, const gchar *); + extern void gtk_action_disconnect_proxy(GtkAction *, GtkWidget *); + extern void gtk_image_set_pixel_size(GtkImage *, gint); + extern GList *gtk_tree_view_column_get_cell_renderers(GtkTreeViewColumn + *); + extern GType gtk_arrow_type_get_type(void); + extern void gtk_accel_group_connect_by_path(GtkAccelGroup *, + const gchar *, GClosure *); + extern void gtk_tree_view_scroll_to_point(GtkTreeView *, gint, gint); + extern GtkTreePath *gtk_tree_model_get_path(GtkTreeModel *, + GtkTreeIter *); + extern void gtk_menu_shell_prepend(GtkMenuShell *, GtkWidget *); + extern void gtk_image_set_from_image(GtkImage *, GdkImage *, + GdkBitmap *); + extern GType gtk_widget_help_type_get_type(void); + extern GType gtk_corner_type_get_type(void); + extern void gtk_tree_row_reference_deleted(GObject *, GtkTreePath *); + extern GtkWidget *gtk_combo_box_new(void); + extern GtkAdjustment *gtk_viewport_get_vadjustment(GtkViewport *); + extern gboolean gtk_text_iter_inside_sentence(const GtkTextIter *); + extern void gtk_action_group_add_action_with_accel(GtkActionGroup *, + GtkAction *, + const gchar *); + extern GSList *gtk_file_chooser_get_uris(GtkFileChooser *); + extern gboolean gtk_window_is_active(GtkWindow *); + extern void gtk_settings_set_double_property(GtkSettings *, + const gchar *, gdouble, + const gchar *); + extern GtkTextBuffer *gtk_text_mark_get_buffer(GtkTextMark *); + extern GType gtk_scrolled_window_get_type(void); + extern gboolean gtk_text_iter_equal(const GtkTextIter *, + const GtkTextIter *); + extern void gtk_window_group_add_window(GtkWindowGroup *, GtkWindow *); + extern GtkAccelGroup *gtk_menu_get_accel_group(GtkMenu *); + extern gchar *gtk_rc_get_module_dir(void); + extern void gtk_color_button_set_alpha(GtkColorButton *, guint16); + extern void gtk_table_attach(GtkTable *, GtkWidget *, guint, guint, + guint, guint, GtkAttachOptions, + GtkAttachOptions, guint, guint); + extern void gtk_menu_reorder_child(GtkMenu *, GtkWidget *, gint); + extern gboolean gtk_widget_event(GtkWidget *, GdkEvent *); + extern gchar *gtk_font_selection_get_font_name(GtkFontSelection *); + extern GdkPixbuf *gtk_icon_info_load_icon(GtkIconInfo *, GError * *); + extern gboolean gtk_label_get_selection_bounds(GtkLabel *, gint *, + gint *); + extern void gtk_icon_factory_remove_default(GtkIconFactory *); + extern void gtk_tree_store_swap(GtkTreeStore *, GtkTreeIter *, + GtkTreeIter *); + extern void gtk_color_selection_set_has_palette(GtkColorSelection *, + gboolean); + extern void gtk_tree_path_next(GtkTreePath *); + extern void gtk_action_unblock_activate_from(GtkAction *, GtkWidget *); + extern void gtk_notebook_set_tab_pos(GtkNotebook *, GtkPositionType); + extern void gtk_icon_source_set_filename(GtkIconSource *, + const gchar *); + extern void gtk_progress_bar_set_text(GtkProgressBar *, const gchar *); + extern GtkWidget *gtk_invisible_new_for_screen(GdkScreen *); + extern gboolean gtk_tree_view_get_enable_search(GtkTreeView *); + extern gboolean gtk_tree_store_is_ancestor(GtkTreeStore *, + GtkTreeIter *, + GtkTreeIter *); + extern GtkWidget *gtk_button_get_image(GtkButton *); + extern void gtk_tool_button_set_stock_id(GtkToolButton *, + const gchar *); + extern GtkWidget *gtk_font_selection_dialog_new(const gchar *); + extern void gtk_drag_source_set_icon(GtkWidget *, GdkColormap *, + GdkPixmap *, GdkBitmap *); + extern void gtk_file_chooser_set_local_only(GtkFileChooser *, + gboolean); + extern void gtk_text_buffer_remove_all_tags(GtkTextBuffer *, + const GtkTextIter *, + const GtkTextIter *); + extern gfloat gtk_entry_get_alignment(GtkEntry *); + extern GSList *gtk_text_iter_get_toggled_tags(const GtkTextIter *, + gboolean); + extern gchar *gtk_text_buffer_get_text(GtkTextBuffer *, + const GtkTextIter *, + const GtkTextIter *, gboolean); + extern void gtk_progress_bar_set_pulse_step(GtkProgressBar *, gdouble); + extern GtkTreePath *gtk_cell_view_get_displayed_row(GtkCellView *); + extern GtkTreePath *gtk_tree_path_copy(const GtkTreePath *); + extern GQuark gtk_icon_theme_error_quark(void); + extern void gtk_disable_setlocale(void); + extern GSList *gtk_radio_tool_button_get_group(GtkRadioToolButton *); + extern GType gtk_accel_flags_get_type(void); + extern gboolean gtk_window_get_skip_taskbar_hint(GtkWindow *); + extern void gtk_widget_style_get_valist(GtkWidget *, const gchar *, + va_list); + extern GType gtk_message_type_get_type(void); + extern GType gtk_icon_lookup_flags_get_type(void); + extern gint gtk_text_iter_get_chars_in_line(const GtkTextIter *); + extern void gtk_clipboard_request_text(GtkClipboard *, + GtkClipboardTextReceivedFunc, + gpointer); + extern GType gtk_tree_selection_get_type(void); + extern void gtk_text_buffer_cut_clipboard(GtkTextBuffer *, + GtkClipboard *, gboolean); + extern void gtk_tree_view_widget_to_tree_coords(GtkTreeView *, gint, + gint, gint *, gint *); + extern gboolean gtk_list_store_remove(GtkListStore *, GtkTreeIter *); + extern void gtk_drag_dest_unset(GtkWidget *); + extern GType gtk_accel_label_get_type(void); + extern gboolean gtk_text_iter_ends_line(const GtkTextIter *); + extern void gtk_spin_button_set_numeric(GtkSpinButton *, gboolean); + extern gboolean gtk_text_iter_backward_chars(GtkTextIter *, gint); + extern void gtk_tree_view_column_cell_get_size(GtkTreeViewColumn *, + GdkRectangle *, gint *, + gint *, gint *, gint *); + extern GtkTreePath *gtk_tree_path_new_from_string(const gchar *); + extern GScanner *gtk_rc_scanner_new(void); + extern GtkWidget *gtk_combo_box_entry_new(void); + extern GtkWidget + *gtk_radio_button_new_with_mnemonic_from_widget(GtkRadioButton *, + const gchar *); + extern GType gtk_tree_sortable_get_type(void); + extern GtkTextTag *gtk_text_tag_new(const gchar *); + extern GtkWidget *gtk_hbutton_box_new(void); + extern GType gtk_alignment_get_type(void); + extern GtkTreeRowReference *gtk_tree_row_reference_new_proxy(GObject *, + GtkTreeModel + *, + GtkTreePath + *); + extern const gchar *gtk_about_dialog_get_license(GtkAboutDialog *); + extern GtkWidget *gtk_check_menu_item_new(void); + extern GType gtk_size_group_mode_get_type(void); + extern gboolean gtk_calendar_unmark_day(GtkCalendar *, guint); + extern GtkWidget *gtk_label_get_mnemonic_widget(GtkLabel *); + extern void gtk_button_set_focus_on_click(GtkButton *, gboolean); + extern void gtk_combo_box_prepend_text(GtkComboBox *, const gchar *); + extern void gtk_tree_store_set(GtkTreeStore *, GtkTreeIter *, ...); + extern GType gtk_im_preedit_style_get_type(void); + extern gboolean gtk_get_current_event_state(GdkModifierType *); + extern GType gtk_handle_box_get_type(void); + extern void gtk_tree_model_sort_clear_cache(GtkTreeModelSort *); + extern void gtk_selection_clear_targets(GtkWidget *, GdkAtom); + extern void gtk_about_dialog_set_comments(GtkAboutDialog *, + const gchar *); + extern void gtk_list_store_append(GtkListStore *, GtkTreeIter *); + extern gboolean gtk_tool_item_get_visible_horizontal(GtkToolItem *); + extern void gtk_window_set_default_size(GtkWindow *, gint, gint); + extern void gtk_drag_set_icon_stock(GdkDragContext *, const gchar *, + gint, gint); + extern void gtk_paned_set_position(GtkPaned *, gint); + extern void gtk_tree_view_column_set_sort_order(GtkTreeViewColumn *, + GtkSortType); + extern GtkWidget *gtk_image_new_from_icon_set(GtkIconSet *, + GtkIconSize); + extern GType gtk_image_get_type(void); + extern GtkTextDirection gtk_widget_get_default_direction(void); + extern GtkWidget *gtk_color_button_new(void); + extern void gtk_paint_hline(GtkStyle *, GdkWindow *, GtkStateType, + GdkRectangle *, GtkWidget *, const gchar *, + gint, gint, gint); + extern void gtk_menu_item_toggle_size_request(GtkMenuItem *, gint *); + extern void gtk_size_group_remove_widget(GtkSizeGroup *, GtkWidget *); + extern GtkClipboard *gtk_widget_get_clipboard(GtkWidget *, GdkAtom); + extern void gtk_scale_set_draw_value(GtkScale *, gboolean); + extern void gtk_frame_set_label_widget(GtkFrame *, GtkWidget *); + extern GType gtk_check_button_get_type(void); + extern void gtk_widget_show(GtkWidget *); + extern void gtk_adjustment_changed(GtkAdjustment *); + extern gboolean gtk_text_iter_forward_visible_word_ends(GtkTextIter *, + gint); + extern void gtk_entry_set_has_frame(GtkEntry *, gboolean); + extern GtkWidget *gtk_hbox_new(gboolean, gint); + extern PangoContext *gtk_widget_get_pango_context(GtkWidget *); + extern GtkAccelKey *gtk_accel_group_find(GtkAccelGroup *, + GtkAccelGroupFindFunc, + gpointer); + extern const gchar *gtk_font_button_get_font_name(GtkFontButton *); + extern void + gtk_entry_completion_set_inline_completion(GtkEntryCompletion *, + gboolean); + extern gboolean gtk_toggle_tool_button_get_active(GtkToggleToolButton + *); + extern gchar *gtk_widget_get_composite_name(GtkWidget *); + extern GType gtk_ui_manager_item_type_get_type(void); + extern void gtk_tree_sortable_set_sort_column_id(GtkTreeSortable *, + gint, GtkSortType); + extern void gtk_tree_path_append_index(GtkTreePath *, gint); + extern GtkToolItem *gtk_radio_tool_button_new_from_stock(GSList *, + const gchar + *); + extern void gtk_image_get_icon_name(GtkImage *, const gchar * *, + GtkIconSize *); + extern GtkIconSource *gtk_icon_source_copy(const GtkIconSource *); + extern void gtk_icon_view_set_text_column(GtkIconView *, gint); + extern void gtk_label_set_justify(GtkLabel *, GtkJustification); + extern void gtk_tree_view_column_set_attributes(GtkTreeViewColumn *, + GtkCellRenderer *, + ...); + extern void gtk_box_pack_start(GtkBox *, GtkWidget *, gboolean, + gboolean, guint); + extern const gchar *const *gtk_about_dialog_get_artists(GtkAboutDialog + *); + extern void gtk_label_set_markup(GtkLabel *, const gchar *); + extern GdkPixbuf *gtk_icon_info_get_builtin_pixbuf(GtkIconInfo *); + extern gboolean gtk_text_iter_starts_sentence(const GtkTextIter *); + extern void gtk_tree_view_set_destroy_count_func(GtkTreeView *, + GtkTreeDestroyCountFunc, + gpointer, + GtkDestroyNotify); + extern GType gtk_expander_get_type(void); + extern void gtk_list_store_move_before(GtkListStore *, GtkTreeIter *, + GtkTreeIter *); + extern gboolean gtk_tree_view_column_get_visible(GtkTreeViewColumn *); + extern GType gtk_text_buffer_get_type(void); + extern void gtk_file_chooser_add_filter(GtkFileChooser *, + GtkFileFilter *); + extern gint gtk_text_tag_table_get_size(GtkTextTagTable *); + extern GType gtk_attach_options_get_type(void); + extern gboolean gtk_rc_reparse_all_for_settings(GtkSettings *, + gboolean); + extern gunichar gtk_entry_get_invisible_char(GtkEntry *); + extern GType gtk_text_view_get_type(void); + extern gboolean gtk_text_iter_is_end(const GtkTextIter *); + extern GdkPixbuf *gtk_icon_source_get_pixbuf(const GtkIconSource *); + extern gboolean gtk_text_iter_forward_word_end(GtkTextIter *); + extern GType gtk_menu_shell_get_type(void); + extern const gchar *gtk_tool_button_get_stock_id(GtkToolButton *); + extern GtkTextMark *gtk_text_buffer_get_mark(GtkTextBuffer *, + const gchar *); + extern gboolean gtk_icon_view_path_is_selected(GtkIconView *, + GtkTreePath *); + extern GtkCellRenderer *gtk_cell_renderer_pixbuf_new(void); + extern gchar *gtk_file_chooser_get_current_folder(GtkFileChooser *); + extern gboolean gtk_selection_owner_set(GtkWidget *, GdkAtom, guint32); + extern void gtk_window_get_size(GtkWindow *, gint *, gint *); + extern void gtk_binding_entry_add_signall(GtkBindingSet *, guint, + GdkModifierType, + const gchar *, GSList *); + extern PangoLanguage *gtk_text_iter_get_language(const GtkTextIter *); + extern void gtk_dialog_add_buttons(GtkDialog *, const gchar *, ...); + extern void gtk_action_disconnect_accelerator(GtkAction *); + extern char *gtk_file_chooser_get_preview_uri(GtkFileChooser *); + extern void gtk_requisition_free(GtkRequisition *); + extern GSList *gtk_text_iter_get_marks(const GtkTextIter *); + extern GType gtk_delete_type_get_type(void); + extern void gtk_box_reorder_child(GtkBox *, GtkWidget *, gint); + extern GtkWidget *gtk_menu_item_new_with_mnemonic(const gchar *); + extern void gtk_item_deselect(GtkItem *); + extern gboolean gtk_file_chooser_get_show_hidden(GtkFileChooser *); + extern GType gtk_hscrollbar_get_type(void); + extern GtkStyle *gtk_widget_get_default_style(void); + extern GtkToolItem + *gtk_radio_tool_button_new_with_stock_from_widget + (GtkRadioToolButton *, const gchar *); + extern void gtk_tree_view_get_drag_dest_row(GtkTreeView *, + GtkTreePath * *, + GtkTreeViewDropPosition *); + extern GSList *gtk_radio_action_get_group(GtkRadioAction *); + extern void gtk_drag_finish(GdkDragContext *, gboolean, gboolean, + guint32); + extern GType gtk_button_box_get_type(void); + extern void gtk_binding_entry_remove(GtkBindingSet *, guint, + GdkModifierType); + extern GtkWidget *gtk_accel_label_get_accel_widget(GtkAccelLabel *); + extern gboolean gtk_accel_map_change_entry(const gchar *, guint, + GdkModifierType, gboolean); + extern gboolean + gtk_cell_renderer_toggle_get_active(GtkCellRendererToggle *); + extern void gtk_cell_renderer_get_size(GtkCellRenderer *, GtkWidget *, + GdkRectangle *, gint *, gint *, + gint *, gint *); + extern void gtk_layout_put(GtkLayout *, GtkWidget *, gint, gint); + extern void gtk_widget_set_parent(GtkWidget *, GtkWidget *); + extern gboolean gtk_text_iter_forward_lines(GtkTextIter *, gint); + extern gboolean gtk_expander_get_use_markup(GtkExpander *); + extern gboolean gtk_main_iteration(void); + extern void gtk_tree_view_column_set_sort_column_id(GtkTreeViewColumn + *, gint); + extern gboolean gtk_text_mark_get_deleted(GtkTextMark *); + extern GtkWidget *gtk_combo_box_new_with_model(GtkTreeModel *); + extern GtkWidget *gtk_icon_view_new_with_model(GtkTreeModel *); + extern GType gtk_side_type_get_type(void); + extern void gtk_settings_install_property(GParamSpec *); + extern void gtk_image_get_image(GtkImage *, GdkImage * *, + GdkBitmap * *); + extern GType gtk_entry_get_type(void); + extern GType gtk_file_selection_get_type(void); + extern void gtk_calendar_set_display_options(GtkCalendar *, + GtkCalendarDisplayOptions); + extern gboolean + gtk_entry_completion_get_popup_completion(GtkEntryCompletion *); + extern void gtk_widget_pop_composite_child(void); + extern gboolean gtk_text_iter_forward_cursor_position(GtkTextIter *); + extern void gtk_drag_dest_set_target_list(GtkWidget *, + GtkTargetList *); + extern GtkTextAttributes *gtk_text_attributes_new(void); + extern void gtk_paned_pack2(GtkPaned *, GtkWidget *, gboolean, + gboolean); + extern void gtk_aspect_frame_set(GtkAspectFrame *, gfloat, gfloat, + gfloat, gboolean); + extern void gtk_propagate_event(GtkWidget *, GdkEvent *); + extern void gtk_rc_style_unref(GtkRcStyle *); + extern void gtk_tree_path_prepend_index(GtkTreePath *, gint); + extern void gtk_text_buffer_delete_mark_by_name(GtkTextBuffer *, + const gchar *); + extern GtkToolItem *gtk_separator_tool_item_new(void); + extern void gtk_ruler_draw_pos(GtkRuler *); + extern void gtk_im_context_focus_in(GtkIMContext *); + extern void gtk_widget_shape_combine_mask(GtkWidget *, GdkBitmap *, + gint, gint); + extern gint gtk_dialog_run(GtkDialog *); + extern gboolean + gtk_cell_renderer_toggle_get_radio(GtkCellRendererToggle *); + extern GType gtk_entry_completion_get_type(void); + extern void gtk_tree_model_get_value(GtkTreeModel *, GtkTreeIter *, + gint, GValue *); + extern GType gtk_pack_type_get_type(void); + extern GtkTreePath *gtk_tree_row_reference_get_path(GtkTreeRowReference + *); + extern void gtk_file_filter_add_custom(GtkFileFilter *, + GtkFileFilterFlags, + GtkFileFilterFunc, gpointer, + GDestroyNotify); + extern void gtk_window_move(GtkWindow *, gint, gint); + extern void gtk_tree_store_set_column_types(GtkTreeStore *, gint, + GType *); + extern gboolean gtk_text_buffer_insert_range_interactive(GtkTextBuffer + *, + GtkTextIter *, + const + GtkTextIter *, + const + GtkTextIter *, + gboolean); + extern gboolean gtk_color_selection_palette_from_string(const gchar *, + GdkColor * *, + gint *); + extern void gtk_text_buffer_get_iter_at_mark(GtkTextBuffer *, + GtkTextIter *, + GtkTextMark *); + extern GType gtk_target_flags_get_type(void); + extern void gtk_text_view_move_child(GtkTextView *, GtkWidget *, gint, + gint); + extern void gtk_binding_entry_add_signal(GtkBindingSet *, guint, + GdkModifierType, + const gchar *, guint, ...); + extern void gtk_text_iter_set_line(GtkTextIter *, gint); + extern void gtk_text_buffer_set_text(GtkTextBuffer *, const gchar *, + gint); + extern void gtk_window_set_default_icon_name(const gchar *); + extern const char *gtk_expander_get_label(GtkExpander *); + extern gpointer gtk_tree_selection_get_user_data(GtkTreeSelection *); + extern GtkWidget *gtk_button_new_from_stock(const gchar *); + extern void gtk_text_iter_set_line_index(GtkTextIter *, gint); + extern GType gtk_radio_action_get_type(void); + extern GtkAdjustment *gtk_tree_view_get_vadjustment(GtkTreeView *); + extern void gtk_label_set_line_wrap(GtkLabel *, gboolean); + extern gchar *gtk_accelerator_get_label(guint, GdkModifierType); + extern void gtk_socket_add_id(GtkSocket *, GdkNativeWindow); + extern GtkWidget *gtk_font_selection_new(void); + extern void gtk_text_iter_order(GtkTextIter *, GtkTextIter *); + extern GtkWidget *gtk_radio_menu_item_new_from_widget(GtkRadioMenuItem + *); + extern gint gtk_text_iter_get_visible_line_index(const GtkTextIter *); + extern gboolean gtk_widget_get_child_visible(GtkWidget *); + extern void gtk_about_dialog_set_documenters(GtkAboutDialog *, + const gchar * *); + extern GtkToolItem *gtk_menu_tool_button_new_from_stock(const gchar *); + extern void gtk_accel_map_save_fd(gint); + extern void gtk_tree_sortable_set_default_sort_func(GtkTreeSortable *, + GtkTreeIterCompareFunc, + gpointer, + GtkDestroyNotify); + extern GType gtk_text_tag_get_type(void); + extern gboolean gtk_widget_child_focus(GtkWidget *, GtkDirectionType); + extern void gtk_tree_view_set_drag_dest_row(GtkTreeView *, + GtkTreePath *, + GtkTreeViewDropPosition); + extern void gtk_layout_set_vadjustment(GtkLayout *, GtkAdjustment *); + extern void gtk_text_view_scroll_to_mark(GtkTextView *, GtkTextMark *, + gdouble, gboolean, gdouble, + gdouble); + extern const gchar + *gtk_about_dialog_get_translator_credits(GtkAboutDialog *); + extern gboolean gtk_notebook_get_scrollable(GtkNotebook *); + extern gboolean gtk_text_iter_forward_word_ends(GtkTextIter *, gint); + extern void gtk_tree_view_column_set_clickable(GtkTreeViewColumn *, + gboolean); + extern void gtk_ui_manager_insert_action_group(GtkUIManager *, + GtkActionGroup *, gint); + extern void gtk_text_iter_free(GtkTextIter *); + extern GdkPixbuf *gtk_clipboard_wait_for_image(GtkClipboard *); + extern void gtk_im_multicontext_append_menuitems(GtkIMMulticontext *, + GtkMenuShell *); + extern gint gtk_tree_view_column_get_max_width(GtkTreeViewColumn *); + extern GdkDisplay *gtk_widget_get_display(GtkWidget *); + extern void gtk_scrolled_window_add_with_viewport(GtkScrolledWindow *, + GtkWidget *); + extern GType gtk_justification_get_type(void); + extern void gtk_file_selection_show_fileop_buttons(GtkFileSelection *); + extern void gtk_widget_set_size_request(GtkWidget *, gint, gint); + extern const gchar *gtk_about_dialog_get_copyright(GtkAboutDialog *); + extern void gtk_window_begin_move_drag(GtkWindow *, gint, gint, gint, + guint32); + extern void gtk_range_set_adjustment(GtkRange *, GtkAdjustment *); + extern gboolean gtk_text_iter_is_cursor_position(const GtkTextIter *); + extern gboolean gtk_text_iter_ends_sentence(const GtkTextIter *); + extern gboolean gtk_text_view_forward_display_line(GtkTextView *, + GtkTextIter *); + extern void gtk_item_toggle(GtkItem *); + extern gint gtk_tree_path_compare(const GtkTreePath *, + const GtkTreePath *); + extern GtkWidget *gtk_paned_get_child1(GtkPaned *); + extern GType gtk_rc_style_get_type(void); + extern gint gtk_text_view_get_right_margin(GtkTextView *); + extern void gtk_paint_extension(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, + GtkWidget *, gchar *, gint, gint, gint, + gint, GtkPositionType); + extern void gtk_icon_source_set_state_wildcarded(GtkIconSource *, + gboolean); + extern guint16 gtk_color_selection_get_previous_alpha(GtkColorSelection + *); + extern gboolean gtk_file_chooser_set_current_folder(GtkFileChooser *, + const gchar *); + extern GdkNativeWindow gtk_plug_get_id(GtkPlug *); + extern GtkAdjustment *gtk_range_get_adjustment(GtkRange *); + extern GType gtk_ui_manager_get_type(void); + extern void + gtk_color_selection_set_has_opacity_control(GtkColorSelection *, + gboolean); + extern gboolean gtk_drag_check_threshold(GtkWidget *, gint, gint, gint, + gint); + extern GtkWidget *gtk_paned_get_child2(GtkPaned *); + extern void gtk_icon_view_set_orientation(GtkIconView *, + GtkOrientation); + extern void gtk_font_button_set_use_size(GtkFontButton *, gboolean); + extern gboolean gtk_file_chooser_add_shortcut_folder(GtkFileChooser *, + const char *, + GError * *); + extern void gtk_text_buffer_get_iter_at_child_anchor(GtkTextBuffer *, + GtkTextIter *, + GtkTextChildAnchor + *); + extern void gtk_stock_add_static(const GtkStockItem *, guint); + extern GtkStyle *gtk_style_copy(GtkStyle *); + extern GtkWidget *gtk_file_chooser_button_new_with_dialog(GtkWidget *); + extern void gtk_tree_store_reorder(GtkTreeStore *, GtkTreeIter *, + gint *); + extern gboolean gtk_window_parse_geometry(GtkWindow *, const gchar *); + extern void gtk_icon_source_set_direction_wildcarded(GtkIconSource *, + gboolean); + extern void gtk_im_context_reset(GtkIMContext *); + extern GType gtk_debug_flag_get_type(void); + extern void gtk_tree_path_free(GtkTreePath *); + extern GtkRcStyle *gtk_widget_get_modifier_style(GtkWidget *); + extern void gtk_icon_source_set_direction(GtkIconSource *, + GtkTextDirection); + extern GtkTreeViewColumn *gtk_tree_view_get_column(GtkTreeView *, + gint); + extern GtkWidget *gtk_notebook_new(void); + extern void gtk_window_unstick(GtkWindow *); + extern GParamSpec *gtk_widget_class_find_style_property(GtkWidgetClass + *, + const gchar *); + extern void gtk_combo_box_set_wrap_width(GtkComboBox *, gint); + extern void gtk_spin_button_set_increments(GtkSpinButton *, gdouble, + gdouble); + extern GtkAdjustment *gtk_tree_view_get_hadjustment(GtkTreeView *); + extern void gtk_window_set_icon(GtkWindow *, GdkPixbuf *); + extern gint gtk_text_view_get_pixels_inside_wrap(GtkTextView *); + extern void gtk_icon_factory_add(GtkIconFactory *, const gchar *, + GtkIconSet *); + extern void gtk_container_propagate_expose(GtkContainer *, GtkWidget *, + GdkEventExpose *); + extern void gtk_list_store_move_after(GtkListStore *, GtkTreeIter *, + GtkTreeIter *); + extern GtkWidget *gtk_color_selection_new(void); + extern GtkOrientation gtk_tool_item_get_orientation(GtkToolItem *); + extern void gtk_text_attributes_ref(GtkTextAttributes *); + extern void gtk_label_set_use_markup(GtkLabel *, gboolean); + extern GtkWidget *gtk_message_dialog_new(GtkWindow *, GtkDialogFlags, + GtkMessageType, + GtkButtonsType, const gchar *, + ...); + extern GType gtk_hseparator_get_type(void); + extern void gtk_menu_set_active(GtkMenu *, guint); + extern gboolean gtk_text_buffer_get_modified(GtkTextBuffer *); + extern void gtk_icon_view_select_path(GtkIconView *, GtkTreePath *); + extern gboolean gtk_widget_can_activate_accel(GtkWidget *, guint); + extern void gtk_box_pack_end(GtkBox *, GtkWidget *, gboolean, gboolean, + guint); + extern gboolean gtk_dialog_get_has_separator(GtkDialog *); + extern void gtk_tree_store_insert(GtkTreeStore *, GtkTreeIter *, + GtkTreeIter *, gint); + extern GType gtk_position_type_get_type(void); + extern gboolean gtk_file_chooser_remove_shortcut_folder(GtkFileChooser + *, + const char *, + GError * *); + extern gboolean gtk_text_iter_forward_visible_word_end(GtkTextIter *); + extern gboolean gtk_tool_item_get_homogeneous(GtkToolItem *); + extern gboolean gtk_parse_args(int *, char ***); + extern void gtk_window_set_screen(GtkWindow *, GdkScreen *); + extern GtkJustification gtk_text_view_get_justification(GtkTextView *); + extern void gtk_container_remove(GtkContainer *, GtkWidget *); + extern void gtk_range_set_increments(GtkRange *, gdouble, gdouble); + extern void gtk_action_group_add_action(GtkActionGroup *, GtkAction *); + extern void gtk_icon_theme_append_search_path(GtkIconTheme *, + const gchar *); + extern void gtk_widget_destroyed(GtkWidget *, GtkWidget * *); + extern void gtk_image_set_from_file(GtkImage *, const gchar *); + extern gint gtk_icon_view_get_pixbuf_column(GtkIconView *); + extern void gtk_size_group_add_widget(GtkSizeGroup *, GtkWidget *); + extern gboolean gtk_tree_view_column_get_expand(GtkTreeViewColumn *); + extern GtkWidget *gtk_menu_new(void); + extern GType gtk_window_get_type(void); + extern GType gtk_range_get_type(void); + extern void gtk_rc_parse_string(const gchar *); + extern GType gtk_progress_bar_style_get_type(void); + extern void gtk_container_set_focus_hadjustment(GtkContainer *, + GtkAdjustment *); + extern void gtk_accel_map_foreach(gpointer, GtkAccelMapForeach); + extern gchar **gtk_file_selection_get_selections(GtkFileSelection *); + extern gboolean gtk_spin_button_get_wrap(GtkSpinButton *); + extern GType gtk_dialog_get_type(void); + extern GType gtk_misc_get_type(void); + extern void gtk_selection_add_target(GtkWidget *, GdkAtom, GdkAtom, + guint); + extern GtkWidget *gtk_file_chooser_dialog_new(const gchar *, + GtkWindow *, + GtkFileChooserAction, + const gchar *, ...); + extern void gtk_quit_remove(guint); + extern GtkSizeGroupMode gtk_size_group_get_mode(GtkSizeGroup *); + extern void gtk_action_group_set_translation_domain(GtkActionGroup *, + const gchar *); + extern void gtk_notebook_remove_page(GtkNotebook *, gint); + extern const gchar *gtk_font_button_get_title(GtkFontButton *); + extern void gtk_file_filter_add_pixbuf_formats(GtkFileFilter *); + extern void gtk_editable_cut_clipboard(GtkEditable *); + extern void gtk_tree_view_column_set_expand(GtkTreeViewColumn *, + gboolean); + extern void gtk_widget_thaw_child_notify(GtkWidget *); + extern void gtk_label_set_attributes(GtkLabel *, PangoAttrList *); + extern void gtk_ui_manager_remove_ui(GtkUIManager *, guint); + extern gboolean gtk_text_iter_forward_chars(GtkTextIter *, gint); + extern void gtk_entry_set_invisible_char(GtkEntry *, gunichar); + extern void gtk_text_view_set_border_window_size(GtkTextView *, + GtkTextWindowType, + gint); + extern void gtk_notebook_query_tab_label_packing(GtkNotebook *, + GtkWidget *, + gboolean *, + gboolean *, + GtkPackType *); + extern GtkWidget + *gtk_radio_menu_item_new_with_mnemonic_from_widget(GtkRadioMenuItem + *, + const gchar *); + extern GtkWidget *gtk_toggle_button_new_with_label(const gchar *); + extern GType gtk_buttons_type_get_type(void); + extern void gtk_text_buffer_apply_tag_by_name(GtkTextBuffer *, + const gchar *, + const GtkTextIter *, + const GtkTextIter *); + extern void gtk_accel_group_connect(GtkAccelGroup *, guint, + GdkModifierType, GtkAccelFlags, + GClosure *); + extern gchar *gtk_text_iter_get_visible_text(const GtkTextIter *, + const GtkTextIter *); + extern gboolean gtk_stock_lookup(const gchar *, GtkStockItem *); + extern void gtk_label_set_mnemonic_widget(GtkLabel *, GtkWidget *); + extern void gtk_tree_view_collapse_all(GtkTreeView *); + extern void gtk_action_set_accel_group(GtkAction *, GtkAccelGroup *); + extern void gtk_ui_manager_add_ui(GtkUIManager *, guint, const gchar *, + const gchar *, const gchar *, + GtkUIManagerItemType, gboolean); + extern GtkWidget *gtk_check_menu_item_new_with_label(const gchar *); + extern void gtk_window_set_default_icon(GdkPixbuf *); + extern gboolean gtk_tree_selection_iter_is_selected(GtkTreeSelection *, + GtkTreeIter *); + extern void gtk_scrolled_window_get_policy(GtkScrolledWindow *, + GtkPolicyType *, + GtkPolicyType *); + extern void gtk_adjustment_clamp_page(GtkAdjustment *, gdouble, + gdouble); + extern void gtk_about_dialog_set_translator_credits(GtkAboutDialog *, + const gchar *); + extern void gtk_menu_item_remove_submenu(GtkMenuItem *); + extern GtkResizeMode gtk_container_get_resize_mode(GtkContainer *); + extern GtkWidget *gtk_menu_item_new_with_label(const gchar *); + extern gboolean gtk_tree_sortable_has_default_sort_func(GtkTreeSortable + *); + extern void gtk_accel_map_foreach_unfiltered(gpointer, + GtkAccelMapForeach); + extern GType gtk_editable_get_type(void); + extern void gtk_widget_show_now(GtkWidget *); + extern GtkColorSelectionChangePaletteWithScreenFunc + gtk_color_selection_set_change_palette_with_screen_hook + (GtkColorSelectionChangePaletteWithScreenFunc); + extern void gtk_entry_completion_complete(GtkEntryCompletion *); + extern gboolean gtk_tree_get_row_drag_data(GtkSelectionData *, + GtkTreeModel * *, + GtkTreePath * *); + extern gchar *gtk_rc_get_im_module_file(void); + extern void gtk_text_view_get_line_at_y(GtkTextView *, GtkTextIter *, + gint, gint *); + extern GtkToolbarStyle gtk_tool_item_get_toolbar_style(GtkToolItem *); + extern gint gtk_tree_view_column_get_fixed_width(GtkTreeViewColumn *); + extern const gchar *gtk_icon_source_get_icon_name(const GtkIconSource + *); + extern GtkStyle *gtk_rc_get_style_by_paths(GtkSettings *, const char *, + const char *, GType); + extern gint gtk_text_view_get_left_margin(GtkTextView *); + extern void gtk_target_list_remove(GtkTargetList *, GdkAtom); + extern void gtk_stock_add(const GtkStockItem *, guint); + extern void gtk_progress_bar_pulse(GtkProgressBar *); + extern void gtk_scale_set_value_pos(GtkScale *, GtkPositionType); + extern void gtk_label_set_max_width_chars(GtkLabel *, gint); + extern gint gtk_label_get_width_chars(GtkLabel *); + extern GtkWidget *gtk_viewport_new(GtkAdjustment *, GtkAdjustment *); + extern void gtk_tree_store_insert_after(GtkTreeStore *, GtkTreeIter *, + GtkTreeIter *, GtkTreeIter *); + extern GType gtk_font_selection_dialog_get_type(void); + extern void gtk_accel_map_load_fd(gint); + extern void gtk_editable_delete_selection(GtkEditable *); + extern GtkShadowType gtk_viewport_get_shadow_type(GtkViewport *); + extern GType gtk_color_button_get_type(void); + extern void gtk_container_set_reallocate_redraws(GtkContainer *, + gboolean); + extern void gtk_menu_shell_select_item(GtkMenuShell *, GtkWidget *); + extern void gtk_toggle_button_set_mode(GtkToggleButton *, gboolean); + extern gint *gtk_tree_path_get_indices(GtkTreePath *); + extern void gtk_target_list_add_image_targets(GtkTargetList *, guint, + gboolean); + extern GtkSelectionMode gtk_tree_selection_get_mode(GtkTreeSelection + *); + extern GType gtk_arrow_get_type(void); + extern gboolean gtk_clipboard_wait_is_image_available(GtkClipboard *); + extern void gtk_icon_view_set_pixbuf_column(GtkIconView *, gint); + extern gint gtk_notebook_get_n_pages(GtkNotebook *); + extern gboolean gtk_text_iter_forward_find_char(GtkTextIter *, + GtkTextCharPredicate, + gpointer, + const GtkTextIter *); + extern GList *gtk_window_get_icon_list(GtkWindow *); + extern void gtk_entry_set_width_chars(GtkEntry *, gint); + extern GtkTreePath *gtk_tree_path_new_first(void); + extern void gtk_im_context_set_cursor_location(GtkIMContext *, + GdkRectangle *); + extern void gtk_text_view_add_child_in_window(GtkTextView *, + GtkWidget *, + GtkTextWindowType, gint, + gint); + extern void gtk_tree_view_scroll_to_cell(GtkTreeView *, GtkTreePath *, + GtkTreeViewColumn *, gboolean, + gfloat, gfloat); + extern void gtk_editable_set_position(GtkEditable *, gint); + extern gint gtk_expander_get_spacing(GtkExpander *); + extern void gtk_widget_add_events(GtkWidget *, gint); + extern void gtk_tool_item_set_use_drag_window(GtkToolItem *, gboolean); + extern gint gtk_tree_path_get_depth(GtkTreePath *); + extern void gtk_spin_button_update(GtkSpinButton *); + extern gboolean gtk_accel_group_disconnect(GtkAccelGroup *, + GClosure *); + extern void gtk_clipboard_request_contents(GtkClipboard *, GdkAtom, + GtkClipboardReceivedFunc, + gpointer); + extern void gtk_tree_view_get_cell_area(GtkTreeView *, GtkTreePath *, + GtkTreeViewColumn *, + GdkRectangle *); + extern GType gtk_combo_box_entry_get_type(void); + extern GtkTextTagTable *gtk_text_buffer_get_tag_table(GtkTextBuffer *); + extern gboolean gtk_tree_model_get_iter(GtkTreeModel *, GtkTreeIter *, + GtkTreePath *); + extern void gtk_window_remove_accel_group(GtkWindow *, + GtkAccelGroup *); + extern gint gtk_notebook_append_page(GtkNotebook *, GtkWidget *, + GtkWidget *); + extern void gtk_container_set_focus_vadjustment(GtkContainer *, + GtkAdjustment *); + extern void gtk_window_reshow_with_initial_size(GtkWindow *); + extern void gtk_viewport_set_hadjustment(GtkViewport *, + GtkAdjustment *); + extern gboolean gtk_text_iter_backward_to_tag_toggle(GtkTextIter *, + GtkTextTag *); + extern void gtk_entry_completion_insert_action_text(GtkEntryCompletion + *, gint, + const gchar *); + extern void gtk_editable_copy_clipboard(GtkEditable *); + extern GtkTextMark *gtk_text_buffer_create_mark(GtkTextBuffer *, + const gchar *, + const GtkTextIter *, + gboolean); + extern GType gtk_scroll_type_get_type(void); + extern void gtk_ui_manager_set_add_tearoffs(GtkUIManager *, gboolean); + extern void gtk_paint_flat_box(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, + GtkWidget *, const gchar *, gint, gint, + gint, gint); + extern void gtk_tree_view_get_cursor(GtkTreeView *, GtkTreePath * *, + GtkTreeViewColumn * *); + extern GtkWidget *gtk_label_new(const gchar *); + extern void gtk_widget_remove_mnemonic_label(GtkWidget *, GtkWidget *); + extern GType gtk_size_group_get_type(void); + extern void gtk_text_buffer_insert_child_anchor(GtkTextBuffer *, + GtkTextIter *, + GtkTextChildAnchor *); + extern void gtk_text_iter_forward_to_end(GtkTextIter *); + extern void gtk_tree_view_column_set_sort_indicator(GtkTreeViewColumn + *, gboolean); + extern void gtk_widget_destroy(GtkWidget *); + extern void gtk_widget_class_install_style_property(GtkWidgetClass *, + GParamSpec *); + extern GType gtk_icon_factory_get_type(void); + extern gboolean gtk_text_buffer_get_selection_bounds(GtkTextBuffer *, + GtkTextIter *, + GtkTextIter *); + extern void gtk_widget_set_composite_name(GtkWidget *, const gchar *); + extern GtkWidget *gtk_vseparator_new(void); + extern GtkFileFilterFlags gtk_file_filter_get_needed(GtkFileFilter *); + extern gint gtk_entry_get_width_chars(GtkEntry *); + extern GtkWidget *gtk_get_event_widget(GdkEvent *); + extern void gtk_tree_view_column_set_title(GtkTreeViewColumn *, + const gchar *); + extern gboolean gtk_text_iter_toggles_tag(const GtkTextIter *, + GtkTextTag *); + extern void gtk_icon_factory_add_default(GtkIconFactory *); + extern void gtk_about_dialog_set_authors(GtkAboutDialog *, + const gchar * *); + extern void gtk_expander_set_expanded(GtkExpander *, gboolean); + extern void gtk_container_foreach(GtkContainer *, GtkCallback, + gpointer); + extern void gtk_notebook_popup_enable(GtkNotebook *); + extern void gtk_widget_set_child_visible(GtkWidget *, gboolean); + extern GtkPositionType gtk_scale_get_value_pos(GtkScale *); + extern void gtk_target_list_unref(GtkTargetList *); + extern GType gtk_rc_flags_get_type(void); + extern void gtk_dialog_set_response_sensitive(GtkDialog *, gint, + gboolean); + extern void gtk_paint_slider(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, + GtkWidget *, const gchar *, gint, gint, + gint, gint, GtkOrientation); + extern void gtk_notebook_set_tab_label(GtkNotebook *, GtkWidget *, + GtkWidget *); + extern void gtk_list_store_set_valist(GtkListStore *, GtkTreeIter *, + va_list); + extern void gtk_widget_grab_default(GtkWidget *); + extern gboolean gtk_table_get_homogeneous(GtkTable *); + extern GtkWidget *gtk_layout_new(GtkAdjustment *, GtkAdjustment *); + extern void gtk_accel_label_set_accel_closure(GtkAccelLabel *, + GClosure *); + extern void gtk_tree_view_map_expanded_rows(GtkTreeView *, + GtkTreeViewMappingFunc, + gpointer); + extern void gtk_tree_model_filter_set_visible_func(GtkTreeModelFilter + *, + GtkTreeModelFilterVisibleFunc, + gpointer, + GtkDestroyNotify); + extern void gtk_tree_view_set_model(GtkTreeView *, GtkTreeModel *); + extern gboolean gtk_icon_source_get_state_wildcarded(const + GtkIconSource *); + extern void gtk_icon_theme_add_builtin_icon(const gchar *, gint, + GdkPixbuf *); + extern GtkWidget *gtk_socket_new(void); + extern GtkWidget *gtk_drawing_area_new(void); + extern void gtk_selection_data_set(GtkSelectionData *, GdkAtom, gint, + const guchar *, gint); + extern gboolean gtk_text_iter_backward_cursor_position(GtkTextIter *); + extern PangoContext *gtk_widget_create_pango_context(GtkWidget *); + extern void gtk_cell_view_set_model(GtkCellView *, GtkTreeModel *); + extern gboolean gtk_clipboard_wait_is_target_available(GtkClipboard *, + GdkAtom); + extern gboolean gtk_window_get_modal(GtkWindow *); + extern void gtk_tree_view_column_clicked(GtkTreeViewColumn *); + extern void gtk_menu_set_monitor(GtkMenu *, gint); + extern gboolean gtk_text_iter_forward_sentence_end(GtkTextIter *); + extern gboolean gtk_button_box_get_child_secondary(GtkButtonBox *, + GtkWidget *); + extern GtkObject *gtk_adjustment_new(gdouble, gdouble, gdouble, + gdouble, gdouble, gdouble); + extern GtkWidget *gtk_cell_view_new(void); + extern gboolean gtk_combo_box_get_add_tearoffs(GtkComboBox *); + extern gboolean gtk_text_iter_forward_cursor_positions(GtkTextIter *, + gint); + extern void gtk_window_set_type_hint(GtkWindow *, GdkWindowTypeHint); + extern void gtk_dialog_set_has_separator(GtkDialog *, gboolean); + extern GtkWidget *gtk_fixed_new(void); + extern void gtk_tree_view_enable_model_drag_source(GtkTreeView *, + GdkModifierType, + const GtkTargetEntry + *, gint, + GdkDragAction); + extern void gtk_button_set_label(GtkButton *, const gchar *); + extern void gtk_text_view_scroll_mark_onscreen(GtkTextView *, + GtkTextMark *); + extern gchar *gtk_tree_model_get_string_from_iter(GtkTreeModel *, + GtkTreeIter *); + extern void gtk_viewport_set_vadjustment(GtkViewport *, + GtkAdjustment *); + extern GtkIconSize gtk_icon_source_get_size(const GtkIconSource *); + extern void gtk_init_add(GtkFunction, gpointer); + extern GtkOrientation gtk_icon_view_get_orientation(GtkIconView *); + extern gint gtk_icon_view_get_markup_column(GtkIconView *); + extern void gtk_scrolled_window_set_vadjustment(GtkScrolledWindow *, + GtkAdjustment *); + extern void gtk_icon_view_set_model(GtkIconView *, GtkTreeModel *); + extern void gtk_widget_set_state(GtkWidget *, GtkStateType); + extern void gtk_event_box_set_above_child(GtkEventBox *, gboolean); + extern gboolean gtk_tree_path_prev(GtkTreePath *); + extern GType gtk_tree_view_get_type(void); + extern void gtk_action_connect_proxy(GtkAction *, GtkWidget *); + extern gboolean gtk_tree_view_get_dest_row_at_pos(GtkTreeView *, gint, + gint, + GtkTreePath * *, + GtkTreeViewDropPosition + *); + extern void gtk_tree_view_column_set_max_width(GtkTreeViewColumn *, + gint); + extern GtkTreeViewColumn *gtk_tree_view_column_new(void); + extern void gtk_tree_view_column_clear(GtkTreeViewColumn *); + extern void gtk_menu_tool_button_set_arrow_tooltip(GtkMenuToolButton *, + GtkTooltips *, + const gchar *, + const gchar *); + extern GtkSettings *gtk_settings_get_default(void); + extern gboolean gtk_text_iter_backward_search(const GtkTextIter *, + const gchar *, + GtkTextSearchFlags, + GtkTextIter *, + GtkTextIter *, + const GtkTextIter *); + extern void gtk_object_destroy(GtkObject *); + extern gchar *gtk_text_buffer_get_slice(GtkTextBuffer *, + const GtkTextIter *, + const GtkTextIter *, gboolean); + extern gboolean gtk_text_iter_backward_char(GtkTextIter *); + extern void gtk_tree_view_column_set_spacing(GtkTreeViewColumn *, + gint); + extern gboolean gtk_action_get_sensitive(GtkAction *); + extern gboolean gtk_tree_view_collapse_row(GtkTreeView *, + GtkTreePath *); + extern void gtk_color_selection_set_previous_color(GtkColorSelection *, + const GdkColor *); + extern gboolean gtk_label_get_selectable(GtkLabel *); + extern const gchar *gtk_file_filter_get_name(GtkFileFilter *); + extern gboolean gtk_font_button_get_show_size(GtkFontButton *); + extern void gtk_radio_action_set_group(GtkRadioAction *, GSList *); + extern GtkWidget *gtk_hscale_new_with_range(gdouble, gdouble, gdouble); + extern GtkWidget *gtk_check_menu_item_new_with_mnemonic(const gchar *); + extern GType gtk_path_type_get_type(void); + extern gboolean gtk_accel_label_refetch(GtkAccelLabel *); + extern gboolean gtk_im_context_get_surrounding(GtkIMContext *, + gchar * *, gint *); + extern void gtk_text_buffer_insert(GtkTextBuffer *, GtkTextIter *, + const gchar *, gint); + extern GtkWidget *gtk_toggle_button_new_with_mnemonic(const gchar *); + extern void gtk_tree_selection_select_path(GtkTreeSelection *, + GtkTreePath *); + extern guint gtk_accelerator_get_default_mod_mask(void); + extern GtkWidget *gtk_notebook_get_tab_label(GtkNotebook *, + GtkWidget *); + extern gboolean gtk_text_iter_inside_word(const GtkTextIter *); + extern void gtk_box_query_child_packing(GtkBox *, GtkWidget *, + gboolean *, gboolean *, + guint *, GtkPackType *); + extern void gtk_rc_add_default_file(const gchar *); + extern void gtk_spin_button_set_value(GtkSpinButton *, gdouble); + extern gboolean gtk_window_get_has_frame(GtkWindow *); + extern void gtk_color_button_set_title(GtkColorButton *, + const gchar *); + extern void gtk_text_buffer_copy_clipboard(GtkTextBuffer *, + GtkClipboard *); + extern void gtk_widget_realize(GtkWidget *); + extern GType gtk_im_status_style_get_type(void); + extern void gtk_icon_view_item_activated(GtkIconView *, GtkTreePath *); + extern gint gtk_scale_get_digits(GtkScale *); + extern GtkTreeModel *gtk_tree_view_get_model(GtkTreeView *); + extern guint gtk_quit_add(guint, GtkFunction, gpointer); + extern void gtk_tool_button_set_use_underline(GtkToolButton *, + gboolean); + extern gboolean gtk_window_activate_key(GtkWindow *, GdkEventKey *); + extern GtkWidget *gtk_drag_get_source_widget(GdkDragContext *); + extern guint gtk_statusbar_get_context_id(GtkStatusbar *, + const gchar *); + extern gboolean gtk_file_chooser_get_use_preview_label(GtkFileChooser + *); + extern void gtk_icon_set_unref(GtkIconSet *); + extern void gtk_tree_store_insert_before(GtkTreeStore *, GtkTreeIter *, + GtkTreeIter *, GtkTreeIter *); + extern void gtk_button_box_set_layout(GtkButtonBox *, + GtkButtonBoxStyle); + extern void gtk_label_set_pattern(GtkLabel *, const gchar *); + extern GType gtk_toggle_tool_button_get_type(void); + extern GtkWidget *gtk_tree_view_column_get_widget(GtkTreeViewColumn *); + extern GtkWidget *gtk_radio_button_new_with_mnemonic(GSList *, + const gchar *); + extern void gtk_clipboard_clear(GtkClipboard *); + extern void gtk_misc_get_alignment(GtkMisc *, gfloat *, gfloat *); + extern void gtk_tree_store_set_value(GtkTreeStore *, GtkTreeIter *, + gint, GValue *); + extern GType gtk_font_selection_get_type(void); + extern GParamSpec + **gtk_container_class_list_child_properties(GObjectClass *, + guint *); + extern void gtk_tree_model_row_has_child_toggled(GtkTreeModel *, + GtkTreePath *, + GtkTreeIter *); + extern GType gtk_vbox_get_type(void); + extern void gtk_drag_set_icon_pixbuf(GdkDragContext *, GdkPixbuf *, + gint, gint); + extern void gtk_text_view_set_overwrite(GtkTextView *, gboolean); + extern void gtk_combo_box_set_row_separator_func(GtkComboBox *, + GtkTreeViewRowSeparatorFunc, + gpointer, + GtkDestroyNotify); + extern GType gtk_cell_renderer_progress_get_type(void); + extern gboolean gtk_fixed_get_has_window(GtkFixed *); + extern gboolean gtk_editable_get_selection_bounds(GtkEditable *, + gint *, gint *); + extern gboolean gtk_icon_theme_rescan_if_needed(GtkIconTheme *); + extern void gtk_accel_map_add_entry(const gchar *, guint, + GdkModifierType); + extern void gtk_text_iter_set_line_offset(GtkTextIter *, gint); + extern void gtk_icon_source_set_size(GtkIconSource *, GtkIconSize); + extern gboolean gtk_window_has_toplevel_focus(GtkWindow *); + extern void gtk_menu_item_deselect(GtkMenuItem *); + extern void gtk_accel_label_set_accel_widget(GtkAccelLabel *, + GtkWidget *); + extern gboolean gtk_main_iteration_do(gboolean); + extern GtkIconTheme *gtk_icon_theme_get_default(void); + extern void gtk_drag_dest_set(GtkWidget *, GtkDestDefaults, + const GtkTargetEntry *, gint, + GdkDragAction); + extern gchar *gtk_rc_find_pixmap_in_path(GtkSettings *, GScanner *, + const gchar *); + extern void gtk_style_apply_default_background(GtkStyle *, GdkWindow *, + gboolean, GtkStateType, + GdkRectangle *, gint, + gint, gint, gint); + extern GType gtk_file_chooser_dialog_get_type(void); + extern gboolean gtk_tree_model_iter_parent(GtkTreeModel *, + GtkTreeIter *, + GtkTreeIter *); + extern GtkWidget *gtk_vscale_new(GtkAdjustment *); + extern GtkWidget *gtk_spin_button_new_with_range(gdouble, gdouble, + gdouble); + extern GtkWidget *gtk_image_new(void); + extern GtkIMContext *gtk_im_multicontext_new(void); + extern void gtk_tree_view_column_set_sizing(GtkTreeViewColumn *, + GtkTreeViewColumnSizing); + extern GtkWidget *gtk_radio_button_new_with_label(GSList *, + const gchar *); + extern GtkTreePath *gtk_icon_view_get_path_at_pos(GtkIconView *, gint, + gint); + extern gboolean gtk_tree_view_column_get_clickable(GtkTreeViewColumn + *); + extern void gtk_editable_insert_text(GtkEditable *, const gchar *, + gint, gint *); + extern guint gtk_key_snooper_install(GtkKeySnoopFunc, gpointer); + extern void gtk_object_sink(GtkObject *); + extern void gtk_widget_style_get(GtkWidget *, const gchar *, ...); + extern GList *gtk_icon_theme_list_icons(GtkIconTheme *, const char *); + extern void gtk_cell_renderer_get_fixed_size(GtkCellRenderer *, gint *, + gint *); + extern void gtk_button_released(GtkButton *); + extern void gtk_icon_source_set_size_wildcarded(GtkIconSource *, + gboolean); + extern void gtk_window_begin_resize_drag(GtkWindow *, GdkWindowEdge, + gint, gint, gint, guint32); + extern gboolean gtk_text_iter_forward_to_tag_toggle(GtkTextIter *, + GtkTextTag *); + extern gboolean gtk_tree_selection_path_is_selected(GtkTreeSelection *, + GtkTreePath *); + extern void gtk_window_set_wmclass(GtkWindow *, const gchar *, + const gchar *); + extern GtkWidget *gtk_action_create_icon(GtkAction *, GtkIconSize); + extern gboolean gtk_text_iter_backward_line(GtkTextIter *); + extern gchar + *gtk_font_selection_dialog_get_font_name(GtkFontSelectionDialog *); + extern GType gtk_cell_renderer_toggle_get_type(void); + extern void gtk_tree_model_rows_reordered(GtkTreeModel *, + GtkTreePath *, GtkTreeIter *, + gint *); + extern PangoLayout *gtk_label_get_layout(GtkLabel *); + extern gboolean gtk_tree_view_get_path_at_pos(GtkTreeView *, gint, + gint, GtkTreePath * *, + GtkTreeViewColumn * *, + gint *, gint *); + extern gboolean gtk_combo_box_get_active_iter(GtkComboBox *, + GtkTreeIter *); + extern gboolean gtk_label_get_line_wrap(GtkLabel *); + extern gboolean gtk_window_activate_focus(GtkWindow *); + extern void gtk_table_set_row_spacing(GtkTable *, guint, guint); + extern void gtk_widget_ensure_style(GtkWidget *); + extern GType gtk_selection_mode_get_type(void); + extern gboolean gtk_window_activate_default(GtkWindow *); + extern GtkAboutDialogActivateLinkFunc + gtk_about_dialog_set_url_hook(GtkAboutDialogActivateLinkFunc, + gpointer, GDestroyNotify); + extern gboolean gtk_check_menu_item_get_inconsistent(GtkCheckMenuItem + *); + extern gchar *gtk_set_locale(void); + extern void gtk_icon_theme_set_screen(GtkIconTheme *, GdkScreen *); + extern gint gtk_editable_get_position(GtkEditable *); + extern void gtk_icon_theme_set_search_path(GtkIconTheme *, + const gchar * *, gint); + extern void gtk_text_view_set_justification(GtkTextView *, + GtkJustification); + extern GdkPixbuf *gtk_selection_data_get_pixbuf(GtkSelectionData *); + extern void gtk_spin_button_spin(GtkSpinButton *, GtkSpinType, + gdouble); + extern gint gtk_notebook_append_page_menu(GtkNotebook *, GtkWidget *, + GtkWidget *, GtkWidget *); + extern gboolean gtk_text_view_move_mark_onscreen(GtkTextView *, + GtkTextMark *); + extern void gtk_widget_set_sensitive(GtkWidget *, gboolean); + extern GtkTreePath + *gtk_tree_model_sort_convert_path_to_child_path(GtkTreeModelSort *, + GtkTreePath *); + extern void gtk_drag_set_icon_pixmap(GdkDragContext *, GdkColormap *, + GdkPixmap *, GdkBitmap *, gint, + gint); + extern gboolean gtk_text_child_anchor_get_deleted(GtkTextChildAnchor + *); + extern gboolean gtk_tree_view_expand_row(GtkTreeView *, GtkTreePath *, + gboolean); + extern GtkWidget *gtk_expander_get_label_widget(GtkExpander *); + extern void gtk_range_set_update_policy(GtkRange *, GtkUpdateType); + extern void gtk_curve_set_curve_type(GtkCurve *, GtkCurveType); + extern void gtk_handle_box_set_shadow_type(GtkHandleBox *, + GtkShadowType); + extern gboolean gtk_tool_item_get_expand(GtkToolItem *); + extern GtkWidget *gtk_window_new(GtkWindowType); + extern GType gtk_list_store_get_type(void); + extern GtkWidget *gtk_cell_view_new_with_markup(const gchar *); + extern void gtk_fixed_set_has_window(GtkFixed *, gboolean); + extern void gtk_cell_view_set_displayed_row(GtkCellView *, + GtkTreePath *); + extern void gtk_button_set_use_underline(GtkButton *, gboolean); + extern GtkWindow *gtk_window_get_transient_for(GtkWindow *); + extern GtkTreeIter *gtk_tree_iter_copy(GtkTreeIter *); + extern void gtk_file_chooser_set_current_name(GtkFileChooser *, + const gchar *); + extern void gtk_window_set_decorated(GtkWindow *, gboolean); + extern const guint gtk_interface_age; + extern void gtk_menu_shell_deselect(GtkMenuShell *); + extern gboolean gtk_text_iter_backward_cursor_positions(GtkTextIter *, + gint); + extern gboolean gtk_text_iter_can_insert(const GtkTextIter *, + gboolean); + extern gboolean gtk_widget_is_ancestor(GtkWidget *, GtkWidget *); + extern GType gtk_check_menu_item_get_type(void); + extern gboolean gtk_tree_path_up(GtkTreePath *); + extern void gtk_dialog_response(GtkDialog *, gint); + extern GdkWindowTypeHint gtk_window_get_type_hint(GtkWindow *); + extern void gtk_widget_queue_resize_no_redraw(GtkWidget *); + extern GtkWidget *gtk_frame_new(const gchar *); + extern void gtk_tree_view_column_set_reorderable(GtkTreeViewColumn *, + gboolean); + extern GtkCellRenderer *gtk_cell_renderer_progress_new(void); + extern void gtk_widget_grab_focus(GtkWidget *); + extern void gtk_target_list_ref(GtkTargetList *); + extern PangoTabArray *gtk_text_view_get_tabs(GtkTextView *); + extern void gtk_icon_info_set_raw_coordinates(GtkIconInfo *, gboolean); + extern void gtk_window_present(GtkWindow *); + extern GType gtk_button_box_style_get_type(void); + extern void gtk_image_get_icon_set(GtkImage *, GtkIconSet * *, + GtkIconSize *); + extern PangoLanguage *gtk_get_default_language(void); + extern gchar **gtk_selection_data_get_uris(GtkSelectionData *); + extern gdouble gtk_progress_bar_get_fraction(GtkProgressBar *); + extern GType gtk_radio_tool_button_get_type(void); + extern gboolean gtk_toggle_action_get_active(GtkToggleAction *); + extern const guint gtk_major_version; + extern GType gtk_signal_run_type_get_type(void); + extern void gtk_rc_reset_styles(GtkSettings *); + extern void gtk_tree_view_set_search_column(GtkTreeView *, gint); + extern void gtk_widget_modify_fg(GtkWidget *, GtkStateType, + const GdkColor *); + extern void gtk_icon_size_register_alias(const gchar *, GtkIconSize); + extern void gtk_text_view_window_to_buffer_coords(GtkTextView *, + GtkTextWindowType, + gint, gint, gint *, + gint *); + extern void gtk_cell_renderer_render(GtkCellRenderer *, GdkWindow *, + GtkWidget *, GdkRectangle *, + GdkRectangle *, GdkRectangle *, + GtkCellRendererState); + extern gboolean gtk_calendar_mark_day(GtkCalendar *, guint); + extern const gchar *gtk_window_get_icon_name(GtkWindow *); + extern void gtk_menu_attach(GtkMenu *, GtkWidget *, guint, guint, + guint, guint); + extern const gchar *gtk_about_dialog_get_name(GtkAboutDialog *); + extern gint gtk_tree_selection_count_selected_rows(GtkTreeSelection *); + extern GtkAccelGroup *gtk_ui_manager_get_accel_group(GtkUIManager *); + extern void gtk_tree_view_column_focus_cell(GtkTreeViewColumn *, + GtkCellRenderer *); + extern gboolean gtk_window_get_resizable(GtkWindow *); + extern void gtk_label_set_angle(GtkLabel *, gdouble); + extern void gtk_tree_view_column_set_alignment(GtkTreeViewColumn *, + gfloat); + extern void gtk_drag_unhighlight(GtkWidget *); + extern guint gtk_debug_flags; + extern GType gtk_tree_view_mode_get_type(void); + extern void gtk_notebook_set_tab_label_packing(GtkNotebook *, + GtkWidget *, gboolean, + gboolean, GtkPackType); + extern GType gtk_tree_drag_source_get_type(void); + extern gchar *gtk_check_version(guint, guint, guint); + extern gboolean gtk_text_iter_backward_word_start(GtkTextIter *); + extern void gtk_toggle_action_set_draw_as_radio(GtkToggleAction *, + gboolean); + extern GtkRcStyle *gtk_rc_style_new(void); + extern gint gtk_toolbar_get_item_index(GtkToolbar *, GtkToolItem *); + extern GtkWidget *gtk_file_chooser_get_extra_widget(GtkFileChooser *); + extern gboolean gtk_font_button_get_use_size(GtkFontButton *); + extern gboolean gtk_false(void); + extern void gtk_accel_map_unlock_path(const gchar *); + extern GtkShadowType + gtk_scrolled_window_get_shadow_type(GtkScrolledWindow *); + extern void gtk_tree_view_column_set_visible(GtkTreeViewColumn *, + gboolean); + extern GtkAction *gtk_ui_manager_get_action(GtkUIManager *, + const gchar *); + extern gboolean gtk_rc_property_parse_flags(const GParamSpec *, + const GString *, GValue *); + extern void gtk_icon_theme_prepend_search_path(GtkIconTheme *, + const gchar *); + extern gint gtk_radio_action_get_current_value(GtkRadioAction *); + extern void gtk_file_selection_set_filename(GtkFileSelection *, + const gchar *); + extern void gtk_im_context_set_surrounding(GtkIMContext *, + const gchar *, gint, gint); + extern void gtk_drag_dest_add_text_targets(GtkWidget *); + extern void gtk_image_set_from_pixmap(GtkImage *, GdkPixmap *, + GdkBitmap *); + extern void gtk_icon_view_unselect_path(GtkIconView *, GtkTreePath *); + extern GSList *gtk_stock_list_ids(void); + extern void gtk_file_chooser_remove_filter(GtkFileChooser *, + GtkFileFilter *); + extern GtkListStore *gtk_list_store_newv(gint, GType *); + extern GtkTextTag *gtk_text_tag_table_lookup(GtkTextTagTable *, + const gchar *); + extern void gtk_window_set_skip_pager_hint(GtkWindow *, gboolean); + extern gboolean gtk_button_get_focus_on_click(GtkButton *); + extern void gtk_file_selection_hide_fileop_buttons(GtkFileSelection *); + extern void gtk_radio_menu_item_set_group(GtkRadioMenuItem *, + GSList *); + extern void gtk_color_button_set_use_alpha(GtkColorButton *, gboolean); + extern void gtk_widget_pop_colormap(void); + extern void gtk_widget_set_no_show_all(GtkWidget *, gboolean); + extern GtkSettings *gtk_settings_get_for_screen(GdkScreen *); + extern void gtk_font_selection_set_preview_text(GtkFontSelection *, + const gchar *); + extern GtkSelectionData *gtk_clipboard_wait_for_contents(GtkClipboard + *, GdkAtom); + extern GType gtk_spin_type_get_type(void); + extern GType gtk_movement_step_get_type(void); + extern GType gtk_icon_source_get_type(void); + extern void gtk_window_set_skip_taskbar_hint(GtkWindow *, gboolean); + extern gint gtk_tree_view_column_get_width(GtkTreeViewColumn *); + extern GType gtk_invisible_get_type(void); + extern void gtk_cell_renderer_toggle_set_active(GtkCellRendererToggle + *, gboolean); + extern void gtk_menu_item_set_right_justified(GtkMenuItem *, gboolean); + extern GType gtk_widget_flags_get_type(void); + extern void gtk_action_connect_accelerator(GtkAction *); + extern GtkWidget *gtk_image_new_from_pixbuf(GdkPixbuf *); + extern gint gtk_icon_view_get_columns(GtkIconView *); + extern void gtk_menu_set_tearoff_state(GtkMenu *, gboolean); + extern void gtk_progress_bar_set_ellipsize(GtkProgressBar *, + PangoEllipsizeMode); + extern void gtk_image_set_from_pixbuf(GtkImage *, GdkPixbuf *); + extern gboolean gtk_text_view_get_cursor_visible(GtkTextView *); + extern void gtk_image_set_from_stock(GtkImage *, const gchar *, + GtkIconSize); + extern GType gtk_event_box_get_type(void); + extern void gtk_icon_source_free(GtkIconSource *); + extern void gtk_menu_attach_to_widget(GtkMenu *, GtkWidget *, + GtkMenuDetachFunc); + extern void gtk_menu_reposition(GtkMenu *); + extern GtkTreeSelection *gtk_tree_view_get_selection(GtkTreeView *); + extern void gtk_button_clicked(GtkButton *); + extern GType gtk_file_chooser_error_get_type(void); + extern void gtk_list_store_swap(GtkListStore *, GtkTreeIter *, + GtkTreeIter *); + extern void gtk_tree_model_get(GtkTreeModel *, GtkTreeIter *, ...); + extern GtkWidget *gtk_ui_manager_get_widget(GtkUIManager *, + const gchar *); + extern GtkIconSize gtk_icon_size_register(const gchar *, gint, gint); + extern gboolean gtk_text_view_get_accepts_tab(GtkTextView *); + extern GtkWidget *gtk_radio_button_new_from_widget(GtkRadioButton *); + extern char *gtk_file_chooser_get_preview_filename(GtkFileChooser *); + extern void gtk_invisible_set_screen(GtkInvisible *, GdkScreen *); + extern GdkDisplay *gtk_clipboard_get_display(GtkClipboard *); + extern GType gtk_statusbar_get_type(void); + extern GtkWidget *gtk_font_button_new(void); + extern GType gtk_tearoff_menu_item_get_type(void); + extern const gchar *gtk_icon_size_get_name(GtkIconSize); + extern GSList + *gtk_file_chooser_list_shortcut_folder_uris(GtkFileChooser *); + extern GType gtk_tree_row_reference_get_type(void); + extern gfloat gtk_tree_view_column_get_alignment(GtkTreeViewColumn *); + extern gboolean gtk_file_chooser_add_shortcut_folder_uri(GtkFileChooser + *, + const char *, + GError * *); + extern GtkWidget *gtk_window_get_focus(GtkWindow *); + extern GtkWidget *gtk_label_new_with_mnemonic(const gchar *); + extern gboolean gtk_entry_get_activates_default(GtkEntry *); + extern void gtk_layout_set_hadjustment(GtkLayout *, GtkAdjustment *); + extern gint gtk_text_buffer_get_line_count(GtkTextBuffer *); + extern GType gtk_button_get_type(void); + extern void gtk_table_set_row_spacings(GtkTable *, guint); + extern GtkWidget *gtk_statusbar_new(void); + extern GtkCellRenderer *gtk_cell_renderer_toggle_new(void); + extern void gtk_widget_modify_style(GtkWidget *, GtkRcStyle *); + extern GdkPixbuf *gtk_widget_render_icon(GtkWidget *, const gchar *, + GtkIconSize, const gchar *); + extern void gtk_accel_map_add_filter(const gchar *); + extern void gtk_window_set_position(GtkWindow *, GtkWindowPosition); + extern void gtk_text_tag_table_foreach(GtkTextTagTable *, + GtkTextTagTableForeach, + gpointer); + extern GtkIconSet *gtk_icon_set_new_from_pixbuf(GdkPixbuf *); + extern GtkWidget *gtk_hruler_new(void); + extern gboolean gtk_expander_get_expanded(GtkExpander *); + extern void gtk_editable_delete_text(GtkEditable *, gint, gint); + extern void gtk_paint_shadow(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, + GtkWidget *, const gchar *, gint, gint, + gint, gint); + extern GdkPixbuf *gtk_icon_theme_load_icon(GtkIconTheme *, + const gchar *, gint, + GtkIconLookupFlags, + GError * *); + extern void gtk_window_maximize(GtkWindow *); + extern GtkWidget *gtk_bin_get_child(GtkBin *); + extern void gtk_notebook_set_menu_label_text(GtkNotebook *, + GtkWidget *, + const gchar *); + extern GtkStockItem *gtk_stock_item_copy(const GtkStockItem *); + extern void gtk_tool_item_rebuild_menu(GtkToolItem *); + extern void gtk_style_set_background(GtkStyle *, GdkWindow *, + GtkStateType); + extern gboolean gtk_text_iter_starts_line(const GtkTextIter *); + extern gboolean gtk_tree_model_sort_iter_is_valid(GtkTreeModelSort *, + GtkTreeIter *); + extern void gtk_clipboard_set_image(GtkClipboard *, GdkPixbuf *); + extern gboolean gtk_selection_owner_set_for_display(GdkDisplay *, + GtkWidget *, + GdkAtom, guint32); + extern void gtk_tree_view_column_pack_start(GtkTreeViewColumn *, + GtkCellRenderer *, + gboolean); + extern gboolean gtk_text_iter_in_range(const GtkTextIter *, + const GtkTextIter *, + const GtkTextIter *); + extern const gchar *gtk_about_dialog_get_comments(GtkAboutDialog *); + extern GtkWidget *gtk_file_chooser_button_new_with_backend(const gchar + *, + GtkFileChooserAction, + const gchar + *); + extern GtkWidget *gtk_widget_new(GType, const gchar *, ...); + extern GtkWidget *gtk_combo_box_entry_new_text(void); + extern GType gtk_resize_mode_get_type(void); + extern void gtk_entry_completion_set_match_func(GtkEntryCompletion *, + GtkEntryCompletionMatchFunc, + gpointer, + GDestroyNotify); + extern void gtk_spin_button_get_increments(GtkSpinButton *, gdouble *, + gdouble *); + extern void gtk_font_button_set_use_font(GtkFontButton *, gboolean); + extern GdkColormap *gtk_widget_get_colormap(GtkWidget *); + extern GtkToolItem *gtk_radio_tool_button_new(GSList *); + extern void gtk_color_selection_set_current_alpha(GtkColorSelection *, + guint16); + extern gchar **gtk_rc_get_default_files(void); + extern void gtk_editable_paste_clipboard(GtkEditable *); + extern void gtk_accel_map_load(const gchar *); + extern GtkTooltips *gtk_tooltips_new(void); + extern GtkWidget *gtk_image_new_from_file(const gchar *); + extern gint gtk_icon_view_get_spacing(GtkIconView *); + extern GtkWidget *gtk_vbutton_box_new(void); + extern void gtk_widget_freeze_child_notify(GtkWidget *); + extern GtkStyle *gtk_style_new(void); + extern void gtk_editable_set_editable(GtkEditable *, gboolean); + extern GtkWidget *gtk_button_new_with_mnemonic(const gchar *); + extern GType gtk_separator_menu_item_get_type(void); + extern void gtk_window_set_frame_dimensions(GtkWindow *, gint, gint, + gint, gint); + extern void gtk_text_buffer_select_range(GtkTextBuffer *, + const GtkTextIter *, + const GtkTextIter *); + extern gboolean gtk_tree_view_row_expanded(GtkTreeView *, + GtkTreePath *); + extern void gtk_window_set_role(GtkWindow *, const gchar *); + extern void gtk_plug_construct_for_display(GtkPlug *, GdkDisplay *, + GdkNativeWindow); + extern void gtk_action_group_set_visible(GtkActionGroup *, gboolean); + extern void gtk_misc_get_padding(GtkMisc *, gint *, gint *); + extern GType gtk_file_chooser_get_type(void); + extern void gtk_tree_view_column_set_resizable(GtkTreeViewColumn *, + gboolean); + extern void gtk_tree_view_columns_autosize(GtkTreeView *); + extern void gtk_layout_set_size(GtkLayout *, guint, guint); + extern gboolean gtk_toggle_button_get_mode(GtkToggleButton *); + extern GType gtk_expander_style_get_type(void); + extern void gtk_accessible_connect_widget_destroyed(GtkAccessible *); + extern void gtk_tree_view_set_cursor(GtkTreeView *, GtkTreePath *, + GtkTreeViewColumn *, gboolean); + extern void gtk_button_box_set_child_secondary(GtkButtonBox *, + GtkWidget *, gboolean); + extern void gtk_tree_model_row_deleted(GtkTreeModel *, GtkTreePath *); + extern void gtk_tree_selection_set_select_function(GtkTreeSelection *, + GtkTreeSelectionFunc, + gpointer, + GtkDestroyNotify); + extern gboolean gtk_tree_drag_source_row_draggable(GtkTreeDragSource *, + GtkTreePath *); + extern GtkAccelGroupEntry *gtk_accel_group_query(GtkAccelGroup *, + guint, + GdkModifierType, + guint *); + extern void gtk_expander_set_label_widget(GtkExpander *, GtkWidget *); + extern void gtk_target_list_add_table(GtkTargetList *, + const GtkTargetEntry *, guint); + extern gint gtk_icon_view_get_row_spacing(GtkIconView *); + extern gboolean gtk_text_view_forward_display_line_end(GtkTextView *, + GtkTextIter *); + extern GtkIconSize gtk_tool_item_get_icon_size(GtkToolItem *); + extern void gtk_widget_set_default_direction(GtkTextDirection); + extern void gtk_tree_view_move_column_after(GtkTreeView *, + GtkTreeViewColumn *, + GtkTreeViewColumn *); + extern GType gtk_notebook_tab_get_type(void); + extern GtkActionGroup *gtk_action_group_new(const gchar *); + extern void gtk_widget_add_mnemonic_label(GtkWidget *, GtkWidget *); + extern GType gtk_text_child_anchor_get_type(void); + extern const gchar *gtk_icon_info_get_filename(GtkIconInfo *); + extern void gtk_menu_item_set_submenu(GtkMenuItem *, GtkWidget *); + extern void gtk_menu_detach(GtkMenu *); + extern void gtk_container_resize_children(GtkContainer *); + extern GType gtk_text_mark_get_type(void); + extern gint gtk_entry_get_max_length(GtkEntry *); + extern GSList *gtk_radio_menu_item_get_group(GtkRadioMenuItem *); + extern GType gtk_text_attributes_get_type(void); + extern gboolean gtk_text_mark_get_left_gravity(GtkTextMark *); + extern GdkRegion *gtk_widget_region_intersect(GtkWidget *, + GdkRegion *); + extern GtkWidget *gtk_handle_box_new(void); + extern GList *gtk_menu_get_for_attach_widget(GtkWidget *); + extern void gtk_list_store_set_column_types(GtkListStore *, gint, + GType *); + extern void gtk_paint_option(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, + GtkWidget *, const gchar *, gint, gint, + gint, gint); + extern void gtk_tree_selection_select_iter(GtkTreeSelection *, + GtkTreeIter *); + extern void gtk_tree_view_column_set_fixed_width(GtkTreeViewColumn *, + gint); + extern GtkTextBuffer *gtk_text_buffer_new(GtkTextTagTable *); + extern void gtk_menu_shell_activate_item(GtkMenuShell *, GtkWidget *, + gboolean); + extern void gtk_tree_view_column_set_widget(GtkTreeViewColumn *, + GtkWidget *); + extern gint gtk_notebook_get_current_page(GtkNotebook *); + extern GtkWidget *gtk_message_dialog_new_with_markup(GtkWindow *, + GtkDialogFlags, + GtkMessageType, + GtkButtonsType, + const gchar *, + ...); + extern const gchar *gtk_widget_get_name(GtkWidget *); + extern gint gtk_entry_completion_get_text_column(GtkEntryCompletion *); + extern GType gtk_calendar_get_type(void); + extern void gtk_tree_view_unset_rows_drag_source(GtkTreeView *); + extern void gtk_tool_button_set_icon_widget(GtkToolButton *, + GtkWidget *); + extern GType gtk_cell_renderer_mode_get_type(void); + extern GtkWidget *gtk_check_button_new_with_label(const gchar *); + extern void gtk_cell_editable_start_editing(GtkCellEditable *, + GdkEvent *); + extern gboolean gtk_widget_has_screen(GtkWidget *); + extern void gtk_dialog_set_alternative_button_order(GtkDialog *, gint, + ...); + extern void gtk_radio_tool_button_set_group(GtkRadioToolButton *, + GSList *); + extern void gtk_menu_item_activate(GtkMenuItem *); + extern const gchar *gtk_window_get_title(GtkWindow *); + extern void gtk_window_set_gravity(GtkWindow *, GdkGravity); + extern GtkCalendarDisplayOptions + gtk_calendar_get_display_options(GtkCalendar *); + extern void gtk_text_tag_table_remove(GtkTextTagTable *, GtkTextTag *); + extern void gtk_font_button_set_title(GtkFontButton *, const gchar *); + extern void gtk_tree_row_reference_reordered(GObject *, GtkTreePath *, + GtkTreeIter *, gint *); + extern void gtk_file_filter_add_mime_type(GtkFileFilter *, + const gchar *); + extern GOptionGroup *gtk_get_option_group(gboolean); + extern gchar *gtk_ui_manager_get_ui(GtkUIManager *); + extern void gtk_ruler_set_metric(GtkRuler *, GtkMetricType); + extern GtkToolItem *gtk_tool_item_new(void); + extern void gtk_about_dialog_set_license(GtkAboutDialog *, + const gchar *); + extern void gtk_paint_box_gap(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, + GtkWidget *, gchar *, gint, gint, gint, + gint, GtkPositionType, gint, gint); + extern GtkWidget *gtk_plug_new(GdkNativeWindow); + extern GType gtk_im_multicontext_get_type(void); + extern void gtk_toggle_action_set_active(GtkToggleAction *, gboolean); + extern void gtk_label_set_text_with_mnemonic(GtkLabel *, + const gchar *); + extern GtkWidget *gtk_table_new(guint, guint, gboolean); + extern GtkWidget *gtk_alignment_new(gfloat, gfloat, gfloat, gfloat); + extern gint gtk_icon_view_get_margin(GtkIconView *); + extern void gtk_notebook_set_show_border(GtkNotebook *, gboolean); + extern void gtk_text_buffer_paste_clipboard(GtkTextBuffer *, + GtkClipboard *, + GtkTextIter *, gboolean); + extern GtkWidget *gtk_hscrollbar_new(GtkAdjustment *); + extern gboolean gtk_tree_view_get_fixed_height_mode(GtkTreeView *); + extern gboolean gtk_tree_store_remove(GtkTreeStore *, GtkTreeIter *); + extern GList *gtk_widget_list_mnemonic_labels(GtkWidget *); + extern void gtk_cell_layout_add_attribute(GtkCellLayout *, + GtkCellRenderer *, + const gchar *, gint); + extern GParamSpec + **gtk_widget_class_list_style_properties(GtkWidgetClass *, + guint *); + extern gint + gtk_entry_completion_get_minimum_key_length(GtkEntryCompletion *); + extern void gtk_text_buffer_move_mark(GtkTextBuffer *, GtkTextMark *, + const GtkTextIter *); + extern gboolean gtk_text_mark_get_visible(GtkTextMark *); + extern void gtk_list_store_set_value(GtkListStore *, GtkTreeIter *, + gint, GValue *); + extern void gtk_widget_style_get_property(GtkWidget *, const gchar *, + GValue *); + extern void gtk_widget_modify_bg(GtkWidget *, GtkStateType, + const GdkColor *); + extern GtkWidget *gtk_image_menu_item_new_with_label(const gchar *); + extern gboolean gtk_font_button_get_use_font(GtkFontButton *); + extern gboolean gtk_im_context_delete_surrounding(GtkIMContext *, gint, + gint); + extern void gtk_misc_set_alignment(GtkMisc *, gfloat, gfloat); + extern GtkWidget *gtk_tool_button_get_label_widget(GtkToolButton *); + extern gint gtk_toolbar_get_n_items(GtkToolbar *); + extern GtkWidget *gtk_tool_button_get_icon_widget(GtkToolButton *); + extern gboolean gtk_tree_row_reference_valid(GtkTreeRowReference *); + extern gboolean gtk_tree_model_iter_nth_child(GtkTreeModel *, + GtkTreeIter *, + GtkTreeIter *, gint); + extern void gtk_tree_view_set_search_equal_func(GtkTreeView *, + GtkTreeViewSearchEqualFunc, + gpointer, + GtkDestroyNotify); + extern GtkWidget *gtk_image_new_from_animation(GdkPixbufAnimation *); + extern gint gtk_tree_view_remove_column(GtkTreeView *, + GtkTreeViewColumn *); + extern void gtk_window_remove_mnemonic(GtkWindow *, guint, + GtkWidget *); + extern GType gtk_text_iter_get_type(void); + extern gboolean gtk_action_get_visible(GtkAction *); + extern GtkWidget *gtk_radio_button_new(GSList *); + extern gboolean gtk_text_iter_ends_word(const GtkTextIter *); + extern GType gtk_visibility_get_type(void); + extern GType gtk_im_context_simple_get_type(void); + extern GdkWindow *gtk_widget_get_root_window(GtkWidget *); + extern GType gtk_vruler_get_type(void); + extern void gtk_image_set_from_animation(GtkImage *, + GdkPixbufAnimation *); + extern void gtk_tree_view_set_enable_search(GtkTreeView *, gboolean); + extern void gtk_combo_box_popdown(GtkComboBox *); + extern void gtk_tree_view_expand_all(GtkTreeView *); + extern void gtk_drag_source_set_icon_stock(GtkWidget *, const gchar *); + extern const gchar *gtk_icon_info_get_display_name(GtkIconInfo *); + extern void gtk_window_iconify(GtkWindow *); + extern GType gtk_color_selection_dialog_get_type(void); + extern GtkIconTheme *gtk_icon_theme_new(void); + extern gint gtk_icon_info_get_base_size(GtkIconInfo *); + extern void gtk_action_block_activate_from(GtkAction *, GtkWidget *); + extern void gtk_action_group_add_actions(GtkActionGroup *, + const GtkActionEntry *, guint, + gpointer); + extern GType gtk_separator_get_type(void); + extern void gtk_table_set_col_spacing(GtkTable *, guint, guint); + extern gboolean gtk_text_view_get_editable(GtkTextView *); + extern GdkWindow *gtk_widget_get_parent_window(GtkWidget *); + extern void gtk_color_selection_get_current_color(GtkColorSelection *, + GdkColor *); + extern void gtk_about_dialog_set_website(GtkAboutDialog *, + const gchar *); + extern GType gtk_requisition_get_type(void); + extern void gtk_accelerator_parse(const gchar *, guint *, + GdkModifierType *); + extern GtkShadowType gtk_frame_get_shadow_type(GtkFrame *); + extern gboolean gtk_tree_view_get_rules_hint(GtkTreeView *); + extern void gtk_accelerator_set_default_mod_mask(GdkModifierType); + extern void gtk_window_set_keep_below(GtkWindow *, gboolean); + extern gchar *gtk_text_iter_get_visible_slice(const GtkTextIter *, + const GtkTextIter *); + extern void gtk_drag_source_add_uri_targets(GtkWidget *); + extern gboolean gtk_font_selection_set_font_name(GtkFontSelection *, + const gchar *); + extern void gtk_entry_set_completion(GtkEntry *, GtkEntryCompletion *); + extern gboolean gtk_action_group_get_sensitive(GtkActionGroup *); + extern void gtk_label_set_ellipsize(GtkLabel *, PangoEllipsizeMode); + extern GType gtk_arg_flags_get_type(void); + extern void gtk_rc_parse(const gchar *); + extern gboolean gtk_text_iter_has_tag(const GtkTextIter *, + GtkTextTag *); + extern void gtk_file_selection_set_select_multiple(GtkFileSelection *, + gboolean); + extern GtkTreePath + *gtk_tree_model_filter_convert_child_path_to_path + (GtkTreeModelFilter *, GtkTreePath *); + extern void gtk_fixed_put(GtkFixed *, GtkWidget *, gint, gint); + extern GtkSizeGroup *gtk_size_group_new(GtkSizeGroupMode); + extern void gtk_entry_completion_delete_action(GtkEntryCompletion *, + gint); + extern void gtk_paint_expander(GtkStyle *, GdkWindow *, GtkStateType, + GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, + GtkExpanderStyle); + extern GtkTreePath *gtk_tree_path_new(void); + extern GType gtk_rc_token_type_get_type(void); + extern void gtk_accel_group_lock(GtkAccelGroup *); + extern gboolean gtk_tree_model_iter_has_child(GtkTreeModel *, + GtkTreeIter *); + extern gboolean gtk_widget_activate(GtkWidget *); + extern void gtk_text_buffer_begin_user_action(GtkTextBuffer *); + extern void gtk_check_menu_item_toggled(GtkCheckMenuItem *); + extern gboolean gtk_rc_property_parse_color(const GParamSpec *, + const GString *, GValue *); + extern void gtk_menu_item_toggle_size_allocate(GtkMenuItem *, gint); + extern void gtk_file_chooser_button_set_title(GtkFileChooserButton *, + const gchar *); + extern void gtk_cell_renderer_stop_editing(GtkCellRenderer *, + gboolean); + extern void gtk_widget_unrealize(GtkWidget *); + extern GType gtk_icon_theme_get_type(void); + extern GSList *gtk_file_chooser_get_filenames(GtkFileChooser *); + extern void gtk_box_pack_start_defaults(GtkBox *, GtkWidget *); + extern GParamSpec *gtk_container_class_find_child_property(GObjectClass + *, + const gchar + *); + extern guint gtk_table_get_default_col_spacing(GtkTable *); + extern void gtk_menu_shell_insert(GtkMenuShell *, GtkWidget *, gint); + extern GtkWidget *gtk_notebook_get_nth_page(GtkNotebook *, gint); + extern void gtk_text_buffer_get_iter_at_line_offset(GtkTextBuffer *, + GtkTextIter *, + gint, gint); + extern GtkWidget *gtk_combo_box_entry_new_with_model(GtkTreeModel *, + gint); + extern void gtk_handle_box_set_snap_edge(GtkHandleBox *, + GtkPositionType); + extern void gtk_combo_box_set_active(GtkComboBox *, gint); + extern void gtk_message_dialog_format_secondary_markup(GtkMessageDialog + *, + const gchar *, + ...); + extern GType gtk_toolbar_get_type(void); + extern GType gtk_border_get_type(void); + extern gboolean gtk_bindings_activate_event(GtkObject *, + GdkEventKey *); + extern const gchar + *gtk_font_selection_get_preview_text(GtkFontSelection *); + extern GtkWidget *gtk_progress_bar_new(void); + extern const gchar + *gtk_font_selection_dialog_get_preview_text(GtkFontSelectionDialog + *); + extern void gtk_curve_set_vector(GtkCurve *, int, gfloat *); + extern void gtk_tree_view_set_hadjustment(GtkTreeView *, + GtkAdjustment *); + extern gboolean gtk_toolbar_get_tooltips(GtkToolbar *); + extern GtkWidget *gtk_image_new_from_pixmap(GdkPixmap *, GdkBitmap *); + extern void gtk_file_chooser_select_all(GtkFileChooser *); + extern void gtk_tree_selection_unselect_iter(GtkTreeSelection *, + GtkTreeIter *); + extern GType gtk_scroll_step_get_type(void); + extern GType gtk_identifier_get_type(void); + extern GtkWidget *gtk_font_button_new_with_font(const gchar *); + extern void gtk_combo_box_set_focus_on_click(GtkComboBox *, gboolean); + extern void gtk_icon_view_set_selection_mode(GtkIconView *, + GtkSelectionMode); + extern void gtk_message_dialog_set_markup(GtkMessageDialog *, + const gchar *); + extern gchar *gtk_file_chooser_get_uri(GtkFileChooser *); + extern GtkWidget *gtk_action_create_tool_item(GtkAction *); + extern void gtk_widget_unref(GtkWidget *); + extern gint gtk_widget_send_expose(GtkWidget *, GdkEvent *); + extern gchar *gtk_text_iter_get_text(const GtkTextIter *, + const GtkTextIter *); + extern GType gtk_image_type_get_type(void); + extern GtkWidget *gtk_file_chooser_widget_new(GtkFileChooserAction); + extern gboolean + gtk_entry_completion_get_inline_completion(GtkEntryCompletion *); + extern GType gtk_response_type_get_type(void); + extern void gtk_widget_modify_text(GtkWidget *, GtkStateType, + const GdkColor *); + extern guint gtk_rc_parse_priority(GScanner *, GtkPathPriorityType *); + extern GtkWidget *gtk_invisible_new(void); + extern void gtk_paint_handle(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, + GtkWidget *, const gchar *, gint, gint, + gint, gint, GtkOrientation); + extern gboolean + gtk_text_iter_backward_visible_cursor_positions(GtkTextIter *, + gint); + extern gboolean gtk_font_button_get_show_style(GtkFontButton *); + extern guint gtk_container_get_border_width(GtkContainer *); + extern GtkWidget *gtk_widget_get_parent(GtkWidget *); + extern void gtk_button_enter(GtkButton *); + extern void gtk_text_view_set_accepts_tab(GtkTextView *, gboolean); + extern void gtk_widget_set_redraw_on_allocate(GtkWidget *, gboolean); + extern GtkWidget *gtk_radio_menu_item_new_with_label(GSList *, + const gchar *); + extern gboolean gtk_tree_view_column_get_reorderable(GtkTreeViewColumn + *); + extern GType gtk_icon_view_get_type(void); + extern void gtk_entry_set_visibility(GtkEntry *, gboolean); + extern const gchar *const + *gtk_about_dialog_get_documenters(GtkAboutDialog *); + extern GtkWidget *gtk_vruler_new(void); + extern void gtk_widget_set_parent_window(GtkWidget *, GdkWindow *); + extern GdkScreen *gtk_window_get_screen(GtkWindow *); + extern GType gtk_clipboard_get_type(void); + extern GType gtk_layout_get_type(void); + extern void gtk_tree_selection_unselect_path(GtkTreeSelection *, + GtkTreePath *); + extern GdkScreen *gtk_invisible_get_screen(GtkInvisible *); + extern void gtk_paint_tab(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint); + extern void gtk_button_set_alignment(GtkButton *, gfloat, gfloat); + extern void + gtk_file_chooser_button_set_width_chars(GtkFileChooserButton *, + gint); + extern void gtk_action_group_add_radio_actions_full(GtkActionGroup *, + const + GtkRadioActionEntry + *, guint, gint, + GCallback, + gpointer, + GDestroyNotify); + extern void gtk_alignment_set(GtkAlignment *, gfloat, gfloat, gfloat, + gfloat); + extern void gtk_container_set_resize_mode(GtkContainer *, + GtkResizeMode); + extern void gtk_notebook_set_show_tabs(GtkNotebook *, gboolean); + extern GtkWidget *gtk_grab_get_current(void); + extern GType gtk_tooltips_get_type(void); + extern GtkToolItem *gtk_tool_button_new_from_stock(const gchar *); + extern GtkWidget *gtk_color_button_new_with_color(const GdkColor *); + extern void gtk_arrow_set(GtkArrow *, GtkArrowType, GtkShadowType); + extern GtkTextTag *gtk_text_buffer_create_tag(GtkTextBuffer *, + const gchar *, + const gchar *, ...); + extern void gtk_icon_view_selected_foreach(GtkIconView *, + GtkIconViewForeachFunc, + gpointer); + extern gboolean gtk_icon_source_get_size_wildcarded(const GtkIconSource + *); + extern GQuark gtk_file_chooser_error_quark(void); + extern gboolean gtk_tooltips_get_info_from_tip_window(GtkWindow *, + GtkTooltips * *, + GtkWidget * *); + extern gboolean gtk_window_mnemonic_activate(GtkWindow *, guint, + GdkModifierType); + extern GtkWidget *gtk_hseparator_new(void); + extern const gchar *gtk_progress_bar_get_text(GtkProgressBar *); + extern void gtk_window_remove_embedded_xid(GtkWindow *, guint); + extern GtkWidget *gtk_menu_item_new(void); + extern void gtk_window_set_has_frame(GtkWindow *, gboolean); + extern void gtk_tree_model_filter_set_modify_func(GtkTreeModelFilter *, + gint, GType *, + GtkTreeModelFilterModifyFunc, + gpointer, + GtkDestroyNotify); + extern gboolean gtk_selection_convert(GtkWidget *, GdkAtom, GdkAtom, + guint32); + extern void gtk_text_buffer_get_end_iter(GtkTextBuffer *, + GtkTextIter *); + extern GType gtk_hbox_get_type(void); + extern void gtk_widget_set_accel_path(GtkWidget *, const gchar *, + GtkAccelGroup *); + extern void gtk_text_tag_set_priority(GtkTextTag *, gint); + extern void gtk_text_buffer_move_mark_by_name(GtkTextBuffer *, + const gchar *, + const GtkTextIter *); + extern void gtk_handle_box_set_handle_position(GtkHandleBox *, + GtkPositionType); + extern GtkWidget *gtk_cell_view_new_with_pixbuf(GdkPixbuf *); + extern void gtk_grab_remove(GtkWidget *); + extern void gtk_window_set_auto_startup_notification(gboolean); + extern GType gtk_orientation_get_type(void); + extern gint gtk_text_iter_get_line_index(const GtkTextIter *); + extern void gtk_text_buffer_get_bounds(GtkTextBuffer *, GtkTextIter *, + GtkTextIter *); + extern gboolean gtk_widget_is_focus(GtkWidget *); + extern gboolean gtk_check_menu_item_get_active(GtkCheckMenuItem *); + extern gint gtk_icon_view_get_item_width(GtkIconView *); + extern gboolean gtk_check_menu_item_get_draw_as_radio(GtkCheckMenuItem + *); + extern GtkClipboard *gtk_clipboard_get_for_display(GdkDisplay *, + GdkAtom); + extern void gtk_tree_iter_free(GtkTreeIter *); + extern void gtk_widget_unmap(GtkWidget *); + extern gboolean gtk_cell_renderer_activate(GtkCellRenderer *, + GdkEvent *, GtkWidget *, + const gchar *, + GdkRectangle *, + GdkRectangle *, + GtkCellRendererState); + extern GType gtk_settings_get_type(void); + extern GType gtk_aspect_frame_get_type(void); + extern GtkBindingSet *gtk_binding_set_by_class(gpointer); + extern void gtk_icon_source_set_pixbuf(GtkIconSource *, GdkPixbuf *); + extern void gtk_main_do_event(GdkEvent *); + extern GtkWidget *gtk_check_button_new(void); + extern gboolean gtk_rc_reparse_all(void); + extern GtkTreeStore *gtk_tree_store_newv(gint, GType *); + extern gboolean gtk_text_view_place_cursor_onscreen(GtkTextView *); + extern void gtk_box_set_spacing(GtkBox *, gint); + extern GType gtk_accel_map_get_type(void); + extern gboolean gtk_color_button_get_use_alpha(GtkColorButton *); + extern gboolean + gtk_text_iter_forward_visible_cursor_positions(GtkTextIter *, + gint); + extern void gtk_menu_item_set_accel_path(GtkMenuItem *, const gchar *); + extern gchar *gtk_combo_box_get_active_text(GtkComboBox *); + extern gboolean gtk_icon_info_get_attach_points(GtkIconInfo *, + GdkPoint * *, gint *); + extern void + gtk_entry_completion_set_minimum_key_length(GtkEntryCompletion *, + gint); + extern void gtk_text_view_set_buffer(GtkTextView *, GtkTextBuffer *); + extern void gtk_cell_layout_clear_attributes(GtkCellLayout *, + GtkCellRenderer *); + extern void gtk_toolbar_set_show_arrow(GtkToolbar *, gboolean); + extern GtkWidget + *gtk_file_chooser_widget_new_with_backend(GtkFileChooserAction, + const gchar *); + extern void gtk_text_buffer_insert_at_cursor(GtkTextBuffer *, + const gchar *, gint); + extern void gtk_tool_item_set_visible_vertical(GtkToolItem *, + gboolean); + extern void + gtk_cell_renderer_text_set_fixed_height_from_font + (GtkCellRendererText *, gint); + extern gboolean gtk_window_get_skip_pager_hint(GtkWindow *); + extern GType gtk_gamma_curve_get_type(void); + extern void + gtk_tree_model_filter_convert_child_iter_to_iter(GtkTreeModelFilter + *, GtkTreeIter *, + GtkTreeIter *); + extern void gtk_text_buffer_remove_tag_by_name(GtkTextBuffer *, + const gchar *, + const GtkTextIter *, + const GtkTextIter *); + extern gboolean gtk_file_chooser_set_filename(GtkFileChooser *, + const gchar *); + extern void gtk_about_dialog_set_logo_icon_name(GtkAboutDialog *, + const gchar *); + extern GdkPixbuf *gtk_image_get_pixbuf(GtkImage *); + extern GtkWidget *gtk_action_create_menu_item(GtkAction *); + extern GtkJustification gtk_label_get_justify(GtkLabel *); + extern void gtk_file_filter_set_name(GtkFileFilter *, const gchar *); + extern gboolean gtk_text_iter_forward_char(GtkTextIter *); + extern GtkWidget *gtk_radio_menu_item_new(GSList *); + extern void gtk_action_group_add_toggle_actions_full(GtkActionGroup *, + const + GtkToggleActionEntry + *, guint, + gpointer, + GDestroyNotify); + extern gboolean gtk_text_iter_is_start(const GtkTextIter *); + extern void gtk_cell_renderer_set_fixed_size(GtkCellRenderer *, gint, + gint); + extern void gtk_rc_set_default_files(gchar * *); + extern void gtk_tool_item_set_proxy_menu_item(GtkToolItem *, + const gchar *, + GtkWidget *); + extern void gtk_paint_check(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint); + extern void gtk_scrolled_window_set_policy(GtkScrolledWindow *, + GtkPolicyType, + GtkPolicyType); + extern GtkEntryCompletion *gtk_entry_completion_new(void); + extern guint gtk_rc_parse_state(GScanner *, GtkStateType *); + extern gint gtk_tree_view_get_search_column(GtkTreeView *); + extern void gtk_ui_manager_remove_action_group(GtkUIManager *, + GtkActionGroup *); + extern PangoEllipsizeMode gtk_label_get_ellipsize(GtkLabel *); + extern gboolean + gtk_file_chooser_get_preview_widget_active(GtkFileChooser *); + extern gboolean gtk_button_get_use_underline(GtkButton *); + extern void gtk_entry_set_activates_default(GtkEntry *, gboolean); + extern GtkStyle *gtk_rc_get_style(GtkWidget *); + extern GtkTreeViewColumn + *gtk_tree_view_column_new_with_attributes(const gchar *, + GtkCellRenderer *, ...); + extern gchar *gtk_file_chooser_get_filename(GtkFileChooser *); + extern GType gtk_font_button_get_type(void); + extern GtkAdjustment *gtk_spin_button_get_adjustment(GtkSpinButton *); + extern void + gtk_dialog_set_alternative_button_order_from_array(GtkDialog *, + gint, gint *); + extern void gtk_window_set_icon_name(GtkWindow *, const gchar *); + extern void gtk_ruler_get_range(GtkRuler *, gdouble *, gdouble *, + gdouble *, gdouble *); + extern void gtk_action_group_remove_action(GtkActionGroup *, + GtkAction *); + extern const char *gtk_text_mark_get_name(GtkTextMark *); + extern gboolean gtk_tool_button_get_use_underline(GtkToolButton *); + extern gboolean gtk_clipboard_wait_is_text_available(GtkClipboard *); + extern void gtk_label_set_single_line_mode(GtkLabel *, gboolean); + extern void gtk_label_set_width_chars(GtkLabel *, gint); + extern GType gtk_file_chooser_button_get_type(void); + extern void gtk_scrolled_window_set_hadjustment(GtkScrolledWindow *, + GtkAdjustment *); + extern void gtk_accel_map_lock_path(const gchar *); + extern void gtk_tree_sortable_set_sort_func(GtkTreeSortable *, gint, + GtkTreeIterCompareFunc, + gpointer, + GtkDestroyNotify); + extern gboolean gtk_icon_size_lookup_for_settings(GtkSettings *, + GtkIconSize, gint *, + gint *); + extern void gtk_tree_model_unref_node(GtkTreeModel *, GtkTreeIter *); + extern GtkWidget *gtk_menu_get_active(GtkMenu *); + extern GtkTextChildAnchor + *gtk_text_buffer_create_child_anchor(GtkTextBuffer *, + GtkTextIter *); + extern void gtk_file_chooser_set_extra_widget(GtkFileChooser *, + GtkWidget *); + extern GtkWidget *gtk_image_new_from_image(GdkImage *, GdkBitmap *); + extern GType gtk_fixed_get_type(void); + extern GtkWidget *gtk_scrolled_window_new(GtkAdjustment *, + GtkAdjustment *); + extern void gtk_about_dialog_set_copyright(GtkAboutDialog *, + const gchar *); + extern void gtk_target_list_add(GtkTargetList *, GdkAtom, guint, + guint); + extern GList *gtk_tree_view_get_columns(GtkTreeView *); + extern GtkIconSource *gtk_icon_source_new(void); + extern void gtk_check_menu_item_set_active(GtkCheckMenuItem *, + gboolean); + extern gboolean gtk_text_iter_forward_sentence_ends(GtkTextIter *, + gint); + extern GdkScreen *gtk_widget_get_screen(GtkWidget *); + extern GtkWidget *gtk_expander_new(const gchar *); + extern GtkWidget *gtk_spin_button_new(GtkAdjustment *, gdouble, guint); + extern void gtk_window_fullscreen(GtkWindow *); + extern void gtk_toolbar_set_tooltips(GtkToolbar *, gboolean); + extern void gtk_file_chooser_set_preview_widget(GtkFileChooser *, + GtkWidget *); + extern gboolean gtk_accel_group_activate(GtkAccelGroup *, GQuark, + GObject *, guint, + GdkModifierType); + extern gboolean gtk_tree_drag_source_drag_data_get(GtkTreeDragSource *, + GtkTreePath *, + GtkSelectionData *); + extern GtkTextDirection gtk_widget_get_direction(GtkWidget *); + extern gboolean gtk_text_iter_get_attributes(const GtkTextIter *, + GtkTextAttributes *); + extern gboolean gtk_editable_get_editable(GtkEditable *); + extern void gtk_widget_set_events(GtkWidget *, gint); + extern void gtk_paned_pack1(GtkPaned *, GtkWidget *, gboolean, + gboolean); + extern GType gtk_state_type_get_type(void); + extern gboolean gtk_text_iter_editable(const GtkTextIter *, gboolean); + extern gboolean gtk_tree_model_get_iter_from_string(GtkTreeModel *, + GtkTreeIter *, + const gchar *); + extern gboolean gtk_container_get_focus_chain(GtkContainer *, + GList * *); + extern void gtk_icon_view_set_margin(GtkIconView *, gint); + extern void gtk_tree_selection_unselect_range(GtkTreeSelection *, + GtkTreePath *, + GtkTreePath *); + extern gboolean gtk_widget_get_no_show_all(GtkWidget *); + extern GList *gtk_cell_view_get_cell_renderers(GtkCellView *); + extern gboolean gtk_clipboard_set_with_owner(GtkClipboard *, + const GtkTargetEntry *, + guint, + GtkClipboardGetFunc, + GtkClipboardClearFunc, + GObject *); + extern void gtk_tree_store_clear(GtkTreeStore *); + extern GType gtk_vscrollbar_get_type(void); + extern GType gtk_curve_type_get_type(void); + extern gboolean gtk_entry_get_has_frame(GtkEntry *); + extern GType gtk_dest_defaults_get_type(void); + extern GType gtk_window_position_get_type(void); + extern void gtk_tree_model_get_valist(GtkTreeModel *, GtkTreeIter *, + va_list); + extern GtkWidget *gtk_expander_new_with_mnemonic(const gchar *); + extern void gtk_viewport_set_shadow_type(GtkViewport *, GtkShadowType); + extern gint gtk_tree_view_insert_column_with_attributes(GtkTreeView *, + gint, + const gchar *, + GtkCellRenderer + *, ...); + extern GSList *gtk_file_chooser_list_shortcut_folders(GtkFileChooser + *); + extern GType gtk_drawing_area_get_type(void); + extern GtkOrientation gtk_toolbar_get_orientation(GtkToolbar *); + extern void gtk_tree_model_foreach(GtkTreeModel *, + GtkTreeModelForeachFunc, gpointer); + extern gboolean + gtk_color_selection_get_has_opacity_control(GtkColorSelection *); + extern gboolean gtk_tree_drag_dest_drag_data_received(GtkTreeDragDest + *, GtkTreePath *, + GtkSelectionData + *); + extern gboolean gtk_window_set_icon_from_file(GtkWindow *, + const gchar *, + GError * *); + extern void gtk_window_set_focus(GtkWindow *, GtkWidget *); + extern void gtk_button_set_use_stock(GtkButton *, gboolean); + extern void gtk_paint_arrow(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, GtkArrowType, gboolean, + gint, gint, gint, gint); + extern GtkWidget *gtk_hpaned_new(void); + extern void gtk_calendar_select_day(GtkCalendar *, guint); + extern void gtk_settings_set_property_value(GtkSettings *, + const gchar *, + const GtkSettingsValue *); + extern void gtk_toolbar_insert(GtkToolbar *, GtkToolItem *, gint); + extern void gtk_im_context_get_preedit_string(GtkIMContext *, + gchar * *, + PangoAttrList * *, + gint *); + extern void gtk_event_box_set_visible_window(GtkEventBox *, gboolean); + extern GType gtk_menu_item_get_type(void); + extern gboolean gtk_text_buffer_delete_interactive(GtkTextBuffer *, + GtkTextIter *, + GtkTextIter *, + gboolean); + extern void gtk_range_set_inverted(GtkRange *, gboolean); + extern void gtk_selection_add_targets(GtkWidget *, GdkAtom, + const GtkTargetEntry *, guint); + extern gchar *gtk_rc_get_theme_dir(void); + extern const gchar *gtk_action_get_name(GtkAction *); + extern gint gtk_tree_store_iter_depth(GtkTreeStore *, GtkTreeIter *); + extern void gtk_icon_view_set_markup_column(GtkIconView *, gint); + extern void gtk_scale_get_layout_offsets(GtkScale *, gint *, gint *); + extern GType gtk_bin_get_type(void); + extern long unsigned int gtk_object_get_type(void); + extern void gtk_tree_store_prepend(GtkTreeStore *, GtkTreeIter *, + GtkTreeIter *); + extern void gtk_list_store_insert_after(GtkListStore *, GtkTreeIter *, + GtkTreeIter *); + extern void gtk_im_context_focus_out(GtkIMContext *); + extern GtkBindingSet *gtk_binding_set_find(const gchar *); + extern const gchar *gtk_action_group_translate_string(GtkActionGroup *, + const gchar *); + extern gboolean gtk_window_get_decorated(GtkWindow *); + extern gboolean gtk_range_get_inverted(GtkRange *); + extern void gtk_widget_child_notify(GtkWidget *, const gchar *); + extern void gtk_text_view_set_right_margin(GtkTextView *, gint); + extern guint gtk_table_get_row_spacing(GtkTable *, guint); + extern GtkAction *gtk_action_new(const gchar *, const gchar *, + const gchar *, const gchar *); + extern void gtk_container_child_set_property(GtkContainer *, + GtkWidget *, + const gchar *, + const GValue *); + extern void + gtk_tree_model_filter_convert_iter_to_child_iter(GtkTreeModelFilter + *, GtkTreeIter *, + GtkTreeIter *); + extern void gtk_widget_reset_shapes(GtkWidget *); + extern GtkTextWindowType gtk_text_view_get_window_type(GtkTextView *, + GdkWindow *); + extern void gtk_text_view_set_editable(GtkTextView *, gboolean); + extern gint gtk_text_iter_get_offset(const GtkTextIter *); + extern GType gtk_plug_get_type(void); + extern void gtk_im_context_set_client_window(GtkIMContext *, + GdkWindow *); + extern void gtk_image_set_from_icon_name(GtkImage *, const gchar *, + GtkIconSize); + extern gboolean gtk_text_iter_forward_search(const GtkTextIter *, + const gchar *, + GtkTextSearchFlags, + GtkTextIter *, + GtkTextIter *, + const GtkTextIter *); + extern void gtk_tree_view_set_fixed_height_mode(GtkTreeView *, + gboolean); + extern GList *gtk_icon_view_get_selected_items(GtkIconView *); + extern void gtk_widget_hide_all(GtkWidget *); + extern void gtk_about_dialog_set_artists(GtkAboutDialog *, + const gchar * *); + extern void gtk_target_list_add_uri_targets(GtkTargetList *, guint); + extern GType gtk_scale_get_type(void); + extern gint gtk_text_tag_get_priority(GtkTextTag *); + extern void gtk_tree_selection_set_mode(GtkTreeSelection *, + GtkSelectionMode); + extern GType gtk_text_direction_get_type(void); + extern GType gtk_accessible_get_type(void); + extern void gtk_window_get_frame_dimensions(GtkWindow *, gint *, + gint *, gint *, gint *); + extern GType gtk_tool_button_get_type(void); + extern gboolean gtk_text_iter_backward_visible_word_starts(GtkTextIter + *, gint); + extern void gtk_container_add_with_properties(GtkContainer *, + GtkWidget *, + const gchar *, ...); + extern void gtk_spin_button_set_snap_to_ticks(GtkSpinButton *, + gboolean); + extern GtkClipboard *gtk_clipboard_get(GdkAtom); + extern GtkWrapMode gtk_text_view_get_wrap_mode(GtkTextView *); + extern GType gtk_menu_tool_button_get_type(void); + extern const gchar *gtk_tree_view_column_get_title(GtkTreeViewColumn + *); + extern GType gtk_window_type_get_type(void); + extern void gtk_widget_reset_rc_styles(GtkWidget *); + extern GList *gtk_action_group_list_actions(GtkActionGroup *); + extern void gtk_list_store_prepend(GtkListStore *, GtkTreeIter *); + extern GType gtk_hscale_get_type(void); + extern void gtk_binding_set_add_path(GtkBindingSet *, GtkPathType, + const gchar *, + GtkPathPriorityType); + extern void gtk_paint_diamond(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, + GtkWidget *, const gchar *, gint, gint, + gint, gint); + extern void gtk_tool_item_set_visible_horizontal(GtkToolItem *, + gboolean); + extern GType gtk_object_flags_get_type(void); + extern const gchar *gtk_about_dialog_get_website(GtkAboutDialog *); + extern GtkBorder *gtk_border_copy(const GtkBorder *); + extern gboolean gtk_spin_button_get_numeric(GtkSpinButton *); + extern gint gtk_label_get_max_width_chars(GtkLabel *); + extern gboolean gtk_tree_view_get_hover_selection(GtkTreeView *); + extern GType gtk_dialog_flags_get_type(void); + extern GType gtk_cell_view_get_type(void); + extern GtkWidget *gtk_image_menu_item_new_from_stock(const gchar *, + GtkAccelGroup *); + extern void gtk_icon_view_set_spacing(GtkIconView *, gint); + extern void gtk_paint_box(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, GtkWidget *, + const gchar *, gint, gint, gint, gint); + extern void + gtk_entry_completion_set_popup_completion(GtkEntryCompletion *, + gboolean); + extern void gtk_toolbar_set_orientation(GtkToolbar *, GtkOrientation); + extern void gtk_drag_source_set_target_list(GtkWidget *, + GtkTargetList *); + extern void gtk_settings_install_property_parser(GParamSpec *, + GtkRcPropertyParser); + extern void gtk_file_chooser_set_show_hidden(GtkFileChooser *, + gboolean); + extern gboolean gtk_icon_source_get_direction_wildcarded(const + GtkIconSource + *); + extern void gtk_spin_button_configure(GtkSpinButton *, GtkAdjustment *, + gdouble, guint); + extern void gtk_notebook_next_page(GtkNotebook *); + extern void gtk_icon_view_set_column_spacing(GtkIconView *, gint); + extern GSList *gtk_file_chooser_list_filters(GtkFileChooser *); + extern void gtk_fixed_move(GtkFixed *, GtkWidget *, gint, gint); + extern GtkAccelMap *gtk_accel_map_get(void); + extern GType gtk_vscale_get_type(void); + extern void gtk_about_dialog_set_logo(GtkAboutDialog *, GdkPixbuf *); + extern gint gtk_text_iter_get_line(const GtkTextIter *); + extern GtkToolItem *gtk_toggle_tool_button_new_from_stock(const gchar + *); + extern gboolean gtk_tree_model_get_iter_first(GtkTreeModel *, + GtkTreeIter *); + extern PangoAttrList *gtk_label_get_attributes(GtkLabel *); + extern GtkWidget *gtk_image_new_from_icon_name(const gchar *, + GtkIconSize); + extern AtkObject *gtk_widget_get_accessible(GtkWidget *); + extern GType gtk_metric_type_get_type(void); + extern GtkToolItem *gtk_menu_tool_button_new(GtkWidget *, + const gchar *); + extern void gtk_scale_set_digits(GtkScale *, gint); + extern void gtk_label_set_text(GtkLabel *, const gchar *); + extern GtkWidget *gtk_notebook_get_menu_label(GtkNotebook *, + GtkWidget *); + extern GtkIMContext *gtk_im_context_simple_new(void); + extern GtkIconSet *gtk_icon_set_copy(GtkIconSet *); + extern GtkRcStyle *gtk_rc_style_copy(GtkRcStyle *); + extern void gtk_text_buffer_remove_tag(GtkTextBuffer *, GtkTextTag *, + const GtkTextIter *, + const GtkTextIter *); + extern GType gtk_tree_view_drop_position_get_type(void); + extern GType gtk_match_type_get_type(void); + extern GType gtk_toolbar_space_style_get_type(void); + extern GtkAdjustment *gtk_container_get_focus_vadjustment(GtkContainer + *); + extern gboolean gtk_widget_translate_coordinates(GtkWidget *, + GtkWidget *, gint, + gint, gint *, gint *); + extern void gtk_label_set_label(GtkLabel *, const gchar *); + extern void gtk_entry_set_alignment(GtkEntry *, gfloat); + extern GtkTextChildAnchor *gtk_text_iter_get_child_anchor(const + GtkTextIter + *); + extern void gtk_tree_view_unset_rows_drag_dest(GtkTreeView *); + extern GdkVisual *gtk_widget_get_default_visual(void); + extern void gtk_drag_dest_set_proxy(GtkWidget *, GdkWindow *, + GdkDragProtocol, gboolean); + extern void gtk_entry_set_max_length(GtkEntry *, gint); + extern GType gtk_vseparator_get_type(void); + extern void gtk_tree_view_set_vadjustment(GtkTreeView *, + GtkAdjustment *); + extern GtkSelectionData *gtk_selection_data_copy(GtkSelectionData *); + extern void gtk_list_store_reorder(GtkListStore *, gint *); + extern void gtk_accel_map_load_scanner(GScanner *); + extern void gtk_tree_view_set_hover_expand(GtkTreeView *, gboolean); + extern void gtk_table_set_col_spacings(GtkTable *, guint); + extern void gtk_widget_queue_draw_area(GtkWidget *, gint, gint, gint, + gint); + extern GtkTreeModel *gtk_icon_view_get_model(GtkIconView *); + extern void gtk_tree_view_set_reorderable(GtkTreeView *, gboolean); + extern GtkTextMark *gtk_text_buffer_get_insert(GtkTextBuffer *); + extern const gchar *gtk_action_get_accel_path(GtkAction *); + extern GtkWidget *gtk_entry_new(void); + extern void gtk_tree_view_expand_to_path(GtkTreeView *, GtkTreePath *); + extern void gtk_paint_polygon(GtkStyle *, GdkWindow *, GtkStateType, + GtkShadowType, GdkRectangle *, + GtkWidget *, const gchar *, GdkPoint *, + gint, gboolean); + extern gboolean gtk_init_check(int *, char ***); + extern gboolean gtk_tool_item_get_visible_vertical(GtkToolItem *); + extern gint gtk_text_iter_get_visible_line_offset(const GtkTextIter *); + extern gboolean gtk_spin_button_get_snap_to_ticks(GtkSpinButton *); + extern gboolean gtk_text_iter_forward_line(GtkTextIter *); + extern GType gtk_tree_view_column_get_type(void); + extern GType gtk_direction_type_get_type(void); + extern void gtk_tree_view_set_hover_selection(GtkTreeView *, gboolean); + extern void gtk_tree_view_set_expander_column(GtkTreeView *, + GtkTreeViewColumn *); + extern GType gtk_cell_renderer_combo_get_type(void); + extern void gtk_toggle_button_set_inconsistent(GtkToggleButton *, + gboolean); + extern GtkWidget *gtk_menu_get_attach_widget(GtkMenu *); + extern gboolean gtk_tree_model_iter_children(GtkTreeModel *, + GtkTreeIter *, + GtkTreeIter *); + extern GdkPixbuf *gtk_window_get_icon(GtkWindow *); + extern GdkDragContext *gtk_drag_begin(GtkWidget *, GtkTargetList *, + GdkDragAction, gint, GdkEvent *); + extern void gtk_init(int *, char ***); + extern gchar *gtk_color_selection_palette_to_string(const GdkColor *, + gint); + extern void gtk_container_child_set_valist(GtkContainer *, GtkWidget *, + const gchar *, va_list); + extern void gtk_paint_focus(GtkStyle *, GdkWindow *, GtkStateType, + GdkRectangle *, GtkWidget *, const gchar *, + gint, gint, gint, gint); + extern GtkUpdateType gtk_range_get_update_policy(GtkRange *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/limits.h b/lsb-build/headers/limits.h new file mode 100644 index 0000000..41ae207 --- /dev/null +++ b/lsb-build/headers/limits.h @@ -0,0 +1,168 @@ +#ifndef _LIMITS_H_ +#define _LIMITS_H_ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#define LLONG_MIN (-LLONG_MAX-1LL) +#if __ia64__ +#define LONG_MAX 0x7FFFFFFFFFFFFFFFL +#endif +#if __x86_64__ +#define LONG_MAX 0x7FFFFFFFFFFFFFFFL +#endif +#if __i386__ +#define LONG_MAX 0x7FFFFFFFL +#endif +#if __ia64__ +#define ULONG_MAX 0xFFFFFFFFFFFFFFFFUL +#endif +#if __powerpc64__ +#define ULONG_MAX 0xFFFFFFFFFFFFFFFFUL +#endif +#if __x86_64__ +#define ULONG_MAX 0xFFFFFFFFFFFFFFFFUL +#endif +#if __s390x__ +#define ULONG_MAX 0xFFFFFFFFFFFFFFFFUL +#endif +#if __i386__ +#define ULONG_MAX 0xFFFFFFFFUL +#endif +#if __powerpc__ && !__powerpc64__ +#define ULONG_MAX 0xFFFFFFFFUL +#endif +#if __s390__ && !__s390x__ +#define ULONG_MAX 0xFFFFFFFFUL +#endif +#define ULLONG_MAX 18446744073709551615ULL +#if __s390__ && !__s390x__ +#define LONG_MAX 2147483647 +#endif +#if __powerpc__ && !__powerpc64__ +#define LONG_MAX 2147483647L +#endif +#define OPEN_MAX 256 +#define NGROUPS_MAX 32 +#define PATH_MAX 4096 +#if __powerpc64__ +#define LONG_MAX 9223372036854775807L +#endif +#if __s390x__ +#define LONG_MAX 9223372036854775807L +#endif +#define LLONG_MAX 9223372036854775807LL +#define SSIZE_MAX LONG_MAX + + + +/* Maximum length of any multibyte character in any locale.*/ +#define MB_LEN_MAX 16 + + + +/* Number of bits in a `char'.*/ +#define SCHAR_MIN (-128) +#if __powerpc__ && !__powerpc64__ +#define CHAR_MIN 0 +#endif +#if __powerpc64__ +#define CHAR_MIN 0 +#endif +#if __s390__ && !__s390x__ +#define CHAR_MIN 0 +#endif +#if __s390x__ +#define CHAR_MIN 0 +#endif +#if __x86_64__ +#define CHAR_MAX 127 +#endif +#define SCHAR_MAX 127 +#if __powerpc__ && !__powerpc64__ +#define CHAR_MAX 255 +#endif +#if __powerpc64__ +#define CHAR_MAX 255 +#endif +#if __s390__ && !__s390x__ +#define CHAR_MAX 255 +#endif +#if __s390x__ +#define CHAR_MAX 255 +#endif +#define UCHAR_MAX 255 +#define CHAR_BIT 8 +#if __i386__ +#define CHAR_MAX SCHAR_MAX +#endif +#if __ia64__ +#define CHAR_MAX SCHAR_MAX +#endif +#if __i386__ +#define CHAR_MIN SCHAR_MIN +#endif +#if __ia64__ +#define CHAR_MIN SCHAR_MIN +#endif +#if __x86_64__ +#define CHAR_MIN SCHAR_MIN +#endif + + + +/* Minimum and maximum values a `signed short int' can hold.*/ +#define SHRT_MIN (-32768) +#define SHRT_MAX 32767 +#define USHRT_MAX 65535 + + + +/* Minimum and maximum values a `int' can hold.*/ +#define INT_MIN (-INT_MAX-1) +#define INT_MAX 2147483647 +#define __INT_MAX__ 2147483647 +#define UINT_MAX 4294967295U + + + +/* Minimum and maximum values a `long int' can hold.*/ +#define LONG_MIN (-LONG_MAX-1L) + + + +/* POSIX Threads values*/ +#define PTHREAD_KEYS_MAX 1024 +#if __i386__ +#define PTHREAD_STACK_MIN 16384 +#endif +#if __powerpc__ && !__powerpc64__ +#define PTHREAD_STACK_MIN 16384 +#endif +#if __powerpc64__ +#define PTHREAD_STACK_MIN 16384 +#endif +#if __s390__ && !__s390x__ +#define PTHREAD_STACK_MIN 16384 +#endif +#if __x86_64__ +#define PTHREAD_STACK_MIN 16384 +#endif +#if __s390x__ +#define PTHREAD_STACK_MIN 16384 +#endif +#define PTHREAD_THREADS_MAX 16384 +#if __ia64__ +#define PTHREAD_STACK_MIN 196608 +#endif +#define PTHREAD_DESTRUCTOR_ITERATIONS 4 + + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/pango-1.0/pango/pango-utils.h b/lsb-build/headers/pango-1.0/pango/pango-utils.h new file mode 100644 index 0000000..f45c1c6 --- /dev/null +++ b/lsb-build/headers/pango-1.0/pango/pango-utils.h @@ -0,0 +1,38 @@ +#ifndef _PANGO_1_0_PANGO_PANGO_UTILS_H_ +#define _PANGO_1_0_PANGO_PANGO_UTILS_H_ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + + + + + extern char *pango_trim_string(const char *); + extern gboolean pango_scan_word(const char **, GString *); + extern gboolean pango_skip_space(const char **); + extern gboolean pango_parse_stretch(const char *, PangoStretch *, + gboolean); + extern gboolean pango_scan_int(const char **, int *); + extern gboolean pango_parse_weight(const char *, PangoWeight *, + gboolean); + extern gint pango_read_line(FILE *, GString *); + extern gboolean pango_log2vis_get_embedding_levels(gunichar *, gint, + PangoDirection *, + guint8 *); + extern const char *pango_language_get_sample_string(PangoLanguage *); + extern gboolean pango_parse_style(const char *, PangoStyle *, + gboolean); + extern gboolean pango_scan_string(const char **, GString *); + extern gboolean pango_parse_variant(const char *, PangoVariant *, + gboolean); + extern char **pango_split_file_list(const char *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/pango-1.0/pango/pango.h b/lsb-build/headers/pango-1.0/pango/pango.h new file mode 100644 index 0000000..69cd179 --- /dev/null +++ b/lsb-build/headers/pango-1.0/pango/pango.h @@ -0,0 +1,1167 @@ +#ifndef _PANGO_1_0_PANGO_PANGO_H_ +#define _PANGO_1_0_PANGO_PANGO_H_ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define PANGO_CONTEXT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_CONTEXT, \ + PangoContextClass)) +#define PANGO_LAYOUT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_LAYOUT, \ + PangoLayoutClass)) +#define PANGO_RENDERER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_RENDERER, \ + PangoRendererClass)) +#define PANGO_IS_CONTEXT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_CONTEXT)) +#define PANGO_IS_LAYOUT_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_LAYOUT)) +#define PANGO_IS_RENDERER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_RENDERER)) +#define PANGO_CONTEXT(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_CONTEXT, \ + PangoContext)) +#define PANGO_FONT(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT, PangoFont)) +#define PANGO_FONTSET(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONTSET, \ + PangoFontset)) +#define PANGO_FONT_FACE(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FACE, \ + PangoFontFace)) +#define PANGO_FONT_FAMILY(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FAMILY, \ + PangoFontFamily)) +#define PANGO_FONT_MAP(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_MAP, \ + PangoFontMap)) +#define PANGO_LAYOUT(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_LAYOUT, \ + PangoLayout)) +#define PANGO_RENDERER(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_RENDERER, \ + PangoRenderer)) +#define PANGO_IS_CONTEXT(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_CONTEXT)) +#define PANGO_IS_FONT(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT)) +#define PANGO_IS_FONTSET(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONTSET)) +#define PANGO_IS_FONT_FACE(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FACE)) +#define PANGO_IS_FONT_FAMILY(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FAMILY)) +#define PANGO_IS_FONT_MAP(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_MAP)) +#define PANGO_IS_LAYOUT(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_LAYOUT)) +#define PANGO_IS_RENDERER(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_RENDERER)) +#define PANGO_CONTEXT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_CONTEXT, \ + PangoContextClass)) +#define PANGO_LAYOUT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_LAYOUT, \ + PangoLayoutClass)) +#define PANGO_RENDERER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_RENDERER, \ + PangoRendererClass)) +#define PANGO_PIXELS(d) (((int)(d) + 512) >> 10) +#define pango_language_to_string(language) ((const char *)language) +#define PANGO_SCALE_XX_SMALL ((double)0.5787037037037) +#define PANGO_SCALE_X_SMALL ((double)0.6444444444444) +#define PANGO_SCALE_SMALL ((double)0.8333333333333) +#define PANGO_SCALE_MEDIUM ((double)1.0) +#define PANGO_SCALE_LARGE ((double)1.2) +#define PANGO_SCALE_X_LARGE ((double)1.4399999999999) +#define PANGO_SCALE_XX_LARGE ((double)1.728) +#define PANGO_RBEARING(rect) ((rect).x + (rect).width) +#define PANGO_LBEARING(rect) ((rect).x) +#define PANGO_DESCENT(rect) ((rect).y + (rect).height) +#define PANGO_ASCENT(rect) (-(rect).y) +#define PANGO_TYPE_ALIGNMENT (pango_alignment_get_type()) +#define PANGO_TYPE_ATTR_TYPE (pango_attr_type_get_type()) +#define PANGO_TYPE_CONTEXT (pango_context_get_type ()) +#define PANGO_TYPE_COVERAGE_LEVEL (pango_coverage_level_get_type()) +#define PANGO_TYPE_DIRECTION (pango_direction_get_type()) +#define PANGO_TYPE_ELLIPSIZE_MODE (pango_ellipsize_mode_get_type()) +#define PANGO_TYPE_FONTSET (pango_fontset_get_type ()) +#define PANGO_TYPE_FONT_DESCRIPTION (pango_font_description_get_type ()) +#define PANGO_TYPE_FONT_FACE (pango_font_face_get_type ()) +#define PANGO_TYPE_FONT_FAMILY (pango_font_family_get_type ()) +#define PANGO_TYPE_FONT (pango_font_get_type ()) +#define PANGO_TYPE_FONT_MAP (pango_font_map_get_type ()) +#define PANGO_TYPE_FONT_MASK (pango_font_mask_get_type()) +#define PANGO_TYPE_FONT_METRICS (pango_font_metrics_get_type ()) +#define PANGO_TYPE_GLYPH_STRING (pango_glyph_string_get_type ()) +#define PANGO_TYPE_LANGUAGE (pango_language_get_type ()) +#define PANGO_TYPE_LAYOUT (pango_layout_get_type ()) +#define PANGO_TYPE_LAYOUT_ITER (pango_layout_iter_get_type ()) +#define PANGO_TYPE_MATRIX (pango_matrix_get_type ()) +#define PANGO_TYPE_RENDERER (pango_renderer_get_type()) +#define PANGO_TYPE_RENDER_PART (pango_render_part_get_type()) +#define PANGO_TYPE_SCRIPT (pango_script_get_type()) +#define PANGO_TYPE_STRETCH (pango_stretch_get_type()) +#define PANGO_TYPE_STYLE (pango_style_get_type()) +#define PANGO_TYPE_TAB_ALIGN (pango_tab_align_get_type()) +#define PANGO_TYPE_TAB_ARRAY (pango_tab_array_get_type ()) +#define PANGO_TYPE_UNDERLINE (pango_underline_get_type()) +#define PANGO_TYPE_VARIANT (pango_variant_get_type()) +#define PANGO_TYPE_WEIGHT (pango_weight_get_type()) +#define PANGO_TYPE_WRAP_MODE (pango_wrap_mode_get_type()) +#define PANGO_SCALE 1024 +#define PANGO_TYPE_ATTR_LIST pango_attr_list_get_type () +#define PANGO_TYPE_COLOR pango_color_get_type () +#define PANGO_MATRIX_INIT { 1., 0., 0., 1., 0., 0. } + + + typedef struct _PangoFontFace PangoFontFace; + + typedef enum { + PANGO_WRAP_WORD = 0, + PANGO_WRAP_CHAR = 1, + PANGO_WRAP_WORD_CHAR = 2 + } PangoWrapMode; + + typedef struct _PangoLayout PangoLayout; + + typedef struct _PangoScriptIter PangoScriptIter; + + typedef enum { + PANGO_SCRIPT_INVALID_CODE = -1, + PANGO_SCRIPT_COMMON = 0, + PANGO_SCRIPT_INHERITED = 1, + PANGO_SCRIPT_ARABIC = 2, + PANGO_SCRIPT_ARMENIAN = 3, + PANGO_SCRIPT_BENGALI = 4, + PANGO_SCRIPT_BOPOMOFO = 5, + PANGO_SCRIPT_CHEROKEE = 6, + PANGO_SCRIPT_COPTIC = 7, + PANGO_SCRIPT_CYRILLIC = 8, + PANGO_SCRIPT_DESERET = 9, + PANGO_SCRIPT_DEVANAGARI = 10, + PANGO_SCRIPT_ETHIOPIC = 11, + PANGO_SCRIPT_GEORGIAN = 12, + PANGO_SCRIPT_GOTHIC = 13, + PANGO_SCRIPT_GREEK = 14, + PANGO_SCRIPT_GUJARATI = 15, + PANGO_SCRIPT_GURMUKHI = 16, + PANGO_SCRIPT_HAN = 17, + PANGO_SCRIPT_HANGUL = 18, + PANGO_SCRIPT_HEBREW = 19, + PANGO_SCRIPT_HIRAGANA = 20, + PANGO_SCRIPT_KANNADA = 21, + PANGO_SCRIPT_KATAKANA = 22, + PANGO_SCRIPT_KHMER = 23, + PANGO_SCRIPT_LAO = 24, + PANGO_SCRIPT_LATIN = 25, + PANGO_SCRIPT_MALAYALAM = 26, + PANGO_SCRIPT_MONGOLIAN = 27, + PANGO_SCRIPT_MYANMAR = 28, + PANGO_SCRIPT_OGHAM = 29, + PANGO_SCRIPT_OLD_ITALIC = 30, + PANGO_SCRIPT_ORIYA = 31, + PANGO_SCRIPT_RUNIC = 32, + PANGO_SCRIPT_SINHALA = 33, + PANGO_SCRIPT_SYRIAC = 34, + PANGO_SCRIPT_TAMIL = 35, + PANGO_SCRIPT_TELUGU = 36, + PANGO_SCRIPT_THAANA = 37, + PANGO_SCRIPT_THAI = 38, + PANGO_SCRIPT_TIBETAN = 39, + PANGO_SCRIPT_CANADIAN_ABORIGINAL = 40, + PANGO_SCRIPT_YI = 41, + PANGO_SCRIPT_TAGALOG = 42, + PANGO_SCRIPT_HANUNOO = 43, + PANGO_SCRIPT_BUHID = 44, + PANGO_SCRIPT_TAGBANWA = 45, + PANGO_SCRIPT_BRAILLE = 46, + PANGO_SCRIPT_CYPRIOT = 47, + PANGO_SCRIPT_LIMBU = 48, + PANGO_SCRIPT_OSMANYA = 49, + PANGO_SCRIPT_SHAVIAN = 50, + PANGO_SCRIPT_LINEAR_B = 51, + PANGO_SCRIPT_TAI_LE = 52, + PANGO_SCRIPT_UGARITIC = 53 + } PangoScript; + + typedef struct _PangoFont PangoFont; + + typedef struct _PangoContext PangoContext; + + typedef struct _PangoFontDescription PangoFontDescription; + + typedef enum { + PANGO_ATTR_INVALID = 0, + PANGO_ATTR_LANGUAGE = 1, + PANGO_ATTR_FAMILY = 2, + PANGO_ATTR_STYLE = 3, + PANGO_ATTR_WEIGHT = 4, + PANGO_ATTR_VARIANT = 5, + PANGO_ATTR_STRETCH = 6, + PANGO_ATTR_SIZE = 7, + PANGO_ATTR_FONT_DESC = 8, + PANGO_ATTR_FOREGROUND = 9, + PANGO_ATTR_BACKGROUND = 10, + PANGO_ATTR_UNDERLINE = 11, + PANGO_ATTR_STRIKETHROUGH = 12, + PANGO_ATTR_RISE = 13, + PANGO_ATTR_SHAPE = 14, + PANGO_ATTR_SCALE = 15, + PANGO_ATTR_FALLBACK = 16, + PANGO_ATTR_LETTER_SPACING = 17, + PANGO_ATTR_UNDERLINE_COLOR = 18, + PANGO_ATTR_STRIKETHROUGH_COLOR = 19, + PANGO_ATTR_ABSOLUTE_SIZE = 20 + } PangoAttrType; + + typedef struct _PangoAttribute PangoAttribute; + + typedef struct _PangoAttrClass PangoAttrClass; + + typedef struct _PangoLanguage PangoLanguage; + + typedef struct _PangoLogAttr PangoLogAttr; + + typedef struct _PangoColor PangoColor; + + typedef struct _PangoMatrix PangoMatrix; + + typedef struct _PangoEngineShape PangoEngineShape; + + typedef struct _PangoEngineLang PangoEngineLang; + + typedef struct _PangoAnalysis PangoAnalysis; + + typedef struct _PangoItem PangoItem; + + typedef guint32 PangoGlyph; + + typedef gint32 PangoGlyphUnit; + + typedef struct _PangoGlyphGeometry PangoGlyphGeometry; + + typedef struct _PangoGlyphVisAttr PangoGlyphVisAttr; + + typedef struct _PangoGlyphInfo PangoGlyphInfo; + + typedef struct _PangoGlyphString PangoGlyphString; + + typedef struct _PangoGlyphItem PangoGlyphItem; + + typedef PangoGlyphItem PangoLayoutRun; + + typedef struct _PangoLayoutIter PangoLayoutIter; + + typedef enum { + PANGO_UNDERLINE_NONE = 0, + PANGO_UNDERLINE_SINGLE = 1, + PANGO_UNDERLINE_DOUBLE = 2, + PANGO_UNDERLINE_LOW = 3, + PANGO_UNDERLINE_ERROR = 4 + } PangoUnderline; + + typedef struct _PangoRendererPrivate PangoRendererPrivate; + + typedef struct _PangoRenderer PangoRenderer; + + typedef enum { + PANGO_RENDER_PART_FOREGROUND = 0, + PANGO_RENDER_PART_BACKGROUND = 1, + PANGO_RENDER_PART_UNDERLINE = 2, + PANGO_RENDER_PART_STRIKETHROUGH = 3 + } PangoRenderPart; + + typedef struct _PangoAttrList PangoAttrList; + + typedef struct _PangoLayoutLine PangoLayoutLine; + + typedef enum { + PANGO_STRETCH_ULTRA_CONDENSED = 0, + PANGO_STRETCH_EXTRA_CONDENSED = 1, + PANGO_STRETCH_CONDENSED = 2, + PANGO_STRETCH_SEMI_CONDENSED = 3, + PANGO_STRETCH_NORMAL = 4, + PANGO_STRETCH_SEMI_EXPANDED = 5, + PANGO_STRETCH_EXPANDED = 6, + PANGO_STRETCH_EXTRA_EXPANDED = 7, + PANGO_STRETCH_ULTRA_EXPANDED = 8 + } PangoStretch; + + typedef struct _PangoRectangle PangoRectangle; + + typedef struct _PangoFontFamily PangoFontFamily; + + typedef struct _PangoFontMetrics PangoFontMetrics; + + typedef struct _PangoTabArray PangoTabArray; + + typedef enum { + PANGO_TAB_LEFT = 0 + } PangoTabAlign; + + typedef enum { + PANGO_ALIGN_LEFT = 0, + PANGO_ALIGN_CENTER = 1, + PANGO_ALIGN_RIGHT = 2 + } PangoAlignment; + + typedef struct _PangoAttrIterator PangoAttrIterator; + + typedef enum { + PANGO_FONT_MASK_FAMILY = 1, + PANGO_FONT_MASK_STYLE = 2, + PANGO_FONT_MASK_VARIANT = 4, + PANGO_FONT_MASK_WEIGHT = 8, + PANGO_FONT_MASK_STRETCH = 16, + PANGO_FONT_MASK_SIZE = 32 + } PangoFontMask; + + typedef enum { + PANGO_DIRECTION_LTR = 0, + PANGO_DIRECTION_RTL = 1, + PANGO_DIRECTION_TTB_LTR = 2, + PANGO_DIRECTION_TTB_RTL = 3, + PANGO_DIRECTION_WEAK_LTR = 4, + PANGO_DIRECTION_WEAK_RTL = 5, + PANGO_DIRECTION_NEUTRAL = 6 + } PangoDirection; + + typedef enum { + PANGO_ELLIPSIZE_NONE = 0, + PANGO_ELLIPSIZE_START = 1, + PANGO_ELLIPSIZE_MIDDLE = 2, + PANGO_ELLIPSIZE_END = 3 + } PangoEllipsizeMode; + + typedef struct _PangoCoverage PangoCoverage; + + typedef enum { + PANGO_STYLE_NORMAL = 0, + PANGO_STYLE_OBLIQUE = 1, + PANGO_STYLE_ITALIC = 2 + } PangoStyle; + + typedef enum { + PANGO_COVERAGE_NONE = 0, + PANGO_COVERAGE_FALLBACK = 1, + PANGO_COVERAGE_APPROXIMATE = 2, + PANGO_COVERAGE_EXACT = 3 + } PangoCoverageLevel; + + typedef struct _PangoFontMap PangoFontMap; + + typedef gboolean(*PangoAttrFilterFunc) (PangoAttribute *, gpointer); + + typedef struct _PangoFontset PangoFontset; + + typedef enum { + PANGO_WEIGHT_ULTRALIGHT = 200, + PANGO_WEIGHT_LIGHT = 300, + PANGO_WEIGHT_NORMAL = 400, + PANGO_WEIGHT_SEMIBOLD = 600, + PANGO_WEIGHT_BOLD = 700, + PANGO_WEIGHT_ULTRABOLD = 800, + PANGO_WEIGHT_HEAVY = 900 + } PangoWeight; + + typedef gboolean(*PangoFontsetForeachFunc) (PangoFontset *, + PangoFont *, gpointer); + + typedef enum { + PANGO_VARIANT_NORMAL = 0, + PANGO_VARIANT_SMALL_CAPS = 1 + } PangoVariant; + + typedef gpointer(*PangoAttrDataCopyFunc) (gconstpointer); + + typedef struct _PangoAttrShape PangoAttrShape; + + typedef struct _PangoContextClass PangoContextClass; + + typedef struct _PangoAttrString PangoAttrString; + + typedef struct _PangoAttrColor PangoAttrColor; + + typedef struct _PangoAttrFontDesc PangoAttrFontDesc; + + typedef struct _PangoAttrFloat PangoAttrFloat; + + typedef struct _PangoRendererClass PangoRendererClass; + + typedef struct _PangoAttrLanguage PangoAttrLanguage; + + typedef struct _PangoAttrInt PangoAttrInt; + + typedef struct _PangoAttrSize PangoAttrSize; + + typedef struct _PangoLayoutClass PangoLayoutClass; + + + + + + + + + + + + + + + + + + + + + struct _PangoAttribute { + const PangoAttrClass *klass; + guint start_index; + guint end_index; + }; + + + struct _PangoAttrClass { + PangoAttrType type; + PangoAttribute *(*copy) (const PangoAttribute *); + void (*destroy) (PangoAttribute *); + gboolean(*equal) (const PangoAttribute *, const PangoAttribute *); + }; + + + + + + struct _PangoLogAttr { + guint is_line_break:1; + guint is_mandatory_break:1; + guint is_char_break:1; + guint is_white:1; + guint is_cursor_position:1; + guint is_word_start:1; + guint is_word_end:1; + guint is_sentence_boundary:1; + guint is_sentence_start:1; + guint is_sentence_end:1; + guint backspace_deletes_character:1; + }; + + + struct _PangoColor { + guint16 red; + guint16 green; + guint16 blue; + }; + + + struct _PangoMatrix { + double xx; + double xy; + double yx; + double yy; + double x0; + double y0; + }; + + + + + + + + + struct _PangoAnalysis { + PangoEngineShape *shape_engine; + PangoEngineLang *lang_engine; + PangoFont *font; + guint8 level; + PangoLanguage *language; + GSList *extra_attrs; + }; + + + struct _PangoItem { + gint offset; + gint length; + gint num_chars; + PangoAnalysis analysis; + }; + + + struct _PangoGlyphGeometry { + PangoGlyphUnit width; + PangoGlyphUnit x_offset; + PangoGlyphUnit y_offset; + }; + + + struct _PangoGlyphVisAttr { + guint is_cluster_start:1; + }; + + + struct _PangoGlyphInfo { + PangoGlyph glyph; + PangoGlyphGeometry geometry; + PangoGlyphVisAttr attr; + }; + + + struct _PangoGlyphString { + gint num_glyphs; + PangoGlyphInfo *glyphs; + gint *log_clusters; + gint space; + }; + + + struct _PangoGlyphItem { + PangoItem *item; + PangoGlyphString *glyphs; + }; + + + + + + + + + struct _PangoRenderer { + GObject parent_instance; + PangoUnderline underline; + gboolean strikethrough; + int active_count; + PangoMatrix *matrix; + PangoRendererPrivate *priv; + }; + + + + + + struct _PangoLayoutLine { + PangoLayout *layout; + gint start_index; + gint length; + GSList *runs; + guint is_paragraph_start:1; + guint resolved_dir:3; + }; + + + struct _PangoRectangle { + int x; + int y; + int width; + int height; + }; + + + + + + + + + + + + + + + + + + + + + + + + struct _PangoAttrShape { + PangoAttribute attr; + PangoRectangle ink_rect; + PangoRectangle logical_rect; + gpointer data; + PangoAttrDataCopyFunc copy_func; + GDestroyNotify destroy_func; + }; + + + + + + struct _PangoAttrString { + PangoAttribute attr; + char *value; + }; + + + struct _PangoAttrColor { + PangoAttribute attr; + PangoColor color; + }; + + + struct _PangoAttrFontDesc { + PangoAttribute attr; + PangoFontDescription *desc; + }; + + + struct _PangoAttrFloat { + PangoAttribute attr; + double value; + }; + + + struct _PangoRendererClass { + GObjectClass parent_class; + void (*draw_glyphs) (PangoRenderer *, PangoFont *, + PangoGlyphString *, int, int); + void (*draw_rectangle) (PangoRenderer *, PangoRenderPart, int, int, + int, int); + void (*draw_error_underline) (PangoRenderer *, int, int, int, int); + void (*draw_shape) (PangoRenderer *, PangoAttrShape *, int, int); + void (*draw_trapezoid) (PangoRenderer *, PangoRenderPart, double, + double, double, double, double, double); + void (*draw_glyph) (PangoRenderer *, PangoFont *, PangoGlyph, + double, double); + void (*part_changed) (PangoRenderer *, PangoRenderPart); + void (*begin) (PangoRenderer *); + void (*end) (PangoRenderer *); + void (*prepare_run) (PangoRenderer *, PangoLayoutRun *); + void (*_pango_reserved1) (void); + void (*_pango_reserved2) (void); + void (*_pango_reserved3) (void); + void (*_pango_reserved4) (void); + }; + + + struct _PangoAttrLanguage { + PangoAttribute attr; + PangoLanguage *value; + }; + + + struct _PangoAttrInt { + PangoAttribute attr; + int value; + }; + + + struct _PangoAttrSize { + PangoAttribute attr; + int size; + guint absolute:1; + }; + + + + + + extern GType pango_script_get_type(void); + extern const char *pango_font_face_get_face_name(PangoFontFace *); + extern PangoWrapMode pango_layout_get_wrap(PangoLayout *); + extern void pango_layout_context_changed(PangoLayout *); + extern gboolean pango_script_iter_next(PangoScriptIter *); + extern PangoScript pango_script_for_unichar(gunichar); + extern PangoFont *pango_context_load_font(PangoContext *, + const PangoFontDescription + *); + extern gboolean pango_attribute_equal(const PangoAttribute *, + const PangoAttribute *); + extern void pango_get_log_attrs(const char *, int, int, + PangoLanguage *, PangoLogAttr *, int); + extern gboolean pango_color_parse(PangoColor *, const char *); + extern gboolean pango_font_description_equal(const PangoFontDescription + *, + const PangoFontDescription + *); + extern PangoAttribute *pango_attr_rise_new(int); + extern void pango_matrix_translate(PangoMatrix *, double, double); + extern PangoLayoutRun *pango_layout_iter_get_run(PangoLayoutIter *); + extern PangoLayout *pango_layout_new(PangoContext *); + extern PangoAttribute *pango_attr_size_new(int); + extern PangoAttribute *pango_attr_family_new(const char *); + extern void pango_layout_set_markup_with_accel(PangoLayout *, + const char *, int, + gunichar, gunichar *); + extern PangoLanguage *pango_script_get_sample_language(PangoScript); + extern void pango_renderer_draw_trapezoid(PangoRenderer *, + PangoRenderPart, double, + double, double, double, + double, double); + extern void pango_attr_list_insert_before(PangoAttrList *, + PangoAttribute *); + extern PangoAttribute *pango_attr_underline_new(PangoUnderline); + extern void pango_layout_line_unref(PangoLayoutLine *); + extern void pango_glyph_string_get_logical_widths(PangoGlyphString *, + const char *, int, + int, int *); + extern PangoStretch pango_font_description_get_stretch(const + PangoFontDescription + *); + extern void pango_layout_iter_get_char_extents(PangoLayoutIter *, + PangoRectangle *); + extern PangoAttribute *pango_attr_scale_new(double); + extern void pango_layout_set_width(PangoLayout *, int); + extern void pango_layout_line_index_to_x(PangoLayoutLine *, int, int, + int *); + extern gboolean pango_font_family_is_monospace(PangoFontFamily *); + extern void pango_font_descriptions_free(PangoFontDescription * *, + int); + extern void pango_layout_set_single_paragraph_mode(PangoLayout *, + gboolean); + extern char *pango_font_description_to_filename(const + PangoFontDescription + *); + extern PangoLayout *pango_layout_copy(PangoLayout *); + extern int + pango_font_metrics_get_approximate_char_width(PangoFontMetrics *); + extern void pango_shape(const gchar *, gint, PangoAnalysis *, + PangoGlyphString *); + extern void pango_layout_line_get_pixel_extents(PangoLayoutLine *, + PangoRectangle *, + PangoRectangle *); + extern void pango_layout_set_wrap(PangoLayout *, PangoWrapMode); + extern const char *pango_font_description_get_family(const + PangoFontDescription + *); + extern void pango_tab_array_get_tabs(PangoTabArray *, + PangoTabAlign * *, gint * *); + extern void pango_script_iter_get_range(PangoScriptIter *, + const char **, const char **, + PangoScript *); + extern gboolean pango_layout_iter_next_line(PangoLayoutIter *); + extern void pango_layout_get_log_attrs(PangoLayout *, PangoLogAttr * *, + gint *); + extern void pango_tab_array_free(PangoTabArray *); + extern PangoTabArray *pango_layout_get_tabs(PangoLayout *); + extern PangoFontDescription *pango_font_describe(PangoFont *); + extern void pango_context_set_font_description(PangoContext *, + const + PangoFontDescription *); + extern gint pango_tab_array_get_size(PangoTabArray *); + extern PangoAlignment pango_layout_get_alignment(PangoLayout *); + extern const PangoMatrix *pango_renderer_get_matrix(PangoRenderer *); + extern PangoAttrIterator *pango_attr_iterator_copy(PangoAttrIterator + *); + extern GType pango_style_get_type(void); + extern PangoFontMask pango_font_description_get_set_fields(const + PangoFontDescription + *); + extern gboolean pango_language_matches(PangoLanguage *, const char *); + extern int pango_font_metrics_get_descent(PangoFontMetrics *); + extern void pango_layout_get_extents(PangoLayout *, PangoRectangle *, + PangoRectangle *); + extern char *pango_font_description_to_string(const + PangoFontDescription *); + extern void pango_layout_set_justify(PangoLayout *, gboolean); + extern void pango_find_paragraph_boundary(const gchar *, gint, gint *, + gint *); + extern PangoDirection pango_unichar_direction(gunichar); + extern GList *pango_reorder_items(GList *); + extern void pango_glyph_string_set_size(PangoGlyphString *, gint); + extern PangoFontDescription *pango_font_description_from_string(const + char + *); + extern int + pango_font_metrics_get_strikethrough_position(PangoFontMetrics *); + extern PangoEngineShape *pango_font_find_shaper(PangoFont *, + PangoLanguage *, + guint32); + extern GType pango_glyph_string_get_type(void); + extern PangoEllipsizeMode pango_layout_get_ellipsize(PangoLayout *); + extern PangoFontDescription *pango_font_face_describe(PangoFontFace *); + extern PangoMatrix *pango_matrix_copy(const PangoMatrix *); + extern const PangoMatrix *pango_context_get_matrix(PangoContext *); + extern void pango_attr_iterator_range(PangoAttrIterator *, gint *, + gint *); + extern void pango_context_set_language(PangoContext *, + PangoLanguage *); + extern void pango_glyph_item_letter_space(PangoGlyphItem *, + const char *, PangoLogAttr *, + int); + extern void pango_coverage_max(PangoCoverage *, PangoCoverage *); + extern PangoStyle pango_font_description_get_style(const + PangoFontDescription + *); + extern void pango_layout_line_get_extents(PangoLayoutLine *, + PangoRectangle *, + PangoRectangle *); + extern void pango_attribute_destroy(PangoAttribute *); + extern PangoLayoutLine *pango_layout_get_line(PangoLayout *, int); + extern gboolean pango_layout_get_auto_dir(PangoLayout *); + extern int + pango_font_metrics_get_approximate_digit_width(PangoFontMetrics *); + extern void pango_attr_list_splice(PangoAttrList *, PangoAttrList *, + gint, gint); + extern PangoLayoutLine *pango_layout_iter_get_line(PangoLayoutIter *); + extern PangoFontDescription *pango_font_description_new(void); + extern PangoAttribute *pango_attr_font_desc_new(const + PangoFontDescription + *); + extern PangoFontDescription *pango_font_description_copy_static(const + PangoFontDescription + *); + extern void pango_font_metrics_unref(PangoFontMetrics *); + extern PangoDirection pango_find_base_dir(const gchar *, gint); + extern void pango_layout_iter_get_run_extents(PangoLayoutIter *, + PangoRectangle *, + PangoRectangle *); + extern void pango_layout_index_to_pos(PangoLayout *, int, + PangoRectangle *); + extern const char *pango_font_family_get_name(PangoFontFamily *); + extern void pango_layout_line_get_x_ranges(PangoLayoutLine *, int, int, + int **, int *); + extern void pango_item_free(PangoItem *); + extern GType pango_renderer_get_type(void); + extern void pango_layout_set_indent(PangoLayout *, int); + extern void pango_layout_set_text(PangoLayout *, const char *, int); + extern gint pango_font_description_get_size(const PangoFontDescription + *); + extern GType pango_fontset_get_type(void); + extern GType pango_weight_get_type(void); + extern guint pango_font_description_hash(const PangoFontDescription *); + extern void pango_renderer_activate(PangoRenderer *); + extern PangoContext *pango_layout_get_context(PangoLayout *); + extern PangoCoverage *pango_coverage_new(void); + extern PangoAttribute *pango_attr_strikethrough_new(gboolean); + extern void pango_coverage_set(PangoCoverage *, int, + PangoCoverageLevel); + extern PangoFont *pango_font_map_load_font(PangoFontMap *, + PangoContext *, + const PangoFontDescription + *); + extern int pango_layout_iter_get_baseline(PangoLayoutIter *); + extern gboolean pango_font_description_better_match(const + PangoFontDescription + *, + const + PangoFontDescription + *, + const + PangoFontDescription + *); + extern void pango_layout_iter_get_line_extents(PangoLayoutIter *, + PangoRectangle *, + PangoRectangle *); + extern PangoItem *pango_item_new(void); + extern GType pango_font_mask_get_type(void); + extern void pango_tab_array_get_tab(PangoTabArray *, gint, + PangoTabAlign *, gint *); + extern gboolean pango_attr_iterator_next(PangoAttrIterator *); + extern gboolean pango_layout_get_justify(PangoLayout *); + extern PangoCoverage *pango_coverage_ref(PangoCoverage *); + extern PangoAttribute *pango_attr_foreground_new(guint16, guint16, + guint16); + extern PangoAttrList *pango_attr_list_filter(PangoAttrList *, + PangoAttrFilterFunc, + gpointer); + extern PangoFontDescription + *pango_context_get_font_description(PangoContext *); + extern PangoTabArray *pango_tab_array_new_with_positions(gint, + gboolean, + PangoTabAlign, + gint, ...); + extern GSList *pango_glyph_item_apply_attrs(PangoGlyphItem *, + const char *, + PangoAttrList *); + extern PangoAttribute *pango_attr_shape_new(const PangoRectangle *, + const PangoRectangle *); + extern GType pango_variant_get_type(void); + extern void pango_layout_set_spacing(PangoLayout *, int); + extern void pango_attr_list_ref(PangoAttrList *); + extern void + pango_font_description_set_family_static(PangoFontDescription *, + const char *); + extern gboolean pango_layout_iter_next_char(PangoLayoutIter *); + extern void pango_glyph_string_index_to_x(PangoGlyphString *, char *, + int, PangoAnalysis *, int, + gboolean, int *); + extern PangoAttribute *pango_attr_stretch_new(PangoStretch); + extern GType pango_attr_type_get_type(void); + extern GType pango_language_get_type(void); + extern void pango_font_get_glyph_extents(PangoFont *, PangoGlyph, + PangoRectangle *, + PangoRectangle *); + extern PangoAttribute *pango_attr_fallback_new(gboolean); + extern void pango_font_description_merge_static(PangoFontDescription *, + const + PangoFontDescription *, + gboolean); + extern PangoAttrList *pango_layout_get_attributes(PangoLayout *); + extern PangoFontset *pango_font_map_load_fontset(PangoFontMap *, + PangoContext *, + const + PangoFontDescription + *, PangoLanguage *); + extern void pango_layout_set_tabs(PangoLayout *, PangoTabArray *); + extern GType pango_attr_list_get_type(void); + extern GType pango_font_family_get_type(void); + extern void pango_matrix_free(PangoMatrix *); + extern PangoAttribute *pango_attr_language_new(PangoLanguage *); + extern void pango_layout_iter_get_cluster_extents(PangoLayoutIter *, + PangoRectangle *, + PangoRectangle *); + extern PangoAttrType pango_attr_type_register(const gchar *); + extern void pango_context_set_matrix(PangoContext *, + const PangoMatrix *); + extern void pango_layout_set_markup(PangoLayout *, const char *, int); + extern GType pango_coverage_level_get_type(void); + extern PangoTabArray *pango_tab_array_copy(PangoTabArray *); + extern void pango_attr_list_change(PangoAttrList *, PangoAttribute *); + extern PangoColor *pango_renderer_get_color(PangoRenderer *, + PangoRenderPart); + extern void pango_renderer_part_changed(PangoRenderer *, + PangoRenderPart); + extern void pango_glyph_string_x_to_index(PangoGlyphString *, char *, + int, PangoAnalysis *, int, + int *, gboolean *); + extern void pango_tab_array_resize(PangoTabArray *, gint); + extern void pango_break(const gchar *, gint, PangoAnalysis *, + PangoLogAttr *, int); + extern void pango_coverage_unref(PangoCoverage *); + extern void pango_font_map_list_families(PangoFontMap *, + PangoFontFamily * **, int *); + extern void pango_matrix_concat(PangoMatrix *, const PangoMatrix *); + extern PangoAttrList *pango_attr_list_copy(PangoAttrList *); + extern GType pango_layout_iter_get_type(void); + extern void pango_layout_set_attributes(PangoLayout *, + PangoAttrList *); + extern void pango_color_free(PangoColor *); + extern PangoItem *pango_item_copy(PangoItem *); + extern void pango_font_description_set_weight(PangoFontDescription *, + PangoWeight); + extern PangoAttribute *pango_attr_letter_spacing_new(int); + extern PangoLanguage *pango_language_from_string(const char *); + extern PangoAttribute *pango_attr_strikethrough_color_new(guint16, + guint16, + guint16); + extern void pango_attr_list_insert(PangoAttrList *, PangoAttribute *); + extern gboolean pango_layout_line_x_to_index(PangoLayoutLine *, int, + int *, int *); + extern PangoFontMap *pango_context_get_font_map(PangoContext *); + extern GType pango_direction_get_type(void); + extern void pango_layout_iter_get_layout_extents(PangoLayoutIter *, + PangoRectangle *, + PangoRectangle *); + extern void pango_glyph_string_free(PangoGlyphString *); + extern gboolean pango_tab_array_get_positions_in_pixels(PangoTabArray + *); + extern PangoFontMetrics *pango_fontset_get_metrics(PangoFontset *); + extern int pango_layout_iter_get_index(PangoLayoutIter *); + extern int pango_layout_get_spacing(PangoLayout *); + extern gboolean pango_layout_get_single_paragraph_mode(PangoLayout *); + extern GSList *pango_layout_get_lines(PangoLayout *); + extern GType pango_underline_get_type(void); + extern void pango_layout_get_pixel_extents(PangoLayout *, + PangoRectangle *, + PangoRectangle *); + extern void pango_matrix_scale(PangoMatrix *, double, double); + extern void pango_attr_iterator_destroy(PangoAttrIterator *); + extern void pango_glyph_string_extents(PangoGlyphString *, PangoFont *, + PangoRectangle *, + PangoRectangle *); + extern PangoTabArray *pango_tab_array_new(gint, gboolean); + extern PangoAttribute *pango_attr_weight_new(PangoWeight); + extern int pango_layout_get_width(PangoLayout *); + extern gboolean pango_parse_markup(const char *, int, gunichar, + PangoAttrList * *, char **, + gunichar *, GError * *); + extern void pango_matrix_rotate(PangoMatrix *, double); + extern void pango_font_description_set_style(PangoFontDescription *, + PangoStyle); + extern void pango_layout_set_auto_dir(PangoLayout *, gboolean); + extern GType pango_context_get_type(void); + extern PangoAttribute *pango_attr_background_new(guint16, guint16, + guint16); + extern void pango_coverage_to_bytes(PangoCoverage *, guchar * *, + int *); + extern void pango_font_description_set_size(PangoFontDescription *, + gint); + extern void pango_attr_list_unref(PangoAttrList *); + extern int + pango_font_metrics_get_strikethrough_thickness(PangoFontMetrics *); + extern PangoAttribute *pango_attr_size_new_absolute(int); + extern PangoAttribute *pango_attribute_copy(const PangoAttribute *); + extern PangoAttribute *pango_attr_iterator_get(PangoAttrIterator *, + PangoAttrType); + extern GType pango_matrix_get_type(void); + extern PangoDirection pango_context_get_base_dir(PangoContext *); + extern PangoAttribute *pango_attr_style_new(PangoStyle); + extern void pango_attr_iterator_get_font(PangoAttrIterator *, + PangoFontDescription *, + PangoLanguage * *, + GSList * *); + extern void pango_renderer_draw_glyph(PangoRenderer *, PangoFont *, + PangoGlyph, double, double); + extern void pango_glyph_item_free(PangoGlyphItem *); + extern gboolean pango_language_includes_script(PangoLanguage *, + PangoScript); + extern gboolean pango_font_description_get_size_is_absolute(const + PangoFontDescription + *); + extern GSList *pango_attr_iterator_get_attrs(PangoAttrIterator *); + extern GType pango_ellipsize_mode_get_type(void); + extern void pango_font_face_list_sizes(PangoFontFace *, int **, int *); + extern void pango_layout_get_size(PangoLayout *, int *, int *); + extern void pango_renderer_draw_glyphs(PangoRenderer *, PangoFont *, + PangoGlyphString *, int, int); + extern GType pango_tab_array_get_type(void); + extern PangoGlyphItem *pango_glyph_item_split(PangoGlyphItem *, + const char *, int); + extern PangoLayoutIter *pango_layout_get_iter(PangoLayout *); + extern PangoGlyphString *pango_glyph_string_new(void); + extern gboolean pango_layout_iter_next_run(PangoLayoutIter *); + extern void pango_glyph_string_extents_range(PangoGlyphString *, int, + int, PangoFont *, + PangoRectangle *, + PangoRectangle *); + extern PangoWeight pango_font_description_get_weight(const + PangoFontDescription + *); + extern GType pango_font_description_get_type(void); + extern void pango_renderer_deactivate(PangoRenderer *); + extern PangoGlyphString *pango_glyph_string_copy(PangoGlyphString *); + extern void pango_script_iter_free(PangoScriptIter *); + extern PangoCoverage *pango_coverage_from_bytes(guchar *, int); + extern void pango_layout_iter_get_line_yrange(PangoLayoutIter *, int *, + int *); + extern GType pango_stretch_get_type(void); + extern int pango_layout_get_line_count(PangoLayout *); + extern void pango_layout_set_ellipsize(PangoLayout *, + PangoEllipsizeMode); + extern PangoCoverage *pango_font_get_coverage(PangoFont *, + PangoLanguage *); + extern PangoFontDescription *pango_font_description_copy(const + PangoFontDescription + *); + extern void pango_fontset_foreach(PangoFontset *, + PangoFontsetForeachFunc, gpointer); + extern GType pango_font_get_type(void); + extern void pango_layout_set_alignment(PangoLayout *, PangoAlignment); + extern GType pango_layout_get_type(void); + extern void pango_renderer_draw_layout_line(PangoRenderer *, + PangoLayoutLine *, int, + int); + extern GType pango_alignment_get_type(void); + extern void pango_renderer_draw_rectangle(PangoRenderer *, + PangoRenderPart, int, int, + int, int); + extern void pango_context_list_families(PangoContext *, + PangoFontFamily * **, int *); + extern void + pango_font_description_set_absolute_size(PangoFontDescription *, + double); + extern void pango_layout_iter_free(PangoLayoutIter *); + extern PangoCoverageLevel pango_coverage_get(PangoCoverage *, int); + extern void pango_renderer_draw_error_underline(PangoRenderer *, int, + int, int, int); + extern PangoFontset *pango_context_load_fontset(PangoContext *, + const + PangoFontDescription *, + PangoLanguage *); + extern void pango_layout_line_ref(PangoLayoutLine *); + extern void pango_font_description_set_family(PangoFontDescription *, + const char *); + extern gboolean pango_layout_iter_at_last_line(PangoLayoutIter *); + extern GType pango_render_part_get_type(void); + extern PangoAttrList *pango_attr_list_new(void); + extern void pango_font_description_set_stretch(PangoFontDescription *, + PangoStretch); + extern void pango_font_description_merge(PangoFontDescription *, + const PangoFontDescription *, + gboolean); + extern int pango_font_metrics_get_underline_thickness(PangoFontMetrics + *); + extern const char *pango_layout_get_text(PangoLayout *); + extern int pango_font_metrics_get_ascent(PangoFontMetrics *); + extern PangoFont *pango_fontset_get_font(PangoFontset *, guint); + extern void pango_renderer_draw_layout(PangoRenderer *, PangoLayout *, + int, int); + extern int pango_font_metrics_get_underline_position(PangoFontMetrics + *); + extern GType pango_color_get_type(void); + extern PangoFontMetrics *pango_context_get_metrics(PangoContext *, + const + PangoFontDescription + *, PangoLanguage *); + extern gboolean pango_layout_xy_to_index(PangoLayout *, int, int, + int *, gint *); + extern void pango_renderer_set_matrix(PangoRenderer *, + const PangoMatrix *); + extern void pango_font_description_set_variant(PangoFontDescription *, + PangoVariant); + extern GList *pango_itemize(PangoContext *, const char *, int, int, + PangoAttrList *, PangoAttrIterator *); + extern void pango_layout_move_cursor_visually(PangoLayout *, gboolean, + int, int, int, int *, + int *); + extern int pango_layout_get_indent(PangoLayout *); + extern PangoAttrIterator *pango_attr_list_get_iterator(PangoAttrList + *); + extern void pango_layout_get_pixel_size(PangoLayout *, int *, int *); + extern void pango_font_description_unset_fields(PangoFontDescription *, + PangoFontMask); + extern GType pango_tab_align_get_type(void); + extern PangoItem *pango_item_split(PangoItem *, int, int); + extern PangoFontMetrics *pango_font_metrics_ref(PangoFontMetrics *); + extern void pango_context_set_base_dir(PangoContext *, PangoDirection); + extern PangoAttribute *pango_attr_underline_color_new(guint16, guint16, + guint16); + extern gboolean pango_layout_iter_next_cluster(PangoLayoutIter *); + extern PangoAttribute *pango_attr_variant_new(PangoVariant); + extern GType pango_font_face_get_type(void); + extern void pango_font_family_list_faces(PangoFontFamily *, + PangoFontFace * **, int *); + extern PangoColor *pango_color_copy(const PangoColor *); + extern GType pango_wrap_mode_get_type(void); + extern void pango_tab_array_set_tab(PangoTabArray *, gint, + PangoTabAlign, gint); + extern PangoAttribute *pango_attr_shape_new_with_data(const + PangoRectangle *, + const + PangoRectangle *, + gpointer, + PangoAttrDataCopyFunc, + GDestroyNotify); + extern PangoVariant pango_font_description_get_variant(const + PangoFontDescription + *); + extern void pango_font_description_free(PangoFontDescription *); + extern GType pango_font_metrics_get_type(void); + extern void pango_layout_get_cursor_pos(PangoLayout *, int, + PangoRectangle *, + PangoRectangle *); + extern GList *pango_itemize_with_base_dir(PangoContext *, + PangoDirection, const char *, + int, int, PangoAttrList *, + PangoAttrIterator *); + extern PangoLanguage *pango_context_get_language(PangoContext *); + extern void pango_renderer_set_color(PangoRenderer *, PangoRenderPart, + const PangoColor *); + extern GType pango_font_map_get_type(void); + extern const PangoFontDescription + *pango_layout_get_font_description(PangoLayout *); + extern void pango_layout_set_font_description(PangoLayout *, + const + PangoFontDescription *); + extern PangoFontMetrics *pango_font_get_metrics(PangoFont *, + PangoLanguage *); + extern PangoScriptIter *pango_script_iter_new(const char *, int); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/pango-1.0/pango/pangofc-decoder.h b/lsb-build/headers/pango-1.0/pango/pangofc-decoder.h new file mode 100644 index 0000000..83dcb51 --- /dev/null +++ b/lsb-build/headers/pango-1.0/pango/pangofc-decoder.h @@ -0,0 +1,61 @@ +#ifndef _PANGO_1_0_PANGO_PANGOFC_DECODER_H_ +#define _PANGO_1_0_PANGO_PANGOFC_DECODER_H_ + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define PANGO_FC_DECODER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FC_DECODER, \ + PangoFcDecoderClass)) +#define PANGO_IS_FC_DECODER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FC_DECODER)) +#define PANGO_FC_DECODER(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FC_DECODER, \ + PangoFcDecoder)) +#define PANGO_IS_FC_DECODER(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FC_DECODER)) +#define PANGO_FC_DECODER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FC_DECODER, \ + PangoFcDecoderClass)) +#define PANGO_TYPE_FC_DECODER (pango_fc_decoder_get_type()) + + + typedef struct _PangoFcDecoder PangoFcDecoder; + + typedef struct _PangoFcDecoderClass PangoFcDecoderClass; + + + struct _PangoFcDecoder { + GObject parent_instance; + }; + + + struct _PangoFcDecoderClass { + GObjectClass parent_class; + FcCharSet *(*get_charset) (PangoFcDecoder *, PangoFcFont *); + PangoGlyph(*get_glyph) (PangoFcDecoder *, PangoFcFont *, guint32); + void (*_pango_reserved1) (void); + void (*_pango_reserved2) (void); + void (*_pango_reserved3) (void); + void (*_pango_reserved4) (void); + }; + + + extern FcCharSet *pango_fc_decoder_get_charset(PangoFcDecoder *, + PangoFcFont *); + extern PangoGlyph pango_fc_decoder_get_glyph(PangoFcDecoder *, + PangoFcFont *, guint32); + extern GType pango_fc_decoder_get_type(void); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/pango-1.0/pango/pangofc-fontmap.h b/lsb-build/headers/pango-1.0/pango/pangofc-fontmap.h new file mode 100644 index 0000000..68fee27 --- /dev/null +++ b/lsb-build/headers/pango-1.0/pango/pangofc-fontmap.h @@ -0,0 +1,47 @@ +#ifndef _PANGO_1_0_PANGO_PANGOFC_FONTMAP_H_ +#define _PANGO_1_0_PANGO_PANGOFC_FONTMAP_H_ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define PANGO_FC_FONT_MAP(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FC_FONT_MAP, \ + PangoFcFontMap)) +#define PANGO_IS_FC_FONT_MAP(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FC_FONT_MAP)) +#define PANGO_TYPE_FC_FONT_MAP (pango_fc_font_map_get_type ()) + + + typedef struct _PangoFcFontMap PangoFcFontMap; + + typedef PangoFcDecoder *(*PangoFcDecoderFindFunc) (FcPattern *, + gpointer); + + typedef struct _PangoFcFontMapClass PangoFcFontMapClass; + + + + + + + + + extern void pango_fc_font_map_add_decoder_find_func(PangoFcFontMap *, + PangoFcDecoderFindFunc, + gpointer, + GDestroyNotify); + extern PangoFontDescription + *pango_fc_font_description_from_pattern(FcPattern *, gboolean); + extern GType pango_fc_font_map_get_type(void); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/pango-1.0/pango/pangoft2.h b/lsb-build/headers/pango-1.0/pango/pangoft2.h new file mode 100644 index 0000000..faa88d8 --- /dev/null +++ b/lsb-build/headers/pango-1.0/pango/pangoft2.h @@ -0,0 +1,71 @@ +#ifndef _PANGO_1_0_PANGO_PANGOFT2_H_ +#define _PANGO_1_0_PANGO_PANGOFT2_H_ + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define PANGO_FC_FONT(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FC_FONT, \ + PangoFcFont)) +#define PANGO_FT2_FONT_MAP(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FT2_FONT_MAP, \ + PangoFT2FontMap)) +#define PANGO_IS_FC_FONT(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FC_FONT)) +#define PANGO_FT2_IS_FONT_MAP(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FT2_FONT_MAP)) +#define PANGO_TYPE_FC_FONT (pango_fc_font_get_type ()) +#define PANGO_TYPE_FT2_FONT_MAP (pango_ft2_font_map_get_type ()) + + + typedef struct _PangoFT2FontMap PangoFT2FontMap; + + typedef void (*PangoFT2SubstituteFunc) (FcPattern *, gpointer); + + + + + + extern void pango_ft2_font_map_set_default_substitute(PangoFT2FontMap + *, + PangoFT2SubstituteFunc, + gpointer, + GDestroyNotify); + extern void pango_fc_font_unlock_face(PangoFcFont *); + extern GType pango_ft2_font_map_get_type(void); + extern void pango_ft2_render_transformed(FT_Bitmap *, + const PangoMatrix *, + PangoFont *, + PangoGlyphString *, int, int); + extern PangoContext *pango_ft2_font_map_create_context(PangoFT2FontMap + *); + extern void pango_ft2_render_layout_subpixel(FT_Bitmap *, + PangoLayout *, int, int); + extern void pango_ft2_render_layout(FT_Bitmap *, PangoLayout *, int, + int); + extern void pango_ft2_font_map_set_resolution(PangoFT2FontMap *, + double, double); + extern void pango_ft2_render(FT_Bitmap *, PangoFont *, + PangoGlyphString *, int, int); + extern void pango_ft2_font_map_substitute_changed(PangoFT2FontMap *); + extern void pango_ft2_render_layout_line(FT_Bitmap *, + PangoLayoutLine *, int, int); + extern GType pango_fc_font_get_type(void); + extern void pango_ft2_render_layout_line_subpixel(FT_Bitmap *, + PangoLayoutLine *, + int, int); + extern FT_Face pango_fc_font_lock_face(PangoFcFont *); + extern PangoFontMap *pango_ft2_font_map_new(void); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/pango-1.0/pango/pangoxft.h b/lsb-build/headers/pango-1.0/pango/pangoxft.h new file mode 100644 index 0000000..eeafba5 --- /dev/null +++ b/lsb-build/headers/pango-1.0/pango/pangoxft.h @@ -0,0 +1,117 @@ +#ifndef _PANGO_1_0_PANGO_PANGOXFT_H_ +#define _PANGO_1_0_PANGO_PANGOXFT_H_ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define PANGO_XFT_RENDERER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_XFT_RENDERER, \ + PangoXftRendererClass)) +#define PANGO_IS_XFT_RENDERER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_XFT_RENDERER)) +#define PANGO_XFT_FONT(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_XFT_FONT, \ + PangoXftFont)) +#define PANGO_XFT_FONT_MAP(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_XFT_FONT_MAP, \ + PangoXftFontMap)) +#define PANGO_XFT_RENDERER(object) \ + (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_XFT_RENDERER, \ + PangoXftRenderer)) +#define PANGO_XFT_IS_FONT(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_XFT_FONT)) +#define PANGO_XFT_IS_FONT_MAP(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_XFT_FONT_MAP)) +#define PANGO_IS_XFT_RENDERER(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_XFT_RENDERER)) +#define PANGO_XFT_RENDERER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_XFT_RENDERER, \ + PangoXftRendererClass)) +#define PANGO_TYPE_XFT_FONT (pango_xft_font_get_type ()) +#define PANGO_TYPE_XFT_FONT_MAP (pango_xft_font_map_get_type ()) +#define PANGO_TYPE_XFT_RENDERER (pango_xft_renderer_get_type()) +#define PANGO_RENDER_TYPE_XFT "PangoRenderXft" + + + typedef struct _PangoXftRenderer PangoXftRenderer; + + typedef void (*PangoXftSubstituteFunc) (FcPattern *, gpointer); + + typedef struct _PangoXftFontMap PangoXftFontMap; + + typedef struct _PangoXftRendererClass PangoXftRendererClass; + + typedef struct _PangoFcFontClass PangoFcFontClass; + + typedef struct _PangoFcFont PangoFcFont; + + typedef struct _PangoXftFont PangoXftFont; + + typedef struct _PangoXftRendererPrivate PangoXftRendererPrivate; + + + + + + + + + struct _PangoXftRendererClass { + PangoRendererClass parent_class; + void (*composite_trapezoids) (PangoXftRenderer *, PangoRenderPart, + XTrapezoid *, int); + void (*composite_glyphs) (PangoXftRenderer *, XftFont *, + XftGlyphSpec *, int); + }; + + + + + + + + + + + + + + + extern void pango_xft_substitute_changed(Display *, int); + extern void pango_xft_render(XftDraw *, XftColor *, PangoFont *, + PangoGlyphString *, gint, gint); + extern PangoRenderer *pango_xft_renderer_new(Display *, int); + extern GType pango_xft_renderer_get_type(void); + extern void pango_xft_renderer_set_default_color(PangoXftRenderer *, + PangoColor *); + extern GType pango_xft_font_get_type(void); + extern void pango_xft_picture_render(Display *, Picture, Picture, + PangoFont *, PangoGlyphString *, + gint, gint); + extern void pango_xft_render_layout(XftDraw *, XftColor *, + PangoLayout *, int, int); + extern void pango_xft_render_transformed(XftDraw *, XftColor *, + PangoMatrix *, PangoFont *, + PangoGlyphString *, int, int); + extern void pango_xft_renderer_set_draw(PangoXftRenderer *, XftDraw *); + extern void pango_xft_render_layout_line(XftDraw *, XftColor *, + PangoLayoutLine *, int, int); + extern void pango_xft_shutdown_display(Display *, int); + extern PangoFontMap *pango_xft_get_font_map(Display *, int); + extern PangoContext *pango_xft_get_context(Display *, int); + extern GType pango_xft_font_map_get_type(void); + extern void pango_xft_set_default_substitute(Display *, int, + PangoXftSubstituteFunc, + gpointer, GDestroyNotify); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/stddef.h b/lsb-build/headers/stddef.h new file mode 100644 index 0000000..f263bd8 --- /dev/null +++ b/lsb-build/headers/stddef.h @@ -0,0 +1,92 @@ +#ifndef _STDDEF_H_ +#define _STDDEF_H_ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#define offsetof(TYPE,MEMBER) ((size_t)&((TYPE*)0)->MEMBER) +#define NULL (0L) + + +#if !defined(__cplusplus) + typedef int wchar_t; + +#endif +#if __ia64__ +/* IA64 */ + typedef long int ptrdiff_t; + +#endif +#if __i386__ +/* IA32 */ + typedef unsigned int size_t; + +#endif +#if __ia64__ +/* IA64 */ + typedef unsigned long int size_t; + +#endif +#if __powerpc__ && !__powerpc64__ +/* PPC32 */ + typedef unsigned int size_t; + +#endif +#if __powerpc64__ +/* PPC64 */ + typedef unsigned long int size_t; + +#endif +#if __s390__ && !__s390x__ +/* S390 */ + typedef unsigned long int size_t; + +#endif +#if __i386__ +/* IA32 */ + typedef int ptrdiff_t; + +#endif +#if __powerpc__ && !__powerpc64__ +/* PPC32 */ + typedef int ptrdiff_t; + +#endif +#if __s390__ && !__s390x__ +/* S390 */ + typedef int ptrdiff_t; + +#endif +#if __powerpc64__ +/* PPC64 */ + typedef long int ptrdiff_t; + +#endif +#if __s390x__ +/* S390X */ + typedef unsigned long int size_t; + +#endif +#if __x86_64__ +/* x86-64 */ + typedef long int ptrdiff_t; + +#endif +#if __x86_64__ +/* x86-64 */ + typedef unsigned long int size_t; + +#endif +#if __s390x__ +/* S390X */ + typedef long int ptrdiff_t; + +#endif + +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/stdio.h b/lsb-build/headers/stdio.h new file mode 100644 index 0000000..b266c5e --- /dev/null +++ b/lsb-build/headers/stdio.h @@ -0,0 +1,166 @@ +#ifndef _STDIO_H_ +#define _STDIO_H_ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define EOF (-1) +#define P_tmpdir "/tmp" +#if __i386__ +#define __IO_FILE_SIZE 148 +#endif +#if __powerpc__ && !__powerpc64__ +#define __IO_FILE_SIZE 152 +#endif +#if __s390__ && !__s390x__ +#define __IO_FILE_SIZE 152 +#endif +#define FOPEN_MAX 16 +#define L_tmpnam 20 +#if __ia64__ +#define __IO_FILE_SIZE 216 +#endif +#if __powerpc64__ +#define __IO_FILE_SIZE 216 +#endif +#if __x86_64__ +#define __IO_FILE_SIZE 216 +#endif +#if __s390x__ +#define __IO_FILE_SIZE 216 +#endif +#define FILENAME_MAX 4096 +#define BUFSIZ 8192 +#define L_ctermid 9 +#define L_cuserid 9 + + + typedef struct { + off_t __pos; + mbstate_t __state; + } fpos_t; + + typedef struct { + off64_t __pos; + mbstate_t __state; + } fpos64_t; + + struct _IO_FILE { + char dummy[__IO_FILE_SIZE]; + }; + + +/* The opaque type of streams.*/ + + + typedef struct _IO_FILE FILE; + + + + + +/* The possibilities for the third argument to `setvbuf'.*/ +#define _IOFBF 0 +#define _IOLBF 1 +#define _IONBF 2 + + + +/* The possibilities for the third argument to `fseek'.*/ + + + +/* End of file character.*/ + + + + extern char *const _sys_errlist[128]; + extern void clearerr(FILE *); + extern int fclose(FILE *); + extern FILE *fdopen(int, const char *); + extern int fflush_unlocked(FILE *); + extern int fileno(FILE *); + extern FILE *fopen(const char *, const char *); + extern int fprintf(FILE *, const char *, ...); + extern int fputc(int, FILE *); + extern FILE *freopen(const char *, const char *, FILE *); + extern FILE *freopen64(const char *, const char *, FILE *); + extern int fscanf(FILE *, const char *, ...); + extern int fseek(FILE *, long int, int); + extern int fseeko(FILE *, off_t, int); + extern int fseeko64(FILE *, loff_t, int); + extern off_t ftello(FILE *); + extern loff_t ftello64(FILE *); + extern int getchar(void); + extern int getchar_unlocked(void); + extern int getw(FILE *); + extern int pclose(FILE *); + extern void perror(const char *); + extern FILE *popen(const char *, const char *); + extern int printf(const char *, ...); + extern int putc_unlocked(int, FILE *); + extern int putchar(int); + extern int putchar_unlocked(int); + extern int putw(int, FILE *); + extern int remove(const char *); + extern void rewind(FILE *); + extern int scanf(const char *, ...); + extern void setbuf(FILE *, char *); + extern int sprintf(char *, const char *, ...); + extern int sscanf(const char *, const char *, ...); + extern FILE *stderr; + extern FILE *stdin; + extern FILE *stdout; + extern char *tempnam(const char *, const char *); + extern FILE *tmpfile64(void); + extern FILE *tmpfile(void); + extern char *tmpnam(char *); + extern int vfprintf(FILE *, const char *, va_list); + extern int vprintf(const char *, va_list); + extern int feof(FILE *); + extern int ferror(FILE *); + extern int fflush(FILE *); + extern int fgetc(FILE *); + extern int fgetpos(FILE *, fpos_t *); + extern char *fgets(char *, int, FILE *); + extern int fputs(const char *, FILE *); + extern size_t fread(void *, size_t, size_t, FILE *); + extern int fsetpos(FILE *, const fpos_t *); + extern long int ftell(FILE *); + extern size_t fwrite(const void *, size_t, size_t, FILE *); + extern int getc(FILE *); + extern char *gets(char *); + extern int putc(int, FILE *); + extern int puts(const char *); + extern int setvbuf(FILE *, char *, int, size_t); + extern int snprintf(char *, size_t, const char *, ...); + extern int ungetc(int, FILE *); + extern int vsnprintf(char *, size_t, const char *, va_list); + extern int vsprintf(char *, const char *, va_list); + extern void flockfile(FILE *); + extern int asprintf(char **, const char *, ...); + extern int fgetpos64(FILE *, fpos64_t *); + extern FILE *fopen64(const char *, const char *); + extern int fsetpos64(FILE *, const fpos64_t *); + extern int ftrylockfile(FILE *); + extern void funlockfile(FILE *); + extern int getc_unlocked(FILE *); + extern void setbuffer(FILE *, char *, size_t); + extern int vasprintf(char **, const char *, va_list); + extern int vdprintf(int, const char *, va_list); + extern int vfscanf(FILE *, const char *, va_list); + extern int vscanf(const char *, va_list); + extern int vsscanf(const char *, const char *, va_list); + extern size_t __fpending(FILE *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/stdlib.h b/lsb-build/headers/stdlib.h new file mode 100644 index 0000000..ab7823c --- /dev/null +++ b/lsb-build/headers/stdlib.h @@ -0,0 +1,145 @@ +#ifndef _STDLIB_H_ +#define _STDLIB_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define MB_CUR_MAX (__ctype_get_mb_cur_max()) +#define EXIT_SUCCESS 0 +#define EXIT_FAILURE 1 +#define RAND_MAX 2147483647 + + + typedef int (*__compar_fn_t) (const void *, const void *); + + struct random_data { + int32_t *fptr; /* Front pointer. */ + int32_t *rptr; /* Rear pointer. */ + int32_t *state; /* Array of state values. */ + int rand_type; /* Type of random number generator. */ + int rand_deg; /* Degree of random number generator. */ + int rand_sep; /* Distance between front and rear. */ + int32_t *end_ptr; /* Pointer behind state table. */ + }; + + +/* Returned by `div'.*/ + + + typedef struct { + int quot; + int rem; + } div_t; + + +/* Returned by `ldiv'.*/ + + + typedef struct { + long int quot; + long int rem; + } ldiv_t; + + +/* Returned by `lldiv'.*/ + + + typedef struct { + long long int quot; + long long int rem; + } lldiv_t; + + + extern double __strtod_internal(const char *, char **, int); + extern float __strtof_internal(const char *, char **, int); + extern long int __strtol_internal(const char *, char **, int, int); + extern long double __strtold_internal(const char *, char **, int); + extern long long int __strtoll_internal(const char *, char **, int, + int); + extern unsigned long int __strtoul_internal(const char *, char **, int, + int); + extern unsigned long long int __strtoull_internal(const char *, + char **, int, int); + extern long int a64l(const char *); + extern void abort(void); + extern int abs(int); + extern int atexit(void (*)(void) + ); + extern double atof(const char *); + extern int atoi(const char *); + extern long int atol(const char *); + extern long long int atoll(const char *); + extern void *bsearch(const void *, const void *, size_t, size_t, + __compar_fn_t); + extern div_t div(int, int); + extern double drand48(void); + extern char *ecvt(double, int, int *, int *); + extern double erand48(unsigned short[3]); + extern void exit(int); + extern char *fcvt(double, int, int *, int *); + extern char *gcvt(double, int, char *); + extern char *getenv(const char *); + extern int getsubopt(char **, char *const *, char **); + extern int grantpt(int); + extern long int jrand48(unsigned short[3]); + extern char *l64a(long int); + extern long int labs(long int); + extern void lcong48(unsigned short[7]); + extern ldiv_t ldiv(long int, long int); + extern long long int llabs(long long int); + extern lldiv_t lldiv(long long int, long long int); + extern long int lrand48(void); + extern int mblen(const char *, size_t); + extern size_t mbstowcs(wchar_t *, const char *, size_t); + extern int mbtowc(wchar_t *, const char *, size_t); + extern char *mktemp(char *); + extern long int mrand48(void); + extern long int nrand48(unsigned short[3]); + extern char *ptsname(int); + extern int putenv(char *); + extern void qsort(void *, size_t, size_t, const __compar_fn_t); + extern int rand(void); + extern int rand_r(unsigned int *); + extern unsigned short *seed48(unsigned short[]); + extern void srand48(long int); + extern int unlockpt(int); + extern size_t wcstombs(char *, const wchar_t *, size_t); + extern int wctomb(char *, wchar_t); + extern int system(const char *); + extern void *calloc(size_t, size_t); + extern void free(void *); + extern char *initstate(unsigned int, char *, size_t); + extern void *malloc(size_t); + extern long int random(void); + extern void *realloc(void *, size_t); + extern char *setstate(char *); + extern void srand(unsigned int); + extern void srandom(unsigned int); + extern double strtod(const char *, char **); + extern float strtof(const char *, char **); + extern long int strtol(const char *, char **, int); + extern long double strtold(const char *, char **); + extern long long int strtoll(const char *, char **, int); + extern long long int strtoq(const char *, char **, int); + extern unsigned long int strtoul(const char *, char **, int); + extern unsigned long long int strtoull(const char *, char **, int); + extern unsigned long long int strtouq(const char *, char **, int); + extern void _Exit(int); + extern size_t __ctype_get_mb_cur_max(void); + extern char **environ; + extern char *realpath(const char *, char *); + extern int setenv(const char *, const char *, int); + extern int unsetenv(const char *); + extern int getloadavg(double[], int); + extern int mkstemp64(char *); + extern int posix_memalign(void **, size_t, size_t); + extern int posix_openpt(int); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/string.h b/lsb-build/headers/string.h new file mode 100644 index 0000000..ee3b508 --- /dev/null +++ b/lsb-build/headers/string.h @@ -0,0 +1,63 @@ +#ifndef _STRING_H_ +#define _STRING_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + + + + + extern void *__mempcpy(void *, const void *, size_t); + extern char *__stpcpy(char *, const char *); + extern char *__strtok_r(char *, const char *, char **); + extern void bcopy(const void *, void *, size_t); + extern void *memchr(const void *, int, size_t); + extern int memcmp(const void *, const void *, size_t); + extern void *memcpy(void *, const void *, size_t); + extern void *memmem(const void *, size_t, const void *, size_t); + extern void *memmove(void *, const void *, size_t); + extern void *memset(void *, int, size_t); + extern char *strcat(char *, const char *); + extern char *strchr(const char *, int); + extern int strcmp(const char *, const char *); + extern int strcoll(const char *, const char *); + extern char *strcpy(char *, const char *); + extern size_t strcspn(const char *, const char *); + extern char *strerror(int); + extern size_t strlen(const char *); + extern char *strncat(char *, const char *, size_t); + extern int strncmp(const char *, const char *, size_t); + extern char *strncpy(char *, const char *, size_t); + extern char *strpbrk(const char *, const char *); + extern char *strrchr(const char *, int); + extern char *strsignal(int); + extern size_t strspn(const char *, const char *); + extern char *strstr(const char *, const char *); + extern char *strtok(char *, const char *); + extern size_t strxfrm(char *, const char *, size_t); + extern int bcmp(const void *, const void *, size_t); + extern void bzero(void *, size_t); + extern int ffs(int); + extern char *index(const char *, int); + extern void *memccpy(void *, const void *, int, size_t); + extern char *rindex(const char *, int); + extern int strcasecmp(const char *, const char *); + extern char *strdup(const char *); + extern int strncasecmp(const char *, const char *, size_t); + extern char *strndup(const char *, size_t); + extern size_t strnlen(const char *, size_t); + extern char *strsep(char **, const char *); + extern char *strerror_r(int, char *, size_t); + extern char *strtok_r(char *, const char *, char **); + extern char *strcasestr(const char *, const char *); + extern char *stpcpy(char *, const char *); + extern char *stpncpy(char *, const char *, size_t); + extern void *memrchr(const void *, int, size_t); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/sys/resource.h b/lsb-build/headers/sys/resource.h new file mode 100644 index 0000000..441d7d4 --- /dev/null +++ b/lsb-build/headers/sys/resource.h @@ -0,0 +1,110 @@ +#ifndef _SYS_RESOURCE_H_ +#define _SYS_RESOURCE_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define RUSAGE_CHILDREN (-1) +#define RUSAGE_BOTH (-2) +#define RLIM_INFINITY (~0UL) +#define RLIM_SAVED_CUR -1 +#define RLIM_SAVED_MAX -1 +#define RLIMIT_CPU 0 +#define RUSAGE_SELF 0 +#define RLIMIT_FSIZE 1 +#define RLIMIT_LOCKS 10 +#define RLIM_NLIMITS 11 +#define RLIMIT_DATA 2 +#define RLIMIT_STACK 3 +#define RLIMIT_CORE 4 +#define RLIMIT_RSS 5 +#define RLIMIT_NPROC 6 +#define RLIMIT_NOFILE 7 +#define RLIMIT_MEMLOCK 8 +#define RLIMIT_AS 9 + + + + + + typedef unsigned long int rlim_t; + + typedef unsigned long long int rlim64_t; + + typedef int __rlimit_resource_t; + + + + + struct rlimit { + rlim_t rlim_cur; /* The current (soft) limit. */ + rlim_t rlim_max; /* The hard limit. */ + }; + + struct rlimit64 { + rlim64_t rlim_cur; /* The current (soft) limit. */ + rlim64_t rlim_max; /* The hard limit. */ + }; + + + + + struct rusage { + struct timeval ru_utime; /* Total amount of user time used. */ + struct timeval ru_stime; /* Total amount of system time used. */ + long int ru_maxrss; /* Maximum resident set size (in kilobytes). */ + long int ru_ixrss; /* Amount of sharing of text segment memory with other p */ + long int ru_idrss; /* Amount of data segment memory used (kilobyte-seconds). */ + long int ru_isrss; /* Amount of stack memory used (kilobyte-seconds). */ + long int ru_minflt; /* Number of soft page faults (i.e. those serviced by reclaimin */ + long int ru_majflt; /* Number of hard page faults (i.e. those that required I/O). */ + long int ru_nswap; /* Number of times a process was swapped out of physical memory */ + long int ru_inblock; /* Number of input operations via the file system. Note: This */ + long int ru_oublock; /* Number of output operations via the file system. */ + long int ru_msgsnd; /* Number of IPC messages sent. */ + long int ru_msgrcv; /* Number of IPC messages received. */ + long int ru_nsignals; /* Number of signals delivered. */ + long int ru_nvcsw; /* Number of voluntary context switches, i.e. because the proce */ + long int ru_nivcsw; /* Number of involuntary context switches, i.e. a higher priori */ + }; + + +/* Priority limits.*/ + + + +/* The type of the WHICH argument to `getpriority' and `setpriority', +indicating what flavor of entity the WHO argument specifies.*/ + + + enum __priority_which { + PRIO_PROCESS = 0, /* WHO is a process ID. */ + PRIO_PGRP = 1, /* WHO is a process group ID. */ + PRIO_USER = 2 /* WHO is a user ID. */ + }; + + +#define PRIO_PGRP PRIO_PGRP +#define PRIO_PROCESS PRIO_PROCESS +#define PRIO_USER PRIO_USER + + + typedef enum __priority_which __priority_which_t; + + + extern int getpriority(__priority_which_t, id_t); + extern int getrlimit64(id_t, struct rlimit64 *); + extern int setpriority(__priority_which_t, id_t, int); + extern int setrlimit(__rlimit_resource_t, const struct rlimit *); + extern int setrlimit64(__rlimit_resource_t, const struct rlimit64 *); + extern int getrlimit(__rlimit_resource_t, struct rlimit *); + extern int getrusage(int, struct rusage *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/sys/select.h b/lsb-build/headers/sys/select.h new file mode 100644 index 0000000..4b59863 --- /dev/null +++ b/lsb-build/headers/sys/select.h @@ -0,0 +1,17 @@ +#ifndef _SYS_SELECT_H_ +#define _SYS_SELECT_H_ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#define NFDBITS (8 * sizeof (long)) + + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/sys/time.h b/lsb-build/headers/sys/time.h new file mode 100644 index 0000000..d379a29 --- /dev/null +++ b/lsb-build/headers/sys/time.h @@ -0,0 +1,69 @@ +#ifndef _SYS_TIME_H_ +#define _SYS_TIME_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define ITIMER_REAL 0 +#define ITIMER_VIRTUAL 1 +#define ITIMER_PROF 2 + + + struct timezone { + int tz_minuteswest; + int tz_dsttime; + }; + + + + + +/* Values for the first argument to `getitimer' and `setitimer'.*/ + + + typedef int __itimer_which_t; + + + + + struct timespec { + time_t tv_sec; + long int tv_nsec; + }; + + + + + + + + struct timeval { + time_t tv_sec; + suseconds_t tv_usec; + }; + + +/* Type of the second argument to `getitimer' and +the second and third arguments `setitimer'.*/ + + + struct itimerval { + struct timeval it_interval; + struct timeval it_value; + }; + + + extern int getitimer(__itimer_which_t, struct itimerval *); + extern int setitimer(__itimer_which_t, const struct itimerval *, + struct itimerval *); + extern int adjtime(const struct timeval *, struct timeval *); + extern int gettimeofday(struct timeval *, struct timezone *); + extern int utimes(const char *, const struct timeval *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/sys/types.h b/lsb-build/headers/sys/types.h new file mode 100644 index 0000000..fb9b6c7 --- /dev/null +++ b/lsb-build/headers/sys/types.h @@ -0,0 +1,249 @@ +#ifndef _SYS_TYPES_H_ +#define _SYS_TYPES_H_ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#define FALSE 0 +#define TRUE 1 +#define FD_SETSIZE 1024 +#define FD_ZERO(fdsetp) bzero(fdsetp, sizeof(*(fdsetp))) +#define FD_ISSET(d,set) \ + ((set)->fds_bits[((d)/(8*sizeof(long)))]&(1<<((d)%(8*sizeof(long))))) +#define FD_CLR(d,set) \ + ((set)->fds_bits[((d)/(8*sizeof(long)))]&=~(1<<((d)%(8*sizeof(long))))) +#define FD_SET(d,set) \ + ((set)->fds_bits[((d)/(8*sizeof(long)))]|=(1<<((d)%(8*sizeof(long))))) + + + typedef signed char int8_t; + + typedef short int16_t; + + typedef int int32_t; + +#if __i386__ +/* IA32 */ + typedef long long int int64_t; + +#endif + typedef unsigned char u_int8_t; + + typedef unsigned short u_int16_t; + + typedef unsigned int u_int32_t; + + typedef unsigned int uid_t; + + typedef int pid_t; + + typedef long int off_t; + + typedef int key_t; + + typedef long int suseconds_t; + + typedef unsigned int u_int; + + typedef struct { + int __val[2]; + } fsid_t; + + typedef unsigned int useconds_t; + + typedef unsigned long int blksize_t; + + typedef long int fd_mask; + + typedef int timer_t; + + typedef int clockid_t; + +#if __ia64__ +/* IA64 */ + typedef long int int64_t; + +#endif +#if __powerpc64__ +/* PPC64 */ + typedef long int int64_t; + +#endif +#if __x86_64__ +/* x86-64 */ + typedef long int int64_t; + +#endif +#if __s390x__ +/* S390X */ + typedef long int int64_t; + +#endif +#if __powerpc__ && !__powerpc64__ +/* PPC32 */ + typedef long long int int64_t; + +#endif +#if __s390__ && !__s390x__ +/* S390 */ + typedef long long int int64_t; + +#endif + +/* These types are derived from the ones above*/ + + +#if __i386__ +/* IA32 */ + typedef int32_t ssize_t; + +#endif + typedef unsigned int id_t; + +#if __powerpc__ && !__powerpc64__ +/* PPC32 */ + typedef int32_t ssize_t; + +#endif +#if __ia64__ +/* IA64 */ + typedef int64_t ssize_t; + +#endif +#if __s390__ && !__s390x__ +/* S390 */ + typedef int32_t ssize_t; + +#endif +#if __powerpc64__ +/* PPC64 */ + typedef int64_t ssize_t; + +#endif +#if __x86_64__ +/* x86-64 */ + typedef int64_t ssize_t; + +#endif +#if __s390x__ +/* S390X */ + typedef int64_t ssize_t; + +#endif + +/* Stuff that really in bits/types.h*/ + + + typedef unsigned long long int ino64_t; + + typedef long long int loff_t; + + typedef unsigned long int blkcnt_t; + + typedef unsigned long int fsblkcnt_t; + + typedef unsigned long int fsfilcnt_t; + + typedef unsigned long long int blkcnt64_t; + + typedef unsigned long long int fsblkcnt64_t; + + typedef unsigned long long int fsfilcnt64_t; + + typedef unsigned char u_char; + + typedef unsigned short u_short; + + typedef unsigned long int u_long; + + +/* Stuff really in linux/types.h*/ + + + typedef unsigned long int ino_t; + + typedef unsigned int gid_t; + + typedef unsigned long long int dev_t; + + typedef unsigned int mode_t; + + typedef unsigned long int nlink_t; + + typedef char *caddr_t; + + +#if __ia64__ +#define __FDSET_LONGS 16 +#endif +#if __powerpc64__ +#define __FDSET_LONGS 16 +#endif +#if __x86_64__ +#define __FDSET_LONGS 16 +#endif +#if __s390x__ +#define __FDSET_LONGS 16 +#endif +#if __i386__ +#define __FDSET_LONGS 32 +#endif +#if __powerpc__ && !__powerpc64__ +#define __FDSET_LONGS 32 +#endif +#if __s390__ && !__s390x__ +#define __FDSET_LONGS 32 +#endif + + + typedef struct { + unsigned long int fds_bits[__FDSET_LONGS]; + } fd_set; + + +/* Time related types*/ + + + typedef long int clock_t; + + typedef long int time_t; + + +/* Setup some values*/ +#define __LITTLE_ENDIAN 1234 +#define __BIG_ENDIAN 4321 + + + +/* Per Architecture settings*/ +#if __powerpc__ && !__powerpc64__ +#define __BYTE_ORDER __BIG_ENDIAN +#endif +#if __powerpc64__ +#define __BYTE_ORDER __BIG_ENDIAN +#endif +#if __s390__ && !__s390x__ +#define __BYTE_ORDER __BIG_ENDIAN +#endif +#if __s390x__ +#define __BYTE_ORDER __BIG_ENDIAN +#endif +#if __i386__ +#define __BYTE_ORDER __LITTLE_ENDIAN +#endif +#if __ia64__ +#define __BYTE_ORDER __LITTLE_ENDIAN +#endif +#if __x86_64__ +#define __BYTE_ORDER __LITTLE_ENDIAN +#endif + + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/sys/wait.h b/lsb-build/headers/sys/wait.h new file mode 100644 index 0000000..777a777 --- /dev/null +++ b/lsb-build/headers/sys/wait.h @@ -0,0 +1,38 @@ +#ifndef _SYS_WAIT_H_ +#define _SYS_WAIT_H_ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define WIFSIGNALED(status) (!WIFSTOPPED(status) && !WIFEXITED(status)) +#define WIFSTOPPED(status) (((status) & 0xff) == 0x7f) +#define WEXITSTATUS(status) (((status) & 0xff00) >> 8) +#define WTERMSIG(status) ((status) & 0x7f) +#define WCOREDUMP(status) ((status) & 0x80) +#define WIFEXITED(status) (WTERMSIG(status) == 0) +#define WNOHANG 0x00000001 +#define WUNTRACED 0x00000002 +#define WCOREFLAG 0x80 +#define WSTOPSIG(status) WEXITSTATUS(status) + + + typedef enum { + P_ALL, + P_PID, + P_PGID + } idtype_t; + + + extern pid_t wait(int *); + extern pid_t waitpid(pid_t, int *, int); + extern pid_t wait4(pid_t, int *, int, struct rusage *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/time.h b/lsb-build/headers/time.h new file mode 100644 index 0000000..c5f2c17 --- /dev/null +++ b/lsb-build/headers/time.h @@ -0,0 +1,100 @@ +#ifndef _TIME_H_ +#define _TIME_H_ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define CLK_TCK ((clock_t)__sysconf(2)) +#define CLOCK_REALTIME 0 +#define TIMER_ABSTIME 1 +#define CLOCKS_PER_SEC 1000000l + + + struct tm { + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; + long int tm_gmtoff; + char *tm_zone; + }; + + struct itimerspec { + struct timespec it_interval; + struct timespec it_value; + }; + + + + + +/* Returned by clock()*/ + + + +/* Returned by `time'*/ + + + +/* POSIX.1b structure for a time value.*/ + + + +/* Used by other time functions.*/ + + + + extern int __daylight; + extern long int __timezone; + extern char *__tzname[2]; + extern char *asctime(const struct tm *); + extern clock_t clock(void); + extern char *ctime(const time_t *); + extern char *ctime_r(const time_t *, char *); + extern double difftime(time_t, time_t); + extern struct tm *getdate(const char *); + extern int getdate_err; + extern struct tm *gmtime(const time_t *); + extern struct tm *localtime(const time_t *); + extern time_t mktime(struct tm *); + extern int stime(const time_t *); + extern size_t strftime(char *, size_t, const char *, + const struct tm *); + extern char *strptime(const char *, const char *, struct tm *); + extern time_t time(time_t *); + extern int nanosleep(const struct timespec *, struct timespec *); + extern int daylight; + extern long int timezone; + extern char *tzname[2]; + extern void tzset(void); + extern char *asctime_r(const struct tm *, char *); + extern struct tm *gmtime_r(const time_t *, struct tm *); + extern struct tm *localtime_r(const time_t *, struct tm *); + extern int clock_getcpuclockid(pid_t, clockid_t *); + extern int clock_getres(clockid_t, struct timespec *); + extern int clock_gettime(clockid_t, struct timespec *); + extern int clock_nanosleep(clockid_t, int, const struct timespec *, + struct timespec *); + extern int clock_settime(clockid_t, const struct timespec *); + extern int timer_create(clockid_t, struct sigevent *, timer_t *); + extern int timer_delete(timer_t); + extern int timer_getoverrun(timer_t); + extern int timer_gettime(timer_t, struct itimerspec *); + extern int timer_settime(timer_t, int, const struct itimerspec *, + struct itimerspec *); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/unistd.h b/lsb-build/headers/unistd.h new file mode 100644 index 0000000..3768c6a --- /dev/null +++ b/lsb-build/headers/unistd.h @@ -0,0 +1,372 @@ +#ifndef _UNISTD_H_ +#define _UNISTD_H_ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#define SEEK_SET 0 +#define STDIN_FILENO 0 +#define SEEK_CUR 1 +#define STDOUT_FILENO 1 +#define SEEK_END 2 +#define STDERR_FILENO 2 + + + typedef long long int off64_t; + +#if __i386__ +/* IA32 */ + typedef int intptr_t; + +#endif +#if __ia64__ +/* IA64 */ + typedef long int intptr_t; + +#endif +#if __powerpc64__ +/* PPC64 */ + typedef long int intptr_t; + +#endif +#if __powerpc__ && !__powerpc64__ +/* PPC32 */ + typedef int intptr_t; + +#endif +#if __s390__ && !__s390x__ +/* S390 */ + typedef int intptr_t; + +#endif +#if __x86_64__ +/* x86-64 */ + typedef long int intptr_t; + +#endif + +/* Values for the second argument to access.*/ +#define F_OK 0 +#define X_OK 1 +#define W_OK 2 +#define R_OK 4 + + + +#define _POSIX_VDISABLE '\0' +#define _POSIX_CHOWN_RESTRICTED 1 +#define _POSIX_JOB_CONTROL 1 +#define _POSIX_NO_TRUNC 1 +#define _POSIX_SHELL 1 +#define _POSIX_FSYNC 200112 +#define _POSIX_MAPPED_FILES 200112 +#define _POSIX_MEMLOCK 200112 +#define _POSIX_MEMLOCK_RANGE 200112 +#define _POSIX_MEMORY_PROTECTION 200112 +#define _POSIX_SEMAPHORES 200112 +#define _POSIX_SHARED_MEMORY_OBJECTS 200112 +#define _POSIX_TIMERS 200112 +#define _POSIX2_C_BIND 200112L +#define _POSIX2_VERSION 200112L +#define _POSIX_THREADS 200112L +#define _POSIX_VERSION 200112L + + + +/* `pathconf' NAME values.*/ +#define _PC_LINK_MAX 0 +#define _PC_MAX_CANON 1 +#define _PC_ASYNC_IO 10 +#define _PC_PRIO_IO 11 +#define _PC_FILESIZEBITS 13 +#define _PC_REC_INCR_XFER_SIZE 14 +#define _PC_REC_MIN_XFER_SIZE 16 +#define _PC_REC_XFER_ALIGN 17 +#define _PC_ALLOC_SIZE_MIN 18 +#define _PC_MAX_INPUT 2 +#define _PC_2_SYMLINKS 20 +#define _PC_NAME_MAX 3 +#define _PC_PATH_MAX 4 +#define _PC_PIPE_BUF 5 +#define _PC_CHOWN_RESTRICTED 6 +#define _PC_NO_TRUNC 7 +#define _PC_VDISABLE 8 +#define _PC_SYNC_IO 9 + + + +/* `sysconf' NAME values.*/ +#define _SC_ARG_MAX 0 +#define _SC_CHILD_MAX 1 +#define _SC_PRIORITY_SCHEDULING 10 +#define _SC_TIMERS 11 +#define _SC_ASYNCHRONOUS_IO 12 +#define _SC_XBS5_ILP32_OFF32 125 +#define _SC_XBS5_ILP32_OFFBIG 126 +#define _SC_XBS5_LP64_OFF64 127 +#define _SC_XBS5_LPBIG_OFFBIG 128 +#define _SC_XOPEN_LEGACY 129 +#define _SC_PRIORITIZED_IO 13 +#define _SC_XOPEN_REALTIME 130 +#define _SC_XOPEN_REALTIME_THREADS 131 +#define _SC_ADVISORY_INFO 132 +#define _SC_BARRIERS 133 +#define _SC_CLOCK_SELECTION 137 +#define _SC_CPUTIME 138 +#define _SC_THREAD_CPUTIME 139 +#define _SC_SYNCHRONIZED_IO 14 +#define _SC_MONOTONIC_CLOCK 149 +#define _SC_FSYNC 15 +#define _SC_READER_WRITER_LOCKS 153 +#define _SC_SPIN_LOCKS 154 +#define _SC_REGEXP 155 +#define _SC_SHELL 157 +#define _SC_SPAWN 159 +#define _SC_MAPPED_FILES 16 +#define _SC_SPORADIC_SERVER 160 +#define _SC_THREAD_SPORADIC_SERVER 161 +#define _SC_TIMEOUTS 164 +#define _SC_TYPED_MEMORY_OBJECTS 165 +#define _SC_2_PBS_ACCOUNTING 169 +#define _SC_MEMLOCK 17 +#define _SC_2_PBS_LOCATE 170 +#define _SC_2_PBS_MESSAGE 171 +#define _SC_2_PBS_TRACK 172 +#define _SC_SYMLOOP_MAX 173 +#define _SC_2_PBS_CHECKPOINT 175 +#define _SC_V6_ILP32_OFF32 176 +#define _SC_V6_ILP32_OFFBIG 177 +#define _SC_V6_LP64_OFF64 178 +#define _SC_V6_LPBIG_OFFBIG 179 +#define _SC_MEMLOCK_RANGE 18 +#define _SC_HOST_NAME_MAX 180 +#define _SC_TRACE 181 +#define _SC_TRACE_EVENT_FILTER 182 +#define _SC_TRACE_INHERIT 183 +#define _SC_TRACE_LOG 184 +#define _SC_MEMORY_PROTECTION 19 +#define _SC_CLK_TCK 2 +#define _SC_MESSAGE_PASSING 20 +#define _SC_SEMAPHORES 21 +#define _SC_SHARED_MEMORY_OBJECTS 22 +#define _SC_AIO_LISTIO_MAX 23 +#define _SC_AIO_MAX 24 +#define _SC_AIO_PRIO_DELTA_MAX 25 +#define _SC_DELAYTIMER_MAX 26 +#define _SC_MQ_OPEN_MAX 27 +#define _SC_MQ_PRIO_MAX 28 +#define _SC_VERSION 29 +#define _SC_NGROUPS_MAX 3 +#define _SC_PAGESIZE 30 +#define _SC_PAGE_SIZE 30 +#define _SC_RTSIG_MAX 31 +#define _SC_SEM_NSEMS_MAX 32 +#define _SC_SEM_VALUE_MAX 33 +#define _SC_SIGQUEUE_MAX 34 +#define _SC_TIMER_MAX 35 +#define _SC_BC_BASE_MAX 36 +#define _SC_BC_DIM_MAX 37 +#define _SC_BC_SCALE_MAX 38 +#define _SC_BC_STRING_MAX 39 +#define _SC_OPEN_MAX 4 +#define _SC_COLL_WEIGHTS_MAX 40 +#define _SC_EXPR_NEST_MAX 42 +#define _SC_LINE_MAX 43 +#define _SC_RE_DUP_MAX 44 +#define _SC_2_VERSION 46 +#define _SC_2_C_BIND 47 +#define _SC_2_C_DEV 48 +#define _SC_2_FORT_DEV 49 +#define _SC_STREAM_MAX 5 +#define _SC_2_FORT_RUN 50 +#define _SC_2_SW_DEV 51 +#define _SC_2_LOCALEDEF 52 +#define _SC_TZNAME_MAX 6 +#define _SC_IOV_MAX 60 +#define _SC_THREADS 67 +#define _SC_THREAD_SAFE_FUNCTIONS 68 +#define _SC_GETGR_R_SIZE_MAX 69 +#define _SC_JOB_CONTROL 7 +#define _SC_GETPW_R_SIZE_MAX 70 +#define _SC_LOGIN_NAME_MAX 71 +#define _SC_TTY_NAME_MAX 72 +#define _SC_THREAD_DESTRUCTOR_ITERATIONS 73 +#define _SC_THREAD_KEYS_MAX 74 +#define _SC_THREAD_STACK_MIN 75 +#define _SC_THREAD_THREADS_MAX 76 +#define _SC_THREAD_ATTR_STACKADDR 77 +#define _SC_THREAD_ATTR_STACKSIZE 78 +#define _SC_THREAD_PRIORITY_SCHEDULING 79 +#define _SC_SAVED_IDS 8 +#define _SC_THREAD_PRIO_INHERIT 80 +#define _SC_THREAD_PRIO_PROTECT 81 +#define _SC_THREAD_PROCESS_SHARED 82 +#define _SC_ATEXIT_MAX 87 +#define _SC_PASS_MAX 88 +#define _SC_XOPEN_VERSION 89 +#define _SC_REALTIME_SIGNALS 9 +#define _SC_XOPEN_UNIX 91 +#define _SC_XOPEN_CRYPT 92 +#define _SC_XOPEN_ENH_I18N 93 +#define _SC_XOPEN_SHM 94 +#define _SC_2_CHAR_TERM 95 +#define _SC_2_C_VERSION 96 +#define _SC_2_UPE 97 + + + +/* `confstr' NAME values.*/ +#define _CS_PATH 0 +#define _POSIX_REGEXP 1 +#define _CS_XBS5_ILP32_OFF32_CFLAGS 1100 +#define _CS_XBS5_ILP32_OFF32_LDFLAGS 1101 +#define _CS_XBS5_ILP32_OFF32_LIBS 1102 +#define _CS_XBS5_ILP32_OFF32_LINTFLAGS 1103 +#define _CS_XBS5_ILP32_OFFBIG_CFLAGS 1104 +#define _CS_XBS5_ILP32_OFFBIG_LDFLAGS 1105 +#define _CS_XBS5_ILP32_OFFBIG_LIBS 1106 +#define _CS_XBS5_ILP32_OFFBIG_LINTFLAGS 1107 +#define _CS_XBS5_LP64_OFF64_CFLAGS 1108 +#define _CS_XBS5_LP64_OFF64_LDFLAGS 1109 +#define _CS_XBS5_LP64_OFF64_LIBS 1110 +#define _CS_XBS5_LP64_OFF64_LINTFLAGS 1111 +#define _CS_XBS5_LPBIG_OFFBIG_CFLAGS 1112 +#define _CS_XBS5_LPBIG_OFFBIG_LDFLAGS 1113 +#define _CS_XBS5_LPBIG_OFFBIG_LIBS 1114 +#define _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS 1115 + + + +#define _XOPEN_XPG4 1 +#define _XOPEN_VERSION 500 + + + +/* Flags for lockf()*/ +#define F_ULOCK 0 +#define F_LOCK 1 +#define F_TLOCK 2 +#define F_TEST 3 + + + + extern char **__environ; + extern pid_t __getpgid(pid_t); + extern void _exit(int); + extern int acct(const char *); + extern unsigned int alarm(unsigned int); + extern int chown(const char *, uid_t, gid_t); + extern int chroot(const char *); + extern size_t confstr(int, char *, size_t); + extern int creat(const char *, mode_t); + extern int creat64(const char *, mode_t); + extern char *ctermid(char *); + extern char *cuserid(char *); + extern int daemon(int, int); + extern int execl(const char *, const char *, ...); + extern int execle(const char *, const char *, ...); + extern int execlp(const char *, const char *, ...); + extern int execv(const char *, char *const[]); + extern int execvp(const char *, char *const[]); + extern int fdatasync(int); + extern int ftruncate64(int, off64_t); + extern long int gethostid(void); + extern char *getlogin(void); + extern int getlogin_r(char *, size_t); + extern int getopt(int, char *const[], const char *); + extern pid_t getpgrp(void); + extern pid_t getsid(pid_t); + extern char *getwd(char *); + extern int lockf(int, int, off_t); + extern int mkstemp(char *); + extern int nice(int); + extern char *optarg; + extern int opterr; + extern int optind; + extern int optopt; + extern int rename(const char *, const char *); + extern int setegid(gid_t); + extern int seteuid(uid_t); + extern int sethostname(const char *, size_t); + extern int setpgrp(void); + extern void swab(const void *, void *, ssize_t); + extern void sync(void); + extern pid_t tcgetpgrp(int); + extern int tcsetpgrp(int, pid_t); + extern int truncate(const char *, off_t); + extern int truncate64(const char *, off64_t); + extern char *ttyname(int); + extern unsigned int ualarm(useconds_t, useconds_t); + extern int usleep(useconds_t); + extern int close(int); + extern int fsync(int); + extern off_t lseek(int, off_t, int); + extern int open(const char *, int, ...); + extern int pause(void); + extern ssize_t read(int, void *, size_t); + extern ssize_t write(int, const void *, size_t); + extern char *crypt(const char *, const char *); + extern void encrypt(char *, int); + extern void setkey(const char *); + extern int access(const char *, int); + extern int brk(void *); + extern int chdir(const char *); + extern int dup(int); + extern int dup2(int, int); + extern int execve(const char *, char *const[], char *const[]); + extern int fchdir(int); + extern int fchown(int, uid_t, gid_t); + extern pid_t fork(void); + extern gid_t getegid(void); + extern uid_t geteuid(void); + extern gid_t getgid(void); + extern int getgroups(int, gid_t[]); + extern int gethostname(char *, size_t); + extern pid_t getpgid(pid_t); + extern pid_t getpid(void); + extern uid_t getuid(void); + extern int lchown(const char *, uid_t, gid_t); + extern int link(const char *, const char *); + extern int mkdir(const char *, mode_t); + extern long int pathconf(const char *, int); + extern int pipe(int[2]); + extern int readlink(const char *, char *, size_t); + extern int rmdir(const char *); + extern void *sbrk(ptrdiff_t); + extern int select(int, fd_set *, fd_set *, fd_set *, struct timeval *); + extern int setgid(gid_t); + extern int setpgid(pid_t, pid_t); + extern int setregid(gid_t, gid_t); + extern int setreuid(uid_t, uid_t); + extern pid_t setsid(void); + extern int setuid(uid_t); + extern unsigned int sleep(unsigned int); + extern int symlink(const char *, const char *); + extern long int sysconf(int); + extern int unlink(const char *); + extern pid_t vfork(void); + extern ssize_t pread(int, void *, size_t, off_t); + extern ssize_t pwrite(int, const void *, size_t, off_t); + extern char **_environ; + extern long int fpathconf(int, int); + extern int ftruncate(int, off_t); + extern char *getcwd(char *, size_t); + extern int getpagesize(void); + extern pid_t getppid(void); + extern int isatty(int); + extern loff_t lseek64(int, loff_t, int); + extern int open64(const char *, int, ...); + extern ssize_t pread64(int, void *, size_t, off64_t); + extern ssize_t pwrite64(int, const void *, size_t, off64_t); + extern int ttyname_r(int, char *, size_t); + extern int mknod(const char *, mode_t, dev_t); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/headers/wctype.h b/lsb-build/headers/wctype.h new file mode 100644 index 0000000..0af6ed1 --- /dev/null +++ b/lsb-build/headers/wctype.h @@ -0,0 +1,52 @@ +#ifndef _WCTYPE_H_ +#define _WCTYPE_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + + + + typedef unsigned long int wctype_t; + + typedef unsigned int wint_t; + + typedef const int32_t *wctrans_t; + + typedef struct { + int count; + wint_t value; + } __mbstate_t; + + +/* This really belongs in wchar.h, but it's presense creates a circular dependency with stdio.h, so put it here to break the circle.*/ + + + typedef __mbstate_t mbstate_t; + + + extern int iswblank(wint_t); + extern wint_t towlower(wint_t); + extern wint_t towupper(wint_t); + extern wctrans_t wctrans(const char *); + extern int iswalnum(wint_t); + extern int iswalpha(wint_t); + extern int iswcntrl(wint_t); + extern int iswctype(wint_t, wctype_t); + extern int iswdigit(wint_t); + extern int iswgraph(wint_t); + extern int iswlower(wint_t); + extern int iswprint(wint_t); + extern int iswpunct(wint_t); + extern int iswspace(wint_t); + extern int iswupper(wint_t); + extern int iswxdigit(wint_t); + extern wctype_t wctype(const char *); + extern wint_t towctrans(wint_t, wctrans_t); +#ifdef __cplusplus +} +#endif +#endif diff --git a/lsb-build/stub_libs/LibNameMap.txt b/lsb-build/stub_libs/LibNameMap.txt new file mode 100644 index 0000000..7a9cc64 --- /dev/null +++ b/lsb-build/stub_libs/LibNameMap.txt @@ -0,0 +1,44 @@ +libGL libGL.so.1 +libICE libICE.so.6 +libQtCore libQtCore.so.4 +libQtGui libQtGui.so.4 +libQtNetwork libQtNetwork.so.4 +libQtOpenGL libQtOpenGL.so.4 +libQtSql libQtSql.so.4 +libQtSvg libQtSvg.so.4 +libQtXml libQtXml.so.4 +libSM libSM.so.6 +libX11 libX11.so.6 +libXext libXext.so.6 +libXi libXi.so.6 +libXt libXt.so.6 +libatk-1.0 libatk-1.0.so.0 +libc_main libc.so.6 +libcrypt libcrypt.so.1 +libdl libdl.so.2 +libfontconfig libfontconfig.so.1 +libgcc_s libgcc_s.so.1 +libgdk-x11-2.0 libgdk-x11-2.0.so.0 +libgdk_pixbuf-2.0 libgdk_pixbuf-2.0.so.0 +libgdk_pixbuf_xlib-2.0 libgdk_pixbuf_xlib-2.0.so.0 +libglib-2.0 libglib-2.0.so.0 +libgmodule-2.0 libgmodule-2.0.so.0 +libgobject-2.0 libgobject-2.0.so.0 +libgthread-2.0 libgthread-2.0.so.0 +libgtk-x11-2.0 libgtk-x11-2.0.so.0 +libjpeg libjpeg.so.62 +libm libm.so.6 +libncurses libncurses.so.5 +libpam libpam.so.0 +libpango-1.0 libpango-1.0.so.0 +libpangoft2-1.0 libpangoft2-1.0.so.0 +libpangoxft-1.0 libpangoxft-1.0.so.0 +libpng12 libpng12.so.0 +libpthread libpthread.so.0 +libqt-mt libqt-mt.so.3 +librt librt.so.1 +libstdcxx libstdc++.so.6 +libutil libutil.so.1 +libxml2 libxml2.so.2 +libz libz.so.1 +proginterp /lib/ld-lsb.so.3 diff --git a/lsb-build/stub_libs/core_filelist b/lsb-build/stub_libs/core_filelist new file mode 100644 index 0000000..5d7038f --- /dev/null +++ b/lsb-build/stub_libs/core_filelist @@ -0,0 +1,7 @@ +libdl +libc_main +libpthread +libgcc_s +libX11 +libXt +libXext diff --git a/lsb-build/stub_libs/core_static_filelist b/lsb-build/stub_libs/core_static_filelist new file mode 100644 index 0000000..4b431d6 --- /dev/null +++ b/lsb-build/stub_libs/core_static_filelist @@ -0,0 +1 @@ +libc_nonshared diff --git a/lsb-build/stub_libs/desktop_filelist b/lsb-build/stub_libs/desktop_filelist new file mode 100644 index 0000000..795f51b --- /dev/null +++ b/lsb-build/stub_libs/desktop_filelist @@ -0,0 +1,5 @@ +libglib-2.0 +libgobject-2.0 +libgthread-2.0 +libgdk-x11-2.0 +libgtk-x11-2.0 diff --git a/lsb-build/stub_libs/libX11.Version b/lsb-build/stub_libs/libX11.Version new file mode 100644 index 0000000..08a3220 --- /dev/null +++ b/lsb-build/stub_libs/libX11.Version @@ -0,0 +1 @@ +LSB_DUMMY { __LSB_DUMMY; }; diff --git a/lsb-build/stub_libs/libX11.c b/lsb-build/stub_libs/libX11.c new file mode 100644 index 0000000..bb0e1c4 --- /dev/null +++ b/lsb-build/stub_libs/libX11.c @@ -0,0 +1,716 @@ +void XActivateScreenSaver() {} ; +void XAddConnectionWatch() {} ; +void XAddExtension() {} ; +void XAddHost() {} ; +void XAddHosts() {} ; +void XAddPixel() {} ; +void XAddToExtensionList() {} ; +void XAddToSaveSet() {} ; +void XAllPlanes() {} ; +void XAllocClassHint() {} ; +void XAllocColor() {} ; +void XAllocColorCells() {} ; +void XAllocColorPlanes() {} ; +void XAllocIconSize() {} ; +void XAllocNamedColor() {} ; +void XAllocSizeHints() {} ; +void XAllocStandardColormap() {} ; +void XAllocWMHints() {} ; +void XAllowEvents() {} ; +void XAutoRepeatOff() {} ; +void XAutoRepeatOn() {} ; +void XBaseFontNameListOfFontSet() {} ; +void XBell() {} ; +void XBitmapBitOrder() {} ; +void XBitmapPad() {} ; +void XBitmapUnit() {} ; +void XBlackPixel() {} ; +void XBlackPixelOfScreen() {} ; +void XCellsOfScreen() {} ; +void XChangeActivePointerGrab() {} ; +void XChangeGC() {} ; +void XChangeKeyboardControl() {} ; +void XChangeKeyboardMapping() {} ; +void XChangePointerControl() {} ; +void XChangeProperty() {} ; +void XChangeSaveSet() {} ; +void XChangeWindowAttributes() {} ; +void XCheckIfEvent() {} ; +void XCheckMaskEvent() {} ; +void XCheckTypedEvent() {} ; +void XCheckTypedWindowEvent() {} ; +void XCheckWindowEvent() {} ; +void XCirculateSubwindows() {} ; +void XCirculateSubwindowsDown() {} ; +void XCirculateSubwindowsUp() {} ; +void XClearArea() {} ; +void XClearWindow() {} ; +void XClipBox() {} ; +void XCloseDisplay() {} ; +void XCloseIM() {} ; +void XCloseOM() {} ; +void XConfigureWindow() {} ; +void XConnectionNumber() {} ; +void XContextDependentDrawing() {} ; +void XContextualDrawing() {} ; +void XConvertCase() {} ; +void XConvertSelection() {} ; +void XCopyArea() {} ; +void XCopyColormapAndFree() {} ; +void XCopyGC() {} ; +void XCopyPlane() {} ; +void XCreateBitmapFromData() {} ; +void XCreateColormap() {} ; +void XCreateFontCursor() {} ; +void XCreateFontSet() {} ; +void XCreateGC() {} ; +void XCreateGlyphCursor() {} ; +void XCreateIC() {} ; +void XCreateImage() {} ; +void XCreateOC() {} ; +void XCreatePixmap() {} ; +void XCreatePixmapCursor() {} ; +void XCreatePixmapFromBitmapData() {} ; +void XCreateRegion() {} ; +void XCreateSimpleWindow() {} ; +void XCreateWindow() {} ; +void XDefaultColormap() {} ; +void XDefaultColormapOfScreen() {} ; +void XDefaultDepth() {} ; +void XDefaultDepthOfScreen() {} ; +void XDefaultGC() {} ; +void XDefaultGCOfScreen() {} ; +void XDefaultRootWindow() {} ; +void XDefaultScreen() {} ; +void XDefaultScreenOfDisplay() {} ; +void XDefaultString() {} ; +void XDefaultVisual() {} ; +void XDefaultVisualOfScreen() {} ; +void XDefineCursor() {} ; +void XDeleteContext() {} ; +void XDeleteModifiermapEntry() {} ; +void XDeleteProperty() {} ; +void XDestroyIC() {} ; +void XDestroyImage() {} ; +void XDestroyOC() {} ; +void XDestroyRegion() {} ; +void XDestroySubwindows() {} ; +void XDestroyWindow() {} ; +void XDirectionalDependentDrawing() {} ; +void XDisableAccessControl() {} ; +void XDisplayCells() {} ; +void XDisplayHeight() {} ; +void XDisplayHeightMM() {} ; +void XDisplayKeycodes() {} ; +void XDisplayMotionBufferSize() {} ; +void XDisplayName() {} ; +void XDisplayOfIM() {} ; +void XDisplayOfOM() {} ; +void XDisplayOfScreen() {} ; +void XDisplayPlanes() {} ; +void XDisplayString() {} ; +void XDisplayWidth() {} ; +void XDisplayWidthMM() {} ; +void XDoesBackingStore() {} ; +void XDoesSaveUnders() {} ; +void XDrawArc() {} ; +void XDrawArcs() {} ; +void XDrawImageString() {} ; +void XDrawImageString16() {} ; +void XDrawLine() {} ; +void XDrawLines() {} ; +void XDrawPoint() {} ; +void XDrawPoints() {} ; +void XDrawRectangle() {} ; +void XDrawRectangles() {} ; +void XDrawSegments() {} ; +void XDrawString() {} ; +void XDrawString16() {} ; +void XDrawText() {} ; +void XDrawText16() {} ; +void XEHeadOfExtensionList() {} ; +void XESetBeforeFlush() {} ; +void XESetCloseDisplay() {} ; +void XESetCopyGC() {} ; +void XESetCreateFont() {} ; +void XESetCreateGC() {} ; +void XESetError() {} ; +void XESetErrorString() {} ; +void XESetEventToWire() {} ; +void XESetFlushGC() {} ; +void XESetFreeFont() {} ; +void XESetFreeGC() {} ; +void XESetPrintErrorValues() {} ; +void XESetWireToError() {} ; +void XESetWireToEvent() {} ; +void XEmptyRegion() {} ; +void XEnableAccessControl() {} ; +void XEqualRegion() {} ; +void XEventMaskOfScreen() {} ; +void XEventsQueued() {} ; +void XExtendedMaxRequestSize() {} ; +void XExtentsOfFontSet() {} ; +void XFetchBuffer() {} ; +void XFetchBytes() {} ; +void XFetchName() {} ; +void XFillArc() {} ; +void XFillArcs() {} ; +void XFillPolygon() {} ; +void XFillRectangle() {} ; +void XFillRectangles() {} ; +void XFilterEvent() {} ; +void XFindContext() {} ; +void XFindOnExtensionList() {} ; +void XFlush() {} ; +void XFlushGC() {} ; +void XFontsOfFontSet() {} ; +void XForceScreenSaver() {} ; +void XFree() {} ; +void XFreeColormap() {} ; +void XFreeColors() {} ; +void XFreeCursor() {} ; +void XFreeExtensionList() {} ; +void XFreeFont() {} ; +void XFreeFontInfo() {} ; +void XFreeFontNames() {} ; +void XFreeFontPath() {} ; +void XFreeFontSet() {} ; +void XFreeGC() {} ; +void XFreeModifiermap() {} ; +void XFreePixmap() {} ; +void XFreeStringList() {} ; +void XGContextFromGC() {} ; +void XGeometry() {} ; +void XGetAtomName() {} ; +void XGetAtomNames() {} ; +void XGetClassHint() {} ; +void XGetCommand() {} ; +void XGetDefault() {} ; +void XGetErrorDatabaseText() {} ; +void XGetErrorText() {} ; +void XGetFontPath() {} ; +void XGetFontProperty() {} ; +void XGetGCValues() {} ; +void XGetGeometry() {} ; +void XGetICValues() {} ; +void XGetIMValues() {} ; +void XGetIconName() {} ; +void XGetIconSizes() {} ; +void XGetImage() {} ; +void XGetInputFocus() {} ; +void XGetKeyboardControl() {} ; +void XGetKeyboardMapping() {} ; +void XGetModifierMapping() {} ; +void XGetMotionEvents() {} ; +void XGetNormalHints() {} ; +void XGetOCValues() {} ; +void XGetOMValues() {} ; +void XGetPixel() {} ; +void XGetPointerControl() {} ; +void XGetPointerMapping() {} ; +void XGetRGBColormaps() {} ; +void XGetScreenSaver() {} ; +void XGetSelectionOwner() {} ; +void XGetSizeHints() {} ; +void XGetStandardColormap() {} ; +void XGetSubImage() {} ; +void XGetTextProperty() {} ; +void XGetTransientForHint() {} ; +void XGetVisualInfo() {} ; +void XGetWMClientMachine() {} ; +void XGetWMColormapWindows() {} ; +void XGetWMHints() {} ; +void XGetWMIconName() {} ; +void XGetWMName() {} ; +void XGetWMNormalHints() {} ; +void XGetWMProtocols() {} ; +void XGetWMSizeHints() {} ; +void XGetWindowAttributes() {} ; +void XGetWindowProperty() {} ; +void XGetZoomHints() {} ; +void XGrabButton() {} ; +void XGrabKey() {} ; +void XGrabKeyboard() {} ; +void XGrabPointer() {} ; +void XGrabServer() {} ; +void XHeightMMOfScreen() {} ; +void XHeightOfScreen() {} ; +void XIMOfIC() {} ; +void XIconifyWindow() {} ; +void XIfEvent() {} ; +void XImageByteOrder() {} ; +void XInitExtension() {} ; +void XInitImage() {} ; +void XInitThreads() {} ; +void XInsertModifiermapEntry() {} ; +void XInstallColormap() {} ; +void XInternAtom() {} ; +void XInternAtoms() {} ; +void XInternalConnectionNumbers() {} ; +void XIntersectRegion() {} ; +void XKeycodeToKeysym() {} ; +void XKeysymToKeycode() {} ; +void XKeysymToString() {} ; +void XKillClient() {} ; +void XLastKnownRequestProcessed() {} ; +void XListDepths() {} ; +void XListExtensions() {} ; +void XListFonts() {} ; +void XListFontsWithInfo() {} ; +void XListHosts() {} ; +void XListInstalledColormaps() {} ; +void XListPixmapFormats() {} ; +void XListProperties() {} ; +void XLoadFont() {} ; +void XLoadQueryFont() {} ; +void XLocaleOfFontSet() {} ; +void XLocaleOfIM() {} ; +void XLocaleOfOM() {} ; +void XLockDisplay() {} ; +void XLookupColor() {} ; +void XLookupKeysym() {} ; +void XLookupString() {} ; +void XLowerWindow() {} ; +void XMapRaised() {} ; +void XMapSubwindows() {} ; +void XMapWindow() {} ; +void XMaskEvent() {} ; +void XMatchVisualInfo() {} ; +void XMaxCmapsOfScreen() {} ; +void XMaxRequestSize() {} ; +void XMinCmapsOfScreen() {} ; +void XMoveResizeWindow() {} ; +void XMoveWindow() {} ; +void XNewModifiermap() {} ; +void XNextEvent() {} ; +void XNextRequest() {} ; +void XNoOp() {} ; +void XOMOfOC() {} ; +void XOffsetRegion() {} ; +void XOpenDisplay() {} ; +void XOpenIM() {} ; +void XOpenOM() {} ; +void XParseColor() {} ; +void XParseGeometry() {} ; +void XPeekEvent() {} ; +void XPeekIfEvent() {} ; +void XPending() {} ; +void XPlanesOfScreen() {} ; +void XPointInRegion() {} ; +void XPolygonRegion() {} ; +void XProcessInternalConnection() {} ; +void XProtocolRevision() {} ; +void XProtocolVersion() {} ; +void XPutBackEvent() {} ; +void XPutImage() {} ; +void XPutPixel() {} ; +void XQLength() {} ; +void XQueryBestCursor() {} ; +void XQueryBestSize() {} ; +void XQueryBestStipple() {} ; +void XQueryBestTile() {} ; +void XQueryColor() {} ; +void XQueryColors() {} ; +void XQueryExtension() {} ; +void XQueryFont() {} ; +void XQueryKeymap() {} ; +void XQueryPointer() {} ; +void XQueryTextExtents() {} ; +void XQueryTextExtents16() {} ; +void XQueryTree() {} ; +void XRaiseWindow() {} ; +void XReadBitmapFile() {} ; +void XReadBitmapFileData() {} ; +void XRebindKeysym() {} ; +void XRecolorCursor() {} ; +void XReconfigureWMWindow() {} ; +void XRectInRegion() {} ; +void XRefreshKeyboardMapping() {} ; +void XRegisterIMInstantiateCallback() {} ; +void XRemoveConnectionWatch() {} ; +void XRemoveFromSaveSet() {} ; +void XRemoveHost() {} ; +void XRemoveHosts() {} ; +void XReparentWindow() {} ; +void XResetScreenSaver() {} ; +void XResizeWindow() {} ; +void XResourceManagerString() {} ; +void XRestackWindows() {} ; +void XRootWindow() {} ; +void XRootWindowOfScreen() {} ; +void XRotateBuffers() {} ; +void XRotateWindowProperties() {} ; +void XSaveContext() {} ; +void XScreenCount() {} ; +void XScreenNumberOfScreen() {} ; +void XScreenOfDisplay() {} ; +void XScreenResourceString() {} ; +void XSelectInput() {} ; +void XSendEvent() {} ; +void XServerVendor() {} ; +void XSetAccessControl() {} ; +void XSetArcMode() {} ; +void XSetAuthorization() {} ; +void XSetBackground() {} ; +void XSetClassHint() {} ; +void XSetClipMask() {} ; +void XSetClipOrigin() {} ; +void XSetClipRectangles() {} ; +void XSetCloseDownMode() {} ; +void XSetCommand() {} ; +void XSetDashes() {} ; +void XSetErrorHandler() {} ; +void XSetFillRule() {} ; +void XSetFillStyle() {} ; +void XSetFont() {} ; +void XSetFontPath() {} ; +void XSetForeground() {} ; +void XSetFunction() {} ; +void XSetGraphicsExposures() {} ; +void XSetICFocus() {} ; +void XSetICValues() {} ; +void XSetIMValues() {} ; +void XSetIOErrorHandler() {} ; +void XSetIconName() {} ; +void XSetIconSizes() {} ; +void XSetInputFocus() {} ; +void XSetLineAttributes() {} ; +void XSetLocaleModifiers() {} ; +void XSetModifierMapping() {} ; +void XSetNormalHints() {} ; +void XSetOCValues() {} ; +void XSetOMValues() {} ; +void XSetPlaneMask() {} ; +void XSetPointerMapping() {} ; +void XSetRGBColormaps() {} ; +void XSetRegion() {} ; +void XSetScreenSaver() {} ; +void XSetSelectionOwner() {} ; +void XSetSizeHints() {} ; +void XSetStandardColormap() {} ; +void XSetStandardProperties() {} ; +void XSetState() {} ; +void XSetStipple() {} ; +void XSetSubwindowMode() {} ; +void XSetTSOrigin() {} ; +void XSetTextProperty() {} ; +void XSetTile() {} ; +void XSetTransientForHint() {} ; +void XSetWMClientMachine() {} ; +void XSetWMColormapWindows() {} ; +void XSetWMHints() {} ; +void XSetWMIconName() {} ; +void XSetWMName() {} ; +void XSetWMNormalHints() {} ; +void XSetWMProperties() {} ; +void XSetWMProtocols() {} ; +void XSetWMSizeHints() {} ; +void XSetWindowBackground() {} ; +void XSetWindowBackgroundPixmap() {} ; +void XSetWindowBorder() {} ; +void XSetWindowBorderPixmap() {} ; +void XSetWindowBorderWidth() {} ; +void XSetWindowColormap() {} ; +void XSetZoomHints() {} ; +void XShrinkRegion() {} ; +void XStoreBuffer() {} ; +void XStoreBytes() {} ; +void XStoreColor() {} ; +void XStoreColors() {} ; +void XStoreName() {} ; +void XStoreNamedColor() {} ; +void XStringListToTextProperty() {} ; +void XStringToKeysym() {} ; +void XSubImage() {} ; +void XSubtractRegion() {} ; +void XSupportsLocale() {} ; +void XSync() {} ; +void XTextExtents() {} ; +void XTextExtents16() {} ; +void XTextPropertyToStringList() {} ; +void XTextWidth() {} ; +void XTextWidth16() {} ; +void XTranslateCoordinates() {} ; +void XUndefineCursor() {} ; +void XUngrabButton() {} ; +void XUngrabKey() {} ; +void XUngrabKeyboard() {} ; +void XUngrabPointer() {} ; +void XUngrabServer() {} ; +void XUninstallColormap() {} ; +void XUnionRectWithRegion() {} ; +void XUnionRegion() {} ; +void XUnloadFont() {} ; +void XUnlockDisplay() {} ; +void XUnmapSubwindows() {} ; +void XUnmapWindow() {} ; +void XUnregisterIMInstantiateCallback() {} ; +void XUnsetICFocus() {} ; +void XVaCreateNestedList() {} ; +void XVendorRelease() {} ; +void XVisualIDFromVisual() {} ; +void XWMGeometry() {} ; +void XWarpPointer() {} ; +void XWhitePixel() {} ; +void XWhitePixelOfScreen() {} ; +void XWidthMMOfScreen() {} ; +void XWidthOfScreen() {} ; +void XWindowEvent() {} ; +void XWithdrawWindow() {} ; +void XWriteBitmapFile() {} ; +void XXorRegion() {} ; +void XauDisposeAuth() {} ; +void XauFileName() {} ; +void XauGetBestAuthByAddr() {} ; +void XauReadAuth() {} ; +void XcmsAddColorSpace() {} ; +void XcmsAddFunctionSet() {} ; +void XcmsAllocColor() {} ; +void XcmsAllocNamedColor() {} ; +void XcmsCCCOfColormap() {} ; +void XcmsCIELabClipL() {} ; +void XcmsCIELabClipLab() {} ; +void XcmsCIELabClipab() {} ; +void XcmsCIELabQueryMaxC() {} ; +void XcmsCIELabQueryMaxL() {} ; +void XcmsCIELabQueryMaxLC() {} ; +void XcmsCIELabQueryMinL() {} ; +void XcmsCIELabToCIEXYZ() {} ; +void XcmsCIELabWhiteShiftColors() {} ; +void XcmsCIELuvClipL() {} ; +void XcmsCIELuvClipLuv() {} ; +void XcmsCIELuvClipuv() {} ; +void XcmsCIELuvQueryMaxC() {} ; +void XcmsCIELuvQueryMaxL() {} ; +void XcmsCIELuvQueryMaxLC() {} ; +void XcmsCIELuvQueryMinL() {} ; +void XcmsCIELuvToCIEuvY() {} ; +void XcmsCIELuvWhiteShiftColors() {} ; +void XcmsCIEXYZToCIELab() {} ; +void XcmsCIEXYZToCIEuvY() {} ; +void XcmsCIEXYZToCIExyY() {} ; +void XcmsCIEXYZToRGBi() {} ; +void XcmsCIEuvYToCIELuv() {} ; +void XcmsCIEuvYToCIEXYZ() {} ; +void XcmsCIEuvYToTekHVC() {} ; +void XcmsCIExyYToCIEXYZ() {} ; +void XcmsClientWhitePointOfCCC() {} ; +void XcmsConvertColors() {} ; +void XcmsCreateCCC() {} ; +void XcmsDefaultCCC() {} ; +void XcmsDisplayOfCCC() {} ; +void XcmsFormatOfPrefix() {} ; +void XcmsFreeCCC() {} ; +void XcmsLookupColor() {} ; +void XcmsPrefixOfFormat() {} ; +void XcmsQueryBlack() {} ; +void XcmsQueryBlue() {} ; +void XcmsQueryColor() {} ; +void XcmsQueryColors() {} ; +void XcmsQueryGreen() {} ; +void XcmsQueryRed() {} ; +void XcmsQueryWhite() {} ; +void XcmsRGBToRGBi() {} ; +void XcmsRGBiToCIEXYZ() {} ; +void XcmsRGBiToRGB() {} ; +void XcmsScreenNumberOfCCC() {} ; +void XcmsScreenWhitePointOfCCC() {} ; +void XcmsSetCCCOfColormap() {} ; +void XcmsSetCompressionProc() {} ; +void XcmsSetWhiteAdjustProc() {} ; +void XcmsSetWhitePoint() {} ; +void XcmsStoreColor() {} ; +void XcmsStoreColors() {} ; +void XcmsTekHVCClipC() {} ; +void XcmsTekHVCClipV() {} ; +void XcmsTekHVCClipVC() {} ; +void XcmsTekHVCQueryMaxC() {} ; +void XcmsTekHVCQueryMaxV() {} ; +void XcmsTekHVCQueryMaxVC() {} ; +void XcmsTekHVCQueryMaxVSamples() {} ; +void XcmsTekHVCQueryMinV() {} ; +void XcmsTekHVCToCIEuvY() {} ; +void XcmsTekHVCWhiteShiftColors() {} ; +void XcmsVisualOfCCC() {} ; +void XkbAllocClientMap() {} ; +void XkbAllocCompatMap() {} ; +void XkbAllocControls() {} ; +void XkbAllocGeomColors() {} ; +void XkbAllocGeomDoodads() {} ; +void XkbAllocGeomKeyAliases() {} ; +void XkbAllocGeomKeys() {} ; +void XkbAllocGeomOutlines() {} ; +void XkbAllocGeomOverlayKeys() {} ; +void XkbAllocGeomOverlayRows() {} ; +void XkbAllocGeomOverlays() {} ; +void XkbAllocGeomPoints() {} ; +void XkbAllocGeomProps() {} ; +void XkbAllocGeomRows() {} ; +void XkbAllocGeomSectionDoodads() {} ; +void XkbAllocGeomSections() {} ; +void XkbAllocGeomShapes() {} ; +void XkbAllocGeometry() {} ; +void XkbAllocIndicatorMaps() {} ; +void XkbAllocKeyboard() {} ; +void XkbAllocNames() {} ; +void XkbAllocServerMap() {} ; +void XkbApplyCompatMapToKey() {} ; +void XkbBell() {} ; +void XkbBellEvent() {} ; +void XkbChangeEnabledControls() {} ; +void XkbChangeMap() {} ; +void XkbChangeNames() {} ; +void XkbChangeTypesOfKey() {} ; +void XkbComputeEffectiveMap() {} ; +void XkbComputeRowBounds() {} ; +void XkbComputeSectionBounds() {} ; +void XkbComputeShapeBounds() {} ; +void XkbComputeShapeTop() {} ; +void XkbCopyKeyType() {} ; +void XkbCopyKeyTypes() {} ; +void XkbFindOverlayForKey() {} ; +void XkbForceBell() {} ; +void XkbFreeClientMap() {} ; +void XkbFreeCompatMap() {} ; +void XkbFreeComponentList() {} ; +void XkbFreeControls() {} ; +void XkbFreeGeomColors() {} ; +void XkbFreeGeomDoodads() {} ; +void XkbFreeGeomKeyAliases() {} ; +void XkbFreeGeomKeys() {} ; +void XkbFreeGeomOutlines() {} ; +void XkbFreeGeomOverlayKeys() {} ; +void XkbFreeGeomOverlayRows() {} ; +void XkbFreeGeomOverlays() {} ; +void XkbFreeGeomPoints() {} ; +void XkbFreeGeomProperties() {} ; +void XkbFreeGeomRows() {} ; +void XkbFreeGeomSections() {} ; +void XkbFreeGeomShapes() {} ; +void XkbFreeGeometry() {} ; +void XkbFreeIndicatorMaps() {} ; +void XkbFreeKeyboard() {} ; +void XkbFreeNames() {} ; +void XkbFreeServerMap() {} ; +void XkbGetAutoRepeatRate() {} ; +void XkbGetCompatMap() {} ; +void XkbGetControls() {} ; +void XkbGetGeometry() {} ; +void XkbGetIndicatorMap() {} ; +void XkbGetIndicatorState() {} ; +void XkbGetKeyActions() {} ; +void XkbGetKeyBehaviors() {} ; +void XkbGetKeyExplicitComponents() {} ; +void XkbGetKeyModifierMap() {} ; +void XkbGetKeySyms() {} ; +void XkbGetKeyTypes() {} ; +void XkbGetKeyboard() {} ; +void XkbGetKeyboardByName() {} ; +void XkbGetMap() {} ; +void XkbGetMapChanges() {} ; +void XkbGetNamedGeometry() {} ; +void XkbGetNamedIndicator() {} ; +void XkbGetNames() {} ; +void XkbGetState() {} ; +void XkbGetUpdatedMap() {} ; +void XkbGetVirtualMods() {} ; +void XkbGetXlibControls() {} ; +void XkbIgnoreExtension() {} ; +void XkbInitCanonicalKeyTypes() {} ; +void XkbKeyTypesForCoreSymbols() {} ; +void XkbKeycodeToKeysym() {} ; +void XkbKeysymToModifiers() {} ; +void XkbLatchGroup() {} ; +void XkbLatchModifiers() {} ; +void XkbLibraryVersion() {} ; +void XkbListComponents() {} ; +void XkbLockGroup() {} ; +void XkbLockModifiers() {} ; +void XkbLookupKeyBinding() {} ; +void XkbLookupKeySym() {} ; +void XkbNoteControlsChanges() {} ; +void XkbNoteMapChanges() {} ; +void XkbNoteNameChanges() {} ; +void XkbOpenDisplay() {} ; +void XkbQueryExtension() {} ; +void XkbRefreshKeyboardMapping() {} ; +void XkbResizeKeyActions() {} ; +void XkbResizeKeySyms() {} ; +void XkbResizeKeyType() {} ; +void XkbSelectEventDetails() {} ; +void XkbSelectEvents() {} ; +void XkbSetAtomFuncs() {} ; +void XkbSetAutoRepeatRate() {} ; +void XkbSetAutoResetControls() {} ; +void XkbSetCompatMap() {} ; +void XkbSetControls() {} ; +void XkbSetDebuggingFlags() {} ; +void XkbSetDetectableAutoRepeat() {} ; +void XkbSetGeometry() {} ; +void XkbSetIgnoreLockMods() {} ; +void XkbSetIndicatorMap() {} ; +void XkbSetMap() {} ; +void XkbSetNamedIndicator() {} ; +void XkbSetNames() {} ; +void XkbSetServerInternalMods() {} ; +void XkbSetXlibControls() {} ; +void XkbToControl() {} ; +void XkbTranslateKeyCode() {} ; +void XkbTranslateKeySym() {} ; +void XkbUpdateMapFromCore() {} ; +void XkbUseExtension() {} ; +void XkbVirtualModsToReal() {} ; +void XmbDrawImageString() {} ; +void XmbDrawString() {} ; +void XmbDrawText() {} ; +void XmbLookupString() {} ; +void XmbResetIC() {} ; +void XmbSetWMProperties() {} ; +void XmbTextEscapement() {} ; +void XmbTextExtents() {} ; +void XmbTextListToTextProperty() {} ; +void XmbTextPerCharExtents() {} ; +void XmbTextPropertyToTextList() {} ; +void XrmCombineDatabase() {} ; +void XrmCombineFileDatabase() {} ; +void XrmDestroyDatabase() {} ; +void XrmEnumerateDatabase() {} ; +void XrmGetDatabase() {} ; +void XrmGetFileDatabase() {} ; +void XrmGetResource() {} ; +void XrmGetStringDatabase() {} ; +void XrmInitialize() {} ; +void XrmLocaleOfDatabase() {} ; +void XrmMergeDatabases() {} ; +void XrmParseCommand() {} ; +void XrmPermStringToQuark() {} ; +void XrmPutFileDatabase() {} ; +void XrmPutLineResource() {} ; +void XrmPutResource() {} ; +void XrmPutStringResource() {} ; +void XrmQGetResource() {} ; +void XrmQGetSearchList() {} ; +void XrmQGetSearchResource() {} ; +void XrmQPutResource() {} ; +void XrmQPutStringResource() {} ; +void XrmQuarkToString() {} ; +void XrmSetDatabase() {} ; +void XrmStringToBindingQuarkList() {} ; +void XrmStringToQuark() {} ; +void XrmStringToQuarkList() {} ; +void XrmUniqueQuark() {} ; +void Xutf8TextListToTextProperty() {} ; +void Xutf8TextPropertyToTextList() {} ; +void XwcDrawImageString() {} ; +void XwcDrawString() {} ; +void XwcDrawText() {} ; +void XwcFreeStringList() {} ; +void XwcLookupString() {} ; +void XwcResetIC() {} ; +void XwcTextEscapement() {} ; +void XwcTextExtents() {} ; +void XwcTextListToTextProperty() {} ; +void XwcTextPerCharExtents() {} ; +void XwcTextPropertyToTextList() {} ; +__asm__(".globl XSetAfterFunction; .pushsection .data; .type XSetAfterFunction,@object; .size XSetAfterFunction, 0; XSetAfterFunction: .long 0; .popsection"); +__asm__(".globl XSynchronize; .pushsection .data; .type XSynchronize,@object; .size XSynchronize, 0; XSynchronize: .long 0; .popsection"); diff --git a/lsb-build/stub_libs/libXext.Version b/lsb-build/stub_libs/libXext.Version new file mode 100644 index 0000000..08a3220 --- /dev/null +++ b/lsb-build/stub_libs/libXext.Version @@ -0,0 +1 @@ +LSB_DUMMY { __LSB_DUMMY; }; diff --git a/lsb-build/stub_libs/libXext.c b/lsb-build/stub_libs/libXext.c new file mode 100644 index 0000000..73e2d59 --- /dev/null +++ b/lsb-build/stub_libs/libXext.c @@ -0,0 +1,79 @@ +void DPMSCapable() {} ; +void DPMSDisable() {} ; +void DPMSEnable() {} ; +void DPMSForceLevel() {} ; +void DPMSGetTimeouts() {} ; +void DPMSGetVersion() {} ; +void DPMSInfo() {} ; +void DPMSQueryExtension() {} ; +void DPMSSetTimeouts() {} ; +void XSecurityAllocXauth() {} ; +void XSecurityFreeXauth() {} ; +void XSecurityGenerateAuthorization() {} ; +void XSecurityQueryExtension() {} ; +void XSecurityRevokeAuthorization() {} ; +void XShapeCombineMask() {} ; +void XShapeCombineRectangles() {} ; +void XShapeCombineRegion() {} ; +void XShapeCombineShape() {} ; +void XShapeGetRectangles() {} ; +void XShapeInputSelected() {} ; +void XShapeOffsetShape() {} ; +void XShapeQueryExtension() {} ; +void XShapeQueryExtents() {} ; +void XShapeQueryVersion() {} ; +void XShapeSelectInput() {} ; +void XShmAttach() {} ; +void XShmCreateImage() {} ; +void XShmCreatePixmap() {} ; +void XShmDetach() {} ; +void XShmGetEventBase() {} ; +void XShmGetImage() {} ; +void XShmPixmapFormat() {} ; +void XShmPutImage() {} ; +void XShmQueryExtension() {} ; +void XShmQueryVersion() {} ; +void XSyncAwait() {} ; +void XSyncChangeAlarm() {} ; +void XSyncChangeCounter() {} ; +void XSyncCreateAlarm() {} ; +void XSyncCreateCounter() {} ; +void XSyncDestroyAlarm() {} ; +void XSyncDestroyCounter() {} ; +void XSyncFreeSystemCounterList() {} ; +void XSyncGetPriority() {} ; +void XSyncInitialize() {} ; +void XSyncIntToValue() {} ; +void XSyncIntsToValue() {} ; +void XSyncListSystemCounters() {} ; +void XSyncMaxValue() {} ; +void XSyncMinValue() {} ; +void XSyncQueryAlarm() {} ; +void XSyncQueryCounter() {} ; +void XSyncQueryExtension() {} ; +void XSyncSetCounter() {} ; +void XSyncSetPriority() {} ; +void XSyncValueAdd() {} ; +void XSyncValueEqual() {} ; +void XSyncValueGreaterOrEqual() {} ; +void XSyncValueGreaterThan() {} ; +void XSyncValueHigh32() {} ; +void XSyncValueIsNegative() {} ; +void XSyncValueIsPositive() {} ; +void XSyncValueIsZero() {} ; +void XSyncValueLessOrEqual() {} ; +void XSyncValueLessThan() {} ; +void XSyncValueLow32() {} ; +void XSyncValueSubtract() {} ; +void XdbeAllocateBackBufferName() {} ; +void XdbeBeginIdiom() {} ; +void XdbeDeallocateBackBufferName() {} ; +void XdbeEndIdiom() {} ; +void XdbeFreeVisualInfo() {} ; +void XdbeGetBackBufferAttributes() {} ; +void XdbeGetVisualInfo() {} ; +void XdbeQueryExtension() {} ; +void XdbeSwapBuffers() {} ; +void XeviGetVisualInfo() {} ; +void XeviQueryExtension() {} ; +void XeviQueryVersion() {} ; diff --git a/lsb-build/stub_libs/libXt.Version b/lsb-build/stub_libs/libXt.Version new file mode 100644 index 0000000..08a3220 --- /dev/null +++ b/lsb-build/stub_libs/libXt.Version @@ -0,0 +1 @@ +LSB_DUMMY { __LSB_DUMMY; }; diff --git a/lsb-build/stub_libs/libXt.c b/lsb-build/stub_libs/libXt.c new file mode 100644 index 0000000..5daf7f9 --- /dev/null +++ b/lsb-build/stub_libs/libXt.c @@ -0,0 +1,331 @@ +void XtAddActions() {} ; +void XtAddCallback() {} ; +void XtAddCallbacks() {} ; +void XtAddConverter() {} ; +void XtAddEventHandler() {} ; +void XtAddExposureToRegion() {} ; +void XtAddGrab() {} ; +void XtAddInput() {} ; +void XtAddRawEventHandler() {} ; +void XtAddSignal() {} ; +void XtAddTimeOut() {} ; +void XtAddWorkProc() {} ; +void XtAllocateGC() {} ; +void XtAppAddActionHook() {} ; +void XtAppAddActions() {} ; +void XtAppAddBlockHook() {} ; +void XtAppAddConverter() {} ; +void XtAppAddInput() {} ; +void XtAppAddSignal() {} ; +void XtAppAddTimeOut() {} ; +void XtAppAddWorkProc() {} ; +void XtAppCreateShell() {} ; +void XtAppError() {} ; +void XtAppErrorMsg() {} ; +void XtAppGetErrorDatabase() {} ; +void XtAppGetErrorDatabaseText() {} ; +void XtAppGetExitFlag() {} ; +void XtAppGetSelectionTimeout() {} ; +void XtAppInitialize() {} ; +void XtAppLock() {} ; +void XtAppMainLoop() {} ; +void XtAppNextEvent() {} ; +void XtAppPeekEvent() {} ; +void XtAppPending() {} ; +void XtAppProcessEvent() {} ; +void XtAppReleaseCacheRefs() {} ; +void XtAppSetErrorHandler() {} ; +void XtAppSetErrorMsgHandler() {} ; +void XtAppSetExitFlag() {} ; +void XtAppSetFallbackResources() {} ; +void XtAppSetSelectionTimeout() {} ; +void XtAppSetTypeConverter() {} ; +void XtAppSetWarningHandler() {} ; +void XtAppSetWarningMsgHandler() {} ; +void XtAppUnlock() {} ; +void XtAppWarning() {} ; +void XtAppWarningMsg() {} ; +void XtAugmentTranslations() {} ; +void XtBuildEventMask() {} ; +void XtCallAcceptFocus() {} ; +void XtCallActionProc() {} ; +void XtCallCallbackList() {} ; +void XtCallCallbacks() {} ; +void XtCallConverter() {} ; +void XtCallbackExclusive() {} ; +void XtCallbackNone() {} ; +void XtCallbackNonexclusive() {} ; +void XtCallbackPopdown() {} ; +void XtCallbackReleaseCacheRef() {} ; +void XtCallbackReleaseCacheRefList() {} ; +void XtCalloc() {} ; +void XtCancelSelectionRequest() {} ; +void XtChangeManagedSet() {} ; +void XtClass() {} ; +void XtCloseDisplay() {} ; +void XtConfigureWidget() {} ; +void XtConvert() {} ; +void XtConvertAndStore() {} ; +void XtConvertCase() {} ; +void XtCreateApplicationContext() {} ; +void XtCreateApplicationShell() {} ; +void XtCreateManagedWidget() {} ; +void XtCreatePopupShell() {} ; +void XtCreateSelectionRequest() {} ; +void XtCreateWidget() {} ; +void XtCreateWindow() {} ; +void XtCvtColorToPixel() {} ; +void XtCvtIntToBool() {} ; +void XtCvtIntToBoolean() {} ; +void XtCvtIntToColor() {} ; +void XtCvtIntToFloat() {} ; +void XtCvtIntToFont() {} ; +void XtCvtIntToPixel() {} ; +void XtCvtIntToPixmap() {} ; +void XtCvtIntToShort() {} ; +void XtCvtIntToUnsignedChar() {} ; +void XtCvtStringToAcceleratorTable() {} ; +void XtCvtStringToAtom() {} ; +void XtCvtStringToBool() {} ; +void XtCvtStringToBoolean() {} ; +void XtCvtStringToCommandArgArray() {} ; +void XtCvtStringToCursor() {} ; +void XtCvtStringToDimension() {} ; +void XtCvtStringToDirectoryString() {} ; +void XtCvtStringToDisplay() {} ; +void XtCvtStringToFile() {} ; +void XtCvtStringToFloat() {} ; +void XtCvtStringToFont() {} ; +void XtCvtStringToFontSet() {} ; +void XtCvtStringToFontStruct() {} ; +void XtCvtStringToGravity() {} ; +void XtCvtStringToInitialState() {} ; +void XtCvtStringToInt() {} ; +void XtCvtStringToPixel() {} ; +void XtCvtStringToRestartStyle() {} ; +void XtCvtStringToShort() {} ; +void XtCvtStringToTranslationTable() {} ; +void XtCvtStringToUnsignedChar() {} ; +void XtCvtStringToVisual() {} ; +void XtDatabase() {} ; +void XtDestroyApplicationContext() {} ; +void XtDestroyGC() {} ; +void XtDestroyWidget() {} ; +void XtDirectConvert() {} ; +void XtDisownSelection() {} ; +void XtDispatchEvent() {} ; +void XtDispatchEventToWidget() {} ; +void XtDisplay() {} ; +void XtDisplayInitialize() {} ; +void XtDisplayOfObject() {} ; +void XtDisplayStringConversionWarning() {} ; +void XtDisplayToApplicationContext() {} ; +void XtError() {} ; +void XtErrorMsg() {} ; +void XtFindFile() {} ; +void XtFree() {} ; +void XtGetActionKeysym() {} ; +void XtGetActionList() {} ; +void XtGetApplicationNameAndClass() {} ; +void XtGetApplicationResources() {} ; +void XtGetClassExtension() {} ; +void XtGetConstraintResourceList() {} ; +void XtGetDisplays() {} ; +void XtGetErrorDatabase() {} ; +void XtGetErrorDatabaseText() {} ; +void XtGetGC() {} ; +void XtGetKeyboardFocusWidget() {} ; +void XtGetKeysymTable() {} ; +void XtGetMultiClickTime() {} ; +void XtGetResourceList() {} ; +void XtGetSelectionParameters() {} ; +void XtGetSelectionRequest() {} ; +void XtGetSelectionTimeout() {} ; +void XtGetSelectionValue() {} ; +void XtGetSelectionValueIncremental() {} ; +void XtGetSelectionValues() {} ; +void XtGetSelectionValuesIncremental() {} ; +void XtGetSubresources() {} ; +void XtGetSubvalues() {} ; +void XtGetValues() {} ; +void XtGrabButton() {} ; +void XtGrabKey() {} ; +void XtGrabKeyboard() {} ; +void XtGrabPointer() {} ; +void XtHasCallbacks() {} ; +void XtHooksOfDisplay() {} ; +void XtInitialize() {} ; +void XtInitializeWidgetClass() {} ; +void XtInsertEventHandler() {} ; +void XtInsertEventTypeHandler() {} ; +void XtInsertRawEventHandler() {} ; +void XtInstallAccelerators() {} ; +void XtInstallAllAccelerators() {} ; +void XtIsApplicationShell() {} ; +void XtIsComposite() {} ; +void XtIsConstraint() {} ; +void XtIsManaged() {} ; +void XtIsObject() {} ; +void XtIsOverrideShell() {} ; +void XtIsRealized() {} ; +void XtIsRectObj() {} ; +void XtIsSensitive() {} ; +void XtIsSessionShell() {} ; +void XtIsShell() {} ; +void XtIsSubclass() {} ; +void XtIsTopLevelShell() {} ; +void XtIsTransientShell() {} ; +void XtIsVendorShell() {} ; +void XtIsWMShell() {} ; +void XtIsWidget() {} ; +void XtKeysymToKeycodeList() {} ; +void XtLastEventProcessed() {} ; +void XtLastTimestampProcessed() {} ; +void XtMainLoop() {} ; +void XtMakeGeometryRequest() {} ; +void XtMakeResizeRequest() {} ; +void XtMalloc() {} ; +void XtManageChild() {} ; +void XtManageChildren() {} ; +void XtMapWidget() {} ; +void XtMenuPopupAction() {} ; +void XtMergeArgLists() {} ; +void XtMoveWidget() {} ; +void XtName() {} ; +void XtNameToWidget() {} ; +void XtNewString() {} ; +void XtNextEvent() {} ; +void XtNoticeSignal() {} ; +void XtOpenApplication() {} ; +void XtOpenDisplay() {} ; +void XtOverrideTranslations() {} ; +void XtOwnSelection() {} ; +void XtOwnSelectionIncremental() {} ; +void XtParent() {} ; +void XtParseAcceleratorTable() {} ; +void XtParseTranslationTable() {} ; +void XtPeekEvent() {} ; +void XtPending() {} ; +void XtPopdown() {} ; +void XtPopup() {} ; +void XtPopupSpringLoaded() {} ; +void XtProcessEvent() {} ; +void XtProcessLock() {} ; +void XtProcessUnlock() {} ; +void XtQueryGeometry() {} ; +void XtRealizeWidget() {} ; +void XtRealloc() {} ; +void XtRegisterCaseConverter() {} ; +void XtRegisterDrawable() {} ; +void XtRegisterExtensionSelector() {} ; +void XtRegisterGrabAction() {} ; +void XtReleaseGC() {} ; +void XtReleasePropertyAtom() {} ; +void XtRemoveActionHook() {} ; +void XtRemoveAllCallbacks() {} ; +void XtRemoveBlockHook() {} ; +void XtRemoveCallback() {} ; +void XtRemoveCallbacks() {} ; +void XtRemoveEventHandler() {} ; +void XtRemoveEventTypeHandler() {} ; +void XtRemoveGrab() {} ; +void XtRemoveInput() {} ; +void XtRemoveRawEventHandler() {} ; +void XtRemoveSignal() {} ; +void XtRemoveTimeOut() {} ; +void XtRemoveWorkProc() {} ; +void XtReservePropertyAtom() {} ; +void XtResizeWidget() {} ; +void XtResizeWindow() {} ; +void XtResolvePathname() {} ; +void XtScreen() {} ; +void XtScreenDatabase() {} ; +void XtScreenOfObject() {} ; +void XtSendSelectionRequest() {} ; +void XtSessionGetToken() {} ; +void XtSessionReturnToken() {} ; +void XtSetErrorHandler() {} ; +void XtSetErrorMsgHandler() {} ; +void XtSetEventDispatcher() {} ; +void XtSetKeyTranslator() {} ; +void XtSetKeyboardFocus() {} ; +void XtSetLanguageProc() {} ; +void XtSetMappedWhenManaged() {} ; +void XtSetMultiClickTime() {} ; +void XtSetSelectionParameters() {} ; +void XtSetSelectionTimeout() {} ; +void XtSetSensitive() {} ; +void XtSetSubvalues() {} ; +void XtSetTypeConverter() {} ; +void XtSetValues() {} ; +void XtSetWMColormapWindows() {} ; +void XtSetWarningHandler() {} ; +void XtSetWarningMsgHandler() {} ; +void XtStringConversionWarning() {} ; +void XtSuperclass() {} ; +void XtToolkitInitialize() {} ; +void XtToolkitThreadInitialize() {} ; +void XtTranslateCoords() {} ; +void XtTranslateKey() {} ; +void XtTranslateKeycode() {} ; +void XtUngrabButton() {} ; +void XtUngrabKey() {} ; +void XtUngrabKeyboard() {} ; +void XtUngrabPointer() {} ; +void XtUninstallTranslations() {} ; +void XtUnmanageChild() {} ; +void XtUnmanageChildren() {} ; +void XtUnmapWidget() {} ; +void XtUnrealizeWidget() {} ; +void XtUnregisterDrawable() {} ; +void XtVaAppCreateShell() {} ; +void XtVaAppInitialize() {} ; +void XtVaCreateArgsList() {} ; +void XtVaCreateManagedWidget() {} ; +void XtVaCreatePopupShell() {} ; +void XtVaCreateWidget() {} ; +void XtVaGetApplicationResources() {} ; +void XtVaGetSubresources() {} ; +void XtVaGetSubvalues() {} ; +void XtVaGetValues() {} ; +void XtVaOpenApplication() {} ; +void XtVaSetSubvalues() {} ; +void XtVaSetValues() {} ; +void XtWarning() {} ; +void XtWarningMsg() {} ; +void XtWidgetToApplicationContext() {} ; +void XtWindow() {} ; +void XtWindowOfObject() {} ; +void XtWindowToWidget() {} ; +void _XtCheckSubclassFlag() {} ; +void _XtCopyFromArg() {} ; +void _XtInherit() {} ; +void _XtIsSubclassOf() {} ; +__asm__(".globl XtCXtToolkitError; .pushsection .data; .type XtCXtToolkitError,@object; .size XtCXtToolkitError, 4; XtCXtToolkitError: .long 0; .popsection"); +__asm__(".globl XtShellStrings; .pushsection .data; .type XtShellStrings,@object; .size XtShellStrings, 1289; XtShellStrings: .long 0; .popsection"); +__asm__(".globl XtStrings; .pushsection .data; .type XtStrings,@object; .size XtStrings, 2649; XtStrings: .long 0; .popsection"); +__asm__(".globl _XtInheritTranslations; .pushsection .data; .type _XtInheritTranslations,@object; .size _XtInheritTranslations, 4; _XtInheritTranslations: .long 0; .popsection"); +__asm__(".globl applicationShellWidgetClass; .pushsection .data; .type applicationShellWidgetClass,@object; .size applicationShellWidgetClass, 4; applicationShellWidgetClass: .long 0; .popsection"); +__asm__(".globl compositeClassRec; .pushsection .data; .type compositeClassRec,@object; .size compositeClassRec, 136; compositeClassRec: .long 0; .popsection"); +__asm__(".globl compositeWidgetClass; .pushsection .data; .type compositeWidgetClass,@object; .size compositeWidgetClass, 4; compositeWidgetClass: .long 0; .popsection"); +__asm__(".globl constraintClassRec; .pushsection .data; .type constraintClassRec,@object; .size constraintClassRec, 164; constraintClassRec: .long 0; .popsection"); +__asm__(".globl constraintWidgetClass; .pushsection .data; .type constraintWidgetClass,@object; .size constraintWidgetClass, 4; constraintWidgetClass: .long 0; .popsection"); +__asm__(".globl coreWidgetClass; .pushsection .data; .type coreWidgetClass,@object; .size coreWidgetClass, 4; coreWidgetClass: .long 0; .popsection"); +__asm__(".globl objectClass; .pushsection .data; .type objectClass,@object; .size objectClass, 4; objectClass: .long 0; .popsection"); +__asm__(".globl objectClassRec; .pushsection .data; .type objectClassRec,@object; .size objectClassRec, 116; objectClassRec: .long 0; .popsection"); +__asm__(".globl overrideShellClassRec; .pushsection .data; .type overrideShellClassRec,@object; .size overrideShellClassRec, 144; overrideShellClassRec: .long 0; .popsection"); +__asm__(".globl overrideShellWidgetClass; .pushsection .data; .type overrideShellWidgetClass,@object; .size overrideShellWidgetClass, 4; overrideShellWidgetClass: .long 0; .popsection"); +__asm__(".globl rectObjClass; .pushsection .data; .type rectObjClass,@object; .size rectObjClass, 4; rectObjClass: .long 0; .popsection"); +__asm__(".globl rectObjClassRec; .pushsection .data; .type rectObjClassRec,@object; .size rectObjClassRec, 116; rectObjClassRec: .long 0; .popsection"); +__asm__(".globl sessionShellClassRec; .pushsection .data; .type sessionShellClassRec,@object; .size sessionShellClassRec, 160; sessionShellClassRec: .long 0; .popsection"); +__asm__(".globl sessionShellWidgetClass; .pushsection .data; .type sessionShellWidgetClass,@object; .size sessionShellWidgetClass, 4; sessionShellWidgetClass: .long 0; .popsection"); +__asm__(".globl shellClassRec; .pushsection .data; .type shellClassRec,@object; .size shellClassRec, 140; shellClassRec: .long 0; .popsection"); +__asm__(".globl shellWidgetClass; .pushsection .data; .type shellWidgetClass,@object; .size shellWidgetClass, 4; shellWidgetClass: .long 0; .popsection"); +__asm__(".globl topLevelShellClassRec; .pushsection .data; .type topLevelShellClassRec,@object; .size topLevelShellClassRec, 152; topLevelShellClassRec: .long 0; .popsection"); +__asm__(".globl topLevelShellWidgetClass; .pushsection .data; .type topLevelShellWidgetClass,@object; .size topLevelShellWidgetClass, 4; topLevelShellWidgetClass: .long 0; .popsection"); +__asm__(".globl transientShellClassRec; .pushsection .data; .type transientShellClassRec,@object; .size transientShellClassRec, 152; transientShellClassRec: .long 0; .popsection"); +__asm__(".globl transientShellWidgetClass; .pushsection .data; .type transientShellWidgetClass,@object; .size transientShellWidgetClass, 4; transientShellWidgetClass: .long 0; .popsection"); +__asm__(".globl widgetClass; .pushsection .data; .type widgetClass,@object; .size widgetClass, 4; widgetClass: .long 0; .popsection"); +__asm__(".globl widgetClassRec; .pushsection .data; .type widgetClassRec,@object; .size widgetClassRec, 116; widgetClassRec: .long 0; .popsection"); +__asm__(".globl wmShellClassRec; .pushsection .data; .type wmShellClassRec,@object; .size wmShellClassRec, 144; wmShellClassRec: .long 0; .popsection"); +__asm__(".globl wmShellWidgetClass; .pushsection .data; .type wmShellWidgetClass,@object; .size wmShellWidgetClass, 4; wmShellWidgetClass: .long 0; .popsection"); diff --git a/lsb-build/stub_libs/libc_main.Version b/lsb-build/stub_libs/libc_main.Version new file mode 100644 index 0000000..7b7c811 --- /dev/null +++ b/lsb-build/stub_libs/libc_main.Version @@ -0,0 +1,829 @@ +LSB_DUMMY { __LSB_DUMMY; }; +GLIBC_2.0 { + _IO_feof; + _IO_getc; + _IO_putc; + _IO_puts; + __assert_fail; + __ctype_get_mb_cur_max; + __errno_location; + __fxstat; + __getpagesize; + __getpgid; + __h_errno_location; + __isinf; + __isinff; + __isinfl; + __isnan; + __isnanf; + __isnanl; + __libc_start_main; + __lxstat; + __mempcpy; + __sigsetjmp; + __stpcpy; + __strdup; + __strtod_internal; + __strtof_internal; + __strtok_r; + __strtol_internal; + __strtold_internal; + __strtoll_internal; + __strtoul_internal; + __strtoull_internal; + __sysv_signal; + __wcstod_internal; + __wcstof_internal; + __wcstol_internal; + __wcstold_internal; + __wcstoul_internal; + __xmknod; + __xstat; + _exit; + _longjmp; + _setjmp; + _tolower; + _toupper; + a64l; + abort; + abs; + accept; + access; + acct; + adjtime; + alarm; + asctime; + asctime_r; + asprintf; + atof; + atoi; + atol; + atoll; + authnone_create; + basename; + bcmp; + bcopy; + bind; + bindresvport; + bindtextdomain; + brk; + bsd_signal; + bsearch; + btowc; + bzero; + calloc; + catclose; + catgets; + catopen; + cfgetispeed; + cfgetospeed; + cfmakeraw; + cfsetispeed; + cfsetospeed; + cfsetspeed; + chdir; + chmod; + chroot; + clearerr; + clnt_create; + clnt_pcreateerror; + clnt_perrno; + clnt_perror; + clnt_spcreateerror; + clnt_sperrno; + clnt_sperror; + clock; + close; + closedir; + closelog; + confstr; + connect; + creat; + ctermid; + ctime; + ctime_r; + cuserid; + daemon; + dcgettext; + dgettext; + difftime; + dirname; + div; + drand48; + dup; + dup2; + ecvt; + endgrent; + endprotoent; + endpwent; + endservent; + endutent; + erand48; + err; + error; + errx; + execl; + execle; + execlp; + execv; + execve; + execvp; + exit; + fchdir; + fchmod; + fchown; + fcntl; + fcvt; + fdatasync; + feof; + ferror; + fflush; + fflush_unlocked; + ffs; + fgetc; + fgets; + fileno; + flock; + flockfile; + fork; + fpathconf; + fprintf; + fputc; + fputs; + fread; + free; + freeaddrinfo; + freopen; + fscanf; + fseek; + fsync; + ftell; + ftime; + ftok; + ftruncate; + ftrylockfile; + ftw; + funlockfile; + fwrite; + gcvt; + getaddrinfo; + getc; + getc_unlocked; + getchar; + getchar_unlocked; + getcwd; + getegid; + getenv; + geteuid; + getgid; + getgrent; + getgrgid; + getgrnam; + getgroups; + gethostbyaddr; + gethostbyname; + gethostid; + gethostname; + getitimer; + getlogin; + getlogin_r; + getopt; + getopt_long; + getopt_long_only; + getpagesize; + getpeername; + getpgid; + getpgrp; + getpid; + getppid; + getpriority; + getprotobyname; + getprotobynumber; + getprotoent; + getpwent; + getpwnam; + getpwuid; + getrusage; + getservbyname; + getservbyport; + getservent; + getsid; + getsockname; + getsockopt; + getsubopt; + gettext; + gettimeofday; + getuid; + getutent; + getutent_r; + getw; + getwd; + glob; + globfree; + gmtime; + gmtime_r; + hcreate; + hdestroy; + hsearch; + htonl; + htons; + index; + inet_addr; + inet_ntoa; + inet_ntop; + inet_pton; + initgroups; + initstate; + insque; + ioctl; + isalnum; + isalpha; + isascii; + isatty; + isblank; + iscntrl; + isdigit; + isgraph; + islower; + isprint; + ispunct; + isspace; + isupper; + iswalnum; + iswalpha; + iswcntrl; + iswctype; + iswdigit; + iswgraph; + iswlower; + iswprint; + iswpunct; + iswspace; + iswupper; + iswxdigit; + isxdigit; + jrand48; + kill; + killpg; + l64a; + labs; + lchown; + lcong48; + ldiv; + lfind; + link; + listen; + llabs; + lldiv; + localtime; + localtime_r; + lockf; + longjmp; + lrand48; + lsearch; + lseek; + malloc; + mblen; + mbrlen; + mbrtowc; + mbsinit; + mbsnrtowcs; + mbsrtowcs; + mbstowcs; + mbtowc; + memccpy; + memchr; + memcmp; + memcpy; + memmem; + memmove; + memset; + mkdir; + mkfifo; + mkstemp; + mktemp; + mktime; + mlock; + mlockall; + mmap; + mprotect; + mrand48; + msgget; + msgrcv; + msgsnd; + msync; + munlock; + munlockall; + munmap; + nanosleep; + nice; + nl_langinfo; + nrand48; + ntohl; + ntohs; + open; + opendir; + openlog; + pathconf; + pause; + perror; + pipe; + pmap_getport; + pmap_set; + pmap_unset; + poll; + printf; + psignal; + putc; + putc_unlocked; + putchar; + putchar_unlocked; + putenv; + puts; + putw; + qsort; + raise; + rand; + rand_r; + random; + read; + readdir; + readdir_r; + readlink; + readv; + realloc; + recv; + recvfrom; + recvmsg; + regcomp; + regerror; + regfree; + remove; + remque; + rename; + rewind; + rewinddir; + rindex; + rmdir; + sbrk; + scanf; + sched_get_priority_max; + sched_get_priority_min; + sched_getparam; + sched_getscheduler; + sched_rr_get_interval; + sched_setparam; + sched_setscheduler; + sched_yield; + seed48; + seekdir; + select; + semget; + semop; + send; + sendmsg; + sendto; + setbuf; + setbuffer; + setcontext; + setegid; + setenv; + seteuid; + setgid; + setgrent; + setgroups; + sethostname; + setitimer; + setlocale; + setlogmask; + setpgid; + setpgrp; + setpriority; + setprotoent; + setpwent; + setregid; + setreuid; + setservent; + setsid; + setsockopt; + setstate; + setuid; + setutent; + setvbuf; + shmat; + shmdt; + shmget; + shutdown; + sigaction; + sigaddset; + sigaltstack; + sigandset; + sigdelset; + sigemptyset; + sigfillset; + siginterrupt; + sigisemptyset; + sigismember; + siglongjmp; + signal; + sigorset; + sigpause; + sigpending; + sigprocmask; + sigreturn; + sigsuspend; + sigwait; + sleep; + snprintf; + socket; + socketpair; + sprintf; + srand; + srand48; + srandom; + sscanf; + stime; + stpcpy; + stpncpy; + strcasecmp; + strcat; + strchr; + strcmp; + strcoll; + strcpy; + strcspn; + strdup; + strerror; + strerror_r; + strfmon; + strftime; + strlen; + strncasecmp; + strncat; + strncmp; + strncpy; + strndup; + strnlen; + strpbrk; + strptime; + strrchr; + strsep; + strsignal; + strspn; + strstr; + strtod; + strtof; + strtok; + strtok_r; + strtol; + strtold; + strtoll; + strtoq; + strtoul; + strtoull; + strtouq; + strxfrm; + svc_getreqset; + svc_register; + svc_run; + svc_sendreply; + svcerr_auth; + svcerr_decode; + svcerr_noproc; + svcerr_noprog; + svcerr_progvers; + svcerr_systemerr; + svcerr_weakauth; + svctcp_create; + svcudp_create; + swab; + symlink; + sync; + sysconf; + syslog; + system; + tcdrain; + tcflow; + tcflush; + tcgetattr; + tcgetpgrp; + tcsendbreak; + tcsetattr; + tcsetpgrp; + tdelete; + telldir; + tempnam; + textdomain; + tfind; + time; + times; + tmpnam; + toascii; + tolower; + toupper; + towctrans; + towlower; + towupper; + truncate; + tsearch; + ttyname; + ttyname_r; + twalk; + tzset; + ualarm; + ulimit; + umask; + uname; + ungetc; + unlink; + unsetenv; + usleep; + utime; + utimes; + utmpname; + vasprintf; + vdprintf; + verrx; + vfork; + vfprintf; + vfscanf; + vprintf; + vscanf; + vsnprintf; + vsprintf; + vsscanf; + vsyslog; + wait; + wait4; + waitpid; + warn; + warnx; + wcpcpy; + wcpncpy; + wcrtomb; + wcscat; + wcschr; + wcscmp; + wcscoll; + wcscpy; + wcscspn; + wcsdup; + wcslen; + wcsncat; + wcsncmp; + wcsncpy; + wcsnrtombs; + wcspbrk; + wcsrchr; + wcsrtombs; + wcsspn; + wcsstr; + wcstod; + wcstof; + wcstok; + wcstol; + wcstold; + wcstombs; + wcstoq; + wcstoul; + wcstouq; + wcswidth; + wcsxfrm; + wctob; + wctomb; + wctrans; + wctype; + wcwidth; + wmemchr; + wmemcmp; + wmemcpy; + wmemmove; + wmemset; + write; + writev; + xdr_accepted_reply; + xdr_array; + xdr_bool; + xdr_bytes; + xdr_callhdr; + xdr_callmsg; + xdr_char; + xdr_double; + xdr_enum; + xdr_float; + xdr_free; + xdr_int; + xdr_long; + xdr_opaque; + xdr_opaque_auth; + xdr_pointer; + xdr_reference; + xdr_rejected_reply; + xdr_replymsg; + xdr_short; + xdr_string; + xdr_u_char; + xdr_u_int; + xdr_u_long; + xdr_u_short; + xdr_union; + xdr_vector; + xdr_void; + xdr_wrapstring; + xdrmem_create; + xdrrec_create; + xdrrec_eof; + __daylight; + __environ; + __timezone; + __tzname; + _environ; + _nl_msg_cat_cntr; + daylight; + environ; + optarg; + opterr; + optind; + optopt; + stderr; + stdin; + stdout; + timezone; + tzname; +}; +GLIBC_2.1 { + __libc_current_sigrtmax; + __libc_current_sigrtmin; + __rawmemchr; + chown; + creat64; + endutxent; + fclose; + fdopen; + fmtmsg; + fopen; + fopen64; + freopen64; + fseeko; + fseeko64; + fstatvfs; + fstatvfs64; + ftello; + ftello64; + ftruncate64; + ftw64; + gai_strerror; + getcontext; + getdate; + getnameinfo; + getutxent; + getutxid; + getutxline; + globfree64; + grantpt; + iconv; + iconv_close; + iconv_open; + if_freenameindex; + if_indextoname; + if_nameindex; + if_nametoindex; + iswblank; + key_decryptsession; + lockf64; + makecontext; + mmap64; + pclose; + popen; + ptsname; + pututxline; + setrlimit64; + setutxent; + sighold; + sigignore; + sigqueue; + sigrelse; + sigset; + sigtimedwait; + sigwaitinfo; + statvfs; + statvfs64; + strcasestr; + strtoimax; + strtoumax; + swapcontext; + tcgetsid; + tmpfile; + tmpfile64; + truncate64; + unlockpt; + wcscasecmp; + wcsncasecmp; + wcsnlen; + wcstoimax; + wcstoll; + wcstoull; + wcstoumax; + wcswcs; + wordexp; + wordfree; + getdate_err; +}; +GLIBC_2.1.1 { + _Exit; + imaxabs; + imaxdiv; +}; +GLIBC_2.1.2 { + getgrgid_r; + getgrnam_r; + getpwnam_r; + getpwuid_r; +}; +GLIBC_2.1.3 { + __cxa_atexit; +}; +GLIBC_2.2 { + __fpending; + __fxstat64; + __lxstat64; + __sysconf; + __xstat64; + bind_textdomain_codeset; + dcngettext; + dngettext; + fgetpos; + fgetpos64; + fgetwc; + fgetwc_unlocked; + fgetws; + fputwc; + fputws; + fsetpos; + fsetpos64; + fwide; + fwprintf; + fwscanf; + getloadavg; + getrlimit; + getrlimit64; + getwc; + getwchar; + glob64; + localeconv; + memrchr; + mkstemp64; + msgctl; + ngettext; + posix_memalign; + putwc; + putwchar; + readdir64; + semctl; + setrlimit; + shmctl; + swprintf; + swscanf; + ungetwc; + vfwprintf; + vfwscanf; + vswprintf; + vswscanf; + vwprintf; + vwscanf; + wcsftime; + wprintf; + wscanf; +}; +GLIBC_2.2.1 { + posix_openpt; +}; +GLIBC_2.2.3 { + fnmatch; +}; +GLIBC_2.2.4 { + getgrouplist; + sockatmark; +}; +GLIBC_2.3 { + __ctype_b_loc; + __ctype_tolower_loc; + __ctype_toupper_loc; + duplocale; + freelocale; + newlocale; + realpath; + uselocale; + _sys_errlist; +}; +GLIBC_2.3.2 { + __register_atfork; +}; +GLIBC_2.3.3 { + nftw; + nftw64; + _sys_siglist; +}; +GLIBC_2.3.4 { + regexec; +}; diff --git a/lsb-build/stub_libs/libc_main.c b/lsb-build/stub_libs/libc_main.c new file mode 100644 index 0000000..3f3530c --- /dev/null +++ b/lsb-build/stub_libs/libc_main.c @@ -0,0 +1,804 @@ +void _Exit() {} ; +void _IO_feof() {} ; +void _IO_getc() {} ; +void _IO_putc() {} ; +void _IO_puts() {} ; +void __assert_fail() {} ; +void __ctype_b_loc() {} ; +void __ctype_get_mb_cur_max() {} ; +void __ctype_tolower_loc() {} ; +void __ctype_toupper_loc() {} ; +void __cxa_atexit() {} ; +void __errno_location() {} ; +void __fpending() {} ; +void __fxstat() {} ; +void __fxstat64() {} ; +void __getpagesize() {} ; +void __getpgid() {} ; +void __h_errno_location() {} ; +void __isinf() {} ; +void __isinff() {} ; +void __isinfl() {} ; +void __isnan() {} ; +void __isnanf() {} ; +void __isnanl() {} ; +void __libc_current_sigrtmax() {} ; +void __libc_current_sigrtmin() {} ; +void __libc_start_main() {} ; +void __lxstat() {} ; +void __lxstat64() {} ; +void __mempcpy() {} ; +void __rawmemchr() {} ; +void __register_atfork() {} ; +void __sigsetjmp() {} ; +void __stpcpy() {} ; +void __strdup() {} ; +void __strtod_internal() {} ; +void __strtof_internal() {} ; +void __strtok_r() {} ; +void __strtol_internal() {} ; +void __strtold_internal() {} ; +void __strtoll_internal() {} ; +void __strtoul_internal() {} ; +void __strtoull_internal() {} ; +void __sysconf() {} ; +void __sysv_signal() {} ; +void __wcstod_internal() {} ; +void __wcstof_internal() {} ; +void __wcstol_internal() {} ; +void __wcstold_internal() {} ; +void __wcstoul_internal() {} ; +void __xmknod() {} ; +void __xstat() {} ; +void __xstat64() {} ; +void _exit() {} ; +void _longjmp() {} ; +void _setjmp() {} ; +void _tolower() {} ; +void _toupper() {} ; +void a64l() {} ; +void abort() {} ; +void abs() {} ; +void accept() {} ; +void access() {} ; +void acct() {} ; +void adjtime() {} ; +void alarm() {} ; +void asctime() {} ; +void asctime_r() {} ; +void asprintf() {} ; +void atof() {} ; +void atoi() {} ; +void atol() {} ; +void atoll() {} ; +void authnone_create() {} ; +void basename() {} ; +void bcmp() {} ; +void bcopy() {} ; +void bind() {} ; +void bind_textdomain_codeset() {} ; +void bindresvport() {} ; +void bindtextdomain() {} ; +void brk() {} ; +void bsd_signal() {} ; +void bsearch() {} ; +void btowc() {} ; +void bzero() {} ; +void calloc() {} ; +void catclose() {} ; +void catgets() {} ; +void catopen() {} ; +void cfgetispeed() {} ; +void cfgetospeed() {} ; +void cfmakeraw() {} ; +void cfsetispeed() {} ; +void cfsetospeed() {} ; +void cfsetspeed() {} ; +void chdir() {} ; +void chmod() {} ; +void chown() {} ; +void chroot() {} ; +void clearerr() {} ; +void clnt_create() {} ; +void clnt_pcreateerror() {} ; +void clnt_perrno() {} ; +void clnt_perror() {} ; +void clnt_spcreateerror() {} ; +void clnt_sperrno() {} ; +void clnt_sperror() {} ; +void clock() {} ; +void close() {} ; +void closedir() {} ; +void closelog() {} ; +void confstr() {} ; +void connect() {} ; +void creat() {} ; +void creat64() {} ; +void ctermid() {} ; +void ctime() {} ; +void ctime_r() {} ; +void cuserid() {} ; +void daemon() {} ; +void dcgettext() {} ; +void dcngettext() {} ; +void dgettext() {} ; +void difftime() {} ; +void dirname() {} ; +void div() {} ; +void dngettext() {} ; +void drand48() {} ; +void dup() {} ; +void dup2() {} ; +void duplocale() {} ; +void ecvt() {} ; +void endgrent() {} ; +void endprotoent() {} ; +void endpwent() {} ; +void endservent() {} ; +void endutent() {} ; +void endutxent() {} ; +void erand48() {} ; +void err() {} ; +void error() {} ; +void errx() {} ; +void execl() {} ; +void execle() {} ; +void execlp() {} ; +void execv() {} ; +void execve() {} ; +void execvp() {} ; +void exit() {} ; +void fchdir() {} ; +void fchmod() {} ; +void fchown() {} ; +void fclose() {} ; +void fcntl() {} ; +void fcvt() {} ; +void fdatasync() {} ; +void fdopen() {} ; +void feof() {} ; +void ferror() {} ; +void fflush() {} ; +void fflush_unlocked() {} ; +void ffs() {} ; +void fgetc() {} ; +void fgetpos() {} ; +void fgetpos64() {} ; +void fgets() {} ; +void fgetwc() {} ; +void fgetwc_unlocked() {} ; +void fgetws() {} ; +void fileno() {} ; +void flock() {} ; +void flockfile() {} ; +void fmtmsg() {} ; +void fnmatch() {} ; +void fopen() {} ; +void fopen64() {} ; +void fork() {} ; +void fpathconf() {} ; +void fprintf() {} ; +void fputc() {} ; +void fputs() {} ; +void fputwc() {} ; +void fputws() {} ; +void fread() {} ; +void free() {} ; +void freeaddrinfo() {} ; +void freelocale() {} ; +void freopen() {} ; +void freopen64() {} ; +void fscanf() {} ; +void fseek() {} ; +void fseeko() {} ; +void fseeko64() {} ; +void fsetpos() {} ; +void fsetpos64() {} ; +void fstatvfs() {} ; +void fstatvfs64() {} ; +void fsync() {} ; +void ftell() {} ; +void ftello() {} ; +void ftello64() {} ; +void ftime() {} ; +void ftok() {} ; +void ftruncate() {} ; +void ftruncate64() {} ; +void ftrylockfile() {} ; +void ftw() {} ; +void ftw64() {} ; +void funlockfile() {} ; +void fwide() {} ; +void fwprintf() {} ; +void fwrite() {} ; +void fwscanf() {} ; +void gai_strerror() {} ; +void gcvt() {} ; +void getaddrinfo() {} ; +void getc() {} ; +void getc_unlocked() {} ; +void getchar() {} ; +void getchar_unlocked() {} ; +void getcontext() {} ; +void getcwd() {} ; +void getdate() {} ; +void getegid() {} ; +void getenv() {} ; +void geteuid() {} ; +void getgid() {} ; +void getgrent() {} ; +void getgrgid() {} ; +void getgrgid_r() {} ; +void getgrnam() {} ; +void getgrnam_r() {} ; +void getgrouplist() {} ; +void getgroups() {} ; +void gethostbyaddr() {} ; +void gethostbyname() {} ; +void gethostid() {} ; +void gethostname() {} ; +void getitimer() {} ; +void getloadavg() {} ; +void getlogin() {} ; +void getlogin_r() {} ; +void getnameinfo() {} ; +void getopt() {} ; +void getopt_long() {} ; +void getopt_long_only() {} ; +void getpagesize() {} ; +void getpeername() {} ; +void getpgid() {} ; +void getpgrp() {} ; +void getpid() {} ; +void getppid() {} ; +void getpriority() {} ; +void getprotobyname() {} ; +void getprotobynumber() {} ; +void getprotoent() {} ; +void getpwent() {} ; +void getpwnam() {} ; +void getpwnam_r() {} ; +void getpwuid() {} ; +void getpwuid_r() {} ; +void getrlimit() {} ; +void getrlimit64() {} ; +void getrusage() {} ; +void getservbyname() {} ; +void getservbyport() {} ; +void getservent() {} ; +void getsid() {} ; +void getsockname() {} ; +void getsockopt() {} ; +void getsubopt() {} ; +void gettext() {} ; +void gettimeofday() {} ; +void getuid() {} ; +void getutent() {} ; +void getutent_r() {} ; +void getutxent() {} ; +void getutxid() {} ; +void getutxline() {} ; +void getw() {} ; +void getwc() {} ; +void getwchar() {} ; +void getwd() {} ; +void glob() {} ; +void glob64() {} ; +void globfree() {} ; +void globfree64() {} ; +void gmtime() {} ; +void gmtime_r() {} ; +void grantpt() {} ; +void hcreate() {} ; +void hdestroy() {} ; +void hsearch() {} ; +void htonl() {} ; +void htons() {} ; +void iconv() {} ; +void iconv_close() {} ; +void iconv_open() {} ; +void if_freenameindex() {} ; +void if_indextoname() {} ; +void if_nameindex() {} ; +void if_nametoindex() {} ; +void imaxabs() {} ; +void imaxdiv() {} ; +void index() {} ; +void inet_addr() {} ; +void inet_ntoa() {} ; +void inet_ntop() {} ; +void inet_pton() {} ; +void initgroups() {} ; +void initstate() {} ; +void insque() {} ; +void ioctl() {} ; +void isalnum() {} ; +void isalpha() {} ; +void isascii() {} ; +void isatty() {} ; +void isblank() {} ; +void iscntrl() {} ; +void isdigit() {} ; +void isgraph() {} ; +void islower() {} ; +void isprint() {} ; +void ispunct() {} ; +void isspace() {} ; +void isupper() {} ; +void iswalnum() {} ; +void iswalpha() {} ; +void iswblank() {} ; +void iswcntrl() {} ; +void iswctype() {} ; +void iswdigit() {} ; +void iswgraph() {} ; +void iswlower() {} ; +void iswprint() {} ; +void iswpunct() {} ; +void iswspace() {} ; +void iswupper() {} ; +void iswxdigit() {} ; +void isxdigit() {} ; +void jrand48() {} ; +void key_decryptsession() {} ; +void kill() {} ; +void killpg() {} ; +void l64a() {} ; +void labs() {} ; +void lchown() {} ; +void lcong48() {} ; +void ldiv() {} ; +void lfind() {} ; +void link() {} ; +void listen() {} ; +void llabs() {} ; +void lldiv() {} ; +void localeconv() {} ; +void localtime() {} ; +void localtime_r() {} ; +void lockf() {} ; +void lockf64() {} ; +void longjmp() {} ; +void lrand48() {} ; +void lsearch() {} ; +void lseek() {} ; +void makecontext() {} ; +void malloc() {} ; +void mblen() {} ; +void mbrlen() {} ; +void mbrtowc() {} ; +void mbsinit() {} ; +void mbsnrtowcs() {} ; +void mbsrtowcs() {} ; +void mbstowcs() {} ; +void mbtowc() {} ; +void memccpy() {} ; +void memchr() {} ; +void memcmp() {} ; +void memcpy() {} ; +void memmem() {} ; +void memmove() {} ; +void memrchr() {} ; +void memset() {} ; +void mkdir() {} ; +void mkfifo() {} ; +void mkstemp() {} ; +void mkstemp64() {} ; +void mktemp() {} ; +void mktime() {} ; +void mlock() {} ; +void mlockall() {} ; +void mmap() {} ; +void mmap64() {} ; +void mprotect() {} ; +void mrand48() {} ; +void msgctl() {} ; +void msgget() {} ; +void msgrcv() {} ; +void msgsnd() {} ; +void msync() {} ; +void munlock() {} ; +void munlockall() {} ; +void munmap() {} ; +void nanosleep() {} ; +void newlocale() {} ; +void nftw() {} ; +void nftw64() {} ; +void ngettext() {} ; +void nice() {} ; +void nl_langinfo() {} ; +void nrand48() {} ; +void ntohl() {} ; +void ntohs() {} ; +void open() {} ; +void opendir() {} ; +void openlog() {} ; +void pathconf() {} ; +void pause() {} ; +void pclose() {} ; +void perror() {} ; +void pipe() {} ; +void pmap_getport() {} ; +void pmap_set() {} ; +void pmap_unset() {} ; +void poll() {} ; +void popen() {} ; +void posix_memalign() {} ; +void posix_openpt() {} ; +void printf() {} ; +void psignal() {} ; +void ptsname() {} ; +void putc() {} ; +void putc_unlocked() {} ; +void putchar() {} ; +void putchar_unlocked() {} ; +void putenv() {} ; +void puts() {} ; +void pututxline() {} ; +void putw() {} ; +void putwc() {} ; +void putwchar() {} ; +void qsort() {} ; +void raise() {} ; +void rand() {} ; +void rand_r() {} ; +void random() {} ; +void read() {} ; +void readdir() {} ; +void readdir64() {} ; +void readdir_r() {} ; +void readlink() {} ; +void readv() {} ; +void realloc() {} ; +void realpath() {} ; +void recv() {} ; +void recvfrom() {} ; +void recvmsg() {} ; +void regcomp() {} ; +void regerror() {} ; +void regexec() {} ; +void regfree() {} ; +void remove() {} ; +void remque() {} ; +void rename() {} ; +void rewind() {} ; +void rewinddir() {} ; +void rindex() {} ; +void rmdir() {} ; +void sbrk() {} ; +void scanf() {} ; +void sched_get_priority_max() {} ; +void sched_get_priority_min() {} ; +void sched_getparam() {} ; +void sched_getscheduler() {} ; +void sched_rr_get_interval() {} ; +void sched_setparam() {} ; +void sched_setscheduler() {} ; +void sched_yield() {} ; +void seed48() {} ; +void seekdir() {} ; +void select() {} ; +void semctl() {} ; +void semget() {} ; +void semop() {} ; +void send() {} ; +void sendmsg() {} ; +void sendto() {} ; +void setbuf() {} ; +void setbuffer() {} ; +void setcontext() {} ; +void setegid() {} ; +void setenv() {} ; +void seteuid() {} ; +void setgid() {} ; +void setgrent() {} ; +void setgroups() {} ; +void sethostname() {} ; +void setitimer() {} ; +void setlocale() {} ; +void setlogmask() {} ; +void setpgid() {} ; +void setpgrp() {} ; +void setpriority() {} ; +void setprotoent() {} ; +void setpwent() {} ; +void setregid() {} ; +void setreuid() {} ; +void setrlimit() {} ; +void setrlimit64() {} ; +void setservent() {} ; +void setsid() {} ; +void setsockopt() {} ; +void setstate() {} ; +void setuid() {} ; +void setutent() {} ; +void setutxent() {} ; +void setvbuf() {} ; +void shmat() {} ; +void shmctl() {} ; +void shmdt() {} ; +void shmget() {} ; +void shutdown() {} ; +void sigaction() {} ; +void sigaddset() {} ; +void sigaltstack() {} ; +void sigandset() {} ; +void sigdelset() {} ; +void sigemptyset() {} ; +void sigfillset() {} ; +void sighold() {} ; +void sigignore() {} ; +void siginterrupt() {} ; +void sigisemptyset() {} ; +void sigismember() {} ; +void siglongjmp() {} ; +void signal() {} ; +void sigorset() {} ; +void sigpause() {} ; +void sigpending() {} ; +void sigprocmask() {} ; +void sigqueue() {} ; +void sigrelse() {} ; +void sigreturn() {} ; +void sigset() {} ; +void sigsuspend() {} ; +void sigtimedwait() {} ; +void sigwait() {} ; +void sigwaitinfo() {} ; +void sleep() {} ; +void snprintf() {} ; +void sockatmark() {} ; +void socket() {} ; +void socketpair() {} ; +void sprintf() {} ; +void srand() {} ; +void srand48() {} ; +void srandom() {} ; +void sscanf() {} ; +void statvfs() {} ; +void statvfs64() {} ; +void stime() {} ; +void stpcpy() {} ; +void stpncpy() {} ; +void strcasecmp() {} ; +void strcasestr() {} ; +void strcat() {} ; +void strchr() {} ; +void strcmp() {} ; +void strcoll() {} ; +void strcpy() {} ; +void strcspn() {} ; +void strdup() {} ; +void strerror() {} ; +void strerror_r() {} ; +void strfmon() {} ; +void strftime() {} ; +void strlen() {} ; +void strncasecmp() {} ; +void strncat() {} ; +void strncmp() {} ; +void strncpy() {} ; +void strndup() {} ; +void strnlen() {} ; +void strpbrk() {} ; +void strptime() {} ; +void strrchr() {} ; +void strsep() {} ; +void strsignal() {} ; +void strspn() {} ; +void strstr() {} ; +void strtod() {} ; +void strtof() {} ; +void strtoimax() {} ; +void strtok() {} ; +void strtok_r() {} ; +void strtol() {} ; +void strtold() {} ; +void strtoll() {} ; +void strtoq() {} ; +void strtoul() {} ; +void strtoull() {} ; +void strtoumax() {} ; +void strtouq() {} ; +void strxfrm() {} ; +void svc_getreqset() {} ; +void svc_register() {} ; +void svc_run() {} ; +void svc_sendreply() {} ; +void svcerr_auth() {} ; +void svcerr_decode() {} ; +void svcerr_noproc() {} ; +void svcerr_noprog() {} ; +void svcerr_progvers() {} ; +void svcerr_systemerr() {} ; +void svcerr_weakauth() {} ; +void svctcp_create() {} ; +void svcudp_create() {} ; +void swab() {} ; +void swapcontext() {} ; +void swprintf() {} ; +void swscanf() {} ; +void symlink() {} ; +void sync() {} ; +void sysconf() {} ; +void syslog() {} ; +void system() {} ; +void tcdrain() {} ; +void tcflow() {} ; +void tcflush() {} ; +void tcgetattr() {} ; +void tcgetpgrp() {} ; +void tcgetsid() {} ; +void tcsendbreak() {} ; +void tcsetattr() {} ; +void tcsetpgrp() {} ; +void tdelete() {} ; +void telldir() {} ; +void tempnam() {} ; +void textdomain() {} ; +void tfind() {} ; +void time() {} ; +void times() {} ; +void tmpfile() {} ; +void tmpfile64() {} ; +void tmpnam() {} ; +void toascii() {} ; +void tolower() {} ; +void toupper() {} ; +void towctrans() {} ; +void towlower() {} ; +void towupper() {} ; +void truncate() {} ; +void truncate64() {} ; +void tsearch() {} ; +void ttyname() {} ; +void ttyname_r() {} ; +void twalk() {} ; +void tzset() {} ; +void ualarm() {} ; +void ulimit() {} ; +void umask() {} ; +void uname() {} ; +void ungetc() {} ; +void ungetwc() {} ; +void unlink() {} ; +void unlockpt() {} ; +void unsetenv() {} ; +void uselocale() {} ; +void usleep() {} ; +void utime() {} ; +void utimes() {} ; +void utmpname() {} ; +void vasprintf() {} ; +void vdprintf() {} ; +void verrx() {} ; +void vfork() {} ; +void vfprintf() {} ; +void vfscanf() {} ; +void vfwprintf() {} ; +void vfwscanf() {} ; +void vprintf() {} ; +void vscanf() {} ; +void vsnprintf() {} ; +void vsprintf() {} ; +void vsscanf() {} ; +void vswprintf() {} ; +void vswscanf() {} ; +void vsyslog() {} ; +void vwprintf() {} ; +void vwscanf() {} ; +void wait() {} ; +void wait4() {} ; +void waitpid() {} ; +void warn() {} ; +void warnx() {} ; +void wcpcpy() {} ; +void wcpncpy() {} ; +void wcrtomb() {} ; +void wcscasecmp() {} ; +void wcscat() {} ; +void wcschr() {} ; +void wcscmp() {} ; +void wcscoll() {} ; +void wcscpy() {} ; +void wcscspn() {} ; +void wcsdup() {} ; +void wcsftime() {} ; +void wcslen() {} ; +void wcsncasecmp() {} ; +void wcsncat() {} ; +void wcsncmp() {} ; +void wcsncpy() {} ; +void wcsnlen() {} ; +void wcsnrtombs() {} ; +void wcspbrk() {} ; +void wcsrchr() {} ; +void wcsrtombs() {} ; +void wcsspn() {} ; +void wcsstr() {} ; +void wcstod() {} ; +void wcstof() {} ; +void wcstoimax() {} ; +void wcstok() {} ; +void wcstol() {} ; +void wcstold() {} ; +void wcstoll() {} ; +void wcstombs() {} ; +void wcstoq() {} ; +void wcstoul() {} ; +void wcstoull() {} ; +void wcstoumax() {} ; +void wcstouq() {} ; +void wcswcs() {} ; +void wcswidth() {} ; +void wcsxfrm() {} ; +void wctob() {} ; +void wctomb() {} ; +void wctrans() {} ; +void wctype() {} ; +void wcwidth() {} ; +void wmemchr() {} ; +void wmemcmp() {} ; +void wmemcpy() {} ; +void wmemmove() {} ; +void wmemset() {} ; +void wordexp() {} ; +void wordfree() {} ; +void wprintf() {} ; +void write() {} ; +void writev() {} ; +void wscanf() {} ; +void xdr_accepted_reply() {} ; +void xdr_array() {} ; +void xdr_bool() {} ; +void xdr_bytes() {} ; +void xdr_callhdr() {} ; +void xdr_callmsg() {} ; +void xdr_char() {} ; +void xdr_double() {} ; +void xdr_enum() {} ; +void xdr_float() {} ; +void xdr_free() {} ; +void xdr_int() {} ; +void xdr_long() {} ; +void xdr_opaque() {} ; +void xdr_opaque_auth() {} ; +void xdr_pointer() {} ; +void xdr_reference() {} ; +void xdr_rejected_reply() {} ; +void xdr_replymsg() {} ; +void xdr_short() {} ; +void xdr_string() {} ; +void xdr_u_char() {} ; +void xdr_u_int() {} ; +void xdr_u_long() {} ; +void xdr_u_short() {} ; +void xdr_union() {} ; +void xdr_vector() {} ; +void xdr_void() {} ; +void xdr_wrapstring() {} ; +void xdrmem_create() {} ; +void xdrrec_create() {} ; +void xdrrec_eof() {} ; +__asm__(".globl __daylight; .pushsection .data; .type __daylight,@object; .size __daylight, 4; __daylight: .long 0; .popsection"); +__asm__(".globl __environ; .pushsection .data; .type __environ,@object; .size __environ, 4; __environ: .long 0; .popsection"); +__asm__(".globl __timezone; .pushsection .data; .type __timezone,@object; .size __timezone, 4; __timezone: .long 0; .popsection"); +__asm__(".globl __tzname; .pushsection .data; .type __tzname,@object; .size __tzname, 8; __tzname: .long 0; .popsection"); +__asm__(".weak _environ; _environ = __environ"); +__asm__(".comm _nl_msg_cat_cntr,4"); +__asm__(".globl _sys_errlist; .pushsection .data; .type _sys_errlist,@object; .size _sys_errlist, 0; _sys_errlist: .long 0; .popsection"); +__asm__(".comm _sys_siglist,0"); +__asm__(".weak daylight; daylight = __daylight"); +__asm__(".weak environ; environ = __environ"); +__asm__(".comm getdate_err,4"); +__asm__(".comm optarg,4"); +__asm__(".comm opterr,4"); +__asm__(".comm optind,4"); +__asm__(".comm optopt,4"); +__asm__(".comm stderr,4"); +__asm__(".comm stdin,4"); +__asm__(".comm stdout,4"); +__asm__(".weak timezone; timezone = __timezone"); +__asm__(".weak tzname; tzname = __tzname"); +extern const int _IO_stdin_used; +__asm__(".weak _IO_stdin_used;.weak _LSB_IO_stdin_used; _LSB_IO_stdin_used=_IO_stdin_used "); diff --git a/lsb-build/stub_libs/libc_nonshared.c b/lsb-build/stub_libs/libc_nonshared.c new file mode 100644 index 0000000..cc74de6 --- /dev/null +++ b/lsb-build/stub_libs/libc_nonshared.c @@ -0,0 +1,100 @@ +/* Startup support for ELF initializers/finalizers in the main executable. + Copyright (C) 2002, 2003 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + In addition to the permissions in the GNU Lesser General Public + License, the Free Software Foundation gives you unlimited + permission to link the compiled version of this file with other + programs, and to distribute those programs without any restriction + coming from the use of this file. (The GNU Lesser General Public + License restrictions do apply in other respects; for example, they + cover modification of the file, and distribution when not linked + into another program.) + + Note that people who make modified versions of this file are not + obligated to grant this special exception for their modified + versions; it is their choice whether to do so. The GNU Lesser + General Public License gives permission to release a modified + version without this exception; this exception also makes it + possible to release a modified version which carries forward this + exception. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#include "config.h" +#include + +#ifdef HAVE_INITFINI_ARRAY +/* These magic symbols are provided by the linker. */ +extern void (*__preinit_array_start []) (void) attribute_hidden; +extern void (*__preinit_array_end []) (void) attribute_hidden; +extern void (*__init_array_start []) (void) attribute_hidden; +extern void (*__init_array_end []) (void) attribute_hidden; +extern void (*__fini_array_start []) (void) attribute_hidden; +extern void (*__fini_array_end []) (void) attribute_hidden; +#endif + +/* These function symbols are provided for the .init/.fini section entry + points automagically by the linker. */ +extern void _init (void); +extern void _fini (void); + +/* These functions are passed to __libc_start_main by the startup code. + These get statically linked into each program. For dynamically linked + programs, this module will come from libc_nonshared.a and differs from + the libc.a module in that it doesn't call the preinit array. */ + +void +__libc_csu_init (void) +{ +#ifdef HAVE_INITFINI_ARRAY + /* For dynamically linked executables the preinit array is executed by + the dynamic linker (before initializing any shared object. */ + +# ifndef LIBC_NONSHARED + /* For static executables, preinit happens rights before init. */ + { + const size_t size = __preinit_array_end - __preinit_array_start; + size_t i; + for (i = 0; i < size; i++) + (*__preinit_array_start [i]) (); + } +# endif +#endif + + _init (); + +#ifdef HAVE_INITFINI_ARRAY + { + const size_t size = __init_array_end - __init_array_start; + size_t i; + for (i = 0; i < size; i++) + (*__init_array_start [i]) (); + } +#endif +} + +void +__libc_csu_fini (void) +{ +#ifdef HAVE_INITFINI_ARRAY + size_t i = __fini_array_end - __fini_array_start; + while (i-- > 0) + (*__fini_array_start [i]) (); +#endif + + _fini (); +} diff --git a/lsb-build/stub_libs/libdl.Version b/lsb-build/stub_libs/libdl.Version new file mode 100644 index 0000000..d829931 --- /dev/null +++ b/lsb-build/stub_libs/libdl.Version @@ -0,0 +1,10 @@ +LSB_DUMMY { __LSB_DUMMY; }; +GLIBC_2.0 { + dladdr; + dlclose; + dlerror; + dlsym; +}; +GLIBC_2.1 { + dlopen; +}; diff --git a/lsb-build/stub_libs/libdl.c b/lsb-build/stub_libs/libdl.c new file mode 100644 index 0000000..00dcfe5 --- /dev/null +++ b/lsb-build/stub_libs/libdl.c @@ -0,0 +1,5 @@ +void dladdr() {} ; +void dlclose() {} ; +void dlerror() {} ; +void dlopen() {} ; +void dlsym() {} ; diff --git a/lsb-build/stub_libs/libgcc_s.Version b/lsb-build/stub_libs/libgcc_s.Version new file mode 100644 index 0000000..f9f3911 --- /dev/null +++ b/lsb-build/stub_libs/libgcc_s.Version @@ -0,0 +1,22 @@ +LSB_DUMMY { __LSB_DUMMY; }; +GCC_3.0 { + _Unwind_DeleteException; + _Unwind_Find_FDE; + _Unwind_ForcedUnwind; + _Unwind_GetDataRelBase; + _Unwind_GetGR; + _Unwind_GetIP; + _Unwind_GetLanguageSpecificData; + _Unwind_GetRegionStart; + _Unwind_GetTextRelBase; + _Unwind_RaiseException; + _Unwind_Resume; + _Unwind_SetGR; + _Unwind_SetIP; +}; +GCC_3.3 { + _Unwind_Backtrace; + _Unwind_FindEnclosingFunction; + _Unwind_GetCFA; + _Unwind_Resume_or_Rethrow; +}; diff --git a/lsb-build/stub_libs/libgcc_s.c b/lsb-build/stub_libs/libgcc_s.c new file mode 100644 index 0000000..2b48f0e --- /dev/null +++ b/lsb-build/stub_libs/libgcc_s.c @@ -0,0 +1,17 @@ +void _Unwind_Backtrace() {} ; +void _Unwind_DeleteException() {} ; +void _Unwind_FindEnclosingFunction() {} ; +void _Unwind_Find_FDE() {} ; +void _Unwind_ForcedUnwind() {} ; +void _Unwind_GetCFA() {} ; +void _Unwind_GetDataRelBase() {} ; +void _Unwind_GetGR() {} ; +void _Unwind_GetIP() {} ; +void _Unwind_GetLanguageSpecificData() {} ; +void _Unwind_GetRegionStart() {} ; +void _Unwind_GetTextRelBase() {} ; +void _Unwind_RaiseException() {} ; +void _Unwind_Resume() {} ; +void _Unwind_Resume_or_Rethrow() {} ; +void _Unwind_SetGR() {} ; +void _Unwind_SetIP() {} ; diff --git a/lsb-build/stub_libs/libgdk-x11-2.0.Version b/lsb-build/stub_libs/libgdk-x11-2.0.Version new file mode 100644 index 0000000..08a3220 --- /dev/null +++ b/lsb-build/stub_libs/libgdk-x11-2.0.Version @@ -0,0 +1 @@ +LSB_DUMMY { __LSB_DUMMY; }; diff --git a/lsb-build/stub_libs/libgdk-x11-2.0.c b/lsb-build/stub_libs/libgdk-x11-2.0.c new file mode 100644 index 0000000..679f269 --- /dev/null +++ b/lsb-build/stub_libs/libgdk-x11-2.0.c @@ -0,0 +1,546 @@ +void gdk_add_client_message_filter() {} ; +void gdk_atom_intern() {} ; +void gdk_atom_name() {} ; +void gdk_axis_use_get_type() {} ; +void gdk_beep() {} ; +void gdk_bitmap_create_from_data() {} ; +void gdk_byte_order_get_type() {} ; +void gdk_cap_style_get_type() {} ; +void gdk_color_copy() {} ; +void gdk_color_equal() {} ; +void gdk_color_free() {} ; +void gdk_color_get_type() {} ; +void gdk_color_hash() {} ; +void gdk_color_parse() {} ; +void gdk_colormap_alloc_color() {} ; +void gdk_colormap_alloc_colors() {} ; +void gdk_colormap_free_colors() {} ; +void gdk_colormap_get_screen() {} ; +void gdk_colormap_get_system() {} ; +void gdk_colormap_get_type() {} ; +void gdk_colormap_get_visual() {} ; +void gdk_colormap_new() {} ; +void gdk_colormap_query_color() {} ; +void gdk_crossing_mode_get_type() {} ; +void gdk_cursor_get_display() {} ; +void gdk_cursor_get_type() {} ; +void gdk_cursor_new() {} ; +void gdk_cursor_new_for_display() {} ; +void gdk_cursor_new_from_pixbuf() {} ; +void gdk_cursor_new_from_pixmap() {} ; +void gdk_cursor_ref() {} ; +void gdk_cursor_type_get_type() {} ; +void gdk_cursor_unref() {} ; +void gdk_device_free_history() {} ; +void gdk_device_get_axis() {} ; +void gdk_device_get_core_pointer() {} ; +void gdk_device_get_history() {} ; +void gdk_device_get_state() {} ; +void gdk_device_get_type() {} ; +void gdk_device_set_axis_use() {} ; +void gdk_device_set_key() {} ; +void gdk_device_set_mode() {} ; +void gdk_device_set_source() {} ; +void gdk_devices_list() {} ; +void gdk_display_add_client_message_filter() {} ; +void gdk_display_beep() {} ; +void gdk_display_close() {} ; +void gdk_display_flush() {} ; +void gdk_display_get_core_pointer() {} ; +void gdk_display_get_default() {} ; +void gdk_display_get_default_cursor_size() {} ; +void gdk_display_get_default_group() {} ; +void gdk_display_get_default_screen() {} ; +void gdk_display_get_event() {} ; +void gdk_display_get_maximal_cursor_size() {} ; +void gdk_display_get_n_screens() {} ; +void gdk_display_get_name() {} ; +void gdk_display_get_pointer() {} ; +void gdk_display_get_screen() {} ; +void gdk_display_get_type() {} ; +void gdk_display_get_window_at_pointer() {} ; +void gdk_display_keyboard_ungrab() {} ; +void gdk_display_list_devices() {} ; +void gdk_display_manager_get() {} ; +void gdk_display_manager_get_default_display() {} ; +void gdk_display_manager_get_type() {} ; +void gdk_display_manager_list_displays() {} ; +void gdk_display_manager_set_default_display() {} ; +void gdk_display_open() {} ; +void gdk_display_peek_event() {} ; +void gdk_display_pointer_is_grabbed() {} ; +void gdk_display_pointer_ungrab() {} ; +void gdk_display_put_event() {} ; +void gdk_display_request_selection_notification() {} ; +void gdk_display_set_double_click_distance() {} ; +void gdk_display_set_double_click_time() {} ; +void gdk_display_set_pointer_hooks() {} ; +void gdk_display_store_clipboard() {} ; +void gdk_display_supports_clipboard_persistence() {} ; +void gdk_display_supports_cursor_alpha() {} ; +void gdk_display_supports_cursor_color() {} ; +void gdk_display_supports_selection_notification() {} ; +void gdk_display_sync() {} ; +void gdk_drag_abort() {} ; +void gdk_drag_action_get_type() {} ; +void gdk_drag_begin() {} ; +void gdk_drag_context_get_type() {} ; +void gdk_drag_context_new() {} ; +void gdk_drag_drop() {} ; +void gdk_drag_drop_succeeded() {} ; +void gdk_drag_find_window() {} ; +void gdk_drag_find_window_for_screen() {} ; +void gdk_drag_get_protocol() {} ; +void gdk_drag_get_protocol_for_display() {} ; +void gdk_drag_get_selection() {} ; +void gdk_drag_motion() {} ; +void gdk_drag_protocol_get_type() {} ; +void gdk_drag_status() {} ; +void gdk_draw_arc() {} ; +void gdk_draw_drawable() {} ; +void gdk_draw_glyphs() {} ; +void gdk_draw_glyphs_transformed() {} ; +void gdk_draw_gray_image() {} ; +void gdk_draw_image() {} ; +void gdk_draw_indexed_image() {} ; +void gdk_draw_layout() {} ; +void gdk_draw_layout_line() {} ; +void gdk_draw_layout_line_with_colors() {} ; +void gdk_draw_layout_with_colors() {} ; +void gdk_draw_line() {} ; +void gdk_draw_lines() {} ; +void gdk_draw_pixbuf() {} ; +void gdk_draw_point() {} ; +void gdk_draw_points() {} ; +void gdk_draw_polygon() {} ; +void gdk_draw_rectangle() {} ; +void gdk_draw_rgb_32_image() {} ; +void gdk_draw_rgb_32_image_dithalign() {} ; +void gdk_draw_rgb_image() {} ; +void gdk_draw_rgb_image_dithalign() {} ; +void gdk_draw_segments() {} ; +void gdk_draw_trapezoids() {} ; +void gdk_drawable_copy_to_image() {} ; +void gdk_drawable_get_clip_region() {} ; +void gdk_drawable_get_colormap() {} ; +void gdk_drawable_get_depth() {} ; +void gdk_drawable_get_display() {} ; +void gdk_drawable_get_image() {} ; +void gdk_drawable_get_screen() {} ; +void gdk_drawable_get_size() {} ; +void gdk_drawable_get_type() {} ; +void gdk_drawable_get_visible_region() {} ; +void gdk_drawable_get_visual() {} ; +void gdk_drawable_set_colormap() {} ; +void gdk_drop_finish() {} ; +void gdk_drop_reply() {} ; +void gdk_error_trap_pop() {} ; +void gdk_error_trap_push() {} ; +void gdk_event_copy() {} ; +void gdk_event_free() {} ; +void gdk_event_get() {} ; +void gdk_event_get_axis() {} ; +void gdk_event_get_coords() {} ; +void gdk_event_get_graphics_expose() {} ; +void gdk_event_get_root_coords() {} ; +void gdk_event_get_screen() {} ; +void gdk_event_get_state() {} ; +void gdk_event_get_time() {} ; +void gdk_event_get_type() {} ; +void gdk_event_handler_set() {} ; +void gdk_event_mask_get_type() {} ; +void gdk_event_new() {} ; +void gdk_event_peek() {} ; +void gdk_event_put() {} ; +void gdk_event_send_client_message() {} ; +void gdk_event_send_client_message_for_display() {} ; +void gdk_event_send_clientmessage_toall() {} ; +void gdk_event_set_screen() {} ; +void gdk_event_type_get_type() {} ; +void gdk_events_pending() {} ; +void gdk_extension_mode_get_type() {} ; +void gdk_fill_get_type() {} ; +void gdk_fill_rule_get_type() {} ; +void gdk_filter_return_get_type() {} ; +void gdk_flush() {} ; +void gdk_font_type_get_type() {} ; +void gdk_free_compound_text() {} ; +void gdk_free_text_list() {} ; +void gdk_function_get_type() {} ; +void gdk_gc_copy() {} ; +void gdk_gc_get_colormap() {} ; +void gdk_gc_get_screen() {} ; +void gdk_gc_get_type() {} ; +void gdk_gc_get_values() {} ; +void gdk_gc_new() {} ; +void gdk_gc_new_with_values() {} ; +void gdk_gc_offset() {} ; +void gdk_gc_set_background() {} ; +void gdk_gc_set_clip_mask() {} ; +void gdk_gc_set_clip_origin() {} ; +void gdk_gc_set_clip_rectangle() {} ; +void gdk_gc_set_clip_region() {} ; +void gdk_gc_set_colormap() {} ; +void gdk_gc_set_dashes() {} ; +void gdk_gc_set_exposures() {} ; +void gdk_gc_set_fill() {} ; +void gdk_gc_set_foreground() {} ; +void gdk_gc_set_function() {} ; +void gdk_gc_set_line_attributes() {} ; +void gdk_gc_set_rgb_bg_color() {} ; +void gdk_gc_set_rgb_fg_color() {} ; +void gdk_gc_set_stipple() {} ; +void gdk_gc_set_subwindow() {} ; +void gdk_gc_set_tile() {} ; +void gdk_gc_set_ts_origin() {} ; +void gdk_gc_set_values() {} ; +void gdk_gc_values_mask_get_type() {} ; +void gdk_get_default_root_window() {} ; +void gdk_get_display() {} ; +void gdk_get_display_arg_name() {} ; +void gdk_get_program_class() {} ; +void gdk_get_show_events() {} ; +void gdk_grab_status_get_type() {} ; +void gdk_gravity_get_type() {} ; +void gdk_image_get_colormap() {} ; +void gdk_image_get_pixel() {} ; +void gdk_image_get_type() {} ; +void gdk_image_new() {} ; +void gdk_image_put_pixel() {} ; +void gdk_image_set_colormap() {} ; +void gdk_image_type_get_type() {} ; +void gdk_init() {} ; +void gdk_init_check() {} ; +void gdk_input_condition_get_type() {} ; +void gdk_input_mode_get_type() {} ; +void gdk_input_set_extension_events() {} ; +void gdk_input_source_get_type() {} ; +void gdk_join_style_get_type() {} ; +void gdk_keyboard_grab() {} ; +void gdk_keyboard_ungrab() {} ; +void gdk_keymap_get_default() {} ; +void gdk_keymap_get_direction() {} ; +void gdk_keymap_get_entries_for_keycode() {} ; +void gdk_keymap_get_entries_for_keyval() {} ; +void gdk_keymap_get_for_display() {} ; +void gdk_keymap_get_type() {} ; +void gdk_keymap_lookup_key() {} ; +void gdk_keymap_translate_keyboard_state() {} ; +void gdk_keyval_convert_case() {} ; +void gdk_keyval_from_name() {} ; +void gdk_keyval_is_lower() {} ; +void gdk_keyval_is_upper() {} ; +void gdk_keyval_name() {} ; +void gdk_keyval_to_lower() {} ; +void gdk_keyval_to_unicode() {} ; +void gdk_keyval_to_upper() {} ; +void gdk_line_style_get_type() {} ; +void gdk_list_visuals() {} ; +void gdk_modifier_type_get_type() {} ; +void gdk_net_wm_supports() {} ; +void gdk_notify_startup_complete() {} ; +void gdk_notify_type_get_type() {} ; +void gdk_overlap_type_get_type() {} ; +void gdk_owner_change_get_type() {} ; +void gdk_pango_attr_embossed_new() {} ; +void gdk_pango_attr_stipple_new() {} ; +void gdk_pango_context_get() {} ; +void gdk_pango_context_get_for_screen() {} ; +void gdk_pango_layout_get_clip_region() {} ; +void gdk_pango_layout_line_get_clip_region() {} ; +void gdk_pango_renderer_get_default() {} ; +void gdk_pango_renderer_get_type() {} ; +void gdk_pango_renderer_new() {} ; +void gdk_pango_renderer_set_drawable() {} ; +void gdk_pango_renderer_set_gc() {} ; +void gdk_pango_renderer_set_override_color() {} ; +void gdk_pango_renderer_set_stipple() {} ; +void gdk_parse_args() {} ; +void gdk_pixbuf_get_from_drawable() {} ; +void gdk_pixbuf_get_from_image() {} ; +void gdk_pixbuf_render_pixmap_and_mask() {} ; +void gdk_pixbuf_render_pixmap_and_mask_for_colormap() {} ; +void gdk_pixbuf_render_threshold_alpha() {} ; +void gdk_pixmap_colormap_create_from_xpm() {} ; +void gdk_pixmap_colormap_create_from_xpm_d() {} ; +void gdk_pixmap_create_from_data() {} ; +void gdk_pixmap_create_from_xpm() {} ; +void gdk_pixmap_create_from_xpm_d() {} ; +void gdk_pixmap_foreign_new() {} ; +void gdk_pixmap_foreign_new_for_display() {} ; +void gdk_pixmap_get_type() {} ; +void gdk_pixmap_lookup() {} ; +void gdk_pixmap_lookup_for_display() {} ; +void gdk_pixmap_new() {} ; +void gdk_pointer_grab() {} ; +void gdk_pointer_is_grabbed() {} ; +void gdk_pointer_ungrab() {} ; +void gdk_prop_mode_get_type() {} ; +void gdk_property_change() {} ; +void gdk_property_delete() {} ; +void gdk_property_get() {} ; +void gdk_property_state_get_type() {} ; +void gdk_query_depths() {} ; +void gdk_query_visual_types() {} ; +void gdk_rectangle_get_type() {} ; +void gdk_rectangle_intersect() {} ; +void gdk_rectangle_union() {} ; +void gdk_region_copy() {} ; +void gdk_region_destroy() {} ; +void gdk_region_empty() {} ; +void gdk_region_equal() {} ; +void gdk_region_get_clipbox() {} ; +void gdk_region_get_rectangles() {} ; +void gdk_region_intersect() {} ; +void gdk_region_new() {} ; +void gdk_region_offset() {} ; +void gdk_region_point_in() {} ; +void gdk_region_polygon() {} ; +void gdk_region_rect_in() {} ; +void gdk_region_rectangle() {} ; +void gdk_region_shrink() {} ; +void gdk_region_spans_intersect_foreach() {} ; +void gdk_region_subtract() {} ; +void gdk_region_union() {} ; +void gdk_region_union_with_rect() {} ; +void gdk_region_xor() {} ; +void gdk_rgb_cmap_free() {} ; +void gdk_rgb_cmap_new() {} ; +void gdk_rgb_colormap_ditherable() {} ; +void gdk_rgb_dither_get_type() {} ; +void gdk_rgb_ditherable() {} ; +void gdk_rgb_find_color() {} ; +void gdk_rgb_get_colormap() {} ; +void gdk_rgb_get_visual() {} ; +void gdk_rgb_set_install() {} ; +void gdk_rgb_set_min_colors() {} ; +void gdk_rgb_set_verbose() {} ; +void gdk_screen_broadcast_client_message() {} ; +void gdk_screen_get_default() {} ; +void gdk_screen_get_default_colormap() {} ; +void gdk_screen_get_display() {} ; +void gdk_screen_get_height() {} ; +void gdk_screen_get_height_mm() {} ; +void gdk_screen_get_monitor_at_point() {} ; +void gdk_screen_get_monitor_at_window() {} ; +void gdk_screen_get_monitor_geometry() {} ; +void gdk_screen_get_n_monitors() {} ; +void gdk_screen_get_number() {} ; +void gdk_screen_get_rgb_colormap() {} ; +void gdk_screen_get_rgb_visual() {} ; +void gdk_screen_get_root_window() {} ; +void gdk_screen_get_setting() {} ; +void gdk_screen_get_system_colormap() {} ; +void gdk_screen_get_system_visual() {} ; +void gdk_screen_get_toplevel_windows() {} ; +void gdk_screen_get_type() {} ; +void gdk_screen_get_width() {} ; +void gdk_screen_get_width_mm() {} ; +void gdk_screen_height() {} ; +void gdk_screen_height_mm() {} ; +void gdk_screen_list_visuals() {} ; +void gdk_screen_make_display_name() {} ; +void gdk_screen_set_default_colormap() {} ; +void gdk_screen_width() {} ; +void gdk_screen_width_mm() {} ; +void gdk_scroll_direction_get_type() {} ; +void gdk_selection_convert() {} ; +void gdk_selection_owner_get() {} ; +void gdk_selection_owner_get_for_display() {} ; +void gdk_selection_owner_set() {} ; +void gdk_selection_owner_set_for_display() {} ; +void gdk_selection_property_get() {} ; +void gdk_selection_send_notify() {} ; +void gdk_selection_send_notify_for_display() {} ; +void gdk_set_double_click_time() {} ; +void gdk_set_locale() {} ; +void gdk_set_pointer_hooks() {} ; +void gdk_set_program_class() {} ; +void gdk_set_show_events() {} ; +void gdk_set_sm_client_id() {} ; +void gdk_setting_action_get_type() {} ; +void gdk_setting_get() {} ; +void gdk_spawn_command_line_on_screen() {} ; +void gdk_spawn_on_screen() {} ; +void gdk_spawn_on_screen_with_pipes() {} ; +void gdk_status_get_type() {} ; +void gdk_string_to_compound_text() {} ; +void gdk_string_to_compound_text_for_display() {} ; +void gdk_subwindow_mode_get_type() {} ; +void gdk_synthesize_window_state() {} ; +void gdk_text_property_to_text_list() {} ; +void gdk_text_property_to_text_list_for_display() {} ; +void gdk_text_property_to_utf8_list() {} ; +void gdk_text_property_to_utf8_list_for_display() {} ; +void gdk_threads_enter() {} ; +void gdk_threads_init() {} ; +void gdk_threads_leave() {} ; +void gdk_threads_set_lock_functions() {} ; +void gdk_unicode_to_keyval() {} ; +void gdk_utf8_to_compound_text() {} ; +void gdk_utf8_to_compound_text_for_display() {} ; +void gdk_utf8_to_string_target() {} ; +void gdk_visibility_state_get_type() {} ; +void gdk_visual_get_best() {} ; +void gdk_visual_get_best_depth() {} ; +void gdk_visual_get_best_type() {} ; +void gdk_visual_get_best_with_both() {} ; +void gdk_visual_get_best_with_depth() {} ; +void gdk_visual_get_best_with_type() {} ; +void gdk_visual_get_screen() {} ; +void gdk_visual_get_system() {} ; +void gdk_visual_get_type() {} ; +void gdk_visual_type_get_type() {} ; +void gdk_window_add_filter() {} ; +void gdk_window_at_pointer() {} ; +void gdk_window_attributes_type_get_type() {} ; +void gdk_window_begin_move_drag() {} ; +void gdk_window_begin_paint_rect() {} ; +void gdk_window_begin_paint_region() {} ; +void gdk_window_begin_resize_drag() {} ; +void gdk_window_class_get_type() {} ; +void gdk_window_clear() {} ; +void gdk_window_clear_area() {} ; +void gdk_window_clear_area_e() {} ; +void gdk_window_configure_finished() {} ; +void gdk_window_constrain_size() {} ; +void gdk_window_deiconify() {} ; +void gdk_window_destroy() {} ; +void gdk_window_destroy_notify() {} ; +void gdk_window_edge_get_type() {} ; +void gdk_window_enable_synchronized_configure() {} ; +void gdk_window_end_paint() {} ; +void gdk_window_focus() {} ; +void gdk_window_foreign_new() {} ; +void gdk_window_foreign_new_for_display() {} ; +void gdk_window_freeze_updates() {} ; +void gdk_window_fullscreen() {} ; +void gdk_window_get_children() {} ; +void gdk_window_get_decorations() {} ; +void gdk_window_get_events() {} ; +void gdk_window_get_frame_extents() {} ; +void gdk_window_get_geometry() {} ; +void gdk_window_get_group() {} ; +void gdk_window_get_internal_paint_info() {} ; +void gdk_window_get_origin() {} ; +void gdk_window_get_parent() {} ; +void gdk_window_get_pointer() {} ; +void gdk_window_get_position() {} ; +void gdk_window_get_root_origin() {} ; +void gdk_window_get_state() {} ; +void gdk_window_get_toplevel() {} ; +void gdk_window_get_toplevels() {} ; +void gdk_window_get_update_area() {} ; +void gdk_window_get_user_data() {} ; +void gdk_window_get_window_type() {} ; +void gdk_window_hide() {} ; +void gdk_window_hints_get_type() {} ; +void gdk_window_iconify() {} ; +void gdk_window_invalidate_maybe_recurse() {} ; +void gdk_window_invalidate_rect() {} ; +void gdk_window_invalidate_region() {} ; +void gdk_window_is_viewable() {} ; +void gdk_window_is_visible() {} ; +void gdk_window_lookup() {} ; +void gdk_window_lookup_for_display() {} ; +void gdk_window_lower() {} ; +void gdk_window_maximize() {} ; +void gdk_window_merge_child_shapes() {} ; +void gdk_window_move() {} ; +void gdk_window_move_resize() {} ; +void gdk_window_new() {} ; +void gdk_window_object_get_type() {} ; +void gdk_window_peek_children() {} ; +void gdk_window_process_all_updates() {} ; +void gdk_window_process_updates() {} ; +void gdk_window_raise() {} ; +void gdk_window_register_dnd() {} ; +void gdk_window_remove_filter() {} ; +void gdk_window_reparent() {} ; +void gdk_window_resize() {} ; +void gdk_window_scroll() {} ; +void gdk_window_set_accept_focus() {} ; +void gdk_window_set_back_pixmap() {} ; +void gdk_window_set_background() {} ; +void gdk_window_set_child_shapes() {} ; +void gdk_window_set_cursor() {} ; +void gdk_window_set_debug_updates() {} ; +void gdk_window_set_decorations() {} ; +void gdk_window_set_events() {} ; +void gdk_window_set_focus_on_map() {} ; +void gdk_window_set_functions() {} ; +void gdk_window_set_geometry_hints() {} ; +void gdk_window_set_group() {} ; +void gdk_window_set_icon() {} ; +void gdk_window_set_icon_list() {} ; +void gdk_window_set_icon_name() {} ; +void gdk_window_set_keep_above() {} ; +void gdk_window_set_keep_below() {} ; +void gdk_window_set_modal_hint() {} ; +void gdk_window_set_override_redirect() {} ; +void gdk_window_set_role() {} ; +void gdk_window_set_skip_pager_hint() {} ; +void gdk_window_set_skip_taskbar_hint() {} ; +void gdk_window_set_static_gravities() {} ; +void gdk_window_set_title() {} ; +void gdk_window_set_transient_for() {} ; +void gdk_window_set_type_hint() {} ; +void gdk_window_set_user_data() {} ; +void gdk_window_shape_combine_mask() {} ; +void gdk_window_shape_combine_region() {} ; +void gdk_window_show() {} ; +void gdk_window_show_unraised() {} ; +void gdk_window_state_get_type() {} ; +void gdk_window_stick() {} ; +void gdk_window_thaw_updates() {} ; +void gdk_window_type_get_type() {} ; +void gdk_window_type_hint_get_type() {} ; +void gdk_window_unfullscreen() {} ; +void gdk_window_unmaximize() {} ; +void gdk_window_unstick() {} ; +void gdk_window_withdraw() {} ; +void gdk_wm_decoration_get_type() {} ; +void gdk_wm_function_get_type() {} ; +void gdk_x11_atom_to_xatom() {} ; +void gdk_x11_atom_to_xatom_for_display() {} ; +void gdk_x11_colormap_foreign_new() {} ; +void gdk_x11_colormap_get_xcolormap() {} ; +void gdk_x11_colormap_get_xdisplay() {} ; +void gdk_x11_cursor_get_xcursor() {} ; +void gdk_x11_cursor_get_xdisplay() {} ; +void gdk_x11_display_get_xdisplay() {} ; +void gdk_x11_display_grab() {} ; +void gdk_x11_display_ungrab() {} ; +void gdk_x11_drawable_get_xdisplay() {} ; +void gdk_x11_drawable_get_xid() {} ; +void gdk_x11_gc_get_xdisplay() {} ; +void gdk_x11_gc_get_xgc() {} ; +void gdk_x11_get_default_root_xwindow() {} ; +void gdk_x11_get_default_screen() {} ; +void gdk_x11_get_default_xdisplay() {} ; +void gdk_x11_get_server_time() {} ; +void gdk_x11_get_xatom_by_name() {} ; +void gdk_x11_get_xatom_by_name_for_display() {} ; +void gdk_x11_get_xatom_name() {} ; +void gdk_x11_get_xatom_name_for_display() {} ; +void gdk_x11_grab_server() {} ; +void gdk_x11_image_get_xdisplay() {} ; +void gdk_x11_image_get_ximage() {} ; +void gdk_x11_lookup_xdisplay() {} ; +void gdk_x11_register_standard_event_type() {} ; +void gdk_x11_screen_get_screen_number() {} ; +void gdk_x11_screen_get_window_manager_name() {} ; +void gdk_x11_screen_get_xscreen() {} ; +void gdk_x11_screen_lookup_visual() {} ; +void gdk_x11_screen_supports_net_wm_hint() {} ; +void gdk_x11_ungrab_server() {} ; +void gdk_x11_visual_get_xvisual() {} ; +void gdk_x11_window_set_user_time() {} ; +void gdk_x11_xatom_to_atom() {} ; +void gdk_x11_xatom_to_atom_for_display() {} ; +void gdk_xid_table_lookup() {} ; +void gdk_xid_table_lookup_for_display() {} ; +void gdkx_visual_get() {} ; +__asm__(".globl gdk_display; .pushsection .data; .type gdk_display,@object; .size gdk_display, 4; gdk_display: .long 0; .popsection"); +__asm__(".globl gdk_threads_lock; .pushsection .data; .type gdk_threads_lock,@object; .size gdk_threads_lock, 4; gdk_threads_lock: .long 0; .popsection"); +__asm__(".globl gdk_threads_unlock; .pushsection .data; .type gdk_threads_unlock,@object; .size gdk_threads_unlock, 4; gdk_threads_unlock: .long 0; .popsection"); diff --git a/lsb-build/stub_libs/libglib-2.0.Version b/lsb-build/stub_libs/libglib-2.0.Version new file mode 100644 index 0000000..08a3220 --- /dev/null +++ b/lsb-build/stub_libs/libglib-2.0.Version @@ -0,0 +1 @@ +LSB_DUMMY { __LSB_DUMMY; }; diff --git a/lsb-build/stub_libs/libglib-2.0.c b/lsb-build/stub_libs/libglib-2.0.c new file mode 100644 index 0000000..26150f5 --- /dev/null +++ b/lsb-build/stub_libs/libglib-2.0.c @@ -0,0 +1,847 @@ +void g_allocator_free() {} ; +void g_allocator_new() {} ; +void g_array_append_vals() {} ; +void g_array_free() {} ; +void g_array_insert_vals() {} ; +void g_array_new() {} ; +void g_array_prepend_vals() {} ; +void g_array_remove_index() {} ; +void g_array_remove_index_fast() {} ; +void g_array_remove_range() {} ; +void g_array_set_size() {} ; +void g_array_sized_new() {} ; +void g_array_sort() {} ; +void g_array_sort_with_data() {} ; +void g_ascii_digit_value() {} ; +void g_ascii_dtostr() {} ; +void g_ascii_formatd() {} ; +void g_ascii_strcasecmp() {} ; +void g_ascii_strdown() {} ; +void g_ascii_strncasecmp() {} ; +void g_ascii_strtod() {} ; +void g_ascii_strtoull() {} ; +void g_ascii_strup() {} ; +void g_ascii_tolower() {} ; +void g_ascii_toupper() {} ; +void g_ascii_xdigit_value() {} ; +void g_assert_warning() {} ; +void g_async_queue_length() {} ; +void g_async_queue_length_unlocked() {} ; +void g_async_queue_lock() {} ; +void g_async_queue_new() {} ; +void g_async_queue_pop() {} ; +void g_async_queue_pop_unlocked() {} ; +void g_async_queue_push() {} ; +void g_async_queue_push_unlocked() {} ; +void g_async_queue_ref() {} ; +void g_async_queue_timed_pop() {} ; +void g_async_queue_timed_pop_unlocked() {} ; +void g_async_queue_try_pop() {} ; +void g_async_queue_try_pop_unlocked() {} ; +void g_async_queue_unlock() {} ; +void g_async_queue_unref() {} ; +void g_atexit() {} ; +void g_atomic_int_add() {} ; +void g_atomic_int_compare_and_exchange() {} ; +void g_atomic_int_exchange_and_add() {} ; +void g_atomic_pointer_compare_and_exchange() {} ; +void g_bit_nth_lsf() {} ; +void g_bit_nth_msf() {} ; +void g_bit_storage() {} ; +void g_blow_chunks() {} ; +void g_build_filename() {} ; +void g_build_path() {} ; +void g_byte_array_append() {} ; +void g_byte_array_free() {} ; +void g_byte_array_new() {} ; +void g_byte_array_prepend() {} ; +void g_byte_array_remove_index() {} ; +void g_byte_array_remove_index_fast() {} ; +void g_byte_array_remove_range() {} ; +void g_byte_array_set_size() {} ; +void g_byte_array_sized_new() {} ; +void g_byte_array_sort() {} ; +void g_byte_array_sort_with_data() {} ; +void g_cache_destroy() {} ; +void g_cache_insert() {} ; +void g_cache_key_foreach() {} ; +void g_cache_new() {} ; +void g_cache_remove() {} ; +void g_cache_value_foreach() {} ; +void g_child_watch_add() {} ; +void g_child_watch_add_full() {} ; +void g_child_watch_source_new() {} ; +void g_clear_error() {} ; +void g_completion_add_items() {} ; +void g_completion_clear_items() {} ; +void g_completion_complete() {} ; +void g_completion_complete_utf8() {} ; +void g_completion_free() {} ; +void g_completion_new() {} ; +void g_completion_remove_items() {} ; +void g_completion_set_compare() {} ; +void g_convert() {} ; +void g_convert_error_quark() {} ; +void g_convert_with_fallback() {} ; +void g_convert_with_iconv() {} ; +void g_datalist_clear() {} ; +void g_datalist_foreach() {} ; +void g_datalist_id_get_data() {} ; +void g_datalist_id_remove_no_notify() {} ; +void g_datalist_id_set_data_full() {} ; +void g_datalist_init() {} ; +void g_dataset_destroy() {} ; +void g_dataset_foreach() {} ; +void g_dataset_id_get_data() {} ; +void g_dataset_id_remove_no_notify() {} ; +void g_dataset_id_set_data_full() {} ; +void g_date_add_days() {} ; +void g_date_add_months() {} ; +void g_date_add_years() {} ; +void g_date_clamp() {} ; +void g_date_clear() {} ; +void g_date_compare() {} ; +void g_date_days_between() {} ; +void g_date_free() {} ; +void g_date_get_day() {} ; +void g_date_get_day_of_year() {} ; +void g_date_get_days_in_month() {} ; +void g_date_get_iso8601_week_of_year() {} ; +void g_date_get_julian() {} ; +void g_date_get_monday_week_of_year() {} ; +void g_date_get_monday_weeks_in_year() {} ; +void g_date_get_month() {} ; +void g_date_get_sunday_week_of_year() {} ; +void g_date_get_sunday_weeks_in_year() {} ; +void g_date_get_weekday() {} ; +void g_date_get_year() {} ; +void g_date_is_first_of_month() {} ; +void g_date_is_last_of_month() {} ; +void g_date_is_leap_year() {} ; +void g_date_new() {} ; +void g_date_new_dmy() {} ; +void g_date_new_julian() {} ; +void g_date_order() {} ; +void g_date_set_day() {} ; +void g_date_set_dmy() {} ; +void g_date_set_julian() {} ; +void g_date_set_month() {} ; +void g_date_set_parse() {} ; +void g_date_set_time() {} ; +void g_date_set_year() {} ; +void g_date_strftime() {} ; +void g_date_subtract_days() {} ; +void g_date_subtract_months() {} ; +void g_date_subtract_years() {} ; +void g_date_to_struct_tm() {} ; +void g_date_valid() {} ; +void g_date_valid_day() {} ; +void g_date_valid_dmy() {} ; +void g_date_valid_julian() {} ; +void g_date_valid_month() {} ; +void g_date_valid_weekday() {} ; +void g_date_valid_year() {} ; +void g_dir_close() {} ; +void g_dir_open() {} ; +void g_dir_read_name() {} ; +void g_dir_rewind() {} ; +void g_direct_equal() {} ; +void g_direct_hash() {} ; +void g_error_copy() {} ; +void g_error_free() {} ; +void g_error_matches() {} ; +void g_error_new() {} ; +void g_error_new_literal() {} ; +void g_file_error_from_errno() {} ; +void g_file_error_quark() {} ; +void g_file_get_contents() {} ; +void g_file_open_tmp() {} ; +void g_file_read_link() {} ; +void g_file_test() {} ; +void g_filename_display_basename() {} ; +void g_filename_display_name() {} ; +void g_filename_from_uri() {} ; +void g_filename_from_utf8() {} ; +void g_filename_to_uri() {} ; +void g_filename_to_utf8() {} ; +void g_find_program_in_path() {} ; +void g_fprintf() {} ; +void g_free() {} ; +void g_get_application_name() {} ; +void g_get_charset() {} ; +void g_get_current_dir() {} ; +void g_get_current_time() {} ; +void g_get_filename_charsets() {} ; +void g_get_home_dir() {} ; +void g_get_language_names() {} ; +void g_get_prgname() {} ; +void g_get_real_name() {} ; +void g_get_system_config_dirs() {} ; +void g_get_system_data_dirs() {} ; +void g_get_tmp_dir() {} ; +void g_get_user_cache_dir() {} ; +void g_get_user_config_dir() {} ; +void g_get_user_data_dir() {} ; +void g_get_user_name() {} ; +void g_getenv() {} ; +void g_hash_table_destroy() {} ; +void g_hash_table_find() {} ; +void g_hash_table_foreach() {} ; +void g_hash_table_foreach_remove() {} ; +void g_hash_table_foreach_steal() {} ; +void g_hash_table_insert() {} ; +void g_hash_table_lookup() {} ; +void g_hash_table_lookup_extended() {} ; +void g_hash_table_new() {} ; +void g_hash_table_new_full() {} ; +void g_hash_table_remove() {} ; +void g_hash_table_replace() {} ; +void g_hash_table_size() {} ; +void g_hash_table_steal() {} ; +void g_hook_alloc() {} ; +void g_hook_compare_ids() {} ; +void g_hook_destroy() {} ; +void g_hook_destroy_link() {} ; +void g_hook_find() {} ; +void g_hook_find_data() {} ; +void g_hook_find_func() {} ; +void g_hook_find_func_data() {} ; +void g_hook_first_valid() {} ; +void g_hook_free() {} ; +void g_hook_get() {} ; +void g_hook_insert_before() {} ; +void g_hook_insert_sorted() {} ; +void g_hook_list_clear() {} ; +void g_hook_list_init() {} ; +void g_hook_list_invoke() {} ; +void g_hook_list_invoke_check() {} ; +void g_hook_list_marshal() {} ; +void g_hook_list_marshal_check() {} ; +void g_hook_next_valid() {} ; +void g_hook_prepend() {} ; +void g_hook_ref() {} ; +void g_hook_unref() {} ; +void g_iconv() {} ; +void g_iconv_close() {} ; +void g_iconv_open() {} ; +void g_idle_add() {} ; +void g_idle_add_full() {} ; +void g_idle_remove_by_data() {} ; +void g_idle_source_new() {} ; +void g_int_equal() {} ; +void g_int_hash() {} ; +void g_io_add_watch() {} ; +void g_io_add_watch_full() {} ; +void g_io_channel_error_from_errno() {} ; +void g_io_channel_error_quark() {} ; +void g_io_channel_flush() {} ; +void g_io_channel_get_buffer_condition() {} ; +void g_io_channel_get_buffer_size() {} ; +void g_io_channel_get_buffered() {} ; +void g_io_channel_get_close_on_unref() {} ; +void g_io_channel_get_encoding() {} ; +void g_io_channel_get_flags() {} ; +void g_io_channel_get_line_term() {} ; +void g_io_channel_init() {} ; +void g_io_channel_new_file() {} ; +void g_io_channel_read_chars() {} ; +void g_io_channel_read_line() {} ; +void g_io_channel_read_line_string() {} ; +void g_io_channel_read_to_end() {} ; +void g_io_channel_read_unichar() {} ; +void g_io_channel_ref() {} ; +void g_io_channel_seek_position() {} ; +void g_io_channel_set_buffer_size() {} ; +void g_io_channel_set_buffered() {} ; +void g_io_channel_set_close_on_unref() {} ; +void g_io_channel_set_encoding() {} ; +void g_io_channel_set_flags() {} ; +void g_io_channel_set_line_term() {} ; +void g_io_channel_shutdown() {} ; +void g_io_channel_unix_get_fd() {} ; +void g_io_channel_unix_new() {} ; +void g_io_channel_unref() {} ; +void g_io_channel_write_chars() {} ; +void g_io_channel_write_unichar() {} ; +void g_io_create_watch() {} ; +void g_key_file_error_quark() {} ; +void g_key_file_free() {} ; +void g_key_file_get_boolean() {} ; +void g_key_file_get_boolean_list() {} ; +void g_key_file_get_comment() {} ; +void g_key_file_get_groups() {} ; +void g_key_file_get_integer() {} ; +void g_key_file_get_integer_list() {} ; +void g_key_file_get_keys() {} ; +void g_key_file_get_locale_string() {} ; +void g_key_file_get_locale_string_list() {} ; +void g_key_file_get_start_group() {} ; +void g_key_file_get_string() {} ; +void g_key_file_get_string_list() {} ; +void g_key_file_get_value() {} ; +void g_key_file_has_group() {} ; +void g_key_file_has_key() {} ; +void g_key_file_load_from_data() {} ; +void g_key_file_load_from_data_dirs() {} ; +void g_key_file_load_from_file() {} ; +void g_key_file_new() {} ; +void g_key_file_remove_comment() {} ; +void g_key_file_remove_group() {} ; +void g_key_file_remove_key() {} ; +void g_key_file_set_boolean() {} ; +void g_key_file_set_boolean_list() {} ; +void g_key_file_set_comment() {} ; +void g_key_file_set_integer() {} ; +void g_key_file_set_integer_list() {} ; +void g_key_file_set_list_separator() {} ; +void g_key_file_set_locale_string() {} ; +void g_key_file_set_locale_string_list() {} ; +void g_key_file_set_string() {} ; +void g_key_file_set_string_list() {} ; +void g_key_file_set_value() {} ; +void g_key_file_to_data() {} ; +void g_list_alloc() {} ; +void g_list_append() {} ; +void g_list_concat() {} ; +void g_list_copy() {} ; +void g_list_delete_link() {} ; +void g_list_find() {} ; +void g_list_find_custom() {} ; +void g_list_first() {} ; +void g_list_foreach() {} ; +void g_list_free() {} ; +void g_list_free_1() {} ; +void g_list_index() {} ; +void g_list_insert() {} ; +void g_list_insert_before() {} ; +void g_list_insert_sorted() {} ; +void g_list_last() {} ; +void g_list_length() {} ; +void g_list_nth() {} ; +void g_list_nth_data() {} ; +void g_list_nth_prev() {} ; +void g_list_pop_allocator() {} ; +void g_list_position() {} ; +void g_list_prepend() {} ; +void g_list_push_allocator() {} ; +void g_list_remove() {} ; +void g_list_remove_all() {} ; +void g_list_remove_link() {} ; +void g_list_reverse() {} ; +void g_list_sort() {} ; +void g_list_sort_with_data() {} ; +void g_locale_from_utf8() {} ; +void g_locale_to_utf8() {} ; +void g_log() {} ; +void g_log_default_handler() {} ; +void g_log_remove_handler() {} ; +void g_log_set_always_fatal() {} ; +void g_log_set_default_handler() {} ; +void g_log_set_fatal_mask() {} ; +void g_log_set_handler() {} ; +void g_logv() {} ; +void g_main_context_acquire() {} ; +void g_main_context_add_poll() {} ; +void g_main_context_check() {} ; +void g_main_context_default() {} ; +void g_main_context_dispatch() {} ; +void g_main_context_find_source_by_funcs_user_data() {} ; +void g_main_context_find_source_by_id() {} ; +void g_main_context_find_source_by_user_data() {} ; +void g_main_context_get_poll_func() {} ; +void g_main_context_iteration() {} ; +void g_main_context_new() {} ; +void g_main_context_pending() {} ; +void g_main_context_prepare() {} ; +void g_main_context_query() {} ; +void g_main_context_ref() {} ; +void g_main_context_release() {} ; +void g_main_context_remove_poll() {} ; +void g_main_context_set_poll_func() {} ; +void g_main_context_unref() {} ; +void g_main_context_wait() {} ; +void g_main_context_wakeup() {} ; +void g_main_depth() {} ; +void g_main_loop_get_context() {} ; +void g_main_loop_is_running() {} ; +void g_main_loop_new() {} ; +void g_main_loop_quit() {} ; +void g_main_loop_ref() {} ; +void g_main_loop_run() {} ; +void g_main_loop_unref() {} ; +void g_malloc() {} ; +void g_malloc0() {} ; +void g_markup_error_quark() {} ; +void g_markup_escape_text() {} ; +void g_markup_parse_context_end_parse() {} ; +void g_markup_parse_context_free() {} ; +void g_markup_parse_context_get_element() {} ; +void g_markup_parse_context_get_position() {} ; +void g_markup_parse_context_new() {} ; +void g_markup_parse_context_parse() {} ; +void g_markup_printf_escaped() {} ; +void g_markup_vprintf_escaped() {} ; +void g_mem_chunk_alloc() {} ; +void g_mem_chunk_alloc0() {} ; +void g_mem_chunk_clean() {} ; +void g_mem_chunk_destroy() {} ; +void g_mem_chunk_free() {} ; +void g_mem_chunk_info() {} ; +void g_mem_chunk_new() {} ; +void g_mem_chunk_print() {} ; +void g_mem_chunk_reset() {} ; +void g_mem_is_system_malloc() {} ; +void g_mem_profile() {} ; +void g_mem_set_vtable() {} ; +void g_memdup() {} ; +void g_mkstemp() {} ; +void g_node_child_index() {} ; +void g_node_child_position() {} ; +void g_node_children_foreach() {} ; +void g_node_copy() {} ; +void g_node_copy_deep() {} ; +void g_node_depth() {} ; +void g_node_destroy() {} ; +void g_node_find() {} ; +void g_node_find_child() {} ; +void g_node_first_sibling() {} ; +void g_node_get_root() {} ; +void g_node_insert() {} ; +void g_node_insert_after() {} ; +void g_node_insert_before() {} ; +void g_node_is_ancestor() {} ; +void g_node_last_child() {} ; +void g_node_last_sibling() {} ; +void g_node_max_height() {} ; +void g_node_n_children() {} ; +void g_node_n_nodes() {} ; +void g_node_new() {} ; +void g_node_nth_child() {} ; +void g_node_pop_allocator() {} ; +void g_node_prepend() {} ; +void g_node_push_allocator() {} ; +void g_node_reverse_children() {} ; +void g_node_traverse() {} ; +void g_node_unlink() {} ; +void g_nullify_pointer() {} ; +void g_on_error_query() {} ; +void g_on_error_stack_trace() {} ; +void g_once_impl() {} ; +void g_option_context_add_group() {} ; +void g_option_context_add_main_entries() {} ; +void g_option_context_free() {} ; +void g_option_context_get_help_enabled() {} ; +void g_option_context_get_ignore_unknown_options() {} ; +void g_option_context_get_main_group() {} ; +void g_option_context_new() {} ; +void g_option_context_parse() {} ; +void g_option_context_set_help_enabled() {} ; +void g_option_context_set_ignore_unknown_options() {} ; +void g_option_context_set_main_group() {} ; +void g_option_error_quark() {} ; +void g_option_group_add_entries() {} ; +void g_option_group_free() {} ; +void g_option_group_new() {} ; +void g_option_group_set_error_hook() {} ; +void g_option_group_set_parse_hooks() {} ; +void g_option_group_set_translate_func() {} ; +void g_option_group_set_translation_domain() {} ; +void g_parse_debug_string() {} ; +void g_path_get_basename() {} ; +void g_path_get_dirname() {} ; +void g_path_is_absolute() {} ; +void g_path_skip_root() {} ; +void g_pattern_match() {} ; +void g_pattern_match_simple() {} ; +void g_pattern_match_string() {} ; +void g_pattern_spec_equal() {} ; +void g_pattern_spec_free() {} ; +void g_pattern_spec_new() {} ; +void g_print() {} ; +void g_printerr() {} ; +void g_printf() {} ; +void g_printf_string_upper_bound() {} ; +void g_propagate_error() {} ; +void g_ptr_array_add() {} ; +void g_ptr_array_foreach() {} ; +void g_ptr_array_free() {} ; +void g_ptr_array_new() {} ; +void g_ptr_array_remove() {} ; +void g_ptr_array_remove_fast() {} ; +void g_ptr_array_remove_index() {} ; +void g_ptr_array_remove_index_fast() {} ; +void g_ptr_array_remove_range() {} ; +void g_ptr_array_set_size() {} ; +void g_ptr_array_sized_new() {} ; +void g_ptr_array_sort() {} ; +void g_ptr_array_sort_with_data() {} ; +void g_qsort_with_data() {} ; +void g_quark_from_static_string() {} ; +void g_quark_from_string() {} ; +void g_quark_to_string() {} ; +void g_quark_try_string() {} ; +void g_queue_copy() {} ; +void g_queue_delete_link() {} ; +void g_queue_find() {} ; +void g_queue_find_custom() {} ; +void g_queue_foreach() {} ; +void g_queue_free() {} ; +void g_queue_get_length() {} ; +void g_queue_index() {} ; +void g_queue_insert_after() {} ; +void g_queue_insert_before() {} ; +void g_queue_insert_sorted() {} ; +void g_queue_is_empty() {} ; +void g_queue_link_index() {} ; +void g_queue_new() {} ; +void g_queue_peek_head() {} ; +void g_queue_peek_head_link() {} ; +void g_queue_peek_nth() {} ; +void g_queue_peek_nth_link() {} ; +void g_queue_peek_tail() {} ; +void g_queue_peek_tail_link() {} ; +void g_queue_pop_head() {} ; +void g_queue_pop_head_link() {} ; +void g_queue_pop_nth() {} ; +void g_queue_pop_nth_link() {} ; +void g_queue_pop_tail() {} ; +void g_queue_pop_tail_link() {} ; +void g_queue_push_head() {} ; +void g_queue_push_head_link() {} ; +void g_queue_push_nth() {} ; +void g_queue_push_nth_link() {} ; +void g_queue_push_tail() {} ; +void g_queue_push_tail_link() {} ; +void g_queue_remove() {} ; +void g_queue_remove_all() {} ; +void g_queue_reverse() {} ; +void g_queue_sort() {} ; +void g_queue_unlink() {} ; +void g_rand_copy() {} ; +void g_rand_double() {} ; +void g_rand_double_range() {} ; +void g_rand_free() {} ; +void g_rand_int() {} ; +void g_rand_int_range() {} ; +void g_rand_new() {} ; +void g_rand_new_with_seed() {} ; +void g_rand_new_with_seed_array() {} ; +void g_rand_set_seed() {} ; +void g_rand_set_seed_array() {} ; +void g_random_double() {} ; +void g_random_double_range() {} ; +void g_random_int() {} ; +void g_random_int_range() {} ; +void g_random_set_seed() {} ; +void g_realloc() {} ; +void g_relation_count() {} ; +void g_relation_delete() {} ; +void g_relation_destroy() {} ; +void g_relation_exists() {} ; +void g_relation_index() {} ; +void g_relation_insert() {} ; +void g_relation_new() {} ; +void g_relation_print() {} ; +void g_relation_select() {} ; +void g_return_if_fail_warning() {} ; +void g_scanner_cur_line() {} ; +void g_scanner_cur_position() {} ; +void g_scanner_cur_token() {} ; +void g_scanner_cur_value() {} ; +void g_scanner_destroy() {} ; +void g_scanner_eof() {} ; +void g_scanner_error() {} ; +void g_scanner_get_next_token() {} ; +void g_scanner_input_file() {} ; +void g_scanner_input_text() {} ; +void g_scanner_lookup_symbol() {} ; +void g_scanner_new() {} ; +void g_scanner_peek_next_token() {} ; +void g_scanner_scope_add_symbol() {} ; +void g_scanner_scope_foreach_symbol() {} ; +void g_scanner_scope_lookup_symbol() {} ; +void g_scanner_scope_remove_symbol() {} ; +void g_scanner_set_scope() {} ; +void g_scanner_sync_file_offset() {} ; +void g_scanner_unexp_token() {} ; +void g_scanner_warn() {} ; +void g_set_application_name() {} ; +void g_set_error() {} ; +void g_set_prgname() {} ; +void g_set_print_handler() {} ; +void g_set_printerr_handler() {} ; +void g_setenv() {} ; +void g_shell_error_quark() {} ; +void g_shell_parse_argv() {} ; +void g_shell_quote() {} ; +void g_shell_unquote() {} ; +void g_slist_alloc() {} ; +void g_slist_append() {} ; +void g_slist_concat() {} ; +void g_slist_copy() {} ; +void g_slist_delete_link() {} ; +void g_slist_find() {} ; +void g_slist_find_custom() {} ; +void g_slist_foreach() {} ; +void g_slist_free() {} ; +void g_slist_free_1() {} ; +void g_slist_index() {} ; +void g_slist_insert() {} ; +void g_slist_insert_before() {} ; +void g_slist_insert_sorted() {} ; +void g_slist_last() {} ; +void g_slist_length() {} ; +void g_slist_nth() {} ; +void g_slist_nth_data() {} ; +void g_slist_pop_allocator() {} ; +void g_slist_position() {} ; +void g_slist_prepend() {} ; +void g_slist_push_allocator() {} ; +void g_slist_remove() {} ; +void g_slist_remove_all() {} ; +void g_slist_remove_link() {} ; +void g_slist_reverse() {} ; +void g_slist_sort() {} ; +void g_slist_sort_with_data() {} ; +void g_snprintf() {} ; +void g_source_add_poll() {} ; +void g_source_attach() {} ; +void g_source_destroy() {} ; +void g_source_get_can_recurse() {} ; +void g_source_get_context() {} ; +void g_source_get_current_time() {} ; +void g_source_get_id() {} ; +void g_source_get_priority() {} ; +void g_source_new() {} ; +void g_source_ref() {} ; +void g_source_remove() {} ; +void g_source_remove_by_funcs_user_data() {} ; +void g_source_remove_by_user_data() {} ; +void g_source_remove_poll() {} ; +void g_source_set_callback() {} ; +void g_source_set_callback_indirect() {} ; +void g_source_set_can_recurse() {} ; +void g_source_set_priority() {} ; +void g_source_unref() {} ; +void g_spaced_primes_closest() {} ; +void g_spawn_async() {} ; +void g_spawn_async_with_pipes() {} ; +void g_spawn_close_pid() {} ; +void g_spawn_command_line_async() {} ; +void g_spawn_command_line_sync() {} ; +void g_spawn_error_quark() {} ; +void g_spawn_sync() {} ; +void g_sprintf() {} ; +void g_static_mutex_free() {} ; +void g_static_mutex_get_mutex_impl() {} ; +void g_static_mutex_init() {} ; +void g_static_private_free() {} ; +void g_static_private_get() {} ; +void g_static_private_init() {} ; +void g_static_private_set() {} ; +void g_static_rec_mutex_free() {} ; +void g_static_rec_mutex_init() {} ; +void g_static_rec_mutex_lock() {} ; +void g_static_rec_mutex_lock_full() {} ; +void g_static_rec_mutex_trylock() {} ; +void g_static_rec_mutex_unlock() {} ; +void g_static_rec_mutex_unlock_full() {} ; +void g_static_rw_lock_free() {} ; +void g_static_rw_lock_init() {} ; +void g_static_rw_lock_reader_lock() {} ; +void g_static_rw_lock_reader_trylock() {} ; +void g_static_rw_lock_reader_unlock() {} ; +void g_static_rw_lock_writer_lock() {} ; +void g_static_rw_lock_writer_trylock() {} ; +void g_static_rw_lock_writer_unlock() {} ; +void g_stpcpy() {} ; +void g_str_equal() {} ; +void g_str_has_prefix() {} ; +void g_str_has_suffix() {} ; +void g_str_hash() {} ; +void g_strcanon() {} ; +void g_strchomp() {} ; +void g_strchug() {} ; +void g_strcompress() {} ; +void g_strconcat() {} ; +void g_strdelimit() {} ; +void g_strdup() {} ; +void g_strdup_printf() {} ; +void g_strdup_vprintf() {} ; +void g_strdupv() {} ; +void g_strerror() {} ; +void g_strescape() {} ; +void g_strfreev() {} ; +void g_string_append() {} ; +void g_string_append_c() {} ; +void g_string_append_len() {} ; +void g_string_append_printf() {} ; +void g_string_append_unichar() {} ; +void g_string_ascii_down() {} ; +void g_string_ascii_up() {} ; +void g_string_assign() {} ; +void g_string_chunk_free() {} ; +void g_string_chunk_insert() {} ; +void g_string_chunk_insert_const() {} ; +void g_string_chunk_insert_len() {} ; +void g_string_chunk_new() {} ; +void g_string_equal() {} ; +void g_string_erase() {} ; +void g_string_free() {} ; +void g_string_hash() {} ; +void g_string_insert() {} ; +void g_string_insert_c() {} ; +void g_string_insert_len() {} ; +void g_string_insert_unichar() {} ; +void g_string_new() {} ; +void g_string_new_len() {} ; +void g_string_prepend() {} ; +void g_string_prepend_c() {} ; +void g_string_prepend_len() {} ; +void g_string_prepend_unichar() {} ; +void g_string_printf() {} ; +void g_string_set_size() {} ; +void g_string_sized_new() {} ; +void g_string_truncate() {} ; +void g_strip_context() {} ; +void g_strjoin() {} ; +void g_strjoinv() {} ; +void g_strlcat() {} ; +void g_strlcpy() {} ; +void g_strndup() {} ; +void g_strnfill() {} ; +void g_strreverse() {} ; +void g_strrstr() {} ; +void g_strrstr_len() {} ; +void g_strsignal() {} ; +void g_strsplit() {} ; +void g_strsplit_set() {} ; +void g_strstr_len() {} ; +void g_strtod() {} ; +void g_strv_length() {} ; +void g_thread_create_full() {} ; +void g_thread_error_quark() {} ; +void g_thread_exit() {} ; +void g_thread_join() {} ; +void g_thread_pool_free() {} ; +void g_thread_pool_get_max_threads() {} ; +void g_thread_pool_get_max_unused_threads() {} ; +void g_thread_pool_get_num_threads() {} ; +void g_thread_pool_get_num_unused_threads() {} ; +void g_thread_pool_new() {} ; +void g_thread_pool_push() {} ; +void g_thread_pool_set_max_threads() {} ; +void g_thread_pool_set_max_unused_threads() {} ; +void g_thread_pool_stop_unused_threads() {} ; +void g_thread_pool_unprocessed() {} ; +void g_thread_self() {} ; +void g_thread_set_priority() {} ; +void g_time_val_add() {} ; +void g_timeout_add() {} ; +void g_timeout_add_full() {} ; +void g_timeout_source_new() {} ; +void g_timer_continue() {} ; +void g_timer_destroy() {} ; +void g_timer_elapsed() {} ; +void g_timer_new() {} ; +void g_timer_reset() {} ; +void g_timer_start() {} ; +void g_timer_stop() {} ; +void g_trash_stack_height() {} ; +void g_trash_stack_peek() {} ; +void g_trash_stack_pop() {} ; +void g_trash_stack_push() {} ; +void g_tree_destroy() {} ; +void g_tree_foreach() {} ; +void g_tree_height() {} ; +void g_tree_insert() {} ; +void g_tree_lookup() {} ; +void g_tree_lookup_extended() {} ; +void g_tree_new() {} ; +void g_tree_new_full() {} ; +void g_tree_new_with_data() {} ; +void g_tree_nnodes() {} ; +void g_tree_remove() {} ; +void g_tree_replace() {} ; +void g_tree_search() {} ; +void g_tree_steal() {} ; +void g_try_malloc() {} ; +void g_try_realloc() {} ; +void g_tuples_destroy() {} ; +void g_tuples_index() {} ; +void g_ucs4_to_utf16() {} ; +void g_ucs4_to_utf8() {} ; +void g_unichar_break_type() {} ; +void g_unichar_digit_value() {} ; +void g_unichar_get_mirror_char() {} ; +void g_unichar_isalnum() {} ; +void g_unichar_isalpha() {} ; +void g_unichar_iscntrl() {} ; +void g_unichar_isdefined() {} ; +void g_unichar_isdigit() {} ; +void g_unichar_isgraph() {} ; +void g_unichar_islower() {} ; +void g_unichar_isprint() {} ; +void g_unichar_ispunct() {} ; +void g_unichar_isspace() {} ; +void g_unichar_istitle() {} ; +void g_unichar_isupper() {} ; +void g_unichar_iswide() {} ; +void g_unichar_isxdigit() {} ; +void g_unichar_to_utf8() {} ; +void g_unichar_tolower() {} ; +void g_unichar_totitle() {} ; +void g_unichar_toupper() {} ; +void g_unichar_type() {} ; +void g_unichar_validate() {} ; +void g_unichar_xdigit_value() {} ; +void g_unicode_canonical_decomposition() {} ; +void g_unicode_canonical_ordering() {} ; +void g_unsetenv() {} ; +void g_uri_list_extract_uris() {} ; +void g_usleep() {} ; +void g_utf16_to_ucs4() {} ; +void g_utf16_to_utf8() {} ; +void g_utf8_casefold() {} ; +void g_utf8_collate() {} ; +void g_utf8_collate_key() {} ; +void g_utf8_find_next_char() {} ; +void g_utf8_find_prev_char() {} ; +void g_utf8_get_char() {} ; +void g_utf8_get_char_validated() {} ; +void g_utf8_normalize() {} ; +void g_utf8_offset_to_pointer() {} ; +void g_utf8_pointer_to_offset() {} ; +void g_utf8_prev_char() {} ; +void g_utf8_strchr() {} ; +void g_utf8_strdown() {} ; +void g_utf8_strlen() {} ; +void g_utf8_strncpy() {} ; +void g_utf8_strrchr() {} ; +void g_utf8_strreverse() {} ; +void g_utf8_strup() {} ; +void g_utf8_to_ucs4() {} ; +void g_utf8_to_ucs4_fast() {} ; +void g_utf8_to_utf16() {} ; +void g_utf8_validate() {} ; +void g_vasprintf() {} ; +void g_vfprintf() {} ; +void g_vprintf() {} ; +void g_vsnprintf() {} ; +void g_vsprintf() {} ; +void glib_check_version() {} ; +__asm__(".globl g_ascii_table; .pushsection .data; .type g_ascii_table,@object; .size g_ascii_table, 4; g_ascii_table: .long 0; .popsection"); +__asm__(".globl g_child_watch_funcs; .pushsection .data; .type g_child_watch_funcs,@object; .size g_child_watch_funcs, 24; g_child_watch_funcs: .long 0; .popsection"); +__asm__(".globl g_idle_funcs; .pushsection .data; .type g_idle_funcs,@object; .size g_idle_funcs, 24; g_idle_funcs: .long 0; .popsection"); +__asm__(".globl g_io_watch_funcs; .pushsection .data; .type g_io_watch_funcs,@object; .size g_io_watch_funcs, 24; g_io_watch_funcs: .long 0; .popsection"); +__asm__(".globl g_thread_functions_for_glib_use; .pushsection .data; .type g_thread_functions_for_glib_use,@object; .size g_thread_functions_for_glib_use, 84; g_thread_functions_for_glib_use: .long 0; .popsection"); +__asm__(".globl g_thread_use_default_impl; .pushsection .data; .type g_thread_use_default_impl,@object; .size g_thread_use_default_impl, 4; g_thread_use_default_impl: .long 0; .popsection"); +__asm__(".globl g_threads_got_initialized; .pushsection .data; .type g_threads_got_initialized,@object; .size g_threads_got_initialized, 4; g_threads_got_initialized: .long 0; .popsection"); +__asm__(".globl g_timeout_funcs; .pushsection .data; .type g_timeout_funcs,@object; .size g_timeout_funcs, 24; g_timeout_funcs: .long 0; .popsection"); +__asm__(".globl g_utf8_skip; .pushsection .data; .type g_utf8_skip,@object; .size g_utf8_skip, 4; g_utf8_skip: .long 0; .popsection"); +__asm__(".globl glib_binary_age; .pushsection .data; .type glib_binary_age,@object; .size glib_binary_age, 4; glib_binary_age: .long 0; .popsection"); +__asm__(".globl glib_interface_age; .pushsection .data; .type glib_interface_age,@object; .size glib_interface_age, 4; glib_interface_age: .long 0; .popsection"); +__asm__(".globl glib_major_version; .pushsection .data; .type glib_major_version,@object; .size glib_major_version, 4; glib_major_version: .long 0; .popsection"); +__asm__(".globl glib_mem_profiler_table; .pushsection .data; .type glib_mem_profiler_table,@object; .size glib_mem_profiler_table, 4; glib_mem_profiler_table: .long 0; .popsection"); +__asm__(".globl glib_micro_version; .pushsection .data; .type glib_micro_version,@object; .size glib_micro_version, 4; glib_micro_version: .long 0; .popsection"); +__asm__(".globl glib_minor_version; .pushsection .data; .type glib_minor_version,@object; .size glib_minor_version, 4; glib_minor_version: .long 0; .popsection"); diff --git a/lsb-build/stub_libs/libgobject-2.0.Version b/lsb-build/stub_libs/libgobject-2.0.Version new file mode 100644 index 0000000..08a3220 --- /dev/null +++ b/lsb-build/stub_libs/libgobject-2.0.Version @@ -0,0 +1 @@ +LSB_DUMMY { __LSB_DUMMY; }; diff --git a/lsb-build/stub_libs/libgobject-2.0.c b/lsb-build/stub_libs/libgobject-2.0.c new file mode 100644 index 0000000..9500401 --- /dev/null +++ b/lsb-build/stub_libs/libgobject-2.0.c @@ -0,0 +1,315 @@ +void g_boxed_copy() {} ; +void g_boxed_free() {} ; +void g_boxed_type_register_static() {} ; +void g_cclosure_marshal_BOOLEAN__FLAGS() {} ; +void g_cclosure_marshal_STRING__OBJECT_POINTER() {} ; +void g_cclosure_marshal_VOID__BOOLEAN() {} ; +void g_cclosure_marshal_VOID__BOXED() {} ; +void g_cclosure_marshal_VOID__CHAR() {} ; +void g_cclosure_marshal_VOID__DOUBLE() {} ; +void g_cclosure_marshal_VOID__ENUM() {} ; +void g_cclosure_marshal_VOID__FLAGS() {} ; +void g_cclosure_marshal_VOID__FLOAT() {} ; +void g_cclosure_marshal_VOID__INT() {} ; +void g_cclosure_marshal_VOID__LONG() {} ; +void g_cclosure_marshal_VOID__OBJECT() {} ; +void g_cclosure_marshal_VOID__PARAM() {} ; +void g_cclosure_marshal_VOID__POINTER() {} ; +void g_cclosure_marshal_VOID__STRING() {} ; +void g_cclosure_marshal_VOID__UCHAR() {} ; +void g_cclosure_marshal_VOID__UINT() {} ; +void g_cclosure_marshal_VOID__UINT_POINTER() {} ; +void g_cclosure_marshal_VOID__ULONG() {} ; +void g_cclosure_marshal_VOID__VOID() {} ; +void g_cclosure_new() {} ; +void g_cclosure_new_object() {} ; +void g_cclosure_new_object_swap() {} ; +void g_cclosure_new_swap() {} ; +void g_closure_add_finalize_notifier() {} ; +void g_closure_add_invalidate_notifier() {} ; +void g_closure_add_marshal_guards() {} ; +void g_closure_get_type() {} ; +void g_closure_invalidate() {} ; +void g_closure_invoke() {} ; +void g_closure_new_object() {} ; +void g_closure_new_simple() {} ; +void g_closure_ref() {} ; +void g_closure_remove_finalize_notifier() {} ; +void g_closure_remove_invalidate_notifier() {} ; +void g_closure_set_marshal() {} ; +void g_closure_set_meta_marshal() {} ; +void g_closure_sink() {} ; +void g_closure_unref() {} ; +void g_enum_complete_type_info() {} ; +void g_enum_get_value() {} ; +void g_enum_get_value_by_name() {} ; +void g_enum_get_value_by_nick() {} ; +void g_enum_register_static() {} ; +void g_flags_complete_type_info() {} ; +void g_flags_get_first_value() {} ; +void g_flags_get_value_by_name() {} ; +void g_flags_get_value_by_nick() {} ; +void g_flags_register_static() {} ; +void g_gstring_get_type() {} ; +void g_io_channel_get_type() {} ; +void g_io_condition_get_type() {} ; +void g_object_add_weak_pointer() {} ; +void g_object_class_find_property() {} ; +void g_object_class_install_property() {} ; +void g_object_class_list_properties() {} ; +void g_object_class_override_property() {} ; +void g_object_connect() {} ; +void g_object_disconnect() {} ; +void g_object_freeze_notify() {} ; +void g_object_get() {} ; +void g_object_get_data() {} ; +void g_object_get_property() {} ; +void g_object_get_qdata() {} ; +void g_object_get_valist() {} ; +void g_object_interface_find_property() {} ; +void g_object_interface_install_property() {} ; +void g_object_interface_list_properties() {} ; +void g_object_new() {} ; +void g_object_new_valist() {} ; +void g_object_newv() {} ; +void g_object_notify() {} ; +void g_object_ref() {} ; +void g_object_remove_weak_pointer() {} ; +void g_object_run_dispose() {} ; +void g_object_set() {} ; +void g_object_set_data() {} ; +void g_object_set_data_full() {} ; +void g_object_set_property() {} ; +void g_object_set_qdata() {} ; +void g_object_set_qdata_full() {} ; +void g_object_set_valist() {} ; +void g_object_steal_data() {} ; +void g_object_steal_qdata() {} ; +void g_object_thaw_notify() {} ; +void g_object_unref() {} ; +void g_object_watch_closure() {} ; +void g_object_weak_ref() {} ; +void g_object_weak_unref() {} ; +void g_param_spec_boolean() {} ; +void g_param_spec_boxed() {} ; +void g_param_spec_char() {} ; +void g_param_spec_double() {} ; +void g_param_spec_enum() {} ; +void g_param_spec_flags() {} ; +void g_param_spec_float() {} ; +void g_param_spec_get_blurb() {} ; +void g_param_spec_get_name() {} ; +void g_param_spec_get_nick() {} ; +void g_param_spec_get_qdata() {} ; +void g_param_spec_get_redirect_target() {} ; +void g_param_spec_int() {} ; +void g_param_spec_int64() {} ; +void g_param_spec_internal() {} ; +void g_param_spec_long() {} ; +void g_param_spec_object() {} ; +void g_param_spec_override() {} ; +void g_param_spec_param() {} ; +void g_param_spec_pointer() {} ; +void g_param_spec_pool_insert() {} ; +void g_param_spec_pool_list() {} ; +void g_param_spec_pool_list_owned() {} ; +void g_param_spec_pool_lookup() {} ; +void g_param_spec_pool_new() {} ; +void g_param_spec_pool_remove() {} ; +void g_param_spec_ref() {} ; +void g_param_spec_set_qdata() {} ; +void g_param_spec_set_qdata_full() {} ; +void g_param_spec_sink() {} ; +void g_param_spec_steal_qdata() {} ; +void g_param_spec_string() {} ; +void g_param_spec_uchar() {} ; +void g_param_spec_uint() {} ; +void g_param_spec_uint64() {} ; +void g_param_spec_ulong() {} ; +void g_param_spec_unichar() {} ; +void g_param_spec_unref() {} ; +void g_param_spec_value_array() {} ; +void g_param_type_register_static() {} ; +void g_param_value_convert() {} ; +void g_param_value_defaults() {} ; +void g_param_value_set_default() {} ; +void g_param_value_validate() {} ; +void g_param_values_cmp() {} ; +void g_pointer_type_register_static() {} ; +void g_signal_accumulator_true_handled() {} ; +void g_signal_add_emission_hook() {} ; +void g_signal_chain_from_overridden() {} ; +void g_signal_connect_closure() {} ; +void g_signal_connect_closure_by_id() {} ; +void g_signal_connect_data() {} ; +void g_signal_connect_object() {} ; +void g_signal_emit() {} ; +void g_signal_emit_by_name() {} ; +void g_signal_emit_valist() {} ; +void g_signal_emitv() {} ; +void g_signal_get_invocation_hint() {} ; +void g_signal_handler_block() {} ; +void g_signal_handler_disconnect() {} ; +void g_signal_handler_find() {} ; +void g_signal_handler_is_connected() {} ; +void g_signal_handler_unblock() {} ; +void g_signal_handlers_block_matched() {} ; +void g_signal_handlers_destroy() {} ; +void g_signal_handlers_disconnect_matched() {} ; +void g_signal_handlers_unblock_matched() {} ; +void g_signal_has_handler_pending() {} ; +void g_signal_list_ids() {} ; +void g_signal_lookup() {} ; +void g_signal_name() {} ; +void g_signal_new() {} ; +void g_signal_new_valist() {} ; +void g_signal_newv() {} ; +void g_signal_override_class_closure() {} ; +void g_signal_parse_name() {} ; +void g_signal_query() {} ; +void g_signal_remove_emission_hook() {} ; +void g_signal_stop_emission() {} ; +void g_signal_stop_emission_by_name() {} ; +void g_signal_type_cclosure_new() {} ; +void g_source_set_closure() {} ; +void g_strdup_value_contents() {} ; +void g_strv_get_type() {} ; +void g_type_add_class_cache_func() {} ; +void g_type_add_interface_check() {} ; +void g_type_add_interface_dynamic() {} ; +void g_type_add_interface_static() {} ; +void g_type_check_class_cast() {} ; +void g_type_check_class_is_a() {} ; +void g_type_check_instance() {} ; +void g_type_check_instance_cast() {} ; +void g_type_check_instance_is_a() {} ; +void g_type_check_is_value_type() {} ; +void g_type_check_value() {} ; +void g_type_check_value_holds() {} ; +void g_type_children() {} ; +void g_type_class_add_private() {} ; +void g_type_class_peek() {} ; +void g_type_class_peek_parent() {} ; +void g_type_class_peek_static() {} ; +void g_type_class_ref() {} ; +void g_type_class_unref() {} ; +void g_type_class_unref_uncached() {} ; +void g_type_create_instance() {} ; +void g_type_default_interface_peek() {} ; +void g_type_default_interface_ref() {} ; +void g_type_default_interface_unref() {} ; +void g_type_depth() {} ; +void g_type_free_instance() {} ; +void g_type_from_name() {} ; +void g_type_fundamental() {} ; +void g_type_fundamental_next() {} ; +void g_type_get_plugin() {} ; +void g_type_get_qdata() {} ; +void g_type_init() {} ; +void g_type_init_with_debug_flags() {} ; +void g_type_instance_get_private() {} ; +void g_type_interface_add_prerequisite() {} ; +void g_type_interface_get_plugin() {} ; +void g_type_interface_peek() {} ; +void g_type_interface_peek_parent() {} ; +void g_type_interface_prerequisites() {} ; +void g_type_interfaces() {} ; +void g_type_is_a() {} ; +void g_type_module_add_interface() {} ; +void g_type_module_get_type() {} ; +void g_type_module_register_enum() {} ; +void g_type_module_register_flags() {} ; +void g_type_module_register_type() {} ; +void g_type_module_set_name() {} ; +void g_type_module_unuse() {} ; +void g_type_module_use() {} ; +void g_type_name() {} ; +void g_type_name_from_class() {} ; +void g_type_name_from_instance() {} ; +void g_type_next_base() {} ; +void g_type_parent() {} ; +void g_type_plugin_complete_interface_info() {} ; +void g_type_plugin_complete_type_info() {} ; +void g_type_plugin_get_type() {} ; +void g_type_plugin_unuse() {} ; +void g_type_plugin_use() {} ; +void g_type_qname() {} ; +void g_type_query() {} ; +void g_type_register_dynamic() {} ; +void g_type_register_fundamental() {} ; +void g_type_register_static() {} ; +void g_type_remove_class_cache_func() {} ; +void g_type_remove_interface_check() {} ; +void g_type_set_qdata() {} ; +void g_type_test_flags() {} ; +void g_type_value_table_peek() {} ; +void g_value_array_append() {} ; +void g_value_array_copy() {} ; +void g_value_array_free() {} ; +void g_value_array_get_nth() {} ; +void g_value_array_get_type() {} ; +void g_value_array_insert() {} ; +void g_value_array_new() {} ; +void g_value_array_prepend() {} ; +void g_value_array_remove() {} ; +void g_value_array_sort() {} ; +void g_value_array_sort_with_data() {} ; +void g_value_copy() {} ; +void g_value_dup_boxed() {} ; +void g_value_dup_object() {} ; +void g_value_dup_param() {} ; +void g_value_dup_string() {} ; +void g_value_fits_pointer() {} ; +void g_value_get_boolean() {} ; +void g_value_get_boxed() {} ; +void g_value_get_char() {} ; +void g_value_get_double() {} ; +void g_value_get_enum() {} ; +void g_value_get_flags() {} ; +void g_value_get_float() {} ; +void g_value_get_int() {} ; +void g_value_get_int64() {} ; +void g_value_get_long() {} ; +void g_value_get_object() {} ; +void g_value_get_param() {} ; +void g_value_get_pointer() {} ; +void g_value_get_string() {} ; +void g_value_get_type() {} ; +void g_value_get_uchar() {} ; +void g_value_get_uint() {} ; +void g_value_get_uint64() {} ; +void g_value_get_ulong() {} ; +void g_value_init() {} ; +void g_value_peek_pointer() {} ; +void g_value_register_transform_func() {} ; +void g_value_reset() {} ; +void g_value_set_boolean() {} ; +void g_value_set_boxed() {} ; +void g_value_set_char() {} ; +void g_value_set_double() {} ; +void g_value_set_enum() {} ; +void g_value_set_flags() {} ; +void g_value_set_float() {} ; +void g_value_set_instance() {} ; +void g_value_set_int() {} ; +void g_value_set_int64() {} ; +void g_value_set_long() {} ; +void g_value_set_object() {} ; +void g_value_set_param() {} ; +void g_value_set_pointer() {} ; +void g_value_set_static_boxed() {} ; +void g_value_set_static_string() {} ; +void g_value_set_string() {} ; +void g_value_set_uchar() {} ; +void g_value_set_uint() {} ; +void g_value_set_uint64() {} ; +void g_value_set_ulong() {} ; +void g_value_take_boxed() {} ; +void g_value_take_object() {} ; +void g_value_take_param() {} ; +void g_value_take_string() {} ; +void g_value_transform() {} ; +void g_value_type_compatible() {} ; +void g_value_type_transformable() {} ; +void g_value_unset() {} ; +__asm__(".globl g_param_spec_types; .pushsection .data; .type g_param_spec_types,@object; .size g_param_spec_types, 4; g_param_spec_types: .long 0; .popsection"); diff --git a/lsb-build/stub_libs/libgthread-2.0.Version b/lsb-build/stub_libs/libgthread-2.0.Version new file mode 100644 index 0000000..08a3220 --- /dev/null +++ b/lsb-build/stub_libs/libgthread-2.0.Version @@ -0,0 +1 @@ +LSB_DUMMY { __LSB_DUMMY; }; diff --git a/lsb-build/stub_libs/libgthread-2.0.c b/lsb-build/stub_libs/libgthread-2.0.c new file mode 100644 index 0000000..2124abe --- /dev/null +++ b/lsb-build/stub_libs/libgthread-2.0.c @@ -0,0 +1,2 @@ +void g_thread_init() {} ; +void g_thread_init_with_errorcheck_mutexes() {} ; diff --git a/lsb-build/stub_libs/libgtk-x11-2.0.Version b/lsb-build/stub_libs/libgtk-x11-2.0.Version new file mode 100644 index 0000000..08a3220 --- /dev/null +++ b/lsb-build/stub_libs/libgtk-x11-2.0.Version @@ -0,0 +1 @@ +LSB_DUMMY { __LSB_DUMMY; }; diff --git a/lsb-build/stub_libs/libgtk-x11-2.0.c b/lsb-build/stub_libs/libgtk-x11-2.0.c new file mode 100644 index 0000000..129ad9b --- /dev/null +++ b/lsb-build/stub_libs/libgtk-x11-2.0.c @@ -0,0 +1,2259 @@ +void gtk_about_dialog_get_artists() {} ; +void gtk_about_dialog_get_authors() {} ; +void gtk_about_dialog_get_comments() {} ; +void gtk_about_dialog_get_copyright() {} ; +void gtk_about_dialog_get_documenters() {} ; +void gtk_about_dialog_get_license() {} ; +void gtk_about_dialog_get_logo() {} ; +void gtk_about_dialog_get_logo_icon_name() {} ; +void gtk_about_dialog_get_name() {} ; +void gtk_about_dialog_get_translator_credits() {} ; +void gtk_about_dialog_get_type() {} ; +void gtk_about_dialog_get_version() {} ; +void gtk_about_dialog_get_website() {} ; +void gtk_about_dialog_get_website_label() {} ; +void gtk_about_dialog_new() {} ; +void gtk_about_dialog_set_artists() {} ; +void gtk_about_dialog_set_authors() {} ; +void gtk_about_dialog_set_comments() {} ; +void gtk_about_dialog_set_copyright() {} ; +void gtk_about_dialog_set_documenters() {} ; +void gtk_about_dialog_set_email_hook() {} ; +void gtk_about_dialog_set_license() {} ; +void gtk_about_dialog_set_logo() {} ; +void gtk_about_dialog_set_logo_icon_name() {} ; +void gtk_about_dialog_set_name() {} ; +void gtk_about_dialog_set_translator_credits() {} ; +void gtk_about_dialog_set_url_hook() {} ; +void gtk_about_dialog_set_version() {} ; +void gtk_about_dialog_set_website() {} ; +void gtk_about_dialog_set_website_label() {} ; +void gtk_accel_flags_get_type() {} ; +void gtk_accel_group_activate() {} ; +void gtk_accel_group_connect() {} ; +void gtk_accel_group_connect_by_path() {} ; +void gtk_accel_group_disconnect() {} ; +void gtk_accel_group_disconnect_key() {} ; +void gtk_accel_group_find() {} ; +void gtk_accel_group_from_accel_closure() {} ; +void gtk_accel_group_get_type() {} ; +void gtk_accel_group_lock() {} ; +void gtk_accel_group_new() {} ; +void gtk_accel_group_query() {} ; +void gtk_accel_group_unlock() {} ; +void gtk_accel_groups_activate() {} ; +void gtk_accel_groups_from_object() {} ; +void gtk_accel_label_get_accel_widget() {} ; +void gtk_accel_label_get_accel_width() {} ; +void gtk_accel_label_get_type() {} ; +void gtk_accel_label_new() {} ; +void gtk_accel_label_refetch() {} ; +void gtk_accel_label_set_accel_closure() {} ; +void gtk_accel_label_set_accel_widget() {} ; +void gtk_accel_map_add_entry() {} ; +void gtk_accel_map_add_filter() {} ; +void gtk_accel_map_change_entry() {} ; +void gtk_accel_map_foreach() {} ; +void gtk_accel_map_foreach_unfiltered() {} ; +void gtk_accel_map_get() {} ; +void gtk_accel_map_get_type() {} ; +void gtk_accel_map_load() {} ; +void gtk_accel_map_load_fd() {} ; +void gtk_accel_map_load_scanner() {} ; +void gtk_accel_map_lock_path() {} ; +void gtk_accel_map_lookup_entry() {} ; +void gtk_accel_map_save() {} ; +void gtk_accel_map_save_fd() {} ; +void gtk_accel_map_unlock_path() {} ; +void gtk_accelerator_get_default_mod_mask() {} ; +void gtk_accelerator_get_label() {} ; +void gtk_accelerator_name() {} ; +void gtk_accelerator_parse() {} ; +void gtk_accelerator_set_default_mod_mask() {} ; +void gtk_accelerator_valid() {} ; +void gtk_accessible_connect_widget_destroyed() {} ; +void gtk_accessible_get_type() {} ; +void gtk_action_activate() {} ; +void gtk_action_block_activate_from() {} ; +void gtk_action_connect_accelerator() {} ; +void gtk_action_connect_proxy() {} ; +void gtk_action_create_icon() {} ; +void gtk_action_create_menu_item() {} ; +void gtk_action_create_tool_item() {} ; +void gtk_action_disconnect_accelerator() {} ; +void gtk_action_disconnect_proxy() {} ; +void gtk_action_get_accel_path() {} ; +void gtk_action_get_name() {} ; +void gtk_action_get_proxies() {} ; +void gtk_action_get_sensitive() {} ; +void gtk_action_get_type() {} ; +void gtk_action_get_visible() {} ; +void gtk_action_group_add_action() {} ; +void gtk_action_group_add_action_with_accel() {} ; +void gtk_action_group_add_actions() {} ; +void gtk_action_group_add_actions_full() {} ; +void gtk_action_group_add_radio_actions() {} ; +void gtk_action_group_add_radio_actions_full() {} ; +void gtk_action_group_add_toggle_actions() {} ; +void gtk_action_group_add_toggle_actions_full() {} ; +void gtk_action_group_get_action() {} ; +void gtk_action_group_get_name() {} ; +void gtk_action_group_get_sensitive() {} ; +void gtk_action_group_get_type() {} ; +void gtk_action_group_get_visible() {} ; +void gtk_action_group_list_actions() {} ; +void gtk_action_group_new() {} ; +void gtk_action_group_remove_action() {} ; +void gtk_action_group_set_sensitive() {} ; +void gtk_action_group_set_translate_func() {} ; +void gtk_action_group_set_translation_domain() {} ; +void gtk_action_group_set_visible() {} ; +void gtk_action_group_translate_string() {} ; +void gtk_action_is_sensitive() {} ; +void gtk_action_is_visible() {} ; +void gtk_action_new() {} ; +void gtk_action_set_accel_group() {} ; +void gtk_action_set_accel_path() {} ; +void gtk_action_set_sensitive() {} ; +void gtk_action_set_visible() {} ; +void gtk_action_unblock_activate_from() {} ; +void gtk_adjustment_changed() {} ; +void gtk_adjustment_clamp_page() {} ; +void gtk_adjustment_get_type() {} ; +void gtk_adjustment_get_value() {} ; +void gtk_adjustment_new() {} ; +void gtk_adjustment_set_value() {} ; +void gtk_adjustment_value_changed() {} ; +void gtk_alignment_get_padding() {} ; +void gtk_alignment_get_type() {} ; +void gtk_alignment_new() {} ; +void gtk_alignment_set() {} ; +void gtk_alignment_set_padding() {} ; +void gtk_alternative_dialog_button_order() {} ; +void gtk_anchor_type_get_type() {} ; +void gtk_arg_flags_get_type() {} ; +void gtk_arrow_get_type() {} ; +void gtk_arrow_new() {} ; +void gtk_arrow_set() {} ; +void gtk_arrow_type_get_type() {} ; +void gtk_aspect_frame_get_type() {} ; +void gtk_aspect_frame_new() {} ; +void gtk_aspect_frame_set() {} ; +void gtk_attach_options_get_type() {} ; +void gtk_bin_get_child() {} ; +void gtk_bin_get_type() {} ; +void gtk_binding_entry_add_signal() {} ; +void gtk_binding_entry_add_signall() {} ; +void gtk_binding_entry_clear() {} ; +void gtk_binding_entry_remove() {} ; +void gtk_binding_parse_binding() {} ; +void gtk_binding_set_activate() {} ; +void gtk_binding_set_add_path() {} ; +void gtk_binding_set_by_class() {} ; +void gtk_binding_set_find() {} ; +void gtk_binding_set_new() {} ; +void gtk_bindings_activate() {} ; +void gtk_bindings_activate_event() {} ; +void gtk_border_copy() {} ; +void gtk_border_free() {} ; +void gtk_border_get_type() {} ; +void gtk_box_get_homogeneous() {} ; +void gtk_box_get_spacing() {} ; +void gtk_box_get_type() {} ; +void gtk_box_pack_end() {} ; +void gtk_box_pack_end_defaults() {} ; +void gtk_box_pack_start() {} ; +void gtk_box_pack_start_defaults() {} ; +void gtk_box_query_child_packing() {} ; +void gtk_box_reorder_child() {} ; +void gtk_box_set_child_packing() {} ; +void gtk_box_set_homogeneous() {} ; +void gtk_box_set_spacing() {} ; +void gtk_button_box_get_child_secondary() {} ; +void gtk_button_box_get_layout() {} ; +void gtk_button_box_get_type() {} ; +void gtk_button_box_set_child_secondary() {} ; +void gtk_button_box_set_layout() {} ; +void gtk_button_box_style_get_type() {} ; +void gtk_button_clicked() {} ; +void gtk_button_enter() {} ; +void gtk_button_get_alignment() {} ; +void gtk_button_get_focus_on_click() {} ; +void gtk_button_get_image() {} ; +void gtk_button_get_label() {} ; +void gtk_button_get_relief() {} ; +void gtk_button_get_type() {} ; +void gtk_button_get_use_stock() {} ; +void gtk_button_get_use_underline() {} ; +void gtk_button_leave() {} ; +void gtk_button_new() {} ; +void gtk_button_new_from_stock() {} ; +void gtk_button_new_with_label() {} ; +void gtk_button_new_with_mnemonic() {} ; +void gtk_button_pressed() {} ; +void gtk_button_released() {} ; +void gtk_button_set_alignment() {} ; +void gtk_button_set_focus_on_click() {} ; +void gtk_button_set_image() {} ; +void gtk_button_set_label() {} ; +void gtk_button_set_relief() {} ; +void gtk_button_set_use_stock() {} ; +void gtk_button_set_use_underline() {} ; +void gtk_buttons_type_get_type() {} ; +void gtk_calendar_clear_marks() {} ; +void gtk_calendar_display_options_get_type() {} ; +void gtk_calendar_get_date() {} ; +void gtk_calendar_get_display_options() {} ; +void gtk_calendar_get_type() {} ; +void gtk_calendar_mark_day() {} ; +void gtk_calendar_new() {} ; +void gtk_calendar_select_day() {} ; +void gtk_calendar_select_month() {} ; +void gtk_calendar_set_display_options() {} ; +void gtk_calendar_unmark_day() {} ; +void gtk_cell_editable_editing_done() {} ; +void gtk_cell_editable_get_type() {} ; +void gtk_cell_editable_remove_widget() {} ; +void gtk_cell_editable_start_editing() {} ; +void gtk_cell_layout_add_attribute() {} ; +void gtk_cell_layout_clear() {} ; +void gtk_cell_layout_clear_attributes() {} ; +void gtk_cell_layout_get_type() {} ; +void gtk_cell_layout_pack_end() {} ; +void gtk_cell_layout_pack_start() {} ; +void gtk_cell_layout_reorder() {} ; +void gtk_cell_layout_set_attributes() {} ; +void gtk_cell_layout_set_cell_data_func() {} ; +void gtk_cell_renderer_activate() {} ; +void gtk_cell_renderer_combo_get_type() {} ; +void gtk_cell_renderer_combo_new() {} ; +void gtk_cell_renderer_get_fixed_size() {} ; +void gtk_cell_renderer_get_size() {} ; +void gtk_cell_renderer_get_type() {} ; +void gtk_cell_renderer_mode_get_type() {} ; +void gtk_cell_renderer_pixbuf_get_type() {} ; +void gtk_cell_renderer_pixbuf_new() {} ; +void gtk_cell_renderer_progress_get_type() {} ; +void gtk_cell_renderer_progress_new() {} ; +void gtk_cell_renderer_render() {} ; +void gtk_cell_renderer_set_fixed_size() {} ; +void gtk_cell_renderer_start_editing() {} ; +void gtk_cell_renderer_state_get_type() {} ; +void gtk_cell_renderer_stop_editing() {} ; +void gtk_cell_renderer_text_get_type() {} ; +void gtk_cell_renderer_text_new() {} ; +void gtk_cell_renderer_text_set_fixed_height_from_font() {} ; +void gtk_cell_renderer_toggle_get_active() {} ; +void gtk_cell_renderer_toggle_get_radio() {} ; +void gtk_cell_renderer_toggle_get_type() {} ; +void gtk_cell_renderer_toggle_new() {} ; +void gtk_cell_renderer_toggle_set_active() {} ; +void gtk_cell_renderer_toggle_set_radio() {} ; +void gtk_cell_view_get_cell_renderers() {} ; +void gtk_cell_view_get_displayed_row() {} ; +void gtk_cell_view_get_size_of_row() {} ; +void gtk_cell_view_get_type() {} ; +void gtk_cell_view_new() {} ; +void gtk_cell_view_new_with_markup() {} ; +void gtk_cell_view_new_with_pixbuf() {} ; +void gtk_cell_view_new_with_text() {} ; +void gtk_cell_view_set_background_color() {} ; +void gtk_cell_view_set_displayed_row() {} ; +void gtk_cell_view_set_model() {} ; +void gtk_check_button_get_type() {} ; +void gtk_check_button_new() {} ; +void gtk_check_button_new_with_label() {} ; +void gtk_check_button_new_with_mnemonic() {} ; +void gtk_check_menu_item_get_active() {} ; +void gtk_check_menu_item_get_draw_as_radio() {} ; +void gtk_check_menu_item_get_inconsistent() {} ; +void gtk_check_menu_item_get_type() {} ; +void gtk_check_menu_item_new() {} ; +void gtk_check_menu_item_new_with_label() {} ; +void gtk_check_menu_item_new_with_mnemonic() {} ; +void gtk_check_menu_item_set_active() {} ; +void gtk_check_menu_item_set_draw_as_radio() {} ; +void gtk_check_menu_item_set_inconsistent() {} ; +void gtk_check_menu_item_toggled() {} ; +void gtk_check_version() {} ; +void gtk_clipboard_clear() {} ; +void gtk_clipboard_get() {} ; +void gtk_clipboard_get_display() {} ; +void gtk_clipboard_get_for_display() {} ; +void gtk_clipboard_get_owner() {} ; +void gtk_clipboard_get_type() {} ; +void gtk_clipboard_request_contents() {} ; +void gtk_clipboard_request_image() {} ; +void gtk_clipboard_request_targets() {} ; +void gtk_clipboard_request_text() {} ; +void gtk_clipboard_set_can_store() {} ; +void gtk_clipboard_set_image() {} ; +void gtk_clipboard_set_text() {} ; +void gtk_clipboard_set_with_data() {} ; +void gtk_clipboard_set_with_owner() {} ; +void gtk_clipboard_store() {} ; +void gtk_clipboard_wait_for_contents() {} ; +void gtk_clipboard_wait_for_image() {} ; +void gtk_clipboard_wait_for_targets() {} ; +void gtk_clipboard_wait_for_text() {} ; +void gtk_clipboard_wait_is_image_available() {} ; +void gtk_clipboard_wait_is_target_available() {} ; +void gtk_clipboard_wait_is_text_available() {} ; +void gtk_color_button_get_alpha() {} ; +void gtk_color_button_get_color() {} ; +void gtk_color_button_get_title() {} ; +void gtk_color_button_get_type() {} ; +void gtk_color_button_get_use_alpha() {} ; +void gtk_color_button_new() {} ; +void gtk_color_button_new_with_color() {} ; +void gtk_color_button_set_alpha() {} ; +void gtk_color_button_set_color() {} ; +void gtk_color_button_set_title() {} ; +void gtk_color_button_set_use_alpha() {} ; +void gtk_color_selection_dialog_get_type() {} ; +void gtk_color_selection_dialog_new() {} ; +void gtk_color_selection_get_current_alpha() {} ; +void gtk_color_selection_get_current_color() {} ; +void gtk_color_selection_get_has_opacity_control() {} ; +void gtk_color_selection_get_has_palette() {} ; +void gtk_color_selection_get_previous_alpha() {} ; +void gtk_color_selection_get_previous_color() {} ; +void gtk_color_selection_get_type() {} ; +void gtk_color_selection_is_adjusting() {} ; +void gtk_color_selection_new() {} ; +void gtk_color_selection_palette_from_string() {} ; +void gtk_color_selection_palette_to_string() {} ; +void gtk_color_selection_set_change_palette_with_screen_hook() {} ; +void gtk_color_selection_set_current_alpha() {} ; +void gtk_color_selection_set_current_color() {} ; +void gtk_color_selection_set_has_opacity_control() {} ; +void gtk_color_selection_set_has_palette() {} ; +void gtk_color_selection_set_previous_alpha() {} ; +void gtk_color_selection_set_previous_color() {} ; +void gtk_combo_box_append_text() {} ; +void gtk_combo_box_entry_get_text_column() {} ; +void gtk_combo_box_entry_get_type() {} ; +void gtk_combo_box_entry_new() {} ; +void gtk_combo_box_entry_new_text() {} ; +void gtk_combo_box_entry_new_with_model() {} ; +void gtk_combo_box_entry_set_text_column() {} ; +void gtk_combo_box_get_active() {} ; +void gtk_combo_box_get_active_iter() {} ; +void gtk_combo_box_get_active_text() {} ; +void gtk_combo_box_get_add_tearoffs() {} ; +void gtk_combo_box_get_column_span_column() {} ; +void gtk_combo_box_get_focus_on_click() {} ; +void gtk_combo_box_get_model() {} ; +void gtk_combo_box_get_popup_accessible() {} ; +void gtk_combo_box_get_row_separator_func() {} ; +void gtk_combo_box_get_row_span_column() {} ; +void gtk_combo_box_get_type() {} ; +void gtk_combo_box_get_wrap_width() {} ; +void gtk_combo_box_insert_text() {} ; +void gtk_combo_box_new() {} ; +void gtk_combo_box_new_text() {} ; +void gtk_combo_box_new_with_model() {} ; +void gtk_combo_box_popdown() {} ; +void gtk_combo_box_popup() {} ; +void gtk_combo_box_prepend_text() {} ; +void gtk_combo_box_remove_text() {} ; +void gtk_combo_box_set_active() {} ; +void gtk_combo_box_set_active_iter() {} ; +void gtk_combo_box_set_add_tearoffs() {} ; +void gtk_combo_box_set_column_span_column() {} ; +void gtk_combo_box_set_focus_on_click() {} ; +void gtk_combo_box_set_model() {} ; +void gtk_combo_box_set_row_separator_func() {} ; +void gtk_combo_box_set_row_span_column() {} ; +void gtk_combo_box_set_wrap_width() {} ; +void gtk_container_add() {} ; +void gtk_container_add_with_properties() {} ; +void gtk_container_check_resize() {} ; +void gtk_container_child_get() {} ; +void gtk_container_child_get_property() {} ; +void gtk_container_child_get_valist() {} ; +void gtk_container_child_set() {} ; +void gtk_container_child_set_property() {} ; +void gtk_container_child_set_valist() {} ; +void gtk_container_child_type() {} ; +void gtk_container_class_find_child_property() {} ; +void gtk_container_class_install_child_property() {} ; +void gtk_container_class_list_child_properties() {} ; +void gtk_container_forall() {} ; +void gtk_container_foreach() {} ; +void gtk_container_get_border_width() {} ; +void gtk_container_get_children() {} ; +void gtk_container_get_focus_chain() {} ; +void gtk_container_get_focus_hadjustment() {} ; +void gtk_container_get_focus_vadjustment() {} ; +void gtk_container_get_resize_mode() {} ; +void gtk_container_get_type() {} ; +void gtk_container_propagate_expose() {} ; +void gtk_container_remove() {} ; +void gtk_container_resize_children() {} ; +void gtk_container_set_border_width() {} ; +void gtk_container_set_focus_chain() {} ; +void gtk_container_set_focus_child() {} ; +void gtk_container_set_focus_hadjustment() {} ; +void gtk_container_set_focus_vadjustment() {} ; +void gtk_container_set_reallocate_redraws() {} ; +void gtk_container_set_resize_mode() {} ; +void gtk_container_unset_focus_chain() {} ; +void gtk_corner_type_get_type() {} ; +void gtk_curve_get_type() {} ; +void gtk_curve_get_vector() {} ; +void gtk_curve_new() {} ; +void gtk_curve_reset() {} ; +void gtk_curve_set_curve_type() {} ; +void gtk_curve_set_gamma() {} ; +void gtk_curve_set_range() {} ; +void gtk_curve_set_vector() {} ; +void gtk_curve_type_get_type() {} ; +void gtk_debug_flag_get_type() {} ; +void gtk_delete_type_get_type() {} ; +void gtk_dest_defaults_get_type() {} ; +void gtk_dialog_add_action_widget() {} ; +void gtk_dialog_add_button() {} ; +void gtk_dialog_add_buttons() {} ; +void gtk_dialog_flags_get_type() {} ; +void gtk_dialog_get_has_separator() {} ; +void gtk_dialog_get_type() {} ; +void gtk_dialog_new() {} ; +void gtk_dialog_new_with_buttons() {} ; +void gtk_dialog_response() {} ; +void gtk_dialog_run() {} ; +void gtk_dialog_set_alternative_button_order() {} ; +void gtk_dialog_set_alternative_button_order_from_array() {} ; +void gtk_dialog_set_default_response() {} ; +void gtk_dialog_set_has_separator() {} ; +void gtk_dialog_set_response_sensitive() {} ; +void gtk_direction_type_get_type() {} ; +void gtk_disable_setlocale() {} ; +void gtk_drag_begin() {} ; +void gtk_drag_check_threshold() {} ; +void gtk_drag_dest_add_image_targets() {} ; +void gtk_drag_dest_add_text_targets() {} ; +void gtk_drag_dest_add_uri_targets() {} ; +void gtk_drag_dest_find_target() {} ; +void gtk_drag_dest_get_target_list() {} ; +void gtk_drag_dest_set() {} ; +void gtk_drag_dest_set_proxy() {} ; +void gtk_drag_dest_set_target_list() {} ; +void gtk_drag_dest_unset() {} ; +void gtk_drag_finish() {} ; +void gtk_drag_get_data() {} ; +void gtk_drag_get_source_widget() {} ; +void gtk_drag_highlight() {} ; +void gtk_drag_set_icon_default() {} ; +void gtk_drag_set_icon_pixbuf() {} ; +void gtk_drag_set_icon_pixmap() {} ; +void gtk_drag_set_icon_stock() {} ; +void gtk_drag_set_icon_widget() {} ; +void gtk_drag_source_add_image_targets() {} ; +void gtk_drag_source_add_text_targets() {} ; +void gtk_drag_source_add_uri_targets() {} ; +void gtk_drag_source_get_target_list() {} ; +void gtk_drag_source_set() {} ; +void gtk_drag_source_set_icon() {} ; +void gtk_drag_source_set_icon_pixbuf() {} ; +void gtk_drag_source_set_icon_stock() {} ; +void gtk_drag_source_set_target_list() {} ; +void gtk_drag_source_unset() {} ; +void gtk_drag_unhighlight() {} ; +void gtk_draw_insertion_cursor() {} ; +void gtk_drawing_area_get_type() {} ; +void gtk_drawing_area_new() {} ; +void gtk_editable_copy_clipboard() {} ; +void gtk_editable_cut_clipboard() {} ; +void gtk_editable_delete_selection() {} ; +void gtk_editable_delete_text() {} ; +void gtk_editable_get_chars() {} ; +void gtk_editable_get_editable() {} ; +void gtk_editable_get_position() {} ; +void gtk_editable_get_selection_bounds() {} ; +void gtk_editable_get_type() {} ; +void gtk_editable_insert_text() {} ; +void gtk_editable_paste_clipboard() {} ; +void gtk_editable_select_region() {} ; +void gtk_editable_set_editable() {} ; +void gtk_editable_set_position() {} ; +void gtk_entry_completion_complete() {} ; +void gtk_entry_completion_delete_action() {} ; +void gtk_entry_completion_get_entry() {} ; +void gtk_entry_completion_get_inline_completion() {} ; +void gtk_entry_completion_get_minimum_key_length() {} ; +void gtk_entry_completion_get_model() {} ; +void gtk_entry_completion_get_popup_completion() {} ; +void gtk_entry_completion_get_text_column() {} ; +void gtk_entry_completion_get_type() {} ; +void gtk_entry_completion_insert_action_markup() {} ; +void gtk_entry_completion_insert_action_text() {} ; +void gtk_entry_completion_insert_prefix() {} ; +void gtk_entry_completion_new() {} ; +void gtk_entry_completion_set_inline_completion() {} ; +void gtk_entry_completion_set_match_func() {} ; +void gtk_entry_completion_set_minimum_key_length() {} ; +void gtk_entry_completion_set_model() {} ; +void gtk_entry_completion_set_popup_completion() {} ; +void gtk_entry_completion_set_text_column() {} ; +void gtk_entry_get_activates_default() {} ; +void gtk_entry_get_alignment() {} ; +void gtk_entry_get_completion() {} ; +void gtk_entry_get_has_frame() {} ; +void gtk_entry_get_invisible_char() {} ; +void gtk_entry_get_layout() {} ; +void gtk_entry_get_layout_offsets() {} ; +void gtk_entry_get_max_length() {} ; +void gtk_entry_get_text() {} ; +void gtk_entry_get_type() {} ; +void gtk_entry_get_visibility() {} ; +void gtk_entry_get_width_chars() {} ; +void gtk_entry_layout_index_to_text_index() {} ; +void gtk_entry_new() {} ; +void gtk_entry_set_activates_default() {} ; +void gtk_entry_set_alignment() {} ; +void gtk_entry_set_completion() {} ; +void gtk_entry_set_has_frame() {} ; +void gtk_entry_set_invisible_char() {} ; +void gtk_entry_set_max_length() {} ; +void gtk_entry_set_text() {} ; +void gtk_entry_set_visibility() {} ; +void gtk_entry_set_width_chars() {} ; +void gtk_entry_text_index_to_layout_index() {} ; +void gtk_event_box_get_above_child() {} ; +void gtk_event_box_get_type() {} ; +void gtk_event_box_get_visible_window() {} ; +void gtk_event_box_new() {} ; +void gtk_event_box_set_above_child() {} ; +void gtk_event_box_set_visible_window() {} ; +void gtk_events_pending() {} ; +void gtk_expander_get_expanded() {} ; +void gtk_expander_get_label() {} ; +void gtk_expander_get_label_widget() {} ; +void gtk_expander_get_spacing() {} ; +void gtk_expander_get_type() {} ; +void gtk_expander_get_use_markup() {} ; +void gtk_expander_get_use_underline() {} ; +void gtk_expander_new() {} ; +void gtk_expander_new_with_mnemonic() {} ; +void gtk_expander_set_expanded() {} ; +void gtk_expander_set_label() {} ; +void gtk_expander_set_label_widget() {} ; +void gtk_expander_set_spacing() {} ; +void gtk_expander_set_use_markup() {} ; +void gtk_expander_set_use_underline() {} ; +void gtk_expander_style_get_type() {} ; +void gtk_false() {} ; +void gtk_file_chooser_action_get_type() {} ; +void gtk_file_chooser_add_filter() {} ; +void gtk_file_chooser_add_shortcut_folder() {} ; +void gtk_file_chooser_add_shortcut_folder_uri() {} ; +void gtk_file_chooser_button_get_title() {} ; +void gtk_file_chooser_button_get_type() {} ; +void gtk_file_chooser_button_get_width_chars() {} ; +void gtk_file_chooser_button_new() {} ; +void gtk_file_chooser_button_new_with_backend() {} ; +void gtk_file_chooser_button_new_with_dialog() {} ; +void gtk_file_chooser_button_set_title() {} ; +void gtk_file_chooser_button_set_width_chars() {} ; +void gtk_file_chooser_dialog_get_type() {} ; +void gtk_file_chooser_dialog_new() {} ; +void gtk_file_chooser_dialog_new_with_backend() {} ; +void gtk_file_chooser_error_get_type() {} ; +void gtk_file_chooser_error_quark() {} ; +void gtk_file_chooser_get_action() {} ; +void gtk_file_chooser_get_current_folder() {} ; +void gtk_file_chooser_get_current_folder_uri() {} ; +void gtk_file_chooser_get_extra_widget() {} ; +void gtk_file_chooser_get_filename() {} ; +void gtk_file_chooser_get_filenames() {} ; +void gtk_file_chooser_get_filter() {} ; +void gtk_file_chooser_get_local_only() {} ; +void gtk_file_chooser_get_preview_filename() {} ; +void gtk_file_chooser_get_preview_uri() {} ; +void gtk_file_chooser_get_preview_widget() {} ; +void gtk_file_chooser_get_preview_widget_active() {} ; +void gtk_file_chooser_get_select_multiple() {} ; +void gtk_file_chooser_get_show_hidden() {} ; +void gtk_file_chooser_get_type() {} ; +void gtk_file_chooser_get_uri() {} ; +void gtk_file_chooser_get_uris() {} ; +void gtk_file_chooser_get_use_preview_label() {} ; +void gtk_file_chooser_list_filters() {} ; +void gtk_file_chooser_list_shortcut_folder_uris() {} ; +void gtk_file_chooser_list_shortcut_folders() {} ; +void gtk_file_chooser_remove_filter() {} ; +void gtk_file_chooser_remove_shortcut_folder() {} ; +void gtk_file_chooser_remove_shortcut_folder_uri() {} ; +void gtk_file_chooser_select_all() {} ; +void gtk_file_chooser_select_filename() {} ; +void gtk_file_chooser_select_uri() {} ; +void gtk_file_chooser_set_action() {} ; +void gtk_file_chooser_set_current_folder() {} ; +void gtk_file_chooser_set_current_folder_uri() {} ; +void gtk_file_chooser_set_current_name() {} ; +void gtk_file_chooser_set_extra_widget() {} ; +void gtk_file_chooser_set_filename() {} ; +void gtk_file_chooser_set_filter() {} ; +void gtk_file_chooser_set_local_only() {} ; +void gtk_file_chooser_set_preview_widget() {} ; +void gtk_file_chooser_set_preview_widget_active() {} ; +void gtk_file_chooser_set_select_multiple() {} ; +void gtk_file_chooser_set_show_hidden() {} ; +void gtk_file_chooser_set_uri() {} ; +void gtk_file_chooser_set_use_preview_label() {} ; +void gtk_file_chooser_unselect_all() {} ; +void gtk_file_chooser_unselect_filename() {} ; +void gtk_file_chooser_unselect_uri() {} ; +void gtk_file_chooser_widget_get_type() {} ; +void gtk_file_chooser_widget_new() {} ; +void gtk_file_chooser_widget_new_with_backend() {} ; +void gtk_file_filter_add_custom() {} ; +void gtk_file_filter_add_mime_type() {} ; +void gtk_file_filter_add_pattern() {} ; +void gtk_file_filter_add_pixbuf_formats() {} ; +void gtk_file_filter_filter() {} ; +void gtk_file_filter_flags_get_type() {} ; +void gtk_file_filter_get_name() {} ; +void gtk_file_filter_get_needed() {} ; +void gtk_file_filter_get_type() {} ; +void gtk_file_filter_new() {} ; +void gtk_file_filter_set_name() {} ; +void gtk_file_selection_complete() {} ; +void gtk_file_selection_get_filename() {} ; +void gtk_file_selection_get_select_multiple() {} ; +void gtk_file_selection_get_selections() {} ; +void gtk_file_selection_get_type() {} ; +void gtk_file_selection_hide_fileop_buttons() {} ; +void gtk_file_selection_new() {} ; +void gtk_file_selection_set_filename() {} ; +void gtk_file_selection_set_select_multiple() {} ; +void gtk_file_selection_show_fileop_buttons() {} ; +void gtk_fixed_get_has_window() {} ; +void gtk_fixed_get_type() {} ; +void gtk_fixed_move() {} ; +void gtk_fixed_new() {} ; +void gtk_fixed_put() {} ; +void gtk_fixed_set_has_window() {} ; +void gtk_font_button_get_font_name() {} ; +void gtk_font_button_get_show_size() {} ; +void gtk_font_button_get_show_style() {} ; +void gtk_font_button_get_title() {} ; +void gtk_font_button_get_type() {} ; +void gtk_font_button_get_use_font() {} ; +void gtk_font_button_get_use_size() {} ; +void gtk_font_button_new() {} ; +void gtk_font_button_new_with_font() {} ; +void gtk_font_button_set_font_name() {} ; +void gtk_font_button_set_show_size() {} ; +void gtk_font_button_set_show_style() {} ; +void gtk_font_button_set_title() {} ; +void gtk_font_button_set_use_font() {} ; +void gtk_font_button_set_use_size() {} ; +void gtk_font_selection_dialog_get_font_name() {} ; +void gtk_font_selection_dialog_get_preview_text() {} ; +void gtk_font_selection_dialog_get_type() {} ; +void gtk_font_selection_dialog_new() {} ; +void gtk_font_selection_dialog_set_font_name() {} ; +void gtk_font_selection_dialog_set_preview_text() {} ; +void gtk_font_selection_get_font_name() {} ; +void gtk_font_selection_get_preview_text() {} ; +void gtk_font_selection_get_type() {} ; +void gtk_font_selection_new() {} ; +void gtk_font_selection_set_font_name() {} ; +void gtk_font_selection_set_preview_text() {} ; +void gtk_frame_get_label() {} ; +void gtk_frame_get_label_align() {} ; +void gtk_frame_get_label_widget() {} ; +void gtk_frame_get_shadow_type() {} ; +void gtk_frame_get_type() {} ; +void gtk_frame_new() {} ; +void gtk_frame_set_label() {} ; +void gtk_frame_set_label_align() {} ; +void gtk_frame_set_label_widget() {} ; +void gtk_frame_set_shadow_type() {} ; +void gtk_gamma_curve_get_type() {} ; +void gtk_gamma_curve_new() {} ; +void gtk_gc_get() {} ; +void gtk_gc_release() {} ; +void gtk_get_current_event() {} ; +void gtk_get_current_event_state() {} ; +void gtk_get_current_event_time() {} ; +void gtk_get_default_language() {} ; +void gtk_get_event_widget() {} ; +void gtk_get_option_group() {} ; +void gtk_grab_add() {} ; +void gtk_grab_get_current() {} ; +void gtk_grab_remove() {} ; +void gtk_handle_box_get_handle_position() {} ; +void gtk_handle_box_get_shadow_type() {} ; +void gtk_handle_box_get_snap_edge() {} ; +void gtk_handle_box_get_type() {} ; +void gtk_handle_box_new() {} ; +void gtk_handle_box_set_handle_position() {} ; +void gtk_handle_box_set_shadow_type() {} ; +void gtk_handle_box_set_snap_edge() {} ; +void gtk_hbox_get_type() {} ; +void gtk_hbox_new() {} ; +void gtk_hbutton_box_get_type() {} ; +void gtk_hbutton_box_new() {} ; +void gtk_hpaned_get_type() {} ; +void gtk_hpaned_new() {} ; +void gtk_hruler_get_type() {} ; +void gtk_hruler_new() {} ; +void gtk_hscale_get_type() {} ; +void gtk_hscale_new() {} ; +void gtk_hscale_new_with_range() {} ; +void gtk_hscrollbar_get_type() {} ; +void gtk_hscrollbar_new() {} ; +void gtk_hseparator_get_type() {} ; +void gtk_hseparator_new() {} ; +void gtk_icon_factory_add() {} ; +void gtk_icon_factory_add_default() {} ; +void gtk_icon_factory_get_type() {} ; +void gtk_icon_factory_lookup() {} ; +void gtk_icon_factory_lookup_default() {} ; +void gtk_icon_factory_new() {} ; +void gtk_icon_factory_remove_default() {} ; +void gtk_icon_info_copy() {} ; +void gtk_icon_info_free() {} ; +void gtk_icon_info_get_attach_points() {} ; +void gtk_icon_info_get_base_size() {} ; +void gtk_icon_info_get_builtin_pixbuf() {} ; +void gtk_icon_info_get_display_name() {} ; +void gtk_icon_info_get_embedded_rect() {} ; +void gtk_icon_info_get_filename() {} ; +void gtk_icon_info_get_type() {} ; +void gtk_icon_info_load_icon() {} ; +void gtk_icon_info_set_raw_coordinates() {} ; +void gtk_icon_lookup_flags_get_type() {} ; +void gtk_icon_set_add_source() {} ; +void gtk_icon_set_copy() {} ; +void gtk_icon_set_get_sizes() {} ; +void gtk_icon_set_get_type() {} ; +void gtk_icon_set_new() {} ; +void gtk_icon_set_new_from_pixbuf() {} ; +void gtk_icon_set_ref() {} ; +void gtk_icon_set_render_icon() {} ; +void gtk_icon_set_unref() {} ; +void gtk_icon_size_from_name() {} ; +void gtk_icon_size_get_name() {} ; +void gtk_icon_size_get_type() {} ; +void gtk_icon_size_lookup() {} ; +void gtk_icon_size_lookup_for_settings() {} ; +void gtk_icon_size_register() {} ; +void gtk_icon_size_register_alias() {} ; +void gtk_icon_source_copy() {} ; +void gtk_icon_source_free() {} ; +void gtk_icon_source_get_direction() {} ; +void gtk_icon_source_get_direction_wildcarded() {} ; +void gtk_icon_source_get_filename() {} ; +void gtk_icon_source_get_icon_name() {} ; +void gtk_icon_source_get_pixbuf() {} ; +void gtk_icon_source_get_size() {} ; +void gtk_icon_source_get_size_wildcarded() {} ; +void gtk_icon_source_get_state() {} ; +void gtk_icon_source_get_state_wildcarded() {} ; +void gtk_icon_source_get_type() {} ; +void gtk_icon_source_new() {} ; +void gtk_icon_source_set_direction() {} ; +void gtk_icon_source_set_direction_wildcarded() {} ; +void gtk_icon_source_set_filename() {} ; +void gtk_icon_source_set_icon_name() {} ; +void gtk_icon_source_set_pixbuf() {} ; +void gtk_icon_source_set_size() {} ; +void gtk_icon_source_set_size_wildcarded() {} ; +void gtk_icon_source_set_state() {} ; +void gtk_icon_source_set_state_wildcarded() {} ; +void gtk_icon_theme_add_builtin_icon() {} ; +void gtk_icon_theme_append_search_path() {} ; +void gtk_icon_theme_error_get_type() {} ; +void gtk_icon_theme_error_quark() {} ; +void gtk_icon_theme_get_default() {} ; +void gtk_icon_theme_get_example_icon_name() {} ; +void gtk_icon_theme_get_for_screen() {} ; +void gtk_icon_theme_get_icon_sizes() {} ; +void gtk_icon_theme_get_search_path() {} ; +void gtk_icon_theme_get_type() {} ; +void gtk_icon_theme_has_icon() {} ; +void gtk_icon_theme_list_icons() {} ; +void gtk_icon_theme_load_icon() {} ; +void gtk_icon_theme_lookup_icon() {} ; +void gtk_icon_theme_new() {} ; +void gtk_icon_theme_prepend_search_path() {} ; +void gtk_icon_theme_rescan_if_needed() {} ; +void gtk_icon_theme_set_custom_theme() {} ; +void gtk_icon_theme_set_screen() {} ; +void gtk_icon_theme_set_search_path() {} ; +void gtk_icon_view_get_column_spacing() {} ; +void gtk_icon_view_get_columns() {} ; +void gtk_icon_view_get_item_width() {} ; +void gtk_icon_view_get_margin() {} ; +void gtk_icon_view_get_markup_column() {} ; +void gtk_icon_view_get_model() {} ; +void gtk_icon_view_get_orientation() {} ; +void gtk_icon_view_get_path_at_pos() {} ; +void gtk_icon_view_get_pixbuf_column() {} ; +void gtk_icon_view_get_row_spacing() {} ; +void gtk_icon_view_get_selected_items() {} ; +void gtk_icon_view_get_selection_mode() {} ; +void gtk_icon_view_get_spacing() {} ; +void gtk_icon_view_get_text_column() {} ; +void gtk_icon_view_get_type() {} ; +void gtk_icon_view_item_activated() {} ; +void gtk_icon_view_new() {} ; +void gtk_icon_view_new_with_model() {} ; +void gtk_icon_view_path_is_selected() {} ; +void gtk_icon_view_select_all() {} ; +void gtk_icon_view_select_path() {} ; +void gtk_icon_view_selected_foreach() {} ; +void gtk_icon_view_set_column_spacing() {} ; +void gtk_icon_view_set_columns() {} ; +void gtk_icon_view_set_item_width() {} ; +void gtk_icon_view_set_margin() {} ; +void gtk_icon_view_set_markup_column() {} ; +void gtk_icon_view_set_model() {} ; +void gtk_icon_view_set_orientation() {} ; +void gtk_icon_view_set_pixbuf_column() {} ; +void gtk_icon_view_set_row_spacing() {} ; +void gtk_icon_view_set_selection_mode() {} ; +void gtk_icon_view_set_spacing() {} ; +void gtk_icon_view_set_text_column() {} ; +void gtk_icon_view_unselect_all() {} ; +void gtk_icon_view_unselect_path() {} ; +void gtk_identifier_get_type() {} ; +void gtk_im_context_delete_surrounding() {} ; +void gtk_im_context_filter_keypress() {} ; +void gtk_im_context_focus_in() {} ; +void gtk_im_context_focus_out() {} ; +void gtk_im_context_get_preedit_string() {} ; +void gtk_im_context_get_surrounding() {} ; +void gtk_im_context_get_type() {} ; +void gtk_im_context_reset() {} ; +void gtk_im_context_set_client_window() {} ; +void gtk_im_context_set_cursor_location() {} ; +void gtk_im_context_set_surrounding() {} ; +void gtk_im_context_set_use_preedit() {} ; +void gtk_im_context_simple_add_table() {} ; +void gtk_im_context_simple_get_type() {} ; +void gtk_im_context_simple_new() {} ; +void gtk_im_multicontext_append_menuitems() {} ; +void gtk_im_multicontext_get_type() {} ; +void gtk_im_multicontext_new() {} ; +void gtk_im_preedit_style_get_type() {} ; +void gtk_im_status_style_get_type() {} ; +void gtk_image_get_animation() {} ; +void gtk_image_get_icon_name() {} ; +void gtk_image_get_icon_set() {} ; +void gtk_image_get_image() {} ; +void gtk_image_get_pixbuf() {} ; +void gtk_image_get_pixel_size() {} ; +void gtk_image_get_pixmap() {} ; +void gtk_image_get_stock() {} ; +void gtk_image_get_storage_type() {} ; +void gtk_image_get_type() {} ; +void gtk_image_menu_item_get_image() {} ; +void gtk_image_menu_item_get_type() {} ; +void gtk_image_menu_item_new() {} ; +void gtk_image_menu_item_new_from_stock() {} ; +void gtk_image_menu_item_new_with_label() {} ; +void gtk_image_menu_item_new_with_mnemonic() {} ; +void gtk_image_menu_item_set_image() {} ; +void gtk_image_new() {} ; +void gtk_image_new_from_animation() {} ; +void gtk_image_new_from_file() {} ; +void gtk_image_new_from_icon_name() {} ; +void gtk_image_new_from_icon_set() {} ; +void gtk_image_new_from_image() {} ; +void gtk_image_new_from_pixbuf() {} ; +void gtk_image_new_from_pixmap() {} ; +void gtk_image_new_from_stock() {} ; +void gtk_image_set_from_animation() {} ; +void gtk_image_set_from_file() {} ; +void gtk_image_set_from_icon_name() {} ; +void gtk_image_set_from_icon_set() {} ; +void gtk_image_set_from_image() {} ; +void gtk_image_set_from_pixbuf() {} ; +void gtk_image_set_from_pixmap() {} ; +void gtk_image_set_from_stock() {} ; +void gtk_image_set_pixel_size() {} ; +void gtk_image_type_get_type() {} ; +void gtk_init() {} ; +void gtk_init_add() {} ; +void gtk_init_check() {} ; +void gtk_init_with_args() {} ; +void gtk_input_dialog_get_type() {} ; +void gtk_input_dialog_new() {} ; +void gtk_invisible_get_screen() {} ; +void gtk_invisible_get_type() {} ; +void gtk_invisible_new() {} ; +void gtk_invisible_new_for_screen() {} ; +void gtk_invisible_set_screen() {} ; +void gtk_item_deselect() {} ; +void gtk_item_get_type() {} ; +void gtk_item_select() {} ; +void gtk_item_toggle() {} ; +void gtk_justification_get_type() {} ; +void gtk_key_snooper_install() {} ; +void gtk_key_snooper_remove() {} ; +void gtk_label_get_angle() {} ; +void gtk_label_get_attributes() {} ; +void gtk_label_get_ellipsize() {} ; +void gtk_label_get_justify() {} ; +void gtk_label_get_label() {} ; +void gtk_label_get_layout() {} ; +void gtk_label_get_layout_offsets() {} ; +void gtk_label_get_line_wrap() {} ; +void gtk_label_get_max_width_chars() {} ; +void gtk_label_get_mnemonic_keyval() {} ; +void gtk_label_get_mnemonic_widget() {} ; +void gtk_label_get_selectable() {} ; +void gtk_label_get_selection_bounds() {} ; +void gtk_label_get_single_line_mode() {} ; +void gtk_label_get_text() {} ; +void gtk_label_get_type() {} ; +void gtk_label_get_use_markup() {} ; +void gtk_label_get_use_underline() {} ; +void gtk_label_get_width_chars() {} ; +void gtk_label_new() {} ; +void gtk_label_new_with_mnemonic() {} ; +void gtk_label_select_region() {} ; +void gtk_label_set_angle() {} ; +void gtk_label_set_attributes() {} ; +void gtk_label_set_ellipsize() {} ; +void gtk_label_set_justify() {} ; +void gtk_label_set_label() {} ; +void gtk_label_set_line_wrap() {} ; +void gtk_label_set_markup() {} ; +void gtk_label_set_markup_with_mnemonic() {} ; +void gtk_label_set_max_width_chars() {} ; +void gtk_label_set_mnemonic_widget() {} ; +void gtk_label_set_pattern() {} ; +void gtk_label_set_selectable() {} ; +void gtk_label_set_single_line_mode() {} ; +void gtk_label_set_text() {} ; +void gtk_label_set_text_with_mnemonic() {} ; +void gtk_label_set_use_markup() {} ; +void gtk_label_set_use_underline() {} ; +void gtk_label_set_width_chars() {} ; +void gtk_layout_get_hadjustment() {} ; +void gtk_layout_get_size() {} ; +void gtk_layout_get_type() {} ; +void gtk_layout_get_vadjustment() {} ; +void gtk_layout_move() {} ; +void gtk_layout_new() {} ; +void gtk_layout_put() {} ; +void gtk_layout_set_hadjustment() {} ; +void gtk_layout_set_size() {} ; +void gtk_layout_set_vadjustment() {} ; +void gtk_list_store_append() {} ; +void gtk_list_store_clear() {} ; +void gtk_list_store_get_type() {} ; +void gtk_list_store_insert() {} ; +void gtk_list_store_insert_after() {} ; +void gtk_list_store_insert_before() {} ; +void gtk_list_store_insert_with_values() {} ; +void gtk_list_store_insert_with_valuesv() {} ; +void gtk_list_store_iter_is_valid() {} ; +void gtk_list_store_move_after() {} ; +void gtk_list_store_move_before() {} ; +void gtk_list_store_new() {} ; +void gtk_list_store_newv() {} ; +void gtk_list_store_prepend() {} ; +void gtk_list_store_remove() {} ; +void gtk_list_store_reorder() {} ; +void gtk_list_store_set() {} ; +void gtk_list_store_set_column_types() {} ; +void gtk_list_store_set_valist() {} ; +void gtk_list_store_set_value() {} ; +void gtk_list_store_swap() {} ; +void gtk_main() {} ; +void gtk_main_do_event() {} ; +void gtk_main_iteration() {} ; +void gtk_main_iteration_do() {} ; +void gtk_main_level() {} ; +void gtk_main_quit() {} ; +void gtk_match_type_get_type() {} ; +void gtk_menu_attach() {} ; +void gtk_menu_attach_to_widget() {} ; +void gtk_menu_bar_get_type() {} ; +void gtk_menu_bar_new() {} ; +void gtk_menu_detach() {} ; +void gtk_menu_direction_type_get_type() {} ; +void gtk_menu_get_accel_group() {} ; +void gtk_menu_get_active() {} ; +void gtk_menu_get_attach_widget() {} ; +void gtk_menu_get_for_attach_widget() {} ; +void gtk_menu_get_tearoff_state() {} ; +void gtk_menu_get_title() {} ; +void gtk_menu_get_type() {} ; +void gtk_menu_item_activate() {} ; +void gtk_menu_item_deselect() {} ; +void gtk_menu_item_get_right_justified() {} ; +void gtk_menu_item_get_submenu() {} ; +void gtk_menu_item_get_type() {} ; +void gtk_menu_item_new() {} ; +void gtk_menu_item_new_with_label() {} ; +void gtk_menu_item_new_with_mnemonic() {} ; +void gtk_menu_item_remove_submenu() {} ; +void gtk_menu_item_select() {} ; +void gtk_menu_item_set_accel_path() {} ; +void gtk_menu_item_set_right_justified() {} ; +void gtk_menu_item_set_submenu() {} ; +void gtk_menu_item_toggle_size_allocate() {} ; +void gtk_menu_item_toggle_size_request() {} ; +void gtk_menu_new() {} ; +void gtk_menu_popdown() {} ; +void gtk_menu_popup() {} ; +void gtk_menu_reorder_child() {} ; +void gtk_menu_reposition() {} ; +void gtk_menu_set_accel_group() {} ; +void gtk_menu_set_accel_path() {} ; +void gtk_menu_set_active() {} ; +void gtk_menu_set_monitor() {} ; +void gtk_menu_set_screen() {} ; +void gtk_menu_set_tearoff_state() {} ; +void gtk_menu_set_title() {} ; +void gtk_menu_shell_activate_item() {} ; +void gtk_menu_shell_append() {} ; +void gtk_menu_shell_cancel() {} ; +void gtk_menu_shell_deactivate() {} ; +void gtk_menu_shell_deselect() {} ; +void gtk_menu_shell_get_type() {} ; +void gtk_menu_shell_insert() {} ; +void gtk_menu_shell_prepend() {} ; +void gtk_menu_shell_select_first() {} ; +void gtk_menu_shell_select_item() {} ; +void gtk_menu_tool_button_get_menu() {} ; +void gtk_menu_tool_button_get_type() {} ; +void gtk_menu_tool_button_new() {} ; +void gtk_menu_tool_button_new_from_stock() {} ; +void gtk_menu_tool_button_set_arrow_tooltip() {} ; +void gtk_menu_tool_button_set_menu() {} ; +void gtk_message_dialog_format_secondary_markup() {} ; +void gtk_message_dialog_format_secondary_text() {} ; +void gtk_message_dialog_get_type() {} ; +void gtk_message_dialog_new() {} ; +void gtk_message_dialog_new_with_markup() {} ; +void gtk_message_dialog_set_markup() {} ; +void gtk_message_type_get_type() {} ; +void gtk_metric_type_get_type() {} ; +void gtk_misc_get_alignment() {} ; +void gtk_misc_get_padding() {} ; +void gtk_misc_get_type() {} ; +void gtk_misc_set_alignment() {} ; +void gtk_misc_set_padding() {} ; +void gtk_movement_step_get_type() {} ; +void gtk_notebook_append_page() {} ; +void gtk_notebook_append_page_menu() {} ; +void gtk_notebook_get_current_page() {} ; +void gtk_notebook_get_menu_label() {} ; +void gtk_notebook_get_menu_label_text() {} ; +void gtk_notebook_get_n_pages() {} ; +void gtk_notebook_get_nth_page() {} ; +void gtk_notebook_get_scrollable() {} ; +void gtk_notebook_get_show_border() {} ; +void gtk_notebook_get_show_tabs() {} ; +void gtk_notebook_get_tab_label() {} ; +void gtk_notebook_get_tab_label_text() {} ; +void gtk_notebook_get_tab_pos() {} ; +void gtk_notebook_get_type() {} ; +void gtk_notebook_insert_page() {} ; +void gtk_notebook_insert_page_menu() {} ; +void gtk_notebook_new() {} ; +void gtk_notebook_next_page() {} ; +void gtk_notebook_page_num() {} ; +void gtk_notebook_popup_disable() {} ; +void gtk_notebook_popup_enable() {} ; +void gtk_notebook_prepend_page() {} ; +void gtk_notebook_prepend_page_menu() {} ; +void gtk_notebook_prev_page() {} ; +void gtk_notebook_query_tab_label_packing() {} ; +void gtk_notebook_remove_page() {} ; +void gtk_notebook_reorder_child() {} ; +void gtk_notebook_set_current_page() {} ; +void gtk_notebook_set_menu_label() {} ; +void gtk_notebook_set_menu_label_text() {} ; +void gtk_notebook_set_scrollable() {} ; +void gtk_notebook_set_show_border() {} ; +void gtk_notebook_set_show_tabs() {} ; +void gtk_notebook_set_tab_label() {} ; +void gtk_notebook_set_tab_label_packing() {} ; +void gtk_notebook_set_tab_label_text() {} ; +void gtk_notebook_set_tab_pos() {} ; +void gtk_notebook_tab_get_type() {} ; +void gtk_object_destroy() {} ; +void gtk_object_flags_get_type() {} ; +void gtk_object_get_type() {} ; +void gtk_object_sink() {} ; +void gtk_orientation_get_type() {} ; +void gtk_pack_type_get_type() {} ; +void gtk_paint_arrow() {} ; +void gtk_paint_box() {} ; +void gtk_paint_box_gap() {} ; +void gtk_paint_check() {} ; +void gtk_paint_diamond() {} ; +void gtk_paint_expander() {} ; +void gtk_paint_extension() {} ; +void gtk_paint_flat_box() {} ; +void gtk_paint_focus() {} ; +void gtk_paint_handle() {} ; +void gtk_paint_hline() {} ; +void gtk_paint_layout() {} ; +void gtk_paint_option() {} ; +void gtk_paint_polygon() {} ; +void gtk_paint_resize_grip() {} ; +void gtk_paint_shadow() {} ; +void gtk_paint_shadow_gap() {} ; +void gtk_paint_slider() {} ; +void gtk_paint_tab() {} ; +void gtk_paint_vline() {} ; +void gtk_paned_add1() {} ; +void gtk_paned_add2() {} ; +void gtk_paned_get_child1() {} ; +void gtk_paned_get_child2() {} ; +void gtk_paned_get_position() {} ; +void gtk_paned_get_type() {} ; +void gtk_paned_pack1() {} ; +void gtk_paned_pack2() {} ; +void gtk_paned_set_position() {} ; +void gtk_parse_args() {} ; +void gtk_path_priority_type_get_type() {} ; +void gtk_path_type_get_type() {} ; +void gtk_plug_construct() {} ; +void gtk_plug_construct_for_display() {} ; +void gtk_plug_get_id() {} ; +void gtk_plug_get_type() {} ; +void gtk_plug_new() {} ; +void gtk_plug_new_for_display() {} ; +void gtk_policy_type_get_type() {} ; +void gtk_position_type_get_type() {} ; +void gtk_progress_bar_get_ellipsize() {} ; +void gtk_progress_bar_get_fraction() {} ; +void gtk_progress_bar_get_orientation() {} ; +void gtk_progress_bar_get_pulse_step() {} ; +void gtk_progress_bar_get_text() {} ; +void gtk_progress_bar_get_type() {} ; +void gtk_progress_bar_new() {} ; +void gtk_progress_bar_orientation_get_type() {} ; +void gtk_progress_bar_pulse() {} ; +void gtk_progress_bar_set_ellipsize() {} ; +void gtk_progress_bar_set_fraction() {} ; +void gtk_progress_bar_set_orientation() {} ; +void gtk_progress_bar_set_pulse_step() {} ; +void gtk_progress_bar_set_text() {} ; +void gtk_progress_bar_style_get_type() {} ; +void gtk_propagate_event() {} ; +void gtk_quit_add() {} ; +void gtk_quit_add_destroy() {} ; +void gtk_quit_add_full() {} ; +void gtk_quit_remove() {} ; +void gtk_quit_remove_by_data() {} ; +void gtk_radio_action_get_current_value() {} ; +void gtk_radio_action_get_group() {} ; +void gtk_radio_action_get_type() {} ; +void gtk_radio_action_new() {} ; +void gtk_radio_action_set_group() {} ; +void gtk_radio_button_get_group() {} ; +void gtk_radio_button_get_type() {} ; +void gtk_radio_button_new() {} ; +void gtk_radio_button_new_from_widget() {} ; +void gtk_radio_button_new_with_label() {} ; +void gtk_radio_button_new_with_label_from_widget() {} ; +void gtk_radio_button_new_with_mnemonic() {} ; +void gtk_radio_button_new_with_mnemonic_from_widget() {} ; +void gtk_radio_button_set_group() {} ; +void gtk_radio_menu_item_get_group() {} ; +void gtk_radio_menu_item_get_type() {} ; +void gtk_radio_menu_item_new() {} ; +void gtk_radio_menu_item_new_from_widget() {} ; +void gtk_radio_menu_item_new_with_label() {} ; +void gtk_radio_menu_item_new_with_label_from_widget() {} ; +void gtk_radio_menu_item_new_with_mnemonic() {} ; +void gtk_radio_menu_item_new_with_mnemonic_from_widget() {} ; +void gtk_radio_menu_item_set_group() {} ; +void gtk_radio_tool_button_get_group() {} ; +void gtk_radio_tool_button_get_type() {} ; +void gtk_radio_tool_button_new() {} ; +void gtk_radio_tool_button_new_from_stock() {} ; +void gtk_radio_tool_button_new_from_widget() {} ; +void gtk_radio_tool_button_new_with_stock_from_widget() {} ; +void gtk_radio_tool_button_set_group() {} ; +void gtk_range_get_adjustment() {} ; +void gtk_range_get_inverted() {} ; +void gtk_range_get_type() {} ; +void gtk_range_get_update_policy() {} ; +void gtk_range_get_value() {} ; +void gtk_range_set_adjustment() {} ; +void gtk_range_set_increments() {} ; +void gtk_range_set_inverted() {} ; +void gtk_range_set_range() {} ; +void gtk_range_set_update_policy() {} ; +void gtk_range_set_value() {} ; +void gtk_rc_add_default_file() {} ; +void gtk_rc_find_module_in_path() {} ; +void gtk_rc_find_pixmap_in_path() {} ; +void gtk_rc_flags_get_type() {} ; +void gtk_rc_get_default_files() {} ; +void gtk_rc_get_im_module_file() {} ; +void gtk_rc_get_im_module_path() {} ; +void gtk_rc_get_module_dir() {} ; +void gtk_rc_get_style() {} ; +void gtk_rc_get_style_by_paths() {} ; +void gtk_rc_get_theme_dir() {} ; +void gtk_rc_parse() {} ; +void gtk_rc_parse_color() {} ; +void gtk_rc_parse_priority() {} ; +void gtk_rc_parse_state() {} ; +void gtk_rc_parse_string() {} ; +void gtk_rc_property_parse_border() {} ; +void gtk_rc_property_parse_color() {} ; +void gtk_rc_property_parse_enum() {} ; +void gtk_rc_property_parse_flags() {} ; +void gtk_rc_property_parse_requisition() {} ; +void gtk_rc_reparse_all() {} ; +void gtk_rc_reparse_all_for_settings() {} ; +void gtk_rc_reset_styles() {} ; +void gtk_rc_scanner_new() {} ; +void gtk_rc_set_default_files() {} ; +void gtk_rc_style_copy() {} ; +void gtk_rc_style_get_type() {} ; +void gtk_rc_style_new() {} ; +void gtk_rc_style_ref() {} ; +void gtk_rc_style_unref() {} ; +void gtk_rc_token_type_get_type() {} ; +void gtk_relief_style_get_type() {} ; +void gtk_requisition_copy() {} ; +void gtk_requisition_free() {} ; +void gtk_requisition_get_type() {} ; +void gtk_resize_mode_get_type() {} ; +void gtk_response_type_get_type() {} ; +void gtk_ruler_draw_pos() {} ; +void gtk_ruler_draw_ticks() {} ; +void gtk_ruler_get_metric() {} ; +void gtk_ruler_get_range() {} ; +void gtk_ruler_get_type() {} ; +void gtk_ruler_set_metric() {} ; +void gtk_ruler_set_range() {} ; +void gtk_scale_get_digits() {} ; +void gtk_scale_get_draw_value() {} ; +void gtk_scale_get_layout() {} ; +void gtk_scale_get_layout_offsets() {} ; +void gtk_scale_get_type() {} ; +void gtk_scale_get_value_pos() {} ; +void gtk_scale_set_digits() {} ; +void gtk_scale_set_draw_value() {} ; +void gtk_scale_set_value_pos() {} ; +void gtk_scroll_step_get_type() {} ; +void gtk_scroll_type_get_type() {} ; +void gtk_scrollbar_get_type() {} ; +void gtk_scrolled_window_add_with_viewport() {} ; +void gtk_scrolled_window_get_hadjustment() {} ; +void gtk_scrolled_window_get_placement() {} ; +void gtk_scrolled_window_get_policy() {} ; +void gtk_scrolled_window_get_shadow_type() {} ; +void gtk_scrolled_window_get_type() {} ; +void gtk_scrolled_window_get_vadjustment() {} ; +void gtk_scrolled_window_new() {} ; +void gtk_scrolled_window_set_hadjustment() {} ; +void gtk_scrolled_window_set_placement() {} ; +void gtk_scrolled_window_set_policy() {} ; +void gtk_scrolled_window_set_shadow_type() {} ; +void gtk_scrolled_window_set_vadjustment() {} ; +void gtk_selection_add_target() {} ; +void gtk_selection_add_targets() {} ; +void gtk_selection_clear_targets() {} ; +void gtk_selection_convert() {} ; +void gtk_selection_data_copy() {} ; +void gtk_selection_data_free() {} ; +void gtk_selection_data_get_pixbuf() {} ; +void gtk_selection_data_get_targets() {} ; +void gtk_selection_data_get_text() {} ; +void gtk_selection_data_get_type() {} ; +void gtk_selection_data_get_uris() {} ; +void gtk_selection_data_set() {} ; +void gtk_selection_data_set_pixbuf() {} ; +void gtk_selection_data_set_text() {} ; +void gtk_selection_data_set_uris() {} ; +void gtk_selection_data_targets_include_image() {} ; +void gtk_selection_data_targets_include_text() {} ; +void gtk_selection_mode_get_type() {} ; +void gtk_selection_owner_set() {} ; +void gtk_selection_owner_set_for_display() {} ; +void gtk_selection_remove_all() {} ; +void gtk_separator_get_type() {} ; +void gtk_separator_menu_item_get_type() {} ; +void gtk_separator_menu_item_new() {} ; +void gtk_separator_tool_item_get_draw() {} ; +void gtk_separator_tool_item_get_type() {} ; +void gtk_separator_tool_item_new() {} ; +void gtk_separator_tool_item_set_draw() {} ; +void gtk_set_locale() {} ; +void gtk_settings_get_default() {} ; +void gtk_settings_get_for_screen() {} ; +void gtk_settings_get_type() {} ; +void gtk_settings_install_property() {} ; +void gtk_settings_install_property_parser() {} ; +void gtk_settings_set_double_property() {} ; +void gtk_settings_set_long_property() {} ; +void gtk_settings_set_property_value() {} ; +void gtk_settings_set_string_property() {} ; +void gtk_shadow_type_get_type() {} ; +void gtk_show_about_dialog() {} ; +void gtk_side_type_get_type() {} ; +void gtk_signal_run_type_get_type() {} ; +void gtk_size_group_add_widget() {} ; +void gtk_size_group_get_mode() {} ; +void gtk_size_group_get_type() {} ; +void gtk_size_group_mode_get_type() {} ; +void gtk_size_group_new() {} ; +void gtk_size_group_remove_widget() {} ; +void gtk_size_group_set_mode() {} ; +void gtk_socket_add_id() {} ; +void gtk_socket_get_id() {} ; +void gtk_socket_get_type() {} ; +void gtk_socket_new() {} ; +void gtk_sort_type_get_type() {} ; +void gtk_spin_button_configure() {} ; +void gtk_spin_button_get_adjustment() {} ; +void gtk_spin_button_get_digits() {} ; +void gtk_spin_button_get_increments() {} ; +void gtk_spin_button_get_numeric() {} ; +void gtk_spin_button_get_range() {} ; +void gtk_spin_button_get_snap_to_ticks() {} ; +void gtk_spin_button_get_type() {} ; +void gtk_spin_button_get_update_policy() {} ; +void gtk_spin_button_get_value() {} ; +void gtk_spin_button_get_value_as_int() {} ; +void gtk_spin_button_get_wrap() {} ; +void gtk_spin_button_new() {} ; +void gtk_spin_button_new_with_range() {} ; +void gtk_spin_button_set_adjustment() {} ; +void gtk_spin_button_set_digits() {} ; +void gtk_spin_button_set_increments() {} ; +void gtk_spin_button_set_numeric() {} ; +void gtk_spin_button_set_range() {} ; +void gtk_spin_button_set_snap_to_ticks() {} ; +void gtk_spin_button_set_update_policy() {} ; +void gtk_spin_button_set_value() {} ; +void gtk_spin_button_set_wrap() {} ; +void gtk_spin_button_spin() {} ; +void gtk_spin_button_update() {} ; +void gtk_spin_button_update_policy_get_type() {} ; +void gtk_spin_type_get_type() {} ; +void gtk_state_type_get_type() {} ; +void gtk_statusbar_get_context_id() {} ; +void gtk_statusbar_get_has_resize_grip() {} ; +void gtk_statusbar_get_type() {} ; +void gtk_statusbar_new() {} ; +void gtk_statusbar_pop() {} ; +void gtk_statusbar_push() {} ; +void gtk_statusbar_remove() {} ; +void gtk_statusbar_set_has_resize_grip() {} ; +void gtk_stock_add() {} ; +void gtk_stock_add_static() {} ; +void gtk_stock_item_copy() {} ; +void gtk_stock_item_free() {} ; +void gtk_stock_list_ids() {} ; +void gtk_stock_lookup() {} ; +void gtk_style_apply_default_background() {} ; +void gtk_style_attach() {} ; +void gtk_style_copy() {} ; +void gtk_style_detach() {} ; +void gtk_style_get_type() {} ; +void gtk_style_lookup_icon_set() {} ; +void gtk_style_new() {} ; +void gtk_style_render_icon() {} ; +void gtk_style_set_background() {} ; +void gtk_submenu_direction_get_type() {} ; +void gtk_submenu_placement_get_type() {} ; +void gtk_table_attach() {} ; +void gtk_table_attach_defaults() {} ; +void gtk_table_get_col_spacing() {} ; +void gtk_table_get_default_col_spacing() {} ; +void gtk_table_get_default_row_spacing() {} ; +void gtk_table_get_homogeneous() {} ; +void gtk_table_get_row_spacing() {} ; +void gtk_table_get_type() {} ; +void gtk_table_new() {} ; +void gtk_table_resize() {} ; +void gtk_table_set_col_spacing() {} ; +void gtk_table_set_col_spacings() {} ; +void gtk_table_set_homogeneous() {} ; +void gtk_table_set_row_spacing() {} ; +void gtk_table_set_row_spacings() {} ; +void gtk_target_flags_get_type() {} ; +void gtk_target_list_add() {} ; +void gtk_target_list_add_image_targets() {} ; +void gtk_target_list_add_table() {} ; +void gtk_target_list_add_text_targets() {} ; +void gtk_target_list_add_uri_targets() {} ; +void gtk_target_list_find() {} ; +void gtk_target_list_new() {} ; +void gtk_target_list_ref() {} ; +void gtk_target_list_remove() {} ; +void gtk_target_list_unref() {} ; +void gtk_tearoff_menu_item_get_type() {} ; +void gtk_tearoff_menu_item_new() {} ; +void gtk_text_attributes_copy() {} ; +void gtk_text_attributes_copy_values() {} ; +void gtk_text_attributes_get_type() {} ; +void gtk_text_attributes_new() {} ; +void gtk_text_attributes_ref() {} ; +void gtk_text_attributes_unref() {} ; +void gtk_text_buffer_add_selection_clipboard() {} ; +void gtk_text_buffer_apply_tag() {} ; +void gtk_text_buffer_apply_tag_by_name() {} ; +void gtk_text_buffer_backspace() {} ; +void gtk_text_buffer_begin_user_action() {} ; +void gtk_text_buffer_copy_clipboard() {} ; +void gtk_text_buffer_create_child_anchor() {} ; +void gtk_text_buffer_create_mark() {} ; +void gtk_text_buffer_create_tag() {} ; +void gtk_text_buffer_cut_clipboard() {} ; +void gtk_text_buffer_delete() {} ; +void gtk_text_buffer_delete_interactive() {} ; +void gtk_text_buffer_delete_mark() {} ; +void gtk_text_buffer_delete_mark_by_name() {} ; +void gtk_text_buffer_delete_selection() {} ; +void gtk_text_buffer_end_user_action() {} ; +void gtk_text_buffer_get_bounds() {} ; +void gtk_text_buffer_get_char_count() {} ; +void gtk_text_buffer_get_end_iter() {} ; +void gtk_text_buffer_get_insert() {} ; +void gtk_text_buffer_get_iter_at_child_anchor() {} ; +void gtk_text_buffer_get_iter_at_line() {} ; +void gtk_text_buffer_get_iter_at_line_index() {} ; +void gtk_text_buffer_get_iter_at_line_offset() {} ; +void gtk_text_buffer_get_iter_at_mark() {} ; +void gtk_text_buffer_get_iter_at_offset() {} ; +void gtk_text_buffer_get_line_count() {} ; +void gtk_text_buffer_get_mark() {} ; +void gtk_text_buffer_get_modified() {} ; +void gtk_text_buffer_get_selection_bound() {} ; +void gtk_text_buffer_get_selection_bounds() {} ; +void gtk_text_buffer_get_slice() {} ; +void gtk_text_buffer_get_start_iter() {} ; +void gtk_text_buffer_get_tag_table() {} ; +void gtk_text_buffer_get_text() {} ; +void gtk_text_buffer_get_type() {} ; +void gtk_text_buffer_insert() {} ; +void gtk_text_buffer_insert_at_cursor() {} ; +void gtk_text_buffer_insert_child_anchor() {} ; +void gtk_text_buffer_insert_interactive() {} ; +void gtk_text_buffer_insert_interactive_at_cursor() {} ; +void gtk_text_buffer_insert_pixbuf() {} ; +void gtk_text_buffer_insert_range() {} ; +void gtk_text_buffer_insert_range_interactive() {} ; +void gtk_text_buffer_insert_with_tags() {} ; +void gtk_text_buffer_insert_with_tags_by_name() {} ; +void gtk_text_buffer_move_mark() {} ; +void gtk_text_buffer_move_mark_by_name() {} ; +void gtk_text_buffer_new() {} ; +void gtk_text_buffer_paste_clipboard() {} ; +void gtk_text_buffer_place_cursor() {} ; +void gtk_text_buffer_remove_all_tags() {} ; +void gtk_text_buffer_remove_selection_clipboard() {} ; +void gtk_text_buffer_remove_tag() {} ; +void gtk_text_buffer_remove_tag_by_name() {} ; +void gtk_text_buffer_select_range() {} ; +void gtk_text_buffer_set_modified() {} ; +void gtk_text_buffer_set_text() {} ; +void gtk_text_child_anchor_get_deleted() {} ; +void gtk_text_child_anchor_get_type() {} ; +void gtk_text_child_anchor_get_widgets() {} ; +void gtk_text_child_anchor_new() {} ; +void gtk_text_direction_get_type() {} ; +void gtk_text_iter_backward_char() {} ; +void gtk_text_iter_backward_chars() {} ; +void gtk_text_iter_backward_cursor_position() {} ; +void gtk_text_iter_backward_cursor_positions() {} ; +void gtk_text_iter_backward_find_char() {} ; +void gtk_text_iter_backward_line() {} ; +void gtk_text_iter_backward_lines() {} ; +void gtk_text_iter_backward_search() {} ; +void gtk_text_iter_backward_sentence_start() {} ; +void gtk_text_iter_backward_sentence_starts() {} ; +void gtk_text_iter_backward_to_tag_toggle() {} ; +void gtk_text_iter_backward_visible_cursor_position() {} ; +void gtk_text_iter_backward_visible_cursor_positions() {} ; +void gtk_text_iter_backward_visible_word_start() {} ; +void gtk_text_iter_backward_visible_word_starts() {} ; +void gtk_text_iter_backward_word_start() {} ; +void gtk_text_iter_backward_word_starts() {} ; +void gtk_text_iter_begins_tag() {} ; +void gtk_text_iter_can_insert() {} ; +void gtk_text_iter_compare() {} ; +void gtk_text_iter_copy() {} ; +void gtk_text_iter_editable() {} ; +void gtk_text_iter_ends_line() {} ; +void gtk_text_iter_ends_sentence() {} ; +void gtk_text_iter_ends_tag() {} ; +void gtk_text_iter_ends_word() {} ; +void gtk_text_iter_equal() {} ; +void gtk_text_iter_forward_char() {} ; +void gtk_text_iter_forward_chars() {} ; +void gtk_text_iter_forward_cursor_position() {} ; +void gtk_text_iter_forward_cursor_positions() {} ; +void gtk_text_iter_forward_find_char() {} ; +void gtk_text_iter_forward_line() {} ; +void gtk_text_iter_forward_lines() {} ; +void gtk_text_iter_forward_search() {} ; +void gtk_text_iter_forward_sentence_end() {} ; +void gtk_text_iter_forward_sentence_ends() {} ; +void gtk_text_iter_forward_to_end() {} ; +void gtk_text_iter_forward_to_line_end() {} ; +void gtk_text_iter_forward_to_tag_toggle() {} ; +void gtk_text_iter_forward_visible_cursor_position() {} ; +void gtk_text_iter_forward_visible_cursor_positions() {} ; +void gtk_text_iter_forward_visible_word_end() {} ; +void gtk_text_iter_forward_visible_word_ends() {} ; +void gtk_text_iter_forward_word_end() {} ; +void gtk_text_iter_forward_word_ends() {} ; +void gtk_text_iter_free() {} ; +void gtk_text_iter_get_attributes() {} ; +void gtk_text_iter_get_buffer() {} ; +void gtk_text_iter_get_bytes_in_line() {} ; +void gtk_text_iter_get_char() {} ; +void gtk_text_iter_get_chars_in_line() {} ; +void gtk_text_iter_get_child_anchor() {} ; +void gtk_text_iter_get_language() {} ; +void gtk_text_iter_get_line() {} ; +void gtk_text_iter_get_line_index() {} ; +void gtk_text_iter_get_line_offset() {} ; +void gtk_text_iter_get_marks() {} ; +void gtk_text_iter_get_offset() {} ; +void gtk_text_iter_get_pixbuf() {} ; +void gtk_text_iter_get_slice() {} ; +void gtk_text_iter_get_tags() {} ; +void gtk_text_iter_get_text() {} ; +void gtk_text_iter_get_toggled_tags() {} ; +void gtk_text_iter_get_type() {} ; +void gtk_text_iter_get_visible_line_index() {} ; +void gtk_text_iter_get_visible_line_offset() {} ; +void gtk_text_iter_get_visible_slice() {} ; +void gtk_text_iter_get_visible_text() {} ; +void gtk_text_iter_has_tag() {} ; +void gtk_text_iter_in_range() {} ; +void gtk_text_iter_inside_sentence() {} ; +void gtk_text_iter_inside_word() {} ; +void gtk_text_iter_is_cursor_position() {} ; +void gtk_text_iter_is_end() {} ; +void gtk_text_iter_is_start() {} ; +void gtk_text_iter_order() {} ; +void gtk_text_iter_set_line() {} ; +void gtk_text_iter_set_line_index() {} ; +void gtk_text_iter_set_line_offset() {} ; +void gtk_text_iter_set_offset() {} ; +void gtk_text_iter_set_visible_line_index() {} ; +void gtk_text_iter_set_visible_line_offset() {} ; +void gtk_text_iter_starts_line() {} ; +void gtk_text_iter_starts_sentence() {} ; +void gtk_text_iter_starts_word() {} ; +void gtk_text_iter_toggles_tag() {} ; +void gtk_text_mark_get_buffer() {} ; +void gtk_text_mark_get_deleted() {} ; +void gtk_text_mark_get_left_gravity() {} ; +void gtk_text_mark_get_name() {} ; +void gtk_text_mark_get_type() {} ; +void gtk_text_mark_get_visible() {} ; +void gtk_text_mark_set_visible() {} ; +void gtk_text_search_flags_get_type() {} ; +void gtk_text_tag_event() {} ; +void gtk_text_tag_get_priority() {} ; +void gtk_text_tag_get_type() {} ; +void gtk_text_tag_new() {} ; +void gtk_text_tag_set_priority() {} ; +void gtk_text_tag_table_add() {} ; +void gtk_text_tag_table_foreach() {} ; +void gtk_text_tag_table_get_size() {} ; +void gtk_text_tag_table_get_type() {} ; +void gtk_text_tag_table_lookup() {} ; +void gtk_text_tag_table_new() {} ; +void gtk_text_tag_table_remove() {} ; +void gtk_text_view_add_child_at_anchor() {} ; +void gtk_text_view_add_child_in_window() {} ; +void gtk_text_view_backward_display_line() {} ; +void gtk_text_view_backward_display_line_start() {} ; +void gtk_text_view_buffer_to_window_coords() {} ; +void gtk_text_view_forward_display_line() {} ; +void gtk_text_view_forward_display_line_end() {} ; +void gtk_text_view_get_accepts_tab() {} ; +void gtk_text_view_get_border_window_size() {} ; +void gtk_text_view_get_buffer() {} ; +void gtk_text_view_get_cursor_visible() {} ; +void gtk_text_view_get_default_attributes() {} ; +void gtk_text_view_get_editable() {} ; +void gtk_text_view_get_indent() {} ; +void gtk_text_view_get_iter_at_location() {} ; +void gtk_text_view_get_iter_at_position() {} ; +void gtk_text_view_get_iter_location() {} ; +void gtk_text_view_get_justification() {} ; +void gtk_text_view_get_left_margin() {} ; +void gtk_text_view_get_line_at_y() {} ; +void gtk_text_view_get_line_yrange() {} ; +void gtk_text_view_get_overwrite() {} ; +void gtk_text_view_get_pixels_above_lines() {} ; +void gtk_text_view_get_pixels_below_lines() {} ; +void gtk_text_view_get_pixels_inside_wrap() {} ; +void gtk_text_view_get_right_margin() {} ; +void gtk_text_view_get_tabs() {} ; +void gtk_text_view_get_type() {} ; +void gtk_text_view_get_visible_rect() {} ; +void gtk_text_view_get_window() {} ; +void gtk_text_view_get_window_type() {} ; +void gtk_text_view_get_wrap_mode() {} ; +void gtk_text_view_move_child() {} ; +void gtk_text_view_move_mark_onscreen() {} ; +void gtk_text_view_move_visually() {} ; +void gtk_text_view_new() {} ; +void gtk_text_view_new_with_buffer() {} ; +void gtk_text_view_place_cursor_onscreen() {} ; +void gtk_text_view_scroll_mark_onscreen() {} ; +void gtk_text_view_scroll_to_iter() {} ; +void gtk_text_view_scroll_to_mark() {} ; +void gtk_text_view_set_accepts_tab() {} ; +void gtk_text_view_set_border_window_size() {} ; +void gtk_text_view_set_buffer() {} ; +void gtk_text_view_set_cursor_visible() {} ; +void gtk_text_view_set_editable() {} ; +void gtk_text_view_set_indent() {} ; +void gtk_text_view_set_justification() {} ; +void gtk_text_view_set_left_margin() {} ; +void gtk_text_view_set_overwrite() {} ; +void gtk_text_view_set_pixels_above_lines() {} ; +void gtk_text_view_set_pixels_below_lines() {} ; +void gtk_text_view_set_pixels_inside_wrap() {} ; +void gtk_text_view_set_right_margin() {} ; +void gtk_text_view_set_tabs() {} ; +void gtk_text_view_set_wrap_mode() {} ; +void gtk_text_view_starts_display_line() {} ; +void gtk_text_view_window_to_buffer_coords() {} ; +void gtk_text_window_type_get_type() {} ; +void gtk_toggle_action_get_active() {} ; +void gtk_toggle_action_get_draw_as_radio() {} ; +void gtk_toggle_action_get_type() {} ; +void gtk_toggle_action_new() {} ; +void gtk_toggle_action_set_active() {} ; +void gtk_toggle_action_set_draw_as_radio() {} ; +void gtk_toggle_action_toggled() {} ; +void gtk_toggle_button_get_active() {} ; +void gtk_toggle_button_get_inconsistent() {} ; +void gtk_toggle_button_get_mode() {} ; +void gtk_toggle_button_get_type() {} ; +void gtk_toggle_button_new() {} ; +void gtk_toggle_button_new_with_label() {} ; +void gtk_toggle_button_new_with_mnemonic() {} ; +void gtk_toggle_button_set_active() {} ; +void gtk_toggle_button_set_inconsistent() {} ; +void gtk_toggle_button_set_mode() {} ; +void gtk_toggle_button_toggled() {} ; +void gtk_toggle_tool_button_get_active() {} ; +void gtk_toggle_tool_button_get_type() {} ; +void gtk_toggle_tool_button_new() {} ; +void gtk_toggle_tool_button_new_from_stock() {} ; +void gtk_toggle_tool_button_set_active() {} ; +void gtk_tool_button_get_icon_widget() {} ; +void gtk_tool_button_get_label() {} ; +void gtk_tool_button_get_label_widget() {} ; +void gtk_tool_button_get_stock_id() {} ; +void gtk_tool_button_get_type() {} ; +void gtk_tool_button_get_use_underline() {} ; +void gtk_tool_button_new() {} ; +void gtk_tool_button_new_from_stock() {} ; +void gtk_tool_button_set_icon_widget() {} ; +void gtk_tool_button_set_label() {} ; +void gtk_tool_button_set_label_widget() {} ; +void gtk_tool_button_set_stock_id() {} ; +void gtk_tool_button_set_use_underline() {} ; +void gtk_tool_item_get_expand() {} ; +void gtk_tool_item_get_homogeneous() {} ; +void gtk_tool_item_get_icon_size() {} ; +void gtk_tool_item_get_is_important() {} ; +void gtk_tool_item_get_orientation() {} ; +void gtk_tool_item_get_proxy_menu_item() {} ; +void gtk_tool_item_get_relief_style() {} ; +void gtk_tool_item_get_toolbar_style() {} ; +void gtk_tool_item_get_type() {} ; +void gtk_tool_item_get_use_drag_window() {} ; +void gtk_tool_item_get_visible_horizontal() {} ; +void gtk_tool_item_get_visible_vertical() {} ; +void gtk_tool_item_new() {} ; +void gtk_tool_item_rebuild_menu() {} ; +void gtk_tool_item_retrieve_proxy_menu_item() {} ; +void gtk_tool_item_set_expand() {} ; +void gtk_tool_item_set_homogeneous() {} ; +void gtk_tool_item_set_is_important() {} ; +void gtk_tool_item_set_proxy_menu_item() {} ; +void gtk_tool_item_set_tooltip() {} ; +void gtk_tool_item_set_use_drag_window() {} ; +void gtk_tool_item_set_visible_horizontal() {} ; +void gtk_tool_item_set_visible_vertical() {} ; +void gtk_toolbar_child_type_get_type() {} ; +void gtk_toolbar_get_drop_index() {} ; +void gtk_toolbar_get_icon_size() {} ; +void gtk_toolbar_get_item_index() {} ; +void gtk_toolbar_get_n_items() {} ; +void gtk_toolbar_get_nth_item() {} ; +void gtk_toolbar_get_orientation() {} ; +void gtk_toolbar_get_relief_style() {} ; +void gtk_toolbar_get_show_arrow() {} ; +void gtk_toolbar_get_style() {} ; +void gtk_toolbar_get_tooltips() {} ; +void gtk_toolbar_get_type() {} ; +void gtk_toolbar_insert() {} ; +void gtk_toolbar_new() {} ; +void gtk_toolbar_set_drop_highlight_item() {} ; +void gtk_toolbar_set_orientation() {} ; +void gtk_toolbar_set_show_arrow() {} ; +void gtk_toolbar_set_style() {} ; +void gtk_toolbar_set_tooltips() {} ; +void gtk_toolbar_space_style_get_type() {} ; +void gtk_toolbar_style_get_type() {} ; +void gtk_toolbar_unset_style() {} ; +void gtk_tooltips_data_get() {} ; +void gtk_tooltips_disable() {} ; +void gtk_tooltips_enable() {} ; +void gtk_tooltips_force_window() {} ; +void gtk_tooltips_get_info_from_tip_window() {} ; +void gtk_tooltips_get_type() {} ; +void gtk_tooltips_new() {} ; +void gtk_tooltips_set_tip() {} ; +void gtk_tree_drag_dest_drag_data_received() {} ; +void gtk_tree_drag_dest_get_type() {} ; +void gtk_tree_drag_dest_row_drop_possible() {} ; +void gtk_tree_drag_source_drag_data_delete() {} ; +void gtk_tree_drag_source_drag_data_get() {} ; +void gtk_tree_drag_source_get_type() {} ; +void gtk_tree_drag_source_row_draggable() {} ; +void gtk_tree_get_row_drag_data() {} ; +void gtk_tree_iter_copy() {} ; +void gtk_tree_iter_free() {} ; +void gtk_tree_iter_get_type() {} ; +void gtk_tree_model_filter_clear_cache() {} ; +void gtk_tree_model_filter_convert_child_iter_to_iter() {} ; +void gtk_tree_model_filter_convert_child_path_to_path() {} ; +void gtk_tree_model_filter_convert_iter_to_child_iter() {} ; +void gtk_tree_model_filter_convert_path_to_child_path() {} ; +void gtk_tree_model_filter_get_model() {} ; +void gtk_tree_model_filter_get_type() {} ; +void gtk_tree_model_filter_new() {} ; +void gtk_tree_model_filter_refilter() {} ; +void gtk_tree_model_filter_set_modify_func() {} ; +void gtk_tree_model_filter_set_visible_column() {} ; +void gtk_tree_model_filter_set_visible_func() {} ; +void gtk_tree_model_flags_get_type() {} ; +void gtk_tree_model_foreach() {} ; +void gtk_tree_model_get() {} ; +void gtk_tree_model_get_column_type() {} ; +void gtk_tree_model_get_flags() {} ; +void gtk_tree_model_get_iter() {} ; +void gtk_tree_model_get_iter_first() {} ; +void gtk_tree_model_get_iter_from_string() {} ; +void gtk_tree_model_get_n_columns() {} ; +void gtk_tree_model_get_path() {} ; +void gtk_tree_model_get_string_from_iter() {} ; +void gtk_tree_model_get_type() {} ; +void gtk_tree_model_get_valist() {} ; +void gtk_tree_model_get_value() {} ; +void gtk_tree_model_iter_children() {} ; +void gtk_tree_model_iter_has_child() {} ; +void gtk_tree_model_iter_n_children() {} ; +void gtk_tree_model_iter_next() {} ; +void gtk_tree_model_iter_nth_child() {} ; +void gtk_tree_model_iter_parent() {} ; +void gtk_tree_model_ref_node() {} ; +void gtk_tree_model_row_changed() {} ; +void gtk_tree_model_row_deleted() {} ; +void gtk_tree_model_row_has_child_toggled() {} ; +void gtk_tree_model_row_inserted() {} ; +void gtk_tree_model_rows_reordered() {} ; +void gtk_tree_model_sort_clear_cache() {} ; +void gtk_tree_model_sort_convert_child_iter_to_iter() {} ; +void gtk_tree_model_sort_convert_child_path_to_path() {} ; +void gtk_tree_model_sort_convert_iter_to_child_iter() {} ; +void gtk_tree_model_sort_convert_path_to_child_path() {} ; +void gtk_tree_model_sort_get_model() {} ; +void gtk_tree_model_sort_get_type() {} ; +void gtk_tree_model_sort_iter_is_valid() {} ; +void gtk_tree_model_sort_new_with_model() {} ; +void gtk_tree_model_sort_reset_default_sort_func() {} ; +void gtk_tree_model_unref_node() {} ; +void gtk_tree_path_append_index() {} ; +void gtk_tree_path_compare() {} ; +void gtk_tree_path_copy() {} ; +void gtk_tree_path_down() {} ; +void gtk_tree_path_free() {} ; +void gtk_tree_path_get_depth() {} ; +void gtk_tree_path_get_indices() {} ; +void gtk_tree_path_get_type() {} ; +void gtk_tree_path_is_ancestor() {} ; +void gtk_tree_path_is_descendant() {} ; +void gtk_tree_path_new() {} ; +void gtk_tree_path_new_first() {} ; +void gtk_tree_path_new_from_indices() {} ; +void gtk_tree_path_new_from_string() {} ; +void gtk_tree_path_next() {} ; +void gtk_tree_path_prepend_index() {} ; +void gtk_tree_path_prev() {} ; +void gtk_tree_path_to_string() {} ; +void gtk_tree_path_up() {} ; +void gtk_tree_row_reference_copy() {} ; +void gtk_tree_row_reference_deleted() {} ; +void gtk_tree_row_reference_free() {} ; +void gtk_tree_row_reference_get_path() {} ; +void gtk_tree_row_reference_get_type() {} ; +void gtk_tree_row_reference_inserted() {} ; +void gtk_tree_row_reference_new() {} ; +void gtk_tree_row_reference_new_proxy() {} ; +void gtk_tree_row_reference_reordered() {} ; +void gtk_tree_row_reference_valid() {} ; +void gtk_tree_selection_count_selected_rows() {} ; +void gtk_tree_selection_get_mode() {} ; +void gtk_tree_selection_get_selected() {} ; +void gtk_tree_selection_get_selected_rows() {} ; +void gtk_tree_selection_get_tree_view() {} ; +void gtk_tree_selection_get_type() {} ; +void gtk_tree_selection_get_user_data() {} ; +void gtk_tree_selection_iter_is_selected() {} ; +void gtk_tree_selection_path_is_selected() {} ; +void gtk_tree_selection_select_all() {} ; +void gtk_tree_selection_select_iter() {} ; +void gtk_tree_selection_select_path() {} ; +void gtk_tree_selection_select_range() {} ; +void gtk_tree_selection_selected_foreach() {} ; +void gtk_tree_selection_set_mode() {} ; +void gtk_tree_selection_set_select_function() {} ; +void gtk_tree_selection_unselect_all() {} ; +void gtk_tree_selection_unselect_iter() {} ; +void gtk_tree_selection_unselect_path() {} ; +void gtk_tree_selection_unselect_range() {} ; +void gtk_tree_set_row_drag_data() {} ; +void gtk_tree_sortable_get_sort_column_id() {} ; +void gtk_tree_sortable_get_type() {} ; +void gtk_tree_sortable_has_default_sort_func() {} ; +void gtk_tree_sortable_set_default_sort_func() {} ; +void gtk_tree_sortable_set_sort_column_id() {} ; +void gtk_tree_sortable_set_sort_func() {} ; +void gtk_tree_sortable_sort_column_changed() {} ; +void gtk_tree_store_append() {} ; +void gtk_tree_store_clear() {} ; +void gtk_tree_store_get_type() {} ; +void gtk_tree_store_insert() {} ; +void gtk_tree_store_insert_after() {} ; +void gtk_tree_store_insert_before() {} ; +void gtk_tree_store_is_ancestor() {} ; +void gtk_tree_store_iter_depth() {} ; +void gtk_tree_store_iter_is_valid() {} ; +void gtk_tree_store_move_after() {} ; +void gtk_tree_store_move_before() {} ; +void gtk_tree_store_new() {} ; +void gtk_tree_store_newv() {} ; +void gtk_tree_store_prepend() {} ; +void gtk_tree_store_remove() {} ; +void gtk_tree_store_reorder() {} ; +void gtk_tree_store_set() {} ; +void gtk_tree_store_set_column_types() {} ; +void gtk_tree_store_set_valist() {} ; +void gtk_tree_store_set_value() {} ; +void gtk_tree_store_swap() {} ; +void gtk_tree_view_append_column() {} ; +void gtk_tree_view_collapse_all() {} ; +void gtk_tree_view_collapse_row() {} ; +void gtk_tree_view_column_add_attribute() {} ; +void gtk_tree_view_column_cell_get_position() {} ; +void gtk_tree_view_column_cell_get_size() {} ; +void gtk_tree_view_column_cell_is_visible() {} ; +void gtk_tree_view_column_cell_set_cell_data() {} ; +void gtk_tree_view_column_clear() {} ; +void gtk_tree_view_column_clear_attributes() {} ; +void gtk_tree_view_column_clicked() {} ; +void gtk_tree_view_column_focus_cell() {} ; +void gtk_tree_view_column_get_alignment() {} ; +void gtk_tree_view_column_get_cell_renderers() {} ; +void gtk_tree_view_column_get_clickable() {} ; +void gtk_tree_view_column_get_expand() {} ; +void gtk_tree_view_column_get_fixed_width() {} ; +void gtk_tree_view_column_get_max_width() {} ; +void gtk_tree_view_column_get_min_width() {} ; +void gtk_tree_view_column_get_reorderable() {} ; +void gtk_tree_view_column_get_resizable() {} ; +void gtk_tree_view_column_get_sizing() {} ; +void gtk_tree_view_column_get_sort_column_id() {} ; +void gtk_tree_view_column_get_sort_indicator() {} ; +void gtk_tree_view_column_get_sort_order() {} ; +void gtk_tree_view_column_get_spacing() {} ; +void gtk_tree_view_column_get_title() {} ; +void gtk_tree_view_column_get_type() {} ; +void gtk_tree_view_column_get_visible() {} ; +void gtk_tree_view_column_get_widget() {} ; +void gtk_tree_view_column_get_width() {} ; +void gtk_tree_view_column_new() {} ; +void gtk_tree_view_column_new_with_attributes() {} ; +void gtk_tree_view_column_pack_end() {} ; +void gtk_tree_view_column_pack_start() {} ; +void gtk_tree_view_column_set_alignment() {} ; +void gtk_tree_view_column_set_attributes() {} ; +void gtk_tree_view_column_set_cell_data_func() {} ; +void gtk_tree_view_column_set_clickable() {} ; +void gtk_tree_view_column_set_expand() {} ; +void gtk_tree_view_column_set_fixed_width() {} ; +void gtk_tree_view_column_set_max_width() {} ; +void gtk_tree_view_column_set_min_width() {} ; +void gtk_tree_view_column_set_reorderable() {} ; +void gtk_tree_view_column_set_resizable() {} ; +void gtk_tree_view_column_set_sizing() {} ; +void gtk_tree_view_column_set_sort_column_id() {} ; +void gtk_tree_view_column_set_sort_indicator() {} ; +void gtk_tree_view_column_set_sort_order() {} ; +void gtk_tree_view_column_set_spacing() {} ; +void gtk_tree_view_column_set_title() {} ; +void gtk_tree_view_column_set_visible() {} ; +void gtk_tree_view_column_set_widget() {} ; +void gtk_tree_view_column_sizing_get_type() {} ; +void gtk_tree_view_columns_autosize() {} ; +void gtk_tree_view_create_row_drag_icon() {} ; +void gtk_tree_view_drop_position_get_type() {} ; +void gtk_tree_view_enable_model_drag_dest() {} ; +void gtk_tree_view_enable_model_drag_source() {} ; +void gtk_tree_view_expand_all() {} ; +void gtk_tree_view_expand_row() {} ; +void gtk_tree_view_expand_to_path() {} ; +void gtk_tree_view_get_background_area() {} ; +void gtk_tree_view_get_bin_window() {} ; +void gtk_tree_view_get_cell_area() {} ; +void gtk_tree_view_get_column() {} ; +void gtk_tree_view_get_columns() {} ; +void gtk_tree_view_get_cursor() {} ; +void gtk_tree_view_get_dest_row_at_pos() {} ; +void gtk_tree_view_get_drag_dest_row() {} ; +void gtk_tree_view_get_enable_search() {} ; +void gtk_tree_view_get_expander_column() {} ; +void gtk_tree_view_get_fixed_height_mode() {} ; +void gtk_tree_view_get_hadjustment() {} ; +void gtk_tree_view_get_headers_visible() {} ; +void gtk_tree_view_get_hover_expand() {} ; +void gtk_tree_view_get_hover_selection() {} ; +void gtk_tree_view_get_model() {} ; +void gtk_tree_view_get_path_at_pos() {} ; +void gtk_tree_view_get_reorderable() {} ; +void gtk_tree_view_get_row_separator_func() {} ; +void gtk_tree_view_get_rules_hint() {} ; +void gtk_tree_view_get_search_column() {} ; +void gtk_tree_view_get_search_equal_func() {} ; +void gtk_tree_view_get_selection() {} ; +void gtk_tree_view_get_type() {} ; +void gtk_tree_view_get_vadjustment() {} ; +void gtk_tree_view_get_visible_rect() {} ; +void gtk_tree_view_insert_column() {} ; +void gtk_tree_view_insert_column_with_attributes() {} ; +void gtk_tree_view_insert_column_with_data_func() {} ; +void gtk_tree_view_map_expanded_rows() {} ; +void gtk_tree_view_mode_get_type() {} ; +void gtk_tree_view_move_column_after() {} ; +void gtk_tree_view_new() {} ; +void gtk_tree_view_new_with_model() {} ; +void gtk_tree_view_remove_column() {} ; +void gtk_tree_view_row_activated() {} ; +void gtk_tree_view_row_expanded() {} ; +void gtk_tree_view_scroll_to_cell() {} ; +void gtk_tree_view_scroll_to_point() {} ; +void gtk_tree_view_set_column_drag_function() {} ; +void gtk_tree_view_set_cursor() {} ; +void gtk_tree_view_set_cursor_on_cell() {} ; +void gtk_tree_view_set_destroy_count_func() {} ; +void gtk_tree_view_set_drag_dest_row() {} ; +void gtk_tree_view_set_enable_search() {} ; +void gtk_tree_view_set_expander_column() {} ; +void gtk_tree_view_set_fixed_height_mode() {} ; +void gtk_tree_view_set_hadjustment() {} ; +void gtk_tree_view_set_headers_clickable() {} ; +void gtk_tree_view_set_headers_visible() {} ; +void gtk_tree_view_set_hover_expand() {} ; +void gtk_tree_view_set_hover_selection() {} ; +void gtk_tree_view_set_model() {} ; +void gtk_tree_view_set_reorderable() {} ; +void gtk_tree_view_set_row_separator_func() {} ; +void gtk_tree_view_set_rules_hint() {} ; +void gtk_tree_view_set_search_column() {} ; +void gtk_tree_view_set_search_equal_func() {} ; +void gtk_tree_view_set_vadjustment() {} ; +void gtk_tree_view_tree_to_widget_coords() {} ; +void gtk_tree_view_unset_rows_drag_dest() {} ; +void gtk_tree_view_unset_rows_drag_source() {} ; +void gtk_tree_view_widget_to_tree_coords() {} ; +void gtk_true() {} ; +void gtk_type_class() {} ; +void gtk_ui_manager_add_ui() {} ; +void gtk_ui_manager_add_ui_from_file() {} ; +void gtk_ui_manager_add_ui_from_string() {} ; +void gtk_ui_manager_ensure_update() {} ; +void gtk_ui_manager_get_accel_group() {} ; +void gtk_ui_manager_get_action() {} ; +void gtk_ui_manager_get_action_groups() {} ; +void gtk_ui_manager_get_add_tearoffs() {} ; +void gtk_ui_manager_get_toplevels() {} ; +void gtk_ui_manager_get_type() {} ; +void gtk_ui_manager_get_ui() {} ; +void gtk_ui_manager_get_widget() {} ; +void gtk_ui_manager_insert_action_group() {} ; +void gtk_ui_manager_item_type_get_type() {} ; +void gtk_ui_manager_new() {} ; +void gtk_ui_manager_new_merge_id() {} ; +void gtk_ui_manager_remove_action_group() {} ; +void gtk_ui_manager_remove_ui() {} ; +void gtk_ui_manager_set_add_tearoffs() {} ; +void gtk_update_type_get_type() {} ; +void gtk_vbox_get_type() {} ; +void gtk_vbox_new() {} ; +void gtk_vbutton_box_get_type() {} ; +void gtk_vbutton_box_new() {} ; +void gtk_viewport_get_hadjustment() {} ; +void gtk_viewport_get_shadow_type() {} ; +void gtk_viewport_get_type() {} ; +void gtk_viewport_get_vadjustment() {} ; +void gtk_viewport_new() {} ; +void gtk_viewport_set_hadjustment() {} ; +void gtk_viewport_set_shadow_type() {} ; +void gtk_viewport_set_vadjustment() {} ; +void gtk_visibility_get_type() {} ; +void gtk_vpaned_get_type() {} ; +void gtk_vpaned_new() {} ; +void gtk_vruler_get_type() {} ; +void gtk_vruler_new() {} ; +void gtk_vscale_get_type() {} ; +void gtk_vscale_new() {} ; +void gtk_vscale_new_with_range() {} ; +void gtk_vscrollbar_get_type() {} ; +void gtk_vscrollbar_new() {} ; +void gtk_vseparator_get_type() {} ; +void gtk_vseparator_new() {} ; +void gtk_widget_activate() {} ; +void gtk_widget_add_accelerator() {} ; +void gtk_widget_add_events() {} ; +void gtk_widget_add_mnemonic_label() {} ; +void gtk_widget_can_activate_accel() {} ; +void gtk_widget_child_focus() {} ; +void gtk_widget_child_notify() {} ; +void gtk_widget_class_find_style_property() {} ; +void gtk_widget_class_install_style_property() {} ; +void gtk_widget_class_install_style_property_parser() {} ; +void gtk_widget_class_list_style_properties() {} ; +void gtk_widget_class_path() {} ; +void gtk_widget_create_pango_context() {} ; +void gtk_widget_create_pango_layout() {} ; +void gtk_widget_destroy() {} ; +void gtk_widget_destroyed() {} ; +void gtk_widget_ensure_style() {} ; +void gtk_widget_event() {} ; +void gtk_widget_flags_get_type() {} ; +void gtk_widget_freeze_child_notify() {} ; +void gtk_widget_get_accessible() {} ; +void gtk_widget_get_ancestor() {} ; +void gtk_widget_get_child_requisition() {} ; +void gtk_widget_get_child_visible() {} ; +void gtk_widget_get_clipboard() {} ; +void gtk_widget_get_colormap() {} ; +void gtk_widget_get_composite_name() {} ; +void gtk_widget_get_default_colormap() {} ; +void gtk_widget_get_default_direction() {} ; +void gtk_widget_get_default_style() {} ; +void gtk_widget_get_default_visual() {} ; +void gtk_widget_get_direction() {} ; +void gtk_widget_get_display() {} ; +void gtk_widget_get_events() {} ; +void gtk_widget_get_extension_events() {} ; +void gtk_widget_get_modifier_style() {} ; +void gtk_widget_get_name() {} ; +void gtk_widget_get_no_show_all() {} ; +void gtk_widget_get_pango_context() {} ; +void gtk_widget_get_parent() {} ; +void gtk_widget_get_parent_window() {} ; +void gtk_widget_get_pointer() {} ; +void gtk_widget_get_root_window() {} ; +void gtk_widget_get_screen() {} ; +void gtk_widget_get_settings() {} ; +void gtk_widget_get_size_request() {} ; +void gtk_widget_get_style() {} ; +void gtk_widget_get_toplevel() {} ; +void gtk_widget_get_type() {} ; +void gtk_widget_get_visual() {} ; +void gtk_widget_grab_default() {} ; +void gtk_widget_grab_focus() {} ; +void gtk_widget_has_screen() {} ; +void gtk_widget_help_type_get_type() {} ; +void gtk_widget_hide() {} ; +void gtk_widget_hide_all() {} ; +void gtk_widget_hide_on_delete() {} ; +void gtk_widget_intersect() {} ; +void gtk_widget_is_ancestor() {} ; +void gtk_widget_is_focus() {} ; +void gtk_widget_list_accel_closures() {} ; +void gtk_widget_list_mnemonic_labels() {} ; +void gtk_widget_map() {} ; +void gtk_widget_mnemonic_activate() {} ; +void gtk_widget_modify_base() {} ; +void gtk_widget_modify_bg() {} ; +void gtk_widget_modify_fg() {} ; +void gtk_widget_modify_font() {} ; +void gtk_widget_modify_style() {} ; +void gtk_widget_modify_text() {} ; +void gtk_widget_new() {} ; +void gtk_widget_path() {} ; +void gtk_widget_pop_colormap() {} ; +void gtk_widget_pop_composite_child() {} ; +void gtk_widget_push_colormap() {} ; +void gtk_widget_push_composite_child() {} ; +void gtk_widget_queue_draw() {} ; +void gtk_widget_queue_draw_area() {} ; +void gtk_widget_queue_resize() {} ; +void gtk_widget_queue_resize_no_redraw() {} ; +void gtk_widget_realize() {} ; +void gtk_widget_ref() {} ; +void gtk_widget_region_intersect() {} ; +void gtk_widget_remove_accelerator() {} ; +void gtk_widget_remove_mnemonic_label() {} ; +void gtk_widget_render_icon() {} ; +void gtk_widget_reparent() {} ; +void gtk_widget_reset_rc_styles() {} ; +void gtk_widget_reset_shapes() {} ; +void gtk_widget_send_expose() {} ; +void gtk_widget_set_accel_path() {} ; +void gtk_widget_set_app_paintable() {} ; +void gtk_widget_set_child_visible() {} ; +void gtk_widget_set_colormap() {} ; +void gtk_widget_set_composite_name() {} ; +void gtk_widget_set_default_colormap() {} ; +void gtk_widget_set_default_direction() {} ; +void gtk_widget_set_direction() {} ; +void gtk_widget_set_double_buffered() {} ; +void gtk_widget_set_events() {} ; +void gtk_widget_set_extension_events() {} ; +void gtk_widget_set_name() {} ; +void gtk_widget_set_no_show_all() {} ; +void gtk_widget_set_parent() {} ; +void gtk_widget_set_parent_window() {} ; +void gtk_widget_set_redraw_on_allocate() {} ; +void gtk_widget_set_scroll_adjustments() {} ; +void gtk_widget_set_sensitive() {} ; +void gtk_widget_set_size_request() {} ; +void gtk_widget_set_state() {} ; +void gtk_widget_set_style() {} ; +void gtk_widget_shape_combine_mask() {} ; +void gtk_widget_show() {} ; +void gtk_widget_show_all() {} ; +void gtk_widget_show_now() {} ; +void gtk_widget_size_allocate() {} ; +void gtk_widget_size_request() {} ; +void gtk_widget_style_get() {} ; +void gtk_widget_style_get_property() {} ; +void gtk_widget_style_get_valist() {} ; +void gtk_widget_thaw_child_notify() {} ; +void gtk_widget_translate_coordinates() {} ; +void gtk_widget_unmap() {} ; +void gtk_widget_unparent() {} ; +void gtk_widget_unrealize() {} ; +void gtk_widget_unref() {} ; +void gtk_window_activate_default() {} ; +void gtk_window_activate_focus() {} ; +void gtk_window_activate_key() {} ; +void gtk_window_add_accel_group() {} ; +void gtk_window_add_embedded_xid() {} ; +void gtk_window_add_mnemonic() {} ; +void gtk_window_begin_move_drag() {} ; +void gtk_window_begin_resize_drag() {} ; +void gtk_window_deiconify() {} ; +void gtk_window_fullscreen() {} ; +void gtk_window_get_accept_focus() {} ; +void gtk_window_get_decorated() {} ; +void gtk_window_get_default_icon_list() {} ; +void gtk_window_get_default_size() {} ; +void gtk_window_get_destroy_with_parent() {} ; +void gtk_window_get_focus() {} ; +void gtk_window_get_focus_on_map() {} ; +void gtk_window_get_frame_dimensions() {} ; +void gtk_window_get_gravity() {} ; +void gtk_window_get_has_frame() {} ; +void gtk_window_get_icon() {} ; +void gtk_window_get_icon_list() {} ; +void gtk_window_get_icon_name() {} ; +void gtk_window_get_mnemonic_modifier() {} ; +void gtk_window_get_modal() {} ; +void gtk_window_get_position() {} ; +void gtk_window_get_resizable() {} ; +void gtk_window_get_role() {} ; +void gtk_window_get_screen() {} ; +void gtk_window_get_size() {} ; +void gtk_window_get_skip_pager_hint() {} ; +void gtk_window_get_skip_taskbar_hint() {} ; +void gtk_window_get_title() {} ; +void gtk_window_get_transient_for() {} ; +void gtk_window_get_type() {} ; +void gtk_window_get_type_hint() {} ; +void gtk_window_group_add_window() {} ; +void gtk_window_group_get_type() {} ; +void gtk_window_group_new() {} ; +void gtk_window_group_remove_window() {} ; +void gtk_window_has_toplevel_focus() {} ; +void gtk_window_iconify() {} ; +void gtk_window_is_active() {} ; +void gtk_window_list_toplevels() {} ; +void gtk_window_maximize() {} ; +void gtk_window_mnemonic_activate() {} ; +void gtk_window_move() {} ; +void gtk_window_new() {} ; +void gtk_window_parse_geometry() {} ; +void gtk_window_position_get_type() {} ; +void gtk_window_present() {} ; +void gtk_window_propagate_key_event() {} ; +void gtk_window_remove_accel_group() {} ; +void gtk_window_remove_embedded_xid() {} ; +void gtk_window_remove_mnemonic() {} ; +void gtk_window_reshow_with_initial_size() {} ; +void gtk_window_resize() {} ; +void gtk_window_set_accept_focus() {} ; +void gtk_window_set_auto_startup_notification() {} ; +void gtk_window_set_decorated() {} ; +void gtk_window_set_default() {} ; +void gtk_window_set_default_icon() {} ; +void gtk_window_set_default_icon_from_file() {} ; +void gtk_window_set_default_icon_list() {} ; +void gtk_window_set_default_icon_name() {} ; +void gtk_window_set_default_size() {} ; +void gtk_window_set_destroy_with_parent() {} ; +void gtk_window_set_focus() {} ; +void gtk_window_set_focus_on_map() {} ; +void gtk_window_set_frame_dimensions() {} ; +void gtk_window_set_geometry_hints() {} ; +void gtk_window_set_gravity() {} ; +void gtk_window_set_has_frame() {} ; +void gtk_window_set_icon() {} ; +void gtk_window_set_icon_from_file() {} ; +void gtk_window_set_icon_list() {} ; +void gtk_window_set_icon_name() {} ; +void gtk_window_set_keep_above() {} ; +void gtk_window_set_keep_below() {} ; +void gtk_window_set_mnemonic_modifier() {} ; +void gtk_window_set_modal() {} ; +void gtk_window_set_position() {} ; +void gtk_window_set_resizable() {} ; +void gtk_window_set_role() {} ; +void gtk_window_set_screen() {} ; +void gtk_window_set_skip_pager_hint() {} ; +void gtk_window_set_skip_taskbar_hint() {} ; +void gtk_window_set_title() {} ; +void gtk_window_set_transient_for() {} ; +void gtk_window_set_type_hint() {} ; +void gtk_window_set_wmclass() {} ; +void gtk_window_stick() {} ; +void gtk_window_type_get_type() {} ; +void gtk_window_unfullscreen() {} ; +void gtk_window_unmaximize() {} ; +void gtk_window_unstick() {} ; +void gtk_wrap_mode_get_type() {} ; +__asm__(".globl gtk_binary_age; .pushsection .data; .type gtk_binary_age,@object; .size gtk_binary_age, 4; gtk_binary_age: .long 0; .popsection"); +__asm__(".globl gtk_debug_flags; .pushsection .data; .type gtk_debug_flags,@object; .size gtk_debug_flags, 4; gtk_debug_flags: .long 0; .popsection"); +__asm__(".globl gtk_interface_age; .pushsection .data; .type gtk_interface_age,@object; .size gtk_interface_age, 4; gtk_interface_age: .long 0; .popsection"); +__asm__(".globl gtk_major_version; .pushsection .data; .type gtk_major_version,@object; .size gtk_major_version, 4; gtk_major_version: .long 0; .popsection"); +__asm__(".globl gtk_micro_version; .pushsection .data; .type gtk_micro_version,@object; .size gtk_micro_version, 4; gtk_micro_version: .long 0; .popsection"); +__asm__(".globl gtk_minor_version; .pushsection .data; .type gtk_minor_version,@object; .size gtk_minor_version, 4; gtk_minor_version: .long 0; .popsection"); diff --git a/lsb-build/stub_libs/libpthread.Version b/lsb-build/stub_libs/libpthread.Version new file mode 100644 index 0000000..4ff30af --- /dev/null +++ b/lsb-build/stub_libs/libpthread.Version @@ -0,0 +1,107 @@ +LSB_DUMMY { __LSB_DUMMY; }; +GLIBC_2.0 { + _pthread_cleanup_pop; + _pthread_cleanup_push; + pthread_attr_destroy; + pthread_attr_getdetachstate; + pthread_attr_getinheritsched; + pthread_attr_getschedparam; + pthread_attr_getschedpolicy; + pthread_attr_getscope; + pthread_attr_setdetachstate; + pthread_attr_setinheritsched; + pthread_attr_setschedparam; + pthread_attr_setschedpolicy; + pthread_attr_setscope; + pthread_cancel; + pthread_condattr_destroy; + pthread_condattr_init; + pthread_detach; + pthread_equal; + pthread_exit; + pthread_getschedparam; + pthread_getspecific; + pthread_join; + pthread_key_create; + pthread_key_delete; + pthread_kill; + pthread_mutex_destroy; + pthread_mutex_init; + pthread_mutex_lock; + pthread_mutex_trylock; + pthread_mutex_unlock; + pthread_mutexattr_destroy; + pthread_mutexattr_init; + pthread_once; + pthread_self; + pthread_setcancelstate; + pthread_setcanceltype; + pthread_setschedparam; + pthread_setspecific; + pthread_sigmask; + pthread_testcancel; +}; +GLIBC_2.1 { + pthread_attr_getguardsize; + pthread_attr_getstackaddr; + pthread_attr_getstacksize; + pthread_attr_init; + pthread_attr_setguardsize; + pthread_attr_setstackaddr; + pthread_attr_setstacksize; + pthread_create; + pthread_getconcurrency; + pthread_mutexattr_gettype; + pthread_mutexattr_settype; + pthread_rwlock_destroy; + pthread_rwlock_init; + pthread_rwlock_rdlock; + pthread_rwlock_tryrdlock; + pthread_rwlock_trywrlock; + pthread_rwlock_unlock; + pthread_rwlock_wrlock; + pthread_rwlockattr_destroy; + pthread_rwlockattr_getpshared; + pthread_rwlockattr_init; + pthread_rwlockattr_setpshared; + pthread_setconcurrency; + sem_destroy; + sem_getvalue; + sem_init; + sem_post; + sem_trywait; + sem_wait; +}; +GLIBC_2.1.1 { + sem_close; + sem_open; + sem_unlink; +}; +GLIBC_2.2 { + lseek64; + open64; + pread; + pread64; + pthread_attr_getstack; + pthread_attr_setstack; + pthread_condattr_getpshared; + pthread_condattr_setpshared; + pthread_mutexattr_getpshared; + pthread_mutexattr_setpshared; + pthread_rwlock_timedrdlock; + pthread_rwlock_timedwrlock; + pwrite; + pwrite64; + sem_timedwait; +}; +GLIBC_2.3.2 { + pthread_cond_broadcast; + pthread_cond_destroy; + pthread_cond_init; + pthread_cond_signal; + pthread_cond_timedwait; + pthread_cond_wait; +}; +GLIBC_2.3.4 { + pthread_setschedprio; +}; diff --git a/lsb-build/stub_libs/libpthread.c b/lsb-build/stub_libs/libpthread.c new file mode 100644 index 0000000..c6f0586 --- /dev/null +++ b/lsb-build/stub_libs/libpthread.c @@ -0,0 +1,94 @@ +void _pthread_cleanup_pop() {} ; +void _pthread_cleanup_push() {} ; +void lseek64() {} ; +void open64() {} ; +void pread() {} ; +void pread64() {} ; +void pthread_attr_destroy() {} ; +void pthread_attr_getdetachstate() {} ; +void pthread_attr_getguardsize() {} ; +void pthread_attr_getinheritsched() {} ; +void pthread_attr_getschedparam() {} ; +void pthread_attr_getschedpolicy() {} ; +void pthread_attr_getscope() {} ; +void pthread_attr_getstack() {} ; +void pthread_attr_getstackaddr() {} ; +void pthread_attr_getstacksize() {} ; +void pthread_attr_init() {} ; +void pthread_attr_setdetachstate() {} ; +void pthread_attr_setguardsize() {} ; +void pthread_attr_setinheritsched() {} ; +void pthread_attr_setschedparam() {} ; +void pthread_attr_setschedpolicy() {} ; +void pthread_attr_setscope() {} ; +void pthread_attr_setstack() {} ; +void pthread_attr_setstackaddr() {} ; +void pthread_attr_setstacksize() {} ; +void pthread_cancel() {} ; +void pthread_cond_broadcast() {} ; +void pthread_cond_destroy() {} ; +void pthread_cond_init() {} ; +void pthread_cond_signal() {} ; +void pthread_cond_timedwait() {} ; +void pthread_cond_wait() {} ; +void pthread_condattr_destroy() {} ; +void pthread_condattr_getpshared() {} ; +void pthread_condattr_init() {} ; +void pthread_condattr_setpshared() {} ; +void pthread_create() {} ; +void pthread_detach() {} ; +void pthread_equal() {} ; +void pthread_exit() {} ; +void pthread_getconcurrency() {} ; +void pthread_getschedparam() {} ; +void pthread_getspecific() {} ; +void pthread_join() {} ; +void pthread_key_create() {} ; +void pthread_key_delete() {} ; +void pthread_kill() {} ; +void pthread_mutex_destroy() {} ; +void pthread_mutex_init() {} ; +void pthread_mutex_lock() {} ; +void pthread_mutex_trylock() {} ; +void pthread_mutex_unlock() {} ; +void pthread_mutexattr_destroy() {} ; +void pthread_mutexattr_getpshared() {} ; +void pthread_mutexattr_gettype() {} ; +void pthread_mutexattr_init() {} ; +void pthread_mutexattr_setpshared() {} ; +void pthread_mutexattr_settype() {} ; +void pthread_once() {} ; +void pthread_rwlock_destroy() {} ; +void pthread_rwlock_init() {} ; +void pthread_rwlock_rdlock() {} ; +void pthread_rwlock_timedrdlock() {} ; +void pthread_rwlock_timedwrlock() {} ; +void pthread_rwlock_tryrdlock() {} ; +void pthread_rwlock_trywrlock() {} ; +void pthread_rwlock_unlock() {} ; +void pthread_rwlock_wrlock() {} ; +void pthread_rwlockattr_destroy() {} ; +void pthread_rwlockattr_getpshared() {} ; +void pthread_rwlockattr_init() {} ; +void pthread_rwlockattr_setpshared() {} ; +void pthread_self() {} ; +void pthread_setcancelstate() {} ; +void pthread_setcanceltype() {} ; +void pthread_setconcurrency() {} ; +void pthread_setschedparam() {} ; +void pthread_setschedprio() {} ; +void pthread_setspecific() {} ; +void pthread_sigmask() {} ; +void pthread_testcancel() {} ; +void pwrite() {} ; +void pwrite64() {} ; +void sem_close() {} ; +void sem_destroy() {} ; +void sem_getvalue() {} ; +void sem_init() {} ; +void sem_open() {} ; +void sem_post() {} ; +void sem_timedwait() {} ; +void sem_trywait() {} ; +void sem_unlink() {} ; +void sem_wait() {} ; diff --git a/npapi/jni.h b/npapi/jni.h new file mode 100644 index 0000000..863075a --- /dev/null +++ b/npapi/jni.h @@ -0,0 +1,1810 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is the Java Runtime Interface. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation and Sun Microsystems, Inc. + * Portions created by the Initial Developer are Copyright (C) 1993-1996 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef JNI_H +#define JNI_H + +#include +#include + +/* jni_md.h contains the machine-dependent typedefs for jbyte, jint + and jlong */ + +#include "jni_md.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * JNI Types + */ + +typedef unsigned char jboolean; +typedef unsigned short jchar; +typedef short jshort; +typedef float jfloat; +typedef double jdouble; + +typedef jint jsize; + +#ifdef __cplusplus + +class _jobject {}; +class _jclass : public _jobject {}; +class _jthrowable : public _jobject {}; +class _jstring : public _jobject {}; +class _jarray : public _jobject {}; +class _jbooleanArray : public _jarray {}; +class _jbyteArray : public _jarray {}; +class _jcharArray : public _jarray {}; +class _jshortArray : public _jarray {}; +class _jintArray : public _jarray {}; +class _jlongArray : public _jarray {}; +class _jfloatArray : public _jarray {}; +class _jdoubleArray : public _jarray {}; +class _jobjectArray : public _jarray {}; + +typedef _jobject *jobject; +typedef _jclass *jclass; +typedef _jthrowable *jthrowable; +typedef _jstring *jstring; +typedef _jarray *jarray; +typedef _jbooleanArray *jbooleanArray; +typedef _jbyteArray *jbyteArray; +typedef _jcharArray *jcharArray; +typedef _jshortArray *jshortArray; +typedef _jintArray *jintArray; +typedef _jlongArray *jlongArray; +typedef _jfloatArray *jfloatArray; +typedef _jdoubleArray *jdoubleArray; +typedef _jobjectArray *jobjectArray; + +#else + +struct _jobject; + +typedef struct _jobject *jobject; +typedef jobject jclass; +typedef jobject jthrowable; +typedef jobject jstring; +typedef jobject jarray; +typedef jarray jbooleanArray; +typedef jarray jbyteArray; +typedef jarray jcharArray; +typedef jarray jshortArray; +typedef jarray jintArray; +typedef jarray jlongArray; +typedef jarray jfloatArray; +typedef jarray jdoubleArray; +typedef jarray jobjectArray; + +#endif + +#if 0 /* moved to jri_md.h */ +typedef jobject jref; /* For transition---not meant to be part of public + API anymore.*/ +#endif + +typedef union jvalue { + jboolean z; + jbyte b; + jchar c; + jshort s; + jint i; + jlong j; + jfloat f; + jdouble d; + jobject l; +} jvalue; + +struct _jfieldID; +typedef struct _jfieldID *jfieldID; + +struct _jmethodID; +typedef struct _jmethodID *jmethodID; + +/* + * jboolean constants + */ + +#define JNI_FALSE 0 +#define JNI_TRUE 1 + +/* + * possible return values for JNI functions. + */ + +#define JNI_OK 0 +#define JNI_ERR (-1) + +/* + * used in ReleaseScalarArrayElements + */ + +#define JNI_COMMIT 1 +#define JNI_ABORT 2 + +/* + * used in RegisterNatives to describe native method name, signature, + * and function pointer. + */ + +typedef struct { + char *name; + char *signature; + void *fnPtr; +} JNINativeMethod; + +/* + * JNI Native Method Interface. + */ + +struct JNINativeInterface_; + +struct JNIEnv_; + +#ifdef __cplusplus +typedef JNIEnv_ JNIEnv; +#else +typedef const struct JNINativeInterface_ *JNIEnv; +#endif + +/* + * JNI Invocation Interface. + */ + +struct JNIInvokeInterface_; + +struct JavaVM_; + +#ifdef __cplusplus +typedef JavaVM_ JavaVM; +#else +typedef const struct JNIInvokeInterface_ *JavaVM; +#endif + +struct JNINativeInterface_ { + void *reserved0; + void *reserved1; + void *reserved2; + + void *reserved3; + jint (JNICALL *GetVersion)(JNIEnv *env); + + jclass (JNICALL *DefineClass) + (JNIEnv *env, const char *name, jobject loader, const jbyte *buf, + jsize len); + jclass (JNICALL *FindClass) + (JNIEnv *env, const char *name); + + void *reserved4; + void *reserved5; + void *reserved6; + + jclass (JNICALL *GetSuperclass) + (JNIEnv *env, jclass sub); + jboolean (JNICALL *IsAssignableFrom) + (JNIEnv *env, jclass sub, jclass sup); + void *reserved7; + + + jint (JNICALL *Throw) + (JNIEnv *env, jthrowable obj); + jint (JNICALL *ThrowNew) + (JNIEnv *env, jclass clazz, const char *msg); + jthrowable (JNICALL *ExceptionOccurred) + (JNIEnv *env); + void (JNICALL *ExceptionDescribe) + (JNIEnv *env); + void (JNICALL *ExceptionClear) + (JNIEnv *env); + void (JNICALL *FatalError) + (JNIEnv *env, const char *msg); + void *reserved8; + void *reserved9; + + jobject (JNICALL *NewGlobalRef) + (JNIEnv *env, jobject lobj); + void (JNICALL *DeleteGlobalRef) + (JNIEnv *env, jobject gref); + void (JNICALL *DeleteLocalRef) + (JNIEnv *env, jobject obj); + jboolean (JNICALL *IsSameObject) + (JNIEnv *env, jobject obj1, jobject obj2); + void *reserved10; + void *reserved11; + + jobject (JNICALL *AllocObject) + (JNIEnv *env, jclass clazz); + jobject (JNICALL *NewObject) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jobject (JNICALL *NewObjectV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jobject (JNICALL *NewObjectA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jclass (JNICALL *GetObjectClass) + (JNIEnv *env, jobject obj); + jboolean (JNICALL *IsInstanceOf) + (JNIEnv *env, jobject obj, jclass clazz); + + jmethodID (JNICALL *GetMethodID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + + jobject (JNICALL *CallObjectMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jobject (JNICALL *CallObjectMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jobject (JNICALL *CallObjectMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args); + + jboolean (JNICALL *CallBooleanMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jboolean (JNICALL *CallBooleanMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jboolean (JNICALL *CallBooleanMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args); + + jbyte (JNICALL *CallByteMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jbyte (JNICALL *CallByteMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jbyte (JNICALL *CallByteMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + jchar (JNICALL *CallCharMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jchar (JNICALL *CallCharMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jchar (JNICALL *CallCharMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + jshort (JNICALL *CallShortMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jshort (JNICALL *CallShortMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jshort (JNICALL *CallShortMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + jint (JNICALL *CallIntMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jint (JNICALL *CallIntMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jint (JNICALL *CallIntMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + jlong (JNICALL *CallLongMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jlong (JNICALL *CallLongMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jlong (JNICALL *CallLongMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + jfloat (JNICALL *CallFloatMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jfloat (JNICALL *CallFloatMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jfloat (JNICALL *CallFloatMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + jdouble (JNICALL *CallDoubleMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + jdouble (JNICALL *CallDoubleMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + jdouble (JNICALL *CallDoubleMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args); + + void (JNICALL *CallVoidMethod) + (JNIEnv *env, jobject obj, jmethodID methodID, ...); + void (JNICALL *CallVoidMethodV) + (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + void (JNICALL *CallVoidMethodA) + (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args); + + jobject (JNICALL *CallNonvirtualObjectMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jobject (JNICALL *CallNonvirtualObjectMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jobject (JNICALL *CallNonvirtualObjectMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue * args); + + jboolean (JNICALL *CallNonvirtualBooleanMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jboolean (JNICALL *CallNonvirtualBooleanMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jboolean (JNICALL *CallNonvirtualBooleanMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue * args); + + jbyte (JNICALL *CallNonvirtualByteMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jbyte (JNICALL *CallNonvirtualByteMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jbyte (JNICALL *CallNonvirtualByteMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + jchar (JNICALL *CallNonvirtualCharMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jchar (JNICALL *CallNonvirtualCharMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jchar (JNICALL *CallNonvirtualCharMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + jshort (JNICALL *CallNonvirtualShortMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jshort (JNICALL *CallNonvirtualShortMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jshort (JNICALL *CallNonvirtualShortMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + jint (JNICALL *CallNonvirtualIntMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jint (JNICALL *CallNonvirtualIntMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jint (JNICALL *CallNonvirtualIntMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + jlong (JNICALL *CallNonvirtualLongMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jlong (JNICALL *CallNonvirtualLongMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jlong (JNICALL *CallNonvirtualLongMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + jfloat (JNICALL *CallNonvirtualFloatMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jfloat (JNICALL *CallNonvirtualFloatMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jfloat (JNICALL *CallNonvirtualFloatMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + jdouble (JNICALL *CallNonvirtualDoubleMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jdouble (JNICALL *CallNonvirtualDoubleMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jdouble (JNICALL *CallNonvirtualDoubleMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue *args); + + void (JNICALL *CallNonvirtualVoidMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + void (JNICALL *CallNonvirtualVoidMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + void (JNICALL *CallNonvirtualVoidMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + jvalue * args); + + jfieldID (JNICALL *GetFieldID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + + jobject (JNICALL *GetObjectField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jboolean (JNICALL *GetBooleanField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jbyte (JNICALL *GetByteField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jchar (JNICALL *GetCharField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jshort (JNICALL *GetShortField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jint (JNICALL *GetIntField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jlong (JNICALL *GetLongField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jfloat (JNICALL *GetFloatField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jdouble (JNICALL *GetDoubleField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + + void (JNICALL *SetObjectField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val); + void (JNICALL *SetBooleanField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val); + void (JNICALL *SetByteField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val); + void (JNICALL *SetCharField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val); + void (JNICALL *SetShortField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val); + void (JNICALL *SetIntField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jint val); + void (JNICALL *SetLongField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val); + void (JNICALL *SetFloatField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val); + void (JNICALL *SetDoubleField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val); + + jmethodID (JNICALL *GetStaticMethodID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + + jobject (JNICALL *CallStaticObjectMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jobject (JNICALL *CallStaticObjectMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jobject (JNICALL *CallStaticObjectMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jboolean (JNICALL *CallStaticBooleanMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jboolean (JNICALL *CallStaticBooleanMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jboolean (JNICALL *CallStaticBooleanMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jbyte (JNICALL *CallStaticByteMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jbyte (JNICALL *CallStaticByteMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jbyte (JNICALL *CallStaticByteMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jchar (JNICALL *CallStaticCharMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jchar (JNICALL *CallStaticCharMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jchar (JNICALL *CallStaticCharMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jshort (JNICALL *CallStaticShortMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jshort (JNICALL *CallStaticShortMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jshort (JNICALL *CallStaticShortMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jint (JNICALL *CallStaticIntMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jint (JNICALL *CallStaticIntMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jint (JNICALL *CallStaticIntMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jlong (JNICALL *CallStaticLongMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jlong (JNICALL *CallStaticLongMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jlong (JNICALL *CallStaticLongMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jfloat (JNICALL *CallStaticFloatMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jfloat (JNICALL *CallStaticFloatMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jfloat (JNICALL *CallStaticFloatMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + jdouble (JNICALL *CallStaticDoubleMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jdouble (JNICALL *CallStaticDoubleMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jdouble (JNICALL *CallStaticDoubleMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); + + void (JNICALL *CallStaticVoidMethod) + (JNIEnv *env, jclass cls, jmethodID methodID, ...); + void (JNICALL *CallStaticVoidMethodV) + (JNIEnv *env, jclass cls, jmethodID methodID, va_list args); + void (JNICALL *CallStaticVoidMethodA) + (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args); + + jfieldID (JNICALL *GetStaticFieldID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + jobject (JNICALL *GetStaticObjectField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jboolean (JNICALL *GetStaticBooleanField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jbyte (JNICALL *GetStaticByteField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jchar (JNICALL *GetStaticCharField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jshort (JNICALL *GetStaticShortField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jint (JNICALL *GetStaticIntField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jlong (JNICALL *GetStaticLongField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jfloat (JNICALL *GetStaticFloatField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jdouble (JNICALL *GetStaticDoubleField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + + void (JNICALL *SetStaticObjectField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value); + void (JNICALL *SetStaticBooleanField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value); + void (JNICALL *SetStaticByteField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value); + void (JNICALL *SetStaticCharField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value); + void (JNICALL *SetStaticShortField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value); + void (JNICALL *SetStaticIntField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value); + void (JNICALL *SetStaticLongField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value); + void (JNICALL *SetStaticFloatField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value); + void (JNICALL *SetStaticDoubleField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value); + + jstring (JNICALL *NewString) + (JNIEnv *env, const jchar *unicode, jsize len); + jsize (JNICALL *GetStringLength) + (JNIEnv *env, jstring str); + const jchar *(JNICALL *GetStringChars) + (JNIEnv *env, jstring str, jboolean *isCopy); + void (JNICALL *ReleaseStringChars) + (JNIEnv *env, jstring str, const jchar *chars); + + jstring (JNICALL *NewStringUTF) + (JNIEnv *env, const char *utf); + jsize (JNICALL *GetStringUTFLength) + (JNIEnv *env, jstring str); + const char* (JNICALL *GetStringUTFChars) + (JNIEnv *env, jstring str, jboolean *isCopy); + void (JNICALL *ReleaseStringUTFChars) + (JNIEnv *env, jstring str, const char* chars); + + + jsize (JNICALL *GetArrayLength) + (JNIEnv *env, jarray array); + + jobjectArray (JNICALL *NewObjectArray) + (JNIEnv *env, jsize len, jclass clazz, jobject init); + jobject (JNICALL *GetObjectArrayElement) + (JNIEnv *env, jobjectArray array, jsize index); + void (JNICALL *SetObjectArrayElement) + (JNIEnv *env, jobjectArray array, jsize index, jobject val); + + jbooleanArray (JNICALL *NewBooleanArray) + (JNIEnv *env, jsize len); + jbyteArray (JNICALL *NewByteArray) + (JNIEnv *env, jsize len); + jcharArray (JNICALL *NewCharArray) + (JNIEnv *env, jsize len); + jshortArray (JNICALL *NewShortArray) + (JNIEnv *env, jsize len); + jintArray (JNICALL *NewIntArray) + (JNIEnv *env, jsize len); + jlongArray (JNICALL *NewLongArray) + (JNIEnv *env, jsize len); + jfloatArray (JNICALL *NewFloatArray) + (JNIEnv *env, jsize len); + jdoubleArray (JNICALL *NewDoubleArray) + (JNIEnv *env, jsize len); + + jboolean * (JNICALL *GetBooleanArrayElements) + (JNIEnv *env, jbooleanArray array, jboolean *isCopy); + jbyte * (JNICALL *GetByteArrayElements) + (JNIEnv *env, jbyteArray array, jboolean *isCopy); + jchar * (JNICALL *GetCharArrayElements) + (JNIEnv *env, jcharArray array, jboolean *isCopy); + jshort * (JNICALL *GetShortArrayElements) + (JNIEnv *env, jshortArray array, jboolean *isCopy); + jint * (JNICALL *GetIntArrayElements) + (JNIEnv *env, jintArray array, jboolean *isCopy); + jlong * (JNICALL *GetLongArrayElements) + (JNIEnv *env, jlongArray array, jboolean *isCopy); + jfloat * (JNICALL *GetFloatArrayElements) + (JNIEnv *env, jfloatArray array, jboolean *isCopy); + jdouble * (JNICALL *GetDoubleArrayElements) + (JNIEnv *env, jdoubleArray array, jboolean *isCopy); + + void (JNICALL *ReleaseBooleanArrayElements) + (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode); + void (JNICALL *ReleaseByteArrayElements) + (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode); + void (JNICALL *ReleaseCharArrayElements) + (JNIEnv *env, jcharArray array, jchar *elems, jint mode); + void (JNICALL *ReleaseShortArrayElements) + (JNIEnv *env, jshortArray array, jshort *elems, jint mode); + void (JNICALL *ReleaseIntArrayElements) + (JNIEnv *env, jintArray array, jint *elems, jint mode); + void (JNICALL *ReleaseLongArrayElements) + (JNIEnv *env, jlongArray array, jlong *elems, jint mode); + void (JNICALL *ReleaseFloatArrayElements) + (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode); + void (JNICALL *ReleaseDoubleArrayElements) + (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode); + + void (JNICALL *GetBooleanArrayRegion) + (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf); + void (JNICALL *GetByteArrayRegion) + (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf); + void (JNICALL *GetCharArrayRegion) + (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf); + void (JNICALL *GetShortArrayRegion) + (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf); + void (JNICALL *GetIntArrayRegion) + (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf); + void (JNICALL *GetLongArrayRegion) + (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf); + void (JNICALL *GetFloatArrayRegion) + (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf); + void (JNICALL *GetDoubleArrayRegion) + (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf); + + void (JNICALL *SetBooleanArrayRegion) + (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf); + void (JNICALL *SetByteArrayRegion) + (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf); + void (JNICALL *SetCharArrayRegion) + (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf); + void (JNICALL *SetShortArrayRegion) + (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf); + void (JNICALL *SetIntArrayRegion) + (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf); + void (JNICALL *SetLongArrayRegion) + (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf); + void (JNICALL *SetFloatArrayRegion) + (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf); + void (JNICALL *SetDoubleArrayRegion) + (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf); + + jint (JNICALL *RegisterNatives) + (JNIEnv *env, jclass clazz, const JNINativeMethod *methods, + jint nMethods); + jint (JNICALL *UnregisterNatives) + (JNIEnv *env, jclass clazz); + + jint (JNICALL *MonitorEnter) + (JNIEnv *env, jobject obj); + jint (JNICALL *MonitorExit) + (JNIEnv *env, jobject obj); + + jint (JNICALL *GetJavaVM) + (JNIEnv *env, JavaVM **vm); +}; + +/* + * We use inlined functions for C++ so that programmers can write: + * + * env->FindClass("java/lang/String") + * + * in C++ rather than: + * + * (*env)->FindClass(env, "java/lang/String") + * + * in C. + */ + +struct JNIEnv_ { + const struct JNINativeInterface_ *functions; + void *reserved0; + void *reserved1[6]; +#ifdef __cplusplus + + jint GetVersion() { + return functions->GetVersion(this); + } + jclass DefineClass(const char *name, jobject loader, const jbyte *buf, + jsize len) { + return functions->DefineClass(this, name, loader, buf, len); + } + jclass FindClass(const char *name) { + return functions->FindClass(this, name); + } + jclass GetSuperclass(jclass sub) { + return functions->GetSuperclass(this, sub); + } + jboolean IsAssignableFrom(jclass sub, jclass sup) { + return functions->IsAssignableFrom(this, sub, sup); + } + + jint Throw(jthrowable obj) { + return functions->Throw(this, obj); + } + jint ThrowNew(jclass clazz, const char *msg) { + return functions->ThrowNew(this, clazz, msg); + } + jthrowable ExceptionOccurred() { + return functions->ExceptionOccurred(this); + } + void ExceptionDescribe() { + functions->ExceptionDescribe(this); + } + void ExceptionClear() { + functions->ExceptionClear(this); + } + void FatalError(const char *msg) { + functions->FatalError(this, msg); + } + + jobject NewGlobalRef(jobject lobj) { + return functions->NewGlobalRef(this,lobj); + } + void DeleteGlobalRef(jobject gref) { + functions->DeleteGlobalRef(this,gref); + } + void DeleteLocalRef(jobject obj) { + functions->DeleteLocalRef(this, obj); + } + + jboolean IsSameObject(jobject obj1, jobject obj2) { + return functions->IsSameObject(this,obj1,obj2); + } + + jobject AllocObject(jclass clazz) { + return functions->AllocObject(this,clazz); + } + jobject NewObject(jclass clazz, jmethodID methodID, ...) { + va_list args; + jobject result; + va_start(args, methodID); + result = functions->NewObjectV(this,clazz,methodID,args); + va_end(args); + return result; + } + jobject NewObjectV(jclass clazz, jmethodID methodID, + va_list args) { + return functions->NewObjectV(this,clazz,methodID,args); + } + jobject NewObjectA(jclass clazz, jmethodID methodID, + jvalue *args) { + return functions->NewObjectA(this,clazz,methodID,args); + } + + jclass GetObjectClass(jobject obj) { + return functions->GetObjectClass(this,obj); + } + jboolean IsInstanceOf(jobject obj, jclass clazz) { + return functions->IsInstanceOf(this,obj,clazz); + } + + jmethodID GetMethodID(jclass clazz, const char *name, + const char *sig) { + return functions->GetMethodID(this,clazz,name,sig); + } + + jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jobject result; + va_start(args,methodID); + result = functions->CallObjectMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jobject CallObjectMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallObjectMethodV(this,obj,methodID,args); + } + jobject CallObjectMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallObjectMethodA(this,obj,methodID,args); + } + + jboolean CallBooleanMethod(jobject obj, + jmethodID methodID, ...) { + va_list args; + jboolean result; + va_start(args,methodID); + result = functions->CallBooleanMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jboolean CallBooleanMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallBooleanMethodV(this,obj,methodID,args); + } + jboolean CallBooleanMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallBooleanMethodA(this,obj,methodID, args); + } + + jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jbyte result; + va_start(args,methodID); + result = functions->CallByteMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jbyte CallByteMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallByteMethodV(this,obj,methodID,args); + } + jbyte CallByteMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallByteMethodA(this,obj,methodID,args); + } + + jchar CallCharMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jchar result; + va_start(args,methodID); + result = functions->CallCharMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jchar CallCharMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallCharMethodV(this,obj,methodID,args); + } + jchar CallCharMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallCharMethodA(this,obj,methodID,args); + } + + jshort CallShortMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jshort result; + va_start(args,methodID); + result = functions->CallShortMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jshort CallShortMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallShortMethodV(this,obj,methodID,args); + } + jshort CallShortMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallShortMethodA(this,obj,methodID,args); + } + + jint CallIntMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jint result; + va_start(args,methodID); + result = functions->CallIntMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jint CallIntMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallIntMethodV(this,obj,methodID,args); + } + jint CallIntMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallIntMethodA(this,obj,methodID,args); + } + + jlong CallLongMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jlong result; + va_start(args,methodID); + result = functions->CallLongMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jlong CallLongMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallLongMethodV(this,obj,methodID,args); + } + jlong CallLongMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallLongMethodA(this,obj,methodID,args); + } + + jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jfloat result; + va_start(args,methodID); + result = functions->CallFloatMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jfloat CallFloatMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallFloatMethodV(this,obj,methodID,args); + } + jfloat CallFloatMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallFloatMethodA(this,obj,methodID,args); + } + + jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jdouble result; + va_start(args,methodID); + result = functions->CallDoubleMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jdouble CallDoubleMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallDoubleMethodV(this,obj,methodID,args); + } + jdouble CallDoubleMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + return functions->CallDoubleMethodA(this,obj,methodID,args); + } + + void CallVoidMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + va_start(args,methodID); + functions->CallVoidMethodV(this,obj,methodID,args); + va_end(args); + } + void CallVoidMethodV(jobject obj, jmethodID methodID, + va_list args) { + functions->CallVoidMethodV(this,obj,methodID,args); + } + void CallVoidMethodA(jobject obj, jmethodID methodID, + jvalue * args) { + functions->CallVoidMethodA(this,obj,methodID,args); + } + + jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jobject result; + va_start(args,methodID); + result = functions->CallNonvirtualObjectMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualObjectMethodV(this,obj,clazz, + methodID,args); + } + jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualObjectMethodA(this,obj,clazz, + methodID,args); + } + + jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jboolean result; + va_start(args,methodID); + result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualBooleanMethodV(this,obj,clazz, + methodID,args); + } + jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualBooleanMethodA(this,obj,clazz, + methodID, args); + } + + jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jbyte result; + va_start(args,methodID); + result = functions->CallNonvirtualByteMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualByteMethodV(this,obj,clazz, + methodID,args); + } + jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualByteMethodA(this,obj,clazz, + methodID,args); + } + + jchar CallNonvirtualCharMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jchar result; + va_start(args,methodID); + result = functions->CallNonvirtualCharMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualCharMethodV(this,obj,clazz, + methodID,args); + } + jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualCharMethodA(this,obj,clazz, + methodID,args); + } + + jshort CallNonvirtualShortMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jshort result; + va_start(args,methodID); + result = functions->CallNonvirtualShortMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualShortMethodV(this,obj,clazz, + methodID,args); + } + jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualShortMethodA(this,obj,clazz, + methodID,args); + } + + jint CallNonvirtualIntMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jint result; + va_start(args,methodID); + result = functions->CallNonvirtualIntMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jint CallNonvirtualIntMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualIntMethodV(this,obj,clazz, + methodID,args); + } + jint CallNonvirtualIntMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualIntMethodA(this,obj,clazz, + methodID,args); + } + + jlong CallNonvirtualLongMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jlong result; + va_start(args,methodID); + result = functions->CallNonvirtualLongMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualLongMethodV(this,obj,clazz, + methodID,args); + } + jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz, + jmethodID methodID, jvalue * args) { + return functions->CallNonvirtualLongMethodA(this,obj,clazz, + methodID,args); + } + + jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jfloat result; + va_start(args,methodID); + result = functions->CallNonvirtualFloatMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz, + jmethodID methodID, + va_list args) { + return functions->CallNonvirtualFloatMethodV(this,obj,clazz, + methodID,args); + } + jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz, + jmethodID methodID, + jvalue * args) { + return functions->CallNonvirtualFloatMethodA(this,obj,clazz, + methodID,args); + } + + jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jdouble result; + va_start(args,methodID); + result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz, + jmethodID methodID, + va_list args) { + return functions->CallNonvirtualDoubleMethodV(this,obj,clazz, + methodID,args); + } + jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz, + jmethodID methodID, + jvalue * args) { + return functions->CallNonvirtualDoubleMethodA(this,obj,clazz, + methodID,args); + } + + void CallNonvirtualVoidMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + va_start(args,methodID); + functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); + va_end(args); + } + void CallNonvirtualVoidMethodV(jobject obj, jclass clazz, + jmethodID methodID, + va_list args) { + functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); + } + void CallNonvirtualVoidMethodA(jobject obj, jclass clazz, + jmethodID methodID, + jvalue * args) { + functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args); + } + + jfieldID GetFieldID(jclass clazz, const char *name, + const char *sig) { + return functions->GetFieldID(this,clazz,name,sig); + } + + jobject GetObjectField(jobject obj, jfieldID fieldID) { + return functions->GetObjectField(this,obj,fieldID); + } + jboolean GetBooleanField(jobject obj, jfieldID fieldID) { + return functions->GetBooleanField(this,obj,fieldID); + } + jbyte GetByteField(jobject obj, jfieldID fieldID) { + return functions->GetByteField(this,obj,fieldID); + } + jchar GetCharField(jobject obj, jfieldID fieldID) { + return functions->GetCharField(this,obj,fieldID); + } + jshort GetShortField(jobject obj, jfieldID fieldID) { + return functions->GetShortField(this,obj,fieldID); + } + jint GetIntField(jobject obj, jfieldID fieldID) { + return functions->GetIntField(this,obj,fieldID); + } + jlong GetLongField(jobject obj, jfieldID fieldID) { + return functions->GetLongField(this,obj,fieldID); + } + jfloat GetFloatField(jobject obj, jfieldID fieldID) { + return functions->GetFloatField(this,obj,fieldID); + } + jdouble GetDoubleField(jobject obj, jfieldID fieldID) { + return functions->GetDoubleField(this,obj,fieldID); + } + + void SetObjectField(jobject obj, jfieldID fieldID, jobject val) { + functions->SetObjectField(this,obj,fieldID,val); + } + void SetBooleanField(jobject obj, jfieldID fieldID, + jboolean val) { + functions->SetBooleanField(this,obj,fieldID,val); + } + void SetByteField(jobject obj, jfieldID fieldID, + jbyte val) { + functions->SetByteField(this,obj,fieldID,val); + } + void SetCharField(jobject obj, jfieldID fieldID, + jchar val) { + functions->SetCharField(this,obj,fieldID,val); + } + void SetShortField(jobject obj, jfieldID fieldID, + jshort val) { + functions->SetShortField(this,obj,fieldID,val); + } + void SetIntField(jobject obj, jfieldID fieldID, + jint val) { + functions->SetIntField(this,obj,fieldID,val); + } + void SetLongField(jobject obj, jfieldID fieldID, + jlong val) { + functions->SetLongField(this,obj,fieldID,val); + } + void SetFloatField(jobject obj, jfieldID fieldID, + jfloat val) { + functions->SetFloatField(this,obj,fieldID,val); + } + void SetDoubleField(jobject obj, jfieldID fieldID, + jdouble val) { + functions->SetDoubleField(this,obj,fieldID,val); + } + + jmethodID GetStaticMethodID(jclass clazz, const char *name, + const char *sig) { + return functions->GetStaticMethodID(this,clazz,name,sig); + } + + jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID, + ...) { + va_list args; + jobject result; + va_start(args,methodID); + result = functions->CallStaticObjectMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID, + va_list args) { + return functions->CallStaticObjectMethodV(this,clazz,methodID,args); + } + jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID, + jvalue *args) { + return functions->CallStaticObjectMethodA(this,clazz,methodID,args); + } + + jboolean CallStaticBooleanMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jboolean result; + va_start(args,methodID); + result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jboolean CallStaticBooleanMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticBooleanMethodV(this,clazz,methodID,args); + } + jboolean CallStaticBooleanMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticBooleanMethodA(this,clazz,methodID,args); + } + + jbyte CallStaticByteMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jbyte result; + va_start(args,methodID); + result = functions->CallStaticByteMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jbyte CallStaticByteMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticByteMethodV(this,clazz,methodID,args); + } + jbyte CallStaticByteMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticByteMethodA(this,clazz,methodID,args); + } + + jchar CallStaticCharMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jchar result; + va_start(args,methodID); + result = functions->CallStaticCharMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jchar CallStaticCharMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticCharMethodV(this,clazz,methodID,args); + } + jchar CallStaticCharMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticCharMethodA(this,clazz,methodID,args); + } + + jshort CallStaticShortMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jshort result; + va_start(args,methodID); + result = functions->CallStaticShortMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jshort CallStaticShortMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticShortMethodV(this,clazz,methodID,args); + } + jshort CallStaticShortMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticShortMethodA(this,clazz,methodID,args); + } + + jint CallStaticIntMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jint result; + va_start(args,methodID); + result = functions->CallStaticIntMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jint CallStaticIntMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticIntMethodV(this,clazz,methodID,args); + } + jint CallStaticIntMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticIntMethodA(this,clazz,methodID,args); + } + + jlong CallStaticLongMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jlong result; + va_start(args,methodID); + result = functions->CallStaticLongMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jlong CallStaticLongMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticLongMethodV(this,clazz,methodID,args); + } + jlong CallStaticLongMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticLongMethodA(this,clazz,methodID,args); + } + + jfloat CallStaticFloatMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jfloat result; + va_start(args,methodID); + result = functions->CallStaticFloatMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jfloat CallStaticFloatMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticFloatMethodV(this,clazz,methodID,args); + } + jfloat CallStaticFloatMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticFloatMethodA(this,clazz,methodID,args); + } + + jdouble CallStaticDoubleMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jdouble result; + va_start(args,methodID); + result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jdouble CallStaticDoubleMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticDoubleMethodV(this,clazz,methodID,args); + } + jdouble CallStaticDoubleMethodA(jclass clazz, + jmethodID methodID, jvalue *args) { + return functions->CallStaticDoubleMethodA(this,clazz,methodID,args); + } + + void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) { + va_list args; + va_start(args,methodID); + functions->CallStaticVoidMethodV(this,cls,methodID,args); + va_end(args); + } + void CallStaticVoidMethodV(jclass cls, jmethodID methodID, + va_list args) { + functions->CallStaticVoidMethodV(this,cls,methodID,args); + } + void CallStaticVoidMethodA(jclass cls, jmethodID methodID, + jvalue * args) { + functions->CallStaticVoidMethodA(this,cls,methodID,args); + } + + jfieldID GetStaticFieldID(jclass clazz, const char *name, + const char *sig) { + return functions->GetStaticFieldID(this,clazz,name,sig); + } + jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticObjectField(this,clazz,fieldID); + } + jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticBooleanField(this,clazz,fieldID); + } + jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticByteField(this,clazz,fieldID); + } + jchar GetStaticCharField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticCharField(this,clazz,fieldID); + } + jshort GetStaticShortField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticShortField(this,clazz,fieldID); + } + jint GetStaticIntField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticIntField(this,clazz,fieldID); + } + jlong GetStaticLongField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticLongField(this,clazz,fieldID); + } + jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticFloatField(this,clazz,fieldID); + } + jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) { + return functions->GetStaticDoubleField(this,clazz,fieldID); + } + + void SetStaticObjectField(jclass clazz, jfieldID fieldID, + jobject value) { + functions->SetStaticObjectField(this,clazz,fieldID,value); + } + void SetStaticBooleanField(jclass clazz, jfieldID fieldID, + jboolean value) { + functions->SetStaticBooleanField(this,clazz,fieldID,value); + } + void SetStaticByteField(jclass clazz, jfieldID fieldID, + jbyte value) { + functions->SetStaticByteField(this,clazz,fieldID,value); + } + void SetStaticCharField(jclass clazz, jfieldID fieldID, + jchar value) { + functions->SetStaticCharField(this,clazz,fieldID,value); + } + void SetStaticShortField(jclass clazz, jfieldID fieldID, + jshort value) { + functions->SetStaticShortField(this,clazz,fieldID,value); + } + void SetStaticIntField(jclass clazz, jfieldID fieldID, + jint value) { + functions->SetStaticIntField(this,clazz,fieldID,value); + } + void SetStaticLongField(jclass clazz, jfieldID fieldID, + jlong value) { + functions->SetStaticLongField(this,clazz,fieldID,value); + } + void SetStaticFloatField(jclass clazz, jfieldID fieldID, + jfloat value) { + functions->SetStaticFloatField(this,clazz,fieldID,value); + } + void SetStaticDoubleField(jclass clazz, jfieldID fieldID, + jdouble value) { + functions->SetStaticDoubleField(this,clazz,fieldID,value); + } + + jstring NewString(const jchar *unicode, jsize len) { + return functions->NewString(this,unicode,len); + } + jsize GetStringLength(jstring str) { + return functions->GetStringLength(this,str); + } + const jchar *GetStringChars(jstring str, jboolean *isCopy) { + return functions->GetStringChars(this,str,isCopy); + } + void ReleaseStringChars(jstring str, const jchar *chars) { + functions->ReleaseStringChars(this,str,chars); + } + + jstring NewStringUTF(const char *utf) { + return functions->NewStringUTF(this,utf); + } + jsize GetStringUTFLength(jstring str) { + return functions->GetStringUTFLength(this,str); + } + const char* GetStringUTFChars(jstring str, jboolean *isCopy) { + return functions->GetStringUTFChars(this,str,isCopy); + } + void ReleaseStringUTFChars(jstring str, const char* chars) { + functions->ReleaseStringUTFChars(this,str,chars); + } + + jsize GetArrayLength(jarray array) { + return functions->GetArrayLength(this,array); + } + + jobjectArray NewObjectArray(jsize len, jclass clazz, + jobject init) { + return functions->NewObjectArray(this,len,clazz,init); + } + jobject GetObjectArrayElement(jobjectArray array, jsize index) { + return functions->GetObjectArrayElement(this,array,index); + } + void SetObjectArrayElement(jobjectArray array, jsize index, + jobject val) { + functions->SetObjectArrayElement(this,array,index,val); + } + + jbooleanArray NewBooleanArray(jsize len) { + return functions->NewBooleanArray(this,len); + } + jbyteArray NewByteArray(jsize len) { + return functions->NewByteArray(this,len); + } + jcharArray NewCharArray(jsize len) { + return functions->NewCharArray(this,len); + } + jshortArray NewShortArray(jsize len) { + return functions->NewShortArray(this,len); + } + jintArray NewIntArray(jsize len) { + return functions->NewIntArray(this,len); + } + jlongArray NewLongArray(jsize len) { + return functions->NewLongArray(this,len); + } + jfloatArray NewFloatArray(jsize len) { + return functions->NewFloatArray(this,len); + } + jdoubleArray NewDoubleArray(jsize len) { + return functions->NewDoubleArray(this,len); + } + + jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) { + return functions->GetBooleanArrayElements(this,array,isCopy); + } + jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) { + return functions->GetByteArrayElements(this,array,isCopy); + } + jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) { + return functions->GetCharArrayElements(this,array,isCopy); + } + jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) { + return functions->GetShortArrayElements(this,array,isCopy); + } + jint * GetIntArrayElements(jintArray array, jboolean *isCopy) { + return functions->GetIntArrayElements(this,array,isCopy); + } + jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) { + return functions->GetLongArrayElements(this,array,isCopy); + } + jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) { + return functions->GetFloatArrayElements(this,array,isCopy); + } + jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) { + return functions->GetDoubleArrayElements(this,array,isCopy); + } + + void ReleaseBooleanArrayElements(jbooleanArray array, + jboolean *elems, + jint mode) { + functions->ReleaseBooleanArrayElements(this,array,elems,mode); + } + void ReleaseByteArrayElements(jbyteArray array, + jbyte *elems, + jint mode) { + functions->ReleaseByteArrayElements(this,array,elems,mode); + } + void ReleaseCharArrayElements(jcharArray array, + jchar *elems, + jint mode) { + functions->ReleaseCharArrayElements(this,array,elems,mode); + } + void ReleaseShortArrayElements(jshortArray array, + jshort *elems, + jint mode) { + functions->ReleaseShortArrayElements(this,array,elems,mode); + } + void ReleaseIntArrayElements(jintArray array, + jint *elems, + jint mode) { + functions->ReleaseIntArrayElements(this,array,elems,mode); + } + void ReleaseLongArrayElements(jlongArray array, + jlong *elems, + jint mode) { + functions->ReleaseLongArrayElements(this,array,elems,mode); + } + void ReleaseFloatArrayElements(jfloatArray array, + jfloat *elems, + jint mode) { + functions->ReleaseFloatArrayElements(this,array,elems,mode); + } + void ReleaseDoubleArrayElements(jdoubleArray array, + jdouble *elems, + jint mode) { + functions->ReleaseDoubleArrayElements(this,array,elems,mode); + } + + void GetBooleanArrayRegion(jbooleanArray array, + jsize start, jsize len, jboolean *buf) { + functions->GetBooleanArrayRegion(this,array,start,len,buf); + } + void GetByteArrayRegion(jbyteArray array, + jsize start, jsize len, jbyte *buf) { + functions->GetByteArrayRegion(this,array,start,len,buf); + } + void GetCharArrayRegion(jcharArray array, + jsize start, jsize len, jchar *buf) { + functions->GetCharArrayRegion(this,array,start,len,buf); + } + void GetShortArrayRegion(jshortArray array, + jsize start, jsize len, jshort *buf) { + functions->GetShortArrayRegion(this,array,start,len,buf); + } + void GetIntArrayRegion(jintArray array, + jsize start, jsize len, jint *buf) { + functions->GetIntArrayRegion(this,array,start,len,buf); + } + void GetLongArrayRegion(jlongArray array, + jsize start, jsize len, jlong *buf) { + functions->GetLongArrayRegion(this,array,start,len,buf); + } + void GetFloatArrayRegion(jfloatArray array, + jsize start, jsize len, jfloat *buf) { + functions->GetFloatArrayRegion(this,array,start,len,buf); + } + void GetDoubleArrayRegion(jdoubleArray array, + jsize start, jsize len, jdouble *buf) { + functions->GetDoubleArrayRegion(this,array,start,len,buf); + } + + void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, + jboolean *buf) { + functions->SetBooleanArrayRegion(this,array,start,len,buf); + } + void SetByteArrayRegion(jbyteArray array, jsize start, jsize len, + jbyte *buf) { + functions->SetByteArrayRegion(this,array,start,len,buf); + } + void SetCharArrayRegion(jcharArray array, jsize start, jsize len, + jchar *buf) { + functions->SetCharArrayRegion(this,array,start,len,buf); + } + void SetShortArrayRegion(jshortArray array, jsize start, jsize len, + jshort *buf) { + functions->SetShortArrayRegion(this,array,start,len,buf); + } + void SetIntArrayRegion(jintArray array, jsize start, jsize len, + jint *buf) { + functions->SetIntArrayRegion(this,array,start,len,buf); + } + void SetLongArrayRegion(jlongArray array, jsize start, jsize len, + jlong *buf) { + functions->SetLongArrayRegion(this,array,start,len,buf); + } + void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, + jfloat *buf) { + functions->SetFloatArrayRegion(this,array,start,len,buf); + } + void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, + jdouble *buf) { + functions->SetDoubleArrayRegion(this,array,start,len,buf); + } + + jint RegisterNatives(jclass clazz, const JNINativeMethod *methods, + jint nMethods) { + return functions->RegisterNatives(this,clazz,methods,nMethods); + } + jint UnregisterNatives(jclass clazz) { + return functions->UnregisterNatives(this,clazz); + } + + jint MonitorEnter(jobject obj) { + return functions->MonitorEnter(this,obj); + } + jint MonitorExit(jobject obj) { + return functions->MonitorExit(this,obj); + } + + jint GetJavaVM(JavaVM **vm) { + return functions->GetJavaVM(this,vm); + } + +#endif /* __cplusplus */ +}; + +/* These structures will be VM-specific. */ + +typedef struct JDK1_1InitArgs { + jint version; + + char **properties; + jint checkSource; + jint nativeStackSize; + jint javaStackSize; + jint minHeapSize; + jint maxHeapSize; + jint verifyMode; + char *classpath; + + jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args); + void (JNICALL *exit)(jint code); + void (JNICALL *abort)(); + + jint enableClassGC; + jint enableVerboseGC; + jint disableAsyncGC; + jint verbose; + jboolean debugging; + jint debugPort; +} JDK1_1InitArgs; + +typedef struct JDK1_1AttachArgs { + void * __padding; /* C compilers don't allow empty structures. */ +} JDK1_1AttachArgs; + +/* End VM-specific. */ + +struct JNIInvokeInterface_ { + void *reserved0; + void *reserved1; + void *reserved2; + + jint (JNICALL *DestroyJavaVM)(JavaVM *vm); + + jint (JNICALL *AttachCurrentThread) + (JavaVM *vm, JNIEnv **penv, void *args); + + jint (JNICALL *DetachCurrentThread)(JavaVM *vm); +}; + +struct JavaVM_ { + const struct JNIInvokeInterface_ *functions; + void *reserved0; + void *reserved1; + void *reserved2; +#ifdef __cplusplus + + jint DestroyJavaVM() { + return functions->DestroyJavaVM(this); + } + jint AttachCurrentThread(JNIEnv **penv, void *args) { + return functions->AttachCurrentThread(this, penv, args); + } + jint DetachCurrentThread() { + return functions->DetachCurrentThread(this); + } + +#endif +}; + +JNI_PUBLIC_API(void) JNI_GetDefaultJavaVMInitArgs(void *); + +JNI_PUBLIC_API(jint) JNI_CreateJavaVM(JavaVM **, JNIEnv **, void *); + +JNI_PUBLIC_API(jint) JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *); +JNI_PUBLIC_API(jref) JNI_MakeLocalRef(JNIEnv *pJNIEnv, void *pHObject); + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ + +#endif /* JNI_H */ + + diff --git a/npapi/jni_md.h b/npapi/jni_md.h new file mode 100644 index 0000000..d3e96ab --- /dev/null +++ b/npapi/jni_md.h @@ -0,0 +1,182 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * The contents of this file are subject to the Netscape Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/NPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * + * + * This Original Code has been modified by IBM Corporation. + * Modifications made by IBM described herein are + * Copyright (c) International Business Machines + * Corporation, 2000 + * + * Modifications to Mozilla code or documentation + * identified per MPL Section 3.3 + * + * Date Modified by Description of modification + * 03/27/2000 IBM Corp. Set JNICALL to Optlink for + * use in OS2 + */ + +/******************************************************************************* + * Netscape version of jni_md.h -- depends on jri_md.h + ******************************************************************************/ + +#ifndef JNI_MD_H +#define JNI_MD_H + +#include "prtypes.h" /* needed for _declspec */ + +/******************************************************************************* + * WHAT'S UP WITH THIS FILE? + * + * This is where we define the mystical JNI_PUBLIC_API macro that works on all + * platforms. If you're running with Visual C++, Symantec C, or Borland's + * development environment on the PC, you're all set. Or if you're on the Mac + * with Metrowerks, Symantec or MPW with SC you're ok too. For UNIX it shouldn't + * matter. + + * Changes by sailesh on 9/26 + + * There are two symbols used in the declaration of the JNI functions + * and native code that uses the JNI: + * JNICALL - specifies the calling convention + * JNIEXPORT - specifies export status of the function + * + * The syntax to specify calling conventions is different in Win16 and + * Win32 - the brains at Micro$oft at work here. JavaSoft in their + * infinite wisdom cares for no platform other than Win32, and so they + * just define these two symbols as: + + #define JNIEXPORT __declspec(dllexport) + #define JNICALL __stdcall + + * We deal with this, in the way JRI defines the JRI_PUBLIC_API, by + * defining a macro called JNI_PUBLIC_API. Any of our developers who + * wish to use code for Win16 and Win32, _must_ use JNI_PUBLIC_API to + * be able to export functions properly. + + * Since we must also maintain compatibility with JavaSoft, we + * continue to define the symbol JNIEXPORT. However, use of this + * internally is deprecated, since it will cause a mess on Win16. + + * We _do not_ need a new symbol called JNICALL. Instead we + * redefine JNICALL in the same way JRI_CALLBACK was defined. + + ******************************************************************************/ + +/* DLL Entry modifiers... */ +#if defined(XP_OS2) +# ifdef XP_OS2_VACPP +# define JNI_PUBLIC_API(ResultType) ResultType _System +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNICALL _Optlink +# define JNIEXPORT +# else +# define JNI_PUBLIC_API(ResultType) ResultType +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNICALL +# define JNIEXPORT +# endif +/* Win32 */ +#elif defined(XP_WIN) || defined(_WINDOWS) || defined(WIN32) || defined(_WIN32) +# include +# if defined(_MSC_VER) || defined(__GNUC__) +# if defined(WIN32) || defined(_WIN32) +# define JNI_PUBLIC_API(ResultType) _declspec(dllexport) ResultType __stdcall +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNI_NATIVE_STUB(ResultType) _declspec(dllexport) ResultType +# define JNICALL __stdcall +# else /* !_WIN32 */ +# if defined(_WINDLL) +# define JNI_PUBLIC_API(ResultType) ResultType __cdecl __export __loadds +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNI_NATIVE_STUB(ResultType) ResultType __cdecl __loadds +# define JNICALL __loadds +# else /* !WINDLL */ +# define JNI_PUBLIC_API(ResultType) ResultType __cdecl __export +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNI_NATIVE_STUB(ResultType) ResultType __cdecl __export +# define JNICALL __export +# endif /* !WINDLL */ +# endif /* !_WIN32 */ +# elif defined(__BORLANDC__) +# if defined(WIN32) || defined(_WIN32) +# define JNI_PUBLIC_API(ResultType) __export ResultType +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNI_NATIVE_STUB(ResultType) __export ResultType +# define JNICALL +# else /* !_WIN32 */ +# define JNI_PUBLIC_API(ResultType) ResultType _cdecl _export _loadds +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNI_NATIVE_STUB(ResultType) ResultType _cdecl _loadds +# define JNICALL _loadds +# endif +# else +# error Unsupported PC development environment. +# endif +# ifndef IS_LITTLE_ENDIAN +# define IS_LITTLE_ENDIAN +# endif + /* This is the stuff inherited from JavaSoft .. */ +# define JNIEXPORT __declspec(dllexport) + + +/* Mac */ +#elif macintosh || Macintosh || THINK_C +# if defined(__MWERKS__) /* Metrowerks */ +# if !__option(enumsalwaysint) +# error You need to define 'Enums Always Int' for your project. +# endif +# if defined(TARGET_CPU_68K) && !TARGET_RT_MAC_CFM +# if !__option(fourbyteints) +# error You need to define 'Struct Alignment: 68k' for your project. +# endif +# endif /* !GENERATINGCFM */ +# define JNI_PUBLIC_API(ResultType) __declspec(export) ResultType +# define JNI_PUBLIC_VAR(VarType) JNI_PUBLIC_API(VarType) +# define JNI_NATIVE_STUB(ResultType) JNI_PUBLIC_API(ResultType) +# elif defined(__SC__) /* Symantec */ +# error What are the Symantec defines? (warren@netscape.com) +# elif macintosh && applec /* MPW */ +# error Please upgrade to the latest MPW compiler (SC). +# else +# error Unsupported Mac development environment. +# endif +# define JNICALL + /* This is the stuff inherited from JavaSoft .. */ +# define JNIEXPORT + +/* Unix or else */ +#else +# define JNI_PUBLIC_API(ResultType) ResultType +# define JNI_PUBLIC_VAR(VarType) VarType +# define JNI_NATIVE_STUB(ResultType) ResultType +# define JNICALL + /* This is the stuff inherited from JavaSoft .. */ +# define JNIEXPORT +#endif + +#ifndef FAR /* for non-Win16 */ +#define FAR +#endif + +/* Get the rest of the stuff from jri_md.h */ +#include "jri_md.h" + +#endif /* JNI_MD_H */ diff --git a/npapi/jri.h b/npapi/jri.h new file mode 100644 index 0000000..f29945b --- /dev/null +++ b/npapi/jri.h @@ -0,0 +1,689 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: NPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Netscape Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the NPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the NPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +/******************************************************************************* + * Java Runtime Interface + ******************************************************************************/ + +#ifndef JRI_H +#define JRI_H + +#include "jritypes.h" + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/******************************************************************************* + * JRIEnv + ******************************************************************************/ + +/* The type of the JRIEnv interface. */ +typedef struct JRIEnvInterface JRIEnvInterface; + +/* The type of a JRIEnv instance. */ +typedef const JRIEnvInterface* JRIEnv; + +/******************************************************************************* + * JRIEnv Operations + ******************************************************************************/ + +#define JRI_DefineClass(env, classLoader, buf, bufLen) \ + (((*(env))->DefineClass)(env, JRI_DefineClass_op, classLoader, buf, bufLen)) + +#define JRI_FindClass(env, name) \ + (((*(env))->FindClass)(env, JRI_FindClass_op, name)) + +#define JRI_Throw(env, obj) \ + (((*(env))->Throw)(env, JRI_Throw_op, obj)) + +#define JRI_ThrowNew(env, clazz, message) \ + (((*(env))->ThrowNew)(env, JRI_ThrowNew_op, clazz, message)) + +#define JRI_ExceptionOccurred(env) \ + (((*(env))->ExceptionOccurred)(env, JRI_ExceptionOccurred_op)) + +#define JRI_ExceptionDescribe(env) \ + (((*(env))->ExceptionDescribe)(env, JRI_ExceptionDescribe_op)) + +#define JRI_ExceptionClear(env) \ + (((*(env))->ExceptionClear)(env, JRI_ExceptionClear_op)) + +#define JRI_NewGlobalRef(env, ref) \ + (((*(env))->NewGlobalRef)(env, JRI_NewGlobalRef_op, ref)) + +#define JRI_DisposeGlobalRef(env, gref) \ + (((*(env))->DisposeGlobalRef)(env, JRI_DisposeGlobalRef_op, gref)) + +#define JRI_GetGlobalRef(env, gref) \ + (((*(env))->GetGlobalRef)(env, JRI_GetGlobalRef_op, gref)) + +#define JRI_SetGlobalRef(env, gref, ref) \ + (((*(env))->SetGlobalRef)(env, JRI_SetGlobalRef_op, gref, ref)) + +#define JRI_IsSameObject(env, a, b) \ + (((*(env))->IsSameObject)(env, JRI_IsSameObject_op, a, b)) + +#define JRI_NewObject(env) ((*(env))->NewObject) +#define JRI_NewObjectV(env, clazz, methodID, args) \ + (((*(env))->NewObjectV)(env, JRI_NewObject_op_va_list, clazz, methodID, args)) +#define JRI_NewObjectA(env, clazz, method, args) \ + (((*(env))->NewObjectA)(env, JRI_NewObject_op_array, clazz, methodID, args)) + +#define JRI_GetObjectClass(env, obj) \ + (((*(env))->GetObjectClass)(env, JRI_GetObjectClass_op, obj)) + +#define JRI_IsInstanceOf(env, obj, clazz) \ + (((*(env))->IsInstanceOf)(env, JRI_IsInstanceOf_op, obj, clazz)) + +#define JRI_GetMethodID(env, clazz, name, sig) \ + (((*(env))->GetMethodID)(env, JRI_GetMethodID_op, clazz, name, sig)) + +#define JRI_CallMethod(env) ((*(env))->CallMethod) +#define JRI_CallMethodV(env, obj, methodID, args) \ + (((*(env))->CallMethodV)(env, JRI_CallMethod_op_va_list, obj, methodID, args)) +#define JRI_CallMethodA(env, obj, methodID, args) \ + (((*(env))->CallMethodA)(env, JRI_CallMethod_op_array, obj, methodID, args)) + +#define JRI_CallMethodBoolean(env) ((*(env))->CallMethodBoolean) +#define JRI_CallMethodBooleanV(env, obj, methodID, args) \ + (((*(env))->CallMethodBooleanV)(env, JRI_CallMethodBoolean_op_va_list, obj, methodID, args)) +#define JRI_CallMethodBooleanA(env, obj, methodID, args) \ + (((*(env))->CallMethodBooleanA)(env, JRI_CallMethodBoolean_op_array, obj, methodID, args)) + +#define JRI_CallMethodByte(env) ((*(env))->CallMethodByte) +#define JRI_CallMethodByteV(env, obj, methodID, args) \ + (((*(env))->CallMethodByteV)(env, JRI_CallMethodByte_op_va_list, obj, methodID, args)) +#define JRI_CallMethodByteA(env, obj, methodID, args) \ + (((*(env))->CallMethodByteA)(env, JRI_CallMethodByte_op_array, obj, methodID, args)) + +#define JRI_CallMethodChar(env) ((*(env))->CallMethodChar) +#define JRI_CallMethodCharV(env, obj, methodID, args) \ + (((*(env))->CallMethodCharV)(env, JRI_CallMethodChar_op_va_list, obj, methodID, args)) +#define JRI_CallMethodCharA(env, obj, methodID, args) \ + (((*(env))->CallMethodCharA)(env, JRI_CallMethodChar_op_array, obj, methodID, args)) + +#define JRI_CallMethodShort(env) ((*(env))->CallMethodShort) +#define JRI_CallMethodShortV(env, obj, methodID, args) \ + (((*(env))->CallMethodShortV)(env, JRI_CallMethodShort_op_va_list, obj, methodID, args)) +#define JRI_CallMethodShortA(env, obj, methodID, args) \ + (((*(env))->CallMethodShortA)(env, JRI_CallMethodShort_op_array, obj, methodID, args)) + +#define JRI_CallMethodInt(env) ((*(env))->CallMethodInt) +#define JRI_CallMethodIntV(env, obj, methodID, args) \ + (((*(env))->CallMethodIntV)(env, JRI_CallMethodInt_op_va_list, obj, methodID, args)) +#define JRI_CallMethodIntA(env, obj, methodID, args) \ + (((*(env))->CallMethodIntA)(env, JRI_CallMethodInt_op_array, obj, methodID, args)) + +#define JRI_CallMethodLong(env) ((*(env))->CallMethodLong) +#define JRI_CallMethodLongV(env, obj, methodID, args) \ + (((*(env))->CallMethodLongV)(env, JRI_CallMethodLong_op_va_list, obj, methodID, args)) +#define JRI_CallMethodLongA(env, obj, methodID, args) \ + (((*(env))->CallMethodLongA)(env, JRI_CallMethodLong_op_array, obj, methodID, args)) + +#define JRI_CallMethodFloat(env) ((*(env))->CallMethodFloat) +#define JRI_CallMethodFloatV(env, obj, methodID, args) \ + (((*(env))->CallMethodFloatV)(env, JRI_CallMethodFloat_op_va_list, obj, methodID, args)) +#define JRI_CallMethodFloatA(env, obj, methodID, args) \ + (((*(env))->CallMethodFloatA)(env, JRI_CallMethodFloat_op_array, obj, methodID, args)) + +#define JRI_CallMethodDouble(env) ((*(env))->CallMethodDouble) +#define JRI_CallMethodDoubleV(env, obj, methodID, args) \ + (((*(env))->CallMethodDoubleV)(env, JRI_CallMethodDouble_op_va_list, obj, methodID, args)) +#define JRI_CallMethodDoubleA(env, obj, methodID, args) \ + (((*(env))->CallMethodDoubleA)(env, JRI_CallMethodDouble_op_array, obj, methodID, args)) + +#define JRI_GetFieldID(env, clazz, name, sig) \ + (((*(env))->GetFieldID)(env, JRI_GetFieldID_op, clazz, name, sig)) + +#define JRI_GetField(env, obj, fieldID) \ + (((*(env))->GetField)(env, JRI_GetField_op, obj, fieldID)) + +#define JRI_GetFieldBoolean(env, obj, fieldID) \ + (((*(env))->GetFieldBoolean)(env, JRI_GetFieldBoolean_op, obj, fieldID)) + +#define JRI_GetFieldByte(env, obj, fieldID) \ + (((*(env))->GetFieldByte)(env, JRI_GetFieldByte_op, obj, fieldID)) + +#define JRI_GetFieldChar(env, obj, fieldID) \ + (((*(env))->GetFieldChar)(env, JRI_GetFieldChar_op, obj, fieldID)) + +#define JRI_GetFieldShort(env, obj, fieldID) \ + (((*(env))->GetFieldShort)(env, JRI_GetFieldShort_op, obj, fieldID)) + +#define JRI_GetFieldInt(env, obj, fieldID) \ + (((*(env))->GetFieldInt)(env, JRI_GetFieldInt_op, obj, fieldID)) + +#define JRI_GetFieldLong(env, obj, fieldID) \ + (((*(env))->GetFieldLong)(env, JRI_GetFieldLong_op, obj, fieldID)) + +#define JRI_GetFieldFloat(env, obj, fieldID) \ + (((*(env))->GetFieldFloat)(env, JRI_GetFieldFloat_op, obj, fieldID)) + +#define JRI_GetFieldDouble(env, obj, fieldID) \ + (((*(env))->GetFieldDouble)(env, JRI_GetFieldDouble_op, obj, fieldID)) + +#define JRI_SetField(env, obj, fieldID, value) \ + (((*(env))->SetField)(env, JRI_SetField_op, obj, fieldID, value)) + +#define JRI_SetFieldBoolean(env, obj, fieldID, value) \ + (((*(env))->SetFieldBoolean)(env, JRI_SetFieldBoolean_op, obj, fieldID, value)) + +#define JRI_SetFieldByte(env, obj, fieldID, value) \ + (((*(env))->SetFieldByte)(env, JRI_SetFieldByte_op, obj, fieldID, value)) + +#define JRI_SetFieldChar(env, obj, fieldID, value) \ + (((*(env))->SetFieldChar)(env, JRI_SetFieldChar_op, obj, fieldID, value)) + +#define JRI_SetFieldShort(env, obj, fieldID, value) \ + (((*(env))->SetFieldShort)(env, JRI_SetFieldShort_op, obj, fieldID, value)) + +#define JRI_SetFieldInt(env, obj, fieldID, value) \ + (((*(env))->SetFieldInt)(env, JRI_SetFieldInt_op, obj, fieldID, value)) + +#define JRI_SetFieldLong(env, obj, fieldID, value) \ + (((*(env))->SetFieldLong)(env, JRI_SetFieldLong_op, obj, fieldID, value)) + +#define JRI_SetFieldFloat(env, obj, fieldID, value) \ + (((*(env))->SetFieldFloat)(env, JRI_SetFieldFloat_op, obj, fieldID, value)) + +#define JRI_SetFieldDouble(env, obj, fieldID, value) \ + (((*(env))->SetFieldDouble)(env, JRI_SetFieldDouble_op, obj, fieldID, value)) + +#define JRI_IsSubclassOf(env, a, b) \ + (((*(env))->IsSubclassOf)(env, JRI_IsSubclassOf_op, a, b)) + +#define JRI_GetStaticMethodID(env, clazz, name, sig) \ + (((*(env))->GetStaticMethodID)(env, JRI_GetStaticMethodID_op, clazz, name, sig)) + +#define JRI_CallStaticMethod(env) ((*(env))->CallStaticMethod) +#define JRI_CallStaticMethodV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodV)(env, JRI_CallStaticMethod_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodA)(env, JRI_CallStaticMethod_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodBoolean(env) ((*(env))->CallStaticMethodBoolean) +#define JRI_CallStaticMethodBooleanV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodBooleanV)(env, JRI_CallStaticMethodBoolean_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodBooleanA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodBooleanA)(env, JRI_CallStaticMethodBoolean_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodByte(env) ((*(env))->CallStaticMethodByte) +#define JRI_CallStaticMethodByteV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodByteV)(env, JRI_CallStaticMethodByte_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodByteA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodByteA)(env, JRI_CallStaticMethodByte_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodChar(env) ((*(env))->CallStaticMethodChar) +#define JRI_CallStaticMethodCharV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodCharV)(env, JRI_CallStaticMethodChar_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodCharA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodCharA)(env, JRI_CallStaticMethodChar_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodShort(env) ((*(env))->CallStaticMethodShort) +#define JRI_CallStaticMethodShortV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodShortV)(env, JRI_CallStaticMethodShort_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodShortA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodShortA)(env, JRI_CallStaticMethodShort_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodInt(env) ((*(env))->CallStaticMethodInt) +#define JRI_CallStaticMethodIntV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodIntV)(env, JRI_CallStaticMethodInt_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodIntA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodIntA)(env, JRI_CallStaticMethodInt_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodLong(env) ((*(env))->CallStaticMethodLong) +#define JRI_CallStaticMethodLongV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodLongV)(env, JRI_CallStaticMethodLong_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodLongA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodLongA)(env, JRI_CallStaticMethodLong_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodFloat(env) ((*(env))->CallStaticMethodFloat) +#define JRI_CallStaticMethodFloatV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodFloatV)(env, JRI_CallStaticMethodFloat_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodFloatA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodFloatA)(env, JRI_CallStaticMethodFloat_op_array, clazz, methodID, args)) + +#define JRI_CallStaticMethodDouble(env) ((*(env))->CallStaticMethodDouble) +#define JRI_CallStaticMethodDoubleV(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodDoubleV)(env, JRI_CallStaticMethodDouble_op_va_list, clazz, methodID, args)) +#define JRI_CallStaticMethodDoubleA(env, clazz, methodID, args) \ + (((*(env))->CallStaticMethodDoubleA)(env, JRI_CallStaticMethodDouble_op_array, clazz, methodID, args)) + +#define JRI_GetStaticFieldID(env, clazz, name, sig) \ + (((*(env))->GetStaticFieldID)(env, JRI_GetStaticFieldID_op, clazz, name, sig)) + +#define JRI_GetStaticField(env, clazz, fieldID) \ + (((*(env))->GetStaticField)(env, JRI_GetStaticField_op, clazz, fieldID)) + +#define JRI_GetStaticFieldBoolean(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldBoolean)(env, JRI_GetStaticFieldBoolean_op, clazz, fieldID)) + +#define JRI_GetStaticFieldByte(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldByte)(env, JRI_GetStaticFieldByte_op, clazz, fieldID)) + +#define JRI_GetStaticFieldChar(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldChar)(env, JRI_GetStaticFieldChar_op, clazz, fieldID)) + +#define JRI_GetStaticFieldShort(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldShort)(env, JRI_GetStaticFieldShort_op, clazz, fieldID)) + +#define JRI_GetStaticFieldInt(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldInt)(env, JRI_GetStaticFieldInt_op, clazz, fieldID)) + +#define JRI_GetStaticFieldLong(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldLong)(env, JRI_GetStaticFieldLong_op, clazz, fieldID)) + +#define JRI_GetStaticFieldFloat(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldFloat)(env, JRI_GetStaticFieldFloat_op, clazz, fieldID)) + +#define JRI_GetStaticFieldDouble(env, clazz, fieldID) \ + (((*(env))->GetStaticFieldDouble)(env, JRI_GetStaticFieldDouble_op, clazz, fieldID)) + +#define JRI_SetStaticField(env, clazz, fieldID, value) \ + (((*(env))->SetStaticField)(env, JRI_SetStaticField_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldBoolean(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldBoolean)(env, JRI_SetStaticFieldBoolean_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldByte(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldByte)(env, JRI_SetStaticFieldByte_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldChar(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldChar)(env, JRI_SetStaticFieldChar_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldShort(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldShort)(env, JRI_SetStaticFieldShort_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldInt(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldInt)(env, JRI_SetStaticFieldInt_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldLong(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldLong)(env, JRI_SetStaticFieldLong_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldFloat(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldFloat)(env, JRI_SetStaticFieldFloat_op, clazz, fieldID, value)) + +#define JRI_SetStaticFieldDouble(env, clazz, fieldID, value) \ + (((*(env))->SetStaticFieldDouble)(env, JRI_SetStaticFieldDouble_op, clazz, fieldID, value)) + +#define JRI_NewString(env, unicode, len) \ + (((*(env))->NewString)(env, JRI_NewString_op, unicode, len)) + +#define JRI_GetStringLength(env, string) \ + (((*(env))->GetStringLength)(env, JRI_GetStringLength_op, string)) + +#define JRI_GetStringChars(env, string) \ + (((*(env))->GetStringChars)(env, JRI_GetStringChars_op, string)) + +#define JRI_NewStringUTF(env, utf, len) \ + (((*(env))->NewStringUTF)(env, JRI_NewStringUTF_op, utf, len)) + +#define JRI_GetStringUTFLength(env, string) \ + (((*(env))->GetStringUTFLength)(env, JRI_GetStringUTFLength_op, string)) + +#define JRI_GetStringUTFChars(env, string) \ + (((*(env))->GetStringUTFChars)(env, JRI_GetStringUTFChars_op, string)) + +#define JRI_NewScalarArray(env, length, elementSig, initialElements) \ + (((*(env))->NewScalarArray)(env, JRI_NewScalarArray_op, length, elementSig, initialElements)) + +#define JRI_GetScalarArrayLength(env, array) \ + (((*(env))->GetScalarArrayLength)(env, JRI_GetScalarArrayLength_op, array)) + +#define JRI_GetScalarArrayElements(env, array) \ + (((*(env))->GetScalarArrayElements)(env, JRI_GetScalarArrayElements_op, array)) + +#define JRI_NewObjectArray(env, length, elementClass, initialElement) \ + (((*(env))->NewObjectArray)(env, JRI_NewObjectArray_op, length, elementClass, initialElement)) + +#define JRI_GetObjectArrayLength(env, array) \ + (((*(env))->GetObjectArrayLength)(env, JRI_GetObjectArrayLength_op, array)) + +#define JRI_GetObjectArrayElement(env, array, index) \ + (((*(env))->GetObjectArrayElement)(env, JRI_GetObjectArrayElement_op, array, index)) + +#define JRI_SetObjectArrayElement(env, array, index, value) \ + (((*(env))->SetObjectArrayElement)(env, JRI_SetObjectArrayElement_op, array, index, value)) + +#define JRI_RegisterNatives(env, clazz, nameAndSigArray, nativeProcArray) \ + (((*(env))->RegisterNatives)(env, JRI_RegisterNatives_op, clazz, nameAndSigArray, nativeProcArray)) + +#define JRI_UnregisterNatives(env, clazz) \ + (((*(env))->UnregisterNatives)(env, JRI_UnregisterNatives_op, clazz)) + +#define JRI_NewStringPlatform(env, string, len, encoding, encodingLength) \ + (((*(env))->NewStringPlatform)(env, JRI_NewStringPlatform_op, string, len, encoding, encodingLength)) + +#define JRI_GetStringPlatformChars(env, string, encoding, encodingLength) \ + (((*(env))->GetStringPlatformChars)(env, JRI_GetStringPlatformChars_op, string, encoding, encodingLength)) + + +/******************************************************************************* + * JRIEnv Interface + ******************************************************************************/ + +struct java_lang_ClassLoader; +struct java_lang_Class; +struct java_lang_Throwable; +struct java_lang_Object; +struct java_lang_String; + +struct JRIEnvInterface { + void* reserved0; + void* reserved1; + void* reserved2; + void* reserved3; + struct java_lang_Class* (*FindClass)(JRIEnv* env, jint op, const char* a); + void (*Throw)(JRIEnv* env, jint op, struct java_lang_Throwable* a); + void (*ThrowNew)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b); + struct java_lang_Throwable* (*ExceptionOccurred)(JRIEnv* env, jint op); + void (*ExceptionDescribe)(JRIEnv* env, jint op); + void (*ExceptionClear)(JRIEnv* env, jint op); + jglobal (*NewGlobalRef)(JRIEnv* env, jint op, void* a); + void (*DisposeGlobalRef)(JRIEnv* env, jint op, jglobal a); + void* (*GetGlobalRef)(JRIEnv* env, jint op, jglobal a); + void (*SetGlobalRef)(JRIEnv* env, jint op, jglobal a, void* b); + jbool (*IsSameObject)(JRIEnv* env, jint op, void* a, void* b); + void* (*NewObject)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + void* (*NewObjectV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + void* (*NewObjectA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + struct java_lang_Class* (*GetObjectClass)(JRIEnv* env, jint op, void* a); + jbool (*IsInstanceOf)(JRIEnv* env, jint op, void* a, struct java_lang_Class* b); + jint (*GetMethodID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c); + void* (*CallMethod)(JRIEnv* env, jint op, void* a, jint b, ...); + void* (*CallMethodV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + void* (*CallMethodA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jbool (*CallMethodBoolean)(JRIEnv* env, jint op, void* a, jint b, ...); + jbool (*CallMethodBooleanV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jbool (*CallMethodBooleanA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jbyte (*CallMethodByte)(JRIEnv* env, jint op, void* a, jint b, ...); + jbyte (*CallMethodByteV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jbyte (*CallMethodByteA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jchar (*CallMethodChar)(JRIEnv* env, jint op, void* a, jint b, ...); + jchar (*CallMethodCharV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jchar (*CallMethodCharA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jshort (*CallMethodShort)(JRIEnv* env, jint op, void* a, jint b, ...); + jshort (*CallMethodShortV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jshort (*CallMethodShortA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jint (*CallMethodInt)(JRIEnv* env, jint op, void* a, jint b, ...); + jint (*CallMethodIntV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jint (*CallMethodIntA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jlong (*CallMethodLong)(JRIEnv* env, jint op, void* a, jint b, ...); + jlong (*CallMethodLongV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jlong (*CallMethodLongA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jfloat (*CallMethodFloat)(JRIEnv* env, jint op, void* a, jint b, ...); + jfloat (*CallMethodFloatV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jfloat (*CallMethodFloatA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jdouble (*CallMethodDouble)(JRIEnv* env, jint op, void* a, jint b, ...); + jdouble (*CallMethodDoubleV)(JRIEnv* env, jint op, void* a, jint b, va_list c); + jdouble (*CallMethodDoubleA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c); + jint (*GetFieldID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c); + void* (*GetField)(JRIEnv* env, jint op, void* a, jint b); + jbool (*GetFieldBoolean)(JRIEnv* env, jint op, void* a, jint b); + jbyte (*GetFieldByte)(JRIEnv* env, jint op, void* a, jint b); + jchar (*GetFieldChar)(JRIEnv* env, jint op, void* a, jint b); + jshort (*GetFieldShort)(JRIEnv* env, jint op, void* a, jint b); + jint (*GetFieldInt)(JRIEnv* env, jint op, void* a, jint b); + jlong (*GetFieldLong)(JRIEnv* env, jint op, void* a, jint b); + jfloat (*GetFieldFloat)(JRIEnv* env, jint op, void* a, jint b); + jdouble (*GetFieldDouble)(JRIEnv* env, jint op, void* a, jint b); + void (*SetField)(JRIEnv* env, jint op, void* a, jint b, void* c); + void (*SetFieldBoolean)(JRIEnv* env, jint op, void* a, jint b, jbool c); + void (*SetFieldByte)(JRIEnv* env, jint op, void* a, jint b, jbyte c); + void (*SetFieldChar)(JRIEnv* env, jint op, void* a, jint b, jchar c); + void (*SetFieldShort)(JRIEnv* env, jint op, void* a, jint b, jshort c); + void (*SetFieldInt)(JRIEnv* env, jint op, void* a, jint b, jint c); + void (*SetFieldLong)(JRIEnv* env, jint op, void* a, jint b, jlong c); + void (*SetFieldFloat)(JRIEnv* env, jint op, void* a, jint b, jfloat c); + void (*SetFieldDouble)(JRIEnv* env, jint op, void* a, jint b, jdouble c); + jbool (*IsSubclassOf)(JRIEnv* env, jint op, struct java_lang_Class* a, struct java_lang_Class* b); + jint (*GetStaticMethodID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c); + void* (*CallStaticMethod)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + void* (*CallStaticMethodV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + void* (*CallStaticMethodA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jbool (*CallStaticMethodBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jbool (*CallStaticMethodBooleanV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jbool (*CallStaticMethodBooleanA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jbyte (*CallStaticMethodByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jbyte (*CallStaticMethodByteV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jbyte (*CallStaticMethodByteA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jchar (*CallStaticMethodChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jchar (*CallStaticMethodCharV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jchar (*CallStaticMethodCharA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jshort (*CallStaticMethodShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jshort (*CallStaticMethodShortV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jshort (*CallStaticMethodShortA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jint (*CallStaticMethodInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jint (*CallStaticMethodIntV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jint (*CallStaticMethodIntA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jlong (*CallStaticMethodLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jlong (*CallStaticMethodLongV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jlong (*CallStaticMethodLongA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jfloat (*CallStaticMethodFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jfloat (*CallStaticMethodFloatV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jfloat (*CallStaticMethodFloatA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jdouble (*CallStaticMethodDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jdouble (*CallStaticMethodDoubleV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jdouble (*CallStaticMethodDoubleA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jint (*GetStaticFieldID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c); + void* (*GetStaticField)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jbool (*GetStaticFieldBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jbyte (*GetStaticFieldByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jchar (*GetStaticFieldChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jshort (*GetStaticFieldShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jint (*GetStaticFieldInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jlong (*GetStaticFieldLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jfloat (*GetStaticFieldFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jdouble (*GetStaticFieldDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + void (*SetStaticField)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, void* c); + void (*SetStaticFieldBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jbool c); + void (*SetStaticFieldByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jbyte c); + void (*SetStaticFieldChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jchar c); + void (*SetStaticFieldShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jshort c); + void (*SetStaticFieldInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jint c); + void (*SetStaticFieldLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jlong c); + void (*SetStaticFieldFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jfloat c); + void (*SetStaticFieldDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jdouble c); + struct java_lang_String* (*NewString)(JRIEnv* env, jint op, const jchar* a, jint b); + jint (*GetStringLength)(JRIEnv* env, jint op, struct java_lang_String* a); + const jchar* (*GetStringChars)(JRIEnv* env, jint op, struct java_lang_String* a); + struct java_lang_String* (*NewStringUTF)(JRIEnv* env, jint op, const jbyte* a, jint b); + jint (*GetStringUTFLength)(JRIEnv* env, jint op, struct java_lang_String* a); + const jbyte* (*GetStringUTFChars)(JRIEnv* env, jint op, struct java_lang_String* a); + void* (*NewScalarArray)(JRIEnv* env, jint op, jint a, const char* b, const jbyte* c); + jint (*GetScalarArrayLength)(JRIEnv* env, jint op, void* a); + jbyte* (*GetScalarArrayElements)(JRIEnv* env, jint op, void* a); + void* (*NewObjectArray)(JRIEnv* env, jint op, jint a, struct java_lang_Class* b, void* c); + jint (*GetObjectArrayLength)(JRIEnv* env, jint op, void* a); + void* (*GetObjectArrayElement)(JRIEnv* env, jint op, void* a, jint b); + void (*SetObjectArrayElement)(JRIEnv* env, jint op, void* a, jint b, void* c); + void (*RegisterNatives)(JRIEnv* env, jint op, struct java_lang_Class* a, char** b, void** c); + void (*UnregisterNatives)(JRIEnv* env, jint op, struct java_lang_Class* a); + struct java_lang_Class* (*DefineClass)(JRIEnv* env, jint op, struct java_lang_ClassLoader* a, jbyte* b, jsize bLen); + struct java_lang_String* (*NewStringPlatform)(JRIEnv* env, jint op, const jbyte* a, jint b, const jbyte* c, jint d); + const jbyte* (*GetStringPlatformChars)(JRIEnv* env, jint op, struct java_lang_String* a, const jbyte* b, jint c); +}; + +/* +** **************************************************************************** +** JRIEnv Operation IDs +** *************************************************************************** +*/ + +typedef enum JRIEnvOperations { + JRI_Reserved0_op, + JRI_Reserved1_op, + JRI_Reserved2_op, + JRI_Reserved3_op, + JRI_FindClass_op, + JRI_Throw_op, + JRI_ThrowNew_op, + JRI_ExceptionOccurred_op, + JRI_ExceptionDescribe_op, + JRI_ExceptionClear_op, + JRI_NewGlobalRef_op, + JRI_DisposeGlobalRef_op, + JRI_GetGlobalRef_op, + JRI_SetGlobalRef_op, + JRI_IsSameObject_op, + JRI_NewObject_op, + JRI_NewObject_op_va_list, + JRI_NewObject_op_array, + JRI_GetObjectClass_op, + JRI_IsInstanceOf_op, + JRI_GetMethodID_op, + JRI_CallMethod_op, + JRI_CallMethod_op_va_list, + JRI_CallMethod_op_array, + JRI_CallMethodBoolean_op, + JRI_CallMethodBoolean_op_va_list, + JRI_CallMethodBoolean_op_array, + JRI_CallMethodByte_op, + JRI_CallMethodByte_op_va_list, + JRI_CallMethodByte_op_array, + JRI_CallMethodChar_op, + JRI_CallMethodChar_op_va_list, + JRI_CallMethodChar_op_array, + JRI_CallMethodShort_op, + JRI_CallMethodShort_op_va_list, + JRI_CallMethodShort_op_array, + JRI_CallMethodInt_op, + JRI_CallMethodInt_op_va_list, + JRI_CallMethodInt_op_array, + JRI_CallMethodLong_op, + JRI_CallMethodLong_op_va_list, + JRI_CallMethodLong_op_array, + JRI_CallMethodFloat_op, + JRI_CallMethodFloat_op_va_list, + JRI_CallMethodFloat_op_array, + JRI_CallMethodDouble_op, + JRI_CallMethodDouble_op_va_list, + JRI_CallMethodDouble_op_array, + JRI_GetFieldID_op, + JRI_GetField_op, + JRI_GetFieldBoolean_op, + JRI_GetFieldByte_op, + JRI_GetFieldChar_op, + JRI_GetFieldShort_op, + JRI_GetFieldInt_op, + JRI_GetFieldLong_op, + JRI_GetFieldFloat_op, + JRI_GetFieldDouble_op, + JRI_SetField_op, + JRI_SetFieldBoolean_op, + JRI_SetFieldByte_op, + JRI_SetFieldChar_op, + JRI_SetFieldShort_op, + JRI_SetFieldInt_op, + JRI_SetFieldLong_op, + JRI_SetFieldFloat_op, + JRI_SetFieldDouble_op, + JRI_IsSubclassOf_op, + JRI_GetStaticMethodID_op, + JRI_CallStaticMethod_op, + JRI_CallStaticMethod_op_va_list, + JRI_CallStaticMethod_op_array, + JRI_CallStaticMethodBoolean_op, + JRI_CallStaticMethodBoolean_op_va_list, + JRI_CallStaticMethodBoolean_op_array, + JRI_CallStaticMethodByte_op, + JRI_CallStaticMethodByte_op_va_list, + JRI_CallStaticMethodByte_op_array, + JRI_CallStaticMethodChar_op, + JRI_CallStaticMethodChar_op_va_list, + JRI_CallStaticMethodChar_op_array, + JRI_CallStaticMethodShort_op, + JRI_CallStaticMethodShort_op_va_list, + JRI_CallStaticMethodShort_op_array, + JRI_CallStaticMethodInt_op, + JRI_CallStaticMethodInt_op_va_list, + JRI_CallStaticMethodInt_op_array, + JRI_CallStaticMethodLong_op, + JRI_CallStaticMethodLong_op_va_list, + JRI_CallStaticMethodLong_op_array, + JRI_CallStaticMethodFloat_op, + JRI_CallStaticMethodFloat_op_va_list, + JRI_CallStaticMethodFloat_op_array, + JRI_CallStaticMethodDouble_op, + JRI_CallStaticMethodDouble_op_va_list, + JRI_CallStaticMethodDouble_op_array, + JRI_GetStaticFieldID_op, + JRI_GetStaticField_op, + JRI_GetStaticFieldBoolean_op, + JRI_GetStaticFieldByte_op, + JRI_GetStaticFieldChar_op, + JRI_GetStaticFieldShort_op, + JRI_GetStaticFieldInt_op, + JRI_GetStaticFieldLong_op, + JRI_GetStaticFieldFloat_op, + JRI_GetStaticFieldDouble_op, + JRI_SetStaticField_op, + JRI_SetStaticFieldBoolean_op, + JRI_SetStaticFieldByte_op, + JRI_SetStaticFieldChar_op, + JRI_SetStaticFieldShort_op, + JRI_SetStaticFieldInt_op, + JRI_SetStaticFieldLong_op, + JRI_SetStaticFieldFloat_op, + JRI_SetStaticFieldDouble_op, + JRI_NewString_op, + JRI_GetStringLength_op, + JRI_GetStringChars_op, + JRI_NewStringUTF_op, + JRI_GetStringUTFLength_op, + JRI_GetStringUTFChars_op, + JRI_NewScalarArray_op, + JRI_GetScalarArrayLength_op, + JRI_GetScalarArrayElements_op, + JRI_NewObjectArray_op, + JRI_GetObjectArrayLength_op, + JRI_GetObjectArrayElement_op, + JRI_SetObjectArrayElement_op, + JRI_RegisterNatives_op, + JRI_UnregisterNatives_op, + JRI_DefineClass_op, + JRI_NewStringPlatform_op, + JRI_GetStringPlatformChars_op +} JRIEnvOperations; + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ + +#endif /* JRI_H */ +/******************************************************************************/ diff --git a/npapi/jri_md.h b/npapi/jri_md.h new file mode 100644 index 0000000..f18093c --- /dev/null +++ b/npapi/jri_md.h @@ -0,0 +1,565 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: NPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Netscape Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the NPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the NPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +/******************************************************************************* + * Java Runtime Interface - Machine Dependent Types + ******************************************************************************/ + +#ifndef JRI_MD_H +#define JRI_MD_H + +#include +#include "prtypes.h" /* Needed for HAS_LONG_LONG ifdefs */ + +#ifdef __cplusplus +extern "C" { +#endif + +/******************************************************************************* + * WHAT'S UP WITH THIS FILE? + * + * This is where we define the mystical JRI_PUBLIC_API macro that works on all + * platforms. If you're running with Visual C++, Symantec C, or Borland's + * development environment on the PC, you're all set. Or if you're on the Mac + * with Metrowerks, Symantec or MPW with SC you're ok too. For UNIX it shouldn't + * matter. + * + * On UNIX though you probably care about a couple of other symbols though: + * IS_LITTLE_ENDIAN must be defined for little-endian systems + * HAVE_LONG_LONG must be defined on systems that have 'long long' integers + * HAVE_ALIGNED_LONGLONGS must be defined if long-longs must be 8 byte aligned + * HAVE_ALIGNED_DOUBLES must be defined if doubles must be 8 byte aligned + * IS_64 must be defined on 64-bit machines (like Dec Alpha) + ******************************************************************************/ + +/* DLL Entry modifiers... */ + +/* PC */ +#if defined(XP_OS2) +# ifdef XP_OS2_VACPP +# define JRI_PUBLIC_API(ResultType) ResultType _Optlink +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_CALLBACK +# else +# define JRI_PUBLIC_API(ResultType) ResultType +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_CALLBACK +# endif +#elif defined(XP_WIN) || defined(_WINDOWS) || defined(WIN32) || defined(_WIN32) +# include +# if defined(_MSC_VER) || defined(__GNUC__) +# if defined(WIN32) || defined(_WIN32) +# define JRI_PUBLIC_API(ResultType) __declspec(dllexport) ResultType +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) __declspec(dllexport) VarType +# define JRI_PUBLIC_VAR_IMP(VarType) __declspec(dllimport) VarType +# define JRI_NATIVE_STUB(ResultType) __declspec(dllexport) ResultType +# define JRI_CALLBACK +# else /* !_WIN32 */ +# if defined(_WINDLL) +# define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export __loadds +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_NATIVE_STUB(ResultType) ResultType __cdecl __loadds +# define JRI_CALLBACK __loadds +# else /* !WINDLL */ +# define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_NATIVE_STUB(ResultType) ResultType __cdecl __export +# define JRI_CALLBACK __export +# endif /* !WINDLL */ +# endif /* !_WIN32 */ +# elif defined(__BORLANDC__) +# if defined(WIN32) || defined(_WIN32) +# define JRI_PUBLIC_API(ResultType) __export ResultType +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) __export VarType +# define JRI_PUBLIC_VAR_IMP(VarType) __import VarType +# define JRI_NATIVE_STUB(ResultType) __export ResultType +# define JRI_CALLBACK +# else /* !_WIN32 */ +# define JRI_PUBLIC_API(ResultType) ResultType _cdecl _export _loadds +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) __cdecl __export VarType +# define JRI_PUBLIC_VAR_IMP(VarType) __cdecl __import VarType +# define JRI_NATIVE_STUB(ResultType) ResultType _cdecl _loadds +# define JRI_CALLBACK _loadds +# endif +# else +# error Unsupported PC development environment. +# endif +# ifndef IS_LITTLE_ENDIAN +# define IS_LITTLE_ENDIAN +# endif + +/* Mac */ +#elif defined (macintosh) || Macintosh || THINK_C +# if defined(__MWERKS__) /* Metrowerks */ +# if !__option(enumsalwaysint) +# error You need to define 'Enums Always Int' for your project. +# endif +# if defined(TARGET_CPU_68K) && !TARGET_RT_MAC_CFM +# if !__option(fourbyteints) +# error You need to define 'Struct Alignment: 68k' for your project. +# endif +# endif /* !GENERATINGCFM */ +# define JRI_PUBLIC_API(ResultType) __declspec(export) ResultType +# define JRI_PUBLIC_VAR(VarType) JRI_PUBLIC_API(VarType) +# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_API(VarType) +# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_API(VarType) +# define JRI_NATIVE_STUB(ResultType) JRI_PUBLIC_API(ResultType) +# elif defined(__SC__) /* Symantec */ +# error What are the Symantec defines? (warren@netscape.com) +# elif macintosh && applec /* MPW */ +# error Please upgrade to the latest MPW compiler (SC). +# else +# error Unsupported Mac development environment. +# endif +# define JRI_CALLBACK + +/* Unix or else */ +#else +# define JRI_PUBLIC_API(ResultType) ResultType +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_NATIVE_STUB(ResultType) ResultType +# define JRI_CALLBACK +#endif + +#ifndef FAR /* for non-Win16 */ +#define FAR +#endif + +/******************************************************************************/ + +/* Java Scalar Types */ + +#if 0 /* now in jni.h */ +typedef short jchar; +typedef short jshort; +typedef float jfloat; +typedef double jdouble; +typedef juint jsize; +#endif + +/* moved from jni.h -- Sun's new jni.h doesn't have this anymore */ +#ifdef __cplusplus +typedef class _jobject *jref; +#else +typedef struct _jobject *jref; +#endif + +typedef unsigned char jbool; +typedef signed char jbyte; +#ifdef IS_64 /* XXX ok for alpha, but not right on all 64-bit architectures */ +typedef unsigned int juint; +typedef int jint; +#else +typedef unsigned long juint; +typedef long jint; +#endif + +/******************************************************************************* + * jlong : long long (64-bit signed integer type) support. + ******************************************************************************/ + +/* +** Bit masking macros. (n must be <= 31 to be portable) +*/ +#define JRI_BIT(n) ((juint)1 << (n)) +#define JRI_BITMASK(n) (JRI_BIT(n) - 1) + +#ifdef HAVE_LONG_LONG + +#ifdef OSF1 + +/* long is default 64-bit on OSF1, -std1 does not allow long long */ +typedef long jlong; +typedef unsigned long julong; +#define jlong_MAXINT 0x7fffffffffffffffL +#define jlong_MININT 0x8000000000000000L +#define jlong_ZERO 0x0L + +#elif (defined(WIN32) || defined(_WIN32)) + +typedef LONGLONG jlong; +typedef DWORDLONG julong; +#define jlong_MAXINT 0x7fffffffffffffffi64 +#define jlong_MININT 0x8000000000000000i64 +#define jlong_ZERO 0x0i64 + +#else + +typedef long long jlong; +typedef unsigned long long julong; +#define jlong_MAXINT 0x7fffffffffffffffLL +#define jlong_MININT 0x8000000000000000LL +#define jlong_ZERO 0x0LL + +#endif + +#define jlong_IS_ZERO(a) ((a) == 0) +#define jlong_EQ(a, b) ((a) == (b)) +#define jlong_NE(a, b) ((a) != (b)) +#define jlong_GE_ZERO(a) ((a) >= 0) +#define jlong_CMP(a, op, b) ((a) op (b)) + +#define jlong_AND(r, a, b) ((r) = (a) & (b)) +#define jlong_OR(r, a, b) ((r) = (a) | (b)) +#define jlong_XOR(r, a, b) ((r) = (a) ^ (b)) +#define jlong_OR2(r, a) ((r) = (r) | (a)) +#define jlong_NOT(r, a) ((r) = ~(a)) + +#define jlong_NEG(r, a) ((r) = -(a)) +#define jlong_ADD(r, a, b) ((r) = (a) + (b)) +#define jlong_SUB(r, a, b) ((r) = (a) - (b)) + +#define jlong_MUL(r, a, b) ((r) = (a) * (b)) +#define jlong_DIV(r, a, b) ((r) = (a) / (b)) +#define jlong_MOD(r, a, b) ((r) = (a) % (b)) + +#define jlong_SHL(r, a, b) ((r) = (a) << (b)) +#define jlong_SHR(r, a, b) ((r) = (a) >> (b)) +#define jlong_USHR(r, a, b) ((r) = (julong)(a) >> (b)) +#define jlong_ISHL(r, a, b) ((r) = ((jlong)(a)) << (b)) + +#define jlong_L2I(i, l) ((i) = (int)(l)) +#define jlong_L2UI(ui, l) ((ui) =(unsigned int)(l)) +#define jlong_L2F(f, l) ((f) = (l)) +#define jlong_L2D(d, l) ((d) = (l)) + +#define jlong_I2L(l, i) ((l) = (i)) +#define jlong_UI2L(l, ui) ((l) = (ui)) +#define jlong_F2L(l, f) ((l) = (f)) +#define jlong_D2L(l, d) ((l) = (d)) + +#define jlong_UDIVMOD(qp, rp, a, b) \ + (*(qp) = ((julong)(a) / (b)), \ + *(rp) = ((julong)(a) % (b))) + +#else /* !HAVE_LONG_LONG */ + +typedef struct { +#ifdef IS_LITTLE_ENDIAN + juint lo, hi; +#else + juint hi, lo; +#endif +} jlong; +typedef jlong julong; + +extern jlong jlong_MAXINT, jlong_MININT, jlong_ZERO; + +#define jlong_IS_ZERO(a) (((a).hi == 0) && ((a).lo == 0)) +#define jlong_EQ(a, b) (((a).hi == (b).hi) && ((a).lo == (b).lo)) +#define jlong_NE(a, b) (((a).hi != (b).hi) || ((a).lo != (b).lo)) +#define jlong_GE_ZERO(a) (((a).hi >> 31) == 0) + +/* + * NB: jlong_CMP and jlong_UCMP work only for strict relationals (<, >). + */ +#define jlong_CMP(a, op, b) (((int32)(a).hi op (int32)(b).hi) || \ + (((a).hi == (b).hi) && ((a).lo op (b).lo))) +#define jlong_UCMP(a, op, b) (((a).hi op (b).hi) || \ + (((a).hi == (b).hi) && ((a).lo op (b).lo))) + +#define jlong_AND(r, a, b) ((r).lo = (a).lo & (b).lo, \ + (r).hi = (a).hi & (b).hi) +#define jlong_OR(r, a, b) ((r).lo = (a).lo | (b).lo, \ + (r).hi = (a).hi | (b).hi) +#define jlong_XOR(r, a, b) ((r).lo = (a).lo ^ (b).lo, \ + (r).hi = (a).hi ^ (b).hi) +#define jlong_OR2(r, a) ((r).lo = (r).lo | (a).lo, \ + (r).hi = (r).hi | (a).hi) +#define jlong_NOT(r, a) ((r).lo = ~(a).lo, \ + (r).hi = ~(a).hi) + +#define jlong_NEG(r, a) ((r).lo = -(int32)(a).lo, \ + (r).hi = -(int32)(a).hi - ((r).lo != 0)) +#define jlong_ADD(r, a, b) { \ + jlong _a, _b; \ + _a = a; _b = b; \ + (r).lo = _a.lo + _b.lo; \ + (r).hi = _a.hi + _b.hi + ((r).lo < _b.lo); \ +} + +#define jlong_SUB(r, a, b) { \ + jlong _a, _b; \ + _a = a; _b = b; \ + (r).lo = _a.lo - _b.lo; \ + (r).hi = _a.hi - _b.hi - (_a.lo < _b.lo); \ +} \ + +/* + * Multiply 64-bit operands a and b to get 64-bit result r. + * First multiply the low 32 bits of a and b to get a 64-bit result in r. + * Then add the outer and inner products to r.hi. + */ +#define jlong_MUL(r, a, b) { \ + jlong _a, _b; \ + _a = a; _b = b; \ + jlong_MUL32(r, _a.lo, _b.lo); \ + (r).hi += _a.hi * _b.lo + _a.lo * _b.hi; \ +} + +/* XXX _jlong_lo16(a) = ((a) << 16 >> 16) is better on some archs (not on mips) */ +#define _jlong_lo16(a) ((a) & JRI_BITMASK(16)) +#define _jlong_hi16(a) ((a) >> 16) + +/* + * Multiply 32-bit operands a and b to get 64-bit result r. + * Use polynomial expansion based on primitive field element (1 << 16). + */ +#define jlong_MUL32(r, a, b) { \ + juint _a1, _a0, _b1, _b0, _y0, _y1, _y2, _y3; \ + _a1 = _jlong_hi16(a), _a0 = _jlong_lo16(a); \ + _b1 = _jlong_hi16(b), _b0 = _jlong_lo16(b); \ + _y0 = _a0 * _b0; \ + _y1 = _a0 * _b1; \ + _y2 = _a1 * _b0; \ + _y3 = _a1 * _b1; \ + _y1 += _jlong_hi16(_y0); /* can't carry */ \ + _y1 += _y2; /* might carry */ \ + if (_y1 < _y2) _y3 += 1 << 16; /* propagate */ \ + (r).lo = (_jlong_lo16(_y1) << 16) + _jlong_lo16(_y0); \ + (r).hi = _y3 + _jlong_hi16(_y1); \ +} + +/* + * Divide 64-bit unsigned operand a by 64-bit unsigned operand b, setting *qp + * to the 64-bit unsigned quotient, and *rp to the 64-bit unsigned remainder. + * Minimize effort if one of qp and rp is null. + */ +#define jlong_UDIVMOD(qp, rp, a, b) jlong_udivmod(qp, rp, a, b) + +extern JRI_PUBLIC_API(void) +jlong_udivmod(julong *qp, julong *rp, julong a, julong b); + +#define jlong_DIV(r, a, b) { \ + jlong _a, _b; \ + juint _negative = (int32)(a).hi < 0; \ + if (_negative) { \ + jlong_NEG(_a, a); \ + } else { \ + _a = a; \ + } \ + if ((int32)(b).hi < 0) { \ + _negative ^= 1; \ + jlong_NEG(_b, b); \ + } else { \ + _b = b; \ + } \ + jlong_UDIVMOD(&(r), 0, _a, _b); \ + if (_negative) \ + jlong_NEG(r, r); \ +} + +#define jlong_MOD(r, a, b) { \ + jlong _a, _b; \ + juint _negative = (int32)(a).hi < 0; \ + if (_negative) { \ + jlong_NEG(_a, a); \ + } else { \ + _a = a; \ + } \ + if ((int32)(b).hi < 0) { \ + jlong_NEG(_b, b); \ + } else { \ + _b = b; \ + } \ + jlong_UDIVMOD(0, &(r), _a, _b); \ + if (_negative) \ + jlong_NEG(r, r); \ +} + +/* + * NB: b is a juint, not jlong or julong, for the shift ops. + */ +#define jlong_SHL(r, a, b) { \ + if (b) { \ + jlong _a; \ + _a = a; \ + if ((b) < 32) { \ + (r).lo = _a.lo << (b); \ + (r).hi = (_a.hi << (b)) | (_a.lo >> (32 - (b))); \ + } else { \ + (r).lo = 0; \ + (r).hi = _a.lo << ((b) & 31); \ + } \ + } else { \ + (r) = (a); \ + } \ +} + +/* a is an int32, b is int32, r is jlong */ +#define jlong_ISHL(r, a, b) { \ + if (b) { \ + jlong _a; \ + _a.lo = (a); \ + _a.hi = 0; \ + if ((b) < 32) { \ + (r).lo = (a) << (b); \ + (r).hi = ((a) >> (32 - (b))); \ + } else { \ + (r).lo = 0; \ + (r).hi = (a) << ((b) & 31); \ + } \ + } else { \ + (r).lo = (a); \ + (r).hi = 0; \ + } \ +} + +#define jlong_SHR(r, a, b) { \ + if (b) { \ + jlong _a; \ + _a = a; \ + if ((b) < 32) { \ + (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b)); \ + (r).hi = (int32)_a.hi >> (b); \ + } else { \ + (r).lo = (int32)_a.hi >> ((b) & 31); \ + (r).hi = (int32)_a.hi >> 31; \ + } \ + } else { \ + (r) = (a); \ + } \ +} + +#define jlong_USHR(r, a, b) { \ + if (b) { \ + jlong _a; \ + _a = a; \ + if ((b) < 32) { \ + (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b)); \ + (r).hi = _a.hi >> (b); \ + } else { \ + (r).lo = _a.hi >> ((b) & 31); \ + (r).hi = 0; \ + } \ + } else { \ + (r) = (a); \ + } \ +} + +#define jlong_L2I(i, l) ((i) = (l).lo) +#define jlong_L2UI(ui, l) ((ui) = (l).lo) +#define jlong_L2F(f, l) { double _d; jlong_L2D(_d, l); (f) = (float) _d; } + +#define jlong_L2D(d, l) { \ + int32 _negative; \ + jlong _absval; \ + \ + _negative = (l).hi >> 31; \ + if (_negative) { \ + jlong_NEG(_absval, l); \ + } else { \ + _absval = l; \ + } \ + (d) = (double)_absval.hi * 4.294967296e9 + _absval.lo; \ + if (_negative) \ + (d) = -(d); \ +} + +#define jlong_I2L(l, i) ((l).hi = (i) >> 31, (l).lo = (i)) +#define jlong_UI2L(l, ui) ((l).hi = 0, (l).lo = (ui)) +#define jlong_F2L(l, f) { double _d = (double) f; jlong_D2L(l, _d); } + +#define jlong_D2L(l, d) { \ + int _negative; \ + double _absval, _d_hi; \ + jlong _lo_d; \ + \ + _negative = ((d) < 0); \ + _absval = _negative ? -(d) : (d); \ + \ + (l).hi = (juint)(_absval / 4.294967296e9); \ + (l).lo = 0; \ + jlong_L2D(_d_hi, l); \ + _absval -= _d_hi; \ + _lo_d.hi = 0; \ + if (_absval < 0) { \ + _lo_d.lo = (juint) -_absval; \ + jlong_SUB(l, l, _lo_d); \ + } else { \ + _lo_d.lo = (juint) _absval; \ + jlong_ADD(l, l, _lo_d); \ + } \ + \ + if (_negative) \ + jlong_NEG(l, l); \ +} + +#endif /* !HAVE_LONG_LONG */ + +/******************************************************************************/ + +#ifdef HAVE_ALIGNED_LONGLONGS +#define JRI_GET_INT64(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \ + ((_t).x[1] = ((jint*)(_addr))[1]), \ + (_t).l ) +#define JRI_SET_INT64(_t, _addr, _v) ( (_t).l = (_v), \ + ((jint*)(_addr))[0] = (_t).x[0], \ + ((jint*)(_addr))[1] = (_t).x[1] ) +#else +#define JRI_GET_INT64(_t,_addr) (*(jlong*)(_addr)) +#define JRI_SET_INT64(_t, _addr, _v) (*(jlong*)(_addr) = (_v)) +#endif + +/* If double's must be aligned on doubleword boundaries then define this */ +#ifdef HAVE_ALIGNED_DOUBLES +#define JRI_GET_DOUBLE(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \ + ((_t).x[1] = ((jint*)(_addr))[1]), \ + (_t).d ) +#define JRI_SET_DOUBLE(_t, _addr, _v) ( (_t).d = (_v), \ + ((jint*)(_addr))[0] = (_t).x[0], \ + ((jint*)(_addr))[1] = (_t).x[1] ) +#else +#define JRI_GET_DOUBLE(_t,_addr) (*(jdouble*)(_addr)) +#define JRI_SET_DOUBLE(_t, _addr, _v) (*(jdouble*)(_addr) = (_v)) +#endif + +/******************************************************************************/ +#ifdef __cplusplus +} +#endif +#endif /* JRI_MD_H */ +/******************************************************************************/ diff --git a/npapi/jritypes.h b/npapi/jritypes.h new file mode 100644 index 0000000..ddeb633 --- /dev/null +++ b/npapi/jritypes.h @@ -0,0 +1,243 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: NPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Netscape Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the NPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the NPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +/******************************************************************************* + * Java Runtime Interface + ******************************************************************************/ + +#ifndef JRITYPES_H +#define JRITYPES_H + +#include "jri_md.h" +#include "jni.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/******************************************************************************* + * Types + ******************************************************************************/ + +struct JRIEnvInterface; + +typedef void* JRIRef; +typedef void* JRIGlobalRef; + +typedef jint JRIFieldID; +typedef jint JRIMethodID; + +/* synonyms: */ +typedef JRIGlobalRef jglobal; + +typedef union JRIValue { + jbool z; + jbyte b; + jchar c; + jshort s; + jint i; + jlong l; + jfloat f; + jdouble d; + jref r; +} JRIValue; + +typedef enum JRIBoolean { + JRIFalse = 0, + JRITrue = 1 +} JRIBoolean; + +typedef enum JRIConstant { + JRIUninitialized = -1 +} JRIConstant; + +/* convenience types (these must be distinct struct types for c++ overloading): */ +#if 0 /* now in jni.h */ +typedef struct jbooleanArrayStruct* jbooleanArray; +typedef struct jbyteArrayStruct* jbyteArray; +typedef struct jcharArrayStruct* jcharArray; +typedef struct jshortArrayStruct* jshortArray; +typedef struct jintArrayStruct* jintArray; +typedef struct jlongArrayStruct* jlongArray; +typedef struct jfloatArrayStruct* jfloatArray; +typedef struct jdoubleArrayStruct* jdoubleArray; +typedef struct jobjectArrayStruct* jobjectArray; +#endif +typedef struct jstringArrayStruct* jstringArray; +typedef struct jarrayArrayStruct* jarrayArray; + +#define JRIConstructorMethodName "" + +/******************************************************************************* + * Signature Construction Macros + ******************************************************************************/ + +/* +** These macros can be used to construct signature strings. Hopefully their names +** are a little easier to remember than the single character they correspond to. +** For example, to specify the signature of the method: +** +** public int read(byte b[], int off, int len); +** +** you could write something like this in C: +** +** char* readSig = JRISigMethod(JRISigArray(JRISigByte) +** JRISigInt +** JRISigInt) JRISigInt; +** +** Of course, don't put commas between the types. +*/ +#define JRISigArray(T) "[" T +#define JRISigByte "B" +#define JRISigChar "C" +#define JRISigClass(name) "L" name ";" +#define JRISigFloat "F" +#define JRISigDouble "D" +#define JRISigMethod(args) "(" args ")" +#define JRISigNoArgs "" +#define JRISigInt "I" +#define JRISigLong "J" +#define JRISigShort "S" +#define JRISigVoid "V" +#define JRISigBoolean "Z" + +/******************************************************************************* + * Environments + ******************************************************************************/ + +extern JRI_PUBLIC_API(const struct JRIEnvInterface**) +JRI_GetCurrentEnv(void); + +/******************************************************************************* + * Specific Scalar Array Types + ******************************************************************************/ + +/* +** The JRI Native Method Interface does not support boolean arrays. This +** is to allow Java runtime implementations to optimize boolean array +** storage. Using the ScalarArray operations on boolean arrays is bound +** to fail, so convert any boolean arrays to byte arrays in Java before +** passing them to a native method. +*/ + +#define JRI_NewByteArray(env, length, initialValues) \ + JRI_NewScalarArray(env, length, JRISigByte, (jbyte*)(initialValues)) +#define JRI_GetByteArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetByteArrayElements(env, array) \ + JRI_GetScalarArrayElements(env, array) + +#define JRI_NewCharArray(env, length, initialValues) \ + JRI_NewScalarArray(env, ((length) * sizeof(jchar)), JRISigChar, (jbyte*)(initialValues)) +#define JRI_GetCharArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetCharArrayElements(env, array) \ + ((jchar*)JRI_GetScalarArrayElements(env, array)) + +#define JRI_NewShortArray(env, length, initialValues) \ + JRI_NewScalarArray(env, ((length) * sizeof(jshort)), JRISigShort, (jbyte*)(initialValues)) +#define JRI_GetShortArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetShortArrayElements(env, array) \ + ((jshort*)JRI_GetScalarArrayElements(env, array)) + +#define JRI_NewIntArray(env, length, initialValues) \ + JRI_NewScalarArray(env, ((length) * sizeof(jint)), JRISigInt, (jbyte*)(initialValues)) +#define JRI_GetIntArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetIntArrayElements(env, array) \ + ((jint*)JRI_GetScalarArrayElements(env, array)) + +#define JRI_NewLongArray(env, length, initialValues) \ + JRI_NewScalarArray(env, ((length) * sizeof(jlong)), JRISigLong, (jbyte*)(initialValues)) +#define JRI_GetLongArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetLongArrayElements(env, array) \ + ((jlong*)JRI_GetScalarArrayElements(env, array)) + +#define JRI_NewFloatArray(env, length, initialValues) \ + JRI_NewScalarArray(env, ((length) * sizeof(jfloat)), JRISigFloat, (jbyte*)(initialValues)) +#define JRI_GetFloatArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetFloatArrayElements(env, array) \ + ((jfloat*)JRI_GetScalarArrayElements(env, array)) + +#define JRI_NewDoubleArray(env, length, initialValues) \ + JRI_NewScalarArray(env, ((length) * sizeof(jdouble)), JRISigDouble, (jbyte*)(initialValues)) +#define JRI_GetDoubleArrayLength(env, array) \ + JRI_GetScalarArrayLength(env, array) +#define JRI_GetDoubleArrayElements(env, array) \ + ((jdouble*)JRI_GetScalarArrayElements(env, array)) + +/******************************************************************************/ +/* +** JDK Stuff -- This stuff is still needed while we're using the JDK +** dynamic linking strategy to call native methods. +*/ + +typedef union JRI_JDK_stack_item { + /* Non pointer items */ + jint i; + jfloat f; + jint o; + /* Pointer items */ + void *h; + void *p; + unsigned char *addr; +#ifdef IS_64 + double d; + long l; /* == 64bits! */ +#endif +} JRI_JDK_stack_item; + +typedef union JRI_JDK_Java8Str { + jint x[2]; + jdouble d; + jlong l; + void *p; + float f; +} JRI_JDK_Java8; + +/******************************************************************************/ +#ifdef __cplusplus +} +#endif +#endif /* JRITYPES_H */ +/******************************************************************************/ diff --git a/npapi/npapi.h b/npapi/npapi.h new file mode 100644 index 0000000..35909f8 --- /dev/null +++ b/npapi/npapi.h @@ -0,0 +1,717 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: NPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Netscape Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the NPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the NPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + + +/* + * npapi.h $Revision: 3.33.6.1 $ + * Netscape client plug-in API spec + */ + +#ifndef _NPAPI_H_ +#define _NPAPI_H_ + +#ifdef __OS2__ +#pragma pack(1) +#endif + +#include "prtypes.h" +/* Copied from xp_core.h */ +/* removed #ifdef for hpux defined in /usr/include/model.h */ +#ifndef XP_MAC +#ifndef _INT16 +#define _INT16 +#endif +#ifndef _INT32 +#define _INT32 +#endif +#ifndef _UINT16 +#define _UINT16 +#endif +#ifndef _UINT32 +#define _UINT32 +#endif +#endif + +/* + * NO_NSPR_10_SUPPORT disables the inclusion + * of obsolete/protypes.h, whose int16, uint16, + * int32, and uint32 typedefs conflict with those + * in this file. + */ +#ifndef NO_NSPR_10_SUPPORT +#define NO_NSPR_10_SUPPORT +#endif +#ifdef OJI +#include "jri.h" /* Java Runtime Interface */ +#endif + +#if defined (__OS2__ ) || defined (OS2) +# ifndef XP_OS2 +# define XP_OS2 1 +# endif /* XP_OS2 */ +#endif /* __OS2__ */ + +#ifdef _WINDOWS +# include +# ifndef XP_WIN +# define XP_WIN 1 +# endif /* XP_WIN */ +#endif /* _WINDOWS */ + +#ifdef __MWERKS__ +# define _declspec __declspec +# ifdef macintosh +# ifndef XP_MAC +# define XP_MAC 1 +# endif /* XP_MAC */ +# endif /* macintosh */ +# ifdef __INTEL__ +# undef NULL +# ifndef XP_WIN +# define XP_WIN 1 +# endif /* XP_WIN */ +# endif /* __INTEL__ */ +#endif /* __MWERKS__ */ + +#if defined(XP_MAC) || defined(XP_MACOSX) + #include + #include +#endif + +#if defined(XP_UNIX) +# include +# if defined(MOZ_X11) +# include +# include +# endif +#endif + +/*----------------------------------------------------------------------*/ +/* Plugin Version Constants */ +/*----------------------------------------------------------------------*/ + +#define NP_VERSION_MAJOR 0 +#define NP_VERSION_MINOR 14 + + +/* The OS/2 version of Netscape uses RC_DATA to define the + mime types, file extensions, etc that are required. + Use a vertical bar to separate types, end types with \0. + FileVersion and ProductVersion are 32bit ints, all other + entries are strings the MUST be terminated wwith a \0. + +AN EXAMPLE: + +RCDATA NP_INFO_ProductVersion { 1,0,0,1,} + +RCDATA NP_INFO_MIMEType { "video/x-video|", + "video/x-flick\0" } +RCDATA NP_INFO_FileExtents { "avi|", + "flc\0" } +RCDATA NP_INFO_FileOpenName{ "MMOS2 video player(*.avi)|", + "MMOS2 Flc/Fli player(*.flc)\0" } + +RCDATA NP_INFO_FileVersion { 1,0,0,1 } +RCDATA NP_INFO_CompanyName { "Netscape Communications\0" } +RCDATA NP_INFO_FileDescription { "NPAVI32 Extension DLL\0" +RCDATA NP_INFO_InternalName { "NPAVI32\0" ) +RCDATA NP_INFO_LegalCopyright { "Copyright Netscape Communications \251 1996\0" +RCDATA NP_INFO_OriginalFilename { "NVAPI32.DLL" } +RCDATA NP_INFO_ProductName { "NPAVI32 Dynamic Link Library\0" } + +*/ + + +/* RC_DATA types for version info - required */ +#define NP_INFO_ProductVersion 1 +#define NP_INFO_MIMEType 2 +#define NP_INFO_FileOpenName 3 +#define NP_INFO_FileExtents 4 + +/* RC_DATA types for version info - used if found */ +#define NP_INFO_FileDescription 5 +#define NP_INFO_ProductName 6 + +/* RC_DATA types for version info - optional */ +#define NP_INFO_CompanyName 7 +#define NP_INFO_FileVersion 8 +#define NP_INFO_InternalName 9 +#define NP_INFO_LegalCopyright 10 +#define NP_INFO_OriginalFilename 11 + +#ifndef RC_INVOKED + + + +/*----------------------------------------------------------------------*/ +/* Definition of Basic Types */ +/*----------------------------------------------------------------------*/ + +#ifndef _UINT16 +typedef unsigned short uint16; +#endif + +#ifndef _UINT32 +# if defined(__alpha) || defined(__amd64__) || defined(__x86_64__) +typedef unsigned int uint32; +# else /* __alpha */ +typedef unsigned long uint32; +# endif /* __alpha */ +#endif + +/* + * AIX defines these in sys/inttypes.h included from sys/types.h + */ +#ifndef AIX +#ifndef _INT16 +typedef short int16; +#endif + +#ifndef _INT32 +# if defined(__alpha) || defined(__amd64__) || defined(__x86_64__) +typedef int int32; +# else /* __alpha */ +typedef long int32; +# endif /* __alpha */ +#endif +#endif + +#ifndef FALSE +#define FALSE (0) +#endif +#ifndef TRUE +#define TRUE (1) +#endif +#ifndef NULL +#define NULL (0L) +#endif + +typedef unsigned char NPBool; +typedef int16 NPError; +typedef int16 NPReason; +typedef char* NPMIMEType; + + + +/*----------------------------------------------------------------------*/ +/* Structures and definitions */ +/*----------------------------------------------------------------------*/ + +#ifdef XP_MAC +#pragma options align=mac68k +#endif + +/* + * NPP is a plug-in's opaque instance handle + */ +typedef struct _NPP +{ + void* pdata; /* plug-in private data */ + void* ndata; /* netscape private data */ +} NPP_t; + +typedef NPP_t* NPP; + + +typedef struct _NPStream +{ + void* pdata; /* plug-in private data */ + void* ndata; /* netscape private data */ + const char* url; + uint32 end; + uint32 lastmodified; + void* notifyData; +} NPStream; + + +typedef struct _NPByteRange +{ + int32 offset; /* negative offset means from the end */ + uint32 length; + struct _NPByteRange* next; +} NPByteRange; + + +typedef struct _NPSavedData +{ + int32 len; + void* buf; +} NPSavedData; + + +typedef struct _NPRect +{ + uint16 top; + uint16 left; + uint16 bottom; + uint16 right; +} NPRect; + +typedef struct _NPSize +{ + int32 width; + int32 height; +} NPSize; + +#ifdef XP_UNIX +/* + * Unix specific structures and definitions + */ + +/* + * Callback Structures. + * + * These are used to pass additional platform specific information. + */ +enum { + NP_SETWINDOW = 1, + NP_PRINT +}; + +typedef struct +{ + int32 type; +} NPAnyCallbackStruct; + +typedef struct +{ + int32 type; +#ifdef MOZ_X11 + Display* display; + Visual* visual; + Colormap colormap; + unsigned int depth; +#endif +} NPSetWindowCallbackStruct; + +typedef struct +{ + int32 type; + FILE* fp; +} NPPrintCallbackStruct; + +#endif /* XP_UNIX */ + + +/* + * The following masks are applied on certain platforms to NPNV and + * NPPV selectors that pass around pointers to COM interfaces. Newer + * compilers on some platforms may generate vtables that are not + * compatible with older compilers. To prevent older plugins from + * not understanding a new browser's ABI, these masks change the + * values of those selectors on those platforms. To remain backwards + * compatible with differenet versions of the browser, plugins can + * use these masks to dynamically determine and use the correct C++ + * ABI that the browser is expecting. This does not apply to Windows + * as Microsoft's COM ABI will likely not change. + */ + +#define NP_ABI_GCC3_MASK 0x10000000 +/* + * gcc 3.x generated vtables on UNIX and OSX are incompatible with + * previous compilers. + */ +#if (defined (XP_UNIX) && defined(__GNUC__) && (__GNUC__ >= 3)) +#define _NP_ABI_MIXIN_FOR_GCC3 NP_ABI_GCC3_MASK +#else +#define _NP_ABI_MIXIN_FOR_GCC3 0 +#endif + + +#define NP_ABI_MACHO_MASK 0x01000000 +/* + * On OSX, the Mach-O executable format is significantly + * different than CFM. In addition to having a different + * C++ ABI, it also has has different C calling convention. + * You must use glue code when calling between CFM and + * Mach-O C functions. + */ +#if (defined(TARGET_RT_MAC_MACHO)) +#define _NP_ABI_MIXIN_FOR_MACHO NP_ABI_MACHO_MASK +#else +#define _NP_ABI_MIXIN_FOR_MACHO 0 +#endif + + +#define NP_ABI_MASK (_NP_ABI_MIXIN_FOR_GCC3 | _NP_ABI_MIXIN_FOR_MACHO) + +/* + * List of variable names for which NPP_GetValue shall be implemented + */ +typedef enum { + NPPVpluginNameString = 1, + NPPVpluginDescriptionString, + NPPVpluginWindowBool, + NPPVpluginTransparentBool, + NPPVjavaClass, /* Not implemented in Mozilla 1.0 */ + NPPVpluginWindowSize, + NPPVpluginTimerInterval, + + NPPVpluginScriptableInstance = (10 | NP_ABI_MASK), + NPPVpluginScriptableIID = 11, + + /* 12 and over are available on Mozilla builds starting with 0.9.9 */ + NPPVjavascriptPushCallerBool = 12, + NPPVpluginKeepLibraryInMemory = 13, /* available in Mozilla 1.0 */ + NPPVpluginNeedsXEmbed = 14, + + /* Get the NPObject for scripting the plugin. */ + NPPVpluginScriptableNPObject = 15 +} NPPVariable; + +/* + * List of variable names for which NPN_GetValue is implemented by Mozilla + */ +typedef enum { + NPNVxDisplay = 1, + NPNVxtAppContext, + NPNVnetscapeWindow, + NPNVjavascriptEnabledBool, + NPNVasdEnabledBool, + NPNVisOfflineBool, + + /* 10 and over are available on Mozilla builds starting with 0.9.4 */ + NPNVserviceManager = (10 | NP_ABI_MASK), + NPNVDOMElement = (11 | NP_ABI_MASK), /* available in Mozilla 1.2 */ + NPNVDOMWindow = (12 | NP_ABI_MASK), + NPNVToolkit = (13 | NP_ABI_MASK), + NPNVSupportsXEmbedBool = 14, + + /* Get the NPObject wrapper for the browser window. */ + NPNVWindowNPObject = 15, + + /* Get the NPObject wrapper for the plugins DOM element. */ + NPNVPluginElementNPObject = 16 +} NPNVariable; + +/* + * The type of Tookkit the widgets use + */ +typedef enum { + NPNVGtk12 = 1, + NPNVGtk2 +} NPNToolkitType; + +/* + * The type of a NPWindow - it specifies the type of the data structure + * returned in the window field. + */ +typedef enum { + NPWindowTypeWindow = 1, + NPWindowTypeDrawable +} NPWindowType; + +typedef struct _NPWindow +{ + void* window; /* Platform specific window handle */ + /* OS/2: x - Position of bottom left corner */ + /* OS/2: y - relative to visible netscape window */ + int32 x; /* Position of top left corner relative */ + int32 y; /* to a netscape page. */ + uint32 width; /* Maximum window size */ + uint32 height; + NPRect clipRect; /* Clipping rectangle in port coordinates */ + /* Used by MAC only. */ +#if defined(XP_UNIX) && !defined(XP_MACOSX) + void * ws_info; /* Platform-dependent additonal data */ +#endif /* XP_UNIX */ + NPWindowType type; /* Is this a window or a drawable? */ +} NPWindow; + + +typedef struct _NPFullPrint +{ + NPBool pluginPrinted;/* Set TRUE if plugin handled fullscreen printing */ + NPBool printOne; /* TRUE if plugin should print one copy to default printer */ + void* platformPrint; /* Platform-specific printing info */ +} NPFullPrint; + +typedef struct _NPEmbedPrint +{ + NPWindow window; + void* platformPrint; /* Platform-specific printing info */ +} NPEmbedPrint; + +typedef struct _NPPrint +{ + uint16 mode; /* NP_FULL or NP_EMBED */ + union + { + NPFullPrint fullPrint; /* if mode is NP_FULL */ + NPEmbedPrint embedPrint; /* if mode is NP_EMBED */ + } print; +} NPPrint; + +#if defined(XP_MAC) || defined(XP_MACOSX) +typedef EventRecord NPEvent; +#elif defined(XP_WIN) +typedef struct _NPEvent +{ + uint16 event; + uint32 wParam; + uint32 lParam; +} NPEvent; +#elif defined(XP_OS2) +typedef struct _NPEvent +{ + uint32 event; + uint32 wParam; + uint32 lParam; +} NPEvent; +#elif defined (XP_UNIX) && defined(MOZ_X11) +typedef XEvent NPEvent; +#else +typedef void* NPEvent; +#endif /* XP_MAC */ + +#if defined(XP_MAC) || defined(XP_MACOSX) +typedef RgnHandle NPRegion; +#elif defined(XP_WIN) +typedef HRGN NPRegion; +#elif defined(XP_UNIX) && defined(MOZ_X11) +typedef Region NPRegion; +#else +typedef void *NPRegion; +#endif /* XP_MAC */ + +#if defined(XP_MAC) || defined(XP_MACOSX) +/* + * Mac-specific structures and definitions. + */ + +typedef struct NP_Port +{ + CGrafPtr port; /* Grafport */ + int32 portx; /* position inside the topmost window */ + int32 porty; +} NP_Port; + +/* + * Non-standard event types that can be passed to HandleEvent + */ + +enum NPEventType { + NPEventType_GetFocusEvent = (osEvt + 16), + NPEventType_LoseFocusEvent, + NPEventType_AdjustCursorEvent, + NPEventType_MenuCommandEvent, + NPEventType_ClippingChangedEvent, + NPEventType_ScrollingBeginsEvent = 1000, + NPEventType_ScrollingEndsEvent +}; + +#ifdef OBSOLETE +#define getFocusEvent (osEvt + 16) +#define loseFocusEvent (osEvt + 17) +#define adjustCursorEvent (osEvt + 18) +#endif +#endif /* XP_MAC */ + +/* + * Values for mode passed to NPP_New: + */ +#define NP_EMBED 1 +#define NP_FULL 2 + +/* + * Values for stream type passed to NPP_NewStream: + */ +#define NP_NORMAL 1 +#define NP_SEEK 2 +#define NP_ASFILE 3 +#define NP_ASFILEONLY 4 + +#define NP_MAXREADY (((unsigned)(~0)<<1)>>1) + +#ifdef XP_MAC +#pragma options align=reset +#endif + + +/*----------------------------------------------------------------------*/ +/* Error and Reason Code definitions */ +/*----------------------------------------------------------------------*/ + +/* + * Values of type NPError: + */ +#define NPERR_BASE 0 +#define NPERR_NO_ERROR (NPERR_BASE + 0) +#define NPERR_GENERIC_ERROR (NPERR_BASE + 1) +#define NPERR_INVALID_INSTANCE_ERROR (NPERR_BASE + 2) +#define NPERR_INVALID_FUNCTABLE_ERROR (NPERR_BASE + 3) +#define NPERR_MODULE_LOAD_FAILED_ERROR (NPERR_BASE + 4) +#define NPERR_OUT_OF_MEMORY_ERROR (NPERR_BASE + 5) +#define NPERR_INVALID_PLUGIN_ERROR (NPERR_BASE + 6) +#define NPERR_INVALID_PLUGIN_DIR_ERROR (NPERR_BASE + 7) +#define NPERR_INCOMPATIBLE_VERSION_ERROR (NPERR_BASE + 8) +#define NPERR_INVALID_PARAM (NPERR_BASE + 9) +#define NPERR_INVALID_URL (NPERR_BASE + 10) +#define NPERR_FILE_NOT_FOUND (NPERR_BASE + 11) +#define NPERR_NO_DATA (NPERR_BASE + 12) +#define NPERR_STREAM_NOT_SEEKABLE (NPERR_BASE + 13) + +/* + * Values of type NPReason: + */ +#define NPRES_BASE 0 +#define NPRES_DONE (NPRES_BASE + 0) +#define NPRES_NETWORK_ERR (NPRES_BASE + 1) +#define NPRES_USER_BREAK (NPRES_BASE + 2) + +/* + * Don't use these obsolete error codes any more. + */ +#define NP_NOERR NP_NOERR_is_obsolete_use_NPERR_NO_ERROR +#define NP_EINVAL NP_EINVAL_is_obsolete_use_NPERR_GENERIC_ERROR +#define NP_EABORT NP_EABORT_is_obsolete_use_NPRES_USER_BREAK + +/* + * Version feature information + */ +#define NPVERS_HAS_STREAMOUTPUT 8 +#define NPVERS_HAS_NOTIFICATION 9 +#define NPVERS_HAS_LIVECONNECT 9 +#define NPVERS_WIN16_HAS_LIVECONNECT 9 +#define NPVERS_68K_HAS_LIVECONNECT 11 +#define NPVERS_HAS_WINDOWLESS 11 +#define NPVERS_HAS_XPCONNECT_SCRIPTING 13 + +/*----------------------------------------------------------------------*/ +/* Function Prototypes */ +/*----------------------------------------------------------------------*/ + +#if defined(_WINDOWS) && !defined(WIN32) +#define NP_LOADDS _loadds +#else +#if defined(__OS2__) +#define NP_LOADDS _System +#else +#define NP_LOADDS +#endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * NPP_* functions are provided by the plugin and called by the navigator. + */ + +#ifdef XP_UNIX +char* NPP_GetMIMEDescription(void); +#endif /* XP_UNIX */ + +NPError NP_LOADDS NPP_Initialize(void); +void NP_LOADDS NPP_Shutdown(void); +NPError NP_LOADDS NPP_New(NPMIMEType pluginType, NPP instance, + uint16 mode, int16 argc, char* argn[], + char* argv[], NPSavedData* saved); +NPError NP_LOADDS NPP_Destroy(NPP instance, NPSavedData** save); +NPError NP_LOADDS NPP_SetWindow(NPP instance, NPWindow* window); +NPError NP_LOADDS NPP_NewStream(NPP instance, NPMIMEType type, + NPStream* stream, NPBool seekable, + uint16* stype); +NPError NP_LOADDS NPP_DestroyStream(NPP instance, NPStream* stream, + NPReason reason); +int32 NP_LOADDS NPP_WriteReady(NPP instance, NPStream* stream); +int32 NP_LOADDS NPP_Write(NPP instance, NPStream* stream, int32 offset, + int32 len, void* buffer); +void NP_LOADDS NPP_StreamAsFile(NPP instance, NPStream* stream, + const char* fname); +void NP_LOADDS NPP_Print(NPP instance, NPPrint* platformPrint); +int16 NP_LOADDS NPP_HandleEvent(NPP instance, void* event); +void NP_LOADDS NPP_URLNotify(NPP instance, const char* url, + NPReason reason, void* notifyData); +#ifdef OJI +jref NP_LOADDS NPP_GetJavaClass(void); +#endif +NPError NP_LOADDS NPP_GetValue(NPP instance, NPPVariable variable, void *value); +/* + * Uh, shouldn't NPP_SetValue() take an NPPVariable and not an NPNVariable? + */ +NPError NP_LOADDS NPP_SetValue(NPP instance, NPNVariable variable, void *value); + +/* + * NPN_* functions are provided by the navigator and called by the plugin. + */ +void NP_LOADDS NPN_Version(int* plugin_major, int* plugin_minor, + int* netscape_major, int* netscape_minor); +NPError NP_LOADDS NPN_GetURLNotify(NPP instance, const char* url, + const char* target, void* notifyData); +NPError NP_LOADDS NPN_GetURL(NPP instance, const char* url, + const char* target); +NPError NP_LOADDS NPN_PostURLNotify(NPP instance, const char* url, + const char* target, uint32 len, + const char* buf, NPBool file, + void* notifyData); +NPError NP_LOADDS NPN_PostURL(NPP instance, const char* url, + const char* target, uint32 len, + const char* buf, NPBool file); +NPError NP_LOADDS NPN_RequestRead(NPStream* stream, NPByteRange* rangeList); +NPError NP_LOADDS NPN_NewStream(NPP instance, NPMIMEType type, + const char* target, NPStream** stream); +int32 NP_LOADDS NPN_Write(NPP instance, NPStream* stream, int32 len, void* buffer); +NPError NP_LOADDS NPN_DestroyStream(NPP instance, NPStream* stream, NPReason reason); +void NP_LOADDS NPN_Status(NPP instance, const char* message); +const char* NP_LOADDS NPN_UserAgent(NPP instance); +void* NP_LOADDS NPN_MemAlloc(uint32 size); +void NP_LOADDS NPN_MemFree(void* ptr); +uint32 NP_LOADDS NPN_MemFlush(uint32 size); +void NP_LOADDS NPN_ReloadPlugins(NPBool reloadPages); +#ifdef OJI +JRIEnv* NP_LOADDS NPN_GetJavaEnv(void); +jref NP_LOADDS NPN_GetJavaPeer(NPP instance); +#endif +NPError NP_LOADDS NPN_GetValue(NPP instance, NPNVariable variable, void *value); +NPError NP_LOADDS NPN_SetValue(NPP instance, NPPVariable variable, void *value); +void NP_LOADDS NPN_InvalidateRect(NPP instance, NPRect *invalidRect); +void NP_LOADDS NPN_InvalidateRegion(NPP instance, NPRegion invalidRegion); +void NP_LOADDS NPN_ForceRedraw(NPP instance); + +#ifdef __cplusplus +} /* end extern "C" */ +#endif + +#endif /* RC_INVOKED */ +#ifdef __OS2__ +#pragma pack() +#endif + +#endif /* _NPAPI_H_ */ diff --git a/npapi/npruntime.h b/npapi/npruntime.h new file mode 100644 index 0000000..2d1dc02 --- /dev/null +++ b/npapi/npruntime.h @@ -0,0 +1,397 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Copyright © 2004, Apple Computer, Inc. and The Mozilla Foundation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the names of Apple Computer, Inc. ("Apple") or The Mozilla + * Foundation ("Mozilla") nor the names of their contributors may be used + * to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY APPLE, MOZILLA AND THEIR CONTRIBUTORS "AS + * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE, MOZILLA OR + * THEIR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Revision 1 (March 4, 2004): + * Initial proposal. + * + * Revision 2 (March 10, 2004): + * All calls into script were made asynchronous. Results are + * provided via the NPScriptResultFunctionPtr callback. + * + * Revision 3 (March 10, 2004): + * Corrected comments to not refer to class retain/release FunctionPtrs. + * + * Revision 4 (March 11, 2004): + * Added additional convenience NPN_SetExceptionWithUTF8(). + * Changed NPHasPropertyFunctionPtr and NPHasMethodFunctionPtr to take NPClass + * pointers instead of NPObject pointers. + * Added NPIsValidIdentifier(). + * + * Revision 5 (March 17, 2004): + * Added context parameter to result callbacks from ScriptObject functions. + * + * Revision 6 (March 29, 2004): + * Renamed functions implemented by user agent to NPN_*. Removed _ from + * type names. + * Renamed "JavaScript" types to "Script". + * + * Revision 7 (April 21, 2004): + * NPIdentifier becomes a void*, was int32_t + * Remove NP_IsValidIdentifier, renamed NP_IdentifierFromUTF8 to NP_GetIdentifier + * Added NPVariant and modified functions to use this new type. + * + * Revision 8 (July 9, 2004): + * Updated to joint Apple-Mozilla license. + * + */ +#ifndef _NP_RUNTIME_H_ +#define _NP_RUNTIME_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "nptypes.h" + +/* + This API is used to facilitate binding code written in C to script + objects. The API in this header does not assume the presence of a + user agent. That is, it can be used to bind C code to scripting + environments outside of the context of a user agent. + + However, the normal use of the this API is in the context of a + scripting environment running in a browser or other user agent. + In particular it is used to support the extended Netscape + script-ability API for plugins (NP-SAP). NP-SAP is an extension + of the Netscape plugin API. As such we have adopted the use of + the "NP" prefix for this API. + + The following NP{N|P}Variables were added to the Netscape plugin + API (in npapi.h): + + NPNVWindowNPObject + NPNVPluginElementNPObject + NPPVpluginScriptableNPObject + + These variables are exposed through NPN_GetValue() and + NPP_GetValue() (respectively) and are used to establish the + initial binding between the user agent and native code. The DOM + objects in the user agent can be examined and manipulated using + the NPN_ functions that operate on NPObjects described in this + header. + + To the extent possible the assumptions about the scripting + language used by the scripting environment have been minimized. +*/ + +#define NP_BEGIN_MACRO do { +#define NP_END_MACRO } while (0) + +/* + Objects (non-primitive data) passed between 'C' and script is + always wrapped in an NPObject. The 'interface' of an NPObject is + described by an NPClass. +*/ +typedef struct NPObject NPObject; +typedef struct NPClass NPClass; + +typedef char NPUTF8; +typedef struct _NPString { + const NPUTF8 *utf8characters; + uint32_t utf8length; +} NPString; + +typedef enum { + NPVariantType_Void, + NPVariantType_Null, + NPVariantType_Bool, + NPVariantType_Int32, + NPVariantType_Double, + NPVariantType_String, + NPVariantType_Object +} NPVariantType; + +typedef struct _NPVariant { + NPVariantType type; + union { + bool boolValue; + uint32_t intValue; + double doubleValue; + NPString stringValue; + NPObject *objectValue; + } value; +} NPVariant; + +/* + NPN_ReleaseVariantValue is called on all 'out' parameters + references. Specifically it is to be called on variants that own + their value, as is the case with all non-const NPVariant* + arguments after a successful call to any methods (except this one) + in this API. + + After calling NPN_ReleaseVariantValue, the type of the variant + will be NPVariantType_Void. +*/ +void NPN_ReleaseVariantValue(NPVariant *variant); + +#define NPVARIANT_IS_VOID(_v) ((_v).type == NPVariantType_Void) +#define NPVARIANT_IS_NULL(_v) ((_v).type == NPVariantType_Null) +#define NPVARIANT_IS_BOOLEAN(_v) ((_v).type == NPVariantType_Bool) +#define NPVARIANT_IS_INT32(_v) ((_v).type == NPVariantType_Int32) +#define NPVARIANT_IS_DOUBLE(_v) ((_v).type == NPVariantType_Double) +#define NPVARIANT_IS_STRING(_v) ((_v).type == NPVariantType_String) +#define NPVARIANT_IS_OBJECT(_v) ((_v).type == NPVariantType_Object) + +#define NPVARIANT_TO_BOOLEAN(_v) ((_v).value.boolValue) +#define NPVARIANT_TO_INT32(_v) ((_v).value.intValue) +#define NPVARIANT_TO_DOUBLE(_v) ((_v).value.doubleValue) +#define NPVARIANT_TO_STRING(_v) ((_v).value.stringValue) +#define NPVARIANT_TO_OBJECT(_v) ((_v).value.objectValue) + +#define VOID_TO_NPVARIANT(_v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_Void; \ + (_v).value.objectValue = NULL; \ +NP_END_MACRO + +#define NULL_TO_NPVARIANT(_v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_Null; \ + (_v).value.objectValue = NULL; \ +NP_END_MACRO + +#define BOOLEAN_TO_NPVARIANT(_val, _v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_Bool; \ + (_v).value.boolValue = !!(_val); \ +NP_END_MACRO + +#define INT32_TO_NPVARIANT(_val, _v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_Int32; \ + (_v).value.intValue = _val; \ +NP_END_MACRO + +#define DOUBLE_TO_NPVARIANT(_val, _v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_Double; \ + (_v).value.doubleValue = _val; \ +NP_END_MACRO + +#define STRINGZ_TO_NPVARIANT(_val, _v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_String; \ + NPString str = { _val, strlen(_val) }; \ + (_v).value.stringValue = str; \ +NP_END_MACRO + +#define STRINGN_TO_NPVARIANT(_val, _len, _v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_String; \ + NPString str = { _val, _len }; \ + (_v).value.stringValue = str; \ +NP_END_MACRO + +#define OBJECT_TO_NPVARIANT(_val, _v) \ +NP_BEGIN_MACRO \ + (_v).type = NPVariantType_Object; \ + (_v).value.objectValue = _val; \ +NP_END_MACRO + + +/* + Type mappings (JavaScript types have been used for illustration + purposes): + + JavaScript to C (NPVariant with type:) + undefined NPVariantType_Void + null NPVariantType_Null + Boolean NPVariantType_Bool + Number NPVariantType_Double or NPVariantType_Int32 + String NPVariantType_String + Object NPVariantType_Object + + C (NPVariant with type:) to JavaScript + NPVariantType_Void undefined + NPVariantType_Null null + NPVariantType_Bool Boolean + NPVariantType_Int32 Number + NPVariantType_Double Number + NPVariantType_String String + NPVariantType_Object Object +*/ + +typedef void *NPIdentifier; + +/* + NPObjects have methods and properties. Methods and properties are + identified with NPIdentifiers. These identifiers may be reflected + in script. NPIdentifiers can be either strings or integers, IOW, + methods and properties can be identified by either strings or + integers (i.e. foo["bar"] vs foo[1]). NPIdentifiers can be + compared using ==. In case of any errors, the requested + NPIdentifier(s) will be NULL. +*/ +NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name); +void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount, + NPIdentifier *identifiers); +NPIdentifier NPN_GetIntIdentifier(int32_t intid); +bool NPN_IdentifierIsString(NPIdentifier identifier); + +/* + The NPUTF8 returned from NPN_UTF8FromIdentifier SHOULD be freed. +*/ +NPUTF8 *NPN_UTF8FromIdentifier(NPIdentifier identifier); + +/* + Get the integer represented by identifier. If identifier is not an + integer identifier, the behaviour is undefined. +*/ +int32_t NPN_IntFromIdentifier(NPIdentifier identifier); + +/* + NPObject behavior is implemented using the following set of + callback functions. + + The NPVariant *result argument of these functions (where + applicable) should be released using NPN_ReleaseVariantValue(). +*/ +typedef NPObject *(*NPAllocateFunctionPtr)(NPP npp, NPClass *aClass); +typedef void (*NPDeallocateFunctionPtr)(NPObject *npobj); +typedef void (*NPInvalidateFunctionPtr)(NPObject *npobj); +typedef bool (*NPHasMethodFunctionPtr)(NPObject *npobj, NPIdentifier name); +typedef bool (*NPInvokeFunctionPtr)(NPObject *npobj, NPIdentifier name, + const NPVariant *args, uint32_t argCount, + NPVariant *result); +typedef bool (*NPInvokeDefaultFunctionPtr)(NPObject *npobj, + const NPVariant *args, + uint32_t argCount, + NPVariant *result); +typedef bool (*NPHasPropertyFunctionPtr)(NPObject *npobj, NPIdentifier name); +typedef bool (*NPGetPropertyFunctionPtr)(NPObject *npobj, NPIdentifier name, + NPVariant *result); +typedef bool (*NPSetPropertyFunctionPtr)(NPObject *npobj, NPIdentifier name, + const NPVariant *value); +typedef bool (*NPRemovePropertyFunctionPtr)(NPObject *npobj, + NPIdentifier name); + +/* + NPObjects returned by create, retain, invoke, and getProperty pass + a reference count to the caller. That is, the callee adds a + reference count which passes to the caller. It is the caller's + responsibility to release the returned object. + + NPInvokeFunctionPtr function may return 0 to indicate a void + result. + + NPInvalidateFunctionPtr is called by the scripting environment + when the native code is shutdown. Any attempt to message a + NPObject instance after the invalidate callback has been + called will result in undefined behavior, even if the native code + is still retaining those NPObject instances. (The runtime + will typically return immediately, with 0 or NULL, from an attempt + to dispatch to a NPObject, but this behavior should not be + depended upon.) +*/ +struct NPClass +{ + uint32_t structVersion; + NPAllocateFunctionPtr allocate; + NPDeallocateFunctionPtr deallocate; + NPInvalidateFunctionPtr invalidate; + NPHasMethodFunctionPtr hasMethod; + NPInvokeFunctionPtr invoke; + NPInvokeDefaultFunctionPtr invokeDefault; + NPHasPropertyFunctionPtr hasProperty; + NPGetPropertyFunctionPtr getProperty; + NPSetPropertyFunctionPtr setProperty; + NPRemovePropertyFunctionPtr removeProperty; +}; + +#define NP_CLASS_STRUCT_VERSION 1 + +struct NPObject { + NPClass *_class; + uint32_t referenceCount; + /* + * Additional space may be allocated here by types of NPObjects + */ +}; + +/* + If the class has an allocate function, NPN_CreateObject invokes + that function, otherwise a NPObject is allocated and + returned. This method will initialize the referenceCount member of + the NPObject to 1. +*/ +NPObject *NPN_CreateObject(NPP npp, NPClass *aClass); + +/* + Increment the NPObject's reference count. +*/ +NPObject *NPN_RetainObject(NPObject *npobj); + +/* + Decremented the NPObject's reference count. If the reference + count goes to zero, the class's destroy function is invoke if + specified, otherwise the object is freed directly. +*/ +void NPN_ReleaseObject(NPObject *npobj); + +/* + Functions to access script objects represented by NPObject. + + Calls to script objects are synchronous. If a function returns a + value, it will be supplied via the result NPVariant + argument. Successful calls will return true, false will be + returned in case of an error. + + Calls made from plugin code to script must be made from the thread + on which the plugin was initialized. +*/ + +bool NPN_Invoke(NPP npp, NPObject *npobj, NPIdentifier methodName, + const NPVariant *args, uint32_t argCount, NPVariant *result); +bool NPN_InvokeDefault(NPP npp, NPObject *npobj, const NPVariant *args, + uint32_t argCount, NPVariant *result); +bool NPN_Evaluate(NPP npp, NPObject *npobj, NPString *script, + NPVariant *result); +bool NPN_GetProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName, + NPVariant *result); +bool NPN_SetProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName, + const NPVariant *value); +bool NPN_RemoveProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName); +bool NPN_HasProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName); +bool NPN_HasMethod(NPP npp, NPObject *npobj, NPIdentifier methodName); + +/* + NPN_SetException may be called to trigger a script exception upon + return from entry points into NPObjects. Typical usage: + + NPN_SetException (npobj, message); +*/ +void NPN_SetException(NPObject *npobj, const NPUTF8 *message); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/npapi/nptypes.h b/npapi/nptypes.h new file mode 100644 index 0000000..918b649 --- /dev/null +++ b/npapi/nptypes.h @@ -0,0 +1,109 @@ +/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * mozilla.org. + * Portions created by the Initial Developer are Copyright (C) 2004 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Johnny Stenback (Original author) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +/* + * Header file for ensuring that C99 types ([u]int32_t and bool) are + * available. + */ + +#if defined(WIN32) || defined(OS2) + /* + * Win32 and OS/2 don't know C99, so define [u]int_32 here. The bool + * is predefined tho, both in C and C++. + */ + typedef int int32_t; + typedef unsigned int uint32_t; +#elif defined(_AIX) || defined(__sun) || defined(__osf__) || defined(IRIX) + /* + * AIX and SunOS ship a inttypes.h header that defines [u]int32_t, + * but not bool for C. + */ + #include + + #ifndef __cplusplus + typedef int bool; + #endif +#elif defined(bsdi) || defined(FREEBSD) || defined(OPENBSD) + /* + * BSD/OS, FreeBSD, and OpenBSD ship sys/types.h that define int32_t and + * u_int32_t. + */ + #include + + /* + * BSD/OS ships no header that defines uint32_t, nor bool (for C) + * OpenBSD ships no header that defines uint32_t, but provides bool as a + * macro. + */ + #if defined(bsdi) || defined(OPENBSD) + typedef u_int32_t uint32_t; + + #if defined(bsdi) + #if !defined(__cplusplus) + typedef int bool; + #endif + #else /* OPENBSD is defined, so use its bool */ + #include + #endif + #else + /* + * FreeBSD defines uint32_t and bool. + */ + #include + #include + #endif +#elif defined(BEOS) + #include +#else + /* + * For those that ship a standard C99 stdint.h header file, include + * it. Can't do the same for stdbool.h tho, since some systems ship + * with a stdbool.h file that doesn't compile! + */ + #include + + #if !defined(__GNUC__) || (__GNUC__ > 2 || __GNUC_MINOR__ > 95) + #include + #else + /* + * GCC 2.91 can't deal with a typedef for bool, but a #define + * works. + */ + #define bool int + #endif +#endif diff --git a/npapi/npupp.h b/npapi/npupp.h new file mode 100644 index 0000000..274e91e --- /dev/null +++ b/npapi/npupp.h @@ -0,0 +1,1836 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: NPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Netscape Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the NPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the NPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + + +/* + * npupp.h $Revision: 3.15.38.2 $ + * function call mecahnics needed by platform specific glue code. + */ + + +#ifndef _NPUPP_H_ +#define _NPUPP_H_ + +#if defined(__OS2__) +#pragma pack(1) +#endif + +#ifndef GENERATINGCFM +#define GENERATINGCFM 0 +#endif + +#ifndef _NPAPI_H_ +#include "npapi.h" +#endif + +#include "npruntime.h" + +#include "jri.h" + +/****************************************************************************************** + plug-in function table macros + for each function in and out of the plugin API we define + typedef NPP_FooUPP + #define NewNPP_FooProc + #define CallNPP_FooProc + for mac, define the UPP magic for PPC/68K calling + *******************************************************************************************/ + + +/* NPP_Initialize */ + +#define _NPUPP_USE_UPP_ (TARGET_RT_MAC_CFM && !TARGET_API_MAC_CARBON) + +#if _NPUPP_USE_UPP_ +typedef UniversalProcPtr NPP_InitializeUPP; + +enum { + uppNPP_InitializeProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0)) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPP_InitializeProc(FUNC) \ + (NPP_InitializeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_InitializeProcInfo, GetCurrentArchitecture()) +#define CallNPP_InitializeProc(FUNC) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_InitializeProcInfo) + +#else + +typedef void (* NP_LOADDS NPP_InitializeUPP)(void); +#define NewNPP_InitializeProc(FUNC) \ + ((NPP_InitializeUPP) (FUNC)) +#define CallNPP_InitializeProc(FUNC) \ + (*(FUNC))() + +#endif + + +/* NPP_Shutdown */ + +#if _NPUPP_USE_UPP_ +typedef UniversalProcPtr NPP_ShutdownUPP; + +enum { + uppNPP_ShutdownProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0)) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPP_ShutdownProc(FUNC) \ + (NPP_ShutdownUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_ShutdownProcInfo, GetCurrentArchitecture()) +#define CallNPP_ShutdownProc(FUNC) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_ShutdownProcInfo) + +#else + +typedef void (* NP_LOADDS NPP_ShutdownUPP)(void); +#define NewNPP_ShutdownProc(FUNC) \ + ((NPP_ShutdownUPP) (FUNC)) +#define CallNPP_ShutdownProc(FUNC) \ + (*(FUNC))() + +#endif + + +/* NPP_New */ + +#if _NPUPP_USE_UPP_ +typedef UniversalProcPtr NPP_NewUPP; + +enum { + uppNPP_NewProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPMIMEType))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(uint16))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int16))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char **))) + | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(char **))) + | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(NPSavedData *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; + +#define NewNPP_NewProc(FUNC) \ + (NPP_NewUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewProcInfo, GetCurrentArchitecture()) +#define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewProcInfo, \ + (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) +#else + +typedef NPError (* NP_LOADDS NPP_NewUPP)(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved); +#define NewNPP_NewProc(FUNC) \ + ((NPP_NewUPP) (FUNC)) +#define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) + +#endif + + +/* NPP_Destroy */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_DestroyUPP; +enum { + uppNPP_DestroyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPSavedData **))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_DestroyProc(FUNC) \ + (NPP_DestroyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyProcInfo, GetCurrentArchitecture()) +#define CallNPP_DestroyProc(FUNC, ARG1, ARG2) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyProcInfo, (ARG1), (ARG2)) +#else + +typedef NPError (* NP_LOADDS NPP_DestroyUPP)(NPP instance, NPSavedData** save); +#define NewNPP_DestroyProc(FUNC) \ + ((NPP_DestroyUPP) (FUNC)) +#define CallNPP_DestroyProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) + +#endif + + +/* NPP_SetWindow */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_SetWindowUPP; +enum { + uppNPP_SetWindowProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPWindow *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_SetWindowProc(FUNC) \ + (NPP_SetWindowUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_SetWindowProcInfo, GetCurrentArchitecture()) +#define CallNPP_SetWindowProc(FUNC, ARG1, ARG2) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_SetWindowProcInfo, (ARG1), (ARG2)) + +#else + +typedef NPError (* NP_LOADDS NPP_SetWindowUPP)(NPP instance, NPWindow* window); +#define NewNPP_SetWindowProc(FUNC) \ + ((NPP_SetWindowUPP) (FUNC)) +#define CallNPP_SetWindowProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) + +#endif + + +/* NPP_NewStream */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_NewStreamUPP; +enum { + uppNPP_NewStreamProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPMIMEType))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPBool))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(uint16 *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_NewStreamProc(FUNC) \ + (NPP_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewStreamProcInfo, GetCurrentArchitecture()) +#define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewStreamProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5)) +#else + +typedef NPError (* NP_LOADDS NPP_NewStreamUPP)(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16* stype); +#define NewNPP_NewStreamProc(FUNC) \ + ((NPP_NewStreamUPP) (FUNC)) +#define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5)) +#endif + + +/* NPP_DestroyStream */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_DestroyStreamUPP; +enum { + uppNPP_DestroyStreamProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_DestroyStreamProc(FUNC) \ + (NPP_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, GetCurrentArchitecture()) +#define CallNPP_DestroyStreamProc(FUNC, NPParg, NPStreamPtr, NPReasonArg) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, (NPParg), (NPStreamPtr), (NPReasonArg)) + +#else + +typedef NPError (* NP_LOADDS NPP_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason); +#define NewNPP_DestroyStreamProc(FUNC) \ + ((NPP_DestroyStreamUPP) (FUNC)) +#define CallNPP_DestroyStreamProc(FUNC, NPParg, NPStreamPtr, NPReasonArg) \ + (*(FUNC))((NPParg), (NPStreamPtr), (NPReasonArg)) + +#endif + + +/* NPP_WriteReady */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_WriteReadyUPP; +enum { + uppNPP_WriteReadyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) + | RESULT_SIZE(SIZE_CODE(sizeof(int32))) +}; +#define NewNPP_WriteReadyProc(FUNC) \ + (NPP_WriteReadyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, GetCurrentArchitecture()) +#define CallNPP_WriteReadyProc(FUNC, NPParg, NPStreamPtr) \ + (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, (NPParg), (NPStreamPtr)) + +#else + +typedef int32 (* NP_LOADDS NPP_WriteReadyUPP)(NPP instance, NPStream* stream); +#define NewNPP_WriteReadyProc(FUNC) \ + ((NPP_WriteReadyUPP) (FUNC)) +#define CallNPP_WriteReadyProc(FUNC, NPParg, NPStreamPtr) \ + (*(FUNC))((NPParg), (NPStreamPtr)) + +#endif + + +/* NPP_Write */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_WriteUPP; +enum { + uppNPP_WriteProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int32))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int32))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(void*))) + | RESULT_SIZE(SIZE_CODE(sizeof(int32))) +}; +#define NewNPP_WriteProc(FUNC) \ + (NPP_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteProcInfo, GetCurrentArchitecture()) +#define CallNPP_WriteProc(FUNC, NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr) \ + (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteProcInfo, (NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr)) + +#else + +typedef int32 (* NP_LOADDS NPP_WriteUPP)(NPP instance, NPStream* stream, int32 offset, int32 len, void* buffer); +#define NewNPP_WriteProc(FUNC) \ + ((NPP_WriteUPP) (FUNC)) +#define CallNPP_WriteProc(FUNC, NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr) \ + (*(FUNC))((NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr)) + +#endif + + +/* NPP_StreamAsFile */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_StreamAsFileUPP; +enum { + uppNPP_StreamAsFileProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char *))) + | RESULT_SIZE(SIZE_CODE(0)) +}; +#define NewNPP_StreamAsFileProc(FUNC) \ + (NPP_StreamAsFileUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, GetCurrentArchitecture()) +#define CallNPP_StreamAsFileProc(FUNC, ARG1, ARG2, ARG3) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, (ARG1), (ARG2), (ARG3)) + +#else + +typedef void (* NP_LOADDS NPP_StreamAsFileUPP)(NPP instance, NPStream* stream, const char* fname); +#define NewNPP_StreamAsFileProc(FUNC) \ + ((NPP_StreamAsFileUPP) (FUNC)) +#define CallNPP_StreamAsFileProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) +#endif + + +/* NPP_Print */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_PrintUPP; +enum { + uppNPP_PrintProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPrint *))) + | RESULT_SIZE(SIZE_CODE(0)) +}; +#define NewNPP_PrintProc(FUNC) \ + (NPP_PrintUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_PrintProcInfo, GetCurrentArchitecture()) +#define CallNPP_PrintProc(FUNC, NPParg, voidPtr) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_PrintProcInfo, (NPParg), (voidPtr)) + +#else + +typedef void (* NP_LOADDS NPP_PrintUPP)(NPP instance, NPPrint* platformPrint); +#define NewNPP_PrintProc(FUNC) \ + ((NPP_PrintUPP) (FUNC)) +#define CallNPP_PrintProc(FUNC, NPParg, NPPrintArg) \ + (*(FUNC))((NPParg), (NPPrintArg)) + +#endif + + +/* NPP_HandleEvent */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_HandleEventUPP; +enum { + uppNPP_HandleEventProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *))) + | RESULT_SIZE(SIZE_CODE(sizeof(int16))) +}; +#define NewNPP_HandleEventProc(FUNC) \ + (NPP_HandleEventUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_HandleEventProcInfo, GetCurrentArchitecture()) +#define CallNPP_HandleEventProc(FUNC, NPParg, voidPtr) \ + (int16)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_HandleEventProcInfo, (NPParg), (voidPtr)) + +#else + +typedef int16 (* NP_LOADDS NPP_HandleEventUPP)(NPP instance, void* event); +#define NewNPP_HandleEventProc(FUNC) \ + ((NPP_HandleEventUPP) (FUNC)) +#define CallNPP_HandleEventProc(FUNC, NPParg, voidPtr) \ + (*(FUNC))((NPParg), (voidPtr)) + +#endif + + +/* NPP_URLNotify */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_URLNotifyUPP; +enum { + uppNPP_URLNotifyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*))) + | RESULT_SIZE(SIZE_CODE(SIZE_CODE(0))) +}; +#define NewNPP_URLNotifyProc(FUNC) \ + (NPP_URLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, GetCurrentArchitecture()) +#define CallNPP_URLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) + +#else + +typedef void (* NP_LOADDS NPP_URLNotifyUPP)(NPP instance, const char* url, NPReason reason, void* notifyData); +#define NewNPP_URLNotifyProc(FUNC) \ + ((NPP_URLNotifyUPP) (FUNC)) +#define CallNPP_URLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) + +#endif + + +/* NPP_GetValue */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_GetValueUPP; +enum { + uppNPP_GetValueProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPVariable))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_GetValueProc(FUNC) \ + (NPP_GetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_GetValueProcInfo, GetCurrentArchitecture()) +#define CallNPP_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_GetValueProcInfo, (ARG1), (ARG2), (ARG3)) +#else + +typedef NPError (* NP_LOADDS NPP_GetValueUPP)(NPP instance, NPPVariable variable, void *ret_alue); +#define NewNPP_GetValueProc(FUNC) \ + ((NPP_GetValueUPP) (FUNC)) +#define CallNPP_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) +#endif + + +/* NPP_SetValue */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_SetValueUPP; +enum { + uppNPP_SetValueProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPNVariable))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_SetValueProc(FUNC) \ + (NPP_SetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_SetValueProcInfo, GetCurrentArchitecture()) +#define CallNPP_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_SetValueProcInfo, (ARG1), (ARG2), (ARG3)) +#else + +typedef NPError (* NP_LOADDS NPP_SetValueUPP)(NPP instance, NPNVariable variable, void *ret_alue); +#define NewNPP_SetValueProc(FUNC) \ + ((NPP_SetValueUPP) (FUNC)) +#define CallNPP_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) +#endif + + +/* + * Netscape entry points + */ + + +/* NPN_GetValue */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetValueUPP; +enum { + uppNPN_GetValueProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPNVariable))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_GetValueProc(FUNC) \ + (NPN_GetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetValueProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetValueProcInfo, (ARG1), (ARG2), (ARG3)) +#else + +typedef NPError (* NP_LOADDS NPN_GetValueUPP)(NPP instance, NPNVariable variable, void *ret_alue); +#define NewNPN_GetValueProc(FUNC) \ + ((NPN_GetValueUPP) (FUNC)) +#define CallNPN_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) +#endif + + +/* NPN_SetValue */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_SetValueUPP; +enum { + uppNPN_SetValueProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPVariable))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_SetValueProc(FUNC) \ + (NPN_SetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_SetValueProcInfo, GetCurrentArchitecture()) +#define CallNPN_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_SetValueProcInfo, (ARG1), (ARG2), (ARG3)) +#else + +typedef NPError (* NP_LOADDS NPN_SetValueUPP)(NPP instance, NPPVariable variable, void *ret_alue); +#define NewNPN_SetValueProc(FUNC) \ + ((NPN_SetValueUPP) (FUNC)) +#define CallNPN_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) +#endif + + +/* NPN_GetUrlNotify */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetURLNotifyUPP; +enum { + uppNPN_GetURLNotifyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_GetURLNotifyProc(FUNC) \ + (NPN_GetURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) +#else + +typedef NPError (* NP_LOADDS NPN_GetURLNotifyUPP)(NPP instance, const char* url, const char* window, void* notifyData); +#define NewNPN_GetURLNotifyProc(FUNC) \ + ((NPN_GetURLNotifyUPP) (FUNC)) +#define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) +#endif + + +/* NPN_PostUrlNotify */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_PostURLNotifyUPP; +enum { + uppNPN_PostURLNotifyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(uint32))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPBool))) + | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(void*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_PostURLNotifyProc(FUNC) \ + (NPN_PostURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, GetCurrentArchitecture()) +#define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) +#else + +typedef NPError (* NP_LOADDS NPN_PostURLNotifyUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file, void* notifyData); +#define NewNPN_PostURLNotifyProc(FUNC) \ + ((NPN_PostURLNotifyUPP) (FUNC)) +#define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) +#endif + + +/* NPN_GetUrl */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetURLUPP; +enum { + uppNPN_GetURLProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_GetURLProc(FUNC) \ + (NPN_GetURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLProcInfo, (ARG1), (ARG2), (ARG3)) +#else + +typedef NPError (* NP_LOADDS NPN_GetURLUPP)(NPP instance, const char* url, const char* window); +#define NewNPN_GetURLProc(FUNC) \ + ((NPN_GetURLUPP) (FUNC)) +#define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) +#endif + + +/* NPN_PostUrl */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_PostURLUPP; +enum { + uppNPN_PostURLProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(uint32))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(const char*))) + | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPBool))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_PostURLProc(FUNC) \ + (NPN_PostURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLProcInfo, GetCurrentArchitecture()) +#define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6)) +#else + +typedef NPError (* NP_LOADDS NPN_PostURLUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file); +#define NewNPN_PostURLProc(FUNC) \ + ((NPN_PostURLUPP) (FUNC)) +#define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6)) +#endif + + +/* NPN_RequestRead */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_RequestReadUPP; +enum { + uppNPN_RequestReadProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPByteRange *))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_RequestReadProc(FUNC) \ + (NPN_RequestReadUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_RequestReadProcInfo, GetCurrentArchitecture()) +#define CallNPN_RequestReadProc(FUNC, stream, range) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_RequestReadProcInfo, (stream), (range)) + +#else + +typedef NPError (* NP_LOADDS NPN_RequestReadUPP)(NPStream* stream, NPByteRange* rangeList); +#define NewNPN_RequestReadProc(FUNC) \ + ((NPN_RequestReadUPP) (FUNC)) +#define CallNPN_RequestReadProc(FUNC, stream, range) \ + (*(FUNC))((stream), (range)) + +#endif + + +/* NPN_NewStream */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_NewStreamUPP; +enum { + uppNPN_NewStreamProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPMIMEType))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char *))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPStream **))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_NewStreamProc(FUNC) \ + (NPN_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_NewStreamProcInfo, GetCurrentArchitecture()) +#define CallNPN_NewStreamProc(FUNC, npp, type, window, stream) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_NewStreamProcInfo, (npp), (type), (window), (stream)) + +#else + +typedef NPError (* NP_LOADDS NPN_NewStreamUPP)(NPP instance, NPMIMEType type, const char* window, NPStream** stream); +#define NewNPN_NewStreamProc(FUNC) \ + ((NPN_NewStreamUPP) (FUNC)) +#define CallNPN_NewStreamProc(FUNC, npp, type, window, stream) \ + (*(FUNC))((npp), (type), (window), (stream)) + +#endif + + +/* NPN_Write */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_WriteUPP; +enum { + uppNPN_WriteProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int32))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*))) + | RESULT_SIZE(SIZE_CODE(sizeof(int32))) +}; +#define NewNPN_WriteProc(FUNC) \ + (NPN_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_WriteProcInfo, GetCurrentArchitecture()) +#define CallNPN_WriteProc(FUNC, npp, stream, len, buffer) \ + (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_WriteProcInfo, (npp), (stream), (len), (buffer)) + +#else + +typedef int32 (* NP_LOADDS NPN_WriteUPP)(NPP instance, NPStream* stream, int32 len, void* buffer); +#define NewNPN_WriteProc(FUNC) \ + ((NPN_WriteUPP) (FUNC)) +#define CallNPN_WriteProc(FUNC, npp, stream, len, buffer) \ + (*(FUNC))((npp), (stream), (len), (buffer)) + +#endif + + +/* NPN_DestroyStream */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_DestroyStreamUPP; +enum { + uppNPN_DestroyStreamProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP ))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPN_DestroyStreamProc(FUNC) \ + (NPN_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, GetCurrentArchitecture()) +#define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, (npp), (stream), (reason)) + +#else + +typedef NPError (* NP_LOADDS NPN_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason); +#define NewNPN_DestroyStreamProc(FUNC) \ + ((NPN_DestroyStreamUPP) (FUNC)) +#define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason) \ + (*(FUNC))((npp), (stream), (reason)) + +#endif + + +/* NPN_Status */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_StatusUPP; +enum { + uppNPN_StatusProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *))) +}; + +#define NewNPN_StatusProc(FUNC) \ + (NPN_StatusUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_StatusProcInfo, GetCurrentArchitecture()) +#define CallNPN_StatusProc(FUNC, npp, msg) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_StatusProcInfo, (npp), (msg)) + +#else + +typedef void (* NP_LOADDS NPN_StatusUPP)(NPP instance, const char* message); +#define NewNPN_StatusProc(FUNC) \ + ((NPN_StatusUPP) (FUNC)) +#define CallNPN_StatusProc(FUNC, npp, msg) \ + (*(FUNC))((npp), (msg)) + +#endif + + +/* NPN_UserAgent */ +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_UserAgentUPP; +enum { + uppNPN_UserAgentProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | RESULT_SIZE(SIZE_CODE(sizeof(const char *))) +}; + +#define NewNPN_UserAgentProc(FUNC) \ + (NPN_UserAgentUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_UserAgentProcInfo, GetCurrentArchitecture()) +#define CallNPN_UserAgentProc(FUNC, ARG1) \ + (const char*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_UserAgentProcInfo, (ARG1)) + +#else + +typedef const char* (* NP_LOADDS NPN_UserAgentUPP)(NPP instance); +#define NewNPN_UserAgentProc(FUNC) \ + ((NPN_UserAgentUPP) (FUNC)) +#define CallNPN_UserAgentProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + + +/* NPN_MemAlloc */ +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_MemAllocUPP; +enum { + uppNPN_MemAllocProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(uint32))) + | RESULT_SIZE(SIZE_CODE(sizeof(void *))) +}; + +#define NewNPN_MemAllocProc(FUNC) \ + (NPN_MemAllocUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemAllocProcInfo, GetCurrentArchitecture()) +#define CallNPN_MemAllocProc(FUNC, ARG1) \ + (void*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemAllocProcInfo, (ARG1)) + +#else + +typedef void* (* NP_LOADDS NPN_MemAllocUPP)(uint32 size); +#define NewNPN_MemAllocProc(FUNC) \ + ((NPN_MemAllocUPP) (FUNC)) +#define CallNPN_MemAllocProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + + +/* NPN__MemFree */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_MemFreeUPP; +enum { + uppNPN_MemFreeProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(void *))) +}; + +#define NewNPN_MemFreeProc(FUNC) \ + (NPN_MemFreeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFreeProcInfo, GetCurrentArchitecture()) +#define CallNPN_MemFreeProc(FUNC, ARG1) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFreeProcInfo, (ARG1)) + +#else + +typedef void (* NP_LOADDS NPN_MemFreeUPP)(void* ptr); +#define NewNPN_MemFreeProc(FUNC) \ + ((NPN_MemFreeUPP) (FUNC)) +#define CallNPN_MemFreeProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + + +/* NPN_MemFlush */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_MemFlushUPP; +enum { + uppNPN_MemFlushProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(uint32))) + | RESULT_SIZE(SIZE_CODE(sizeof(uint32))) +}; + +#define NewNPN_MemFlushProc(FUNC) \ + (NPN_MemFlushUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFlushProcInfo, GetCurrentArchitecture()) +#define CallNPN_MemFlushProc(FUNC, ARG1) \ + (uint32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFlushProcInfo, (ARG1)) + +#else + +typedef uint32 (* NP_LOADDS NPN_MemFlushUPP)(uint32 size); +#define NewNPN_MemFlushProc(FUNC) \ + ((NPN_MemFlushUPP) (FUNC)) +#define CallNPN_MemFlushProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + + + +/* NPN_ReloadPlugins */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_ReloadPluginsUPP; +enum { + uppNPN_ReloadPluginsProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPBool))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_ReloadPluginsProc(FUNC) \ + (NPN_ReloadPluginsUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, GetCurrentArchitecture()) +#define CallNPN_ReloadPluginsProc(FUNC, ARG1) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, (ARG1)) + +#else + +typedef void (* NP_LOADDS NPN_ReloadPluginsUPP)(NPBool reloadPages); +#define NewNPN_ReloadPluginsProc(FUNC) \ + ((NPN_ReloadPluginsUPP) (FUNC)) +#define CallNPN_ReloadPluginsProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_GetJavaEnv */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetJavaEnvUPP; +enum { + uppNPN_GetJavaEnvProcInfo = kThinkCStackBased + | RESULT_SIZE(SIZE_CODE(sizeof(JRIEnv*))) +}; + +#define NewNPN_GetJavaEnvProc(FUNC) \ + (NPN_GetJavaEnvUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetJavaEnvProc(FUNC) \ + (JRIEnv*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo) + +#else +typedef JRIEnv* (* NP_LOADDS NPN_GetJavaEnvUPP)(void); +#define NewNPN_GetJavaEnvProc(FUNC) \ + ((NPN_GetJavaEnvUPP) (FUNC)) +#define CallNPN_GetJavaEnvProc(FUNC) \ + (*(FUNC))() + +#endif + + +/* NPN_GetJavaPeer */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetJavaPeerUPP; +enum { + uppNPN_GetJavaPeerProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | RESULT_SIZE(SIZE_CODE(sizeof(jref))) +}; + +#define NewNPN_GetJavaPeerProc(FUNC) \ + (NPN_GetJavaPeerUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetJavaPeerProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, (ARG1)) + +#else + +typedef jref (* NP_LOADDS NPN_GetJavaPeerUPP)(NPP instance); +#define NewNPN_GetJavaPeerProc(FUNC) \ + ((NPN_GetJavaPeerUPP) (FUNC)) +#define CallNPN_GetJavaPeerProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_InvalidateRect */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_InvalidateRectUPP; +enum { + uppNPN_InvalidateRectProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPRect *))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_InvalidateRectProc(FUNC) \ + (NPN_InvalidateRectUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvalidateRectProcInfo, GetCurrentArchitecture()) +#define CallNPN_InvalidateRectProc(FUNC, ARG1, ARG2) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvalidateRectProcInfo, (ARG1), (ARG2)) + +#else + +typedef void (* NP_LOADDS NPN_InvalidateRectUPP)(NPP instance, NPRect *rect); +#define NewNPN_InvalidateRectProc(FUNC) \ + ((NPN_InvalidateRectUPP) (FUNC)) +#define CallNPN_InvalidateRectProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) + +#endif + + +/* NPN_InvalidateRegion */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_InvalidateRegionUPP; +enum { + uppNPN_InvalidateRegionProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPRegion))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_InvalidateRegionProc(FUNC) \ + (NPN_InvalidateRegionUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvalidateRegionProcInfo, GetCurrentArchitecture()) +#define CallNPN_InvalidateRegionProc(FUNC, ARG1, ARG2) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvalidateRegionProcInfo, (ARG1), (ARG2)) + +#else + +typedef void (* NP_LOADDS NPN_InvalidateRegionUPP)(NPP instance, NPRegion region); +#define NewNPN_InvalidateRegionProc(FUNC) \ + ((NPN_InvalidateRegionUPP) (FUNC)) +#define CallNPN_InvalidateRegionProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) + +#endif + +/* NPN_ForceRedraw */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_ForceRedrawUPP; +enum { + uppNPN_ForceRedrawProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | RESULT_SIZE(SIZE_CODE(sizeof(0))) +}; + +#define NewNPN_ForceRedrawProc(FUNC) \ + (NPN_ForceRedrawUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ForceRedrawProcInfo, GetCurrentArchitecture()) +#define CallNPN_ForceRedrawProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ForceRedrawProcInfo, (ARG1)) + +#else + +typedef void (* NP_LOADDS NPN_ForceRedrawUPP)(NPP instance); +#define NewNPN_ForceRedrawProc(FUNC) \ + ((NPN_ForceRedrawUPP) (FUNC)) +#define CallNPN_ForceRedrawProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_GetStringIdentifier */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetStringIdentifierUPP; +enum { + uppNPN_GetStringIdentifierProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(const NPUTF8*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPIdentifier))) +}; + +#define NewNPN_GetStringIdentifierProc(FUNC) \ + (NPN_GetStringIdentifierUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetStringIdentifierProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetStringIdentifierProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetStringIdentifierProcInfo, (ARG1)) + +#else + +typedef NPIdentifier (* NP_LOADDS NPN_GetStringIdentifierUPP)(const NPUTF8* name); +#define NewNPN_GetStringIdentifierProc(FUNC) \ + ((NPN_GetStringIdentifierUPP) (FUNC)) +#define CallNPN_GetStringIdentifierProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_GetStringIdentifiers */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetStringIdentifiersUPP; +enum { + uppNPN_GetStringIdentifiersProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(const NPUTF8**))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(int32_t))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier*))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_GetStringIdentifiersProc(FUNC) \ + (NPN_GetStringIdentifiersUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetStringIdentifiersProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetStringIdentifiersProc(FUNC, ARG1, ARG2, ARG3) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetStringIdentifiersProcInfo, (ARG1), (ARG2), (ARG3)) + +#else + +typedef void (* NP_LOADDS NPN_GetStringIdentifiersUPP)(const NPUTF8** names, + int32_t nameCount, + NPIdentifier* identifiers); +#define NewNPN_GetStringIdentifiersProc(FUNC) \ + ((NPN_GetStringIdentifiersUPP) (FUNC)) +#define CallNPN_GetStringIdentifiersProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) + +#endif + +/* NPN_GetIntIdentifier */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetIntIdentifierUPP; +enum { + uppNPN_GetIntIdentifierProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int32_t))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPIdentifier))) +}; + +#define NewNPN_GetIntIdentifierProc(FUNC) \ + (NPN_GetIntIdentifierUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetIntIdentifierProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetIntIdentifierProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetIntIdentifierProcInfo, (ARG1)) + +#else + +typedef NPIdentifier (* NP_LOADDS NPN_GetIntIdentifierUPP)(int32_t intid); +#define NewNPN_GetIntIdentifierProc(FUNC) \ + ((NPN_GetIntIdentifierUPP) (FUNC)) +#define CallNPN_GetIntIdentifierProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_IdentifierIsString */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_IdentifierIsStringUPP; +enum { + uppNPN_IdentifierIsStringProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPIdentifier identifier))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_IdentifierIsStringProc(FUNC) \ + (NPN_IdentifierIsStringUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_IdentifierIsStringProcInfo, GetCurrentArchitecture()) +#define CallNPN_IdentifierIsStringProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_IdentifierIsStringProcInfo, (ARG1)) + +#else + +typedef bool (* NP_LOADDS NPN_IdentifierIsStringUPP)(NPIdentifier identifier); +#define NewNPN_IdentifierIsStringProc(FUNC) \ + ((NPN_IdentifierIsStringUPP) (FUNC)) +#define CallNPN_IdentifierIsStringProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_UTF8FromIdentifier */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_UTF8FromIdentifierUPP; +enum { + uppNPN_UTF8FromIdentifierProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPIdentifier))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPUTF8*))) +}; + +#define NewNPN_UTF8FromIdentifierProc(FUNC) \ + (NPN_UTF8FromIdentifierUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_UTF8FromIdentifierProcInfo, GetCurrentArchitecture()) +#define CallNPN_UTF8FromIdentifierProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_UTF8FromIdentifierProcInfo, (ARG1)) + +#else + +typedef NPUTF8* (* NP_LOADDS NPN_UTF8FromIdentifierUPP)(NPIdentifier identifier); +#define NewNPN_UTF8FromIdentifierProc(FUNC) \ + ((NPN_UTF8FromIdentifierUPP) (FUNC)) +#define CallNPN_UTF8FromIdentifierProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_IntFromIdentifier */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_IntFromIdentifierUPP; +enum { + uppNPN_IntFromIdentifierProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPIdentifier))) + | RESULT_SIZE(SIZE_CODE(sizeof(int32_t))) +}; + +#define NewNPN_IntFromIdentifierProc(FUNC) \ + (NPN_IntFromIdentifierUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_IntFromIdentifierProcInfo, GetCurrentArchitecture()) +#define CallNPN_IntFromIdentifierProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_IntFromIdentifierProcInfo, (ARG1)) + +#else + +typedef int32_t (* NP_LOADDS NPN_IntFromIdentifierUPP)(NPIdentifier identifier); +#define NewNPN_IntFromIdentifierProc(FUNC) \ + ((NPN_IntFromIdentifierUPP) (FUNC)) +#define CallNPN_IntFromIdentifierProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_CreateObject */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_CreateObjectUPP; +enum { + uppNPN_CreateObjectProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPClass*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPObject*))) +}; + +#define NewNPN_CreateObjectProc(FUNC) \ + (NPN_CreateObjectUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_CreateObjectProcInfo, GetCurrentArchitecture()) +#define CallNPN_CreateObjectProc(FUNC, ARG1, ARG2) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_CreateObjectProcInfo, (ARG1), (ARG2)) + +#else + +typedef NPObject* (* NP_LOADDS NPN_CreateObjectUPP)(NPP npp, NPClass *aClass); +#define NewNPN_CreateObjectProc(FUNC) \ + ((NPN_CreateObjectUPP) (FUNC)) +#define CallNPN_CreateObjectProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) + +#endif + +/* NPN_RetainObject */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_RetainObjectUPP; +enum { + uppNPN_RetainObjectProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPObject*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPObject*))) +}; + +#define NewNPN_RetainObjectProc(FUNC) \ + (NPN_RetainObjectUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_RetainObjectProcInfo, GetCurrentArchitecture()) +#define CallNPN_RetainObjectProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_RetainObjectProcInfo, (ARG1)) + +#else + +typedef NPObject* (* NP_LOADDS NPN_RetainObjectUPP)(NPObject *obj); +#define NewNPN_RetainObjectProc(FUNC) \ + ((NPN_RetainObjectUPP) (FUNC)) +#define CallNPN_RetainObjectProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_ReleaseObject */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_ReleaseObjectUPP; +enum { + uppNPN_ReleaseObjectProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPObject*))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_ReleaseObjectProc(FUNC) \ + (NPN_ReleaseObjectUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ReleaseObjectProcInfo, GetCurrentArchitecture()) +#define CallNPN_ReleaseObjectProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReleaseObjectProcInfo, (ARG1)) + +#else + +typedef void (* NP_LOADDS NPN_ReleaseObjectUPP)(NPObject *obj); +#define NewNPN_ReleaseObjectProc(FUNC) \ + ((NPN_ReleaseObjectUPP) (FUNC)) +#define CallNPN_ReleaseObjectProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_Invoke */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_InvokeUPP; +enum { + uppNPN_InvokeProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(const NPVariant*))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(uint32_t))) + | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPVariant*))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_InvokeProc(FUNC) \ + (NPN_InvokeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvokeProcInfo, GetCurrentArchitecture()) +#define CallNPN_InvokeProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvokeProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6)) + +#else + +typedef bool (* NP_LOADDS NPN_InvokeUPP)(NPP npp, NPObject* obj, NPIdentifier methodName, const NPVariant *args, uint32_t argCount, NPVariant *result); +#define NewNPN_InvokeProc(FUNC) \ + ((NPN_InvokeUPP) (FUNC)) +#define CallNPN_InvokeProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6)) + +#endif + +/* NPN_InvokeDefault */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_InvokeDefaultUPP; +enum { + uppNPN_InvokeDefaultProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(const NPVariant*))) + | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(uint32_t))) + | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPVariant*))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_InvokeDefaultProc(FUNC) \ + (NPN_InvokeDefaultUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvokeDefaultProcInfo, GetCurrentArchitecture()) +#define CallNPN_InvokeDefaultProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvokeDefaultProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5)) + +#else + +typedef bool (* NP_LOADDS NPN_InvokeDefaultUPP)(NPP npp, NPObject* obj, const NPVariant *args, uint32_t argCount, NPVariant *result); +#define NewNPN_InvokeDefaultProc(FUNC) \ + ((NPN_InvokeDefaultUPP) (FUNC)) +#define CallNPN_InvokeDefaultProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5)) + +#endif + +/* NPN_Evaluate */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_EvaluateUPP; +enum { + uppNPN_EvaluateProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPString*))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPVariant*))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_EvaluateProc(FUNC) \ + (NPN_EvaluateUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_EvaluateProcInfo, GetCurrentArchitecture()) +#define CallNPN_EvaluateProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_EvaluateProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) + +#else + +typedef bool (* NP_LOADDS NPN_EvaluateUPP)(NPP npp, NPObject *obj, NPString *script, NPVariant *result); +#define NewNPN_EvaluateProc(FUNC) \ + ((NPN_EvaluateUPP) (FUNC)) +#define CallNPN_EvaluateProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) + +#endif + +/* NPN_GetProperty */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_GetPropertyUPP; +enum { + uppNPN_GetPropertyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPVariant*))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_GetPropertyProc(FUNC) \ + (NPN_GetPropertyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetPropertyProcInfo, GetCurrentArchitecture()) +#define CallNPN_GetPropertyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetPropertyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) + +#else + +typedef bool (* NP_LOADDS NPN_GetPropertyUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName, NPVariant *result); +#define NewNPN_GetPropertyProc(FUNC) \ + ((NPN_GetPropertyUPP) (FUNC)) +#define CallNPN_GetPropertyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) + +#endif + +/* NPN_SetProperty */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_SetPropertyUPP; +enum { + uppNPN_SetPropertyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier))) + | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(const NPVariant*))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_SetPropertyProc(FUNC) \ + (NPN_SetPropertyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_SetPropertyProcInfo, GetCurrentArchitecture()) +#define CallNPN_SetPropertyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_SetPropertyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) + +#else + +typedef bool (* NP_LOADDS NPN_SetPropertyUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName, const NPVariant *value); +#define NewNPN_SetPropertyProc(FUNC) \ + ((NPN_SetPropertyUPP) (FUNC)) +#define CallNPN_SetPropertyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ + (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) + +#endif + +/* NPN_RemoveProperty */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_RemovePropertyUPP; +enum { + uppNPN_RemovePropertyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_RemovePropertyProc(FUNC) \ + (NPN_RemovePropertyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_RemovePropertyProcInfo, GetCurrentArchitecture()) +#define CallNPN_RemovePropertyProc(FUNC, ARG1, ARG2, ARG3) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_RemovePropertyProcInfo, (ARG1), (ARG2), (ARG3)) + +#else + +typedef bool (* NP_LOADDS NPN_RemovePropertyUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName); +#define NewNPN_RemovePropertyProc(FUNC) \ + ((NPN_RemovePropertyUPP) (FUNC)) +#define CallNPN_RemovePropertyProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) + +#endif + +/* NPN_HasProperty */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_HasPropertyUPP; +enum { + uppNPN_HasPropertyProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_HasPropertyProc(FUNC) \ + (NPN_HasPropertyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_HasPropertyProcInfo, GetCurrentArchitecture()) +#define CallNPN_HasPropertyProc(FUNC, ARG1, ARG2, ARG3) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_HasPropertyProcInfo, (ARG1), (ARG2), (ARG3)) + +#else + +typedef bool (* NP_LOADDS NPN_HasPropertyUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName); +#define NewNPN_HasPropertyProc(FUNC) \ + ((NPN_HasPropertyUPP) (FUNC)) +#define CallNPN_HasPropertyProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) + +#endif + +/* NPN_HasMethod */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_HasMethodUPP; +enum { + uppNPN_HasMethodProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPP))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPIdentifier))) + | RESULT_SIZE(SIZE_CODE(sizeof(bool))) +}; + +#define NewNPN_HasMethodProc(FUNC) \ + (NPN_HasMethodUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_HasMethodProcInfo, GetCurrentArchitecture()) +#define CallNPN_HasMethodProc(FUNC, ARG1, ARG2, ARG3) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_HasMethodProcInfo, (ARG1), (ARG2), (ARG3)) + +#else + +typedef bool (* NP_LOADDS NPN_HasMethodUPP)(NPP npp, NPObject *obj, NPIdentifier propertyName); +#define NewNPN_HasMethodProc(FUNC) \ + ((NPN_HasMethodUPP) (FUNC)) +#define CallNPN_HasMethodProc(FUNC, ARG1, ARG2, ARG3) \ + (*(FUNC))((ARG1), (ARG2), (ARG3)) + +#endif + +/* NPN_ReleaseVariantValue */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_ReleaseVariantValue; +enum { + uppNPN_ReleaseVariantValueProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPVariant*))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_ReleaseVariantValueProc(FUNC) \ + (NPN_ReleaseVariantValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ReleaseVariantValueProcInfo, GetCurrentArchitecture()) +#define CallNPN_ReleaseVariantValueProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReleaseVariantValueProcInfo, (ARG1)) + +#else + +typedef void (* NP_LOADDS NPN_ReleaseVariantValueUPP)(NPVariant *variant); +#define NewNPN_ReleaseVariantValueProc(FUNC) \ + ((NPN_ReleaseVariantValueUPP) (FUNC)) +#define CallNPN_ReleaseVariantValueProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) + +#endif + +/* NPN_SetException */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPN_SetExceptionUPP; +enum { + uppNPN_SetExceptionProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPObject*))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const NPUTF8*))) + | RESULT_SIZE(SIZE_CODE(0)) +}; + +#define NewNPN_SetExceptionProc(FUNC) \ + (NPN_SetExceptionUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_SetExceptionProcInfo, GetCurrentArchitecture()) +#define CallNPN_SetExceptionProc(FUNC, ARG1, ARG2) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_SetExceptionProcInfo, (ARG1), (ARG2)) + +#else + +typedef void (* NP_LOADDS NPN_SetExceptionUPP)(NPObject *obj, const NPUTF8 *message); +#define NewNPN_SetExceptionProc(FUNC) \ + ((NPN_SetExceptionUPP) (FUNC)) +#define CallNPN_SetExceptionProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) + +#endif + + + + +/****************************************************************************************** + * The actual plugin function table definitions + *******************************************************************************************/ + +#ifdef XP_MAC +#if PRAGMA_STRUCT_ALIGN +#pragma options align=mac68k +#endif +#endif + +typedef struct _NPPluginFuncs { + uint16 size; + uint16 version; + NPP_NewUPP newp; + NPP_DestroyUPP destroy; + NPP_SetWindowUPP setwindow; + NPP_NewStreamUPP newstream; + NPP_DestroyStreamUPP destroystream; + NPP_StreamAsFileUPP asfile; + NPP_WriteReadyUPP writeready; + NPP_WriteUPP write; + NPP_PrintUPP print; + NPP_HandleEventUPP event; + NPP_URLNotifyUPP urlnotify; + JRIGlobalRef javaClass; + NPP_GetValueUPP getvalue; + NPP_SetValueUPP setvalue; +} NPPluginFuncs; + +typedef struct _NPNetscapeFuncs { + uint16 size; + uint16 version; + NPN_GetURLUPP geturl; + NPN_PostURLUPP posturl; + NPN_RequestReadUPP requestread; + NPN_NewStreamUPP newstream; + NPN_WriteUPP write; + NPN_DestroyStreamUPP destroystream; + NPN_StatusUPP status; + NPN_UserAgentUPP uagent; + NPN_MemAllocUPP memalloc; + NPN_MemFreeUPP memfree; + NPN_MemFlushUPP memflush; + NPN_ReloadPluginsUPP reloadplugins; + NPN_GetJavaEnvUPP getJavaEnv; + NPN_GetJavaPeerUPP getJavaPeer; + NPN_GetURLNotifyUPP geturlnotify; + NPN_PostURLNotifyUPP posturlnotify; + NPN_GetValueUPP getvalue; + NPN_SetValueUPP setvalue; + NPN_InvalidateRectUPP invalidaterect; + NPN_InvalidateRegionUPP invalidateregion; + NPN_ForceRedrawUPP forceredraw; + NPN_GetStringIdentifierUPP getstringidentifier; + NPN_GetStringIdentifiersUPP getstringidentifiers; + NPN_GetIntIdentifierUPP getintidentifier; + NPN_IdentifierIsStringUPP identifierisstring; + NPN_UTF8FromIdentifierUPP utf8fromidentifier; + NPN_IntFromIdentifierUPP intfromidentifier; + NPN_CreateObjectUPP createobject; + NPN_RetainObjectUPP retainobject; + NPN_ReleaseObjectUPP releaseobject; + NPN_InvokeUPP invoke; + NPN_InvokeDefaultUPP invokeDefault; + NPN_EvaluateUPP evaluate; + NPN_GetPropertyUPP getproperty; + NPN_SetPropertyUPP setproperty; + NPN_RemovePropertyUPP removeproperty; + NPN_HasPropertyUPP hasproperty; + NPN_HasMethodUPP hasmethod; + NPN_ReleaseVariantValueUPP releasevariantvalue; + NPN_SetExceptionUPP setexception; +} NPNetscapeFuncs; + +#ifdef XP_MAC +#if PRAGMA_STRUCT_ALIGN +#pragma options align=reset +#endif +#endif + + +#if defined(XP_MAC) || defined(XP_MACOSX) +/****************************************************************************************** + * Mac platform-specific plugin glue stuff + *******************************************************************************************/ + +/* + * Main entry point of the plugin. + * This routine will be called when the plugin is loaded. The function + * tables are passed in and the plugin fills in the NPPluginFuncs table + * and NPPShutdownUPP for Netscape's use. + */ + +#if _NPUPP_USE_UPP_ + +typedef UniversalProcPtr NPP_MainEntryUPP; +enum { + uppNPP_MainEntryProcInfo = kThinkCStackBased + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(NPNetscapeFuncs*))) + | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPluginFuncs*))) + | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPP_ShutdownUPP*))) + | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) +}; +#define NewNPP_MainEntryProc(FUNC) \ + (NPP_MainEntryUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_MainEntryProcInfo, GetCurrentArchitecture()) +#define CallNPP_MainEntryProc(FUNC, netscapeFunc, pluginFunc, shutdownUPP) \ + CallUniversalProc((UniversalProcPtr)(FUNC), (ProcInfoType)uppNPP_MainEntryProcInfo, (netscapeFunc), (pluginFunc), (shutdownUPP)) + +#else + +typedef NPError (* NP_LOADDS NPP_MainEntryUPP)(NPNetscapeFuncs*, NPPluginFuncs*, NPP_ShutdownUPP*); +#define NewNPP_MainEntryProc(FUNC) \ + ((NPP_MainEntryUPP) (FUNC)) +#define CallNPP_MainEntryProc(FUNC, netscapeFunc, pluginFunc, shutdownUPP) \ + (*(FUNC))((netscapeFunc), (pluginFunc), (shutdownUPP)) + +#endif + + +/* + * Mac version(s) of NP_GetMIMEDescription(const char *) + * These can be called to retreive MIME information from the plugin dynamically + * + * Note: For compatibility with Quicktime, BPSupportedMIMEtypes is another way + * to get mime info from the plugin only on OSX and may not be supported + * in furture version--use NP_GetMIMEDescription instead + */ + +enum +{ + kBPSupportedMIMETypesStructVers_1 = 1 +}; + +typedef struct _BPSupportedMIMETypes +{ + SInt32 structVersion; /* struct version */ + Handle typeStrings; /* STR# formated handle, allocated by plug-in */ + Handle infoStrings; /* STR# formated handle, allocated by plug-in */ +} BPSupportedMIMETypes; +OSErr BP_GetSupportedMIMETypes(BPSupportedMIMETypes *mimeInfo, UInt32 flags); + +#if _NPUPP_USE_UPP_ + +#define NP_GETMIMEDESCRIPTION_NAME "NP_GetMIMEDescriptionRD" +typedef UniversalProcPtr NP_GetMIMEDescriptionUPP; +enum { + uppNP_GetMIMEDescEntryProc = kThinkCStackBased + | RESULT_SIZE(SIZE_CODE(sizeof(const char *))) +}; +#define NewNP_GetMIMEDescEntryProc(FUNC) \ + (NP_GetMIMEDescriptionUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNP_GetMIMEDescEntryProc, GetCurrentArchitecture()) +#define CallNP_GetMIMEDescEntryProc(FUNC) \ + (const char *)CallUniversalProc((UniversalProcPtr)(FUNC), (ProcInfoType)uppNP_GetMIMEDescEntryProc) + + +#else /* !_NPUPP_USE_UPP_ */ + + /* NP_GetMIMEDescription */ +#define NP_GETMIMEDESCRIPTION_NAME "NP_GetMIMEDescription" +typedef const char* (* NP_LOADDS NP_GetMIMEDescriptionUPP)(); +#define NewNP_GetMIMEDescEntryProc(FUNC) \ + ((NP_GetMIMEDescriptionUPP) (FUNC)) +#define CallNP_GetMIMEDescEntryProc(FUNC) \ + (*(FUNC))() +/* BP_GetSupportedMIMETypes */ +typedef OSErr (* NP_LOADDS BP_GetSupportedMIMETypesUPP)(BPSupportedMIMETypes*, UInt32); +#define NewBP_GetSupportedMIMETypesEntryProc(FUNC) \ + ((BP_GetSupportedMIMETypesUPP) (FUNC)) +#define CallBP_GetMIMEDescEntryProc(FUNC, mimeInfo, flags) \ + (*(FUNC))((mimeInfo), (flags)) + +#endif +#endif /* MAC */ + +#if defined(_WINDOWS) +#define OSCALL WINAPI +#else +#if defined(__OS2__) +#define OSCALL _System +#else +#define OSCALL +#endif +#endif + +#if defined( _WINDOWS ) || defined (__OS2__) + +#ifdef __cplusplus +extern "C" { +#endif + +/* plugin meta member functions */ +#if defined(__OS2__) + +typedef struct _NPPluginData { /* Alternate OS2 Plugin interface */ + char *pMimeTypes; + char *pFileExtents; + char *pFileOpenTemplate; + char *pProductName; + char *pProductDescription; + unsigned long dwProductVersionMS; + unsigned long dwProductVersionLS; +} NPPluginData; + +NPError OSCALL NP_GetPluginData(NPPluginData * pPluginData); + +#endif + +NPError OSCALL NP_GetEntryPoints(NPPluginFuncs* pFuncs); + +NPError OSCALL NP_Initialize(NPNetscapeFuncs* pFuncs); + +NPError OSCALL NP_Shutdown(); + +char* NP_GetMIMEDescription(); + +#ifdef __cplusplus +} +#endif + +#endif /* _WINDOWS || __OS2__ */ + +#if defined(__OS2__) +#pragma pack() +#endif + +#ifdef XP_UNIX + +#ifdef __cplusplus +extern "C" { +#endif + +/* plugin meta member functions */ + +char* NP_GetMIMEDescription(void); +NPError NP_Initialize(NPNetscapeFuncs*, NPPluginFuncs*); +NPError NP_Shutdown(void); +NPError NP_GetValue(void *future, NPPVariable aVariable, void *aValue); + +#ifdef __cplusplus +} +#endif + +#endif /* XP_UNIX */ + +#endif /* _NPUPP_H_ */ diff --git a/npapi/nspr/obsolete/protypes.h b/npapi/nspr/obsolete/protypes.h new file mode 100644 index 0000000..e96cfcf --- /dev/null +++ b/npapi/nspr/obsolete/protypes.h @@ -0,0 +1,251 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Mozilla Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is the Netscape Portable Runtime (NSPR). + * + * The Initial Developer of the Original Code is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998-2000 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 or later (the + * "GPL"), in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your + * version of this file only under the terms of the GPL and not to + * allow others to use your version of this file under the MPL, + * indicate your decision by deleting the provisions above and + * replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient + * may use your version of this file under either the MPL or the + * GPL. + */ + +/* + * This header typedefs the old 'native' types to the new PRs. + * These definitions are scheduled to be eliminated at the earliest + * possible time. The NSPR API is implemented and documented using + * the new definitions. + */ + +#if !defined(PROTYPES_H) +#define PROTYPES_H + +typedef PRUintn uintn; +#ifndef _XP_Core_ +typedef PRIntn intn; +#endif + +/* + * It is trickier to define uint, int8, uint8, int16, uint16, + * int32, uint32, int64, and uint64 because some of these int + * types are defined by standard header files on some platforms. + * Our strategy here is to include all such standard headers + * first, and then define these int types only if they are not + * defined by those standard headers. + */ + +/* + * BeOS defines all the int types below in its standard header + * file SupportDefs.h. + */ +#ifdef XP_BEOS +#include +#endif + +/* + * OpenVMS defines all the int types below in its standard + * header files ints.h and types.h. + */ +#ifdef VMS +#include +#include +#endif + +/* + * SVR4 typedef of uint is commonly found on UNIX machines. + * + * On AIX 4.3, sys/inttypes.h (which is included by sys/types.h) + * defines the types int8, int16, int32, and int64. + */ +#ifdef XP_UNIX +#include +#endif + +/* model.h on HP-UX defines int8, int16, and int32. */ +#ifdef HPUX +#include +#endif + +/* + * uint + */ + +#if !defined(XP_BEOS) && !defined(VMS) \ + && !defined(XP_UNIX) || defined(NTO) +typedef PRUintn uint; +#endif + +/* + * uint64 + */ + +#if !defined(XP_BEOS) && !defined(VMS) +typedef PRUint64 uint64; +#endif + +/* + * uint32 + */ + +#if !defined(XP_BEOS) && !defined(VMS) +#if !defined(XP_MAC) && !defined(_WIN32) && !defined(XP_OS2) && !defined(NTO) +typedef PRUint32 uint32; +#else +typedef unsigned long uint32; +#endif +#endif + +/* + * uint16 + */ + +#if !defined(XP_BEOS) && !defined(VMS) +typedef PRUint16 uint16; +#endif + +/* + * uint8 + */ + +#if !defined(XP_BEOS) && !defined(VMS) +typedef PRUint8 uint8; +#endif + +/* + * int64 + */ + +#if !defined(XP_BEOS) && !defined(VMS) \ + && !defined(_PR_AIX_HAVE_BSD_INT_TYPES) +typedef PRInt64 int64; +#endif + +/* + * int32 + */ + +#if !defined(XP_BEOS) && !defined(VMS) \ + && !defined(_PR_AIX_HAVE_BSD_INT_TYPES) \ + && !defined(HPUX) +#if !defined(WIN32) || !defined(_WINSOCK2API_) /* defines its own "int32" */ +#if !defined(XP_MAC) && !defined(_WIN32) && !defined(XP_OS2) && !defined(NTO) +typedef PRInt32 int32; +#else +typedef long int32; +#endif +#endif +#endif + +/* + * int16 + */ + +#if !defined(XP_BEOS) && !defined(VMS) \ + && !defined(_PR_AIX_HAVE_BSD_INT_TYPES) \ + && !defined(HPUX) +typedef PRInt16 int16; +#endif + +/* + * int8 + */ + +#if !defined(XP_BEOS) && !defined(VMS) \ + && !defined(_PR_AIX_HAVE_BSD_INT_TYPES) \ + && !defined(HPUX) +typedef PRInt8 int8; +#endif + +typedef PRFloat64 float64; +typedef PRUptrdiff uptrdiff_t; +typedef PRUword uprword_t; +typedef PRWord prword_t; + + +/* Re: prbit.h */ +#define TEST_BIT PR_TEST_BIT +#define SET_BIT PR_SET_BIT +#define CLEAR_BIT PR_CLEAR_BIT + +/* Re: prarena.h->plarena.h */ +#define PRArena PLArena +#define PRArenaPool PLArenaPool +#define PRArenaStats PLArenaStats +#define PR_ARENA_ALIGN PL_ARENA_ALIGN +#define PR_INIT_ARENA_POOL PL_INIT_ARENA_POOL +#define PR_ARENA_ALLOCATE PL_ARENA_ALLOCATE +#define PR_ARENA_GROW PL_ARENA_GROW +#define PR_ARENA_MARK PL_ARENA_MARK +#define PR_CLEAR_UNUSED PL_CLEAR_UNUSED +#define PR_CLEAR_ARENA PL_CLEAR_ARENA +#define PR_ARENA_RELEASE PL_ARENA_RELEASE +#define PR_COUNT_ARENA PL_COUNT_ARENA +#define PR_ARENA_DESTROY PL_ARENA_DESTROY +#define PR_InitArenaPool PL_InitArenaPool +#define PR_FreeArenaPool PL_FreeArenaPool +#define PR_FinishArenaPool PL_FinishArenaPool +#define PR_CompactArenaPool PL_CompactArenaPool +#define PR_ArenaFinish PL_ArenaFinish +#define PR_ArenaAllocate PL_ArenaAllocate +#define PR_ArenaGrow PL_ArenaGrow +#define PR_ArenaRelease PL_ArenaRelease +#define PR_ArenaCountAllocation PL_ArenaCountAllocation +#define PR_ArenaCountInplaceGrowth PL_ArenaCountInplaceGrowth +#define PR_ArenaCountGrowth PL_ArenaCountGrowth +#define PR_ArenaCountRelease PL_ArenaCountRelease +#define PR_ArenaCountRetract PL_ArenaCountRetract + +/* Re: prhash.h->plhash.h */ +#define PRHashEntry PLHashEntry +#define PRHashTable PLHashTable +#define PRHashNumber PLHashNumber +#define PRHashFunction PLHashFunction +#define PRHashComparator PLHashComparator +#define PRHashEnumerator PLHashEnumerator +#define PRHashAllocOps PLHashAllocOps +#define PR_NewHashTable PL_NewHashTable +#define PR_HashTableDestroy PL_HashTableDestroy +#define PR_HashTableRawLookup PL_HashTableRawLookup +#define PR_HashTableRawAdd PL_HashTableRawAdd +#define PR_HashTableRawRemove PL_HashTableRawRemove +#define PR_HashTableAdd PL_HashTableAdd +#define PR_HashTableRemove PL_HashTableRemove +#define PR_HashTableEnumerateEntries PL_HashTableEnumerateEntries +#define PR_HashTableLookup PL_HashTableLookup +#define PR_HashTableDump PL_HashTableDump +#define PR_HashString PL_HashString +#define PR_CompareStrings PL_CompareStrings +#define PR_CompareValues PL_CompareValues + +#if defined(XP_MAC) +#ifndef TRUE /* Mac standard is lower case true */ + #define TRUE 1 +#endif +#ifndef FALSE /* Mac standard is lower case false */ + #define FALSE 0 +#endif +#endif + +#endif /* !defined(PROTYPES_H) */ diff --git a/npapi/nspr/prcpucfg.h b/npapi/nspr/prcpucfg.h new file mode 100644 index 0000000..681217e --- /dev/null +++ b/npapi/nspr/prcpucfg.h @@ -0,0 +1,707 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Mozilla Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is the Netscape Portable Runtime (NSPR). + * + * The Initial Developer of the Original Code is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998-2000 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 or later (the + * "GPL"), in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your + * version of this file only under the terms of the GPL and not to + * allow others to use your version of this file under the MPL, + * indicate your decision by deleting the provisions above and + * replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient + * may use your version of this file under either the MPL or the + * GPL. + */ + +#ifndef nspr_cpucfg___ +#define nspr_cpucfg___ + +#ifndef XP_UNIX +#define XP_UNIX +#endif + +#ifndef LINUX +#define LINUX +#endif + +#define PR_AF_INET6 10 /* same as AF_INET6 */ + +#ifdef __powerpc64__ + +#undef IS_LITTLE_ENDIAN +#define IS_BIG_ENDIAN 1 +#define IS_64 +#define IS_LIB64 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 8 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 8 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 64 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 64 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 6 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 6 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 8 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 8 +#define PR_ALIGN_OF_WORD 8 + +#define PR_BYTES_PER_WORD_LOG2 3 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__powerpc__) + +#undef IS_LITTLE_ENDIAN +#define IS_BIG_ENDIAN 1 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__alpha) + +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN +#define IS_64 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 8 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 8 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 64 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 64 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 6 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 6 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 8 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 8 +#define PR_ALIGN_OF_WORD 8 + +#define PR_BYTES_PER_WORD_LOG2 3 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__ia64__) + +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN +#define IS_64 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 8 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 8 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 64 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 64 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 6 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 6 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 8 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 8 +#define PR_ALIGN_OF_WORD 8 + +#define PR_BYTES_PER_WORD_LOG2 3 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__x86_64__) + +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN +#define IS_64 +#define IS_LIB64 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 8 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 8 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 64 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 64 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 6 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 6 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 8 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 8 +#define PR_ALIGN_OF_WORD 8 + +#define PR_BYTES_PER_WORD_LOG2 3 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__mc68000__) + +#undef IS_LITTLE_ENDIAN +#define IS_BIG_ENDIAN 1 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 2 +#define PR_ALIGN_OF_LONG 2 +#define PR_ALIGN_OF_INT64 2 +#define PR_ALIGN_OF_FLOAT 2 +#define PR_ALIGN_OF_DOUBLE 2 +#define PR_ALIGN_OF_POINTER 2 +#define PR_ALIGN_OF_WORD 2 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__sparc__) + +#undef IS_LITTLE_ENDIAN +#define IS_BIG_ENDIAN 1 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__i386__) + +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 4 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 4 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__mips__) + +#ifdef __MIPSEB__ +#define IS_BIG_ENDIAN 1 +#undef IS_LITTLE_ENDIAN +#elif defined(__MIPSEL__) +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN +#else +#error "Unknown MIPS endianness." +#endif + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__arm__) + +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 4 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 4 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__hppa__) + +#undef IS_LITTLE_ENDIAN +#define IS_BIG_ENDIAN 1 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__s390__) + +#define IS_BIG_ENDIAN 1 +#undef IS_LITTLE_ENDIAN + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 4 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 4 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__s390x__) + +#define IS_BIG_ENDIAN 1 +#undef IS_LITTLE_ENDIAN +#define IS_64 +#define IS_LIB64 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 8 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 8 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 64 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 64 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 6 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 6 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 8 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 8 +#define PR_ALIGN_OF_WORD 8 + +#define PR_BYTES_PER_WORD_LOG2 3 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#else + +#error "Unknown CPU architecture" + +#endif + +#define HAVE_LONG_LONG +#if PR_ALIGN_OF_DOUBLE == 8 +#define HAVE_ALIGNED_DOUBLES +#endif +#if PR_ALIGN_OF_INT64 == 8 +#define HAVE_ALIGNED_LONGLONGS +#endif + +#ifndef NO_NSPR_10_SUPPORT + +#define BYTES_PER_BYTE PR_BYTES_PER_BYTE +#define BYTES_PER_SHORT PR_BYTES_PER_SHORT +#define BYTES_PER_INT PR_BYTES_PER_INT +#define BYTES_PER_INT64 PR_BYTES_PER_INT64 +#define BYTES_PER_LONG PR_BYTES_PER_LONG +#define BYTES_PER_FLOAT PR_BYTES_PER_FLOAT +#define BYTES_PER_DOUBLE PR_BYTES_PER_DOUBLE +#define BYTES_PER_WORD PR_BYTES_PER_WORD +#define BYTES_PER_DWORD PR_BYTES_PER_DWORD + +#define BITS_PER_BYTE PR_BITS_PER_BYTE +#define BITS_PER_SHORT PR_BITS_PER_SHORT +#define BITS_PER_INT PR_BITS_PER_INT +#define BITS_PER_INT64 PR_BITS_PER_INT64 +#define BITS_PER_LONG PR_BITS_PER_LONG +#define BITS_PER_FLOAT PR_BITS_PER_FLOAT +#define BITS_PER_DOUBLE PR_BITS_PER_DOUBLE +#define BITS_PER_WORD PR_BITS_PER_WORD + +#define BITS_PER_BYTE_LOG2 PR_BITS_PER_BYTE_LOG2 +#define BITS_PER_SHORT_LOG2 PR_BITS_PER_SHORT_LOG2 +#define BITS_PER_INT_LOG2 PR_BITS_PER_INT_LOG2 +#define BITS_PER_INT64_LOG2 PR_BITS_PER_INT64_LOG2 +#define BITS_PER_LONG_LOG2 PR_BITS_PER_LONG_LOG2 +#define BITS_PER_FLOAT_LOG2 PR_BITS_PER_FLOAT_LOG2 +#define BITS_PER_DOUBLE_LOG2 PR_BITS_PER_DOUBLE_LOG2 +#define BITS_PER_WORD_LOG2 PR_BITS_PER_WORD_LOG2 + +#define ALIGN_OF_SHORT PR_ALIGN_OF_SHORT +#define ALIGN_OF_INT PR_ALIGN_OF_INT +#define ALIGN_OF_LONG PR_ALIGN_OF_LONG +#define ALIGN_OF_INT64 PR_ALIGN_OF_INT64 +#define ALIGN_OF_FLOAT PR_ALIGN_OF_FLOAT +#define ALIGN_OF_DOUBLE PR_ALIGN_OF_DOUBLE +#define ALIGN_OF_POINTER PR_ALIGN_OF_POINTER +#define ALIGN_OF_WORD PR_ALIGN_OF_WORD + +#define BYTES_PER_WORD_LOG2 PR_BYTES_PER_WORD_LOG2 +#define BYTES_PER_DWORD_LOG2 PR_BYTES_PER_DWORD_LOG2 +#define WORDS_PER_DWORD_LOG2 PR_WORDS_PER_DWORD_LOG2 + +#endif /* NO_NSPR_10_SUPPORT */ + +#endif /* nspr_cpucfg___ */ diff --git a/npapi/nspr/prtypes.h b/npapi/nspr/prtypes.h new file mode 100644 index 0000000..819f9c1 --- /dev/null +++ b/npapi/nspr/prtypes.h @@ -0,0 +1,523 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Mozilla Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is the Netscape Portable Runtime (NSPR). + * + * The Initial Developer of the Original Code is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998-2000 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License Version 2 or later (the + * "GPL"), in which case the provisions of the GPL are applicable + * instead of those above. If you wish to allow use of your + * version of this file only under the terms of the GPL and not to + * allow others to use your version of this file under the MPL, + * indicate your decision by deleting the provisions above and + * replace them with the notice and other provisions required by + * the GPL. If you do not delete the provisions above, a recipient + * may use your version of this file under either the MPL or the + * GPL. + */ + +/* +** File: prtypes.h +** Description: Definitions of NSPR's basic types +** +** Prototypes and macros used to make up for deficiencies in ANSI environments +** that we have found. +** +** Since we do not wrap and all the other standard headers, authors +** of portable code will not know in general that they need these definitions. +** Instead of requiring these authors to find the dependent uses in their code +** and take the following steps only in those C files, we take steps once here +** for all C files. +**/ + +#ifndef prtypes_h___ +#define prtypes_h___ + +#ifdef MDCPUCFG +#include MDCPUCFG +#else +#include "prcpucfg.h" +#endif + +#include + +/*********************************************************************** +** MACROS: PR_EXTERN +** PR_IMPLEMENT +** DESCRIPTION: +** These are only for externally visible routines and globals. For +** internal routines, just use "extern" for type checking and that +** will not export internal cross-file or forward-declared symbols. +** Define a macro for declaring procedures return types. We use this to +** deal with windoze specific type hackery for DLL definitions. Use +** PR_EXTERN when the prototype for the method is declared. Use +** PR_IMPLEMENT for the implementation of the method. +** +** Example: +** in dowhim.h +** PR_EXTERN( void ) DoWhatIMean( void ); +** in dowhim.c +** PR_IMPLEMENT( void ) DoWhatIMean( void ) { return; } +** +** +***********************************************************************/ +#if defined(WIN32) + +#define PR_EXPORT(__type) extern __declspec(dllexport) __type +#define PR_EXPORT_DATA(__type) extern __declspec(dllexport) __type +#define PR_IMPORT(__type) __declspec(dllimport) __type +#define PR_IMPORT_DATA(__type) __declspec(dllimport) __type + +#define PR_EXTERN(__type) extern __declspec(dllexport) __type +#define PR_IMPLEMENT(__type) __declspec(dllexport) __type +#define PR_EXTERN_DATA(__type) extern __declspec(dllexport) __type +#define PR_IMPLEMENT_DATA(__type) __declspec(dllexport) __type + +#define PR_CALLBACK +#define PR_CALLBACK_DECL +#define PR_STATIC_CALLBACK(__x) static __x + +#elif defined(XP_BEOS) + +#define PR_EXPORT(__type) extern __declspec(dllexport) __type +#define PR_EXPORT_DATA(__type) extern __declspec(dllexport) __type +#define PR_IMPORT(__type) extern __declspec(dllexport) __type +#define PR_IMPORT_DATA(__type) extern __declspec(dllexport) __type + +#define PR_EXTERN(__type) extern __declspec(dllexport) __type +#define PR_IMPLEMENT(__type) __declspec(dllexport) __type +#define PR_EXTERN_DATA(__type) extern __declspec(dllexport) __type +#define PR_IMPLEMENT_DATA(__type) __declspec(dllexport) __type + +#define PR_CALLBACK +#define PR_CALLBACK_DECL +#define PR_STATIC_CALLBACK(__x) static __x + +#elif defined(WIN16) + +#define PR_CALLBACK_DECL __cdecl + +#if defined(_WINDLL) +#define PR_EXPORT(__type) extern __type _cdecl _export _loadds +#define PR_IMPORT(__type) extern __type _cdecl _export _loadds +#define PR_EXPORT_DATA(__type) extern __type _export +#define PR_IMPORT_DATA(__type) extern __type _export + +#define PR_EXTERN(__type) extern __type _cdecl _export _loadds +#define PR_IMPLEMENT(__type) __type _cdecl _export _loadds +#define PR_EXTERN_DATA(__type) extern __type _export +#define PR_IMPLEMENT_DATA(__type) __type _export + +#define PR_CALLBACK __cdecl __loadds +#define PR_STATIC_CALLBACK(__x) static __x PR_CALLBACK + +#else /* this must be .EXE */ +#define PR_EXPORT(__type) extern __type _cdecl _export +#define PR_IMPORT(__type) extern __type _cdecl _export +#define PR_EXPORT_DATA(__type) extern __type _export +#define PR_IMPORT_DATA(__type) extern __type _export + +#define PR_EXTERN(__type) extern __type _cdecl _export +#define PR_IMPLEMENT(__type) __type _cdecl _export +#define PR_EXTERN_DATA(__type) extern __type _export +#define PR_IMPLEMENT_DATA(__type) __type _export + +#define PR_CALLBACK __cdecl __loadds +#define PR_STATIC_CALLBACK(__x) __x PR_CALLBACK +#endif /* _WINDLL */ + +#elif defined(XP_MAC) + +#define PR_EXPORT(__type) extern __declspec(export) __type +#define PR_EXPORT_DATA(__type) extern __declspec(export) __type +#define PR_IMPORT(__type) extern __declspec(export) __type +#define PR_IMPORT_DATA(__type) extern __declspec(export) __type + +#define PR_EXTERN(__type) extern __declspec(export) __type +#define PR_IMPLEMENT(__type) __declspec(export) __type +#define PR_EXTERN_DATA(__type) extern __declspec(export) __type +#define PR_IMPLEMENT_DATA(__type) __declspec(export) __type + +#define PR_CALLBACK +#define PR_CALLBACK_DECL +#define PR_STATIC_CALLBACK(__x) static __x + +#else /* Unix */ + +#define PR_EXPORT(__type) extern __type +#define PR_EXPORT_DATA(__type) extern __type +#define PR_IMPORT(__type) extern __type +#define PR_IMPORT_DATA(__type) extern __type + +#define PR_EXTERN(__type) extern __type +#define PR_IMPLEMENT(__type) __type +#define PR_EXTERN_DATA(__type) extern __type +#define PR_IMPLEMENT_DATA(__type) __type +#define PR_CALLBACK +#define PR_CALLBACK_DECL +#define PR_STATIC_CALLBACK(__x) static __x + +#endif + +#if defined(_NSPR_BUILD_) +#define NSPR_API(__type) PR_EXPORT(__type) +#define NSPR_DATA_API(__type) PR_EXPORT_DATA(__type) +#else +#define NSPR_API(__type) PR_IMPORT(__type) +#define NSPR_DATA_API(__type) PR_IMPORT_DATA(__type) +#endif + +/*********************************************************************** +** MACROS: PR_BEGIN_MACRO +** PR_END_MACRO +** DESCRIPTION: +** Macro body brackets so that macros with compound statement definitions +** behave syntactically more like functions when called. +***********************************************************************/ +#define PR_BEGIN_MACRO do { +#define PR_END_MACRO } while (0) + +/*********************************************************************** +** MACROS: PR_BEGIN_EXTERN_C +** PR_END_EXTERN_C +** DESCRIPTION: +** Macro shorthands for conditional C++ extern block delimiters. +***********************************************************************/ +#ifdef __cplusplus +#define PR_BEGIN_EXTERN_C extern "C" { +#define PR_END_EXTERN_C } +#else +#define PR_BEGIN_EXTERN_C +#define PR_END_EXTERN_C +#endif + +/*********************************************************************** +** MACROS: PR_BIT +** PR_BITMASK +** DESCRIPTION: +** Bit masking macros. XXX n must be <= 31 to be portable +***********************************************************************/ +#define PR_BIT(n) ((PRUint32)1 << (n)) +#define PR_BITMASK(n) (PR_BIT(n) - 1) + +/*********************************************************************** +** MACROS: PR_ROUNDUP +** PR_MIN +** PR_MAX +** PR_ABS +** DESCRIPTION: +** Commonly used macros for operations on compatible types. +***********************************************************************/ +#define PR_ROUNDUP(x,y) ((((x)+((y)-1))/(y))*(y)) +#define PR_MIN(x,y) ((x)<(y)?(x):(y)) +#define PR_MAX(x,y) ((x)>(y)?(x):(y)) +#define PR_ABS(x) ((x)<0?-(x):(x)) + +PR_BEGIN_EXTERN_C + +/************************************************************************ +** TYPES: PRUint8 +** PRInt8 +** DESCRIPTION: +** The int8 types are known to be 8 bits each. There is no type that +** is equivalent to a plain "char". +************************************************************************/ +#if PR_BYTES_PER_BYTE == 1 +typedef unsigned char PRUint8; +/* +** Some cfront-based C++ compilers do not like 'signed char' and +** issue the warning message: +** warning: "signed" not implemented (ignored) +** For these compilers, we have to define PRInt8 as plain 'char'. +** Make sure that plain 'char' is indeed signed under these compilers. +*/ +#if (defined(HPUX) && defined(__cplusplus) \ + && !defined(__GNUC__) && __cplusplus < 199707L) \ + || (defined(SCO) && defined(__cplusplus) \ + && !defined(__GNUC__) && __cplusplus == 1L) +typedef char PRInt8; +#else +typedef signed char PRInt8; +#endif +#else +#error No suitable type for PRInt8/PRUint8 +#endif + +/************************************************************************ + * MACROS: PR_INT8_MAX + * PR_INT8_MIN + * PR_UINT8_MAX + * DESCRIPTION: + * The maximum and minimum values of a PRInt8 or PRUint8. +************************************************************************/ + +#define PR_INT8_MAX 127 +#define PR_INT8_MIN (-128) +#define PR_UINT8_MAX 255U + +/************************************************************************ +** TYPES: PRUint16 +** PRInt16 +** DESCRIPTION: +** The int16 types are known to be 16 bits each. +************************************************************************/ +#if PR_BYTES_PER_SHORT == 2 +typedef unsigned short PRUint16; +typedef short PRInt16; +#else +#error No suitable type for PRInt16/PRUint16 +#endif + +/************************************************************************ + * MACROS: PR_INT16_MAX + * PR_INT16_MIN + * PR_UINT16_MAX + * DESCRIPTION: + * The maximum and minimum values of a PRInt16 or PRUint16. +************************************************************************/ + +#define PR_INT16_MAX 32767 +#define PR_INT16_MIN (-32768) +#define PR_UINT16_MAX 65535U + +/************************************************************************ +** TYPES: PRUint32 +** PRInt32 +** DESCRIPTION: +** The int32 types are known to be 32 bits each. +************************************************************************/ +#if PR_BYTES_PER_INT == 4 +typedef unsigned int PRUint32; +typedef int PRInt32; +#define PR_INT32(x) x +#define PR_UINT32(x) x ## U +#elif PR_BYTES_PER_LONG == 4 +typedef unsigned long PRUint32; +typedef long PRInt32; +#define PR_INT32(x) x ## L +#define PR_UINT32(x) x ## UL +#else +#error No suitable type for PRInt32/PRUint32 +#endif + +/************************************************************************ + * MACROS: PR_INT32_MAX + * PR_INT32_MIN + * PR_UINT32_MAX + * DESCRIPTION: + * The maximum and minimum values of a PRInt32 or PRUint32. +************************************************************************/ + +#define PR_INT32_MAX PR_INT32(2147483647) +#define PR_INT32_MIN (-PR_INT32_MAX - 1) +#define PR_UINT32_MAX PR_UINT32(4294967295) + +/************************************************************************ +** TYPES: PRUint64 +** PRInt64 +** DESCRIPTION: +** The int64 types are known to be 64 bits each. Care must be used when +** declaring variables of type PRUint64 or PRInt64. Different hardware +** architectures and even different compilers have varying support for +** 64 bit values. The only guaranteed portability requires the use of +** the LL_ macros (see prlong.h). +************************************************************************/ +#ifdef HAVE_LONG_LONG +#if PR_BYTES_PER_LONG == 8 +typedef long PRInt64; +typedef unsigned long PRUint64; +#elif defined(WIN16) +typedef __int64 PRInt64; +typedef unsigned __int64 PRUint64; +#elif defined(WIN32) && !defined(__GNUC__) +typedef __int64 PRInt64; +typedef unsigned __int64 PRUint64; +#else +typedef long long PRInt64; +typedef unsigned long long PRUint64; +#endif /* PR_BYTES_PER_LONG == 8 */ +#else /* !HAVE_LONG_LONG */ +typedef struct { +#ifdef IS_LITTLE_ENDIAN + PRUint32 lo, hi; +#else + PRUint32 hi, lo; +#endif +} PRInt64; +typedef PRInt64 PRUint64; +#endif /* !HAVE_LONG_LONG */ + +/************************************************************************ +** TYPES: PRUintn +** PRIntn +** DESCRIPTION: +** The PRIntn types are most appropriate for automatic variables. They are +** guaranteed to be at least 16 bits, though various architectures may +** define them to be wider (e.g., 32 or even 64 bits). These types are +** never valid for fields of a structure. +************************************************************************/ +#if PR_BYTES_PER_INT >= 2 +typedef int PRIntn; +typedef unsigned int PRUintn; +#else +#error 'sizeof(int)' not sufficient for platform use +#endif + +/************************************************************************ +** TYPES: PRFloat64 +** DESCRIPTION: +** NSPR's floating point type is always 64 bits. +************************************************************************/ +typedef double PRFloat64; + +/************************************************************************ +** TYPES: PRSize +** DESCRIPTION: +** A type for representing the size of objects. +************************************************************************/ +typedef size_t PRSize; + + +/************************************************************************ +** TYPES: PROffset32, PROffset64 +** DESCRIPTION: +** A type for representing byte offsets from some location. +************************************************************************/ +typedef PRInt32 PROffset32; +typedef PRInt64 PROffset64; + +/************************************************************************ +** TYPES: PRPtrDiff +** DESCRIPTION: +** A type for pointer difference. Variables of this type are suitable +** for storing a pointer or pointer sutraction. +************************************************************************/ +typedef ptrdiff_t PRPtrdiff; + +/************************************************************************ +** TYPES: PRUptrdiff +** DESCRIPTION: +** A type for pointer difference. Variables of this type are suitable +** for storing a pointer or pointer sutraction. +************************************************************************/ +typedef unsigned long PRUptrdiff; + +/************************************************************************ +** TYPES: PRBool +** DESCRIPTION: +** Use PRBool for variables and parameter types. Use PR_FALSE and PR_TRUE +** for clarity of target type in assignments and actual arguments. Use +** 'if (bool)', 'while (!bool)', '(bool) ? x : y' etc., to test booleans +** juast as you would C int-valued conditions. +************************************************************************/ +typedef PRIntn PRBool; +#define PR_TRUE 1 +#define PR_FALSE 0 + +/************************************************************************ +** TYPES: PRPackedBool +** DESCRIPTION: +** Use PRPackedBOol within structs where bitfields are not desireable +** but minimum and consistant overhead matters. +************************************************************************/ +typedef PRUint8 PRPackedBool; + +/* +** Status code used by some routines that have a single point of failure or +** special status return. +*/ +typedef enum { PR_FAILURE = -1, PR_SUCCESS = 0 } PRStatus; + +#ifdef MOZ_UNICODE +/* + * EXPERIMENTAL: This type may be removed in a future release. + */ +#ifndef __PRUNICHAR__ +#define __PRUNICHAR__ +#if defined(WIN32) || defined(XP_MAC) +typedef wchar_t PRUnichar; +#else +typedef PRUint16 PRUnichar; +#endif +#endif +#endif /* MOZ_UNICODE */ + +/* +** WARNING: The undocumented data types PRWord and PRUword are +** only used in the garbage collection and arena code. Do not +** use PRWord and PRUword in new code. +** +** A PRWord is an integer that is the same size as a void*. +** It implements the notion of a "word" in the Java Virtual +** Machine. (See Sec. 3.4 "Words", The Java Virtual Machine +** Specification, Addison-Wesley, September 1996. +** http://java.sun.com/docs/books/vmspec/index.html.) +*/ +typedef long PRWord; +typedef unsigned long PRUword; + +#if defined(NO_NSPR_10_SUPPORT) +#else +/********* ???????????????? FIX ME ??????????????????????????? *****/ +/********************** Some old definitions until pr=>ds transition is done ***/ +/********************** Also, we are still using NSPR 1.0. GC ******************/ +/* +** Fundamental NSPR macros, used nearly everywhere. +*/ + +#define PR_PUBLIC_API PR_IMPLEMENT + +/* +** Macro body brackets so that macros with compound statement definitions +** behave syntactically more like functions when called. +*/ +#define NSPR_BEGIN_MACRO do { +#define NSPR_END_MACRO } while (0) + +/* +** Macro shorthands for conditional C++ extern block delimiters. +*/ +#ifdef NSPR_BEGIN_EXTERN_C +#undef NSPR_BEGIN_EXTERN_C +#endif +#ifdef NSPR_END_EXTERN_C +#undef NSPR_END_EXTERN_C +#endif + +#ifdef __cplusplus +#define NSPR_BEGIN_EXTERN_C extern "C" { +#define NSPR_END_EXTERN_C } +#else +#define NSPR_BEGIN_EXTERN_C +#define NSPR_END_EXTERN_C +#endif + +#ifdef XP_MAC +#include "protypes.h" +#else +#include "obsolete/protypes.h" +#endif + +/********* ????????????? End Fix me ?????????????????????????????? *****/ +#endif /* NO_NSPR_10_SUPPORT */ + +PR_END_EXTERN_C + +#endif /* prtypes_h___ */ + diff --git a/nspluginwrapper.spec b/nspluginwrapper.spec new file mode 100644 index 0000000..deb482f --- /dev/null +++ b/nspluginwrapper.spec @@ -0,0 +1,183 @@ +%define name nspluginwrapper +%define version 0.9.91.1 +%define release 1 +#define svndate 20061227 + +# define 32-bit arch of multiarch platforms +%define arch_32 %{nil} +%ifarch x86_64 +%define arch_32 i386 +%endif +%ifarch ppc64 +%define arch_32 ppc +%endif +%ifarch sparc64 +%define arch_32 sparc +%endif + +# define target architecture of plugins we want to support +%define target_arch i386 + +# define target operating system of plugins we want to support +%define target_os linux + +# define nspluginswrapper libdir (invariant, including libdir) +%define pkglibdir %{_prefix}/lib/%{name} + +# define mozilla plugin dir +%define plugindir %{_libdir}/mozilla/plugins + +# define to build a biarch package +# XXX really build one package and handle upgrades +%define build_biarch 0 +%if "%{_arch}:%{arch_32}" == "x86_64:i386" +%define build_biarch 1 +%endif +%{expand: %{?_with_biarch: %%global build_biarch 1}} +%{expand: %{?_without_biarch: %%global build_biarch 0}} + +Summary: A compatibility layer for Netscape 4 plugins +Name: %{name} +Version: %{version} +Release: %{release} +Source0: %{name}-%{version}%{?svndate:-%{svndate}}.tar.bz2 +License: GPL +Group: Networking/WWW +Url: http://gwenole.beauchesne.info/projects/nspluginwrapper/ +BuildRequires: gtk+2-devel +Provides: %{name}-%{_arch} = %{version}-%{release} +Requires: %{name}-%{target_arch} = %{version}-%{release} +BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot + +%description +nspluginwrapper makes it possible to use Netscape 4 compatible plugins +compiled for %{target_arch} into Mozilla for another architecture, e.g. x86_64. + +This package consists in: + * npviewer: the plugin viewer + * npwrapper.so: the browser-side plugin + * nspluginwrapper: a tool to manage plugins installation and update + +%if %{build_biarch} +%package %{target_arch} +Summary: A viewer for %{target_arch} compiled Netscape 4 plugins +Group: Networking/WWW + +%description %{target_arch} +nspluginwrapper makes it possible to use Netscape 4 compatible plugins +compiled for %{target_arch} into Mozilla for another architecture, e.g. x86_64. + +This package consists in: + * npviewer: the plugin viewer + * npwrapper.so: the browser-side plugin + * nspluginwrapper: a tool to manage plugins installation and update + +This package provides the npviewer program for %{target_arch}. +%endif + +%prep +%setup -q + +%build +%if %{build_biarch} +biarch="--with-biarch" +%else +biarch="--without-biarch" +%endif +mkdir objs +pushd objs +../configure --prefix=%{_prefix} $biarch +make +popd + +%install +rm -rf $RPM_BUILD_ROOT + +make -C objs install DESTDIR=$RPM_BUILD_ROOT + +mkdir -p $RPM_BUILD_ROOT%{plugindir} +ln -s %{pkglibdir}/%{_arch}/%{_os}/npwrapper.so $RPM_BUILD_ROOT%{plugindir}/npwrapper.so + +%clean +rm -rf $RPM_BUILD_ROOT + +%post +if [ $1 = 1 ]; then + %{_bindir}/%{name} -v -a -i +else + %{_bindir}/%{name} -v -a -u +fi + +%preun +if [ $1 = 0 ]; then + %{_bindir}/%{name} -v -a -r +fi + +%files +%defattr(-,root,root) +%doc README COPYING NEWS +%{_bindir}/%{name} +%{plugindir}/npwrapper.so +%dir %{pkglibdir} +%dir %{pkglibdir}/noarch +%{pkglibdir}/noarch/npviewer +%{pkglibdir}/noarch/mkruntime +%dir %{pkglibdir}/%{_arch} +%dir %{pkglibdir}/%{_arch}/%{_os} +%{pkglibdir}/%{_arch}/%{_os}/npconfig +%if ! %{build_biarch} +%{pkglibdir}/%{_arch}/%{_os}/npviewer +%{pkglibdir}/%{_arch}/%{_os}/npviewer.bin +%{pkglibdir}/%{_arch}/%{_os}/libxpcom.so +%endif +%{pkglibdir}/%{_arch}/%{_os}/npwrapper.so + +%if %{build_biarch} +%files %{target_arch} +%defattr(-,root,root) +%dir %{pkglibdir}/%{target_arch} +%dir %{pkglibdir}/%{target_arch}/%{target_os} +%{pkglibdir}/%{target_arch}/%{target_os}/npviewer +%{pkglibdir}/%{target_arch}/%{target_os}/npviewer.bin +%{pkglibdir}/%{target_arch}/%{target_os}/libxpcom.so +%endif + +%changelog +* Tue Dec 26 2006 Gwenole Beauchesne 0.9.91.1-1 +- fix NPRuntime bridge (VLC plugin) +- fix Mozilla plugins dir creation on NetBSD and FreeBSD hosts +- fix potential buffer overflow in RPC marshalers +- handle empty args for plugin creation (flasharcade.com) + +* Thu Dec 21 2006 Gwenole Beauchesne 0.9.91-1 +- add scripting support through npruntime +- add XEMBED support (mplayer plug-in) +- add NPN_RequestRead() support (Acrobat Reader) +- add support for NetBSD, FreeBSD and non-x86 Linux hosts +- fix ppc64 / ppc32 support +- fix focus problems +- fix some rare hangs (add delayed requests) +- fix libstdc++2 compat glue for broken plugins +- create user mozilla plugins dir if it does not exist yet + +* Wed Nov 18 2006 Gwenole Beauchesne 0.9.90.4-1 +- add printing support (NPP_Print) +- add initial support for Konqueror +- fix post data to a URL (NPN_PostURL, NPN_PostURLNotify) +- reduce plugin load times +- robustify error condition (Darryl L. Miles) + +* Tue Sep 19 2006 Gwenole Beauchesne 0.9.90.3-1 +- fix acrobat reader 7 plugin + +* Sun Sep 17 2006 Gwenole Beauchesne 0.9.90.2-1 +- use a bidirectional communication channel + +* Sun Jun 4 2006 Gwenole Beauchesne 0.9.90.1-1 +- relicense under GPL +- don't use QEMU on IA-64 +- handle SuSE Linux Mozilla paths +- portability fixes to non-Linux platforms + +* Tue Oct 25 2005 Gwenole Beauchesne 0.9.90-1 +- first public beta version diff --git a/src/cxxabi-compat.cpp b/src/cxxabi-compat.cpp new file mode 100644 index 0000000..6a054ba --- /dev/null +++ b/src/cxxabi-compat.cpp @@ -0,0 +1,80 @@ +/* + * cxxabi-compat.cpp - Compatibility glue for older libg++ symbols + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +/* Original code from Mozilla */ + +// On x86 linux, the current builds of some popular plugins (notably +// flashplayer and real) expect a few builtin symbols from libgcc +// which were available in some older versions of gcc. However, +// they're _NOT_ available in newer versions of gcc (eg 3.1), so if we +// want those plugin to work with a gcc-3.1 built binary, we need to +// provide these symbols. MOZ_ENABLE_OLD_ABI_COMPAT_WRAPPERS defaults +// to true on x86 linux, and false everywhere else. +// +// The fact that the new and free operators are mismatched mirrors the +// way the original functions in egcs 1.1.2 worked. + +#include +#include +#include + +#if defined(__linux__) && defined(__i386__) + +extern "C" { + +# ifndef HAVE___BUILTIN_VEC_NEW + void *__builtin_vec_new(size_t aSize, const std::nothrow_t &aNoThrow) throw() + { + return ::operator new(aSize, aNoThrow); + } +# endif + +# ifndef HAVE___BUILTIN_VEC_DELETE + void __builtin_vec_delete(void *aPtr, const std::nothrow_t &) throw () + { + free(aPtr); + } +# endif + +# ifndef HAVE___BUILTIN_NEW + void *__builtin_new(int aSize) + { + return malloc(aSize); + } +# endif + +# ifndef HAVE___BUILTIN_DELETE + void __builtin_delete(void *aPtr) + { + free(aPtr); + } +# endif + +# ifndef HAVE___PURE_VIRTUAL + void __pure_virtual(void) + { + extern void __cxa_pure_virtual(void); + __cxa_pure_virtual(); + } +# endif + +} + +#endif diff --git a/src/debug.c b/src/debug.c new file mode 100644 index 0000000..49d199c --- /dev/null +++ b/src/debug.c @@ -0,0 +1,102 @@ +/* + * debug.c - Debugging utilities + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "sysdeps.h" + +#include +#include +#include +#include +#include + +#include "debug.h" + + +static int g_debug_level = -1; + +void npw_dprintf(const char *format, ...) +{ + if (g_debug_level < 0) { + g_debug_level = 0; + const char *debug_str = getenv("NPW_DEBUG"); + if (debug_str) { + errno = 0; + long v = strtol(debug_str, NULL, 10); + if ((v != LONG_MIN && v != LONG_MAX) || errno != ERANGE) + g_debug_level = v; + } + } + + if (g_debug_level > 0) { + va_list args; + va_start(args, format); + npw_vprintf(format, args); + va_end(args); + } +} + + +static FILE *g_log_file = NULL; + +static FILE *npw_log_file(void) +{ + if (g_log_file == NULL) { + const char *log_file = getenv("NPW_LOG"); + if (log_file) { + const char *mode = "w"; +#ifdef BUILD_VIEWER + /* the wrapper plugin has the responsability to create the file, + thus the viewer is only opening it for appending data. */ + mode = "a"; +#endif + g_log_file = fopen(log_file, mode); + } + if (log_file == NULL) + g_log_file = stderr; + } + if (g_log_file != stderr) + fseek(g_log_file, 0, SEEK_END); + return g_log_file; +} + +static void __attribute__((destructor)) log_file_sentinel(void) +{ + if (g_log_file && g_log_file != stderr) { + fclose(g_log_file); + g_log_file = stderr; + } +} + + +void npw_vprintf(const char *format, va_list args) +{ + FILE *log_file = npw_log_file(); + fprintf(log_file, "*** NSPlugin %s *** ", NPW_COMPONENT_NAME); + vfprintf(log_file, format, args); + fflush(log_file); +} + +void npw_printf(const char *format, ...) +{ + va_list args; + va_start(args, format); + npw_vprintf(format, args); + va_end(args); +} diff --git a/src/debug.h b/src/debug.h new file mode 100644 index 0000000..e8abe57 --- /dev/null +++ b/src/debug.h @@ -0,0 +1,38 @@ +/* + * debug.h - Debugging utilities + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef DEBUG_H +#define DEBUG_H + +#include + +extern void npw_dprintf(const char *format, ...) attribute_hidden; + +extern void npw_printf(const char *format, ...) attribute_hidden; +extern void npw_vprintf(const char *format, va_list args) attribute_hidden; + +#if DEBUG +#define bug npw_dprintf +#define D(x) x +#else +#define D(x) ; +#endif + +#endif /* DEBUG_H */ diff --git a/src/libxpcom.c b/src/libxpcom.c new file mode 100644 index 0000000..b63e37c --- /dev/null +++ b/src/libxpcom.c @@ -0,0 +1,26 @@ +/* + * libxpcom.c - Dummy XPCOM glue + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "sysdeps.h" + +#define DEBUG 1 +#include "debug.h" + +/* NOT IMPLEMENTED YET */ diff --git a/src/npruntime-impl.h b/src/npruntime-impl.h new file mode 100644 index 0000000..f9151e7 --- /dev/null +++ b/src/npruntime-impl.h @@ -0,0 +1,66 @@ +/* + * npruntime.c - Scripting plugins support + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef NPRUNTIME_IMPL_H +#define NPRUNTIME_IMPL_H + +// NPObjectInfo is used to hold additional information for an NPObject instance +typedef struct { + NPObject *npobj; + uint32_t npobj_id; +} NPObjectInfo; + +extern NPObjectInfo *npobject_info_new(NPObject *npobj) attribute_hidden; +extern void npobject_info_destroy(NPObjectInfo *npobj_info) attribute_hidden; +extern NPObjectInfo *npobject_info_lookup(NPObject *npobj) attribute_hidden; + +extern NPObject *npobject_new(uint32_t npobj_id, NPP instance, NPClass *class) attribute_hidden; +extern void npobject_destroy(NPObject *npobj) attribute_hidden; +extern NPObject *npobject_lookup(uint32_t npobj_id) attribute_hidden; +extern void npobject_associate(NPObject *npobj, NPObjectInfo *npobj_info) attribute_hidden; + +extern bool npobject_bridge_new(void) attribute_hidden; +extern void npobject_bridge_destroy(void) attribute_hidden; + +extern NPClass npclass_bridge; + +extern void npclass_invoke_Invalidate(NPObject *npobj) attribute_hidden; +extern bool npclass_invoke_HasMethod(NPObject *npobj, NPIdentifier name) attribute_hidden; +extern bool npclass_invoke_Invoke(NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result) attribute_hidden; +extern bool npclass_invoke_InvokeDefault(NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant *result) attribute_hidden; +extern bool npclass_invoke_HasProperty(NPObject *npobj, NPIdentifier name) attribute_hidden; +extern bool npclass_invoke_GetProperty(NPObject *npobj, NPIdentifier name, NPVariant *result) attribute_hidden; +extern bool npclass_invoke_SetProperty(NPObject *npobj, NPIdentifier name, const NPVariant *value) attribute_hidden; +extern bool npclass_invoke_RemoveProperty(NPObject *npobj, NPIdentifier name) attribute_hidden; + +extern int npclass_handle_Invalidate(rpc_connection_t *connection) attribute_hidden; +extern int npclass_handle_HasMethod(rpc_connection_t *connection) attribute_hidden; +extern int npclass_handle_Invoke(rpc_connection_t *connection) attribute_hidden; +extern int npclass_handle_InvokeDefault(rpc_connection_t *connection) attribute_hidden; +extern int npclass_handle_HasProperty(rpc_connection_t *connection) attribute_hidden; +extern int npclass_handle_GetProperty(rpc_connection_t *connection) attribute_hidden; +extern int npclass_handle_SetProperty(rpc_connection_t *connection) attribute_hidden; +extern int npclass_handle_RemoveProperty(rpc_connection_t *connection) attribute_hidden; +extern int npclass_handle_Invalidate(rpc_connection_t *connection) attribute_hidden; + +struct _NPNetscapeFuncs; +extern void npruntime_init_callbacks(struct _NPNetscapeFuncs *mozilla_funcs); + +#endif /* NPRUNTIME_IMPL_H */ diff --git a/src/npruntime.c b/src/npruntime.c new file mode 100644 index 0000000..7c632bb --- /dev/null +++ b/src/npruntime.c @@ -0,0 +1,706 @@ +/* + * npruntime.c - Scripting plugins support + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "sysdeps.h" + +#include +#include /* */ +#include "utils.h" +#include "rpc.h" +#include "npw-rpc.h" + +#define XP_UNIX 1 +#define MOZ_X11 1 +#include +#include +#include +#include "npruntime-impl.h" + +#define DEBUG 1 +#include "debug.h" + + +// Defined in npw-{wrapper,viewer}.c +extern rpc_connection_t *g_rpc_connection attribute_hidden; + + +/* ====================================================================== */ +/* === NPClass Bridge === */ +/* ====================================================================== */ + +NPClass npclass_bridge = { + NP_CLASS_STRUCT_VERSION, + NULL, + NULL, + npclass_invoke_Invalidate, + npclass_invoke_HasMethod, + npclass_invoke_Invoke, + npclass_invoke_InvokeDefault, + npclass_invoke_HasProperty, + npclass_invoke_GetProperty, + npclass_invoke_SetProperty, + npclass_invoke_RemoveProperty +}; + +// NPClass::Invalidate +int npclass_handle_Invalidate(rpc_connection_t *connection) +{ + NPObject *npobj; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::Invalidate() get args", error); + return error; + } + + if (npobj && npobj->_class && npobj->_class->invalidate) { + D(bug("NPClass::Invalidate(npobj %p)\n", npobj)); + npobj->_class->invalidate(npobj); + D(bug(" done\n")); + } + + return RPC_ERROR_NO_ERROR; +} + +void npclass_invoke_Invalidate(NPObject *npobj) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPCLASS_INVALIDATE, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::Invalidate() invoke", error); + return; + } + + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::Invalidate() wait for reply", error); + return; + } +} + +// NPClass::HasMethod +int npclass_handle_HasMethod(rpc_connection_t *connection) +{ + NPObject *npobj; + NPIdentifier name; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_NP_IDENTIFIER, &name, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::HasMethod() get args", error); + return error; + } + + uint32_t ret = 0; + if (npobj && npobj->_class && npobj->_class->hasMethod) { + D(bug("NPClass::HasMethod(npobj %p, name id %p)\n", npobj, name)); + ret = npobj->_class->hasMethod(npobj, name); + D(bug(" return: %d\n", ret)); + } + + return rpc_method_send_reply(connection, RPC_TYPE_UINT32, ret, RPC_TYPE_INVALID); +} + +bool npclass_invoke_HasMethod(NPObject *npobj, NPIdentifier name) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPCLASS_HAS_METHOD, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_NP_IDENTIFIER, name, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::HasMethod() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &ret, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::HasMethod() wait for reply", error); + return false; + } + + return ret; +} + +// NPClass::Invoke +int npclass_handle_Invoke(rpc_connection_t *connection) +{ + NPObject *npobj; + NPIdentifier name; + uint32_t argCount; + NPVariant *args; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_NP_IDENTIFIER, &name, + RPC_TYPE_ARRAY, RPC_TYPE_NP_VARIANT, &argCount, &args, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::Invoke() get args", error); + return error; + } + + uint32_t ret = 0; + NPVariant result; + VOID_TO_NPVARIANT(result); + if (npobj && npobj->_class && npobj->_class->invoke) { + D(bug("NPClass::Invoke(npobj %p, name id %p)\n", npobj, name)); + ret = npobj->_class->invoke(npobj, name, args, argCount, &result); + D(bug(" return: %d\n", ret)); + } + + free(args); + + return rpc_method_send_reply(connection, + RPC_TYPE_UINT32, ret, + RPC_TYPE_NP_VARIANT, &result, + RPC_TYPE_INVALID); +} + +bool npclass_invoke_Invoke(NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32_t argCount, + NPVariant *result) +{ + if (result == NULL) + return false; + VOID_TO_NPVARIANT(*result); + + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPCLASS_INVOKE, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_NP_IDENTIFIER, name, + RPC_TYPE_ARRAY, RPC_TYPE_NP_VARIANT, argCount, args, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::Invoke() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &ret, + RPC_TYPE_NP_VARIANT, result, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::Invoke() wait for reply", error); + return false; + } + + return ret; +} + +// NPClass::InvokeDefault +int npclass_handle_InvokeDefault(rpc_connection_t *connection) +{ + NPObject *npobj; + uint32_t argCount; + NPVariant *args; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_ARRAY, RPC_TYPE_NP_VARIANT, &argCount, &args, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::InvokeDefault() get args", error); + return error; + } + + uint32_t ret = 0; + NPVariant result; + VOID_TO_NPVARIANT(result); + if (npobj && npobj->_class && npobj->_class->invokeDefault) { + D(bug("NPClass::InvokeDefault(npobj %p)\n", npobj)); + ret = npobj->_class->invokeDefault(npobj, args, argCount, &result); + D(bug(" return: %d\n", ret)); + } + + free(args); + + return rpc_method_send_reply(connection, + RPC_TYPE_UINT32, ret, + RPC_TYPE_NP_VARIANT, &result, + RPC_TYPE_INVALID); +} + +bool npclass_invoke_InvokeDefault(NPObject *npobj, const NPVariant *args, uint32_t argCount, + NPVariant *result) +{ + if (result == NULL) + return false; + VOID_TO_NPVARIANT(*result); + + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPCLASS_INVOKE_DEFAULT, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_ARRAY, RPC_TYPE_NP_VARIANT, argCount, args, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::InvokeDefault() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &ret, + RPC_TYPE_NP_VARIANT, result, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::InvokeDefault() wait for reply", error); + return false; + } + + return ret; +} + +// NPClass::HasProperty +int npclass_handle_HasProperty(rpc_connection_t *connection) +{ + NPObject *npobj; + NPIdentifier name; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_NP_IDENTIFIER, &name, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::HasProperty() get args", error); + return error; + } + + uint32_t ret = 0; + if (npobj && npobj->_class && npobj->_class->hasProperty) { + D(bug("NPClass::HasProperty(npobj %p, name id %p)\n", npobj, name)); + ret = npobj->_class->hasProperty(npobj, name); + D(bug(" return: %d\n", ret)); + } + + return rpc_method_send_reply(connection, RPC_TYPE_UINT32, ret, RPC_TYPE_INVALID); +} + +bool npclass_invoke_HasProperty(NPObject *npobj, NPIdentifier name) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPCLASS_HAS_PROPERTY, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_NP_IDENTIFIER, name, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::HasProperty() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &ret, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::HasProperty() wait for reply", error); + return false; + } + + return ret; +} + +// NPClass::GetProperty +int npclass_handle_GetProperty(rpc_connection_t *connection) +{ + NPObject *npobj; + NPIdentifier name; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_NP_IDENTIFIER, &name, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::GetProperty() get args", error); + return error; + } + + uint32_t ret = 0; + NPVariant result; + VOID_TO_NPVARIANT(result); + if (npobj && npobj->_class && npobj->_class->getProperty) { + D(bug("NPClass::GetProperty(npobj %p, name id %p)\n", npobj, name)); + ret = npobj->_class->getProperty(npobj, name, &result); + D(bug(" return: %d\n", ret)); + } + + return rpc_method_send_reply(connection, + RPC_TYPE_UINT32, ret, + RPC_TYPE_NP_VARIANT, &result, + RPC_TYPE_INVALID); +} + +bool npclass_invoke_GetProperty(NPObject *npobj, NPIdentifier name, NPVariant *result) +{ + if (result == NULL) + return false; + VOID_TO_NPVARIANT(*result); + + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPCLASS_GET_PROPERTY, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_NP_IDENTIFIER, name, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::GetProperty() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &ret, + RPC_TYPE_NP_VARIANT, result, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::GetProperty() wait for reply", error); + return false; + } + + return ret; +} + +// NPClass::SetProperty +int npclass_handle_SetProperty(rpc_connection_t *connection) +{ + NPObject *npobj; + NPIdentifier name; + NPVariant value; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_NP_IDENTIFIER, &name, + RPC_TYPE_NP_VARIANT, &value, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::SetProperty() get args", error); + return error; + } + + uint32_t ret = 0; + if (npobj && npobj->_class && npobj->_class->setProperty) { + D(bug("NPClass::SetProperty(npobj %p, name id %p)\n", npobj, name)); + ret = npobj->_class->setProperty(npobj, name, &value); + D(bug(" return: %d\n", ret)); + } + + return rpc_method_send_reply(connection, + RPC_TYPE_UINT32, ret, + RPC_TYPE_INVALID); +} + +bool npclass_invoke_SetProperty(NPObject *npobj, NPIdentifier name, const NPVariant *value) +{ + if (value == NULL) + return false; + + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPCLASS_SET_PROPERTY, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_NP_IDENTIFIER, name, + RPC_TYPE_NP_VARIANT, value, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::SetProperty() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &ret, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::SetProperty() wait for reply", error); + return false; + } + + return ret; +} + +// NPClass::RemoveProperty +int npclass_handle_RemoveProperty(rpc_connection_t *connection) +{ + NPObject *npobj; + NPIdentifier name; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_NP_IDENTIFIER, &name, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::RemoveProperty() get args", error); + return error; + } + + uint32_t ret = 0; + if (npobj && npobj->_class && npobj->_class->removeProperty) { + D(bug("NPClass::RemoveProperty(npobj %p, name id %p)\n", npobj, name)); + ret = npobj->_class->removeProperty(npobj, name); + D(bug(" return: %d\n", ret)); + } + + return rpc_method_send_reply(connection, RPC_TYPE_UINT32, ret, RPC_TYPE_INVALID); +} + +bool npclass_invoke_RemoveProperty(NPObject *npobj, NPIdentifier name) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPCLASS_REMOVE_PROPERTY, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_NP_IDENTIFIER, name, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::RemoveProperty() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &ret, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPClass::RemoveProperty() wait for reply", error); + return false; + } + + return ret; +} + + +/* ====================================================================== */ +/* === NPObjectInfo === */ +/* ====================================================================== */ + +NPObjectInfo *npobject_info_new(NPObject *npobj) +{ + NPObjectInfo *npobj_info = malloc(sizeof(*npobj_info)); + if (npobj_info) { + static uint32_t id; + npobj_info->npobj = npobj; + npobj_info->npobj_id = ++id; + } + return npobj_info; +} + +void npobject_info_destroy(NPObjectInfo *npobj_info) +{ + if (npobj_info) + free(npobj_info); +} + + +/* ====================================================================== */ +/* === NPObject === */ +/* ====================================================================== */ + +static void npobject_hash_table_insert(NPObject *npobj, NPObjectInfo *npobj_info); +static bool npobject_hash_table_remove(NPObject *npobj); + +static NPObject *_npobject_new(NPP instance, NPClass *class) +{ + NPObject *npobj; + if (class && class->allocate) + npobj = class->allocate(instance, class); + else + npobj = malloc(sizeof(*npobj)); + if (npobj) { + npobj->_class = class ? class : &npclass_bridge; + npobj->referenceCount = 1; + } + return npobj; +} + +static void _npobject_destroy(NPObject *npobj) +{ + if (npobj) { + if (npobj->_class && npobj->_class->deallocate) + npobj->_class->deallocate(npobj); + else + free(npobj); + } +} + +NPObject *npobject_new(uint32_t npobj_id, NPP instance, NPClass *class) +{ + NPObject *npobj = _npobject_new(instance, class); + if (npobj == NULL) + return NULL; + + NPObjectInfo *npobj_info = npobject_info_new(npobj); + if (npobj_info == NULL) { + _npobject_destroy(npobj); + return NULL; + } + npobj_info->npobj_id = npobj_id; + npobject_associate(npobj, npobj_info); + return npobj; +} + +void npobject_destroy(NPObject *npobj) +{ + if (npobj) + npobject_hash_table_remove(npobj); + + _npobject_destroy(npobj); +} + +void npobject_associate(NPObject *npobj, NPObjectInfo *npobj_info) +{ + assert(npobj && npobj_info && npobj_info > 0); + npobject_hash_table_insert(npobj, npobj_info); +} + + +/* ====================================================================== */ +/* === NPObject Repository === */ +/* ====================================================================== */ + +// NOTE: those hashes must be maintained in a whole, not separately +static GHashTable *g_npobjects = NULL; // (NPObject *) -> (NPObjectInfo *) +static GHashTable *g_npobject_ids = NULL; // (NPObject ID) -> (NPObject *) + +bool npobject_bridge_new(void) +{ + if ((g_npobjects = g_hash_table_new_full(NULL, NULL, NULL, (GDestroyNotify)npobject_info_destroy)) == NULL) + return false; + if ((g_npobject_ids = g_hash_table_new(NULL, NULL)) == NULL) + return false; + return true; +} + +void npobject_bridge_destroy(void) +{ + g_hash_table_destroy(g_npobject_ids); + g_hash_table_destroy(g_npobjects); +} + +void npobject_hash_table_insert(NPObject *npobj, NPObjectInfo *npobj_info) +{ + g_hash_table_insert(g_npobjects, npobj, npobj_info); + g_hash_table_insert(g_npobject_ids, (void *)(uintptr_t)npobj_info->npobj_id, npobj); +} + +bool npobject_hash_table_remove(NPObject *npobj) +{ + NPObjectInfo *npobj_info = npobject_info_lookup(npobj); + assert(npobj_info != NULL); + bool removed_all = true; + if (!g_hash_table_remove(g_npobject_ids, (void *)(uintptr_t)npobj_info->npobj_id)) + removed_all = false; + if (!g_hash_table_remove(g_npobjects, npobj)) + removed_all = false; + return removed_all; +} + +NPObjectInfo *npobject_info_lookup(NPObject *npobj) +{ + return g_hash_table_lookup(g_npobjects, npobj); +} + +NPObject *npobject_lookup(uint32_t npobj_id) +{ + return g_hash_table_lookup(g_npobject_ids, (void *)(uintptr_t)npobj_id); +} + + +/* ====================================================================== */ +/* === Dummy npruntime accessors === */ +/* ====================================================================== */ + +static void dummy_function_do_nothing(void) +{ +} + +static int dummy_function_return_zero(void) +{ + return 0; +} + +static bool dummy_function_return_void_variant(NPVariant *variant) +{ + if (variant) + VOID_TO_NPVARIANT(*variant); + return false; +} + +static bool dummy_NPN_Invoke(NPP npp, NPObject* obj, NPIdentifier methodName, + const NPVariant *args, uint32_t argCount, NPVariant *result) +{ + return dummy_function_return_void_variant(result); +} + +static bool dummy_NPN_InvokeDefault(NPP npp, NPObject* obj, const NPVariant *args, + uint32_t argCount, NPVariant *result) +{ + return dummy_function_return_void_variant(result); +} + +static bool dummy_NPN_Evaluate(NPP npp, NPObject* obj, NPString *script, + NPVariant *result) +{ + return dummy_function_return_void_variant(result); +} + +static bool dummy_NPN_GetProperty(NPP npp, NPObject* obj, NPIdentifier propertyName, + NPVariant *result) +{ + return dummy_function_return_void_variant(result); +} + +void npruntime_init_callbacks(NPNetscapeFuncs *mozilla_funcs) +{ + mozilla_funcs->getstringidentifier = NewNPN_GetStringIdentifierProc(dummy_function_return_zero); + mozilla_funcs->getstringidentifiers = NewNPN_GetStringIdentifiersProc(dummy_function_do_nothing); + mozilla_funcs->getintidentifier = NewNPN_GetIntIdentifierProc(dummy_function_return_zero); + mozilla_funcs->identifierisstring = NewNPN_IdentifierIsStringProc(dummy_function_return_zero); + mozilla_funcs->utf8fromidentifier = NewNPN_UTF8FromIdentifierProc(dummy_function_return_zero); + mozilla_funcs->intfromidentifier = NewNPN_IntFromIdentifierProc(dummy_function_return_zero); + mozilla_funcs->createobject = NewNPN_CreateObjectProc(dummy_function_return_zero); + mozilla_funcs->retainobject = NewNPN_RetainObjectProc(dummy_function_return_zero); + mozilla_funcs->releaseobject = NewNPN_ReleaseObjectProc(dummy_function_do_nothing); + mozilla_funcs->invoke = NewNPN_InvokeProc(dummy_NPN_Invoke); + mozilla_funcs->invokeDefault = NewNPN_InvokeDefaultProc(dummy_NPN_InvokeDefault); + mozilla_funcs->evaluate = NewNPN_EvaluateProc(dummy_NPN_Evaluate); + mozilla_funcs->getproperty = NewNPN_GetPropertyProc(dummy_NPN_GetProperty); + mozilla_funcs->setproperty = NewNPN_SetPropertyProc(dummy_function_return_zero); + mozilla_funcs->removeproperty = NewNPN_RemovePropertyProc(dummy_function_return_zero); + mozilla_funcs->hasproperty = NewNPN_HasPropertyProc(dummy_function_return_zero); + mozilla_funcs->hasmethod = NewNPN_HasMethodProc(dummy_function_return_zero); + mozilla_funcs->releasevariantvalue = NewNPN_ReleaseVariantValueProc(dummy_function_do_nothing); + mozilla_funcs->setexception = NewNPN_SetExceptionProc(dummy_function_do_nothing); +} diff --git a/src/npw-config.c b/src/npw-config.c new file mode 100644 index 0000000..65c2d9d --- /dev/null +++ b/src/npw-config.c @@ -0,0 +1,1097 @@ +/* + * npw-config.c - nspluginwrapper configuration tool + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "sysdeps.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include + + +static bool g_auto = false; +static bool g_verbose = false; +static const char NPW_CONFIG[] = "nspluginwrapper"; + +static void error(const char *format, ...) +{ + va_list args; + va_start(args, format); + fprintf(stderr, "%s: ", NPW_CONFIG); + vfprintf(stderr, format, args); + fprintf(stderr, "\n"); + va_end(args); + exit(1); +} + +static int strstart(const char *str, const char *val, const char **ptr) +{ + const char *p, *q; + p = str; + q = val; + while (*q != '\0') { + if (*p != *q) + return 0; + p++; + q++; + } + if (ptr) + *ptr = p; + return 1; +} + +/* Implement mkdir -p with default permissions (derived from busybox code) */ +static int mkdir_p(const char *path) +{ + char path_copy[strlen(path) + 1]; + char *s = path_copy; + path = strcpy(s, path); + for (;;) { + char c = 0; + while (*s) { + if (*s == '/') { + while (*++s == '/') + ; + c = *s; + *s = 0; + break; + } + ++s; + } + if (mkdir(path, 0755) < 0) { + struct stat st; + if ((errno != EEXIST && errno != EISDIR) || stat(path, &st) < 0 || !S_ISDIR(st.st_mode)) + break; + } + if ((*s = c) == '\0') + return 0; + } + return -1; +} + +static const char *get_user_home_dir(void) +{ + struct passwd *pwent = getpwuid(geteuid()); + if (pwent) + return pwent->pw_dir; + + return getenv("HOME"); +} + +static const char *get_system_mozilla_plugin_dir(void) +{ + static const char default_dir[] = LIBDIR "/mozilla/plugins"; + static const char *dir = NULL; + + if (dir == NULL) { + const char **dirs = NULL; + +#if defined(__FreeBSD__) + { + static const char *freebsd_dirs[] = { + "/usr/X11R6/" LIB "/browser_plugins", + "/usr/X11R6/" LIB "/firefox/plugins", + }; + dirs = freebsd_dirs; + } +#elif defined(__NetBSD__) + { + static const char *netbsd_dirs[] = { + "/usr/pkg/" LIB "/mozilla/plugins", + "/usr/pkg/" LIB "/firefox/plugins", + }; + dirs = netbsd_dirs; + } +#elif defined(__linux__) + if (access("/etc/SuSE-release", F_OK) == 0) { + static const char *suse_dirs[] = { + LIBDIR "/browser-plugins", + LIBDIR "/firefox/plugins", + LIBDIR "/seamonkey/plugins", + "/opt/MozillaFirefox/" LIB "/plugins", + }; + dirs = suse_dirs; + } + else if (access("/etc/debian_version", F_OK) == 0) { + static const char *debian_dirs[] = { + "/usr/lib/mozilla/plugins", // XXX how unfortunate + }; + dirs = debian_dirs; + } + else if (access("/etc/gentoo-release", F_OK) == 0) { + static const char *gentoo_dirs[] = { + LIBDIR "/nsbrowser/plugins", + }; + dirs = gentoo_dirs; + } +#endif + + if (dirs) { + while ((dir = *dirs++) != NULL) { + if (access(dir, F_OK) == 0) + break; + } + } + + if (dir == NULL) + dir = default_dir; + } + + return dir; +} + +static const char *get_user_mozilla_plugin_dir(void) +{ + const char *home; + static char plugin_path[PATH_MAX]; + + if ((home = get_user_home_dir()) == NULL) + return NULL; + + sprintf(plugin_path, "%s/.mozilla/plugins", home); + return plugin_path; +} + +static const char **get_mozilla_plugin_dirs(void) +{ + static const char *default_dirs[] = { + "/usr/lib/mozilla/plugins", + "/usr/lib32/mozilla/plugins", // XXX how unfortunate + "/usr/lib64/mozilla/plugins", + "/usr/lib/browser-plugins", + "/usr/lib64/browser-plugins", + "/usr/lib/firefox/plugins", + "/usr/lib64/firefox/plugins", + "/usr/lib/seamonkey/plugins", + "/usr/lib64/seamonkey/plugins", + "/opt/MozillaFirefox/lib/plugins", + "/opt/MozillaFirefox/lib64/plugins", + "/usr/lib/nsbrowser/plugins", + "/usr/lib32/nsbrowser/plugins", // XXX how unfortunate + "/usr/lib64/nsbrowser/plugins", +#if defined(__FreeBSD__) + "/usr/X11R6/lib/browser_plugins", + "/usr/X11R6/lib/firefox/plugins", + "/usr/X11R6/lib/linux-mozilla/plugins", + "/usr/local/lib/npapi/linux-flashplugin", + "/usr/X11R6/Adobe/Acrobat7.0/ENU/Browser/intellinux", +#endif +#if defined(__NetBSD__) + "/usr/pkg/lib/netscape/plugins", + "/usr/pkg/lib/firefox/plugins", + "/usr/pkg/lib/RealPlayer/mozilla", + "/usr/pkg/Acrobat5/Browsers/intellinux", + "/usr/pkg/Acrobat7/Browser/intellinux", +#endif + }; + + const int n_default_dirs = (sizeof(default_dirs) / sizeof(default_dirs[0])); + const char **dirs = malloc((n_default_dirs + 2) * sizeof(dirs[0])); + int i, j; + for (i = 0, j = 0; i < n_default_dirs; i++) { + const char *dir = default_dirs[i]; + if (dir && access(dir, F_OK) == 0) + dirs[j++] = dir; + } + dirs[j++] = get_user_mozilla_plugin_dir(); + dirs[j] = NULL; + return dirs; +} + +/* ELF decoder derived from QEMU code */ + +#undef bswap_16 +#define bswap_16(x) \ + ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8)) + +#undef bswap_32 +#define bswap_32(x) \ + ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \ + (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24)) + +/* 32-bit ELF base types. */ +typedef uint16_t Elf32_Half; +typedef uint32_t Elf32_Word; +typedef uint32_t Elf32_Addr; +typedef uint32_t Elf32_Off; + +/* The ELF file header. This appears at the start of every ELF file. */ +#define EI_NIDENT (16) + +typedef struct +{ + unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */ + Elf32_Half e_type; /* Object file type */ + Elf32_Half e_machine; /* Architecture */ + Elf32_Word e_version; /* Object file version */ + Elf32_Addr e_entry; /* Entry point virtual address */ + Elf32_Off e_phoff; /* Program header table file offset */ + Elf32_Off e_shoff; /* Section header table file offset */ + Elf32_Word e_flags; /* Processor-specific flags */ + Elf32_Half e_ehsize; /* ELF header size in bytes */ + Elf32_Half e_phentsize; /* Program header table entry size */ + Elf32_Half e_phnum; /* Program header table entry count */ + Elf32_Half e_shentsize; /* Section header table entry size */ + Elf32_Half e_shnum; /* Section header table entry count */ + Elf32_Half e_shstrndx; /* Section header string table index */ +} Elf32_Ehdr; + +#define EI_MAG0 0 /* File identification byte 0 index */ +#define ELFMAG0 0x7f /* Magic number byte 0 */ +#define EI_MAG1 1 /* File identification byte 1 index */ +#define ELFMAG1 'E' /* Magic number byte 1 */ +#define EI_MAG2 2 /* File identification byte 2 index */ +#define ELFMAG2 'L' /* Magic number byte 2 */ +#define EI_MAG3 3 /* File identification byte 3 index */ +#define ELFMAG3 'F' /* Magic number byte 3 */ +#define EI_CLASS 4 /* File class byte index */ +#define ELFCLASS32 1 /* 32-bit objects */ +#define ELFCLASS64 2 /* 64-bit objects */ +#define EI_DATA 5 /* Data encoding byte index */ +#define ELFDATA2LSB 1 /* 2's complement, little endian */ +#define ELFDATA2MSB 2 /* 2's complement, big endian */ +#define EI_OSABI 7 /* OS ABI identification */ +#define ELFOSABI_SYSV 0 /* UNIX System V ABI */ +#define ELFOSABI_NETBSD 2 /* NetBSD. */ +#define ELFOSABI_LINUX 3 /* Linux. */ +#define ELFOSABI_SOLARIS 6 /* Sun Solaris. */ +#define ELFOSABI_FREEBSD 9 /* FreeBSD. */ +#define ET_DYN 3 /* Shared object file */ +#define EM_386 3 /* Intel 80386 */ +#define EM_SPARC 2 /* SUN SPARC */ +#define EM_PPC 20 /* PowerPC */ +#define EM_PPC64 21 /* PowerPC 64-bit */ +#define EM_SPARCV9 43 /* SPARC v9 64-bit */ +#define EM_IA_64 50 /* Intel Merced */ +#define EM_X86_64 62 /* AMD x86-64 architecture */ +#define EV_CURRENT 1 /* Current version */ + +/* Section header. */ +typedef struct +{ + Elf32_Word sh_name; /* Section name (string tbl index) */ + Elf32_Word sh_type; /* Section type */ + Elf32_Word sh_flags; /* Section flags */ + Elf32_Addr sh_addr; /* Section virtual addr at execution */ + Elf32_Off sh_offset; /* Section file offset */ + Elf32_Word sh_size; /* Section size in bytes */ + Elf32_Word sh_link; /* Link to another section */ + Elf32_Word sh_info; /* Additional section information */ + Elf32_Word sh_addralign; /* Section alignment */ + Elf32_Word sh_entsize; /* Entry size if section holds table */ +} Elf32_Shdr; + +#define SHT_NOBITS 8 /* Program space with no data (bss) */ +#define SHT_DYNSYM 11 /* Dynamic linker symbol table */ + +/* Symbol table entry. */ +typedef struct +{ + Elf32_Word st_name; /* Symbol name (string tbl index) */ + Elf32_Addr st_value; /* Symbol value */ + Elf32_Word st_size; /* Symbol size */ + unsigned char st_info; /* Symbol type and binding */ + unsigned char st_other; /* Symbol visibility */ + Elf32_Half st_shndx; /* Section index */ +} Elf32_Sym; + +#define ELF32_ST_BIND(val) (((unsigned char) (val)) >> 4) +#define ELF32_ST_TYPE(val) ((val) & 0xf) +#define STB_GLOBAL 1 /* Global symbol */ +#define STT_OBJECT 1 /* Symbol is a data object */ +#define STT_FUNC 2 /* Symbol is a code object */ + +/* We handle 32-bit ELF plugins only */ +#undef ELF_CLASS +#define ELF_CLASS ELFCLASS32 +#define ElfW(x) Elf32_ ## x +#define ELFW(x) ELF32_ ## x + +void *load_data(int fd, long offset, unsigned int size) +{ + char *data = (char *)malloc(size); + if (!data) + return NULL; + + lseek(fd, offset, SEEK_SET); + if (read(fd, data, size) != size) { + free(data); + return NULL; + } + + return data; +} + +static bool is_little_endian(void) +{ + union { uint32_t i; uint8_t b[4]; } x; + x.i = 0x01020304; + return x.b[0] == 0x04; +} + +static void elf_swap_ehdr(ElfW(Ehdr) *hdr) +{ + hdr->e_type = bswap_16(hdr->e_type); + hdr->e_machine = bswap_16(hdr->e_machine); + hdr->e_version = bswap_32(hdr->e_version); + hdr->e_entry = bswap_32(hdr->e_entry); + hdr->e_phoff = bswap_32(hdr->e_phoff); + hdr->e_shoff = bswap_32(hdr->e_shoff); + hdr->e_flags = bswap_32(hdr->e_flags); + hdr->e_ehsize = bswap_16(hdr->e_ehsize); + hdr->e_phentsize = bswap_16(hdr->e_phentsize); + hdr->e_phnum = bswap_16(hdr->e_phnum); + hdr->e_shentsize = bswap_16(hdr->e_shentsize); + hdr->e_shnum = bswap_16(hdr->e_shnum); + hdr->e_shstrndx = bswap_16(hdr->e_shstrndx); +} + +static void elf_swap_shdr(ElfW(Shdr) *shdr) +{ + shdr->sh_name = bswap_32(shdr->sh_name); + shdr->sh_type = bswap_32(shdr->sh_type); + shdr->sh_flags = bswap_32(shdr->sh_flags); + shdr->sh_addr = bswap_32(shdr->sh_addr); + shdr->sh_offset = bswap_32(shdr->sh_offset); + shdr->sh_size = bswap_32(shdr->sh_size); + shdr->sh_link = bswap_32(shdr->sh_link); + shdr->sh_info = bswap_32(shdr->sh_info); + shdr->sh_addralign = bswap_32(shdr->sh_addralign); + shdr->sh_entsize = bswap_32(shdr->sh_entsize); +} + +static void elf_swap_sym(ElfW(Sym) *sym) +{ + sym->st_name = bswap_32(sym->st_name); + sym->st_value = bswap_32(sym->st_value); + sym->st_size = bswap_32(sym->st_size); + sym->st_shndx = bswap_32(sym->st_shndx); +} + +static bool is_plugin_fd(int fd, NPW_PluginInfo *out_plugin_info) +{ + int i; + bool ret = false; + + ElfW(Ehdr) ehdr; + if (read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr)) + return false; + + if (ehdr.e_ident[EI_MAG0] != ELFMAG0 + || ehdr.e_ident[EI_MAG1] != ELFMAG1 + || ehdr.e_ident[EI_MAG2] != ELFMAG2 + || ehdr.e_ident[EI_MAG3] != ELFMAG3) + return false; + + bool do_swap = (ehdr.e_ident[EI_DATA] == ELFDATA2LSB) && !is_little_endian(); + if (do_swap) + elf_swap_ehdr(&ehdr); + + if (ehdr.e_ident[EI_CLASS] != ELF_CLASS) + return false; + if (ehdr.e_type != ET_DYN) + return false; + if (ehdr.e_version != EV_CURRENT) + return false; + + if (out_plugin_info) { + const char *target_arch = ""; + switch (ehdr.e_machine) { + case EM_386: target_arch = "i386"; break; + case EM_SPARC: target_arch = "sparc"; break; + case EM_PPC: target_arch = "ppc"; break; + } + strcpy(out_plugin_info->target_arch, target_arch); + const char *target_os = ""; + switch (ehdr.e_ident[EI_OSABI]) { + case ELFOSABI_LINUX: target_os = "linux"; break; + case ELFOSABI_SOLARIS: target_os = "solaris"; break; + case ELFOSABI_FREEBSD: target_os = "freebsd"; break; + } + strcpy(out_plugin_info->target_os, target_os); + } + + ElfW(Shdr) *shdr = (ElfW(Shdr) *)load_data(fd, ehdr.e_shoff, ehdr.e_shnum * sizeof(*shdr)); + if (do_swap) { + for (i = 0; i < ehdr.e_shnum; i++) + elf_swap_shdr(&shdr[i]); + } + + char **sdata = (char **)calloc(ehdr.e_shnum, sizeof(*sdata)); + for (i = 0; i < ehdr.e_shnum; i++) { + ElfW(Shdr) *sec = &shdr[i]; + if (sec->sh_type != SHT_NOBITS) + sdata[i] = (char *)load_data(fd, sec->sh_offset, sec->sh_size); + } + + ElfW(Shdr) *symtab_sec = NULL; + for (i = 0; i < ehdr.e_shnum; i++) { + ElfW(Shdr) *sec = &shdr[i]; + if (sec->sh_type == SHT_DYNSYM + && strcmp(sdata[ehdr.e_shstrndx] + sec->sh_name, ".dynsym") == 0) { + symtab_sec = sec; + break; + } + } + if (symtab_sec == NULL) + goto done; + ElfW(Sym) *symtab = (ElfW(Sym) *)sdata[symtab_sec - shdr]; + char *strtab = sdata[symtab_sec->sh_link]; + + int nb_syms = symtab_sec->sh_size / sizeof(*symtab); + if (do_swap) { + for (i = 0; i < nb_syms; i++) + elf_swap_sym(&symtab[i]); + } + + int nb_np_syms; + int is_wrapper_plugin = 0; + for (i = 0, nb_np_syms = 0; i < nb_syms; i++) { + ElfW(Sym) *sym = &symtab[i]; + const char *name = strtab + sym->st_name; + if (ELFW(ST_BIND)(sym->st_info) != STB_GLOBAL) + continue; + if (ELFW(ST_TYPE)(sym->st_info) == STT_OBJECT && strcmp(name, "NPW_Plugin") == 0) + is_wrapper_plugin = 1; + if (ELFW(ST_TYPE)(sym->st_info) != STT_FUNC) + continue; + if (!strcmp(name, "NP_GetMIMEDescription") || + !strcmp(name, "NP_Initialize") || + !strcmp(name, "NP_Shutdown")) + nb_np_syms++; + } + ret = (nb_np_syms == 3) && !is_wrapper_plugin; + + done: + for (i = 0; i < ehdr.e_shnum; i++) + free(sdata[i]); + free(sdata); + free(shdr); + return ret; +} + +static bool is_plugin_viewer_available(const char *filename, NPW_PluginInfo *out_plugin_info) +{ + static const char *target_arch_table[] = { + NULL, + "i386", + NULL + }; + const int target_arch_table_size = sizeof(target_arch_table) / sizeof(target_arch_table[0]); + + if (out_plugin_info && out_plugin_info->target_arch[0] != '\0') + target_arch_table[0] = out_plugin_info->target_arch; + else + target_arch_table[0] = NULL; + + static const char *target_os_table[] = { + NULL, + "linux", + NULL + }; + const int target_os_table_size = sizeof(target_os_table) / sizeof(target_os_table[0]); + + if (out_plugin_info && out_plugin_info->target_os[0] != '\0') + target_os_table[0] = out_plugin_info->target_os; + else + target_os_table[0] = NULL; + + for (int i = 0; i < target_arch_table_size; i++) { + const char *target_arch = target_arch_table[i]; + if (target_arch == NULL) + continue; + char viewer_arch_path[PATH_MAX]; + sprintf(viewer_arch_path, "%s/%s", NPW_LIBDIR, target_arch); + if (access(viewer_arch_path, F_OK) != 0) { + target_arch_table[i] = NULL; // this target ARCH is not available, skip it for good + continue; + } + for (int j = 0; j < target_os_table_size; j++) { + const char *target_os = target_os_table[j]; + if (target_os == NULL) + continue; + if (strcmp(target_arch, HOST_ARCH) == 0 && strcmp(target_os, HOST_OS) == 0) + continue; // skip viewers that match host OS/ARCH pairs + char viewer_path[PATH_MAX]; + sprintf(viewer_path, "%s/%s/%s", viewer_arch_path, target_os, NPW_VIEWER); + if (access(viewer_path, F_OK) != 0) + continue; + int pid = fork(); + if (pid < 0) + continue; + else if (pid == 0) { + execl(viewer_path, NPW_VIEWER, "--test", "--plugin", filename, NULL); + exit(1); + } + else { + int status; + while (waitpid(pid, &status, 0) != pid) + ; + if (WIFEXITED(status) && WEXITSTATUS(status) == 0) { + if (out_plugin_info) { + strcpy(out_plugin_info->target_arch, target_arch); + strcpy(out_plugin_info->target_os, target_os); + } + return true; + } + } + } + } + return false; +} + +static bool is_plugin(const char *filename, NPW_PluginInfo *out_plugin_info) +{ + int fd = open(filename, O_RDONLY); + if (fd < 0) + return false; + + bool ret = is_plugin_fd(fd, out_plugin_info); + close(fd); + return ret; +} + +static bool is_compatible_plugin(const char *filename, NPW_PluginInfo *out_plugin_info) +{ + return is_plugin(filename, out_plugin_info) && is_plugin_viewer_available(filename, out_plugin_info); +} + +static bool is_wrapper_plugin_handle(void *handle, NPW_PluginInfo *out_plugin_info) +{ + if (dlsym(handle, "NP_Initialize") == NULL) + return false; + if (dlsym(handle, "NP_Shutdown") == NULL) + return false; + if (dlsym(handle, "NP_GetMIMEDescription") == NULL) + return false; + NPW_PluginInfo *pi; + if ((pi = (NPW_PluginInfo *)dlsym(handle, "NPW_Plugin")) == NULL) + return false; + if (out_plugin_info) { + strcpy(out_plugin_info->ident, pi->ident); + strcpy(out_plugin_info->path, pi->path); + out_plugin_info->mtime = pi->mtime; + out_plugin_info->target_arch[0] = '\0'; + out_plugin_info->target_os[0] = '\0'; + if (strncmp(pi->ident, "NPW:0.9.90", 10) != 0) { // additional members in 0.9.91+ + strcpy(out_plugin_info->target_arch, pi->target_arch); + strcpy(out_plugin_info->target_os, pi->target_os); + } + } + return true; +} + +static bool is_wrapper_plugin(const char *plugin_path, NPW_PluginInfo *out_plugin_info) +{ + void *handle = dlopen(plugin_path, RTLD_LAZY); + if (handle == NULL) + return false; + + bool ret = is_wrapper_plugin_handle(handle, out_plugin_info); + dlclose(handle); + return ret; +} + +static bool is_wrapper_plugin_0(const char *plugin_path) +{ + NPW_PluginInfo plugin_info; + return is_wrapper_plugin(plugin_path, &plugin_info) + && strcmp(plugin_info.path, NPW_DEFAULT_PLUGIN_PATH) != 0 // exclude OS/ARCH npwrapper.so + && strcmp(plugin_info.path, NPW_OLD_DEFAULT_PLUGIN_PATH) != 0; // exclude ARCH npwrapper.so +} + +static bool is_system_wide_wrapper_plugin(const char *plugin_path) +{ + char *plugin_base = strrchr(plugin_path, '/'); + if (plugin_base == NULL) + return false; + plugin_base += 1; + + char s_plugin_path[PATH_MAX]; + int n = snprintf(s_plugin_path, sizeof(s_plugin_path), "%s/%s.%s", get_system_mozilla_plugin_dir(), NPW_WRAPPER_BASE, plugin_base); + if (n < 0 || n >= sizeof(s_plugin_path)) + return false; + + struct stat st; + if (stat(plugin_path, &st) < 0) + return false; + + NPW_PluginInfo plugin_info; + return (is_wrapper_plugin(s_plugin_path, &plugin_info) + && strcmp(plugin_info.path, plugin_path) == 0 + && strcmp(plugin_info.ident, NPW_PLUGIN_IDENT) == 0 + && plugin_info.mtime == st.st_mtime); +} + +typedef bool (*is_plugin_cb)(const char *plugin_path, NPW_PluginInfo *plugin_info); +typedef int (*process_plugin_cb)(const char *plugin_path, NPW_PluginInfo *plugin_info); + +static int process_plugin_dir(const char *plugin_dir, is_plugin_cb test, process_plugin_cb process) +{ + if (g_verbose) + printf("Looking for plugins in %s\n", plugin_dir); + + DIR *dir = opendir(plugin_dir); + if (dir == NULL) + return -1; + + int plugin_path_length = 256; + char *plugin_path = (char *)malloc(plugin_path_length); + int plugin_dir_length = strlen(plugin_dir); + + struct dirent *ent; + while ((ent = readdir(dir)) != NULL) { + int len = plugin_dir_length + 1 + strlen(ent->d_name) + 1; + if (len > plugin_path_length) { + plugin_path_length = len; + plugin_path = (char *)realloc(plugin_path, plugin_path_length); + } + sprintf(plugin_path, "%s/%s", plugin_dir, ent->d_name); + NPW_PluginInfo plugin_info; + if (test(plugin_path, &plugin_info)) + process(plugin_path, &plugin_info); + } + + free(plugin_path); + closedir(dir); + return 0; +} + +static int do_install_plugin(const char *plugin_path, const char *plugin_dir, NPW_PluginInfo *plugin_info) +{ + if (plugin_dir == NULL) + return 1; + + char *plugin_base = strrchr(plugin_path, '/'); + if (plugin_base == NULL) + return 2; + plugin_base += 1; + + char d_plugin_path[PATH_MAX]; + int n = snprintf(d_plugin_path, sizeof(d_plugin_path), "%s/%s.%s", plugin_dir, NPW_WRAPPER_BASE, plugin_base); + if (n < 0 || n >= sizeof(d_plugin_path)) + return 3; + + int mode = 0700; + if (geteuid() == 0 && strcmp(plugin_dir, "/root") != 0) + mode = 0755; + + NPW_PluginInfo w_plugin_info; + if (!is_wrapper_plugin(NPW_DEFAULT_PLUGIN_PATH, &w_plugin_info)) + return 5; + const char *w_plugin_path, *plugin_ident; + plugin_ident = w_plugin_info.ident; + w_plugin_path = w_plugin_info.path; + if (strcmp(w_plugin_path, NPW_DEFAULT_PLUGIN_PATH) != 0) + return 6; + int w_plugin_path_length = strlen(w_plugin_path); + int plugin_ident_length = strlen(plugin_ident); + + int w_fd = open(w_plugin_path, O_RDONLY); + if (w_fd < 0) + return 7; + + ssize_t w_size = lseek(w_fd, 0, SEEK_END); + if (w_size < 0) + return 8; + lseek(w_fd, 0, SEEK_SET); + + char *plugin_data = malloc(w_size); + if (plugin_data == NULL) + return 9; + + if (read(w_fd, plugin_data, w_size) != w_size) + return 10; + close(w_fd); + + int i, ofs = -1; + for (i = NPW_PLUGIN_IDENT_SIZE; i < w_size - PATH_MAX; i++) { + if (memcmp(plugin_data + i, w_plugin_path, w_plugin_path_length) == 0 && + memcmp(plugin_data + i - NPW_PLUGIN_IDENT_SIZE, NPW_PLUGIN_IDENT, plugin_ident_length) == 0) { + ofs = i; + break; + } + } + if (ofs < 0) + return 11; + strcpy(plugin_data + ofs, plugin_path); + + struct stat st; + if (stat(plugin_path, &st) < 0) + return 12; + + if (plugin_info == NULL) + return 14; + if (plugin_info->target_arch[0] == '\0' || plugin_info->target_os[0] == '\0') { + if (!is_plugin_viewer_available(plugin_path, plugin_info)) + return 15; + } + + NPW_PluginInfo *pi = (NPW_PluginInfo *)(plugin_data + ofs - NPW_PLUGIN_IDENT_SIZE); + pi->mtime = st.st_mtime; + strcpy(pi->target_arch, plugin_info->target_arch); + strcpy(pi->target_os, plugin_info->target_os); + + int d_fd = open(d_plugin_path, O_CREAT | O_WRONLY, mode); + if (d_fd < 0) + return 4; + + if (write(d_fd, plugin_data, w_size) != w_size) + return 13; + close(d_fd); + + if (g_verbose) + printf(" into %s\n", d_plugin_path); + + free(plugin_data); + return 0; +} + +static int install_plugin(const char *plugin_path, NPW_PluginInfo *plugin_info) +{ + int ret; + + if (g_verbose) + printf("Install plugin %s\n", plugin_path); + + ret = do_install_plugin(plugin_path, get_system_mozilla_plugin_dir(), plugin_info); + if (ret == 0) + return 0; + + // don't install plugin in user home dir if already available system-wide + if (is_system_wide_wrapper_plugin(plugin_path)) { + if (g_verbose) + printf(" ... already installed system-wide, skipping\n"); + return 0; + } + + const char *user_plugin_dir = get_user_mozilla_plugin_dir(); + if (access(user_plugin_dir, R_OK | W_OK) < 0 && mkdir_p(user_plugin_dir) < 0) + return 1; + + ret = do_install_plugin(plugin_path, user_plugin_dir, plugin_info); + if (ret == 0) + return 0; + + return ret; +} + +static int auto_install_plugins(void) +{ + const char **plugin_dirs = get_mozilla_plugin_dirs(); + if (plugin_dirs) { + int i; + for (i = 0; plugin_dirs[i] != NULL; i++) { + const char *plugin_dir = plugin_dirs[i]; + if (g_verbose) + printf("Auto-install plugins from %s\n", plugin_dir); + process_plugin_dir(plugin_dir, is_compatible_plugin, (process_plugin_cb)install_plugin); + } + } + free(plugin_dirs); + return 0; +} + +static int remove_plugin(const char *plugin_path, ...) +{ + if (g_verbose) + printf("Remove plugin %s\n", plugin_path); + + if (unlink(plugin_path) < 0) + return 1; + + return 0; +} + +static int auto_remove_plugins(void) +{ + const char **plugin_dirs = get_mozilla_plugin_dirs(); + if (plugin_dirs) { + int i; + for (i = 0; plugin_dirs[i] != NULL; i++) { + const char *plugin_dir = plugin_dirs[i]; + if (g_verbose) + printf("Auto-remove plugins from %s\n", plugin_dir); + process_plugin_dir(plugin_dir, (is_plugin_cb)is_wrapper_plugin_0, (process_plugin_cb)remove_plugin); + } + } + free(plugin_dirs); + return 0; +} + +static int update_plugin(const char *plugin_path, ...) +{ + if (g_verbose) + printf("Update plugin %s\n", plugin_path); + + int ret = 0; + NPW_PluginInfo plugin_info; + is_wrapper_plugin(plugin_path, &plugin_info); + + struct stat st; + + if (access(plugin_info.path, F_OK) < 0) { + if (g_verbose) + printf(" NS4 plugin %s is no longer available, removing wrapper\n", plugin_info.path); + ret = remove_plugin(plugin_path); + } + else if (is_system_wide_wrapper_plugin(plugin_info.path) + && !strstart(plugin_path, get_system_mozilla_plugin_dir(), NULL)) { + if (g_verbose) + printf(" NS4 plugin %s is already installed system-wide, removing wrapper\n", plugin_info.path); + ret = remove_plugin(plugin_path); + } + else if (stat(plugin_info.path, &st) == 0 && st.st_mtime > plugin_info.mtime) { + if (g_verbose) + printf(" NS4 plugin %s was modified, reinstalling plugin\n", plugin_info.path); + ret = install_plugin(plugin_info.path, &plugin_info); + } + else if (strcmp(plugin_info.ident, NPW_PLUGIN_IDENT) != 0) { + if (g_verbose) + printf(" nspluginwrapper ident mismatch, reinstalling plugin\n"); + ret = install_plugin(plugin_info.path, &plugin_info); + } + + return ret; +} + +static int auto_update_plugins(void) +{ + const char **plugin_dirs = get_mozilla_plugin_dirs(); + if (plugin_dirs) { + int i; + for (i = 0; plugin_dirs[i] != NULL; i++) { + const char *plugin_dir = plugin_dirs[i]; + if (g_verbose) + printf("Auto-update plugins from %s\n", plugin_dir); + process_plugin_dir(plugin_dir, (is_plugin_cb)is_wrapper_plugin_0, (process_plugin_cb)update_plugin); + } + } + free(plugin_dirs); + return 0; +} + +static int list_plugin(const char *plugin_path, ...) +{ + NPW_PluginInfo plugin_info; + is_wrapper_plugin(plugin_path, &plugin_info); + + printf("%s\n", plugin_path); + printf(" Original plugin: %s\n", plugin_info.path); + char *str = strtok(plugin_info.ident, ":"); + if (str && strcmp(str, "NPW") == 0) { + str = strtok(NULL, ":"); + if (str) { + printf(" Wrapper version string: %s", str); + str = strtok(NULL, ":"); + if (str) + printf(" (%s)", str); + printf("\n"); + } + } + + return 0; +} + +static void print_usage(void) +{ + printf("%s, configuration tool. Version %s\n", NPW_CONFIG, NPW_VERSION); + printf("\n"); + printf(" usage: %s [flags] [command [plugin(s)]]\n", NPW_CONFIG); + printf("\n"); + printf(" -h --help print this message\n"); + printf(" -v --verbose flag: set verbose mode\n"); + printf(" -a --auto flag: set automatic mode for plugins discovery\n"); + printf(" -l --list list plugins currently installed\n"); + printf(" -u --update update plugin(s) currently installed\n"); + printf(" -i --install [FILE(S)] install plugin(s)\n"); + printf(" -r --remove [FILE(S)] remove plugin(s)\n"); + printf("\n"); +} + +static int process_help(int argc, char *argv[]) +{ + print_usage(); + return 0; +} + +static int process_verbose(int argc, char *argv[]) +{ + g_verbose = true; + return 0; +} + +static int process_auto(int argc, char *argv[]) +{ + g_auto = true; + return 0; +} + +static int process_list(int argvc, char *argv[]) +{ + const char **plugin_dirs = get_mozilla_plugin_dirs(); + if (plugin_dirs) { + int i; + for (i = 0; plugin_dirs[i] != NULL; i++) { + const char *plugin_dir = plugin_dirs[i]; + if (g_verbose) + printf("List plugins in %s\n", plugin_dir); + process_plugin_dir(plugin_dir, (is_plugin_cb)is_wrapper_plugin_0, (process_plugin_cb)list_plugin); + } + } + free(plugin_dirs); + return 0; +} + +static int process_update(int argc, char *argv[]) +{ + int i; + + if (g_auto) + return auto_update_plugins(); + + if (argc < 1) + error("expected plugin(s) file name to update"); + + for (i = 0; i < argc; i++) { + const char *plugin_path = argv[i]; + if (!is_wrapper_plugin_0(plugin_path)) + error("%s is not a valid nspluginwrapper plugin", plugin_path); + int ret = update_plugin(plugin_path); + if (ret != 0) + return ret; + } + + return 0; +} + +static int process_install(int argc, char *argv[]) +{ + int i; + + if (g_auto) + return auto_install_plugins(); + + if (argc < 1) + error("expected plugin(s) file name to install"); + + for (i = 0; i < argc; i++) { + NPW_PluginInfo plugin_info; + const char *plugin_path = argv[i]; + if (!is_compatible_plugin(plugin_path, &plugin_info)) + error("%s is not a valid NPAPI plugin", plugin_path); + int ret = install_plugin(plugin_path, &plugin_info); + if (ret != 0) + return ret; + } + + return 0; +} + +static int process_remove(int argc, char *argv[]) +{ + int i; + + if (g_auto) + return auto_remove_plugins(); + + if (argc < 1) + error("expected plugin(s) file name to remove"); + + for (i = 0; i < argc; i++) { + const char *plugin_path = argv[i]; + if (!is_wrapper_plugin_0(plugin_path)) + error("%s is not a valid nspluginwrapper plugin", plugin_path); + int ret = remove_plugin(plugin_path); + if (ret != 0) + return ret; + } + + return 0; +} + +int main(int argc, char *argv[]) +{ + char **args; + int i, j, n_args; + + n_args = argc - 1; + args = argv + 1; + + if (n_args < 1) { + print_usage(); + return 1; + } + + if (args[0][0] != '-') { + print_usage(); + return 1; + } + + static const struct option { + char short_option; + const char *long_option; + int (*process_callback)(int argc, char *argv[]); + bool terminal; + } + options[] = { + { 'h', "help", process_help, 1 }, + { 'v', "verbose", process_verbose, 0 }, + { 'a', "auto", process_auto, 0 }, + { 'l', "list", process_list, 1 }, + { 'u', "update", process_update, 1 }, + { 'i', "install", process_install, 1 }, + { 'r', "remove", process_remove, 1 }, + { 0, NULL, NULL, 1 } + }; + + for (i = 0; i < n_args; i++) { + const char *arg = args[i]; + const struct option *opt = NULL; + for (j = 0; opt == NULL && options[j].process_callback != NULL; j++) { + if ((arg[0] == '-' && arg[1] == options[j].short_option && arg[2] == '\0') || + (arg[0] == '-' && arg[1] == '-' && strcmp(&arg[2], options[j].long_option) == 0)) + opt = &options[j]; + } + if (opt == NULL) { + fprintf(stderr, "invalid option %s\n", arg); + print_usage(); + return 1; + } + int ret = opt->process_callback(n_args - i - 1, args + i + 1); + if (opt->terminal) + return ret; + } + + return 0; +} diff --git a/src/npw-rpc.c b/src/npw-rpc.c new file mode 100644 index 0000000..aa7f57d --- /dev/null +++ b/src/npw-rpc.c @@ -0,0 +1,919 @@ +/* + * npw-rpc.c - Remote Procedure Calls (NPAPI specialisation) + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "sysdeps.h" +#include + +#include "rpc.h" +#include "npw-rpc.h" +#include "utils.h" + +#define XP_UNIX 1 +#define MOZ_X11 1 +#include +#include +#include "npruntime-impl.h" + +#define DEBUG 1 +#include "debug.h" + + +/* + * RPC types of NPP/NPN variables + */ + +int rpc_type_of_NPNVariable(int variable) +{ + int type; + switch (variable) { + case NPNVjavascriptEnabledBool: + case NPNVasdEnabledBool: + case NPNVisOfflineBool: + case NPNVSupportsXEmbedBool: + type = RPC_TYPE_BOOLEAN; + break; + case NPNVWindowNPObject: + case NPNVPluginElementNPObject: + type = RPC_TYPE_NP_OBJECT; + break; + default: + type = RPC_ERROR_GENERIC; + break; + } + return type; +} + +int rpc_type_of_NPPVariable(int variable) +{ + int type; + switch (variable) { + case NPPVpluginNameString: + case NPPVpluginDescriptionString: + type = RPC_TYPE_STRING; + break; + case NPPVpluginWindowBool: + case NPPVpluginTransparentBool: + case NPPVpluginWindowSize: + case NPPVpluginTimerInterval: + type = RPC_TYPE_INT32; + break; + case NPPVpluginNeedsXEmbed: + type = RPC_TYPE_BOOLEAN; + break; + case NPPVpluginScriptableNPObject: + type = RPC_TYPE_NP_OBJECT; + break; + default: + type = RPC_ERROR_GENERIC; + break; + } + return type; +} + + +/* + * Process NPP objects + */ + +typedef struct { + NPP instance; + uint32_t instance_id; +} PluginInstance; + +#ifdef BUILD_WRAPPER +#define PLUGIN_INSTANCE(instance) ((instance)->pdata) +#endif +#ifdef BUILD_VIEWER +#define PLUGIN_INSTANCE(instance) ((instance)->ndata) +#endif + +static int do_send_NPP(rpc_message_t *message, void *p_value) +{ + uint32_t instance_id = 0; + NPP instance = (NPP)p_value; + if (instance) { + PluginInstance *plugin = PLUGIN_INSTANCE(instance); + if (plugin) + instance_id = plugin->instance_id; + } + return rpc_message_send_uint32(message, instance_id); +} + +static int do_recv_NPP(rpc_message_t *message, void *p_value) +{ + int error; + uint32_t instance_id; + + if ((error = rpc_message_recv_uint32(message, &instance_id)) < 0) + return error; + + PluginInstance *plugin = id_lookup(instance_id); + if (instance_id && plugin == NULL) + npw_printf("ERROR: passing an unknown instance\n"); + if (plugin && plugin->instance == NULL) + npw_printf("ERROR: passing a NULL instance through plugin instance id\n"); + *((NPP *)p_value) = plugin ? plugin->instance : NULL; + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NPStream objects + */ + +typedef struct { + NPStream *stream; + uint32_t stream_id; +} StreamInstance; + +#ifdef BUILD_WRAPPER +#define STREAM_INSTANCE(instance) ((instance)->pdata) +#endif +#ifdef BUILD_VIEWER +#define STREAM_INSTANCE(instance) ((instance)->ndata) +#endif + +static int do_send_NPStream(rpc_message_t *message, void *p_value) +{ + uint32_t stream_id = 0; + NPStream *stream = (NPStream *)p_value; + if (stream) { + StreamInstance *sip = STREAM_INSTANCE(stream); + if (sip) + stream_id = sip->stream_id; + } + return rpc_message_send_uint32(message, stream_id); +} + +static int do_recv_NPStream(rpc_message_t *message, void *p_value) +{ + int error; + uint32_t stream_id; + + if ((error = rpc_message_recv_uint32(message, &stream_id)) < 0) + return error; + + StreamInstance *stream = id_lookup(stream_id); + *((NPStream **)p_value) = stream ? stream->stream : NULL; + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NPByteRange objects + */ + +static int do_send_NPByteRange(rpc_message_t *message, void *p_value) +{ + NPByteRange *range = (NPByteRange *)p_value; + while (range) { + int error; + if ((error = rpc_message_send_uint32(message, 1)) < 0) + return error; + if ((error = rpc_message_send_int32(message, range->offset)) < 0) + return error; + if ((error = rpc_message_send_uint32(message, range->length)) < 0) + return error; + range = range->next; + } + return rpc_message_send_uint32(message, 0); +} + +static int do_recv_NPByteRange(rpc_message_t *message, void *p_value) +{ + NPByteRange **rangeListPtr = (NPByteRange **)p_value; + if (rangeListPtr == NULL) + return RPC_ERROR_MESSAGE_ARGUMENT_INVALID; + *rangeListPtr = NULL; + + for (;;) { + int error; + uint32_t cont; + + if ((error = rpc_message_recv_uint32(message, &cont)) < 0) + return error; + if (!cont) + break; + NPByteRange *range = malloc(sizeof(*range)); + if (range == NULL) + return RPC_ERROR_NO_MEMORY; + range->next = NULL; + if ((error = rpc_message_recv_int32(message, &range->offset)) < 0) + return error; + if ((error = rpc_message_recv_uint32(message, &range->length)) < 0) + return error; + *rangeListPtr = range; + rangeListPtr = &range->next; + } + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NPSavedData objects + */ + +static int do_send_NPSavedData(rpc_message_t *message, void *p_value) +{ + NPSavedData *save_area = (NPSavedData *)p_value; + int error; + + if (save_area == NULL) { + if ((error = rpc_message_send_int32(message, 0)) < 0) + return error; + } + else { + if ((error = rpc_message_send_int32(message, save_area->len)) < 0) + return error; + if ((error = rpc_message_send_bytes(message, save_area->buf, save_area->len)) < 0) + return error; + } + + return RPC_ERROR_NO_ERROR; +} + +static int do_recv_NPSavedData(rpc_message_t *message, void *p_value) +{ + NPSavedData *save_area; + int error; + int32_t len; + unsigned char *buf; + + if ((error = rpc_message_recv_int32(message, &len)) < 0) + return error; + if (len == 0) + save_area = NULL; + else { + if ((save_area = malloc(sizeof(*save_area))) == NULL) + return RPC_ERROR_NO_MEMORY; + if ((buf = malloc(len)) == NULL) + return RPC_ERROR_NO_MEMORY; + if ((error = rpc_message_recv_bytes(message, buf, len)) < 0) + return error; + save_area->len = len; + save_area->buf = buf; + } + + if (p_value) + *((NPSavedData **)p_value) = save_area; + else if (save_area) { + free(save_area->buf); + free(save_area); + } + + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NotifyData objects + */ + +// Rationale: NotifyData objects are allocated on the plugin side +// only. IDs are passed through to the browser, and they have no +// meaning on that side as they are only used to get passed back to +// the plugin side +// +// XXX 64-bit viewers in 32-bit wrappers are not supported +static int do_send_NotifyData(rpc_message_t *message, void *p_value) +{ + void *notifyData = (void *)p_value; + return rpc_message_send_uint64(message, (uintptr_t)notifyData); +} + +static int do_recv_NotifyData(rpc_message_t *message, void *p_value) +{ + int error; + uint64_t id; + + if ((error = rpc_message_recv_uint64(message, &id)) < 0) + return error; + + if (sizeof(void *) == 4 && ((uint32_t)(id >> 32)) != 0) { + npw_printf("ERROR: 64-bit viewers in 32-bit wrappers are not supported\n"); + abort(); + } + + *((void **)p_value) = (void *)(uintptr_t)id; + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NPRect objects + */ + +static int do_send_NPRect(rpc_message_t *message, void *p_value) +{ + NPRect *rect = (NPRect *)p_value; + int error; + + if ((error = rpc_message_send_uint32(message, rect->top)) < 0) + return error; + if ((error = rpc_message_send_uint32(message, rect->left)) < 0) + return error; + if ((error = rpc_message_send_uint32(message, rect->bottom)) < 0) + return error; + if ((error = rpc_message_send_uint32(message, rect->right)) < 0) + return error; + + return RPC_ERROR_NO_ERROR; +} + +static int do_recv_NPRect(rpc_message_t *message, void *p_value) +{ + NPRect *rect = (NPRect *)p_value; + uint32_t top, left, bottom, right; + int error; + + if ((error = rpc_message_recv_uint32(message, &top)) < 0) + return error; + if ((error = rpc_message_recv_uint32(message, &left)) < 0) + return error; + if ((error = rpc_message_recv_uint32(message, &bottom)) < 0) + return error; + if ((error = rpc_message_recv_uint32(message, &right)) < 0) + return error; + + rect->top = top; + rect->left = left; + rect->bottom = bottom; + rect->right = right; + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NPWindow objects + */ + +static int do_send_NPWindow(rpc_message_t *message, void *p_value) +{ + NPWindow *window = (NPWindow *)p_value; + int error; + + if (window == NULL) { + if ((error = rpc_message_send_uint32(message, 0)) < 0) + return error; + } + else { + if ((error = rpc_message_send_uint32(message, (Window)window->window)) < 0) + return error; + if ((error = rpc_message_send_int32(message, window->x)) < 0) + return error; + if ((error = rpc_message_send_int32(message, window->y)) < 0) + return error; + if ((error = rpc_message_send_uint32(message, window->width)) < 0) + return error; + if ((error = rpc_message_send_uint32(message, window->height)) < 0) + return error; + if ((error = do_send_NPRect(message, &window->clipRect)) < 0) + return error; + if ((error = rpc_message_send_int32(message, window->type)) < 0) + return error; + } + + return RPC_ERROR_NO_ERROR; +} + +static int do_recv_NPWindow(rpc_message_t *message, void *p_value) +{ + NPWindow **window_p = (NPWindow **)p_value; + NPWindow *window; + uint32_t window_id; + int32_t window_type; + int error; + + if ((error = rpc_message_recv_uint32(message, &window_id)) < 0) + return error; + *window_p = NULL; + if (window_id) { + if ((window = *window_p = malloc(sizeof(NPWindow))) == NULL) + return RPC_ERROR_NO_MEMORY; + if ((error = rpc_message_recv_int32(message, &window->x)) < 0) + return error; + if ((error = rpc_message_recv_int32(message, &window->y)) < 0) + return error; + if ((error = rpc_message_recv_uint32(message, &window->width)) < 0) + return error; + if ((error = rpc_message_recv_uint32(message, &window->height)) < 0) + return error; + if ((error = do_recv_NPRect(message, &window->clipRect)) < 0) + return error; + if ((error = rpc_message_recv_int32(message, &window_type)) < 0) + return error; + window->type = window_type; + window->ws_info = NULL; // to be filled in by the plugin + window->window = (void *)(Window)window_id; + } + + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NPFullPrint objects + */ + +static int do_send_NPFullPrint(rpc_message_t *message, void *p_value) +{ + NPFullPrint *fullPrint = (NPFullPrint *)p_value; + int error; + + if ((error = rpc_message_send_uint32(message, fullPrint->pluginPrinted)) < 0) + return error; + if ((error = rpc_message_send_uint32(message, fullPrint->printOne)) < 0) + return error; + + return RPC_ERROR_NO_ERROR; +} + +static int do_recv_NPFullPrint(rpc_message_t *message, void *p_value) +{ + NPFullPrint *fullPrint = (NPFullPrint *)p_value; + uint32_t pluginPrinted, printOne; + int error; + + if ((error = rpc_message_recv_uint32(message, &pluginPrinted)) < 0) + return error; + if ((error = rpc_message_recv_uint32(message, &printOne)) < 0) + return error; + + fullPrint->pluginPrinted = pluginPrinted; + fullPrint->printOne = printOne; + fullPrint->platformPrint = NULL; // to be filled in by the plugin + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NPEmbedPrint objects + */ + +static int do_send_NPEmbedPrint(rpc_message_t *message, void *p_value) +{ + NPEmbedPrint *embedPrint = (NPEmbedPrint *)p_value; + int error; + + if ((error = do_send_NPWindow(message, &embedPrint->window)) < 0) + return error; + + return RPC_ERROR_NO_ERROR; +} + +static int do_recv_NPEmbedPrint(rpc_message_t *message, void *p_value) +{ + NPEmbedPrint *embedPrint = (NPEmbedPrint *)p_value; + int error; + + if ((error = do_recv_NPWindow(message, &embedPrint->window)) < 0) + return error; + + embedPrint->platformPrint = NULL; // to be filled in by the plugin + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NPPrint objects + */ + +static int do_send_NPPrint(rpc_message_t *message, void *p_value) +{ + NPPrint *printInfo = (NPPrint *)p_value; + int error; + + if ((error = rpc_message_send_uint32(message, printInfo->mode)) < 0) + return error; + switch (printInfo->mode) { + case NP_FULL: + if ((error = do_send_NPFullPrint(message, &printInfo->print.fullPrint)) < 0) + return error; + break; + case NP_EMBED: + if ((error = do_send_NPEmbedPrint(message, &printInfo->print.embedPrint)) < 0) + return error; + break; + default: + return RPC_ERROR_GENERIC; + } + + return RPC_ERROR_NO_ERROR; +} + +static int do_recv_NPPrint(rpc_message_t *message, void *p_value) +{ + NPPrint *printInfo = (NPPrint *)p_value; + uint32_t print_mode; + int error; + + if ((error = rpc_message_recv_uint32(message, &print_mode)) < 0) + return error; + switch (print_mode) { + case NP_FULL: + if ((error = do_recv_NPFullPrint(message, &printInfo->print.fullPrint)) < 0) + return error; + break; + case NP_EMBED: + if ((error = do_recv_NPEmbedPrint(message, &printInfo->print.embedPrint)) < 0) + return error; + break; + default: + return RPC_ERROR_GENERIC; + } + + printInfo->mode = print_mode; + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NPPrintData objects + */ + +static int do_send_NPPrintData(rpc_message_t *message, void *p_value) +{ + NPPrintData *printData = (NPPrintData *)p_value; + int error; + + if ((error = rpc_message_send_uint32(message, printData->size)) < 0) + return error; + if ((error = rpc_message_send_bytes(message, printData->data, printData->size)) < 0) + return error; + + return RPC_ERROR_NO_ERROR; +} + +static int do_recv_NPPrintData(rpc_message_t *message, void *p_value) +{ + NPPrintData *printData = (NPPrintData *)p_value; + int error; + + if ((error = rpc_message_recv_uint32(message, &printData->size)) < 0) + return error; + if ((error = rpc_message_recv_bytes(message, printData->data, printData->size)) < 0) + return error; + + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NPObject objects + */ + +// XXX propagate reference counters? +static int do_send_NPObject(rpc_message_t *message, void *p_value) +{ + uint32_t npobj_id = 0; + NPObject *npobj = (NPObject *)p_value; + if (npobj) { + NPObjectInfo *npobj_info = npobject_info_lookup(npobj); + if (npobj_info) + npobj_id = npobj_info->npobj_id; +#ifdef BUILD_WRAPPER + else { + // create a new mapping (browser-side) + if ((npobj_info = npobject_info_new(npobj)) == NULL) + return RPC_ERROR_NO_MEMORY; + npobj_id = npobj_info->npobj_id; + npobject_associate(npobj, npobj_info); + } +#endif + assert(npobj_id != 0); + } + return rpc_message_send_uint32(message, npobj_id); +} + +static int do_recv_NPObject(rpc_message_t *message, void *p_value) +{ + int error; + uint32_t npobj_id; + + if ((error = rpc_message_recv_uint32(message, &npobj_id)) < 0) + return error; + + NPObject *npobj = NULL; + if (npobj_id) { + npobj = npobject_lookup(npobj_id); +#ifdef BUILD_VIEWER + // create a new mapping (plugin-side) + if (npobj == NULL) { + if ((npobj = npobject_new(npobj_id, NULL, NULL)) == NULL) + return RPC_ERROR_NO_MEMORY; + } +#endif + assert(npobj != NULL); + } + *((NPObject **)p_value) = npobj; + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NPIdentifier objects + */ + +// Rationale: NPIdentifiers are allocated on the browser side +// only. IDs are passed through to the viewer, and they have no +// meaning on that side as they are only used to get passed back to +// the browser side +static int do_send_NPIdentifier(rpc_message_t *message, void *p_value) +{ + NPIdentifier ident = (NPIdentifier)p_value; + int id = 0; + if (ident) { +#ifdef BUILD_WRAPPER + id = id_lookup_value(ident); + if (id < 0) + id = id_create(ident); +#endif +#ifdef BUILD_VIEWER + id = (uintptr_t)ident; +#endif + assert(id != 0); + } + return rpc_message_send_uint32(message, id); +} + +static int do_recv_NPIdentifier(rpc_message_t *message, void *p_value) +{ + int error; + uint32_t id; + + if ((error = rpc_message_recv_uint32(message, &id)) < 0) + return error; + + NPIdentifier ident = NULL; + if (id) { +#ifdef BUILD_WRAPPER + ident = id_lookup(id); +#endif +#ifdef BUILD_VIEWER + ident = (void *)(uintptr_t)id; +#endif + assert(ident != NULL); + } + *((NPIdentifier *)p_value) = ident; + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NPString objects + */ + +static int do_send_NPString(rpc_message_t *message, void *p_value) +{ + NPString *string = (NPString *)p_value; + if (string == NULL) + return RPC_ERROR_MESSAGE_ARGUMENT_INVALID; + + int error = rpc_message_send_uint32(message, string->utf8length); + if (error < 0) + return error; + if (string->utf8length && string->utf8characters) + return rpc_message_send_bytes(message, (unsigned char *)string->utf8characters, string->utf8length); + return RPC_ERROR_NO_ERROR; +} + +static int do_recv_NPString(rpc_message_t *message, void *p_value) +{ + NPString *string = (NPString *)p_value; + if (string == NULL) + return RPC_ERROR_MESSAGE_ARGUMENT_INVALID; + string->utf8length = 0; + string->utf8characters = NULL; + + int error = rpc_message_recv_uint32(message, &string->utf8length); + if (error < 0) + return error; + + if (string->utf8length > 0) { + // calloc() will make the string nul-terminated, even if utf8characters is a const NPUTF8 * + if ((string->utf8characters = calloc(1, string->utf8length + 1)) == NULL) + return RPC_ERROR_NO_MEMORY; + if ((error = rpc_message_recv_bytes(message, (unsigned char *)string->utf8characters, string->utf8length)) < 0) + return error; + } + + return RPC_ERROR_NO_ERROR; +} + + +/* + * Process NPVariant objects + */ + +static int do_send_NPVariant(rpc_message_t *message, void *p_value) +{ + NPVariant *variant = (NPVariant *)p_value; + if (variant == NULL) + return RPC_ERROR_MESSAGE_ARGUMENT_INVALID; + + int error = rpc_message_send_uint32(message, variant->type); + if (error < 0) + return error; + + switch (variant->type) { + case NPVariantType_Void: + case NPVariantType_Null: + // nothing to do (initialized in receiver) + break; + case NPVariantType_Bool: + if ((error = rpc_message_send_uint32(message, variant->value.boolValue)) < 0) + return error; + break; + case NPVariantType_Int32: + if ((error = rpc_message_send_uint32(message, variant->value.intValue)) < 0) + return error; + break; + case NPVariantType_Double: + if ((error = rpc_message_send_double(message, variant->value.doubleValue)) < 0) + return error; + break; + case NPVariantType_String: + if ((error = do_send_NPString(message, &variant->value.stringValue)) < 0) + return error; + break; + case NPVariantType_Object: + if ((error = do_send_NPObject(message, variant->value.objectValue)) < 0) + return error; + break; + } + + return RPC_ERROR_NO_ERROR; +} + +static int do_recv_NPVariant(rpc_message_t *message, void *p_value) +{ + NPVariant *variant = (NPVariant *)p_value; + if (variant) + VOID_TO_NPVARIANT(*variant); + + uint32_t type; + int error = rpc_message_recv_uint32(message, &type); + if (error < 0) + return error; + + NPVariant result; + VOID_TO_NPVARIANT(result); + switch (type) { + case NPVariantType_Void: + VOID_TO_NPVARIANT(result); + break; + case NPVariantType_Null: + NULL_TO_NPVARIANT(result); + break; + case NPVariantType_Bool: { + uint32_t value; + if ((error = rpc_message_recv_uint32(message, &value)) < 0) + return error; + result.value.boolValue = value; + break; + } + case NPVariantType_Int32: + if ((error = rpc_message_recv_uint32(message, &result.value.intValue)) < 0) + return error; + break; + case NPVariantType_Double: + if ((error = rpc_message_recv_double(message, &result.value.doubleValue)) < 0) + return error; + break; + case NPVariantType_String: + if ((error = do_recv_NPString(message, &result.value.stringValue)) < 0) + return error; + break; + case NPVariantType_Object: + if ((error = do_recv_NPObject(message, &result.value.objectValue)) < 0) + return error; + break; + } + + if (variant) { + *variant = result; + variant->type = type; + } + + return RPC_ERROR_NO_ERROR; +} + + +/* + * Initialize marshalers for NPAPI types + */ + +static const rpc_message_descriptor_t message_descs[] = { + { + RPC_TYPE_NPP, + sizeof(NPP), + do_send_NPP, + do_recv_NPP + }, + { + RPC_TYPE_NP_STREAM, + sizeof(NPStream *), + do_send_NPStream, + do_recv_NPStream + }, + { + RPC_TYPE_NP_BYTE_RANGE, + sizeof(NPByteRange *), + do_send_NPByteRange, + do_recv_NPByteRange + }, + { + RPC_TYPE_NP_SAVED_DATA, + sizeof(NPSavedData *), + do_send_NPSavedData, + do_recv_NPSavedData + }, + { + RPC_TYPE_NP_NOTIFY_DATA, + sizeof(void *), + do_send_NotifyData, + do_recv_NotifyData + }, + { + RPC_TYPE_NP_RECT, + sizeof(NPRect), + do_send_NPRect, + do_recv_NPRect + }, + { + RPC_TYPE_NP_WINDOW, + sizeof(NPWindow *), + do_send_NPWindow, + do_recv_NPWindow + }, + { + RPC_TYPE_NP_PRINT, + sizeof(NPPrint), + do_send_NPPrint, + do_recv_NPPrint + }, + { + RPC_TYPE_NP_FULL_PRINT, + sizeof(NPFullPrint), + do_send_NPFullPrint, + do_recv_NPFullPrint + }, + { + RPC_TYPE_NP_EMBED_PRINT, + sizeof(NPEmbedPrint), + do_send_NPEmbedPrint, + do_recv_NPEmbedPrint + }, + { + RPC_TYPE_NP_PRINT_DATA, + sizeof(NPPrintData), + do_send_NPPrintData, + do_recv_NPPrintData + }, + { + RPC_TYPE_NP_OBJECT, + sizeof(NPObject *), + do_send_NPObject, + do_recv_NPObject + }, + { + RPC_TYPE_NP_IDENTIFIER, + sizeof(NPIdentifier), + do_send_NPIdentifier, + do_recv_NPIdentifier + }, + { + RPC_TYPE_NP_STRING, + sizeof(NPString), + do_send_NPString, + do_recv_NPString + }, + { + RPC_TYPE_NP_VARIANT, + sizeof(NPVariant), + do_send_NPVariant, + do_recv_NPVariant + } +}; + +int rpc_add_np_marshalers(void) +{ + return rpc_message_add_callbacks(message_descs, sizeof(message_descs) / sizeof(message_descs[0])); +} diff --git a/src/npw-rpc.h b/src/npw-rpc.h new file mode 100644 index 0000000..a21339f --- /dev/null +++ b/src/npw-rpc.h @@ -0,0 +1,116 @@ +/* + * npw-rpc.h - Remote Procedure Calls (NPAPI specialisation) + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef NPW_RPC_H +#define NPW_RPC_H + +// NPAPI methods +enum { + RPC_METHOD_NP_GET_VALUE = 1, + RPC_METHOD_NP_GET_MIME_DESCRIPTION, + RPC_METHOD_NP_INITIALIZE, + RPC_METHOD_NP_SHUTDOWN, + RPC_METHOD_NP_EXIT, + + RPC_METHOD_NPN_USER_AGENT, + RPC_METHOD_NPN_GET_VALUE, + RPC_METHOD_NPN_GET_URL, + RPC_METHOD_NPN_GET_URL_NOTIFY, + RPC_METHOD_NPN_POST_URL, + RPC_METHOD_NPN_POST_URL_NOTIFY, + RPC_METHOD_NPN_STATUS, + RPC_METHOD_NPN_PRINT_DATA, + RPC_METHOD_NPN_REQUEST_READ, + + RPC_METHOD_NPP_NEW, + RPC_METHOD_NPP_DESTROY, + RPC_METHOD_NPP_SET_WINDOW, + RPC_METHOD_NPP_GET_VALUE, + RPC_METHOD_NPP_URL_NOTIFY, + RPC_METHOD_NPP_NEW_STREAM, + RPC_METHOD_NPP_DESTROY_STREAM, + RPC_METHOD_NPP_WRITE_READY, + RPC_METHOD_NPP_WRITE, + RPC_METHOD_NPP_STREAM_AS_FILE, + RPC_METHOD_NPP_PRINT, + + RPC_METHOD_NPN_CREATE_OBJECT, + RPC_METHOD_NPN_RETAIN_OBJECT, + RPC_METHOD_NPN_RELEASE_OBJECT, + RPC_METHOD_NPN_INVOKE, + RPC_METHOD_NPN_INVOKE_DEFAULT, + RPC_METHOD_NPN_EVALUATE, + RPC_METHOD_NPN_GET_PROPERTY, + RPC_METHOD_NPN_SET_PROPERTY, + RPC_METHOD_NPN_REMOVE_PROPERTY, + RPC_METHOD_NPN_HAS_PROPERTY, + RPC_METHOD_NPN_HAS_METHOD, + RPC_METHOD_NPN_SET_EXCEPTION, + + RPC_METHOD_NPN_GET_STRING_IDENTIFIER, + RPC_METHOD_NPN_GET_STRING_IDENTIFIERS, + RPC_METHOD_NPN_GET_INT_IDENTIFIER, + RPC_METHOD_NPN_IDENTIFIER_IS_STRING, + RPC_METHOD_NPN_UTF8_FROM_IDENTIFIER, + RPC_METHOD_NPN_INT_FROM_IDENTIFIER, + + RPC_METHOD_NPCLASS_INVALIDATE, + RPC_METHOD_NPCLASS_HAS_METHOD, + RPC_METHOD_NPCLASS_INVOKE, + RPC_METHOD_NPCLASS_INVOKE_DEFAULT, + RPC_METHOD_NPCLASS_HAS_PROPERTY, + RPC_METHOD_NPCLASS_GET_PROPERTY, + RPC_METHOD_NPCLASS_SET_PROPERTY, + RPC_METHOD_NPCLASS_REMOVE_PROPERTY, +}; + +// NPAPI data types +enum { + RPC_TYPE_NPP = 1, + RPC_TYPE_NP_STREAM, + RPC_TYPE_NP_BYTE_RANGE, + RPC_TYPE_NP_SAVED_DATA, + RPC_TYPE_NP_NOTIFY_DATA, + RPC_TYPE_NP_RECT, + RPC_TYPE_NP_WINDOW, + RPC_TYPE_NP_PRINT, + RPC_TYPE_NP_FULL_PRINT, + RPC_TYPE_NP_EMBED_PRINT, + RPC_TYPE_NP_PRINT_DATA, + RPC_TYPE_NP_OBJECT, + RPC_TYPE_NP_IDENTIFIER, + RPC_TYPE_NP_STRING, + RPC_TYPE_NP_VARIANT, +}; + +// NPPrintData is used to get the plugin printed tmpfile +typedef struct _NPPrintData { + uint32_t size; + uint8_t data[4096]; +} NPPrintData; + +// Initialize marshalers for NS4 plugin types +extern int rpc_add_np_marshalers(void) attribute_hidden; + +// RPC types +extern int rpc_type_of_NPNVariable(int variable) attribute_hidden; +extern int rpc_type_of_NPPVariable(int variable) attribute_hidden; + +#endif /* NPW_RPC_H */ diff --git a/src/npw-viewer.c b/src/npw-viewer.c new file mode 100644 index 0000000..5d553a2 --- /dev/null +++ b/src/npw-viewer.c @@ -0,0 +1,2851 @@ +/* + * npw-viewer.c - Target plugin loader and viewer + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#define _GNU_SOURCE 1 /* RTLD_NEXT */ +#include "sysdeps.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "rpc.h" +#include "npw-rpc.h" +#include "utils.h" + +#define XP_UNIX 1 +#define MOZ_X11 1 +#include +#include +#include "npruntime-impl.h" + +#define DEBUG 1 +#include "debug.h" + + +// [UNIMPLEMENTED] Define to use XPCOM emulation +#define USE_XPCOM 0 + +// Define to use XEMBED +#define USE_XEMBED 1 + +// XXX define which widget to use +#define USE_GTK_TOOLKIT 1 +#define USE_X11_TOOLKIT 0 + +// XXX unimplemented functions +#define UNIMPLEMENTED() npw_printf("WARNING: Unimplemented function %s at line %d\n", __func__, __LINE__) + + +// RPC global connections +rpc_connection_t *g_rpc_connection attribute_hidden = NULL; + +// Instance state information about the plugin +typedef struct _PluginInstance { + NPP instance; + uint32_t instance_id; + bool use_xembed; + NPWindow window; + uint32_t width, height; + Window old_window; + Window focus_window; + Window old_focus_window; +#if USE_GTK_TOOLKIT + GtkWidget *top_window; +#else + Window top_window; +#endif + Widget top_widget; + Widget form; +} PluginInstance; + +// Browser side data for an NPStream instance +typedef struct _StreamInstance { + NPStream *stream; + uint32_t stream_id; +} StreamInstance; + + +/* ====================================================================== */ +/* === X Toolkit glue === */ +/* ====================================================================== */ + +static Display *x_display; +static XtAppContext x_app_context; + +typedef struct _XtTMRec { + XtTranslations translations; /* private to Translation Manager */ + XtBoundActions proc_table; /* procedure bindings for actions */ + struct _XtStateRec *current_state; /* Translation Manager state ptr */ + unsigned long lastEventTime; +} XtTMRec, *XtTM; + +typedef struct _CorePart { + Widget self; /* pointer to widget itself */ + WidgetClass widget_class; /* pointer to Widget's ClassRec */ + Widget parent; /* parent widget */ + XrmName xrm_name; /* widget resource name quarkified */ + Boolean being_destroyed; /* marked for destroy */ + XtCallbackList destroy_callbacks; /* who to call when widget destroyed */ + XtPointer constraints; /* constraint record */ + Position x, y; /* window position */ + Dimension width, height; /* window dimensions */ + Dimension border_width; /* window border width */ + Boolean managed; /* is widget geometry managed? */ + Boolean sensitive; /* is widget sensitive to user events*/ + Boolean ancestor_sensitive; /* are all ancestors sensitive? */ + XtEventTable event_table; /* private to event dispatcher */ + XtTMRec tm; /* translation management */ + XtTranslations accelerators; /* accelerator translations */ + Pixel border_pixel; /* window border pixel */ + Pixmap border_pixmap; /* window border pixmap or NULL */ + WidgetList popup_list; /* list of popups */ + Cardinal num_popups; /* how many popups */ + String name; /* widget resource name */ + Screen *screen; /* window's screen */ + Colormap colormap; /* colormap */ + Window window; /* window ID */ + Cardinal depth; /* number of planes in window */ + Pixel background_pixel; /* window background pixel */ + Pixmap background_pixmap; /* window background pixmap or NULL */ + Boolean visible; /* is window mapped and not occluded?*/ + Boolean mapped_when_managed;/* map window if it's managed? */ +} CorePart; + +typedef struct _WidgetRec { + CorePart core; +} WidgetRec, CoreRec; + +extern void XtResizeWidget( + Widget /* widget */, + _XtDimension /* width */, + _XtDimension /* height */, + _XtDimension /* border_width */ +); + +// Update focus to plugin window +// XXX I am not convinced this is the really corrent... +static void xt_client_focus_listener(Widget w, XtPointer user_data, XEvent *event, Boolean *cont) +{ + PluginInstance *plugin = (PluginInstance *)user_data; + + switch (event->type) { + case ButtonRelease: + if (plugin->focus_window != XtWindow(plugin->form)) { + XSetInputFocus(x_display, XtWindow(plugin->form), RevertToParent, event->xbutton.time); + plugin->focus_window = XtWindow(plugin->form); + XSync(x_display, False); + } + break; + case LeaveNotify: + if (plugin->old_focus_window && plugin->focus_window != plugin->old_focus_window) { + XSetInputFocus(x_display, plugin->old_focus_window, RevertToParent, event->xcrossing.time); + plugin->focus_window = plugin->old_focus_window; + XSync(x_display, False); + } + break; + } +} + + +/* ====================================================================== */ +/* === XPCOM glue === */ +/* ====================================================================== */ + +#if defined(__GNUC__) && (__GNUC__ > 2) +#define NS_LIKELY(x) (__builtin_expect((x), 1)) +#define NS_UNLIKELY(x) (__builtin_expect((x), 0)) +#else +#define NS_LIKELY(x) (x) +#define NS_UNLIKELY(x) (x) +#endif + +#define NS_FAILED(_nsresult) (NS_UNLIKELY((_nsresult) & 0x80000000)) +#define NS_SUCCEEDED(_nsresult) (NS_LIKELY(!((_nsresult) & 0x80000000))) + +typedef uint32 nsresult; +typedef struct nsIServiceManager nsIServiceManager; +extern nsresult NS_GetServiceManager(nsIServiceManager **result); + + +/* ====================================================================== */ +/* === Window utilities === */ +/* ====================================================================== */ + +// Reconstruct window attributes +static int create_window_attributes(NPWindow *window) +{ + if (window == NULL) + return -1; + if (window->ws_info == NULL) { + if ((window->ws_info = malloc(sizeof(NPSetWindowCallbackStruct))) == NULL) { + npw_printf("ERROR: could not allocate window attributes for NPWindow %p\n", window->window); + return -2; + } + } + NPSetWindowCallbackStruct *ws_info = window->ws_info; + ws_info->type = 0; // should be NP_SETWINDOW but Mozilla sets it to 0 + ws_info->display = x_display; + XWindowAttributes win_attr; + if (!XGetWindowAttributes(ws_info->display, (Window)window->window, &win_attr)) { + npw_printf("ERROR: could not reconstruct window attributes from NPWindow\n"); + return -3; + } + ws_info->visual = win_attr.visual; + ws_info->colormap = win_attr.colormap; + ws_info->depth = win_attr.depth; + return 0; +} + +// Destroy window attributes struct +static void destroy_window_attributes(NPWindow *window) +{ + if (window && window->ws_info) { + free(window->ws_info); + window->ws_info = NULL; + } +} + +// Fix size hints in NPWindow (Flash Player doesn't like null width) +static void fixup_size_hints(PluginInstance *plugin) +{ + NPWindow *window = &plugin->window; + + // check global hints (got through EMBED plugin args) + if (window->width == 0 || window->height == 0) { + if (plugin->width && plugin->height) { + window->width = plugin->width; + window->height = plugin->height; + return; + } + } + + // check actual window size and commit back to plugin data + if (window->width == 0 || window->height == 0) { + XWindowAttributes win_attr; + if (XGetWindowAttributes(x_display, (Window)window->window, &win_attr)) { + plugin->width = window->width = win_attr.width; + plugin->height = window->height = win_attr.height; + return; + } + } + + if (window->width == 0 || window->height == 0) + npw_printf("WARNING: grmpf, despite much effort, I could not determine the actual plugin area size...\n"); +} + +// Create a new window from NPWindow +static int create_window(PluginInstance *plugin, NPWindow *window) +{ + // cache new window information + // XXX destroy previous window here? + memcpy(&plugin->window, window, sizeof(*window)); + window = &plugin->window; + fixup_size_hints(plugin); + + // reconstruct window attributes + if (create_window_attributes(window) < 0) + return -1; + NPSetWindowCallbackStruct *ws_info = window->ws_info; + + // create the new window + if (plugin->use_xembed) + return 0; +#if USE_GTK_TOOLKIT + plugin->top_window = gtk_plug_new(0); + gtk_window_resize(GTK_WINDOW(plugin->top_window), plugin->width, plugin->height); + gtk_widget_set_size_request(plugin->top_window, window->width, window->height); + gtk_widget_show(plugin->top_window); + { + GdkDrawable *win = GDK_DRAWABLE(plugin->top_window->window); + XReparentWindow(GDK_DRAWABLE_XDISPLAY(win), + GDK_DRAWABLE_XID(win), + (Window)window->window, 0, 0); + + XMapWindow(GDK_DRAWABLE_XDISPLAY(win), + GDK_DRAWABLE_XID(win)); + } +#else + XSetWindowAttributes attr; + attr.bit_gravity = NorthWestGravity; + attr.colormap = ws_info->colormap; + attr.event_mask = + ButtonMotionMask | + ButtonPressMask | + ButtonReleaseMask | + KeyPressMask | + KeyReleaseMask | + EnterWindowMask | + LeaveWindowMask | + PointerMotionMask | + StructureNotifyMask | + VisibilityChangeMask | + FocusChangeMask | + ExposureMask; + + unsigned long mask = CWBitGravity | CWEventMask; + if (attr.colormap) + mask |= CWColormap; + + plugin->top_window = XCreateWindow(x_display, (Window)window->window, + 0, 0, window->width, window->height, + 0, ws_info->depth, InputOutput, ws_info->visual, mask, &attr); + + XSelectInput(x_display, plugin->top_window, ExposureMask); + + XMapWindow(x_display, plugin->top_window); + XFlush(x_display); +#endif + + Widget top_widget = XtAppCreateShell("drawingArea", "npw-viewer", applicationShellWidgetClass, x_display, NULL, 0); + plugin->top_widget = top_widget; + XtResizeWidget(top_widget, window->width, window->height, 0); + + Widget form = XtVaCreateWidget("form", compositeWidgetClass, top_widget, + XtNdepth, ws_info->depth, + XtNvisual, ws_info->visual, + XtNcolormap, ws_info->colormap, + NULL); + plugin->form = form; + XtResizeWidget(form, window->width, window->height, 0); + +#if USE_GTK_TOOLKIT + plugin->old_window = top_widget->core.window; + top_widget->core.window = GDK_WINDOW_XWINDOW(plugin->top_window->window); + XtRegisterDrawable(x_display, GDK_WINDOW_XWINDOW(plugin->top_window->window), top_widget); +#else + plugin->old_window = top_widget->core.window; + top_widget->core.window = plugin->top_window; + XtRegisterDrawable(x_display, plugin->top_window, top_widget); +#endif + + XtRealizeWidget(form); + XtManageChild(form); + + int revert_to; + plugin->old_focus_window = None; + XGetInputFocus(x_display, &plugin->old_focus_window, &revert_to); + XtAddEventHandler(form, (LeaveWindowMask | ButtonReleaseMask), True, xt_client_focus_listener, plugin); + plugin->focus_window = plugin->old_focus_window; + XSync(x_display, False); + + window->window = (void *)XtWindow(form); + return 0; +} + +// Update window information from NPWindow +static int update_window(PluginInstance *plugin, NPWindow *window) +{ + if (plugin->window.width != window->width || plugin->window.height != window->height) { + plugin->window.width = window->width; + plugin->window.height = window->height; + if (plugin->form) + XtResizeWidget(plugin->form, plugin->window.width, plugin->window.height, 0); + if (plugin->top_widget) + XtResizeWidget(plugin->top_widget, plugin->window.width, plugin->window.height, 0); + } + return 0; +} + +// Destroy window +static void destroy_window(PluginInstance *plugin) +{ + if (plugin->old_focus_window) { + XtRemoveEventHandler(plugin->form, (LeaveWindowMask | ButtonReleaseMask), True, xt_client_focus_listener, plugin); + plugin->old_focus_window = None; + } + + if (plugin->top_widget) { + XSync(x_display, False); +#if USE_GTK_TOOLKIT + XtUnregisterDrawable(x_display, GDK_WINDOW_XWINDOW(plugin->top_window->window)); +#else + XtUnregisterDrawable(x_display, plugin->top_window); +#endif + XSync(x_display, False); + plugin->top_widget->core.window = plugin->old_window; + XtUnrealizeWidget(plugin->top_widget); + XtDestroyWidget(plugin->top_widget); + XSync(x_display, False); + plugin->top_widget = NULL; + } + + if (plugin->top_window) { +#if USE_GTK_TOOLKIT + gtk_widget_destroy((GtkWidget *)plugin->top_window); + plugin->top_window = NULL; +#else + XDestroyWindow(x_display, plugin->top_window); + plugin->top_window = None; +#endif + XSync(x_display, False); + } + + destroy_window_attributes(&plugin->window); +} + + +/* ====================================================================== */ +/* === Browser side plug-in API === */ +/* ====================================================================== */ + +static char *g_user_agent = NULL; + +// Netscape exported functions +static NPNetscapeFuncs mozilla_funcs; + +// Closes and deletes a stream +static NPError +g_NPN_DestroyStream(NPP instance, NPStream *stream, NPError reason) +{ + D(bug("NPN_DestroyStream instance=%p\n", instance)); + + UNIMPLEMENTED(); + + return NPERR_GENERIC_ERROR; +} + +// Forces a repaint message for a windowless plug-in +static void +g_NPN_ForceRedraw(NPP instance) +{ + D(bug("NPN_ForceRedraw instance=%p\n", instance)); + + UNIMPLEMENTED(); +} + +// Asks the browser to create a stream for the specified URL +static NPError +invoke_NPN_GetURL(NPP instance, const char *url, const char *target) +{ + int error = rpc_method_invoke_delayed(g_rpc_connection, + RPC_METHOD_NPN_GET_URL, + RPC_TYPE_NPP, instance, + RPC_TYPE_STRING, url, + RPC_TYPE_STRING, target, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetURL() invoke", error); + return NPERR_GENERIC_ERROR; + } + + int32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetURL() wait for reply", error); + return NPERR_GENERIC_ERROR; + } + + return ret; +} + +static NPError +g_NPN_GetURL(NPP instance, const char *url, const char *target) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + D(bug("NPN_GetURL instance=%p\n", instance)); + NPError ret = invoke_NPN_GetURL(instance, url, target); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +// Requests creation of a new stream with the contents of the specified URL +static NPError +invoke_NPN_GetURLNotify(NPP instance, const char *url, const char *target, void *notifyData) +{ + int error = rpc_method_invoke_delayed(g_rpc_connection, + RPC_METHOD_NPN_GET_URL_NOTIFY, + RPC_TYPE_NPP, instance, + RPC_TYPE_STRING, url, + RPC_TYPE_STRING, target, + RPC_TYPE_NP_NOTIFY_DATA, notifyData, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetURLNotify() invoke", error); + return NPERR_GENERIC_ERROR; + } + + int32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetURLNotify() wait for reply", error); + return NPERR_GENERIC_ERROR; + } + + return ret; +} + +static NPError +g_NPN_GetURLNotify(NPP instance, const char *url, const char *target, void *notifyData) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + D(bug("NPN_GetURLNotify instance=%p\n", instance)); + NPError ret = invoke_NPN_GetURLNotify(instance, url, target, notifyData); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +// Allows the plug-in to query the browser for information +static NPError +invoke_NPN_GetValue(NPP instance, NPNVariable variable, void *value) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_GET_VALUE, + RPC_TYPE_NPP, instance, + RPC_TYPE_UINT32, variable, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetValue() invoke", error); + return NPERR_GENERIC_ERROR; + } + + int32_t ret; + switch (rpc_type_of_NPNVariable(variable)) { + case RPC_TYPE_BOOLEAN: + { + uint32_t b = 0; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_BOOLEAN, &b, RPC_TYPE_INVALID); + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetValue() wait for reply", error); + ret = NPERR_GENERIC_ERROR; + } + D(bug(" value: %s\n", b ? "true" : "false")); + *((PRBool *)value) = b ? PR_TRUE : PR_FALSE; + break; + } + case RPC_TYPE_NP_OBJECT: + { + NPObject *npobj = NULL; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_NP_OBJECT, &npobj, RPC_TYPE_INVALID); + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetValue() wait for reply", error); + ret = NPERR_GENERIC_ERROR; + } + D(bug(" value: %p\n", npobj)); + *((NPObject **)value) = npobj; + break; + } + } + + return ret; +} + +static NPError +g_NPN_GetValue(NPP instance, NPNVariable variable, void *value) +{ + D(bug("NPN_GetValue instance=%p, variable=%d [%08x]\n", instance, variable & 0xffff, variable)); + + switch (variable) { + case NPNVxDisplay: + *(void **)value = x_display; + break; + case NPNVxtAppContext: + *(void **)value = XtDisplayToApplicationContext(x_display); + break; + case NPNVToolkit: + *(NPNToolkitType *)value = NPNVGtk2; + break; +#if USE_XPCOM + case NPNVserviceManager: { + nsIServiceManager *sm; + int ret = NS_GetServiceManager(&sm); + if (NS_FAILED(ret)) + return NPERR_GENERIC_ERROR; + *(nsIServiceManager **)value = sm; + break; + } +#endif +#if USE_XEMBED + case NPNVSupportsXEmbedBool: +#endif + case NPNVWindowNPObject: + case NPNVPluginElementNPObject: { + int ret = invoke_NPN_GetValue(instance, variable, value); + if (ret == NPERR_NO_ERROR) + return ret; + // fall-through + } + default: + npw_printf("WARNING: unhandled variable %d in NPN_GetValue()\n", variable); + return NPERR_INVALID_PARAM; + } + + return NPERR_NO_ERROR; +} + +// Invalidates specified drawing area prior to repainting or refreshing a windowless plug-in +static void +g_NPN_InvalidateRect(NPP instance, NPRect *invalidRect) +{ + D(bug("NPN_InvalidateRect instance=%p\n", instance)); + + UNIMPLEMENTED(); +} + +// Invalidates specified region prior to repainting or refreshing a windowless plug-in +static void +g_NPN_InvalidateRegion(NPP instance, NPRegion invalidRegion) +{ + D(bug("NPN_InvalidateRegion instance=%p\n", instance)); + + UNIMPLEMENTED(); +} + +// Allocates memory from the browser's memory space +static void * +g_NPN_MemAlloc(uint32 size) +{ + D(bug("NPN_MemAlloc size=%d\n", size)); + + return malloc(size); +} + +// Requests that the browser free a specified amount of memory +static uint32 +g_NPN_MemFlush(uint32 size) +{ + D(bug("NPN_MemFlush size=%d\n", size)); + + return 0; +} + +// Deallocates a block of allocated memory +static void +g_NPN_MemFree(void *ptr) +{ + D(bug("NPN_MemFree ptr=%p\n", ptr)); + + free(ptr); +} + +// Requests the creation of a new data stream produced by the plug-in and consumed by the browser +static NPError +g_NPN_NewStream(NPP instance, NPMIMEType type, const char *target, NPStream **stream) +{ + D(bug("NPN_NewStream instance=%p\n", instance)); + + UNIMPLEMENTED(); + + return NPERR_GENERIC_ERROR; +} + +// Posts data to a URL +static NPError +invoke_NPN_PostURL(NPP instance, const char *url, const char *target, uint32 len, const char *buf, NPBool file) +{ + int error = rpc_method_invoke_delayed(g_rpc_connection, + RPC_METHOD_NPN_POST_URL, + RPC_TYPE_NPP, instance, + RPC_TYPE_STRING, url, + RPC_TYPE_STRING, target, + RPC_TYPE_ARRAY, RPC_TYPE_CHAR, len, buf, + RPC_TYPE_BOOLEAN, file, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_PostURL() invoke", error); + return NPERR_GENERIC_ERROR; + } + + int32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_PostURL() wait for reply", error); + return NPERR_GENERIC_ERROR; + } + + return ret; +} + +static NPError +g_NPN_PostURL(NPP instance, const char *url, const char *target, uint32 len, const char *buf, NPBool file) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + D(bug("NPN_PostURL instance=%p\n", instance)); + NPError ret = invoke_NPN_PostURL(instance, url, target, len, buf, file); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +// Posts data to a URL, and receives notification of the result +static NPError +invoke_NPN_PostURLNotify(NPP instance, const char *url, const char *target, uint32 len, const char *buf, NPBool file, void *notifyData) +{ + int error = rpc_method_invoke_delayed(g_rpc_connection, + RPC_METHOD_NPN_POST_URL_NOTIFY, + RPC_TYPE_NPP, instance, + RPC_TYPE_STRING, url, + RPC_TYPE_STRING, target, + RPC_TYPE_ARRAY, RPC_TYPE_CHAR, len, buf, + RPC_TYPE_BOOLEAN, file, + RPC_TYPE_NP_NOTIFY_DATA, notifyData, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_PostURLNotify() invoke", error); + return NPERR_GENERIC_ERROR; + } + + int32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_PostURLNotify() wait for reply", error); + return NPERR_GENERIC_ERROR; + } + + return ret; +} + +static NPError +g_NPN_PostURLNotify(NPP instance, const char *url, const char *target, uint32 len, const char *buf, NPBool file, void *notifyData) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + D(bug("NPN_PostURLNotify instance=%p\n", instance)); + NPError ret = invoke_NPN_PostURLNotify(instance, url, target, len, buf, file, notifyData); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +// Posts data to a URL, and receives notification of the result +static void +g_NPN_ReloadPlugins(NPBool reloadPages) +{ + D(bug("NPN_ReloadPlugins reloadPages=%d\n", reloadPages)); + + UNIMPLEMENTED(); +} + +// Returns the Java execution environment +static JRIEnv * +g_NPN_GetJavaEnv(void) +{ + D(bug("NPN_GetJavaEnv\n")); + + return NULL; +} + +// Returns the Java object associated with the plug-in instance +static jref +g_NPN_GetJavaPeer(NPP instance) +{ + D(bug("NPN_GetJavaPeer instance=%p\n", instance)); + + return NULL; +} + +// Requests a range of bytes for a seekable stream +static NPError +invoke_NPN_RequestRead(NPStream *stream, NPByteRange *rangeList) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_REQUEST_READ, + RPC_TYPE_NP_STREAM, stream, + RPC_TYPE_NP_BYTE_RANGE, rangeList, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_RequestRead() invoke", error); + return NPERR_GENERIC_ERROR; + } + + int32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_RequestRead() wait for reply", error); + return NPERR_GENERIC_ERROR; + } + + return ret; +} + +static NPError +g_NPN_RequestRead(NPStream *stream, NPByteRange *rangeList) +{ + if (stream == NULL || stream->ndata == NULL || rangeList == NULL) + return NPERR_INVALID_PARAM; + + D(bug("NPN_RequestRead stream=%p\n", stream)); + NPError ret = invoke_NPN_RequestRead(stream, rangeList); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +// Sets various modes of plug-in operation +static NPError +g_NPN_SetValue(NPP instance, NPPVariable variable, void *value) +{ + D(bug("NPN_SetValue instance=%p\n", instance)); + + UNIMPLEMENTED(); + + return NPERR_GENERIC_ERROR; +} + +// Displays a message on the status line of the browser window +static void +invoke_NPN_Status(NPP instance, const char *message) +{ + int error = rpc_method_invoke_delayed(g_rpc_connection, + RPC_METHOD_NPN_STATUS, + RPC_TYPE_NPP, instance, + RPC_TYPE_STRING, message, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_Status() invoke", error); + return; + } + + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_Status() wait for reply", error); + return; + } +} + +static void +g_NPN_Status(NPP instance, const char *message) +{ + D(bug("NPN_Status instance=%p\n", instance)); + invoke_NPN_Status(instance, message); + D(bug(" done\n")); +} + +// Returns the browser's user agent field +static char * +invoke_NPN_UserAgent(void) +{ + int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_USER_AGENT, RPC_TYPE_INVALID); + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_UserAgent() invoke", error); + return NULL; + } + + char *user_agent; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_STRING, &user_agent, RPC_TYPE_INVALID); + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_UserAgent() wait for reply", error); + return NULL; + } + + return user_agent; +} + +static const char * +g_NPN_UserAgent(NPP instance) +{ + D(bug("NPN_UserAgent instance=%p\n", instance)); + if (g_user_agent == NULL) + g_user_agent = invoke_NPN_UserAgent(); + D(bug(" user_agent='%s'\n", g_user_agent)); + return g_user_agent; +} + +// Pushes data into a stream produced by the plug-in and consumed by the browser +static int32 +g_NPN_Write(NPP instance, NPStream *stream, int32 len, void *buf) +{ + D(bug("NPN_Write instance=%d\n", instance)); + + UNIMPLEMENTED(); + + return -1; +} + + +/* ====================================================================== */ +/* === NPRuntime glue === */ +/* ====================================================================== */ + +// Allocates a new NPObject +static uint32_t +invoke_NPN_CreateObject(NPP instance) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_CREATE_OBJECT, + RPC_TYPE_NPP, instance, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_CreateObject() invoke", error); + return 0; + } + + uint32_t npobj_id = 0; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &npobj_id, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_CreateObject() wait for reply", error); + return 0; + } + + return npobj_id; +} + +static NPObject * +g_NPN_CreateObject(NPP instance, NPClass *class) +{ + if (instance == NULL) + return NULL; + + if (class == NULL) + return NULL; + + D(bug("NPN_CreateObject\n")); + uint32_t npobj_id = invoke_NPN_CreateObject(instance); + D(bug(" return: %d\n", npobj_id)); + return npobject_new(npobj_id, instance, class); +} + +// Increments the reference count of the given NPObject +static uint32_t +invoke_NPN_RetainObject(NPObject *npobj) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_RETAIN_OBJECT, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_RetainObject() invoke", error); + return npobj->referenceCount; + } + + uint32_t refcount; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &refcount, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_RetainObject() wait for reply", error); + return npobj->referenceCount; + } + + return refcount; +} + +static NPObject * +g_NPN_RetainObject(NPObject *npobj) +{ + if (npobj == NULL) + return NULL; + + D(bug("NPN_RetainObject %p\n", npobj)); + uint32_t refcount = invoke_NPN_RetainObject(npobj); + D(bug(" return: %d\n", refcount)); + npobj->referenceCount = refcount; + return npobj; +} + +// Decrements the reference count of the give NPObject +static uint32_t +invoke_NPN_ReleaseObject(NPObject *npobj) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_RELEASE_OBJECT, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_ReleaseObject() invoke", error); + return npobj->referenceCount; + } + + uint32_t refcount; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &refcount, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_ReleaseObject() wait for reply", error); + return npobj->referenceCount; + } + + return refcount; +} + +static void +g_NPN_ReleaseObject(NPObject *npobj) +{ + if (npobj == NULL) + return; + + D(bug("NPN_ReleaseObject %p\n", npobj)); + uint32_t refcount = invoke_NPN_ReleaseObject(npobj); + D(bug(" return: %d\n", refcount)); + + if ((npobj->referenceCount = refcount) == 0) + npobject_destroy(npobj); +} + +// Invokes a method on the given NPObject +static bool +invoke_NPN_Invoke(NPP instance, NPObject *npobj, NPIdentifier methodName, + const NPVariant *args, uint32_t argCount, NPVariant *result) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_INVOKE, + RPC_TYPE_NPP, instance, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_NP_IDENTIFIER, methodName, + RPC_TYPE_ARRAY, RPC_TYPE_NP_VARIANT, argCount, args, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_Invoke() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &ret, + RPC_TYPE_NP_VARIANT, result, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_Invoke() wait for reply", error); + return false; + } + + return ret; +} + +static bool +g_NPN_Invoke(NPP instance, NPObject *npobj, NPIdentifier methodName, + const NPVariant *args, uint32_t argCount, NPVariant *result) +{ + if (!instance || !npobj || !npobj->_class || !npobj->_class->invoke) + return false; + + D(bug("NPN_Invoke instance=%p, npobj=%p\n", instance, npobj)); + bool ret = invoke_NPN_Invoke(instance, npobj, methodName, args, argCount, result); + D(bug(" return: %d\n", ret)); + return ret; +} + +// Invokes the default method on the given NPObject +static bool +invoke_NPN_InvokeDefault(NPP instance, NPObject *npobj, + const NPVariant *args, uint32_t argCount, NPVariant *result) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_INVOKE_DEFAULT, + RPC_TYPE_NPP, instance, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_ARRAY, RPC_TYPE_NP_VARIANT, argCount, args, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_InvokeDefault() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &ret, + RPC_TYPE_NP_VARIANT, result, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_InvokeDefault() wait for reply", error); + return false; + } + + return ret; +} + +static bool +g_NPN_InvokeDefault(NPP instance, NPObject *npobj, + const NPVariant *args, uint32_t argCount, NPVariant *result) +{ + if (!instance || !npobj || !npobj->_class || !npobj->_class->invokeDefault) + return false; + + D(bug("NPN_InvokeDefault instance=%p, npobj=%p\n", instance, npobj)); + bool ret = invoke_NPN_InvokeDefault(instance, npobj, args, argCount, result); + D(bug(" return: %d\n", ret)); + return ret; +} + +// Evaluates a script on the scope of a given NPObject +static bool +invoke_NPN_Evaluate(NPP instance, NPObject *npobj, NPString *script, NPVariant *result) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_EVALUATE, + RPC_TYPE_NPP, instance, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_NP_STRING, script, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_Evaluate() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &ret, + RPC_TYPE_NP_VARIANT, result, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_Evaluate() wait for reply", error); + return false; + } + + return ret; +} + +static bool +g_NPN_Evaluate(NPP instance, NPObject *npobj, NPString *script, NPVariant *result) +{ + if (!instance || !npobj) + return false; + + if (!script || !script->utf8length || !script->utf8characters) + return true; // nothing to evaluate + + D(bug("NPN_Evaluate instance=%p, npobj=%p\n", instance, npobj)); + bool ret = invoke_NPN_Evaluate(instance, npobj, script, result); + D(bug(" return: %d\n", ret)); + return ret; +} + +// Gets the value of a property on the given NPObject +static bool +invoke_NPN_GetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, + NPVariant *result) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_GET_PROPERTY, + RPC_TYPE_NPP, instance, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_NP_IDENTIFIER, propertyName, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetProperty() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &ret, + RPC_TYPE_NP_VARIANT, result, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetProperty() wait for reply", error); + return false; + } + + return ret; +} + +static bool +g_NPN_GetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, + NPVariant *result) +{ + if (!instance || !npobj || !npobj->_class || !npobj->_class->getProperty) + return false; + + D(bug("NPN_GetProperty instance=%p, npobj=%p\n", instance, npobj)); + bool ret = invoke_NPN_GetProperty(instance, npobj, propertyName, result); + D(bug(" return: %d\n", ret)); + return ret; +} + +// Sets the value of a property on the given NPObject +static bool +invoke_NPN_SetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, + const NPVariant *value) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_SET_PROPERTY, + RPC_TYPE_NPP, instance, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_NP_IDENTIFIER, propertyName, + RPC_TYPE_NP_VARIANT, value, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_SetProperty() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &ret, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_SetProperty() wait for reply", error); + return false; + } + + return ret; +} + +static bool +g_NPN_SetProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName, + const NPVariant *value) +{ + if (!instance || !npobj || !npobj->_class || !npobj->_class->setProperty) + return false; + + D(bug("NPN_SetProperty instance=%p, npobj=%p\n", instance, npobj)); + bool ret = invoke_NPN_SetProperty(instance, npobj, propertyName, value); + D(bug(" return: %d\n", ret)); + return ret; +} + +// Removes a property on the given NPObject +static bool +invoke_NPN_RemoveProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_REMOVE_PROPERTY, + RPC_TYPE_NPP, instance, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_NP_IDENTIFIER, propertyName, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_RemoveProperty() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &ret, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_RemoveProperty() wait for reply", error); + return false; + } + + return ret; +} + +static bool +g_NPN_RemoveProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName) +{ + if (!instance || !npobj || !npobj->_class || !npobj->_class->removeProperty) + return false; + + D(bug("NPN_RemoveProperty instance=%p, npobj=%p\n", instance, npobj)); + bool ret = invoke_NPN_RemoveProperty(instance, npobj, propertyName); + D(bug(" return: %d\n", ret)); + return ret; +} + +// Checks if a given property exists on the given NPObject +static bool +invoke_NPN_HasProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_HAS_PROPERTY, + RPC_TYPE_NPP, instance, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_NP_IDENTIFIER, propertyName, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_HasProperty() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &ret, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_HasProperty() wait for reply", error); + return false; + } + + return ret; +} + +static bool +g_NPN_HasProperty(NPP instance, NPObject *npobj, NPIdentifier propertyName) +{ + if (!instance || !npobj || !npobj->_class || !npobj->_class->hasProperty) + return false; + + D(bug("NPN_HasProperty instance=%p, npobj=%p\n", instance, npobj)); + bool ret = invoke_NPN_HasProperty(instance, npobj, propertyName); + D(bug(" return: %d\n", ret)); + return ret; +} + +// Checks if a given method exists on the given NPObject +static bool +invoke_NPN_HasMethod(NPP instance, NPObject *npobj, NPIdentifier methodName) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_HAS_METHOD, + RPC_TYPE_NPP, instance, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_NP_IDENTIFIER, methodName, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_HasMethod() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &ret, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_HasMethod() wait for reply", error); + return false; + } + + return ret; +} + +static bool +g_NPN_HasMethod(NPP instance, NPObject *npobj, NPIdentifier methodName) +{ + if (!instance || !npobj || !npobj->_class || !npobj->_class->hasMethod) + return false; + + D(bug("NPN_HasMethod instance=%p, npobj=%p\n", instance, npobj)); + bool ret = invoke_NPN_HasMethod(instance, npobj, methodName); + D(bug(" return: %d\n", ret)); + return ret; +} + +// Indicates that a call to one of the plugins NPObjects generated an error +static void +invoke_NPN_SetException(NPObject *npobj, const NPUTF8 *message) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_SET_EXCEPTION, + RPC_TYPE_NP_OBJECT, npobj, + RPC_TYPE_STRING, message, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_SetException() invoke", error); + return; + } + + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_SetException() wait for reply", error); + return; + } +} + +static void +g_NPN_SetException(NPObject *npobj, const NPUTF8 *message) +{ + D(bug("NPN_SetException npobj=%p, message='%s'\n", npobj, message)); + invoke_NPN_SetException(npobj, message); + D(bug(" done\n")); +} + +// Releases the value in the given variant +static void +g_NPN_ReleaseVariantValue(NPVariant *variant) +{ + D(bug("NPN_ReleaseVariantValue\n")); + + switch (variant->type) { + case NPVariantType_String: + { + NPString *s = &NPVARIANT_TO_STRING(*variant); + if (s->utf8characters) + free((void *)s->utf8characters); + break; + } + case NPVariantType_Object: + { + NPObject *npobj = NPVARIANT_TO_OBJECT(*variant); + if (npobj) + g_NPN_ReleaseObject(npobj); + break; + } + } + + D(bug(" done\n")); +} + +// Returns an opaque identifier for the string that is passed in +static NPIdentifier +invoke_NPN_GetStringIdentifier(const NPUTF8 *name) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_GET_STRING_IDENTIFIER, + RPC_TYPE_STRING, name, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetStringIdentifier() invoke", error); + return NULL; + } + + NPIdentifier ident; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_NP_IDENTIFIER, &ident, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetStringIdentifier() wait for reply", error); + return NULL; + } + + return ident; +} + +static NPIdentifier +g_NPN_GetStringIdentifier(const NPUTF8 *name) +{ + if (name == NULL) + return NULL; + + D(bug("NPN_GetStringIdentifier name='%s'\n", name)); + NPIdentifier ret = invoke_NPN_GetStringIdentifier(name); + D(bug(" return: %p\n", ret)); + return ret; +} + +// Returns an array of opaque identifiers for the names that are passed in +static void +invoke_NPN_GetStringIdentifiers(const NPUTF8 **names, uint32_t nameCount, NPIdentifier *identifiers) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_GET_STRING_IDENTIFIERS, + RPC_TYPE_ARRAY, RPC_TYPE_STRING, nameCount, names, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetStringIdentifiers() invoke", error); + return; + } + + uint32_t n_idents; + NPIdentifier *idents; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_ARRAY, RPC_TYPE_NP_IDENTIFIER, &n_idents, &idents, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetStringIdentifiers() wait for reply", error); + return; + } + + if (identifiers) { + if (n_idents != nameCount) { + npw_printf("ERROR: NPN_GetStringIdentifiers returned fewer NPIdentifiers than expected\n"); + if (n_idents > nameCount) + n_idents = nameCount; + } + for (int i = 0; i < n_idents; i++) + identifiers[i] = idents[i]; + free(idents); + } +} + +static void +g_NPN_GetStringIdentifiers(const NPUTF8 **names, uint32_t nameCount, NPIdentifier *identifiers) +{ + if (names == NULL) + return; + + if (identifiers == NULL) + return; + + D(bug("NPN_GetStringIdentifiers names=%p\n", names)); + invoke_NPN_GetStringIdentifiers(names, nameCount, identifiers); + D(bug(" done\n")); +} + +// Returns an opaque identifier for the integer that is passed in +static NPIdentifier +invoke_NPN_GetIntIdentifier(int32_t intid) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_GET_INT_IDENTIFIER, + RPC_TYPE_INT32, intid, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetIntIdentifier() invoke", error); + return NULL; + } + + NPIdentifier ident; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_NP_IDENTIFIER, &ident, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetIntIdentifier() wait for reply", error); + return NULL; + } + + return ident; +} + +static NPIdentifier +g_NPN_GetIntIdentifier(int32_t intid) +{ + D(bug("NPN_GetIntIdentifier intid=%d\n", intid)); + NPIdentifier ret = invoke_NPN_GetIntIdentifier(intid); + D(bug(" return: %p\n", ret)); + return ret; +} + +// Returns true if the given identifier is a string identifier, or false if it is an integer identifier +static bool +invoke_NPN_IdentifierIsString(NPIdentifier identifier) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_IDENTIFIER_IS_STRING, + RPC_TYPE_NP_IDENTIFIER, identifier, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_IdentifierIsString() invoke", error); + return false; + } + + uint32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_UINT32, &ret, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_IdentifierIsString() wait for reply", error); + return false; + } + + return ret; +} + +static bool +g_NPN_IdentifierIsString(NPIdentifier identifier) +{ + D(bug("NPN_IdentifierIsString identifier=%p\n", identifier)); + bool ret = invoke_NPN_IdentifierIsString(identifier); + D(bug(" return: %d\n", ret)); + return ret; +} + +// Returns a pointer to a UTF-8 string as a sequence of 8-bit units (NPUTF8) +static NPUTF8 * +invoke_NPN_UTF8FromIdentifier(NPIdentifier identifier) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_UTF8_FROM_IDENTIFIER, + RPC_TYPE_NP_IDENTIFIER, identifier, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_UTF8FromIdentifier() invoke", error); + return NULL; + } + + char *str; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_STRING, &str, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_UTF8FromIdentifier() wait for reply", error); + return NULL; + } + + return str; +} + +static NPUTF8 * +g_NPN_UTF8FromIdentifier(NPIdentifier identifier) +{ + D(bug("NPN_UTF8FromIdentifier identifier=%p\n", identifier)); + NPUTF8 *ret = invoke_NPN_UTF8FromIdentifier(identifier); + D(bug(" return: '%s'\n", ret)); + return ret; +} + +// Returns the integer value for the given integer identifier +// NOTE: if the given identifier is not a integer identifier, the behavior is undefined (we return -1) +static int32_t +invoke_NPN_IntFromIdentifier(NPIdentifier identifier) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_INT_FROM_IDENTIFIER, + RPC_TYPE_NP_IDENTIFIER, identifier, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_IntFromIdentifier() invoke", error); + return -1; + } + + int32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_INT32, &ret, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_IntFromIdentifier() wait for reply", error); + return -1; + } + + return ret; +} + +static int32_t +g_NPN_IntFromIdentifier(NPIdentifier identifier) +{ + D(bug("NPN_IntFromIdentifier identifier=%p\n", identifier)); + int32_t ret = invoke_NPN_IntFromIdentifier(identifier); + D(bug(" return: %d\n", ret)); + return ret; +} + + +/* ====================================================================== */ +/* === Plug-in side data === */ +/* ====================================================================== */ + +// Functions supplied by the plug-in +static NPPluginFuncs plugin_funcs; + +// Allows the browser to query the plug-in supported formats +typedef char * (*NP_GetMIMEDescriptionUPP)(void); +static NP_GetMIMEDescriptionUPP g_NP_GetMIMEDescription = NULL; + +// Allows the browser to query the plug-in for information +typedef NPError (*NP_GetValueUPP)(void *instance, NPPVariable variable, void *value); +static NP_GetValueUPP g_NP_GetValue = NULL; + +// Provides global initialization for a plug-in +typedef NPError (*NP_InitializeUPP)(NPNetscapeFuncs *moz_funcs, NPPluginFuncs *plugin_funcs); +static NP_InitializeUPP g_NP_Initialize = NULL; + +// Provides global deinitialization for a plug-in +typedef NPError (*NP_ShutdownUPP)(void); +static NP_ShutdownUPP g_NP_Shutdown = NULL; + + +/* ====================================================================== */ +/* === RPC communication === */ +/* ====================================================================== */ + +// NP_GetMIMEDescription +static int handle_NP_GetMIMEDescription(rpc_connection_t *connection) +{ + D(bug("handle_NP_GetMIMEDescription\n")); + + char *str = g_NP_GetMIMEDescription(); + return rpc_method_send_reply(connection, RPC_TYPE_STRING, str, RPC_TYPE_INVALID); +} + +// NP_GetValue +static int handle_NP_GetValue(rpc_connection_t *connection) +{ + D(bug("handle_NP_GetValue\n")); + + int32_t variable; + int error = rpc_method_get_args(connection, RPC_TYPE_INT32, &variable, RPC_TYPE_INVALID); + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NP_GetValue() get args", error); + return error; + } + + char *str = NULL; + NPError ret = g_NP_GetValue ? g_NP_GetValue(NULL, variable, (void *)&str) : NPERR_GENERIC_ERROR; + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_STRING, str, RPC_TYPE_INVALID); +} + +// NP_Initialize +static int handle_NP_Initialize(rpc_connection_t *connection) +{ + D(bug("handle_NP_Initialize\n")); + + uint32_t has_npruntime = 0; + int error = rpc_method_get_args(connection, + RPC_TYPE_UINT32, &has_npruntime, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NP_Initialize() get args", error); + return error; + } + + memset(&plugin_funcs, 0, sizeof(plugin_funcs)); + plugin_funcs.size = sizeof(plugin_funcs); + + memset(&mozilla_funcs, 0, sizeof(mozilla_funcs)); + mozilla_funcs.size = sizeof(mozilla_funcs); + mozilla_funcs.version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR; + mozilla_funcs.geturl = NewNPN_GetURLProc(g_NPN_GetURL); + mozilla_funcs.posturl = NewNPN_PostURLProc(g_NPN_PostURL); + mozilla_funcs.requestread = NewNPN_RequestReadProc(g_NPN_RequestRead); + mozilla_funcs.newstream = NewNPN_NewStreamProc(g_NPN_NewStream); + mozilla_funcs.write = NewNPN_WriteProc(g_NPN_Write); + mozilla_funcs.destroystream = NewNPN_DestroyStreamProc(g_NPN_DestroyStream); + mozilla_funcs.status = NewNPN_StatusProc(g_NPN_Status); + mozilla_funcs.uagent = NewNPN_UserAgentProc(g_NPN_UserAgent); + mozilla_funcs.memalloc = NewNPN_MemAllocProc(g_NPN_MemAlloc); + mozilla_funcs.memfree = NewNPN_MemFreeProc(g_NPN_MemFree); + mozilla_funcs.memflush = NewNPN_MemFlushProc(g_NPN_MemFlush); + mozilla_funcs.reloadplugins = NewNPN_ReloadPluginsProc(g_NPN_ReloadPlugins); + mozilla_funcs.getJavaEnv = NewNPN_GetJavaEnvProc(g_NPN_GetJavaEnv); + mozilla_funcs.getJavaPeer = NewNPN_GetJavaPeerProc(g_NPN_GetJavaPeer); + mozilla_funcs.geturlnotify = NewNPN_GetURLNotifyProc(g_NPN_GetURLNotify); + mozilla_funcs.posturlnotify = NewNPN_PostURLNotifyProc(g_NPN_PostURLNotify); + mozilla_funcs.getvalue = NewNPN_GetValueProc(g_NPN_GetValue); + mozilla_funcs.setvalue = NewNPN_SetValueProc(g_NPN_SetValue); + mozilla_funcs.invalidaterect = NewNPN_InvalidateRectProc(g_NPN_InvalidateRect); + mozilla_funcs.invalidateregion = NewNPN_InvalidateRegionProc(g_NPN_InvalidateRegion); + mozilla_funcs.forceredraw = NewNPN_ForceRedrawProc(g_NPN_ForceRedraw); + + npruntime_init_callbacks(&mozilla_funcs); + + if (has_npruntime && getenv("NPW_DISABLE_NPRUNTIME")) { + D(bug(" user disabled npruntime support\n")); + has_npruntime = false; + } + + if (has_npruntime) { + D(bug(" browser supports scripting through npruntime\n")); + mozilla_funcs.getstringidentifier = NewNPN_GetStringIdentifierProc(g_NPN_GetStringIdentifier); + mozilla_funcs.getstringidentifiers = NewNPN_GetStringIdentifiersProc(g_NPN_GetStringIdentifiers); + mozilla_funcs.getintidentifier = NewNPN_GetIntIdentifierProc(g_NPN_GetIntIdentifier); + mozilla_funcs.identifierisstring = NewNPN_IdentifierIsStringProc(g_NPN_IdentifierIsString); + mozilla_funcs.utf8fromidentifier = NewNPN_UTF8FromIdentifierProc(g_NPN_UTF8FromIdentifier); + mozilla_funcs.intfromidentifier = NewNPN_IntFromIdentifierProc(g_NPN_IntFromIdentifier); + mozilla_funcs.createobject = NewNPN_CreateObjectProc(g_NPN_CreateObject); + mozilla_funcs.retainobject = NewNPN_RetainObjectProc(g_NPN_RetainObject); + mozilla_funcs.releaseobject = NewNPN_ReleaseObjectProc(g_NPN_ReleaseObject); + mozilla_funcs.invoke = NewNPN_InvokeProc(g_NPN_Invoke); + mozilla_funcs.invokeDefault = NewNPN_InvokeDefaultProc(g_NPN_InvokeDefault); + mozilla_funcs.evaluate = NewNPN_EvaluateProc(g_NPN_Evaluate); + mozilla_funcs.getproperty = NewNPN_GetPropertyProc(g_NPN_GetProperty); + mozilla_funcs.setproperty = NewNPN_SetPropertyProc(g_NPN_SetProperty); + mozilla_funcs.removeproperty = NewNPN_RemovePropertyProc(g_NPN_RemoveProperty); + mozilla_funcs.hasproperty = NewNPN_HasPropertyProc(g_NPN_HasProperty); + mozilla_funcs.hasmethod = NewNPN_HasMethodProc(g_NPN_HasMethod); + mozilla_funcs.releasevariantvalue = NewNPN_ReleaseVariantValueProc(g_NPN_ReleaseVariantValue); + mozilla_funcs.setexception = NewNPN_SetExceptionProc(g_NPN_SetException); + } + + NPError ret = NPERR_NO_ERROR; + + if (!npobject_bridge_new()) + ret = NPERR_OUT_OF_MEMORY_ERROR; + + if (ret == NPERR_NO_ERROR) + ret = g_NP_Initialize(&mozilla_funcs, &plugin_funcs); + + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); +} + +// NP_Shutdown +static int handle_NP_Shutdown(rpc_connection_t *connection) +{ + D(bug("handle_NP_Shutdown\n")); + + NPError ret = g_NP_Shutdown(); + npobject_bridge_destroy(); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); +} + +// NP_Exit +static int handle_NP_Exit(rpc_connection_t *connection) +{ + D(bug("handle_NP_Exit\n")); + + gtk_main_quit(); + return RPC_ERROR_NO_ERROR; +} + +// NPP_New +static NPError g_NPP_New(NPMIMEType plugin_type, uint32_t instance_id, + uint16_t mode, int16_t argc, char *argn[], char *argv[], + NPSavedData *saved) +{ + PluginInstance *plugin = malloc(sizeof(*plugin)); + if (plugin == NULL) + return NPERR_OUT_OF_MEMORY_ERROR; + memset(plugin, 0, sizeof(*plugin)); + plugin->instance_id = instance_id; + id_link(instance_id, plugin); + + NPP instance = malloc(sizeof(*instance)); + if (instance == NULL) + return NPERR_OUT_OF_MEMORY_ERROR; + memset(instance, 0, sizeof(*instance)); + instance->ndata = plugin; + plugin->instance = instance; + + // check for size hints + for (int i = 0; i < argc; i++) { + if (argn[i] == NULL) + continue; + if (strcasecmp(argn[i], "width") == 0) { + if (i < argc && argv[i]) + plugin->width = atoi(argv[i]); + } + else if (strcasecmp(argn[i], "height") == 0) { + if (i < argc && argv[i]) + plugin->height = atoi(argv[i]); + } + } + + D(bug("NPP_New instance=%p\n", instance)); + NPError ret = plugin_funcs.newp(plugin_type, instance, mode, argc, argn, argv, saved); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + + // check if XEMBED is to be used + PRBool supports_XEmbed = PR_FALSE; + if (mozilla_funcs.getvalue) { + NPError error = mozilla_funcs.getvalue(NULL, NPNVSupportsXEmbedBool, (void *)&supports_XEmbed); + if (error == NPERR_NO_ERROR && plugin_funcs.getvalue) { + PRBool needs_XEmbed = PR_FALSE; + error = plugin_funcs.getvalue(instance, NPPVpluginNeedsXEmbed, (void *)&needs_XEmbed); + if (error == NPERR_NO_ERROR) + plugin->use_xembed = supports_XEmbed && needs_XEmbed; + } + } + + return ret; +} + +static int handle_NPP_New(rpc_connection_t *connection) +{ + D(bug("handle_NPP_New\n")); + + uint32_t instance_id; + NPMIMEType plugin_type; + int32_t mode; + int argn_count, argv_count; + char **argn, **argv; + NPSavedData *saved; + int error = rpc_method_get_args(connection, + RPC_TYPE_UINT32, &instance_id, + RPC_TYPE_STRING, &plugin_type, + RPC_TYPE_INT32, &mode, + RPC_TYPE_ARRAY, RPC_TYPE_STRING, &argn_count, &argn, + RPC_TYPE_ARRAY, RPC_TYPE_STRING, &argv_count, &argv, + RPC_TYPE_NP_SAVED_DATA, &saved, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_New() get args", error); + return error; + } + + assert(argn_count == argv_count); + NPError ret = g_NPP_New(plugin_type, instance_id, mode, argn_count, argn, argv, saved); + + if (plugin_type) + free(plugin_type); + if (argn) { + for (int i = 0; i < argn_count; i++) + free(argn[i]); + free(argn); + } + if (argv) { + for (int i = 0; i < argv_count; i++) + free(argv[i]); + free(argv); + } + + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); +} + +// NPP_Destroy +static NPError g_NPP_Destroy(NPP instance, NPSavedData **sdata) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + if (sdata) + *sdata = NULL; + + D(bug("NPP_Destroy instance=%p\n", instance)); + NPError ret = plugin_funcs.destroy(instance, sdata); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + + PluginInstance *plugin = instance->ndata; + if (plugin) { + destroy_window(plugin); + id_remove(plugin->instance_id); + free(plugin); + } + free(instance); + + return ret; +} + +static int handle_NPP_Destroy(rpc_connection_t *connection) +{ + int error; + NPP instance; + error = rpc_method_get_args(connection, RPC_TYPE_NPP, &instance, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_Destroy() get args", error); + return error; + } + + NPSavedData *save_area; + NPError ret = g_NPP_Destroy(instance, &save_area); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_NP_SAVED_DATA, save_area, RPC_TYPE_INVALID); +} + +// NPP_SetWindow +static NPError +g_NPP_SetWindow(NPP instance, NPWindow *np_window) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + if (plugin_funcs.setwindow == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + PluginInstance *plugin = instance->ndata; + if (plugin == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + NPWindow *window = np_window; + if (window) { + if (plugin->top_window) { + if (update_window(plugin, window) < 0) + return NPERR_GENERIC_ERROR; + } + else { + if (create_window(plugin, window) < 0) + return NPERR_GENERIC_ERROR; + } + window = &plugin->window; + } + + D(bug("NPP_SetWindow instance=%p, window=%p\n", instance, window ? window->window : NULL)); + NPError ret = plugin_funcs.setwindow(instance, window); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + + if (np_window == NULL) + destroy_window(plugin); + + return ret; +} + +static int handle_NPP_SetWindow(rpc_connection_t *connection) +{ + D(bug("handle_NPP_SetWindow\n")); + + int error; + NPP instance; + NPWindow *window; + + error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_NP_WINDOW, &window, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_SetWindow() get args", error); + return error; + } + + NPError ret = g_NPP_SetWindow(instance, window); + if (window) + free(window); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); +} + +// NPP_GetValue +static NPError +g_NPP_GetValue(NPP instance, NPPVariable variable, void *value) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + if (plugin_funcs.getvalue == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + D(bug("NPP_GetValue instance=%p, variable=%d\n", instance, variable)); + NPError ret = plugin_funcs.getvalue(instance, variable, value); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +static int handle_NPP_GetValue(rpc_connection_t *connection) +{ + int error; + NPP instance; + int32_t variable; + + error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_INT32, &variable, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_printf("ERROR: could not get NPP_GetValue variable\n"); + return error; + } + + NPError ret = NPERR_GENERIC_ERROR; + int variable_type = rpc_type_of_NPPVariable(variable); + + switch (variable_type) { + case RPC_TYPE_STRING: + { + char *str = NULL; + ret = g_NPP_GetValue(instance, variable, (void *)&str); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_STRING, str, RPC_TYPE_INVALID); + } + case RPC_TYPE_INT32: + { + uint32_t n = 0; + ret = g_NPP_GetValue(instance, variable, (void *)&n); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INT32, n, RPC_TYPE_INVALID); + } + case RPC_TYPE_BOOLEAN: + { + PRBool b = PR_FALSE; + ret = g_NPP_GetValue(instance, variable, (void *)&b); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_BOOLEAN, b, RPC_TYPE_INVALID); + } + case RPC_TYPE_NP_OBJECT: + { + NPObject *npobj = NULL; + ret = g_NPP_GetValue(instance, variable, (void *)&npobj); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_INVALID); + } + } + + abort(); +} + +// NPP_URLNotify +static void +g_NPP_URLNotify(NPP instance, const char *url, NPReason reason, void *notifyData) +{ + if (instance) + return; + + if (plugin_funcs.urlnotify == NULL) + return; + + D(bug("NPP_URLNotify instance=%p, url='%s', reason=%s, notifyData=%p\n", + instance, url, string_of_NPReason(reason), notifyData)); + plugin_funcs.urlnotify(instance, url, reason, notifyData); + D(bug(" done\n")); +} + +static int handle_NPP_URLNotify(rpc_connection_t *connection) +{ + int error; + NPP instance; + char *url; + int32_t reason; + void *notifyData; + + error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_STRING, &url, + RPC_TYPE_INT32, &reason, + RPC_TYPE_NP_NOTIFY_DATA, ¬ifyData, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_URLNotify() get args", error); + return error; + } + + g_NPP_URLNotify(instance, url, reason, notifyData); + + if (url) + free(url); + + return RPC_ERROR_NO_ERROR; +} + +// NPP_NewStream +static NPError +g_NPP_NewStream(NPP instance, NPMIMEType type, NPStream *stream, NPBool seekable, uint16 *stype) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + if (plugin_funcs.newstream == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + D(bug("NPP_NewStream instance=%p, stream=%p, type='%s', seekable=%d, stype=%s\n", + instance, stream, type, seekable, string_of_NPStreamType(*stype))); + NPError ret = plugin_funcs.newstream(instance, type, stream, seekable, stype); + D(bug(" return: %d [%s], stype=%s\n", ret, string_of_NPError(ret), string_of_NPStreamType(*stype))); + return ret; +} + +static int handle_NPP_NewStream(rpc_connection_t *connection) +{ + int error; + NPP instance; + uint32_t stream_id; + uint32_t seekable; + NPMIMEType type; + + NPStream *stream; + if ((stream = malloc(sizeof(*stream))) == NULL) + return RPC_ERROR_NO_MEMORY; + memset(stream, 0, sizeof(*stream)); + + error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_STRING, &type, + RPC_TYPE_UINT32, &stream_id, + RPC_TYPE_STRING, &stream->url, + RPC_TYPE_UINT32, &stream->end, + RPC_TYPE_UINT32, &stream->lastmodified, + RPC_TYPE_NP_NOTIFY_DATA, &stream->notifyData, + RPC_TYPE_BOOLEAN, &seekable, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_NewStream() get args", error); + return error; + } + + StreamInstance *stream_ndata; + if ((stream_ndata = malloc(sizeof(*stream_ndata))) == NULL) + return RPC_ERROR_NO_MEMORY; + stream->ndata = stream_ndata; + memset(stream_ndata, 0, sizeof(*stream_ndata)); + stream_ndata->stream_id = stream_id; + id_link(stream_id, stream_ndata); + stream_ndata->stream = stream; + + uint16 stype = NP_NORMAL; + NPError ret = g_NPP_NewStream(instance, type, stream, seekable, &stype); + + if (type) + free(type); + + return rpc_method_send_reply(connection, + RPC_TYPE_INT32, ret, + RPC_TYPE_UINT32, (uint32_t)stype, + RPC_TYPE_NP_NOTIFY_DATA, stream->notifyData, + RPC_TYPE_INVALID); +} + +// NPP_DestroyStream +static NPError +g_NPP_DestroyStream(NPP instance, NPStream *stream, NPReason reason) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + if (plugin_funcs.destroystream == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + if (stream == NULL) + return NPERR_INVALID_PARAM; + + D(bug("NPP_DestroyStream instance=%p, stream=%p, reason=%s\n", + instance, stream, string_of_NPReason(reason))); + NPError ret = plugin_funcs.destroystream(instance, stream, reason); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + + StreamInstance *stream_ndata = stream->ndata; + if (stream_ndata) { + id_remove(stream_ndata->stream_id); + free(stream_ndata); + } + free((char *)stream->url); + free(stream); + + return ret; +} + +static int handle_NPP_DestroyStream(rpc_connection_t *connection) +{ + D(bug("handle_NPP_DestroyStream\n")); + + NPP instance; + NPStream *stream; + int32_t reason; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_NP_STREAM, &stream, + RPC_TYPE_INT32, &reason, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_DestroyStream() get args", error); + return error; + } + + NPError ret = g_NPP_DestroyStream(instance, stream, reason); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); +} + +// NPP_WriteReady +static int32 +g_NPP_WriteReady(NPP instance, NPStream *stream) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + if (plugin_funcs.writeready == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + if (stream == NULL) + return NPERR_INVALID_PARAM; + + D(bug("NPP_WriteReady instance=%p, stream=%p\n", instance, stream)); + int32 ret = plugin_funcs.writeready(instance, stream); + D(bug(" return: %d\n", ret)); + return ret; +} + +static int handle_NPP_WriteReady(rpc_connection_t *connection) +{ + D(bug("handle_NPP_WriteReady\n")); + + NPP instance; + NPStream *stream; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_NP_STREAM, &stream, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_WriteReady() get args", error); + return error; + } + + int32 ret = g_NPP_WriteReady(instance, stream); + + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); +} + +// NPP_Write +static int32 +g_NPP_Write(NPP instance, NPStream *stream, int32 offset, int32 len, void *buf) +{ + if (instance == NULL) + return -1; + + if (plugin_funcs.write == NULL) + return -1; + + if (stream == NULL) + return -1; + + D(bug("NPP_Write instance=%p, stream=%p, offset=%d, len=%d, buf=%p\n", instance, stream, offset, len, buf)); + int32 ret = plugin_funcs.write(instance, stream, offset, len, buf); + D(bug(" return: %d\n", ret)); + return ret; +} + +static int handle_NPP_Write(rpc_connection_t *connection) +{ + NPP instance; + NPStream *stream; + unsigned char *buf; + int32_t offset, len; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_NP_STREAM, &stream, + RPC_TYPE_INT32, &offset, + RPC_TYPE_ARRAY, RPC_TYPE_CHAR, &len, &buf, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_Write() get args", error); + return error; + } + + int32 ret = g_NPP_Write(instance, stream, offset, len, buf); + + if (buf) + free(buf); + + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); +} + +// NPP_StreamAsFile +static void +g_NPP_StreamAsFile(NPP instance, NPStream *stream, const char *fname) +{ + if (instance == NULL) + return; + + if (plugin_funcs.asfile == NULL) + return; + + if (stream == NULL) + return; + + D(bug("NPP_StreamAsFile instance=%p, stream=%p, fname='%s'\n", instance, stream, fname)); + plugin_funcs.asfile(instance, stream, fname); + D(bug(" done\n")); +} + +static int handle_NPP_StreamAsFile(rpc_connection_t *connection) +{ + NPP instance; + NPStream *stream; + char *fname; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_NP_STREAM, &stream, + RPC_TYPE_STRING, &fname, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_StreamAsFile() get args", error); + return error; + } + + g_NPP_StreamAsFile(instance, stream, fname); + + if (fname) + free(fname); + + return RPC_ERROR_NO_ERROR; +} + +// NPP_Print +static void +g_NPP_Print(NPP instance, NPPrint *printInfo) +{ + if (plugin_funcs.print == NULL) + return; + + if (printInfo == NULL) + return; + + D(bug("NPP_Print instance=%p, printInfo->mode=%d\n", instance, printInfo->mode)); + plugin_funcs.print(instance, printInfo); + D(bug(" done\n")); +} + +static void invoke_NPN_PrintData(PluginInstance *plugin, uint32_t platform_print_id, NPPrintData *printData) +{ + if (printData == NULL) + return; + + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPN_PRINT_DATA, + RPC_TYPE_UINT32, platform_print_id, + RPC_TYPE_NP_PRINT_DATA, printData, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_PrintData() invoke", error); + return; + } + + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_PrintData() wait for reply", error); + return; + } +} + +static int handle_NPP_Print(rpc_connection_t *connection) +{ + NPP instance; + NPPrint printInfo; + uint32_t platform_print_id; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_UINT32, &platform_print_id, + RPC_TYPE_NP_PRINT, &printInfo, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_Print() get args", error); + return error; + } + + // reconstruct printer info + NPPrintCallbackStruct printer; + printer.type = NP_PRINT; + printer.fp = platform_print_id ? tmpfile() : NULL; + switch (printInfo.mode) { + case NP_FULL: + printInfo.print.fullPrint.platformPrint = &printer; + break; + case NP_EMBED: + printInfo.print.embedPrint.platformPrint = &printer; + // XXX the window ID is unlikely to work here as is. The NPWindow + // is probably only used as a bounding box? + create_window_attributes(&printInfo.print.embedPrint.window); + break; + } + + g_NPP_Print(instance, &printInfo); + + // send back the printed data + if (printer.fp) { + long file_size = ftell(printer.fp); + D(bug(" writeback data [%d bytes]\n", file_size)); + rewind(printer.fp); + NPPrintData printData; + const int printDataMaxSize = sizeof(printData.data); + int n = file_size / printDataMaxSize; + while (--n >= 0) { + printData.size = printDataMaxSize; + if (fread(&printData.data, sizeof(printData.data), 1, printer.fp) != 1) { + npw_printf("ERROR: unexpected end-of-file or error condition in NPP_Print\n"); + break; + } + invoke_NPN_PrintData(instance->ndata, platform_print_id, &printData); + } + printData.size = file_size % printDataMaxSize; + if (fread(&printData.data, printData.size, 1, printer.fp) != 1) + npw_printf("ERROR: unexpected end-of-file or error condition in NPP_Print\n"); + invoke_NPN_PrintData(instance->ndata, platform_print_id, &printData); + fclose(printer.fp); + } + + if (printInfo.mode == NP_EMBED) + destroy_window_attributes(&printInfo.print.embedPrint.window); + + uint32_t plugin_printed = FALSE; + if (printInfo.mode == NP_FULL) + plugin_printed = printInfo.print.fullPrint.pluginPrinted; + return rpc_method_send_reply(connection, RPC_TYPE_BOOLEAN, plugin_printed, RPC_TYPE_INVALID); +} + + +/* ====================================================================== */ +/* === Events processing === */ +/* ====================================================================== */ + +typedef gboolean (*GSourcePrepare)(GSource *, gint *); +typedef gboolean (*GSourceCheckFunc)(GSource *); +typedef gboolean (*GSourceDispatchFunc)(GSource *, GSourceFunc, gpointer); +typedef void (*GSourceFinalizeFunc)(GSource *); + +// Xt events +static GPollFD xt_event_poll_fd; + +static gboolean xt_event_prepare(GSource *source, gint *timeout) +{ + int mask = XtAppPending(x_app_context); + return mask & XtIMXEvent; +} + +static gboolean xt_event_check(GSource *source) +{ + if (xt_event_poll_fd.revents & G_IO_IN) { + int mask = XtAppPending(x_app_context); + if (mask & XtIMXEvent) + return TRUE; + } + return FALSE; +} + +static gboolean xt_event_dispatch(GSource *source, GSourceFunc callback, gpointer user_data) +{ + int i; + for (i = 0; i < 5; i++) { + int mask = XtAppPending(x_app_context); + if ((mask & XtIMXEvent) == 0) + break; + XtAppProcessEvent(x_app_context, XtIMXEvent); + } + return TRUE; +} + +static GSourceFuncs xt_event_funcs = { + xt_event_prepare, + xt_event_check, + xt_event_dispatch, + (GSourceFinalizeFunc)g_free, + (GSourceFunc)NULL, + (GSourceDummyMarshal)NULL +}; + +static gboolean xt_event_polling_timer_callback(gpointer user_data) +{ + int i; + for (i = 0; i < 5; i++) { + if ((XtAppPending(x_app_context) & (XtIMAll & ~XtIMXEvent)) == 0) + break; + XtAppProcessEvent(x_app_context, XtIMAll & ~XtIMXEvent); + } + return TRUE; +} + +// RPC events +static GPollFD rpc_event_poll_fd; + +static gboolean rpc_event_prepare(GSource *source, gint *timeout) +{ + *timeout = -1; + return FALSE; +} + +static gboolean rpc_event_check(GSource *source) +{ + return rpc_wait_dispatch(g_rpc_connection, 0) > 0; +} + +static gboolean rpc_event_dispatch(GSource *source, GSourceFunc callback, gpointer user_data) +{ + callback(user_data); + return TRUE; +} + +static GSourceFuncs rpc_event_funcs = { + rpc_event_prepare, + rpc_event_check, + rpc_event_dispatch, + (GSourceFinalizeFunc)g_free, + (GSourceFunc)NULL, + (GSourceDummyMarshal)NULL +}; + + +/* ====================================================================== */ +/* === Main program === */ +/* ====================================================================== */ + +static int do_test(void); + +static int do_main(int argc, char **argv, const char *connection_path) +{ + if (do_test() != 0) + return 1; + if (connection_path == NULL) { + npw_printf("ERROR: missing connection path argument\n"); + return 1; + } + D(bug(" Plugin connection: %s\n", connection_path)); + + id_init(); + + // Xt and GTK initialization + XtToolkitInitialize(); + x_app_context = XtCreateApplicationContext(); + x_display = XtOpenDisplay(x_app_context, NULL, "npw-viewer", "npw-viewer", NULL, 0, &argc, argv); + gtk_init(&argc, &argv); + + // Initialize RPC communication channel + if (rpc_add_np_marshalers() < 0) { + npw_printf("ERROR: failed to initialize plugin-side marshalers\n"); + return 1; + } + if ((g_rpc_connection = rpc_init_server(connection_path)) == NULL) { + npw_printf("ERROR: failed to initialize plugin-side RPC server connection\n"); + return 1; + } + static const rpc_method_descriptor_t vtable[] = { + { RPC_METHOD_NP_GET_MIME_DESCRIPTION, handle_NP_GetMIMEDescription }, + { RPC_METHOD_NP_GET_VALUE, handle_NP_GetValue }, + { RPC_METHOD_NP_INITIALIZE, handle_NP_Initialize }, + { RPC_METHOD_NP_SHUTDOWN, handle_NP_Shutdown }, + { RPC_METHOD_NP_EXIT, handle_NP_Exit }, + { RPC_METHOD_NPP_NEW, handle_NPP_New }, + { RPC_METHOD_NPP_DESTROY, handle_NPP_Destroy }, + { RPC_METHOD_NPP_GET_VALUE, handle_NPP_GetValue }, + { RPC_METHOD_NPP_SET_WINDOW, handle_NPP_SetWindow }, + { RPC_METHOD_NPP_URL_NOTIFY, handle_NPP_URLNotify }, + { RPC_METHOD_NPP_NEW_STREAM, handle_NPP_NewStream }, + { RPC_METHOD_NPP_DESTROY_STREAM, handle_NPP_DestroyStream }, + { RPC_METHOD_NPP_WRITE_READY, handle_NPP_WriteReady }, + { RPC_METHOD_NPP_WRITE, handle_NPP_Write }, + { RPC_METHOD_NPP_STREAM_AS_FILE, handle_NPP_StreamAsFile }, + { RPC_METHOD_NPP_PRINT, handle_NPP_Print }, + { RPC_METHOD_NPCLASS_INVALIDATE, npclass_handle_Invalidate }, + { RPC_METHOD_NPCLASS_HAS_METHOD, npclass_handle_HasMethod }, + { RPC_METHOD_NPCLASS_INVOKE, npclass_handle_Invoke }, + { RPC_METHOD_NPCLASS_INVOKE_DEFAULT, npclass_handle_InvokeDefault }, + { RPC_METHOD_NPCLASS_HAS_PROPERTY, npclass_handle_HasProperty }, + { RPC_METHOD_NPCLASS_GET_PROPERTY, npclass_handle_GetProperty }, + { RPC_METHOD_NPCLASS_SET_PROPERTY, npclass_handle_SetProperty }, + { RPC_METHOD_NPCLASS_REMOVE_PROPERTY, npclass_handle_RemoveProperty }, + }; + if (rpc_method_add_callbacks(g_rpc_connection, vtable, sizeof(vtable) / sizeof(vtable[0])) < 0) { + npw_printf("ERROR: failed to setup NPP method callbacks\n"); + return 1; + } + + // Initialize Xt events listener (integrate X events into GTK events loop) + GSource *xt_source = g_source_new(&xt_event_funcs, sizeof(GSource)); + if (xt_source == NULL) { + npw_printf("ERROR: failed to initialize Xt events listener\n"); + return 1; + } + g_source_set_priority(xt_source, GDK_PRIORITY_EVENTS); + g_source_set_can_recurse(xt_source, TRUE); + gint xt_tag = g_source_attach(xt_source, NULL); + xt_event_poll_fd.fd = ConnectionNumber(x_display); + xt_event_poll_fd.events = G_IO_IN; + xt_event_poll_fd.revents = 0; + g_source_add_poll(xt_source, &xt_event_poll_fd); + + gint xt_polling_timer_id = g_timeout_add(25, + xt_event_polling_timer_callback, + NULL); + + // Initialize RPC events listener + GSource *rpc_source = g_source_new(&rpc_event_funcs, sizeof(GSource)); + if (rpc_source == NULL) { + npw_printf("ERROR: failed to initialize plugin-side RPC events listener\n"); + return 1; + } + g_source_set_priority(rpc_source, GDK_PRIORITY_EVENTS); + gint rpc_tag = g_source_attach(rpc_source, NULL); + rpc_event_poll_fd.fd = rpc_listen_socket(g_rpc_connection); + rpc_event_poll_fd.events = G_IO_IN; + rpc_event_poll_fd.revents = 0; + g_source_set_callback(rpc_source, (GSourceFunc)rpc_dispatch, g_rpc_connection, NULL); + g_source_add_poll(rpc_source, &rpc_event_poll_fd); + + gtk_main(); + D(bug("--- EXIT ---\n")); + + g_source_remove(xt_polling_timer_id); + g_source_remove_poll(rpc_source, &rpc_event_poll_fd); + g_source_remove(rpc_tag); + g_source_remove_poll(xt_source, &xt_event_poll_fd); + g_source_remove(xt_tag); + + if (g_user_agent) + free(g_user_agent); + if (g_rpc_connection) + rpc_exit(g_rpc_connection); + + id_kill(); + return 0; +} + +// Flash Player 9 beta 1 is not stable enough and will generally +// freeze on NP_Shutdown when multiple Flash movies are active +static int is_flash_player9_beta1(void) +{ + if (g_NP_GetValue) { + const char *plugin_desc = NULL; + if (g_NP_GetValue(NULL, NPPVpluginDescriptionString, &plugin_desc) == NPERR_NO_ERROR + && plugin_desc && strcmp(plugin_desc, "Shockwave Flash 9.0 d55") == 0) { + npw_printf("WARNING: Flash Player 9 beta 1 detected and rejected\n"); + return 1; + } + } + return 0; +} + +static int do_test(void) +{ + if (g_NP_GetMIMEDescription == NULL) + return 1; + if (g_NP_Initialize == NULL) + return 2; + if (g_NP_Shutdown == NULL) + return 3; + if (is_flash_player9_beta1()) + return 4; + return 0; +} + +static int do_info(void) +{ + if (do_test() != 0) + return 1; + if (g_NP_GetValue == NULL) + printf("0\n\n0\n\n"); + else { + const char *plugin_name = NULL; + if (g_NP_GetValue(NULL, NPPVpluginNameString, &plugin_name) == NPERR_NO_ERROR && plugin_name) + printf("%zd\n%s\n", strlen(plugin_name) + 1, plugin_name); + else + printf("0\n\n"); + const char *plugin_desc = NULL; + if (g_NP_GetValue(NULL, NPPVpluginDescriptionString, &plugin_desc) == NPERR_NO_ERROR && plugin_desc) + printf("%zd\n%s\n", strlen(plugin_desc) + 1, plugin_desc); + else + printf("0\n\n"); + } + const char *mime_info = g_NP_GetMIMEDescription(); + if (mime_info) + printf("%zd\n%s\n", strlen(mime_info) + 1, mime_info); + else + printf("0\n\n"); + return 0; +} + +static int do_help(const char *prog) +{ + printf("%s, NPAPI plugin viewer. Version %s\n", NPW_VIEWER, NPW_VERSION); + printf("\n"); + printf("usage: %s [GTK flags] [flags]\n", prog); + printf(" -h --help print this message\n"); + printf(" -t --test check plugin is compatible\n"); + printf(" -i --info print plugin information\n"); + printf(" -p --plugin set plugin path\n"); + printf(" -c --connection set connection path\n"); + return 0; +} + +int main(int argc, char **argv) +{ + const char *plugin_path = NULL; + const char *connection_path = NULL; + + enum { + CMD_RUN, + CMD_TEST, + CMD_INFO, + CMD_HELP + }; + int cmd = CMD_RUN; + + // Parse command line arguments + for (int i = 0; i < argc; i++) { + const char *arg = argv[i]; + if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) { + argv[i] = NULL; + cmd = CMD_HELP; + } + else if (strcmp(arg, "-t") == 0 || strcmp(arg, "--test") == 0) { + argv[i] = NULL; + cmd = CMD_TEST; + } + else if (strcmp(arg, "-i") == 0 || strcmp(arg, "--info") == 0) { + argv[i] = NULL; + cmd = CMD_INFO; + } + else if (strcmp(arg, "-p") == 0 || strcmp(arg, "--plugin") == 0) { + argv[i] = NULL; + if (++i < argc) { + plugin_path = argv[i]; + argv[i] = NULL; + } + } + else if (strcmp(arg, "-c") == 0 || strcmp(arg, "--connection") == 0) { + argv[i] = NULL; + if (++i < argc) { + connection_path = argv[i]; + argv[i] = NULL; + } + } + } + + // Remove processed arguments + for (int i = 1, j = 1, n = argc; i < n; i++) { + if (argv[i]) + argv[j++] = argv[i]; + else + --argc; + } + + // Open plug-in and get exported lib functions + void *handle = NULL; + if (plugin_path == NULL) + cmd = CMD_HELP; + else { + const char *error; + D(bug(" %s\n", plugin_path)); + if ((handle = dlopen(plugin_path, RTLD_LAZY)) == NULL) { + npw_printf("ERROR: %s\n", dlerror()); + return 1; + } + dlerror(); + g_NP_GetMIMEDescription = (NP_GetMIMEDescriptionUPP)dlsym(handle, "NP_GetMIMEDescription"); + if ((error = dlerror()) != NULL) { + npw_printf("ERROR: %s\n", error); + return 1; + } + g_NP_Initialize = (NP_InitializeUPP)dlsym(handle, "NP_Initialize"); + if ((error = dlerror()) != NULL) { + npw_printf("ERROR: %s\n", error); + return 1; + } + g_NP_Shutdown = (NP_ShutdownUPP)dlsym(handle, "NP_Shutdown"); + if ((error = dlerror()) != NULL) { + npw_printf("ERROR: %s\n", error); + return 1; + } + g_NP_GetValue = (NP_GetValueUPP)dlsym(handle, "NP_GetValue"); + } + + int ret = 1; + switch (cmd) { + case CMD_RUN: + ret = do_main(argc, argv, connection_path); + break; + case CMD_TEST: + ret = do_test(); + break; + case CMD_INFO: + ret = do_info(); + break; + case CMD_HELP: + ret = do_help(argv[0]); + break; + } + + if (handle) + dlclose(handle); + return ret; +} diff --git a/src/npw-viewer.map b/src/npw-viewer.map new file mode 100644 index 0000000..6c0f488 --- /dev/null +++ b/src/npw-viewer.map @@ -0,0 +1,10 @@ +{ + global: + __builtin_vec_new; + __builtin_vec_delete; + __builtin_new; + __builtin_delete; + __pure_virtual; + local: + *; +}; diff --git a/src/npw-viewer.sh b/src/npw-viewer.sh new file mode 100644 index 0000000..d1e645e --- /dev/null +++ b/src/npw-viewer.sh @@ -0,0 +1,110 @@ +#!/bin/sh +# +# nsplugin viewer wrapper script (C) 2005-2006 Gwenole Beauchesne +# +OS="`uname -s`" +ARCH="`uname -m`" +NPW_LIBDIR="%NPW_LIBDIR%" + +if test -z "$TARGET_OS"; then + echo "*** NSPlugin Viewer *** error, TARGET_OS not initialized" + exit 1 +fi + +if test -z "$TARGET_ARCH"; then + echo "*** NSPlugin Viewer *** error, TARGET_ARCH not initialized" + exit 1 +fi + +NPW_VIEWER_DIR=$NPW_LIBDIR/$TARGET_ARCH/$TARGET_OS + +case $ARCH in +i?86) + ARCH=i386 + ;; +amd64) + ARCH=x86_64 + ;; +esac + +if test -n "$LD_LIBRARY_PATH"; then + LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$NPW_VIEWER_DIR +else + LD_LIBRARY_PATH=$NPW_VIEWER_DIR +fi +export LD_LIBRARY_PATH + +if test "$ARCH" != "$TARGET_ARCH"; then + case $TARGET_ARCH in + i386) + if test "$ARCH" = "x86_64"; then + case "$OS" in + Linux) + LOADER=`which linux32` + ;; + FreeBSD | NetBSD) + # XXX check that COMPAT_LINUX is enabled or fail otherwise + LOADER="none" + ;; + esac + elif test "$ARCH" = "ia64"; then + # XXX check that IA-32 EL or HW emulator is enabled or fail + # otherwise (use QEMU?) + LOADER="none" + else + LOADER=`which qemu-i386` + fi + ;; + ppc) + if test "$ARCH" = "ppc64"; then + case "$OS" in + Linux) + LOADER=`which linux32` + ;; + esac + else + LOADER=`which qemu-ppc` + fi + ;; + esac + if test "$LOADER" = "none"; then + unset LOADER + elif test -z "$LOADER" -o ! -x "$LOADER"; then + echo "*** NSPlugin Viewer *** preloader not found" + exit 1 + fi +fi + +# XXX qemu doesn't support NPTL +case " $LOADER " in +*qemu*) + if test -f "/etc/mandrake-release"; then + # glibc --enable-kernel (as of 2.3.4-8mdk) + case $ARCH in + ppc64) KERNEL_VERSION=2.4.21;; + ia64) KERNEL_VERSION=2.4.0;; + x86_64) KERNEL_VERSION=2.4.0;; + *) KERNEL_VERSION=2.2.5;; + esac + else + # this generally brings floating-stacks + KERNEL_VERSION=2.4.1 + fi + ;; +*none*) + unset LOADER + ;; +esac +if test -n "$KERNEL_VERSION"; then + export LD_ASSUME_KERNEL=$KERNEL_VERSION +fi + +# Expand PATH for RealPlayer package on NetBSD (realplay) +if test "$OS" = "NetBSD"; then + REALPLAYER_HOME="/usr/pkg/lib/RealPlayer" + if test -x "$REALPLAYER_HOME/realplay"; then + export PATH=$PATH:$REALPLAYER_HOME + fi +fi + +exec $LOADER $NPW_VIEWER_DIR/npviewer.bin ${1+"$@"} diff --git a/src/npw-wrapper.c b/src/npw-wrapper.c new file mode 100644 index 0000000..33a3b28 --- /dev/null +++ b/src/npw-wrapper.c @@ -0,0 +1,1977 @@ +/* + * npw-wrapper.c - Host Mozilla plugin (loads the actual viewer) + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "sysdeps.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include "rpc.h" +#include "npw-rpc.h" +#include "utils.h" + +#define XP_UNIX 1 +#define MOZ_X11 1 +#include +#include +#include "npruntime-impl.h" + +#define DEBUG 1 +#include "debug.h" + + +// XXX unimplemented functions +#define UNIMPLEMENTED() npw_printf("WARNING: Unimplemented function %s at line %d\n", __func__, __LINE__) + +// Globally exported plugin ident, used by the "npconfig" tool +const NPW_PluginInfo NPW_Plugin = { + NPW_PLUGIN_IDENT, + NPW_DEFAULT_PLUGIN_PATH, + 0, + HOST_OS, + HOST_ARCH +}; + +// Path to plugin to use +static const char *plugin_path = NPW_Plugin.path; + +// Netscape exported functions +static NPNetscapeFuncs mozilla_funcs; + +// Wrapper plugin data +typedef struct { + int initialized; + int viewer_pid; + int is_wrapper; + char *name; + char *description; + char *formats; +} Plugin; + +static Plugin g_plugin = { 0, -1, 0, NULL, NULL, NULL }; + +// Instance state information about the plugin +typedef struct _PluginInstance { + NPP instance; + uint32_t instance_id; +} PluginInstance; + +// Plugin side data for an NPStream instance +typedef struct _StreamInstance { + NPStream *stream; + uint32_t stream_id; +} StreamInstance; + +// Prototypes +static void plugin_init(int is_NP_Initialize); +static void plugin_exit(void); +static pthread_mutex_t plugin_init_lock = PTHREAD_MUTEX_INITIALIZER; + +// Helpers +#ifndef min +#define min(x, y) ((x) < (y) ? (x) : (y)) +#endif +#ifndef max +#define max(x, y) ((x) > (y) ? (x) : (y)) +#endif + + +/* ====================================================================== */ +/* === RPC communication === */ +/* ====================================================================== */ + +static GSource *g_rpc_source; +static GPollFD g_rpc_poll_fd; +static XtInputId xt_rpc_source_id; +rpc_connection_t *g_rpc_connection attribute_hidden = NULL; + +static gboolean rpc_event_prepare(GSource *source, gint *timeout) +{ + *timeout = -1; + return FALSE; +} + +static gboolean rpc_event_check(GSource *source) +{ + return rpc_wait_dispatch(g_rpc_connection, 0) > 0; +} + +static gboolean rpc_event_dispatch(GSource *source, GSourceFunc callback, gpointer user_data) +{ + callback(user_data); + return TRUE; +} + + +/* ====================================================================== */ +/* === Browser side plug-in API === */ +/* ====================================================================== */ + +// NPN_UserAgent +static int handle_NPN_UserAgent(rpc_connection_t *connection) +{ + D(bug("handle_NPN_UserAgent\n")); + + const char *user_agent = mozilla_funcs.uagent ? mozilla_funcs.uagent(NULL) : NULL; + return rpc_method_send_reply(connection, RPC_TYPE_STRING, user_agent, RPC_TYPE_INVALID); +} + +// NPN_Status +static int handle_NPN_Status(rpc_connection_t *connection) +{ + D(bug("handle_NPN_Status\n")); + + NPP instance; + char *message; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_STRING, &message, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_Status() get args", error); + return error; + } + + D(bug(" instance=%p, message='%s'\n", instance, message)); + + if (mozilla_funcs.status) + mozilla_funcs.status(instance, message); + if (message) + free(message); + return RPC_ERROR_NO_ERROR; +} + +// NPN_GetValue +static NPError +g_NPN_GetValue(NPP instance, NPNVariable variable, void *value) +{ + if (mozilla_funcs.getvalue == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + D(bug("NPN_GetValue instance=%p, variable=%d\n", instance, variable)); + NPError ret = mozilla_funcs.getvalue(instance, variable, value); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +static int handle_NPN_GetValue(rpc_connection_t *connection) +{ + D(bug("handle_NPN_GetValue\n")); + + NPP instance; + uint32_t variable; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_UINT32, &variable, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetValue() get args", error); + return error; + } + + NPError ret = NPERR_GENERIC_ERROR; + switch (rpc_type_of_NPNVariable(variable)) { + case RPC_TYPE_BOOLEAN: + { + PRBool b = PR_FALSE; + ret = g_NPN_GetValue(instance, variable, (void *)&b); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_BOOLEAN, b, RPC_TYPE_INVALID); + } + case RPC_TYPE_NP_OBJECT: + { + NPObject *npobj = NULL; + ret = g_NPN_GetValue(instance, variable, (void *)&npobj); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_INVALID); + } + } + + abort(); +} + +// NPN_GetURL +static NPError g_NPN_GetURL(NPP instance, const char *url, const char *target) +{ + if (mozilla_funcs.geturl == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + D(bug("NPN_GetURL instance=%p, url='%s', target='%s'\n", instance, url, target)); + NPError ret = CallNPN_GetURLProc(mozilla_funcs.geturl, instance, url, target); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +static int handle_NPN_GetURL(rpc_connection_t *connection) +{ + D(bug("handle_NPN_GetURL\n")); + + NPP instance; + char *url, *target; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_STRING, &url, + RPC_TYPE_STRING, &target, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetURL() get args", error); + return error; + } + + NPError ret = g_NPN_GetURL(instance, url, target); + + if (url) + free(url); + if (target) + free(target); + + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); +} + +// NPN_GetURLNotify +static NPError g_NPN_GetURLNotify(NPP instance, const char *url, const char *target, void *notifyData) +{ + if (mozilla_funcs.geturlnotify == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + D(bug("NPN_GetURLNotify instance=%p, url='%s', target='%s', notifyData=%p\n", instance, url, target, notifyData)); + NPError ret = CallNPN_GetURLNotifyProc(mozilla_funcs.geturlnotify, instance, url, target, notifyData); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +static int handle_NPN_GetURLNotify(rpc_connection_t *connection) +{ + D(bug("handle_NPN_GetURLNotify\n")); + + NPP instance; + char *url, *target; + void *notifyData; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_STRING, &url, + RPC_TYPE_STRING, &target, + RPC_TYPE_NP_NOTIFY_DATA, ¬ifyData, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetURLNotify() get args", error); + return error; + } + + NPError ret = g_NPN_GetURLNotify(instance, url, target, notifyData); + + if (url) + free(url); + if (target) + free(target); + + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); +} + +// NPN_PostURL +static NPError g_NPN_PostURL(NPP instance, const char *url, const char *target, uint32_t len, const char *buf, NPBool file) +{ + if (mozilla_funcs.posturl == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + D(bug("NPN_PostURL instance=%p, url='%s', target='%s', file='%s'\n", instance, url, target, file ? buf : "")); + NPError ret = CallNPN_PostURLProc(mozilla_funcs.posturl, instance, url, target, len, buf, file); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +static int handle_NPN_PostURL(rpc_connection_t *connection) +{ + D(bug("handle_NPN_PostURL\n")); + + NPP instance; + char *url, *target; + uint32_t len; + char *buf; + uint32_t file; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_STRING, &url, + RPC_TYPE_STRING, &target, + RPC_TYPE_ARRAY, RPC_TYPE_CHAR, &len, &buf, + RPC_TYPE_BOOLEAN, &file, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_PostURL() get args", error); + return error; + } + + NPError ret = g_NPN_PostURL(instance, url, target, len, buf, file); + + if (url) + free(url); + if (target) + free(target); + if (buf) + free(buf); + + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); +} + +// NPN_PostURLNotify +static NPError g_NPN_PostURLNotify(NPP instance, const char *url, const char *target, uint32_t len, const char *buf, NPBool file, void *notifyData) +{ + if (mozilla_funcs.posturlnotify == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + D(bug("NPN_PostURLNotify instance=%p, url='%s', target='%s', file='%s', notifyData=%p\n", instance, url, target, file ? buf : "", notifyData)); + NPError ret = CallNPN_PostURLNotifyProc(mozilla_funcs.posturlnotify, instance, url, target, len, buf, file, notifyData); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +static int handle_NPN_PostURLNotify(rpc_connection_t *connection) +{ + D(bug("handle_NPN_PostURLNotify\n")); + + NPP instance; + char *url, *target; + int32_t len; + char *buf; + uint32_t file; + void *notifyData; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_STRING, &url, + RPC_TYPE_STRING, &target, + RPC_TYPE_ARRAY, RPC_TYPE_CHAR, &len, &buf, + RPC_TYPE_BOOLEAN, &file, + RPC_TYPE_NP_NOTIFY_DATA, ¬ifyData, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_PostURLNotify() get args", error); + return error; + } + + NPError ret = g_NPN_PostURLNotify(instance, url, target, len, buf, file, notifyData); + + if (url) + free(url); + if (target) + free(target); + if (buf) + free(buf); + + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); +} + +// NPN_PrintData +static int handle_NPN_PrintData(rpc_connection_t *connection) +{ + D(bug("handle_NPN_PrintData\n")); + + uint32_t platform_print_id; + NPPrintData printData; + int error = rpc_method_get_args(connection, + RPC_TYPE_UINT32, &platform_print_id, + RPC_TYPE_NP_PRINT_DATA, &printData, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_PrintData() get args", error); + return error; + } + + NPPrintCallbackStruct *platformPrint = id_lookup(platform_print_id); + if (platformPrint == NULL) + return RPC_ERROR_GENERIC; + D(bug(" platformPrint=%p, printData.size=%d\n", platformPrint, printData.size)); + if (fwrite(printData.data, printData.size, 1, platformPrint->fp) != 1) + return RPC_ERROR_ERRNO_SET; + + return RPC_ERROR_NO_ERROR; +} + +// NPN_RequestRead +static NPError g_NPN_RequestRead(NPStream *stream, NPByteRange *rangeList) +{ + if (mozilla_funcs.requestread == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + D(bug("NPN_RequestRead stream=%p, rangeList=%p\n", stream, rangeList)); + NPError ret = CallNPN_RequestReadProc(mozilla_funcs.requestread, stream, rangeList); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +static int handle_NPN_RequestRead(rpc_connection_t *connection) +{ + D(bug("handle_NPN_RequestRead\n")); + + NPStream *stream; + NPByteRange *rangeList; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_STREAM, &stream, + RPC_TYPE_NP_BYTE_RANGE, &rangeList, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_RequestRead() get args", error); + return error; + } + + NPError ret = g_NPN_RequestRead(stream, rangeList); + + while (rangeList) { + NPByteRange *p = rangeList; + rangeList = rangeList->next; + free(p); + } + + return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); +} + +// NPN_CreateObject +static int handle_NPN_CreateObject(rpc_connection_t *connection) +{ + NPP instance; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_CreateObject() get args", error); + return error; + } + + NPObject *npobj = mozilla_funcs.createobject(instance, &npclass_bridge); + + uint32_t npobj_id = 0; + if (npobj) { + NPObjectInfo *npobj_info = npobject_info_new(npobj); + if (npobj_info) { + npobj_id = npobj_info->npobj_id; + npobject_associate(npobj, npobj_info); + } + } + + return rpc_method_send_reply(connection, RPC_TYPE_UINT32, npobj_id, RPC_TYPE_INVALID); +} + +// NPN_RetainObject +static int handle_NPN_RetainObject(rpc_connection_t *connection) +{ + NPObject *npobj; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_RetainObject() get args", error); + return error; + } + + if (npobj == NULL) // this shall not happen, let it crash + npw_printf("ERROR: NPN_RetainObject got a null NPObject\n"); + + mozilla_funcs.retainobject(npobj); + + return rpc_method_send_reply(connection, RPC_TYPE_UINT32, npobj->referenceCount, RPC_TYPE_INVALID); +} + +// NPN_ReleaseObject +static int handle_NPN_ReleaseObject(rpc_connection_t *connection) +{ + NPObject *npobj; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_ReleaseObject() get args", error); + return error; + } + + if (npobj == NULL) // this shall not happen, let it crash + npw_printf("ERROR: NPN_ReleaseObject got a null NPObject\n"); + + mozilla_funcs.releaseobject(npobj); + + return rpc_method_send_reply(connection, RPC_TYPE_UINT32, npobj->referenceCount, RPC_TYPE_INVALID); +} + +// NPN_Invoke +static int handle_NPN_Invoke(rpc_connection_t *connection) +{ + NPP instance; + NPObject *npobj; + NPIdentifier methodName; + NPVariant *args; + uint32_t argCount; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_NP_IDENTIFIER, &methodName, + RPC_TYPE_ARRAY, RPC_TYPE_NP_VARIANT, &argCount, &args, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_Invoke() get args", error); + return error; + } + + NPVariant result; + VOID_TO_NPVARIANT(result); + bool ret = mozilla_funcs.invoke(instance, npobj, methodName, args, argCount, &result); + + if (args) + free(args); + + return rpc_method_send_reply(connection, + RPC_TYPE_UINT32, ret, + RPC_TYPE_NP_VARIANT, &result, + RPC_TYPE_INVALID); +} + +// NPN_InvokeDefault +static int handle_NPN_InvokeDefault(rpc_connection_t *connection) +{ + NPP instance; + NPObject *npobj; + NPVariant *args; + uint32_t argCount; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_ARRAY, RPC_TYPE_NP_VARIANT, &argCount, &args, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_Invoke() get args", error); + return error; + } + + NPVariant result; + VOID_TO_NPVARIANT(result); + bool ret = mozilla_funcs.invokeDefault(instance, npobj, args, argCount, &result); + + if (args) + free(args); + + return rpc_method_send_reply(connection, + RPC_TYPE_UINT32, ret, + RPC_TYPE_NP_VARIANT, &result, + RPC_TYPE_INVALID); +} + +// NPN_Evaluate +static int handle_NPN_Evaluate(rpc_connection_t *connection) +{ + NPP instance; + NPObject *npobj; + NPString script; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_NP_STRING, &script, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_Evaluate() get args", error); + return error; + } + + NPVariant result; + VOID_TO_NPVARIANT(result); + bool ret = mozilla_funcs.evaluate(instance, npobj, &script, &result); + + if (script.utf8characters) + free((void *)script.utf8characters); + + return rpc_method_send_reply(connection, + RPC_TYPE_UINT32, ret, + RPC_TYPE_NP_VARIANT, &result, + RPC_TYPE_INVALID); +} + +// NPN_GetProperty +static int handle_NPN_GetProperty(rpc_connection_t *connection) +{ + NPP instance; + NPObject *npobj; + NPIdentifier propertyName; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_NP_IDENTIFIER, &propertyName, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetProperty() get args", error); + return error; + } + + NPVariant result; + VOID_TO_NPVARIANT(result); + bool ret = mozilla_funcs.getproperty(instance, npobj, propertyName, &result); + + return rpc_method_send_reply(connection, + RPC_TYPE_UINT32, ret, + RPC_TYPE_NP_VARIANT, &result, + RPC_TYPE_INVALID); +} + +// NPN_SetProperty +static int handle_NPN_SetProperty(rpc_connection_t *connection) +{ + NPP instance; + NPObject *npobj; + NPIdentifier propertyName; + NPVariant value; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_NP_IDENTIFIER, &propertyName, + RPC_TYPE_NP_VARIANT, &value, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_SetProperty() get args", error); + return error; + } + + bool ret = mozilla_funcs.setproperty(instance, npobj, propertyName, &value); + + return rpc_method_send_reply(connection, + RPC_TYPE_UINT32, ret, + RPC_TYPE_INVALID); +} + +// NPN_RemoveProperty +static int handle_NPN_RemoveProperty(rpc_connection_t *connection) +{ + NPP instance; + NPObject *npobj; + NPIdentifier propertyName; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_NP_IDENTIFIER, &propertyName, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_RemoveProperty() get args", error); + return error; + } + + bool ret = mozilla_funcs.removeproperty(instance, npobj, propertyName); + + return rpc_method_send_reply(connection, + RPC_TYPE_UINT32, ret, + RPC_TYPE_INVALID); +} + +// NPN_HasProperty +static int handle_NPN_HasProperty(rpc_connection_t *connection) +{ + NPP instance; + NPObject *npobj; + NPIdentifier propertyName; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_NP_IDENTIFIER, &propertyName, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_HasProperty() get args", error); + return error; + } + + bool ret = mozilla_funcs.hasproperty(instance, npobj, propertyName); + + return rpc_method_send_reply(connection, + RPC_TYPE_UINT32, ret, + RPC_TYPE_INVALID); +} + +// NPN_HasMethod +static int handle_NPN_HasMethod(rpc_connection_t *connection) +{ + NPP instance; + NPObject *npobj; + NPIdentifier methodName; + int error = rpc_method_get_args(connection, + RPC_TYPE_NPP, &instance, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_NP_IDENTIFIER, &methodName, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_HasMethod() get args", error); + return error; + } + + bool ret = mozilla_funcs.hasmethod(instance, npobj, methodName); + + return rpc_method_send_reply(connection, + RPC_TYPE_UINT32, ret, + RPC_TYPE_INVALID); +} + +// NPN_SetException +static int handle_NPN_SetException(rpc_connection_t *connection) +{ + NPObject *npobj; + NPUTF8 *message; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_OBJECT, &npobj, + RPC_TYPE_STRING, &message, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_SetException() get args", error); + return error; + } + + mozilla_funcs.setexception(npobj, message); + + // XXX memory leak (message) + + return RPC_ERROR_NO_ERROR; +} + +// NPN_GetStringIdentifier +static int handle_NPN_GetStringIdentifier(rpc_connection_t *connection) +{ + char *name; + int error = rpc_method_get_args(connection, + RPC_TYPE_STRING, &name, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetStringIdentifier() get args", error); + return error; + } + + NPIdentifier ident = mozilla_funcs.getstringidentifier(name); + + if (name) + free(name); + + return rpc_method_send_reply(connection, + RPC_TYPE_NP_IDENTIFIER, ident, + RPC_TYPE_INVALID); +} + +// NPN_GetStringIdentifiers +static int handle_NPN_GetStringIdentifiers(rpc_connection_t *connection) +{ + NPUTF8 **names; + uint32_t nameCount; + int error = rpc_method_get_args(connection, + RPC_TYPE_ARRAY, RPC_TYPE_STRING, &nameCount, &names, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetStringIdentifiers() get args", error); + return error; + } + + NPIdentifier *idents = malloc(nameCount * sizeof(idents[0])); + if (idents) + mozilla_funcs.getstringidentifiers((const NPUTF8 **)names, nameCount, idents); + + if (names) { + for (int i = 0; i < nameCount; i++) + free(names[i]); + free(names); + } + + return rpc_method_send_reply(connection, + RPC_TYPE_ARRAY, RPC_TYPE_NP_IDENTIFIER, nameCount, idents, + RPC_TYPE_INVALID); +} + +// NPN_GetIntIdentifier +static int handle_NPN_GetIntIdentifier(rpc_connection_t *connection) +{ + int32_t intid; + int error = rpc_method_get_args(connection, + RPC_TYPE_INT32, &intid, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_GetIntIdentifier() get args", error); + return error; + } + + NPIdentifier ident = mozilla_funcs.getintidentifier(intid); + + return rpc_method_send_reply(connection, + RPC_TYPE_NP_IDENTIFIER, ident, + RPC_TYPE_INVALID); +} + +// NPN_IdentifierIsString +static int handle_NPN_IdentifierIsString(rpc_connection_t *connection) +{ + NPIdentifier ident; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_IDENTIFIER, &ident, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_IdentifierIsString() get args", error); + return error; + } + + bool ret = mozilla_funcs.identifierisstring(ident); + + return rpc_method_send_reply(connection, + RPC_TYPE_UINT32, ret, + RPC_TYPE_INVALID); +} + +// NPN_UTF8FromIdentifier +static int handle_NPN_UTF8FromIdentifier(rpc_connection_t *connection) +{ + NPIdentifier ident; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_IDENTIFIER, &ident, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_UTF8FromIdentifier() get args", error); + return error; + } + + NPUTF8 *str = mozilla_funcs.utf8fromidentifier(ident); + + error = rpc_method_send_reply(connection, + RPC_TYPE_STRING, str, + RPC_TYPE_INVALID); + + // the caller is responsible for deallocating the memory used by the string + mozilla_funcs.memfree(str); + + return error; +} + +// NPN_IntFromIdentifier +static int handle_NPN_IntFromIdentifier(rpc_connection_t *connection) +{ + NPIdentifier ident; + int error = rpc_method_get_args(connection, + RPC_TYPE_NP_IDENTIFIER, &ident, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPN_IntFromIdentifier() get args", error); + return error; + } + + int32_t ret = mozilla_funcs.intfromidentifier(ident); + + return rpc_method_send_reply(connection, + RPC_TYPE_INT32, ret, + RPC_TYPE_INVALID); +} + + +/* ====================================================================== */ +/* === Plug-in side data === */ +/* ====================================================================== */ + +// Creates a new instance of a plug-in +static NPError +invoke_NPP_New(NPMIMEType mime_type, NPP instance, + uint16_t mode, int16_t argc, char *argn[], char *argv[], + NPSavedData *saved) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPP_NEW, + RPC_TYPE_UINT32, ((PluginInstance *)instance->pdata)->instance_id, + RPC_TYPE_STRING, mime_type, + RPC_TYPE_INT32, (int32_t)mode, + RPC_TYPE_ARRAY, RPC_TYPE_STRING, (uint32_t)argc, argn, + RPC_TYPE_ARRAY, RPC_TYPE_STRING, (uint32_t)argc, argv, + RPC_TYPE_NP_SAVED_DATA, saved, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_New() invoke", error); + return NPERR_GENERIC_ERROR; + } + + int32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_INT32, &ret, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_New() wait for reply", error); + return NPERR_GENERIC_ERROR; + } + + return ret; +} + +static NPError +g_NPP_New(NPMIMEType mime_type, NPP instance, + uint16_t mode, int16_t argc, char *argn[], char *argv[], + NPSavedData *saved) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + PluginInstance *plugin = malloc(sizeof(*plugin)); + if (plugin == NULL) + return NPERR_OUT_OF_MEMORY_ERROR; + memset(plugin, 0, sizeof(*plugin)); + plugin->instance = instance; + plugin->instance_id = id_create(plugin); + instance->pdata = plugin; + + D(bug("NPP_New instance=%p\n", instance)); + NPError ret = invoke_NPP_New(mime_type, instance, mode, argc, argn, argv, saved); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + + if (saved) { + if (saved->buf) + free(saved->buf); + free(saved); + } + + return ret; +} + +// Deletes a specific instance of a plug-in +static NPError +invoke_NPP_Destroy(NPP instance, NPSavedData **save) +{ + // XXX handle save area (transfer raw bytes but keep size information somewhere) + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPP_DESTROY, + RPC_TYPE_NPP, instance, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_Destroy() invoke", error); + return NPERR_GENERIC_ERROR; + } + + int32_t ret; + NPSavedData *save_area = NULL; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_INT32, &ret, + RPC_TYPE_NP_SAVED_DATA, &save_area, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_Destroy() wait for reply", error); + return NPERR_GENERIC_ERROR; + } + + if (save) + *save = save_area; + + return ret; +} + +static NPError +g_NPP_Destroy(NPP instance, NPSavedData **save) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + D(bug("NPP_Destroy instance=%p\n", instance)); + NPError ret = invoke_NPP_Destroy(instance, save); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + + PluginInstance *plugin = instance->pdata; + if (plugin) { + id_remove(plugin->instance_id); + free(plugin); + instance->pdata = NULL; + } + + return ret; +} + +// Tells the plug-in when a window is created, moved, sized, or destroyed +static NPError +invoke_NPP_SetWindow(NPP instance, NPWindow *window) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPP_SET_WINDOW, + RPC_TYPE_NPP, instance, + RPC_TYPE_NP_WINDOW, window, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_SetWindow() invoke", error); + return NPERR_GENERIC_ERROR; + } + + int32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_INT32, &ret, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_SetWindow() wait for reply", error); + return NPERR_GENERIC_ERROR; + } + + return ret; +} + +static NPError +g_NPP_SetWindow(NPP instance, NPWindow *window) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + D(bug("NPP_SetWindow instance=%p\n", instance)); + NPError ret = invoke_NPP_SetWindow(instance, window); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +// Allows the browser to query the plug-in for information +static NPError +invoke_NPP_GetValue(NPP instance, NPPVariable variable, void *value) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPP_GET_VALUE, + RPC_TYPE_NPP, instance, + RPC_TYPE_INT32, variable, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_GetValue() invoke", error); + return NPERR_GENERIC_ERROR; + } + + int32_t ret; + switch (rpc_type_of_NPPVariable(variable)) { + case RPC_TYPE_STRING: + { + char *str = NULL; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_STRING, &str, RPC_TYPE_INVALID); + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_GetValue() wait for reply", error); + ret = NPERR_GENERIC_ERROR; + } + D(bug(" value: %s\n", str)); + *((char **)value) = str; // XXX memory leak + break; + } + case RPC_TYPE_INT32: + { + int32_t n = 0; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INT32, &n, RPC_TYPE_INVALID); + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_GetValue() wait for reply", error); + ret = NPERR_GENERIC_ERROR; + } + D(bug(" value: %d\n", n)); + *((int *)value) = n; + break; + } + case RPC_TYPE_BOOLEAN: + { + uint32_t b = 0; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_BOOLEAN, &b, RPC_TYPE_INVALID); + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_GetValue() wait for reply", error); + ret = NPERR_GENERIC_ERROR; + } + D(bug(" value: %s\n", b ? "true" : "false")); + *((PRBool *)value) = b ? PR_TRUE : PR_FALSE; + break; + } + case RPC_TYPE_NP_OBJECT: + { + NPObject *npobj = NULL; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_NP_OBJECT, &npobj, RPC_TYPE_INVALID); + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_GetValue() wait for reply", error); + ret = NPERR_GENERIC_ERROR; + } + D(bug(" value: %p\n", npobj)); + *((NPObject **)value) = npobj; + break; + } + } + + return ret; +} + +static NPError +g_NPP_GetValue(NPP instance, NPPVariable variable, void *value) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + switch (rpc_type_of_NPPVariable(variable)) { + case RPC_TYPE_STRING: + case RPC_TYPE_INT32: + case RPC_TYPE_BOOLEAN: + case RPC_TYPE_NP_OBJECT: + break; + default: + npw_printf("WARNING: unhandled variable %d in NPP_GetValue()\n", variable); + return NPERR_INVALID_PARAM; + } + + D(bug("NPP_GetValue instance=%p, variable=%d\n", instance, variable)); + NPError ret = invoke_NPP_GetValue(instance, variable, value); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +// Sets information about the plug-in +static NPError +invoke_NPP_SetValue(NPP instance, NPPVariable variable, void *value) +{ + UNIMPLEMENTED(); + + return NPERR_GENERIC_ERROR; +} + +static NPError +g_NPP_SetValue(NPP instance, NPPVariable variable, void *value) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + D(bug("NPP_SetValue instance=%p, variable=%d\n", instance, variable)); + NPError ret = invoke_NPP_SetValue(instance, variable, value); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return NPERR_GENERIC_ERROR; +} + +// Notifies the instance of the completion of a URL request +static void +invoke_NPP_URLNotify(NPP instance, const char *url, NPReason reason, void *notifyData) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPP_URL_NOTIFY, + RPC_TYPE_NPP, instance, + RPC_TYPE_STRING, url, + RPC_TYPE_INT32, reason, + RPC_TYPE_NP_NOTIFY_DATA, notifyData, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_URLNotify() invoke", error); + return; + } + + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) + npw_perror("NPP_URLNotify() wait for reply", error); +} + +static void +g_NPP_URLNotify(NPP instance, const char *url, NPReason reason, void *notifyData) +{ + if (instance == NULL) + return; + + D(bug("NPP_URLNotify instance=%p, url='%s', reason=%d, notifyData=%p\n", instance, url, reason, notifyData)); + invoke_NPP_URLNotify(instance, url, reason, notifyData); + D(bug(" done\n")); +} + +// Notifies a plug-in instance of a new data stream +static NPError +invoke_NPP_NewStream(NPP instance, NPMIMEType type, NPStream *stream, NPBool seekable, uint16 *stype) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPP_NEW_STREAM, + RPC_TYPE_NPP, instance, + RPC_TYPE_STRING, type, + RPC_TYPE_UINT32, ((StreamInstance *)stream->pdata)->stream_id, + RPC_TYPE_STRING, stream->url, + RPC_TYPE_UINT32, stream->end, + RPC_TYPE_UINT32, stream->lastmodified, + RPC_TYPE_NP_NOTIFY_DATA, stream->notifyData, + RPC_TYPE_BOOLEAN, seekable, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_NewStream() invoke", error); + return NPERR_GENERIC_ERROR; + } + + int32_t ret; + uint32_t r_stype; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_INT32, &ret, + RPC_TYPE_UINT32, &r_stype, + RPC_TYPE_NP_NOTIFY_DATA, &stream->notifyData, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_NewStream() wait for reply", error); + return NPERR_GENERIC_ERROR; + } + + *stype = r_stype; + return ret; +} + +static NPError +g_NPP_NewStream(NPP instance, NPMIMEType type, NPStream *stream, NPBool seekable, uint16 *stype) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + StreamInstance *stream_pdata = malloc(sizeof(*stream_pdata)); + if (stream_pdata == NULL) + return NPERR_OUT_OF_MEMORY_ERROR; + memset(stream_pdata, 0, sizeof(*stream_pdata)); + stream_pdata->stream = stream; + stream_pdata->stream_id = id_create(stream_pdata); + stream->pdata = stream_pdata; + + D(bug("NPP_NewStream instance=%p\n", instance)); + NPError ret = invoke_NPP_NewStream(instance, type, stream, seekable, stype); + D(bug(" return: %d [%s], stype=%s\n", ret, string_of_NPError(ret), string_of_NPStreamType(*stype))); + return ret; +} + +// Tells the plug-in that a stream is about to be closed or destroyed +static NPError +invoke_NPP_DestroyStream(NPP instance, NPStream *stream, NPReason reason) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPP_DESTROY_STREAM, + RPC_TYPE_NPP, instance, + RPC_TYPE_NP_STREAM, stream, + RPC_TYPE_INT32, reason, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_DestroyStream() invoke", error); + return NPERR_GENERIC_ERROR; + } + + int32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_INT32, &ret, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_DestroyStream() wait for reply", error); + return NPERR_GENERIC_ERROR; + } + + return ret; +} + +static NPError +g_NPP_DestroyStream(NPP instance, NPStream *stream, NPReason reason) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + D(bug("NPP_DestroyStream instance=%p\n", instance)); + NPError ret = invoke_NPP_DestroyStream(instance, stream, reason); + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + + StreamInstance *stream_pdata = stream->pdata; + if (stream_pdata) { + id_remove(stream_pdata->stream_id); + free(stream->pdata); + stream->pdata = NULL; + } + + return ret; +} + +// Provides a local file name for the data from a stream +static void +invoke_NPP_StreamAsFile(NPP instance, NPStream *stream, const char *fname) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPP_STREAM_AS_FILE, + RPC_TYPE_NPP, instance, + RPC_TYPE_NP_STREAM, stream, + RPC_TYPE_STRING, fname, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_StreamAsFile() invoke", error); + return; + } + + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) + npw_perror("NPP_StreamAsFile() wait for reply", error); +} + +static void +g_NPP_StreamAsFile(NPP instance, NPStream *stream, const char *fname) +{ + if (instance == NULL) + return; + + D(bug("NPP_StreamAsFile instance=%p\n", instance)); + invoke_NPP_StreamAsFile(instance, stream, fname); + D(bug(" done\n")); +} + +// Determines maximum number of bytes that the plug-in can consume +static int32 +invoke_NPP_WriteReady(NPP instance, NPStream *stream) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPP_WRITE_READY, + RPC_TYPE_NPP, instance, + RPC_TYPE_NP_STREAM, stream, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_WriteReady() invoke", error); + return 0; + } + + int32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_INT32, &ret, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_WriteReady() wait for reply", error); + return 0; + } + + return ret; +} + +static int32 +g_NPP_WriteReady(NPP instance, NPStream *stream) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + D(bug("NPP_WriteReady instance=%p\n", instance)); + int32 ret = invoke_NPP_WriteReady(instance, stream); + D(bug(" return: %d\n", ret)); + return ret; +} + + +// Delivers data to a plug-in instance +static int32 +invoke_NPP_Write(NPP instance, NPStream *stream, int32 offset, int32 len, void *buf) +{ + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPP_WRITE, + RPC_TYPE_NPP, instance, + RPC_TYPE_NP_STREAM, stream, + RPC_TYPE_INT32, offset, + RPC_TYPE_ARRAY, RPC_TYPE_CHAR, len, buf, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_Write() invoke", error); + return -1; + } + + int32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_INT32, &ret, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_Write() wait for reply", error); + return -1; + } + + return ret; +} + +static int32 +g_NPP_Write(NPP instance, NPStream *stream, int32 offset, int32 len, void *buf) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + D(bug("NPP_Write instance=%p\n", instance)); + int32 ret = invoke_NPP_Write(instance, stream, offset, len, buf); + D(bug(" return: %d\n", ret)); + return ret; +} + + +// Requests a platform-specific print operation for an embedded or full-screen plug-in +static void invoke_NPP_Print(NPP instance, NPPrint *PrintInfo) +{ + NPPrintCallbackStruct *platformPrint; + switch (PrintInfo->mode) { + case NP_FULL: + platformPrint = PrintInfo->print.fullPrint.platformPrint; + break; + case NP_EMBED: + platformPrint = PrintInfo->print.embedPrint.platformPrint; + break; + default: + npw_printf("WARNING: PrintInfo mode %d is not supported\n", PrintInfo->mode); + return; + } + uint32_t platform_print_id = 0; + if (platformPrint) + platform_print_id = id_create(platformPrint); + D(bug(" platformPrint=%p\n", platformPrint)); + + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NPP_PRINT, + RPC_TYPE_NPP, instance, + RPC_TYPE_UINT32, platform_print_id, + RPC_TYPE_NP_PRINT, PrintInfo, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_Print() invoke", error); + return; + } + + uint32_t pluginPrinted; + error = rpc_method_wait_for_reply(g_rpc_connection, + RPC_TYPE_BOOLEAN, &pluginPrinted, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NPP_Print() wait for reply", error); + return; + } + + // update browser-side NPPrint struct + if (PrintInfo->mode == NP_FULL) + PrintInfo->print.fullPrint.pluginPrinted = pluginPrinted; + + if (platform_print_id) + id_remove(platform_print_id); +} + +static void g_NPP_Print(NPP instance, NPPrint *PrintInfo) +{ + if (instance == NULL) + return; + + if (PrintInfo == NULL) + return; + + D(bug("NPP_Print instance=%p\n", instance)); + invoke_NPP_Print(instance->pdata, PrintInfo); + D(bug(" done\n")); +} + +// Delivers a platform-specific window event to the instance +static int16 invoke_NPP_HandleEvent(NPP instance, void *event) +{ + UNIMPLEMENTED(); + + return 0; +} + +static int16 g_NPP_HandleEvent(NPP instance, void *event) +{ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + D(bug("NPP_HandleEvent instance=%p\n", instance)); + int16 ret = invoke_NPP_HandleEvent(instance, event); + D(bug(" return: ret\n", ret)); + return ret; +} + +// Allows the browser to query the plug-in for information +NPError +NP_GetValue(void *future, NPPVariable variable, void *value) +{ + D(bug("NP_GetValue\n")); + + if (g_plugin.initialized == 0) + plugin_init(0); + if (g_plugin.initialized <= 0) + return NPERR_GENERIC_ERROR; + + char *str = NULL; + int ret = NPERR_GENERIC_ERROR; + switch (variable) { + case NPPVpluginNameString: + if (g_plugin.is_wrapper) { + str = "NPAPI Plugins Wrapper " NPW_VERSION; + ret = NPERR_NO_ERROR; + } + else if (g_plugin.name) { + str = g_plugin.name; + ret = NPERR_NO_ERROR; + } + break; + case NPPVpluginDescriptionString: + if (g_plugin.is_wrapper) { + str = + "nspluginwrapper " + " is a cross-platform NPAPI plugin viewer, in particular for linux/i386 plugins.
" + "This is beta software available under the terms of the GNU General Public License.
" + ; + ret = NPERR_NO_ERROR; + } + else if (g_plugin.description) { + str = g_plugin.description; + ret = NPERR_NO_ERROR; + } + break; + default: + return NPERR_INVALID_PARAM; + } + *((char **)value) = str; + + D(bug(" return: %d ['%s']\n", ret, str)); + return ret; +} + +// Allows the browser to query the plug-in supported formats +char * +NP_GetMIMEDescription(void) +{ + D(bug("NP_GetMIMEDescription\n")); + + if (g_plugin.initialized == 0) + plugin_init(0); + if (g_plugin.initialized <= 0) + return NULL; + + if (g_plugin.is_wrapper) + return "unknown/mime-type:none:Do not open"; + + D(bug(" formats: '%s'\n", g_plugin.formats)); + return g_plugin.formats; +} + +// Provides global initialization for a plug-in +NPError +NP_Initialize(NPNetscapeFuncs *moz_funcs, NPPluginFuncs *plugin_funcs) +{ + D(bug("NP_Initialize\n")); + + if (moz_funcs == NULL || plugin_funcs == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + + if ((moz_funcs->version >> 8) != NP_VERSION_MAJOR) + return NPERR_INCOMPATIBLE_VERSION_ERROR; + // for now, we only need fields up to including forceRedraw + if (moz_funcs->size < (offsetof(NPNetscapeFuncs, forceredraw) + sizeof(NPN_ForceRedrawUPP))) + return NPERR_INVALID_FUNCTABLE_ERROR; + if (plugin_funcs->size < sizeof(NPPluginFuncs)) + return NPERR_INVALID_FUNCTABLE_ERROR; + if (g_plugin.is_wrapper) + return NPERR_NO_ERROR; + + // copy mozilla_funcs table here as plugin_init() will need it + memcpy(&mozilla_funcs, moz_funcs, min(moz_funcs->size, sizeof(mozilla_funcs))); + + memset(plugin_funcs, 0, sizeof(*plugin_funcs)); + plugin_funcs->size = sizeof(NPPluginFuncs); + plugin_funcs->version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR; + plugin_funcs->newp = NewNPP_NewProc(g_NPP_New); + plugin_funcs->destroy = NewNPP_DestroyProc(g_NPP_Destroy); + plugin_funcs->setwindow = NewNPP_SetWindowProc(g_NPP_SetWindow); + plugin_funcs->newstream = NewNPP_NewStreamProc(g_NPP_NewStream); + plugin_funcs->destroystream = NewNPP_DestroyStreamProc(g_NPP_DestroyStream); + plugin_funcs->asfile = NewNPP_StreamAsFileProc(g_NPP_StreamAsFile); + plugin_funcs->writeready = NewNPP_WriteReadyProc(g_NPP_WriteReady); + plugin_funcs->write = NewNPP_WriteProc(g_NPP_Write); + plugin_funcs->print = NewNPP_PrintProc(g_NPP_Print); + plugin_funcs->event = NewNPP_HandleEventProc(g_NPP_HandleEvent); + plugin_funcs->urlnotify = NewNPP_URLNotifyProc(g_NPP_URLNotify); + plugin_funcs->javaClass = NULL; + plugin_funcs->getvalue = NewNPP_GetValueProc(g_NPP_GetValue); + plugin_funcs->setvalue = NewNPP_SetValueProc(g_NPP_SetValue); + + if (g_plugin.initialized == 0 || g_plugin.initialized == 1) + plugin_init(1); + if (g_plugin.initialized <= 0) + return NPERR_MODULE_LOAD_FAILED_ERROR; + + if (!npobject_bridge_new()) + return NPERR_MODULE_LOAD_FAILED_ERROR; + + // NPRuntime appeared in NPAPI >= 0.14 + bool has_npruntime = true; + if ((moz_funcs->version >> 8) == 0 && (moz_funcs->version & 0xff) < 14) + has_npruntime = false; + // check that the browser doesn't lie + if (moz_funcs->size < (offsetof(NPNetscapeFuncs, setexception) + sizeof(NPN_SetExceptionUPP))) + has_npruntime = false; + + int error = rpc_method_invoke(g_rpc_connection, + RPC_METHOD_NP_INITIALIZE, + RPC_TYPE_UINT32, (uint32_t)has_npruntime, + RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NP_Initialize() invoke", error); + return NPERR_MODULE_LOAD_FAILED_ERROR; + } + + int32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); + + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NP_Initialize() wait for reply", error); + return NPERR_MODULE_LOAD_FAILED_ERROR; + } + + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + +// Provides global deinitialization for a plug-in +static NPError +invoke_NP_Shutdown(void) +{ + int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NP_SHUTDOWN, RPC_TYPE_INVALID); + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NP_Shutdown() invoke", error); + return NPERR_GENERIC_ERROR; + } + + int32_t ret; + error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); + if (error != RPC_ERROR_NO_ERROR) { + npw_perror("NP_Shutdown() wait for reply", error); + return NPERR_GENERIC_ERROR; + } + + npobject_bridge_destroy(); + + return ret; +} + +NPError +NP_Shutdown(void) +{ + D(bug("NP_Shutdown\n")); + + int32_t ret = NPERR_NO_ERROR; + + if (g_rpc_connection) + ret = invoke_NP_Shutdown(); + + if (!g_plugin.is_wrapper) + plugin_exit(); + + D(bug(" return: %d [%s]\n", ret, string_of_NPError(ret))); + return ret; +} + + +/* ====================================================================== */ +/* === Plug initialization === */ +/* ====================================================================== */ + +// Initialize wrapper plugin and execute viewer +static void do_plugin_init(int is_NP_Initialize) +{ + if (g_plugin.initialized < 0) + return; + g_plugin.initialized = -1; + + D(bug("plugin_init for %s\n", plugin_path)); + if (strcmp(plugin_path, NPW_DEFAULT_PLUGIN_PATH) == 0) { + g_plugin.is_wrapper = 1; + g_plugin.initialized = 1 + is_NP_Initialize; + return; + } + + static const char *plugin_file_name = NULL; + if (plugin_file_name == NULL) { + const char *p; + for (p = &plugin_path[strlen(plugin_path) - 1]; p > plugin_path; p--) { + if (*p == '/') { + plugin_file_name = p + 1; + break; + } + } + if (plugin_file_name == NULL) + return; + } + + static int init_count = 0; + ++init_count; + char viewer_path[PATH_MAX]; + sprintf(viewer_path, "%s/%s/%s/%s", NPW_LIBDIR, NPW_Plugin.target_arch, NPW_Plugin.target_os, NPW_VIEWER); + char connection_path[128]; + sprintf(connection_path, "%s/%s/%d-%d", NPW_CONNECTION_PATH, plugin_file_name, getpid(), init_count); + + // Cache MIME info and plugin name/description + if (!is_NP_Initialize && g_plugin.name == NULL && g_plugin.description == NULL && g_plugin.formats == NULL) { + char command[1024]; + if (snprintf(command, sizeof(command), "%s --info --plugin %s", viewer_path, plugin_path) >= sizeof(command)) + return; + FILE *viewer_fp = popen(command, "r"); + if (viewer_fp == NULL) + return; + char **strings[] = { &g_plugin.name, &g_plugin.description, &g_plugin.formats, NULL }; + int i, error = 0; + for (i = 0; strings[i] != NULL; i++) { + int len; + if (fscanf(viewer_fp, "%d\n", &len) != 1) { + error = 1; + break; + } + char *str = malloc(len + 1); + if (len == 0) + str[0] = '\0'; + else { + if (fgets(str, len, viewer_fp) == NULL) { + error = 1; + break; + } + } + *(strings[i]) = str; + } + pclose(viewer_fp); + if (error == 0) + g_plugin.initialized = 1; + return; + } + + // Start plug-in viewer + if ((g_plugin.viewer_pid = fork()) == 0) { + char *argv[8]; + int argc = 0; + + argv[argc++] = NPW_VIEWER; + argv[argc++] = "--plugin"; + argv[argc++] = (char *)plugin_path; + argv[argc++] = "--connection"; + argv[argc++] = connection_path; + argv[argc] = NULL; + + execv(viewer_path, argv); + npw_printf("ERROR: failed to execute NSPlugin viewer\n"); + _Exit(255); + } + + // Initialize browser-side RPC communication channel + if (rpc_add_np_marshalers() < 0) { + npw_printf("ERROR: failed to initialize browser-side marshalers\n"); + return; + } + if ((g_rpc_connection = rpc_init_client(connection_path)) == NULL) { + npw_printf("ERROR: failed to initialize plugin-side RPC client connection\n"); + return; + } + static const rpc_method_descriptor_t vtable[] = { + { RPC_METHOD_NPN_USER_AGENT, handle_NPN_UserAgent }, + { RPC_METHOD_NPN_GET_VALUE, handle_NPN_GetValue }, + { RPC_METHOD_NPN_GET_URL, handle_NPN_GetURL }, + { RPC_METHOD_NPN_GET_URL_NOTIFY, handle_NPN_GetURLNotify }, + { RPC_METHOD_NPN_POST_URL, handle_NPN_PostURL }, + { RPC_METHOD_NPN_POST_URL_NOTIFY, handle_NPN_PostURLNotify }, + { RPC_METHOD_NPN_STATUS, handle_NPN_Status }, + { RPC_METHOD_NPN_PRINT_DATA, handle_NPN_PrintData }, + { RPC_METHOD_NPN_REQUEST_READ, handle_NPN_RequestRead }, + { RPC_METHOD_NPN_CREATE_OBJECT, handle_NPN_CreateObject }, + { RPC_METHOD_NPN_RETAIN_OBJECT, handle_NPN_RetainObject }, + { RPC_METHOD_NPN_RELEASE_OBJECT, handle_NPN_ReleaseObject }, + { RPC_METHOD_NPN_INVOKE, handle_NPN_Invoke }, + { RPC_METHOD_NPN_INVOKE_DEFAULT, handle_NPN_InvokeDefault }, + { RPC_METHOD_NPN_EVALUATE, handle_NPN_Evaluate }, + { RPC_METHOD_NPN_GET_PROPERTY, handle_NPN_GetProperty }, + { RPC_METHOD_NPN_SET_PROPERTY, handle_NPN_SetProperty }, + { RPC_METHOD_NPN_REMOVE_PROPERTY, handle_NPN_RemoveProperty }, + { RPC_METHOD_NPN_HAS_PROPERTY, handle_NPN_HasProperty }, + { RPC_METHOD_NPN_HAS_METHOD, handle_NPN_HasMethod }, + { RPC_METHOD_NPN_SET_EXCEPTION, handle_NPN_SetException }, + { RPC_METHOD_NPN_GET_STRING_IDENTIFIER, handle_NPN_GetStringIdentifier }, + { RPC_METHOD_NPN_GET_STRING_IDENTIFIERS, handle_NPN_GetStringIdentifiers }, + { RPC_METHOD_NPN_GET_INT_IDENTIFIER, handle_NPN_GetIntIdentifier }, + { RPC_METHOD_NPN_IDENTIFIER_IS_STRING, handle_NPN_IdentifierIsString }, + { RPC_METHOD_NPN_UTF8_FROM_IDENTIFIER, handle_NPN_UTF8FromIdentifier }, + { RPC_METHOD_NPN_INT_FROM_IDENTIFIER, handle_NPN_IntFromIdentifier }, + { RPC_METHOD_NPCLASS_INVALIDATE, npclass_handle_Invalidate }, + { RPC_METHOD_NPCLASS_HAS_METHOD, npclass_handle_HasMethod }, + { RPC_METHOD_NPCLASS_INVOKE, npclass_handle_Invoke }, + { RPC_METHOD_NPCLASS_INVOKE_DEFAULT, npclass_handle_InvokeDefault }, + { RPC_METHOD_NPCLASS_HAS_PROPERTY, npclass_handle_HasProperty }, + { RPC_METHOD_NPCLASS_GET_PROPERTY, npclass_handle_GetProperty }, + { RPC_METHOD_NPCLASS_SET_PROPERTY, npclass_handle_SetProperty }, + { RPC_METHOD_NPCLASS_REMOVE_PROPERTY, npclass_handle_RemoveProperty }, + }; + if (rpc_method_add_callbacks(g_rpc_connection, vtable, sizeof(vtable) / sizeof(vtable[0])) < 0) { + npw_printf("ERROR: failed to setup NPN method callbacks\n"); + return; + } + + // Retrieve toolkit information + if (mozilla_funcs.getvalue == NULL) + return; + NPNToolkitType toolkit = 0; + mozilla_funcs.getvalue(NULL, NPNVToolkit, (void *)&toolkit); + + // Initialize RPC events listener, try to attach it to the main event loop + if (toolkit == NPNVGtk12 || toolkit == NPNVGtk2) { // GLib + D(bug(" trying to attach RPC listener to main GLib event loop\n")); + static GSourceFuncs rpc_event_funcs = { + rpc_event_prepare, + rpc_event_check, + rpc_event_dispatch, + (void (*)(GSource *))g_free, + (GSourceFunc)NULL, + (GSourceDummyMarshal)NULL + }; + g_rpc_source = g_source_new(&rpc_event_funcs, sizeof(GSource)); + if (g_rpc_source) { + g_source_set_priority(g_rpc_source, G_PRIORITY_DEFAULT); + g_source_set_callback(g_rpc_source, (GSourceFunc)rpc_dispatch, g_rpc_connection, NULL); + g_source_attach(g_rpc_source, NULL); + g_rpc_poll_fd.fd = rpc_socket(g_rpc_connection); + g_rpc_poll_fd.events = G_IO_IN; + g_rpc_poll_fd.revents = 0; + g_source_add_poll(g_rpc_source, &g_rpc_poll_fd); + } + } + if (g_rpc_source == NULL) { // X11 + D(bug(" trying to attach RPC listener to main X11 event loop\n")); + XtAppContext x_app_context = NULL; + int error = mozilla_funcs.getvalue(NULL, NPNVxtAppContext, (void *)&x_app_context); + if (error != NPERR_NO_ERROR || x_app_context == NULL) { + D(bug(" ... getting raw application context through X display\n")); + Display *x_display = NULL; + error = mozilla_funcs.getvalue(NULL, NPNVxDisplay, (void *)&x_display); + if (error == NPERR_NO_ERROR && x_display) + x_app_context = XtDisplayToApplicationContext(x_display); + } + if (x_app_context) { + xt_rpc_source_id = XtAppAddInput(x_app_context, + rpc_socket(g_rpc_connection), + (XtPointer)XtInputReadMask, + (XtInputCallbackProc)rpc_dispatch, g_rpc_connection); + } + } + if (g_rpc_source == NULL && xt_rpc_source_id == 0) { + npw_printf("ERROR: failed to initialize brower-side RPC events listener\n"); + return; + } + + if (!id_init()) { + npw_printf("ERROR: failed to allocate ID hash table\n"); + return; + } + + g_plugin.initialized = 1 + is_NP_Initialize; + D(bug("--- INIT ---\n")); +} + +static void plugin_init(int is_NP_Initialize) +{ + pthread_mutex_lock(&plugin_init_lock); + do_plugin_init(is_NP_Initialize); + pthread_mutex_unlock(&plugin_init_lock); +} + +// Kill NSPlugin Viewer process +static void do_plugin_exit(void) +{ + D(bug("plugin_exit\n")); + + if (xt_rpc_source_id) { + XtRemoveInput(xt_rpc_source_id); + xt_rpc_source_id = 0; + } + + if (g_rpc_source) { + g_source_remove_poll(g_rpc_source, &g_rpc_poll_fd); + g_source_destroy(g_rpc_source); + g_rpc_source = NULL; + } + + if (g_rpc_connection) { + int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NP_EXIT, RPC_TYPE_INVALID); + if (error != RPC_ERROR_NO_ERROR) + npw_perror("NP_Exit() invoke", error); + rpc_exit(g_rpc_connection); + g_rpc_connection = NULL; + } + + if (g_plugin.viewer_pid != -1) { + int status; + waitpid(g_plugin.viewer_pid, &status, 0); + g_plugin.viewer_pid = -1; + } + + id_kill(); + + g_plugin.initialized = 0; +} + +static void plugin_exit(void) +{ + pthread_mutex_lock(&plugin_init_lock); + do_plugin_exit(); + pthread_mutex_unlock(&plugin_init_lock); +} + +static void __attribute__((destructor)) plugin_exit_sentinel(void) +{ + plugin_exit(); + + if (g_plugin.formats) { + free(g_plugin.formats); + g_plugin.formats = NULL; + } + + if (g_plugin.name) { + free(g_plugin.name); + g_plugin.name = NULL; + } + + if (g_plugin.description) { + free(g_plugin.description); + g_plugin.description = NULL; + } +} diff --git a/src/rpc.c b/src/rpc.c new file mode 100644 index 0000000..4bfad91 --- /dev/null +++ b/src/rpc.c @@ -0,0 +1,1970 @@ +/* + * rpc.c - Remote Procedure Calls + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +/* + * NOTES: + * - this RPC system is very minimal and only suited for 1:1 communication. + * + * TODO: + * - better failure conditions + * - split for windows rpc support + */ + +#include "sysdeps.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "rpc.h" +#include "utils.h" + +#define DEBUG 0 +#include "debug.h" + +#define NON_BLOCKING_IO 0 + +// Define to delay certain calls (marked so explicitly) until the +// communication stream is empty +#define USE_DELAYED_REQUESTS 1 + +// Don't use anonymous sockets by default so that a generic Linux/i386 +// build of the viewer can interoperate with non-Linux wrappers. Linux +// distributions can use this code though. +// XXX better clean-up dead sockets properly on failure... +#if defined __linux__ +#define USE_ANONYMOUS_SOCKETS 0 +#endif + + +/* ====================================================================== */ +/* === Utility functions === */ +/* ====================================================================== */ + +// Use threads (needed for rpc_listen()) +#define USE_THREADS + +// PThreads glue +#ifndef USE_THREADS +#define pthread_t void * +#define pthread_cancel(th) +#define pthread_join(th, ret) +#define pthread_testcancel() +#define pthread_create(th, attr, start, arg) dummy_thread_create() +static inline int dummy_thread_create(void) { errno = ENOSYS; return -1; } + +#undef pthread_mutex_t +#define pthread_mutex_t volatile int +#undef pthread_mutex_lock +#define pthread_mutex_lock(m) -1 +#undef pthread_mutex_unlock +#define pthread_mutex_unlock(m) -1 +#undef PTHREAD_MUTEX_INITIALIZER +#define PTHREAD_MUTEX_INITIALIZER 0 +#endif + +// IEEE754 double representation +typedef union { + double value; + struct { +#ifdef WORDS_BIGENDIAN + unsigned int negative : 1; + unsigned int exponent : 11; + unsigned int mantissa0 : 20; + unsigned int mantissa1 : 32; +#else +#ifdef FLOAT_WORDS_BIGENDIAN + unsigned int mantissa0 : 20; + unsigned int exponent : 11; + unsigned int negative : 1; + unsigned int mantissa1 : 32; +#else + unsigned int mantissa1 : 32; + unsigned int mantissa0 : 20; + unsigned int exponent : 11; + unsigned int negative : 1; +#endif +#endif + } parts; +} ieee_double_shape_t; + +// Wait for the specified amount of microseconds (usec shall be < 1 second) +#if defined __linux__ +// Linux select() changes its timeout parameter upon return to contain +// the remaining time. Most other unixen leave it unchanged or undefined. +#define SELECT_SETS_REMAINING +#else +#define USE_NANOSLEEP +#endif + +static void rpc_delay(uint32_t usec) +{ + int was_error; + +#if defined(USE_NANOSLEEP) + struct timespec elapsed, tv; +#else + struct timeval tv; +#endif + + // Set the timeout interval - Linux only needs to do this once +#if defined(SELECT_SETS_REMAINING) + tv.tv_sec = 0; + tv.tv_usec = usec; +#elif defined(USE_NANOSLEEP) + elapsed.tv_sec = 0; + elapsed.tv_nsec = usec * 1000; +#endif + + do { + errno = 0; +#if defined(USE_NANOSLEEP) + tv.tv_sec = elapsed.tv_sec; + tv.tv_nsec = elapsed.tv_nsec; + was_error = nanosleep(&tv, &elapsed); +#else + was_error = select(0, NULL, NULL, NULL, &tv); +#endif + } while (was_error && (errno == EINTR)); +} + +// Returns a string describing the error code passed in the argument ERROR +const char *rpc_strerror(int error) +{ + const char *str; + switch (error) { + case RPC_ERROR_NO_ERROR: + str = "No error"; + break; + case RPC_ERROR_GENERIC: + str = "Generic error"; + break; + case RPC_ERROR_ERRNO_SET: + str = strerror(errno); + break; + case RPC_ERROR_NO_MEMORY: + str = "Out of memory"; + break; + case RPC_ERROR_CONNECTION_NULL: + str = "Connection was NULL"; + break; + case RPC_ERROR_CONNECTION_TYPE_MISMATCH: + str = "Connection type mismatch"; + break; + case RPC_ERROR_MESSAGE_TRUNCATED: + str = "Message truncated"; + break; + case RPC_ERROR_MESSAGE_ARGUMENT_MISMATCH: + str = "Message argument mismatch"; + break; + case RPC_ERROR_MESSAGE_ARGUMENT_UNKNOWN: + str = "Message argument type unknown"; + break; + case RPC_ERROR_MESSAGE_ARGUMENT_INVALID: + str = "Message argument invalid"; + break; + default: + str = ""; + break; + } + return str; +} + + +/* ====================================================================== */ +/* === RPC Connection Handling === */ +/* ====================================================================== */ + +// Connection type +enum { + RPC_CONNECTION_SERVER, + RPC_CONNECTION_CLIENT, +}; + +// Connection status +enum { + RPC_STATUS_IDLE, + RPC_STATUS_BUSY, +}; + +// Client / Server connection +struct rpc_connection_t { + int type; + int status; + int socket; + char *socket_path; + int server_socket; + int server_thread_active; + pthread_t server_thread; + rpc_method_descriptor_t *callbacks; + int n_callbacks; + int send_offset; + char send_buffer[BUFSIZ]; +}; + +#define return_error(ERROR) do { error = (ERROR); goto do_return; } while (0) + +// Set connection status (XXX protect connection with a lock?) +static inline void rpc_connection_set_status(rpc_connection_t *connection, int status) +{ + connection->status = status; +} + +// Returns TRUE if the connection is busy (e.g. waiting for a reply) +int rpc_connection_busy(rpc_connection_t *connection) +{ + return connection && connection->status == RPC_STATUS_BUSY; +} + +// Returns socket fd or -1 if invalid connection +int rpc_socket(rpc_connection_t *connection) +{ + if (connection == NULL) + return -1; + + return connection->socket; +} + +// Prepare socket path for addr.sun_path[] +// Returns the path length minus the terminating '\0' +static int _rpc_socket_path(char **pathp, const char *ident) +{ + if (pathp == NULL) + return 0; + + char *path; + int n, len; + +#if USE_ANONYMOUS_SOCKETS + n = 0; +#else +#if 0 + char *tmpdir = getenv("TMPDIR"); + if (tmpdir == NULL) + tmpdir = "/tmp"; +#else + // XXX don't use TMPDIR because the length of the resulting path + // could exceed the size of sun_path[] (typically 108 bytes on Linux) + char *tmpdir = "/tmp"; +#endif + n = strlen(tmpdir); +#endif + + len = strlen(ident); + if ((path = (char *)malloc(n + 1 + len + 1)) == NULL) + return 0; + +#if USE_ANONYMOUS_SOCKETS + path[0] = 0; + strcpy(&path[1], ident); + n = 1 + len; +#else + n = sprintf(path, "%s/", tmpdir); + for (int i = 0; i < len; i++) { + char ch = ident[i]; + if (ch == '/') + ch = '_'; + path[n++] = ch; + } + path[n] = '\0'; +#endif + + if (*pathp) + free(*pathp); + *pathp = path; + return n; +} + +// Initialize server-side RPC system +rpc_connection_t *rpc_init_server(const char *ident) +{ + D(bug("rpc_init_server ident='%s'\n", ident)); + + rpc_connection_t *connection; + struct sockaddr_un addr; + socklen_t addr_len; + + if (ident == NULL) + return NULL; + + connection = (rpc_connection_t *)malloc(sizeof(*connection)); + if (connection == NULL) + return NULL; + connection->type = RPC_CONNECTION_SERVER; + connection->status = RPC_STATUS_IDLE; + connection->socket = -1; + connection->server_thread_active = 0; + connection->callbacks = NULL; + connection->n_callbacks = 0; + + if ((connection->server_socket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { + perror("server socket"); + free(connection); + return NULL; + } + + memset(&addr, 0, sizeof(addr)); + addr.sun_family = AF_UNIX; + connection->socket_path = NULL; + addr_len = _rpc_socket_path(&connection->socket_path, ident); + memcpy(&addr.sun_path[0], connection->socket_path, addr_len); + addr_len += sizeof(struct sockaddr_un) - sizeof(addr.sun_path); + + if (bind(connection->server_socket, (struct sockaddr *)&addr, addr_len) < 0) { + perror("server bind"); + free(connection); + return NULL; + } + + if (listen(connection->server_socket, 1) < 0) { + perror("server listen"); + free(connection); + return NULL; + } + + return connection; +} + +// Initialize client-side RPC system +rpc_connection_t *rpc_init_client(const char *ident) +{ + D(bug("rpc_init_client ident='%s'\n", ident)); + + rpc_connection_t *connection; + struct sockaddr_un addr; + socklen_t addr_len; + + if (ident == NULL) + return NULL; + + connection = (rpc_connection_t *)malloc(sizeof(*connection)); + if (connection == NULL) + return NULL; + connection->type = RPC_CONNECTION_CLIENT; + connection->status = RPC_STATUS_IDLE; + connection->server_socket = -1; + connection->callbacks = NULL; + connection->n_callbacks = 0; + + if ((connection->socket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { + perror("client socket"); + free(connection); + return NULL; + } + + memset(&addr, 0, sizeof(addr)); + addr.sun_family = AF_UNIX; + connection->socket_path = NULL; + addr_len = _rpc_socket_path(&connection->socket_path, ident); + memcpy(&addr.sun_path[0], connection->socket_path, addr_len); + addr_len += sizeof(struct sockaddr_un) - sizeof(addr.sun_path); + + // Wait at most 5 seconds for server to initialize + const int N_CONNECT_WAIT_DELAY = 10; + int n_connect_attempts = 5000 / N_CONNECT_WAIT_DELAY; + if (n_connect_attempts == 0) + n_connect_attempts = 1; + while (n_connect_attempts > 0) { + if (connect(connection->socket, (struct sockaddr *)&addr, addr_len) == 0) + break; + if (n_connect_attempts > 1 && errno != ECONNREFUSED && errno != ENOENT) { + perror("client_connect"); + free(connection); + return NULL; + } + n_connect_attempts--; + rpc_delay(N_CONNECT_WAIT_DELAY * 1000); + } + if (n_connect_attempts == 0) { + free(connection); + return NULL; + } + + return connection; +} + +// Close RPC connection +int rpc_exit(rpc_connection_t *connection) +{ + D(bug("rpc_exit\n")); + + if (connection == NULL) + return RPC_ERROR_CONNECTION_NULL; + + if (connection->socket_path) { + if (connection->socket_path[0]) + unlink(connection->socket_path); + free(connection->socket_path); + } + + if (connection->type == RPC_CONNECTION_SERVER) { + if (connection->server_thread_active) { + pthread_cancel(connection->server_thread); + pthread_join(connection->server_thread, NULL); + } + if (connection->socket != -1) + close(connection->socket); + if (connection->server_socket != -1) + close(connection->server_socket); + } + else { + if (connection->socket != -1) + close(connection->socket); + } + + if (connection->callbacks) + free(connection->callbacks); + free(connection); + + return RPC_ERROR_NO_ERROR; +} + +// Wait for a message to arrive on the connection port +static inline int _rpc_wait_dispatch(rpc_connection_t *connection, int timeout) +{ + struct timeval tv; + tv.tv_sec = timeout / 1000000; + tv.tv_usec = timeout % 1000000; + + fd_set rfds; + FD_ZERO(&rfds); + FD_SET(connection->socket, &rfds); + return select(connection->socket + 1, &rfds, NULL, NULL, &tv); +} + +int rpc_wait_dispatch(rpc_connection_t *connection, int timeout) +{ + if (connection == NULL) + return RPC_ERROR_CONNECTION_NULL; + if (connection->socket < 0) + return RPC_ERROR_GENERIC; + + return _rpc_wait_dispatch(connection, timeout); +} + +// Process incoming messages in the background +static void *rpc_server_func(void *arg) +{ + rpc_connection_t *connection = (rpc_connection_t *)arg; + + int ret = rpc_listen_socket(connection); + if (ret < 0) + return NULL; + + connection->server_thread_active = 1; + for (;;) { + // XXX broken MacOS X doesn't implement cancellation points correctly + pthread_testcancel(); + + // wait for data to arrive + int ret = _rpc_wait_dispatch(connection, 50000); + if (ret == 0) + continue; + if (ret < 0) + break; + + rpc_dispatch(connection); + } + connection->server_thread_active = 0; + return NULL; +} + +// Return listen socket of RPC connection +int rpc_listen_socket(rpc_connection_t *connection) +{ + D(bug("rpc_listen_socket\n")); + + if (connection == NULL) + return RPC_ERROR_CONNECTION_NULL; + if (connection->type != RPC_CONNECTION_SERVER) + return RPC_ERROR_CONNECTION_TYPE_MISMATCH; + + struct sockaddr_un addr; + socklen_t addr_len = sizeof(addr); + if ((connection->socket = accept(connection->server_socket, (struct sockaddr *)&addr, &addr_len)) < 0) { + perror("server accept"); + return RPC_ERROR_ERRNO_SET; + } + +#if NON_BLOCKING_IO + int val = fcntl(connection->socket, F_GETFL, 0); + if (val < 0) { + perror("server fcntl F_GETFL"); + return RPC_ERROR_ERRNO_SET; + } + if (fcntl(connection->socket, F_SETFL, val | O_NONBLOCK) < 0) { + perror("server fcntl F_SETFL"); + return RPC_ERROR_ERRNO_SET; + } +#endif + + return connection->socket; +} + +// Listen for incoming messages on RPC connection +#ifdef USE_THREADS +int rpc_listen(rpc_connection_t *connection) +{ + D(bug("rpc_listen\n")); + + if (pthread_create(&connection->server_thread, NULL, rpc_server_func, connection) != 0) { + perror("server thread"); + return RPC_ERROR_ERRNO_SET; + } + + return RPC_ERROR_NO_ERROR; +} +#endif + + +/* ====================================================================== */ +/* === Message Passing === */ +/* ====================================================================== */ + +// Message markers +enum { + RPC_MESSAGE_START = -3000, + RPC_MESSAGE_ARGS = -3001, + RPC_MESSAGE_END = -3002, + RPC_MESSAGE_ACK = -3003, + RPC_MESSAGE_REPLY = -3004, + RPC_MESSAGE_FAILURE = -3005, +}; + +// Message type +struct rpc_message_t { + int socket; + int offset; + unsigned char buffer[BUFSIZ]; +}; + +// User-defined marshalers +static struct { + rpc_message_descriptor_t *descs; + int last; + int count; +} g_message_descriptors = { NULL, 0, 0 }; +static pthread_mutex_t g_message_descriptors_lock = PTHREAD_MUTEX_INITIALIZER; + +// Add a user-defined marshaler +static int rpc_message_add_callback(const rpc_message_descriptor_t *desc) +{ + D(bug("rpc_message_add_callback\n")); + + const int N_ENTRIES_ALLOC = 8; + int error = RPC_ERROR_NO_ERROR; + + pthread_mutex_lock(&g_message_descriptors_lock); + if (g_message_descriptors.descs == NULL) { + g_message_descriptors.count = N_ENTRIES_ALLOC; + if ((g_message_descriptors.descs = (rpc_message_descriptor_t *)malloc(g_message_descriptors.count * sizeof(g_message_descriptors.descs[0]))) == NULL) { + pthread_mutex_unlock(&g_message_descriptors_lock); + return RPC_ERROR_NO_MEMORY; + } + g_message_descriptors.last = 0; + } + else if (g_message_descriptors.last >= g_message_descriptors.count) { + g_message_descriptors.count += N_ENTRIES_ALLOC; + if ((g_message_descriptors.descs = (rpc_message_descriptor_t *)realloc(g_message_descriptors.descs, g_message_descriptors.count * sizeof(g_message_descriptors.descs[0]))) == NULL) { + pthread_mutex_unlock(&g_message_descriptors_lock); + return RPC_ERROR_NO_MEMORY; + } + } + + // XXX only one callback per ID + int i; + for (i = 0; i < g_message_descriptors.last; i++) { + if (g_message_descriptors.descs[i].id == desc->id) { + pthread_mutex_unlock(&g_message_descriptors_lock); + return RPC_ERROR_NO_ERROR; + } + } + + g_message_descriptors.descs[g_message_descriptors.last++] = *desc; + pthread_mutex_unlock(&g_message_descriptors_lock); + return error; +} + +// Add user-defined marshalers +int rpc_message_add_callbacks(const rpc_message_descriptor_t *descs, int n_descs) +{ + D(bug("rpc_message_add_callbacks\n")); + + int i, error; + for (i = 0; i < n_descs; i++) { + if ((error = rpc_message_add_callback(&descs[i])) < 0) + return error; + } + + return RPC_ERROR_NO_ERROR; +} + +// Find user-defined marshaler +static rpc_message_descriptor_t *rpc_message_find_descriptor(int id) +{ + D(bug("rpc_message_find_descriptor\n")); + + if (g_message_descriptors.descs) { + int i; + for (i = 0; i < g_message_descriptors.count; i++) { + if (g_message_descriptors.descs[i].id == id) + return &g_message_descriptors.descs[i]; + } + } + + return NULL; +} + +// Initialize message +static inline void rpc_message_init(rpc_message_t *message, rpc_connection_t *connection) +{ + message->socket = connection->socket; + message->offset = 0; +} + +// Send BYTES +static inline int _rpc_message_send_bytes(rpc_message_t *message, unsigned char *bytes, int count) +{ + if (send(message->socket, bytes, count, 0) != count) + return RPC_ERROR_ERRNO_SET; + return RPC_ERROR_NO_ERROR; +} + +// Send message on wire +static inline int rpc_message_flush(rpc_message_t *message) +{ + int error = _rpc_message_send_bytes(message, message->buffer, message->offset); + message->offset = 0; + return error; +} + +// Send BYTES +int rpc_message_send_bytes(rpc_message_t *message, unsigned char *bytes, int count) +{ + if (message->offset + count >= sizeof(message->buffer)) { + int error = rpc_message_flush(message); + if (error != RPC_ERROR_NO_ERROR) + return error; + return _rpc_message_send_bytes(message, bytes, count); + } + memcpy(&message->buffer[message->offset], bytes, count); + message->offset += count; + return RPC_ERROR_NO_ERROR; +} + +// Send CHAR +int rpc_message_send_char(rpc_message_t *message, char c) +{ + D(bug(" send CHAR '%c'\n", c)); + + unsigned char e_value = c; + return rpc_message_send_bytes(message, (unsigned char *)&e_value, sizeof(e_value)); +} + +// Send INT32 +int rpc_message_send_int32(rpc_message_t *message, int32_t value) +{ + D(bug(" send INT32 %d\n", value)); + + int32_t e_value = htonl(value); + return rpc_message_send_bytes(message, (unsigned char *)&e_value, sizeof(e_value)); +} + +// Send UINT32 +int rpc_message_send_uint32(rpc_message_t *message, uint32_t value) +{ + D(bug(" send UINT32 %u\n", value)); + + uint32_t e_value = htonl(value); + return rpc_message_send_bytes(message, (unsigned char *)&e_value, sizeof(e_value)); +} + +// Send UINT64 +int rpc_message_send_uint64(rpc_message_t *message, uint64_t value) +{ + D(bug(" send UINT64 %" PRIx64 "\n", value)); + + int error = rpc_message_send_uint32(message, (uint32_t)(value >> 32)); + if (error < 0) + return error; + return rpc_message_send_uint32(message, (uint32_t)value); +} + +// Send DOUBLE +int rpc_message_send_double(rpc_message_t *message, double value) +{ + D(bug(" send DOUBLE %g\n", value)); + + int error; + ieee_double_shape_t dbl; + dbl.value = value; + if ((error = rpc_message_send_uint32(message, (uint32_t)dbl.parts.negative)) < 0) + return error; + if ((error = rpc_message_send_uint32(message, (uint32_t)dbl.parts.exponent)) < 0) + return error; + if ((error = rpc_message_send_uint32(message, (uint32_t)dbl.parts.mantissa0)) < 0) + return error; + if ((error = rpc_message_send_uint32(message, (uint32_t)dbl.parts.mantissa1)) < 0) + return error; + return RPC_ERROR_NO_ERROR; +} + +// Send STRING +int rpc_message_send_string(rpc_message_t *message, const char *str) +{ + D(bug(" send STRING \"%s\"\n", str)); + + int error, length = str ? strlen(str) : -1; + uint32_t e_value = htonl(length); + error = rpc_message_send_bytes(message, (unsigned char *)&e_value, sizeof(e_value)); + if (error != RPC_ERROR_NO_ERROR) + return error; + if (length > 0) + return rpc_message_send_bytes(message, (unsigned char *)str, length); + return RPC_ERROR_NO_ERROR; +} + +// Send message arguments +static int rpc_message_send_args(rpc_message_t *message, va_list args) +{ + int type, error, nargs = 0; + rpc_message_descriptor_t *desc; + while ((type = va_arg(args, int)) != RPC_TYPE_INVALID) { + if (++nargs == 1) { + error = rpc_message_send_int32(message, RPC_MESSAGE_ARGS); + if (error != RPC_ERROR_NO_ERROR) + return error; + } + error = rpc_message_send_int32(message, type); + if (error != RPC_ERROR_NO_ERROR) + return error; + switch (type) { + case RPC_TYPE_CHAR: + error = rpc_message_send_char(message, (char )va_arg(args, int)); + break; + case RPC_TYPE_BOOLEAN: + case RPC_TYPE_INT32: + error = rpc_message_send_int32(message, va_arg(args, int)); + break; + case RPC_TYPE_UINT32: + error = rpc_message_send_uint32(message, va_arg(args, unsigned int)); + break; + case RPC_TYPE_UINT64: + error = rpc_message_send_uint64(message, va_arg(args, uint64_t)); + break; + case RPC_TYPE_DOUBLE: + error = rpc_message_send_double(message, va_arg(args, double)); + break; + case RPC_TYPE_STRING: + error = rpc_message_send_string(message, va_arg(args, char *)); + break; + case RPC_TYPE_ARRAY: { + int i; + int array_type = va_arg(args, int32_t); + int array_size = va_arg(args, uint32_t); + if ((error = rpc_message_send_int32(message, array_type)) < 0) + return error; + if ((error = rpc_message_send_uint32(message, array_size)) < 0) + return error; + switch (array_type) { + case RPC_TYPE_CHAR: { + unsigned char *array = va_arg(args, unsigned char *); + error = rpc_message_send_bytes(message, array, array_size); + break; + } + case RPC_TYPE_BOOLEAN: + case RPC_TYPE_INT32: { + int32_t *array = va_arg(args, int32_t *); + for (i = 0; i < array_size; i++) { + if ((error = rpc_message_send_int32(message, array[i])) < 0) + break; + } + break; + } + case RPC_TYPE_UINT32: { + uint32_t *array = va_arg(args, uint32_t *); + for (i = 0; i < array_size; i++) { + if ((error = rpc_message_send_uint32(message, array[i])) < 0) + break; + } + break; + } + case RPC_TYPE_STRING: { + char **array = va_arg(args, char **); + for (i = 0; i < array_size; i++) { + if ((error = rpc_message_send_string(message, array[i])) < 0) + break; + } + break; + } + default: + if ((desc = rpc_message_find_descriptor(array_type)) != NULL) { + if (desc->size <= sizeof(void *)) { // arguments are passed by value + switch (desc->size) { + case sizeof(void *): { + void **array = va_arg(args, void **); + for (i = 0; i < array_size; i++) { + if ((error = desc->send_callback(message, array[i])) < 0) + break; + } + break; + } + default: + fprintf(stderr, "invalid argument passing by value with type size of %d bytes\n", desc->size); + error = RPC_ERROR_MESSAGE_ARGUMENT_INVALID; + break; + } + } + else { // arguments are passed by reference + uint8_t *array = va_arg(args, uint8_t *); + for (i = 0; i < array_size; i++) { + if ((error = desc->send_callback(message, &array[i * desc->size])) < 0) + break; + } + } + } + else { + fprintf(stderr, "unknown array arg type %d to send\n", type); + error = RPC_ERROR_MESSAGE_ARGUMENT_UNKNOWN; + } + break; + } + break; + } + default: + if ((desc = rpc_message_find_descriptor(type)) != NULL) + error = desc->send_callback(message, va_arg(args, uint8_t *)); + else { + fprintf(stderr, "unknown arg type %d to send\n", type); + error = RPC_ERROR_MESSAGE_ARGUMENT_UNKNOWN; + } + break; + } + if (error != RPC_ERROR_NO_ERROR) + return error; + } + if (nargs) { + error = rpc_message_send_int32(message, RPC_MESSAGE_END); + if (error != RPC_ERROR_NO_ERROR) + return error; + } + return RPC_ERROR_NO_ERROR; +} + +// Receive raw BYTES +static inline int _rpc_message_recv_bytes(rpc_message_t *message, unsigned char *bytes, int count) +{ + do { + int n = recv(message->socket, bytes, count, 0); + if (n > 0) { + count -= n; + bytes += n; + } + else if (n == -1 && errno == EINTR) + continue; + else { +#if NON_BLOCKING_IO + if (errno == EAGAIN || errno == EWOULDBLOCK) { + // wait for data to arrive + fd_set rfds; + FD_ZERO(&rfds); + FD_SET(message->socket, &rfds); + int ret = select(message->socket + 1, &rfds, NULL, NULL, NULL); + if (ret > 0) + continue; + } +#endif + return RPC_ERROR_ERRNO_SET; + } + } while (count > 0); + return RPC_ERROR_NO_ERROR; +} + +int rpc_message_recv_bytes(rpc_message_t *message, unsigned char *bytes, int count) +{ + return _rpc_message_recv_bytes(message, bytes, count); +} + +// Receive CHAR +int rpc_message_recv_char(rpc_message_t *message, char *ret) +{ + char r_value; + int error; + if ((error = _rpc_message_recv_bytes(message, (unsigned char *)&r_value, sizeof(r_value))) < 0) + return error; + *ret = r_value; + D(bug(" recv CHAR '%c'\n", *ret)); + return RPC_ERROR_NO_ERROR; +} + +// Receive INT32 +int rpc_message_recv_int32(rpc_message_t *message, int32_t *ret) +{ + int32_t r_value; + int error; + if ((error = _rpc_message_recv_bytes(message, (unsigned char *)&r_value, sizeof(r_value))) < 0) + return error; + *ret = ntohl(r_value); + D(bug(" recv INT32 %d\n", *ret)); + return RPC_ERROR_NO_ERROR; +} + +// Receive UINT32 +int rpc_message_recv_uint32(rpc_message_t *message, uint32_t *ret) +{ + uint32_t r_value; + int error; + if ((error = _rpc_message_recv_bytes(message, (unsigned char *)&r_value, sizeof(r_value))) < 0) + return error; + *ret = ntohl(r_value); + D(bug(" recv UINT32 %u\n", *ret)); + return RPC_ERROR_NO_ERROR; +} + +// Receive UINT64 +int rpc_message_recv_uint64(rpc_message_t *message, uint64_t *ret) +{ + uint32_t hi, lo; + int error; + if ((error = rpc_message_recv_uint32(message, &hi)) < 0) + return error; + if ((error = rpc_message_recv_uint32(message, &lo)) < 0) + return error; + *((uint64_t *)ret) = (((uint64_t)hi) << 32) | lo; + D(bug(" recv UINT64 0x%016" PRIx64 "\n", *ret)); + return RPC_ERROR_NO_ERROR; +} + +// Receive DOUBLE +int rpc_message_recv_double(rpc_message_t *message, double *ret) +{ + uint32_t negative, exponent, mantissa0, mantissa1; + + int error; + if ((error = rpc_message_recv_uint32(message, &negative)) < 0) + return error; + if ((error = rpc_message_recv_uint32(message, &exponent)) < 0) + return error; + if ((error = rpc_message_recv_uint32(message, &mantissa0)) < 0) + return error; + if ((error = rpc_message_recv_uint32(message, &mantissa1)) < 0) + return error; + + ieee_double_shape_t dbl; + dbl.parts.negative = negative; + dbl.parts.exponent = exponent; + dbl.parts.mantissa0 = mantissa0; + dbl.parts.mantissa1 = mantissa1; + *ret = dbl.value; + + D(bug(" recv DOUBLE %g\n", *ret)); + return RPC_ERROR_NO_ERROR; +} + +// Receive STRING +int rpc_message_recv_string(rpc_message_t *message, char **ret) +{ + char *str; + int length; + uint32_t r_value; + int error; + if ((error = _rpc_message_recv_bytes(message, (unsigned char *)&r_value, sizeof(r_value))) < 0) + return error; + length = ntohl(r_value); + if (length == -1) + str = NULL; + else { + if ((str = (char *)malloc(length + 1)) == NULL) + return RPC_ERROR_NO_MEMORY; + if (length > 0) { + if ((error = _rpc_message_recv_bytes(message, (unsigned char *)str, length)) < 0) + return error; + } + str[length] = '\0'; + } + *ret = str; + D(bug(" recv STRING \"%s\"\n", *ret)); + return RPC_ERROR_NO_ERROR; +} + +// Receive message arguments +static int rpc_message_recv_args(rpc_message_t *message, va_list args) +{ + int nargs = 0; + int expected_type, error; + rpc_message_descriptor_t *desc; + + while ((expected_type = va_arg(args, int)) != RPC_TYPE_INVALID) { + if (++nargs == 1) { + int32_t value; + if ((error = rpc_message_recv_int32(message, &value)) < 0) + return error; + if (value != RPC_MESSAGE_ARGS) + return RPC_ERROR_MESSAGE_TRUNCATED; + } + void *p_value = va_arg(args, void *); + int32_t type; + if ((error = rpc_message_recv_int32(message, &type)) < 0) + return error; + if (type != expected_type) + return RPC_ERROR_MESSAGE_ARGUMENT_MISMATCH; + switch (type) { + case RPC_TYPE_CHAR: + error = rpc_message_recv_char(message, (char *)p_value); + break; + case RPC_TYPE_BOOLEAN: + case RPC_TYPE_INT32: + error = rpc_message_recv_int32(message, (int32_t *)p_value); + break; + case RPC_TYPE_UINT32: + error = rpc_message_recv_uint32(message, (uint32_t *)p_value); + break; + case RPC_TYPE_UINT64: + error = rpc_message_recv_uint64(message, (uint64_t *)p_value); + break; + case RPC_TYPE_DOUBLE: + error = rpc_message_recv_double(message, (double *)p_value); + break; + case RPC_TYPE_STRING: + error = rpc_message_recv_string(message, (char **)p_value); + break; + case RPC_TYPE_ARRAY: { + int i; + int32_t array_type; + uint32_t array_size; + if ((error = rpc_message_recv_int32(message, &array_type)) < 0) + return error; + if ((error = rpc_message_recv_uint32(message, &array_size)) < 0) + return error; + p_value = va_arg(args, void *); + *((uint32_t *)p_value) = array_size; + p_value = va_arg(args, void *); + switch (array_type) { + case RPC_TYPE_CHAR: { + unsigned char *array; + if ((array = (unsigned char *)malloc(array_size * sizeof(*array))) == NULL) + return RPC_ERROR_NO_MEMORY; + error = _rpc_message_recv_bytes(message, array, array_size); + if (error != RPC_ERROR_NO_ERROR) + return error; + *((void **)p_value) = (void *)array; + break; + } + case RPC_TYPE_BOOLEAN: + case RPC_TYPE_INT32: { + int *array; + if ((array = (int *)malloc(array_size * sizeof(*array))) == NULL) + return RPC_ERROR_NO_MEMORY; + for (i = 0; i < array_size; i++) { + int32_t value; + if ((error = rpc_message_recv_int32(message, &value)) < 0) + return error; + array[i] = value; + } + *((void **)p_value) = (void *)array; + break; + } + case RPC_TYPE_UINT32: { + unsigned int *array; + if ((array = (unsigned int *)malloc(array_size * sizeof(*array))) == NULL) + return RPC_ERROR_NO_MEMORY; + for (i = 0; i < array_size; i++) { + uint32_t value; + if ((error = rpc_message_recv_uint32(message, &value)) < 0) + return error; + array[i] = value; + } + *((void **)p_value) = (void *)array; + break; + } + case RPC_TYPE_STRING: { + char **array; + if ((array = (char **)malloc(array_size * sizeof(*array))) == NULL) + return RPC_ERROR_NO_MEMORY; + for (i = 0; i < array_size; i++) { + char *str; + if ((error = rpc_message_recv_string(message, &str)) < 0) + return error; + array[i] = str; + } + *((void **)p_value) = (void *)array; + break; + } + default: + if ((desc = rpc_message_find_descriptor(array_type)) != NULL) { + char *array; + if ((array = (char *)malloc(array_size * desc->size)) == NULL) + return RPC_ERROR_NO_MEMORY; + for (i = 0; i < array_size; i++) { + if ((error = desc->recv_callback(message, &array[i * desc->size])) < 0) + return error; + } + *((void **)p_value) = array; + } + else { + fprintf(stderr, "unknown array arg type %d to receive\n", type); + error = RPC_ERROR_MESSAGE_ARGUMENT_UNKNOWN; + } + break; + } + break; + } + default: + if ((desc = rpc_message_find_descriptor(type)) != NULL) + error = desc->recv_callback(message, p_value); + else { + fprintf(stderr, "unknown arg type %d to send\n", type); + error = RPC_ERROR_MESSAGE_ARGUMENT_UNKNOWN; + } + break; + } + if (error != RPC_ERROR_NO_ERROR) + return error; + } + if (nargs) { + int32_t value; + if ((error = rpc_message_recv_int32(message, &value)) < 0) + return error; + if (value != RPC_MESSAGE_END) + return RPC_ERROR_MESSAGE_TRUNCATED; + } + return RPC_ERROR_NO_ERROR; +} + +// Skip message argument +static int rpc_message_skip_arg(rpc_message_t *message, int type) +{ + unsigned char dummy[BUFSIZ]; + int error = RPC_ERROR_GENERIC; + switch (type) { + case RPC_TYPE_CHAR: + error = _rpc_message_recv_bytes(message, dummy, 1); + break; + case RPC_TYPE_BOOLEAN: + case RPC_TYPE_INT32: + case RPC_TYPE_UINT32: + error = _rpc_message_recv_bytes(message, dummy, 4); + break; + case RPC_TYPE_STRING: { + int32_t length; + if ((error = rpc_message_recv_int32(message, &length)) < 0) + return error; + while (length >= sizeof(dummy)) { + if ((error = _rpc_message_recv_bytes(message, dummy, sizeof(dummy))) < 0) + return error; + length -= sizeof(dummy); + } + if (length > 0) { + if ((error = _rpc_message_recv_bytes(message, dummy, length)) < 0) + return error; + } + break; + } + default: + fprintf(stderr, "unknown arg type %d to receive\n", type); + break; + } + return error; +} + +static rpc_method_callback_t rpc_lookup_callback(rpc_connection_t *connection, int method) +{ + if (connection->callbacks) { + int i; + for (i = 0; i < connection->n_callbacks; i++) { + if (connection->callbacks[i].id == method) + return connection->callbacks[i].callback; + } + } + return NULL; +} + +// Dispatch message received in the server loop +static int _rpc_dispatch(rpc_connection_t *connection, rpc_message_t *message) +{ + D(bug("receiving message\n")); + int32_t method, value, ret = RPC_MESSAGE_FAILURE; + if (rpc_message_recv_int32(message, &method) == RPC_ERROR_NO_ERROR && + rpc_message_recv_int32(message, &value) == RPC_ERROR_NO_ERROR && value == RPC_MESSAGE_END) { + rpc_method_callback_t callback = rpc_lookup_callback(connection, method); + if (callback && callback(connection) == RPC_ERROR_NO_ERROR) + ret = RPC_MESSAGE_ACK; + } + rpc_message_send_int32(message, ret); + rpc_message_flush(message); + if (ret == RPC_MESSAGE_ACK) + ret = method; + D(bug(" -- message received [%d]\n", ret)); + return ret; +} + +int rpc_dispatch(rpc_connection_t *connection) +{ + rpc_message_t message; + rpc_message_init(&message, connection); + + int32_t value; + if (rpc_message_recv_int32(&message, &value) != RPC_ERROR_NO_ERROR && + value != RPC_MESSAGE_START) + return RPC_MESSAGE_FAILURE; + + return _rpc_dispatch(connection, &message); +} + + +/* ====================================================================== */ +/* === Method Callbacks Handling === */ +/* ====================================================================== */ + +// Add a user-defined method callback (server side) +static int rpc_method_add_callback(rpc_connection_t *connection, const rpc_method_descriptor_t *desc) +{ + const int N_ENTRIES_ALLOC = 8; + int i; + + // pre-allocate up to N_ENTRIES_ALLOC entries + if (connection->callbacks == NULL) { + if ((connection->callbacks = (rpc_method_descriptor_t *)calloc(N_ENTRIES_ALLOC, sizeof(connection->callbacks[0]))) == NULL) + return RPC_ERROR_NO_MEMORY; + connection->n_callbacks = N_ENTRIES_ALLOC; + } + + // look for a free slot + for (i = connection->n_callbacks - 1; i >= 0; i--) { + if (connection->callbacks[i].callback == NULL) + break; + } + + // none found, reallocate + if (i < 0) { + if ((connection->callbacks = (rpc_method_descriptor_t *)realloc(connection->callbacks, (connection->n_callbacks + N_ENTRIES_ALLOC) * sizeof(connection->callbacks[0]))) == NULL) + return RPC_ERROR_NO_MEMORY; + i = connection->n_callbacks; + memset(&connection->callbacks[i], 0, N_ENTRIES_ALLOC * sizeof(connection->callbacks[0])); + connection->n_callbacks += N_ENTRIES_ALLOC; + } + + D(bug("rpc_method_add_callback for method %d in slot %d\n", desc->id, i)); + connection->callbacks[i] = *desc; + return RPC_ERROR_NO_ERROR; +} + +// Add user-defined method callbacks (server side) +int rpc_method_add_callbacks(rpc_connection_t *connection, const rpc_method_descriptor_t *descs, int n_descs) +{ + D(bug("rpc_method_add_callbacks\n")); + + if (connection == NULL) + return RPC_ERROR_CONNECTION_NULL; + + while (--n_descs >= 0) { + int error = rpc_method_add_callback(connection, &descs[n_descs]); + if (error != RPC_ERROR_NO_ERROR) + return error; + } + + return RPC_ERROR_NO_ERROR; +} + +// Remove a user-defined method callback (common code) +int rpc_method_remove_callback_id(rpc_connection_t *connection, int id) +{ + D(bug("rpc_method_remove_callback_id\n")); + + if (connection->callbacks) { + int i; + for (i = 0; i < connection->n_callbacks; i++) { + if (connection->callbacks[i].id == id) { + connection->callbacks[i].callback = NULL; + return RPC_ERROR_NO_ERROR; + } + } + } + + return RPC_ERROR_GENERIC; +} + +// Remove user-defined method callbacks (server side) +int rpc_method_remove_callbacks(rpc_connection_t *connection, const rpc_method_descriptor_t *callbacks, int n_callbacks) +{ + D(bug("rpc_method_remove_callbacks\n")); + + if (connection == NULL) + return RPC_ERROR_CONNECTION_NULL; + + while (--n_callbacks >= 0) { + int error = rpc_method_remove_callback_id(connection, callbacks[n_callbacks].id); + if (error != RPC_ERROR_NO_ERROR) + return error; + } + + return RPC_ERROR_NO_ERROR; +} + + +/* ====================================================================== */ +/* === Remote Procedure Call (method invocation) === */ +/* ====================================================================== */ + +// Invoke remote procedure (client side) +static int _rpc_method_invoke(rpc_connection_t *connection, int method, va_list args) +{ + int error; + rpc_message_t message; + + rpc_message_init(&message, connection); + error = rpc_message_send_int32(&message, RPC_MESSAGE_START); + if (error != RPC_ERROR_NO_ERROR) + return error; + error = rpc_message_send_int32(&message, method); + if (error != RPC_ERROR_NO_ERROR) + return error; + error = rpc_message_send_int32(&message, RPC_MESSAGE_END); + if (error != RPC_ERROR_NO_ERROR) + return error; + error = rpc_message_send_args(&message, args); + if (error != RPC_ERROR_NO_ERROR) + return error; + error = rpc_message_flush(&message); + if (error != RPC_ERROR_NO_ERROR) + return error; + return RPC_ERROR_NO_ERROR; +} + +int rpc_method_invoke(rpc_connection_t *connection, int method, ...) +{ + D(bug("rpc_method_invoke method=%d\n", method)); + + if (connection == NULL) + return RPC_ERROR_CONNECTION_NULL; + + va_list args; + va_start(args, method); + int error = _rpc_method_invoke(connection, method, args); + va_end(args); + return error; +} + +// Invoke remote procedure, after pending requests are processed +int rpc_method_invoke_delayed(rpc_connection_t *connection, int method, ...) +{ + D(bug("rpc_method_invoke_delayed method=%d\n", method)); + + if (connection == NULL) + return RPC_ERROR_CONNECTION_NULL; + +#if USE_DELAYED_REQUESTS + int n_requests = 0; + for (;;) { + int ret = _rpc_wait_dispatch(connection, 0); + if (ret <= 0) + break; + D(bug("... delayed\n")); + rpc_dispatch(connection); + ++n_requests; + } + if (n_requests > 0) + D(bug("... %d pending requests processed\n", n_requests)); +#endif + + va_list args; + va_start(args, method); + int error = _rpc_method_invoke(connection, method, args); + va_end(args); + return error; +} + +// Retrieve procedure arguments (server side) +int rpc_method_get_args(rpc_connection_t *connection, ...) +{ + D(bug("rpc_method_get_args\n")); + + int error; + va_list args; + rpc_message_t message; + + if (connection == NULL) + return RPC_ERROR_CONNECTION_NULL; + + rpc_message_init(&message, connection); + va_start(args, connection); + error = rpc_message_recv_args(&message, args); + va_end(args); + + return error; +} + +// Wait for a reply from the remote procedure (client side) +int rpc_method_wait_for_reply(rpc_connection_t *connection, ...) +{ + D(bug("rpc_method_wait_for_reply\n")); + + int error, type; + int32_t ret; + va_list args; + rpc_message_t message; + + if (connection == NULL) + return RPC_ERROR_CONNECTION_NULL; + + rpc_connection_set_status(connection, RPC_STATUS_BUSY); + + rpc_message_init(&message, connection); + va_start(args, connection); + type = va_arg(args, int); + va_end(args); + + if (type != RPC_TYPE_INVALID) { + do { + error = rpc_message_recv_int32(&message, &ret); + if (error != RPC_ERROR_NO_ERROR) + return_error(error); + switch (ret) { + case RPC_MESSAGE_START: + // bidirectional communication? + D(bug("BIDIRECTIONAL 1\n")); + if ((error = _rpc_dispatch(connection, &message)) < 0) + return_error(error); + break; + case RPC_MESSAGE_REPLY: + // expected reply, do nothing + break; + default: + D(bug("TRUNCATED 1 [%d]\n", ret)); + return_error(RPC_ERROR_MESSAGE_TRUNCATED); + break; + } + } while (ret != RPC_MESSAGE_REPLY); + va_start(args, connection); + error = rpc_message_recv_args(&message, args); + va_end(args); + if (error != RPC_ERROR_NO_ERROR) + return_error(error); + error = rpc_message_recv_int32(&message, &ret); + if (error != RPC_ERROR_NO_ERROR) + return_error(error); + if (ret != RPC_MESSAGE_END) { + D(bug("TRUNCATED 2 [%d]\n", ret)); + return_error(RPC_ERROR_MESSAGE_TRUNCATED); + } + } + + do { + error = rpc_message_recv_int32(&message, &ret); + if (error != RPC_ERROR_NO_ERROR) + return_error(error); + switch (ret) { + case RPC_MESSAGE_START: + // bidirectional communication? + D(bug("BIDIRECTIONAL 2\n")); + if ((error = _rpc_dispatch(connection, &message)) < 0) + return_error(error); + break; + case RPC_MESSAGE_ACK: + // expected reply, do nothing + break; + default: + D(bug("TRUNCATED 3 [%d]\n", ret)); + return_error(RPC_ERROR_MESSAGE_TRUNCATED); + break; + } + } while (ret != RPC_MESSAGE_ACK); + + return_error(RPC_ERROR_NO_ERROR); + + do_return: + rpc_connection_set_status(connection, RPC_STATUS_IDLE); + return error; +} + +// Send a reply to the client (server side) +int rpc_method_send_reply(rpc_connection_t *connection, ...) +{ + D(bug("rpc_method_send_reply\n")); + + rpc_message_t message; + int error; + va_list args; + + if (connection == NULL) + return RPC_ERROR_GENERIC; + + rpc_message_init(&message, connection); + error = rpc_message_send_int32(&message, RPC_MESSAGE_REPLY); + if (error != RPC_ERROR_NO_ERROR) + return error; + va_start(args, connection); + error = rpc_message_send_args(&message, args); + va_end(args); + if (error != RPC_ERROR_NO_ERROR) + return error; + error = rpc_message_send_int32(&message, RPC_MESSAGE_END); + if (error != RPC_ERROR_NO_ERROR) + return error; + error = rpc_message_flush(&message); + if (error != RPC_ERROR_NO_ERROR) + return error; + return RPC_ERROR_NO_ERROR; +} + + +/* ====================================================================== */ +/* === Test Program === */ +/* ====================================================================== */ + +#ifdef TEST_RPC +// User-defined method IDs +enum { + TEST_RPC_METHOD_ADD = 1, + TEST_RPC_METHOD_CHILD, + TEST_RPC_METHOD_PID, + TEST_RPC_METHOD_ECHO, + TEST_RPC_METHOD_PRINT, + TEST_RPC_METHOD_STRINGS, + TEST_RPC_METHOD_POINTS, + TEST_RPC_METHOD_EXIT, +}; + +// User-defined marshalers +enum { + RPC_TYPE_POINT = 100, +}; + +struct Point { + int x, y; +}; + +static int do_send_point(rpc_message_t *message, void *p_value) +{ + D(bug("do_send_point\n")); + + struct Point *pt = p_value; + int error; + + if ((error = rpc_message_send_int32(message, pt->x)) < 0) + return error; + if ((error = rpc_message_send_int32(message, pt->y)) < 0) + return error; + return RPC_ERROR_NO_ERROR; +} + +static int do_recv_point(rpc_message_t *message, void *p_value) +{ + D(bug("do_recv_point\n")); + + struct Point *pt = p_value; + int error; + int32_t value; + + if ((error = rpc_message_recv_int32(message, &value)) < 0) + return error; + pt->x = value; + if ((error = rpc_message_recv_int32(message, &value)) < 0) + return error; + pt->y = value; + return RPC_ERROR_NO_ERROR; +} + +static const rpc_message_descriptor_t point_desc = { + RPC_TYPE_POINT, + sizeof(struct Point), + do_send_point, + do_recv_point +}; + +// Global connections +static rpc_connection_t *g_npn_connection; +static char g_npn_connection_path[PATH_MAX]; +static rpc_connection_t *g_npp_connection; +static char g_npp_connection_path[PATH_MAX]; +static int g_client_pid; +static int g_server_pid; + +// handle ADD(INT32, INT32, INT32) -> INT32 +static int handle_ADD(rpc_connection_t *connection) +{ + D(bug("handle_ADD\n")); + + int error; + int32_t a, b, c; + if ((error = rpc_method_get_args(connection, RPC_TYPE_INT32, &a, RPC_TYPE_INT32, &b, RPC_TYPE_INT32, &c, RPC_TYPE_INVALID)) < 0) + return error; + + printf(" > %d, %d, %d\n", a, b, c); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, a + b + c, RPC_TYPE_INVALID); +} + +// handle PID(VOID) -> INT32 +static int handle_server_PID(rpc_connection_t *connection) +{ + D(bug("handle_server_PID\n")); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, g_server_pid, RPC_TYPE_INVALID); +} + +static int handle_client_PID(rpc_connection_t *connection) +{ + D(bug("handle_client_PID\n")); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, g_client_pid, RPC_TYPE_INVALID); +} + +// handle CHILD(VOID) -> INT32 +static int handle_CHILD(rpc_connection_t *connection) +{ + D(bug("handle_CHILD\n")); + + int error; + int32_t pid; + if ((error = rpc_method_invoke(g_npp_connection, TEST_RPC_METHOD_PID, RPC_TYPE_INVALID)) < 0) + return error; + if ((error = rpc_method_wait_for_reply(g_npp_connection, RPC_TYPE_INT32, &pid, RPC_TYPE_INVALID)) < 0) + return error; + printf(" > %d\n", pid); + return rpc_method_send_reply(connection, RPC_TYPE_INT32, pid + 1, RPC_TYPE_INVALID); +} + +// handle ECHO(STRING) -> VOID +static int handle_ECHO(rpc_connection_t *connection) +{ + D(bug("handle_ECHO\n")); + + int error; + char *str; + if ((error = rpc_method_get_args(connection, RPC_TYPE_STRING, &str, RPC_TYPE_INVALID)) < 0) + return error; + + printf(" > %s\n", str); + free(str); + return RPC_ERROR_NO_ERROR; +} + +// handle PRINT(STRING, UINT64, DOUBLE) -> VOID +static int handle_PRINT(rpc_connection_t *connection) +{ + D(bug("handle_PRINT\n")); + + char *str; + uint64_t val; + double dbl; + + int error = rpc_method_get_args(connection, + RPC_TYPE_STRING, &str, + RPC_TYPE_UINT64, &val, + RPC_TYPE_DOUBLE, &dbl, + RPC_TYPE_INVALID); + if (error < 0) + return error; + + printf(" > '%s', 0x%016" PRIx64 ", %f\n", str, val, dbl); + free(str); + return RPC_ERROR_NO_ERROR; +} + +// handle STRINGS(ARRAY of STRING) -> VOID +static int handle_STRINGS(rpc_connection_t *connection) +{ + D(bug("handle_STRINGS\n")); + + int i, error; + char **strtab; + int32_t strtab_length; + if ((error = rpc_method_get_args(connection, RPC_TYPE_ARRAY, RPC_TYPE_STRING, &strtab_length, &strtab, RPC_TYPE_INVALID)) < 0) + return error; + + for (i = 0; i < strtab_length; i++) { + char *str = strtab[i]; + printf(" > %s\n", str); + free(str); + } + free(strtab); + return RPC_ERROR_NO_ERROR; +} + +// handle POINTS(ARRAY of STRING) -> POINT +static int handle_POINTS(rpc_connection_t *connection) +{ + D(bug("handle_POINTS\n")); + + int i, error; + struct Point *pttab; + int32_t pttab_length; + if ((error = rpc_method_get_args(connection, RPC_TYPE_ARRAY, RPC_TYPE_POINT, &pttab_length, &pttab, RPC_TYPE_INVALID)) < 0) + return error; + + struct Point ptret = { 0, 0 }; + for (i = 0; i < pttab_length; i++) { + struct Point *pt = &pttab[i]; + printf(" > { %d, %d }\n", pt->x, pt->y); + ptret.x += pt->x; + ptret.y += pt->y; + } + free(pttab); + + return rpc_method_send_reply(connection, RPC_TYPE_POINT, &ptret, RPC_TYPE_INVALID); +} + +// handle EXIT(VOID) -> VOID +static int handle_EXIT(rpc_connection_t *connection) +{ + D(bug("handle_EXIT\n")); + + return RPC_ERROR_NO_ERROR; +} + +// Run server (NPN aka browser-side) +static int run_server(void) +{ + rpc_connection_t *connection; + + g_server_pid = getpid(); + printf("Server PID: %d\n", g_server_pid); + + if (rpc_message_add_callbacks(&point_desc, 1) < 0) { + fprintf(stderr, "ERROR: failed to add Point marshaler\n"); + return 0; + } + + if ((connection = rpc_init_server(g_npn_connection_path)) == NULL) { + fprintf(stderr, "ERROR: failed to initialize RPC server connection to NPN\n"); + return 0; + } + g_npn_connection = connection; + + if ((g_npp_connection = rpc_init_client(g_npp_connection_path)) == NULL) { + fprintf(stderr, "ERROR: failed to initialize RPC server connection to NPP\n"); + return 0; + } + + static const rpc_method_descriptor_t vtable1[] = { + { TEST_RPC_METHOD_ADD, handle_ADD }, + { TEST_RPC_METHOD_ECHO, handle_ECHO }, + { TEST_RPC_METHOD_PRINT, handle_PRINT }, + { TEST_RPC_METHOD_PID, handle_server_PID }, + { TEST_RPC_METHOD_EXIT, handle_EXIT }, + }; + if (rpc_method_add_callbacks(connection, &vtable1[0], sizeof(vtable1) / sizeof(vtable1[0])) < 0) { + fprintf(stderr, "ERROR: failed to setup method callbacks\n"); + return 0; + } + if (rpc_method_remove_callback_id(connection, TEST_RPC_METHOD_PID) < 0) { + fprintf(stderr, "ERROR: failed to remove superfluous callback %d\n", TEST_RPC_METHOD_PID); + return 0; + } + static const rpc_method_descriptor_t vtable2[] = { + { TEST_RPC_METHOD_CHILD, handle_CHILD }, + { TEST_RPC_METHOD_STRINGS, handle_STRINGS }, + { TEST_RPC_METHOD_POINTS, handle_POINTS }, + }; + if (rpc_method_add_callbacks(connection, &vtable2[0], sizeof(vtable2) / sizeof(vtable2[0])) < 0) { + fprintf(stderr, "ERROR: failed to setup method callbacks\n"); + return 0; + } + if (rpc_listen(connection) < 0) { + fprintf(stderr, "ERROR: failed to initialize RPC server thread\n"); + return 0; + } + + printf("Waiting for client to terminate\n"); + int status; + while (waitpid(g_client_pid, &status, 0) != g_client_pid) + ; + if (WIFEXITED(status)) + printf(" client exitted with status=%d\n", WEXITSTATUS(status)); + rpc_exit(g_npp_connection); + printf(" client connection closed\n"); + + rpc_exit(g_npn_connection); + printf("Server exitted\n"); + return 1; +} + +// Run client (NPP aka plugin-side) +static int run_client(void) +{ + rpc_connection_t *connection; + int i, error; + + g_client_pid = getpid(); + printf("Client PID: %d\n", g_client_pid); + + if (rpc_message_add_callbacks(&point_desc, 1) < 0) { + fprintf(stderr, "ERROR: failed to add Point marshaler\n"); + return 0; + } + + if ((connection = rpc_init_client(g_npn_connection_path)) == NULL) { + fprintf(stderr, "ERROR: failed to initialize RPC client connection to NPN\n"); + return 0; + } + g_npn_connection = connection; + + if ((g_npp_connection = rpc_init_server(g_npp_connection_path)) == NULL) { + fprintf(stderr, "ERROR: failed to initialize RPC server connection to NPP\n"); + return 0; + } + + static const rpc_method_descriptor_t vtable[] = { + { TEST_RPC_METHOD_PID, handle_client_PID }, + { TEST_RPC_METHOD_EXIT, handle_EXIT }, + }; + if (rpc_method_add_callbacks(g_npp_connection, &vtable[0], sizeof(vtable) / sizeof(vtable[0])) < 0) { + fprintf(stderr, "ERROR: failed to setup method callbacks\n"); + return 0; + } + if (rpc_listen(g_npp_connection) < 0) { + fprintf(stderr, "ERROR: failed to initialize RPC server thread\n"); + return 0; + } + + printf("Call CHILD\n"); + int32_t pid; + if ((error = rpc_method_invoke(connection, TEST_RPC_METHOD_CHILD, RPC_TYPE_INVALID)) < 0) { + fprintf(stderr, "ERROR: failed to send CHILD message [%d]\n", error); + return 0; + } + if ((error = rpc_method_wait_for_reply(connection, RPC_TYPE_INT32, &pid, RPC_TYPE_INVALID)) < 0) { + fprintf(stderr, "ERROR: failed to receive CHILD reply [%d]\n", error); + return 0; + } + if (pid != g_client_pid + 1) { + fprintf(stderr, "ERROR: failed to receive correct pid of this child\n"); + return 0; + } + printf(" result: %d\n", pid - 1); + + printf("Call ADD\n"); + int32_t value; + if ((error = rpc_method_invoke(connection, TEST_RPC_METHOD_ADD, RPC_TYPE_INT32, 1, RPC_TYPE_INT32, 2, RPC_TYPE_INT32, 3, RPC_TYPE_INVALID)) < 0) { + fprintf(stderr, "ERROR: failed to send ADD message [%d]\n", error); + return 0; + } + if ((error = rpc_method_wait_for_reply(connection, RPC_TYPE_INT32, &value, RPC_TYPE_INVALID)) < 0) { + fprintf(stderr, "ERROR: failed to receive ADD reply [%d]\n", error); + return 0; + } + printf(" result: %d\n", value); + printf(" done\n"); + + printf("Call ECHO\n"); + const char *str = "Coucou"; + if ((error = rpc_method_invoke(connection, TEST_RPC_METHOD_ECHO, RPC_TYPE_STRING, str, RPC_TYPE_INVALID)) < 0) { + fprintf(stderr, "ERROR: failed to send ECHO message [%d]\n", error); + return 0; + } + if ((error = rpc_method_wait_for_reply(connection, RPC_TYPE_INVALID)) < 0) { + fprintf(stderr, "ERROR: failed to receive ECHO ack [%d]\n", error); + return 0; + } + printf(" done\n"); + + printf("Call PRINT\n"); + error = rpc_method_invoke(connection, + TEST_RPC_METHOD_PRINT, + RPC_TYPE_STRING, "A string", + RPC_TYPE_UINT64, 0x0123456789abcdefull, + RPC_TYPE_DOUBLE, 3.14159265358979323846, + RPC_TYPE_INVALID); + if (error < 0) { + fprintf(stderr, "ERROR: failed to send PRINT message [%d]\n", error); + return 0; + } + if ((error = rpc_method_wait_for_reply(connection, RPC_TYPE_INVALID)) < 0) { + fprintf(stderr, "ERROR: failed to receive PRINT ack [%d]\n", error); + return 0; + } + printf(" done\n"); + + printf("Call STRINGS\n", str); + const char *strtab[] = { "un", "deux", "trois", "quatre" }; + if ((error = rpc_method_invoke(connection, TEST_RPC_METHOD_STRINGS, RPC_TYPE_ARRAY, RPC_TYPE_STRING, 4, strtab, RPC_TYPE_INVALID)) < 0) { + fprintf(stderr, "ERROR: failed to send STRINGS message [%d]\n", error); + return 0; + } + if ((error = rpc_method_wait_for_reply(connection, RPC_TYPE_INVALID)) < 0) { + fprintf(stderr, "ERROR: failed to receive STRINGS ack [%d]\n", error); + return 0; + } + printf(" done\n"); + + printf("Call POINTS\n", str); + const struct Point pttab[] = { + { -1, 0 }, + { 2, -1 }, + { 1, 4 }, + { -2, -2 } + }; + if ((error = rpc_method_invoke(connection, TEST_RPC_METHOD_POINTS, RPC_TYPE_ARRAY, RPC_TYPE_POINT, sizeof(pttab) / sizeof(pttab[0]), pttab, RPC_TYPE_INVALID)) < 0) { + fprintf(stderr, "ERROR: failed to send POINTS message [%d]\n", error); + return 0; + } + struct Point pt; + if ((error = rpc_method_wait_for_reply(connection, RPC_TYPE_POINT, &pt, RPC_TYPE_INVALID)) < 0) { + fprintf(stderr, "ERROR: failed to receive POINTS reply [%d]\n", error); + return 0; + } + printf(" result: { %d, %d }\n", pt.x, pt.y); + printf(" done\n"); + + printf("Call EXIT\n"); + if ((error = rpc_method_invoke(connection, TEST_RPC_METHOD_EXIT, RPC_TYPE_INVALID)) < 0) { + fprintf(stderr, "ERROR: failed to send EXIT message [%d]\n", error); + return 0; + } + if ((error = rpc_method_wait_for_reply(connection, RPC_TYPE_INVALID)) < 0) { + fprintf(stderr, "ERROR: failed to receive EXIT ack [%d]\n", error); + return 0; + } + printf(" done\n"); + + printf("Sleep 2 seconds\n"); + sleep(2); + + rpc_exit(connection); + printf("Client exitted\n"); + return 1; +} + +int main(void) +{ + sprintf(g_npn_connection_path, "/org/wrapper/NSPlugin/NPN/%d", getpid()); + sprintf(g_npp_connection_path, "/org/wrapper/NSPlugin/NPP/%d", getpid()); + + g_client_pid = fork(); + if (g_client_pid == 0) { + if (!run_client()) + return 1; + } + else { + if (!run_server()) + return 1; + } + return 0; +} +#endif diff --git a/src/rpc.h b/src/rpc.h new file mode 100644 index 0000000..a838b40 --- /dev/null +++ b/src/rpc.h @@ -0,0 +1,104 @@ +/* + * rpc.h - Remote Procedure Calls + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef RPC_H +#define RPC_H + +// Error Types +enum { + RPC_ERROR_NO_ERROR = 0, + RPC_ERROR_GENERIC = -1000, + RPC_ERROR_ERRNO_SET = -1001, + RPC_ERROR_NO_MEMORY = -1002, + RPC_ERROR_CONNECTION_NULL = -1003, + RPC_ERROR_CONNECTION_TYPE_MISMATCH = -1004, + RPC_ERROR_MESSAGE_TRUNCATED = -1005, + RPC_ERROR_MESSAGE_ARGUMENT_MISMATCH = -1006, + RPC_ERROR_MESSAGE_ARGUMENT_UNKNOWN = -1007, + RPC_ERROR_MESSAGE_ARGUMENT_INVALID = -1008, +}; +extern const char *rpc_strerror(int error) attribute_hidden; + +// Connection Handling +typedef struct rpc_connection_t rpc_connection_t; +extern rpc_connection_t *rpc_init_server(const char *ident) attribute_hidden; +extern rpc_connection_t *rpc_init_client(const char *ident) attribute_hidden; +extern int rpc_exit(rpc_connection_t *connection) attribute_hidden; +extern int rpc_listen_socket(rpc_connection_t *connection) attribute_hidden; +extern int rpc_listen(rpc_connection_t *connection) attribute_hidden; +extern int rpc_dispatch(rpc_connection_t *connection) attribute_hidden; +extern int rpc_wait_dispatch(rpc_connection_t *connection, int timeout) attribute_hidden; +extern int rpc_connection_busy(rpc_connection_t *connection) attribute_hidden; +extern int rpc_socket(rpc_connection_t *connection) attribute_hidden; + +// Message Passing +enum { + RPC_TYPE_INVALID = 0, + RPC_TYPE_CHAR = -2000, + RPC_TYPE_BOOLEAN = -2001, + RPC_TYPE_INT32 = -2002, + RPC_TYPE_UINT32 = -2003, + RPC_TYPE_UINT64 = -2004, + RPC_TYPE_DOUBLE = -2005, + RPC_TYPE_STRING = -2006, + RPC_TYPE_ARRAY = -2007, +}; +typedef struct rpc_message_t rpc_message_t; +extern int rpc_message_send_char(rpc_message_t *message, char c) attribute_hidden; +extern int rpc_message_send_int32(rpc_message_t *message, int32_t value) attribute_hidden; +extern int rpc_message_send_uint32(rpc_message_t *message, uint32_t value) attribute_hidden; +extern int rpc_message_send_uint64(rpc_message_t *message, uint64_t value) attribute_hidden; +extern int rpc_message_send_double(rpc_message_t *message, double value) attribute_hidden; +extern int rpc_message_send_string(rpc_message_t *message, const char *str) attribute_hidden; +extern int rpc_message_send_bytes(rpc_message_t *message, unsigned char *bytes, int count) attribute_hidden; +extern int rpc_message_recv_char(rpc_message_t *message, char *ret) attribute_hidden; +extern int rpc_message_recv_int32(rpc_message_t *message, int32_t *ret) attribute_hidden; +extern int rpc_message_recv_uint32(rpc_message_t *message, uint32_t *ret) attribute_hidden; +extern int rpc_message_recv_uint64(rpc_message_t *message, uint64_t *ret) attribute_hidden; +extern int rpc_message_recv_double(rpc_message_t *message, double *ret) attribute_hidden; +extern int rpc_message_recv_string(rpc_message_t *message, char **ret) attribute_hidden; +extern int rpc_message_recv_bytes(rpc_message_t *message, unsigned char *bytes, int count) attribute_hidden; +typedef int (*rpc_message_callback_t)(rpc_message_t *message, void *p_value); +typedef struct { + int id; + int size; + rpc_message_callback_t send_callback; + rpc_message_callback_t recv_callback; +} rpc_message_descriptor_t; +extern int rpc_message_add_callbacks(const rpc_message_descriptor_t *descs, int n_descs) attribute_hidden; + +// Method Callbacks Handling +typedef int (*rpc_method_callback_t)(rpc_connection_t *connection); +typedef struct { + int id; + rpc_method_callback_t callback; +} rpc_method_descriptor_t; +extern int rpc_method_add_callbacks(rpc_connection_t *connection, const rpc_method_descriptor_t *descs, int n_descs) attribute_hidden; +extern int rpc_method_remove_callback_id(rpc_connection_t *connection, int id) attribute_hidden; +extern int rpc_method_remove_callbacks(rpc_connection_t *connection, const rpc_method_descriptor_t *descs, int n_descs) attribute_hidden; + +// Remote Procedure Call (method invocation) +extern int rpc_method_invoke(rpc_connection_t *connection, int method, ...) attribute_hidden; +extern int rpc_method_invoke_delayed(rpc_connection_t *connection, int method, ...) attribute_hidden; +extern int rpc_method_wait_for_reply(rpc_connection_t *connection, ...) attribute_hidden; +extern int rpc_method_get_args(rpc_connection_t *connection, ...) attribute_hidden; +extern int rpc_method_send_reply(rpc_connection_t *connection, ...) attribute_hidden; + +#endif /* RPC_H */ diff --git a/src/sysdeps.h b/src/sysdeps.h new file mode 100644 index 0000000..4c5ddc0 --- /dev/null +++ b/src/sysdeps.h @@ -0,0 +1,84 @@ +/* + * sysdeps.h - System dependent definitions + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef SYSDEPS_H +#define SYSDEPS_H + +#if !defined(__STDC__) || (__STDC_VERSION__ < 199901L) +#error "Your compiler is not ISO. Get a real one." +#endif + +#include "config.h" + +/* XXX detect popen() et al. at configure time */ +#define _XOPEN_SOURCE 600 + +#include +#include +#include +#include +#include +#include + +// NSPluginWrapper paths and identification strings +#define NPW_CONNECTION_PATH "/org/wrapper/NSPlugins" +#define NPW_VIEWER_BASE "npviewer" +#define NPW_VIEWER NPW_VIEWER_BASE +#define NPW_WRAPPER_BASE "npwrapper" +#define NPW_WRAPPER NPW_WRAPPER_BASE ".so" +#define NPW_OLD_DEFAULT_PLUGIN_PATH NPW_LIBDIR "/" HOST_ARCH "/" NPW_WRAPPER +#define NPW_DEFAULT_PLUGIN_PATH NPW_LIBDIR "/" HOST_ARCH "/" HOST_OS "/" NPW_WRAPPER +#define NPW_PLUGIN_IDENT "NPW:" NPW_VERSION +#define NPW_PLUGIN_IDENT_SIZE 32 +typedef struct __attribute__((packed)) { + char ident[NPW_PLUGIN_IDENT_SIZE]; + char path[PATH_MAX]; + time_t mtime; + char target_arch[65]; + char target_os[65]; +} NPW_PluginInfo; + +#if defined(BUILD_XPCOM) +#define NPW_COMPONENT_NAME "XPCOM " +#elif defined(BUILD_WRAPPER) +#define NPW_COMPONENT_NAME "Wrapper" +#elif defined(BUILD_VIEWER) +#define NPW_COMPONENT_NAME "Viewer " +#endif + +// Boolean types +#ifndef __cplusplus +#ifdef HAVE_STDBOOL_H +#include +#else +#ifndef __bool_true_false_are_defined +#define __bool_true_false_are_defined 1 +#define bool _Bool +#ifndef true +#define true 1 +#endif +#ifndef false +#define false 0 +#endif +#endif +#endif +#endif + +#endif /* SYSDEPS_H */ diff --git a/src/utils.c b/src/utils.c new file mode 100644 index 0000000..a553e47 --- /dev/null +++ b/src/utils.c @@ -0,0 +1,272 @@ +/* + * utils.c - Utility functions + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "sysdeps.h" + +#include +#include +#include +#include /* */ + +#include "utils.h" +#include "rpc.h" + +#ifndef TEST_UTILS +#define XP_UNIX 1 +#define MOZ_X11 1 +#include +#endif + +#define DEBUG 1 +#include "debug.h" + + +/* ====================================================================== */ +/* === Hashes === */ +/* ====================================================================== */ + +static GHashTable *g_ids; + +static inline void *id_key(uint32_t id) +{ + return (void *)(uintptr_t)id; +} + +bool id_init(void) +{ + return (g_ids = g_hash_table_new(NULL, NULL)) != NULL; +} + +void id_kill(void) +{ + if (g_ids) { + g_hash_table_destroy(g_ids); + g_ids = NULL; + } +} + +void id_link(int id, void *ptr) +{ + g_hash_table_insert(g_ids, id_key(id), ptr); +} + +int id_create(void *ptr) +{ + static int id = 0; + id_link(++id, ptr); + return id; +} + +bool id_remove(int id) +{ + return g_hash_table_remove(g_ids, id_key(id)); +} + +void *id_lookup(int id) +{ + return g_hash_table_lookup(g_ids, id_key(id)); +} + +static gboolean id_match_value(gpointer key, gpointer value, gpointer user_data) +{ + if (value == *(gpointer *)user_data) { + *(int *)user_data = (uintptr_t)key; + return true; + } + return false; +} + +int id_lookup_value(void *ptr) +{ + return g_hash_table_find(g_ids, id_match_value, &ptr) ? (uintptr_t)ptr : -1; +} + + +/* ====================================================================== */ +/* === String expansions === */ +/* ====================================================================== */ + +#ifndef TEST_UTILS +const char *string_of_NPError(int error) +{ + const char *str; + + switch ((NPError)error) { +#define _(VAL) case VAL: str = #VAL; break; + _(NPERR_NO_ERROR); + _(NPERR_GENERIC_ERROR); + _(NPERR_INVALID_INSTANCE_ERROR); + _(NPERR_INVALID_FUNCTABLE_ERROR); + _(NPERR_MODULE_LOAD_FAILED_ERROR); + _(NPERR_OUT_OF_MEMORY_ERROR); + _(NPERR_INVALID_PLUGIN_ERROR); + _(NPERR_INVALID_PLUGIN_DIR_ERROR); + _(NPERR_INCOMPATIBLE_VERSION_ERROR); + _(NPERR_INVALID_PARAM); + _(NPERR_INVALID_URL); + _(NPERR_FILE_NOT_FOUND); + _(NPERR_NO_DATA); + _(NPERR_STREAM_NOT_SEEKABLE); +#undef _ + default: + str = ""; + break; + } + + return str; +} + +const char *string_of_NPReason(int reason) +{ + const char *str; + + switch ((NPReason)reason) { +#define _(VAL) case VAL: str = #VAL; break; + _(NPRES_DONE); + _(NPRES_NETWORK_ERR); + _(NPRES_USER_BREAK); +#undef _ + default: + str = ""; + break; + } + + return str; +} + +const char *string_of_NPStreamType(int stype) +{ + const char *str; + + switch (stype) { +#define _(VAL) case VAL: str = #VAL; break; + _(NP_NORMAL); + _(NP_SEEK); + _(NP_ASFILE); + _(NP_ASFILEONLY); +#undef _ + default: + str = ""; + break; + } + + return str; +} +#endif + + +/* ====================================================================== */ +/* === Misc utility functions === */ +/* ====================================================================== */ + +void npw_perror(const char *prefix, int error) +{ + if (prefix && *prefix) + npw_printf("ERROR: %s: %s\n", prefix, npw_strerror(error)); + else + npw_printf("ERROR: %s\n", npw_strerror(error)); +} + +const char *npw_strerror(int error) +{ + if (error > -1100 && error <= -1000) // RPC errors + return rpc_strerror(error); + + switch (error) { + case 0: return "No error"; + } + + return "Unknown error"; +} + + +/* ====================================================================== */ +/* === Test Program === */ +/* ====================================================================== */ + +#ifdef TEST_UTILS +int main(void) +{ + char *str; + int i, id; + + id_init(); + +#define N_CELLS_PER_SLOT 8 +#define N_STRINGS ((2 * N_CELLS_PER_SLOT) + 3) + char *strings[N_STRINGS]; + int ids[N_STRINGS]; + + for (i = 0; i < N_STRINGS; i++) { + str = malloc(10); + sprintf(str, "%d", i); + strings[i] = str; + id = id_create(str); + if (id < 0) { + fprintf(stderr, "ERROR: failed to allocate ID for '%s'\n", str); + return 1; + } + ids[i] = id; + } + + // basic lookup + id = ids[N_CELLS_PER_SLOT / 2]; + str = id_lookup(id); + printf("str(%d) : '%s'\n", id, str); + + // basic unlink + id = ids[N_CELLS_PER_SLOT]; + if (id_remove(id) < 0) { + fprintf(stderr, "ERROR: failed to unlink ID %d\n", id); + return 1; + } + ids[N_CELLS_PER_SLOT] = 0; + + // remove slot 1 + for (i = 0; i < N_CELLS_PER_SLOT; i++) { + id = ids[N_CELLS_PER_SLOT + i]; + if (id && id_remove(id) < 0) { + fprintf(stderr, "ERROR: failed to unlink ID %d from slot 1\n", id); + return 1; + } + ids[N_CELLS_PER_SLOT + i] = 0; + } + + // basic lookup after slot removal + id = ids[2 * N_CELLS_PER_SLOT]; + str = id_lookup(id); + printf("str(%d) : '%s'\n", id, str); + + // check slot 1 was removed and slots 0 & 2 linked together + for (i = 0; i < N_STRINGS; i++) { + id = ids[i]; + if (id && id_remove(id) < 0) { + fprintf(stderr, "ERROR: failed to unlink ID %d for final cleanup\n", id); + return 1; + } + } + + for (i = 0; i < N_STRINGS; i++) + free(strings[i]); + + id_kill(); + return 0; +} +#endif diff --git a/src/utils.h b/src/utils.h new file mode 100644 index 0000000..1ca225a --- /dev/null +++ b/src/utils.h @@ -0,0 +1,42 @@ +/* + * utils.h - Utility functions + * + * nspluginwrapper (C) 2005-2006 Gwenole Beauchesne + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef UTILS_H +#define UTILS_H + +// Hashes +extern bool id_init(void) attribute_hidden; +extern void id_kill(void) attribute_hidden; +extern void id_link(int id, void *ptr) attribute_hidden; +extern int id_create(void *ptr) attribute_hidden; +extern bool id_remove(int id) attribute_hidden; +extern void *id_lookup(int id) attribute_hidden; +extern int id_lookup_value(void *ptr) attribute_hidden; + +// String expansions +extern const char *string_of_NPError(int error) attribute_hidden; +extern const char *string_of_NPReason(int reason) attribute_hidden; +extern const char *string_of_NPStreamType(int stype) attribute_hidden; + +// Misc utility functions +extern void npw_perror(const char *prefix, int error) attribute_hidden; +extern const char *npw_strerror(int error) attribute_hidden; + +#endif /* UTILS_H */ diff --git a/tests/test-plugins.html b/tests/test-plugins.html new file mode 100644 index 0000000..ef4bfbf --- /dev/null +++ b/tests/test-plugins.html @@ -0,0 +1,32 @@ + + +nspluginwrapper external testsuite + + +Various sample data to exercise the NPAPI plugins compatibility layer + + + diff --git a/utils/getdeps.sh b/utils/getdeps.sh new file mode 100755 index 0000000..a78c5f5 --- /dev/null +++ b/utils/getdeps.sh @@ -0,0 +1,73 @@ +#!/bin/bash +# +# getdeps.sh - get dependent libs of a program +# +# nspluginwrapper (C) 2005-2006 Gwenole Beauchesne +# + +# FIXME: needs pango config files, extra X11 libraries, etc. Thus it's +# better to rewrite the script so that to install from the actual RPMs... + +function fatal_error() { + echo "Error:" ${1+"$@"} >/dev/stderr + exit 1 +} + +if [[ $# -ne 1 ]]; then + echo "Usage: $0 " + exit 1 +fi + +FILE=$1 +[[ -f "$FILE" ]] || fatal_error "specified program $file does not exist" + +nLIBS=0 +declare -a LIBS + +nDEPS=0 +declare -a DEPS + +function path_find() { + local var=$1 + local path=$2 + eval "echo \" \${$var[*]} \"" | grep -q $path +} + +function path_add() { + local var=$1 + local path=$2 + path_find $var $path || { + eval "$var[n$var]=$path ; n$var=\$((n$var+1))" + [[ -L $path ]] && { + link=`readlink $path` + case $link in + /*|../*) + fatal_error "links to files in other paths are not supported" + ;; + *) + link="`dirname $path`/$link" + esac + eval "$var[n$var]=$link ; n$var=\$((n$var+1))" + } + } +} + +function get_deps() { + local file=$1 + path_find LIBS $file || { + path_add LIBS $file + local paths=`ldd $file | sed -n '/^[^l]*\(lib[^ ]*\) => \(\/[^ ]*\).*/s//\2/p'` + for fullpath in $paths; do + local path=`echo $fullpath | sed -e 's/\(\/lib[0-9]*\)\/\(tls\|i686\|mmx\|sse[23]*\)/\1/'` + path_add DEPS $path + get_deps $path + done + } +} + +ldso=`ldd $FILE | sed -n '/^[^\/]*\(\/[^ ]*ld-[^ ]*\) .*/s//\1/p'` +path_add DEPS $ldso + +get_deps $FILE +echo ${DEPS[*]} +exit 0 diff --git a/utils/mkruntime.sh b/utils/mkruntime.sh new file mode 100755 index 0000000..d30c835 --- /dev/null +++ b/utils/mkruntime.sh @@ -0,0 +1,84 @@ +#!/bin/sh +# +# mkruntime.sh - prepare QEMU runtime from Mandriva Linux 2006.0 +# +# nspluginwrapper (C) 2005-2006 Gwenole Beauchesne +# + +# Usage: mkruntime +# unpacks RPMs to /usr/gnemul/qemu-i386/ +# +# Notes: +# - Check acroread5, something is missing while loading a PDF +# - Enough for Flash Player & PluginSDK npsimple.so + +function error() { + echo ${1+"$@"} > /dev/stderr +} + +function status() { + echo ${1+"$@"} > /dev/stderr +} + +function run() { + status " " ${1+"$@"} + ${1+"$@"} +} + +RPMS=$1 +[[ -d "$RPMS" ]] || { error "unspecified RPMs dir"; exit 1; } + +ARCH=$2 +[[ -n "$ARCH" ]] || ARCH="i386" + +ROOT=$3 +[[ -d "$ROOT" ]] || ROOT="/usr/gnemul/qemu-$ARCH" + +QEMU="qemu-$ARCH" +[[ -x "`which $QEMU`" ]] || { error "inexistent QEMU for $ARCH in PATH"; exit 1; } +QEMU="$QEMU -L $ROOT" + +files="$files glibc-[0-9]* ldconfig-[0-9]*" +files="$files zlib1-[0-9]* libbzip2_[0-9]-[0-9]*" +files="$files bash-[0-9]* libtermcap2-[0-9]* libslang1-[0-9]*" +files="$files libstdc++5-[0-9]*" +files="$files libxorg-x11-[0-9]*" +files="$files fontconfig-[0-9]* libfontconfig1-[0-9]* libfreetype6-[0-9]*" +files="$files libxml2-[0-9]* libexpat0-[0-9]* libxslt1-[0-9]*" +files="$files libjpeg62-[0-9]* libpng3-[0-9]*" +files="$files libaudiofile0-[0-9]* libesound0-[0-9]*" +files="$files libglib2.0_0-[0-9]* libgtk+2.0_0-[0-9]* libgtk+-x11-2.0_0-[0-9]*" +files="$files libgdk_pixbuf2.0_0-[0-9]*" +files="$files libatk1.0_0-[0-9]* libcairo2-[0-9]*" +files="$files pango-[0-9]* libpango1.0_0-[0-9]* libpango1.0_0-modules-[0-9]*" + +mkdir -p $ROOT +pushd $ROOT >& /dev/null +for file in $(cd $RPMS && echo $files); do + echo "Processing $file" > /dev/stderr + rpm2cpio $RPMS/$file | cpio -id >& /dev/null +done +popd $ROOT >& /dev/null + +find $ROOT -type d -name tls | xargs rm -rf + +echo "Regenerating ld.so.cache" +echo "/usr/X11R6/lib" >> $ROOT/etc/ld.so.conf +run touch $ROOT/etc/ld.so.cache +run $QEMU $ROOT/sbin/ldconfig -C $ROOT/etc/ld.so.cache + +echo "Regenerating fontconfig cache" +run $QEMU $ROOT/usr/bin/fc-cache -f + +echo "Regenerating pango cache" +for file in $ROOT/usr/lib/pango/*/modules/*.so; do + case $file in + */pango-basic*.so);; + *) run rm -f $file;; + esac +done +if [[ "$ARCH" = "i386" ]]; then + run $QEMU $ROOT/usr/bin/pango-querymodules-32 > $ROOT/etc/pango/i386/pango.modules +else + run $QEMU $ROOT/usr/bin/pango-querymodules > $ROOT/etc/pango/pango.modules +fi diff --git a/utils/npw-shadow.c b/utils/npw-shadow.c new file mode 100644 index 0000000..de2cfaf --- /dev/null +++ b/utils/npw-shadow.c @@ -0,0 +1,1069 @@ +#define _GNU_SOURCE 1 +#include "sysdeps.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#define XP_UNIX 1 +#define MOZ_X11 1 +#include +#include + +#define DEBUG 1 +#include "debug.h" + + +// XXX unimplemented functions +#define UNIMPLEMENTED() npw_printf("WARNING: Unimplemented function %s at line %d\n", __func__, __LINE__) + +// Path to plugin to use +static const char *g_plugin_path = "/home/gb/npshadow-impl.so"; + +// Netscape exported functions +static NPNetscapeFuncs g_mozilla_funcs; + +// Functions supplied by the plug-in +static NPPluginFuncs g_plugin_funcs; + +// Plugin instance +typedef struct { + NPP instance; + NPP npn_instance; + Window old_window; + Window window; + Widget top_widget; + Widget form; + int width, height; +} PluginInstance; + +// Plugin implementation +static int g_plugin_initialized = 0; +static void *g_plugin_handle = NULL; + +// Allows the browser to query the plug-in supported formats +typedef char * (*NP_GetMIMEDescriptionUPP)(void); +static NP_GetMIMEDescriptionUPP g_NP_GetMIMEDescription = NULL; + +// Allows the browser to query the plug-in for information +typedef NPError (*NP_GetValueUPP)(void *instance, NPPVariable variable, void *value); +static NP_GetValueUPP g_NP_GetValue = NULL; + +// Provides global initialization for a plug-in +typedef NPError (*NP_InitializeUPP)(NPNetscapeFuncs *moz_funcs, NPPluginFuncs *plugin_funcs); +static NP_InitializeUPP g_NP_Initialize = NULL; + +// Provides global deinitialization for a plug-in +typedef NPError (*NP_ShutdownUPP)(void); +static NP_ShutdownUPP g_NP_Shutdown = NULL; + + +/* ====================================================================== */ +/* === X Toolkit glue === */ +/* ====================================================================== */ + +static Display *x_display; +static XtAppContext x_app_context; + +typedef struct _XtTMRec { + XtTranslations translations; /* private to Translation Manager */ + XtBoundActions proc_table; /* procedure bindings for actions */ + struct _XtStateRec *current_state; /* Translation Manager state ptr */ + unsigned long lastEventTime; +} XtTMRec, *XtTM; + +typedef struct _CorePart { + Widget self; /* pointer to widget itself */ + WidgetClass widget_class; /* pointer to Widget's ClassRec */ + Widget parent; /* parent widget */ + XrmName xrm_name; /* widget resource name quarkified */ + Boolean being_destroyed; /* marked for destroy */ + XtCallbackList destroy_callbacks; /* who to call when widget destroyed */ + XtPointer constraints; /* constraint record */ + Position x, y; /* window position */ + Dimension width, height; /* window dimensions */ + Dimension border_width; /* window border width */ + Boolean managed; /* is widget geometry managed? */ + Boolean sensitive; /* is widget sensitive to user events*/ + Boolean ancestor_sensitive; /* are all ancestors sensitive? */ + XtEventTable event_table; /* private to event dispatcher */ + XtTMRec tm; /* translation management */ + XtTranslations accelerators; /* accelerator translations */ + Pixel border_pixel; /* window border pixel */ + Pixmap border_pixmap; /* window border pixmap or NULL */ + WidgetList popup_list; /* list of popups */ + Cardinal num_popups; /* how many popups */ + String name; /* widget resource name */ + Screen *screen; /* window's screen */ + Colormap colormap; /* colormap */ + Window window; /* window ID */ + Cardinal depth; /* number of planes in window */ + Pixel background_pixel; /* window background pixel */ + Pixmap background_pixmap; /* window background pixmap or NULL */ + Boolean visible; /* is window mapped and not occluded?*/ + Boolean mapped_when_managed;/* map window if it's managed? */ +} CorePart; + +typedef struct _WidgetRec { + CorePart core; +} WidgetRec, CoreRec; + + +/* ====================================================================== */ +/* === Plugin glue === */ +/* ====================================================================== */ + +// Initialize plugin wrapper +static void __attribute__((constructor)) +plugin_init(void) +{ + if (g_plugin_initialized) + return; + + D(bug("plugin_init\n")); + + XtToolkitInitialize(); + x_app_context = XtCreateApplicationContext(); + int argc = 0; + x_display = XtOpenDisplay(x_app_context, NULL, "npw-viewer", "npw-viewer", NULL, 0, &argc, NULL); + + if ((g_plugin_handle = dlopen(g_plugin_path, RTLD_LAZY)) == NULL) { + npw_printf("ERROR: %s\n", dlerror()); + g_plugin_initialized = -1; + return; + } + { + const char *error; + dlerror(); + g_NP_GetMIMEDescription = (NP_GetMIMEDescriptionUPP)dlsym(g_plugin_handle, "NP_GetMIMEDescription"); + if ((error = dlerror()) != NULL) { + npw_printf("ERROR: %s\n", error); + g_plugin_initialized = -1; + return; + } + g_NP_Initialize = (NP_InitializeUPP)dlsym(g_plugin_handle, "NP_Initialize"); + if ((error = dlerror()) != NULL) { + npw_printf("ERROR: %s\n", error); + g_plugin_initialized = -1; + return; + } + g_NP_Shutdown = (NP_ShutdownUPP)dlsym(g_plugin_handle, "NP_Shutdown"); + if ((error = dlerror()) != NULL) { + npw_printf("ERROR: %s\n", error); + g_plugin_initialized = -1; + return; + } + g_NP_GetValue = (NP_GetValueUPP)dlsym(g_plugin_handle, "NP_GetValue"); + } + + g_plugin_initialized = 1; +} + +// Kill plugin wrapper +static void __attribute__((destructor)) +plugin_exit(void) +{ + D(bug("plugin_exit\n")); + + if (g_plugin_handle) + dlclose(g_plugin_handle); +} + + +/* ====================================================================== */ +/* === Browser side plug-in API === */ +/* ====================================================================== */ + +// Closes and deletes a stream +NPError +g_NPN_DestroyStream(NPP instance, NPStream *stream, NPError reason) +{ + D(bug("NPN_DestroyStream instance=%p\n", instance)); + UNIMPLEMENTED(); + + return NPERR_GENERIC_ERROR; +} + +// Forces a repaint message for a windowless plug-in +void +g_NPN_ForceRedraw(NPP instance) +{ + D(bug("NPN_ForceRedraw instance=%p\n", instance)); + UNIMPLEMENTED(); +} + +// Asks the browser to create a stream for the specified URL +NPError +g_NPN_GetURL(NPP instance, const char *url, const char *target) +{ + D(bug("NPN_GetURL instance=%p\n", instance)); + + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + PluginInstance *plugin = instance->ndata; + + if (!g_mozilla_funcs.geturl) + return NPERR_GENERIC_ERROR; + + D(bug(" instance=%p, url='%s', target='%s'\n", plugin->npn_instance, url, target)); + NPError ret = g_mozilla_funcs.geturl(plugin->npn_instance, url, target); + + D(bug(" return: %d\n", ret)); + return ret; +} + +// Requests creation of a new stream with the contents of the specified URL +NPError +g_NPN_GetURLNotify(NPP instance, const char *url, const char *target, void *notifyData) +{ + D(bug("NPN_GetURLNotify instance=%p\n", instance)); + + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + PluginInstance *plugin = instance->ndata; + + NPP the_instance; + if (plugin->instance->pdata == plugin) + the_instance = plugin->npn_instance; + else + the_instance = instance; + + if (!g_mozilla_funcs.geturlnotify) + return NPERR_GENERIC_ERROR; + + D(bug(" instance=%p, url='%s', target='%s', notifyData=%p\n", the_instance, url, target, notifyData)); + NPError ret = g_mozilla_funcs.geturlnotify(plugin->npn_instance, url, target, notifyData); + + D(bug(" return: %d\n", ret)); + return ret; +} + +// Allows the plug-in to query the browser for information +NPError +g_NPN_GetValue(NPP instance, NPNVariable variable, void *value) +{ + D(bug("NPN_GetValue instance=%p, variable=%d\n", instance, variable)); + +#if 0 + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + PluginInstance *plugin = instance->ndata; + + if (!g_mozilla_funcs.getvalue) + return NPERR_GENERIC_ERROR; + + NPError ret = g_mozilla_funcs.getvalue(plugin->npn_instance, variable, value); +#else + NPError ret; + switch (variable) { + case NPNVxDisplay: + *(void **)value = x_display; + ret = NPERR_NO_ERROR; + break; + case NPNVxtAppContext: + *(void **)value = XtDisplayToApplicationContext(x_display); + ret = NPERR_NO_ERROR; + break; + default: + npw_printf("WARNING: unhandled variable %d for NPN_GetValue\n", variable); + ret = NPERR_INVALID_PARAM; + } +#endif + + D(bug(" return: %d\n", ret)); + return ret; +} + +// Invalidates specified drawing area prior to repainting or refreshing a windowless plug-in +void +g_NPN_InvalidateRect(NPP instance, NPRect *invalidRect) +{ + D(bug("NPN_InvalidateRect instance=%p\n", instance)); + UNIMPLEMENTED(); +} + +// Invalidates specified region prior to repainting or refreshing a windowless plug-in +void +g_NPN_InvalidateRegion(NPP instance, NPRegion invalidRegion) +{ + D(bug("NPN_InvalidateRegion instance=%p\n", instance)); + UNIMPLEMENTED(); +} + +// Allocates memory from the browser's memory space +void * +g_NPN_MemAlloc(uint32 size) +{ + D(bug("NPN_MemAlloc size=%d\n", size)); + + return malloc(size); +} + +// Requests that the browser free a specified amount of memory +uint32 +g_NPN_MemFlush(uint32 size) +{ + D(bug("NPN_MemFlush size=%d\n", size)); + UNIMPLEMENTED(); + + return 0; +} + +// Deallocates a block of allocated memory +void +g_NPN_MemFree(void *ptr) +{ + D(bug("NPN_MemFree ptr=%p\n", ptr)); + + free(ptr); +} + +// Requests the creation of a new data stream produced by the plug-in and consumed by the browser +NPError +g_NPN_NewStream(NPP instance, NPMIMEType type, const char *target, NPStream **stream) +{ + D(bug("NPN_NewStream instance=%p\n", instance)); + UNIMPLEMENTED(); + + return NPERR_GENERIC_ERROR; +} + +// Posts data to a URL +NPError +g_NPN_PostURL(NPP instance, const char *url, const char *target, uint32 len, const char *buf, NPBool file) +{ + D(bug("NPN_PostURL instance=%p\n", instance)); + UNIMPLEMENTED(); + + return NPERR_GENERIC_ERROR; +} + +// Posts data to a URL, and receives notification of the result +NPError +g_NPN_PostURLNotify(NPP instance, const char *url, const char *target, uint32 len, const char *buf, NPBool file, void *notifyData) +{ + D(bug("NPN_PostURLNotify instance=%p\n", instance)); + UNIMPLEMENTED(); + + return NPERR_GENERIC_ERROR; +} + +// Posts data to a URL, and receives notification of the result +void +g_NPN_ReloadPlugins(NPBool reloadPages) +{ + D(bug("NPN_ReloadPlugins reloadPages=%d\n", reloadPages)); + UNIMPLEMENTED(); +} + +// Returns the Java execution environment +JRIEnv * +g_NPN_GetJavaEnv(void) +{ + D(bug("NPN_GetJavaEnv\n")); + UNIMPLEMENTED(); + + return NULL; +} + +// Returns the Java object associated with the plug-in instance +jref +g_NPN_GetJavaPeer(NPP instance) +{ + D(bug("NPN_GetJavaPeer instance=%p\n", instance)); + UNIMPLEMENTED(); + + return NULL; +} + +// Requests a range of bytes for a seekable stream +NPError +g_NPN_RequestRead(NPStream *stream, NPByteRange *rangeList) +{ + D(bug("NPN_RequestRead stream=%p\n", stream)); + UNIMPLEMENTED(); + + return NPERR_GENERIC_ERROR; +} + +// Sets various modes of plug-in operation +NPError +g_NPN_SetValue(NPP instance, NPPVariable variable, void *value) +{ + D(bug("NPN_SetValue instance=%p\n", instance)); + UNIMPLEMENTED(); + + return NPERR_GENERIC_ERROR; +} + +// Displays a message on the status line of the browser window +void +g_NPN_Status(NPP instance, const char *message) +{ + D(bug("NPN_Status instance=%p\n", instance)); + + if (instance == NULL) + return; + + PluginInstance *plugin = instance->ndata; + + if (!g_mozilla_funcs.status) + return; + + g_mozilla_funcs.status(plugin->npn_instance, message); +} + +// Returns the browser's user agent field +const char * +g_NPN_UserAgent(NPP instance) +{ + D(bug("NPN_UserAgent instance=%p\n", instance)); + + NPP my_instance = NULL; + if (instance) + my_instance = ((PluginInstance *)instance->ndata)->npn_instance; + + if (!g_mozilla_funcs.uagent) + return NULL; + + // const char *user_agent = g_mozilla_funcs.uagent(my_instance); + const char *user_agent = NULL; + + D(bug(" user_agent='%s'\n", user_agent)); + return user_agent; +} + +// Returns version information for the Plug-in API +void +g_NPN_Version(int *plugin_major, int *plugin_minor, int *netscape_major, int *netscape_minor) +{ + D(bug("NPN_Version\n")); + UNIMPLEMENTED(); +} + +// Pushes data into a stream produced by the plug-in and consumed by the browser +int32 +g_NPN_Write(NPP instance, NPStream *stream, int32 len, void *buf) +{ + D(bug("NPN_Write instance=%d\n", instance)); + UNIMPLEMENTED(); + + return -1; +} + + +/* ====================================================================== */ +/* === Plug-in side data === */ +/* ====================================================================== */ + +// Creates a new instance of a plug-in +static NPError +g_NPP_New(NPMIMEType mime_type, NPP instance, + uint16_t mode, int16_t argc, char *argn[], char *argv[], + NPSavedData *saved) +{ + D(bug("NPP_New instance=%p\n", instance)); + + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + if (!g_plugin_funcs.newp) + return NPERR_GENERIC_ERROR; + + if ((uintptr_t)instance > 0xffffffffUL) { + npw_printf("ERROR: FIXME: 64-bit instance doesn't fit!\n"); + return NPERR_GENERIC_ERROR; + } + + if (saved) + npw_printf("WARNING: NPP_New with non-null saved arguments\n"); + + PluginInstance *plugin = malloc(sizeof(*plugin)); + if (plugin == NULL) + return NPERR_OUT_OF_MEMORY_ERROR; + memset(plugin, 0, sizeof(*plugin)); + plugin->instance = malloc(sizeof(*plugin->instance)); + if (plugin->instance == NULL) + return NPERR_OUT_OF_MEMORY_ERROR; + plugin->instance->ndata = plugin; + + instance->pdata = (void *)plugin; + plugin->npn_instance = instance; + NPError ret = g_plugin_funcs.newp(mime_type, plugin->instance, mode, argc, argn, argv, saved); + if (plugin->npn_instance != instance) + npw_printf("############# OOOFDOFDF \n"); + D(bug(" plugin instance: %p\n", plugin->instance)); + instance->pdata = (void *)plugin; + plugin->npn_instance = instance; + + D(bug(" return: %d\n", ret)); + return ret; +} + +// Deletes a specific instance of a plug-in +static NPError +g_NPP_Destroy(NPP instance, NPSavedData **save) +{ + D(bug("NPP_Destroy instance=%p\n", instance)); + + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + PluginInstance *plugin = instance->pdata; + + if (!g_plugin_funcs.destroy) + return NPERR_GENERIC_ERROR; + + NPError ret = g_plugin_funcs.destroy(plugin->instance, save); + free(plugin->instance); + + D(bug(" return: %d\n", ret)); + return ret; +} + +// Tells the plug-in when a window is created, moved, sized, or destroyed +static NPError +g_NPP_SetWindow(NPP instance, NPWindow *io_window) +{ + D(bug("NPP_SetWindow instance=%p\n", instance)); + + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + PluginInstance *plugin = instance->pdata; + + if (!g_plugin_funcs.setwindow) + return NPERR_GENERIC_ERROR; + + if (io_window == NULL) + npw_printf("NULL window\n"); + + if (io_window == NULL) + return NPERR_NO_ERROR; + +#if 0 + NPWindow the_window, *window = &the_window; + window->window = io_window->window; + window->x = io_window->x; + window->y = io_window->y; + window->width = io_window->width; + window->height = io_window->height; + window->type = io_window->type; + window->clipRect.top = io_window->clipRect.top; + window->clipRect.left = io_window->clipRect.left; + window->clipRect.bottom = io_window->clipRect.bottom; + window->clipRect.right = io_window->clipRect.right; + + NPSetWindowCallbackStruct *io_ws_info = io_window->ws_info; + + NPSetWindowCallbackStruct the_ws_info, *ws_info = &the_ws_info; + window->ws_info = ws_info; + ws_info->type = io_ws_info->type; + ws_info->depth = io_ws_info->depth; + ws_info->display = x_display; + XVisualInfo visualInfo; + int screen = DefaultScreen(ws_info->display); + if (!XMatchVisualInfo(ws_info->display, screen, ws_info->depth, io_ws_info->visual->class, &visualInfo)) { + npw_printf("ERROR: could not reconstruct visual info for NPP_SetWindow\n"); + return NPERR_GENERIC_ERROR; + } + ws_info->colormap = DefaultColormap(ws_info->display, screen); + ws_info->visual = visualInfo.visual; + +#if 0 + ws_info->display = io_ws_info->display; + ws_info->visual = io_ws_info->visual; + ws_info->colormap = io_ws_info->colormap; +#endif + + D(bug(" window size = %d x %d\n", window->width, window->height)); + +#if 1 + if (plugin->window) { + if (plugin->width != window->width || plugin->height != window->height) { + D(bug(" resize window\n")); + plugin->width = window->width; + plugin->height = window->height; + XResizeWindow(x_display, plugin->window, plugin->width, plugin->height); + } + } + else { + Arg args[7]; + XSetWindowAttributes attr; + unsigned long mask; + int n; + Widget top_widget, form; + + mask = CWEventMask; + attr.event_mask = + ButtonMotionMask | + ButtonPressMask | + ButtonReleaseMask | + KeyPressMask | + KeyReleaseMask | + EnterWindowMask | + LeaveWindowMask | + PointerMotionMask | + StructureNotifyMask | + VisibilityChangeMask | + FocusChangeMask | + ExposureMask; + + plugin->width = window->width; + plugin->height = window->height; + plugin->window = XCreateWindow(x_display, (Window)window->window, + 0, 0, window->width, window->height, + 0, ws_info->depth, InputOutput, ws_info->visual, mask, &attr); + XMapWindow(x_display, plugin->window); + XFlush(x_display); + + String app_name, app_class; + XtGetApplicationNameAndClass(x_display, &app_name, &app_class); + + top_widget = XtAppCreateShell("drawingArea", app_class, applicationShellWidgetClass, x_display, NULL, 0); + plugin->top_widget = top_widget; + + n = 0; + XtSetArg(args[n], XtNwidth, window->width); n++; + XtSetArg(args[n], XtNheight, window->height); n++; + XtSetArg(args[n], XtNvisual, ws_info->visual); n++; + XtSetArg(args[n], XtNdepth, ws_info->depth); n++; + XtSetArg(args[n], XtNcolormap, ws_info->colormap ); n++; + XtSetArg(args[n], XtNborderWidth, 0); n++; + XtSetValues(top_widget, args, n); + + form = XtVaCreateWidget("form", compositeWidgetClass, top_widget, NULL); + plugin->form = form; + + n = 0; + XtSetArg(args[n], XtNwidth, window->width); n++; + XtSetArg(args[n], XtNheight, window->height); n++; + XtSetArg(args[n], XtNvisual, ws_info->visual); n++; + XtSetArg(args[n], XtNdepth, ws_info->depth); n++; + XtSetArg(args[n], XtNcolormap, ws_info->colormap ); n++; + XtSetArg(args[n], XtNborderWidth, 0); n++; + XtSetValues(form, args, n); + +#if 1 + plugin->old_window = top_widget->core.window; + top_widget->core.window = plugin->window; +#endif + + XtRegisterDrawable(x_display, plugin->window, top_widget); + XtRealizeWidget(form); + XtManageChild(form); + + plugin->window = XtWindow(plugin->form); + + XSelectInput(x_display, XtWindow(top_widget), 0x0fffff); + XSelectInput(x_display, XtWindow(form), 0x0fffff); + + XSync(x_display, False); + } + D(bug(" old window id %p\n", window->window)); + window->window = (void *)XtWindow(plugin->form); +#endif + +#if 0 + D(bug(" window=%d:%p at (%d,%d), size=%dx%d\n", (Window)window->window, window->window, window->x, window->y, window->width, window->height)); + D(bug(" clipRect={ {%d,%d}, {%d,%d} }\n", window->clipRect.top, window->clipRect.left, window->clipRect.bottom, window->clipRect.right)); + D(bug(" type=%s, %d:%d\n", window->type == NPWindowTypeWindow ? "Window" : (window->type == NPWindowTypeDrawable ? "Drawable" : "Unknown"), window->type, ws_info->type)); + D(bug(" display=%p[%s], visual=%p, colormap=%d, depth=%d\n", ws_info->display, DisplayString(ws_info->display), ws_info->visual, ws_info->colormap, ws_info->depth)); + Visual *vis = ws_info->visual; + D(bug(" Visual from visualInfo=%p { %d, %d, %x, %x, %x, %d, %d }\n", vis, + vis->visualid, vis->class, vis->red_mask, vis->green_mask, vis->blue_mask, vis->bits_per_rgb, vis->map_entries)); +#endif +#else + NPWindow *window = io_window; +#endif + + D(bug(" window id %p\n", window->window)); + NPError ret = g_plugin_funcs.setwindow(plugin->instance, window); + + D(bug(" return: %d\n", ret)); + return ret; +} + +// Allows the browser to query the plug-in for information +static NPError +g_NPP_GetValue(NPP instance, NPPVariable variable, void *value) +{ + D(bug("NPP_GetValue instance=%p, variable=%d\n", instance, variable)); + + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + PluginInstance *plugin = instance->pdata; + + if (!g_plugin_funcs.getvalue) + return NPERR_GENERIC_ERROR; + + NPError ret = NPERR_GENERIC_ERROR; + + switch (variable) { + case NPPVpluginNameString: + case NPPVpluginDescriptionString: + { + char *s; + ret = g_plugin_funcs.getvalue(plugin->instance, variable, &s); + if (ret == NPERR_NO_ERROR) { + D(bug(" value='%s'\n", s)); + *((char **)value) = s; + } + break; + } + case NPPVpluginWindowBool: + case NPPVpluginTransparentBool: + case NPPVpluginWindowSize: + case NPPVpluginTimerInterval: + { + uint32_t n; + ret = g_plugin_funcs.getvalue(plugin->instance, variable, &n); + if (ret == NPERR_NO_ERROR) { + D(bug(" value=%d\n", n)); + *((int *)value) = n; + } + break; + } + case NPPVpluginNeedsXEmbed: + { + PRBool b; + ret = g_plugin_funcs.getvalue(plugin->instance, variable, &b); + if (ret == NPERR_NO_ERROR) { +#if 1 + // XXX Flash plugin hack + npw_printf(" XEmbed not supported yet\n"); + b = FALSE; +#else + D(bug(" value=%s\n", b ? "true" : "false")); +#endif + *((PRBool *)value) = b; + } + break; + } + } + + D(bug(" return: %d\n", ret)); + return ret; +} + +// Sets information about the plug-in +static NPError +g_NPP_SetValue(NPP instance, NPPVariable variable, void *value) +{ + D(bug("NPP_SetValue instance=%p, variable=%d\n", instance, variable)); + UNIMPLEMENTED(); + + return NPERR_GENERIC_ERROR; +} + +// Notifies the instance of the completion of a URL request +static void +g_NPP_URLNotify(NPP instance, const char *url, NPReason reason, void *notifyData) +{ + D(bug("NPP_URLNotify instance=%p, url='%s', reason=%d, notifyData=%p\n", instance, url, reason, notifyData)); + + if (instance == NULL) + return; + + PluginInstance *plugin = instance->pdata; + + if (!g_plugin_funcs.urlnotify) + return; + + g_plugin_funcs.urlnotify(plugin->instance, url, reason, notifyData); +} + +// Notifies a plug-in instance of a new data stream +static NPError +g_NPP_NewStream(NPP instance, NPMIMEType type, NPStream *io_stream, NPBool seekable, uint16 *stype) +{ + D(bug("NPP_NewStream instance=%p\n", instance)); + + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + PluginInstance *plugin = instance->pdata; + + if (!g_plugin_funcs.newstream) + return NPERR_GENERIC_ERROR; + + uint16 v_stype = NP_NORMAL; + if (stype) + v_stype = *stype; + + NPStream *stream = malloc(sizeof(*stream)); + if (stream == NULL) + return NPERR_OUT_OF_MEMORY_ERROR; + stream->url = io_stream->url; + stream->end = io_stream->end; + stream->lastmodified = io_stream->lastmodified; + + NPError ret = g_plugin_funcs.newstream(plugin->instance, type, stream, seekable, &v_stype); + io_stream->pdata = stream; + io_stream->notifyData = stream->notifyData; + D(bug(" io_stream=%p, stream=%p, notifyData=%p\n", io_stream, stream, stream->notifyData)); + + if (stype) + *stype = v_stype; + + D(bug(" return: %d [stype=%d]\n", ret, *stype)); + return ret; +} + +// Tells the plug-in that a stream is about to be closed or destroyed +static NPError +g_NPP_DestroyStream(NPP instance, NPStream *io_stream, NPReason reason) +{ + D(bug("NPP_DestroyStream instance=%p\n", instance)); + + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + PluginInstance *plugin = instance->pdata; + + if (!g_plugin_funcs.destroystream) + return NPERR_GENERIC_ERROR; + + NPStream *stream = io_stream->pdata; + + NPError ret = g_plugin_funcs.destroystream(plugin->instance, stream, reason); + + free(stream); + + D(bug(" return: %d\n", ret)); + return ret; +} + +// Provides a local file name for the data from a stream +static void +g_NPP_StreamAsFile(NPP instance, NPStream *io_stream, const char *fname) +{ + D(bug("NPP_StreamAsFile instance=%p\n", instance)); + + if (instance == NULL) + return; + + PluginInstance *plugin = instance->pdata; + + if (!g_plugin_funcs.asfile) + return; + + NPStream *stream = io_stream->pdata; + + D(bug(" fname='%s'\n", fname ? fname : "")); + g_plugin_funcs.asfile(plugin->instance, stream, fname); +} + +// Determines maximum number of bytes that the plug-in can consume +static int32 +g_NPP_WriteReady(NPP instance, NPStream *io_stream) +{ + D(bug("NPP_WriteReady instance=%p\n", instance)); + + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + PluginInstance *plugin = instance->pdata; + + if (!g_plugin_funcs.writeready) + return NPERR_GENERIC_ERROR; + + NPStream *stream = io_stream->pdata; + + int32 ret = g_plugin_funcs.writeready(plugin->instance, stream); + + D(bug(" return: %d\n", ret)); + return ret; +} + +// Delivers data to a plug-in instance +static int32 +g_NPP_Write(NPP instance, NPStream *io_stream, int32 offset, int32 len, void *buf) +{ + D(bug("NPP_Write instance=%p\n", instance)); + + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + PluginInstance *plugin = instance->pdata; + + if (!g_plugin_funcs.write) + return NPERR_GENERIC_ERROR; + + NPStream *stream = io_stream->pdata; + + int32 ret = g_plugin_funcs.write(plugin->instance, stream, offset, len, buf); + + D(bug(" return: %d\n", ret)); + return ret; +} + +// Requests a platform-specific print operation for an embedded or full-screen plug-in +static void +g_NPP_Print(NPP instance, NPPrint *PrintInfo) +{ + D(bug("NPP_Write instance=%p\n", instance)); + UNIMPLEMENTED(); +} + +// Delivers a platform-specific window event to the instance +static int16 +g_NPP_HandleEvent(NPP instance, void *event) +{ + D(bug("NPP_HandleEvent instance=%p\n", instance)); + UNIMPLEMENTED(); + + return NPERR_GENERIC_ERROR; +} + +// Allows the browser to query the plug-in for information +NPError +NP_GetValue(void *future, NPPVariable variable, void *value) +{ + D(bug("NP_GetValue\n")); + + if (g_plugin_initialized <= 0) { + npw_printf("ERROR: could not initialize underlying plugin\n"); + return NPERR_GENERIC_ERROR; + } + + // Handle NPPVpluginNameString and NPPVpluginDescriptionString only + switch (variable) { + case NPPVpluginNameString: + break; + case NPPVpluginDescriptionString: + break; + default: + return NPERR_INVALID_PARAM; + } + + char *str = NULL; + NPError ret = g_NP_GetValue ? g_NP_GetValue(NULL, variable, (void *)&str) : NPERR_GENERIC_ERROR; + + if (ret == NPERR_NO_ERROR) + *((char **) value) = str; + + D(bug(" return: %d\n", ret)); + return ret; +} + +// Allows the browser to query the plug-in supported formats +char * +NP_GetMIMEDescription(void) +{ + D(bug("NP_GetMIMEDescription\n")); + + if (g_plugin_initialized <= 0) { + npw_printf("ERROR: could not initialize underlying plugin\n"); + return NULL; + } + + char *formats = g_NP_GetMIMEDescription(); + D(bug(" formats='%s'\n", formats)); + return formats; +} + +// Provides global initialization for a plug-in +NPError +NP_Initialize(NPNetscapeFuncs *moz_funcs, NPPluginFuncs *plugin_funcs) +{ + D(bug("NP_Initialize\n")); + + if (g_plugin_initialized <= 0) { + npw_printf("ERROR: could not initialize underlying plugin\n"); + return NPERR_GENERIC_ERROR; + } + + if (moz_funcs == NULL || plugin_funcs == NULL) + return NPERR_INVALID_FUNCTABLE_ERROR; + if ((moz_funcs->version >> 8) > NP_VERSION_MAJOR) + return NPERR_INCOMPATIBLE_VERSION_ERROR; + if (moz_funcs->size < sizeof(NPNetscapeFuncs)) + return NPERR_INVALID_FUNCTABLE_ERROR; + if (plugin_funcs->size < sizeof(NPPluginFuncs)) + return NPERR_INVALID_FUNCTABLE_ERROR; + + memcpy(&g_mozilla_funcs, moz_funcs, sizeof(g_mozilla_funcs)); + + memset(&g_plugin_funcs, 0, sizeof(g_plugin_funcs)); + g_plugin_funcs.size = sizeof(g_plugin_funcs); + + memset(moz_funcs, 0, sizeof(*moz_funcs)); + moz_funcs->size = sizeof(*moz_funcs); + moz_funcs->version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR; + moz_funcs->geturl = g_NPN_GetURL; + moz_funcs->posturl = g_NPN_PostURL; + moz_funcs->requestread = g_NPN_RequestRead; + moz_funcs->newstream = g_NPN_NewStream; + moz_funcs->write = g_NPN_Write; + moz_funcs->destroystream = g_NPN_DestroyStream; + moz_funcs->status = g_NPN_Status; + moz_funcs->uagent = g_NPN_UserAgent; + moz_funcs->memalloc = g_NPN_MemAlloc; + moz_funcs->memfree = g_NPN_MemFree; + moz_funcs->memflush = g_NPN_MemFlush; + moz_funcs->reloadplugins = g_NPN_ReloadPlugins; + moz_funcs->getJavaEnv = g_NPN_GetJavaEnv; + moz_funcs->getJavaPeer = g_NPN_GetJavaPeer; + moz_funcs->geturlnotify = g_NPN_GetURLNotify; + moz_funcs->posturlnotify = g_NPN_PostURLNotify; + moz_funcs->getvalue = g_NPN_GetValue; + moz_funcs->setvalue = g_NPN_SetValue; + moz_funcs->invalidaterect = g_NPN_InvalidateRect; + moz_funcs->invalidateregion = g_NPN_InvalidateRegion; + moz_funcs->forceredraw = g_NPN_ForceRedraw; + + memset(plugin_funcs, 0, sizeof(*plugin_funcs)); + plugin_funcs->size = sizeof(NPPluginFuncs); + plugin_funcs->version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR; + plugin_funcs->newp = NewNPP_NewProc(g_NPP_New); + plugin_funcs->destroy = NewNPP_DestroyProc(g_NPP_Destroy); + plugin_funcs->setwindow = NewNPP_SetWindowProc(g_NPP_SetWindow); + plugin_funcs->newstream = NewNPP_NewStreamProc(g_NPP_NewStream); + plugin_funcs->destroystream = NewNPP_DestroyStreamProc(g_NPP_DestroyStream); + plugin_funcs->asfile = NewNPP_StreamAsFileProc(g_NPP_StreamAsFile); + plugin_funcs->writeready = NewNPP_WriteReadyProc(g_NPP_WriteReady); + plugin_funcs->write = NewNPP_WriteProc(g_NPP_Write); + plugin_funcs->print = NewNPP_PrintProc(g_NPP_Print); + plugin_funcs->event = NewNPP_HandleEventProc(g_NPP_HandleEvent); + plugin_funcs->urlnotify = NewNPP_URLNotifyProc(g_NPP_URLNotify); + plugin_funcs->javaClass = NULL; + plugin_funcs->getvalue = NewNPP_GetValueProc(g_NPP_GetValue); + plugin_funcs->setvalue = NewNPP_SetValueProc(g_NPP_SetValue); + + NPError ret = g_NP_Initialize(moz_funcs, &g_plugin_funcs); + D(bug(" return: %d\n", ret)); + return ret; +} + +// Provides global deinitialization for a plug-in +NPError +NP_Shutdown(void) +{ + D(bug("NP_Shutdown\n")); + + if (g_plugin_initialized <= 0) { + npw_printf("ERROR: could not initialize underlying plugin\n"); + return NPERR_GENERIC_ERROR; + } + + NPError ret = g_NP_Shutdown(); + D(bug(" return: %d\n", ret)); + return ret; +} diff --git a/utils/repackage.sh b/utils/repackage.sh new file mode 100755 index 0000000..7cbbf45 --- /dev/null +++ b/utils/repackage.sh @@ -0,0 +1,111 @@ +#!/bin/bash +# +# repackage.sh - repackage script for nspluginwrapper-ARCH +# +# nspluginwrapper (C) 2005-2006 Gwenole Beauchesne +# + +TMPDIR=${TMPDIR:-/tmp} +RPM_TOP_DIR=${RPM_TOP_DIR=$(rpm --eval "%{_topdir}")} + +function fatal_error() { + echo "Error:" ${1+"$@"} >/dev/stderr + exit 1 +} + +if [[ $# -eq 0 ]]; then + echo "Usage: $0 []" + exit 1 +fi + +file=$1 +rpm -qp "$file" >& /dev/null || fatal_error "package $file does not exist" + +ARCH=$2 +[[ -n "$ARCH" ]] || ARCH=$(rpm -qp --qf "%{arch}" $file | sed -e "s/^i.86$/i386/") + +NAME=$(rpm -qp --qf "%{name}" $file) +PKGNAME=$(rpm -qpR $file | sed -n "/^\($NAME-[^ ]*\) .*/s//\1/p") +PKGARCH=$(rpm -qpR $file | sed -n "/^$NAME-\([^ ]*\) .*/s//\1/p") +[[ "$PKGNAME" = "$NAME-$ARCH" ]] || fatal_error "package $file is not nspluginwrapper for $PKGARCH" +VERSION=$(rpm -qp --qf "%{version}" $file) +RELEASE=$(rpm -qp --qf "%{release}" $file) +PACKAGE=$PKGNAME-$VERSION +TARBALL=$PACKAGE.tar.bz2 +echo "Processing $NAME-$VERSION-$RELEASE" + +# define platforms where we want binary deps generated +case $ARCH in +i?86) AUTOREQ_ARCHES="%%ix86 x86_64 ia64";; +ppc) AUTOREQ_ARCHES="ppc ppc64";; +sparc) AUTOREQ_ARCHES="sparc sparcv9 sparc64";; +*) AUTOREQ_ARCHES="$ARCH";; +esac + +dstdir=$TMPDIR/$PACKAGE +rm -rf $dstdir +mkdir -p $dstdir + +srcdir=$TMPDIR/package.d.$$ +mkdir -p $srcdir +pushd $srcdir >& /dev/null +rpm2cpio $file | cpio -id >& /dev/null +tar cf - $(find . -name "npviewer.bin" -type f) | tar xf - -C $dstdir/ +popd >& /dev/null +rm -rf $srcdir + +cd $dstdir/.. +rm -f $RPM_TOP_DIR/SOURCES/$TARBALL +tar jcf $RPM_TOP_DIR/SOURCES/$TARBALL $PACKAGE +filelist=$(cd $PACKAGE && find . "(" -type f -o -type l ")" | sed -n "/^\.\(.*\)/s//\1/p") +rm -rf $dstdir + +specfile=$RPM_TOP_DIR/SPECS/$PKGNAME.spec +TZ=GMT LC_ALL=C rpm -qp --qf "\ +###\n\ +###\n\ +### THIS PACKAGE IS AUTOMATICALLY GENERATED, DO NOT EDIT\n\ +###\n\ +###\n\ +Summary: %{SUMMARY}\n\ +Name: $PKGNAME\n\ +Version: %{VERSION}\n\ +Release: %{RELEASE}\n\ +Source: $TARBALL\n\ +License: %{LICENSE}\n\ +Group: %{GROUP}\n\ +%%ifnarch $AUTOREQ_ARCHES\n\ +AutoReq: off\n\ +%%endif\n\ +BuildRoot: %%_tmppath/%%name-%%version-%%release-buildroot\n\ +%|URL?{URL: %{URL}\n}|\ +\n\ +%%description\n\ +%{DESCRIPTION}\n\ +\nThis package provides the npviewer program for $ARCH.\n\ +\n\ +%%prep\n\ +%%setup -q\n\ +\n\ +%%build\n\ +\n\ +%%install\n\ +rm -rf \$RPM_BUILD_ROOT\n\ +mkdir -p \$RPM_BUILD_ROOT\n\ +tar cf - . | tar xf - -C \$RPM_BUILD_ROOT/\n\ +\n\ +%%clean\n\ +rm -rf \$RPM_BUILD_ROOT\n\ +\n\ +\n\ +%%files\n\ +%%defattr(-,root,root)\n\ +$filelist\ +\n\ +\n\ +%%changelog\n\ +[* %{CHANGELOGTIME:day} %{CHANGELOGNAME}\n\n%{CHANGELOGTEXT}\n\n]\ +" $file > $specfile + +rpm -ba --clean --nodeps --rmspec --rmsource $specfile >& /dev/null +exit 0 diff --git a/utils/xtrace.c b/utils/xtrace.c new file mode 100644 index 0000000..e592fa5 --- /dev/null +++ b/utils/xtrace.c @@ -0,0 +1,284 @@ +#define _GNU_SOURCE 1 /* RTLD_NEXT */ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + + +static int g_debug_level = -1; +static FILE *g_log_file = NULL; + +void npw_printf(const char *format, ...) +{ + if (g_debug_level < 0) { + g_debug_level = 0; + const char *debug_str = getenv("NPW_DEBUG"); + if (debug_str) { + errno = 0; + long v = strtol(debug_str, NULL, 10); + if ((v != LONG_MIN && v != LONG_MAX) || errno != ERANGE) + g_debug_level = v; + } + } + + if (g_log_file == NULL) { + const char *log_file = getenv("NPW_LOG"); + if (log_file) + g_log_file = fopen(log_file, "w"); + if (log_file == NULL) + g_log_file = stderr; + } + + if (g_debug_level > 0) { + va_list args; + va_start(args, format); + vfprintf(g_log_file, format, args); + va_end(args); + } +} + + +Atom XInternAtom(Display *display, const char *atom_name, Bool only_if_exists) +{ + static Atom (*x_XInternAtom)(Display *, const char *, Bool) = NULL; + if (x_XInternAtom == NULL) + x_XInternAtom = dlsym(RTLD_NEXT, "XInternAtom"); + + npw_printf("[X11] XInternAtom(display=%p, atom_name='%s', only_if_exists=%d)\n", display, atom_name, only_if_exists); + Atom ret = x_XInternAtom(display, atom_name, only_if_exists); + return ret; +} + +static XtEventHandler app_event_handler = NULL; + +static void fake_event_handler(Widget w, XtPointer client_data, XEvent *event, Boolean *cont) +{ + switch (event->type) { + case KeyPress: + npw_printf("KeyPress\n"); + break; + case ButtonPress: + npw_printf("ButtonPress\n"); + // asm volatile ("int3"); + break; + } + app_event_handler(w, client_data, event, cont); +} + +static const char *dlname(void *addr) +{ + static Dl_info dlinfo; + if (dladdr(addr, &dlinfo) < 0) + return NULL; + return dlinfo.dli_sname; +} + +void XtAddEventHandler(Widget w, EventMask event_mask, Bool nonmaskable, + XtEventHandler proc, XtPointer client_data) +{ + static void (*x_XtAddEventHandler)(Widget, EventMask, Bool, XtEventHandler, XtPointer) = NULL; + if (x_XtAddEventHandler == NULL) + x_XtAddEventHandler = dlsym(RTLD_NEXT, "XtAddEventHandler"); + + npw_printf("[X11] XtAddEventHandler(Widget=%p[0x%08x], event_mask=%x, nonmaskable=%d, proc=%p[%s])\n", + w, XtWindow(w), event_mask, nonmaskable, proc, dlname(proc)); + if (event_mask & ButtonPressMask) { + app_event_handler = proc; + proc = fake_event_handler; + } + x_XtAddEventHandler(w, event_mask, nonmaskable, proc, client_data); +} + +XtIntervalId XtAppAddTimeOut(XtAppContext app_context, unsigned long + interval, XtTimerCallbackProc proc, XtPointer client_data) +{ + static XtIntervalId (*x_XtAppAddTimeOut)(XtAppContext, unsigned long, XtTimerCallbackProc, XtPointer) = NULL; + if (x_XtAppAddTimeOut == NULL) + x_XtAppAddTimeOut = dlsym(RTLD_NEXT, "XtAppAddTimeOut"); + + static int once = 1; + if (once) + npw_printf("[X11] XtAppAddTimeout(ctx=%p, interval=%d, proc=%p[%s], client_data=%p)\n", + app_context, interval, proc, dlname(proc), client_data); + XtIntervalId ret = x_XtAppAddTimeOut(app_context, interval, proc, client_data); + if (once) + npw_printf(" return: %d\n", ret); + if (1) + once = 0; + return ret; +} + +int XSetForeground(Display *display, GC gc, unsigned long foreground) +{ + static int (*x_XSetForeground)(Display *, GC, unsigned long) = NULL; + if (x_XSetForeground == NULL) + x_XSetForeground = dlsym(RTLD_NEXT, "XSetForeground"); + + npw_printf("[X11] XSetForeground(display=%p, gc=%p, foreground=%06x)\n", display, gc, foreground); + int ret = x_XSetForeground(display, gc, foreground); + npw_printf(" return: %d\n", ret); + return ret; +} + +Status XGetWindowAttributes(Display *display, Window w, XWindowAttributes *attr) +{ + static Status (*x_XGetWindowAttributes)(Display *, Window, XWindowAttributes *) = NULL; + if (x_XGetWindowAttributes == NULL) + x_XGetWindowAttributes = dlsym(RTLD_NEXT, "XGetWindowAttributes"); + + npw_printf("[X11] XGetWindowAttributes(display=%p, window=0x%08x)\n", display, w); + Status ret = x_XGetWindowAttributes(display, w, attr); + npw_printf(" return: %d\n", ret); + npw_printf(" pos=(%d, %d), size=%dx%d, border=%d\n", + attr->x, attr->y, attr->width, attr->height, attr->border_width); + return ret; +} + +Widget XtCreatePopupShell(const char *name, WidgetClass widget_class, Widget + parent, ArgList args, Cardinal num_args) +{ + static Widget (*x_XtCreatePopupShell)(const char *, WidgetClass, Widget, ArgList, Cardinal) = NULL; + if (x_XtCreatePopupShell == NULL) + x_XtCreatePopupShell = dlsym(RTLD_NEXT, "XtCreatePopupShell"); + + npw_printf("[X11] XtCreatePopupShell(name='%s', widget_class=%p, parent=%p[0x%08x])\n", name, widget_class, parent, XtWindow(parent)); + int i; + for (i = 0; i < num_args; i++) + npw_printf(" %d: '%s' => %d\n", i, args[i].name, args[i].value); + Widget ret = x_XtCreatePopupShell(name, widget_class, parent, args, num_args); + npw_printf(" return: %p [0x%08x]\n", ret, XtWindow(ret)); + return ret; +} + +#if 0 +Status XQueryTree(Display *display, Window w, Window *root_return, Window *parent_return, + Window **children_return, unsigned int *nchildren_return) +{ + static Status (*x_XQueryTree)(Display *, Window, Window *, Window *, Window **, unsigned int *) = NULL; + if (x_XQueryTree == NULL) + x_XQueryTree = dlsym(RTLD_NEXT, "XQueryTree"); + + npw_printf("[X11] XQueryTree(display=%p, window=0x%08x)\n", display, w); + Status ret = x_XQueryTree(display, w, root_return, parent_return, children_return, nchildren_return); + npw_printf(" return: %d\n", ret); + npw_printf(" + parent_window=0x%08x, root_window=0x%08x\n", root_return ? *root_return : 0, parent_return ? *parent_return : 0); + if (children_return && nchildren_return) { + Window *children = *children_return; + int i, n = *nchildren_return; + for (i = 0; i < n; i++) + npw_printf(" + child 0x%08x\n", children[i]); + } + return ret; +} +#endif + +Bool XQueryPointer(Display *display, Window w, Window *root_return, + Window *child_return, int *root_x_return, int *root_y_return, + int *win_x_return, int *win_y_return, unsigned int *mask_return) +{ + static Bool (*x_XQueryPointer)(Display *, Window, Window *, Window *, int *, int *, int *, int *, unsigned int *) = NULL; + if (x_XQueryPointer == NULL) + x_XQueryPointer = dlsym(RTLD_NEXT, "XQueryPointer"); + + npw_printf("[X11] XQueryPointer(display=%p, window=0x%08x)\n", display, w); + Bool ret = x_XQueryPointer(display, w, root_return, child_return, root_x_return, root_y_return, win_x_return, win_y_return, mask_return); + npw_printf(" return: %d\n", ret); + if (ret) { + if (win_x_return && win_y_return) + npw_printf(" + pos = (%d, %d)\n", *win_x_return, *win_y_return); + if (child_return) + npw_printf(" + child = 0x%08x\n", *child_return); + } + return ret; +} + +#if 0 +Widget XtWindowToWidget(Display *display, Window window) +{ + static Widget (*fn)(Display *, Window) = NULL; + if (fn == NULL) + fn = dlsym(RTLD_NEXT, "XtWindowToWidget"); + + npw_printf("[X11] XtWindowToWidget(display=%p, window=0x%08x)\n", display, window); + Widget ret = fn(display, window); + npw_printf(" return: %p\n", ret); + return ret; +} +#endif + +Widget XtParent(Widget w) +{ + static Widget (*fn)(Widget) = NULL; + if (fn == NULL) + fn = dlsym(RTLD_NEXT, "XtParent"); + + npw_printf("[X11] XtParent(widget=0x%08x)\n", w); + Widget ret = fn(w); + npw_printf(" return: 0x%08x\n", ret); + return ret; +} + +static XErrorHandler app_error_handler = NULL; + +static int fake_error_handler(Display *display, XErrorEvent *error_event) +{ + npw_printf("[X11] ERROR code=%d\n", error_event->error_code); + int ret = app_error_handler(display, error_event); + return ret; +} + +XErrorHandler XSetErrorHandler(XErrorHandler handler) +{ + static XErrorHandler (*fn)(XErrorHandler) = NULL; + if (fn == NULL) + fn = dlsym(RTLD_NEXT, "XSetErrorHandler"); + + app_error_handler = handler; + XErrorHandler ret = fn(fake_error_handler); + return ret; +} + +int XPutImage(Display *display, Drawable d, GC gc, XImage *image, + int src_x, int src_y, int dest_x, int dest_y, unsigned int width, + unsigned int height) +{ + static int (*fn)(Display *, Drawable, GC, XImage *, int, int, int, int, unsigned int, unsigned int) = NULL; + if (fn == NULL) + fn = dlsym(RTLD_NEXT, "XPutImage"); + + npw_printf("[X11] XPutImage(display=%p, drawable=0x%08x, src @ (%d, %d), dst @ (%d, %d), size = %dx%d)\n", + display, d, src_x, src_y, dest_x, dest_y, width, height); + int ret = fn(display, d, gc, image, src_x, src_y, dest_x, dest_y, width, height); + npw_printf(" return: %d\n", ret); + if (src_x == dest_x && src_x == 16 && src_y == dest_y && src_y == 17) { + npw_printf("about to trap into debugger\n"); + getchar(); + asm volatile ("int3"); + } + return ret; +} + +Status XShmPutImage(Display *display, Drawable d, GC gc, XImage *image, + int src_x, int src_y, int dest_x, int dest_y, unsigned int width, + unsigned int height, Bool send_event) +{ + static int (*fn)(Display *, Drawable, GC, XImage *, int, int, int, int, unsigned int, unsigned int, Bool) = NULL; + if (fn == NULL) + fn = dlsym(RTLD_NEXT, "XShmPutImage"); + + npw_printf("[X11] XShmPutImage(display=%p, drawable=0x%08x, src @ (%d, %d), dst @ (%d, %d), size = %dx%d)\n", + display, d, src_x, src_y, dest_x, dest_y, width, height); + int ret = fn(display, d, gc, image, src_x, src_y, dest_x, dest_y, width, height, send_event); + npw_printf(" return: %d\n", ret); + return ret; +}