pax_global_header00006660000000000000000000000064140305457270014521gustar00rootroot0000000000000052 comment=17edce087627ea4f601af9c19465a2c1e6848e66 go-dbus-factory-1.9.6/000077500000000000000000000000001403054572700145435ustar00rootroot00000000000000go-dbus-factory-1.9.6/.gitignore000066400000000000000000000000331403054572700165270ustar00rootroot00000000000000.idea local_test generator go-dbus-factory-1.9.6/.gitlab-ci.yml000066400000000000000000000001411403054572700171730ustar00rootroot00000000000000include: - remote: 'https://gitlab.deepin.io/dev-tools/letmeci/raw/master/gitlab-ci/dde.yml' go-dbus-factory-1.9.6/.packit.yaml000066400000000000000000000011301403054572700167530ustar00rootroot00000000000000# See the documentation for more information: # https://packit.dev/docs/configuration/ specfile_path: rpm/golang-github-linuxdeepin-dbus-factory.spec # add or remove files that should be synced synced_files: - rpm/golang-github-linuxdeepin-dbus-factory.spec - .packit.yaml upstream_package_name: go-dbus-factory # downstream (Fedora) RPM package name downstream_package_name: golang-github-linuxdeepin-dbus-factory actions: fix-spec-file: | bash -c "sed -i -r \"0,/Version:/ s/Version:(\s*)\S*/Version:\1${PACKIT_PROJECT_VERSION}/\" rpm/golang-github-linuxdeepin-dbus-factory.spec" go-dbus-factory-1.9.6/CHANGELOG.md000066400000000000000000000065551403054572700163670ustar00rootroot00000000000000[0.9.0] 2019-06-05 * change(api): add com.deepin.WMSwitcher [0.8.0] 2019-05-09 * change(api): update com.deepin.wm [0.7.0] 2019-04-09 * change(api): update com.deepin.wm [0.6.0] 2019-04-08 * feat: update com.deepin.daemon.greeter and com.deepin.XSettings [0.5.0] 2019-04-02 * change(api): update com.deepin.daemon.greeter * change(api): update com.deepin.wm * change(api): add org.kde.kwin Compositor [0.4.0] 2019-03-15 * change(api): update com.deepin.api.SoundThemePlayer * change(api): add com.deepin.system.Network [0.3.0] 2019-03-01 * change(api): add com.deepin.dde.osd * change(api): update com.deepin.wm * feat: add com.deepin.api.soundthemeplayer * chore: update com.deepin.daemon.Network [0.2.0] 2018-12-13 * feat: add org.freedesktop.NetworkManager ObjectManager [0.1.0] 2018-11-23 * feat: update com.deepin.daemon.daemon * chore: add makefile for `sw_64` [0.0.7] 2018-08-07 * feat: update com.deepin.api.device [0.0.6] 2018-07-31 * chore: networkmanager accessPoint add accessor [0.0.5] 2018-07-19 * update com.deepin.sessionmanager XSettings * add net.hadess.sensorproxy * update org.freedesktop.notifications [0.0.4] 2018-07-05 * update com.deepin.system.power * update com.deepin.lastore * feat: policykit1 add manual code * update com.deepin.SessionManager [0.0.3] 2018-05-14 * chore: replace UnixFdIndex with UnixFd * update com.deepin.lastore/Job * feat: add org.bluez ObjectManager * add com.deepin.daemon.ImageBlur * add com.deepin.daemon.sessionwatcher [0.0.2] 2018-04-19 * feat(generator): common property type define supported * feat: autofill PropertyFix.EmptyValue * add org.freedesktop.colormanager * add org.freedesktop.modemmanager1 * add org.freedesktop.networkmanager device * feat: add PropertyFix RenameTo * add net.reactivated.fprint.Device * add org.freedesktop.networkmanager * add org.freedesktop.miracle.wfd * add org.freedesktop.miracle.wifi * add org.mpris.mediaplayer2 * update README * add README * add org.freedesktop.udisks2 * add org.ayatana.bamf * add org.freedesktop.secrets * add org.freedesktop.policykit1 * add org.freedesktop.timedate1 * add org.freedesktop.notifications * add org.freedesktop.screensaver * add com.deepin.daemon.daemon * add com.deepin.daemon.greeter * add com.deepin.api.cursorhelper * add com.deepin.daemon.timedated * add com.deepin.daemon.accounts * add com.deepin.daemon.helper.backlight * add com.deepin.daemon.inputdevices * add com.deepin.daemon.gesture * add com.deepin.daemon.network * add com.deepin.api.localehelper * add com.deepin.api.pinyin * add com.deepin.system.power * add com.deepin.daemon.audio * add com.deepin.daemon.display * add com.deepin.dde.launcher * add com.deepin.daemon.apps * add com.deepin.api.device * add com.deepin.sessionmanager * add org.freedesktop.dbus * add org.bluez * add net.reactivated.fprint * add com.deepin.wm * change package name * add golang-dlib-dev [0.0.1] 2018-03-28 * regen * check whether the callback is nil * add com.deepin.lastore * add debian * regen * rename client to proxy * check path validity * add org.freedesktop.login1 * generator +6 * add .gitignore * add com.deepin.api.xeventmonitor * generator +5 * add com.deepin.dde.daemon.dock * generator +4 * generator +3 * generator +2 * generator +1 * init go-dbus-factory-1.9.6/LICENSE000066400000000000000000001045131403054572700155540ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. 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 them 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 prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. 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. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey 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; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If 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 convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU 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 that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. 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. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS 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. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. 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 state 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 3 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, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program 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, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU 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 Lesser General Public License instead of this License. But first, please read . go-dbus-factory-1.9.6/Makefile000066400000000000000000000010161403054572700162010ustar00rootroot00000000000000PREFIX = /usr GOSITE_DIR = ${PREFIX}/share/gocode GOPKG_PERFIX = github.com/linuxdeepin/go-dbus-factory SRC_DIR=${DESTDIR}${GOSITE_DIR}/src/${GOPKG_PERFIX} all: build build: echo ignore build print_gopath: GOPATH="${CURDIR}/${GOPATH_DIR}:${GOPATH}" bin: go build -o generator _tool/generator/*.go install: mkdir -p ${SRC_DIR} for dir in object_manager net.* org.* com.*;do\ mkdir -p ${SRC_DIR}/$$dir;\ cp $$dir/*.go ${SRC_DIR}/$$dir;\ done vet: go vet ./... go vet ./_tool/generator go vet ./_tool/prop_gen go-dbus-factory-1.9.6/README.md000066400000000000000000000070161403054572700160260ustar00rootroot00000000000000# go-dbus-factory 用于自动化生成 DBus 服务的方便的 go 绑定代码。 命令如果没有特殊说明，都在项目根目录下执行。 构建生成器，执行命令： ``` make bin ``` 将产生 generator 二进制。 对单个文件夹进行自动化代码生成, 如执行命令： ``` ./generator org.freedesktop.notifications ``` 对所有文件夹执行自动化代码生成，执行命令 ``` ./gen.sh ``` 这个脚本自动查找包含特征文件 config.json 的文件夹进行生成。 ## 文件夹 将生成一个 DBus 服务的代码所需的文件集中放到一个文件夹，文件夹名一般是 DBus 服务名全小写，如标准的通知服务 org.freedesktop.Notifications 文件夹为 org.freedesktop.notifications, 自动生成的代码包的包名为点分割的最后一个组件，比如 notifications。 文件夹内有内省xml, 配置文件 config.json 和 go 代码。 ### 内省 xml 内省 xml 可以用 gdbus introspect 命令获取，比如获取 org.freedesktop.Notifications 服务的 /org/freedesktop/Notifications Object 的内省 xml，执行命令： ``` gdbus introspect -e -d org.freedesktop.Notifications -o /org/freedesktop/Notifications -x > Notifications.xml ``` 内省 xml 的根元素的 tag 为 node，文件名为 config.json 配置文件中 Object 的 Type 加后缀 `.xml`。 ### config.json 简单的例子，如 org.freedesktop.Notifications 服务的配置文件 ```json { "Service": "org.freedesktop.Notifications", "Objects": [ { "Type": "Notifications", "Path": "/org/freedesktop/Notifications", "Interfaces": [ { "Name": "org.freedesktop.Notifications", "Type": "notifications" } ] } ] } ``` 有关配置文件的详细查看生成器的代码 `_tool/generator/config.go` 其中 Object 如果 Path 是固定的，则指定Path，如果 Path 不固定，则不指定 Path。 如果 Object 具有多个接口，则需要指定 InterfaceConfig 的 Accessor 字段， 如果只具有一个接口，则不需要。 参考 `com.deepin.daemon.apps/config.json`。 如果 Object 具有 org.freedestkop.DBus.ObjectManager 接口，则 InterfaceConfig 只需写 Name 字段就行，生成器对这个 interface 进行了特殊处理。 Type 字段一般对应自动生成代码里的 struct 类型的名。 比如 ObjectConfig 的 Type 与 InterfaceConfig 的 Type。 #### 对接口的修正 用 InterfaceConfig 的 Fixes 字段指定， 其类型为 `map[string]json.RawMessage`。 键是属性、方法、信号的名加上特定的前缀： * 属性前缀 `p/` * 方法前缀 `m/` * 信号前缀 `s/` 如要修正属性 Name，则 Fixes 中的键为 "p/Name"。 值可被解析为 ArgFixes 或 PropertyFix 类型。 ArgFixes 用于对方法或信号的某个参数的的类型修正，ArgFix 的 Name 指定了参数名，Type 为这个参数指定了新的类型。 PropertyFix 用与对属性的类型进行修正。 ```go type ArgFixes []ArgFix type ArgFix struct { Name string Type string } type PropertyFix struct { Type string ValueType string EmptyValue string } ``` 对属性的修正是必须的，如果不写则生成器会painc，对方法和信号的修正是可选的，如果不写则会有警告。 如警告信息： ``` Warning: found []interface{} in org.freedesktop.login1.Manager.CreateSession arg properties ``` ### go代码 自动生成的代码命名为 auto.go, 手写代码命名任意，一般为 manual.go。 手写代码一般作为自动代码的补充，比如定义struct类型。go-dbus-factory-1.9.6/_tool/000077500000000000000000000000001403054572700156575ustar00rootroot00000000000000go-dbus-factory-1.9.6/_tool/generator/000077500000000000000000000000001403054572700176455ustar00rootroot00000000000000go-dbus-factory-1.9.6/_tool/generator/config.go000066400000000000000000000122651403054572700214470ustar00rootroot00000000000000package main import ( "encoding/json" "encoding/xml" "fmt" "io/ioutil" "log" "os" "path/filepath" "strings" "github.com/godbus/dbus/introspect" ) type ServiceConfig struct { Service string // optional Objects []*ObjectConfig PropertyTypes []*PropertyTypeConfig } func (sc *ServiceConfig) autoFill() { for _, objCfg := range sc.Objects { objCfg.autoFill() } for _, propTypeCfg := range sc.PropertyTypes { propTypeCfg.autoFill("", nil) } } type PropertyTypeConfig struct { Type string ValueType string EmptyValue string } func (ptc *PropertyTypeConfig) autoFill(propName string, ifcCfg *InterfaceConfig) { if ptc.Type == "" && ifcCfg != nil && ifcCfg.Accessor != "" && propName != "" { ptc.Type = "Prop" + ifcCfg.Accessor + propName } if ptc.EmptyValue == "" { if strings.HasPrefix(ptc.ValueType, "map[") || strings.HasPrefix(ptc.ValueType, "[]") { ptc.EmptyValue = "nil" } else { ptc.EmptyValue = ptc.ValueType + "{}" } } else { ptc.EmptyValue = strings.Replace(ptc.EmptyValue, "$T", ptc.ValueType, 1) } } type ObjectConfig struct { Type string Path string // optional XMLFile string // optional XMLFiles []string // optional Interfaces []*InterfaceConfig } func (oc *ObjectConfig) autoFill() { for _, ifcCfg := range oc.Interfaces { ifcCfg.autoFill() } } func (oc *ObjectConfig) getXmlFiles(dir string) []string { var result []string if len(oc.XMLFiles) > 0 { for _, pat := range oc.XMLFiles { matches, _ := filepath.Glob(filepath.Join(dir, pat+".xml")) result = append(result, matches...) } } else if oc.XMLFile != "" { if oc.XMLFile == "-" { return nil } result = append(result, filepath.Join(dir, oc.XMLFile+".xml")) } else { result = append(result, filepath.Join(dir, oc.Type+".xml")) } return result } func (oc *ObjectConfig) loadXml(dir string) ([]introspect.Interface, error) { var result []introspect.Interface xmlFiles := oc.getXmlFiles(dir) for _, file := range xmlFiles { interfaces, err := getInterfacesFromXmlFile(file) log.Println("load xml file:", file) if err != nil { return nil, err } result = append(result, interfaces...) } return result, nil } func getInterfacesFromXmlFile(file string) ([]introspect.Interface, error) { f, err := os.Open(file) if err != nil { return nil, err } defer f.Close() dec := xml.NewDecoder(f) var node introspect.Node err = dec.Decode(&node) if err != nil { return nil, err } return node.Interfaces, nil } func (oc *ObjectConfig) getInterface(name string) *InterfaceConfig { for _, ifc := range oc.Interfaces { if ifc.Name == name { return ifc } } return nil } type InterfaceConfig struct { Name string Type string Accessor string Fixes map[string]json.RawMessage TypeDefined bool NoGetInterfaceName bool MethodFixes map[string]ArgFixes PropFixes map[string]*PropertyFix SignalFixes map[string]ArgFixes } func (ic *InterfaceConfig) autoFill() { dotRIdx := strings.LastIndex(ic.Name, ".") if dotRIdx == -1 { panic(fmt.Sprintf("not found dot in interface name %q", ic.Name)) } if ic.Accessor == "" { ic.Accessor = strings.Title(ic.Name[dotRIdx+1:]) } if ic.Type == "" && ic.Accessor != "" { firstLetter := strings.ToLower(string(ic.Accessor[0])) ic.Type = firstLetter + ic.Accessor[1:] } for key, fix := range ic.Fixes { if strings.HasPrefix(key, "p/") { propName := strings.TrimPrefix(key, "p/") var propFix PropertyFix err := json.Unmarshal(fix, &propFix) if err != nil { panic(err) } if ic.PropFixes == nil { ic.PropFixes = make(map[string]*PropertyFix) } ic.PropFixes[propName] = &propFix } else if strings.HasPrefix(key, "s/") { signalName := strings.TrimPrefix(key, "s/") var argFixes ArgFixes err := json.Unmarshal(fix, &argFixes) if err != nil { panic(err) } if ic.SignalFixes == nil { ic.SignalFixes = make(map[string]ArgFixes) } ic.SignalFixes[signalName] = argFixes } else if strings.HasPrefix(key, "m/") { methodName := strings.TrimPrefix(key, "m/") var argFixes ArgFixes err := json.Unmarshal(fix, &argFixes) if err != nil { panic(err) } if ic.MethodFixes == nil { ic.MethodFixes = make(map[string]ArgFixes) } ic.MethodFixes[methodName] = argFixes } } for propName, propFix := range ic.PropFixes { propFix.autoFill(propName, ic) } } func (ic *InterfaceConfig) getPropertyFix(name string) *PropertyFix { v := ic.PropFixes[name] return v } func (ic *InterfaceConfig) getMethodFix(name string) ArgFixes { v := ic.MethodFixes[name] return v } func (ic *InterfaceConfig) getSignalFix(name string) ArgFixes { v := ic.SignalFixes[name] return v } type ArgFixes []ArgFix func (fixes ArgFixes) get(name string) ArgFix { for _, fix := range fixes { if fix.Name == name { return fix } } return ArgFix{} } type ArgFix struct { Name string Type string } type PropertyFix struct { PropertyTypeConfig RenameTo string RefType string } func loadConfig(file string) (*ServiceConfig, error) { data, err := ioutil.ReadFile(file) if err != nil { return nil, err } var s ServiceConfig err = json.Unmarshal(data, &s) if err != nil { return nil, err } return &s, nil } go-dbus-factory-1.9.6/_tool/generator/main.go000066400000000000000000000340551403054572700211270ustar00rootroot00000000000000package main import ( "bytes" "fmt" "log" "os" "path/filepath" "strconv" "strings" "github.com/godbus/dbus/introspect" "pkg.deepin.io/lib/utils" ) func init() { log.SetFlags(log.Lshortfile) } func main() { dir := os.Args[1] log.Println("dir:", dir) configFile := filepath.Join(dir, "config.json") srvCfg, err := loadConfig(configFile) if err != nil { log.Fatal("failed to load config: ", err) } dirName := filepath.Base(dir) lastDotIdx := strings.LastIndexByte(dirName, '.') pkg := dirName[lastDotIdx+1:] sf := NewSourceFile(pkg) sf.AddGoImport("errors") sf.AddGoImport("fmt") sf.AddGoImport("unsafe") sf.AddGoImport("github.com/godbus/dbus") sf.AddGoImport("pkg.deepin.io/lib/dbusutil") sf.AddGoImport("pkg.deepin.io/lib/dbusutil/proxy") sf.AddGoImport("github.com/linuxdeepin/go-dbus-factory/object_manager") srvCfg.autoFill() for _, objCfg := range srvCfg.Objects { log.Println("Object", objCfg.Type) interfaces, err := objCfg.loadXml(dir) if err != nil { log.Fatal(err) } sf.GoBody.Pn("type %s struct {", objCfg.Type) for _, ifcCfg := range objCfg.Interfaces { if ifcCfg.Name == "org.freedesktop.DBus.ObjectManager" { ifcCfg.TypeDefined = true sf.GoBody.Pn("object_manager.ObjectManager // interface %s", ifcCfg.Name) } else { sf.GoBody.Pn("%s // interface %s", ifcCfg.Type, ifcCfg.Name) } } sf.GoBody.Pn("proxy.Object") sf.GoBody.Pn("}\n") writeNewObject(sf.GoBody, srvCfg.Service, objCfg) for _, ifcCfg := range objCfg.Interfaces { ifc := getInterfaceByName(interfaces, ifcCfg.Name) if ifcCfg.TypeDefined { continue } if ifc == nil { log.Fatalf("not found interface %q for object %s", ifcCfg.Name, objCfg.Type) } if len(objCfg.Interfaces) > 1 { writeImplementerAccessorMethod(sf.GoBody, ifc, objCfg) } writeImplementerMethods(sf.GoBody, ifc, ifcCfg) for _, method := range ifc.Methods { writeMethod(sf.GoBody, method, ifcCfg) } for _, signal := range ifc.Signals { writeSignal(sf.GoBody, signal, ifcCfg) } for _, prop := range ifc.Properties { var methodSameName bool for _, method := range ifc.Methods { if method.Name == prop.Name { methodSameName = true break } } writeProperty(sf.GoBody, prop, ifcCfg, methodSameName) } } } for _, propTypeCfg := range srvCfg.PropertyTypes { writePropType(sf.GoBody, propTypeCfg) } autoGoFile := filepath.Join(dir, "auto.go") md5sum, ok := utils.SumFileMd5(autoGoFile) sf.Save(autoGoFile) if ok { md5sum1, ok1 := utils.SumFileMd5(autoGoFile) if ok1 && md5sum == md5sum1 { log.Println("auto.go not changed") } } } func writeNewObject(sb *SourceBody, serviceName string, cfg *ObjectConfig) { var inArgs []string outTypes := []string{"*" + cfg.Type} if serviceName == "" { inArgs = append(inArgs, "serviceName string") } if cfg.Path == "" { inArgs = append(inArgs, "path dbus.ObjectPath") outTypes = append(outTypes, "error") } outTypesStr := strings.Join(outTypes, ",") if len(outTypes) > 1 { outTypesStr = "(" + outTypesStr + ")" } sb.Pn("func New%s(conn *dbus.Conn, %s) %s {", cfg.Type, strings.Join(inArgs, ","), outTypesStr) // check path if cfg.Path == "" { sb.Pn("if !path.IsValid() {") sb.Pn(" return nil, errors.New(\"path is invalid\")") sb.Pn("}") } sb.Pn("obj := new(%s)", cfg.Type) var inArgServiceName string var inArgPath string if serviceName != "" { inArgServiceName = strconv.Quote(serviceName) } else { inArgServiceName = "serviceName" } if cfg.Path != "" { inArgPath = strconv.Quote(cfg.Path) } else { inArgPath = "path" } sb.Pn("obj.Object.Init_(conn, %s, %s)", inArgServiceName, inArgPath) // return var returnExpr string if cfg.Path == "" { returnExpr = "obj, nil" } else { returnExpr = "obj" } sb.Pn("return %s", returnExpr) sb.Pn("}\n") } func writeImplementerAccessorMethod(sb *SourceBody, ifc *introspect.Interface, objCfg *ObjectConfig) { ifcCfg := objCfg.getInterface(ifc.Name) sb.Pn("func (obj *%s) %s() *%s {", objCfg.Type, ifcCfg.Accessor, ifcCfg.Type) sb.Pn(" return &obj.%s", ifcCfg.Type) sb.Pn("}\n") } func writeImplementerMethods(sb *SourceBody, ifc *introspect.Interface, ifcCfg *InterfaceConfig) { sb.Pn("type %s struct{}", ifcCfg.Type) sb.Pn("func (v *%s) GetObject_() *proxy.Object {", ifcCfg.Type) sb.Pn(" return (*proxy.Object)(unsafe.Pointer(v))") sb.Pn("}\n") if !ifcCfg.NoGetInterfaceName { sb.Pn("func (*%s) GetInterfaceName_() string {", ifcCfg.Type) sb.Pn(" return %q", ifc.Name) sb.Pn("}\n") } } func writeMethod(sb *SourceBody, method introspect.Method, ifcCfg *InterfaceConfig) { sb.Pn("// method %s\n", method.Name) methodName := strings.Title(method.Name) args := getArgs(method.Args) inArgs := getInArgs(args) outArgs := getOutArgs(args) // sb.Pn("// in %#v", inArgs) // sb.Pn("// out %#v", outArgs) argFixes := ifcCfg.getMethodFix(method.Name) // check and warn for _, arg := range args { argType := getArgType(arg, argFixes) if strings.Contains(argType, "[]interface {}") { log.Printf("Warning: found []interface{} in %s.%s arg %s\n", ifcCfg.Name, method.Name, arg.Name) } } // GoXXX sb.Pn("func (v *%s) Go%s(flags dbus.Flags, ch chan *dbus.Call %s) *dbus.Call {", ifcCfg.Type, methodName, getArgsProto(inArgs, false, argFixes)) sb.Pn(" return v.GetObject_().Go_(v.GetInterfaceName_()+\".%s\", flags, ch %s)", method.Name, getArgsName(inArgs, false)) sb.Pn("}\n") // StoreXXX if len(outArgs) > 0 { sb.Pn("func (*%s) Store%s(call *dbus.Call) (%s,err error) {", ifcCfg.Type, methodName, getArgsProto(outArgs, true, argFixes)) sb.Pn(" err = call.Store(%s)", getArgsRefName(outArgs, true)) sb.Pn(" return") sb.Pn("}\n") } // Call if len(outArgs) == 0 { sb.Pn("func (v *%s) %s(flags dbus.Flags %s) error {", ifcCfg.Type, methodName, getArgsProto(inArgs, false, argFixes)) sb.Pn("return (<-v.Go%s(flags, make(chan *dbus.Call, 1) %s).Done).Err", methodName, getArgsName(inArgs, false)) sb.Pn("}\n") } else { sb.Pn("func (v *%s) %s(flags dbus.Flags %s) (%s, err error) {", ifcCfg.Type, methodName, getArgsProto(inArgs, false, argFixes), getArgsProto(outArgs, true, argFixes)) sb.Pn("return v.Store%s(", methodName) sb.Pn("<-v.Go%s(flags, make(chan *dbus.Call, 1) %s).Done)", methodName, getArgsName(inArgs, false)) sb.Pn("}\n") } } func writeSignal(sb *SourceBody, signal introspect.Signal, ifcCfg *InterfaceConfig) { sb.Pn("// signal %s\n", signal.Name) args := getArgs(signal.Args) argFixes := ifcCfg.getSignalFix(signal.Name) methodName := strings.Title(signal.Name) sb.Pn("func (v *%s) Connect%s(cb func(%s)) (dbusutil.SignalHandlerId, error) {", ifcCfg.Type, methodName, getArgsProto(args, true, argFixes)) sb.Pn("if cb == nil {") sb.Pn(" return 0, errors.New(\"nil callback\")") sb.Pn("}") sb.Pn("obj := v.GetObject_()") sb.Pn("rule := fmt.Sprintf(") sb.writeStr(`"type='signal',interface='%s',member='%s',path='%s',sender='%s'",` + "\n") sb.Pn("v.GetInterfaceName_(), %q, obj.Path_(), obj.ServiceName_())\n", signal.Name) sb.Pn("sigRule := &dbusutil.SignalRule{") sb.Pn("Path: obj.Path_(),") sb.Pn("Name: v.GetInterfaceName_() + \".%s\",", signal.Name) sb.Pn("}") sb.Pn("handlerFunc := func(sig *dbus.Signal) {") if len(args) > 0 { for _, arg := range args { argType := getArgType(arg, argFixes) sb.Pn("var %s %s", arg.Name, argType) } sb.Pn("err := dbus.Store(sig.Body %s)", getArgsRefName(args, false)) sb.Pn("if err == nil {") sb.Pn(" cb(%s)", getArgsName(args, true)) sb.Pn("}") } else { sb.Pn("cb()") } sb.Pn("}\n") // end handlerFunc sb.Pn("return obj.ConnectSignal_(rule, sigRule, handlerFunc)") sb.Pn("}\n") } var propBaseTypeMap = map[string]string{ "y": "Byte", "b": "Bool", "n": "Int16", "q": "Uint16", "i": "Int32", "u": "Uint32", "x": "Int64", "t": "Uint64", "d": "Double", "s": "String", "o": "ObjectPath", } func getPropType(ty string) string { if len(ty) == 1 { val := propBaseTypeMap[ty] if val == "" { return "" } return "proxy.Prop" + val } else if len(ty) == 2 && ty[0] == 'a' { val := propBaseTypeMap[ty[1:]] if val == "" { return "" } return "proxy.Prop" + val + "Array" } return "" } func writePropType(sb *SourceBody, propTypeCfg *PropertyTypeConfig) { const propName = "p.Name" sb.Pn("type %s struct {", propTypeCfg.Type) sb.Pn(" Impl proxy.Implementer") sb.Pn(" Name string") sb.Pn("}\n") writePropGet(sb, propTypeCfg, propName) writePropSet(sb, propTypeCfg, propName) writePropConnectChanged(sb, propTypeCfg, propName) } func writePropGet(sb *SourceBody, propTypeCfg *PropertyTypeConfig, propName string) { sb.Pn("func (p %s) Get(flags dbus.Flags) (value %s, err error) {", propTypeCfg.Type, propTypeCfg.ValueType) sb.Pn("err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(),") sb.Pn("%s, &value)", propName) sb.Pn(" return") sb.Pn("}\n") } func writePropSet(sb *SourceBody, propTypeCfg *PropertyTypeConfig, propName string) { sb.Pn("func (p %s) Set(flags dbus.Flags, value %s) error {", propTypeCfg.Type, propTypeCfg.ValueType) sb.Pn("return p.Impl.GetObject_().SetProperty_(flags,"+ " p.Impl.GetInterfaceName_(), %s, value)", propName) sb.Pn("}\n") } func writePropConnectChanged(sb *SourceBody, propTypeCfg *PropertyTypeConfig, propName string) { sb.Pn("func (p %s) ConnectChanged(cb func(hasValue bool, value %s)) error {", propTypeCfg.Type, propTypeCfg.ValueType) sb.Pn("if cb == nil {") sb.Pn(" return errors.New(\"nil callback\")") sb.Pn("}") sb.Pn("cb0 := func(hasValue bool, value interface{}) {") sb.Pn("if hasValue {") sb.Pn(" var v %s", propTypeCfg.ValueType) sb.Pn(" err := dbus.Store([]interface{}{value}, &v)") sb.Pn(" if err != nil {") sb.Pn(" return") sb.Pn(" }") sb.Pn(" cb(true, v)") sb.Pn("} else {") sb.Pn(" cb(false, %s)", propTypeCfg.EmptyValue) sb.Pn("}") sb.Pn("}") // end cb0 sb.Pn("return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(),") sb.Pn("%s, cb0)", propName) sb.Pn("}\n") } func writeProperty(sb *SourceBody, prop introspect.Property, ifcCfg *InterfaceConfig, methodSameName bool) { sb.Pn("// property %s %s\n", prop.Name, prop.Type) propFix := ifcCfg.getPropertyFix(prop.Name) var renameTo string if propFix != nil { renameTo = propFix.RenameTo } // get funcName funcName := strings.Title(prop.Name) if renameTo != "" { funcName = renameTo } else if methodSameName { funcName = "Prop" + funcName } propType := getPropType(prop.Type) if propType == "" && propFix != nil && propFix.RefType != "" { propType = propFix.RefType } if propType != "" { sb.Pn("func (v *%s) %s() %s {", ifcCfg.Type, funcName, propType) sb.Pn(" return %s{", propType) sb.Pn(" Impl: v,") sb.Pn(" Name: %q,", prop.Name) sb.Pn(" }") sb.Pn("}\n") } else { if propFix == nil { panic(fmt.Errorf("failed to get property fix for %s.%s", ifcCfg.Name, prop.Name)) } sb.Pn("func (v *%s) %s() %s {", ifcCfg.Type, prop.Name, propFix.Type) sb.Pn(" return %s{", propFix.Type) sb.Pn(" Impl: v,") sb.Pn(" }") sb.Pn("}\n") sb.Pn("type %s struct {", propFix.Type) sb.Pn("Impl proxy.Implementer") sb.Pn("}\n") quotedPropName := strconv.Quote(prop.Name) if strings.Contains(prop.Access, "read") { writePropGet(sb, &propFix.PropertyTypeConfig, quotedPropName) } if strings.Contains(prop.Access, "write") { writePropSet(sb, &propFix.PropertyTypeConfig, quotedPropName) } writePropConnectChanged(sb, &propFix.PropertyTypeConfig, quotedPropName) } } func initNameMap() map[string]int { goKeywords := []string{ "break", "default", "func", "interface", "select", "case", "defer", "go", "map", "struct", "chan", "else", "goto", "package", "switch", "const", "fallthrough", "if", "range", "type", "continue", "for", "import", "return", "var", } nameMap := make(map[string]int, len(goKeywords)) for _, keyword := range goKeywords { nameMap[keyword] = 1 } nameMap["flags"] = 1 nameMap["ch"] = 1 return nameMap } func getName(nameMap map[string]int, name string) string { count := nameMap[name] defer func() { nameMap[name] = count + 1 }() if count == 0 { return name } return name + strconv.Itoa(count-1) } func getArgs(args []introspect.Arg) []introspect.Arg { nameMap := initNameMap() var ret []introspect.Arg fixName := false for idx, arg := range args { if idx == 0 { if arg.Name == "" { fixName = true nameMap["arg"] = 1 } } arg0 := arg if fixName { arg0.Name = getName(nameMap, "arg") } else { arg0.Name = getName(nameMap, arg0.Name) } ret = append(ret, arg0) } return ret } func getInArgs(args []introspect.Arg) []introspect.Arg { var ret []introspect.Arg for _, arg := range args { if arg.Direction != "out" { ret = append(ret, arg) } } return ret } func getOutArgs(args []introspect.Arg) []introspect.Arg { var ret []introspect.Arg for _, arg := range args { if arg.Direction == "out" { ret = append(ret, arg) } } return ret } func getArgType(arg introspect.Arg, argFixes ArgFixes) string { argType := argFixes.get(arg.Name).Type if argType != "" { return argType } return TypeFor(arg.Type).String() } func getArgsProto(args []introspect.Arg, begin bool, argFixes ArgFixes) string { var buf bytes.Buffer for _, arg := range args { argType := getArgType(arg, argFixes) buf.WriteString(fmt.Sprintf(",%s %s", arg.Name, argType)) } return fixList(buf.String(), begin) } func getArgsName(args []introspect.Arg, begin bool) string { var buf bytes.Buffer for _, arg := range args { buf.WriteString(fmt.Sprintf(",%s", arg.Name)) } return fixList(buf.String(), begin) } func getArgsRefName(args []introspect.Arg, begin bool) string { var buf bytes.Buffer for _, arg := range args { buf.WriteString(fmt.Sprintf(",&%s", arg.Name)) } return fixList(buf.String(), begin) } func fixList(str string, begin bool) string { if str == "" || !begin { return str } return str[1:] } func getInterfaceByName(interfaces []introspect.Interface, name string) *introspect.Interface { for _, ifc := range interfaces { if ifc.Name == name { return &ifc } } return nil } go-dbus-factory-1.9.6/_tool/generator/sig.go000066400000000000000000000071601403054572700207620ustar00rootroot00000000000000package main import ( "reflect" "strings" "github.com/godbus/dbus" ) // copy from github.com/godbus/dbus/sig.go var ( byteType = reflect.TypeOf(byte(0)) boolType = reflect.TypeOf(false) uint8Type = reflect.TypeOf(uint8(0)) int16Type = reflect.TypeOf(int16(0)) uint16Type = reflect.TypeOf(uint16(0)) intType = reflect.TypeOf(int(0)) uintType = reflect.TypeOf(uint(0)) int32Type = reflect.TypeOf(int32(0)) uint32Type = reflect.TypeOf(uint32(0)) int64Type = reflect.TypeOf(int64(0)) uint64Type = reflect.TypeOf(uint64(0)) float64Type = reflect.TypeOf(float64(0)) stringType = reflect.TypeOf("") signatureType = reflect.TypeOf(dbus.Signature{}) objectPathType = reflect.TypeOf(dbus.ObjectPath("")) variantType = reflect.TypeOf(dbus.Variant{}) interfacesType = reflect.TypeOf([]interface{}{}) interfaceType = reflect.TypeOf((*interface{})(nil)).Elem() unixFDType = reflect.TypeOf(dbus.UnixFD(0)) unixFDIndexType = reflect.TypeOf(dbus.UnixFDIndex(0)) ) var sigToType = map[byte]reflect.Type{ 'y': byteType, 'b': boolType, 'n': int16Type, 'q': uint16Type, 'i': int32Type, 'u': uint32Type, 'x': int64Type, 't': uint64Type, 'd': float64Type, 's': stringType, 'g': signatureType, 'o': objectPathType, 'v': variantType, 'h': unixFDType, } // Try to read a single type from this string. If it was successful, err is nil // and rem is the remaining unparsed part. Otherwise, err is a non-nil // SignatureError and rem is "". depth is the current recursion depth which may // not be greater than 64 and should be given as 0 on the first call. func validSingle(s string, depth int) (err error, rem string) { if s == "" { return dbus.SignatureError{Sig: s, Reason: "empty signature"}, "" } if depth > 64 { return dbus.SignatureError{Sig: s, Reason: "container nesting too deep"}, "" } switch s[0] { case 'y', 'b', 'n', 'q', 'i', 'u', 'x', 't', 'd', 's', 'g', 'o', 'v', 'h': return nil, s[1:] case 'a': if len(s) > 1 && s[1] == '{' { i := findMatching(s[1:], '{', '}') if i == -1 { return dbus.SignatureError{Sig: s, Reason: "unmatched '{'"}, "" } i++ rem = s[i+1:] s = s[2:i] if err, _ = validSingle(s[:1], depth+1); err != nil { return err, "" } err, nr := validSingle(s[1:], depth+1) if err != nil { return err, "" } if nr != "" { return dbus.SignatureError{Sig: s, Reason: "too many types in dict"}, "" } return nil, rem } return validSingle(s[1:], depth+1) case '(': i := findMatching(s, '(', ')') if i == -1 { return dbus.SignatureError{Sig: s, Reason: "unmatched ')'"}, "" } rem = s[i+1:] s = s[1:i] for err == nil && s != "" { err, s = validSingle(s, depth+1) } if err != nil { rem = "" } return } return dbus.SignatureError{Sig: s, Reason: "invalid type character"}, "" } func findMatching(s string, left, right rune) int { n := 0 for i, v := range s { if v == left { n++ } else if v == right { n-- } if n == 0 { return i } } return -1 } // typeFor returns the type of the given signature. It ignores any left over // characters and panics if s doesn't start with a valid type signature. func typeFor(s string) (t reflect.Type) { err, _ := validSingle(s, 0) if err != nil { panic(err) } if t, ok := sigToType[s[0]]; ok { return t } switch s[0] { case 'a': if s[1] == '{' { i := strings.LastIndex(s, "}") t = reflect.MapOf(sigToType[s[2]], typeFor(s[3:i])) } else { t = reflect.SliceOf(typeFor(s[1:])) } case '(': t = interfacesType } return } func TypeFor(s string) reflect.Type { return typeFor(s) } go-dbus-factory-1.9.6/_tool/generator/source_file.go000066400000000000000000000041371403054572700225000ustar00rootroot00000000000000package main import ( "bytes" "fmt" "io" "log" "os" "os/exec" "sort" "strings" ) type SourceFile struct { Pkg string GoImports []string GoBody *SourceBody } func NewSourceFile(pkg string) *SourceFile { sf := &SourceFile{ Pkg: pkg, GoBody: &SourceBody{}, } return sf } func (v *SourceFile) Print() error { _, err := v.WriteTo(os.Stdout) return err } func (v *SourceFile) Save(filename string) { f, err := os.Create(filename) if err != nil { log.Fatal("fail to create file:", err) } defer f.Close() _, err = v.WriteTo(f) if err != nil { log.Fatal("failed to write to file:", err) } out, err := exec.Command("goimports", "-w", filename).CombinedOutput() if err != nil { log.Printf("%s", out) log.Fatal("failed to format file:", filename) } } func (v *SourceFile) WriteTo(w io.Writer) (n int64, err error) { var wn int cmdline := strings.Join(os.Args, " ") wn, err = io.WriteString(w, fmt.Sprintf("// Code generated by %q; DO NOT EDIT.\n\n", cmdline)) n += int64(wn) if err != nil { return } wn, err = io.WriteString(w, "package "+v.Pkg+"\n") n += int64(wn) if err != nil { return } sort.Strings(v.GoImports) for _, imp := range v.GoImports { wn, err = io.WriteString(w, "import "+imp+"\n") n += int64(wn) if err != nil { return } } wn, err = w.Write(v.GoBody.buf.Bytes()) n += int64(wn) return } // unsafe => "unsafe" // or x,github.com/path/ => x "path" func (s *SourceFile) AddGoImport(imp string) { var importStr string if strings.Contains(imp, ",") { parts := strings.SplitN(imp, ",", 2) importStr = fmt.Sprintf("%s %q", parts[0], parts[1]) } else { importStr = `"` + imp + `"` } for _, imp0 := range s.GoImports { if imp0 == importStr { return } } s.GoImports = append(s.GoImports, importStr) } type SourceBody struct { buf bytes.Buffer } func (v *SourceBody) writeStr(str string) { v.buf.WriteString(str) } func (v *SourceBody) Pn(format string, a ...interface{}) { v.P(format, a...) v.buf.WriteByte('\n') } func (v *SourceBody) P(format string, a ...interface{}) { str := fmt.Sprintf(format, a...) v.writeStr(str) } go-dbus-factory-1.9.6/_tool/prop_gen/000077500000000000000000000000001403054572700174705ustar00rootroot00000000000000go-dbus-factory-1.9.6/_tool/prop_gen/gen.sh000077500000000000000000000001561403054572700206020ustar00rootroot00000000000000#!/bin/sh set -x dstFile=$proj_deepin_go_lib/dbusutil/proxy/prop.go go run main.go > $dstFile go fmt $dstFile go-dbus-factory-1.9.6/_tool/prop_gen/main.go000066400000000000000000000043101403054572700207410ustar00rootroot00000000000000package main import ( "fmt" "log" "os" "strings" "text/template" ) const propCode = ` type Prop{{.Type}} struct { Impl Implementer Name string } func (p Prop{{.Type}}) Get(flags dbus.Flags) (value {{.GoType}}, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p Prop{{.Type}}) Set(flags dbus.Flags, value {{.GoType}}) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p Prop{{.Type}}) ConnectChanged(cb func(hasValue bool, value {{.GoType}})) error { if cb == nil { return errNilCallback } cb0 := func(hasValue bool, value interface{}) { if hasValue { val, ok := value.({{.GoType}}) if ok { cb(true, val) } } else { cb(false, {{.GoEmptyValue}}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } ` type config struct { Type string GoType string GoEmptyValue string } func main() { configs := []config{ { Type: "Bool", GoType: "bool", GoEmptyValue: "false", }, { Type: "String", GoType: "string", GoEmptyValue: `""`, }, { Type: "ObjectPath", GoType: "dbus.ObjectPath", GoEmptyValue: `""`, }, { Type: "Double", GoType: "float64", GoEmptyValue: "0", }, } addNumType := func(name string) { configs = append(configs, config{ Type: name, GoType: strings.ToLower(name), GoEmptyValue: "0", }) } for _, name := range []string{"Byte", "Int16", "Uint16", "Int32", "Uint32", "Int64", "Uint64"} { addNumType(name) } t := template.Must(template.New("propCode").Parse(propCode)) fmt.Println("package proxy") fmt.Println("import \"errors\"") fmt.Println("import \"github.com/godbus/dbus\"") fmt.Println("\nvar errNilCallback = errors.New(\"nil callback\")") for _, cfg := range configs { err := t.Execute(os.Stdout, cfg) if err != nil { log.Fatal(err) } } for _, cfg := range configs { cfg.Type = cfg.Type + "Array" cfg.GoType = "[]" + cfg.GoType cfg.GoEmptyValue = "nil" err := t.Execute(os.Stdout, cfg) if err != nil { log.Fatal(err) } } } go-dbus-factory-1.9.6/com.deepin.abrecovery/000077500000000000000000000000001403054572700207245ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.abrecovery/ABRecovery.xml000066400000000000000000000045041403054572700234520ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.abrecovery/auto.go000066400000000000000000000065121403054572700222270ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.abrecovery"; DO NOT EDIT. package abrecovery import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type ABRecovery struct { abRecovery // interface com.deepin.ABRecovery proxy.Object } func NewABRecovery(conn *dbus.Conn) *ABRecovery { obj := new(ABRecovery) obj.Object.Init_(conn, "com.deepin.ABRecovery", "/com/deepin/ABRecovery") return obj } type abRecovery struct{} func (v *abRecovery) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*abRecovery) GetInterfaceName_() string { return "com.deepin.ABRecovery" } // method CanBackup func (v *abRecovery) GoCanBackup(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanBackup", flags, ch) } func (*abRecovery) StoreCanBackup(call *dbus.Call) (can bool, err error) { err = call.Store(&can) return } func (v *abRecovery) CanBackup(flags dbus.Flags) (can bool, err error) { return v.StoreCanBackup( <-v.GoCanBackup(flags, make(chan *dbus.Call, 1)).Done) } // method CanRestore func (v *abRecovery) GoCanRestore(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanRestore", flags, ch) } func (*abRecovery) StoreCanRestore(call *dbus.Call) (can bool, err error) { err = call.Store(&can) return } func (v *abRecovery) CanRestore(flags dbus.Flags) (can bool, err error) { return v.StoreCanRestore( <-v.GoCanRestore(flags, make(chan *dbus.Call, 1)).Done) } // method StartBackup func (v *abRecovery) GoStartBackup(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StartBackup", flags, ch) } func (v *abRecovery) StartBackup(flags dbus.Flags) error { return (<-v.GoStartBackup(flags, make(chan *dbus.Call, 1)).Done).Err } // method StartRestore func (v *abRecovery) GoStartRestore(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StartRestore", flags, ch) } func (v *abRecovery) StartRestore(flags dbus.Flags) error { return (<-v.GoStartRestore(flags, make(chan *dbus.Call, 1)).Done).Err } // signal JobEnd func (v *abRecovery) ConnectJobEnd(cb func(kind string, success bool, errMsg string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "JobEnd", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".JobEnd", } handlerFunc := func(sig *dbus.Signal) { var kind string var success bool var errMsg string err := dbus.Store(sig.Body, &kind, &success, &errMsg) if err == nil { cb(kind, success, errMsg) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property BackingUp b func (v *abRecovery) BackingUp() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "BackingUp", } } // property Restoring b func (v *abRecovery) Restoring() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Restoring", } } // property ConfigValid b func (v *abRecovery) ConfigValid() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ConfigValid", } } go-dbus-factory-1.9.6/com.deepin.abrecovery/config.json000066400000000000000000000004111403054572700230600ustar00rootroot00000000000000{ "Service": "com.deepin.ABRecovery", "Objects": [ { "Type": "ABRecovery", "Path": "/com/deepin/ABRecovery", "Interfaces": [ { "Name": "com.deepin.ABRecovery", "Type": "abRecovery" } ] } ] } go-dbus-factory-1.9.6/com.deepin.api.cursorhelper/000077500000000000000000000000001403054572700220505ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.api.cursorhelper/CursorHelper.xml000066400000000000000000000033471403054572700252160ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.api.cursorhelper/auto.go000066400000000000000000000017561403054572700233600ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.api.cursorhelper"; DO NOT EDIT. package cursorhelper import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type CursorHelper struct { cursorHelper // interface com.deepin.api.CursorHelper proxy.Object } func NewCursorHelper(conn *dbus.Conn) *CursorHelper { obj := new(CursorHelper) obj.Object.Init_(conn, "com.deepin.api.CursorHelper", "/com/deepin/api/CursorHelper") return obj } type cursorHelper struct{} func (v *cursorHelper) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*cursorHelper) GetInterfaceName_() string { return "com.deepin.api.CursorHelper" } // method Set func (v *cursorHelper) GoSet(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Set", flags, ch, name) } func (v *cursorHelper) Set(flags dbus.Flags, name string) error { return (<-v.GoSet(flags, make(chan *dbus.Call, 1), name).Done).Err } go-dbus-factory-1.9.6/com.deepin.api.cursorhelper/config.json000066400000000000000000000004371403054572700242140ustar00rootroot00000000000000{ "Service": "com.deepin.api.CursorHelper", "Objects": [ { "Type": "CursorHelper", "Path": "/com/deepin/api/CursorHelper", "Interfaces": [ { "Name": "com.deepin.api.CursorHelper", "Type": "cursorHelper" } ] } ] } go-dbus-factory-1.9.6/com.deepin.api.device/000077500000000000000000000000001403054572700205725ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.api.device/Device.xml000066400000000000000000000034601403054572700225160ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.api.device/auto.go000066400000000000000000000027631403054572700221010ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.api.device"; DO NOT EDIT. package device import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type Device struct { device // interface com.deepin.api.Device proxy.Object } func NewDevice(conn *dbus.Conn) *Device { obj := new(Device) obj.Object.Init_(conn, "com.deepin.api.Device", "/com/deepin/api/Device") return obj } type device struct{} func (v *device) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*device) GetInterfaceName_() string { return "com.deepin.api.Device" } // method HasBluetoothDeviceBlocked func (v *device) GoHasBluetoothDeviceBlocked(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".HasBluetoothDeviceBlocked", flags, ch) } func (*device) StoreHasBluetoothDeviceBlocked(call *dbus.Call) (has bool, err error) { err = call.Store(&has) return } func (v *device) HasBluetoothDeviceBlocked(flags dbus.Flags) (has bool, err error) { return v.StoreHasBluetoothDeviceBlocked( <-v.GoHasBluetoothDeviceBlocked(flags, make(chan *dbus.Call, 1)).Done) } // method UnblockBluetoothDevices func (v *device) GoUnblockBluetoothDevices(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnblockBluetoothDevices", flags, ch) } func (v *device) UnblockBluetoothDevices(flags dbus.Flags) error { return (<-v.GoUnblockBluetoothDevices(flags, make(chan *dbus.Call, 1)).Done).Err } go-dbus-factory-1.9.6/com.deepin.api.device/config.json000066400000000000000000000004011403054572700227250ustar00rootroot00000000000000{ "Service": "com.deepin.api.Device", "Objects": [ { "Type": "Device", "Path": "/com/deepin/api/Device", "Interfaces": [ { "Name": "com.deepin.api.Device", "Type": "device" } ] } ] } go-dbus-factory-1.9.6/com.deepin.api.localehelper/000077500000000000000000000000001403054572700217725ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.api.localehelper/LocaleHelper.xml000066400000000000000000000037621403054572700250630ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.api.localehelper/auto.go000066400000000000000000000041661403054572700233000ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.api.localehelper"; DO NOT EDIT. package localehelper import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type LocaleHelper struct { localeHelper // interface com.deepin.api.LocaleHelper proxy.Object } func NewLocaleHelper(conn *dbus.Conn) *LocaleHelper { obj := new(LocaleHelper) obj.Object.Init_(conn, "com.deepin.api.LocaleHelper", "/com/deepin/api/LocaleHelper") return obj } type localeHelper struct{} func (v *localeHelper) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*localeHelper) GetInterfaceName_() string { return "com.deepin.api.LocaleHelper" } // method GenerateLocale func (v *localeHelper) GoGenerateLocale(flags dbus.Flags, ch chan *dbus.Call, locale string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GenerateLocale", flags, ch, locale) } func (v *localeHelper) GenerateLocale(flags dbus.Flags, locale string) error { return (<-v.GoGenerateLocale(flags, make(chan *dbus.Call, 1), locale).Done).Err } // method SetLocale func (v *localeHelper) GoSetLocale(flags dbus.Flags, ch chan *dbus.Call, locale string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLocale", flags, ch, locale) } func (v *localeHelper) SetLocale(flags dbus.Flags, locale string) error { return (<-v.GoSetLocale(flags, make(chan *dbus.Call, 1), locale).Done).Err } // signal Success func (v *localeHelper) ConnectSuccess(cb func(ok bool, reason string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Success", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Success", } handlerFunc := func(sig *dbus.Signal) { var ok bool var reason string err := dbus.Store(sig.Body, &ok, &reason) if err == nil { cb(ok, reason) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.deepin.api.localehelper/config.json000066400000000000000000000004371403054572700241360ustar00rootroot00000000000000{ "Service": "com.deepin.api.LocaleHelper", "Objects": [ { "Type": "LocaleHelper", "Path": "/com/deepin/api/LocaleHelper", "Interfaces": [ { "Name": "com.deepin.api.LocaleHelper", "Type": "localeHelper" } ] } ] } go-dbus-factory-1.9.6/com.deepin.api.lunarcalendar/000077500000000000000000000000001403054572700221465ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.api.lunarcalendar/LunarCalendar.xml000066400000000000000000000070471403054572700254130ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.api.lunarcalendar/auto.go000066400000000000000000000061511403054572700234500ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.api.lunarcalendar"; DO NOT EDIT. package lunarcalendar import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type LunarCalendar struct { lunarCalendar // interface com.deepin.api.LunarCalendar proxy.Object } func NewLunarCalendar(conn *dbus.Conn) *LunarCalendar { obj := new(LunarCalendar) obj.Object.Init_(conn, "com.deepin.api.LunarCalendar", "/com/deepin/api/LunarCalendar") return obj } type lunarCalendar struct{} func (v *lunarCalendar) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*lunarCalendar) GetInterfaceName_() string { return "com.deepin.api.LunarCalendar" } // method GetFestivalMonth func (v *lunarCalendar) GoGetFestivalMonth(flags dbus.Flags, ch chan *dbus.Call, year int32, month int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetFestivalMonth", flags, ch, year, month) } func (*lunarCalendar) StoreGetFestivalMonth(call *dbus.Call) (json string, err error) { err = call.Store(&json) return } func (v *lunarCalendar) GetFestivalMonth(flags dbus.Flags, year int32, month int32) (json string, err error) { return v.StoreGetFestivalMonth( <-v.GoGetFestivalMonth(flags, make(chan *dbus.Call, 1), year, month).Done) } // method GetFestivalsInRange func (v *lunarCalendar) GoGetFestivalsInRange(flags dbus.Flags, ch chan *dbus.Call, startDate string, endDate string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetFestivalsInRange", flags, ch, startDate, endDate) } func (*lunarCalendar) StoreGetFestivalsInRange(call *dbus.Call) (result []DayFestival, err error) { err = call.Store(&result) return } func (v *lunarCalendar) GetFestivalsInRange(flags dbus.Flags, startDate string, endDate string) (result []DayFestival, err error) { return v.StoreGetFestivalsInRange( <-v.GoGetFestivalsInRange(flags, make(chan *dbus.Call, 1), startDate, endDate).Done) } // method GetHuangLiDay func (v *lunarCalendar) GoGetHuangLiDay(flags dbus.Flags, ch chan *dbus.Call, year int32, month int32, day int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetHuangLiDay", flags, ch, year, month, day) } func (*lunarCalendar) StoreGetHuangLiDay(call *dbus.Call) (json string, err error) { err = call.Store(&json) return } func (v *lunarCalendar) GetHuangLiDay(flags dbus.Flags, year int32, month int32, day int32) (json string, err error) { return v.StoreGetHuangLiDay( <-v.GoGetHuangLiDay(flags, make(chan *dbus.Call, 1), year, month, day).Done) } // method GetHuangLiMonth func (v *lunarCalendar) GoGetHuangLiMonth(flags dbus.Flags, ch chan *dbus.Call, year int32, month int32, fill bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetHuangLiMonth", flags, ch, year, month, fill) } func (*lunarCalendar) StoreGetHuangLiMonth(call *dbus.Call) (json string, err error) { err = call.Store(&json) return } func (v *lunarCalendar) GetHuangLiMonth(flags dbus.Flags, year int32, month int32, fill bool) (json string, err error) { return v.StoreGetHuangLiMonth( <-v.GoGetHuangLiMonth(flags, make(chan *dbus.Call, 1), year, month, fill).Done) } go-dbus-factory-1.9.6/com.deepin.api.lunarcalendar/config.json000066400000000000000000000010151403054572700243030ustar00rootroot00000000000000{ "Service": "com.deepin.api.LunarCalendar", "Objects": [ { "Type": "LunarCalendar", "Path": "/com/deepin/api/LunarCalendar", "Interfaces": [ { "Name": "com.deepin.api.LunarCalendar", "Type": "lunarCalendar", "Accessor": "LunarCalendar", "Fixes": { "m/GetFestivalsInRange": [ { "Name" : "result", "Type": "[]DayFestival" } ] } } ] } ] } go-dbus-factory-1.9.6/com.deepin.api.lunarcalendar/manual.go000066400000000000000000000001531403054572700237510ustar00rootroot00000000000000package lunarcalendar type DayFestival struct { Year int32 Month int32 Day int32 Festivals []string } go-dbus-factory-1.9.6/com.deepin.api.pinyin/000077500000000000000000000000001403054572700206415ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.api.pinyin/Pinyin.xml000066400000000000000000000037251403054572700226400ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.api.pinyin/auto.go000066400000000000000000000030421403054572700221370ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.api.pinyin"; DO NOT EDIT. package pinyin import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type Pinyin struct { pinyin // interface com.deepin.api.Pinyin proxy.Object } func NewPinyin(conn *dbus.Conn) *Pinyin { obj := new(Pinyin) obj.Object.Init_(conn, "com.deepin.api.Pinyin", "/com/deepin/api/Pinyin") return obj } type pinyin struct{} func (v *pinyin) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*pinyin) GetInterfaceName_() string { return "com.deepin.api.Pinyin" } // method Query func (v *pinyin) GoQuery(flags dbus.Flags, ch chan *dbus.Call, hans string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Query", flags, ch, hans) } func (*pinyin) StoreQuery(call *dbus.Call) (pinyin []string, err error) { err = call.Store(&pinyin) return } func (v *pinyin) Query(flags dbus.Flags, hans string) (pinyin []string, err error) { return v.StoreQuery( <-v.GoQuery(flags, make(chan *dbus.Call, 1), hans).Done) } // method QueryList func (v *pinyin) GoQueryList(flags dbus.Flags, ch chan *dbus.Call, hansList []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".QueryList", flags, ch, hansList) } func (*pinyin) StoreQueryList(call *dbus.Call) (json string, err error) { err = call.Store(&json) return } func (v *pinyin) QueryList(flags dbus.Flags, hansList []string) (json string, err error) { return v.StoreQueryList( <-v.GoQueryList(flags, make(chan *dbus.Call, 1), hansList).Done) } go-dbus-factory-1.9.6/com.deepin.api.pinyin/config.json000066400000000000000000000004011403054572700227740ustar00rootroot00000000000000{ "Service": "com.deepin.api.Pinyin", "Objects": [ { "Type": "Pinyin", "Path": "/com/deepin/api/Pinyin", "Interfaces": [ { "Name": "com.deepin.api.Pinyin", "Type": "pinyin" } ] } ] } go-dbus-factory-1.9.6/com.deepin.api.soundthemeplayer/000077500000000000000000000000001403054572700227235ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.api.soundthemeplayer/SoundThemePlayer.xml000066400000000000000000000044301403054572700266760ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.api.soundthemeplayer/auto.go000066400000000000000000000054161403054572700242300ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.api.soundthemeplayer"; DO NOT EDIT. package soundthemeplayer import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type SoundThemePlayer struct { soundThemePlayer // interface com.deepin.api.SoundThemePlayer proxy.Object } func NewSoundThemePlayer(conn *dbus.Conn) *SoundThemePlayer { obj := new(SoundThemePlayer) obj.Object.Init_(conn, "com.deepin.api.SoundThemePlayer", "/com/deepin/api/SoundThemePlayer") return obj } type soundThemePlayer struct{} func (v *soundThemePlayer) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*soundThemePlayer) GetInterfaceName_() string { return "com.deepin.api.SoundThemePlayer" } // method EnableSoundDesktopLogin func (v *soundThemePlayer) GoEnableSoundDesktopLogin(flags dbus.Flags, ch chan *dbus.Call, enabled bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnableSoundDesktopLogin", flags, ch, enabled) } func (v *soundThemePlayer) EnableSoundDesktopLogin(flags dbus.Flags, enabled bool) error { return (<-v.GoEnableSoundDesktopLogin(flags, make(chan *dbus.Call, 1), enabled).Done).Err } // method Play func (v *soundThemePlayer) GoPlay(flags dbus.Flags, ch chan *dbus.Call, theme string, event string, device string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Play", flags, ch, theme, event, device) } func (v *soundThemePlayer) Play(flags dbus.Flags, theme string, event string, device string) error { return (<-v.GoPlay(flags, make(chan *dbus.Call, 1), theme, event, device).Done).Err } // method PlaySoundDesktopLogin func (v *soundThemePlayer) GoPlaySoundDesktopLogin(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PlaySoundDesktopLogin", flags, ch) } func (v *soundThemePlayer) PlaySoundDesktopLogin(flags dbus.Flags) error { return (<-v.GoPlaySoundDesktopLogin(flags, make(chan *dbus.Call, 1)).Done).Err } // method SaveAudioState func (v *soundThemePlayer) GoSaveAudioState(flags dbus.Flags, ch chan *dbus.Call, activePlayback map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SaveAudioState", flags, ch, activePlayback) } func (v *soundThemePlayer) SaveAudioState(flags dbus.Flags, activePlayback map[string]dbus.Variant) error { return (<-v.GoSaveAudioState(flags, make(chan *dbus.Call, 1), activePlayback).Done).Err } // method SetSoundTheme func (v *soundThemePlayer) GoSetSoundTheme(flags dbus.Flags, ch chan *dbus.Call, theme string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetSoundTheme", flags, ch, theme) } func (v *soundThemePlayer) SetSoundTheme(flags dbus.Flags, theme string) error { return (<-v.GoSetSoundTheme(flags, make(chan *dbus.Call, 1), theme).Done).Err } go-dbus-factory-1.9.6/com.deepin.api.soundthemeplayer/config.json000066400000000000000000000004631403054572700250660ustar00rootroot00000000000000{ "Service": "com.deepin.api.SoundThemePlayer", "Objects": [ { "Type": "SoundThemePlayer", "Path": "/com/deepin/api/SoundThemePlayer", "Interfaces": [ { "Name": "com.deepin.api.SoundThemePlayer", "Type": "soundThemePlayer" } ] } ] } go-dbus-factory-1.9.6/com.deepin.api.xeventmonitor/000077500000000000000000000000001403054572700222545ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.api.xeventmonitor/XEventMonitor.xml000066400000000000000000000077761403054572700256000ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.api.xeventmonitor/auto.go000066400000000000000000000211151403054572700235530ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.api.xeventmonitor"; DO NOT EDIT. package xeventmonitor import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type XEventMonitor struct { xEventMonitor // interface com.deepin.api.XEventMonitor proxy.Object } func NewXEventMonitor(conn *dbus.Conn) *XEventMonitor { obj := new(XEventMonitor) obj.Object.Init_(conn, "com.deepin.api.XEventMonitor", "/com/deepin/api/XEventMonitor") return obj } type xEventMonitor struct{} func (v *xEventMonitor) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*xEventMonitor) GetInterfaceName_() string { return "com.deepin.api.XEventMonitor" } // method RegisterArea func (v *xEventMonitor) GoRegisterArea(flags dbus.Flags, ch chan *dbus.Call, x1 int32, y1 int32, x2 int32, y2 int32, flag int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterArea", flags, ch, x1, y1, x2, y2, flag) } func (*xEventMonitor) StoreRegisterArea(call *dbus.Call) (id string, err error) { err = call.Store(&id) return } func (v *xEventMonitor) RegisterArea(flags dbus.Flags, x1 int32, y1 int32, x2 int32, y2 int32, flag int32) (id string, err error) { return v.StoreRegisterArea( <-v.GoRegisterArea(flags, make(chan *dbus.Call, 1), x1, y1, x2, y2, flag).Done) } // method RegisterAreas func (v *xEventMonitor) GoRegisterAreas(flags dbus.Flags, ch chan *dbus.Call, areas []CoordinateRange, flag int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterAreas", flags, ch, areas, flag) } func (*xEventMonitor) StoreRegisterAreas(call *dbus.Call) (id string, err error) { err = call.Store(&id) return } func (v *xEventMonitor) RegisterAreas(flags dbus.Flags, areas []CoordinateRange, flag int32) (id string, err error) { return v.StoreRegisterAreas( <-v.GoRegisterAreas(flags, make(chan *dbus.Call, 1), areas, flag).Done) } // method RegisterFullScreen func (v *xEventMonitor) GoRegisterFullScreen(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterFullScreen", flags, ch) } func (*xEventMonitor) StoreRegisterFullScreen(call *dbus.Call) (id string, err error) { err = call.Store(&id) return } func (v *xEventMonitor) RegisterFullScreen(flags dbus.Flags) (id string, err error) { return v.StoreRegisterFullScreen( <-v.GoRegisterFullScreen(flags, make(chan *dbus.Call, 1)).Done) } // method UnregisterArea func (v *xEventMonitor) GoUnregisterArea(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnregisterArea", flags, ch, id) } func (*xEventMonitor) StoreUnregisterArea(call *dbus.Call) (ok bool, err error) { err = call.Store(&ok) return } func (v *xEventMonitor) UnregisterArea(flags dbus.Flags, id string) (ok bool, err error) { return v.StoreUnregisterArea( <-v.GoUnregisterArea(flags, make(chan *dbus.Call, 1), id).Done) } // signal CancelAllArea func (v *xEventMonitor) ConnectCancelAllArea(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "CancelAllArea", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".CancelAllArea", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal CursorInto func (v *xEventMonitor) ConnectCursorInto(cb func(x int32, y int32, id string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "CursorInto", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".CursorInto", } handlerFunc := func(sig *dbus.Signal) { var x int32 var y int32 var id string err := dbus.Store(sig.Body, &x, &y, &id) if err == nil { cb(x, y, id) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal CursorOut func (v *xEventMonitor) ConnectCursorOut(cb func(x int32, y int32, id string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "CursorOut", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".CursorOut", } handlerFunc := func(sig *dbus.Signal) { var x int32 var y int32 var id string err := dbus.Store(sig.Body, &x, &y, &id) if err == nil { cb(x, y, id) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal CursorMove func (v *xEventMonitor) ConnectCursorMove(cb func(x int32, y int32, id string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "CursorMove", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".CursorMove", } handlerFunc := func(sig *dbus.Signal) { var x int32 var y int32 var id string err := dbus.Store(sig.Body, &x, &y, &id) if err == nil { cb(x, y, id) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ButtonPress func (v *xEventMonitor) ConnectButtonPress(cb func(button int32, x int32, y int32, id string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ButtonPress", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ButtonPress", } handlerFunc := func(sig *dbus.Signal) { var button int32 var x int32 var y int32 var id string err := dbus.Store(sig.Body, &button, &x, &y, &id) if err == nil { cb(button, x, y, id) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ButtonRelease func (v *xEventMonitor) ConnectButtonRelease(cb func(button int32, x int32, y int32, id string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ButtonRelease", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ButtonRelease", } handlerFunc := func(sig *dbus.Signal) { var button int32 var x int32 var y int32 var id string err := dbus.Store(sig.Body, &button, &x, &y, &id) if err == nil { cb(button, x, y, id) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal KeyPress func (v *xEventMonitor) ConnectKeyPress(cb func(key string, x int32, y int32, id string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "KeyPress", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".KeyPress", } handlerFunc := func(sig *dbus.Signal) { var key string var x int32 var y int32 var id string err := dbus.Store(sig.Body, &key, &x, &y, &id) if err == nil { cb(key, x, y, id) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal KeyRelease func (v *xEventMonitor) ConnectKeyRelease(cb func(key string, x int32, y int32, id string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "KeyRelease", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".KeyRelease", } handlerFunc := func(sig *dbus.Signal) { var key string var x int32 var y int32 var id string err := dbus.Store(sig.Body, &key, &x, &y, &id) if err == nil { cb(key, x, y, id) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.deepin.api.xeventmonitor/config.json000066400000000000000000000007411403054572700244160ustar00rootroot00000000000000{ "Service":"com.deepin.api.XEventMonitor", "Objects": [ { "Type": "XEventMonitor", "Path":"/com/deepin/api/XEventMonitor", "Interfaces": [ { "Name": "com.deepin.api.XEventMonitor", "Type": "xEventMonitor", "Fixes": { "m/RegisterAreas": [ { "Name": "areas", "Type": "[]CoordinateRange" } ] } } ] } ] } go-dbus-factory-1.9.6/com.deepin.api.xeventmonitor/manual.go000066400000000000000000000001151403054572700240550ustar00rootroot00000000000000package xeventmonitor type CoordinateRange struct { X1, Y1, X2, Y2 int32 } go-dbus-factory-1.9.6/com.deepin.daemon.accounts/000077500000000000000000000000001403054572700216445ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.accounts/Accounts.xml000066400000000000000000000075551403054572700241610ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.accounts/ImageBlur.xml000066400000000000000000000041301403054572700242330ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.accounts/User.xml000066400000000000000000000151371403054572700233130ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.accounts/auto.go000066400000000000000000000545421403054572700231550ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.accounts"; DO NOT EDIT. package accounts import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Accounts struct { accounts // interface com.deepin.daemon.Accounts proxy.Object } func NewAccounts(conn *dbus.Conn) *Accounts { obj := new(Accounts) obj.Object.Init_(conn, "com.deepin.daemon.Accounts", "/com/deepin/daemon/Accounts") return obj } type accounts struct{} func (v *accounts) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*accounts) GetInterfaceName_() string { return "com.deepin.daemon.Accounts" } // method AllowGuestAccount func (v *accounts) GoAllowGuestAccount(flags dbus.Flags, ch chan *dbus.Call, allow bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AllowGuestAccount", flags, ch, allow) } func (v *accounts) AllowGuestAccount(flags dbus.Flags, allow bool) error { return (<-v.GoAllowGuestAccount(flags, make(chan *dbus.Call, 1), allow).Done).Err } // method CreateGuestAccount func (v *accounts) GoCreateGuestAccount(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateGuestAccount", flags, ch) } func (*accounts) StoreCreateGuestAccount(call *dbus.Call) (user string, err error) { err = call.Store(&user) return } func (v *accounts) CreateGuestAccount(flags dbus.Flags) (user string, err error) { return v.StoreCreateGuestAccount( <-v.GoCreateGuestAccount(flags, make(chan *dbus.Call, 1)).Done) } // method CreateUser func (v *accounts) GoCreateUser(flags dbus.Flags, ch chan *dbus.Call, name string, fullName string, type0 int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateUser", flags, ch, name, fullName, type0) } func (*accounts) StoreCreateUser(call *dbus.Call) (user dbus.ObjectPath, err error) { err = call.Store(&user) return } func (v *accounts) CreateUser(flags dbus.Flags, name string, fullName string, type0 int32) (user dbus.ObjectPath, err error) { return v.StoreCreateUser( <-v.GoCreateUser(flags, make(chan *dbus.Call, 1), name, fullName, type0).Done) } // method DeleteUser func (v *accounts) GoDeleteUser(flags dbus.Flags, ch chan *dbus.Call, name string, rmFiles bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteUser", flags, ch, name, rmFiles) } func (v *accounts) DeleteUser(flags dbus.Flags, name string, rmFiles bool) error { return (<-v.GoDeleteUser(flags, make(chan *dbus.Call, 1), name, rmFiles).Done).Err } // method FindUserById func (v *accounts) GoFindUserById(flags dbus.Flags, ch chan *dbus.Call, uid string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FindUserById", flags, ch, uid) } func (*accounts) StoreFindUserById(call *dbus.Call) (user string, err error) { err = call.Store(&user) return } func (v *accounts) FindUserById(flags dbus.Flags, uid string) (user string, err error) { return v.StoreFindUserById( <-v.GoFindUserById(flags, make(chan *dbus.Call, 1), uid).Done) } // method FindUserByName func (v *accounts) GoFindUserByName(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FindUserByName", flags, ch, name) } func (*accounts) StoreFindUserByName(call *dbus.Call) (user string, err error) { err = call.Store(&user) return } func (v *accounts) FindUserByName(flags dbus.Flags, name string) (user string, err error) { return v.StoreFindUserByName( <-v.GoFindUserByName(flags, make(chan *dbus.Call, 1), name).Done) } // method IsPasswordValid func (v *accounts) GoIsPasswordValid(flags dbus.Flags, ch chan *dbus.Call, password string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsPasswordValid", flags, ch, password) } func (*accounts) StoreIsPasswordValid(call *dbus.Call) (ok bool, errReason string, errCode int32, err error) { err = call.Store(&ok, &errReason, &errCode) return } func (v *accounts) IsPasswordValid(flags dbus.Flags, password string) (ok bool, errReason string, errCode int32, err error) { return v.StoreIsPasswordValid( <-v.GoIsPasswordValid(flags, make(chan *dbus.Call, 1), password).Done) } // method IsUsernameValid func (v *accounts) GoIsUsernameValid(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsUsernameValid", flags, ch, name) } func (*accounts) StoreIsUsernameValid(call *dbus.Call) (ok bool, errReason string, errCode int32, err error) { err = call.Store(&ok, &errReason, &errCode) return } func (v *accounts) IsUsernameValid(flags dbus.Flags, name string) (ok bool, errReason string, errCode int32, err error) { return v.StoreIsUsernameValid( <-v.GoIsUsernameValid(flags, make(chan *dbus.Call, 1), name).Done) } // method RandUserIcon func (v *accounts) GoRandUserIcon(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RandUserIcon", flags, ch) } func (*accounts) StoreRandUserIcon(call *dbus.Call) (iconFile string, err error) { err = call.Store(&iconFile) return } func (v *accounts) RandUserIcon(flags dbus.Flags) (iconFile string, err error) { return v.StoreRandUserIcon( <-v.GoRandUserIcon(flags, make(chan *dbus.Call, 1)).Done) } // signal UserAdded func (v *accounts) ConnectUserAdded(cb func(objPath string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "UserAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".UserAdded", } handlerFunc := func(sig *dbus.Signal) { var objPath string err := dbus.Store(sig.Body, &objPath) if err == nil { cb(objPath) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal UserDeleted func (v *accounts) ConnectUserDeleted(cb func(objPath string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "UserDeleted", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".UserDeleted", } handlerFunc := func(sig *dbus.Signal) { var objPath string err := dbus.Store(sig.Body, &objPath) if err == nil { cb(objPath) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property UserList as func (v *accounts) UserList() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "UserList", } } // property GuestIcon s func (v *accounts) GuestIcon() proxy.PropString { return proxy.PropString{ Impl: v, Name: "GuestIcon", } } // property AllowGuest b func (v *accounts) AllowGuest() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "AllowGuest", } } type User struct { user // interface com.deepin.daemon.Accounts.User proxy.Object } func NewUser(conn *dbus.Conn, path dbus.ObjectPath) (*User, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(User) obj.Object.Init_(conn, "com.deepin.daemon.Accounts", path) return obj, nil } type user struct{} func (v *user) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*user) GetInterfaceName_() string { return "com.deepin.daemon.Accounts.User" } // method AddGroup func (v *user) GoAddGroup(flags dbus.Flags, ch chan *dbus.Call, group string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddGroup", flags, ch, group) } func (v *user) AddGroup(flags dbus.Flags, group string) error { return (<-v.GoAddGroup(flags, make(chan *dbus.Call, 1), group).Done).Err } // method DeleteGroup func (v *user) GoDeleteGroup(flags dbus.Flags, ch chan *dbus.Call, group string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteGroup", flags, ch, group) } func (v *user) DeleteGroup(flags dbus.Flags, group string) error { return (<-v.GoDeleteGroup(flags, make(chan *dbus.Call, 1), group).Done).Err } // method DeleteIconFile func (v *user) GoDeleteIconFile(flags dbus.Flags, ch chan *dbus.Call, iconFile string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteIconFile", flags, ch, iconFile) } func (v *user) DeleteIconFile(flags dbus.Flags, iconFile string) error { return (<-v.GoDeleteIconFile(flags, make(chan *dbus.Call, 1), iconFile).Done).Err } // method EnableNoPasswdLogin func (v *user) GoEnableNoPasswdLogin(flags dbus.Flags, ch chan *dbus.Call, enabled bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnableNoPasswdLogin", flags, ch, enabled) } func (v *user) EnableNoPasswdLogin(flags dbus.Flags, enabled bool) error { return (<-v.GoEnableNoPasswdLogin(flags, make(chan *dbus.Call, 1), enabled).Done).Err } // method SetAutomaticLogin func (v *user) GoSetAutomaticLogin(flags dbus.Flags, ch chan *dbus.Call, enabled bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetAutomaticLogin", flags, ch, enabled) } func (v *user) SetAutomaticLogin(flags dbus.Flags, enabled bool) error { return (<-v.GoSetAutomaticLogin(flags, make(chan *dbus.Call, 1), enabled).Done).Err } // method SetDesktopBackgrounds func (v *user) GoSetDesktopBackgrounds(flags dbus.Flags, ch chan *dbus.Call, backgrounds []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDesktopBackgrounds", flags, ch, backgrounds) } func (v *user) SetDesktopBackgrounds(flags dbus.Flags, backgrounds []string) error { return (<-v.GoSetDesktopBackgrounds(flags, make(chan *dbus.Call, 1), backgrounds).Done).Err } // method SetFullName func (v *user) GoSetFullName(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetFullName", flags, ch, name) } func (v *user) SetFullName(flags dbus.Flags, name string) error { return (<-v.GoSetFullName(flags, make(chan *dbus.Call, 1), name).Done).Err } // method SetGreeterBackground func (v *user) GoSetGreeterBackground(flags dbus.Flags, ch chan *dbus.Call, background string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetGreeterBackground", flags, ch, background) } func (v *user) SetGreeterBackground(flags dbus.Flags, background string) error { return (<-v.GoSetGreeterBackground(flags, make(chan *dbus.Call, 1), background).Done).Err } // method SetCurrentWorkspace func (v *user) GoSetCurrentWorkspace(flags dbus.Flags, ch chan *dbus.Call, currentWorkspace int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetCurrentWorkspace", flags, ch, currentWorkspace) } func (v *user) SetCurrentWorkspace(flags dbus.Flags, currentWorkspace int32) error { return (<-v.GoSetCurrentWorkspace(flags, make(chan *dbus.Call, 1), currentWorkspace).Done).Err } // method SetHistoryLayout func (v *user) GoSetHistoryLayout(flags dbus.Flags, ch chan *dbus.Call, layouts []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetHistoryLayout", flags, ch, layouts) } func (v *user) SetHistoryLayout(flags dbus.Flags, layouts []string) error { return (<-v.GoSetHistoryLayout(flags, make(chan *dbus.Call, 1), layouts).Done).Err } // method SetHomeDir func (v *user) GoSetHomeDir(flags dbus.Flags, ch chan *dbus.Call, home string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetHomeDir", flags, ch, home) } func (v *user) SetHomeDir(flags dbus.Flags, home string) error { return (<-v.GoSetHomeDir(flags, make(chan *dbus.Call, 1), home).Done).Err } // method SetIconFile func (v *user) GoSetIconFile(flags dbus.Flags, ch chan *dbus.Call, iconFile string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetIconFile", flags, ch, iconFile) } func (v *user) SetIconFile(flags dbus.Flags, iconFile string) error { return (<-v.GoSetIconFile(flags, make(chan *dbus.Call, 1), iconFile).Done).Err } // method SetLayout func (v *user) GoSetLayout(flags dbus.Flags, ch chan *dbus.Call, layout string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLayout", flags, ch, layout) } func (v *user) SetLayout(flags dbus.Flags, layout string) error { return (<-v.GoSetLayout(flags, make(chan *dbus.Call, 1), layout).Done).Err } // method SetLocale func (v *user) GoSetLocale(flags dbus.Flags, ch chan *dbus.Call, locale string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLocale", flags, ch, locale) } func (v *user) SetLocale(flags dbus.Flags, locale string) error { return (<-v.GoSetLocale(flags, make(chan *dbus.Call, 1), locale).Done).Err } // method SetLocked func (v *user) GoSetLocked(flags dbus.Flags, ch chan *dbus.Call, locked bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLocked", flags, ch, locked) } func (v *user) SetLocked(flags dbus.Flags, locked bool) error { return (<-v.GoSetLocked(flags, make(chan *dbus.Call, 1), locked).Done).Err } // method SetPassword func (v *user) GoSetPassword(flags dbus.Flags, ch chan *dbus.Call, password string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetPassword", flags, ch, password) } func (v *user) SetPassword(flags dbus.Flags, password string) error { return (<-v.GoSetPassword(flags, make(chan *dbus.Call, 1), password).Done).Err } // method SetShell func (v *user) GoSetShell(flags dbus.Flags, ch chan *dbus.Call, shell string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetShell", flags, ch, shell) } func (v *user) SetShell(flags dbus.Flags, shell string) error { return (<-v.GoSetShell(flags, make(chan *dbus.Call, 1), shell).Done).Err } // method SetUse24HourFormat func (v *user) GoSetUse24HourFormat(flags dbus.Flags, ch chan *dbus.Call, value bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetUse24HourFormat", flags, ch, value) } func (v *user) SetUse24HourFormat(flags dbus.Flags, value bool) error { return (<-v.GoSetUse24HourFormat(flags, make(chan *dbus.Call, 1), value).Done).Err } // method SetWeekdayFormat func (v *user) GoSetWeekdayFormat(flags dbus.Flags, ch chan *dbus.Call, value int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetWeekdayFormat", flags, ch, value) } func (v *user) SetWeekdayFormat(flags dbus.Flags, value int32) error { return (<-v.GoSetWeekdayFormat(flags, make(chan *dbus.Call, 1), value).Done).Err } // method SetShortDateFormat func (v *user) GoSetShortDateFormat(flags dbus.Flags, ch chan *dbus.Call, value int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetShortDateFormat", flags, ch, value) } func (v *user) SetShortDateFormat(flags dbus.Flags, value int32) error { return (<-v.GoSetShortDateFormat(flags, make(chan *dbus.Call, 1), value).Done).Err } // method SetLongDateFormat func (v *user) GoSetLongDateFormat(flags dbus.Flags, ch chan *dbus.Call, value int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLongDateFormat", flags, ch, value) } func (v *user) SetLongDateFormat(flags dbus.Flags, value int32) error { return (<-v.GoSetLongDateFormat(flags, make(chan *dbus.Call, 1), value).Done).Err } // method SetShortTimeFormat func (v *user) GoSetShortTimeFormat(flags dbus.Flags, ch chan *dbus.Call, value int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetShortTimeFormat", flags, ch, value) } func (v *user) SetShortTimeFormat(flags dbus.Flags, value int32) error { return (<-v.GoSetShortTimeFormat(flags, make(chan *dbus.Call, 1), value).Done).Err } // method SetLongTimeFormat func (v *user) GoSetLongTimeFormat(flags dbus.Flags, ch chan *dbus.Call, value int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLongTimeFormat", flags, ch, value) } func (v *user) SetLongTimeFormat(flags dbus.Flags, value int32) error { return (<-v.GoSetLongTimeFormat(flags, make(chan *dbus.Call, 1), value).Done).Err } // method SetWeekBegins func (v *user) GoSetWeekBegins(flags dbus.Flags, ch chan *dbus.Call, value int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetWeekBegins", flags, ch, value) } func (v *user) SetWeekBegins(flags dbus.Flags, value int32) error { return (<-v.GoSetWeekBegins(flags, make(chan *dbus.Call, 1), value).Done).Err } // property HistoryLayout as func (v *user) HistoryLayout() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "HistoryLayout", } } // property Gid s func (v *user) Gid() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Gid", } } // property Groups as func (v *user) Groups() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Groups", } } // property XSession s func (v *user) XSession() proxy.PropString { return proxy.PropString{ Impl: v, Name: "XSession", } } // property PasswordStatus s func (v *user) PasswordStatus() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PasswordStatus", } } // property LoginTime t func (v *user) LoginTime() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LoginTime", } } // property GreeterBackground s func (v *user) GreeterBackground() proxy.PropString { return proxy.PropString{ Impl: v, Name: "GreeterBackground", } } // property CreatedTime t func (v *user) CreatedTime() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "CreatedTime", } } // property UserName s func (v *user) UserName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "UserName", } } // property Shell s func (v *user) Shell() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Shell", } } // property Layout s func (v *user) Layout() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Layout", } } // property IconFile s func (v *user) IconFile() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IconFile", } } // property Use24HourFormat b func (v *user) Use24HourFormat() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Use24HourFormat", } } // property AccountType i func (v *user) AccountType() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "AccountType", } } // property HomeDir s func (v *user) HomeDir() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HomeDir", } } // property Locale s func (v *user) Locale() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Locale", } } // property DesktopBackgrounds as func (v *user) DesktopBackgrounds() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "DesktopBackgrounds", } } // property Locked b func (v *user) Locked() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Locked", } } // property NoPasswdLogin b func (v *user) NoPasswdLogin() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "NoPasswdLogin", } } // property IconList as func (v *user) IconList() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "IconList", } } // property UUID s func (v *user) UUID() proxy.PropString { return proxy.PropString{ Impl: v, Name: "UUID", } } // property FullName s func (v *user) FullName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FullName", } } // property Uid s func (v *user) Uid() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Uid", } } // property AutomaticLogin b func (v *user) AutomaticLogin() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "AutomaticLogin", } } // property SystemAccount b func (v *user) SystemAccount() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SystemAccount", } } // property WeekdayFormat i func (v *user) WeekdayFormat() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "WeekdayFormat", } } // property ShortDateFormat i func (v *user) ShortDateFormat() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "ShortDateFormat", } } // property LongDateFormat i func (v *user) LongDateFormat() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "LongDateFormat", } } // property ShortTimeFormat i func (v *user) ShortTimeFormat() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "ShortTimeFormat", } } // property LongTimeFormat i func (v *user) LongTimeFormat() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "LongTimeFormat", } } // property WeekBegins i func (v *user) WeekBegins() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "WeekBegins", } } type ImageBlur struct { imageBlur // interface com.deepin.daemon.ImageBlur proxy.Object } func NewImageBlur(conn *dbus.Conn) *ImageBlur { obj := new(ImageBlur) obj.Object.Init_(conn, "com.deepin.daemon.Accounts", "/com/deepin/daemon/ImageBlur") return obj } type imageBlur struct{} func (v *imageBlur) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*imageBlur) GetInterfaceName_() string { return "com.deepin.daemon.ImageBlur" } // method Delete func (v *imageBlur) GoDelete(flags dbus.Flags, ch chan *dbus.Call, file string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Delete", flags, ch, file) } func (v *imageBlur) Delete(flags dbus.Flags, file string) error { return (<-v.GoDelete(flags, make(chan *dbus.Call, 1), file).Done).Err } // method Get func (v *imageBlur) GoGet(flags dbus.Flags, ch chan *dbus.Call, source string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Get", flags, ch, source) } func (*imageBlur) StoreGet(call *dbus.Call) (blurred string, err error) { err = call.Store(&blurred) return } func (v *imageBlur) Get(flags dbus.Flags, source string) (blurred string, err error) { return v.StoreGet( <-v.GoGet(flags, make(chan *dbus.Call, 1), source).Done) } // signal BlurDone func (v *imageBlur) ConnectBlurDone(cb func(imgFile string, imgBlurFile string, ok bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "BlurDone", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".BlurDone", } handlerFunc := func(sig *dbus.Signal) { var imgFile string var imgBlurFile string var ok bool err := dbus.Store(sig.Body, &imgFile, &imgBlurFile, &ok) if err == nil { cb(imgFile, imgBlurFile, ok) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.deepin.daemon.accounts/config.json000066400000000000000000000012161403054572700240040ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.Accounts", "Objects": [ { "Type": "Accounts", "Path": "/com/deepin/daemon/Accounts", "Interfaces": [ { "Name": "com.deepin.daemon.Accounts", "Type": "accounts" } ] }, { "Type": "User", "Interfaces": [ { "Name": "com.deepin.daemon.Accounts.User", "Type": "user" } ] }, { "Type": "ImageBlur", "Path": "/com/deepin/daemon/ImageBlur", "Interfaces": [ { "Name": "com.deepin.daemon.ImageBlur", "Type": "imageBlur" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.airplanemode/000077500000000000000000000000001403054572700224655ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.airplanemode/AirplaneMode.xml000066400000000000000000000043411403054572700255510ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.airplanemode/auto.go000066400000000000000000000047671403054572700240020ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.airplanemode"; DO NOT EDIT. package airplanemode import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type AirplaneMode struct { airplaneMode // interface com.deepin.daemon.AirplaneMode proxy.Object } func NewAirplaneMode(conn *dbus.Conn) *AirplaneMode { obj := new(AirplaneMode) obj.Object.Init_(conn, "com.deepin.daemon.AirplaneMode", "/com/deepin/daemon/AirplaneMode") return obj } type airplaneMode struct{} func (v *airplaneMode) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*airplaneMode) GetInterfaceName_() string { return "com.deepin.daemon.AirplaneMode" } // method DumpState func (v *airplaneMode) GoDumpState(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DumpState", flags, ch) } func (v *airplaneMode) DumpState(flags dbus.Flags) error { return (<-v.GoDumpState(flags, make(chan *dbus.Call, 1)).Done).Err } // method Enable func (v *airplaneMode) GoEnable(flags dbus.Flags, ch chan *dbus.Call, enabled bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Enable", flags, ch, enabled) } func (v *airplaneMode) Enable(flags dbus.Flags, enabled bool) error { return (<-v.GoEnable(flags, make(chan *dbus.Call, 1), enabled).Done).Err } // method EnableBluetooth func (v *airplaneMode) GoEnableBluetooth(flags dbus.Flags, ch chan *dbus.Call, enabled bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnableBluetooth", flags, ch, enabled) } func (v *airplaneMode) EnableBluetooth(flags dbus.Flags, enabled bool) error { return (<-v.GoEnableBluetooth(flags, make(chan *dbus.Call, 1), enabled).Done).Err } // method EnableWifi func (v *airplaneMode) GoEnableWifi(flags dbus.Flags, ch chan *dbus.Call, enabled bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnableWifi", flags, ch, enabled) } func (v *airplaneMode) EnableWifi(flags dbus.Flags, enabled bool) error { return (<-v.GoEnableWifi(flags, make(chan *dbus.Call, 1), enabled).Done).Err } // property Enabled b func (v *airplaneMode) Enabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Enabled", } } // property WifiEnabled b func (v *airplaneMode) WifiEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "WifiEnabled", } } // property BluetoothEnabled b func (v *airplaneMode) BluetoothEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "BluetoothEnabled", } } go-dbus-factory-1.9.6/com.deepin.daemon.airplanemode/config.json000066400000000000000000000005161403054572700246270ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.AirplaneMode", "Objects": [ { "Type": "AirplaneMode", "Path": "/com/deepin/daemon/AirplaneMode", "Interfaces": [ { "Name": "com.deepin.daemon.AirplaneMode", "Type": "airplaneMode", "Accessor": "AirplaneMode" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.apps/000077500000000000000000000000001403054572700207705ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.apps/Apps.xml000066400000000000000000000052171403054572700224220ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.apps/auto.go000066400000000000000000000127251403054572700222760ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.apps"; DO NOT EDIT. package apps import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Apps struct { desktopFileWatcher // interface com.deepin.daemon.Apps.DesktopFileWatcher launchedRecorder // interface com.deepin.daemon.Apps.LaunchedRecorder proxy.Object } func NewApps(conn *dbus.Conn) *Apps { obj := new(Apps) obj.Object.Init_(conn, "com.deepin.daemon.Apps", "/com/deepin/daemon/Apps") return obj } func (obj *Apps) DesktopFileWatcher() *desktopFileWatcher { return &obj.desktopFileWatcher } type desktopFileWatcher struct{} func (v *desktopFileWatcher) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*desktopFileWatcher) GetInterfaceName_() string { return "com.deepin.daemon.Apps.DesktopFileWatcher" } // signal Event func (v *desktopFileWatcher) ConnectEvent(cb func(name string, op uint32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Event", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Event", } handlerFunc := func(sig *dbus.Signal) { var name string var op uint32 err := dbus.Store(sig.Body, &name, &op) if err == nil { cb(name, op) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } func (obj *Apps) LaunchedRecorder() *launchedRecorder { return &obj.launchedRecorder } type launchedRecorder struct{} func (v *launchedRecorder) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*launchedRecorder) GetInterfaceName_() string { return "com.deepin.daemon.Apps.LaunchedRecorder" } // method GetNew func (v *launchedRecorder) GoGetNew(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetNew", flags, ch) } func (*launchedRecorder) StoreGetNew(call *dbus.Call) (newApps map[string][]string, err error) { err = call.Store(&newApps) return } func (v *launchedRecorder) GetNew(flags dbus.Flags) (newApps map[string][]string, err error) { return v.StoreGetNew( <-v.GoGetNew(flags, make(chan *dbus.Call, 1)).Done) } // method MarkLaunched func (v *launchedRecorder) GoMarkLaunched(flags dbus.Flags, ch chan *dbus.Call, desktopFile string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".MarkLaunched", flags, ch, desktopFile) } func (v *launchedRecorder) MarkLaunched(flags dbus.Flags, desktopFile string) error { return (<-v.GoMarkLaunched(flags, make(chan *dbus.Call, 1), desktopFile).Done).Err } // method UninstallHints func (v *launchedRecorder) GoUninstallHints(flags dbus.Flags, ch chan *dbus.Call, desktopFiles []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UninstallHints", flags, ch, desktopFiles) } func (v *launchedRecorder) UninstallHints(flags dbus.Flags, desktopFiles []string) error { return (<-v.GoUninstallHints(flags, make(chan *dbus.Call, 1), desktopFiles).Done).Err } // method WatchDirs func (v *launchedRecorder) GoWatchDirs(flags dbus.Flags, ch chan *dbus.Call, dirs []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".WatchDirs", flags, ch, dirs) } func (v *launchedRecorder) WatchDirs(flags dbus.Flags, dirs []string) error { return (<-v.GoWatchDirs(flags, make(chan *dbus.Call, 1), dirs).Done).Err } // signal Launched func (v *launchedRecorder) ConnectLaunched(cb func(file string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Launched", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Launched", } handlerFunc := func(sig *dbus.Signal) { var file string err := dbus.Store(sig.Body, &file) if err == nil { cb(file) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal StatusSaved func (v *launchedRecorder) ConnectStatusSaved(cb func(root string, file string, ok bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "StatusSaved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".StatusSaved", } handlerFunc := func(sig *dbus.Signal) { var root string var file string var ok bool err := dbus.Store(sig.Body, &root, &file, &ok) if err == nil { cb(root, file, ok) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ServiceRestarted func (v *launchedRecorder) ConnectServiceRestarted(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ServiceRestarted", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ServiceRestarted", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.deepin.daemon.apps/config.json000066400000000000000000000007561403054572700231400ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.Apps", "Objects": [ { "Type": "Apps", "Path": "/com/deepin/daemon/Apps", "Interfaces": [ { "Name": "com.deepin.daemon.Apps.DesktopFileWatcher", "Type": "desktopFileWatcher", "Accessor": "DesktopFileWatcher" }, { "Name": "com.deepin.daemon.Apps.LaunchedRecorder", "Type": "launchedRecorder", "Accessor": "LaunchedRecorder" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.audio/000077500000000000000000000000001403054572700211265ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.audio/Audio.xml000066400000000000000000000060721403054572700227160ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.audio/Sink.xml000066400000000000000000000063311403054572700225570ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.audio/SinkInput.xml000066400000000000000000000053361403054572700236030ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.audio/Source.xml000066400000000000000000000063331403054572700231150ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.audio/auto.go000066400000000000000000000415031403054572700224300ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.audio"; DO NOT EDIT. package audio import ( "errors" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type Audio struct { audio // interface com.deepin.daemon.Audio proxy.Object } func NewAudio(conn *dbus.Conn) *Audio { obj := new(Audio) obj.Object.Init_(conn, "com.deepin.daemon.Audio", "/com/deepin/daemon/Audio") return obj } type audio struct{} func (v *audio) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*audio) GetInterfaceName_() string { return "com.deepin.daemon.Audio" } // method SetDefaultSink func (v *audio) GoSetDefaultSink(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDefaultSink", flags, ch, name) } func (v *audio) SetDefaultSink(flags dbus.Flags, name string) error { return (<-v.GoSetDefaultSink(flags, make(chan *dbus.Call, 1), name).Done).Err } // method SetDefaultSource func (v *audio) GoSetDefaultSource(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDefaultSource", flags, ch, name) } func (v *audio) SetDefaultSource(flags dbus.Flags, name string) error { return (<-v.GoSetDefaultSource(flags, make(chan *dbus.Call, 1), name).Done).Err } // method SetPort func (v *audio) GoSetPort(flags dbus.Flags, ch chan *dbus.Call, cardId uint32, portName string, direction int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetPort", flags, ch, cardId, portName, direction) } func (v *audio) SetPort(flags dbus.Flags, cardId uint32, portName string, direction int32) error { return (<-v.GoSetPort(flags, make(chan *dbus.Call, 1), cardId, portName, direction).Done).Err } // method SetPortEnabled func (v *audio) GoSetPortEnabled(flags dbus.Flags, ch chan *dbus.Call, cardId uint32, portName string, enabled bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetPortEnabled", flags, ch, cardId, portName, enabled) } func (v *audio) SetPortEnabled(flags dbus.Flags, cardId uint32, portName string, enabled bool) error { return (<-v.GoSetPortEnabled(flags, make(chan *dbus.Call, 1), cardId, portName, enabled).Done).Err } // method IsPortEnabled func (v *audio) GoIsPortEnabled(flags dbus.Flags, ch chan *dbus.Call, cardId uint32, portName string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsPortEnabled", flags, ch, cardId, portName) } func (*audio) StoreIsPortEnabled(call *dbus.Call) (enabled bool, err error) { err = call.Store(&enabled) return } func (v *audio) IsPortEnabled(flags dbus.Flags, cardId uint32, portName string) (enabled bool, err error) { return v.StoreIsPortEnabled( <-v.GoIsPortEnabled(flags, make(chan *dbus.Call, 1), cardId, portName).Done) } // property MaxUIVolume d func (v *audio) MaxUIVolume() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "MaxUIVolume", } } // property SinkInputs ao func (v *audio) SinkInputs() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "SinkInputs", } } // property DefaultSink o func (v *audio) DefaultSink() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "DefaultSink", } } // property DefaultSource o func (v *audio) DefaultSource() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "DefaultSource", } } // property Cards s func (v *audio) Cards() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Cards", } } // property CardsWithoutUnavailable s func (v *audio) CardsWithoutUnavailable() proxy.PropString { return proxy.PropString{ Impl: v, Name: "CardsWithoutUnavailable", } } type Sink struct { sink // interface com.deepin.daemon.Audio.Sink proxy.Object } func NewSink(conn *dbus.Conn, path dbus.ObjectPath) (*Sink, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Sink) obj.Object.Init_(conn, "com.deepin.daemon.Audio", path) return obj, nil } type sink struct{} func (v *sink) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*sink) GetInterfaceName_() string { return "com.deepin.daemon.Audio.Sink" } // method GetMeter func (v *sink) GoGetMeter(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetMeter", flags, ch) } func (*sink) StoreGetMeter(call *dbus.Call) (meter dbus.ObjectPath, err error) { err = call.Store(&meter) return } func (v *sink) GetMeter(flags dbus.Flags) (meter dbus.ObjectPath, err error) { return v.StoreGetMeter( <-v.GoGetMeter(flags, make(chan *dbus.Call, 1)).Done) } // method SetBalance func (v *sink) GoSetBalance(flags dbus.Flags, ch chan *dbus.Call, value float64, isPlay bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetBalance", flags, ch, value, isPlay) } func (v *sink) SetBalance(flags dbus.Flags, value float64, isPlay bool) error { return (<-v.GoSetBalance(flags, make(chan *dbus.Call, 1), value, isPlay).Done).Err } // method SetFade func (v *sink) GoSetFade(flags dbus.Flags, ch chan *dbus.Call, value float64) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetFade", flags, ch, value) } func (v *sink) SetFade(flags dbus.Flags, value float64) error { return (<-v.GoSetFade(flags, make(chan *dbus.Call, 1), value).Done).Err } // method SetMute func (v *sink) GoSetMute(flags dbus.Flags, ch chan *dbus.Call, value bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetMute", flags, ch, value) } func (v *sink) SetMute(flags dbus.Flags, value bool) error { return (<-v.GoSetMute(flags, make(chan *dbus.Call, 1), value).Done).Err } // method SetPort func (v *sink) GoSetPort(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetPort", flags, ch, name) } func (v *sink) SetPort(flags dbus.Flags, name string) error { return (<-v.GoSetPort(flags, make(chan *dbus.Call, 1), name).Done).Err } // method SetVolume func (v *sink) GoSetVolume(flags dbus.Flags, ch chan *dbus.Call, value float64, isPlay bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetVolume", flags, ch, value, isPlay) } func (v *sink) SetVolume(flags dbus.Flags, value float64, isPlay bool) error { return (<-v.GoSetVolume(flags, make(chan *dbus.Call, 1), value, isPlay).Done).Err } // property SupportBalance b func (v *sink) SupportBalance() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SupportBalance", } } // property Ports a(ssy) func (v *sink) Ports() PropPortInfoSlice { return PropPortInfoSlice{ Impl: v, Name: "Ports", } } // property Name s func (v *sink) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property Mute b func (v *sink) Mute() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Mute", } } // property Volume d func (v *sink) Volume() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Volume", } } // property Balance d func (v *sink) Balance() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Balance", } } // property ActivePort (ssy) func (v *sink) ActivePort() PropPortInfo { return PropPortInfo{ Impl: v, Name: "ActivePort", } } // property Card u func (v *sink) Card() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Card", } } // property Description s func (v *sink) Description() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Description", } } // property BaseVolume d func (v *sink) BaseVolume() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "BaseVolume", } } // property Fade d func (v *sink) Fade() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Fade", } } // property SupportFade b func (v *sink) SupportFade() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SupportFade", } } type Source struct { source // interface com.deepin.daemon.Audio.Source proxy.Object } func NewSource(conn *dbus.Conn, path dbus.ObjectPath) (*Source, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Source) obj.Object.Init_(conn, "com.deepin.daemon.Audio", path) return obj, nil } type source struct{} func (v *source) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*source) GetInterfaceName_() string { return "com.deepin.daemon.Audio.Source" } // method GetMeter func (v *source) GoGetMeter(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetMeter", flags, ch) } func (*source) StoreGetMeter(call *dbus.Call) (meter dbus.ObjectPath, err error) { err = call.Store(&meter) return } func (v *source) GetMeter(flags dbus.Flags) (meter dbus.ObjectPath, err error) { return v.StoreGetMeter( <-v.GoGetMeter(flags, make(chan *dbus.Call, 1)).Done) } // method SetBalance func (v *source) GoSetBalance(flags dbus.Flags, ch chan *dbus.Call, value float64, isPlay bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetBalance", flags, ch, value, isPlay) } func (v *source) SetBalance(flags dbus.Flags, value float64, isPlay bool) error { return (<-v.GoSetBalance(flags, make(chan *dbus.Call, 1), value, isPlay).Done).Err } // method SetFade func (v *source) GoSetFade(flags dbus.Flags, ch chan *dbus.Call, value float64) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetFade", flags, ch, value) } func (v *source) SetFade(flags dbus.Flags, value float64) error { return (<-v.GoSetFade(flags, make(chan *dbus.Call, 1), value).Done).Err } // method SetMute func (v *source) GoSetMute(flags dbus.Flags, ch chan *dbus.Call, value bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetMute", flags, ch, value) } func (v *source) SetMute(flags dbus.Flags, value bool) error { return (<-v.GoSetMute(flags, make(chan *dbus.Call, 1), value).Done).Err } // method SetPort func (v *source) GoSetPort(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetPort", flags, ch, name) } func (v *source) SetPort(flags dbus.Flags, name string) error { return (<-v.GoSetPort(flags, make(chan *dbus.Call, 1), name).Done).Err } // method SetVolume func (v *source) GoSetVolume(flags dbus.Flags, ch chan *dbus.Call, value float64, isPlay bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetVolume", flags, ch, value, isPlay) } func (v *source) SetVolume(flags dbus.Flags, value float64, isPlay bool) error { return (<-v.GoSetVolume(flags, make(chan *dbus.Call, 1), value, isPlay).Done).Err } // property Mute b func (v *source) Mute() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Mute", } } // property Balance d func (v *source) Balance() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Balance", } } // property SupportBalance b func (v *source) SupportBalance() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SupportBalance", } } // property Fade d func (v *source) Fade() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Fade", } } // property Ports a(ssy) func (v *source) Ports() PropPortInfoSlice { return PropPortInfoSlice{ Impl: v, Name: "Ports", } } // property Card u func (v *source) Card() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Card", } } // property BaseVolume d func (v *source) BaseVolume() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "BaseVolume", } } // property Description s func (v *source) Description() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Description", } } // property Volume d func (v *source) Volume() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Volume", } } // property SupportFade b func (v *source) SupportFade() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SupportFade", } } // property ActivePort (ssy) func (v *source) ActivePort() PropPortInfo { return PropPortInfo{ Impl: v, Name: "ActivePort", } } // property Name s func (v *source) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } type SinkInput struct { sinkInput // interface com.deepin.daemon.Audio.SinkInput proxy.Object } func NewSinkInput(conn *dbus.Conn, path dbus.ObjectPath) (*SinkInput, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(SinkInput) obj.Object.Init_(conn, "com.deepin.daemon.Audio", path) return obj, nil } type sinkInput struct{} func (v *sinkInput) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*sinkInput) GetInterfaceName_() string { return "com.deepin.daemon.Audio.SinkInput" } // method SetBalance func (v *sinkInput) GoSetBalance(flags dbus.Flags, ch chan *dbus.Call, value float64, isPlay bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetBalance", flags, ch, value, isPlay) } func (v *sinkInput) SetBalance(flags dbus.Flags, value float64, isPlay bool) error { return (<-v.GoSetBalance(flags, make(chan *dbus.Call, 1), value, isPlay).Done).Err } // method SetFade func (v *sinkInput) GoSetFade(flags dbus.Flags, ch chan *dbus.Call, value float64) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetFade", flags, ch, value) } func (v *sinkInput) SetFade(flags dbus.Flags, value float64) error { return (<-v.GoSetFade(flags, make(chan *dbus.Call, 1), value).Done).Err } // method SetMute func (v *sinkInput) GoSetMute(flags dbus.Flags, ch chan *dbus.Call, value bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetMute", flags, ch, value) } func (v *sinkInput) SetMute(flags dbus.Flags, value bool) error { return (<-v.GoSetMute(flags, make(chan *dbus.Call, 1), value).Done).Err } // method SetVolume func (v *sinkInput) GoSetVolume(flags dbus.Flags, ch chan *dbus.Call, value float64, isPlay bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetVolume", flags, ch, value, isPlay) } func (v *sinkInput) SetVolume(flags dbus.Flags, value float64, isPlay bool) error { return (<-v.GoSetVolume(flags, make(chan *dbus.Call, 1), value, isPlay).Done).Err } // property Volume d func (v *sinkInput) Volume() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Volume", } } // property Balance d func (v *sinkInput) Balance() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Balance", } } // property SupportBalance b func (v *sinkInput) SupportBalance() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SupportBalance", } } // property Fade d func (v *sinkInput) Fade() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Fade", } } // property SupportFade b func (v *sinkInput) SupportFade() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SupportFade", } } // property Name s func (v *sinkInput) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property Icon s func (v *sinkInput) Icon() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Icon", } } // property Mute b func (v *sinkInput) Mute() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Mute", } } type PropPortInfoSlice struct { Impl proxy.Implementer Name string } func (p PropPortInfoSlice) Get(flags dbus.Flags) (value []PortInfo, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropPortInfoSlice) Set(flags dbus.Flags, value []PortInfo) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropPortInfoSlice) ConnectChanged(cb func(hasValue bool, value []PortInfo)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []PortInfo err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } type PropPortInfo struct { Impl proxy.Implementer Name string } func (p PropPortInfo) Get(flags dbus.Flags) (value PortInfo, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropPortInfo) Set(flags dbus.Flags, value PortInfo) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropPortInfo) ConnectChanged(cb func(hasValue bool, value PortInfo)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v PortInfo err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, PortInfo{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } go-dbus-factory-1.9.6/com.deepin.daemon.audio/config.json000066400000000000000000000025331403054572700232710ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.Audio", "Objects": [ { "Type": "Audio", "Path": "/com/deepin/daemon/Audio", "Interfaces": [ { "Name": "com.deepin.daemon.Audio", "Type": "audio" } ] }, { "Type":"Sink", "Interfaces": [ { "Name": "com.deepin.daemon.Audio.Sink", "Type": "sink", "Fixes": { "p/Ports": { "RefType": "PropPortInfoSlice" }, "p/ActivePort": { "RefType": "PropPortInfo" } } } ] }, { "Type":"Source", "Interfaces": [ { "Name": "com.deepin.daemon.Audio.Source", "Type": "source", "Fixes": { "p/Ports": { "RefType": "PropPortInfoSlice" }, "p/ActivePort": { "RefType": "PropPortInfo" } } } ] }, { "Type":"SinkInput", "Interfaces": [ { "Name": "com.deepin.daemon.Audio.SinkInput", "Type": "sinkInput" } ] } ], "PropertyTypes": [ { "Type": "PropPortInfoSlice", "ValueType": "[]PortInfo" }, { "Type": "PropPortInfo", "ValueType": "PortInfo", "EmptyValue": "$T{}" } ] } go-dbus-factory-1.9.6/com.deepin.daemon.audio/manual.go000066400000000000000000000002221403054572700227260ustar00rootroot00000000000000package audio type PortInfo struct { Name string Description string Priority uint32 Available int // 0: Unknown, 1: No, 2: Yes } go-dbus-factory-1.9.6/com.deepin.daemon.authenticate.fingerprint/000077500000000000000000000000001403054572700250315ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.authenticate.fingerprint/CommonDevice.xml000066400000000000000000000072461403054572700301340ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.authenticate.fingerprint/Device.xml000066400000000000000000000071401403054572700267540ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.authenticate.fingerprint/auto.go000066400000000000000000000326071403054572700263400ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.authenticate.fingerprint"; DO NOT EDIT. package fingerprint import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Device struct { device // interface com.deepin.daemon.Authenticate.Fingerprint.Device proxy.Object } func NewDevice(conn *dbus.Conn, serviceName string, path dbus.ObjectPath) (*Device, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Device) obj.Object.Init_(conn, serviceName, path) return obj, nil } type device struct{} func (v *device) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } // method Claim func (v *device) GoClaim(flags dbus.Flags, ch chan *dbus.Call, userId string, claimed bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Claim", flags, ch, userId, claimed) } func (v *device) Claim(flags dbus.Flags, userId string, claimed bool) error { return (<-v.GoClaim(flags, make(chan *dbus.Call, 1), userId, claimed).Done).Err } // method DeleteAllFingers func (v *device) GoDeleteAllFingers(flags dbus.Flags, ch chan *dbus.Call, userId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteAllFingers", flags, ch, userId) } func (v *device) DeleteAllFingers(flags dbus.Flags, userId string) error { return (<-v.GoDeleteAllFingers(flags, make(chan *dbus.Call, 1), userId).Done).Err } // method DeleteFinger func (v *device) GoDeleteFinger(flags dbus.Flags, ch chan *dbus.Call, userId string, finger string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteFinger", flags, ch, userId, finger) } func (v *device) DeleteFinger(flags dbus.Flags, userId string, finger string) error { return (<-v.GoDeleteFinger(flags, make(chan *dbus.Call, 1), userId, finger).Done).Err } // method Enroll func (v *device) GoEnroll(flags dbus.Flags, ch chan *dbus.Call, finger string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Enroll", flags, ch, finger) } func (v *device) Enroll(flags dbus.Flags, finger string) error { return (<-v.GoEnroll(flags, make(chan *dbus.Call, 1), finger).Done).Err } // method ListFingers func (v *device) GoListFingers(flags dbus.Flags, ch chan *dbus.Call, userId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListFingers", flags, ch, userId) } func (*device) StoreListFingers(call *dbus.Call) (fingers []string, err error) { err = call.Store(&fingers) return } func (v *device) ListFingers(flags dbus.Flags, userId string) (fingers []string, err error) { return v.StoreListFingers( <-v.GoListFingers(flags, make(chan *dbus.Call, 1), userId).Done) } // method RenameFinger func (v *device) GoRenameFinger(flags dbus.Flags, ch chan *dbus.Call, userId string, finger string, newName string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RenameFinger", flags, ch, userId, finger, newName) } func (v *device) RenameFinger(flags dbus.Flags, userId string, finger string, newName string) error { return (<-v.GoRenameFinger(flags, make(chan *dbus.Call, 1), userId, finger, newName).Done).Err } // method StopEnroll func (v *device) GoStopEnroll(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StopEnroll", flags, ch) } func (v *device) StopEnroll(flags dbus.Flags) error { return (<-v.GoStopEnroll(flags, make(chan *dbus.Call, 1)).Done).Err } // method StopVerify func (v *device) GoStopVerify(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StopVerify", flags, ch) } func (v *device) StopVerify(flags dbus.Flags) error { return (<-v.GoStopVerify(flags, make(chan *dbus.Call, 1)).Done).Err } // method Verify func (v *device) GoVerify(flags dbus.Flags, ch chan *dbus.Call, finger string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Verify", flags, ch, finger) } func (v *device) Verify(flags dbus.Flags, finger string) error { return (<-v.GoVerify(flags, make(chan *dbus.Call, 1), finger).Done).Err } // signal EnrollStatus func (v *device) ConnectEnrollStatus(cb func(userId string, code int32, msg string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "EnrollStatus", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".EnrollStatus", } handlerFunc := func(sig *dbus.Signal) { var userId string var code int32 var msg string err := dbus.Store(sig.Body, &userId, &code, &msg) if err == nil { cb(userId, code, msg) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal VerifyStatus func (v *device) ConnectVerifyStatus(cb func(userId string, code int32, msg string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VerifyStatus", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VerifyStatus", } handlerFunc := func(sig *dbus.Signal) { var userId string var code int32 var msg string err := dbus.Store(sig.Body, &userId, &code, &msg) if err == nil { cb(userId, code, msg) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Touch func (v *device) ConnectTouch(cb func(userId string, pressed bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Touch", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Touch", } handlerFunc := func(sig *dbus.Signal) { var userId string var pressed bool err := dbus.Store(sig.Body, &userId, &pressed) if err == nil { cb(userId, pressed) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Name s func (v *device) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property State i func (v *device) State() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "State", } } // property Type i func (v *device) Type() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "Type", } } // property Capability i func (v *device) Capability() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "Capability", } } type CommonDevice struct { commonDevice // interface com.deepin.daemon.Authenticate.Fingerprint.CommonDevice proxy.Object } func NewCommonDevice(conn *dbus.Conn, serviceName string, path dbus.ObjectPath) (*CommonDevice, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(CommonDevice) obj.Object.Init_(conn, serviceName, path) return obj, nil } type commonDevice struct{} func (v *commonDevice) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } // method Claim func (v *commonDevice) GoClaim(flags dbus.Flags, ch chan *dbus.Call, userId string, claimed bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Claim", flags, ch, userId, claimed) } func (v *commonDevice) Claim(flags dbus.Flags, userId string, claimed bool) error { return (<-v.GoClaim(flags, make(chan *dbus.Call, 1), userId, claimed).Done).Err } // method DeleteAllFingers func (v *commonDevice) GoDeleteAllFingers(flags dbus.Flags, ch chan *dbus.Call, userId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteAllFingers", flags, ch, userId) } func (v *commonDevice) DeleteAllFingers(flags dbus.Flags, userId string) error { return (<-v.GoDeleteAllFingers(flags, make(chan *dbus.Call, 1), userId).Done).Err } // method DeleteFinger func (v *commonDevice) GoDeleteFinger(flags dbus.Flags, ch chan *dbus.Call, userId string, finger string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteFinger", flags, ch, userId, finger) } func (v *commonDevice) DeleteFinger(flags dbus.Flags, userId string, finger string) error { return (<-v.GoDeleteFinger(flags, make(chan *dbus.Call, 1), userId, finger).Done).Err } // method Enroll func (v *commonDevice) GoEnroll(flags dbus.Flags, ch chan *dbus.Call, username string, finger string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Enroll", flags, ch, username, finger) } func (v *commonDevice) Enroll(flags dbus.Flags, username string, finger string) error { return (<-v.GoEnroll(flags, make(chan *dbus.Call, 1), username, finger).Done).Err } // method ListFingers func (v *commonDevice) GoListFingers(flags dbus.Flags, ch chan *dbus.Call, userId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListFingers", flags, ch, userId) } func (*commonDevice) StoreListFingers(call *dbus.Call) (fingers []string, err error) { err = call.Store(&fingers) return } func (v *commonDevice) ListFingers(flags dbus.Flags, userId string) (fingers []string, err error) { return v.StoreListFingers( <-v.GoListFingers(flags, make(chan *dbus.Call, 1), userId).Done) } // method RenameFinger func (v *commonDevice) GoRenameFinger(flags dbus.Flags, ch chan *dbus.Call, userId string, finger string, newName string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RenameFinger", flags, ch, userId, finger, newName) } func (v *commonDevice) RenameFinger(flags dbus.Flags, userId string, finger string, newName string) error { return (<-v.GoRenameFinger(flags, make(chan *dbus.Call, 1), userId, finger, newName).Done).Err } // method StopEnroll func (v *commonDevice) GoStopEnroll(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StopEnroll", flags, ch) } func (v *commonDevice) StopEnroll(flags dbus.Flags) error { return (<-v.GoStopEnroll(flags, make(chan *dbus.Call, 1)).Done).Err } // method StopVerify func (v *commonDevice) GoStopVerify(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StopVerify", flags, ch) } func (v *commonDevice) StopVerify(flags dbus.Flags) error { return (<-v.GoStopVerify(flags, make(chan *dbus.Call, 1)).Done).Err } // method Verify func (v *commonDevice) GoVerify(flags dbus.Flags, ch chan *dbus.Call, finger string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Verify", flags, ch, finger) } func (v *commonDevice) Verify(flags dbus.Flags, finger string) error { return (<-v.GoVerify(flags, make(chan *dbus.Call, 1), finger).Done).Err } // signal EnrollStatus func (v *commonDevice) ConnectEnrollStatus(cb func(userId string, code int32, msg string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "EnrollStatus", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".EnrollStatus", } handlerFunc := func(sig *dbus.Signal) { var userId string var code int32 var msg string err := dbus.Store(sig.Body, &userId, &code, &msg) if err == nil { cb(userId, code, msg) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal VerifyStatus func (v *commonDevice) ConnectVerifyStatus(cb func(userId string, code int32, msg string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VerifyStatus", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VerifyStatus", } handlerFunc := func(sig *dbus.Signal) { var userId string var code int32 var msg string err := dbus.Store(sig.Body, &userId, &code, &msg) if err == nil { cb(userId, code, msg) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Touch func (v *commonDevice) ConnectTouch(cb func(userId string, pressed bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Touch", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Touch", } handlerFunc := func(sig *dbus.Signal) { var userId string var pressed bool err := dbus.Store(sig.Body, &userId, &pressed) if err == nil { cb(userId, pressed) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Name s func (v *commonDevice) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property State i func (v *commonDevice) State() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "State", } } // property Type i func (v *commonDevice) Type() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "Type", } } // property Capability i func (v *commonDevice) Capability() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "Capability", } } go-dbus-factory-1.9.6/com.deepin.daemon.authenticate.fingerprint/config.json000066400000000000000000000011411403054572700271660ustar00rootroot00000000000000{ "Service": "", "Objects": [ { "Type": "Device", "Path": "", "Interfaces": [ { "Name": "com.deepin.daemon.Authenticate.Fingerprint.Device", "NoGetInterfaceName": true, "Type": "device", "Accessor": "Device" } ] }, { "Type": "CommonDevice", "Path": "", "Interfaces": [ { "Name": "com.deepin.daemon.Authenticate.Fingerprint.CommonDevice", "NoGetInterfaceName": true, "Type": "commonDevice", "Accessor": "CommonDevice" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.authenticate.fingerprint/manual.go000066400000000000000000000011301403054572700266300ustar00rootroot00000000000000package fingerprint func (v *device) GetInterfaceName_() string { ifcName, _ := v.GetObject_().GetExtra("deviceIfcName") ifcNameStr, ok := ifcName.(string) if ok { return ifcNameStr } return "" } func (v *device) SetInterfaceName(name string) { v.GetObject_().SetExtra("deviceIfcName", name) } func (v *commonDevice) GetInterfaceName_() string { ifcName, _ := v.GetObject_().GetExtra("deviceIfcName") ifcNameStr, ok := ifcName.(string) if ok { return ifcNameStr } return "" } func (v *commonDevice) SetInterfaceName(name string) { v.GetObject_().SetExtra("deviceIfcName", name) } go-dbus-factory-1.9.6/com.deepin.daemon.authenticate.ukey/000077500000000000000000000000001403054572700234575ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.authenticate.ukey/UKey.xml000066400000000000000000000046621403054572700250660ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.authenticate.ukey/auto.go000066400000000000000000000066151403054572700247660ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.authenticate.ukey"; DO NOT EDIT. package ukey import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type UKey struct { ukey // interface com.deepin.daemon.Authenticate.UKey.Device proxy.Object } func NewUKey(conn *dbus.Conn, serviceName string, path dbus.ObjectPath) (*UKey, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(UKey) obj.Object.Init_(conn, serviceName, path) return obj, nil } type ukey struct{} func (v *ukey) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } // method SetPin func (v *ukey) GoSetPin(flags dbus.Flags, ch chan *dbus.Call, username string, id string, pin string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetPin", flags, ch, username, id, pin) } func (v *ukey) SetPin(flags dbus.Flags, username string, id string, pin string) error { return (<-v.GoSetPin(flags, make(chan *dbus.Call, 1), username, id, pin).Done).Err } // method SetSessionPath func (v *ukey) GoSetSessionPath(flags dbus.Flags, ch chan *dbus.Call, username string, id string, path string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetSessionPath", flags, ch, username, id, path) } func (v *ukey) SetSessionPath(flags dbus.Flags, username string, id string, path string) error { return (<-v.GoSetSessionPath(flags, make(chan *dbus.Call, 1), username, id, path).Done).Err } // method StopVerify func (v *ukey) GoStopVerify(flags dbus.Flags, ch chan *dbus.Call, username string, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StopVerify", flags, ch, username, id) } func (v *ukey) StopVerify(flags dbus.Flags, username string, id string) error { return (<-v.GoStopVerify(flags, make(chan *dbus.Call, 1), username, id).Done).Err } // method Verify func (v *ukey) GoVerify(flags dbus.Flags, ch chan *dbus.Call, username string, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Verify", flags, ch, username, id) } func (v *ukey) Verify(flags dbus.Flags, username string, id string) error { return (<-v.GoVerify(flags, make(chan *dbus.Call, 1), username, id).Done).Err } // signal VerifyResult func (v *ukey) ConnectVerifyResult(cb func(id string, msg string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VerifyResult", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VerifyResult", } handlerFunc := func(sig *dbus.Signal) { var id string var msg string err := dbus.Store(sig.Body, &id, &msg) if err == nil { cb(id, msg) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property State i func (v *ukey) State() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "State", } } // property Type i func (v *ukey) Type() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "Type", } } // property Capability i func (v *ukey) Capability() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "Capability", } } // property Name s func (v *ukey) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } go-dbus-factory-1.9.6/com.deepin.daemon.authenticate.ukey/config.json000066400000000000000000000004531403054572700256210ustar00rootroot00000000000000{ "Service": "", "Objects": [ { "Type": "UKey", "Path": "", "Interfaces": [ { "Name": "com.deepin.daemon.Authenticate.UKey.Device", "NoGetInterfaceName": true, "Type": "ukey", "Accessor": "UKey" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.authenticate.ukey/manual.go000066400000000000000000000004451403054572700252660ustar00rootroot00000000000000package ukey func (v *ukey) GetInterfaceName_() string { ifcName, _ := v.GetObject_().GetExtra("deviceIfcName") ifcNameStr, ok := ifcName.(string) if ok { return ifcNameStr } return "" } func (v *ukey) SetInterfaceName(name string) { v.GetObject_().SetExtra("deviceIfcName", name) } go-dbus-factory-1.9.6/com.deepin.daemon.authenticate/000077500000000000000000000000001403054572700225035ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.authenticate/Authenticate.xml000066400000000000000000000052411403054572700256450ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.authenticate/Fingerprint.xml000066400000000000000000000065371403054572700255270ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.authenticate/UKey.xml000066400000000000000000000050331403054572700241030ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.authenticate/auto.go000066400000000000000000000346241403054572700240130ustar00rootroot00000000000000package authenticate import "errors" import "fmt" import "github.com/godbus/dbus" import "pkg.deepin.io/lib/dbusutil" import "pkg.deepin.io/lib/dbusutil/proxy" import "unsafe" /* prevent compile error */ var _ = errors.New var _ dbusutil.SignalHandlerId var _ = fmt.Sprintf var _ unsafe.Pointer type Authenticate struct { authenticate // interface com.deepin.daemon.Authenticate proxy.Object } func NewAuthenticate(conn *dbus.Conn) *Authenticate { obj := new(Authenticate) obj.Object.Init_(conn, "com.deepin.daemon.Authenticate", "/com/deepin/daemon/Authenticate") return obj } type authenticate struct{} func (v *authenticate) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*authenticate) GetInterfaceName_() string { return "com.deepin.daemon.Authenticate" } // method Authenticate func (v *authenticate) GoAuthenticate(flags dbus.Flags, ch chan *dbus.Call, username string, authFlags int32, appType int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Authenticate", flags, ch, username, authFlags, appType) } func (*authenticate) StoreAuthenticate(call *dbus.Call) (path string, err error) { err = call.Store(&path) return } func (v *authenticate) Authenticate(flags dbus.Flags, username string, authFlags int32, appType int32) (path string, err error) { return v.StoreAuthenticate( <-v.GoAuthenticate(flags, make(chan *dbus.Call, 1), username, authFlags, appType).Done) } // method GetLimits func (v *authenticate) GoGetLimits(flags dbus.Flags, ch chan *dbus.Call, username string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetLimits", flags, ch, username) } func (*authenticate) StoreGetLimits(call *dbus.Call) (limits string, err error) { err = call.Store(&limits) return } func (v *authenticate) GetLimits(flags dbus.Flags, username string) (limits string, err error) { return v.StoreGetLimits( <-v.GoGetLimits(flags, make(chan *dbus.Call, 1), username).Done) } // method PreOneKeyLogin func (v *authenticate) GoPreOneKeyLogin(flags dbus.Flags, ch chan *dbus.Call, flag int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PreOneKeyLogin", flags, ch, flag) } func (*authenticate) StorePreOneKeyLogin(call *dbus.Call) (result string, err error) { err = call.Store(&result) return } func (v *authenticate) PreOneKeyLogin(flags dbus.Flags, flag int32) (result string, err error) { return v.StorePreOneKeyLogin( <-v.GoPreOneKeyLogin(flags, make(chan *dbus.Call, 1), flag).Done) } // signal LimitUpdated func (v *authenticate) ConnectLimitUpdated(cb func(username string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "LimitUpdated", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".LimitUpdated", } handlerFunc := func(sig *dbus.Signal) { var username string err := dbus.Store(sig.Body, &username) if err == nil { cb(username) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property SupportEncrypts s func (v *authenticate) SupportEncrypts() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SupportEncrypts", } } // property FrameworkState i func (v *authenticate) FrameworkState() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "FrameworkState", } } // property SupportedFlags i func (v *authenticate) SupportedFlags() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "SupportedFlags", } } type Fingerprint struct { fingerprint // interface com.deepin.daemon.Authenticate.Fingerprint proxy.Object } func NewFingerprint(conn *dbus.Conn) *Fingerprint { obj := new(Fingerprint) obj.Object.Init_(conn, "com.deepin.daemon.Authenticate", "/com/deepin/daemon/Authenticate/Fingerprint") return obj } type fingerprint struct{} func (v *fingerprint) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*fingerprint) GetInterfaceName_() string { return "com.deepin.daemon.Authenticate.Fingerprint" } // method Claim func (v *fingerprint) GoClaim(flags dbus.Flags, ch chan *dbus.Call, username string, claimed bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Claim", flags, ch, username, claimed) } func (v *fingerprint) Claim(flags dbus.Flags, username string, claimed bool) error { return (<-v.GoClaim(flags, make(chan *dbus.Call, 1), username, claimed).Done).Err } // method DeleteAllFingers func (v *fingerprint) GoDeleteAllFingers(flags dbus.Flags, ch chan *dbus.Call, username string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteAllFingers", flags, ch, username) } func (v *fingerprint) DeleteAllFingers(flags dbus.Flags, username string) error { return (<-v.GoDeleteAllFingers(flags, make(chan *dbus.Call, 1), username).Done).Err } // method DeleteFinger func (v *fingerprint) GoDeleteFinger(flags dbus.Flags, ch chan *dbus.Call, username string, finger string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteFinger", flags, ch, username, finger) } func (v *fingerprint) DeleteFinger(flags dbus.Flags, username string, finger string) error { return (<-v.GoDeleteFinger(flags, make(chan *dbus.Call, 1), username, finger).Done).Err } // method Enroll func (v *fingerprint) GoEnroll(flags dbus.Flags, ch chan *dbus.Call, finger string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Enroll", flags, ch, finger) } func (v *fingerprint) Enroll(flags dbus.Flags, finger string) error { return (<-v.GoEnroll(flags, make(chan *dbus.Call, 1), finger).Done).Err } // method ListFingers func (v *fingerprint) GoListFingers(flags dbus.Flags, ch chan *dbus.Call, username string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListFingers", flags, ch, username) } func (*fingerprint) StoreListFingers(call *dbus.Call) (fingers []string, err error) { err = call.Store(&fingers) return } func (v *fingerprint) ListFingers(flags dbus.Flags, username string) (fingers []string, err error) { return v.StoreListFingers( <-v.GoListFingers(flags, make(chan *dbus.Call, 1), username).Done) } // method SetDefaultDevice func (v *fingerprint) GoSetDefaultDevice(flags dbus.Flags, ch chan *dbus.Call, device string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDefaultDevice", flags, ch, device) } func (v *fingerprint) SetDefaultDevice(flags dbus.Flags, device string) error { return (<-v.GoSetDefaultDevice(flags, make(chan *dbus.Call, 1), device).Done).Err } // method StopEnroll func (v *fingerprint) GoStopEnroll(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StopEnroll", flags, ch) } func (v *fingerprint) StopEnroll(flags dbus.Flags) error { return (<-v.GoStopEnroll(flags, make(chan *dbus.Call, 1)).Done).Err } // method StopVerify func (v *fingerprint) GoStopVerify(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StopVerify", flags, ch) } func (v *fingerprint) StopVerify(flags dbus.Flags) error { return (<-v.GoStopVerify(flags, make(chan *dbus.Call, 1)).Done).Err } // method Verify func (v *fingerprint) GoVerify(flags dbus.Flags, ch chan *dbus.Call, finger string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Verify", flags, ch, finger) } func (v *fingerprint) Verify(flags dbus.Flags, finger string) error { return (<-v.GoVerify(flags, make(chan *dbus.Call, 1), finger).Done).Err } // signal EnrollStatus func (v *fingerprint) ConnectEnrollStatus(cb func(id string, code int32, msg string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "EnrollStatus", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".EnrollStatus", } handlerFunc := func(sig *dbus.Signal) { var id string var code int32 var msg string err := dbus.Store(sig.Body, &id, &code, &msg) if err == nil { cb(id, code, msg) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal VerifyStatus func (v *fingerprint) ConnectVerifyStatus(cb func(id string, code int32, msg string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VerifyStatus", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VerifyStatus", } handlerFunc := func(sig *dbus.Signal) { var id string var code int32 var msg string err := dbus.Store(sig.Body, &id, &code, &msg) if err == nil { cb(id, code, msg) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Touch func (v *fingerprint) ConnectTouch(cb func(id string, pressed bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Touch", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Touch", } handlerFunc := func(sig *dbus.Signal) { var id string var pressed bool err := dbus.Store(sig.Body, &id, &pressed) if err == nil { cb(id, pressed) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property DefaultDevice s func (v *fingerprint) DefaultDevice() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DefaultDevice", } } // property Devices s func (v *fingerprint) Devices() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Devices", } } type UKey struct { ukey // interface com.deepin.daemon.Authenticate.UKey proxy.Object } func NewUKey(conn *dbus.Conn) *UKey { obj := new(UKey) obj.Object.Init_(conn, "com.deepin.daemon.Authenticate", "/com/deepin/daemon/Authenticate/UKey") return obj } type ukey struct{} func (v *ukey) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*ukey) GetInterfaceName_() string { return "com.deepin.daemon.Authenticate.UKey" } // method ConstructVerification func (v *ukey) GoConstructVerification(flags dbus.Flags, ch chan *dbus.Call, serviceName string, username string, useDefaultService bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ConstructVerification", flags, ch, serviceName, username, useDefaultService) } func (*ukey) StoreConstructVerification(call *dbus.Call) (id string, err error) { err = call.Store(&id) return } func (v *ukey) ConstructVerification(flags dbus.Flags, serviceName string, username string, useDefaultService bool) (id string, err error) { return v.StoreConstructVerification( <-v.GoConstructVerification(flags, make(chan *dbus.Call, 1), serviceName, username, useDefaultService).Done) } // method SetDefaultDevice func (v *ukey) GoSetDefaultDevice(flags dbus.Flags, ch chan *dbus.Call, device string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDefaultDevice", flags, ch, device) } func (v *ukey) SetDefaultDevice(flags dbus.Flags, device string) error { return (<-v.GoSetDefaultDevice(flags, make(chan *dbus.Call, 1), device).Done).Err } // method SetPin func (v *ukey) GoSetPin(flags dbus.Flags, ch chan *dbus.Call, id string, pin string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetPin", flags, ch, id, pin) } func (v *ukey) SetPin(flags dbus.Flags, id string, pin string) error { return (<-v.GoSetPin(flags, make(chan *dbus.Call, 1), id, pin).Done).Err } // method SetSessionPath func (v *ukey) GoSetSessionPath(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetSessionPath", flags, ch, id) } func (v *ukey) SetSessionPath(flags dbus.Flags, id string) error { return (<-v.GoSetSessionPath(flags, make(chan *dbus.Call, 1), id).Done).Err } // method StartVerify func (v *ukey) GoStartVerify(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StartVerify", flags, ch, id) } func (v *ukey) StartVerify(flags dbus.Flags, id string) error { return (<-v.GoStartVerify(flags, make(chan *dbus.Call, 1), id).Done).Err } // method StopVerify func (v *ukey) GoStopVerify(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StopVerify", flags, ch, id) } func (v *ukey) StopVerify(flags dbus.Flags, id string) error { return (<-v.GoStopVerify(flags, make(chan *dbus.Call, 1), id).Done).Err } // signal VerifyResult func (v *ukey) ConnectVerifyResult(cb func(id string, msg string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VerifyResult", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VerifyResult", } handlerFunc := func(sig *dbus.Signal) { var id string var msg string err := dbus.Store(sig.Body, &id, &msg) if err == nil { cb(id, msg) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal State func (v *ukey) ConnectState(cb func(id string, state int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "State", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".State", } handlerFunc := func(sig *dbus.Signal) { var id string var state int32 err := dbus.Store(sig.Body, &id, &state) if err == nil { cb(id, state) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property ValidDevices s func (v *ukey) ValidDevices() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ValidDevices", } } // property DefaultDevice s func (v *ukey) DefaultDevice() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DefaultDevice", } } go-dbus-factory-1.9.6/com.deepin.daemon.authenticate/config.json000066400000000000000000000015471403054572700246520ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.Authenticate", "Objects": [ { "Type": "Authenticate", "Path": "/com/deepin/daemon/Authenticate", "Interfaces": [ { "Name": "com.deepin.daemon.Authenticate", "Type": "authenticate", "Accessor": "Authenticate" } ] }, { "Type": "Fingerprint", "Path": "/com/deepin/daemon/Authenticate/Fingerprint", "Interfaces": [ { "Name": "com.deepin.daemon.Authenticate.Fingerprint", "Type": "fingerprint", "Accessor": "Fingerprint" } ] }, { "Type": "UKey", "Path": "/com/deepin/daemon/Authenticate/UKey", "Interfaces": [ { "Name": "com.deepin.daemon.Authenticate.UKey", "Type": "ukey", "Accessor": "UKey" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.daemon/000077500000000000000000000000001403054572700212705ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.daemon/Daemon.xml000066400000000000000000000054451403054572700232250ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.daemon/auto.go000066400000000000000000000115101403054572700225650ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.daemon"; DO NOT EDIT. package daemon import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Daemon struct { daemon // interface com.deepin.daemon.Daemon proxy.Object } func NewDaemon(conn *dbus.Conn) *Daemon { obj := new(Daemon) obj.Object.Init_(conn, "com.deepin.daemon.Daemon", "/com/deepin/daemon/Daemon") return obj } type daemon struct{} func (v *daemon) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*daemon) GetInterfaceName_() string { return "com.deepin.daemon.Daemon" } // method BluetoothGetDeviceTechnologies func (v *daemon) GoBluetoothGetDeviceTechnologies(flags dbus.Flags, ch chan *dbus.Call, adapter string, device string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".BluetoothGetDeviceTechnologies", flags, ch, adapter, device) } func (*daemon) StoreBluetoothGetDeviceTechnologies(call *dbus.Call) (technologies []string, err error) { err = call.Store(&technologies) return } func (v *daemon) BluetoothGetDeviceTechnologies(flags dbus.Flags, adapter string, device string) (technologies []string, err error) { return v.StoreBluetoothGetDeviceTechnologies( <-v.GoBluetoothGetDeviceTechnologies(flags, make(chan *dbus.Call, 1), adapter, device).Done) } // method IsPidVirtualMachine func (v *daemon) GoIsPidVirtualMachine(flags dbus.Flags, ch chan *dbus.Call, pid uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsPidVirtualMachine", flags, ch, pid) } func (*daemon) StoreIsPidVirtualMachine(call *dbus.Call) (ret bool, err error) { err = call.Store(&ret) return } func (v *daemon) IsPidVirtualMachine(flags dbus.Flags, pid uint32) (ret bool, err error) { return v.StoreIsPidVirtualMachine( <-v.GoIsPidVirtualMachine(flags, make(chan *dbus.Call, 1), pid).Done) } // method ClearTtys func (v *daemon) GoClearTtys(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ClearTtys", flags, ch) } func (v *daemon) ClearTtys(flags dbus.Flags) error { return (<-v.GoClearTtys(flags, make(chan *dbus.Call, 1)).Done).Err } // method ClearTty func (v *daemon) GoClearTty(flags dbus.Flags, ch chan *dbus.Call, num uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ClearTty", flags, ch, num) } func (v *daemon) ClearTty(flags dbus.Flags, num uint32) error { return (<-v.GoClearTty(flags, make(chan *dbus.Call, 1), num).Done).Err } // method NetworkGetConnections func (v *daemon) GoNetworkGetConnections(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".NetworkGetConnections", flags, ch) } func (*daemon) StoreNetworkGetConnections(call *dbus.Call) (data []uint8, err error) { err = call.Store(&data) return } func (v *daemon) NetworkGetConnections(flags dbus.Flags) (data []uint8, err error) { return v.StoreNetworkGetConnections( <-v.GoNetworkGetConnections(flags, make(chan *dbus.Call, 1)).Done) } // method NetworkSetConnections func (v *daemon) GoNetworkSetConnections(flags dbus.Flags, ch chan *dbus.Call, data []uint8) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".NetworkSetConnections", flags, ch, data) } func (v *daemon) NetworkSetConnections(flags dbus.Flags, data []uint8) error { return (<-v.GoNetworkSetConnections(flags, make(chan *dbus.Call, 1), data).Done).Err } // method ScalePlymouth func (v *daemon) GoScalePlymouth(flags dbus.Flags, ch chan *dbus.Call, scale uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ScalePlymouth", flags, ch, scale) } func (v *daemon) ScalePlymouth(flags dbus.Flags, scale uint32) error { return (<-v.GoScalePlymouth(flags, make(chan *dbus.Call, 1), scale).Done).Err } // method SetLongPressDuration func (v *daemon) GoSetLongPressDuration(flags dbus.Flags, ch chan *dbus.Call, duration uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLongPressDuration", flags, ch, duration) } func (v *daemon) SetLongPressDuration(flags dbus.Flags, duration uint32) error { return (<-v.GoSetLongPressDuration(flags, make(chan *dbus.Call, 1), duration).Done).Err } // signal HandleForSleep func (v *daemon) ConnectHandleForSleep(cb func(start bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "HandleForSleep", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".HandleForSleep", } handlerFunc := func(sig *dbus.Signal) { var start bool err := dbus.Store(sig.Body, &start) if err == nil { cb(start) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.deepin.daemon.daemon/config.json000066400000000000000000000004121403054572700234250ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.Daemon", "Objects": [ { "Type": "Daemon", "Path": "/com/deepin/daemon/Daemon", "Interfaces": [ { "Name": "com.deepin.daemon.Daemon", "Type": "daemon" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.display/000077500000000000000000000000001403054572700214725ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.display/Display.xml000066400000000000000000000102601403054572700236200ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.display/Monitor.xml000066400000000000000000000065451403054572700236550ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.display/auto.go000066400000000000000000000433351403054572700230010ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.display"; DO NOT EDIT. package display import ( "errors" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type Display struct { display // interface com.deepin.daemon.Display proxy.Object } func NewDisplay(conn *dbus.Conn) *Display { obj := new(Display) obj.Object.Init_(conn, "com.deepin.daemon.Display", "/com/deepin/daemon/Display") return obj } type display struct{} func (v *display) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*display) GetInterfaceName_() string { return "com.deepin.daemon.Display" } // method ApplyChanges func (v *display) GoApplyChanges(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ApplyChanges", flags, ch) } func (v *display) ApplyChanges(flags dbus.Flags) error { return (<-v.GoApplyChanges(flags, make(chan *dbus.Call, 1)).Done).Err } // method AssociateTouch func (v *display) GoAssociateTouch(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AssociateTouch", flags, ch, arg0, arg1) } func (v *display) AssociateTouch(flags dbus.Flags, arg0 string, arg1 string) error { return (<-v.GoAssociateTouch(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method ChangeBrightness func (v *display) GoChangeBrightness(flags dbus.Flags, ch chan *dbus.Call, arg0 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ChangeBrightness", flags, ch, arg0) } func (v *display) ChangeBrightness(flags dbus.Flags, arg0 bool) error { return (<-v.GoChangeBrightness(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method DeleteCustomMode func (v *display) GoDeleteCustomMode(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteCustomMode", flags, ch, arg0) } func (v *display) DeleteCustomMode(flags dbus.Flags, arg0 string) error { return (<-v.GoDeleteCustomMode(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method GetBrightness func (v *display) GoGetBrightness(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetBrightness", flags, ch) } func (*display) StoreGetBrightness(call *dbus.Call) (arg0 map[string]float64, err error) { err = call.Store(&arg0) return } func (v *display) GetBrightness(flags dbus.Flags) (arg0 map[string]float64, err error) { return v.StoreGetBrightness( <-v.GoGetBrightness(flags, make(chan *dbus.Call, 1)).Done) } // method ListOutputNames func (v *display) GoListOutputNames(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListOutputNames", flags, ch) } func (*display) StoreListOutputNames(call *dbus.Call) (arg0 []string, err error) { err = call.Store(&arg0) return } func (v *display) ListOutputNames(flags dbus.Flags) (arg0 []string, err error) { return v.StoreListOutputNames( <-v.GoListOutputNames(flags, make(chan *dbus.Call, 1)).Done) } // method ListOutputsCommonModes func (v *display) GoListOutputsCommonModes(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListOutputsCommonModes", flags, ch) } func (*display) StoreListOutputsCommonModes(call *dbus.Call) (arg0 []ModeInfo, err error) { err = call.Store(&arg0) return } func (v *display) ListOutputsCommonModes(flags dbus.Flags) (arg0 []ModeInfo, err error) { return v.StoreListOutputsCommonModes( <-v.GoListOutputsCommonModes(flags, make(chan *dbus.Call, 1)).Done) } // method ModifyConfigName func (v *display) GoModifyConfigName(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ModifyConfigName", flags, ch, arg0, arg1) } func (v *display) ModifyConfigName(flags dbus.Flags, arg0 string, arg1 string) error { return (<-v.GoModifyConfigName(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method RefreshBrightness func (v *display) GoRefreshBrightness(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RefreshBrightness", flags, ch) } func (v *display) RefreshBrightness(flags dbus.Flags) error { return (<-v.GoRefreshBrightness(flags, make(chan *dbus.Call, 1)).Done).Err } // method Reset func (v *display) GoReset(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reset", flags, ch) } func (v *display) Reset(flags dbus.Flags) error { return (<-v.GoReset(flags, make(chan *dbus.Call, 1)).Done).Err } // method ResetChanges func (v *display) GoResetChanges(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ResetChanges", flags, ch) } func (v *display) ResetChanges(flags dbus.Flags) error { return (<-v.GoResetChanges(flags, make(chan *dbus.Call, 1)).Done).Err } // method Save func (v *display) GoSave(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Save", flags, ch) } func (v *display) Save(flags dbus.Flags) error { return (<-v.GoSave(flags, make(chan *dbus.Call, 1)).Done).Err } // method SetAndSaveBrightness func (v *display) GoSetAndSaveBrightness(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 float64) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetAndSaveBrightness", flags, ch, arg0, arg1) } func (v *display) SetAndSaveBrightness(flags dbus.Flags, arg0 string, arg1 float64) error { return (<-v.GoSetAndSaveBrightness(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method SetBrightness func (v *display) GoSetBrightness(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 float64) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetBrightness", flags, ch, arg0, arg1) } func (v *display) SetBrightness(flags dbus.Flags, arg0 string, arg1 float64) error { return (<-v.GoSetBrightness(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method SetPrimary func (v *display) GoSetPrimary(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetPrimary", flags, ch, arg0) } func (v *display) SetPrimary(flags dbus.Flags, arg0 string) error { return (<-v.GoSetPrimary(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method SwitchMode func (v *display) GoSwitchMode(flags dbus.Flags, ch chan *dbus.Call, arg0 uint8, arg1 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SwitchMode", flags, ch, arg0, arg1) } func (v *display) SwitchMode(flags dbus.Flags, arg0 uint8, arg1 string) error { return (<-v.GoSwitchMode(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // property HasChanged b func (v *display) HasChanged() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "HasChanged", } } // property DisplayMode y func (v *display) DisplayMode() proxy.PropByte { return proxy.PropByte{ Impl: v, Name: "DisplayMode", } } // property ScreenWidth q func (v *display) ScreenWidth() proxy.PropUint16 { return proxy.PropUint16{ Impl: v, Name: "ScreenWidth", } } // property ScreenHeight q func (v *display) ScreenHeight() proxy.PropUint16 { return proxy.PropUint16{ Impl: v, Name: "ScreenHeight", } } // property Primary s func (v *display) Primary() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Primary", } } // property CurrentCustomId s func (v *display) CurrentCustomId() proxy.PropString { return proxy.PropString{ Impl: v, Name: "CurrentCustomId", } } // property CustomIdList as func (v *display) CustomIdList() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "CustomIdList", } } // property PrimaryRect (nnqq) func (v *display) PrimaryRect() PropDisplayPrimaryRect { return PropDisplayPrimaryRect{ Impl: v, } } type PropDisplayPrimaryRect struct { Impl proxy.Implementer } func (p PropDisplayPrimaryRect) Get(flags dbus.Flags) (value Rectangle, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "PrimaryRect", &value) return } func (p PropDisplayPrimaryRect) ConnectChanged(cb func(hasValue bool, value Rectangle)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v Rectangle err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, Rectangle{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "PrimaryRect", cb0) } // property Monitors ao func (v *display) Monitors() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Monitors", } } // property Brightness a{sd} func (v *display) Brightness() PropDisplayBrightness { return PropDisplayBrightness{ Impl: v, } } type PropDisplayBrightness struct { Impl proxy.Implementer } func (p PropDisplayBrightness) Get(flags dbus.Flags) (value map[string]float64, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Brightness", &value) return } func (p PropDisplayBrightness) ConnectChanged(cb func(hasValue bool, value map[string]float64)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[string]float64 err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Brightness", cb0) } // property TouchMap a{ss} func (v *display) TouchMap() PropDisplayTouchMap { return PropDisplayTouchMap{ Impl: v, } } type PropDisplayTouchMap struct { Impl proxy.Implementer } func (p PropDisplayTouchMap) Get(flags dbus.Flags) (value map[string]string, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "TouchMap", &value) return } func (p PropDisplayTouchMap) ConnectChanged(cb func(hasValue bool, value map[string]string)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[string]string err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "TouchMap", cb0) } // property MaxBacklightBrightness u func (v *display) MaxBacklightBrightness() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "MaxBacklightBrightness", } } // property ColorTemperatureMode i func (v *display) ColorTemperatureMode() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "ColorTemperatureMode", } } // property ColorTemperatureManual i func (v *display) ColorTemperatureManual() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "ColorTemperatureManual", } } type Monitor struct { monitor // interface com.deepin.daemon.Display.Monitor proxy.Object } func NewMonitor(conn *dbus.Conn, path dbus.ObjectPath) (*Monitor, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Monitor) obj.Object.Init_(conn, "com.deepin.daemon.Display", path) return obj, nil } type monitor struct{} func (v *monitor) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*monitor) GetInterfaceName_() string { return "com.deepin.daemon.Display.Monitor" } // method Enable func (v *monitor) GoEnable(flags dbus.Flags, ch chan *dbus.Call, arg0 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Enable", flags, ch, arg0) } func (v *monitor) Enable(flags dbus.Flags, arg0 bool) error { return (<-v.GoEnable(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method SetMode func (v *monitor) GoSetMode(flags dbus.Flags, ch chan *dbus.Call, arg0 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetMode", flags, ch, arg0) } func (v *monitor) SetMode(flags dbus.Flags, arg0 uint32) error { return (<-v.GoSetMode(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method SetModeBySize func (v *monitor) GoSetModeBySize(flags dbus.Flags, ch chan *dbus.Call, arg0 uint16, arg1 uint16) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetModeBySize", flags, ch, arg0, arg1) } func (v *monitor) SetModeBySize(flags dbus.Flags, arg0 uint16, arg1 uint16) error { return (<-v.GoSetModeBySize(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method SetPosition func (v *monitor) GoSetPosition(flags dbus.Flags, ch chan *dbus.Call, arg0 int16, arg1 int16) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetPosition", flags, ch, arg0, arg1) } func (v *monitor) SetPosition(flags dbus.Flags, arg0 int16, arg1 int16) error { return (<-v.GoSetPosition(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method SetReflect func (v *monitor) GoSetReflect(flags dbus.Flags, ch chan *dbus.Call, arg0 uint16) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetReflect", flags, ch, arg0) } func (v *monitor) SetReflect(flags dbus.Flags, arg0 uint16) error { return (<-v.GoSetReflect(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method SetRefreshRate func (v *monitor) GoSetRefreshRate(flags dbus.Flags, ch chan *dbus.Call, arg0 float64) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetRefreshRate", flags, ch, arg0) } func (v *monitor) SetRefreshRate(flags dbus.Flags, arg0 float64) error { return (<-v.GoSetRefreshRate(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method SetRotation func (v *monitor) GoSetRotation(flags dbus.Flags, ch chan *dbus.Call, arg0 uint16) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetRotation", flags, ch, arg0) } func (v *monitor) SetRotation(flags dbus.Flags, arg0 uint16) error { return (<-v.GoSetRotation(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // property Name s func (v *monitor) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property Enabled b func (v *monitor) Enabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Enabled", } } // property Connected b func (v *monitor) Connected() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Connected", } } // property X n func (v *monitor) X() proxy.PropInt16 { return proxy.PropInt16{ Impl: v, Name: "X", } } // property Y n func (v *monitor) Y() proxy.PropInt16 { return proxy.PropInt16{ Impl: v, Name: "Y", } } // property Width q func (v *monitor) Width() proxy.PropUint16 { return proxy.PropUint16{ Impl: v, Name: "Width", } } // property Height q func (v *monitor) Height() proxy.PropUint16 { return proxy.PropUint16{ Impl: v, Name: "Height", } } // property Rotation q func (v *monitor) Rotation() proxy.PropUint16 { return proxy.PropUint16{ Impl: v, Name: "Rotation", } } // property Reflect q func (v *monitor) Reflect() proxy.PropUint16 { return proxy.PropUint16{ Impl: v, Name: "Reflect", } } // property RefreshRate d func (v *monitor) RefreshRate() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "RefreshRate", } } // property Rotations aq func (v *monitor) Rotations() proxy.PropUint16Array { return proxy.PropUint16Array{ Impl: v, Name: "Rotations", } } // property Reflects aq func (v *monitor) Reflects() proxy.PropUint16Array { return proxy.PropUint16Array{ Impl: v, Name: "Reflects", } } // property BestMode (uqqd) func (v *monitor) BestMode() PropModeInfo { return PropModeInfo{ Impl: v, Name: "BestMode", } } // property CurrentMode (uqqd) func (v *monitor) CurrentMode() PropModeInfo { return PropModeInfo{ Impl: v, Name: "CurrentMode", } } // property Modes a(uqqd) func (v *monitor) Modes() PropModeInfoSlice { return PropModeInfoSlice{ Impl: v, Name: "Modes", } } // property PreferredModes a(uqqd) func (v *monitor) PreferredModes() PropModeInfoSlice { return PropModeInfoSlice{ Impl: v, Name: "PreferredModes", } } type PropModeInfo struct { Impl proxy.Implementer Name string } func (p PropModeInfo) Get(flags dbus.Flags) (value ModeInfo, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropModeInfo) Set(flags dbus.Flags, value ModeInfo) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropModeInfo) ConnectChanged(cb func(hasValue bool, value ModeInfo)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v ModeInfo err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, ModeInfo{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } type PropModeInfoSlice struct { Impl proxy.Implementer Name string } func (p PropModeInfoSlice) Get(flags dbus.Flags) (value []ModeInfo, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropModeInfoSlice) Set(flags dbus.Flags, value []ModeInfo) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropModeInfoSlice) ConnectChanged(cb func(hasValue bool, value []ModeInfo)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []ModeInfo err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } go-dbus-factory-1.9.6/com.deepin.daemon.display/config.json000066400000000000000000000031771403054572700236420ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.Display", "Objects": [ { "Type": "Display", "Path": "/com/deepin/daemon/Display", "Interfaces": [ { "Name": "com.deepin.daemon.Display", "Type": "display", "Fixes": { "m/ListOutputsCommonModes": [ { "Name": "arg0", "Type": "[]ModeInfo" } ], "p/PrimaryRect": { "Type": "PropDisplayPrimaryRect", "ValueType": "Rectangle", "EmptyValue": "$T{}" }, "p/Brightness": { "Type": "PropDisplayBrightness", "ValueType": "map[string]float64" }, "p/TouchMap": { "Type": "PropDisplayTouchMap", "ValueType": "map[string]string" } } } ] }, { "Type": "Monitor", "Interfaces": [ { "Name": "com.deepin.daemon.Display.Monitor", "Type":"monitor", "Fixes": { "p/BestMode": { "RefType": "PropModeInfo" }, "p/CurrentMode": { "RefType": "PropModeInfo" }, "p/Modes": { "RefType": "PropModeInfoSlice" }, "p/PreferredModes": { "RefType": "PropModeInfoSlice" } } } ] } ], "PropertyTypes": [ { "Type": "PropModeInfo", "ValueType": "ModeInfo", "EmptyValue": "$T{}" }, { "Type": "PropModeInfoSlice", "ValueType": "[]ModeInfo" } ] } go-dbus-factory-1.9.6/com.deepin.daemon.display/manual.go000066400000000000000000000002741403054572700233010ustar00rootroot00000000000000package display type ModeInfo struct { Id uint32 Width uint16 Height uint16 Rate float64 } type Rectangle struct { X int16 Y int16 Width uint16 Height uint16 } go-dbus-factory-1.9.6/com.deepin.daemon.fprintd/000077500000000000000000000000001403054572700214735ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.fprintd/Device.xml000066400000000000000000000064351403054572700234240ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.fprintd/Fprintd.xml000066400000000000000000000040021403054572700236170ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.fprintd/auto.go000066400000000000000000000220311403054572700227700ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.fprintd"; DO NOT EDIT. package fprintd import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Fprintd struct { fprintd // interface com.deepin.daemon.Fprintd proxy.Object } func NewFprintd(conn *dbus.Conn) *Fprintd { obj := new(Fprintd) obj.Object.Init_(conn, "com.deepin.daemon.Fprintd", "/com/deepin/daemon/Fprintd") return obj } type fprintd struct{} func (v *fprintd) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*fprintd) GetInterfaceName_() string { return "com.deepin.daemon.Fprintd" } // method GetDefaultDevice func (v *fprintd) GoGetDefaultDevice(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDefaultDevice", flags, ch) } func (*fprintd) StoreGetDefaultDevice(call *dbus.Call) (device dbus.ObjectPath, err error) { err = call.Store(&device) return } func (v *fprintd) GetDefaultDevice(flags dbus.Flags) (device dbus.ObjectPath, err error) { return v.StoreGetDefaultDevice( <-v.GoGetDefaultDevice(flags, make(chan *dbus.Call, 1)).Done) } // method GetDevices func (v *fprintd) GoGetDevices(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDevices", flags, ch) } func (*fprintd) StoreGetDevices(call *dbus.Call) (devices []dbus.ObjectPath, err error) { err = call.Store(&devices) return } func (v *fprintd) GetDevices(flags dbus.Flags) (devices []dbus.ObjectPath, err error) { return v.StoreGetDevices( <-v.GoGetDevices(flags, make(chan *dbus.Call, 1)).Done) } // method TriggerUDevEvent func (v *fprintd) GoTriggerUDevEvent(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TriggerUDevEvent", flags, ch) } func (v *fprintd) TriggerUDevEvent(flags dbus.Flags) error { return (<-v.GoTriggerUDevEvent(flags, make(chan *dbus.Call, 1)).Done).Err } // property Devices ao func (v *fprintd) Devices() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Devices", } } type Device struct { device // interface com.deepin.daemon.Fprintd.Device proxy.Object } func NewDevice(conn *dbus.Conn, path dbus.ObjectPath) (*Device, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Device) obj.Object.Init_(conn, "com.deepin.daemon.Fprintd", path) return obj, nil } type device struct{} func (v *device) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*device) GetInterfaceName_() string { return "com.deepin.daemon.Fprintd.Device" } // method Claim func (v *device) GoClaim(flags dbus.Flags, ch chan *dbus.Call, username string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Claim", flags, ch, username) } func (v *device) Claim(flags dbus.Flags, username string) error { return (<-v.GoClaim(flags, make(chan *dbus.Call, 1), username).Done).Err } // method ClaimForce func (v *device) GoClaimForce(flags dbus.Flags, ch chan *dbus.Call, username string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ClaimForce", flags, ch, username) } func (v *device) ClaimForce(flags dbus.Flags, username string) error { return (<-v.GoClaimForce(flags, make(chan *dbus.Call, 1), username).Done).Err } // method DeleteEnrolledFinger func (v *device) GoDeleteEnrolledFinger(flags dbus.Flags, ch chan *dbus.Call, username string, finger string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteEnrolledFinger", flags, ch, username, finger) } func (v *device) DeleteEnrolledFinger(flags dbus.Flags, username string, finger string) error { return (<-v.GoDeleteEnrolledFinger(flags, make(chan *dbus.Call, 1), username, finger).Done).Err } // method DeleteEnrolledFingers func (v *device) GoDeleteEnrolledFingers(flags dbus.Flags, ch chan *dbus.Call, username string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteEnrolledFingers", flags, ch, username) } func (v *device) DeleteEnrolledFingers(flags dbus.Flags, username string) error { return (<-v.GoDeleteEnrolledFingers(flags, make(chan *dbus.Call, 1), username).Done).Err } // method EnrollStart func (v *device) GoEnrollStart(flags dbus.Flags, ch chan *dbus.Call, finger string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnrollStart", flags, ch, finger) } func (v *device) EnrollStart(flags dbus.Flags, finger string) error { return (<-v.GoEnrollStart(flags, make(chan *dbus.Call, 1), finger).Done).Err } // method EnrollStop func (v *device) GoEnrollStop(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnrollStop", flags, ch) } func (v *device) EnrollStop(flags dbus.Flags) error { return (<-v.GoEnrollStop(flags, make(chan *dbus.Call, 1)).Done).Err } // method GetCapabilities func (v *device) GoGetCapabilities(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetCapabilities", flags, ch) } func (*device) StoreGetCapabilities(call *dbus.Call) (caps []string, err error) { err = call.Store(&caps) return } func (v *device) GetCapabilities(flags dbus.Flags) (caps []string, err error) { return v.StoreGetCapabilities( <-v.GoGetCapabilities(flags, make(chan *dbus.Call, 1)).Done) } // method ListEnrolledFingers func (v *device) GoListEnrolledFingers(flags dbus.Flags, ch chan *dbus.Call, username string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListEnrolledFingers", flags, ch, username) } func (*device) StoreListEnrolledFingers(call *dbus.Call) (fingers []string, err error) { err = call.Store(&fingers) return } func (v *device) ListEnrolledFingers(flags dbus.Flags, username string) (fingers []string, err error) { return v.StoreListEnrolledFingers( <-v.GoListEnrolledFingers(flags, make(chan *dbus.Call, 1), username).Done) } // method Release func (v *device) GoRelease(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Release", flags, ch) } func (v *device) Release(flags dbus.Flags) error { return (<-v.GoRelease(flags, make(chan *dbus.Call, 1)).Done).Err } // method VerifyStart func (v *device) GoVerifyStart(flags dbus.Flags, ch chan *dbus.Call, finger string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".VerifyStart", flags, ch, finger) } func (v *device) VerifyStart(flags dbus.Flags, finger string) error { return (<-v.GoVerifyStart(flags, make(chan *dbus.Call, 1), finger).Done).Err } // method VerifyStop func (v *device) GoVerifyStop(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".VerifyStop", flags, ch) } func (v *device) VerifyStop(flags dbus.Flags) error { return (<-v.GoVerifyStop(flags, make(chan *dbus.Call, 1)).Done).Err } // signal EnrollStatus func (v *device) ConnectEnrollStatus(cb func(status string, done bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "EnrollStatus", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".EnrollStatus", } handlerFunc := func(sig *dbus.Signal) { var status string var done bool err := dbus.Store(sig.Body, &status, &done) if err == nil { cb(status, done) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal VerifyStatus func (v *device) ConnectVerifyStatus(cb func(status string, done bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VerifyStatus", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VerifyStatus", } handlerFunc := func(sig *dbus.Signal) { var status string var done bool err := dbus.Store(sig.Body, &status, &done) if err == nil { cb(status, done) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal VerifyFingerSelected func (v *device) ConnectVerifyFingerSelected(cb func(finger string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VerifyFingerSelected", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VerifyFingerSelected", } handlerFunc := func(sig *dbus.Signal) { var finger string err := dbus.Store(sig.Body, &finger) if err == nil { cb(finger) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property ScanType s func (v *device) ScanType() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ScanType", } } go-dbus-factory-1.9.6/com.deepin.daemon.fprintd/config.json000066400000000000000000000006671403054572700236440ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.Fprintd", "Objects": [ { "Type": "Fprintd", "Path": "/com/deepin/daemon/Fprintd", "Interfaces": [ { "Name": "com.deepin.daemon.Fprintd", "Type": "fprintd" } ] }, { "Type": "Device", "Interfaces": [ { "Name": "com.deepin.daemon.Fprintd.Device", "Type": "device" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.gesture/000077500000000000000000000000001403054572700215035ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.gesture/Gesture.xml000066400000000000000000000103541403054572700236460ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.gesture/auto.go000066400000000000000000000255561403054572700230170ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.gesture"; DO NOT EDIT. package gesture import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Gesture struct { gesture // interface com.deepin.daemon.Gesture proxy.Object } func NewGesture(conn *dbus.Conn) *Gesture { obj := new(Gesture) obj.Object.Init_(conn, "com.deepin.daemon.Gesture", "/com/deepin/daemon/Gesture") return obj } type gesture struct{} func (v *gesture) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*gesture) GetInterfaceName_() string { return "com.deepin.daemon.Gesture" } // method SetShortPressDuration func (v *gesture) GoSetShortPressDuration(flags dbus.Flags, ch chan *dbus.Call, duration uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetShortPressDuration", flags, ch, duration) } func (v *gesture) SetShortPressDuration(flags dbus.Flags, duration uint32) error { return (<-v.GoSetShortPressDuration(flags, make(chan *dbus.Call, 1), duration).Done).Err } // method SetEdgeMoveStopDuration func (v *gesture) GoSetEdgeMoveStopDuration(flags dbus.Flags, ch chan *dbus.Call, duration uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetEdgeMoveStopDuration", flags, ch, duration) } func (v *gesture) SetEdgeMoveStopDuration(flags dbus.Flags, duration uint32) error { return (<-v.GoSetEdgeMoveStopDuration(flags, make(chan *dbus.Call, 1), duration).Done).Err } // signal Event func (v *gesture) ConnectEvent(cb func(name string, direction string, fingers int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Event", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Event", } handlerFunc := func(sig *dbus.Signal) { var name string var direction string var fingers int32 err := dbus.Store(sig.Body, &name, &direction, &fingers) if err == nil { cb(name, direction, fingers) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal DbclickDown func (v *gesture) ConnectDbclickDown(cb func(fingers int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "DbclickDown", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".DbclickDown", } handlerFunc := func(sig *dbus.Signal) { var fingers int32 err := dbus.Store(sig.Body, &fingers) if err == nil { cb(fingers) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal SwipeMoving func (v *gesture) ConnectSwipeMoving(cb func(fingers int32, accelX float64, accely float64)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SwipeMoving", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SwipeMoving", } handlerFunc := func(sig *dbus.Signal) { var fingers int32 var accelX float64 var accely float64 err := dbus.Store(sig.Body, &fingers, &accelX, &accely) if err == nil { cb(fingers, accelX, accely) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal SwipeStop func (v *gesture) ConnectSwipeStop(cb func(fingers int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SwipeStop", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SwipeStop", } handlerFunc := func(sig *dbus.Signal) { var fingers int32 err := dbus.Store(sig.Body, &fingers) if err == nil { cb(fingers) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal TouchEdgeEvent func (v *gesture) ConnectTouchEdgeEvent(cb func(direction string, scalex float64, scaley float64)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "TouchEdgeEvent", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".TouchEdgeEvent", } handlerFunc := func(sig *dbus.Signal) { var direction string var scalex float64 var scaley float64 err := dbus.Store(sig.Body, &direction, &scalex, &scaley) if err == nil { cb(direction, scalex, scaley) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal TouchSinglePressTimeout func (v *gesture) ConnectTouchSinglePressTimeout(cb func(time int32, scalex float64, scaley float64)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "TouchSinglePressTimeout", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".TouchSinglePressTimeout", } handlerFunc := func(sig *dbus.Signal) { var time int32 var scalex float64 var scaley float64 err := dbus.Store(sig.Body, &time, &scalex, &scaley) if err == nil { cb(time, scalex, scaley) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal TouchPressTimeout func (v *gesture) ConnectTouchPressTimeout(cb func(fingers int32, time int32, scalex float64, scaley float64)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "TouchPressTimeout", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".TouchPressTimeout", } handlerFunc := func(sig *dbus.Signal) { var fingers int32 var time int32 var scalex float64 var scaley float64 err := dbus.Store(sig.Body, &fingers, &time, &scalex, &scaley) if err == nil { cb(fingers, time, scalex, scaley) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal TouchUpOrCancel func (v *gesture) ConnectTouchUpOrCancel(cb func(scalex float64, scaley float64)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "TouchUpOrCancel", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".TouchUpOrCancel", } handlerFunc := func(sig *dbus.Signal) { var scalex float64 var scaley float64 err := dbus.Store(sig.Body, &scalex, &scaley) if err == nil { cb(scalex, scaley) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal TouchEdgeMoveStop func (v *gesture) ConnectTouchEdgeMoveStop(cb func(direction string, scalex float64, scaley float64, duration int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "TouchEdgeMoveStop", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".TouchEdgeMoveStop", } handlerFunc := func(sig *dbus.Signal) { var direction string var scalex float64 var scaley float64 var duration int32 err := dbus.Store(sig.Body, &direction, &scalex, &scaley, &duration) if err == nil { cb(direction, scalex, scaley, duration) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal TouchEdgeMoveStopLeave func (v *gesture) ConnectTouchEdgeMoveStopLeave(cb func(direction string, scalex float64, scaley float64, duration int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "TouchEdgeMoveStopLeave", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".TouchEdgeMoveStopLeave", } handlerFunc := func(sig *dbus.Signal) { var direction string var scalex float64 var scaley float64 var duration int32 err := dbus.Store(sig.Body, &direction, &scalex, &scaley, &duration) if err == nil { cb(direction, scalex, scaley, duration) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal TouchMoving func (v *gesture) ConnectTouchMoving(cb func(scalex float64, scaley float64)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "TouchMoving", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".TouchMoving", } handlerFunc := func(sig *dbus.Signal) { var scalex float64 var scaley float64 err := dbus.Store(sig.Body, &scalex, &scaley) if err == nil { cb(scalex, scaley) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal TouchMovementEvent func (v *gesture) ConnectTouchMovementEvent(cb func(duration string, fingers int32, startScalex float64, startScaley float64, endScalex float64, endScaley float64)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "TouchMovementEvent", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".TouchMovementEvent", } handlerFunc := func(sig *dbus.Signal) { var duration string var fingers int32 var startScalex float64 var startScaley float64 var endScalex float64 var endScaley float64 err := dbus.Store(sig.Body, &duration, &fingers, &startScalex, &startScaley, &endScalex, &endScaley) if err == nil { cb(duration, fingers, startScalex, startScaley, endScalex, endScaley) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.deepin.daemon.gesture/config.json000066400000000000000000000004171403054572700236450ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.Gesture", "Objects": [ { "Type": "Gesture", "Path": "/com/deepin/daemon/Gesture", "Interfaces": [ { "Name": "com.deepin.daemon.Gesture", "Type": "gesture" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.greeter/000077500000000000000000000000001403054572700214625ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.greeter/Greeter.xml000066400000000000000000000033641403054572700236070ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.greeter/auto.go000066400000000000000000000020041403054572700227550ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.greeter"; DO NOT EDIT. package greeter import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type Greeter struct { greeter // interface com.deepin.daemon.Greeter proxy.Object } func NewGreeter(conn *dbus.Conn) *Greeter { obj := new(Greeter) obj.Object.Init_(conn, "com.deepin.daemon.Greeter", "/com/deepin/daemon/Greeter") return obj } type greeter struct{} func (v *greeter) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*greeter) GetInterfaceName_() string { return "com.deepin.daemon.Greeter" } // method UpdateGreeterQtTheme func (v *greeter) GoUpdateGreeterQtTheme(flags dbus.Flags, ch chan *dbus.Call, fd dbus.UnixFD) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UpdateGreeterQtTheme", flags, ch, fd) } func (v *greeter) UpdateGreeterQtTheme(flags dbus.Flags, fd dbus.UnixFD) error { return (<-v.GoUpdateGreeterQtTheme(flags, make(chan *dbus.Call, 1), fd).Done).Err } go-dbus-factory-1.9.6/com.deepin.daemon.greeter/config.json000066400000000000000000000004171403054572700236240ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.Greeter", "Objects": [ { "Type": "Greeter", "Path": "/com/deepin/daemon/Greeter", "Interfaces": [ { "Name": "com.deepin.daemon.Greeter", "Type": "greeter" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.helper.backlight/000077500000000000000000000000001403054572700232335ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.helper.backlight/Backlight.xml000066400000000000000000000035611403054572700256520ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.helper.backlight/DDCCI.xml000066400000000000000000000043511403054572700245660ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.helper.backlight/auto.go000066400000000000000000000066131403054572700245400ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.helper.backlight"; DO NOT EDIT. package backlight import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type Backlight struct { backlight // interface com.deepin.daemon.helper.Backlight proxy.Object } func NewBacklight(conn *dbus.Conn) *Backlight { obj := new(Backlight) obj.Object.Init_(conn, "com.deepin.daemon.helper.Backlight", "/com/deepin/daemon/helper/Backlight") return obj } type backlight struct{} func (v *backlight) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*backlight) GetInterfaceName_() string { return "com.deepin.daemon.helper.Backlight" } // method SetBrightness func (v *backlight) GoSetBrightness(flags dbus.Flags, ch chan *dbus.Call, type0 uint8, name string, value int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetBrightness", flags, ch, type0, name, value) } func (v *backlight) SetBrightness(flags dbus.Flags, type0 uint8, name string, value int32) error { return (<-v.GoSetBrightness(flags, make(chan *dbus.Call, 1), type0, name, value).Done).Err } type DDCCI struct { ddcci // interface com.deepin.daemon.helper.Backlight.DDCCI proxy.Object } func NewDDCCI(conn *dbus.Conn) *DDCCI { obj := new(DDCCI) obj.Object.Init_(conn, "com.deepin.daemon.helper.Backlight", "/com/deepin/daemon/helper/Backlight/DDCCI") return obj } type ddcci struct{} func (v *ddcci) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*ddcci) GetInterfaceName_() string { return "com.deepin.daemon.helper.Backlight.DDCCI" } // method CheckSupport func (v *ddcci) GoCheckSupport(flags dbus.Flags, ch chan *dbus.Call, edidChecksum string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CheckSupport", flags, ch, edidChecksum) } func (*ddcci) StoreCheckSupport(call *dbus.Call) (support bool, err error) { err = call.Store(&support) return } func (v *ddcci) CheckSupport(flags dbus.Flags, edidChecksum string) (support bool, err error) { return v.StoreCheckSupport( <-v.GoCheckSupport(flags, make(chan *dbus.Call, 1), edidChecksum).Done) } // method GetBrightness func (v *ddcci) GoGetBrightness(flags dbus.Flags, ch chan *dbus.Call, edidChecksum string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetBrightness", flags, ch, edidChecksum) } func (*ddcci) StoreGetBrightness(call *dbus.Call) (value int32, err error) { err = call.Store(&value) return } func (v *ddcci) GetBrightness(flags dbus.Flags, edidChecksum string) (value int32, err error) { return v.StoreGetBrightness( <-v.GoGetBrightness(flags, make(chan *dbus.Call, 1), edidChecksum).Done) } // method SetBrightness func (v *ddcci) GoSetBrightness(flags dbus.Flags, ch chan *dbus.Call, edidChecksum string, value int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetBrightness", flags, ch, edidChecksum, value) } func (v *ddcci) SetBrightness(flags dbus.Flags, edidChecksum string, value int32) error { return (<-v.GoSetBrightness(flags, make(chan *dbus.Call, 1), edidChecksum, value).Done).Err } // method RefreshDisplays func (v *ddcci) GoRefreshDisplays(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RefreshDisplays", flags, ch) } func (v *ddcci) RefreshDisplays(flags dbus.Flags) error { return (<-v.GoRefreshDisplays(flags, make(chan *dbus.Call, 1)).Done).Err } go-dbus-factory-1.9.6/com.deepin.daemon.helper.backlight/config.json000066400000000000000000000010271403054572700253730ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.helper.Backlight", "Objects": [ { "Type": "Backlight", "Path": "/com/deepin/daemon/helper/Backlight", "Interfaces": [ { "Name": "com.deepin.daemon.helper.Backlight", "Type": "backlight" } ] }, { "Type": "DDCCI", "Path": "/com/deepin/daemon/helper/Backlight/DDCCI", "Interfaces": [ { "Name": "com.deepin.daemon.helper.Backlight.DDCCI", "Type": "ddcci" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.imageeffect/000077500000000000000000000000001403054572700222645ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.imageeffect/ImageEffect.xml000066400000000000000000000040351403054572700251470ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.imageeffect/auto.go000066400000000000000000000031231403054572700235620ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.imageeffect"; DO NOT EDIT. package imageeffect import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type ImageEffect struct { imageEffect // interface com.deepin.daemon.ImageEffect proxy.Object } func NewImageEffect(conn *dbus.Conn) *ImageEffect { obj := new(ImageEffect) obj.Object.Init_(conn, "com.deepin.daemon.ImageEffect", "/com/deepin/daemon/ImageEffect") return obj } type imageEffect struct{} func (v *imageEffect) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*imageEffect) GetInterfaceName_() string { return "com.deepin.daemon.ImageEffect" } // method Delete func (v *imageEffect) GoDelete(flags dbus.Flags, ch chan *dbus.Call, effect string, filename string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Delete", flags, ch, effect, filename) } func (v *imageEffect) Delete(flags dbus.Flags, effect string, filename string) error { return (<-v.GoDelete(flags, make(chan *dbus.Call, 1), effect, filename).Done).Err } // method Get func (v *imageEffect) GoGet(flags dbus.Flags, ch chan *dbus.Call, effect string, filename string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Get", flags, ch, effect, filename) } func (*imageEffect) StoreGet(call *dbus.Call) (outputFile string, err error) { err = call.Store(&outputFile) return } func (v *imageEffect) Get(flags dbus.Flags, effect string, filename string) (outputFile string, err error) { return v.StoreGet( <-v.GoGet(flags, make(chan *dbus.Call, 1), effect, filename).Done) } go-dbus-factory-1.9.6/com.deepin.daemon.imageeffect/config.json000066400000000000000000000004431403054572700244250ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.ImageEffect", "Objects": [ { "Type": "ImageEffect", "Path": "/com/deepin/daemon/ImageEffect", "Interfaces": [ { "Name": "com.deepin.daemon.ImageEffect", "Type": "imageEffect" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.inputdevices/000077500000000000000000000000001403054572700225275ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.inputdevices/Keyboard.xml000066400000000000000000000061531403054572700250160ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.inputdevices/TouchPad.xml000066400000000000000000000061401403054572700247610ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.inputdevices/auto.go000066400000000000000000000206731403054572700240360ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.inputdevices"; DO NOT EDIT. package inputdevices import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type Keyboard struct { keyboard // interface com.deepin.daemon.InputDevice.Keyboard proxy.Object } func NewKeyboard(conn *dbus.Conn) *Keyboard { obj := new(Keyboard) obj.Object.Init_(conn, "com.deepin.daemon.InputDevices", "/com/deepin/daemon/InputDevice/Keyboard") return obj } type keyboard struct{} func (v *keyboard) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*keyboard) GetInterfaceName_() string { return "com.deepin.daemon.InputDevice.Keyboard" } // method AddLayoutOption func (v *keyboard) GoAddLayoutOption(flags dbus.Flags, ch chan *dbus.Call, option string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddLayoutOption", flags, ch, option) } func (v *keyboard) AddLayoutOption(flags dbus.Flags, option string) error { return (<-v.GoAddLayoutOption(flags, make(chan *dbus.Call, 1), option).Done).Err } // method AddUserLayout func (v *keyboard) GoAddUserLayout(flags dbus.Flags, ch chan *dbus.Call, layout string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddUserLayout", flags, ch, layout) } func (v *keyboard) AddUserLayout(flags dbus.Flags, layout string) error { return (<-v.GoAddUserLayout(flags, make(chan *dbus.Call, 1), layout).Done).Err } // method ClearLayoutOption func (v *keyboard) GoClearLayoutOption(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ClearLayoutOption", flags, ch) } func (v *keyboard) ClearLayoutOption(flags dbus.Flags) error { return (<-v.GoClearLayoutOption(flags, make(chan *dbus.Call, 1)).Done).Err } // method DeleteLayoutOption func (v *keyboard) GoDeleteLayoutOption(flags dbus.Flags, ch chan *dbus.Call, option string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteLayoutOption", flags, ch, option) } func (v *keyboard) DeleteLayoutOption(flags dbus.Flags, option string) error { return (<-v.GoDeleteLayoutOption(flags, make(chan *dbus.Call, 1), option).Done).Err } // method DeleteUserLayout func (v *keyboard) GoDeleteUserLayout(flags dbus.Flags, ch chan *dbus.Call, layout string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteUserLayout", flags, ch, layout) } func (v *keyboard) DeleteUserLayout(flags dbus.Flags, layout string) error { return (<-v.GoDeleteUserLayout(flags, make(chan *dbus.Call, 1), layout).Done).Err } // method GetLayoutDesc func (v *keyboard) GoGetLayoutDesc(flags dbus.Flags, ch chan *dbus.Call, layout string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetLayoutDesc", flags, ch, layout) } func (*keyboard) StoreGetLayoutDesc(call *dbus.Call) (description string, err error) { err = call.Store(&description) return } func (v *keyboard) GetLayoutDesc(flags dbus.Flags, layout string) (description string, err error) { return v.StoreGetLayoutDesc( <-v.GoGetLayoutDesc(flags, make(chan *dbus.Call, 1), layout).Done) } // method LayoutList func (v *keyboard) GoLayoutList(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LayoutList", flags, ch) } func (*keyboard) StoreLayoutList(call *dbus.Call) (layout_list map[string]string, err error) { err = call.Store(&layout_list) return } func (v *keyboard) LayoutList(flags dbus.Flags) (layout_list map[string]string, err error) { return v.StoreLayoutList( <-v.GoLayoutList(flags, make(chan *dbus.Call, 1)).Done) } // method Reset func (v *keyboard) GoReset(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reset", flags, ch) } func (v *keyboard) Reset(flags dbus.Flags) error { return (<-v.GoReset(flags, make(chan *dbus.Call, 1)).Done).Err } // property UserOptionList as func (v *keyboard) UserOptionList() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "UserOptionList", } } // property RepeatEnabled b func (v *keyboard) RepeatEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "RepeatEnabled", } } // property CapslockToggle b func (v *keyboard) CapslockToggle() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CapslockToggle", } } // property CursorBlink i func (v *keyboard) CursorBlink() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "CursorBlink", } } // property RepeatInterval u func (v *keyboard) RepeatInterval() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "RepeatInterval", } } // property RepeatDelay u func (v *keyboard) RepeatDelay() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "RepeatDelay", } } // property CurrentLayout s func (v *keyboard) CurrentLayout() proxy.PropString { return proxy.PropString{ Impl: v, Name: "CurrentLayout", } } // property UserLayoutList as func (v *keyboard) UserLayoutList() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "UserLayoutList", } } type TouchPad struct { touchPad // interface com.deepin.daemon.InputDevice.TouchPad proxy.Object } func NewTouchPad(conn *dbus.Conn) *TouchPad { obj := new(TouchPad) obj.Object.Init_(conn, "com.deepin.daemon.InputDevices", "/com/deepin/daemon/InputDevice/TouchPad") return obj } type touchPad struct{} func (v *touchPad) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*touchPad) GetInterfaceName_() string { return "com.deepin.daemon.InputDevice.TouchPad" } // method Reset func (v *touchPad) GoReset(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reset", flags, ch) } func (v *touchPad) Reset(flags dbus.Flags) error { return (<-v.GoReset(flags, make(chan *dbus.Call, 1)).Done).Err } // property EdgeScroll b func (v *touchPad) EdgeScroll() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "EdgeScroll", } } // property PalmDetect b func (v *touchPad) PalmDetect() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PalmDetect", } } // property MotionAcceleration d func (v *touchPad) MotionAcceleration() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "MotionAcceleration", } } // property DeltaScroll i func (v *touchPad) DeltaScroll() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "DeltaScroll", } } // property DragThreshold i func (v *touchPad) DragThreshold() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "DragThreshold", } } // property LeftHanded b func (v *touchPad) LeftHanded() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "LeftHanded", } } // property DisableIfTyping b func (v *touchPad) DisableIfTyping() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "DisableIfTyping", } } // property NaturalScroll b func (v *touchPad) NaturalScroll() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "NaturalScroll", } } // property HorizScroll b func (v *touchPad) HorizScroll() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "HorizScroll", } } // property VertScroll b func (v *touchPad) VertScroll() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "VertScroll", } } // property MotionThreshold d func (v *touchPad) MotionThreshold() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "MotionThreshold", } } // property DoubleClick i func (v *touchPad) DoubleClick() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "DoubleClick", } } // property DeviceList s func (v *touchPad) DeviceList() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DeviceList", } } // property TPadEnable b func (v *touchPad) TPadEnable() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "TPadEnable", } } // property PalmMinZ i func (v *touchPad) PalmMinZ() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "PalmMinZ", } } // property Exist b func (v *touchPad) Exist() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Exist", } } // property TapClick b func (v *touchPad) TapClick() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "TapClick", } } // property MotionScaling d func (v *touchPad) MotionScaling() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "MotionScaling", } } // property PalmMinWidth i func (v *touchPad) PalmMinWidth() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "PalmMinWidth", } } go-dbus-factory-1.9.6/com.deepin.daemon.inputdevices/config.json000066400000000000000000000010331403054572700246640ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.InputDevices", "Objects": [ { "Type": "Keyboard", "Path": "/com/deepin/daemon/InputDevice/Keyboard", "Interfaces": [ { "Name": "com.deepin.daemon.InputDevice.Keyboard", "Type": "keyboard" } ] }, { "Type": "TouchPad", "Path": "/com/deepin/daemon/InputDevice/TouchPad", "Interfaces": [ { "Name": "com.deepin.daemon.InputDevice.TouchPad", "Type": "touchPad" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.keyevent/000077500000000000000000000000001403054572700216575ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.keyevent/KeyEvent.xml000066400000000000000000000012541403054572700241350ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.keyevent/auto.go000066400000000000000000000032201403054572700231530ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.keyevent"; DO NOT EDIT. package keyevent import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type KeyEvent struct { keyEvent // interface com.deepin.daemon.KeyEvent proxy.Object } func NewKeyEvent(conn *dbus.Conn) *KeyEvent { obj := new(KeyEvent) obj.Object.Init_(conn, "com.deepin.daemon.KeyEvent", "/com/deepin/daemon/KeyEvent") return obj } type keyEvent struct{} func (v *keyEvent) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*keyEvent) GetInterfaceName_() string { return "com.deepin.daemon.KeyEvent" } // signal KeyEvent func (v *keyEvent) ConnectKeyEvent(cb func(keycode uint32, pressed bool, ctrlPressed bool, shiftPressed bool, altPressed bool, superPressed bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "KeyEvent", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".KeyEvent", } handlerFunc := func(sig *dbus.Signal) { var keycode uint32 var pressed bool var ctrlPressed bool var shiftPressed bool var altPressed bool var superPressed bool err := dbus.Store(sig.Body, &keycode, &pressed, &ctrlPressed, &shiftPressed, &altPressed, &superPressed) if err == nil { cb(keycode, pressed, ctrlPressed, shiftPressed, altPressed, superPressed) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.deepin.daemon.keyevent/config.json000066400000000000000000000004241403054572700240170ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.KeyEvent", "Objects": [ { "Type": "KeyEvent", "Path": "/com/deepin/daemon/KeyEvent", "Interfaces": [ { "Name": "com.deepin.daemon.KeyEvent", "Type": "keyEvent" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.kwayland/000077500000000000000000000000001403054572700216375ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.kwayland/OutputManagement.xml000066400000000000000000000043101403054572700256540ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.kwayland/Window.xml000066400000000000000000000124611403054572700236340ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.kwayland/WindowManager.xml000066400000000000000000000032441403054572700251260ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.kwayland/auto.go000066400000000000000000001170231403054572700231420ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.kwayland"; DO NOT EDIT. package kwayland import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type OutputManagement struct { outputManagement // interface com.deepin.daemon.KWayland.Output proxy.Object } func NewOutputManagement(conn *dbus.Conn) *OutputManagement { obj := new(OutputManagement) obj.Object.Init_(conn, "com.deepin.daemon.KWayland", "/com/deepin/daemon/KWayland/Output") return obj } type outputManagement struct{} func (v *outputManagement) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*outputManagement) GetInterfaceName_() string { return "com.deepin.daemon.KWayland.Output" } // method ListOutput func (v *outputManagement) GoListOutput(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListOutput", flags, ch) } func (*outputManagement) StoreListOutput(call *dbus.Call) (arg0 string, err error) { err = call.Store(&arg0) return } func (v *outputManagement) ListOutput(flags dbus.Flags) (arg0 string, err error) { return v.StoreListOutput( <-v.GoListOutput(flags, make(chan *dbus.Call, 1)).Done) } // method GetOutput func (v *outputManagement) GoGetOutput(flags dbus.Flags, ch chan *dbus.Call, arg1 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetOutput", flags, ch, arg1) } func (*outputManagement) StoreGetOutput(call *dbus.Call) (arg0 string, err error) { err = call.Store(&arg0) return } func (v *outputManagement) GetOutput(flags dbus.Flags, arg1 string) (arg0 string, err error) { return v.StoreGetOutput( <-v.GoGetOutput(flags, make(chan *dbus.Call, 1), arg1).Done) } // method Apply func (v *outputManagement) GoApply(flags dbus.Flags, ch chan *dbus.Call, outputs string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Apply", flags, ch, outputs) } func (v *outputManagement) Apply(flags dbus.Flags, outputs string) error { return (<-v.GoApply(flags, make(chan *dbus.Call, 1), outputs).Done).Err } // signal OutputAdded func (v *outputManagement) ConnectOutputAdded(cb func(output string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "OutputAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".OutputAdded", } handlerFunc := func(sig *dbus.Signal) { var output string err := dbus.Store(sig.Body, &output) if err == nil { cb(output) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal OutputRemoved func (v *outputManagement) ConnectOutputRemoved(cb func(output string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "OutputRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".OutputRemoved", } handlerFunc := func(sig *dbus.Signal) { var output string err := dbus.Store(sig.Body, &output) if err == nil { cb(output) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal OutputChanged func (v *outputManagement) ConnectOutputChanged(cb func(output string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "OutputChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".OutputChanged", } handlerFunc := func(sig *dbus.Signal) { var output string err := dbus.Store(sig.Body, &output) if err == nil { cb(output) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } type WindowManager struct { windowManager // interface com.deepin.daemon.KWayland.WindowManager proxy.Object } func NewWindowManager(conn *dbus.Conn) *WindowManager { obj := new(WindowManager) obj.Object.Init_(conn, "com.deepin.daemon.KWayland", "/com/deepin/daemon/KWayland/WindowManager") return obj } type windowManager struct{} func (v *windowManager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*windowManager) GetInterfaceName_() string { return "com.deepin.daemon.KWayland.WindowManager" } // method ActiveWindow func (v *windowManager) GoActiveWindow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ActiveWindow", flags, ch) } func (*windowManager) StoreActiveWindow(call *dbus.Call) (argout0 uint32, err error) { err = call.Store(&argout0) return } func (v *windowManager) ActiveWindow(flags dbus.Flags) (argout0 uint32, err error) { return v.StoreActiveWindow( <-v.GoActiveWindow(flags, make(chan *dbus.Call, 1)).Done) } // method Windows func (v *windowManager) GoWindows(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Windows", flags, ch) } func (*windowManager) StoreWindows(call *dbus.Call) (argout0 []dbus.Variant, err error) { err = call.Store(&argout0) return } func (v *windowManager) Windows(flags dbus.Flags) (argout0 []dbus.Variant, err error) { return v.StoreWindows( <-v.GoWindows(flags, make(chan *dbus.Call, 1)).Done) } // signal WindowCreated func (v *windowManager) ConnectWindowCreated(cb func(ObjPath string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "WindowCreated", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".WindowCreated", } handlerFunc := func(sig *dbus.Signal) { var ObjPath string err := dbus.Store(sig.Body, &ObjPath) if err == nil { cb(ObjPath) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal WindowRemove func (v *windowManager) ConnectWindowRemove(cb func(ObjPath string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "WindowRemove", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".WindowRemove", } handlerFunc := func(sig *dbus.Signal) { var ObjPath string err := dbus.Store(sig.Body, &ObjPath) if err == nil { cb(ObjPath) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ActiveWindowChanged func (v *windowManager) ConnectActiveWindowChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ActiveWindowChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ActiveWindowChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } type Window struct { window // interface com.deepin.daemon.KWayland.PlasmaWindow proxy.Object } func NewWindow(conn *dbus.Conn, path dbus.ObjectPath) (*Window, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Window) obj.Object.Init_(conn, "com.deepin.daemon.KWayland", path) return obj, nil } type window struct{} func (v *window) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*window) GetInterfaceName_() string { return "com.deepin.daemon.KWayland.PlasmaWindow" } // method AppId func (v *window) GoAppId(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AppId", flags, ch) } func (*window) StoreAppId(call *dbus.Call) (argout0 string, err error) { err = call.Store(&argout0) return } func (v *window) AppId(flags dbus.Flags) (argout0 string, err error) { return v.StoreAppId( <-v.GoAppId(flags, make(chan *dbus.Call, 1)).Done) } // method Geometry func (v *window) GoGeometry(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Geometry", flags, ch) } func (*window) StoreGeometry(call *dbus.Call) (argout0 Rect, err error) { err = call.Store(&argout0) return } func (v *window) Geometry(flags dbus.Flags) (argout0 Rect, err error) { return v.StoreGeometry( <-v.GoGeometry(flags, make(chan *dbus.Call, 1)).Done) } // method Icon func (v *window) GoIcon(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Icon", flags, ch) } func (*window) StoreIcon(call *dbus.Call) (argout0 string, err error) { err = call.Store(&argout0) return } func (v *window) Icon(flags dbus.Flags) (argout0 string, err error) { return v.StoreIcon( <-v.GoIcon(flags, make(chan *dbus.Call, 1)).Done) } // method InternalId func (v *window) GoInternalId(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".InternalId", flags, ch) } func (*window) StoreInternalId(call *dbus.Call) (argout0 uint32, err error) { err = call.Store(&argout0) return } func (v *window) InternalId(flags dbus.Flags) (argout0 uint32, err error) { return v.StoreInternalId( <-v.GoInternalId(flags, make(chan *dbus.Call, 1)).Done) } // method IsActive func (v *window) GoIsActive(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsActive", flags, ch) } func (*window) StoreIsActive(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsActive(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsActive( <-v.GoIsActive(flags, make(chan *dbus.Call, 1)).Done) } // method IsCloseable func (v *window) GoIsCloseable(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsCloseable", flags, ch) } func (*window) StoreIsCloseable(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsCloseable(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsCloseable( <-v.GoIsCloseable(flags, make(chan *dbus.Call, 1)).Done) } // method IsDemandingAttention func (v *window) GoIsDemandingAttention(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsDemandingAttention", flags, ch) } func (*window) StoreIsDemandingAttention(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsDemandingAttention(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsDemandingAttention( <-v.GoIsDemandingAttention(flags, make(chan *dbus.Call, 1)).Done) } // method IsFullscreen func (v *window) GoIsFullscreen(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsFullscreen", flags, ch) } func (*window) StoreIsFullscreen(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsFullscreen(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsFullscreen( <-v.GoIsFullscreen(flags, make(chan *dbus.Call, 1)).Done) } // method IsFullscreenable func (v *window) GoIsFullscreenable(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsFullscreenable", flags, ch) } func (*window) StoreIsFullscreenable(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsFullscreenable(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsFullscreenable( <-v.GoIsFullscreenable(flags, make(chan *dbus.Call, 1)).Done) } // method IsKeepAbove func (v *window) GoIsKeepAbove(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsKeepAbove", flags, ch) } func (*window) StoreIsKeepAbove(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsKeepAbove(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsKeepAbove( <-v.GoIsKeepAbove(flags, make(chan *dbus.Call, 1)).Done) } // method IsMaximizeable func (v *window) GoIsMaximizeable(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsMaximizeable", flags, ch) } func (*window) StoreIsMaximizeable(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsMaximizeable(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsMaximizeable( <-v.GoIsMaximizeable(flags, make(chan *dbus.Call, 1)).Done) } // method IsMaximized func (v *window) GoIsMaximized(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsMaximized", flags, ch) } func (*window) StoreIsMaximized(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsMaximized(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsMaximized( <-v.GoIsMaximized(flags, make(chan *dbus.Call, 1)).Done) } // method IsMinimizeable func (v *window) GoIsMinimizeable(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsMinimizeable", flags, ch) } func (*window) StoreIsMinimizeable(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsMinimizeable(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsMinimizeable( <-v.GoIsMinimizeable(flags, make(chan *dbus.Call, 1)).Done) } // method IsMinimized func (v *window) GoIsMinimized(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsMinimized", flags, ch) } func (*window) StoreIsMinimized(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsMinimized(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsMinimized( <-v.GoIsMinimized(flags, make(chan *dbus.Call, 1)).Done) } // method IsMovable func (v *window) GoIsMovable(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsMovable", flags, ch) } func (*window) StoreIsMovable(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsMovable(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsMovable( <-v.GoIsMovable(flags, make(chan *dbus.Call, 1)).Done) } // method IsOnAllDesktops func (v *window) GoIsOnAllDesktops(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsOnAllDesktops", flags, ch) } func (*window) StoreIsOnAllDesktops(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsOnAllDesktops(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsOnAllDesktops( <-v.GoIsOnAllDesktops(flags, make(chan *dbus.Call, 1)).Done) } // method IsResizable func (v *window) GoIsResizable(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsResizable", flags, ch) } func (*window) StoreIsResizable(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsResizable(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsResizable( <-v.GoIsResizable(flags, make(chan *dbus.Call, 1)).Done) } // method IsShadeable func (v *window) GoIsShadeable(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsShadeable", flags, ch) } func (*window) StoreIsShadeable(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsShadeable(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsShadeable( <-v.GoIsShadeable(flags, make(chan *dbus.Call, 1)).Done) } // method IsShaded func (v *window) GoIsShaded(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsShaded", flags, ch) } func (*window) StoreIsShaded(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsShaded(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsShaded( <-v.GoIsShaded(flags, make(chan *dbus.Call, 1)).Done) } // method IsValid func (v *window) GoIsValid(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsValid", flags, ch) } func (*window) StoreIsValid(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsValid(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsValid( <-v.GoIsValid(flags, make(chan *dbus.Call, 1)).Done) } // method IsVirtualDesktopChangeable func (v *window) GoIsVirtualDesktopChangeable(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsVirtualDesktopChangeable", flags, ch) } func (*window) StoreIsVirtualDesktopChangeable(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) IsVirtualDesktopChangeable(flags dbus.Flags) (argout0 bool, err error) { return v.StoreIsVirtualDesktopChangeable( <-v.GoIsVirtualDesktopChangeable(flags, make(chan *dbus.Call, 1)).Done) } // method Pid func (v *window) GoPid(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Pid", flags, ch) } func (*window) StorePid(call *dbus.Call) (argout0 uint32, err error) { err = call.Store(&argout0) return } func (v *window) Pid(flags dbus.Flags) (argout0 uint32, err error) { return v.StorePid( <-v.GoPid(flags, make(chan *dbus.Call, 1)).Done) } // method RequestActivate func (v *window) GoRequestActivate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestActivate", flags, ch) } func (v *window) RequestActivate(flags dbus.Flags) error { return (<-v.GoRequestActivate(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestClose func (v *window) GoRequestClose(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestClose", flags, ch) } func (v *window) RequestClose(flags dbus.Flags) error { return (<-v.GoRequestClose(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestEnterNewVirtualDesktop func (v *window) GoRequestEnterNewVirtualDesktop(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestEnterNewVirtualDesktop", flags, ch) } func (v *window) RequestEnterNewVirtualDesktop(flags dbus.Flags) error { return (<-v.GoRequestEnterNewVirtualDesktop(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestEnterVirtualDesktop func (v *window) GoRequestEnterVirtualDesktop(flags dbus.Flags, ch chan *dbus.Call, argin0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestEnterVirtualDesktop", flags, ch, argin0) } func (v *window) RequestEnterVirtualDesktop(flags dbus.Flags, argin0 string) error { return (<-v.GoRequestEnterVirtualDesktop(flags, make(chan *dbus.Call, 1), argin0).Done).Err } // method RequestLeaveVirtualDesktop func (v *window) GoRequestLeaveVirtualDesktop(flags dbus.Flags, ch chan *dbus.Call, argin0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestLeaveVirtualDesktop", flags, ch, argin0) } func (v *window) RequestLeaveVirtualDesktop(flags dbus.Flags, argin0 string) error { return (<-v.GoRequestLeaveVirtualDesktop(flags, make(chan *dbus.Call, 1), argin0).Done).Err } // method RequestMove func (v *window) GoRequestMove(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestMove", flags, ch) } func (v *window) RequestMove(flags dbus.Flags) error { return (<-v.GoRequestMove(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestResize func (v *window) GoRequestResize(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestResize", flags, ch) } func (v *window) RequestResize(flags dbus.Flags) error { return (<-v.GoRequestResize(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestToggleKeepAbove func (v *window) GoRequestToggleKeepAbove(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestToggleKeepAbove", flags, ch) } func (v *window) RequestToggleKeepAbove(flags dbus.Flags) error { return (<-v.GoRequestToggleKeepAbove(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestToggleKeepBelow func (v *window) GoRequestToggleKeepBelow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestToggleKeepBelow", flags, ch) } func (v *window) RequestToggleKeepBelow(flags dbus.Flags) error { return (<-v.GoRequestToggleKeepBelow(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestToggleMaximized func (v *window) GoRequestToggleMaximized(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestToggleMaximized", flags, ch) } func (v *window) RequestToggleMaximized(flags dbus.Flags) error { return (<-v.GoRequestToggleMaximized(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestToggleMinimized func (v *window) GoRequestToggleMinimized(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestToggleMinimized", flags, ch) } func (v *window) RequestToggleMinimized(flags dbus.Flags) error { return (<-v.GoRequestToggleMinimized(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestToggleShaded func (v *window) GoRequestToggleShaded(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestToggleShaded", flags, ch) } func (v *window) RequestToggleShaded(flags dbus.Flags) error { return (<-v.GoRequestToggleShaded(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestVirtualDesktop func (v *window) GoRequestVirtualDesktop(flags dbus.Flags, ch chan *dbus.Call, argin0 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestVirtualDesktop", flags, ch, argin0) } func (v *window) RequestVirtualDesktop(flags dbus.Flags, argin0 uint32) error { return (<-v.GoRequestVirtualDesktop(flags, make(chan *dbus.Call, 1), argin0).Done).Err } // method SkipSwitcher func (v *window) GoSkipSwitcher(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SkipSwitcher", flags, ch) } func (*window) StoreSkipSwitcher(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) SkipSwitcher(flags dbus.Flags) (argout0 bool, err error) { return v.StoreSkipSwitcher( <-v.GoSkipSwitcher(flags, make(chan *dbus.Call, 1)).Done) } // method SkipTaskbar func (v *window) GoSkipTaskbar(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SkipTaskbar", flags, ch) } func (*window) StoreSkipTaskbar(call *dbus.Call) (argout0 bool, err error) { err = call.Store(&argout0) return } func (v *window) SkipTaskbar(flags dbus.Flags) (argout0 bool, err error) { return v.StoreSkipTaskbar( <-v.GoSkipTaskbar(flags, make(chan *dbus.Call, 1)).Done) } // method Title func (v *window) GoTitle(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Title", flags, ch) } func (*window) StoreTitle(call *dbus.Call) (argout0 string, err error) { err = call.Store(&argout0) return } func (v *window) Title(flags dbus.Flags) (argout0 string, err error) { return v.StoreTitle( <-v.GoTitle(flags, make(chan *dbus.Call, 1)).Done) } // method VirtualDesktop func (v *window) GoVirtualDesktop(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".VirtualDesktop", flags, ch) } func (*window) StoreVirtualDesktop(call *dbus.Call) (argout0 uint32, err error) { err = call.Store(&argout0) return } func (v *window) VirtualDesktop(flags dbus.Flags) (argout0 uint32, err error) { return v.StoreVirtualDesktop( <-v.GoVirtualDesktop(flags, make(chan *dbus.Call, 1)).Done) } // signal ActiveChanged func (v *window) ConnectActiveChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ActiveChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ActiveChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal AppIdChanged func (v *window) ConnectAppIdChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "AppIdChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".AppIdChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal CloseableChanged func (v *window) ConnectCloseableChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "CloseableChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".CloseableChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal DemandsAttentionChanged func (v *window) ConnectDemandsAttentionChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "DemandsAttentionChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".DemandsAttentionChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal FullscreenableChanged func (v *window) ConnectFullscreenableChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "FullscreenableChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".FullscreenableChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal FullscreenChanged func (v *window) ConnectFullscreenChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "FullscreenChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".FullscreenChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal GeometryChanged func (v *window) ConnectGeometryChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "GeometryChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".GeometryChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal IconChanged func (v *window) ConnectIconChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "IconChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".IconChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal KeepAboveChanged func (v *window) ConnectKeepAboveChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "KeepAboveChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".KeepAboveChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal KeepBelowChanged func (v *window) ConnectKeepBelowChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "KeepBelowChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".KeepBelowChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal MaximizeableChanged func (v *window) ConnectMaximizeableChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "MaximizeableChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".MaximizeableChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal MaximizedChanged func (v *window) ConnectMaximizedChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "MaximizedChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".MaximizedChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal MinimizeableChanged func (v *window) ConnectMinimizeableChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "MinimizeableChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".MinimizeableChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal MinimizedChanged func (v *window) ConnectMinimizedChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "MinimizedChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".MinimizedChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal MovableChanged func (v *window) ConnectMovableChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "MovableChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".MovableChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal OnAllDesktopsChanged func (v *window) ConnectOnAllDesktopsChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "OnAllDesktopsChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".OnAllDesktopsChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ParentWindowChanged func (v *window) ConnectParentWindowChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ParentWindowChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ParentWindowChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ResizableChanged func (v *window) ConnectResizableChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ResizableChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ResizableChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ShadeableChanged func (v *window) ConnectShadeableChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ShadeableChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ShadeableChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ShadedChanged func (v *window) ConnectShadedChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ShadedChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ShadedChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal SkipSwitcherChanged func (v *window) ConnectSkipSwitcherChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SkipSwitcherChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SkipSwitcherChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal SkipTaskbarChanged func (v *window) ConnectSkipTaskbarChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SkipTaskbarChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SkipTaskbarChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal TitleChanged func (v *window) ConnectTitleChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "TitleChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".TitleChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Unmapped func (v *window) ConnectUnmapped(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Unmapped", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Unmapped", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal VirtualDesktopChangeableChanged func (v *window) ConnectVirtualDesktopChangeableChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VirtualDesktopChangeableChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VirtualDesktopChangeableChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal VirtualDesktopChanged func (v *window) ConnectVirtualDesktopChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VirtualDesktopChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VirtualDesktopChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.deepin.daemon.kwayland/config.json000066400000000000000000000017711403054572700240050ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.KWayland", "Objects": [ { "Type": "OutputManagement", "Path": "/com/deepin/daemon/KWayland/Output", "Interfaces": [ { "Name": "com.deepin.daemon.KWayland.Output", "Type": "outputManagement", "Accessor": "OutputManagement" } ] }, { "Type": "WindowManager", "Path": "/com/deepin/daemon/KWayland/WindowManager", "Interfaces": [ { "Name": "com.deepin.daemon.KWayland.WindowManager", "Type": "windowManager", "Accessor": "WindowManager" } ] }, { "Type": "Window", "Interfaces": [ { "Name": "com.deepin.daemon.KWayland.PlasmaWindow", "Type": "window", "Accessor": "Window", "Fixes": { "m/Geometry": [ { "Name": "argout0", "Type": "Rect" } ] } } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.kwayland/manual.go000066400000000000000000000001021403054572700234340ustar00rootroot00000000000000package kwayland type Rect struct { X, Y, Width, Height int32 } go-dbus-factory-1.9.6/com.deepin.daemon.network/000077500000000000000000000000001403054572700215165ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.network/Network.xml000066400000000000000000000151451403054572700236770ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.network/auto.go000066400000000000000000000406421403054572700230230ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.network"; DO NOT EDIT. package network import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Network struct { network // interface com.deepin.daemon.Network proxy.Object } func NewNetwork(conn *dbus.Conn) *Network { obj := new(Network) obj.Object.Init_(conn, "com.deepin.daemon.Network", "/com/deepin/daemon/Network") return obj } type network struct{} func (v *network) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*network) GetInterfaceName_() string { return "com.deepin.daemon.Network" } // method ActivateAccessPoint func (v *network) GoActivateAccessPoint(flags dbus.Flags, ch chan *dbus.Call, uuid string, apPath dbus.ObjectPath, devPath dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ActivateAccessPoint", flags, ch, uuid, apPath, devPath) } func (*network) StoreActivateAccessPoint(call *dbus.Call) (cPath dbus.ObjectPath, err error) { err = call.Store(&cPath) return } func (v *network) ActivateAccessPoint(flags dbus.Flags, uuid string, apPath dbus.ObjectPath, devPath dbus.ObjectPath) (cPath dbus.ObjectPath, err error) { return v.StoreActivateAccessPoint( <-v.GoActivateAccessPoint(flags, make(chan *dbus.Call, 1), uuid, apPath, devPath).Done) } // method ActivateConnection func (v *network) GoActivateConnection(flags dbus.Flags, ch chan *dbus.Call, uuid string, devPath dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ActivateConnection", flags, ch, uuid, devPath) } func (*network) StoreActivateConnection(call *dbus.Call) (cPath dbus.ObjectPath, err error) { err = call.Store(&cPath) return } func (v *network) ActivateConnection(flags dbus.Flags, uuid string, devPath dbus.ObjectPath) (cPath dbus.ObjectPath, err error) { return v.StoreActivateConnection( <-v.GoActivateConnection(flags, make(chan *dbus.Call, 1), uuid, devPath).Done) } // method DeactivateConnection func (v *network) GoDeactivateConnection(flags dbus.Flags, ch chan *dbus.Call, uuid string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeactivateConnection", flags, ch, uuid) } func (v *network) DeactivateConnection(flags dbus.Flags, uuid string) error { return (<-v.GoDeactivateConnection(flags, make(chan *dbus.Call, 1), uuid).Done).Err } // method DeleteConnection func (v *network) GoDeleteConnection(flags dbus.Flags, ch chan *dbus.Call, uuid string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteConnection", flags, ch, uuid) } func (v *network) DeleteConnection(flags dbus.Flags, uuid string) error { return (<-v.GoDeleteConnection(flags, make(chan *dbus.Call, 1), uuid).Done).Err } // method DisableWirelessHotspotMode func (v *network) GoDisableWirelessHotspotMode(flags dbus.Flags, ch chan *dbus.Call, devPath dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DisableWirelessHotspotMode", flags, ch, devPath) } func (v *network) DisableWirelessHotspotMode(flags dbus.Flags, devPath dbus.ObjectPath) error { return (<-v.GoDisableWirelessHotspotMode(flags, make(chan *dbus.Call, 1), devPath).Done).Err } // method DisconnectDevice func (v *network) GoDisconnectDevice(flags dbus.Flags, ch chan *dbus.Call, devPath dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DisconnectDevice", flags, ch, devPath) } func (v *network) DisconnectDevice(flags dbus.Flags, devPath dbus.ObjectPath) error { return (<-v.GoDisconnectDevice(flags, make(chan *dbus.Call, 1), devPath).Done).Err } // method EnableDevice func (v *network) GoEnableDevice(flags dbus.Flags, ch chan *dbus.Call, devPath dbus.ObjectPath, enabled bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnableDevice", flags, ch, devPath, enabled) } func (*network) StoreEnableDevice(call *dbus.Call) (cpath dbus.ObjectPath, err error) { err = call.Store(&cpath) return } func (v *network) EnableDevice(flags dbus.Flags, devPath dbus.ObjectPath, enabled bool) (cpath dbus.ObjectPath, err error) { return v.StoreEnableDevice( <-v.GoEnableDevice(flags, make(chan *dbus.Call, 1), devPath, enabled).Done) } // method EnableWirelessHotspotMode func (v *network) GoEnableWirelessHotspotMode(flags dbus.Flags, ch chan *dbus.Call, devPath dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnableWirelessHotspotMode", flags, ch, devPath) } func (v *network) EnableWirelessHotspotMode(flags dbus.Flags, devPath dbus.ObjectPath) error { return (<-v.GoEnableWirelessHotspotMode(flags, make(chan *dbus.Call, 1), devPath).Done).Err } // method GetAccessPoints func (v *network) GoGetAccessPoints(flags dbus.Flags, ch chan *dbus.Call, path dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAccessPoints", flags, ch, path) } func (*network) StoreGetAccessPoints(call *dbus.Call) (apsJSON string, err error) { err = call.Store(&apsJSON) return } func (v *network) GetAccessPoints(flags dbus.Flags, path dbus.ObjectPath) (apsJSON string, err error) { return v.StoreGetAccessPoints( <-v.GoGetAccessPoints(flags, make(chan *dbus.Call, 1), path).Done) } // method GetActiveConnectionInfo func (v *network) GoGetActiveConnectionInfo(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetActiveConnectionInfo", flags, ch) } func (*network) StoreGetActiveConnectionInfo(call *dbus.Call) (acInfosJSON string, err error) { err = call.Store(&acInfosJSON) return } func (v *network) GetActiveConnectionInfo(flags dbus.Flags) (acInfosJSON string, err error) { return v.StoreGetActiveConnectionInfo( <-v.GoGetActiveConnectionInfo(flags, make(chan *dbus.Call, 1)).Done) } // method GetAutoProxy func (v *network) GoGetAutoProxy(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAutoProxy", flags, ch) } func (*network) StoreGetAutoProxy(call *dbus.Call) (proxyAuto string, err error) { err = call.Store(&proxyAuto) return } func (v *network) GetAutoProxy(flags dbus.Flags) (proxyAuto string, err error) { return v.StoreGetAutoProxy( <-v.GoGetAutoProxy(flags, make(chan *dbus.Call, 1)).Done) } // method GetProxy func (v *network) GoGetProxy(flags dbus.Flags, ch chan *dbus.Call, proxyType string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetProxy", flags, ch, proxyType) } func (*network) StoreGetProxy(call *dbus.Call) (host string, port string, err error) { err = call.Store(&host, &port) return } func (v *network) GetProxy(flags dbus.Flags, proxyType string) (host string, port string, err error) { return v.StoreGetProxy( <-v.GoGetProxy(flags, make(chan *dbus.Call, 1), proxyType).Done) } // method GetProxyIgnoreHosts func (v *network) GoGetProxyIgnoreHosts(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetProxyIgnoreHosts", flags, ch) } func (*network) StoreGetProxyIgnoreHosts(call *dbus.Call) (ignoreHosts string, err error) { err = call.Store(&ignoreHosts) return } func (v *network) GetProxyIgnoreHosts(flags dbus.Flags) (ignoreHosts string, err error) { return v.StoreGetProxyIgnoreHosts( <-v.GoGetProxyIgnoreHosts(flags, make(chan *dbus.Call, 1)).Done) } // method GetProxyMethod func (v *network) GoGetProxyMethod(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetProxyMethod", flags, ch) } func (*network) StoreGetProxyMethod(call *dbus.Call) (proxyMode string, err error) { err = call.Store(&proxyMode) return } func (v *network) GetProxyMethod(flags dbus.Flags) (proxyMode string, err error) { return v.StoreGetProxyMethod( <-v.GoGetProxyMethod(flags, make(chan *dbus.Call, 1)).Done) } // method GetSupportedConnectionTypes func (v *network) GoGetSupportedConnectionTypes(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetSupportedConnectionTypes", flags, ch) } func (*network) StoreGetSupportedConnectionTypes(call *dbus.Call) (types []string, err error) { err = call.Store(&types) return } func (v *network) GetSupportedConnectionTypes(flags dbus.Flags) (types []string, err error) { return v.StoreGetSupportedConnectionTypes( <-v.GoGetSupportedConnectionTypes(flags, make(chan *dbus.Call, 1)).Done) } // method IsDeviceEnabled func (v *network) GoIsDeviceEnabled(flags dbus.Flags, ch chan *dbus.Call, devPath dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsDeviceEnabled", flags, ch, devPath) } func (*network) StoreIsDeviceEnabled(call *dbus.Call) (enabled bool, err error) { err = call.Store(&enabled) return } func (v *network) IsDeviceEnabled(flags dbus.Flags, devPath dbus.ObjectPath) (enabled bool, err error) { return v.StoreIsDeviceEnabled( <-v.GoIsDeviceEnabled(flags, make(chan *dbus.Call, 1), devPath).Done) } // method IsWirelessHotspotModeEnabled func (v *network) GoIsWirelessHotspotModeEnabled(flags dbus.Flags, ch chan *dbus.Call, devPath dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsWirelessHotspotModeEnabled", flags, ch, devPath) } func (*network) StoreIsWirelessHotspotModeEnabled(call *dbus.Call) (enabled bool, err error) { err = call.Store(&enabled) return } func (v *network) IsWirelessHotspotModeEnabled(flags dbus.Flags, devPath dbus.ObjectPath) (enabled bool, err error) { return v.StoreIsWirelessHotspotModeEnabled( <-v.GoIsWirelessHotspotModeEnabled(flags, make(chan *dbus.Call, 1), devPath).Done) } // method ListDeviceConnections func (v *network) GoListDeviceConnections(flags dbus.Flags, ch chan *dbus.Call, devPath dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListDeviceConnections", flags, ch, devPath) } func (*network) StoreListDeviceConnections(call *dbus.Call) (connections []dbus.ObjectPath, err error) { err = call.Store(&connections) return } func (v *network) ListDeviceConnections(flags dbus.Flags, devPath dbus.ObjectPath) (connections []dbus.ObjectPath, err error) { return v.StoreListDeviceConnections( <-v.GoListDeviceConnections(flags, make(chan *dbus.Call, 1), devPath).Done) } // method RequestWirelessScan func (v *network) GoRequestWirelessScan(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestWirelessScan", flags, ch) } func (v *network) RequestWirelessScan(flags dbus.Flags) error { return (<-v.GoRequestWirelessScan(flags, make(chan *dbus.Call, 1)).Done).Err } // method SetAutoProxy func (v *network) GoSetAutoProxy(flags dbus.Flags, ch chan *dbus.Call, proxyAuto string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetAutoProxy", flags, ch, proxyAuto) } func (v *network) SetAutoProxy(flags dbus.Flags, proxyAuto string) error { return (<-v.GoSetAutoProxy(flags, make(chan *dbus.Call, 1), proxyAuto).Done).Err } // method SetDeviceManaged func (v *network) GoSetDeviceManaged(flags dbus.Flags, ch chan *dbus.Call, devPathOrIfc string, managed bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDeviceManaged", flags, ch, devPathOrIfc, managed) } func (v *network) SetDeviceManaged(flags dbus.Flags, devPathOrIfc string, managed bool) error { return (<-v.GoSetDeviceManaged(flags, make(chan *dbus.Call, 1), devPathOrIfc, managed).Done).Err } // method SetProxy func (v *network) GoSetProxy(flags dbus.Flags, ch chan *dbus.Call, proxyType string, host string, port string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetProxy", flags, ch, proxyType, host, port) } func (v *network) SetProxy(flags dbus.Flags, proxyType string, host string, port string) error { return (<-v.GoSetProxy(flags, make(chan *dbus.Call, 1), proxyType, host, port).Done).Err } // method SetProxyIgnoreHosts func (v *network) GoSetProxyIgnoreHosts(flags dbus.Flags, ch chan *dbus.Call, ignoreHosts string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetProxyIgnoreHosts", flags, ch, ignoreHosts) } func (v *network) SetProxyIgnoreHosts(flags dbus.Flags, ignoreHosts string) error { return (<-v.GoSetProxyIgnoreHosts(flags, make(chan *dbus.Call, 1), ignoreHosts).Done).Err } // method SetProxyMethod func (v *network) GoSetProxyMethod(flags dbus.Flags, ch chan *dbus.Call, proxyMode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetProxyMethod", flags, ch, proxyMode) } func (v *network) SetProxyMethod(flags dbus.Flags, proxyMode string) error { return (<-v.GoSetProxyMethod(flags, make(chan *dbus.Call, 1), proxyMode).Done).Err } // signal AccessPointAdded func (v *network) ConnectAccessPointAdded(cb func(devPath string, apJSON string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "AccessPointAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".AccessPointAdded", } handlerFunc := func(sig *dbus.Signal) { var devPath string var apJSON string err := dbus.Store(sig.Body, &devPath, &apJSON) if err == nil { cb(devPath, apJSON) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal AccessPointRemoved func (v *network) ConnectAccessPointRemoved(cb func(devPath string, apJSON string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "AccessPointRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".AccessPointRemoved", } handlerFunc := func(sig *dbus.Signal) { var devPath string var apJSON string err := dbus.Store(sig.Body, &devPath, &apJSON) if err == nil { cb(devPath, apJSON) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal AccessPointPropertiesChanged func (v *network) ConnectAccessPointPropertiesChanged(cb func(devPath string, apJSON string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "AccessPointPropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".AccessPointPropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var devPath string var apJSON string err := dbus.Store(sig.Body, &devPath, &apJSON) if err == nil { cb(devPath, apJSON) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal DeviceEnabled func (v *network) ConnectDeviceEnabled(cb func(devPath string, enabled bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "DeviceEnabled", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".DeviceEnabled", } handlerFunc := func(sig *dbus.Signal) { var devPath string var enabled bool err := dbus.Store(sig.Body, &devPath, &enabled) if err == nil { cb(devPath, enabled) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Connectivity u func (v *network) Connectivity() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Connectivity", } } // property NetworkingEnabled b func (v *network) NetworkingEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "NetworkingEnabled", } } // property VpnEnabled b func (v *network) VpnEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "VpnEnabled", } } // property Devices s func (v *network) Devices() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Devices", } } // property Connections s func (v *network) Connections() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Connections", } } // property ActiveConnections s func (v *network) ActiveConnections() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ActiveConnections", } } // property State u func (v *network) State() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "State", } } go-dbus-factory-1.9.6/com.deepin.daemon.network/config.json000066400000000000000000000004171403054572700236600ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.Network", "Objects": [ { "Type": "Network", "Path": "/com/deepin/daemon/Network", "Interfaces": [ { "Name": "com.deepin.daemon.Network", "Type": "network" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.powermanager/000077500000000000000000000000001403054572700225145ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.powermanager/PowerManager.xml000066400000000000000000000012621403054572700256260ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.powermanager/auto.go000066400000000000000000000050111403054572700240100ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.powermanager"; DO NOT EDIT. package powermanager import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type PowerManager struct { powerManager // interface com.deepin.daemon.PowerManager proxy.Object } func NewPowerManager(conn *dbus.Conn) *PowerManager { obj := new(PowerManager) obj.Object.Init_(conn, "com.deepin.daemon.PowerManager", "/com/deepin/daemon/PowerManager") return obj } type powerManager struct{} func (v *powerManager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*powerManager) GetInterfaceName_() string { return "com.deepin.daemon.PowerManager" } // method CanShutdown func (v *powerManager) GoCanShutdown(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanShutdown", flags, ch) } func (*powerManager) StoreCanShutdown(call *dbus.Call) (can bool, err error) { err = call.Store(&can) return } func (v *powerManager) CanShutdown(flags dbus.Flags) (can bool, err error) { return v.StoreCanShutdown( <-v.GoCanShutdown(flags, make(chan *dbus.Call, 1)).Done) } // method CanReboot func (v *powerManager) GoCanReboot(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanReboot", flags, ch) } func (*powerManager) StoreCanReboot(call *dbus.Call) (can bool, err error) { err = call.Store(&can) return } func (v *powerManager) CanReboot(flags dbus.Flags) (can bool, err error) { return v.StoreCanReboot( <-v.GoCanReboot(flags, make(chan *dbus.Call, 1)).Done) } // method CanSuspend func (v *powerManager) GoCanSuspend(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanSuspend", flags, ch) } func (*powerManager) StoreCanSuspend(call *dbus.Call) (can bool, err error) { err = call.Store(&can) return } func (v *powerManager) CanSuspend(flags dbus.Flags) (can bool, err error) { return v.StoreCanSuspend( <-v.GoCanSuspend(flags, make(chan *dbus.Call, 1)).Done) } // method CanHibernate func (v *powerManager) GoCanHibernate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanHibernate", flags, ch) } func (*powerManager) StoreCanHibernate(call *dbus.Call) (can bool, err error) { err = call.Store(&can) return } func (v *powerManager) CanHibernate(flags dbus.Flags) (can bool, err error) { return v.StoreCanHibernate( <-v.GoCanHibernate(flags, make(chan *dbus.Call, 1)).Done) } go-dbus-factory-1.9.6/com.deepin.daemon.powermanager/config.json000066400000000000000000000004501403054572700246530ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.PowerManager", "Objects": [ { "Type": "PowerManager", "Path": "/com/deepin/daemon/PowerManager", "Interfaces": [ { "Name": "com.deepin.daemon.PowerManager", "Type": "powerManager" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.sessionwatcher/000077500000000000000000000000001403054572700230665ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.sessionwatcher/SessionWatcher.xml000066400000000000000000000036761403054572700265650ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.sessionwatcher/auto.go000066400000000000000000000036071403054572700243730ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.sessionwatcher"; DO NOT EDIT. package sessionwatcher import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type SessionWatcher struct { sessionWatcher // interface com.deepin.daemon.SessionWatcher proxy.Object } func NewSessionWatcher(conn *dbus.Conn) *SessionWatcher { obj := new(SessionWatcher) obj.Object.Init_(conn, "com.deepin.daemon.SessionWatcher", "/com/deepin/daemon/SessionWatcher") return obj } type sessionWatcher struct{} func (v *sessionWatcher) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*sessionWatcher) GetInterfaceName_() string { return "com.deepin.daemon.SessionWatcher" } // method GetSessions func (v *sessionWatcher) GoGetSessions(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetSessions", flags, ch) } func (*sessionWatcher) StoreGetSessions(call *dbus.Call) (sessions []dbus.ObjectPath, err error) { err = call.Store(&sessions) return } func (v *sessionWatcher) GetSessions(flags dbus.Flags) (sessions []dbus.ObjectPath, err error) { return v.StoreGetSessions( <-v.GoGetSessions(flags, make(chan *dbus.Call, 1)).Done) } // method IsX11SessionActive func (v *sessionWatcher) GoIsX11SessionActive(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsX11SessionActive", flags, ch) } func (*sessionWatcher) StoreIsX11SessionActive(call *dbus.Call) (is_active bool, err error) { err = call.Store(&is_active) return } func (v *sessionWatcher) IsX11SessionActive(flags dbus.Flags) (is_active bool, err error) { return v.StoreIsX11SessionActive( <-v.GoIsX11SessionActive(flags, make(chan *dbus.Call, 1)).Done) } // property IsActive b func (v *sessionWatcher) IsActive() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IsActive", } } go-dbus-factory-1.9.6/com.deepin.daemon.sessionwatcher/config.json000066400000000000000000000004621403054572700252300ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.SessionWatcher", "Objects": [ { "Type": "SessionWatcher", "Path": "/com/deepin/daemon/SessionWatcher", "Interfaces": [ { "Name": "com.deepin.daemon.SessionWatcher", "Type": "sessionWatcher" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.timedate/000077500000000000000000000000001403054572700216215ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.timedate/Timedate.xml000066400000000000000000000004251403054572700241000ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.timedate/auto.go000066400000000000000000000023471403054572700231260ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.timedate"; DO NOT EDIT. package timedate import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Timedate struct { timedate // interface com.deepin.daemon.Timedate proxy.Object } func NewTimedate(conn *dbus.Conn) *Timedate { obj := new(Timedate) obj.Object.Init_(conn, "com.deepin.daemon.Timedate", "/com/deepin/daemon/Timedate") return obj } type timedate struct{} func (v *timedate) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*timedate) GetInterfaceName_() string { return "com.deepin.daemon.Timedate" } // signal TimeUpdate func (v *timedate) ConnectTimeUpdate(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "TimeUpdate", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".TimeUpdate", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.deepin.daemon.timedate/config.json000066400000000000000000000004231403054572700237600ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.Timedate", "Objects": [ { "Type": "Timedate", "Path": "/com/deepin/daemon/Timedate", "Interfaces": [ { "Name": "com.deepin.daemon.Timedate", "Type": "timedate" } ] } ] }go-dbus-factory-1.9.6/com.deepin.daemon.timedated/000077500000000000000000000000001403054572700217655ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.timedated/Timedated.xml000066400000000000000000000054021403054572700244100ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.timedated/auto.go000066400000000000000000000057721403054572700232770ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.timedated"; DO NOT EDIT. package timedated import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type Timedated struct { timedated // interface com.deepin.daemon.Timedated proxy.Object } func NewTimedated(conn *dbus.Conn) *Timedated { obj := new(Timedated) obj.Object.Init_(conn, "com.deepin.daemon.Timedated", "/com/deepin/daemon/Timedated") return obj } type timedated struct{} func (v *timedated) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*timedated) GetInterfaceName_() string { return "com.deepin.daemon.Timedated" } // method SetLocalRTC func (v *timedated) GoSetLocalRTC(flags dbus.Flags, ch chan *dbus.Call, enabled bool, fixSystem bool, message string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLocalRTC", flags, ch, enabled, fixSystem, message) } func (v *timedated) SetLocalRTC(flags dbus.Flags, enabled bool, fixSystem bool, message string) error { return (<-v.GoSetLocalRTC(flags, make(chan *dbus.Call, 1), enabled, fixSystem, message).Done).Err } // method SetNTP func (v *timedated) GoSetNTP(flags dbus.Flags, ch chan *dbus.Call, enabled bool, message string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetNTP", flags, ch, enabled, message) } func (v *timedated) SetNTP(flags dbus.Flags, enabled bool, message string) error { return (<-v.GoSetNTP(flags, make(chan *dbus.Call, 1), enabled, message).Done).Err } // method SetNTPServer func (v *timedated) GoSetNTPServer(flags dbus.Flags, ch chan *dbus.Call, server string, message string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetNTPServer", flags, ch, server, message) } func (v *timedated) SetNTPServer(flags dbus.Flags, server string, message string) error { return (<-v.GoSetNTPServer(flags, make(chan *dbus.Call, 1), server, message).Done).Err } // method SetTime func (v *timedated) GoSetTime(flags dbus.Flags, ch chan *dbus.Call, usec int64, relative bool, message string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetTime", flags, ch, usec, relative, message) } func (v *timedated) SetTime(flags dbus.Flags, usec int64, relative bool, message string) error { return (<-v.GoSetTime(flags, make(chan *dbus.Call, 1), usec, relative, message).Done).Err } // method SetTimezone func (v *timedated) GoSetTimezone(flags dbus.Flags, ch chan *dbus.Call, timezone string, message string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetTimezone", flags, ch, timezone, message) } func (v *timedated) SetTimezone(flags dbus.Flags, timezone string, message string) error { return (<-v.GoSetTimezone(flags, make(chan *dbus.Call, 1), timezone, message).Done).Err } // property NTPServer s func (v *timedated) NTPServer() proxy.PropString { return proxy.PropString{ Impl: v, Name: "NTPServer", } } // property Timezone s func (v *timedated) Timezone() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Timezone", } } go-dbus-factory-1.9.6/com.deepin.daemon.timedated/config.json000066400000000000000000000004311403054572700241230ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.Timedated", "Objects": [ { "Type": "Timedated", "Path": "/com/deepin/daemon/Timedated", "Interfaces": [ { "Name": "com.deepin.daemon.Timedated", "Type": "timedated" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.uadp/000077500000000000000000000000001403054572700207565ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.uadp/Uadp.xml000066400000000000000000000043411403054572700223730ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.uadp/auto.go000066400000000000000000000032701403054572700222570ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.uadp"; DO NOT EDIT. package uadp import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type Uadp struct { uadp // interface com.deepin.daemon.Uadp proxy.Object } func NewUadp(conn *dbus.Conn) *Uadp { obj := new(Uadp) obj.Object.Init_(conn, "com.deepin.daemon.Uadp", "/com/deepin/daemon/Uadp") return obj } type uadp struct{} func (v *uadp) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*uadp) GetInterfaceName_() string { return "com.deepin.daemon.Uadp" } // method SetDataKey func (v *uadp) GoSetDataKey(flags dbus.Flags, ch chan *dbus.Call, exePath string, keyName string, dataKey string, keyringKey string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDataKey", flags, ch, exePath, keyName, dataKey, keyringKey) } func (v *uadp) SetDataKey(flags dbus.Flags, exePath string, keyName string, dataKey string, keyringKey string) error { return (<-v.GoSetDataKey(flags, make(chan *dbus.Call, 1), exePath, keyName, dataKey, keyringKey).Done).Err } // method GetDataKey func (v *uadp) GoGetDataKey(flags dbus.Flags, ch chan *dbus.Call, exePath string, keyName string, keyringKey string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDataKey", flags, ch, exePath, keyName, keyringKey) } func (*uadp) StoreGetDataKey(call *dbus.Call) (dataKey string, err error) { err = call.Store(&dataKey) return } func (v *uadp) GetDataKey(flags dbus.Flags, exePath string, keyName string, keyringKey string) (dataKey string, err error) { return v.StoreGetDataKey( <-v.GoGetDataKey(flags, make(chan *dbus.Call, 1), exePath, keyName, keyringKey).Done) } go-dbus-factory-1.9.6/com.deepin.daemon.uadp/config.json000066400000000000000000000004371403054572700231220ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.Uadp", "Objects": [ { "Type": "Uadp", "Path": "/com/deepin/daemon/Uadp", "Interfaces": [ { "Name": "com.deepin.daemon.Uadp", "Type": "uadp" } ] } ] } go-dbus-factory-1.9.6/com.deepin.daemon.uadpagent/000077500000000000000000000000001403054572700217755ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.daemon.uadpagent/UadpAgent.xml000066400000000000000000000037441403054572700243770ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.daemon.uadpagent/auto.go000066400000000000000000000030671403054572700233020ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.daemon.uadpagent"; DO NOT EDIT. package uadpagent import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type UadpAgent struct { uadpagent // interface com.deepin.daemon.UadpAgent proxy.Object } func NewUadpAgent(conn *dbus.Conn) *UadpAgent { obj := new(UadpAgent) obj.Object.Init_(conn, "com.deepin.daemon.UadpAgent", "/com/deepin/daemon/UadpAgent") return obj } type uadpagent struct{} func (v *uadpagent) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*uadpagent) GetInterfaceName_() string { return "com.deepin.daemon.UadpAgent" } // method SetDataKey func (v *uadpagent) GoSetDataKey(flags dbus.Flags, ch chan *dbus.Call, keyName string, dataKey string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDataKey", flags, ch, keyName, dataKey) } func (v *uadpagent) SetDataKey(flags dbus.Flags, keyName string, dataKey string) error { return (<-v.GoSetDataKey(flags, make(chan *dbus.Call, 1), keyName, dataKey).Done).Err } // method GetDataKey func (v *uadpagent) GoGetDataKey(flags dbus.Flags, ch chan *dbus.Call, keyName string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDataKey", flags, ch, keyName) } func (*uadpagent) StoreGetDataKey(call *dbus.Call) (dataKey string, err error) { err = call.Store(&dataKey) return } func (v *uadpagent) GetDataKey(flags dbus.Flags, keyName string) (dataKey string, err error) { return v.StoreGetDataKey( <-v.GoGetDataKey(flags, make(chan *dbus.Call, 1), keyName).Done) } go-dbus-factory-1.9.6/com.deepin.daemon.uadpagent/config.json000066400000000000000000000004311403054572700241330ustar00rootroot00000000000000{ "Service": "com.deepin.daemon.UadpAgent", "Objects": [ { "Type": "UadpAgent", "Path": "/com/deepin/daemon/UadpAgent", "Interfaces": [ { "Name": "com.deepin.daemon.UadpAgent", "Type": "uadpagent" } ] } ] } go-dbus-factory-1.9.6/com.deepin.dde.clipboard/000077500000000000000000000000001403054572700212555ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.dde.clipboard/Clipboard.xml000066400000000000000000000032631403054572700237020ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.dde.clipboard/auto.go000066400000000000000000000027351403054572700225630ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.dde.clipboard"; DO NOT EDIT. package clipboard import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type Clipboard struct { clipboard // interface com.deepin.dde.Clipboard proxy.Object } func NewClipboard(conn *dbus.Conn) *Clipboard { obj := new(Clipboard) obj.Object.Init_(conn, "com.deepin.dde.Clipboard", "/com/deepin/dde/Clipboard") return obj } type clipboard struct{} func (v *clipboard) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*clipboard) GetInterfaceName_() string { return "com.deepin.dde.Clipboard" } // method Toggle func (v *clipboard) GoToggle(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Toggle", flags, ch) } func (v *clipboard) Toggle(flags dbus.Flags) error { return (<-v.GoToggle(flags, make(chan *dbus.Call, 1)).Done).Err } // method Show func (v *clipboard) GoShow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Show", flags, ch) } func (v *clipboard) Show(flags dbus.Flags) error { return (<-v.GoShow(flags, make(chan *dbus.Call, 1)).Done).Err } // method Hide func (v *clipboard) GoHide(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Hide", flags, ch) } func (v *clipboard) Hide(flags dbus.Flags) error { return (<-v.GoHide(flags, make(chan *dbus.Call, 1)).Done).Err } go-dbus-factory-1.9.6/com.deepin.dde.clipboard/config.json000066400000000000000000000004201403054572700234110ustar00rootroot00000000000000{ "Service": "com.deepin.dde.Clipboard", "Objects": [ { "Type": "Clipboard", "Path": "/com/deepin/dde/Clipboard", "Interfaces": [ { "Name": "com.deepin.dde.Clipboard", "Type": "clipboard" } ] } ] } go-dbus-factory-1.9.6/com.deepin.dde.daemon.dock/000077500000000000000000000000001403054572700215005ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.dde.daemon.dock/Dock.xml000066400000000000000000000120631403054572700231040ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.dde.daemon.dock/Entry.xml000066400000000000000000000060441403054572700233270ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.dde.daemon.dock/auto.go000066400000000000000000000415111403054572700230010ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.dde.daemon.dock"; DO NOT EDIT. package dock import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Dock struct { dock // interface com.deepin.dde.daemon.Dock proxy.Object } func NewDock(conn *dbus.Conn) *Dock { obj := new(Dock) obj.Object.Init_(conn, "com.deepin.dde.daemon.Dock", "/com/deepin/dde/daemon/Dock") return obj } type dock struct{} func (v *dock) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*dock) GetInterfaceName_() string { return "com.deepin.dde.daemon.Dock" } // method ActivateWindow func (v *dock) GoActivateWindow(flags dbus.Flags, ch chan *dbus.Call, win uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ActivateWindow", flags, ch, win) } func (v *dock) ActivateWindow(flags dbus.Flags, win uint32) error { return (<-v.GoActivateWindow(flags, make(chan *dbus.Call, 1), win).Done).Err } // method CancelPreviewWindow func (v *dock) GoCancelPreviewWindow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CancelPreviewWindow", flags, ch) } func (v *dock) CancelPreviewWindow(flags dbus.Flags) error { return (<-v.GoCancelPreviewWindow(flags, make(chan *dbus.Call, 1)).Done).Err } // method CloseWindow func (v *dock) GoCloseWindow(flags dbus.Flags, ch chan *dbus.Call, win uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CloseWindow", flags, ch, win) } func (v *dock) CloseWindow(flags dbus.Flags, win uint32) error { return (<-v.GoCloseWindow(flags, make(chan *dbus.Call, 1), win).Done).Err } // method GetEntryIDs func (v *dock) GoGetEntryIDs(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetEntryIDs", flags, ch) } func (*dock) StoreGetEntryIDs(call *dbus.Call) (list []string, err error) { err = call.Store(&list) return } func (v *dock) GetEntryIDs(flags dbus.Flags) (list []string, err error) { return v.StoreGetEntryIDs( <-v.GoGetEntryIDs(flags, make(chan *dbus.Call, 1)).Done) } // method IsDocked func (v *dock) GoIsDocked(flags dbus.Flags, ch chan *dbus.Call, desktopFile string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsDocked", flags, ch, desktopFile) } func (*dock) StoreIsDocked(call *dbus.Call) (value bool, err error) { err = call.Store(&value) return } func (v *dock) IsDocked(flags dbus.Flags, desktopFile string) (value bool, err error) { return v.StoreIsDocked( <-v.GoIsDocked(flags, make(chan *dbus.Call, 1), desktopFile).Done) } // method IsOnDock func (v *dock) GoIsOnDock(flags dbus.Flags, ch chan *dbus.Call, desktopFile string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsOnDock", flags, ch, desktopFile) } func (*dock) StoreIsOnDock(call *dbus.Call) (value bool, err error) { err = call.Store(&value) return } func (v *dock) IsOnDock(flags dbus.Flags, desktopFile string) (value bool, err error) { return v.StoreIsOnDock( <-v.GoIsOnDock(flags, make(chan *dbus.Call, 1), desktopFile).Done) } // method MakeWindowAbove func (v *dock) GoMakeWindowAbove(flags dbus.Flags, ch chan *dbus.Call, win uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".MakeWindowAbove", flags, ch, win) } func (v *dock) MakeWindowAbove(flags dbus.Flags, win uint32) error { return (<-v.GoMakeWindowAbove(flags, make(chan *dbus.Call, 1), win).Done).Err } // method MaximizeWindow func (v *dock) GoMaximizeWindow(flags dbus.Flags, ch chan *dbus.Call, win uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".MaximizeWindow", flags, ch, win) } func (v *dock) MaximizeWindow(flags dbus.Flags, win uint32) error { return (<-v.GoMaximizeWindow(flags, make(chan *dbus.Call, 1), win).Done).Err } // method MinimizeWindow func (v *dock) GoMinimizeWindow(flags dbus.Flags, ch chan *dbus.Call, win uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".MinimizeWindow", flags, ch, win) } func (v *dock) MinimizeWindow(flags dbus.Flags, win uint32) error { return (<-v.GoMinimizeWindow(flags, make(chan *dbus.Call, 1), win).Done).Err } // method MoveEntry func (v *dock) GoMoveEntry(flags dbus.Flags, ch chan *dbus.Call, index int32, newIndex int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".MoveEntry", flags, ch, index, newIndex) } func (v *dock) MoveEntry(flags dbus.Flags, index int32, newIndex int32) error { return (<-v.GoMoveEntry(flags, make(chan *dbus.Call, 1), index, newIndex).Done).Err } // method MoveWindow func (v *dock) GoMoveWindow(flags dbus.Flags, ch chan *dbus.Call, win uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".MoveWindow", flags, ch, win) } func (v *dock) MoveWindow(flags dbus.Flags, win uint32) error { return (<-v.GoMoveWindow(flags, make(chan *dbus.Call, 1), win).Done).Err } // method PreviewWindow func (v *dock) GoPreviewWindow(flags dbus.Flags, ch chan *dbus.Call, win uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PreviewWindow", flags, ch, win) } func (v *dock) PreviewWindow(flags dbus.Flags, win uint32) error { return (<-v.GoPreviewWindow(flags, make(chan *dbus.Call, 1), win).Done).Err } // method QueryWindowIdentifyMethod func (v *dock) GoQueryWindowIdentifyMethod(flags dbus.Flags, ch chan *dbus.Call, win uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".QueryWindowIdentifyMethod", flags, ch, win) } func (*dock) StoreQueryWindowIdentifyMethod(call *dbus.Call) (identifyMethod string, err error) { err = call.Store(&identifyMethod) return } func (v *dock) QueryWindowIdentifyMethod(flags dbus.Flags, win uint32) (identifyMethod string, err error) { return v.StoreQueryWindowIdentifyMethod( <-v.GoQueryWindowIdentifyMethod(flags, make(chan *dbus.Call, 1), win).Done) } // method RequestDock func (v *dock) GoRequestDock(flags dbus.Flags, ch chan *dbus.Call, desktopFile string, index int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestDock", flags, ch, desktopFile, index) } func (*dock) StoreRequestDock(call *dbus.Call) (ok bool, err error) { err = call.Store(&ok) return } func (v *dock) RequestDock(flags dbus.Flags, desktopFile string, index int32) (ok bool, err error) { return v.StoreRequestDock( <-v.GoRequestDock(flags, make(chan *dbus.Call, 1), desktopFile, index).Done) } // method RequestUndock func (v *dock) GoRequestUndock(flags dbus.Flags, ch chan *dbus.Call, desktopFile string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestUndock", flags, ch, desktopFile) } func (*dock) StoreRequestUndock(call *dbus.Call) (ok bool, err error) { err = call.Store(&ok) return } func (v *dock) RequestUndock(flags dbus.Flags, desktopFile string) (ok bool, err error) { return v.StoreRequestUndock( <-v.GoRequestUndock(flags, make(chan *dbus.Call, 1), desktopFile).Done) } // method SetFrontendWindowRect func (v *dock) GoSetFrontendWindowRect(flags dbus.Flags, ch chan *dbus.Call, x int32, y int32, width uint32, height uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetFrontendWindowRect", flags, ch, x, y, width, height) } func (v *dock) SetFrontendWindowRect(flags dbus.Flags, x int32, y int32, width uint32, height uint32) error { return (<-v.GoSetFrontendWindowRect(flags, make(chan *dbus.Call, 1), x, y, width, height).Done).Err } // signal ServiceRestarted func (v *dock) ConnectServiceRestarted(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ServiceRestarted", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ServiceRestarted", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal EntryAdded func (v *dock) ConnectEntryAdded(cb func(path dbus.ObjectPath, index int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "EntryAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".EntryAdded", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath var index int32 err := dbus.Store(sig.Body, &path, &index) if err == nil { cb(path, index) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal EntryRemoved func (v *dock) ConnectEntryRemoved(cb func(entryId string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "EntryRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".EntryRemoved", } handlerFunc := func(sig *dbus.Signal) { var entryId string err := dbus.Store(sig.Body, &entryId) if err == nil { cb(entryId) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property ShowTimeout u func (v *dock) ShowTimeout() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "ShowTimeout", } } // property HideTimeout u func (v *dock) HideTimeout() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "HideTimeout", } } // property FrontendWindowRect (iiuu) func (v *dock) FrontendWindowRect() PropDockFrontendWindowRect { return PropDockFrontendWindowRect{ Impl: v, } } type PropDockFrontendWindowRect struct { Impl proxy.Implementer } func (p PropDockFrontendWindowRect) Get(flags dbus.Flags) (value FrontendWindowRect, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "FrontendWindowRect", &value) return } func (p PropDockFrontendWindowRect) ConnectChanged(cb func(hasValue bool, value FrontendWindowRect)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v FrontendWindowRect err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, FrontendWindowRect{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "FrontendWindowRect", cb0) } // property Entries ao func (v *dock) Entries() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Entries", } } // property HideMode i func (v *dock) HideMode() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "HideMode", } } // property DisplayMode i func (v *dock) DisplayMode() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "DisplayMode", } } // property HideState i func (v *dock) HideState() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "HideState", } } // property Position i func (v *dock) Position() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "Position", } } // property IconSize u func (v *dock) IconSize() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "IconSize", } } // property DockedApps as func (v *dock) DockedApps() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "DockedApps", } } type Entry struct { entry // interface com.deepin.dde.daemon.Dock.Entry proxy.Object } func NewEntry(conn *dbus.Conn, path dbus.ObjectPath) (*Entry, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Entry) obj.Object.Init_(conn, "com.deepin.dde.daemon.Dock", path) return obj, nil } type entry struct{} func (v *entry) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*entry) GetInterfaceName_() string { return "com.deepin.dde.daemon.Dock.Entry" } // method Activate func (v *entry) GoActivate(flags dbus.Flags, ch chan *dbus.Call, timestamp uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Activate", flags, ch, timestamp) } func (v *entry) Activate(flags dbus.Flags, timestamp uint32) error { return (<-v.GoActivate(flags, make(chan *dbus.Call, 1), timestamp).Done).Err } // method Check func (v *entry) GoCheck(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Check", flags, ch) } func (v *entry) Check(flags dbus.Flags) error { return (<-v.GoCheck(flags, make(chan *dbus.Call, 1)).Done).Err } // method ForceQuit func (v *entry) GoForceQuit(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ForceQuit", flags, ch) } func (v *entry) ForceQuit(flags dbus.Flags) error { return (<-v.GoForceQuit(flags, make(chan *dbus.Call, 1)).Done).Err } // method HandleDragDrop func (v *entry) GoHandleDragDrop(flags dbus.Flags, ch chan *dbus.Call, timestamp uint32, files []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".HandleDragDrop", flags, ch, timestamp, files) } func (v *entry) HandleDragDrop(flags dbus.Flags, timestamp uint32, files []string) error { return (<-v.GoHandleDragDrop(flags, make(chan *dbus.Call, 1), timestamp, files).Done).Err } // method HandleMenuItem func (v *entry) GoHandleMenuItem(flags dbus.Flags, ch chan *dbus.Call, timestamp uint32, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".HandleMenuItem", flags, ch, timestamp, id) } func (v *entry) HandleMenuItem(flags dbus.Flags, timestamp uint32, id string) error { return (<-v.GoHandleMenuItem(flags, make(chan *dbus.Call, 1), timestamp, id).Done).Err } // method NewInstance func (v *entry) GoNewInstance(flags dbus.Flags, ch chan *dbus.Call, timestamp uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".NewInstance", flags, ch, timestamp) } func (v *entry) NewInstance(flags dbus.Flags, timestamp uint32) error { return (<-v.GoNewInstance(flags, make(chan *dbus.Call, 1), timestamp).Done).Err } // method PresentWindows func (v *entry) GoPresentWindows(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PresentWindows", flags, ch) } func (v *entry) PresentWindows(flags dbus.Flags) error { return (<-v.GoPresentWindows(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestDock func (v *entry) GoRequestDock(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestDock", flags, ch) } func (v *entry) RequestDock(flags dbus.Flags) error { return (<-v.GoRequestDock(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestUndock func (v *entry) GoRequestUndock(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestUndock", flags, ch) } func (v *entry) RequestUndock(flags dbus.Flags) error { return (<-v.GoRequestUndock(flags, make(chan *dbus.Call, 1)).Done).Err } // property Name s func (v *entry) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property Icon s func (v *entry) Icon() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Icon", } } // property Id s func (v *entry) Id() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Id", } } // property IsActive b func (v *entry) IsActive() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IsActive", } } // property CurrentWindow u func (v *entry) CurrentWindow() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "CurrentWindow", } } // property IsDocked b func (v *entry) IsDocked() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IsDocked", } } // property WindowInfos a{u(sb)} func (v *entry) WindowInfos() PropEntryWindowInfos { return PropEntryWindowInfos{ Impl: v, } } type PropEntryWindowInfos struct { Impl proxy.Implementer } func (p PropEntryWindowInfos) Get(flags dbus.Flags) (value map[uint32]WindowInfo, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "WindowInfos", &value) return } func (p PropEntryWindowInfos) ConnectChanged(cb func(hasValue bool, value map[uint32]WindowInfo)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[uint32]WindowInfo err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "WindowInfos", cb0) } // property Menu s func (v *entry) Menu() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Menu", } } // property DesktopFile s func (v *entry) DesktopFile() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DesktopFile", } } go-dbus-factory-1.9.6/com.deepin.dde.daemon.dock/config.json000066400000000000000000000015211403054572700236370ustar00rootroot00000000000000{ "Service": "com.deepin.dde.daemon.Dock", "Objects": [ { "Type": "Dock", "Path": "/com/deepin/dde/daemon/Dock", "Interfaces": [ { "Name": "com.deepin.dde.daemon.Dock", "Type": "dock", "Fixes": { "p/FrontendWindowRect": { "Type": "PropDockFrontendWindowRect", "ValueType": "FrontendWindowRect", "EmptyValue": "$T{}" } } } ] }, { "Type": "Entry", "Path":"", "Interfaces": [ { "Name": "com.deepin.dde.daemon.Dock.Entry", "Type": "entry", "Fixes": { "p/WindowInfos": { "Type": "PropEntryWindowInfos", "ValueType": "map[uint32]WindowInfo" } } } ] } ] } go-dbus-factory-1.9.6/com.deepin.dde.daemon.dock/manutal.go000066400000000000000000000002221403054572700234640ustar00rootroot00000000000000package dock type FrontendWindowRect struct { X, Y int32 Width, Height uint32 } type WindowInfo struct { Title string Flash bool } go-dbus-factory-1.9.6/com.deepin.dde.daemon.launcher/000077500000000000000000000000001403054572700223615ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.dde.daemon.launcher/Launcher.xml000066400000000000000000000107411403054572700246470ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.dde.daemon.launcher/auto.go000066400000000000000000000247171403054572700236730ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.dde.daemon.launcher"; DO NOT EDIT. package launcher import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Launcher struct { launcher // interface com.deepin.dde.daemon.Launcher proxy.Object } func NewLauncher(conn *dbus.Conn) *Launcher { obj := new(Launcher) obj.Object.Init_(conn, "com.deepin.dde.daemon.Launcher", "/com/deepin/dde/daemon/Launcher") return obj } type launcher struct{} func (v *launcher) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*launcher) GetInterfaceName_() string { return "com.deepin.dde.daemon.Launcher" } // method GetAllItemInfos func (v *launcher) GoGetAllItemInfos(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAllItemInfos", flags, ch) } func (*launcher) StoreGetAllItemInfos(call *dbus.Call) (itemInfoList []ItemInfo, err error) { err = call.Store(&itemInfoList) return } func (v *launcher) GetAllItemInfos(flags dbus.Flags) (itemInfoList []ItemInfo, err error) { return v.StoreGetAllItemInfos( <-v.GoGetAllItemInfos(flags, make(chan *dbus.Call, 1)).Done) } // method GetAllNewInstalledApps func (v *launcher) GoGetAllNewInstalledApps(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAllNewInstalledApps", flags, ch) } func (*launcher) StoreGetAllNewInstalledApps(call *dbus.Call) (apps []string, err error) { err = call.Store(&apps) return } func (v *launcher) GetAllNewInstalledApps(flags dbus.Flags) (apps []string, err error) { return v.StoreGetAllNewInstalledApps( <-v.GoGetAllNewInstalledApps(flags, make(chan *dbus.Call, 1)).Done) } // method GetDisableScaling func (v *launcher) GoGetDisableScaling(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDisableScaling", flags, ch, id) } func (*launcher) StoreGetDisableScaling(call *dbus.Call) (value bool, err error) { err = call.Store(&value) return } func (v *launcher) GetDisableScaling(flags dbus.Flags, id string) (value bool, err error) { return v.StoreGetDisableScaling( <-v.GoGetDisableScaling(flags, make(chan *dbus.Call, 1), id).Done) } // method GetItemInfo func (v *launcher) GoGetItemInfo(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetItemInfo", flags, ch, id) } func (*launcher) StoreGetItemInfo(call *dbus.Call) (itemInfo ItemInfo, err error) { err = call.Store(&itemInfo) return } func (v *launcher) GetItemInfo(flags dbus.Flags, id string) (itemInfo ItemInfo, err error) { return v.StoreGetItemInfo( <-v.GoGetItemInfo(flags, make(chan *dbus.Call, 1), id).Done) } // method GetUseProxy func (v *launcher) GoGetUseProxy(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetUseProxy", flags, ch, id) } func (*launcher) StoreGetUseProxy(call *dbus.Call) (value bool, err error) { err = call.Store(&value) return } func (v *launcher) GetUseProxy(flags dbus.Flags, id string) (value bool, err error) { return v.StoreGetUseProxy( <-v.GoGetUseProxy(flags, make(chan *dbus.Call, 1), id).Done) } // method IsItemOnDesktop func (v *launcher) GoIsItemOnDesktop(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsItemOnDesktop", flags, ch, id) } func (*launcher) StoreIsItemOnDesktop(call *dbus.Call) (result bool, err error) { err = call.Store(&result) return } func (v *launcher) IsItemOnDesktop(flags dbus.Flags, id string) (result bool, err error) { return v.StoreIsItemOnDesktop( <-v.GoIsItemOnDesktop(flags, make(chan *dbus.Call, 1), id).Done) } // method MarkLaunched func (v *launcher) GoMarkLaunched(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".MarkLaunched", flags, ch, id) } func (v *launcher) MarkLaunched(flags dbus.Flags, id string) error { return (<-v.GoMarkLaunched(flags, make(chan *dbus.Call, 1), id).Done).Err } // method RequestRemoveFromDesktop func (v *launcher) GoRequestRemoveFromDesktop(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestRemoveFromDesktop", flags, ch, id) } func (*launcher) StoreRequestRemoveFromDesktop(call *dbus.Call) (ok bool, err error) { err = call.Store(&ok) return } func (v *launcher) RequestRemoveFromDesktop(flags dbus.Flags, id string) (ok bool, err error) { return v.StoreRequestRemoveFromDesktop( <-v.GoRequestRemoveFromDesktop(flags, make(chan *dbus.Call, 1), id).Done) } // method RequestSendToDesktop func (v *launcher) GoRequestSendToDesktop(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestSendToDesktop", flags, ch, id) } func (*launcher) StoreRequestSendToDesktop(call *dbus.Call) (ok bool, err error) { err = call.Store(&ok) return } func (v *launcher) RequestSendToDesktop(flags dbus.Flags, id string) (ok bool, err error) { return v.StoreRequestSendToDesktop( <-v.GoRequestSendToDesktop(flags, make(chan *dbus.Call, 1), id).Done) } // method RequestUninstall func (v *launcher) GoRequestUninstall(flags dbus.Flags, ch chan *dbus.Call, id string, purge bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestUninstall", flags, ch, id, purge) } func (v *launcher) RequestUninstall(flags dbus.Flags, id string, purge bool) error { return (<-v.GoRequestUninstall(flags, make(chan *dbus.Call, 1), id, purge).Done).Err } // method Search func (v *launcher) GoSearch(flags dbus.Flags, ch chan *dbus.Call, key string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Search", flags, ch, key) } func (v *launcher) Search(flags dbus.Flags, key string) error { return (<-v.GoSearch(flags, make(chan *dbus.Call, 1), key).Done).Err } // method SetDisableScaling func (v *launcher) GoSetDisableScaling(flags dbus.Flags, ch chan *dbus.Call, id string, value bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDisableScaling", flags, ch, id, value) } func (v *launcher) SetDisableScaling(flags dbus.Flags, id string, value bool) error { return (<-v.GoSetDisableScaling(flags, make(chan *dbus.Call, 1), id, value).Done).Err } // method SetUseProxy func (v *launcher) GoSetUseProxy(flags dbus.Flags, ch chan *dbus.Call, id string, value bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetUseProxy", flags, ch, id, value) } func (v *launcher) SetUseProxy(flags dbus.Flags, id string, value bool) error { return (<-v.GoSetUseProxy(flags, make(chan *dbus.Call, 1), id, value).Done).Err } // signal SearchDone func (v *launcher) ConnectSearchDone(cb func(apps []string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SearchDone", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SearchDone", } handlerFunc := func(sig *dbus.Signal) { var apps []string err := dbus.Store(sig.Body, &apps) if err == nil { cb(apps) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ItemChanged func (v *launcher) ConnectItemChanged(cb func(status string, itemInfo ItemInfo, categoryID int64)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ItemChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ItemChanged", } handlerFunc := func(sig *dbus.Signal) { var status string var itemInfo ItemInfo var categoryID int64 err := dbus.Store(sig.Body, &status, &itemInfo, &categoryID) if err == nil { cb(status, itemInfo, categoryID) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal NewAppLaunched func (v *launcher) ConnectNewAppLaunched(cb func(appID string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NewAppLaunched", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NewAppLaunched", } handlerFunc := func(sig *dbus.Signal) { var appID string err := dbus.Store(sig.Body, &appID) if err == nil { cb(appID) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal UninstallSuccess func (v *launcher) ConnectUninstallSuccess(cb func(appID string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "UninstallSuccess", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".UninstallSuccess", } handlerFunc := func(sig *dbus.Signal) { var appID string err := dbus.Store(sig.Body, &appID) if err == nil { cb(appID) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal UninstallFailed func (v *launcher) ConnectUninstallFailed(cb func(appId string, errMsg string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "UninstallFailed", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".UninstallFailed", } handlerFunc := func(sig *dbus.Signal) { var appId string var errMsg string err := dbus.Store(sig.Body, &appId, &errMsg) if err == nil { cb(appId, errMsg) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Fullscreen b func (v *launcher) Fullscreen() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Fullscreen", } } // property DisplayMode i func (v *launcher) DisplayMode() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "DisplayMode", } } go-dbus-factory-1.9.6/com.deepin.dde.daemon.launcher/config.json000066400000000000000000000014121403054572700245170ustar00rootroot00000000000000{ "Service": "com.deepin.dde.daemon.Launcher", "Objects": [ { "Type": "Launcher", "Path": "/com/deepin/dde/daemon/Launcher", "Interfaces": [ { "Name": "com.deepin.dde.daemon.Launcher", "Type": "launcher", "Fixes": { "m/GetAllItemInfos": [ { "Name": "itemInfoList", "Type": "[]ItemInfo" } ], "m/GetItemInfo": [ { "Name": "itemInfo", "Type": "ItemInfo" } ], "s/ItemChanged": [ { "Name": "itemInfo", "Type": "ItemInfo" } ] } } ] } ] } go-dbus-factory-1.9.6/com.deepin.dde.daemon.launcher/manual.go000066400000000000000000000002551403054572700241670ustar00rootroot00000000000000package launcher type ItemInfo struct { Path string Name string ID string Icon string CategoryID int64 TimeInstalled int64 } go-dbus-factory-1.9.6/com.deepin.dde.launcher/000077500000000000000000000000001403054572700211175ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.dde.launcher/Launcher.xml000066400000000000000000000043761403054572700234140ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.dde.launcher/auto.go000066400000000000000000000114101403054572700224130ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.dde.launcher"; DO NOT EDIT. package launcher import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Launcher struct { launcher // interface com.deepin.dde.Launcher proxy.Object } func NewLauncher(conn *dbus.Conn) *Launcher { obj := new(Launcher) obj.Object.Init_(conn, "com.deepin.dde.Launcher", "/com/deepin/dde/Launcher") return obj } type launcher struct{} func (v *launcher) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*launcher) GetInterfaceName_() string { return "com.deepin.dde.Launcher" } // method Exit func (v *launcher) GoExit(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Exit", flags, ch) } func (v *launcher) Exit(flags dbus.Flags) error { return (<-v.GoExit(flags, make(chan *dbus.Call, 1)).Done).Err } // method Hide func (v *launcher) GoHide(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Hide", flags, ch) } func (v *launcher) Hide(flags dbus.Flags) error { return (<-v.GoHide(flags, make(chan *dbus.Call, 1)).Done).Err } // method Show func (v *launcher) GoShow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Show", flags, ch) } func (v *launcher) Show(flags dbus.Flags) error { return (<-v.GoShow(flags, make(chan *dbus.Call, 1)).Done).Err } // method ShowByMode func (v *launcher) GoShowByMode(flags dbus.Flags, ch chan *dbus.Call, in0 int64) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ShowByMode", flags, ch, in0) } func (v *launcher) ShowByMode(flags dbus.Flags, in0 int64) error { return (<-v.GoShowByMode(flags, make(chan *dbus.Call, 1), in0).Done).Err } // method UninstallApp func (v *launcher) GoUninstallApp(flags dbus.Flags, ch chan *dbus.Call, appKey string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UninstallApp", flags, ch, appKey) } func (v *launcher) UninstallApp(flags dbus.Flags, appKey string) error { return (<-v.GoUninstallApp(flags, make(chan *dbus.Call, 1), appKey).Done).Err } // method Toggle func (v *launcher) GoToggle(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Toggle", flags, ch) } func (v *launcher) Toggle(flags dbus.Flags) error { return (<-v.GoToggle(flags, make(chan *dbus.Call, 1)).Done).Err } // method IsVisible func (v *launcher) GoIsVisible(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsVisible", flags, ch) } func (*launcher) StoreIsVisible(call *dbus.Call) (arg0 bool, err error) { err = call.Store(&arg0) return } func (v *launcher) IsVisible(flags dbus.Flags) (arg0 bool, err error) { return v.StoreIsVisible( <-v.GoIsVisible(flags, make(chan *dbus.Call, 1)).Done) } // signal Closed func (v *launcher) ConnectClosed(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Closed", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Closed", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Shown func (v *launcher) ConnectShown(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Shown", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Shown", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal VisibleChanged func (v *launcher) ConnectVisibleChanged(cb func(visible bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VisibleChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VisibleChanged", } handlerFunc := func(sig *dbus.Signal) { var visible bool err := dbus.Store(sig.Body, &visible) if err == nil { cb(visible) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Visible b func (v *launcher) Visible() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Visible", } } go-dbus-factory-1.9.6/com.deepin.dde.launcher/config.json000066400000000000000000000004101403054572700232520ustar00rootroot00000000000000{ "Service":"com.deepin.dde.Launcher", "Objects": [ { "Type": "Launcher", "Path": "/com/deepin/dde/Launcher", "Interfaces": [ { "Name":"com.deepin.dde.Launcher", "Type":"launcher" } ] } ] } go-dbus-factory-1.9.6/com.deepin.dde.lockfront/000077500000000000000000000000001403054572700213175ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.dde.lockfront/LockFront.xml000066400000000000000000000044121403054572700237430ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.dde.lockfront/auto.go000066400000000000000000000056651403054572700226320ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.dde.lockfront"; DO NOT EDIT. package lockfront import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type LockFront struct { lockfront // interface com.deepin.dde.lockFront proxy.Object } func NewLockFront(conn *dbus.Conn) *LockFront { obj := new(LockFront) obj.Object.Init_(conn, "com.deepin.dde.lockFront", "/com/deepin/dde/lockFront") return obj } type lockfront struct{} func (v *lockfront) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*lockfront) GetInterfaceName_() string { return "com.deepin.dde.lockFront" } // method Show func (v *lockfront) GoShow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Show", flags, ch) } func (v *lockfront) Show(flags dbus.Flags) error { return (<-v.GoShow(flags, make(chan *dbus.Call, 1)).Done).Err } // method ShowUserList func (v *lockfront) GoShowUserList(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ShowUserList", flags, ch) } func (v *lockfront) ShowUserList(flags dbus.Flags) error { return (<-v.GoShowUserList(flags, make(chan *dbus.Call, 1)).Done).Err } // method ShowAuth func (v *lockfront) GoShowAuth(flags dbus.Flags, ch chan *dbus.Call, active bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ShowAuth", flags, ch, active) } func (v *lockfront) ShowAuth(flags dbus.Flags, active bool) error { return (<-v.GoShowAuth(flags, make(chan *dbus.Call, 1), active).Done).Err } // method Suspend func (v *lockfront) GoSuspend(flags dbus.Flags, ch chan *dbus.Call, enable bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Suspend", flags, ch, enable) } func (v *lockfront) Suspend(flags dbus.Flags, enable bool) error { return (<-v.GoSuspend(flags, make(chan *dbus.Call, 1), enable).Done).Err } // method Hibernate func (v *lockfront) GoHibernate(flags dbus.Flags, ch chan *dbus.Call, enable bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Hibernate", flags, ch, enable) } func (v *lockfront) Hibernate(flags dbus.Flags, enable bool) error { return (<-v.GoHibernate(flags, make(chan *dbus.Call, 1), enable).Done).Err } // signal ChangKey func (v *lockfront) ConnectChangKey(cb func(keyEvent string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ChangKey", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ChangKey", } handlerFunc := func(sig *dbus.Signal) { var keyEvent string err := dbus.Store(sig.Body, &keyEvent) if err == nil { cb(keyEvent) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.deepin.dde.lockfront/config.json000066400000000000000000000004541403054572700234620ustar00rootroot00000000000000 { "Service":"com.deepin.dde.lockFront", "Objects": [ { "Type": "LockFront", "Path": "/com/deepin/dde/lockFront", "Interfaces": [ { "Name":"com.deepin.dde.lockFront", "Type":"lockfront" } ] } ] } go-dbus-factory-1.9.6/com.deepin.dde.notification/000077500000000000000000000000001403054572700220045ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.dde.notification/Notification.xml000066400000000000000000000143251403054572700251610ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.dde.notification/auto.go000066400000000000000000000432201403054572700233040ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.dde.notification"; DO NOT EDIT. package notification import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Notification struct { notification // interface com.deepin.dde.Notification proxy.Object } func NewNotification(conn *dbus.Conn) *Notification { obj := new(Notification) obj.Object.Init_(conn, "com.deepin.dde.osd", "/com/deepin/dde/Notification") return obj } type notification struct{} func (v *notification) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*notification) GetInterfaceName_() string { return "com.deepin.dde.Notification" } // method CloseNotification func (v *notification) GoCloseNotification(flags dbus.Flags, ch chan *dbus.Call, arg0 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CloseNotification", flags, ch, arg0) } func (v *notification) CloseNotification(flags dbus.Flags, arg0 uint32) error { return (<-v.GoCloseNotification(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method GetCapbilities func (v *notification) GoGetCapbilities(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetCapbilities", flags, ch) } func (*notification) StoreGetCapbilities(call *dbus.Call) (arg0 []string, err error) { err = call.Store(&arg0) return } func (v *notification) GetCapbilities(flags dbus.Flags) (arg0 []string, err error) { return v.StoreGetCapbilities( <-v.GoGetCapbilities(flags, make(chan *dbus.Call, 1)).Done) } // method GetServerInformation func (v *notification) GoGetServerInformation(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetServerInformation", flags, ch) } func (*notification) StoreGetServerInformation(call *dbus.Call) (arg0 string, arg1 string, arg2 string, arg3 string, err error) { err = call.Store(&arg0, &arg1, &arg2, &arg3) return } func (v *notification) GetServerInformation(flags dbus.Flags) (arg0 string, arg1 string, arg2 string, arg3 string, err error) { return v.StoreGetServerInformation( <-v.GoGetServerInformation(flags, make(chan *dbus.Call, 1)).Done) } // method Notify func (v *notification) GoNotify(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 uint32, arg2 string, arg3 string, arg4 string, arg5 []string, arg6 map[string]dbus.Variant, arg7 int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Notify", flags, ch, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) } func (*notification) StoreNotify(call *dbus.Call) (arg8 uint32, err error) { err = call.Store(&arg8) return } func (v *notification) Notify(flags dbus.Flags, arg0 string, arg1 uint32, arg2 string, arg3 string, arg4 string, arg5 []string, arg6 map[string]dbus.Variant, arg7 int32) (arg8 uint32, err error) { return v.StoreNotify( <-v.GoNotify(flags, make(chan *dbus.Call, 1), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7).Done) } // method GetAllRecords func (v *notification) GoGetAllRecords(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAllRecords", flags, ch) } func (*notification) StoreGetAllRecords(call *dbus.Call) (arg0 string, err error) { err = call.Store(&arg0) return } func (v *notification) GetAllRecords(flags dbus.Flags) (arg0 string, err error) { return v.StoreGetAllRecords( <-v.GoGetAllRecords(flags, make(chan *dbus.Call, 1)).Done) } // method GetRecordById func (v *notification) GoGetRecordById(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetRecordById", flags, ch, arg0) } func (*notification) StoreGetRecordById(call *dbus.Call) (arg1 string, err error) { err = call.Store(&arg1) return } func (v *notification) GetRecordById(flags dbus.Flags, arg0 string) (arg1 string, err error) { return v.StoreGetRecordById( <-v.GoGetRecordById(flags, make(chan *dbus.Call, 1), arg0).Done) } // method GetRecordsFromId func (v *notification) GoGetRecordsFromId(flags dbus.Flags, ch chan *dbus.Call, arg0 int32, arg1 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetRecordsFromId", flags, ch, arg0, arg1) } func (*notification) StoreGetRecordsFromId(call *dbus.Call) (arg2 string, err error) { err = call.Store(&arg2) return } func (v *notification) GetRecordsFromId(flags dbus.Flags, arg0 int32, arg1 string) (arg2 string, err error) { return v.StoreGetRecordsFromId( <-v.GoGetRecordsFromId(flags, make(chan *dbus.Call, 1), arg0, arg1).Done) } // method RemoveRecord func (v *notification) GoRemoveRecord(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemoveRecord", flags, ch, arg0) } func (v *notification) RemoveRecord(flags dbus.Flags, arg0 string) error { return (<-v.GoRemoveRecord(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method ClearRecords func (v *notification) GoClearRecords(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ClearRecords", flags, ch) } func (v *notification) ClearRecords(flags dbus.Flags) error { return (<-v.GoClearRecords(flags, make(chan *dbus.Call, 1)).Done).Err } // method getAppSetting func (v *notification) GoGetAppSetting(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".getAppSetting", flags, ch, arg0) } func (*notification) StoreGetAppSetting(call *dbus.Call) (arg1 string, err error) { err = call.Store(&arg1) return } func (v *notification) GetAppSetting(flags dbus.Flags, arg0 string) (arg1 string, err error) { return v.StoreGetAppSetting( <-v.GoGetAppSetting(flags, make(chan *dbus.Call, 1), arg0).Done) } // method Toggle func (v *notification) GoToggle(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Toggle", flags, ch) } func (v *notification) Toggle(flags dbus.Flags) error { return (<-v.GoToggle(flags, make(chan *dbus.Call, 1)).Done).Err } // method Show func (v *notification) GoShow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Show", flags, ch) } func (v *notification) Show(flags dbus.Flags) error { return (<-v.GoShow(flags, make(chan *dbus.Call, 1)).Done).Err } // method Hide func (v *notification) GoHide(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Hide", flags, ch) } func (v *notification) Hide(flags dbus.Flags) error { return (<-v.GoHide(flags, make(chan *dbus.Call, 1)).Done).Err } // method recordCount func (v *notification) GoRecordCount(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".recordCount", flags, ch) } func (*notification) StoreRecordCount(call *dbus.Call) (arg0 uint32, err error) { err = call.Store(&arg0) return } func (v *notification) RecordCount(flags dbus.Flags) (arg0 uint32, err error) { return v.StoreRecordCount( <-v.GoRecordCount(flags, make(chan *dbus.Call, 1)).Done) } // method GetAppList func (v *notification) GoGetAppList(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAppList", flags, ch) } func (*notification) StoreGetAppList(call *dbus.Call) (arg0 []string, err error) { err = call.Store(&arg0) return } func (v *notification) GetAppList(flags dbus.Flags) (arg0 []string, err error) { return v.StoreGetAppList( <-v.GoGetAppList(flags, make(chan *dbus.Call, 1)).Done) } // method GetAppInfo func (v *notification) GoGetAppInfo(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAppInfo", flags, ch, arg0, arg1) } func (*notification) StoreGetAppInfo(call *dbus.Call) (arg2 dbus.Variant, err error) { err = call.Store(&arg2) return } func (v *notification) GetAppInfo(flags dbus.Flags, arg0 string, arg1 uint32) (arg2 dbus.Variant, err error) { return v.StoreGetAppInfo( <-v.GoGetAppInfo(flags, make(chan *dbus.Call, 1), arg0, arg1).Done) } // method GetSystemInfo func (v *notification) GoGetSystemInfo(flags dbus.Flags, ch chan *dbus.Call, arg0 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetSystemInfo", flags, ch, arg0) } func (*notification) StoreGetSystemInfo(call *dbus.Call) (arg1 dbus.Variant, err error) { err = call.Store(&arg1) return } func (v *notification) GetSystemInfo(flags dbus.Flags, arg0 uint32) (arg1 dbus.Variant, err error) { return v.StoreGetSystemInfo( <-v.GoGetSystemInfo(flags, make(chan *dbus.Call, 1), arg0).Done) } // method SetAppInfo func (v *notification) GoSetAppInfo(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 uint32, arg2 dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetAppInfo", flags, ch, arg0, arg1, arg2) } func (v *notification) SetAppInfo(flags dbus.Flags, arg0 string, arg1 uint32, arg2 dbus.Variant) error { return (<-v.GoSetAppInfo(flags, make(chan *dbus.Call, 1), arg0, arg1, arg2).Done).Err } // method SetSystemInfo func (v *notification) GoSetSystemInfo(flags dbus.Flags, ch chan *dbus.Call, arg0 uint32, arg1 dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetSystemInfo", flags, ch, arg0, arg1) } func (v *notification) SetSystemInfo(flags dbus.Flags, arg0 uint32, arg1 dbus.Variant) error { return (<-v.GoSetSystemInfo(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method setAppSetting func (v *notification) GoSetAppSetting(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".setAppSetting", flags, ch, arg0) } func (v *notification) SetAppSetting(flags dbus.Flags, arg0 string) error { return (<-v.GoSetAppSetting(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // signal NotificationClosed func (v *notification) ConnectNotificationClosed(cb func(arg0 uint32, arg1 uint32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NotificationClosed", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NotificationClosed", } handlerFunc := func(sig *dbus.Signal) { var arg0 uint32 var arg1 uint32 err := dbus.Store(sig.Body, &arg0, &arg1) if err == nil { cb(arg0, arg1) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ActionInvoked func (v *notification) ConnectActionInvoked(cb func(arg0 uint32, arg1 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ActionInvoked", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ActionInvoked", } handlerFunc := func(sig *dbus.Signal) { var arg0 uint32 var arg1 string err := dbus.Store(sig.Body, &arg0, &arg1) if err == nil { cb(arg0, arg1) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal RecordAdded func (v *notification) ConnectRecordAdded(cb func(arg0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "RecordAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".RecordAdded", } handlerFunc := func(sig *dbus.Signal) { var arg0 string err := dbus.Store(sig.Body, &arg0) if err == nil { cb(arg0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal AppInfoChanged func (v *notification) ConnectAppInfoChanged(cb func(arg0 string, arg1 uint32, arg2 dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "AppInfoChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".AppInfoChanged", } handlerFunc := func(sig *dbus.Signal) { var arg0 string var arg1 uint32 var arg2 dbus.Variant err := dbus.Store(sig.Body, &arg0, &arg1, &arg2) if err == nil { cb(arg0, arg1, arg2) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal SystemInfoChanged func (v *notification) ConnectSystemInfoChanged(cb func(arg0 uint32, arg1 dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SystemInfoChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SystemInfoChanged", } handlerFunc := func(sig *dbus.Signal) { var arg0 uint32 var arg1 dbus.Variant err := dbus.Store(sig.Body, &arg0, &arg1) if err == nil { cb(arg0, arg1) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal AppAddedSignal func (v *notification) ConnectAppAddedSignal(cb func(arg0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "AppAddedSignal", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".AppAddedSignal", } handlerFunc := func(sig *dbus.Signal) { var arg0 string err := dbus.Store(sig.Body, &arg0) if err == nil { cb(arg0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal AppRemovedSignal func (v *notification) ConnectAppRemovedSignal(cb func(arg0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "AppRemovedSignal", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".AppRemovedSignal", } handlerFunc := func(sig *dbus.Signal) { var arg0 string err := dbus.Store(sig.Body, &arg0) if err == nil { cb(arg0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal appRemoved func (v *notification) ConnectAppRemoved(cb func(arg0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "appRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".appRemoved", } handlerFunc := func(sig *dbus.Signal) { var arg0 string err := dbus.Store(sig.Body, &arg0) if err == nil { cb(arg0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal appAdded func (v *notification) ConnectAppAdded(cb func(arg0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "appAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".appAdded", } handlerFunc := func(sig *dbus.Signal) { var arg0 string err := dbus.Store(sig.Body, &arg0) if err == nil { cb(arg0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal appSettingChanged func (v *notification) ConnectAppSettingChanged(cb func(arg0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "appSettingChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".appSettingChanged", } handlerFunc := func(sig *dbus.Signal) { var arg0 string err := dbus.Store(sig.Body, &arg0) if err == nil { cb(arg0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal systemSettingChanged func (v *notification) ConnectSystemSettingChanged(cb func(arg0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "systemSettingChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".systemSettingChanged", } handlerFunc := func(sig *dbus.Signal) { var arg0 string err := dbus.Store(sig.Body, &arg0) if err == nil { cb(arg0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property allSetting s func (v *notification) AllSetting() proxy.PropString { return proxy.PropString{ Impl: v, Name: "allSetting", } } // property systemSetting s func (v *notification) SystemSetting() proxy.PropString { return proxy.PropString{ Impl: v, Name: "systemSetting", } } go-dbus-factory-1.9.6/com.deepin.dde.notification/config.json000066400000000000000000000004261403054572700241460ustar00rootroot00000000000000{ "Service": "com.deepin.dde.osd", "Objects": [ { "Type": "Notification", "Path": "/com/deepin/dde/Notification", "Interfaces": [ { "Name": "com.deepin.dde.Notification", "Type": "notification" } ] } ] } go-dbus-factory-1.9.6/com.deepin.dde.osd/000077500000000000000000000000001403054572700201035ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.dde.osd/OSD.xml000066400000000000000000000033411403054572700212530ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.dde.osd/auto.go000066400000000000000000000015341403054572700214050ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.dde.osd"; DO NOT EDIT. package osd import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type OSD struct { osd // interface com.deepin.dde.osd proxy.Object } func NewOSD(conn *dbus.Conn) *OSD { obj := new(OSD) obj.Object.Init_(conn, "com.deepin.dde.osd", "/") return obj } type osd struct{} func (v *osd) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*osd) GetInterfaceName_() string { return "com.deepin.dde.osd" } // method ShowOSD func (v *osd) GoShowOSD(flags dbus.Flags, ch chan *dbus.Call, osd string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ShowOSD", flags, ch, osd) } func (v *osd) ShowOSD(flags dbus.Flags, osd string) error { return (<-v.GoShowOSD(flags, make(chan *dbus.Call, 1), osd).Done).Err } go-dbus-factory-1.9.6/com.deepin.dde.osd/config.json000066400000000000000000000003351403054572700222440ustar00rootroot00000000000000{ "Service":"com.deepin.dde.osd", "Objects": [ { "Type": "OSD", "Path": "/", "Interfaces": [ { "Name":"com.deepin.dde.osd", "Type":"osd" } ] } ] } go-dbus-factory-1.9.6/com.deepin.dde.shutdownfront/000077500000000000000000000000001403054572700222425ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.dde.shutdownfront/ShutdownFront.xml000066400000000000000000000042631403054572700256150ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.dde.shutdownfront/auto.go000066400000000000000000000074231403054572700235470ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.dde.shutdownfront"; DO NOT EDIT. package shutdownfront import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type ShutdownFront struct { shutdownfront // interface com.deepin.dde.shutdownFront proxy.Object } func NewShutdownFront(conn *dbus.Conn) *ShutdownFront { obj := new(ShutdownFront) obj.Object.Init_(conn, "com.deepin.dde.shutdownFront", "/com/deepin/dde/shutdownFront") return obj } type shutdownfront struct{} func (v *shutdownfront) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*shutdownfront) GetInterfaceName_() string { return "com.deepin.dde.shutdownFront" } // method Hibernate func (v *shutdownfront) GoHibernate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Hibernate", flags, ch) } func (v *shutdownfront) Hibernate(flags dbus.Flags) error { return (<-v.GoHibernate(flags, make(chan *dbus.Call, 1)).Done).Err } // method Lock func (v *shutdownfront) GoLock(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Lock", flags, ch) } func (v *shutdownfront) Lock(flags dbus.Flags) error { return (<-v.GoLock(flags, make(chan *dbus.Call, 1)).Done).Err } // method Logout func (v *shutdownfront) GoLogout(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Logout", flags, ch) } func (v *shutdownfront) Logout(flags dbus.Flags) error { return (<-v.GoLogout(flags, make(chan *dbus.Call, 1)).Done).Err } // method Restart func (v *shutdownfront) GoRestart(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Restart", flags, ch) } func (v *shutdownfront) Restart(flags dbus.Flags) error { return (<-v.GoRestart(flags, make(chan *dbus.Call, 1)).Done).Err } // method Show func (v *shutdownfront) GoShow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Show", flags, ch) } func (v *shutdownfront) Show(flags dbus.Flags) error { return (<-v.GoShow(flags, make(chan *dbus.Call, 1)).Done).Err } // method Shutdown func (v *shutdownfront) GoShutdown(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Shutdown", flags, ch) } func (v *shutdownfront) Shutdown(flags dbus.Flags) error { return (<-v.GoShutdown(flags, make(chan *dbus.Call, 1)).Done).Err } // method Suspend func (v *shutdownfront) GoSuspend(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Suspend", flags, ch) } func (v *shutdownfront) Suspend(flags dbus.Flags) error { return (<-v.GoSuspend(flags, make(chan *dbus.Call, 1)).Done).Err } // method SwitchUser func (v *shutdownfront) GoSwitchUser(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SwitchUser", flags, ch) } func (v *shutdownfront) SwitchUser(flags dbus.Flags) error { return (<-v.GoSwitchUser(flags, make(chan *dbus.Call, 1)).Done).Err } // signal ChangKey func (v *shutdownfront) ConnectChangKey(cb func(keyEvent string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ChangKey", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ChangKey", } handlerFunc := func(sig *dbus.Signal) { var keyEvent string err := dbus.Store(sig.Body, &keyEvent) if err == nil { cb(keyEvent) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.deepin.dde.shutdownfront/config.json000066400000000000000000000004411403054572700244010ustar00rootroot00000000000000{ "Service":"com.deepin.dde.shutdownFront", "Objects": [ { "Type": "ShutdownFront", "Path": "/com/deepin/dde/shutdownFront", "Interfaces": [ { "Name":"com.deepin.dde.shutdownFront", "Type":"shutdownfront" } ] } ] } go-dbus-factory-1.9.6/com.deepin.lastore/000077500000000000000000000000001403054572700202345ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.lastore/Job.xml000066400000000000000000000043641403054572700214770ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.lastore/Lastore.xml000066400000000000000000000141161403054572700223720ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.lastore/auto.go000066400000000000000000000377231403054572700215470ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.lastore"; DO NOT EDIT. package lastore import ( "errors" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type Lastore struct { manager // interface com.deepin.lastore.Manager updater // interface com.deepin.lastore.Updater proxy.Object } func NewLastore(conn *dbus.Conn) *Lastore { obj := new(Lastore) obj.Object.Init_(conn, "com.deepin.lastore", "/com/deepin/lastore") return obj } func (obj *Lastore) Manager() *manager { return &obj.manager } type manager struct{} func (v *manager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*manager) GetInterfaceName_() string { return "com.deepin.lastore.Manager" } // method CleanArchives func (v *manager) GoCleanArchives(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CleanArchives", flags, ch) } func (*manager) StoreCleanArchives(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) CleanArchives(flags dbus.Flags) (job dbus.ObjectPath, err error) { return v.StoreCleanArchives( <-v.GoCleanArchives(flags, make(chan *dbus.Call, 1)).Done) } // method CleanJob func (v *manager) GoCleanJob(flags dbus.Flags, ch chan *dbus.Call, jobId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CleanJob", flags, ch, jobId) } func (v *manager) CleanJob(flags dbus.Flags, jobId string) error { return (<-v.GoCleanJob(flags, make(chan *dbus.Call, 1), jobId).Done).Err } // method DistUpgrade func (v *manager) GoDistUpgrade(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DistUpgrade", flags, ch) } func (*manager) StoreDistUpgrade(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) DistUpgrade(flags dbus.Flags) (job dbus.ObjectPath, err error) { return v.StoreDistUpgrade( <-v.GoDistUpgrade(flags, make(chan *dbus.Call, 1)).Done) } // method FixError func (v *manager) GoFixError(flags dbus.Flags, ch chan *dbus.Call, errType string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FixError", flags, ch, errType) } func (*manager) StoreFixError(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) FixError(flags dbus.Flags, errType string) (job dbus.ObjectPath, err error) { return v.StoreFixError( <-v.GoFixError(flags, make(chan *dbus.Call, 1), errType).Done) } // method InstallPackage func (v *manager) GoInstallPackage(flags dbus.Flags, ch chan *dbus.Call, jobName string, packages string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".InstallPackage", flags, ch, jobName, packages) } func (*manager) StoreInstallPackage(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) InstallPackage(flags dbus.Flags, jobName string, packages string) (job dbus.ObjectPath, err error) { return v.StoreInstallPackage( <-v.GoInstallPackage(flags, make(chan *dbus.Call, 1), jobName, packages).Done) } // method PackageDesktopPath func (v *manager) GoPackageDesktopPath(flags dbus.Flags, ch chan *dbus.Call, pkgId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PackageDesktopPath", flags, ch, pkgId) } func (*manager) StorePackageDesktopPath(call *dbus.Call) (desktopPath string, err error) { err = call.Store(&desktopPath) return } func (v *manager) PackageDesktopPath(flags dbus.Flags, pkgId string) (desktopPath string, err error) { return v.StorePackageDesktopPath( <-v.GoPackageDesktopPath(flags, make(chan *dbus.Call, 1), pkgId).Done) } // method PackageExists func (v *manager) GoPackageExists(flags dbus.Flags, ch chan *dbus.Call, pkgId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PackageExists", flags, ch, pkgId) } func (*manager) StorePackageExists(call *dbus.Call) (exist bool, err error) { err = call.Store(&exist) return } func (v *manager) PackageExists(flags dbus.Flags, pkgId string) (exist bool, err error) { return v.StorePackageExists( <-v.GoPackageExists(flags, make(chan *dbus.Call, 1), pkgId).Done) } // method PackageInstallable func (v *manager) GoPackageInstallable(flags dbus.Flags, ch chan *dbus.Call, pkgId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PackageInstallable", flags, ch, pkgId) } func (*manager) StorePackageInstallable(call *dbus.Call) (installable bool, err error) { err = call.Store(&installable) return } func (v *manager) PackageInstallable(flags dbus.Flags, pkgId string) (installable bool, err error) { return v.StorePackageInstallable( <-v.GoPackageInstallable(flags, make(chan *dbus.Call, 1), pkgId).Done) } // method PackagesDownloadSize func (v *manager) GoPackagesDownloadSize(flags dbus.Flags, ch chan *dbus.Call, packages []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PackagesDownloadSize", flags, ch, packages) } func (*manager) StorePackagesDownloadSize(call *dbus.Call) (size int64, err error) { err = call.Store(&size) return } func (v *manager) PackagesDownloadSize(flags dbus.Flags, packages []string) (size int64, err error) { return v.StorePackagesDownloadSize( <-v.GoPackagesDownloadSize(flags, make(chan *dbus.Call, 1), packages).Done) } // method PauseJob func (v *manager) GoPauseJob(flags dbus.Flags, ch chan *dbus.Call, jobId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PauseJob", flags, ch, jobId) } func (v *manager) PauseJob(flags dbus.Flags, jobId string) error { return (<-v.GoPauseJob(flags, make(chan *dbus.Call, 1), jobId).Done).Err } // method PrepareDistUpgrade func (v *manager) GoPrepareDistUpgrade(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PrepareDistUpgrade", flags, ch) } func (*manager) StorePrepareDistUpgrade(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) PrepareDistUpgrade(flags dbus.Flags) (job dbus.ObjectPath, err error) { return v.StorePrepareDistUpgrade( <-v.GoPrepareDistUpgrade(flags, make(chan *dbus.Call, 1)).Done) } // method RemovePackage func (v *manager) GoRemovePackage(flags dbus.Flags, ch chan *dbus.Call, jobName string, packages string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemovePackage", flags, ch, jobName, packages) } func (*manager) StoreRemovePackage(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) RemovePackage(flags dbus.Flags, jobName string, packages string) (job dbus.ObjectPath, err error) { return v.StoreRemovePackage( <-v.GoRemovePackage(flags, make(chan *dbus.Call, 1), jobName, packages).Done) } // method SetAutoClean func (v *manager) GoSetAutoClean(flags dbus.Flags, ch chan *dbus.Call, enable bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetAutoClean", flags, ch, enable) } func (v *manager) SetAutoClean(flags dbus.Flags, enable bool) error { return (<-v.GoSetAutoClean(flags, make(chan *dbus.Call, 1), enable).Done).Err } // method SetLogger func (v *manager) GoSetLogger(flags dbus.Flags, ch chan *dbus.Call, levels string, format string, output string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLogger", flags, ch, levels, format, output) } func (v *manager) SetLogger(flags dbus.Flags, levels string, format string, output string) error { return (<-v.GoSetLogger(flags, make(chan *dbus.Call, 1), levels, format, output).Done).Err } // method SetRegion func (v *manager) GoSetRegion(flags dbus.Flags, ch chan *dbus.Call, region string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetRegion", flags, ch, region) } func (v *manager) SetRegion(flags dbus.Flags, region string) error { return (<-v.GoSetRegion(flags, make(chan *dbus.Call, 1), region).Done).Err } // method StartJob func (v *manager) GoStartJob(flags dbus.Flags, ch chan *dbus.Call, jobId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StartJob", flags, ch, jobId) } func (v *manager) StartJob(flags dbus.Flags, jobId string) error { return (<-v.GoStartJob(flags, make(chan *dbus.Call, 1), jobId).Done).Err } // method UpdatePackage func (v *manager) GoUpdatePackage(flags dbus.Flags, ch chan *dbus.Call, jobName string, packages string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UpdatePackage", flags, ch, jobName, packages) } func (*manager) StoreUpdatePackage(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) UpdatePackage(flags dbus.Flags, jobName string, packages string) (job dbus.ObjectPath, err error) { return v.StoreUpdatePackage( <-v.GoUpdatePackage(flags, make(chan *dbus.Call, 1), jobName, packages).Done) } // method UpdateSource func (v *manager) GoUpdateSource(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UpdateSource", flags, ch) } func (*manager) StoreUpdateSource(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) UpdateSource(flags dbus.Flags) (job dbus.ObjectPath, err error) { return v.StoreUpdateSource( <-v.GoUpdateSource(flags, make(chan *dbus.Call, 1)).Done) } // property JobList ao func (v *manager) JobList() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "JobList", } } // property SystemArchitectures as func (v *manager) SystemArchitectures() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "SystemArchitectures", } } // property UpgradableApps as func (v *manager) UpgradableApps() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "UpgradableApps", } } // property SystemOnChanging b func (v *manager) SystemOnChanging() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SystemOnChanging", } } // property AutoClean b func (v *manager) AutoClean() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "AutoClean", } } func (obj *Lastore) Updater() *updater { return &obj.updater } type updater struct{} func (v *updater) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*updater) GetInterfaceName_() string { return "com.deepin.lastore.Updater" } // method ApplicationUpdateInfos func (v *updater) GoApplicationUpdateInfos(flags dbus.Flags, ch chan *dbus.Call, lang string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ApplicationUpdateInfos", flags, ch, lang) } func (*updater) StoreApplicationUpdateInfos(call *dbus.Call) (updateInfos [][]interface{}, err error) { err = call.Store(&updateInfos) return } func (v *updater) ApplicationUpdateInfos(flags dbus.Flags, lang string) (updateInfos [][]interface{}, err error) { return v.StoreApplicationUpdateInfos( <-v.GoApplicationUpdateInfos(flags, make(chan *dbus.Call, 1), lang).Done) } // method ListMirrorSources func (v *updater) GoListMirrorSources(flags dbus.Flags, ch chan *dbus.Call, lang string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListMirrorSources", flags, ch, lang) } func (*updater) StoreListMirrorSources(call *dbus.Call) (mirrorSources [][]interface{}, err error) { err = call.Store(&mirrorSources) return } func (v *updater) ListMirrorSources(flags dbus.Flags, lang string) (mirrorSources [][]interface{}, err error) { return v.StoreListMirrorSources( <-v.GoListMirrorSources(flags, make(chan *dbus.Call, 1), lang).Done) } // method RestoreSystemSource func (v *updater) GoRestoreSystemSource(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RestoreSystemSource", flags, ch) } func (v *updater) RestoreSystemSource(flags dbus.Flags) error { return (<-v.GoRestoreSystemSource(flags, make(chan *dbus.Call, 1)).Done).Err } // method SetAutoCheckUpdates func (v *updater) GoSetAutoCheckUpdates(flags dbus.Flags, ch chan *dbus.Call, enable bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetAutoCheckUpdates", flags, ch, enable) } func (v *updater) SetAutoCheckUpdates(flags dbus.Flags, enable bool) error { return (<-v.GoSetAutoCheckUpdates(flags, make(chan *dbus.Call, 1), enable).Done).Err } // method SetAutoDownloadUpdates func (v *updater) GoSetAutoDownloadUpdates(flags dbus.Flags, ch chan *dbus.Call, enable bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetAutoDownloadUpdates", flags, ch, enable) } func (v *updater) SetAutoDownloadUpdates(flags dbus.Flags, enable bool) error { return (<-v.GoSetAutoDownloadUpdates(flags, make(chan *dbus.Call, 1), enable).Done).Err } // method SetMirrorSource func (v *updater) GoSetMirrorSource(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetMirrorSource", flags, ch, id) } func (v *updater) SetMirrorSource(flags dbus.Flags, id string) error { return (<-v.GoSetMirrorSource(flags, make(chan *dbus.Call, 1), id).Done).Err } // property AutoCheckUpdates b func (v *updater) AutoCheckUpdates() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "AutoCheckUpdates", } } // property AutoDownloadUpdates b func (v *updater) AutoDownloadUpdates() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "AutoDownloadUpdates", } } // property MirrorSource s func (v *updater) MirrorSource() proxy.PropString { return proxy.PropString{ Impl: v, Name: "MirrorSource", } } // property UpdatableApps as func (v *updater) UpdatableApps() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "UpdatableApps", } } // property UpdatablePackages as func (v *updater) UpdatablePackages() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "UpdatablePackages", } } type Job struct { job // interface com.deepin.lastore.Job proxy.Object } func NewJob(conn *dbus.Conn, path dbus.ObjectPath) (*Job, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Job) obj.Object.Init_(conn, "com.deepin.lastore", path) return obj, nil } type job struct{} func (v *job) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*job) GetInterfaceName_() string { return "com.deepin.lastore.Job" } // method String func (v *job) GoString(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".String", flags, ch) } func (*job) StoreString(call *dbus.Call) (arg0 string, err error) { err = call.Store(&arg0) return } func (v *job) String(flags dbus.Flags) (arg0 string, err error) { return v.StoreString( <-v.GoString(flags, make(chan *dbus.Call, 1)).Done) } // property Id s func (v *job) Id() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Id", } } // property Name s func (v *job) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property Packages as func (v *job) Packages() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Packages", } } // property CreateTime x func (v *job) CreateTime() proxy.PropInt64 { return proxy.PropInt64{ Impl: v, Name: "CreateTime", } } // property Type s func (v *job) Type() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Type", } } // property Status s func (v *job) Status() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Status", } } // property Progress d func (v *job) Progress() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Progress", } } // property Description s func (v *job) Description() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Description", } } // property Speed x func (v *job) Speed() proxy.PropInt64 { return proxy.PropInt64{ Impl: v, Name: "Speed", } } // property DownloadSize x func (v *job) DownloadSize() proxy.PropInt64 { return proxy.PropInt64{ Impl: v, Name: "DownloadSize", } } // property Cancelable b func (v *job) Cancelable() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Cancelable", } } go-dbus-factory-1.9.6/com.deepin.lastore/config.json000066400000000000000000000016461403054572700224030ustar00rootroot00000000000000{ "Service": "com.deepin.lastore", "Objects": [ { "Type": "Lastore", "Path": "/com/deepin/lastore", "Interfaces": [ { "Name": "com.deepin.lastore.Manager", "Type": "manager", "Accessor": "Manager" }, { "Name": "com.deepin.lastore.Updater", "Type": "updater", "Accessor": "Updater", "Fixes": { "m/ApplicationUpdateInfos": [ { "Name": "arg1", "Type": "[]ApplicationUpdateInfo" } ], "m/ListMirrorSources": [ { "Name": "arg1", "Type": "[]MirrorSource" } ] } } ] }, { "Type": "Job", "Interfaces": [ { "Name": "com.deepin.lastore.Job", "Type": "job" } ] } ] } go-dbus-factory-1.9.6/com.deepin.lastore/manual.go000066400000000000000000000003571403054572700220450ustar00rootroot00000000000000package lastore type ApplicationUpdateInfo struct { Id string Name string Icon string CurrentVersion string LastVersion string } type MirrorSource struct { Id string Url string Name string } go-dbus-factory-1.9.6/com.deepin.sessionmanager/000077500000000000000000000000001403054572700216015ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.sessionmanager/SessionManager.xml000066400000000000000000000064221403054572700252450ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.sessionmanager/StartManager.xml000066400000000000000000000074771403054572700247320ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.sessionmanager/WMSwitcher.xml000066400000000000000000000033301403054572700243560ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.sessionmanager/XSettings.xml000066400000000000000000000057571403054572700242710ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.sessionmanager/auto.go000066400000000000000000000657201403054572700231120ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.sessionmanager"; DO NOT EDIT. package sessionmanager import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type StartManager struct { startManager // interface com.deepin.StartManager proxy.Object } func NewStartManager(conn *dbus.Conn) *StartManager { obj := new(StartManager) obj.Object.Init_(conn, "com.deepin.SessionManager", "/com/deepin/StartManager") return obj } type startManager struct{} func (v *startManager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*startManager) GetInterfaceName_() string { return "com.deepin.StartManager" } // method AddAutostart func (v *startManager) GoAddAutostart(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddAutostart", flags, ch, arg0) } func (*startManager) StoreAddAutostart(call *dbus.Call) (arg1 bool, err error) { err = call.Store(&arg1) return } func (v *startManager) AddAutostart(flags dbus.Flags, arg0 string) (arg1 bool, err error) { return v.StoreAddAutostart( <-v.GoAddAutostart(flags, make(chan *dbus.Call, 1), arg0).Done) } // method AutostartList func (v *startManager) GoAutostartList(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AutostartList", flags, ch) } func (*startManager) StoreAutostartList(call *dbus.Call) (arg0 []string, err error) { err = call.Store(&arg0) return } func (v *startManager) AutostartList(flags dbus.Flags) (arg0 []string, err error) { return v.StoreAutostartList( <-v.GoAutostartList(flags, make(chan *dbus.Call, 1)).Done) } // method DumpMemRecord func (v *startManager) GoDumpMemRecord(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DumpMemRecord", flags, ch) } func (*startManager) StoreDumpMemRecord(call *dbus.Call) (arg0 string, err error) { err = call.Store(&arg0) return } func (v *startManager) DumpMemRecord(flags dbus.Flags) (arg0 string, err error) { return v.StoreDumpMemRecord( <-v.GoDumpMemRecord(flags, make(chan *dbus.Call, 1)).Done) } // method GetApps func (v *startManager) GoGetApps(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetApps", flags, ch) } func (*startManager) StoreGetApps(call *dbus.Call) (arg0 map[uint32]string, err error) { err = call.Store(&arg0) return } func (v *startManager) GetApps(flags dbus.Flags) (arg0 map[uint32]string, err error) { return v.StoreGetApps( <-v.GoGetApps(flags, make(chan *dbus.Call, 1)).Done) } // method IsAutostart func (v *startManager) GoIsAutostart(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsAutostart", flags, ch, arg0) } func (*startManager) StoreIsAutostart(call *dbus.Call) (arg1 bool, err error) { err = call.Store(&arg1) return } func (v *startManager) IsAutostart(flags dbus.Flags, arg0 string) (arg1 bool, err error) { return v.StoreIsAutostart( <-v.GoIsAutostart(flags, make(chan *dbus.Call, 1), arg0).Done) } // method IsMemSufficient func (v *startManager) GoIsMemSufficient(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsMemSufficient", flags, ch) } func (*startManager) StoreIsMemSufficient(call *dbus.Call) (arg0 bool, err error) { err = call.Store(&arg0) return } func (v *startManager) IsMemSufficient(flags dbus.Flags) (arg0 bool, err error) { return v.StoreIsMemSufficient( <-v.GoIsMemSufficient(flags, make(chan *dbus.Call, 1)).Done) } // method Launch func (v *startManager) GoLaunch(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Launch", flags, ch, arg0) } func (*startManager) StoreLaunch(call *dbus.Call) (arg1 bool, err error) { err = call.Store(&arg1) return } func (v *startManager) Launch(flags dbus.Flags, arg0 string) (arg1 bool, err error) { return v.StoreLaunch( <-v.GoLaunch(flags, make(chan *dbus.Call, 1), arg0).Done) } // method LaunchApp func (v *startManager) GoLaunchApp(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 uint32, arg2 []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LaunchApp", flags, ch, arg0, arg1, arg2) } func (v *startManager) LaunchApp(flags dbus.Flags, arg0 string, arg1 uint32, arg2 []string) error { return (<-v.GoLaunchApp(flags, make(chan *dbus.Call, 1), arg0, arg1, arg2).Done).Err } // method LaunchAppAction func (v *startManager) GoLaunchAppAction(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 string, arg2 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LaunchAppAction", flags, ch, arg0, arg1, arg2) } func (v *startManager) LaunchAppAction(flags dbus.Flags, arg0 string, arg1 string, arg2 uint32) error { return (<-v.GoLaunchAppAction(flags, make(chan *dbus.Call, 1), arg0, arg1, arg2).Done).Err } // method LaunchAppWithOptions func (v *startManager) GoLaunchAppWithOptions(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 uint32, arg2 []string, arg3 map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LaunchAppWithOptions", flags, ch, arg0, arg1, arg2, arg3) } func (v *startManager) LaunchAppWithOptions(flags dbus.Flags, arg0 string, arg1 uint32, arg2 []string, arg3 map[string]dbus.Variant) error { return (<-v.GoLaunchAppWithOptions(flags, make(chan *dbus.Call, 1), arg0, arg1, arg2, arg3).Done).Err } // method LaunchWithTimestamp func (v *startManager) GoLaunchWithTimestamp(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LaunchWithTimestamp", flags, ch, arg0, arg1) } func (*startManager) StoreLaunchWithTimestamp(call *dbus.Call) (arg2 bool, err error) { err = call.Store(&arg2) return } func (v *startManager) LaunchWithTimestamp(flags dbus.Flags, arg0 string, arg1 uint32) (arg2 bool, err error) { return v.StoreLaunchWithTimestamp( <-v.GoLaunchWithTimestamp(flags, make(chan *dbus.Call, 1), arg0, arg1).Done) } // method RemoveAutostart func (v *startManager) GoRemoveAutostart(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemoveAutostart", flags, ch, arg0) } func (*startManager) StoreRemoveAutostart(call *dbus.Call) (arg1 bool, err error) { err = call.Store(&arg1) return } func (v *startManager) RemoveAutostart(flags dbus.Flags, arg0 string) (arg1 bool, err error) { return v.StoreRemoveAutostart( <-v.GoRemoveAutostart(flags, make(chan *dbus.Call, 1), arg0).Done) } // method RunCommand func (v *startManager) GoRunCommand(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RunCommand", flags, ch, arg0, arg1) } func (v *startManager) RunCommand(flags dbus.Flags, arg0 string, arg1 []string) error { return (<-v.GoRunCommand(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method TryAgain func (v *startManager) GoTryAgain(flags dbus.Flags, ch chan *dbus.Call, arg0 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TryAgain", flags, ch, arg0) } func (v *startManager) TryAgain(flags dbus.Flags, arg0 bool) error { return (<-v.GoTryAgain(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // signal AutostartChanged func (v *startManager) ConnectAutostartChanged(cb func(arg0 string, arg1 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "AutostartChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".AutostartChanged", } handlerFunc := func(sig *dbus.Signal) { var arg0 string var arg1 string err := dbus.Store(sig.Body, &arg0, &arg1) if err == nil { cb(arg0, arg1) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property NeededMemory t func (v *startManager) NeededMemory() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "NeededMemory", } } type SessionManager struct { sessionManager // interface com.deepin.SessionManager proxy.Object } func NewSessionManager(conn *dbus.Conn) *SessionManager { obj := new(SessionManager) obj.Object.Init_(conn, "com.deepin.SessionManager", "/com/deepin/SessionManager") return obj } type sessionManager struct{} func (v *sessionManager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*sessionManager) GetInterfaceName_() string { return "com.deepin.SessionManager" } // method AllowSessionDaemonRun func (v *sessionManager) GoAllowSessionDaemonRun(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AllowSessionDaemonRun", flags, ch) } func (*sessionManager) StoreAllowSessionDaemonRun(call *dbus.Call) (arg0 bool, err error) { err = call.Store(&arg0) return } func (v *sessionManager) AllowSessionDaemonRun(flags dbus.Flags) (arg0 bool, err error) { return v.StoreAllowSessionDaemonRun( <-v.GoAllowSessionDaemonRun(flags, make(chan *dbus.Call, 1)).Done) } // method CanHibernate func (v *sessionManager) GoCanHibernate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanHibernate", flags, ch) } func (*sessionManager) StoreCanHibernate(call *dbus.Call) (arg0 bool, err error) { err = call.Store(&arg0) return } func (v *sessionManager) CanHibernate(flags dbus.Flags) (arg0 bool, err error) { return v.StoreCanHibernate( <-v.GoCanHibernate(flags, make(chan *dbus.Call, 1)).Done) } // method CanLogout func (v *sessionManager) GoCanLogout(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanLogout", flags, ch) } func (*sessionManager) StoreCanLogout(call *dbus.Call) (arg0 bool, err error) { err = call.Store(&arg0) return } func (v *sessionManager) CanLogout(flags dbus.Flags) (arg0 bool, err error) { return v.StoreCanLogout( <-v.GoCanLogout(flags, make(chan *dbus.Call, 1)).Done) } // method CanReboot func (v *sessionManager) GoCanReboot(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanReboot", flags, ch) } func (*sessionManager) StoreCanReboot(call *dbus.Call) (arg0 bool, err error) { err = call.Store(&arg0) return } func (v *sessionManager) CanReboot(flags dbus.Flags) (arg0 bool, err error) { return v.StoreCanReboot( <-v.GoCanReboot(flags, make(chan *dbus.Call, 1)).Done) } // method CanShutdown func (v *sessionManager) GoCanShutdown(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanShutdown", flags, ch) } func (*sessionManager) StoreCanShutdown(call *dbus.Call) (arg0 bool, err error) { err = call.Store(&arg0) return } func (v *sessionManager) CanShutdown(flags dbus.Flags) (arg0 bool, err error) { return v.StoreCanShutdown( <-v.GoCanShutdown(flags, make(chan *dbus.Call, 1)).Done) } // method CanSuspend func (v *sessionManager) GoCanSuspend(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanSuspend", flags, ch) } func (*sessionManager) StoreCanSuspend(call *dbus.Call) (arg0 bool, err error) { err = call.Store(&arg0) return } func (v *sessionManager) CanSuspend(flags dbus.Flags) (arg0 bool, err error) { return v.StoreCanSuspend( <-v.GoCanSuspend(flags, make(chan *dbus.Call, 1)).Done) } // method ForceLogout func (v *sessionManager) GoForceLogout(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ForceLogout", flags, ch) } func (v *sessionManager) ForceLogout(flags dbus.Flags) error { return (<-v.GoForceLogout(flags, make(chan *dbus.Call, 1)).Done).Err } // method ForceReboot func (v *sessionManager) GoForceReboot(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ForceReboot", flags, ch) } func (v *sessionManager) ForceReboot(flags dbus.Flags) error { return (<-v.GoForceReboot(flags, make(chan *dbus.Call, 1)).Done).Err } // method ForceShutdown func (v *sessionManager) GoForceShutdown(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ForceShutdown", flags, ch) } func (v *sessionManager) ForceShutdown(flags dbus.Flags) error { return (<-v.GoForceShutdown(flags, make(chan *dbus.Call, 1)).Done).Err } // method Logout func (v *sessionManager) GoLogout(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Logout", flags, ch) } func (v *sessionManager) Logout(flags dbus.Flags) error { return (<-v.GoLogout(flags, make(chan *dbus.Call, 1)).Done).Err } // method PowerOffChoose func (v *sessionManager) GoPowerOffChoose(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PowerOffChoose", flags, ch) } func (v *sessionManager) PowerOffChoose(flags dbus.Flags) error { return (<-v.GoPowerOffChoose(flags, make(chan *dbus.Call, 1)).Done).Err } // method Reboot func (v *sessionManager) GoReboot(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reboot", flags, ch) } func (v *sessionManager) Reboot(flags dbus.Flags) error { return (<-v.GoReboot(flags, make(chan *dbus.Call, 1)).Done).Err } // method Register func (v *sessionManager) GoRegister(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Register", flags, ch, arg0) } func (*sessionManager) StoreRegister(call *dbus.Call) (arg1 bool, err error) { err = call.Store(&arg1) return } func (v *sessionManager) Register(flags dbus.Flags, arg0 string) (arg1 bool, err error) { return v.StoreRegister( <-v.GoRegister(flags, make(chan *dbus.Call, 1), arg0).Done) } // method RequestHibernate func (v *sessionManager) GoRequestHibernate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestHibernate", flags, ch) } func (v *sessionManager) RequestHibernate(flags dbus.Flags) error { return (<-v.GoRequestHibernate(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestLock func (v *sessionManager) GoRequestLock(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestLock", flags, ch) } func (v *sessionManager) RequestLock(flags dbus.Flags) error { return (<-v.GoRequestLock(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestLogout func (v *sessionManager) GoRequestLogout(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestLogout", flags, ch) } func (v *sessionManager) RequestLogout(flags dbus.Flags) error { return (<-v.GoRequestLogout(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestReboot func (v *sessionManager) GoRequestReboot(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestReboot", flags, ch) } func (v *sessionManager) RequestReboot(flags dbus.Flags) error { return (<-v.GoRequestReboot(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestShutdown func (v *sessionManager) GoRequestShutdown(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestShutdown", flags, ch) } func (v *sessionManager) RequestShutdown(flags dbus.Flags) error { return (<-v.GoRequestShutdown(flags, make(chan *dbus.Call, 1)).Done).Err } // method RequestSuspend func (v *sessionManager) GoRequestSuspend(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestSuspend", flags, ch) } func (v *sessionManager) RequestSuspend(flags dbus.Flags) error { return (<-v.GoRequestSuspend(flags, make(chan *dbus.Call, 1)).Done).Err } // method SetLocked func (v *sessionManager) GoSetLocked(flags dbus.Flags, ch chan *dbus.Call, arg0 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLocked", flags, ch, arg0) } func (v *sessionManager) SetLocked(flags dbus.Flags, arg0 bool) error { return (<-v.GoSetLocked(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method Shutdown func (v *sessionManager) GoShutdown(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Shutdown", flags, ch) } func (v *sessionManager) Shutdown(flags dbus.Flags) error { return (<-v.GoShutdown(flags, make(chan *dbus.Call, 1)).Done).Err } // method ToggleDebug func (v *sessionManager) GoToggleDebug(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ToggleDebug", flags, ch) } func (v *sessionManager) ToggleDebug(flags dbus.Flags) error { return (<-v.GoToggleDebug(flags, make(chan *dbus.Call, 1)).Done).Err } // signal Unlock func (v *sessionManager) ConnectUnlock(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Unlock", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Unlock", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Locked b func (v *sessionManager) Locked() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Locked", } } // property CurrentUid s func (v *sessionManager) CurrentUid() proxy.PropString { return proxy.PropString{ Impl: v, Name: "CurrentUid", } } // property Stage i func (v *sessionManager) Stage() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "Stage", } } // property CurrentSessionPath o func (v *sessionManager) CurrentSessionPath() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "CurrentSessionPath", } } type WMSwitcher struct { wmSwitcher // interface com.deepin.WMSwitcher proxy.Object } func NewWMSwitcher(conn *dbus.Conn) *WMSwitcher { obj := new(WMSwitcher) obj.Object.Init_(conn, "com.deepin.SessionManager", "/com/deepin/WMSwitcher") return obj } type wmSwitcher struct{} func (v *wmSwitcher) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*wmSwitcher) GetInterfaceName_() string { return "com.deepin.WMSwitcher" } // method CurrentWM func (v *wmSwitcher) GoCurrentWM(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CurrentWM", flags, ch) } func (*wmSwitcher) StoreCurrentWM(call *dbus.Call) (arg0 string, err error) { err = call.Store(&arg0) return } func (v *wmSwitcher) CurrentWM(flags dbus.Flags) (arg0 string, err error) { return v.StoreCurrentWM( <-v.GoCurrentWM(flags, make(chan *dbus.Call, 1)).Done) } // method RequestSwitchWM func (v *wmSwitcher) GoRequestSwitchWM(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestSwitchWM", flags, ch) } func (v *wmSwitcher) RequestSwitchWM(flags dbus.Flags) error { return (<-v.GoRequestSwitchWM(flags, make(chan *dbus.Call, 1)).Done).Err } // method RestartWM func (v *wmSwitcher) GoRestartWM(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RestartWM", flags, ch) } func (v *wmSwitcher) RestartWM(flags dbus.Flags) error { return (<-v.GoRestartWM(flags, make(chan *dbus.Call, 1)).Done).Err } // method Start2DWM func (v *wmSwitcher) GoStart2DWM(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Start2DWM", flags, ch) } func (v *wmSwitcher) Start2DWM(flags dbus.Flags) error { return (<-v.GoStart2DWM(flags, make(chan *dbus.Call, 1)).Done).Err } // signal WMChanged func (v *wmSwitcher) ConnectWMChanged(cb func(arg0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "WMChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".WMChanged", } handlerFunc := func(sig *dbus.Signal) { var arg0 string err := dbus.Store(sig.Body, &arg0) if err == nil { cb(arg0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } type XSettings struct { xSettings // interface com.deepin.XSettings proxy.Object } func NewXSettings(conn *dbus.Conn) *XSettings { obj := new(XSettings) obj.Object.Init_(conn, "com.deepin.SessionManager", "/com/deepin/XSettings") return obj } type xSettings struct{} func (v *xSettings) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*xSettings) GetInterfaceName_() string { return "com.deepin.XSettings" } // method GetColor func (v *xSettings) GoGetColor(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetColor", flags, ch, arg0) } func (*xSettings) StoreGetColor(call *dbus.Call) (arg1 []int16, err error) { err = call.Store(&arg1) return } func (v *xSettings) GetColor(flags dbus.Flags, arg0 string) (arg1 []int16, err error) { return v.StoreGetColor( <-v.GoGetColor(flags, make(chan *dbus.Call, 1), arg0).Done) } // method GetInteger func (v *xSettings) GoGetInteger(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetInteger", flags, ch, arg0) } func (*xSettings) StoreGetInteger(call *dbus.Call) (arg1 int32, err error) { err = call.Store(&arg1) return } func (v *xSettings) GetInteger(flags dbus.Flags, arg0 string) (arg1 int32, err error) { return v.StoreGetInteger( <-v.GoGetInteger(flags, make(chan *dbus.Call, 1), arg0).Done) } // method GetScaleFactor func (v *xSettings) GoGetScaleFactor(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetScaleFactor", flags, ch) } func (*xSettings) StoreGetScaleFactor(call *dbus.Call) (arg0 float64, err error) { err = call.Store(&arg0) return } func (v *xSettings) GetScaleFactor(flags dbus.Flags) (arg0 float64, err error) { return v.StoreGetScaleFactor( <-v.GoGetScaleFactor(flags, make(chan *dbus.Call, 1)).Done) } // method GetScreenScaleFactors func (v *xSettings) GoGetScreenScaleFactors(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetScreenScaleFactors", flags, ch) } func (*xSettings) StoreGetScreenScaleFactors(call *dbus.Call) (arg0 map[string]float64, err error) { err = call.Store(&arg0) return } func (v *xSettings) GetScreenScaleFactors(flags dbus.Flags) (arg0 map[string]float64, err error) { return v.StoreGetScreenScaleFactors( <-v.GoGetScreenScaleFactors(flags, make(chan *dbus.Call, 1)).Done) } // method GetString func (v *xSettings) GoGetString(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetString", flags, ch, arg0) } func (*xSettings) StoreGetString(call *dbus.Call) (arg1 string, err error) { err = call.Store(&arg1) return } func (v *xSettings) GetString(flags dbus.Flags, arg0 string) (arg1 string, err error) { return v.StoreGetString( <-v.GoGetString(flags, make(chan *dbus.Call, 1), arg0).Done) } // method ListProps func (v *xSettings) GoListProps(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListProps", flags, ch) } func (*xSettings) StoreListProps(call *dbus.Call) (arg0 string, err error) { err = call.Store(&arg0) return } func (v *xSettings) ListProps(flags dbus.Flags) (arg0 string, err error) { return v.StoreListProps( <-v.GoListProps(flags, make(chan *dbus.Call, 1)).Done) } // method SetColor func (v *xSettings) GoSetColor(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 []int16) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetColor", flags, ch, arg0, arg1) } func (v *xSettings) SetColor(flags dbus.Flags, arg0 string, arg1 []int16) error { return (<-v.GoSetColor(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method SetInteger func (v *xSettings) GoSetInteger(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetInteger", flags, ch, arg0, arg1) } func (v *xSettings) SetInteger(flags dbus.Flags, arg0 string, arg1 int32) error { return (<-v.GoSetInteger(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method SetScaleFactor func (v *xSettings) GoSetScaleFactor(flags dbus.Flags, ch chan *dbus.Call, arg0 float64) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetScaleFactor", flags, ch, arg0) } func (v *xSettings) SetScaleFactor(flags dbus.Flags, arg0 float64) error { return (<-v.GoSetScaleFactor(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method SetScreenScaleFactors func (v *xSettings) GoSetScreenScaleFactors(flags dbus.Flags, ch chan *dbus.Call, arg0 map[string]float64) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetScreenScaleFactors", flags, ch, arg0) } func (v *xSettings) SetScreenScaleFactors(flags dbus.Flags, arg0 map[string]float64) error { return (<-v.GoSetScreenScaleFactors(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method SetString func (v *xSettings) GoSetString(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetString", flags, ch, arg0, arg1) } func (v *xSettings) SetString(flags dbus.Flags, arg0 string, arg1 string) error { return (<-v.GoSetString(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // signal SetScaleFactorStarted func (v *xSettings) ConnectSetScaleFactorStarted(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SetScaleFactorStarted", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SetScaleFactorStarted", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal SetScaleFactorDone func (v *xSettings) ConnectSetScaleFactorDone(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SetScaleFactorDone", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SetScaleFactorDone", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.deepin.sessionmanager/config.json000066400000000000000000000016101403054572700237370ustar00rootroot00000000000000{ "Service": "com.deepin.SessionManager", "Objects": [ { "Type": "StartManager", "Path": "/com/deepin/StartManager", "Interfaces": [ { "Name": "com.deepin.StartManager", "Type": "startManager" } ] }, { "Type": "SessionManager", "Path": "/com/deepin/SessionManager", "Interfaces": [ { "Name": "com.deepin.SessionManager", "Type": "sessionManager" } ] }, { "Type": "WMSwitcher", "Path": "/com/deepin/WMSwitcher", "Interfaces": [ { "Name": "com.deepin.WMSwitcher", "Type": "wmSwitcher" } ] }, { "Type": "XSettings", "Path": "/com/deepin/XSettings", "Interfaces": [ { "Name": "com.deepin.XSettings", "Type": "xSettings" } ] } ] } go-dbus-factory-1.9.6/com.deepin.system.inputdevices/000077500000000000000000000000001403054572700226105ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.system.inputdevices/InputDevices.xml000066400000000000000000000036701403054572700257420ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.system.inputdevices/Touchscreen.xml000066400000000000000000000043351403054572700256210ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.system.inputdevices/auto.go000066400000000000000000000100411403054572700241030ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.system.inputdevices"; DO NOT EDIT. package inputdevices import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type InputDevices struct { inputDevices // interface com.deepin.system.InputDevices proxy.Object } func NewInputDevices(conn *dbus.Conn) *InputDevices { obj := new(InputDevices) obj.Object.Init_(conn, "com.deepin.system.InputDevices", "/com/deepin/system/InputDevices") return obj } type inputDevices struct{} func (v *inputDevices) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*inputDevices) GetInterfaceName_() string { return "com.deepin.system.InputDevices" } // signal TouchscreenAdded func (v *inputDevices) ConnectTouchscreenAdded(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "TouchscreenAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".TouchscreenAdded", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal TouchscreenRemoved func (v *inputDevices) ConnectTouchscreenRemoved(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "TouchscreenRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".TouchscreenRemoved", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Touchscreens ao func (v *inputDevices) Touchscreens() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Touchscreens", } } type Touchscreen struct { touchscreen // interface com.deepin.system.InputDevices.Touchscreen proxy.Object } func NewTouchscreen(conn *dbus.Conn, path dbus.ObjectPath) (*Touchscreen, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Touchscreen) obj.Object.Init_(conn, "com.deepin.system.InputDevices", path) return obj, nil } type touchscreen struct{} func (v *touchscreen) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*touchscreen) GetInterfaceName_() string { return "com.deepin.system.InputDevices.Touchscreen" } // property DevNode s func (v *touchscreen) DevNode() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DevNode", } } // property BusType s func (v *touchscreen) BusType() proxy.PropString { return proxy.PropString{ Impl: v, Name: "BusType", } } // property UUID s func (v *touchscreen) UUID() proxy.PropString { return proxy.PropString{ Impl: v, Name: "UUID", } } // property Phys s func (v *touchscreen) Phys() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Phys", } } // property OutputName s func (v *touchscreen) OutputName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "OutputName", } } // property Width d func (v *touchscreen) Width() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Width", } } // property Height d func (v *touchscreen) Height() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Height", } } // property Name s func (v *touchscreen) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property Serial s func (v *touchscreen) Serial() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Serial", } } go-dbus-factory-1.9.6/com.deepin.system.inputdevices/config.json000066400000000000000000000007441403054572700247550ustar00rootroot00000000000000{ "Service": "com.deepin.system.InputDevices", "Objects": [ { "Type": "InputDevices", "Path": "/com/deepin/system/InputDevices", "Interfaces": [ { "Name": "com.deepin.system.InputDevices", "Type": "inputDevices" } ] }, { "Type": "Touchscreen", "Interfaces": [ { "Name": "com.deepin.system.InputDevices.Touchscreen", "Type": "touchscreen" } ] } ] } go-dbus-factory-1.9.6/com.deepin.system.network/000077500000000000000000000000001403054572700215775ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.system.network/Network.xml000066400000000000000000000047751403054572700237670ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.system.network/auto.go000066400000000000000000000070001403054572700230730ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.system.network"; DO NOT EDIT. package network import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Network struct { network // interface com.deepin.system.Network proxy.Object } func NewNetwork(conn *dbus.Conn) *Network { obj := new(Network) obj.Object.Init_(conn, "com.deepin.system.Network", "/com/deepin/system/Network") return obj } type network struct{} func (v *network) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*network) GetInterfaceName_() string { return "com.deepin.system.Network" } // method EnableDevice func (v *network) GoEnableDevice(flags dbus.Flags, ch chan *dbus.Call, pathOrIface string, enabled bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnableDevice", flags, ch, pathOrIface, enabled) } func (*network) StoreEnableDevice(call *dbus.Call) (cpath dbus.ObjectPath, err error) { err = call.Store(&cpath) return } func (v *network) EnableDevice(flags dbus.Flags, pathOrIface string, enabled bool) (cpath dbus.ObjectPath, err error) { return v.StoreEnableDevice( <-v.GoEnableDevice(flags, make(chan *dbus.Call, 1), pathOrIface, enabled).Done) } // method IsDeviceEnabled func (v *network) GoIsDeviceEnabled(flags dbus.Flags, ch chan *dbus.Call, pathOrIface string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsDeviceEnabled", flags, ch, pathOrIface) } func (*network) StoreIsDeviceEnabled(call *dbus.Call) (enabled bool, err error) { err = call.Store(&enabled) return } func (v *network) IsDeviceEnabled(flags dbus.Flags, pathOrIface string) (enabled bool, err error) { return v.StoreIsDeviceEnabled( <-v.GoIsDeviceEnabled(flags, make(chan *dbus.Call, 1), pathOrIface).Done) } // method Ping func (v *network) GoPing(flags dbus.Flags, ch chan *dbus.Call, host string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Ping", flags, ch, host) } func (v *network) Ping(flags dbus.Flags, host string) error { return (<-v.GoPing(flags, make(chan *dbus.Call, 1), host).Done).Err } // method ToggleWirelessEnabled func (v *network) GoToggleWirelessEnabled(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ToggleWirelessEnabled", flags, ch) } func (*network) StoreToggleWirelessEnabled(call *dbus.Call) (enabled bool, err error) { err = call.Store(&enabled) return } func (v *network) ToggleWirelessEnabled(flags dbus.Flags) (enabled bool, err error) { return v.StoreToggleWirelessEnabled( <-v.GoToggleWirelessEnabled(flags, make(chan *dbus.Call, 1)).Done) } // signal DeviceEnabled func (v *network) ConnectDeviceEnabled(cb func(devPath dbus.ObjectPath, enabled bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "DeviceEnabled", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".DeviceEnabled", } handlerFunc := func(sig *dbus.Signal) { var devPath dbus.ObjectPath var enabled bool err := dbus.Store(sig.Body, &devPath, &enabled) if err == nil { cb(devPath, enabled) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property VpnEnabled b func (v *network) VpnEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "VpnEnabled", } } go-dbus-factory-1.9.6/com.deepin.system.network/config.json000066400000000000000000000004171403054572700237410ustar00rootroot00000000000000{ "Service": "com.deepin.system.Network", "Objects": [ { "Type": "Network", "Path": "/com/deepin/system/Network", "Interfaces": [ { "Name": "com.deepin.system.Network", "Type": "network" } ] } ] } go-dbus-factory-1.9.6/com.deepin.system.power/000077500000000000000000000000001403054572700212425ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.system.power/Battery.xml000066400000000000000000000055641403054572700234100ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.system.power/Power.xml000066400000000000000000000075721403054572700230730ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.system.power/auto.go000066400000000000000000000271121403054572700225440ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.system.power"; DO NOT EDIT. package power import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Power struct { power // interface com.deepin.system.Power proxy.Object } func NewPower(conn *dbus.Conn) *Power { obj := new(Power) obj.Object.Init_(conn, "com.deepin.system.Power", "/com/deepin/system/Power") return obj } type power struct{} func (v *power) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*power) GetInterfaceName_() string { return "com.deepin.system.Power" } // method GetBatteries func (v *power) GoGetBatteries(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetBatteries", flags, ch) } func (*power) StoreGetBatteries(call *dbus.Call) (batteries []dbus.ObjectPath, err error) { err = call.Store(&batteries) return } func (v *power) GetBatteries(flags dbus.Flags) (batteries []dbus.ObjectPath, err error) { return v.StoreGetBatteries( <-v.GoGetBatteries(flags, make(chan *dbus.Call, 1)).Done) } // method Refresh func (v *power) GoRefresh(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Refresh", flags, ch) } func (v *power) Refresh(flags dbus.Flags) error { return (<-v.GoRefresh(flags, make(chan *dbus.Call, 1)).Done).Err } // method RefreshBatteries func (v *power) GoRefreshBatteries(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RefreshBatteries", flags, ch) } func (v *power) RefreshBatteries(flags dbus.Flags) error { return (<-v.GoRefreshBatteries(flags, make(chan *dbus.Call, 1)).Done).Err } // method RefreshMains func (v *power) GoRefreshMains(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RefreshMains", flags, ch) } func (v *power) RefreshMains(flags dbus.Flags) error { return (<-v.GoRefreshMains(flags, make(chan *dbus.Call, 1)).Done).Err } // method SetCpuGovernor func (v *power) GoSetCpuGovernor(flags dbus.Flags, ch chan *dbus.Call, governor string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetCpuGovernor", flags, ch, governor) } func (v *power) SetCpuGovernor(flags dbus.Flags, governor string) error { return (<-v.GoSetCpuGovernor(flags, make(chan *dbus.Call, 1), governor).Done).Err } // method SetCpuBoost func (v *power) GoSetCpuBoost(flags dbus.Flags, ch chan *dbus.Call, enabled bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetCpuBoost", flags, ch, enabled) } func (v *power) SetCpuBoost(flags dbus.Flags, enabled bool) error { return (<-v.GoSetCpuBoost(flags, make(chan *dbus.Call, 1), enabled).Done).Err } // method LockCpuFreq func (v *power) GoLockCpuFreq(flags dbus.Flags, ch chan *dbus.Call, governor string, lockTime int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LockCpuFreq", flags, ch, governor, lockTime) } func (v *power) LockCpuFreq(flags dbus.Flags, governor string, lockTime int32) error { return (<-v.GoLockCpuFreq(flags, make(chan *dbus.Call, 1), governor, lockTime).Done).Err } // signal BatteryDisplayUpdate func (v *power) ConnectBatteryDisplayUpdate(cb func(timestamp int64)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "BatteryDisplayUpdate", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".BatteryDisplayUpdate", } handlerFunc := func(sig *dbus.Signal) { var timestamp int64 err := dbus.Store(sig.Body, ×tamp) if err == nil { cb(timestamp) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal BatteryAdded func (v *power) ConnectBatteryAdded(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "BatteryAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".BatteryAdded", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal BatteryRemoved func (v *power) ConnectBatteryRemoved(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "BatteryRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".BatteryRemoved", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal LidClosed func (v *power) ConnectLidClosed(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "LidClosed", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".LidClosed", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal LidOpened func (v *power) ConnectLidOpened(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "LidOpened", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".LidOpened", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property PowerSavingModeAuto b func (v *power) PowerSavingModeAuto() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PowerSavingModeAuto", } } // property OnBattery b func (v *power) OnBattery() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "OnBattery", } } // property HasLidSwitch b func (v *power) HasLidSwitch() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "HasLidSwitch", } } // property BatteryPercentage d func (v *power) BatteryPercentage() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "BatteryPercentage", } } // property BatteryTimeToEmpty t func (v *power) BatteryTimeToEmpty() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "BatteryTimeToEmpty", } } // property HasBattery b func (v *power) HasBattery() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "HasBattery", } } // property BatteryStatus u func (v *power) BatteryStatus() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "BatteryStatus", } } // property BatteryTimeToFull t func (v *power) BatteryTimeToFull() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "BatteryTimeToFull", } } // property BatteryCapacity d func (v *power) BatteryCapacity() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "BatteryCapacity", } } // property PowerSavingModeEnabled b func (v *power) PowerSavingModeEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PowerSavingModeEnabled", } } // property PowerSavingModeAutoWhenBatteryLow b func (v *power) PowerSavingModeAutoWhenBatteryLow() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PowerSavingModeAutoWhenBatteryLow", } } // property PowerSavingModeBrightnessDropPercent u func (v *power) PowerSavingModeBrightnessDropPercent() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "PowerSavingModeBrightnessDropPercent", } } // property CpuGovernor s func (v *power) CpuGovernor() proxy.PropString { return proxy.PropString{ Impl: v, Name: "CpuGovernor", } } // property CpuBoost b func (v *power) CpuBoost() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CpuBoost", } } // property IsBoostSupported b func (v *power) IsBoostSupported() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IsBoostSupported", } } type Battery struct { battery // interface com.deepin.system.Power.Battery proxy.Object } func NewBattery(conn *dbus.Conn, path dbus.ObjectPath) (*Battery, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Battery) obj.Object.Init_(conn, "com.deepin.system.Power", path) return obj, nil } type battery struct{} func (v *battery) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*battery) GetInterfaceName_() string { return "com.deepin.system.Power.Battery" } // property EnergyFullDesign d func (v *battery) EnergyFullDesign() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "EnergyFullDesign", } } // property Capacity d func (v *battery) Capacity() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Capacity", } } // property Technology s func (v *battery) Technology() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Technology", } } // property Energy d func (v *battery) Energy() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Energy", } } // property EnergyFull d func (v *battery) EnergyFull() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "EnergyFull", } } // property Manufacturer s func (v *battery) Manufacturer() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Manufacturer", } } // property ModelName s func (v *battery) ModelName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ModelName", } } // property TimeToEmpty t func (v *battery) TimeToEmpty() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TimeToEmpty", } } // property IsPresent b func (v *battery) IsPresent() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IsPresent", } } // property Status u func (v *battery) Status() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Status", } } // property EnergyRate d func (v *battery) EnergyRate() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "EnergyRate", } } // property Voltage d func (v *battery) Voltage() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Voltage", } } // property Percentage d func (v *battery) Percentage() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Percentage", } } // property TimeToFull t func (v *battery) TimeToFull() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TimeToFull", } } // property UpdateTime x func (v *battery) UpdateTime() proxy.PropInt64 { return proxy.PropInt64{ Impl: v, Name: "UpdateTime", } } // property SysfsPath s func (v *battery) SysfsPath() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SysfsPath", } } // property SerialNumber s func (v *battery) SerialNumber() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SerialNumber", } } // property Name s func (v *battery) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } go-dbus-factory-1.9.6/com.deepin.system.power/config.json000066400000000000000000000006551403054572700234100ustar00rootroot00000000000000{ "Service": "com.deepin.system.Power", "Objects": [ { "Type": "Power", "Path": "/com/deepin/system/Power", "Interfaces": [ { "Name": "com.deepin.system.Power", "Type": "power" } ] }, { "Type":"Battery", "Interfaces": [ { "Name": "com.deepin.system.Power.Battery", "Type": "battery" } ] } ] } go-dbus-factory-1.9.6/com.deepin.system.systeminfo/000077500000000000000000000000001403054572700223065ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.system.systeminfo/SystemInfo.xml000066400000000000000000000036001403054572700251270ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.system.systeminfo/auto.go000066400000000000000000000021441403054572700236060ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.system.systeminfo"; DO NOT EDIT. package systeminfo import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type SystemInfo struct { systemInfo // interface com.deepin.system.SystemInfo proxy.Object } func NewSystemInfo(conn *dbus.Conn) *SystemInfo { obj := new(SystemInfo) obj.Object.Init_(conn, "com.deepin.system.SystemInfo", "/com/deepin/system/SystemInfo") return obj } type systemInfo struct{} func (v *systemInfo) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*systemInfo) GetInterfaceName_() string { return "com.deepin.system.SystemInfo" } // property MemorySizeHuman s func (v *systemInfo) MemorySizeHuman() proxy.PropString { return proxy.PropString{ Impl: v, Name: "MemorySizeHuman", } } // property MemorySize t func (v *systemInfo) MemorySize() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "MemorySize", } } // property CurrentSpeed t func (v *systemInfo) CurrentSpeed() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "CurrentSpeed", } } go-dbus-factory-1.9.6/com.deepin.system.systeminfo/config.json000066400000000000000000000004361403054572700244510ustar00rootroot00000000000000{ "Service": "com.deepin.system.SystemInfo", "Objects": [ { "Type": "SystemInfo", "Path": "/com/deepin/system/SystemInfo", "Interfaces": [ { "Name": "com.deepin.system.SystemInfo", "Type": "systemInfo" } ] } ] } go-dbus-factory-1.9.6/com.deepin.wm/000077500000000000000000000000001403054572700172065ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.wm/Wm.xml000066400000000000000000000160771403054572700203260ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.wm/auto.go000066400000000000000000000562071403054572700205170ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.wm"; DO NOT EDIT. package wm import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Wm struct { wm // interface com.deepin.wm proxy.Object } func NewWm(conn *dbus.Conn) *Wm { obj := new(Wm) obj.Object.Init_(conn, "com.deepin.wm", "/com/deepin/wm") return obj } type wm struct{} func (v *wm) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*wm) GetInterfaceName_() string { return "com.deepin.wm" } // method SwitchApplication func (v *wm) GoSwitchApplication(flags dbus.Flags, ch chan *dbus.Call, backward bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SwitchApplication", flags, ch, backward) } func (v *wm) SwitchApplication(flags dbus.Flags, backward bool) error { return (<-v.GoSwitchApplication(flags, make(chan *dbus.Call, 1), backward).Done).Err } // method TileActiveWindow func (v *wm) GoTileActiveWindow(flags dbus.Flags, ch chan *dbus.Call, side uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TileActiveWindow", flags, ch, side) } func (v *wm) TileActiveWindow(flags dbus.Flags, side uint32) error { return (<-v.GoTileActiveWindow(flags, make(chan *dbus.Call, 1), side).Done).Err } // method BeginToMoveActiveWindow func (v *wm) GoBeginToMoveActiveWindow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".BeginToMoveActiveWindow", flags, ch) } func (v *wm) BeginToMoveActiveWindow(flags dbus.Flags) error { return (<-v.GoBeginToMoveActiveWindow(flags, make(chan *dbus.Call, 1)).Done).Err } // method ToggleActiveWindowMaximize func (v *wm) GoToggleActiveWindowMaximize(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ToggleActiveWindowMaximize", flags, ch) } func (v *wm) ToggleActiveWindowMaximize(flags dbus.Flags) error { return (<-v.GoToggleActiveWindowMaximize(flags, make(chan *dbus.Call, 1)).Done).Err } // method MinimizeActiveWindow func (v *wm) GoMinimizeActiveWindow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".MinimizeActiveWindow", flags, ch) } func (v *wm) MinimizeActiveWindow(flags dbus.Flags) error { return (<-v.GoMinimizeActiveWindow(flags, make(chan *dbus.Call, 1)).Done).Err } // method ShowWorkspace func (v *wm) GoShowWorkspace(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ShowWorkspace", flags, ch) } func (v *wm) ShowWorkspace(flags dbus.Flags) error { return (<-v.GoShowWorkspace(flags, make(chan *dbus.Call, 1)).Done).Err } // method ShowWindow func (v *wm) GoShowWindow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ShowWindow", flags, ch) } func (v *wm) ShowWindow(flags dbus.Flags) error { return (<-v.GoShowWindow(flags, make(chan *dbus.Call, 1)).Done).Err } // method ShowAllWindow func (v *wm) GoShowAllWindow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ShowAllWindow", flags, ch) } func (v *wm) ShowAllWindow(flags dbus.Flags) error { return (<-v.GoShowAllWindow(flags, make(chan *dbus.Call, 1)).Done).Err } // method ClearMoveStatus func (v *wm) GoClearMoveStatus(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ClearMoveStatus", flags, ch) } func (v *wm) ClearMoveStatus(flags dbus.Flags) error { return (<-v.GoClearMoveStatus(flags, make(chan *dbus.Call, 1)).Done).Err } // method TouchToMove func (v *wm) GoTouchToMove(flags dbus.Flags, ch chan *dbus.Call, x int32, y int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TouchToMove", flags, ch, x, y) } func (v *wm) TouchToMove(flags dbus.Flags, x int32, y int32) error { return (<-v.GoTouchToMove(flags, make(chan *dbus.Call, 1), x, y).Done).Err } // method PerformAction func (v *wm) GoPerformAction(flags dbus.Flags, ch chan *dbus.Call, type0 int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PerformAction", flags, ch, type0) } func (v *wm) PerformAction(flags dbus.Flags, type0 int32) error { return (<-v.GoPerformAction(flags, make(chan *dbus.Call, 1), type0).Done).Err } // method PreviewWindow func (v *wm) GoPreviewWindow(flags dbus.Flags, ch chan *dbus.Call, xid uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PreviewWindow", flags, ch, xid) } func (v *wm) PreviewWindow(flags dbus.Flags, xid uint32) error { return (<-v.GoPreviewWindow(flags, make(chan *dbus.Call, 1), xid).Done).Err } // method CancelPreviewWindow func (v *wm) GoCancelPreviewWindow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CancelPreviewWindow", flags, ch) } func (v *wm) CancelPreviewWindow(flags dbus.Flags) error { return (<-v.GoCancelPreviewWindow(flags, make(chan *dbus.Call, 1)).Done).Err } // method GetCurrentWorkspaceBackground func (v *wm) GoGetCurrentWorkspaceBackground(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetCurrentWorkspaceBackground", flags, ch) } func (*wm) StoreGetCurrentWorkspaceBackground(call *dbus.Call) (result string, err error) { err = call.Store(&result) return } func (v *wm) GetCurrentWorkspaceBackground(flags dbus.Flags) (result string, err error) { return v.StoreGetCurrentWorkspaceBackground( <-v.GoGetCurrentWorkspaceBackground(flags, make(chan *dbus.Call, 1)).Done) } // method SetCurrentWorkspaceBackground func (v *wm) GoSetCurrentWorkspaceBackground(flags dbus.Flags, ch chan *dbus.Call, uri string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetCurrentWorkspaceBackground", flags, ch, uri) } func (v *wm) SetCurrentWorkspaceBackground(flags dbus.Flags, uri string) error { return (<-v.GoSetCurrentWorkspaceBackground(flags, make(chan *dbus.Call, 1), uri).Done).Err } // method GetWorkspaceBackground func (v *wm) GoGetWorkspaceBackground(flags dbus.Flags, ch chan *dbus.Call, index int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetWorkspaceBackground", flags, ch, index) } func (*wm) StoreGetWorkspaceBackground(call *dbus.Call) (result string, err error) { err = call.Store(&result) return } func (v *wm) GetWorkspaceBackground(flags dbus.Flags, index int32) (result string, err error) { return v.StoreGetWorkspaceBackground( <-v.GoGetWorkspaceBackground(flags, make(chan *dbus.Call, 1), index).Done) } // method SetWorkspaceBackground func (v *wm) GoSetWorkspaceBackground(flags dbus.Flags, ch chan *dbus.Call, index int32, uri string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetWorkspaceBackground", flags, ch, index, uri) } func (v *wm) SetWorkspaceBackground(flags dbus.Flags, index int32, uri string) error { return (<-v.GoSetWorkspaceBackground(flags, make(chan *dbus.Call, 1), index, uri).Done).Err } // method SetTransientBackground func (v *wm) GoSetTransientBackground(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetTransientBackground", flags, ch, arg0) } func (v *wm) SetTransientBackground(flags dbus.Flags, arg0 string) error { return (<-v.GoSetTransientBackground(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method GetCurrentWorkspaceBackgroundForMonitor func (v *wm) GoGetCurrentWorkspaceBackgroundForMonitor(flags dbus.Flags, ch chan *dbus.Call, strMonitorName string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetCurrentWorkspaceBackgroundForMonitor", flags, ch, strMonitorName) } func (*wm) StoreGetCurrentWorkspaceBackgroundForMonitor(call *dbus.Call) (result string, err error) { err = call.Store(&result) return } func (v *wm) GetCurrentWorkspaceBackgroundForMonitor(flags dbus.Flags, strMonitorName string) (result string, err error) { return v.StoreGetCurrentWorkspaceBackgroundForMonitor( <-v.GoGetCurrentWorkspaceBackgroundForMonitor(flags, make(chan *dbus.Call, 1), strMonitorName).Done) } // method SetCurrentWorkspaceBackgroundForMonitor func (v *wm) GoSetCurrentWorkspaceBackgroundForMonitor(flags dbus.Flags, ch chan *dbus.Call, uri string, strMonitorName string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetCurrentWorkspaceBackgroundForMonitor", flags, ch, uri, strMonitorName) } func (v *wm) SetCurrentWorkspaceBackgroundForMonitor(flags dbus.Flags, uri string, strMonitorName string) error { return (<-v.GoSetCurrentWorkspaceBackgroundForMonitor(flags, make(chan *dbus.Call, 1), uri, strMonitorName).Done).Err } // method GetWorkspaceBackgroundForMonitor func (v *wm) GoGetWorkspaceBackgroundForMonitor(flags dbus.Flags, ch chan *dbus.Call, index int32, strMonitorName string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetWorkspaceBackgroundForMonitor", flags, ch, index, strMonitorName) } func (*wm) StoreGetWorkspaceBackgroundForMonitor(call *dbus.Call) (result string, err error) { err = call.Store(&result) return } func (v *wm) GetWorkspaceBackgroundForMonitor(flags dbus.Flags, index int32, strMonitorName string) (result string, err error) { return v.StoreGetWorkspaceBackgroundForMonitor( <-v.GoGetWorkspaceBackgroundForMonitor(flags, make(chan *dbus.Call, 1), index, strMonitorName).Done) } // method SetWorkspaceBackgroundForMonitor func (v *wm) GoSetWorkspaceBackgroundForMonitor(flags dbus.Flags, ch chan *dbus.Call, index int32, strMonitorName string, uri string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetWorkspaceBackgroundForMonitor", flags, ch, index, strMonitorName, uri) } func (v *wm) SetWorkspaceBackgroundForMonitor(flags dbus.Flags, index int32, strMonitorName string, uri string) error { return (<-v.GoSetWorkspaceBackgroundForMonitor(flags, make(chan *dbus.Call, 1), index, strMonitorName, uri).Done).Err } // method SetTransientBackgroundForMonitor func (v *wm) GoSetTransientBackgroundForMonitor(flags dbus.Flags, ch chan *dbus.Call, uri string, strMonitorName string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetTransientBackgroundForMonitor", flags, ch, uri, strMonitorName) } func (v *wm) SetTransientBackgroundForMonitor(flags dbus.Flags, uri string, strMonitorName string) error { return (<-v.GoSetTransientBackgroundForMonitor(flags, make(chan *dbus.Call, 1), uri, strMonitorName).Done).Err } // method GetCurrentWorkspace func (v *wm) GoGetCurrentWorkspace(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetCurrentWorkspace", flags, ch) } func (*wm) StoreGetCurrentWorkspace(call *dbus.Call) (index int32, err error) { err = call.Store(&index) return } func (v *wm) GetCurrentWorkspace(flags dbus.Flags) (index int32, err error) { return v.StoreGetCurrentWorkspace( <-v.GoGetCurrentWorkspace(flags, make(chan *dbus.Call, 1)).Done) } // method WorkspaceCount func (v *wm) GoWorkspaceCount(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".WorkspaceCount", flags, ch) } func (*wm) StoreWorkspaceCount(call *dbus.Call) (count int32, err error) { err = call.Store(&count) return } func (v *wm) WorkspaceCount(flags dbus.Flags) (count int32, err error) { return v.StoreWorkspaceCount( <-v.GoWorkspaceCount(flags, make(chan *dbus.Call, 1)).Done) } // method SetCurrentWorkspace func (v *wm) GoSetCurrentWorkspace(flags dbus.Flags, ch chan *dbus.Call, index int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetCurrentWorkspace", flags, ch, index) } func (v *wm) SetCurrentWorkspace(flags dbus.Flags, index int32) error { return (<-v.GoSetCurrentWorkspace(flags, make(chan *dbus.Call, 1), index).Done).Err } // method PreviousWorkspace func (v *wm) GoPreviousWorkspace(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PreviousWorkspace", flags, ch) } func (v *wm) PreviousWorkspace(flags dbus.Flags) error { return (<-v.GoPreviousWorkspace(flags, make(chan *dbus.Call, 1)).Done).Err } // method NextWorkspace func (v *wm) GoNextWorkspace(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".NextWorkspace", flags, ch) } func (v *wm) NextWorkspace(flags dbus.Flags) error { return (<-v.GoNextWorkspace(flags, make(chan *dbus.Call, 1)).Done).Err } // method GetAllAccels func (v *wm) GoGetAllAccels(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAllAccels", flags, ch) } func (*wm) StoreGetAllAccels(call *dbus.Call) (data string, err error) { err = call.Store(&data) return } func (v *wm) GetAllAccels(flags dbus.Flags) (data string, err error) { return v.StoreGetAllAccels( <-v.GoGetAllAccels(flags, make(chan *dbus.Call, 1)).Done) } // method GetAccel func (v *wm) GoGetAccel(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAccel", flags, ch, id) } func (*wm) StoreGetAccel(call *dbus.Call) (data []string, err error) { err = call.Store(&data) return } func (v *wm) GetAccel(flags dbus.Flags, id string) (data []string, err error) { return v.StoreGetAccel( <-v.GoGetAccel(flags, make(chan *dbus.Call, 1), id).Done) } // method GetDefaultAccel func (v *wm) GoGetDefaultAccel(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDefaultAccel", flags, ch, id) } func (*wm) StoreGetDefaultAccel(call *dbus.Call) (data []string, err error) { err = call.Store(&data) return } func (v *wm) GetDefaultAccel(flags dbus.Flags, id string) (data []string, err error) { return v.StoreGetDefaultAccel( <-v.GoGetDefaultAccel(flags, make(chan *dbus.Call, 1), id).Done) } // method SetAccel func (v *wm) GoSetAccel(flags dbus.Flags, ch chan *dbus.Call, data string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetAccel", flags, ch, data) } func (*wm) StoreSetAccel(call *dbus.Call) (result bool, err error) { err = call.Store(&result) return } func (v *wm) SetAccel(flags dbus.Flags, data string) (result bool, err error) { return v.StoreSetAccel( <-v.GoSetAccel(flags, make(chan *dbus.Call, 1), data).Done) } // method RemoveAccel func (v *wm) GoRemoveAccel(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemoveAccel", flags, ch, id) } func (v *wm) RemoveAccel(flags dbus.Flags, id string) error { return (<-v.GoRemoveAccel(flags, make(chan *dbus.Call, 1), id).Done).Err } // method SetDecorationTheme func (v *wm) GoSetDecorationTheme(flags dbus.Flags, ch chan *dbus.Call, themeType string, themeName string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDecorationTheme", flags, ch, themeType, themeName) } func (v *wm) SetDecorationTheme(flags dbus.Flags, themeType string, themeName string) error { return (<-v.GoSetDecorationTheme(flags, make(chan *dbus.Call, 1), themeType, themeName).Done).Err } // method SetDecorationDeepinTheme func (v *wm) GoSetDecorationDeepinTheme(flags dbus.Flags, ch chan *dbus.Call, deepinThemeName string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDecorationDeepinTheme", flags, ch, deepinThemeName) } func (v *wm) SetDecorationDeepinTheme(flags dbus.Flags, deepinThemeName string) error { return (<-v.GoSetDecorationDeepinTheme(flags, make(chan *dbus.Call, 1), deepinThemeName).Done).Err } // method ChangeCurrentWorkspaceBackground func (v *wm) GoChangeCurrentWorkspaceBackground(flags dbus.Flags, ch chan *dbus.Call, uri string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ChangeCurrentWorkspaceBackground", flags, ch, uri) } func (v *wm) ChangeCurrentWorkspaceBackground(flags dbus.Flags, uri string) error { return (<-v.GoChangeCurrentWorkspaceBackground(flags, make(chan *dbus.Call, 1), uri).Done).Err } // method SwitchToWorkspace func (v *wm) GoSwitchToWorkspace(flags dbus.Flags, ch chan *dbus.Call, backward bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SwitchToWorkspace", flags, ch, backward) } func (v *wm) SwitchToWorkspace(flags dbus.Flags, backward bool) error { return (<-v.GoSwitchToWorkspace(flags, make(chan *dbus.Call, 1), backward).Done).Err } // method PresentWindows func (v *wm) GoPresentWindows(flags dbus.Flags, ch chan *dbus.Call, xids []uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PresentWindows", flags, ch, xids) } func (v *wm) PresentWindows(flags dbus.Flags, xids []uint32) error { return (<-v.GoPresentWindows(flags, make(chan *dbus.Call, 1), xids).Done).Err } // method EnableZoneDetected func (v *wm) GoEnableZoneDetected(flags dbus.Flags, ch chan *dbus.Call, enabled bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnableZoneDetected", flags, ch, enabled) } func (v *wm) EnableZoneDetected(flags dbus.Flags, enabled bool) error { return (<-v.GoEnableZoneDetected(flags, make(chan *dbus.Call, 1), enabled).Done).Err } // method GetIsShowDesktop func (v *wm) GoGetIsShowDesktop(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetIsShowDesktop", flags, ch) } func (*wm) StoreGetIsShowDesktop(call *dbus.Call) (isShowDesktop bool, err error) { err = call.Store(&isShowDesktop) return } func (v *wm) GetIsShowDesktop(flags dbus.Flags) (isShowDesktop bool, err error) { return v.StoreGetIsShowDesktop( <-v.GoGetIsShowDesktop(flags, make(chan *dbus.Call, 1)).Done) } // method GetMultiTaskingStatus func (v *wm) GoGetMultiTaskingStatus(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetMultiTaskingStatus", flags, ch) } func (*wm) StoreGetMultiTaskingStatus(call *dbus.Call) (isActive bool, err error) { err = call.Store(&isActive) return } func (v *wm) GetMultiTaskingStatus(flags dbus.Flags) (isActive bool, err error) { return v.StoreGetMultiTaskingStatus( <-v.GoGetMultiTaskingStatus(flags, make(chan *dbus.Call, 1)).Done) } // signal WorkspaceBackgroundChanged func (v *wm) ConnectWorkspaceBackgroundChanged(cb func(index int32, newUri string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "WorkspaceBackgroundChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".WorkspaceBackgroundChanged", } handlerFunc := func(sig *dbus.Signal) { var index int32 var newUri string err := dbus.Store(sig.Body, &index, &newUri) if err == nil { cb(index, newUri) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal WorkspaceBackgroundChangedForMonitor func (v *wm) ConnectWorkspaceBackgroundChangedForMonitor(cb func(index int32, monitor string, newUri string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "WorkspaceBackgroundChangedForMonitor", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".WorkspaceBackgroundChangedForMonitor", } handlerFunc := func(sig *dbus.Signal) { var index int32 var monitor string var newUri string err := dbus.Store(sig.Body, &index, &monitor, &newUri) if err == nil { cb(index, monitor, newUri) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal compositingEnabledChanged func (v *wm) ConnectCompositingEnabledChanged(cb func(enabled bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "compositingEnabledChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".compositingEnabledChanged", } handlerFunc := func(sig *dbus.Signal) { var enabled bool err := dbus.Store(sig.Body, &enabled) if err == nil { cb(enabled) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal wmCompositingEnabledChanged func (v *wm) ConnectWmCompositingEnabledChanged(cb func(enabled bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "wmCompositingEnabledChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".wmCompositingEnabledChanged", } handlerFunc := func(sig *dbus.Signal) { var enabled bool err := dbus.Store(sig.Body, &enabled) if err == nil { cb(enabled) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal workspaceCountChanged func (v *wm) ConnectWorkspaceCountChanged(cb func(count int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "workspaceCountChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".workspaceCountChanged", } handlerFunc := func(sig *dbus.Signal) { var count int32 err := dbus.Store(sig.Body, &count) if err == nil { cb(count) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal WorkspaceSwitched func (v *wm) ConnectWorkspaceSwitched(cb func(from int32, to int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "WorkspaceSwitched", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".WorkspaceSwitched", } handlerFunc := func(sig *dbus.Signal) { var from int32 var to int32 err := dbus.Store(sig.Body, &from, &to) if err == nil { cb(from, to) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property compositingEnabled b func (v *wm) CompositingEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "compositingEnabled", } } // property compositingPossible b func (v *wm) CompositingPossible() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "compositingPossible", } } // property compositingAllowSwitch b func (v *wm) CompositingAllowSwitch() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "compositingAllowSwitch", } } // property zoneEnabled b func (v *wm) ZoneEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "zoneEnabled", } } // property cursorTheme s func (v *wm) CursorTheme() proxy.PropString { return proxy.PropString{ Impl: v, Name: "cursorTheme", } } // property cursorSize i func (v *wm) CursorSize() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "cursorSize", } } go-dbus-factory-1.9.6/com.deepin.wm/config.json000066400000000000000000000003411403054572700213440ustar00rootroot00000000000000{ "Service": "com.deepin.wm", "Objects": [ { "Type": "Wm", "Path": "/com/deepin/wm", "Interfaces": [ { "Name": "com.deepin.wm", "Type": "wm" } ] } ] } go-dbus-factory-1.9.6/com.deepin.wmswitcher/000077500000000000000000000000001403054572700207575ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.deepin.wmswitcher/WMSwitcher.xml000066400000000000000000000037621403054572700235450ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.deepin.wmswitcher/auto.go000066400000000000000000000050761403054572700222660ustar00rootroot00000000000000// Code generated by "./generator ./com.deepin.wmswitcher"; DO NOT EDIT. package wmswitcher import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type WMSwitcher struct { wmSwitcher // interface com.deepin.WMSwitcher proxy.Object } func NewWMSwitcher(conn *dbus.Conn) *WMSwitcher { obj := new(WMSwitcher) obj.Object.Init_(conn, "com.deepin.WMSwitcher", "/com/deepin/WMSwitcher") return obj } type wmSwitcher struct{} func (v *wmSwitcher) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*wmSwitcher) GetInterfaceName_() string { return "com.deepin.WMSwitcher" } // method AllowSwitch func (v *wmSwitcher) GoAllowSwitch(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AllowSwitch", flags, ch) } func (*wmSwitcher) StoreAllowSwitch(call *dbus.Call) (allow bool, err error) { err = call.Store(&allow) return } func (v *wmSwitcher) AllowSwitch(flags dbus.Flags) (allow bool, err error) { return v.StoreAllowSwitch( <-v.GoAllowSwitch(flags, make(chan *dbus.Call, 1)).Done) } // method CurrentWM func (v *wmSwitcher) GoCurrentWM(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CurrentWM", flags, ch) } func (*wmSwitcher) StoreCurrentWM(call *dbus.Call) (wmName string, err error) { err = call.Store(&wmName) return } func (v *wmSwitcher) CurrentWM(flags dbus.Flags) (wmName string, err error) { return v.StoreCurrentWM( <-v.GoCurrentWM(flags, make(chan *dbus.Call, 1)).Done) } // method RequestSwitchWM func (v *wmSwitcher) GoRequestSwitchWM(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestSwitchWM", flags, ch) } func (v *wmSwitcher) RequestSwitchWM(flags dbus.Flags) error { return (<-v.GoRequestSwitchWM(flags, make(chan *dbus.Call, 1)).Done).Err } // signal WMChanged func (v *wmSwitcher) ConnectWMChanged(cb func(wmName string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "WMChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".WMChanged", } handlerFunc := func(sig *dbus.Signal) { var wmName string err := dbus.Store(sig.Body, &wmName) if err == nil { cb(wmName) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.deepin.wmswitcher/config.json000066400000000000000000000004111403054572700231130ustar00rootroot00000000000000{ "Service": "com.deepin.WMSwitcher", "Objects": [ { "Type": "WMSwitcher", "Path": "/com/deepin/WMSwitcher", "Interfaces": [ { "Name": "com.deepin.WMSwitcher", "Type": "wmSwitcher" } ] } ] } go-dbus-factory-1.9.6/com.huawei.fingerprint/000077500000000000000000000000001403054572700211305ustar00rootroot00000000000000go-dbus-factory-1.9.6/com.huawei.fingerprint/Fingerprint.xml000066400000000000000000000035231403054572700241440ustar00rootroot00000000000000 go-dbus-factory-1.9.6/com.huawei.fingerprint/auto.go000066400000000000000000000156071403054572700224400ustar00rootroot00000000000000// Code generated by "./generator ./com.huawei.fingerprint"; DO NOT EDIT. package fingerprint import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Fingerprint struct { fingerprint // interface com.huawei.Fingerprint proxy.Object } func NewFingerprint(conn *dbus.Conn) *Fingerprint { obj := new(Fingerprint) obj.Object.Init_(conn, "com.huawei.Fingerprint", "/com/huawei/Fingerprint") return obj } type fingerprint struct{} func (v *fingerprint) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*fingerprint) GetInterfaceName_() string { return "com.huawei.Fingerprint" } // method SearchDevice func (v *fingerprint) GoSearchDevice(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SearchDevice", flags, ch) } func (*fingerprint) StoreSearchDevice(call *dbus.Call) (result bool, err error) { err = call.Store(&result) return } func (v *fingerprint) SearchDevice(flags dbus.Flags) (result bool, err error) { return v.StoreSearchDevice( <-v.GoSearchDevice(flags, make(chan *dbus.Call, 1)).Done) } // method Identify func (v *fingerprint) GoIdentify(flags dbus.Flags, ch chan *dbus.Call, uuid string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Identify", flags, ch, uuid) } func (v *fingerprint) Identify(flags dbus.Flags, uuid string) error { return (<-v.GoIdentify(flags, make(chan *dbus.Call, 1), uuid).Done).Err } // method IdentifyWithMultipleUser func (v *fingerprint) GoIdentifyWithMultipleUser(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IdentifyWithMultipleUser", flags, ch) } func (v *fingerprint) IdentifyWithMultipleUser(flags dbus.Flags) error { return (<-v.GoIdentifyWithMultipleUser(flags, make(chan *dbus.Call, 1)).Done).Err } // method GetStatus func (v *fingerprint) GoGetStatus(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetStatus", flags, ch) } func (*fingerprint) StoreGetStatus(call *dbus.Call) (result int32, err error) { err = call.Store(&result) return } func (v *fingerprint) GetStatus(flags dbus.Flags) (result int32, err error) { return v.StoreGetStatus( <-v.GoGetStatus(flags, make(chan *dbus.Call, 1)).Done) } // method Enroll func (v *fingerprint) GoEnroll(flags dbus.Flags, ch chan *dbus.Call, filePath string, uuid string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Enroll", flags, ch, filePath, uuid) } func (v *fingerprint) Enroll(flags dbus.Flags, filePath string, uuid string) error { return (<-v.GoEnroll(flags, make(chan *dbus.Call, 1), filePath, uuid).Done).Err } // method Close func (v *fingerprint) GoClose(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Close", flags, ch) } func (*fingerprint) StoreClose(call *dbus.Call) (result int32, err error) { err = call.Store(&result) return } func (v *fingerprint) Close(flags dbus.Flags) (result int32, err error) { return v.StoreClose( <-v.GoClose(flags, make(chan *dbus.Call, 1)).Done) } // method Reload func (v *fingerprint) GoReload(flags dbus.Flags, ch chan *dbus.Call, deleteType int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reload", flags, ch, deleteType) } func (*fingerprint) StoreReload(call *dbus.Call) (result int32, err error) { err = call.Store(&result) return } func (v *fingerprint) Reload(flags dbus.Flags, deleteType int32) (result int32, err error) { return v.StoreReload( <-v.GoReload(flags, make(chan *dbus.Call, 1), deleteType).Done) } // method ClearPovImage func (v *fingerprint) GoClearPovImage(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ClearPovImage", flags, ch) } func (*fingerprint) StoreClearPovImage(call *dbus.Call) (result int32, err error) { err = call.Store(&result) return } func (v *fingerprint) ClearPovImage(flags dbus.Flags) (result int32, err error) { return v.StoreClearPovImage( <-v.GoClearPovImage(flags, make(chan *dbus.Call, 1)).Done) } // signal EnrollStatus func (v *fingerprint) ConnectEnrollStatus(cb func(progress int32, result int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "EnrollStatus", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".EnrollStatus", } handlerFunc := func(sig *dbus.Signal) { var progress int32 var result int32 err := dbus.Store(sig.Body, &progress, &result) if err == nil { cb(progress, result) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal IdentifyStatus func (v *fingerprint) ConnectIdentifyStatus(cb func(result int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "IdentifyStatus", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".IdentifyStatus", } handlerFunc := func(sig *dbus.Signal) { var result int32 err := dbus.Store(sig.Body, &result) if err == nil { cb(result) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal IdentifyNoAccount func (v *fingerprint) ConnectIdentifyNoAccount(cb func(result int32, userName string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "IdentifyNoAccount", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".IdentifyNoAccount", } handlerFunc := func(sig *dbus.Signal) { var result int32 var userName string err := dbus.Store(sig.Body, &result, &userName) if err == nil { cb(result, userName) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal VerifyStatus func (v *fingerprint) ConnectVerifyStatus(cb func(result int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VerifyStatus", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VerifyStatus", } handlerFunc := func(sig *dbus.Signal) { var result int32 err := dbus.Store(sig.Body, &result) if err == nil { cb(result) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/com.huawei.fingerprint/config.json000066400000000000000000000004161403054572700232710ustar00rootroot00000000000000{ "Service": "com.huawei.Fingerprint", "Objects": [ { "Type": "Fingerprint", "Path": "/com/huawei/Fingerprint", "Interfaces": [ { "Name": "com.huawei.Fingerprint", "Type": "fingerprint" } ] } ] } go-dbus-factory-1.9.6/debian/000077500000000000000000000000001403054572700157655ustar00rootroot00000000000000go-dbus-factory-1.9.6/debian/changelog000066400000000000000000000002471403054572700176420ustar00rootroot00000000000000golang-github-linuxdeepin-go-dbus-factory (1.0.0-1) unstable; urgency=low * Auto Version update. -- shuttle Wed, 25 Oct 2017 01:40:10 +0000 go-dbus-factory-1.9.6/debian/control000066400000000000000000000013071403054572700173710ustar00rootroot00000000000000Source: golang-github-linuxdeepin-go-dbus-factory Section: devel Priority: optional Maintainer: Deepin Packages Builder Build-Depends: debhelper-compat (= 11), dh-golang, golang-any, golang-dlib-dev, golang-golang-x-tools, Standards-Version: 4.5.1 Homepage: https://github.com/linuxdeepin/go-dbus-factory XS-Go-Import-Path: github.com/linuxdeepin/go-dbus-factory Testsuite: autopkgtest-pkg-go Package: golang-github-linuxdeepin-go-dbus-factory-dev Architecture: all Depends: golang-dlib-dev, ${misc:Depends}, ${shlibs:Depends}, Description: mirrored from https://cr.deepin.io/#/admin/projects/go-dbus-factory Convenient go binding code for automatically generating DBus services go-dbus-factory-1.9.6/debian/copyright000066400000000000000000000006161403054572700177230ustar00rootroot00000000000000Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: go-dbus-factory Source: https://github.com/linuxdeepin/go-dbus-factory Files: * Copyright: 2017 Wuhan Deepin Technology Co.,Ltd. License: TODO Files: debian/* Copyright: 2017 root License: TODO Comment: Debian packaging is licensed under the same terms as upstream License: TODO TODO go-dbus-factory-1.9.6/debian/gbp.conf000066400000000000000000000000361403054572700174030ustar00rootroot00000000000000[DEFAULT] pristine-tar = True go-dbus-factory-1.9.6/debian/rules000077500000000000000000000002771403054572700170530ustar00rootroot00000000000000#!/usr/bin/make -f ifeq ($(DEB_BUILD_ARCH),sw_64) %: dh $@ else %: dh $@ --buildsystem=golang --with=golang endif override_dh_auto_clean: dh_auto_clean -- rm -fr obj-x86_64-linux-gnu go-dbus-factory-1.9.6/debian/source/000077500000000000000000000000001403054572700172655ustar00rootroot00000000000000go-dbus-factory-1.9.6/debian/source/format000066400000000000000000000000151403054572700204740ustar00rootroot000000000000003.0 (native) go-dbus-factory-1.9.6/docs/000077500000000000000000000000001403054572700154735ustar00rootroot00000000000000go-dbus-factory-1.9.6/docs/config.md000066400000000000000000000026321403054572700172650ustar00rootroot00000000000000 ```go type ServiceConfig struct { Service string // optional Objects []*ObjectConfig PropertyTypes []PropertyTypeConfig } type ObjectConfig struct { Type string Path string // optional XMLFile string // optional XMLFiles []string // optional Interfaces []*InterfaceConfig } type InterfaceConfig struct { Name string Type string Accessor string Fixes map[string]json.RawMessage TypeDefined bool } type PropertyTypeConfig struct { Type string ValueType string EmptyValue string } ``` ObjectConfig 的 XMLFiles 字段可以用 glob 通配符。 InterfaceConfig 中的Fixes 字段 map 的键值规则： 键根据不同对象选择不同的前缀，方法的为 "m/"，属性的为 "p/"，信号的为 "s/"。 如果以 "m/" 或 "s/" 开头，值部分为 []ArgFix。 ```go type ArgFix struct { Name string Type string } ``` 如果以 "p/" 开关，值部分为 PropertyFix。 ```go type PropertyFix struct { // PropertyTypeConfig 已展开 Type string ValueType string EmptyValue string RenameTo string RefType string } ``` Type 为属性的 Go 类型，一般为 "Prop" + interface 基本名 + 属性名。 ValueType 为属性值的 Go 类型。 EmptyValue 为属性值为空时的 Go 表示，如果 ValueType 以 "[]" 或 "map[" 开头，可以省略。可以使用 $T 指代 ValueType 的值。 RenameTo 重命名属性。 go-dbus-factory-1.9.6/fi.w1.wpa_supplicant1/000077500000000000000000000000001403054572700206005ustar00rootroot00000000000000go-dbus-factory-1.9.6/fi.w1.wpa_supplicant1/BSS.xml000066400000000000000000000042751403054572700217610ustar00rootroot00000000000000 go-dbus-factory-1.9.6/fi.w1.wpa_supplicant1/Interface.xml000066400000000000000000000553371403054572700232370ustar00rootroot00000000000000 go-dbus-factory-1.9.6/fi.w1.wpa_supplicant1/WPASupplicant.xml000066400000000000000000000046321403054572700240210ustar00rootroot00000000000000 go-dbus-factory-1.9.6/fi.w1.wpa_supplicant1/auto.go000066400000000000000000002643441403054572700221140ustar00rootroot00000000000000// Code generated by "./generator ./fi.w1.wpa_supplicant1"; DO NOT EDIT. package wpa_supplicant1 import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type WPASupplicant struct { wpaSupplicant // interface fi.w1.wpa_supplicant1 proxy.Object } func NewWPASupplicant(conn *dbus.Conn) *WPASupplicant { obj := new(WPASupplicant) obj.Object.Init_(conn, "fi.w1.wpa_supplicant1", "/fi/w1/wpa_supplicant1") return obj } type wpaSupplicant struct{} func (v *wpaSupplicant) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*wpaSupplicant) GetInterfaceName_() string { return "fi.w1.wpa_supplicant1" } // method CreateInterface func (v *wpaSupplicant) GoCreateInterface(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateInterface", flags, ch, args) } func (*wpaSupplicant) StoreCreateInterface(call *dbus.Call) (path dbus.ObjectPath, err error) { err = call.Store(&path) return } func (v *wpaSupplicant) CreateInterface(flags dbus.Flags, args map[string]dbus.Variant) (path dbus.ObjectPath, err error) { return v.StoreCreateInterface( <-v.GoCreateInterface(flags, make(chan *dbus.Call, 1), args).Done) } // method RemoveInterface func (v *wpaSupplicant) GoRemoveInterface(flags dbus.Flags, ch chan *dbus.Call, path dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemoveInterface", flags, ch, path) } func (v *wpaSupplicant) RemoveInterface(flags dbus.Flags, path dbus.ObjectPath) error { return (<-v.GoRemoveInterface(flags, make(chan *dbus.Call, 1), path).Done).Err } // method GetInterface func (v *wpaSupplicant) GoGetInterface(flags dbus.Flags, ch chan *dbus.Call, ifname string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetInterface", flags, ch, ifname) } func (*wpaSupplicant) StoreGetInterface(call *dbus.Call) (path dbus.ObjectPath, err error) { err = call.Store(&path) return } func (v *wpaSupplicant) GetInterface(flags dbus.Flags, ifname string) (path dbus.ObjectPath, err error) { return v.StoreGetInterface( <-v.GoGetInterface(flags, make(chan *dbus.Call, 1), ifname).Done) } // method ExpectDisconnect func (v *wpaSupplicant) GoExpectDisconnect(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ExpectDisconnect", flags, ch) } func (v *wpaSupplicant) ExpectDisconnect(flags dbus.Flags) error { return (<-v.GoExpectDisconnect(flags, make(chan *dbus.Call, 1)).Done).Err } // signal InterfaceAdded func (v *wpaSupplicant) ConnectInterfaceAdded(cb func(path dbus.ObjectPath, properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "InterfaceAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".InterfaceAdded", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &path, &properties) if err == nil { cb(path, properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal InterfaceRemoved func (v *wpaSupplicant) ConnectInterfaceRemoved(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "InterfaceRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".InterfaceRemoved", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal PropertiesChanged func (v *wpaSupplicant) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property DebugLevel s func (v *wpaSupplicant) DebugLevel() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DebugLevel", } } // property DebugTimestamp b func (v *wpaSupplicant) DebugTimestamp() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "DebugTimestamp", } } // property DebugShowKeys b func (v *wpaSupplicant) DebugShowKeys() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "DebugShowKeys", } } // property Interfaces ao func (v *wpaSupplicant) Interfaces() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Interfaces", } } // property EapMethods as func (v *wpaSupplicant) EapMethods() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "EapMethods", } } // property Capabilities as func (v *wpaSupplicant) Capabilities() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Capabilities", } } // property WFDIEs ay func (v *wpaSupplicant) WFDIEs() proxy.PropByteArray { return proxy.PropByteArray{ Impl: v, Name: "WFDIEs", } } type Interface struct { interface1 // interface fi.w1.wpa_supplicant1.Interface interfaceWPS // interface fi.w1.wpa_supplicant1.Interface.WPS interfaceP2PDevice // interface fi.w1.wpa_supplicant1.Interface.P2PDevice proxy.Object } func NewInterface(conn *dbus.Conn, path dbus.ObjectPath) (*Interface, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Interface) obj.Object.Init_(conn, "fi.w1.wpa_supplicant1", path) return obj, nil } func (obj *Interface) Interface() *interface1 { return &obj.interface1 } type interface1 struct{} func (v *interface1) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*interface1) GetInterfaceName_() string { return "fi.w1.wpa_supplicant1.Interface" } // method Scan func (v *interface1) GoScan(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Scan", flags, ch, args) } func (v *interface1) Scan(flags dbus.Flags, args map[string]dbus.Variant) error { return (<-v.GoScan(flags, make(chan *dbus.Call, 1), args).Done).Err } // method SignalPoll func (v *interface1) GoSignalPoll(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SignalPoll", flags, ch) } func (*interface1) StoreSignalPoll(call *dbus.Call) (args map[string]dbus.Variant, err error) { err = call.Store(&args) return } func (v *interface1) SignalPoll(flags dbus.Flags) (args map[string]dbus.Variant, err error) { return v.StoreSignalPoll( <-v.GoSignalPoll(flags, make(chan *dbus.Call, 1)).Done) } // method Disconnect func (v *interface1) GoDisconnect(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Disconnect", flags, ch) } func (v *interface1) Disconnect(flags dbus.Flags) error { return (<-v.GoDisconnect(flags, make(chan *dbus.Call, 1)).Done).Err } // method AddNetwork func (v *interface1) GoAddNetwork(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddNetwork", flags, ch, args) } func (*interface1) StoreAddNetwork(call *dbus.Call) (path dbus.ObjectPath, err error) { err = call.Store(&path) return } func (v *interface1) AddNetwork(flags dbus.Flags, args map[string]dbus.Variant) (path dbus.ObjectPath, err error) { return v.StoreAddNetwork( <-v.GoAddNetwork(flags, make(chan *dbus.Call, 1), args).Done) } // method Reassociate func (v *interface1) GoReassociate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reassociate", flags, ch) } func (v *interface1) Reassociate(flags dbus.Flags) error { return (<-v.GoReassociate(flags, make(chan *dbus.Call, 1)).Done).Err } // method Reattach func (v *interface1) GoReattach(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reattach", flags, ch) } func (v *interface1) Reattach(flags dbus.Flags) error { return (<-v.GoReattach(flags, make(chan *dbus.Call, 1)).Done).Err } // method Reconnect func (v *interface1) GoReconnect(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reconnect", flags, ch) } func (v *interface1) Reconnect(flags dbus.Flags) error { return (<-v.GoReconnect(flags, make(chan *dbus.Call, 1)).Done).Err } // method RemoveNetwork func (v *interface1) GoRemoveNetwork(flags dbus.Flags, ch chan *dbus.Call, path dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemoveNetwork", flags, ch, path) } func (v *interface1) RemoveNetwork(flags dbus.Flags, path dbus.ObjectPath) error { return (<-v.GoRemoveNetwork(flags, make(chan *dbus.Call, 1), path).Done).Err } // method RemoveAllNetworks func (v *interface1) GoRemoveAllNetworks(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemoveAllNetworks", flags, ch) } func (v *interface1) RemoveAllNetworks(flags dbus.Flags) error { return (<-v.GoRemoveAllNetworks(flags, make(chan *dbus.Call, 1)).Done).Err } // method SelectNetwork func (v *interface1) GoSelectNetwork(flags dbus.Flags, ch chan *dbus.Call, path dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SelectNetwork", flags, ch, path) } func (v *interface1) SelectNetwork(flags dbus.Flags, path dbus.ObjectPath) error { return (<-v.GoSelectNetwork(flags, make(chan *dbus.Call, 1), path).Done).Err } // method NetworkReply func (v *interface1) GoNetworkReply(flags dbus.Flags, ch chan *dbus.Call, path dbus.ObjectPath, field string, value string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".NetworkReply", flags, ch, path, field, value) } func (v *interface1) NetworkReply(flags dbus.Flags, path dbus.ObjectPath, field string, value string) error { return (<-v.GoNetworkReply(flags, make(chan *dbus.Call, 1), path, field, value).Done).Err } // method AddBlob func (v *interface1) GoAddBlob(flags dbus.Flags, ch chan *dbus.Call, name string, data []uint8) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddBlob", flags, ch, name, data) } func (v *interface1) AddBlob(flags dbus.Flags, name string, data []uint8) error { return (<-v.GoAddBlob(flags, make(chan *dbus.Call, 1), name, data).Done).Err } // method GetBlob func (v *interface1) GoGetBlob(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetBlob", flags, ch, name) } func (*interface1) StoreGetBlob(call *dbus.Call) (data []uint8, err error) { err = call.Store(&data) return } func (v *interface1) GetBlob(flags dbus.Flags, name string) (data []uint8, err error) { return v.StoreGetBlob( <-v.GoGetBlob(flags, make(chan *dbus.Call, 1), name).Done) } // method RemoveBlob func (v *interface1) GoRemoveBlob(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemoveBlob", flags, ch, name) } func (v *interface1) RemoveBlob(flags dbus.Flags, name string) error { return (<-v.GoRemoveBlob(flags, make(chan *dbus.Call, 1), name).Done).Err } // method SetPKCS11EngineAndModulePath func (v *interface1) GoSetPKCS11EngineAndModulePath(flags dbus.Flags, ch chan *dbus.Call, pkcs11_engine_path string, pkcs11_module_path string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetPKCS11EngineAndModulePath", flags, ch, pkcs11_engine_path, pkcs11_module_path) } func (v *interface1) SetPKCS11EngineAndModulePath(flags dbus.Flags, pkcs11_engine_path string, pkcs11_module_path string) error { return (<-v.GoSetPKCS11EngineAndModulePath(flags, make(chan *dbus.Call, 1), pkcs11_engine_path, pkcs11_module_path).Done).Err } // method FlushBSS func (v *interface1) GoFlushBSS(flags dbus.Flags, ch chan *dbus.Call, age uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FlushBSS", flags, ch, age) } func (v *interface1) FlushBSS(flags dbus.Flags, age uint32) error { return (<-v.GoFlushBSS(flags, make(chan *dbus.Call, 1), age).Done).Err } // method SubscribeProbeReq func (v *interface1) GoSubscribeProbeReq(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SubscribeProbeReq", flags, ch) } func (v *interface1) SubscribeProbeReq(flags dbus.Flags) error { return (<-v.GoSubscribeProbeReq(flags, make(chan *dbus.Call, 1)).Done).Err } // method UnsubscribeProbeReq func (v *interface1) GoUnsubscribeProbeReq(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnsubscribeProbeReq", flags, ch) } func (v *interface1) UnsubscribeProbeReq(flags dbus.Flags) error { return (<-v.GoUnsubscribeProbeReq(flags, make(chan *dbus.Call, 1)).Done).Err } // method EAPLogoff func (v *interface1) GoEAPLogoff(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EAPLogoff", flags, ch) } func (v *interface1) EAPLogoff(flags dbus.Flags) error { return (<-v.GoEAPLogoff(flags, make(chan *dbus.Call, 1)).Done).Err } // method EAPLogon func (v *interface1) GoEAPLogon(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EAPLogon", flags, ch) } func (v *interface1) EAPLogon(flags dbus.Flags) error { return (<-v.GoEAPLogon(flags, make(chan *dbus.Call, 1)).Done).Err } // method AutoScan func (v *interface1) GoAutoScan(flags dbus.Flags, ch chan *dbus.Call, arg string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AutoScan", flags, ch, arg) } func (v *interface1) AutoScan(flags dbus.Flags, arg string) error { return (<-v.GoAutoScan(flags, make(chan *dbus.Call, 1), arg).Done).Err } // method TDLSDiscover func (v *interface1) GoTDLSDiscover(flags dbus.Flags, ch chan *dbus.Call, peer_address string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TDLSDiscover", flags, ch, peer_address) } func (v *interface1) TDLSDiscover(flags dbus.Flags, peer_address string) error { return (<-v.GoTDLSDiscover(flags, make(chan *dbus.Call, 1), peer_address).Done).Err } // method TDLSSetup func (v *interface1) GoTDLSSetup(flags dbus.Flags, ch chan *dbus.Call, peer_address string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TDLSSetup", flags, ch, peer_address) } func (v *interface1) TDLSSetup(flags dbus.Flags, peer_address string) error { return (<-v.GoTDLSSetup(flags, make(chan *dbus.Call, 1), peer_address).Done).Err } // method TDLSStatus func (v *interface1) GoTDLSStatus(flags dbus.Flags, ch chan *dbus.Call, peer_address string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TDLSStatus", flags, ch, peer_address) } func (*interface1) StoreTDLSStatus(call *dbus.Call) (status string, err error) { err = call.Store(&status) return } func (v *interface1) TDLSStatus(flags dbus.Flags, peer_address string) (status string, err error) { return v.StoreTDLSStatus( <-v.GoTDLSStatus(flags, make(chan *dbus.Call, 1), peer_address).Done) } // method TDLSTeardown func (v *interface1) GoTDLSTeardown(flags dbus.Flags, ch chan *dbus.Call, peer_address string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TDLSTeardown", flags, ch, peer_address) } func (v *interface1) TDLSTeardown(flags dbus.Flags, peer_address string) error { return (<-v.GoTDLSTeardown(flags, make(chan *dbus.Call, 1), peer_address).Done).Err } // method TDLSChannelSwitch func (v *interface1) GoTDLSChannelSwitch(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TDLSChannelSwitch", flags, ch, args) } func (v *interface1) TDLSChannelSwitch(flags dbus.Flags, args map[string]dbus.Variant) error { return (<-v.GoTDLSChannelSwitch(flags, make(chan *dbus.Call, 1), args).Done).Err } // method TDLSCancelChannelSwitch func (v *interface1) GoTDLSCancelChannelSwitch(flags dbus.Flags, ch chan *dbus.Call, peer_address string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TDLSCancelChannelSwitch", flags, ch, peer_address) } func (v *interface1) TDLSCancelChannelSwitch(flags dbus.Flags, peer_address string) error { return (<-v.GoTDLSCancelChannelSwitch(flags, make(chan *dbus.Call, 1), peer_address).Done).Err } // method VendorElemAdd func (v *interface1) GoVendorElemAdd(flags dbus.Flags, ch chan *dbus.Call, frame_id int32, ielems []uint8) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".VendorElemAdd", flags, ch, frame_id, ielems) } func (v *interface1) VendorElemAdd(flags dbus.Flags, frame_id int32, ielems []uint8) error { return (<-v.GoVendorElemAdd(flags, make(chan *dbus.Call, 1), frame_id, ielems).Done).Err } // method VendorElemGet func (v *interface1) GoVendorElemGet(flags dbus.Flags, ch chan *dbus.Call, frame_id int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".VendorElemGet", flags, ch, frame_id) } func (*interface1) StoreVendorElemGet(call *dbus.Call) (ielems []uint8, err error) { err = call.Store(&ielems) return } func (v *interface1) VendorElemGet(flags dbus.Flags, frame_id int32) (ielems []uint8, err error) { return v.StoreVendorElemGet( <-v.GoVendorElemGet(flags, make(chan *dbus.Call, 1), frame_id).Done) } // method VendorElemRem func (v *interface1) GoVendorElemRem(flags dbus.Flags, ch chan *dbus.Call, frame_id int32, ielems []uint8) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".VendorElemRem", flags, ch, frame_id, ielems) } func (v *interface1) VendorElemRem(flags dbus.Flags, frame_id int32, ielems []uint8) error { return (<-v.GoVendorElemRem(flags, make(chan *dbus.Call, 1), frame_id, ielems).Done).Err } // method SaveConfig func (v *interface1) GoSaveConfig(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SaveConfig", flags, ch) } func (v *interface1) SaveConfig(flags dbus.Flags) error { return (<-v.GoSaveConfig(flags, make(chan *dbus.Call, 1)).Done).Err } // method AbortScan func (v *interface1) GoAbortScan(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AbortScan", flags, ch) } func (v *interface1) AbortScan(flags dbus.Flags) error { return (<-v.GoAbortScan(flags, make(chan *dbus.Call, 1)).Done).Err } // signal ScanDone func (v *interface1) ConnectScanDone(cb func(success bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ScanDone", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ScanDone", } handlerFunc := func(sig *dbus.Signal) { var success bool err := dbus.Store(sig.Body, &success) if err == nil { cb(success) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal BSSAdded func (v *interface1) ConnectBSSAdded(cb func(path dbus.ObjectPath, properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "BSSAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".BSSAdded", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &path, &properties) if err == nil { cb(path, properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal BSSRemoved func (v *interface1) ConnectBSSRemoved(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "BSSRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".BSSRemoved", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal BlobAdded func (v *interface1) ConnectBlobAdded(cb func(name string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "BlobAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".BlobAdded", } handlerFunc := func(sig *dbus.Signal) { var name string err := dbus.Store(sig.Body, &name) if err == nil { cb(name) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal BlobRemoved func (v *interface1) ConnectBlobRemoved(cb func(name string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "BlobRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".BlobRemoved", } handlerFunc := func(sig *dbus.Signal) { var name string err := dbus.Store(sig.Body, &name) if err == nil { cb(name) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal NetworkAdded func (v *interface1) ConnectNetworkAdded(cb func(path dbus.ObjectPath, properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NetworkAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NetworkAdded", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &path, &properties) if err == nil { cb(path, properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal NetworkRemoved func (v *interface1) ConnectNetworkRemoved(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NetworkRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NetworkRemoved", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal NetworkSelected func (v *interface1) ConnectNetworkSelected(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NetworkSelected", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NetworkSelected", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal PropertiesChanged func (v *interface1) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ProbeRequest func (v *interface1) ConnectProbeRequest(cb func(args map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ProbeRequest", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ProbeRequest", } handlerFunc := func(sig *dbus.Signal) { var args map[string]dbus.Variant err := dbus.Store(sig.Body, &args) if err == nil { cb(args) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Certification func (v *interface1) ConnectCertification(cb func(certification map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Certification", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Certification", } handlerFunc := func(sig *dbus.Signal) { var certification map[string]dbus.Variant err := dbus.Store(sig.Body, &certification) if err == nil { cb(certification) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal EAP func (v *interface1) ConnectEAP(cb func(status string, parameter string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "EAP", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".EAP", } handlerFunc := func(sig *dbus.Signal) { var status string var parameter string err := dbus.Store(sig.Body, &status, ¶meter) if err == nil { cb(status, parameter) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal StaAuthorized func (v *interface1) ConnectStaAuthorized(cb func(name string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "StaAuthorized", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".StaAuthorized", } handlerFunc := func(sig *dbus.Signal) { var name string err := dbus.Store(sig.Body, &name) if err == nil { cb(name) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal StaDeauthorized func (v *interface1) ConnectStaDeauthorized(cb func(name string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "StaDeauthorized", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".StaDeauthorized", } handlerFunc := func(sig *dbus.Signal) { var name string err := dbus.Store(sig.Body, &name) if err == nil { cb(name) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal StationAdded func (v *interface1) ConnectStationAdded(cb func(path dbus.ObjectPath, properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "StationAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".StationAdded", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &path, &properties) if err == nil { cb(path, properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal StationRemoved func (v *interface1) ConnectStationRemoved(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "StationRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".StationRemoved", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal NetworkRequest func (v *interface1) ConnectNetworkRequest(cb func(path dbus.ObjectPath, field string, text string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NetworkRequest", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NetworkRequest", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath var field string var text string err := dbus.Store(sig.Body, &path, &field, &text) if err == nil { cb(path, field, text) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Capabilities a{sv} func (v *interface1) Capabilities() MapStrVariant { return MapStrVariant{ Impl: v, Name: "Capabilities", } } // property State s func (v *interface1) State() proxy.PropString { return proxy.PropString{ Impl: v, Name: "State", } } // property Scanning b func (v *interface1) Scanning() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Scanning", } } // property ApScan u func (v *interface1) ApScan() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "ApScan", } } // property BSSExpireAge u func (v *interface1) BSSExpireAge() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "BSSExpireAge", } } // property BSSExpireCount u func (v *interface1) BSSExpireCount() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "BSSExpireCount", } } // property Country s func (v *interface1) Country() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Country", } } // property Ifname s func (v *interface1) Ifname() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Ifname", } } // property Driver s func (v *interface1) Driver() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Driver", } } // property BridgeIfname s func (v *interface1) BridgeIfname() proxy.PropString { return proxy.PropString{ Impl: v, Name: "BridgeIfname", } } // property ConfigFile s func (v *interface1) ConfigFile() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ConfigFile", } } // property CurrentBSS o func (v *interface1) CurrentBSS() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "CurrentBSS", } } // property CurrentNetwork o func (v *interface1) CurrentNetwork() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "CurrentNetwork", } } // property CurrentAuthMode s func (v *interface1) CurrentAuthMode() proxy.PropString { return proxy.PropString{ Impl: v, Name: "CurrentAuthMode", } } // property Blobs a{say} func (v *interface1) Blobs() PropInterfaceBlobs { return PropInterfaceBlobs{ Impl: v, } } type PropInterfaceBlobs struct { Impl proxy.Implementer } func (p PropInterfaceBlobs) Get(flags dbus.Flags) (value map[string][]byte, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Blobs", &value) return } func (p PropInterfaceBlobs) ConnectChanged(cb func(hasValue bool, value map[string][]byte)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[string][]byte err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Blobs", cb0) } // property BSSs ao func (v *interface1) BSSs() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "BSSs", } } // property Networks ao func (v *interface1) Networks() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Networks", } } // property FastReauth b func (v *interface1) FastReauth() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "FastReauth", } } // property ScanInterval i func (v *interface1) ScanInterval() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "ScanInterval", } } // property PKCS11EnginePath s func (v *interface1) PKCS11EnginePath() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PKCS11EnginePath", } } // property PKCS11ModulePath s func (v *interface1) PKCS11ModulePath() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PKCS11ModulePath", } } // property DisconnectReason i func (v *interface1) DisconnectReason() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "DisconnectReason", } } // property AuthStatusCode i func (v *interface1) AuthStatusCode() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "AuthStatusCode", } } // property AssocStatusCode i func (v *interface1) AssocStatusCode() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "AssocStatusCode", } } // property Stations ao func (v *interface1) Stations() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Stations", } } // property CtrlInterface s func (v *interface1) CtrlInterface() proxy.PropString { return proxy.PropString{ Impl: v, Name: "CtrlInterface", } } // property CtrlInterfaceGroup s func (v *interface1) CtrlInterfaceGroup() proxy.PropString { return proxy.PropString{ Impl: v, Name: "CtrlInterfaceGroup", } } // property EapolVersion s func (v *interface1) EapolVersion() proxy.PropString { return proxy.PropString{ Impl: v, Name: "EapolVersion", } } // property Bgscan s func (v *interface1) Bgscan() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Bgscan", } } // property DisableScanOffload s func (v *interface1) DisableScanOffload() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DisableScanOffload", } } // property OpenscEnginePath s func (v *interface1) OpenscEnginePath() proxy.PropString { return proxy.PropString{ Impl: v, Name: "OpenscEnginePath", } } // property OpensslCiphers s func (v *interface1) OpensslCiphers() proxy.PropString { return proxy.PropString{ Impl: v, Name: "OpensslCiphers", } } // property PcscReader s func (v *interface1) PcscReader() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PcscReader", } } // property PcscPin s func (v *interface1) PcscPin() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PcscPin", } } // property ExternalSim s func (v *interface1) ExternalSim() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ExternalSim", } } // property DriverParam s func (v *interface1) DriverParam() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DriverParam", } } // property Dot11RSNAConfigPMKLifetime s func (v *interface1) Dot11RSNAConfigPMKLifetime() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Dot11RSNAConfigPMKLifetime", } } // property Dot11RSNAConfigPMKReauthThreshold s func (v *interface1) Dot11RSNAConfigPMKReauthThreshold() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Dot11RSNAConfigPMKReauthThreshold", } } // property Dot11RSNAConfigSATimeout s func (v *interface1) Dot11RSNAConfigSATimeout() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Dot11RSNAConfigSATimeout", } } // property UpdateConfig s func (v *interface1) UpdateConfig() proxy.PropString { return proxy.PropString{ Impl: v, Name: "UpdateConfig", } } // property Uuid s func (v *interface1) Uuid() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Uuid", } } // property AutoUuid s func (v *interface1) AutoUuid() proxy.PropString { return proxy.PropString{ Impl: v, Name: "AutoUuid", } } // property DeviceName s func (v *interface1) DeviceName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DeviceName", } } // property Manufacturer s func (v *interface1) Manufacturer() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Manufacturer", } } // property ModelName s func (v *interface1) ModelName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ModelName", } } // property ModelNumber s func (v *interface1) ModelNumber() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ModelNumber", } } // property SerialNumber s func (v *interface1) SerialNumber() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SerialNumber", } } // property DeviceType s func (v *interface1) DeviceType() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DeviceType", } } // property OsVersion s func (v *interface1) OsVersion() proxy.PropString { return proxy.PropString{ Impl: v, Name: "OsVersion", } } // property ConfigMethods s func (v *interface1) ConfigMethods() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ConfigMethods", } } // property WpsCredProcessing s func (v *interface1) WpsCredProcessing() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WpsCredProcessing", } } // property WpsVendorExtM1 s func (v *interface1) WpsVendorExtM1() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WpsVendorExtM1", } } // property SecDeviceType s func (v *interface1) SecDeviceType() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SecDeviceType", } } // property P2pListenRegClass s func (v *interface1) P2pListenRegClass() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pListenRegClass", } } // property P2pListenChannel s func (v *interface1) P2pListenChannel() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pListenChannel", } } // property P2pOperRegClass s func (v *interface1) P2pOperRegClass() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pOperRegClass", } } // property P2pOperChannel s func (v *interface1) P2pOperChannel() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pOperChannel", } } // property P2pGoIntent s func (v *interface1) P2pGoIntent() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pGoIntent", } } // property P2pSsidPostfix s func (v *interface1) P2pSsidPostfix() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pSsidPostfix", } } // property PersistentReconnect s func (v *interface1) PersistentReconnect() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PersistentReconnect", } } // property P2pIntraBss s func (v *interface1) P2pIntraBss() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pIntraBss", } } // property P2pGroupIdle s func (v *interface1) P2pGroupIdle() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pGroupIdle", } } // property P2pGoFreqChangePolicy s func (v *interface1) P2pGoFreqChangePolicy() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pGoFreqChangePolicy", } } // property P2pPassphraseLen s func (v *interface1) P2pPassphraseLen() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pPassphraseLen", } } // property P2pPrefChan s func (v *interface1) P2pPrefChan() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pPrefChan", } } // property P2pNoGoFreq s func (v *interface1) P2pNoGoFreq() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pNoGoFreq", } } // property P2pAddCliChan s func (v *interface1) P2pAddCliChan() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pAddCliChan", } } // property P2pOptimizeListenChan s func (v *interface1) P2pOptimizeListenChan() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pOptimizeListenChan", } } // property P2pGoHt40 s func (v *interface1) P2pGoHt40() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pGoHt40", } } // property P2pGoVht s func (v *interface1) P2pGoVht() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pGoVht", } } // property P2pGoHe s func (v *interface1) P2pGoHe() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pGoHe", } } // property P2pDisabled s func (v *interface1) P2pDisabled() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pDisabled", } } // property P2pGoCtwindow s func (v *interface1) P2pGoCtwindow() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pGoCtwindow", } } // property P2pNoGroupIface s func (v *interface1) P2pNoGroupIface() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pNoGroupIface", } } // property P2pIgnoreSharedFreq s func (v *interface1) P2pIgnoreSharedFreq() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pIgnoreSharedFreq", } } // property IpAddrGo s func (v *interface1) IpAddrGo() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IpAddrGo", } } // property IpAddrMask s func (v *interface1) IpAddrMask() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IpAddrMask", } } // property IpAddrStart s func (v *interface1) IpAddrStart() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IpAddrStart", } } // property IpAddrEnd s func (v *interface1) IpAddrEnd() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IpAddrEnd", } } // property P2pCliProbe s func (v *interface1) P2pCliProbe() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pCliProbe", } } // property P2pDeviceRandomMacAddr s func (v *interface1) P2pDeviceRandomMacAddr() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pDeviceRandomMacAddr", } } // property P2pDevicePersistentMacAddr s func (v *interface1) P2pDevicePersistentMacAddr() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pDevicePersistentMacAddr", } } // property P2pInterfaceRandomMacAddr s func (v *interface1) P2pInterfaceRandomMacAddr() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pInterfaceRandomMacAddr", } } // property BssMaxCount s func (v *interface1) BssMaxCount() proxy.PropString { return proxy.PropString{ Impl: v, Name: "BssMaxCount", } } // property FilterSsids s func (v *interface1) FilterSsids() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FilterSsids", } } // property FilterRssi s func (v *interface1) FilterRssi() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FilterRssi", } } // property MaxNumSta s func (v *interface1) MaxNumSta() proxy.PropString { return proxy.PropString{ Impl: v, Name: "MaxNumSta", } } // property ApIsolate s func (v *interface1) ApIsolate() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ApIsolate", } } // property DisassocLowAck s func (v *interface1) DisassocLowAck() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DisassocLowAck", } } // property Hs20 s func (v *interface1) Hs20() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Hs20", } } // property Interworking s func (v *interface1) Interworking() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Interworking", } } // property Hessid s func (v *interface1) Hessid() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Hessid", } } // property AccessNetworkType s func (v *interface1) AccessNetworkType() proxy.PropString { return proxy.PropString{ Impl: v, Name: "AccessNetworkType", } } // property GoInterworking s func (v *interface1) GoInterworking() proxy.PropString { return proxy.PropString{ Impl: v, Name: "GoInterworking", } } // property GoAccessNetworkType s func (v *interface1) GoAccessNetworkType() proxy.PropString { return proxy.PropString{ Impl: v, Name: "GoAccessNetworkType", } } // property GoInternet s func (v *interface1) GoInternet() proxy.PropString { return proxy.PropString{ Impl: v, Name: "GoInternet", } } // property GoVenueGroup s func (v *interface1) GoVenueGroup() proxy.PropString { return proxy.PropString{ Impl: v, Name: "GoVenueGroup", } } // property GoVenueType s func (v *interface1) GoVenueType() proxy.PropString { return proxy.PropString{ Impl: v, Name: "GoVenueType", } } // property PbcInM1 s func (v *interface1) PbcInM1() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PbcInM1", } } // property Autoscan s func (v *interface1) Autoscan() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Autoscan", } } // property WpsNfcDevPwId s func (v *interface1) WpsNfcDevPwId() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WpsNfcDevPwId", } } // property WpsNfcDhPubkey s func (v *interface1) WpsNfcDhPubkey() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WpsNfcDhPubkey", } } // property WpsNfcDhPrivkey s func (v *interface1) WpsNfcDhPrivkey() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WpsNfcDhPrivkey", } } // property WpsNfcDevPw s func (v *interface1) WpsNfcDevPw() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WpsNfcDevPw", } } // property ExtPasswordBackend s func (v *interface1) ExtPasswordBackend() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ExtPasswordBackend", } } // property P2pGoMaxInactivity s func (v *interface1) P2pGoMaxInactivity() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pGoMaxInactivity", } } // property AutoInterworking s func (v *interface1) AutoInterworking() proxy.PropString { return proxy.PropString{ Impl: v, Name: "AutoInterworking", } } // property Okc s func (v *interface1) Okc() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Okc", } } // property Pmf s func (v *interface1) Pmf() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Pmf", } } // property SaeGroups s func (v *interface1) SaeGroups() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SaeGroups", } } // property DtimPeriod s func (v *interface1) DtimPeriod() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DtimPeriod", } } // property BeaconInt s func (v *interface1) BeaconInt() proxy.PropString { return proxy.PropString{ Impl: v, Name: "BeaconInt", } } // property ApVendorElements s func (v *interface1) ApVendorElements() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ApVendorElements", } } // property IgnoreOldScanRes s func (v *interface1) IgnoreOldScanRes() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IgnoreOldScanRes", } } // property FreqList s func (v *interface1) FreqList() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FreqList", } } // property ScanCurFreq s func (v *interface1) ScanCurFreq() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ScanCurFreq", } } // property SchedScanInterval s func (v *interface1) SchedScanInterval() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SchedScanInterval", } } // property SchedScanStartDelay s func (v *interface1) SchedScanStartDelay() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SchedScanStartDelay", } } // property TdlsExternalControl s func (v *interface1) TdlsExternalControl() proxy.PropString { return proxy.PropString{ Impl: v, Name: "TdlsExternalControl", } } // property OsuDir s func (v *interface1) OsuDir() proxy.PropString { return proxy.PropString{ Impl: v, Name: "OsuDir", } } // property WowlanTriggers s func (v *interface1) WowlanTriggers() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WowlanTriggers", } } // property P2pSearchDelay s func (v *interface1) P2pSearchDelay() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2pSearchDelay", } } // property MacAddr s func (v *interface1) MacAddr() proxy.PropString { return proxy.PropString{ Impl: v, Name: "MacAddr", } } // property RandAddrLifetime s func (v *interface1) RandAddrLifetime() proxy.PropString { return proxy.PropString{ Impl: v, Name: "RandAddrLifetime", } } // property PreassocMacAddr s func (v *interface1) PreassocMacAddr() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PreassocMacAddr", } } // property KeyMgmtOffload s func (v *interface1) KeyMgmtOffload() proxy.PropString { return proxy.PropString{ Impl: v, Name: "KeyMgmtOffload", } } // property PassiveScan s func (v *interface1) PassiveScan() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PassiveScan", } } // property ReassocSameBssOptim s func (v *interface1) ReassocSameBssOptim() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ReassocSameBssOptim", } } // property WpsPriority s func (v *interface1) WpsPriority() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WpsPriority", } } // property FstGroupId s func (v *interface1) FstGroupId() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FstGroupId", } } // property FstPriority s func (v *interface1) FstPriority() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FstPriority", } } // property FstLlt s func (v *interface1) FstLlt() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FstLlt", } } // property CertInCb s func (v *interface1) CertInCb() proxy.PropString { return proxy.PropString{ Impl: v, Name: "CertInCb", } } // property WpaRscRelaxation s func (v *interface1) WpaRscRelaxation() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WpaRscRelaxation", } } // property SchedScanPlans s func (v *interface1) SchedScanPlans() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SchedScanPlans", } } // property GasAddress3 s func (v *interface1) GasAddress3() proxy.PropString { return proxy.PropString{ Impl: v, Name: "GasAddress3", } } // property FtmResponder s func (v *interface1) FtmResponder() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FtmResponder", } } // property FtmInitiator s func (v *interface1) FtmInitiator() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FtmInitiator", } } // property GasRandAddrLifetime s func (v *interface1) GasRandAddrLifetime() proxy.PropString { return proxy.PropString{ Impl: v, Name: "GasRandAddrLifetime", } } // property GasRandMacAddr s func (v *interface1) GasRandMacAddr() proxy.PropString { return proxy.PropString{ Impl: v, Name: "GasRandMacAddr", } } // property DppConfigProcessing s func (v *interface1) DppConfigProcessing() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DppConfigProcessing", } } // property ColocIntfReporting s func (v *interface1) ColocIntfReporting() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ColocIntfReporting", } } func (obj *Interface) WPS() *interfaceWPS { return &obj.interfaceWPS } type interfaceWPS struct{} func (v *interfaceWPS) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*interfaceWPS) GetInterfaceName_() string { return "fi.w1.wpa_supplicant1.Interface.WPS" } // method Start func (v *interfaceWPS) GoStart(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Start", flags, ch, args) } func (*interfaceWPS) StoreStart(call *dbus.Call) (output map[string]dbus.Variant, err error) { err = call.Store(&output) return } func (v *interfaceWPS) Start(flags dbus.Flags, args map[string]dbus.Variant) (output map[string]dbus.Variant, err error) { return v.StoreStart( <-v.GoStart(flags, make(chan *dbus.Call, 1), args).Done) } // method Cancel func (v *interfaceWPS) GoCancel(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Cancel", flags, ch) } func (v *interfaceWPS) Cancel(flags dbus.Flags) error { return (<-v.GoCancel(flags, make(chan *dbus.Call, 1)).Done).Err } // signal Event func (v *interfaceWPS) ConnectEvent(cb func(name string, args map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Event", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Event", } handlerFunc := func(sig *dbus.Signal) { var name string var args map[string]dbus.Variant err := dbus.Store(sig.Body, &name, &args) if err == nil { cb(name, args) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Credentials func (v *interfaceWPS) ConnectCredentials(cb func(credentials map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Credentials", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Credentials", } handlerFunc := func(sig *dbus.Signal) { var credentials map[string]dbus.Variant err := dbus.Store(sig.Body, &credentials) if err == nil { cb(credentials) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal PropertiesChanged func (v *interfaceWPS) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property ProcessCredentials b func (v *interfaceWPS) ProcessCredentials() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ProcessCredentials", } } // property ConfigMethods s func (v *interfaceWPS) ConfigMethods() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ConfigMethods", } } // property DeviceName s func (v *interfaceWPS) DeviceName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DeviceName", } } // property Manufacturer s func (v *interfaceWPS) Manufacturer() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Manufacturer", } } // property ModelName s func (v *interfaceWPS) ModelName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ModelName", } } // property ModelNumber s func (v *interfaceWPS) ModelNumber() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ModelNumber", } } // property SerialNumber s func (v *interfaceWPS) SerialNumber() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SerialNumber", } } // property DeviceType ay func (v *interfaceWPS) DeviceType() proxy.PropByteArray { return proxy.PropByteArray{ Impl: v, Name: "DeviceType", } } func (obj *Interface) P2PDevice() *interfaceP2PDevice { return &obj.interfaceP2PDevice } type interfaceP2PDevice struct{} func (v *interfaceP2PDevice) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*interfaceP2PDevice) GetInterfaceName_() string { return "fi.w1.wpa_supplicant1.Interface.P2PDevice" } // method Find func (v *interfaceP2PDevice) GoFind(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Find", flags, ch, args) } func (v *interfaceP2PDevice) Find(flags dbus.Flags, args map[string]dbus.Variant) error { return (<-v.GoFind(flags, make(chan *dbus.Call, 1), args).Done).Err } // method StopFind func (v *interfaceP2PDevice) GoStopFind(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StopFind", flags, ch) } func (v *interfaceP2PDevice) StopFind(flags dbus.Flags) error { return (<-v.GoStopFind(flags, make(chan *dbus.Call, 1)).Done).Err } // method Listen func (v *interfaceP2PDevice) GoListen(flags dbus.Flags, ch chan *dbus.Call, timeout int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Listen", flags, ch, timeout) } func (v *interfaceP2PDevice) Listen(flags dbus.Flags, timeout int32) error { return (<-v.GoListen(flags, make(chan *dbus.Call, 1), timeout).Done).Err } // method ExtendedListen func (v *interfaceP2PDevice) GoExtendedListen(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ExtendedListen", flags, ch, args) } func (v *interfaceP2PDevice) ExtendedListen(flags dbus.Flags, args map[string]dbus.Variant) error { return (<-v.GoExtendedListen(flags, make(chan *dbus.Call, 1), args).Done).Err } // method PresenceRequest func (v *interfaceP2PDevice) GoPresenceRequest(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PresenceRequest", flags, ch, args) } func (v *interfaceP2PDevice) PresenceRequest(flags dbus.Flags, args map[string]dbus.Variant) error { return (<-v.GoPresenceRequest(flags, make(chan *dbus.Call, 1), args).Done).Err } // method ProvisionDiscoveryRequest func (v *interfaceP2PDevice) GoProvisionDiscoveryRequest(flags dbus.Flags, ch chan *dbus.Call, peer dbus.ObjectPath, config_method string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ProvisionDiscoveryRequest", flags, ch, peer, config_method) } func (v *interfaceP2PDevice) ProvisionDiscoveryRequest(flags dbus.Flags, peer dbus.ObjectPath, config_method string) error { return (<-v.GoProvisionDiscoveryRequest(flags, make(chan *dbus.Call, 1), peer, config_method).Done).Err } // method Connect func (v *interfaceP2PDevice) GoConnect(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Connect", flags, ch, args) } func (*interfaceP2PDevice) StoreConnect(call *dbus.Call) (generated_pin string, err error) { err = call.Store(&generated_pin) return } func (v *interfaceP2PDevice) Connect(flags dbus.Flags, args map[string]dbus.Variant) (generated_pin string, err error) { return v.StoreConnect( <-v.GoConnect(flags, make(chan *dbus.Call, 1), args).Done) } // method GroupAdd func (v *interfaceP2PDevice) GoGroupAdd(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GroupAdd", flags, ch, args) } func (v *interfaceP2PDevice) GroupAdd(flags dbus.Flags, args map[string]dbus.Variant) error { return (<-v.GoGroupAdd(flags, make(chan *dbus.Call, 1), args).Done).Err } // method Cancel func (v *interfaceP2PDevice) GoCancel(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Cancel", flags, ch) } func (v *interfaceP2PDevice) Cancel(flags dbus.Flags) error { return (<-v.GoCancel(flags, make(chan *dbus.Call, 1)).Done).Err } // method Invite func (v *interfaceP2PDevice) GoInvite(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Invite", flags, ch, args) } func (v *interfaceP2PDevice) Invite(flags dbus.Flags, args map[string]dbus.Variant) error { return (<-v.GoInvite(flags, make(chan *dbus.Call, 1), args).Done).Err } // method Disconnect func (v *interfaceP2PDevice) GoDisconnect(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Disconnect", flags, ch) } func (v *interfaceP2PDevice) Disconnect(flags dbus.Flags) error { return (<-v.GoDisconnect(flags, make(chan *dbus.Call, 1)).Done).Err } // method RejectPeer func (v *interfaceP2PDevice) GoRejectPeer(flags dbus.Flags, ch chan *dbus.Call, peer dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RejectPeer", flags, ch, peer) } func (v *interfaceP2PDevice) RejectPeer(flags dbus.Flags, peer dbus.ObjectPath) error { return (<-v.GoRejectPeer(flags, make(chan *dbus.Call, 1), peer).Done).Err } // method RemoveClient func (v *interfaceP2PDevice) GoRemoveClient(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemoveClient", flags, ch, args) } func (v *interfaceP2PDevice) RemoveClient(flags dbus.Flags, args map[string]dbus.Variant) error { return (<-v.GoRemoveClient(flags, make(chan *dbus.Call, 1), args).Done).Err } // method Flush func (v *interfaceP2PDevice) GoFlush(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Flush", flags, ch) } func (v *interfaceP2PDevice) Flush(flags dbus.Flags) error { return (<-v.GoFlush(flags, make(chan *dbus.Call, 1)).Done).Err } // method AddService func (v *interfaceP2PDevice) GoAddService(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddService", flags, ch, args) } func (v *interfaceP2PDevice) AddService(flags dbus.Flags, args map[string]dbus.Variant) error { return (<-v.GoAddService(flags, make(chan *dbus.Call, 1), args).Done).Err } // method DeleteService func (v *interfaceP2PDevice) GoDeleteService(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteService", flags, ch, args) } func (v *interfaceP2PDevice) DeleteService(flags dbus.Flags, args map[string]dbus.Variant) error { return (<-v.GoDeleteService(flags, make(chan *dbus.Call, 1), args).Done).Err } // method FlushService func (v *interfaceP2PDevice) GoFlushService(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FlushService", flags, ch) } func (v *interfaceP2PDevice) FlushService(flags dbus.Flags) error { return (<-v.GoFlushService(flags, make(chan *dbus.Call, 1)).Done).Err } // method ServiceDiscoveryRequest func (v *interfaceP2PDevice) GoServiceDiscoveryRequest(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ServiceDiscoveryRequest", flags, ch, args) } func (*interfaceP2PDevice) StoreServiceDiscoveryRequest(call *dbus.Call) (ref uint64, err error) { err = call.Store(&ref) return } func (v *interfaceP2PDevice) ServiceDiscoveryRequest(flags dbus.Flags, args map[string]dbus.Variant) (ref uint64, err error) { return v.StoreServiceDiscoveryRequest( <-v.GoServiceDiscoveryRequest(flags, make(chan *dbus.Call, 1), args).Done) } // method ServiceDiscoveryResponse func (v *interfaceP2PDevice) GoServiceDiscoveryResponse(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ServiceDiscoveryResponse", flags, ch, args) } func (v *interfaceP2PDevice) ServiceDiscoveryResponse(flags dbus.Flags, args map[string]dbus.Variant) error { return (<-v.GoServiceDiscoveryResponse(flags, make(chan *dbus.Call, 1), args).Done).Err } // method ServiceDiscoveryCancelRequest func (v *interfaceP2PDevice) GoServiceDiscoveryCancelRequest(flags dbus.Flags, ch chan *dbus.Call, args uint64) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ServiceDiscoveryCancelRequest", flags, ch, args) } func (v *interfaceP2PDevice) ServiceDiscoveryCancelRequest(flags dbus.Flags, args uint64) error { return (<-v.GoServiceDiscoveryCancelRequest(flags, make(chan *dbus.Call, 1), args).Done).Err } // method ServiceUpdate func (v *interfaceP2PDevice) GoServiceUpdate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ServiceUpdate", flags, ch) } func (v *interfaceP2PDevice) ServiceUpdate(flags dbus.Flags) error { return (<-v.GoServiceUpdate(flags, make(chan *dbus.Call, 1)).Done).Err } // method ServiceDiscoveryExternal func (v *interfaceP2PDevice) GoServiceDiscoveryExternal(flags dbus.Flags, ch chan *dbus.Call, arg int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ServiceDiscoveryExternal", flags, ch, arg) } func (v *interfaceP2PDevice) ServiceDiscoveryExternal(flags dbus.Flags, arg int32) error { return (<-v.GoServiceDiscoveryExternal(flags, make(chan *dbus.Call, 1), arg).Done).Err } // method AddPersistentGroup func (v *interfaceP2PDevice) GoAddPersistentGroup(flags dbus.Flags, ch chan *dbus.Call, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddPersistentGroup", flags, ch, args) } func (*interfaceP2PDevice) StoreAddPersistentGroup(call *dbus.Call) (path dbus.ObjectPath, err error) { err = call.Store(&path) return } func (v *interfaceP2PDevice) AddPersistentGroup(flags dbus.Flags, args map[string]dbus.Variant) (path dbus.ObjectPath, err error) { return v.StoreAddPersistentGroup( <-v.GoAddPersistentGroup(flags, make(chan *dbus.Call, 1), args).Done) } // method RemovePersistentGroup func (v *interfaceP2PDevice) GoRemovePersistentGroup(flags dbus.Flags, ch chan *dbus.Call, path dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemovePersistentGroup", flags, ch, path) } func (v *interfaceP2PDevice) RemovePersistentGroup(flags dbus.Flags, path dbus.ObjectPath) error { return (<-v.GoRemovePersistentGroup(flags, make(chan *dbus.Call, 1), path).Done).Err } // method RemoveAllPersistentGroups func (v *interfaceP2PDevice) GoRemoveAllPersistentGroups(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemoveAllPersistentGroups", flags, ch) } func (v *interfaceP2PDevice) RemoveAllPersistentGroups(flags dbus.Flags) error { return (<-v.GoRemoveAllPersistentGroups(flags, make(chan *dbus.Call, 1)).Done).Err } // signal DeviceFound func (v *interfaceP2PDevice) ConnectDeviceFound(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "DeviceFound", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".DeviceFound", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal DeviceFoundProperties func (v *interfaceP2PDevice) ConnectDeviceFoundProperties(cb func(path dbus.ObjectPath, properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "DeviceFoundProperties", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".DeviceFoundProperties", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &path, &properties) if err == nil { cb(path, properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal DeviceLost func (v *interfaceP2PDevice) ConnectDeviceLost(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "DeviceLost", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".DeviceLost", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal FindStopped func (v *interfaceP2PDevice) ConnectFindStopped(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "FindStopped", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".FindStopped", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ProvisionDiscoveryRequestDisplayPin func (v *interfaceP2PDevice) ConnectProvisionDiscoveryRequestDisplayPin(cb func(peer_object dbus.ObjectPath, pin string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ProvisionDiscoveryRequestDisplayPin", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ProvisionDiscoveryRequestDisplayPin", } handlerFunc := func(sig *dbus.Signal) { var peer_object dbus.ObjectPath var pin string err := dbus.Store(sig.Body, &peer_object, &pin) if err == nil { cb(peer_object, pin) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ProvisionDiscoveryResponseDisplayPin func (v *interfaceP2PDevice) ConnectProvisionDiscoveryResponseDisplayPin(cb func(peer_object dbus.ObjectPath, pin string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ProvisionDiscoveryResponseDisplayPin", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ProvisionDiscoveryResponseDisplayPin", } handlerFunc := func(sig *dbus.Signal) { var peer_object dbus.ObjectPath var pin string err := dbus.Store(sig.Body, &peer_object, &pin) if err == nil { cb(peer_object, pin) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ProvisionDiscoveryRequestEnterPin func (v *interfaceP2PDevice) ConnectProvisionDiscoveryRequestEnterPin(cb func(peer_object dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ProvisionDiscoveryRequestEnterPin", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ProvisionDiscoveryRequestEnterPin", } handlerFunc := func(sig *dbus.Signal) { var peer_object dbus.ObjectPath err := dbus.Store(sig.Body, &peer_object) if err == nil { cb(peer_object) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ProvisionDiscoveryResponseEnterPin func (v *interfaceP2PDevice) ConnectProvisionDiscoveryResponseEnterPin(cb func(peer_object dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ProvisionDiscoveryResponseEnterPin", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ProvisionDiscoveryResponseEnterPin", } handlerFunc := func(sig *dbus.Signal) { var peer_object dbus.ObjectPath err := dbus.Store(sig.Body, &peer_object) if err == nil { cb(peer_object) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ProvisionDiscoveryPBCRequest func (v *interfaceP2PDevice) ConnectProvisionDiscoveryPBCRequest(cb func(peer_object dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ProvisionDiscoveryPBCRequest", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ProvisionDiscoveryPBCRequest", } handlerFunc := func(sig *dbus.Signal) { var peer_object dbus.ObjectPath err := dbus.Store(sig.Body, &peer_object) if err == nil { cb(peer_object) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ProvisionDiscoveryPBCResponse func (v *interfaceP2PDevice) ConnectProvisionDiscoveryPBCResponse(cb func(peer_object dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ProvisionDiscoveryPBCResponse", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ProvisionDiscoveryPBCResponse", } handlerFunc := func(sig *dbus.Signal) { var peer_object dbus.ObjectPath err := dbus.Store(sig.Body, &peer_object) if err == nil { cb(peer_object) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ProvisionDiscoveryFailure func (v *interfaceP2PDevice) ConnectProvisionDiscoveryFailure(cb func(peer_object dbus.ObjectPath, status int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ProvisionDiscoveryFailure", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ProvisionDiscoveryFailure", } handlerFunc := func(sig *dbus.Signal) { var peer_object dbus.ObjectPath var status int32 err := dbus.Store(sig.Body, &peer_object, &status) if err == nil { cb(peer_object, status) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal GroupStarted func (v *interfaceP2PDevice) ConnectGroupStarted(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "GroupStarted", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".GroupStarted", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal GroupFormationFailure func (v *interfaceP2PDevice) ConnectGroupFormationFailure(cb func(reason string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "GroupFormationFailure", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".GroupFormationFailure", } handlerFunc := func(sig *dbus.Signal) { var reason string err := dbus.Store(sig.Body, &reason) if err == nil { cb(reason) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal GONegotiationSuccess func (v *interfaceP2PDevice) ConnectGONegotiationSuccess(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "GONegotiationSuccess", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".GONegotiationSuccess", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal GONegotiationFailure func (v *interfaceP2PDevice) ConnectGONegotiationFailure(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "GONegotiationFailure", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".GONegotiationFailure", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal GONegotiationRequest func (v *interfaceP2PDevice) ConnectGONegotiationRequest(cb func(path dbus.ObjectPath, dev_passwd_id uint16, device_go_intent uint8)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "GONegotiationRequest", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".GONegotiationRequest", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath var dev_passwd_id uint16 var device_go_intent uint8 err := dbus.Store(sig.Body, &path, &dev_passwd_id, &device_go_intent) if err == nil { cb(path, dev_passwd_id, device_go_intent) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal InvitationResult func (v *interfaceP2PDevice) ConnectInvitationResult(cb func(invite_result map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "InvitationResult", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".InvitationResult", } handlerFunc := func(sig *dbus.Signal) { var invite_result map[string]dbus.Variant err := dbus.Store(sig.Body, &invite_result) if err == nil { cb(invite_result) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal GroupFinished func (v *interfaceP2PDevice) ConnectGroupFinished(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "GroupFinished", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".GroupFinished", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ServiceDiscoveryRequest func (v *interfaceP2PDevice) ConnectServiceDiscoveryRequest(cb func(sd_request map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ServiceDiscoveryRequest", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ServiceDiscoveryRequest", } handlerFunc := func(sig *dbus.Signal) { var sd_request map[string]dbus.Variant err := dbus.Store(sig.Body, &sd_request) if err == nil { cb(sd_request) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ServiceDiscoveryResponse func (v *interfaceP2PDevice) ConnectServiceDiscoveryResponse(cb func(sd_response map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ServiceDiscoveryResponse", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ServiceDiscoveryResponse", } handlerFunc := func(sig *dbus.Signal) { var sd_response map[string]dbus.Variant err := dbus.Store(sig.Body, &sd_response) if err == nil { cb(sd_response) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal PersistentGroupAdded func (v *interfaceP2PDevice) ConnectPersistentGroupAdded(cb func(path dbus.ObjectPath, properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PersistentGroupAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PersistentGroupAdded", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &path, &properties) if err == nil { cb(path, properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal PersistentGroupRemoved func (v *interfaceP2PDevice) ConnectPersistentGroupRemoved(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PersistentGroupRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PersistentGroupRemoved", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal WpsFailed func (v *interfaceP2PDevice) ConnectWpsFailed(cb func(name string, args map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "WpsFailed", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".WpsFailed", } handlerFunc := func(sig *dbus.Signal) { var name string var args map[string]dbus.Variant err := dbus.Store(sig.Body, &name, &args) if err == nil { cb(name, args) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal InvitationReceived func (v *interfaceP2PDevice) ConnectInvitationReceived(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "InvitationReceived", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".InvitationReceived", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property P2PDeviceConfig a{sv} func (v *interfaceP2PDevice) P2PDeviceConfig() MapStrVariant { return MapStrVariant{ Impl: v, Name: "P2PDeviceConfig", } } // property Peers ao func (v *interfaceP2PDevice) Peers() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Peers", } } // property Role s func (v *interfaceP2PDevice) Role() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Role", } } // property Group o func (v *interfaceP2PDevice) Group() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Group", } } // property PeerGO o func (v *interfaceP2PDevice) PeerGO() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "PeerGO", } } // property PersistentGroups ao func (v *interfaceP2PDevice) PersistentGroups() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "PersistentGroups", } } type BSS struct { bss // interface fi.w1.wpa_supplicant1.BSS proxy.Object } func NewBSS(conn *dbus.Conn, path dbus.ObjectPath) (*BSS, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(BSS) obj.Object.Init_(conn, "fi.w1.wpa_supplicant1", path) return obj, nil } type bss struct{} func (v *bss) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*bss) GetInterfaceName_() string { return "fi.w1.wpa_supplicant1.BSS" } // signal PropertiesChanged func (v *bss) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property SSID ay func (v *bss) SSID() proxy.PropByteArray { return proxy.PropByteArray{ Impl: v, Name: "SSID", } } // property BSSID ay func (v *bss) BSSID() proxy.PropByteArray { return proxy.PropByteArray{ Impl: v, Name: "BSSID", } } // property Privacy b func (v *bss) Privacy() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Privacy", } } // property Mode s func (v *bss) Mode() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Mode", } } // property Signal n func (v *bss) Signal() proxy.PropInt16 { return proxy.PropInt16{ Impl: v, Name: "Signal", } } // property Frequency q func (v *bss) Frequency() proxy.PropUint16 { return proxy.PropUint16{ Impl: v, Name: "Frequency", } } // property Rates au func (v *bss) Rates() proxy.PropUint32Array { return proxy.PropUint32Array{ Impl: v, Name: "Rates", } } // property WPA a{sv} func (v *bss) WPA() MapStrVariant { return MapStrVariant{ Impl: v, Name: "WPA", } } // property RSN a{sv} func (v *bss) RSN() MapStrVariant { return MapStrVariant{ Impl: v, Name: "RSN", } } // property WPS a{sv} func (v *bss) WPS() MapStrVariant { return MapStrVariant{ Impl: v, Name: "WPS", } } // property IEs ay func (v *bss) IEs() proxy.PropByteArray { return proxy.PropByteArray{ Impl: v, Name: "IEs", } } // property Age u func (v *bss) Age() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Age", } } type MapStrVariant struct { Impl proxy.Implementer Name string } func (p MapStrVariant) Get(flags dbus.Flags) (value map[string]dbus.Variant, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p MapStrVariant) Set(flags dbus.Flags, value map[string]dbus.Variant) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p MapStrVariant) ConnectChanged(cb func(hasValue bool, value map[string]dbus.Variant)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[string]dbus.Variant err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } go-dbus-factory-1.9.6/fi.w1.wpa_supplicant1/config.json000066400000000000000000000030161403054572700227400ustar00rootroot00000000000000{ "Service": "fi.w1.wpa_supplicant1", "Objects": [ { "Type": "WPASupplicant", "Path": "/fi/w1/wpa_supplicant1", "Interfaces": [ { "Name": "fi.w1.wpa_supplicant1", "Type": "wpaSupplicant" } ] }, { "Type": "Interface", "Interfaces": [ { "Name": "fi.w1.wpa_supplicant1.Interface", "Type": "interface1", "Fixes": { "p/Capabilities": { "RefType": "MapStrVariant" }, "p/Blobs": { "ValueType": "map[string][]byte" } } }, { "Name": "fi.w1.wpa_supplicant1.Interface.WPS", "Type": "interfaceWPS" }, { "Name": "fi.w1.wpa_supplicant1.Interface.P2PDevice", "Type": "interfaceP2PDevice", "Fixes": { "p/P2PDeviceConfig": { "RefType": "MapStrVariant" } } } ] }, { "Type": "BSS", "Interfaces": [ { "Name": "fi.w1.wpa_supplicant1.BSS", "Type": "bss", "Fixes": { "p/WPS": { "RefType": "MapStrVariant" }, "p/WPA": { "RefType": "MapStrVariant" }, "p/RSN": { "RefType": "MapStrVariant" } } } ] } ], "PropertyTypes": [ { "Type": "MapStrVariant", "ValueType": "map[string]dbus.Variant" } ] } go-dbus-factory-1.9.6/gen.sh000077500000000000000000000002361403054572700156540ustar00rootroot00000000000000#!/bin/bash set -e for dir in `find -maxdepth 1 -type d`; do if [ -f $dir/config.json ]; then ./generator $dir pushd $dir go build -v popd fi done go-dbus-factory-1.9.6/net.hadess.sensorproxy/000077500000000000000000000000001403054572700212115ustar00rootroot00000000000000go-dbus-factory-1.9.6/net.hadess.sensorproxy/SensorProxy.xml000066400000000000000000000040401403054572700242440ustar00rootroot00000000000000 go-dbus-factory-1.9.6/net.hadess.sensorproxy/auto.go000066400000000000000000000054061403054572700225150ustar00rootroot00000000000000// Code generated by "./generator ./net.hadess.sensorproxy"; DO NOT EDIT. package sensorproxy import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type SensorProxy struct { sensorProxy // interface net.hadess.SensorProxy proxy.Object } func NewSensorProxy(conn *dbus.Conn) *SensorProxy { obj := new(SensorProxy) obj.Object.Init_(conn, "net.hadess.SensorProxy", "/net/hadess/SensorProxy") return obj } type sensorProxy struct{} func (v *sensorProxy) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*sensorProxy) GetInterfaceName_() string { return "net.hadess.SensorProxy" } // method ClaimAccelerometer func (v *sensorProxy) GoClaimAccelerometer(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ClaimAccelerometer", flags, ch) } func (v *sensorProxy) ClaimAccelerometer(flags dbus.Flags) error { return (<-v.GoClaimAccelerometer(flags, make(chan *dbus.Call, 1)).Done).Err } // method ReleaseAccelerometer func (v *sensorProxy) GoReleaseAccelerometer(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReleaseAccelerometer", flags, ch) } func (v *sensorProxy) ReleaseAccelerometer(flags dbus.Flags) error { return (<-v.GoReleaseAccelerometer(flags, make(chan *dbus.Call, 1)).Done).Err } // method ClaimLight func (v *sensorProxy) GoClaimLight(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ClaimLight", flags, ch) } func (v *sensorProxy) ClaimLight(flags dbus.Flags) error { return (<-v.GoClaimLight(flags, make(chan *dbus.Call, 1)).Done).Err } // method ReleaseLight func (v *sensorProxy) GoReleaseLight(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReleaseLight", flags, ch) } func (v *sensorProxy) ReleaseLight(flags dbus.Flags) error { return (<-v.GoReleaseLight(flags, make(chan *dbus.Call, 1)).Done).Err } // property HasAccelerometer b func (v *sensorProxy) HasAccelerometer() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "HasAccelerometer", } } // property AccelerometerOrientation s func (v *sensorProxy) AccelerometerOrientation() proxy.PropString { return proxy.PropString{ Impl: v, Name: "AccelerometerOrientation", } } // property HasAmbientLight b func (v *sensorProxy) HasAmbientLight() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "HasAmbientLight", } } // property LightLevelUnit s func (v *sensorProxy) LightLevelUnit() proxy.PropString { return proxy.PropString{ Impl: v, Name: "LightLevelUnit", } } // property LightLevel d func (v *sensorProxy) LightLevel() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "LightLevel", } } go-dbus-factory-1.9.6/net.hadess.sensorproxy/config.json000066400000000000000000000004161403054572700233520ustar00rootroot00000000000000{ "Service": "net.hadess.SensorProxy", "Objects": [ { "Type": "SensorProxy", "Path": "/net/hadess/SensorProxy", "Interfaces": [ { "Type": "sensorProxy", "Name": "net.hadess.SensorProxy" } ] } ] } go-dbus-factory-1.9.6/net.reactivated.fprint/000077500000000000000000000000001403054572700211245ustar00rootroot00000000000000go-dbus-factory-1.9.6/net.reactivated.fprint/Device.xml000066400000000000000000000043761403054572700230570ustar00rootroot00000000000000 go-dbus-factory-1.9.6/net.reactivated.fprint/Manager.xml000066400000000000000000000022631403054572700232230ustar00rootroot00000000000000 go-dbus-factory-1.9.6/net.reactivated.fprint/auto.go000066400000000000000000000200611403054572700224220ustar00rootroot00000000000000// Code generated by "./generator ./net.reactivated.fprint"; DO NOT EDIT. package fprint import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Manager struct { manager // interface net.reactivated.Fprint.Manager proxy.Object } func NewManager(conn *dbus.Conn) *Manager { obj := new(Manager) obj.Object.Init_(conn, "net.reactivated.Fprint", "/net/reactivated/Fprint/Manager") return obj } type manager struct{} func (v *manager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*manager) GetInterfaceName_() string { return "net.reactivated.Fprint.Manager" } // method GetDefaultDevice func (v *manager) GoGetDefaultDevice(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDefaultDevice", flags, ch) } func (*manager) StoreGetDefaultDevice(call *dbus.Call) (device dbus.ObjectPath, err error) { err = call.Store(&device) return } func (v *manager) GetDefaultDevice(flags dbus.Flags) (device dbus.ObjectPath, err error) { return v.StoreGetDefaultDevice( <-v.GoGetDefaultDevice(flags, make(chan *dbus.Call, 1)).Done) } // method GetDevices func (v *manager) GoGetDevices(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDevices", flags, ch) } func (*manager) StoreGetDevices(call *dbus.Call) (devices []dbus.ObjectPath, err error) { err = call.Store(&devices) return } func (v *manager) GetDevices(flags dbus.Flags) (devices []dbus.ObjectPath, err error) { return v.StoreGetDevices( <-v.GoGetDevices(flags, make(chan *dbus.Call, 1)).Done) } type Device struct { device // interface net.reactivated.Fprint.Device proxy.Object } func NewDevice(conn *dbus.Conn, path dbus.ObjectPath) (*Device, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Device) obj.Object.Init_(conn, "net.reactivated.Fprint", path) return obj, nil } type device struct{} func (v *device) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*device) GetInterfaceName_() string { return "net.reactivated.Fprint.Device" } // method EnrollStop func (v *device) GoEnrollStop(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnrollStop", flags, ch) } func (v *device) EnrollStop(flags dbus.Flags) error { return (<-v.GoEnrollStop(flags, make(chan *dbus.Call, 1)).Done).Err } // method EnrollStart func (v *device) GoEnrollStart(flags dbus.Flags, ch chan *dbus.Call, finger_name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnrollStart", flags, ch, finger_name) } func (v *device) EnrollStart(flags dbus.Flags, finger_name string) error { return (<-v.GoEnrollStart(flags, make(chan *dbus.Call, 1), finger_name).Done).Err } // method VerifyStop func (v *device) GoVerifyStop(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".VerifyStop", flags, ch) } func (v *device) VerifyStop(flags dbus.Flags) error { return (<-v.GoVerifyStop(flags, make(chan *dbus.Call, 1)).Done).Err } // method VerifyStart func (v *device) GoVerifyStart(flags dbus.Flags, ch chan *dbus.Call, finger_name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".VerifyStart", flags, ch, finger_name) } func (v *device) VerifyStart(flags dbus.Flags, finger_name string) error { return (<-v.GoVerifyStart(flags, make(chan *dbus.Call, 1), finger_name).Done).Err } // method Release func (v *device) GoRelease(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Release", flags, ch) } func (v *device) Release(flags dbus.Flags) error { return (<-v.GoRelease(flags, make(chan *dbus.Call, 1)).Done).Err } // method Claim func (v *device) GoClaim(flags dbus.Flags, ch chan *dbus.Call, username string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Claim", flags, ch, username) } func (v *device) Claim(flags dbus.Flags, username string) error { return (<-v.GoClaim(flags, make(chan *dbus.Call, 1), username).Done).Err } // method DeleteEnrolledFingers func (v *device) GoDeleteEnrolledFingers(flags dbus.Flags, ch chan *dbus.Call, username string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteEnrolledFingers", flags, ch, username) } func (v *device) DeleteEnrolledFingers(flags dbus.Flags, username string) error { return (<-v.GoDeleteEnrolledFingers(flags, make(chan *dbus.Call, 1), username).Done).Err } // method DeleteEnrolledFinger func (v *device) GoDeleteEnrolledFinger(flags dbus.Flags, ch chan *dbus.Call, username string, finger_name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteEnrolledFinger", flags, ch, username, finger_name) } func (v *device) DeleteEnrolledFinger(flags dbus.Flags, username string, finger_name string) error { return (<-v.GoDeleteEnrolledFinger(flags, make(chan *dbus.Call, 1), username, finger_name).Done).Err } // method ListEnrolledFingers func (v *device) GoListEnrolledFingers(flags dbus.Flags, ch chan *dbus.Call, username string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListEnrolledFingers", flags, ch, username) } func (*device) StoreListEnrolledFingers(call *dbus.Call) (enrolled_fingers []string, err error) { err = call.Store(&enrolled_fingers) return } func (v *device) ListEnrolledFingers(flags dbus.Flags, username string) (enrolled_fingers []string, err error) { return v.StoreListEnrolledFingers( <-v.GoListEnrolledFingers(flags, make(chan *dbus.Call, 1), username).Done) } // signal EnrollStatus func (v *device) ConnectEnrollStatus(cb func(arg0 string, arg1 bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "EnrollStatus", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".EnrollStatus", } handlerFunc := func(sig *dbus.Signal) { var arg0 string var arg1 bool err := dbus.Store(sig.Body, &arg0, &arg1) if err == nil { cb(arg0, arg1) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal VerifyStatus func (v *device) ConnectVerifyStatus(cb func(arg0 string, arg1 bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VerifyStatus", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VerifyStatus", } handlerFunc := func(sig *dbus.Signal) { var arg0 string var arg1 bool err := dbus.Store(sig.Body, &arg0, &arg1) if err == nil { cb(arg0, arg1) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal VerifyFingerSelected func (v *device) ConnectVerifyFingerSelected(cb func(arg0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VerifyFingerSelected", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VerifyFingerSelected", } handlerFunc := func(sig *dbus.Signal) { var arg0 string err := dbus.Store(sig.Body, &arg0) if err == nil { cb(arg0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property scan-type s func (v *device) ScanType() proxy.PropString { return proxy.PropString{ Impl: v, Name: "scan-type", } } // property num-enroll-stages i func (v *device) NumEnrollStages() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "num-enroll-stages", } } // property name s func (v *device) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "name", } } go-dbus-factory-1.9.6/net.reactivated.fprint/config.json000066400000000000000000000013251403054572700232650ustar00rootroot00000000000000{ "Service": "net.reactivated.Fprint", "Objects": [ { "Type": "Manager", "Path": "/net/reactivated/Fprint/Manager", "Interfaces": [ { "Name": "net.reactivated.Fprint.Manager", "Type": "manager" } ] }, { "Type": "Device", "Interfaces": [ { "Name": "net.reactivated.Fprint.Device", "Type": "device", "Fixes": { "p/scan-type": { "RenameTo": "ScanType" }, "p/num-enroll-stages": { "RenameTo": "NumEnrollStages" }, "p/name": { "RenameTo": "Name" } } } ] } ] } go-dbus-factory-1.9.6/object_manager/000077500000000000000000000000001403054572700175035ustar00rootroot00000000000000go-dbus-factory-1.9.6/object_manager/objectmanager.go000066400000000000000000000054111403054572700226340ustar00rootroot00000000000000package object_manager import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type ObjectManager struct{} func (v *ObjectManager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*ObjectManager) GetInterfaceName_() string { return "org.freedesktop.DBus.ObjectManager" } // method GetManagedObjects func (v *ObjectManager) GoGetManagedObjects(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetManagedObjects", flags, ch) } func (*ObjectManager) StoreGetManagedObjects(call *dbus.Call) (object_paths_interfaces_and_properties map[dbus.ObjectPath]map[string]map[string]dbus.Variant, err error) { err = call.Store(&object_paths_interfaces_and_properties) return } func (v *ObjectManager) GetManagedObjects(flags dbus.Flags) (object_paths_interfaces_and_properties map[dbus.ObjectPath]map[string]map[string]dbus.Variant, err error) { return v.StoreGetManagedObjects( <-v.GoGetManagedObjects(flags, make(chan *dbus.Call, 1)).Done) } // signal InterfacesAdded func (v *ObjectManager) ConnectInterfacesAdded(cb func(object_path dbus.ObjectPath, interfaces_and_properties map[string]map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "InterfacesAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".InterfacesAdded", } handlerFunc := func(sig *dbus.Signal) { var object_path dbus.ObjectPath var interfaces_and_properties map[string]map[string]dbus.Variant err := dbus.Store(sig.Body, &object_path, &interfaces_and_properties) if err == nil { cb(object_path, interfaces_and_properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal InterfacesRemoved func (v *ObjectManager) ConnectInterfacesRemoved(cb func(object_path dbus.ObjectPath, interfaces []string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "InterfacesRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".InterfacesRemoved", } handlerFunc := func(sig *dbus.Signal) { var object_path dbus.ObjectPath var interfaces []string err := dbus.Store(sig.Body, &object_path, &interfaces) if err == nil { cb(object_path, interfaces) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/org.ayatana.bamf/000077500000000000000000000000001403054572700176535ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.ayatana.bamf/Application.xml000066400000000000000000000126771403054572700226550ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.ayatana.bamf/Control.xml000066400000000000000000000040161403054572700220160ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.ayatana.bamf/Matcher.xml000066400000000000000000000073361403054572700217710ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.ayatana.bamf/Window.xml000066400000000000000000000120611403054572700216440ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.ayatana.bamf/auto.go000066400000000000000000001103731403054572700211570ustar00rootroot00000000000000// Code generated by "./generator ./org.ayatana.bamf"; DO NOT EDIT. package bamf import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Control struct { control // interface org.ayatana.bamf.control proxy.Object } func NewControl(conn *dbus.Conn) *Control { obj := new(Control) obj.Object.Init_(conn, "org.ayatana.bamf", "/org/ayatana/bamf/control") return obj } type control struct{} func (v *control) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*control) GetInterfaceName_() string { return "org.ayatana.bamf.control" } // method Quit func (v *control) GoQuit(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Quit", flags, ch) } func (v *control) Quit(flags dbus.Flags) error { return (<-v.GoQuit(flags, make(chan *dbus.Call, 1)).Done).Err } // method InsertDesktopFile func (v *control) GoInsertDesktopFile(flags dbus.Flags, ch chan *dbus.Call, desktop_path string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".InsertDesktopFile", flags, ch, desktop_path) } func (v *control) InsertDesktopFile(flags dbus.Flags, desktop_path string) error { return (<-v.GoInsertDesktopFile(flags, make(chan *dbus.Call, 1), desktop_path).Done).Err } // method RegisterApplicationForPid func (v *control) GoRegisterApplicationForPid(flags dbus.Flags, ch chan *dbus.Call, application string, pid int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterApplicationForPid", flags, ch, application, pid) } func (v *control) RegisterApplicationForPid(flags dbus.Flags, application string, pid int32) error { return (<-v.GoRegisterApplicationForPid(flags, make(chan *dbus.Call, 1), application, pid).Done).Err } // method CreateLocalDesktopFile func (v *control) GoCreateLocalDesktopFile(flags dbus.Flags, ch chan *dbus.Call, application string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateLocalDesktopFile", flags, ch, application) } func (v *control) CreateLocalDesktopFile(flags dbus.Flags, application string) error { return (<-v.GoCreateLocalDesktopFile(flags, make(chan *dbus.Call, 1), application).Done).Err } // method OmNomNomDesktopFile func (v *control) GoOmNomNomDesktopFile(flags dbus.Flags, ch chan *dbus.Call, desktop_path string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".OmNomNomDesktopFile", flags, ch, desktop_path) } func (v *control) OmNomNomDesktopFile(flags dbus.Flags, desktop_path string) error { return (<-v.GoOmNomNomDesktopFile(flags, make(chan *dbus.Call, 1), desktop_path).Done).Err } type Matcher struct { matcher // interface org.ayatana.bamf.matcher proxy.Object } func NewMatcher(conn *dbus.Conn) *Matcher { obj := new(Matcher) obj.Object.Init_(conn, "org.ayatana.bamf", "/org/ayatana/bamf/matcher") return obj } type matcher struct{} func (v *matcher) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*matcher) GetInterfaceName_() string { return "org.ayatana.bamf.matcher" } // method XidsForApplication func (v *matcher) GoXidsForApplication(flags dbus.Flags, ch chan *dbus.Call, desktop_file string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".XidsForApplication", flags, ch, desktop_file) } func (*matcher) StoreXidsForApplication(call *dbus.Call) (xids []uint32, err error) { err = call.Store(&xids) return } func (v *matcher) XidsForApplication(flags dbus.Flags, desktop_file string) (xids []uint32, err error) { return v.StoreXidsForApplication( <-v.GoXidsForApplication(flags, make(chan *dbus.Call, 1), desktop_file).Done) } // method TabPaths func (v *matcher) GoTabPaths(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TabPaths", flags, ch) } func (*matcher) StoreTabPaths(call *dbus.Call) (paths []string, err error) { err = call.Store(&paths) return } func (v *matcher) TabPaths(flags dbus.Flags) (paths []string, err error) { return v.StoreTabPaths( <-v.GoTabPaths(flags, make(chan *dbus.Call, 1)).Done) } // method RunningApplications func (v *matcher) GoRunningApplications(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RunningApplications", flags, ch) } func (*matcher) StoreRunningApplications(call *dbus.Call) (paths []string, err error) { err = call.Store(&paths) return } func (v *matcher) RunningApplications(flags dbus.Flags) (paths []string, err error) { return v.StoreRunningApplications( <-v.GoRunningApplications(flags, make(chan *dbus.Call, 1)).Done) } // method RunningApplicationsDesktopFiles func (v *matcher) GoRunningApplicationsDesktopFiles(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RunningApplicationsDesktopFiles", flags, ch) } func (*matcher) StoreRunningApplicationsDesktopFiles(call *dbus.Call) (paths []string, err error) { err = call.Store(&paths) return } func (v *matcher) RunningApplicationsDesktopFiles(flags dbus.Flags) (paths []string, err error) { return v.StoreRunningApplicationsDesktopFiles( <-v.GoRunningApplicationsDesktopFiles(flags, make(chan *dbus.Call, 1)).Done) } // method RegisterFavorites func (v *matcher) GoRegisterFavorites(flags dbus.Flags, ch chan *dbus.Call, favorites []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterFavorites", flags, ch, favorites) } func (v *matcher) RegisterFavorites(flags dbus.Flags, favorites []string) error { return (<-v.GoRegisterFavorites(flags, make(chan *dbus.Call, 1), favorites).Done).Err } // method PathForApplication func (v *matcher) GoPathForApplication(flags dbus.Flags, ch chan *dbus.Call, desktop_file string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PathForApplication", flags, ch, desktop_file) } func (*matcher) StorePathForApplication(call *dbus.Call) (path string, err error) { err = call.Store(&path) return } func (v *matcher) PathForApplication(flags dbus.Flags, desktop_file string) (path string, err error) { return v.StorePathForApplication( <-v.GoPathForApplication(flags, make(chan *dbus.Call, 1), desktop_file).Done) } // method WindowPaths func (v *matcher) GoWindowPaths(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".WindowPaths", flags, ch) } func (*matcher) StoreWindowPaths(call *dbus.Call) (paths []string, err error) { err = call.Store(&paths) return } func (v *matcher) WindowPaths(flags dbus.Flags) (paths []string, err error) { return v.StoreWindowPaths( <-v.GoWindowPaths(flags, make(chan *dbus.Call, 1)).Done) } // method ApplicationPaths func (v *matcher) GoApplicationPaths(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ApplicationPaths", flags, ch) } func (*matcher) StoreApplicationPaths(call *dbus.Call) (paths []string, err error) { err = call.Store(&paths) return } func (v *matcher) ApplicationPaths(flags dbus.Flags) (paths []string, err error) { return v.StoreApplicationPaths( <-v.GoApplicationPaths(flags, make(chan *dbus.Call, 1)).Done) } // method ApplicationIsRunning func (v *matcher) GoApplicationIsRunning(flags dbus.Flags, ch chan *dbus.Call, desktop_file string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ApplicationIsRunning", flags, ch, desktop_file) } func (*matcher) StoreApplicationIsRunning(call *dbus.Call) (running bool, err error) { err = call.Store(&running) return } func (v *matcher) ApplicationIsRunning(flags dbus.Flags, desktop_file string) (running bool, err error) { return v.StoreApplicationIsRunning( <-v.GoApplicationIsRunning(flags, make(chan *dbus.Call, 1), desktop_file).Done) } // method ApplicationForXid func (v *matcher) GoApplicationForXid(flags dbus.Flags, ch chan *dbus.Call, xid uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ApplicationForXid", flags, ch, xid) } func (*matcher) StoreApplicationForXid(call *dbus.Call) (application string, err error) { err = call.Store(&application) return } func (v *matcher) ApplicationForXid(flags dbus.Flags, xid uint32) (application string, err error) { return v.StoreApplicationForXid( <-v.GoApplicationForXid(flags, make(chan *dbus.Call, 1), xid).Done) } // method ActiveWindow func (v *matcher) GoActiveWindow(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ActiveWindow", flags, ch) } func (*matcher) StoreActiveWindow(call *dbus.Call) (window string, err error) { err = call.Store(&window) return } func (v *matcher) ActiveWindow(flags dbus.Flags) (window string, err error) { return v.StoreActiveWindow( <-v.GoActiveWindow(flags, make(chan *dbus.Call, 1)).Done) } // method ActiveApplication func (v *matcher) GoActiveApplication(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ActiveApplication", flags, ch) } func (*matcher) StoreActiveApplication(call *dbus.Call) (application string, err error) { err = call.Store(&application) return } func (v *matcher) ActiveApplication(flags dbus.Flags) (application string, err error) { return v.StoreActiveApplication( <-v.GoActiveApplication(flags, make(chan *dbus.Call, 1)).Done) } // method WindowStackForMonitor func (v *matcher) GoWindowStackForMonitor(flags dbus.Flags, ch chan *dbus.Call, monitor_id int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".WindowStackForMonitor", flags, ch, monitor_id) } func (*matcher) StoreWindowStackForMonitor(call *dbus.Call) (window_list []string, err error) { err = call.Store(&window_list) return } func (v *matcher) WindowStackForMonitor(flags dbus.Flags, monitor_id int32) (window_list []string, err error) { return v.StoreWindowStackForMonitor( <-v.GoWindowStackForMonitor(flags, make(chan *dbus.Call, 1), monitor_id).Done) } // signal ActiveApplicationChanged func (v *matcher) ConnectActiveApplicationChanged(cb func(old_app string, new_app string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ActiveApplicationChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ActiveApplicationChanged", } handlerFunc := func(sig *dbus.Signal) { var old_app string var new_app string err := dbus.Store(sig.Body, &old_app, &new_app) if err == nil { cb(old_app, new_app) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ActiveWindowChanged func (v *matcher) ConnectActiveWindowChanged(cb func(old_win string, new_win string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ActiveWindowChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ActiveWindowChanged", } handlerFunc := func(sig *dbus.Signal) { var old_win string var new_win string err := dbus.Store(sig.Body, &old_win, &new_win) if err == nil { cb(old_win, new_win) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ViewClosed func (v *matcher) ConnectViewClosed(cb func(path string, type0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ViewClosed", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ViewClosed", } handlerFunc := func(sig *dbus.Signal) { var path string var type0 string err := dbus.Store(sig.Body, &path, &type0) if err == nil { cb(path, type0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ViewOpened func (v *matcher) ConnectViewOpened(cb func(path string, type0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ViewOpened", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ViewOpened", } handlerFunc := func(sig *dbus.Signal) { var path string var type0 string err := dbus.Store(sig.Body, &path, &type0) if err == nil { cb(path, type0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal StackingOrderChanged func (v *matcher) ConnectStackingOrderChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "StackingOrderChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".StackingOrderChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal RunningApplicationsChanged func (v *matcher) ConnectRunningApplicationsChanged(cb func(opened_desktop_files []string, closed_desktop_files []string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "RunningApplicationsChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".RunningApplicationsChanged", } handlerFunc := func(sig *dbus.Signal) { var opened_desktop_files []string var closed_desktop_files []string err := dbus.Store(sig.Body, &opened_desktop_files, &closed_desktop_files) if err == nil { cb(opened_desktop_files, closed_desktop_files) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } type Application struct { application // interface org.ayatana.bamf.application view // interface org.ayatana.bamf.view proxy.Object } func NewApplication(conn *dbus.Conn, path dbus.ObjectPath) (*Application, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Application) obj.Object.Init_(conn, "org.ayatana.bamf", path) return obj, nil } func (obj *Application) Application() *application { return &obj.application } type application struct{} func (v *application) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*application) GetInterfaceName_() string { return "org.ayatana.bamf.application" } // method ShowStubs func (v *application) GoShowStubs(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ShowStubs", flags, ch) } func (*application) StoreShowStubs(call *dbus.Call) (show_stubs bool, err error) { err = call.Store(&show_stubs) return } func (v *application) ShowStubs(flags dbus.Flags) (show_stubs bool, err error) { return v.StoreShowStubs( <-v.GoShowStubs(flags, make(chan *dbus.Call, 1)).Done) } // method Xids func (v *application) GoXids(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Xids", flags, ch) } func (*application) StoreXids(call *dbus.Call) (xids []uint32, err error) { err = call.Store(&xids) return } func (v *application) Xids(flags dbus.Flags) (xids []uint32, err error) { return v.StoreXids( <-v.GoXids(flags, make(chan *dbus.Call, 1)).Done) } // method DesktopFile func (v *application) GoDesktopFile(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DesktopFile", flags, ch) } func (*application) StoreDesktopFile(call *dbus.Call) (desktop_file string, err error) { err = call.Store(&desktop_file) return } func (v *application) DesktopFile(flags dbus.Flags) (desktop_file string, err error) { return v.StoreDesktopFile( <-v.GoDesktopFile(flags, make(chan *dbus.Call, 1)).Done) } // method SupportedMimeTypes func (v *application) GoSupportedMimeTypes(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SupportedMimeTypes", flags, ch) } func (*application) StoreSupportedMimeTypes(call *dbus.Call) (mime_types []string, err error) { err = call.Store(&mime_types) return } func (v *application) SupportedMimeTypes(flags dbus.Flags) (mime_types []string, err error) { return v.StoreSupportedMimeTypes( <-v.GoSupportedMimeTypes(flags, make(chan *dbus.Call, 1)).Done) } // method ApplicationType func (v *application) GoApplicationType(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ApplicationType", flags, ch) } func (*application) StoreApplicationType(call *dbus.Call) (type0 string, err error) { err = call.Store(&type0) return } func (v *application) ApplicationType(flags dbus.Flags) (type0 string, err error) { return v.StoreApplicationType( <-v.GoApplicationType(flags, make(chan *dbus.Call, 1)).Done) } // method ApplicationMenu func (v *application) GoApplicationMenu(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ApplicationMenu", flags, ch) } func (*application) StoreApplicationMenu(call *dbus.Call) (busname string, objectpath string, err error) { err = call.Store(&busname, &objectpath) return } func (v *application) ApplicationMenu(flags dbus.Flags) (busname string, objectpath string, err error) { return v.StoreApplicationMenu( <-v.GoApplicationMenu(flags, make(chan *dbus.Call, 1)).Done) } // method FocusableChild func (v *application) GoFocusableChild(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FocusableChild", flags, ch) } func (*application) StoreFocusableChild(call *dbus.Call) (path string, err error) { err = call.Store(&path) return } func (v *application) FocusableChild(flags dbus.Flags) (path string, err error) { return v.StoreFocusableChild( <-v.GoFocusableChild(flags, make(chan *dbus.Call, 1)).Done) } // signal WindowRemoved func (v *application) ConnectWindowRemoved(cb func(path string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "WindowRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".WindowRemoved", } handlerFunc := func(sig *dbus.Signal) { var path string err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal WindowAdded func (v *application) ConnectWindowAdded(cb func(path string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "WindowAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".WindowAdded", } handlerFunc := func(sig *dbus.Signal) { var path string err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal SupportedMimeTypesChanged func (v *application) ConnectSupportedMimeTypesChanged(cb func(dnd_mimes []string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SupportedMimeTypesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SupportedMimeTypesChanged", } handlerFunc := func(sig *dbus.Signal) { var dnd_mimes []string err := dbus.Store(sig.Body, &dnd_mimes) if err == nil { cb(dnd_mimes) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal DesktopFileUpdated func (v *application) ConnectDesktopFileUpdated(cb func(desktop_file string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "DesktopFileUpdated", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".DesktopFileUpdated", } handlerFunc := func(sig *dbus.Signal) { var desktop_file string err := dbus.Store(sig.Body, &desktop_file) if err == nil { cb(desktop_file) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } func (obj *Application) View() *view { return &obj.view } type view struct{} func (v *view) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*view) GetInterfaceName_() string { return "org.ayatana.bamf.view" } // method ViewType func (v *view) GoViewType(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ViewType", flags, ch) } func (*view) StoreViewType(call *dbus.Call) (view_type string, err error) { err = call.Store(&view_type) return } func (v *view) ViewType(flags dbus.Flags) (view_type string, err error) { return v.StoreViewType( <-v.GoViewType(flags, make(chan *dbus.Call, 1)).Done) } // method Icon func (v *view) GoIcon(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Icon", flags, ch) } func (*view) StoreIcon(call *dbus.Call) (name string, err error) { err = call.Store(&name) return } func (v *view) Icon(flags dbus.Flags) (name string, err error) { return v.StoreIcon( <-v.GoIcon(flags, make(chan *dbus.Call, 1)).Done) } // method Name func (v *view) GoName(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Name", flags, ch) } func (*view) StoreName(call *dbus.Call) (name string, err error) { err = call.Store(&name) return } func (v *view) Name(flags dbus.Flags) (name string, err error) { return v.StoreName( <-v.GoName(flags, make(chan *dbus.Call, 1)).Done) } // method UserVisible func (v *view) GoUserVisible(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UserVisible", flags, ch) } func (*view) StoreUserVisible(call *dbus.Call) (visible bool, err error) { err = call.Store(&visible) return } func (v *view) UserVisible(flags dbus.Flags) (visible bool, err error) { return v.StoreUserVisible( <-v.GoUserVisible(flags, make(chan *dbus.Call, 1)).Done) } // method IsUrgent func (v *view) GoIsUrgent(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsUrgent", flags, ch) } func (*view) StoreIsUrgent(call *dbus.Call) (urgent bool, err error) { err = call.Store(&urgent) return } func (v *view) IsUrgent(flags dbus.Flags) (urgent bool, err error) { return v.StoreIsUrgent( <-v.GoIsUrgent(flags, make(chan *dbus.Call, 1)).Done) } // method IsRunning func (v *view) GoIsRunning(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsRunning", flags, ch) } func (*view) StoreIsRunning(call *dbus.Call) (running bool, err error) { err = call.Store(&running) return } func (v *view) IsRunning(flags dbus.Flags) (running bool, err error) { return v.StoreIsRunning( <-v.GoIsRunning(flags, make(chan *dbus.Call, 1)).Done) } // method IsActive func (v *view) GoIsActive(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".IsActive", flags, ch) } func (*view) StoreIsActive(call *dbus.Call) (active bool, err error) { err = call.Store(&active) return } func (v *view) IsActive(flags dbus.Flags) (active bool, err error) { return v.StoreIsActive( <-v.GoIsActive(flags, make(chan *dbus.Call, 1)).Done) } // method Parents func (v *view) GoParents(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Parents", flags, ch) } func (*view) StoreParents(call *dbus.Call) (parents_paths []string, err error) { err = call.Store(&parents_paths) return } func (v *view) Parents(flags dbus.Flags) (parents_paths []string, err error) { return v.StoreParents( <-v.GoParents(flags, make(chan *dbus.Call, 1)).Done) } // method Children func (v *view) GoChildren(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Children", flags, ch) } func (*view) StoreChildren(call *dbus.Call) (children_paths []string, err error) { err = call.Store(&children_paths) return } func (v *view) Children(flags dbus.Flags) (children_paths []string, err error) { return v.StoreChildren( <-v.GoChildren(flags, make(chan *dbus.Call, 1)).Done) } // signal NameChanged func (v *view) ConnectNameChanged(cb func(old_name string, new_name string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NameChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NameChanged", } handlerFunc := func(sig *dbus.Signal) { var old_name string var new_name string err := dbus.Store(sig.Body, &old_name, &new_name) if err == nil { cb(old_name, new_name) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal UserVisibleChanged func (v *view) ConnectUserVisibleChanged(cb func(user_visible bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "UserVisibleChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".UserVisibleChanged", } handlerFunc := func(sig *dbus.Signal) { var user_visible bool err := dbus.Store(sig.Body, &user_visible) if err == nil { cb(user_visible) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal UrgentChanged func (v *view) ConnectUrgentChanged(cb func(is_urgent bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "UrgentChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".UrgentChanged", } handlerFunc := func(sig *dbus.Signal) { var is_urgent bool err := dbus.Store(sig.Body, &is_urgent) if err == nil { cb(is_urgent) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal RunningChanged func (v *view) ConnectRunningChanged(cb func(is_running bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "RunningChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".RunningChanged", } handlerFunc := func(sig *dbus.Signal) { var is_running bool err := dbus.Store(sig.Body, &is_running) if err == nil { cb(is_running) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ActiveChanged func (v *view) ConnectActiveChanged(cb func(is_active bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ActiveChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ActiveChanged", } handlerFunc := func(sig *dbus.Signal) { var is_active bool err := dbus.Store(sig.Body, &is_active) if err == nil { cb(is_active) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ChildRemoved func (v *view) ConnectChildRemoved(cb func(path string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ChildRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ChildRemoved", } handlerFunc := func(sig *dbus.Signal) { var path string err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ChildAdded func (v *view) ConnectChildAdded(cb func(path string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ChildAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ChildAdded", } handlerFunc := func(sig *dbus.Signal) { var path string err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Closed func (v *view) ConnectClosed(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Closed", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Closed", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Name s func (v *view) PropName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property Icon s func (v *view) PropIcon() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Icon", } } // property UserVisible b func (v *view) PropUserVisible() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "UserVisible", } } // property Running b func (v *view) Running() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Running", } } // property Starting b func (v *view) Starting() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Starting", } } // property Urgent b func (v *view) Urgent() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Urgent", } } // property Active b func (v *view) Active() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Active", } } type Window struct { window // interface org.ayatana.bamf.window view // interface org.ayatana.bamf.view proxy.Object } func NewWindow(conn *dbus.Conn, path dbus.ObjectPath) (*Window, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Window) obj.Object.Init_(conn, "org.ayatana.bamf", path) return obj, nil } func (obj *Window) Window() *window { return &obj.window } type window struct{} func (v *window) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*window) GetInterfaceName_() string { return "org.ayatana.bamf.window" } // method GetXid func (v *window) GoGetXid(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetXid", flags, ch) } func (*window) StoreGetXid(call *dbus.Call) (xid uint32, err error) { err = call.Store(&xid) return } func (v *window) GetXid(flags dbus.Flags) (xid uint32, err error) { return v.StoreGetXid( <-v.GoGetXid(flags, make(chan *dbus.Call, 1)).Done) } // method GetPid func (v *window) GoGetPid(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetPid", flags, ch) } func (*window) StoreGetPid(call *dbus.Call) (pid uint32, err error) { err = call.Store(&pid) return } func (v *window) GetPid(flags dbus.Flags) (pid uint32, err error) { return v.StoreGetPid( <-v.GoGetPid(flags, make(chan *dbus.Call, 1)).Done) } // method Transient func (v *window) GoTransient(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Transient", flags, ch) } func (*window) StoreTransient(call *dbus.Call) (path string, err error) { err = call.Store(&path) return } func (v *window) Transient(flags dbus.Flags) (path string, err error) { return v.StoreTransient( <-v.GoTransient(flags, make(chan *dbus.Call, 1)).Done) } // method WindowType func (v *window) GoWindowType(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".WindowType", flags, ch) } func (*window) StoreWindowType(call *dbus.Call) (type0 uint32, err error) { err = call.Store(&type0) return } func (v *window) WindowType(flags dbus.Flags) (type0 uint32, err error) { return v.StoreWindowType( <-v.GoWindowType(flags, make(chan *dbus.Call, 1)).Done) } // method Xprop func (v *window) GoXprop(flags dbus.Flags, ch chan *dbus.Call, xprop string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Xprop", flags, ch, xprop) } func (*window) StoreXprop(call *dbus.Call) (name string, err error) { err = call.Store(&name) return } func (v *window) Xprop(flags dbus.Flags, xprop string) (name string, err error) { return v.StoreXprop( <-v.GoXprop(flags, make(chan *dbus.Call, 1), xprop).Done) } // method Monitor func (v *window) GoMonitor(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Monitor", flags, ch) } func (*window) StoreMonitor(call *dbus.Call) (monitor_number int32, err error) { err = call.Store(&monitor_number) return } func (v *window) Monitor(flags dbus.Flags) (monitor_number int32, err error) { return v.StoreMonitor( <-v.GoMonitor(flags, make(chan *dbus.Call, 1)).Done) } // method Maximized func (v *window) GoMaximized(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Maximized", flags, ch) } func (*window) StoreMaximized(call *dbus.Call) (maximized int32, err error) { err = call.Store(&maximized) return } func (v *window) Maximized(flags dbus.Flags) (maximized int32, err error) { return v.StoreMaximized( <-v.GoMaximized(flags, make(chan *dbus.Call, 1)).Done) } // signal MonitorChanged func (v *window) ConnectMonitorChanged(cb func(old int32, new int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "MonitorChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".MonitorChanged", } handlerFunc := func(sig *dbus.Signal) { var old int32 var new int32 err := dbus.Store(sig.Body, &old, &new) if err == nil { cb(old, new) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal MaximizedChanged func (v *window) ConnectMaximizedChanged(cb func(old int32, new int32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "MaximizedChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".MaximizedChanged", } handlerFunc := func(sig *dbus.Signal) { var old int32 var new int32 err := dbus.Store(sig.Body, &old, &new) if err == nil { cb(old, new) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/org.ayatana.bamf/config.json000066400000000000000000000017551403054572700220230ustar00rootroot00000000000000{ "Service": "org.ayatana.bamf", "Objects": [ { "Type": "Control", "Path": "/org/ayatana/bamf/control", "Interfaces": [ { "Name": "org.ayatana.bamf.control", "Type": "control" } ] }, { "Type": "Matcher", "Path": "/org/ayatana/bamf/matcher", "Interfaces": [ { "Name": "org.ayatana.bamf.matcher", "Type": "matcher" } ] }, { "Type":"Application", "Interfaces": [ { "Name": "org.ayatana.bamf.application", "Type":"application" }, { "Name": "org.ayatana.bamf.view", "Type": "view" } ] }, { "Type": "Window", "Interfaces": [ { "Name": "org.ayatana.bamf.window", "Type": "window" }, { "Name": "org.ayatana.bamf.view", "Type": "view", "TypeDefined": true } ] } ] } go-dbus-factory-1.9.6/org.bluez.obex/000077500000000000000000000000001403054572700174065ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.bluez.obex/Manager.xml000066400000000000000000000015421403054572700215040ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.bluez.obex/Session.xml000066400000000000000000000027111403054572700215540ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.bluez.obex/Transfer.xml000066400000000000000000000014371403054572700217210ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.bluez.obex/auto.go000066400000000000000000000216021403054572700207060ustar00rootroot00000000000000// Code generated by "./generator ./org.bluez.obex"; DO NOT EDIT. package obex import ( "errors" "unsafe" "github.com/godbus/dbus" "github.com/linuxdeepin/go-dbus-factory/object_manager" "pkg.deepin.io/lib/dbusutil/proxy" ) type ObjectManager struct { object_manager.ObjectManager // interface org.freedesktop.DBus.ObjectManager proxy.Object } func NewObjectManager(conn *dbus.Conn) *ObjectManager { obj := new(ObjectManager) obj.Object.Init_(conn, "org.bluez.obex", "/") return obj } type Manager struct { agentManager // interface org.bluez.obex.AgentManager1 client // interface org.bluez.obex.Client1 proxy.Object } func NewManager(conn *dbus.Conn) *Manager { obj := new(Manager) obj.Object.Init_(conn, "org.bluez.obex", "/org/bluez/obex") return obj } func (obj *Manager) AgentManager() *agentManager { return &obj.agentManager } type agentManager struct{} func (v *agentManager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*agentManager) GetInterfaceName_() string { return "org.bluez.obex.AgentManager1" } // method RegisterAgent func (v *agentManager) GoRegisterAgent(flags dbus.Flags, ch chan *dbus.Call, agent dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterAgent", flags, ch, agent) } func (v *agentManager) RegisterAgent(flags dbus.Flags, agent dbus.ObjectPath) error { return (<-v.GoRegisterAgent(flags, make(chan *dbus.Call, 1), agent).Done).Err } // method UnregisterAgent func (v *agentManager) GoUnregisterAgent(flags dbus.Flags, ch chan *dbus.Call, agent dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnregisterAgent", flags, ch, agent) } func (v *agentManager) UnregisterAgent(flags dbus.Flags, agent dbus.ObjectPath) error { return (<-v.GoUnregisterAgent(flags, make(chan *dbus.Call, 1), agent).Done).Err } func (obj *Manager) Client() *client { return &obj.client } type client struct{} func (v *client) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*client) GetInterfaceName_() string { return "org.bluez.obex.Client1" } // method CreateSession func (v *client) GoCreateSession(flags dbus.Flags, ch chan *dbus.Call, destination string, args map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateSession", flags, ch, destination, args) } func (*client) StoreCreateSession(call *dbus.Call) (session dbus.ObjectPath, err error) { err = call.Store(&session) return } func (v *client) CreateSession(flags dbus.Flags, destination string, args map[string]dbus.Variant) (session dbus.ObjectPath, err error) { return v.StoreCreateSession( <-v.GoCreateSession(flags, make(chan *dbus.Call, 1), destination, args).Done) } // method RemoveSession func (v *client) GoRemoveSession(flags dbus.Flags, ch chan *dbus.Call, session dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemoveSession", flags, ch, session) } func (v *client) RemoveSession(flags dbus.Flags, session dbus.ObjectPath) error { return (<-v.GoRemoveSession(flags, make(chan *dbus.Call, 1), session).Done).Err } type Session struct { session // interface org.bluez.obex.Session1 objectPush // interface org.bluez.obex.ObjectPush1 proxy.Object } func NewSession(conn *dbus.Conn, path dbus.ObjectPath) (*Session, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Session) obj.Object.Init_(conn, "org.bluez.obex", path) return obj, nil } func (obj *Session) Session() *session { return &obj.session } type session struct{} func (v *session) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*session) GetInterfaceName_() string { return "org.bluez.obex.Session1" } // method GetCapabilities func (v *session) GoGetCapabilities(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetCapabilities", flags, ch) } func (*session) StoreGetCapabilities(call *dbus.Call) (capabilities string, err error) { err = call.Store(&capabilities) return } func (v *session) GetCapabilities(flags dbus.Flags) (capabilities string, err error) { return v.StoreGetCapabilities( <-v.GoGetCapabilities(flags, make(chan *dbus.Call, 1)).Done) } // property Source s func (v *session) Source() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Source", } } // property Destination s func (v *session) Destination() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Destination", } } // property Channel y func (v *session) Channel() proxy.PropByte { return proxy.PropByte{ Impl: v, Name: "Channel", } } // property Target s func (v *session) Target() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Target", } } func (obj *Session) ObjectPush() *objectPush { return &obj.objectPush } type objectPush struct{} func (v *objectPush) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*objectPush) GetInterfaceName_() string { return "org.bluez.obex.ObjectPush1" } // method SendFile func (v *objectPush) GoSendFile(flags dbus.Flags, ch chan *dbus.Call, sourcefile string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SendFile", flags, ch, sourcefile) } func (*objectPush) StoreSendFile(call *dbus.Call) (transfer dbus.ObjectPath, properties map[string]dbus.Variant, err error) { err = call.Store(&transfer, &properties) return } func (v *objectPush) SendFile(flags dbus.Flags, sourcefile string) (transfer dbus.ObjectPath, properties map[string]dbus.Variant, err error) { return v.StoreSendFile( <-v.GoSendFile(flags, make(chan *dbus.Call, 1), sourcefile).Done) } // method PullBusinessCard func (v *objectPush) GoPullBusinessCard(flags dbus.Flags, ch chan *dbus.Call, targetfile string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PullBusinessCard", flags, ch, targetfile) } func (*objectPush) StorePullBusinessCard(call *dbus.Call) (transfer dbus.ObjectPath, properties map[string]dbus.Variant, err error) { err = call.Store(&transfer, &properties) return } func (v *objectPush) PullBusinessCard(flags dbus.Flags, targetfile string) (transfer dbus.ObjectPath, properties map[string]dbus.Variant, err error) { return v.StorePullBusinessCard( <-v.GoPullBusinessCard(flags, make(chan *dbus.Call, 1), targetfile).Done) } // method ExchangeBusinessCards func (v *objectPush) GoExchangeBusinessCards(flags dbus.Flags, ch chan *dbus.Call, clientfile string, targetfile string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ExchangeBusinessCards", flags, ch, clientfile, targetfile) } func (*objectPush) StoreExchangeBusinessCards(call *dbus.Call) (transfer dbus.ObjectPath, properties map[string]dbus.Variant, err error) { err = call.Store(&transfer, &properties) return } func (v *objectPush) ExchangeBusinessCards(flags dbus.Flags, clientfile string, targetfile string) (transfer dbus.ObjectPath, properties map[string]dbus.Variant, err error) { return v.StoreExchangeBusinessCards( <-v.GoExchangeBusinessCards(flags, make(chan *dbus.Call, 1), clientfile, targetfile).Done) } type Transfer struct { transfer // interface org.bluez.obex.Transfer1 proxy.Object } func NewTransfer(conn *dbus.Conn, path dbus.ObjectPath) (*Transfer, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Transfer) obj.Object.Init_(conn, "org.bluez.obex", path) return obj, nil } type transfer struct{} func (v *transfer) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*transfer) GetInterfaceName_() string { return "org.bluez.obex.Transfer1" } // method Cancel func (v *transfer) GoCancel(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Cancel", flags, ch) } func (v *transfer) Cancel(flags dbus.Flags) error { return (<-v.GoCancel(flags, make(chan *dbus.Call, 1)).Done).Err } // property Status s func (v *transfer) Status() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Status", } } // property Session o func (v *transfer) Session() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Session", } } // property Name s func (v *transfer) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property Type s func (v *transfer) Type() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Type", } } // property Size t func (v *transfer) Size() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Size", } } // property Time t func (v *transfer) Time() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Time", } } // property Filename s func (v *transfer) Filename() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Filename", } } // property Transferred t func (v *transfer) Transferred() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Transferred", } } go-dbus-factory-1.9.6/org.bluez.obex/config.json000066400000000000000000000021601403054572700215450ustar00rootroot00000000000000{ "Service": "org.bluez.obex", "Objects": [ { "Type": "ObjectManager", "XMLFile": "-", "Path": "/", "Interfaces": [ { "Name": "org.freedesktop.DBus.ObjectManager" } ] }, { "Type": "Manager", "Path": "/org/bluez/obex", "Interfaces": [ { "Name": "org.bluez.obex.AgentManager1", "Type": "agentManager", "Accessor": "AgentManager" }, { "Name": "org.bluez.obex.Client1", "Type": "client", "Accessor": "Client" } ] }, { "Type": "Session", "Interfaces": [ { "Name": "org.bluez.obex.Session1", "Type": "session", "Accessor": "Session" }, { "Name": "org.bluez.obex.ObjectPush1", "Type": "objectPush", "Accessor": "ObjectPush" } ] }, { "Type": "Transfer", "Interfaces": [ { "Name": "org.bluez.obex.Transfer1", "Type": "transfer", "Accessor": "Transfer" } ] } ] }go-dbus-factory-1.9.6/org.bluez/000077500000000000000000000000001403054572700164525ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.bluez/Device.xml000066400000000000000000000114031403054572700203720ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.bluez/HCI.xml000066400000000000000000000077151403054572700176110ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.bluez/Manager.xml000066400000000000000000000031401403054572700205440ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.bluez/auto.go000066400000000000000000000464731403054572700177670ustar00rootroot00000000000000// Code generated by "./generator ./org.bluez"; DO NOT EDIT. package bluez import ( "errors" "unsafe" "github.com/godbus/dbus" "github.com/linuxdeepin/go-dbus-factory/object_manager" "pkg.deepin.io/lib/dbusutil/proxy" ) type ObjectManager struct { object_manager.ObjectManager // interface org.freedesktop.DBus.ObjectManager proxy.Object } func NewObjectManager(conn *dbus.Conn) *ObjectManager { obj := new(ObjectManager) obj.Object.Init_(conn, "org.bluez", "/") return obj } type Manager struct { agentManager // interface org.bluez.AgentManager1 healthManager // interface org.bluez.HealthManager1 profileManager // interface org.bluez.ProfileManager1 proxy.Object } func NewManager(conn *dbus.Conn) *Manager { obj := new(Manager) obj.Object.Init_(conn, "org.bluez", "/org/bluez") return obj } func (obj *Manager) AgentManager() *agentManager { return &obj.agentManager } type agentManager struct{} func (v *agentManager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*agentManager) GetInterfaceName_() string { return "org.bluez.AgentManager1" } // method RegisterAgent func (v *agentManager) GoRegisterAgent(flags dbus.Flags, ch chan *dbus.Call, agent dbus.ObjectPath, capability string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterAgent", flags, ch, agent, capability) } func (v *agentManager) RegisterAgent(flags dbus.Flags, agent dbus.ObjectPath, capability string) error { return (<-v.GoRegisterAgent(flags, make(chan *dbus.Call, 1), agent, capability).Done).Err } // method UnregisterAgent func (v *agentManager) GoUnregisterAgent(flags dbus.Flags, ch chan *dbus.Call, agent dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnregisterAgent", flags, ch, agent) } func (v *agentManager) UnregisterAgent(flags dbus.Flags, agent dbus.ObjectPath) error { return (<-v.GoUnregisterAgent(flags, make(chan *dbus.Call, 1), agent).Done).Err } // method RequestDefaultAgent func (v *agentManager) GoRequestDefaultAgent(flags dbus.Flags, ch chan *dbus.Call, agent dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestDefaultAgent", flags, ch, agent) } func (v *agentManager) RequestDefaultAgent(flags dbus.Flags, agent dbus.ObjectPath) error { return (<-v.GoRequestDefaultAgent(flags, make(chan *dbus.Call, 1), agent).Done).Err } func (obj *Manager) HealthManager() *healthManager { return &obj.healthManager } type healthManager struct{} func (v *healthManager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*healthManager) GetInterfaceName_() string { return "org.bluez.HealthManager1" } // method CreateApplication func (v *healthManager) GoCreateApplication(flags dbus.Flags, ch chan *dbus.Call, config map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateApplication", flags, ch, config) } func (*healthManager) StoreCreateApplication(call *dbus.Call) (application dbus.ObjectPath, err error) { err = call.Store(&application) return } func (v *healthManager) CreateApplication(flags dbus.Flags, config map[string]dbus.Variant) (application dbus.ObjectPath, err error) { return v.StoreCreateApplication( <-v.GoCreateApplication(flags, make(chan *dbus.Call, 1), config).Done) } // method DestroyApplication func (v *healthManager) GoDestroyApplication(flags dbus.Flags, ch chan *dbus.Call, application dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DestroyApplication", flags, ch, application) } func (v *healthManager) DestroyApplication(flags dbus.Flags, application dbus.ObjectPath) error { return (<-v.GoDestroyApplication(flags, make(chan *dbus.Call, 1), application).Done).Err } func (obj *Manager) ProfileManager() *profileManager { return &obj.profileManager } type profileManager struct{} func (v *profileManager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*profileManager) GetInterfaceName_() string { return "org.bluez.ProfileManager1" } // method RegisterProfile func (v *profileManager) GoRegisterProfile(flags dbus.Flags, ch chan *dbus.Call, profile dbus.ObjectPath, UUID string, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterProfile", flags, ch, profile, UUID, options) } func (v *profileManager) RegisterProfile(flags dbus.Flags, profile dbus.ObjectPath, UUID string, options map[string]dbus.Variant) error { return (<-v.GoRegisterProfile(flags, make(chan *dbus.Call, 1), profile, UUID, options).Done).Err } // method UnregisterProfile func (v *profileManager) GoUnregisterProfile(flags dbus.Flags, ch chan *dbus.Call, profile dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnregisterProfile", flags, ch, profile) } func (v *profileManager) UnregisterProfile(flags dbus.Flags, profile dbus.ObjectPath) error { return (<-v.GoUnregisterProfile(flags, make(chan *dbus.Call, 1), profile).Done).Err } type HCI struct { adapter // interface org.bluez.Adapter1 gattManager // interface org.bluez.GattManager1 media // interface org.bluez.Media1 networkServer // interface org.bluez.NetworkServer1 proxy.Object } func NewHCI(conn *dbus.Conn, path dbus.ObjectPath) (*HCI, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(HCI) obj.Object.Init_(conn, "org.bluez", path) return obj, nil } func (obj *HCI) Adapter() *adapter { return &obj.adapter } type adapter struct{} func (v *adapter) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*adapter) GetInterfaceName_() string { return "org.bluez.Adapter1" } // method StartDiscovery func (v *adapter) GoStartDiscovery(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StartDiscovery", flags, ch) } func (v *adapter) StartDiscovery(flags dbus.Flags) error { return (<-v.GoStartDiscovery(flags, make(chan *dbus.Call, 1)).Done).Err } // method SetDiscoveryFilter func (v *adapter) GoSetDiscoveryFilter(flags dbus.Flags, ch chan *dbus.Call, properties map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDiscoveryFilter", flags, ch, properties) } func (v *adapter) SetDiscoveryFilter(flags dbus.Flags, properties map[string]dbus.Variant) error { return (<-v.GoSetDiscoveryFilter(flags, make(chan *dbus.Call, 1), properties).Done).Err } // method StopDiscovery func (v *adapter) GoStopDiscovery(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StopDiscovery", flags, ch) } func (v *adapter) StopDiscovery(flags dbus.Flags) error { return (<-v.GoStopDiscovery(flags, make(chan *dbus.Call, 1)).Done).Err } // method RemoveDevice func (v *adapter) GoRemoveDevice(flags dbus.Flags, ch chan *dbus.Call, device dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemoveDevice", flags, ch, device) } func (v *adapter) RemoveDevice(flags dbus.Flags, device dbus.ObjectPath) error { return (<-v.GoRemoveDevice(flags, make(chan *dbus.Call, 1), device).Done).Err } // property Address s func (v *adapter) Address() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Address", } } // property Name s func (v *adapter) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property Alias s func (v *adapter) Alias() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Alias", } } // property Class u func (v *adapter) Class() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Class", } } // property Powered b func (v *adapter) Powered() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Powered", } } // property Discoverable b func (v *adapter) Discoverable() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Discoverable", } } // property DiscoverableTimeout u func (v *adapter) DiscoverableTimeout() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "DiscoverableTimeout", } } // property Pairable b func (v *adapter) Pairable() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Pairable", } } // property PairableTimeout u func (v *adapter) PairableTimeout() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "PairableTimeout", } } // property Discovering b func (v *adapter) Discovering() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Discovering", } } // property UUIDs as func (v *adapter) UUIDs() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "UUIDs", } } // property Modalias s func (v *adapter) Modalias() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Modalias", } } func (obj *HCI) GattManager() *gattManager { return &obj.gattManager } type gattManager struct{} func (v *gattManager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*gattManager) GetInterfaceName_() string { return "org.bluez.GattManager1" } // method RegisterApplication func (v *gattManager) GoRegisterApplication(flags dbus.Flags, ch chan *dbus.Call, application dbus.ObjectPath, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterApplication", flags, ch, application, options) } func (v *gattManager) RegisterApplication(flags dbus.Flags, application dbus.ObjectPath, options map[string]dbus.Variant) error { return (<-v.GoRegisterApplication(flags, make(chan *dbus.Call, 1), application, options).Done).Err } // method UnregisterApplication func (v *gattManager) GoUnregisterApplication(flags dbus.Flags, ch chan *dbus.Call, application dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnregisterApplication", flags, ch, application) } func (v *gattManager) UnregisterApplication(flags dbus.Flags, application dbus.ObjectPath) error { return (<-v.GoUnregisterApplication(flags, make(chan *dbus.Call, 1), application).Done).Err } func (obj *HCI) Media() *media { return &obj.media } type media struct{} func (v *media) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*media) GetInterfaceName_() string { return "org.bluez.Media1" } // method RegisterEndpoint func (v *media) GoRegisterEndpoint(flags dbus.Flags, ch chan *dbus.Call, endpoint dbus.ObjectPath, properties map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterEndpoint", flags, ch, endpoint, properties) } func (v *media) RegisterEndpoint(flags dbus.Flags, endpoint dbus.ObjectPath, properties map[string]dbus.Variant) error { return (<-v.GoRegisterEndpoint(flags, make(chan *dbus.Call, 1), endpoint, properties).Done).Err } // method UnregisterEndpoint func (v *media) GoUnregisterEndpoint(flags dbus.Flags, ch chan *dbus.Call, endpoint dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnregisterEndpoint", flags, ch, endpoint) } func (v *media) UnregisterEndpoint(flags dbus.Flags, endpoint dbus.ObjectPath) error { return (<-v.GoUnregisterEndpoint(flags, make(chan *dbus.Call, 1), endpoint).Done).Err } // method RegisterPlayer func (v *media) GoRegisterPlayer(flags dbus.Flags, ch chan *dbus.Call, player dbus.ObjectPath, properties map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterPlayer", flags, ch, player, properties) } func (v *media) RegisterPlayer(flags dbus.Flags, player dbus.ObjectPath, properties map[string]dbus.Variant) error { return (<-v.GoRegisterPlayer(flags, make(chan *dbus.Call, 1), player, properties).Done).Err } // method UnregisterPlayer func (v *media) GoUnregisterPlayer(flags dbus.Flags, ch chan *dbus.Call, player dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnregisterPlayer", flags, ch, player) } func (v *media) UnregisterPlayer(flags dbus.Flags, player dbus.ObjectPath) error { return (<-v.GoUnregisterPlayer(flags, make(chan *dbus.Call, 1), player).Done).Err } func (obj *HCI) NetworkServer() *networkServer { return &obj.networkServer } type networkServer struct{} func (v *networkServer) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*networkServer) GetInterfaceName_() string { return "org.bluez.NetworkServer1" } // method Register func (v *networkServer) GoRegister(flags dbus.Flags, ch chan *dbus.Call, uuid string, bridge string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Register", flags, ch, uuid, bridge) } func (v *networkServer) Register(flags dbus.Flags, uuid string, bridge string) error { return (<-v.GoRegister(flags, make(chan *dbus.Call, 1), uuid, bridge).Done).Err } // method Unregister func (v *networkServer) GoUnregister(flags dbus.Flags, ch chan *dbus.Call, uuid string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Unregister", flags, ch, uuid) } func (v *networkServer) Unregister(flags dbus.Flags, uuid string) error { return (<-v.GoUnregister(flags, make(chan *dbus.Call, 1), uuid).Done).Err } type Device struct { device // interface org.bluez.Device1 proxy.Object } func NewDevice(conn *dbus.Conn, path dbus.ObjectPath) (*Device, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Device) obj.Object.Init_(conn, "org.bluez", path) return obj, nil } type device struct{} func (v *device) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*device) GetInterfaceName_() string { return "org.bluez.Device1" } // method Disconnect func (v *device) GoDisconnect(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Disconnect", flags, ch) } func (v *device) Disconnect(flags dbus.Flags) error { return (<-v.GoDisconnect(flags, make(chan *dbus.Call, 1)).Done).Err } // method Connect func (v *device) GoConnect(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Connect", flags, ch) } func (v *device) Connect(flags dbus.Flags) error { return (<-v.GoConnect(flags, make(chan *dbus.Call, 1)).Done).Err } // method ConnectProfile func (v *device) GoConnectProfile(flags dbus.Flags, ch chan *dbus.Call, UUID string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ConnectProfile", flags, ch, UUID) } func (v *device) ConnectProfile(flags dbus.Flags, UUID string) error { return (<-v.GoConnectProfile(flags, make(chan *dbus.Call, 1), UUID).Done).Err } // method DisconnectProfile func (v *device) GoDisconnectProfile(flags dbus.Flags, ch chan *dbus.Call, UUID string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DisconnectProfile", flags, ch, UUID) } func (v *device) DisconnectProfile(flags dbus.Flags, UUID string) error { return (<-v.GoDisconnectProfile(flags, make(chan *dbus.Call, 1), UUID).Done).Err } // method Pair func (v *device) GoPair(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Pair", flags, ch) } func (v *device) Pair(flags dbus.Flags) error { return (<-v.GoPair(flags, make(chan *dbus.Call, 1)).Done).Err } // method CancelPairing func (v *device) GoCancelPairing(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CancelPairing", flags, ch) } func (v *device) CancelPairing(flags dbus.Flags) error { return (<-v.GoCancelPairing(flags, make(chan *dbus.Call, 1)).Done).Err } // property Address s func (v *device) Address() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Address", } } // property Name s func (v *device) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property Alias s func (v *device) Alias() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Alias", } } // property Class u func (v *device) Class() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Class", } } // property Appearance q func (v *device) Appearance() proxy.PropUint16 { return proxy.PropUint16{ Impl: v, Name: "Appearance", } } // property Icon s func (v *device) Icon() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Icon", } } // property Paired b func (v *device) Paired() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Paired", } } // property Trusted b func (v *device) Trusted() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Trusted", } } // property Blocked b func (v *device) Blocked() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Blocked", } } // property LegacyPairing b func (v *device) LegacyPairing() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "LegacyPairing", } } // property RSSI n func (v *device) RSSI() proxy.PropInt16 { return proxy.PropInt16{ Impl: v, Name: "RSSI", } } // property Connected b func (v *device) Connected() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Connected", } } // property UUIDs as func (v *device) UUIDs() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "UUIDs", } } // property Modalias s func (v *device) Modalias() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Modalias", } } // property Adapter o func (v *device) Adapter() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Adapter", } } // property ManufacturerData a{qv} func (v *device) ManufacturerData() PropDeviceManufacturerData { return PropDeviceManufacturerData{ Impl: v, } } type PropDeviceManufacturerData struct { Impl proxy.Implementer } func (p PropDeviceManufacturerData) Get(flags dbus.Flags) (value map[uint16]dbus.Variant, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "ManufacturerData", &value) return } func (p PropDeviceManufacturerData) ConnectChanged(cb func(hasValue bool, value map[uint16]dbus.Variant)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[uint16]dbus.Variant err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "ManufacturerData", cb0) } // property ServiceData a{sv} func (v *device) ServiceData() PropDeviceServiceData { return PropDeviceServiceData{ Impl: v, } } type PropDeviceServiceData struct { Impl proxy.Implementer } func (p PropDeviceServiceData) Get(flags dbus.Flags) (value map[string]dbus.Variant, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "ServiceData", &value) return } func (p PropDeviceServiceData) ConnectChanged(cb func(hasValue bool, value map[string]dbus.Variant)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[string]dbus.Variant err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "ServiceData", cb0) } // property TxPower n func (v *device) TxPower() proxy.PropInt16 { return proxy.PropInt16{ Impl: v, Name: "TxPower", } } // property ServicesResolved b func (v *device) ServicesResolved() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ServicesResolved", } } go-dbus-factory-1.9.6/org.bluez/config.json000066400000000000000000000034701403054572700206160ustar00rootroot00000000000000{ "Service": "org.bluez", "Objects": [ { "Type": "ObjectManager", "XMLFile": "-", "Path": "/", "Interfaces": [ { "Name": "org.freedesktop.DBus.ObjectManager" } ] }, { "Type": "Manager", "Path": "/org/bluez", "Interfaces": [ { "Name": "org.bluez.AgentManager1", "Type": "agentManager", "Accessor": "AgentManager" }, { "Name": "org.bluez.HealthManager1", "Type": "healthManager", "Accessor": "HealthManager" }, { "Name": "org.bluez.ProfileManager1", "Type": "profileManager", "Accessor": "ProfileManager" } ] }, { "Type": "HCI", "Interfaces": [ { "Name": "org.bluez.Adapter1", "Type": "adapter", "Accessor": "Adapter" }, { "Name": "org.bluez.GattManager1", "Type": "gattManager", "Accessor": "GattManager" }, { "Name": "org.bluez.Media1", "Type": "media", "Accessor": "Media" }, { "Name": "org.bluez.NetworkServer1", "Type": "networkServer", "Accessor": "NetworkServer" } ] }, { "Type": "Device", "Interfaces": [ { "Name": "org.bluez.Device1", "Type": "device", "Accessor": "Device", "Fixes": { "p/ManufacturerData": { "Type": "PropDeviceManufacturerData", "ValueType": "map[uint16]dbus.Variant" }, "p/ServiceData": { "Type": "PropDeviceServiceData", "ValueType": "map[string]dbus.Variant" } } } ] } ] } go-dbus-factory-1.9.6/org.freedesktop.colormanager/000077500000000000000000000000001403054572700223145ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.colormanager/Manager.xml000066400000000000000000000141541403054572700244150ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.colormanager/Profile.xml000066400000000000000000000054221403054572700244410ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.colormanager/auto.go000066400000000000000000000524661403054572700236300ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.colormanager"; DO NOT EDIT. package colormanager import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Manager struct { manager // interface org.freedesktop.ColorManager proxy.Object } func NewManager(conn *dbus.Conn) *Manager { obj := new(Manager) obj.Object.Init_(conn, "org.freedesktop.ColorManager", "/org/freedesktop/ColorManager") return obj } type manager struct{} func (v *manager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*manager) GetInterfaceName_() string { return "org.freedesktop.ColorManager" } // method GetDevices func (v *manager) GoGetDevices(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDevices", flags, ch) } func (*manager) StoreGetDevices(call *dbus.Call) (devices []dbus.ObjectPath, err error) { err = call.Store(&devices) return } func (v *manager) GetDevices(flags dbus.Flags) (devices []dbus.ObjectPath, err error) { return v.StoreGetDevices( <-v.GoGetDevices(flags, make(chan *dbus.Call, 1)).Done) } // method GetDevicesByKind func (v *manager) GoGetDevicesByKind(flags dbus.Flags, ch chan *dbus.Call, kind string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDevicesByKind", flags, ch, kind) } func (*manager) StoreGetDevicesByKind(call *dbus.Call) (devices []dbus.ObjectPath, err error) { err = call.Store(&devices) return } func (v *manager) GetDevicesByKind(flags dbus.Flags, kind string) (devices []dbus.ObjectPath, err error) { return v.StoreGetDevicesByKind( <-v.GoGetDevicesByKind(flags, make(chan *dbus.Call, 1), kind).Done) } // method FindDeviceById func (v *manager) GoFindDeviceById(flags dbus.Flags, ch chan *dbus.Call, device_id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FindDeviceById", flags, ch, device_id) } func (*manager) StoreFindDeviceById(call *dbus.Call) (object_path dbus.ObjectPath, err error) { err = call.Store(&object_path) return } func (v *manager) FindDeviceById(flags dbus.Flags, device_id string) (object_path dbus.ObjectPath, err error) { return v.StoreFindDeviceById( <-v.GoFindDeviceById(flags, make(chan *dbus.Call, 1), device_id).Done) } // method FindSensorById func (v *manager) GoFindSensorById(flags dbus.Flags, ch chan *dbus.Call, sensor_id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FindSensorById", flags, ch, sensor_id) } func (*manager) StoreFindSensorById(call *dbus.Call) (object_path dbus.ObjectPath, err error) { err = call.Store(&object_path) return } func (v *manager) FindSensorById(flags dbus.Flags, sensor_id string) (object_path dbus.ObjectPath, err error) { return v.StoreFindSensorById( <-v.GoFindSensorById(flags, make(chan *dbus.Call, 1), sensor_id).Done) } // method FindDeviceByProperty func (v *manager) GoFindDeviceByProperty(flags dbus.Flags, ch chan *dbus.Call, key string, value string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FindDeviceByProperty", flags, ch, key, value) } func (*manager) StoreFindDeviceByProperty(call *dbus.Call) (object_path dbus.ObjectPath, err error) { err = call.Store(&object_path) return } func (v *manager) FindDeviceByProperty(flags dbus.Flags, key string, value string) (object_path dbus.ObjectPath, err error) { return v.StoreFindDeviceByProperty( <-v.GoFindDeviceByProperty(flags, make(chan *dbus.Call, 1), key, value).Done) } // method FindProfileById func (v *manager) GoFindProfileById(flags dbus.Flags, ch chan *dbus.Call, profile_id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FindProfileById", flags, ch, profile_id) } func (*manager) StoreFindProfileById(call *dbus.Call) (object_path dbus.ObjectPath, err error) { err = call.Store(&object_path) return } func (v *manager) FindProfileById(flags dbus.Flags, profile_id string) (object_path dbus.ObjectPath, err error) { return v.StoreFindProfileById( <-v.GoFindProfileById(flags, make(chan *dbus.Call, 1), profile_id).Done) } // method FindProfileByProperty func (v *manager) GoFindProfileByProperty(flags dbus.Flags, ch chan *dbus.Call, key string, value string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FindProfileByProperty", flags, ch, key, value) } func (*manager) StoreFindProfileByProperty(call *dbus.Call) (object_path dbus.ObjectPath, err error) { err = call.Store(&object_path) return } func (v *manager) FindProfileByProperty(flags dbus.Flags, key string, value string) (object_path dbus.ObjectPath, err error) { return v.StoreFindProfileByProperty( <-v.GoFindProfileByProperty(flags, make(chan *dbus.Call, 1), key, value).Done) } // method FindProfileByFilename func (v *manager) GoFindProfileByFilename(flags dbus.Flags, ch chan *dbus.Call, filename string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FindProfileByFilename", flags, ch, filename) } func (*manager) StoreFindProfileByFilename(call *dbus.Call) (object_path dbus.ObjectPath, err error) { err = call.Store(&object_path) return } func (v *manager) FindProfileByFilename(flags dbus.Flags, filename string) (object_path dbus.ObjectPath, err error) { return v.StoreFindProfileByFilename( <-v.GoFindProfileByFilename(flags, make(chan *dbus.Call, 1), filename).Done) } // method GetStandardSpace func (v *manager) GoGetStandardSpace(flags dbus.Flags, ch chan *dbus.Call, standard_space string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetStandardSpace", flags, ch, standard_space) } func (*manager) StoreGetStandardSpace(call *dbus.Call) (object_path dbus.ObjectPath, err error) { err = call.Store(&object_path) return } func (v *manager) GetStandardSpace(flags dbus.Flags, standard_space string) (object_path dbus.ObjectPath, err error) { return v.StoreGetStandardSpace( <-v.GoGetStandardSpace(flags, make(chan *dbus.Call, 1), standard_space).Done) } // method GetProfiles func (v *manager) GoGetProfiles(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetProfiles", flags, ch) } func (*manager) StoreGetProfiles(call *dbus.Call) (devices []dbus.ObjectPath, err error) { err = call.Store(&devices) return } func (v *manager) GetProfiles(flags dbus.Flags) (devices []dbus.ObjectPath, err error) { return v.StoreGetProfiles( <-v.GoGetProfiles(flags, make(chan *dbus.Call, 1)).Done) } // method GetSensors func (v *manager) GoGetSensors(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetSensors", flags, ch) } func (*manager) StoreGetSensors(call *dbus.Call) (devices []dbus.ObjectPath, err error) { err = call.Store(&devices) return } func (v *manager) GetSensors(flags dbus.Flags) (devices []dbus.ObjectPath, err error) { return v.StoreGetSensors( <-v.GoGetSensors(flags, make(chan *dbus.Call, 1)).Done) } // method GetProfilesByKind func (v *manager) GoGetProfilesByKind(flags dbus.Flags, ch chan *dbus.Call, kind string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetProfilesByKind", flags, ch, kind) } func (*manager) StoreGetProfilesByKind(call *dbus.Call) (devices []dbus.ObjectPath, err error) { err = call.Store(&devices) return } func (v *manager) GetProfilesByKind(flags dbus.Flags, kind string) (devices []dbus.ObjectPath, err error) { return v.StoreGetProfilesByKind( <-v.GoGetProfilesByKind(flags, make(chan *dbus.Call, 1), kind).Done) } // method CreateProfileWithFd func (v *manager) GoCreateProfileWithFd(flags dbus.Flags, ch chan *dbus.Call, profile_id string, scope string, handle dbus.UnixFD, properties map[string]string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateProfileWithFd", flags, ch, profile_id, scope, handle, properties) } func (*manager) StoreCreateProfileWithFd(call *dbus.Call) (object_path dbus.ObjectPath, err error) { err = call.Store(&object_path) return } func (v *manager) CreateProfileWithFd(flags dbus.Flags, profile_id string, scope string, handle dbus.UnixFD, properties map[string]string) (object_path dbus.ObjectPath, err error) { return v.StoreCreateProfileWithFd( <-v.GoCreateProfileWithFd(flags, make(chan *dbus.Call, 1), profile_id, scope, handle, properties).Done) } // method CreateProfile func (v *manager) GoCreateProfile(flags dbus.Flags, ch chan *dbus.Call, profile_id string, scope string, properties map[string]string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateProfile", flags, ch, profile_id, scope, properties) } func (*manager) StoreCreateProfile(call *dbus.Call) (object_path dbus.ObjectPath, err error) { err = call.Store(&object_path) return } func (v *manager) CreateProfile(flags dbus.Flags, profile_id string, scope string, properties map[string]string) (object_path dbus.ObjectPath, err error) { return v.StoreCreateProfile( <-v.GoCreateProfile(flags, make(chan *dbus.Call, 1), profile_id, scope, properties).Done) } // method CreateDevice func (v *manager) GoCreateDevice(flags dbus.Flags, ch chan *dbus.Call, device_id string, scope string, properties map[string]string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateDevice", flags, ch, device_id, scope, properties) } func (*manager) StoreCreateDevice(call *dbus.Call) (object_path dbus.ObjectPath, err error) { err = call.Store(&object_path) return } func (v *manager) CreateDevice(flags dbus.Flags, device_id string, scope string, properties map[string]string) (object_path dbus.ObjectPath, err error) { return v.StoreCreateDevice( <-v.GoCreateDevice(flags, make(chan *dbus.Call, 1), device_id, scope, properties).Done) } // method DeleteDevice func (v *manager) GoDeleteDevice(flags dbus.Flags, ch chan *dbus.Call, object_path dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteDevice", flags, ch, object_path) } func (v *manager) DeleteDevice(flags dbus.Flags, object_path dbus.ObjectPath) error { return (<-v.GoDeleteDevice(flags, make(chan *dbus.Call, 1), object_path).Done).Err } // method DeleteProfile func (v *manager) GoDeleteProfile(flags dbus.Flags, ch chan *dbus.Call, object_path dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteProfile", flags, ch, object_path) } func (v *manager) DeleteProfile(flags dbus.Flags, object_path dbus.ObjectPath) error { return (<-v.GoDeleteProfile(flags, make(chan *dbus.Call, 1), object_path).Done).Err } // signal Changed func (v *manager) ConnectChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Changed", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Changed", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal DeviceAdded func (v *manager) ConnectDeviceAdded(cb func(object_path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "DeviceAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".DeviceAdded", } handlerFunc := func(sig *dbus.Signal) { var object_path dbus.ObjectPath err := dbus.Store(sig.Body, &object_path) if err == nil { cb(object_path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal DeviceRemoved func (v *manager) ConnectDeviceRemoved(cb func(object_path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "DeviceRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".DeviceRemoved", } handlerFunc := func(sig *dbus.Signal) { var object_path dbus.ObjectPath err := dbus.Store(sig.Body, &object_path) if err == nil { cb(object_path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal DeviceChanged func (v *manager) ConnectDeviceChanged(cb func(object_path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "DeviceChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".DeviceChanged", } handlerFunc := func(sig *dbus.Signal) { var object_path dbus.ObjectPath err := dbus.Store(sig.Body, &object_path) if err == nil { cb(object_path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ProfileAdded func (v *manager) ConnectProfileAdded(cb func(object_path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ProfileAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ProfileAdded", } handlerFunc := func(sig *dbus.Signal) { var object_path dbus.ObjectPath err := dbus.Store(sig.Body, &object_path) if err == nil { cb(object_path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ProfileRemoved func (v *manager) ConnectProfileRemoved(cb func(object_path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ProfileRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ProfileRemoved", } handlerFunc := func(sig *dbus.Signal) { var object_path dbus.ObjectPath err := dbus.Store(sig.Body, &object_path) if err == nil { cb(object_path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal SensorAdded func (v *manager) ConnectSensorAdded(cb func(object_path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SensorAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SensorAdded", } handlerFunc := func(sig *dbus.Signal) { var object_path dbus.ObjectPath err := dbus.Store(sig.Body, &object_path) if err == nil { cb(object_path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal SensorRemoved func (v *manager) ConnectSensorRemoved(cb func(object_path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SensorRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SensorRemoved", } handlerFunc := func(sig *dbus.Signal) { var object_path dbus.ObjectPath err := dbus.Store(sig.Body, &object_path) if err == nil { cb(object_path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ProfileChanged func (v *manager) ConnectProfileChanged(cb func(object_path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ProfileChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ProfileChanged", } handlerFunc := func(sig *dbus.Signal) { var object_path dbus.ObjectPath err := dbus.Store(sig.Body, &object_path) if err == nil { cb(object_path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property DaemonVersion s func (v *manager) DaemonVersion() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DaemonVersion", } } // property SystemVendor s func (v *manager) SystemVendor() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SystemVendor", } } // property SystemModel s func (v *manager) SystemModel() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SystemModel", } } type Profile struct { profile // interface org.freedesktop.ColorManager.Profile proxy.Object } func NewProfile(conn *dbus.Conn, path dbus.ObjectPath) (*Profile, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Profile) obj.Object.Init_(conn, "org.freedesktop.ColorManager", path) return obj, nil } type profile struct{} func (v *profile) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*profile) GetInterfaceName_() string { return "org.freedesktop.ColorManager.Profile" } // method SetProperty func (v *profile) GoSetProperty(flags dbus.Flags, ch chan *dbus.Call, property_name string, property_value string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetProperty", flags, ch, property_name, property_value) } func (v *profile) SetProperty(flags dbus.Flags, property_name string, property_value string) error { return (<-v.GoSetProperty(flags, make(chan *dbus.Call, 1), property_name, property_value).Done).Err } // method InstallSystemWide func (v *profile) GoInstallSystemWide(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".InstallSystemWide", flags, ch) } func (v *profile) InstallSystemWide(flags dbus.Flags) error { return (<-v.GoInstallSystemWide(flags, make(chan *dbus.Call, 1)).Done).Err } // signal Changed func (v *profile) ConnectChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Changed", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Changed", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property ProfileId s func (v *profile) ProfileId() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ProfileId", } } // property Title s func (v *profile) Title() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Title", } } // property Metadata a{ss} func (v *profile) Metadata() PropProfileMetadata { return PropProfileMetadata{ Impl: v, } } type PropProfileMetadata struct { Impl proxy.Implementer } func (p PropProfileMetadata) Get(flags dbus.Flags) (value map[string]string, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Metadata", &value) return } func (p PropProfileMetadata) ConnectChanged(cb func(hasValue bool, value map[string]string)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[string]string err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Metadata", cb0) } // property Qualifier s func (v *profile) Qualifier() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Qualifier", } } // property Format s func (v *profile) Format() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Format", } } // property Kind s func (v *profile) Kind() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Kind", } } // property Colorspace s func (v *profile) Colorspace() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Colorspace", } } // property HasVcgt b func (v *profile) HasVcgt() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "HasVcgt", } } // property IsSystemWide b func (v *profile) IsSystemWide() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IsSystemWide", } } // property Filename s func (v *profile) Filename() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Filename", } } // property Created x func (v *profile) Created() proxy.PropInt64 { return proxy.PropInt64{ Impl: v, Name: "Created", } } // property Scope s func (v *profile) Scope() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Scope", } } // property Owner u func (v *profile) Owner() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Owner", } } // property Warnings as func (v *profile) Warnings() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Warnings", } } go-dbus-factory-1.9.6/org.freedesktop.colormanager/config.json000066400000000000000000000011561403054572700244570ustar00rootroot00000000000000{ "Service": "org.freedesktop.ColorManager", "Objects": [ { "Type": "Manager", "Path": "/org/freedesktop/ColorManager", "Interfaces": [ { "Name": "org.freedesktop.ColorManager", "Type": "manager" } ] }, { "Type": "Profile", "Interfaces": [ { "Name": "org.freedesktop.ColorManager.Profile", "Type": "profile", "Fixes": { "p/Metadata": { "Type": "PropProfileMetadata", "ValueType": "map[string]string" } } } ] } ] } go-dbus-factory-1.9.6/org.freedesktop.dbus/000077500000000000000000000000001403054572700206005ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.dbus/DBus.xml000066400000000000000000000064111403054572700221610ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.dbus/auto.go000066400000000000000000000277201403054572700221070ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.dbus"; DO NOT EDIT. package dbus import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type DBus struct { dbusIfc // interface org.freedesktop.DBus proxy.Object } func NewDBus(conn *dbus.Conn) *DBus { obj := new(DBus) obj.Object.Init_(conn, "org.freedesktop.DBus", "/org/freedesktop/DBus") return obj } type dbusIfc struct{} func (v *dbusIfc) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*dbusIfc) GetInterfaceName_() string { return "org.freedesktop.DBus" } // method Hello func (v *dbusIfc) GoHello(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Hello", flags, ch) } func (*dbusIfc) StoreHello(call *dbus.Call) (arg0 string, err error) { err = call.Store(&arg0) return } func (v *dbusIfc) Hello(flags dbus.Flags) (arg0 string, err error) { return v.StoreHello( <-v.GoHello(flags, make(chan *dbus.Call, 1)).Done) } // method RequestName func (v *dbusIfc) GoRequestName(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestName", flags, ch, arg0, arg1) } func (*dbusIfc) StoreRequestName(call *dbus.Call) (arg2 uint32, err error) { err = call.Store(&arg2) return } func (v *dbusIfc) RequestName(flags dbus.Flags, arg0 string, arg1 uint32) (arg2 uint32, err error) { return v.StoreRequestName( <-v.GoRequestName(flags, make(chan *dbus.Call, 1), arg0, arg1).Done) } // method ReleaseName func (v *dbusIfc) GoReleaseName(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReleaseName", flags, ch, arg0) } func (*dbusIfc) StoreReleaseName(call *dbus.Call) (arg1 uint32, err error) { err = call.Store(&arg1) return } func (v *dbusIfc) ReleaseName(flags dbus.Flags, arg0 string) (arg1 uint32, err error) { return v.StoreReleaseName( <-v.GoReleaseName(flags, make(chan *dbus.Call, 1), arg0).Done) } // method StartServiceByName func (v *dbusIfc) GoStartServiceByName(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StartServiceByName", flags, ch, arg0, arg1) } func (*dbusIfc) StoreStartServiceByName(call *dbus.Call) (arg2 uint32, err error) { err = call.Store(&arg2) return } func (v *dbusIfc) StartServiceByName(flags dbus.Flags, arg0 string, arg1 uint32) (arg2 uint32, err error) { return v.StoreStartServiceByName( <-v.GoStartServiceByName(flags, make(chan *dbus.Call, 1), arg0, arg1).Done) } // method UpdateActivationEnvironment func (v *dbusIfc) GoUpdateActivationEnvironment(flags dbus.Flags, ch chan *dbus.Call, arg0 map[string]string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UpdateActivationEnvironment", flags, ch, arg0) } func (v *dbusIfc) UpdateActivationEnvironment(flags dbus.Flags, arg0 map[string]string) error { return (<-v.GoUpdateActivationEnvironment(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method NameHasOwner func (v *dbusIfc) GoNameHasOwner(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".NameHasOwner", flags, ch, arg0) } func (*dbusIfc) StoreNameHasOwner(call *dbus.Call) (arg1 bool, err error) { err = call.Store(&arg1) return } func (v *dbusIfc) NameHasOwner(flags dbus.Flags, arg0 string) (arg1 bool, err error) { return v.StoreNameHasOwner( <-v.GoNameHasOwner(flags, make(chan *dbus.Call, 1), arg0).Done) } // method ListNames func (v *dbusIfc) GoListNames(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListNames", flags, ch) } func (*dbusIfc) StoreListNames(call *dbus.Call) (arg0 []string, err error) { err = call.Store(&arg0) return } func (v *dbusIfc) ListNames(flags dbus.Flags) (arg0 []string, err error) { return v.StoreListNames( <-v.GoListNames(flags, make(chan *dbus.Call, 1)).Done) } // method ListActivatableNames func (v *dbusIfc) GoListActivatableNames(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListActivatableNames", flags, ch) } func (*dbusIfc) StoreListActivatableNames(call *dbus.Call) (arg0 []string, err error) { err = call.Store(&arg0) return } func (v *dbusIfc) ListActivatableNames(flags dbus.Flags) (arg0 []string, err error) { return v.StoreListActivatableNames( <-v.GoListActivatableNames(flags, make(chan *dbus.Call, 1)).Done) } // method AddMatch func (v *dbusIfc) GoAddMatch(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddMatch", flags, ch, arg0) } func (v *dbusIfc) AddMatch(flags dbus.Flags, arg0 string) error { return (<-v.GoAddMatch(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method RemoveMatch func (v *dbusIfc) GoRemoveMatch(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemoveMatch", flags, ch, arg0) } func (v *dbusIfc) RemoveMatch(flags dbus.Flags, arg0 string) error { return (<-v.GoRemoveMatch(flags, make(chan *dbus.Call, 1), arg0).Done).Err } // method GetNameOwner func (v *dbusIfc) GoGetNameOwner(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetNameOwner", flags, ch, arg0) } func (*dbusIfc) StoreGetNameOwner(call *dbus.Call) (arg1 string, err error) { err = call.Store(&arg1) return } func (v *dbusIfc) GetNameOwner(flags dbus.Flags, arg0 string) (arg1 string, err error) { return v.StoreGetNameOwner( <-v.GoGetNameOwner(flags, make(chan *dbus.Call, 1), arg0).Done) } // method ListQueuedOwners func (v *dbusIfc) GoListQueuedOwners(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListQueuedOwners", flags, ch, arg0) } func (*dbusIfc) StoreListQueuedOwners(call *dbus.Call) (arg1 []string, err error) { err = call.Store(&arg1) return } func (v *dbusIfc) ListQueuedOwners(flags dbus.Flags, arg0 string) (arg1 []string, err error) { return v.StoreListQueuedOwners( <-v.GoListQueuedOwners(flags, make(chan *dbus.Call, 1), arg0).Done) } // method GetConnectionUnixUser func (v *dbusIfc) GoGetConnectionUnixUser(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetConnectionUnixUser", flags, ch, arg0) } func (*dbusIfc) StoreGetConnectionUnixUser(call *dbus.Call) (arg1 uint32, err error) { err = call.Store(&arg1) return } func (v *dbusIfc) GetConnectionUnixUser(flags dbus.Flags, arg0 string) (arg1 uint32, err error) { return v.StoreGetConnectionUnixUser( <-v.GoGetConnectionUnixUser(flags, make(chan *dbus.Call, 1), arg0).Done) } // method GetConnectionUnixProcessID func (v *dbusIfc) GoGetConnectionUnixProcessID(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetConnectionUnixProcessID", flags, ch, arg0) } func (*dbusIfc) StoreGetConnectionUnixProcessID(call *dbus.Call) (arg1 uint32, err error) { err = call.Store(&arg1) return } func (v *dbusIfc) GetConnectionUnixProcessID(flags dbus.Flags, arg0 string) (arg1 uint32, err error) { return v.StoreGetConnectionUnixProcessID( <-v.GoGetConnectionUnixProcessID(flags, make(chan *dbus.Call, 1), arg0).Done) } // method GetAdtAuditSessionData func (v *dbusIfc) GoGetAdtAuditSessionData(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAdtAuditSessionData", flags, ch, arg0) } func (*dbusIfc) StoreGetAdtAuditSessionData(call *dbus.Call) (arg1 []uint8, err error) { err = call.Store(&arg1) return } func (v *dbusIfc) GetAdtAuditSessionData(flags dbus.Flags, arg0 string) (arg1 []uint8, err error) { return v.StoreGetAdtAuditSessionData( <-v.GoGetAdtAuditSessionData(flags, make(chan *dbus.Call, 1), arg0).Done) } // method GetConnectionSELinuxSecurityContext func (v *dbusIfc) GoGetConnectionSELinuxSecurityContext(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetConnectionSELinuxSecurityContext", flags, ch, arg0) } func (*dbusIfc) StoreGetConnectionSELinuxSecurityContext(call *dbus.Call) (arg1 []uint8, err error) { err = call.Store(&arg1) return } func (v *dbusIfc) GetConnectionSELinuxSecurityContext(flags dbus.Flags, arg0 string) (arg1 []uint8, err error) { return v.StoreGetConnectionSELinuxSecurityContext( <-v.GoGetConnectionSELinuxSecurityContext(flags, make(chan *dbus.Call, 1), arg0).Done) } // method ReloadConfig func (v *dbusIfc) GoReloadConfig(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReloadConfig", flags, ch) } func (v *dbusIfc) ReloadConfig(flags dbus.Flags) error { return (<-v.GoReloadConfig(flags, make(chan *dbus.Call, 1)).Done).Err } // method GetId func (v *dbusIfc) GoGetId(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetId", flags, ch) } func (*dbusIfc) StoreGetId(call *dbus.Call) (arg0 string, err error) { err = call.Store(&arg0) return } func (v *dbusIfc) GetId(flags dbus.Flags) (arg0 string, err error) { return v.StoreGetId( <-v.GoGetId(flags, make(chan *dbus.Call, 1)).Done) } // method GetConnectionCredentials func (v *dbusIfc) GoGetConnectionCredentials(flags dbus.Flags, ch chan *dbus.Call, arg0 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetConnectionCredentials", flags, ch, arg0) } func (*dbusIfc) StoreGetConnectionCredentials(call *dbus.Call) (arg1 map[string]dbus.Variant, err error) { err = call.Store(&arg1) return } func (v *dbusIfc) GetConnectionCredentials(flags dbus.Flags, arg0 string) (arg1 map[string]dbus.Variant, err error) { return v.StoreGetConnectionCredentials( <-v.GoGetConnectionCredentials(flags, make(chan *dbus.Call, 1), arg0).Done) } // signal NameOwnerChanged func (v *dbusIfc) ConnectNameOwnerChanged(cb func(arg0 string, arg1 string, arg2 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NameOwnerChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NameOwnerChanged", } handlerFunc := func(sig *dbus.Signal) { var arg0 string var arg1 string var arg2 string err := dbus.Store(sig.Body, &arg0, &arg1, &arg2) if err == nil { cb(arg0, arg1, arg2) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal NameLost func (v *dbusIfc) ConnectNameLost(cb func(arg0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NameLost", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NameLost", } handlerFunc := func(sig *dbus.Signal) { var arg0 string err := dbus.Store(sig.Body, &arg0) if err == nil { cb(arg0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal NameAcquired func (v *dbusIfc) ConnectNameAcquired(cb func(arg0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NameAcquired", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NameAcquired", } handlerFunc := func(sig *dbus.Signal) { var arg0 string err := dbus.Store(sig.Body, &arg0) if err == nil { cb(arg0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/org.freedesktop.dbus/config.json000066400000000000000000000003751403054572700227450ustar00rootroot00000000000000{ "Service": "org.freedesktop.DBus", "Objects": [ { "Type": "DBus", "Path": "/org/freedesktop/DBus", "Interfaces": [ { "Name": "org.freedesktop.DBus", "Type": "dbusIfc" } ] } ] } go-dbus-factory-1.9.6/org.freedesktop.geoclue2/000077500000000000000000000000001403054572700213505ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.geoclue2/Client.xml000066400000000000000000000042621403054572700233140ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.geoclue2/Location.xml000066400000000000000000000036001403054572700236410ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.geoclue2/Manager.xml000066400000000000000000000033661403054572700234540ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.geoclue2/auto.go000066400000000000000000000153121403054572700226510ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.geoclue2"; DO NOT EDIT. package geoclue2 import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Manager struct { manager // interface org.freedesktop.GeoClue2.Manager proxy.Object } func NewManager(conn *dbus.Conn) *Manager { obj := new(Manager) obj.Object.Init_(conn, "org.freedesktop.GeoClue2", "/org/freedesktop/GeoClue2/Manager") return obj } type manager struct{} func (v *manager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*manager) GetInterfaceName_() string { return "org.freedesktop.GeoClue2.Manager" } // method GetClient func (v *manager) GoGetClient(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetClient", flags, ch) } func (*manager) StoreGetClient(call *dbus.Call) (client dbus.ObjectPath, err error) { err = call.Store(&client) return } func (v *manager) GetClient(flags dbus.Flags) (client dbus.ObjectPath, err error) { return v.StoreGetClient( <-v.GoGetClient(flags, make(chan *dbus.Call, 1)).Done) } // method AddAgent func (v *manager) GoAddAgent(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddAgent", flags, ch, id) } func (v *manager) AddAgent(flags dbus.Flags, id string) error { return (<-v.GoAddAgent(flags, make(chan *dbus.Call, 1), id).Done).Err } // property InUse b func (v *manager) InUse() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "InUse", } } // property AvailableAccuracyLevel u func (v *manager) AvailableAccuracyLevel() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "AvailableAccuracyLevel", } } type Client struct { client // interface org.freedesktop.GeoClue2.Client proxy.Object } func NewClient(conn *dbus.Conn, path dbus.ObjectPath) (*Client, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Client) obj.Object.Init_(conn, "org.freedesktop.GeoClue2", path) return obj, nil } type client struct{} func (v *client) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*client) GetInterfaceName_() string { return "org.freedesktop.GeoClue2.Client" } // method Start func (v *client) GoStart(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Start", flags, ch) } func (v *client) Start(flags dbus.Flags) error { return (<-v.GoStart(flags, make(chan *dbus.Call, 1)).Done).Err } // method Stop func (v *client) GoStop(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Stop", flags, ch) } func (v *client) Stop(flags dbus.Flags) error { return (<-v.GoStop(flags, make(chan *dbus.Call, 1)).Done).Err } // signal LocationUpdated func (v *client) ConnectLocationUpdated(cb func(old dbus.ObjectPath, new dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "LocationUpdated", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".LocationUpdated", } handlerFunc := func(sig *dbus.Signal) { var old dbus.ObjectPath var new dbus.ObjectPath err := dbus.Store(sig.Body, &old, &new) if err == nil { cb(old, new) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Location o func (v *client) Location() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Location", } } // property DistanceThreshold u func (v *client) DistanceThreshold() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "DistanceThreshold", } } // property TimeThreshold u func (v *client) TimeThreshold() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "TimeThreshold", } } // property DesktopId s func (v *client) DesktopId() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DesktopId", } } // property RequestedAccuracyLevel u func (v *client) RequestedAccuracyLevel() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "RequestedAccuracyLevel", } } // property Active b func (v *client) Active() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Active", } } type Location struct { location // interface org.freedesktop.GeoClue2.Location proxy.Object } func NewLocation(conn *dbus.Conn, path dbus.ObjectPath) (*Location, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Location) obj.Object.Init_(conn, "org.freedesktop.GeoClue2", path) return obj, nil } type location struct{} func (v *location) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*location) GetInterfaceName_() string { return "org.freedesktop.GeoClue2.Location" } // property Latitude d func (v *location) Latitude() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Latitude", } } // property Longitude d func (v *location) Longitude() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Longitude", } } // property Accuracy d func (v *location) Accuracy() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Accuracy", } } // property Altitude d func (v *location) Altitude() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Altitude", } } // property Speed d func (v *location) Speed() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Speed", } } // property Heading d func (v *location) Heading() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Heading", } } // property Description s func (v *location) Description() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Description", } } // property Timestamp (tt) func (v *location) Timestamp() PropTimestamp { return PropTimestamp{ Impl: v, } } type PropTimestamp struct { Impl proxy.Implementer } func (p PropTimestamp) Get(flags dbus.Flags) (value Timestamp, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Timestamp", &value) return } func (p PropTimestamp) ConnectChanged(cb func(hasValue bool, value Timestamp)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v Timestamp err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, Timestamp{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Timestamp", cb0) } go-dbus-factory-1.9.6/org.freedesktop.geoclue2/config.json000066400000000000000000000014641403054572700235150ustar00rootroot00000000000000{ "Service": "org.freedesktop.GeoClue2", "Objects": [ { "Type": "Manager", "Path": "/org/freedesktop/GeoClue2/Manager", "Interfaces": [ { "Name": "org.freedesktop.GeoClue2.Manager", "Type": "manager" } ] }, { "Type":"Client", "Interfaces": [ { "Name": "org.freedesktop.GeoClue2.Client", "Type": "client" } ] }, { "Type":"Location", "Interfaces": [ { "Name": "org.freedesktop.GeoClue2.Location", "Type": "location", "Fixes": { "p/Timestamp": { "Type": "PropTimestamp", "ValueType": "Timestamp", "EmptyValue": "Timestamp{}" } } } ] } ] } go-dbus-factory-1.9.6/org.freedesktop.geoclue2/manual.go000066400000000000000000000004331403054572700231540ustar00rootroot00000000000000package geoclue2 type Timestamp struct { Seconds uint64 Microseconds uint64 } const ( AccuracyLevelNone = 0 AccuracyLevelCountry = 1 AccuracyLevelCity = 4 AccuracyLevelNeighborhood = 5 AccuracyLevelStreet = 6 AccuracyLevelExact = 8 ) go-dbus-factory-1.9.6/org.freedesktop.hostname1/000077500000000000000000000000001403054572700215425ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.hostname1/Hostname.xml000066400000000000000000000071021403054572700240420ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.hostname1/auto.go000066400000000000000000000133641403054572700230500ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.hostname1"; DO NOT EDIT. package hostname1 import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type Hostname struct { hostname // interface org.freedesktop.hostname1 proxy.Object } func NewHostname(conn *dbus.Conn) *Hostname { obj := new(Hostname) obj.Object.Init_(conn, "org.freedesktop.hostname1", "/org/freedesktop/hostname1") return obj } type hostname struct{} func (v *hostname) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*hostname) GetInterfaceName_() string { return "org.freedesktop.hostname1" } // method SetHostname func (v *hostname) GoSetHostname(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetHostname", flags, ch, arg0, arg1) } func (v *hostname) SetHostname(flags dbus.Flags, arg0 string, arg1 bool) error { return (<-v.GoSetHostname(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method SetStaticHostname func (v *hostname) GoSetStaticHostname(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetStaticHostname", flags, ch, arg0, arg1) } func (v *hostname) SetStaticHostname(flags dbus.Flags, arg0 string, arg1 bool) error { return (<-v.GoSetStaticHostname(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method SetPrettyHostname func (v *hostname) GoSetPrettyHostname(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetPrettyHostname", flags, ch, arg0, arg1) } func (v *hostname) SetPrettyHostname(flags dbus.Flags, arg0 string, arg1 bool) error { return (<-v.GoSetPrettyHostname(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method SetIconName func (v *hostname) GoSetIconName(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetIconName", flags, ch, arg0, arg1) } func (v *hostname) SetIconName(flags dbus.Flags, arg0 string, arg1 bool) error { return (<-v.GoSetIconName(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method SetChassis func (v *hostname) GoSetChassis(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetChassis", flags, ch, arg0, arg1) } func (v *hostname) SetChassis(flags dbus.Flags, arg0 string, arg1 bool) error { return (<-v.GoSetChassis(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method SetDeployment func (v *hostname) GoSetDeployment(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDeployment", flags, ch, arg0, arg1) } func (v *hostname) SetDeployment(flags dbus.Flags, arg0 string, arg1 bool) error { return (<-v.GoSetDeployment(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method SetLocation func (v *hostname) GoSetLocation(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLocation", flags, ch, arg0, arg1) } func (v *hostname) SetLocation(flags dbus.Flags, arg0 string, arg1 bool) error { return (<-v.GoSetLocation(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method GetProductUUID func (v *hostname) GoGetProductUUID(flags dbus.Flags, ch chan *dbus.Call, arg0 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetProductUUID", flags, ch, arg0) } func (*hostname) StoreGetProductUUID(call *dbus.Call) (arg1 []uint8, err error) { err = call.Store(&arg1) return } func (v *hostname) GetProductUUID(flags dbus.Flags, arg0 bool) (arg1 []uint8, err error) { return v.StoreGetProductUUID( <-v.GoGetProductUUID(flags, make(chan *dbus.Call, 1), arg0).Done) } // property Hostname s func (v *hostname) Hostname() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Hostname", } } // property StaticHostname s func (v *hostname) StaticHostname() proxy.PropString { return proxy.PropString{ Impl: v, Name: "StaticHostname", } } // property PrettyHostname s func (v *hostname) PrettyHostname() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PrettyHostname", } } // property IconName s func (v *hostname) IconName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IconName", } } // property Chassis s func (v *hostname) Chassis() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Chassis", } } // property Deployment s func (v *hostname) Deployment() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Deployment", } } // property Location s func (v *hostname) Location() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Location", } } // property KernelName s func (v *hostname) KernelName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "KernelName", } } // property KernelRelease s func (v *hostname) KernelRelease() proxy.PropString { return proxy.PropString{ Impl: v, Name: "KernelRelease", } } // property KernelVersion s func (v *hostname) KernelVersion() proxy.PropString { return proxy.PropString{ Impl: v, Name: "KernelVersion", } } // property OperatingSystemPrettyName s func (v *hostname) OperatingSystemPrettyName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "OperatingSystemPrettyName", } } // property OperatingSystemCPEName s func (v *hostname) OperatingSystemCPEName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "OperatingSystemCPEName", } } // property HomeURL s func (v *hostname) HomeURL() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HomeURL", } } go-dbus-factory-1.9.6/org.freedesktop.hostname1/config.json000066400000000000000000000004631403054572700237050ustar00rootroot00000000000000{ "Service": "org.freedesktop.hostname1", "Objects": [ { "Type": "Hostname", "Path": "/org/freedesktop/hostname1", "Interfaces": [ { "Name": "org.freedesktop.hostname1", "Type": "hostname", "Accessor": "Hostname" } ] } ] } go-dbus-factory-1.9.6/org.freedesktop.login1/000077500000000000000000000000001403054572700210345ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.login1/Manager.xml000066400000000000000000000311461403054572700231350ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.login1/Seat.xml000066400000000000000000000050571403054572700224610ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.login1/Session.xml000066400000000000000000000140101403054572700231750ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.login1/User.xml000066400000000000000000000065141403054572700225020ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.login1/auto.go000066400000000000000000001455161403054572700223470ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.login1"; DO NOT EDIT. package login1 import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Manager struct { manager // interface org.freedesktop.login1.Manager proxy.Object } func NewManager(conn *dbus.Conn) *Manager { obj := new(Manager) obj.Object.Init_(conn, "org.freedesktop.login1", "/org/freedesktop/login1") return obj } type manager struct{} func (v *manager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*manager) GetInterfaceName_() string { return "org.freedesktop.login1.Manager" } // method GetSession func (v *manager) GoGetSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetSession", flags, ch, sessionId) } func (*manager) StoreGetSession(call *dbus.Call) (sessionPath dbus.ObjectPath, err error) { err = call.Store(&sessionPath) return } func (v *manager) GetSession(flags dbus.Flags, sessionId string) (sessionPath dbus.ObjectPath, err error) { return v.StoreGetSession( <-v.GoGetSession(flags, make(chan *dbus.Call, 1), sessionId).Done) } // method GetSessionByPID func (v *manager) GoGetSessionByPID(flags dbus.Flags, ch chan *dbus.Call, pid uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetSessionByPID", flags, ch, pid) } func (*manager) StoreGetSessionByPID(call *dbus.Call) (sessionPath dbus.ObjectPath, err error) { err = call.Store(&sessionPath) return } func (v *manager) GetSessionByPID(flags dbus.Flags, pid uint32) (sessionPath dbus.ObjectPath, err error) { return v.StoreGetSessionByPID( <-v.GoGetSessionByPID(flags, make(chan *dbus.Call, 1), pid).Done) } // method GetUser func (v *manager) GoGetUser(flags dbus.Flags, ch chan *dbus.Call, uid uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetUser", flags, ch, uid) } func (*manager) StoreGetUser(call *dbus.Call) (userPath dbus.ObjectPath, err error) { err = call.Store(&userPath) return } func (v *manager) GetUser(flags dbus.Flags, uid uint32) (userPath dbus.ObjectPath, err error) { return v.StoreGetUser( <-v.GoGetUser(flags, make(chan *dbus.Call, 1), uid).Done) } // method GetUserByPID func (v *manager) GoGetUserByPID(flags dbus.Flags, ch chan *dbus.Call, pid uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetUserByPID", flags, ch, pid) } func (*manager) StoreGetUserByPID(call *dbus.Call) (userPath dbus.ObjectPath, err error) { err = call.Store(&userPath) return } func (v *manager) GetUserByPID(flags dbus.Flags, pid uint32) (userPath dbus.ObjectPath, err error) { return v.StoreGetUserByPID( <-v.GoGetUserByPID(flags, make(chan *dbus.Call, 1), pid).Done) } // method GetSeat func (v *manager) GoGetSeat(flags dbus.Flags, ch chan *dbus.Call, seatId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetSeat", flags, ch, seatId) } func (*manager) StoreGetSeat(call *dbus.Call) (seatPath dbus.ObjectPath, err error) { err = call.Store(&seatPath) return } func (v *manager) GetSeat(flags dbus.Flags, seatId string) (seatPath dbus.ObjectPath, err error) { return v.StoreGetSeat( <-v.GoGetSeat(flags, make(chan *dbus.Call, 1), seatId).Done) } // method ListSessions func (v *manager) GoListSessions(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListSessions", flags, ch) } func (*manager) StoreListSessions(call *dbus.Call) (sessionList []SessionDetail, err error) { err = call.Store(&sessionList) return } func (v *manager) ListSessions(flags dbus.Flags) (sessionList []SessionDetail, err error) { return v.StoreListSessions( <-v.GoListSessions(flags, make(chan *dbus.Call, 1)).Done) } // method ListUsers func (v *manager) GoListUsers(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListUsers", flags, ch) } func (*manager) StoreListUsers(call *dbus.Call) (userList []UserDetail, err error) { err = call.Store(&userList) return } func (v *manager) ListUsers(flags dbus.Flags) (userList []UserDetail, err error) { return v.StoreListUsers( <-v.GoListUsers(flags, make(chan *dbus.Call, 1)).Done) } // method ListSeats func (v *manager) GoListSeats(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListSeats", flags, ch) } func (*manager) StoreListSeats(call *dbus.Call) (seatList []SeatInfo, err error) { err = call.Store(&seatList) return } func (v *manager) ListSeats(flags dbus.Flags) (seatList []SeatInfo, err error) { return v.StoreListSeats( <-v.GoListSeats(flags, make(chan *dbus.Call, 1)).Done) } // method ListInhibitors func (v *manager) GoListInhibitors(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListInhibitors", flags, ch) } func (*manager) StoreListInhibitors(call *dbus.Call) (inhibitorList []InhibitorInfo, err error) { err = call.Store(&inhibitorList) return } func (v *manager) ListInhibitors(flags dbus.Flags) (inhibitorList []InhibitorInfo, err error) { return v.StoreListInhibitors( <-v.GoListInhibitors(flags, make(chan *dbus.Call, 1)).Done) } // method CreateSession func (v *manager) GoCreateSession(flags dbus.Flags, ch chan *dbus.Call, uid uint32, pid uint32, service string, type0 string, class string, desktop string, seatId string, vtnr uint32, tty string, display string, remote bool, remoteUser string, remoteHost string, properties [][]interface{}) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateSession", flags, ch, uid, pid, service, type0, class, desktop, seatId, vtnr, tty, display, remote, remoteUser, remoteHost, properties) } func (*manager) StoreCreateSession(call *dbus.Call) (sessionId string, sessionPath dbus.ObjectPath, runtimePath string, fifoFd dbus.UnixFD, uid0 uint32, seatId0 string, vtnr0 uint32, existing bool, err error) { err = call.Store(&sessionId, &sessionPath, &runtimePath, &fifoFd, &uid0, &seatId0, &vtnr0, &existing) return } func (v *manager) CreateSession(flags dbus.Flags, uid uint32, pid uint32, service string, type0 string, class string, desktop string, seatId string, vtnr uint32, tty string, display string, remote bool, remoteUser string, remoteHost string, properties [][]interface{}) (sessionId string, sessionPath dbus.ObjectPath, runtimePath string, fifoFd dbus.UnixFD, uid0 uint32, seatId0 string, vtnr0 uint32, existing bool, err error) { return v.StoreCreateSession( <-v.GoCreateSession(flags, make(chan *dbus.Call, 1), uid, pid, service, type0, class, desktop, seatId, vtnr, tty, display, remote, remoteUser, remoteHost, properties).Done) } // method ReleaseSession func (v *manager) GoReleaseSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReleaseSession", flags, ch, sessionId) } func (v *manager) ReleaseSession(flags dbus.Flags, sessionId string) error { return (<-v.GoReleaseSession(flags, make(chan *dbus.Call, 1), sessionId).Done).Err } // method ActivateSession func (v *manager) GoActivateSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ActivateSession", flags, ch, sessionId) } func (v *manager) ActivateSession(flags dbus.Flags, sessionId string) error { return (<-v.GoActivateSession(flags, make(chan *dbus.Call, 1), sessionId).Done).Err } // method ActivateSessionOnSeat func (v *manager) GoActivateSessionOnSeat(flags dbus.Flags, ch chan *dbus.Call, sessionId string, seatId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ActivateSessionOnSeat", flags, ch, sessionId, seatId) } func (v *manager) ActivateSessionOnSeat(flags dbus.Flags, sessionId string, seatId string) error { return (<-v.GoActivateSessionOnSeat(flags, make(chan *dbus.Call, 1), sessionId, seatId).Done).Err } // method LockSession func (v *manager) GoLockSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LockSession", flags, ch, sessionId) } func (v *manager) LockSession(flags dbus.Flags, sessionId string) error { return (<-v.GoLockSession(flags, make(chan *dbus.Call, 1), sessionId).Done).Err } // method UnlockSession func (v *manager) GoUnlockSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnlockSession", flags, ch, sessionId) } func (v *manager) UnlockSession(flags dbus.Flags, sessionId string) error { return (<-v.GoUnlockSession(flags, make(chan *dbus.Call, 1), sessionId).Done).Err } // method LockSessions func (v *manager) GoLockSessions(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LockSessions", flags, ch) } func (v *manager) LockSessions(flags dbus.Flags) error { return (<-v.GoLockSessions(flags, make(chan *dbus.Call, 1)).Done).Err } // method UnlockSessions func (v *manager) GoUnlockSessions(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnlockSessions", flags, ch) } func (v *manager) UnlockSessions(flags dbus.Flags) error { return (<-v.GoUnlockSessions(flags, make(chan *dbus.Call, 1)).Done).Err } // method KillSession func (v *manager) GoKillSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string, who string, signo int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".KillSession", flags, ch, sessionId, who, signo) } func (v *manager) KillSession(flags dbus.Flags, sessionId string, who string, signo int32) error { return (<-v.GoKillSession(flags, make(chan *dbus.Call, 1), sessionId, who, signo).Done).Err } // method KillUser func (v *manager) GoKillUser(flags dbus.Flags, ch chan *dbus.Call, uid uint32, signo int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".KillUser", flags, ch, uid, signo) } func (v *manager) KillUser(flags dbus.Flags, uid uint32, signo int32) error { return (<-v.GoKillUser(flags, make(chan *dbus.Call, 1), uid, signo).Done).Err } // method TerminateSession func (v *manager) GoTerminateSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TerminateSession", flags, ch, sessionId) } func (v *manager) TerminateSession(flags dbus.Flags, sessionId string) error { return (<-v.GoTerminateSession(flags, make(chan *dbus.Call, 1), sessionId).Done).Err } // method TerminateUser func (v *manager) GoTerminateUser(flags dbus.Flags, ch chan *dbus.Call, uid uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TerminateUser", flags, ch, uid) } func (v *manager) TerminateUser(flags dbus.Flags, uid uint32) error { return (<-v.GoTerminateUser(flags, make(chan *dbus.Call, 1), uid).Done).Err } // method TerminateSeat func (v *manager) GoTerminateSeat(flags dbus.Flags, ch chan *dbus.Call, seatId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TerminateSeat", flags, ch, seatId) } func (v *manager) TerminateSeat(flags dbus.Flags, seatId string) error { return (<-v.GoTerminateSeat(flags, make(chan *dbus.Call, 1), seatId).Done).Err } // method SetUserLinger func (v *manager) GoSetUserLinger(flags dbus.Flags, ch chan *dbus.Call, uid uint32, linger bool, interactive bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetUserLinger", flags, ch, uid, linger, interactive) } func (v *manager) SetUserLinger(flags dbus.Flags, uid uint32, linger bool, interactive bool) error { return (<-v.GoSetUserLinger(flags, make(chan *dbus.Call, 1), uid, linger, interactive).Done).Err } // method AttachDevice func (v *manager) GoAttachDevice(flags dbus.Flags, ch chan *dbus.Call, seatId string, sysfs string, interactive bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AttachDevice", flags, ch, seatId, sysfs, interactive) } func (v *manager) AttachDevice(flags dbus.Flags, seatId string, sysfs string, interactive bool) error { return (<-v.GoAttachDevice(flags, make(chan *dbus.Call, 1), seatId, sysfs, interactive).Done).Err } // method FlushDevices func (v *manager) GoFlushDevices(flags dbus.Flags, ch chan *dbus.Call, interactive bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FlushDevices", flags, ch, interactive) } func (v *manager) FlushDevices(flags dbus.Flags, interactive bool) error { return (<-v.GoFlushDevices(flags, make(chan *dbus.Call, 1), interactive).Done).Err } // method PowerOff func (v *manager) GoPowerOff(flags dbus.Flags, ch chan *dbus.Call, interactive bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PowerOff", flags, ch, interactive) } func (v *manager) PowerOff(flags dbus.Flags, interactive bool) error { return (<-v.GoPowerOff(flags, make(chan *dbus.Call, 1), interactive).Done).Err } // method Reboot func (v *manager) GoReboot(flags dbus.Flags, ch chan *dbus.Call, interactive bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reboot", flags, ch, interactive) } func (v *manager) Reboot(flags dbus.Flags, interactive bool) error { return (<-v.GoReboot(flags, make(chan *dbus.Call, 1), interactive).Done).Err } // method Suspend func (v *manager) GoSuspend(flags dbus.Flags, ch chan *dbus.Call, interactive bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Suspend", flags, ch, interactive) } func (v *manager) Suspend(flags dbus.Flags, interactive bool) error { return (<-v.GoSuspend(flags, make(chan *dbus.Call, 1), interactive).Done).Err } // method Hibernate func (v *manager) GoHibernate(flags dbus.Flags, ch chan *dbus.Call, interactive bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Hibernate", flags, ch, interactive) } func (v *manager) Hibernate(flags dbus.Flags, interactive bool) error { return (<-v.GoHibernate(flags, make(chan *dbus.Call, 1), interactive).Done).Err } // method HybridSleep func (v *manager) GoHybridSleep(flags dbus.Flags, ch chan *dbus.Call, interactive bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".HybridSleep", flags, ch, interactive) } func (v *manager) HybridSleep(flags dbus.Flags, interactive bool) error { return (<-v.GoHybridSleep(flags, make(chan *dbus.Call, 1), interactive).Done).Err } // method CanPowerOff func (v *manager) GoCanPowerOff(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanPowerOff", flags, ch) } func (*manager) StoreCanPowerOff(call *dbus.Call) (result string, err error) { err = call.Store(&result) return } func (v *manager) CanPowerOff(flags dbus.Flags) (result string, err error) { return v.StoreCanPowerOff( <-v.GoCanPowerOff(flags, make(chan *dbus.Call, 1)).Done) } // method CanReboot func (v *manager) GoCanReboot(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanReboot", flags, ch) } func (*manager) StoreCanReboot(call *dbus.Call) (result string, err error) { err = call.Store(&result) return } func (v *manager) CanReboot(flags dbus.Flags) (result string, err error) { return v.StoreCanReboot( <-v.GoCanReboot(flags, make(chan *dbus.Call, 1)).Done) } // method CanSuspend func (v *manager) GoCanSuspend(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanSuspend", flags, ch) } func (*manager) StoreCanSuspend(call *dbus.Call) (result string, err error) { err = call.Store(&result) return } func (v *manager) CanSuspend(flags dbus.Flags) (result string, err error) { return v.StoreCanSuspend( <-v.GoCanSuspend(flags, make(chan *dbus.Call, 1)).Done) } // method CanHibernate func (v *manager) GoCanHibernate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanHibernate", flags, ch) } func (*manager) StoreCanHibernate(call *dbus.Call) (result string, err error) { err = call.Store(&result) return } func (v *manager) CanHibernate(flags dbus.Flags) (result string, err error) { return v.StoreCanHibernate( <-v.GoCanHibernate(flags, make(chan *dbus.Call, 1)).Done) } // method CanHybridSleep func (v *manager) GoCanHybridSleep(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanHybridSleep", flags, ch) } func (*manager) StoreCanHybridSleep(call *dbus.Call) (result string, err error) { err = call.Store(&result) return } func (v *manager) CanHybridSleep(flags dbus.Flags) (result string, err error) { return v.StoreCanHybridSleep( <-v.GoCanHybridSleep(flags, make(chan *dbus.Call, 1)).Done) } // method ScheduleShutdown func (v *manager) GoScheduleShutdown(flags dbus.Flags, ch chan *dbus.Call, type0 string, usec uint64) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ScheduleShutdown", flags, ch, type0, usec) } func (v *manager) ScheduleShutdown(flags dbus.Flags, type0 string, usec uint64) error { return (<-v.GoScheduleShutdown(flags, make(chan *dbus.Call, 1), type0, usec).Done).Err } // method CancelScheduledShutdown func (v *manager) GoCancelScheduledShutdown(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CancelScheduledShutdown", flags, ch) } func (*manager) StoreCancelScheduledShutdown(call *dbus.Call) (cancelled bool, err error) { err = call.Store(&cancelled) return } func (v *manager) CancelScheduledShutdown(flags dbus.Flags) (cancelled bool, err error) { return v.StoreCancelScheduledShutdown( <-v.GoCancelScheduledShutdown(flags, make(chan *dbus.Call, 1)).Done) } // method Inhibit func (v *manager) GoInhibit(flags dbus.Flags, ch chan *dbus.Call, what string, who string, why string, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Inhibit", flags, ch, what, who, why, mode) } func (*manager) StoreInhibit(call *dbus.Call) (pipeFd dbus.UnixFD, err error) { err = call.Store(&pipeFd) return } func (v *manager) Inhibit(flags dbus.Flags, what string, who string, why string, mode string) (pipeFd dbus.UnixFD, err error) { return v.StoreInhibit( <-v.GoInhibit(flags, make(chan *dbus.Call, 1), what, who, why, mode).Done) } // method CanRebootToFirmwareSetup func (v *manager) GoCanRebootToFirmwareSetup(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CanRebootToFirmwareSetup", flags, ch) } func (*manager) StoreCanRebootToFirmwareSetup(call *dbus.Call) (result string, err error) { err = call.Store(&result) return } func (v *manager) CanRebootToFirmwareSetup(flags dbus.Flags) (result string, err error) { return v.StoreCanRebootToFirmwareSetup( <-v.GoCanRebootToFirmwareSetup(flags, make(chan *dbus.Call, 1)).Done) } // method SetRebootToFirmwareSetup func (v *manager) GoSetRebootToFirmwareSetup(flags dbus.Flags, ch chan *dbus.Call, enable bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetRebootToFirmwareSetup", flags, ch, enable) } func (v *manager) SetRebootToFirmwareSetup(flags dbus.Flags, enable bool) error { return (<-v.GoSetRebootToFirmwareSetup(flags, make(chan *dbus.Call, 1), enable).Done).Err } // method SetWallMessage func (v *manager) GoSetWallMessage(flags dbus.Flags, ch chan *dbus.Call, wallMessage string, enable bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetWallMessage", flags, ch, wallMessage, enable) } func (v *manager) SetWallMessage(flags dbus.Flags, wallMessage string, enable bool) error { return (<-v.GoSetWallMessage(flags, make(chan *dbus.Call, 1), wallMessage, enable).Done).Err } // signal SessionNew func (v *manager) ConnectSessionNew(cb func(sessionId string, sessionPath dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SessionNew", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SessionNew", } handlerFunc := func(sig *dbus.Signal) { var sessionId string var sessionPath dbus.ObjectPath err := dbus.Store(sig.Body, &sessionId, &sessionPath) if err == nil { cb(sessionId, sessionPath) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal SessionRemoved func (v *manager) ConnectSessionRemoved(cb func(sessionId string, sessionPath dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SessionRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SessionRemoved", } handlerFunc := func(sig *dbus.Signal) { var sessionId string var sessionPath dbus.ObjectPath err := dbus.Store(sig.Body, &sessionId, &sessionPath) if err == nil { cb(sessionId, sessionPath) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal UserNew func (v *manager) ConnectUserNew(cb func(uid uint32, userPath dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "UserNew", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".UserNew", } handlerFunc := func(sig *dbus.Signal) { var uid uint32 var userPath dbus.ObjectPath err := dbus.Store(sig.Body, &uid, &userPath) if err == nil { cb(uid, userPath) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal UserRemoved func (v *manager) ConnectUserRemoved(cb func(uid uint32, userPath dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "UserRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".UserRemoved", } handlerFunc := func(sig *dbus.Signal) { var uid uint32 var userPath dbus.ObjectPath err := dbus.Store(sig.Body, &uid, &userPath) if err == nil { cb(uid, userPath) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal SeatNew func (v *manager) ConnectSeatNew(cb func(seatId string, seatPath dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SeatNew", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SeatNew", } handlerFunc := func(sig *dbus.Signal) { var seatId string var seatPath dbus.ObjectPath err := dbus.Store(sig.Body, &seatId, &seatPath) if err == nil { cb(seatId, seatPath) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal SeatRemoved func (v *manager) ConnectSeatRemoved(cb func(seatId string, seatPath dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SeatRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SeatRemoved", } handlerFunc := func(sig *dbus.Signal) { var seatId string var seatPath dbus.ObjectPath err := dbus.Store(sig.Body, &seatId, &seatPath) if err == nil { cb(seatId, seatPath) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal PrepareForShutdown func (v *manager) ConnectPrepareForShutdown(cb func(start bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PrepareForShutdown", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PrepareForShutdown", } handlerFunc := func(sig *dbus.Signal) { var start bool err := dbus.Store(sig.Body, &start) if err == nil { cb(start) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal PrepareForSleep func (v *manager) ConnectPrepareForSleep(cb func(start bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PrepareForSleep", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PrepareForSleep", } handlerFunc := func(sig *dbus.Signal) { var start bool err := dbus.Store(sig.Body, &start) if err == nil { cb(start) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property EnableWallMessages b func (v *manager) EnableWallMessages() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "EnableWallMessages", } } // property WallMessage s func (v *manager) WallMessage() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WallMessage", } } // property NAutoVTs u func (v *manager) NAutoVTs() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "NAutoVTs", } } // property KillOnlyUsers as func (v *manager) KillOnlyUsers() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "KillOnlyUsers", } } // property KillExcludeUsers as func (v *manager) KillExcludeUsers() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "KillExcludeUsers", } } // property KillUserProcesses b func (v *manager) KillUserProcesses() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "KillUserProcesses", } } // property RebootToFirmwareSetup b func (v *manager) RebootToFirmwareSetup() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "RebootToFirmwareSetup", } } // property IdleHint b func (v *manager) IdleHint() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IdleHint", } } // property IdleSinceHint t func (v *manager) IdleSinceHint() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IdleSinceHint", } } // property IdleSinceHintMonotonic t func (v *manager) IdleSinceHintMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IdleSinceHintMonotonic", } } // property BlockInhibited s func (v *manager) BlockInhibited() proxy.PropString { return proxy.PropString{ Impl: v, Name: "BlockInhibited", } } // property DelayInhibited s func (v *manager) DelayInhibited() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DelayInhibited", } } // property InhibitDelayMaxUSec t func (v *manager) InhibitDelayMaxUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InhibitDelayMaxUSec", } } // property HandlePowerKey s func (v *manager) HandlePowerKey() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HandlePowerKey", } } // property HandleSuspendKey s func (v *manager) HandleSuspendKey() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HandleSuspendKey", } } // property HandleHibernateKey s func (v *manager) HandleHibernateKey() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HandleHibernateKey", } } // property HandleLidSwitch s func (v *manager) HandleLidSwitch() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HandleLidSwitch", } } // property HandleLidSwitchDocked s func (v *manager) HandleLidSwitchDocked() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HandleLidSwitchDocked", } } // property HoldoffTimeoutUSec t func (v *manager) HoldoffTimeoutUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "HoldoffTimeoutUSec", } } // property IdleAction s func (v *manager) IdleAction() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IdleAction", } } // property IdleActionUSec t func (v *manager) IdleActionUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IdleActionUSec", } } // property PreparingForShutdown b func (v *manager) PreparingForShutdown() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PreparingForShutdown", } } // property PreparingForSleep b func (v *manager) PreparingForSleep() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PreparingForSleep", } } // property ScheduledShutdown (st) func (v *manager) ScheduledShutdown() PropManagerScheduledShutdown { return PropManagerScheduledShutdown{ Impl: v, } } type PropManagerScheduledShutdown struct { Impl proxy.Implementer } func (p PropManagerScheduledShutdown) Get(flags dbus.Flags) (value ScheduledShutdown, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "ScheduledShutdown", &value) return } func (p PropManagerScheduledShutdown) ConnectChanged(cb func(hasValue bool, value ScheduledShutdown)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v ScheduledShutdown err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, ScheduledShutdown{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "ScheduledShutdown", cb0) } // property Docked b func (v *manager) Docked() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Docked", } } // property RemoveIPC b func (v *manager) RemoveIPC() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "RemoveIPC", } } // property RuntimeDirectorySize t func (v *manager) RuntimeDirectorySize() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "RuntimeDirectorySize", } } // property InhibitorsMax t func (v *manager) InhibitorsMax() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InhibitorsMax", } } // property NCurrentInhibitors t func (v *manager) NCurrentInhibitors() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "NCurrentInhibitors", } } // property SessionsMax t func (v *manager) SessionsMax() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "SessionsMax", } } // property NCurrentSessions t func (v *manager) NCurrentSessions() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "NCurrentSessions", } } // property UserTasksMax t func (v *manager) UserTasksMax() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "UserTasksMax", } } type Seat struct { seat // interface org.freedesktop.login1.Seat proxy.Object } func NewSeat(conn *dbus.Conn, path dbus.ObjectPath) (*Seat, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Seat) obj.Object.Init_(conn, "org.freedesktop.login1", path) return obj, nil } type seat struct{} func (v *seat) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*seat) GetInterfaceName_() string { return "org.freedesktop.login1.Seat" } // method Terminate func (v *seat) GoTerminate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Terminate", flags, ch) } func (v *seat) Terminate(flags dbus.Flags) error { return (<-v.GoTerminate(flags, make(chan *dbus.Call, 1)).Done).Err } // method ActivateSession func (v *seat) GoActivateSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ActivateSession", flags, ch, sessionId) } func (v *seat) ActivateSession(flags dbus.Flags, sessionId string) error { return (<-v.GoActivateSession(flags, make(chan *dbus.Call, 1), sessionId).Done).Err } // method SwitchTo func (v *seat) GoSwitchTo(flags dbus.Flags, ch chan *dbus.Call, vtnr uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SwitchTo", flags, ch, vtnr) } func (v *seat) SwitchTo(flags dbus.Flags, vtnr uint32) error { return (<-v.GoSwitchTo(flags, make(chan *dbus.Call, 1), vtnr).Done).Err } // method SwitchToNext func (v *seat) GoSwitchToNext(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SwitchToNext", flags, ch) } func (v *seat) SwitchToNext(flags dbus.Flags) error { return (<-v.GoSwitchToNext(flags, make(chan *dbus.Call, 1)).Done).Err } // method SwitchToPrevious func (v *seat) GoSwitchToPrevious(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SwitchToPrevious", flags, ch) } func (v *seat) SwitchToPrevious(flags dbus.Flags) error { return (<-v.GoSwitchToPrevious(flags, make(chan *dbus.Call, 1)).Done).Err } // property Id s func (v *seat) Id() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Id", } } // property ActiveSession (so) func (v *seat) ActiveSession() PropSessionInfo { return PropSessionInfo{ Impl: v, Name: "ActiveSession", } } // property CanMultiSession b func (v *seat) CanMultiSession() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanMultiSession", } } // property CanTTY b func (v *seat) CanTTY() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanTTY", } } // property CanGraphical b func (v *seat) CanGraphical() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanGraphical", } } // property Sessions a(so) func (v *seat) Sessions() PropSessionInfoSlice { return PropSessionInfoSlice{ Impl: v, Name: "Sessions", } } // property IdleHint b func (v *seat) IdleHint() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IdleHint", } } // property IdleSinceHint t func (v *seat) IdleSinceHint() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IdleSinceHint", } } // property IdleSinceHintMonotonic t func (v *seat) IdleSinceHintMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IdleSinceHintMonotonic", } } type Session struct { session // interface org.freedesktop.login1.Session proxy.Object } func NewSession(conn *dbus.Conn, path dbus.ObjectPath) (*Session, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Session) obj.Object.Init_(conn, "org.freedesktop.login1", path) return obj, nil } type session struct{} func (v *session) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*session) GetInterfaceName_() string { return "org.freedesktop.login1.Session" } // method Terminate func (v *session) GoTerminate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Terminate", flags, ch) } func (v *session) Terminate(flags dbus.Flags) error { return (<-v.GoTerminate(flags, make(chan *dbus.Call, 1)).Done).Err } // method Activate func (v *session) GoActivate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Activate", flags, ch) } func (v *session) Activate(flags dbus.Flags) error { return (<-v.GoActivate(flags, make(chan *dbus.Call, 1)).Done).Err } // method Lock func (v *session) GoLock(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Lock", flags, ch) } func (v *session) Lock(flags dbus.Flags) error { return (<-v.GoLock(flags, make(chan *dbus.Call, 1)).Done).Err } // method Unlock func (v *session) GoUnlock(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Unlock", flags, ch) } func (v *session) Unlock(flags dbus.Flags) error { return (<-v.GoUnlock(flags, make(chan *dbus.Call, 1)).Done).Err } // method SetIdleHint func (v *session) GoSetIdleHint(flags dbus.Flags, ch chan *dbus.Call, idle bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetIdleHint", flags, ch, idle) } func (v *session) SetIdleHint(flags dbus.Flags, idle bool) error { return (<-v.GoSetIdleHint(flags, make(chan *dbus.Call, 1), idle).Done).Err } // method SetLockedHint func (v *session) GoSetLockedHint(flags dbus.Flags, ch chan *dbus.Call, locked bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLockedHint", flags, ch, locked) } func (v *session) SetLockedHint(flags dbus.Flags, locked bool) error { return (<-v.GoSetLockedHint(flags, make(chan *dbus.Call, 1), locked).Done).Err } // method Kill func (v *session) GoKill(flags dbus.Flags, ch chan *dbus.Call, who string, signo int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Kill", flags, ch, who, signo) } func (v *session) Kill(flags dbus.Flags, who string, signo int32) error { return (<-v.GoKill(flags, make(chan *dbus.Call, 1), who, signo).Done).Err } // method TakeControl func (v *session) GoTakeControl(flags dbus.Flags, ch chan *dbus.Call, force bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TakeControl", flags, ch, force) } func (v *session) TakeControl(flags dbus.Flags, force bool) error { return (<-v.GoTakeControl(flags, make(chan *dbus.Call, 1), force).Done).Err } // method ReleaseControl func (v *session) GoReleaseControl(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReleaseControl", flags, ch) } func (v *session) ReleaseControl(flags dbus.Flags) error { return (<-v.GoReleaseControl(flags, make(chan *dbus.Call, 1)).Done).Err } // method TakeDevice func (v *session) GoTakeDevice(flags dbus.Flags, ch chan *dbus.Call, major uint32, minor uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TakeDevice", flags, ch, major, minor) } func (*session) StoreTakeDevice(call *dbus.Call) (fd dbus.UnixFD, inactive bool, err error) { err = call.Store(&fd, &inactive) return } func (v *session) TakeDevice(flags dbus.Flags, major uint32, minor uint32) (fd dbus.UnixFD, inactive bool, err error) { return v.StoreTakeDevice( <-v.GoTakeDevice(flags, make(chan *dbus.Call, 1), major, minor).Done) } // method ReleaseDevice func (v *session) GoReleaseDevice(flags dbus.Flags, ch chan *dbus.Call, major uint32, minor uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReleaseDevice", flags, ch, major, minor) } func (v *session) ReleaseDevice(flags dbus.Flags, major uint32, minor uint32) error { return (<-v.GoReleaseDevice(flags, make(chan *dbus.Call, 1), major, minor).Done).Err } // method PauseDeviceComplete func (v *session) GoPauseDeviceComplete(flags dbus.Flags, ch chan *dbus.Call, major uint32, minor uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PauseDeviceComplete", flags, ch, major, minor) } func (v *session) PauseDeviceComplete(flags dbus.Flags, major uint32, minor uint32) error { return (<-v.GoPauseDeviceComplete(flags, make(chan *dbus.Call, 1), major, minor).Done).Err } // signal PauseDevice func (v *session) ConnectPauseDevice(cb func(major uint32, minor uint32, type0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PauseDevice", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PauseDevice", } handlerFunc := func(sig *dbus.Signal) { var major uint32 var minor uint32 var type0 string err := dbus.Store(sig.Body, &major, &minor, &type0) if err == nil { cb(major, minor, type0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ResumeDevice func (v *session) ConnectResumeDevice(cb func(major uint32, minor uint32, fd dbus.UnixFD)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ResumeDevice", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ResumeDevice", } handlerFunc := func(sig *dbus.Signal) { var major uint32 var minor uint32 var fd dbus.UnixFD err := dbus.Store(sig.Body, &major, &minor, &fd) if err == nil { cb(major, minor, fd) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Lock func (v *session) ConnectLock(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Lock", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Lock", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Unlock func (v *session) ConnectUnlock(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Unlock", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Unlock", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Id s func (v *session) Id() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Id", } } // property User (uo) func (v *session) User() PropSessionUser { return PropSessionUser{ Impl: v, } } type PropSessionUser struct { Impl proxy.Implementer } func (p PropSessionUser) Get(flags dbus.Flags) (value UserInfo, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "User", &value) return } func (p PropSessionUser) ConnectChanged(cb func(hasValue bool, value UserInfo)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v UserInfo err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, UserInfo{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "User", cb0) } // property Name s func (v *session) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property Timestamp t func (v *session) Timestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Timestamp", } } // property TimestampMonotonic t func (v *session) TimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TimestampMonotonic", } } // property VTNr u func (v *session) VTNr() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "VTNr", } } // property Seat (so) func (v *session) Seat() PropSessionSeat { return PropSessionSeat{ Impl: v, } } type PropSessionSeat struct { Impl proxy.Implementer } func (p PropSessionSeat) Get(flags dbus.Flags) (value SeatInfo, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Seat", &value) return } func (p PropSessionSeat) ConnectChanged(cb func(hasValue bool, value SeatInfo)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v SeatInfo err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, SeatInfo{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Seat", cb0) } // property TTY s func (v *session) TTY() proxy.PropString { return proxy.PropString{ Impl: v, Name: "TTY", } } // property Display s func (v *session) Display() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Display", } } // property Remote b func (v *session) Remote() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Remote", } } // property RemoteHost s func (v *session) RemoteHost() proxy.PropString { return proxy.PropString{ Impl: v, Name: "RemoteHost", } } // property RemoteUser s func (v *session) RemoteUser() proxy.PropString { return proxy.PropString{ Impl: v, Name: "RemoteUser", } } // property Service s func (v *session) Service() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Service", } } // property Desktop s func (v *session) Desktop() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Desktop", } } // property Scope s func (v *session) Scope() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Scope", } } // property Leader u func (v *session) Leader() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Leader", } } // property Audit u func (v *session) Audit() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Audit", } } // property Type s func (v *session) Type() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Type", } } // property Class s func (v *session) Class() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Class", } } // property Active b func (v *session) Active() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Active", } } // property State s func (v *session) State() proxy.PropString { return proxy.PropString{ Impl: v, Name: "State", } } // property IdleHint b func (v *session) IdleHint() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IdleHint", } } // property IdleSinceHint t func (v *session) IdleSinceHint() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IdleSinceHint", } } // property IdleSinceHintMonotonic t func (v *session) IdleSinceHintMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IdleSinceHintMonotonic", } } // property LockedHint b func (v *session) LockedHint() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "LockedHint", } } type User struct { user // interface org.freedesktop.login1.User proxy.Object } func NewUser(conn *dbus.Conn, path dbus.ObjectPath) (*User, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(User) obj.Object.Init_(conn, "org.freedesktop.login1", path) return obj, nil } type user struct{} func (v *user) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*user) GetInterfaceName_() string { return "org.freedesktop.login1.User" } // method Terminate func (v *user) GoTerminate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Terminate", flags, ch) } func (v *user) Terminate(flags dbus.Flags) error { return (<-v.GoTerminate(flags, make(chan *dbus.Call, 1)).Done).Err } // method Kill func (v *user) GoKill(flags dbus.Flags, ch chan *dbus.Call, signo int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Kill", flags, ch, signo) } func (v *user) Kill(flags dbus.Flags, signo int32) error { return (<-v.GoKill(flags, make(chan *dbus.Call, 1), signo).Done).Err } // property UID u func (v *user) UID() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "UID", } } // property GID u func (v *user) GID() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "GID", } } // property Name s func (v *user) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property Timestamp t func (v *user) Timestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Timestamp", } } // property TimestampMonotonic t func (v *user) TimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TimestampMonotonic", } } // property RuntimePath s func (v *user) RuntimePath() proxy.PropString { return proxy.PropString{ Impl: v, Name: "RuntimePath", } } // property Service s func (v *user) Service() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Service", } } // property Slice s func (v *user) Slice() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Slice", } } // property Display (so) func (v *user) Display() PropSessionInfo { return PropSessionInfo{ Impl: v, Name: "Display", } } // property State s func (v *user) State() proxy.PropString { return proxy.PropString{ Impl: v, Name: "State", } } // property Sessions a(so) func (v *user) Sessions() PropSessionInfoSlice { return PropSessionInfoSlice{ Impl: v, Name: "Sessions", } } // property IdleHint b func (v *user) IdleHint() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IdleHint", } } // property IdleSinceHint t func (v *user) IdleSinceHint() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IdleSinceHint", } } // property IdleSinceHintMonotonic t func (v *user) IdleSinceHintMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IdleSinceHintMonotonic", } } // property Linger b func (v *user) Linger() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Linger", } } type PropSessionInfo struct { Impl proxy.Implementer Name string } func (p PropSessionInfo) Get(flags dbus.Flags) (value SessionInfo, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropSessionInfo) Set(flags dbus.Flags, value SessionInfo) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropSessionInfo) ConnectChanged(cb func(hasValue bool, value SessionInfo)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v SessionInfo err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, SessionInfo{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } type PropSessionInfoSlice struct { Impl proxy.Implementer Name string } func (p PropSessionInfoSlice) Get(flags dbus.Flags) (value []SessionInfo, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropSessionInfoSlice) Set(flags dbus.Flags, value []SessionInfo) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropSessionInfoSlice) ConnectChanged(cb func(hasValue bool, value []SessionInfo)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []SessionInfo err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } go-dbus-factory-1.9.6/org.freedesktop.login1/config.json000066400000000000000000000050311403054572700231730ustar00rootroot00000000000000{ "Service": "org.freedesktop.login1", "Objects": [ { "Type": "Manager", "Path": "/org/freedesktop/login1", "Interfaces": [ { "Name": "org.freedesktop.login1.Manager", "Type": "manager", "Fixes": { "p/ScheduledShutdown": { "Type": "PropManagerScheduledShutdown", "ValueType": "ScheduledShutdown", "EmptyValue": "$T{}" }, "m/ListSessions": [ { "Name": "sessionList", "Type": "[]SessionDetail" } ], "m/ListUsers": [ { "Name": "userList", "Type": "[]UserDetail" } ], "m/ListSeats": [ { "Name": "seatList", "Type": "[]SeatInfo" } ], "m/ListInhibitors": [ { "Name": "inhibitorList", "Type": "[]InhibitorInfo" } ] } } ] }, { "Type": "Seat", "Interfaces": [ { "Name": "org.freedesktop.login1.Seat", "Type": "seat", "Fixes": { "p/ActiveSession": { "RefType": "PropSessionInfo" }, "p/Sessions": { "RefType": "PropSessionInfoSlice" } } } ] }, { "Type": "Session", "Interfaces": [ { "Name": "org.freedesktop.login1.Session", "Type": "session", "Fixes": { "p/User": { "Type": "PropSessionUser", "ValueType": "UserInfo", "EmptyValue": "$T{}" }, "p/Seat": { "Type": "PropSessionSeat", "ValueType": "SeatInfo", "EmptyValue": "$T{}" } } } ] }, { "Type": "User", "Interfaces": [ { "Name": "org.freedesktop.login1.User", "Type": "user", "Fixes": { "p/Display": { "RefType": "PropSessionInfo" }, "p/Sessions": { "RefType": "PropSessionInfoSlice" } } } ] } ], "PropertyTypes": [ { "Type": "PropSessionInfo", "ValueType": "SessionInfo", "EmptyValue": "$T{}" }, { "Type": "PropSessionInfoSlice", "ValueType": "[]SessionInfo" } ] } go-dbus-factory-1.9.6/org.freedesktop.login1/manual.go000066400000000000000000000011421403054572700226360ustar00rootroot00000000000000package login1 import "github.com/godbus/dbus" type ScheduledShutdown struct { Type string USec uint64 } type SessionInfo struct { Id string Path dbus.ObjectPath } type UserInfo struct { UID uint32 Path dbus.ObjectPath } type SeatInfo struct { Id string Path dbus.ObjectPath } type SessionDetail struct { SessionId string UID uint32 UserName string SeatId string Path dbus.ObjectPath } type UserDetail struct { UID uint32 Name string Path dbus.ObjectPath } type InhibitorInfo struct { What string Who string Why string Mode string UID uint32 PID uint32 } go-dbus-factory-1.9.6/org.freedesktop.miracle.wfd/000077500000000000000000000000001403054572700220365ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.miracle.wfd/Session.xml000066400000000000000000000007261403054572700242100ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.miracle.wfd/Sink.xml000066400000000000000000000011431403054572700234630ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.miracle.wfd/Wfd.xml000066400000000000000000000035311403054572700233020ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.miracle.wfd/auto.go000066400000000000000000000105361403054572700233420ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.miracle.wfd"; DO NOT EDIT. package wfd import ( "errors" "unsafe" "github.com/godbus/dbus" "github.com/linuxdeepin/go-dbus-factory/object_manager" "pkg.deepin.io/lib/dbusutil/proxy" ) type Wfd struct { object_manager.ObjectManager // interface org.freedesktop.DBus.ObjectManager wfd // interface org.freedesktop.miracle.wfd proxy.Object } func NewWfd(conn *dbus.Conn) *Wfd { obj := new(Wfd) obj.Object.Init_(conn, "org.freedesktop.miracle.wfd", "/org/freedesktop/miracle/wfd") return obj } func (obj *Wfd) Wfd() *wfd { return &obj.wfd } type wfd struct{} func (v *wfd) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*wfd) GetInterfaceName_() string { return "org.freedesktop.miracle.wfd" } // method Shutdown func (v *wfd) GoShutdown(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Shutdown", flags, ch) } func (v *wfd) Shutdown(flags dbus.Flags) error { return (<-v.GoShutdown(flags, make(chan *dbus.Call, 1)).Done).Err } type Sink struct { sink // interface org.freedesktop.miracle.wfd.Sink proxy.Object } func NewSink(conn *dbus.Conn, path dbus.ObjectPath) (*Sink, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Sink) obj.Object.Init_(conn, "org.freedesktop.miracle.wfd", path) return obj, nil } type sink struct{} func (v *sink) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*sink) GetInterfaceName_() string { return "org.freedesktop.miracle.wfd.Sink" } // method StartSession func (v *sink) GoStartSession(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 string, arg2 uint32, arg3 uint32, arg4 uint32, arg5 uint32, arg6 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StartSession", flags, ch, arg0, arg1, arg2, arg3, arg4, arg5, arg6) } func (*sink) StoreStartSession(call *dbus.Call) (arg7 dbus.ObjectPath, err error) { err = call.Store(&arg7) return } func (v *sink) StartSession(flags dbus.Flags, arg0 string, arg1 string, arg2 uint32, arg3 uint32, arg4 uint32, arg5 uint32, arg6 string) (arg7 dbus.ObjectPath, err error) { return v.StoreStartSession( <-v.GoStartSession(flags, make(chan *dbus.Call, 1), arg0, arg1, arg2, arg3, arg4, arg5, arg6).Done) } // property Session o func (v *sink) Session() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Session", } } // property Peer o func (v *sink) Peer() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Peer", } } type Session struct { session // interface org.freedesktop.miracle.wfd.Session proxy.Object } func NewSession(conn *dbus.Conn, path dbus.ObjectPath) (*Session, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Session) obj.Object.Init_(conn, "org.freedesktop.miracle.wfd", path) return obj, nil } type session struct{} func (v *session) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*session) GetInterfaceName_() string { return "org.freedesktop.miracle.wfd.Session" } // method Resume func (v *session) GoResume(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Resume", flags, ch) } func (v *session) Resume(flags dbus.Flags) error { return (<-v.GoResume(flags, make(chan *dbus.Call, 1)).Done).Err } // method Pause func (v *session) GoPause(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Pause", flags, ch) } func (v *session) Pause(flags dbus.Flags) error { return (<-v.GoPause(flags, make(chan *dbus.Call, 1)).Done).Err } // method Teardown func (v *session) GoTeardown(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Teardown", flags, ch) } func (v *session) Teardown(flags dbus.Flags) error { return (<-v.GoTeardown(flags, make(chan *dbus.Call, 1)).Done).Err } // property Sink o func (v *session) Sink() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Sink", } } // property Url s func (v *session) Url() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Url", } } // property State i func (v *session) State() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "State", } } go-dbus-factory-1.9.6/org.freedesktop.miracle.wfd/config.json000066400000000000000000000012521403054572700241760ustar00rootroot00000000000000{ "Service": "org.freedesktop.miracle.wfd", "Objects": [ { "Type": "Wfd", "Path": "/org/freedesktop/miracle/wfd", "Interfaces": [ { "Name": "org.freedesktop.DBus.ObjectManager" }, { "Name": "org.freedesktop.miracle.wfd", "Type": "wfd" } ] }, { "Type": "Sink", "Interfaces": [ { "Name": "org.freedesktop.miracle.wfd.Sink", "Type": "sink" } ] }, { "Type": "Session", "Interfaces": [ { "Name": "org.freedesktop.miracle.wfd.Session", "Type": "session" } ] } ] } go-dbus-factory-1.9.6/org.freedesktop.miracle.wifi/000077500000000000000000000000001403054572700222145ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.miracle.wifi/Link.xml000066400000000000000000000041371403054572700236400ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.miracle.wifi/Peer.xml000066400000000000000000000022341403054572700236320ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.miracle.wifi/Wifi.xml000066400000000000000000000035211403054572700236350ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.miracle.wifi/auto.go000066400000000000000000000160301403054572700235130ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.miracle.wifi"; DO NOT EDIT. package wifi import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "github.com/linuxdeepin/go-dbus-factory/object_manager" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Wifi struct { object_manager.ObjectManager // interface org.freedesktop.DBus.ObjectManager proxy.Object } func NewWifi(conn *dbus.Conn) *Wifi { obj := new(Wifi) obj.Object.Init_(conn, "org.freedesktop.miracle.wifi", "/org/freedesktop/miracle/wifi") return obj } type Link struct { link // interface org.freedesktop.miracle.wifi.Link proxy.Object } func NewLink(conn *dbus.Conn, path dbus.ObjectPath) (*Link, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Link) obj.Object.Init_(conn, "org.freedesktop.miracle.wifi", path) return obj, nil } type link struct{} func (v *link) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*link) GetInterfaceName_() string { return "org.freedesktop.miracle.wifi.Link" } // method Manage func (v *link) GoManage(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Manage", flags, ch) } func (v *link) Manage(flags dbus.Flags) error { return (<-v.GoManage(flags, make(chan *dbus.Call, 1)).Done).Err } // method Unmanage func (v *link) GoUnmanage(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Unmanage", flags, ch) } func (v *link) Unmanage(flags dbus.Flags) error { return (<-v.GoUnmanage(flags, make(chan *dbus.Call, 1)).Done).Err } // property InterfaceIndex u func (v *link) InterfaceIndex() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "InterfaceIndex", } } // property MACAddress s func (v *link) MACAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "MACAddress", } } // property InterfaceName s func (v *link) InterfaceName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "InterfaceName", } } // property FriendlyName s func (v *link) FriendlyName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FriendlyName", } } // property Managed b func (v *link) Managed() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Managed", } } // property P2PState i func (v *link) P2PState() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "P2PState", } } // property P2PScanning b func (v *link) P2PScanning() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "P2PScanning", } } // property WfdSubelements s func (v *link) WfdSubelements() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WfdSubelements", } } type Peer struct { peer // interface org.freedesktop.miracle.wifi.Peer proxy.Object } func NewPeer(conn *dbus.Conn, path dbus.ObjectPath) (*Peer, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Peer) obj.Object.Init_(conn, "org.freedesktop.miracle.wifi", path) return obj, nil } type peer struct{} func (v *peer) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*peer) GetInterfaceName_() string { return "org.freedesktop.miracle.wifi.Peer" } // method Connect func (v *peer) GoConnect(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Connect", flags, ch, arg0, arg1) } func (v *peer) Connect(flags dbus.Flags, arg0 string, arg1 string) error { return (<-v.GoConnect(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method Disconnect func (v *peer) GoDisconnect(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Disconnect", flags, ch) } func (v *peer) Disconnect(flags dbus.Flags) error { return (<-v.GoDisconnect(flags, make(chan *dbus.Call, 1)).Done).Err } // signal ProvisionDiscovery func (v *peer) ConnectProvisionDiscovery(cb func(arg0 string, arg1 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ProvisionDiscovery", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ProvisionDiscovery", } handlerFunc := func(sig *dbus.Signal) { var arg0 string var arg1 string err := dbus.Store(sig.Body, &arg0, &arg1) if err == nil { cb(arg0, arg1) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal GoNegRequest func (v *peer) ConnectGoNegRequest(cb func(arg0 string, arg1 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "GoNegRequest", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".GoNegRequest", } handlerFunc := func(sig *dbus.Signal) { var arg0 string var arg1 string err := dbus.Store(sig.Body, &arg0, &arg1) if err == nil { cb(arg0, arg1) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal FormationFailure func (v *peer) ConnectFormationFailure(cb func(arg0 string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "FormationFailure", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".FormationFailure", } handlerFunc := func(sig *dbus.Signal) { var arg0 string err := dbus.Store(sig.Body, &arg0) if err == nil { cb(arg0) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Link o func (v *peer) Link() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Link", } } // property P2PMac s func (v *peer) P2PMac() proxy.PropString { return proxy.PropString{ Impl: v, Name: "P2PMac", } } // property FriendlyName s func (v *peer) FriendlyName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FriendlyName", } } // property Connected b func (v *peer) Connected() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Connected", } } // property Interface s func (v *peer) Interface() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Interface", } } // property LocalAddress s func (v *peer) LocalAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "LocalAddress", } } // property RemoteAddress s func (v *peer) RemoteAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "RemoteAddress", } } // property WfdSubelements s func (v *peer) WfdSubelements() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WfdSubelements", } } go-dbus-factory-1.9.6/org.freedesktop.miracle.wifi/config.json000066400000000000000000000011071403054572700243530ustar00rootroot00000000000000{ "Service": "org.freedesktop.miracle.wifi", "Objects": [ { "Type": "Wifi", "Path": "/org/freedesktop/miracle/wifi", "Interfaces": [ { "Name": "org.freedesktop.DBus.ObjectManager" } ] }, { "Type": "Link", "Interfaces": [ { "Name": "org.freedesktop.miracle.wifi.Link", "Type": "link" } ] }, { "Type": "Peer", "Interfaces": [ { "Name": "org.freedesktop.miracle.wifi.Peer", "Type": "peer" } ] } ] } go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/000077500000000000000000000000001403054572700223605ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Bearer.xml000066400000000000000000000267601403054572700243150ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Call.xml000066400000000000000000000064351403054572700237650ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Modem.Firmware.xml000066400000000000000000000130261403054572700257200ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Modem.Location.xml000066400000000000000000000360641403054572700257230ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Modem.Messaging.xml000066400000000000000000000073141403054572700260640ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Modem.Modem3gpp.Ussd.xml000066400000000000000000000063271403054572700267220ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Modem.Modem3gpp.xml000066400000000000000000000131561403054572700260030ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Modem.ModemCdma.xml000066400000000000000000000143001403054572700257660ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Modem.Oma.xml000066400000000000000000000105161403054572700246610ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Modem.Signal.xml000066400000000000000000000157211403054572700253650ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Modem.Simple.xml000066400000000000000000000230211403054572700253710ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Modem.Time.xml000066400000000000000000000051421403054572700250420ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Modem.Voice.xml000066400000000000000000000045521403054572700252150ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Modem.xml000066400000000000000000000441611403054572700241510ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/ModemManager.xml000066400000000000000000000020201403054572700254300ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Sim.xml000066400000000000000000000050561403054572700236400ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/Sms.xml000066400000000000000000000145651403054572700236570ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/auto.go000066400000000000000000001303541403054572700236650ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.modemmanager1"; DO NOT EDIT. package modemmanager1 import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "github.com/linuxdeepin/go-dbus-factory/object_manager" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Manager struct { object_manager.ObjectManager // interface org.freedesktop.DBus.ObjectManager manager // interface org.freedesktop.ModemManager1 proxy.Object } func NewManager(conn *dbus.Conn) *Manager { obj := new(Manager) obj.Object.Init_(conn, "org.freedesktop.ModemManager1", "/org/freedesktop/ModemManager1") return obj } func (obj *Manager) ModemManager1() *manager { return &obj.manager } type manager struct{} func (v *manager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*manager) GetInterfaceName_() string { return "org.freedesktop.ModemManager1" } // method ScanDevices func (v *manager) GoScanDevices(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ScanDevices", flags, ch) } func (v *manager) ScanDevices(flags dbus.Flags) error { return (<-v.GoScanDevices(flags, make(chan *dbus.Call, 1)).Done).Err } // method SetLogging func (v *manager) GoSetLogging(flags dbus.Flags, ch chan *dbus.Call, level string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLogging", flags, ch, level) } func (v *manager) SetLogging(flags dbus.Flags, level string) error { return (<-v.GoSetLogging(flags, make(chan *dbus.Call, 1), level).Done).Err } type Modem struct { modem // interface org.freedesktop.ModemManager1.Modem modemFirmware // interface org.freedesktop.ModemManager1.Modem.Firmware modemLocation // interface org.freedesktop.ModemManager1.Modem.Location modemMessaging // interface org.freedesktop.ModemManager1.Modem.Messaging modem3gppUssd // interface org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd modem3gpp // interface org.freedesktop.ModemManager1.Modem.Modem3gpp modemCdma // interface org.freedesktop.ModemManager1.Modem.ModemCdma modemOma // interface org.freedesktop.ModemManager1.Modem.Oma modemSignal // interface org.freedesktop.ModemManager1.Modem.Signal modemSimple // interface org.freedesktop.ModemManager1.Modem.Simple modemTime // interface org.freedesktop.ModemManager1.Modem.Time modemVoice // interface org.freedesktop.ModemManager1.Modem.Voice proxy.Object } func NewModem(conn *dbus.Conn, path dbus.ObjectPath) (*Modem, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Modem) obj.Object.Init_(conn, "org.freedesktop.ModemManager1", path) return obj, nil } func (obj *Modem) Modem() *modem { return &obj.modem } type modem struct{} func (v *modem) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*modem) GetInterfaceName_() string { return "org.freedesktop.ModemManager1.Modem" } // method Enable func (v *modem) GoEnable(flags dbus.Flags, ch chan *dbus.Call, enable bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Enable", flags, ch, enable) } func (v *modem) Enable(flags dbus.Flags, enable bool) error { return (<-v.GoEnable(flags, make(chan *dbus.Call, 1), enable).Done).Err } // method ListBearers func (v *modem) GoListBearers(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListBearers", flags, ch) } func (*modem) StoreListBearers(call *dbus.Call) (bearers []dbus.ObjectPath, err error) { err = call.Store(&bearers) return } func (v *modem) ListBearers(flags dbus.Flags) (bearers []dbus.ObjectPath, err error) { return v.StoreListBearers( <-v.GoListBearers(flags, make(chan *dbus.Call, 1)).Done) } // method CreateBearer func (v *modem) GoCreateBearer(flags dbus.Flags, ch chan *dbus.Call, properties map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateBearer", flags, ch, properties) } func (*modem) StoreCreateBearer(call *dbus.Call) (path dbus.ObjectPath, err error) { err = call.Store(&path) return } func (v *modem) CreateBearer(flags dbus.Flags, properties map[string]dbus.Variant) (path dbus.ObjectPath, err error) { return v.StoreCreateBearer( <-v.GoCreateBearer(flags, make(chan *dbus.Call, 1), properties).Done) } // method DeleteBearer func (v *modem) GoDeleteBearer(flags dbus.Flags, ch chan *dbus.Call, bearer dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteBearer", flags, ch, bearer) } func (v *modem) DeleteBearer(flags dbus.Flags, bearer dbus.ObjectPath) error { return (<-v.GoDeleteBearer(flags, make(chan *dbus.Call, 1), bearer).Done).Err } // method Reset func (v *modem) GoReset(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reset", flags, ch) } func (v *modem) Reset(flags dbus.Flags) error { return (<-v.GoReset(flags, make(chan *dbus.Call, 1)).Done).Err } // method FactoryReset func (v *modem) GoFactoryReset(flags dbus.Flags, ch chan *dbus.Call, code string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".FactoryReset", flags, ch, code) } func (v *modem) FactoryReset(flags dbus.Flags, code string) error { return (<-v.GoFactoryReset(flags, make(chan *dbus.Call, 1), code).Done).Err } // method SetPowerState func (v *modem) GoSetPowerState(flags dbus.Flags, ch chan *dbus.Call, state uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetPowerState", flags, ch, state) } func (v *modem) SetPowerState(flags dbus.Flags, state uint32) error { return (<-v.GoSetPowerState(flags, make(chan *dbus.Call, 1), state).Done).Err } // method SetCurrentCapabilities func (v *modem) GoSetCurrentCapabilities(flags dbus.Flags, ch chan *dbus.Call, capabilities uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetCurrentCapabilities", flags, ch, capabilities) } func (v *modem) SetCurrentCapabilities(flags dbus.Flags, capabilities uint32) error { return (<-v.GoSetCurrentCapabilities(flags, make(chan *dbus.Call, 1), capabilities).Done).Err } // method SetCurrentModes func (v *modem) GoSetCurrentModes(flags dbus.Flags, ch chan *dbus.Call, modes ModemModes) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetCurrentModes", flags, ch, modes) } func (v *modem) SetCurrentModes(flags dbus.Flags, modes ModemModes) error { return (<-v.GoSetCurrentModes(flags, make(chan *dbus.Call, 1), modes).Done).Err } // method SetCurrentBands func (v *modem) GoSetCurrentBands(flags dbus.Flags, ch chan *dbus.Call, bands []uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetCurrentBands", flags, ch, bands) } func (v *modem) SetCurrentBands(flags dbus.Flags, bands []uint32) error { return (<-v.GoSetCurrentBands(flags, make(chan *dbus.Call, 1), bands).Done).Err } // method Command func (v *modem) GoCommand(flags dbus.Flags, ch chan *dbus.Call, cmd string, timeout uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Command", flags, ch, cmd, timeout) } func (*modem) StoreCommand(call *dbus.Call) (response string, err error) { err = call.Store(&response) return } func (v *modem) Command(flags dbus.Flags, cmd string, timeout uint32) (response string, err error) { return v.StoreCommand( <-v.GoCommand(flags, make(chan *dbus.Call, 1), cmd, timeout).Done) } // signal StateChanged func (v *modem) ConnectStateChanged(cb func(old int32, new int32, reason uint32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "StateChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".StateChanged", } handlerFunc := func(sig *dbus.Signal) { var old int32 var new int32 var reason uint32 err := dbus.Store(sig.Body, &old, &new, &reason) if err == nil { cb(old, new, reason) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Sim o func (v *modem) Sim() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Sim", } } // property Bearers ao func (v *modem) Bearers() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Bearers", } } // property SupportedCapabilities au func (v *modem) SupportedCapabilities() proxy.PropUint32Array { return proxy.PropUint32Array{ Impl: v, Name: "SupportedCapabilities", } } // property CurrentCapabilities u func (v *modem) CurrentCapabilities() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "CurrentCapabilities", } } // property MaxBearers u func (v *modem) MaxBearers() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "MaxBearers", } } // property MaxActiveBearers u func (v *modem) MaxActiveBearers() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "MaxActiveBearers", } } // property Manufacturer s func (v *modem) Manufacturer() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Manufacturer", } } // property Model s func (v *modem) Model() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Model", } } // property Revision s func (v *modem) Revision() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Revision", } } // property DeviceIdentifier s func (v *modem) DeviceIdentifier() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DeviceIdentifier", } } // property Device s func (v *modem) Device() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Device", } } // property Drivers as func (v *modem) Drivers() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Drivers", } } // property Plugin s func (v *modem) Plugin() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Plugin", } } // property PrimaryPort s func (v *modem) PrimaryPort() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PrimaryPort", } } // property Ports a(su) func (v *modem) Ports() PropModemPorts { return PropModemPorts{ Impl: v, } } type PropModemPorts struct { Impl proxy.Implementer } func (p PropModemPorts) Get(flags dbus.Flags) (value []ModemPort, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Ports", &value) return } func (p PropModemPorts) ConnectChanged(cb func(hasValue bool, value []ModemPort)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []ModemPort err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Ports", cb0) } // property EquipmentIdentifier s func (v *modem) EquipmentIdentifier() proxy.PropString { return proxy.PropString{ Impl: v, Name: "EquipmentIdentifier", } } // property UnlockRequired u func (v *modem) UnlockRequired() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "UnlockRequired", } } // property UnlockRetries a{uu} func (v *modem) UnlockRetries() PropModemUnlockRetries { return PropModemUnlockRetries{ Impl: v, } } type PropModemUnlockRetries struct { Impl proxy.Implementer } func (p PropModemUnlockRetries) Get(flags dbus.Flags) (value map[uint32]uint32, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "UnlockRetries", &value) return } func (p PropModemUnlockRetries) ConnectChanged(cb func(hasValue bool, value map[uint32]uint32)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[uint32]uint32 err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "UnlockRetries", cb0) } // property State i func (v *modem) State() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "State", } } // property StateFailedReason u func (v *modem) StateFailedReason() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "StateFailedReason", } } // property AccessTechnologies u func (v *modem) AccessTechnologies() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "AccessTechnologies", } } // property SignalQuality (ub) func (v *modem) SignalQuality() PropModemSignalQuality { return PropModemSignalQuality{ Impl: v, } } type PropModemSignalQuality struct { Impl proxy.Implementer } func (p PropModemSignalQuality) Get(flags dbus.Flags) (value ModemSignalQuality, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "SignalQuality", &value) return } func (p PropModemSignalQuality) ConnectChanged(cb func(hasValue bool, value ModemSignalQuality)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v ModemSignalQuality err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, ModemSignalQuality{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "SignalQuality", cb0) } // property OwnNumbers as func (v *modem) OwnNumbers() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "OwnNumbers", } } // property PowerState u func (v *modem) PowerState() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "PowerState", } } // property SupportedModes a(uu) func (v *modem) SupportedModes() PropModemSupportedModes { return PropModemSupportedModes{ Impl: v, } } type PropModemSupportedModes struct { Impl proxy.Implementer } func (p PropModemSupportedModes) Get(flags dbus.Flags) (value []ModemModes, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "SupportedModes", &value) return } func (p PropModemSupportedModes) ConnectChanged(cb func(hasValue bool, value []ModemModes)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []ModemModes err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "SupportedModes", cb0) } // property CurrentModes (uu) func (v *modem) CurrentModes() PropModemCurrentModes { return PropModemCurrentModes{ Impl: v, } } type PropModemCurrentModes struct { Impl proxy.Implementer } func (p PropModemCurrentModes) Get(flags dbus.Flags) (value ModemModes, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "CurrentModes", &value) return } func (p PropModemCurrentModes) ConnectChanged(cb func(hasValue bool, value ModemModes)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v ModemModes err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, ModemModes{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "CurrentModes", cb0) } // property SupportedBands au func (v *modem) SupportedBands() proxy.PropUint32Array { return proxy.PropUint32Array{ Impl: v, Name: "SupportedBands", } } // property CurrentBands au func (v *modem) CurrentBands() proxy.PropUint32Array { return proxy.PropUint32Array{ Impl: v, Name: "CurrentBands", } } // property SupportedIpFamilies u func (v *modem) SupportedIpFamilies() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "SupportedIpFamilies", } } func (obj *Modem) Firmware() *modemFirmware { return &obj.modemFirmware } type modemFirmware struct{} func (v *modemFirmware) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*modemFirmware) GetInterfaceName_() string { return "org.freedesktop.ModemManager1.Modem.Firmware" } // method List func (v *modemFirmware) GoList(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".List", flags, ch) } func (*modemFirmware) StoreList(call *dbus.Call) (selected string, installed []map[string]dbus.Variant, err error) { err = call.Store(&selected, &installed) return } func (v *modemFirmware) List(flags dbus.Flags) (selected string, installed []map[string]dbus.Variant, err error) { return v.StoreList( <-v.GoList(flags, make(chan *dbus.Call, 1)).Done) } // method Select func (v *modemFirmware) GoSelect(flags dbus.Flags, ch chan *dbus.Call, uniqueid string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Select", flags, ch, uniqueid) } func (v *modemFirmware) Select(flags dbus.Flags, uniqueid string) error { return (<-v.GoSelect(flags, make(chan *dbus.Call, 1), uniqueid).Done).Err } func (obj *Modem) Location() *modemLocation { return &obj.modemLocation } type modemLocation struct{} func (v *modemLocation) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*modemLocation) GetInterfaceName_() string { return "org.freedesktop.ModemManager1.Modem.Location" } // method Setup func (v *modemLocation) GoSetup(flags dbus.Flags, ch chan *dbus.Call, sources uint32, signal_location bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Setup", flags, ch, sources, signal_location) } func (v *modemLocation) Setup(flags dbus.Flags, sources uint32, signal_location bool) error { return (<-v.GoSetup(flags, make(chan *dbus.Call, 1), sources, signal_location).Done).Err } // method GetLocation func (v *modemLocation) GoGetLocation(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetLocation", flags, ch) } func (*modemLocation) StoreGetLocation(call *dbus.Call) (Location map[uint32]dbus.Variant, err error) { err = call.Store(&Location) return } func (v *modemLocation) GetLocation(flags dbus.Flags) (Location map[uint32]dbus.Variant, err error) { return v.StoreGetLocation( <-v.GoGetLocation(flags, make(chan *dbus.Call, 1)).Done) } // method SetSuplServer func (v *modemLocation) GoSetSuplServer(flags dbus.Flags, ch chan *dbus.Call, supl string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetSuplServer", flags, ch, supl) } func (v *modemLocation) SetSuplServer(flags dbus.Flags, supl string) error { return (<-v.GoSetSuplServer(flags, make(chan *dbus.Call, 1), supl).Done).Err } // method SetGpsRefreshRate func (v *modemLocation) GoSetGpsRefreshRate(flags dbus.Flags, ch chan *dbus.Call, rate uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetGpsRefreshRate", flags, ch, rate) } func (v *modemLocation) SetGpsRefreshRate(flags dbus.Flags, rate uint32) error { return (<-v.GoSetGpsRefreshRate(flags, make(chan *dbus.Call, 1), rate).Done).Err } // property Capabilities u func (v *modemLocation) Capabilities() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Capabilities", } } // property Enabled u func (v *modemLocation) Enabled() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Enabled", } } // property SignalsLocation b func (v *modemLocation) SignalsLocation() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SignalsLocation", } } // property Location a{uv} func (v *modemLocation) Location() PropModemLocation { return PropModemLocation{ Impl: v, } } type PropModemLocation struct { Impl proxy.Implementer } func (p PropModemLocation) Get(flags dbus.Flags) (value map[uint32]dbus.Variant, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Location", &value) return } func (p PropModemLocation) ConnectChanged(cb func(hasValue bool, value map[uint32]dbus.Variant)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[uint32]dbus.Variant err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Location", cb0) } // property SuplServer s func (v *modemLocation) SuplServer() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SuplServer", } } // property GpsRefreshRate u func (v *modemLocation) GpsRefreshRate() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "GpsRefreshRate", } } func (obj *Modem) Messaging() *modemMessaging { return &obj.modemMessaging } type modemMessaging struct{} func (v *modemMessaging) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*modemMessaging) GetInterfaceName_() string { return "org.freedesktop.ModemManager1.Modem.Messaging" } // method List func (v *modemMessaging) GoList(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".List", flags, ch) } func (*modemMessaging) StoreList(call *dbus.Call) (result []dbus.ObjectPath, err error) { err = call.Store(&result) return } func (v *modemMessaging) List(flags dbus.Flags) (result []dbus.ObjectPath, err error) { return v.StoreList( <-v.GoList(flags, make(chan *dbus.Call, 1)).Done) } // method Delete func (v *modemMessaging) GoDelete(flags dbus.Flags, ch chan *dbus.Call, path dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Delete", flags, ch, path) } func (v *modemMessaging) Delete(flags dbus.Flags, path dbus.ObjectPath) error { return (<-v.GoDelete(flags, make(chan *dbus.Call, 1), path).Done).Err } // method Create func (v *modemMessaging) GoCreate(flags dbus.Flags, ch chan *dbus.Call, properties map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Create", flags, ch, properties) } func (*modemMessaging) StoreCreate(call *dbus.Call) (path dbus.ObjectPath, err error) { err = call.Store(&path) return } func (v *modemMessaging) Create(flags dbus.Flags, properties map[string]dbus.Variant) (path dbus.ObjectPath, err error) { return v.StoreCreate( <-v.GoCreate(flags, make(chan *dbus.Call, 1), properties).Done) } // signal Added func (v *modemMessaging) ConnectAdded(cb func(path dbus.ObjectPath, received bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Added", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Added", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath var received bool err := dbus.Store(sig.Body, &path, &received) if err == nil { cb(path, received) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Deleted func (v *modemMessaging) ConnectDeleted(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Deleted", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Deleted", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Messages ao func (v *modemMessaging) Messages() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Messages", } } // property SupportedStorages au func (v *modemMessaging) SupportedStorages() proxy.PropUint32Array { return proxy.PropUint32Array{ Impl: v, Name: "SupportedStorages", } } // property DefaultStorage u func (v *modemMessaging) DefaultStorage() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "DefaultStorage", } } func (obj *Modem) Modem3gppUssd() *modem3gppUssd { return &obj.modem3gppUssd } type modem3gppUssd struct{} func (v *modem3gppUssd) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*modem3gppUssd) GetInterfaceName_() string { return "org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd" } // method Initiate func (v *modem3gppUssd) GoInitiate(flags dbus.Flags, ch chan *dbus.Call, command string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Initiate", flags, ch, command) } func (*modem3gppUssd) StoreInitiate(call *dbus.Call) (reply string, err error) { err = call.Store(&reply) return } func (v *modem3gppUssd) Initiate(flags dbus.Flags, command string) (reply string, err error) { return v.StoreInitiate( <-v.GoInitiate(flags, make(chan *dbus.Call, 1), command).Done) } // method Respond func (v *modem3gppUssd) GoRespond(flags dbus.Flags, ch chan *dbus.Call, response string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Respond", flags, ch, response) } func (*modem3gppUssd) StoreRespond(call *dbus.Call) (reply string, err error) { err = call.Store(&reply) return } func (v *modem3gppUssd) Respond(flags dbus.Flags, response string) (reply string, err error) { return v.StoreRespond( <-v.GoRespond(flags, make(chan *dbus.Call, 1), response).Done) } // method Cancel func (v *modem3gppUssd) GoCancel(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Cancel", flags, ch) } func (v *modem3gppUssd) Cancel(flags dbus.Flags) error { return (<-v.GoCancel(flags, make(chan *dbus.Call, 1)).Done).Err } // property State u func (v *modem3gppUssd) State() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "State", } } // property NetworkNotification s func (v *modem3gppUssd) NetworkNotification() proxy.PropString { return proxy.PropString{ Impl: v, Name: "NetworkNotification", } } // property NetworkRequest s func (v *modem3gppUssd) NetworkRequest() proxy.PropString { return proxy.PropString{ Impl: v, Name: "NetworkRequest", } } func (obj *Modem) Modem3gpp() *modem3gpp { return &obj.modem3gpp } type modem3gpp struct{} func (v *modem3gpp) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*modem3gpp) GetInterfaceName_() string { return "org.freedesktop.ModemManager1.Modem.Modem3gpp" } // method Register func (v *modem3gpp) GoRegister(flags dbus.Flags, ch chan *dbus.Call, operator_id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Register", flags, ch, operator_id) } func (v *modem3gpp) Register(flags dbus.Flags, operator_id string) error { return (<-v.GoRegister(flags, make(chan *dbus.Call, 1), operator_id).Done).Err } // method Scan func (v *modem3gpp) GoScan(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Scan", flags, ch) } func (*modem3gpp) StoreScan(call *dbus.Call) (results []map[string]dbus.Variant, err error) { err = call.Store(&results) return } func (v *modem3gpp) Scan(flags dbus.Flags) (results []map[string]dbus.Variant, err error) { return v.StoreScan( <-v.GoScan(flags, make(chan *dbus.Call, 1)).Done) } // property Imei s func (v *modem3gpp) Imei() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Imei", } } // property RegistrationState u func (v *modem3gpp) RegistrationState() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "RegistrationState", } } // property OperatorCode s func (v *modem3gpp) OperatorCode() proxy.PropString { return proxy.PropString{ Impl: v, Name: "OperatorCode", } } // property OperatorName s func (v *modem3gpp) OperatorName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "OperatorName", } } // property EnabledFacilityLocks u func (v *modem3gpp) EnabledFacilityLocks() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "EnabledFacilityLocks", } } // property SubscriptionState u func (v *modem3gpp) SubscriptionState() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "SubscriptionState", } } func (obj *Modem) Cdma() *modemCdma { return &obj.modemCdma } type modemCdma struct{} func (v *modemCdma) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*modemCdma) GetInterfaceName_() string { return "org.freedesktop.ModemManager1.Modem.ModemCdma" } // method Activate func (v *modemCdma) GoActivate(flags dbus.Flags, ch chan *dbus.Call, carrier_code string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Activate", flags, ch, carrier_code) } func (v *modemCdma) Activate(flags dbus.Flags, carrier_code string) error { return (<-v.GoActivate(flags, make(chan *dbus.Call, 1), carrier_code).Done).Err } // method ActivateManual func (v *modemCdma) GoActivateManual(flags dbus.Flags, ch chan *dbus.Call, properties map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ActivateManual", flags, ch, properties) } func (v *modemCdma) ActivateManual(flags dbus.Flags, properties map[string]dbus.Variant) error { return (<-v.GoActivateManual(flags, make(chan *dbus.Call, 1), properties).Done).Err } // signal ActivationStateChanged func (v *modemCdma) ConnectActivationStateChanged(cb func(activation_state uint32, activation_error uint32, status_changes map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ActivationStateChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ActivationStateChanged", } handlerFunc := func(sig *dbus.Signal) { var activation_state uint32 var activation_error uint32 var status_changes map[string]dbus.Variant err := dbus.Store(sig.Body, &activation_state, &activation_error, &status_changes) if err == nil { cb(activation_state, activation_error, status_changes) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property ActivationState u func (v *modemCdma) ActivationState() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "ActivationState", } } // property Meid s func (v *modemCdma) Meid() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Meid", } } // property Esn s func (v *modemCdma) Esn() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Esn", } } // property Sid u func (v *modemCdma) Sid() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Sid", } } // property Nid u func (v *modemCdma) Nid() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Nid", } } // property Cdma1xRegistrationState u func (v *modemCdma) Cdma1xRegistrationState() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Cdma1xRegistrationState", } } // property EvdoRegistrationState u func (v *modemCdma) EvdoRegistrationState() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "EvdoRegistrationState", } } func (obj *Modem) Oma() *modemOma { return &obj.modemOma } type modemOma struct{} func (v *modemOma) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*modemOma) GetInterfaceName_() string { return "org.freedesktop.ModemManager1.Modem.Oma" } // method Setup func (v *modemOma) GoSetup(flags dbus.Flags, ch chan *dbus.Call, features uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Setup", flags, ch, features) } func (v *modemOma) Setup(flags dbus.Flags, features uint32) error { return (<-v.GoSetup(flags, make(chan *dbus.Call, 1), features).Done).Err } // method StartClientInitiatedSession func (v *modemOma) GoStartClientInitiatedSession(flags dbus.Flags, ch chan *dbus.Call, session_type uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StartClientInitiatedSession", flags, ch, session_type) } func (v *modemOma) StartClientInitiatedSession(flags dbus.Flags, session_type uint32) error { return (<-v.GoStartClientInitiatedSession(flags, make(chan *dbus.Call, 1), session_type).Done).Err } // method AcceptNetworkInitiatedSession func (v *modemOma) GoAcceptNetworkInitiatedSession(flags dbus.Flags, ch chan *dbus.Call, session_id uint32, accept bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AcceptNetworkInitiatedSession", flags, ch, session_id, accept) } func (v *modemOma) AcceptNetworkInitiatedSession(flags dbus.Flags, session_id uint32, accept bool) error { return (<-v.GoAcceptNetworkInitiatedSession(flags, make(chan *dbus.Call, 1), session_id, accept).Done).Err } // method CancelSession func (v *modemOma) GoCancelSession(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CancelSession", flags, ch) } func (v *modemOma) CancelSession(flags dbus.Flags) error { return (<-v.GoCancelSession(flags, make(chan *dbus.Call, 1)).Done).Err } // signal SessionStateChanged func (v *modemOma) ConnectSessionStateChanged(cb func(old_session_state int32, new_session_state int32, session_state_failed_reason uint32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SessionStateChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SessionStateChanged", } handlerFunc := func(sig *dbus.Signal) { var old_session_state int32 var new_session_state int32 var session_state_failed_reason uint32 err := dbus.Store(sig.Body, &old_session_state, &new_session_state, &session_state_failed_reason) if err == nil { cb(old_session_state, new_session_state, session_state_failed_reason) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Features u func (v *modemOma) Features() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Features", } } // property PendingNetworkInitiatedSessions a(uu) func (v *modemOma) PendingNetworkInitiatedSessions() PropModemOmaPendingNetworkInitiatedSessions { return PropModemOmaPendingNetworkInitiatedSessions{ Impl: v, } } type PropModemOmaPendingNetworkInitiatedSessions struct { Impl proxy.Implementer } func (p PropModemOmaPendingNetworkInitiatedSessions) Get(flags dbus.Flags) (value []OmaSession, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "PendingNetworkInitiatedSessions", &value) return } func (p PropModemOmaPendingNetworkInitiatedSessions) ConnectChanged(cb func(hasValue bool, value []OmaSession)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []OmaSession err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "PendingNetworkInitiatedSessions", cb0) } // property SessionType u func (v *modemOma) SessionType() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "SessionType", } } // property SessionState i func (v *modemOma) SessionState() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "SessionState", } } func (obj *Modem) Signal() *modemSignal { return &obj.modemSignal } type modemSignal struct{} func (v *modemSignal) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*modemSignal) GetInterfaceName_() string { return "org.freedesktop.ModemManager1.Modem.Signal" } // method Setup func (v *modemSignal) GoSetup(flags dbus.Flags, ch chan *dbus.Call, rate uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Setup", flags, ch, rate) } func (v *modemSignal) Setup(flags dbus.Flags, rate uint32) error { return (<-v.GoSetup(flags, make(chan *dbus.Call, 1), rate).Done).Err } // property Rate u func (v *modemSignal) Rate() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Rate", } } // property Cdma a{sv} func (v *modemSignal) Cdma() PropMapStringVariant { return PropMapStringVariant{ Impl: v, Name: "Cdma", } } // property Evdo a{sv} func (v *modemSignal) Evdo() PropMapStringVariant { return PropMapStringVariant{ Impl: v, Name: "Evdo", } } // property Gsm a{sv} func (v *modemSignal) Gsm() PropMapStringVariant { return PropMapStringVariant{ Impl: v, Name: "Gsm", } } // property Umts a{sv} func (v *modemSignal) Umts() PropMapStringVariant { return PropMapStringVariant{ Impl: v, Name: "Umts", } } // property Lte a{sv} func (v *modemSignal) Lte() PropMapStringVariant { return PropMapStringVariant{ Impl: v, Name: "Lte", } } func (obj *Modem) Simple() *modemSimple { return &obj.modemSimple } type modemSimple struct{} func (v *modemSimple) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*modemSimple) GetInterfaceName_() string { return "org.freedesktop.ModemManager1.Modem.Simple" } // method Connect func (v *modemSimple) GoConnect(flags dbus.Flags, ch chan *dbus.Call, properties map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Connect", flags, ch, properties) } func (*modemSimple) StoreConnect(call *dbus.Call) (bearer dbus.ObjectPath, err error) { err = call.Store(&bearer) return } func (v *modemSimple) Connect(flags dbus.Flags, properties map[string]dbus.Variant) (bearer dbus.ObjectPath, err error) { return v.StoreConnect( <-v.GoConnect(flags, make(chan *dbus.Call, 1), properties).Done) } // method Disconnect func (v *modemSimple) GoDisconnect(flags dbus.Flags, ch chan *dbus.Call, bearer dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Disconnect", flags, ch, bearer) } func (v *modemSimple) Disconnect(flags dbus.Flags, bearer dbus.ObjectPath) error { return (<-v.GoDisconnect(flags, make(chan *dbus.Call, 1), bearer).Done).Err } // method GetStatus func (v *modemSimple) GoGetStatus(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetStatus", flags, ch) } func (*modemSimple) StoreGetStatus(call *dbus.Call) (properties map[string]dbus.Variant, err error) { err = call.Store(&properties) return } func (v *modemSimple) GetStatus(flags dbus.Flags) (properties map[string]dbus.Variant, err error) { return v.StoreGetStatus( <-v.GoGetStatus(flags, make(chan *dbus.Call, 1)).Done) } func (obj *Modem) Time() *modemTime { return &obj.modemTime } type modemTime struct{} func (v *modemTime) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*modemTime) GetInterfaceName_() string { return "org.freedesktop.ModemManager1.Modem.Time" } // method GetNetworkTime func (v *modemTime) GoGetNetworkTime(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetNetworkTime", flags, ch) } func (*modemTime) StoreGetNetworkTime(call *dbus.Call) (time string, err error) { err = call.Store(&time) return } func (v *modemTime) GetNetworkTime(flags dbus.Flags) (time string, err error) { return v.StoreGetNetworkTime( <-v.GoGetNetworkTime(flags, make(chan *dbus.Call, 1)).Done) } // signal NetworkTimeChanged func (v *modemTime) ConnectNetworkTimeChanged(cb func(time string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NetworkTimeChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NetworkTimeChanged", } handlerFunc := func(sig *dbus.Signal) { var time string err := dbus.Store(sig.Body, &time) if err == nil { cb(time) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property NetworkTimezone a{sv} func (v *modemTime) NetworkTimezone() PropMapStringVariant { return PropMapStringVariant{ Impl: v, Name: "NetworkTimezone", } } func (obj *Modem) Voice() *modemVoice { return &obj.modemVoice } type modemVoice struct{} func (v *modemVoice) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*modemVoice) GetInterfaceName_() string { return "org.freedesktop.ModemManager1.Modem.Voice" } // method ListCalls func (v *modemVoice) GoListCalls(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListCalls", flags, ch) } func (*modemVoice) StoreListCalls(call *dbus.Call) (result []dbus.ObjectPath, err error) { err = call.Store(&result) return } func (v *modemVoice) ListCalls(flags dbus.Flags) (result []dbus.ObjectPath, err error) { return v.StoreListCalls( <-v.GoListCalls(flags, make(chan *dbus.Call, 1)).Done) } // method DeleteCall func (v *modemVoice) GoDeleteCall(flags dbus.Flags, ch chan *dbus.Call, path dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteCall", flags, ch, path) } func (v *modemVoice) DeleteCall(flags dbus.Flags, path dbus.ObjectPath) error { return (<-v.GoDeleteCall(flags, make(chan *dbus.Call, 1), path).Done).Err } // method CreateCall func (v *modemVoice) GoCreateCall(flags dbus.Flags, ch chan *dbus.Call, properties map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateCall", flags, ch, properties) } func (*modemVoice) StoreCreateCall(call *dbus.Call) (path dbus.ObjectPath, err error) { err = call.Store(&path) return } func (v *modemVoice) CreateCall(flags dbus.Flags, properties map[string]dbus.Variant) (path dbus.ObjectPath, err error) { return v.StoreCreateCall( <-v.GoCreateCall(flags, make(chan *dbus.Call, 1), properties).Done) } // signal CallAdded func (v *modemVoice) ConnectCallAdded(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "CallAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".CallAdded", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal CallDeleted func (v *modemVoice) ConnectCallDeleted(cb func(path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "CallDeleted", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".CallDeleted", } handlerFunc := func(sig *dbus.Signal) { var path dbus.ObjectPath err := dbus.Store(sig.Body, &path) if err == nil { cb(path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Calls ao func (v *modemVoice) Calls() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Calls", } } type PropMapStringVariant struct { Impl proxy.Implementer Name string } func (p PropMapStringVariant) Get(flags dbus.Flags) (value map[string]dbus.Variant, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropMapStringVariant) Set(flags dbus.Flags, value map[string]dbus.Variant) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropMapStringVariant) ConnectChanged(cb func(hasValue bool, value map[string]dbus.Variant)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[string]dbus.Variant err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/config.json000066400000000000000000000103521403054572700245210ustar00rootroot00000000000000{ "Service": "org.freedesktop.ModemManager1", "Objects": [ { "Type": "Manager", "XmlFile": "ModemManager", "Path": "/org/freedesktop/ModemManager1", "Interfaces": [ { "Name": "org.freedesktop.DBus.ObjectManager" }, { "Name":"org.freedesktop.ModemManager1", "Type": "manager" } ] }, { "Type": "Modem", "XmlFiles": ["Modem", "Modem.*"], "Interfaces": [ { "Name": "org.freedesktop.ModemManager1.Modem", "Accessor": "Modem", "Type": "modem", "Fixes": { "p/Ports": { "Type": "PropModemPorts", "ValueType": "[]ModemPort" }, "p/UnlockRetries": { "Type": "PropModemUnlockRetries", "ValueType": "map[uint32]uint32" }, "p/SignalQuality": { "Type": "PropModemSignalQuality", "ValueType": "ModemSignalQuality", "EmptyValue": "$T{}" }, "p/SupportedModes": { "Type": "PropModemSupportedModes", "ValueType": "[]ModemModes" }, "p/CurrentModes": { "Type": "PropModemCurrentModes", "ValueType": "ModemModes", "EmptyValue": "$T{}" }, "m/SetCurrentModes": [ { "Name": "modes", "Type": "ModemModes" } ] } }, { "Name": "org.freedesktop.ModemManager1.Modem.Firmware", "Accessor": "Firmware", "Type": "modemFirmware" }, { "Name":"org.freedesktop.ModemManager1.Modem.Location", "Accessor": "Location", "Type": "modemLocation", "Fixes": { "p/Location": { "Type": "PropModemLocation", "ValueType": "map[uint32]dbus.Variant" } } }, { "Name":"org.freedesktop.ModemManager1.Modem.Messaging", "Accessor": "Messaging", "Type": "modemMessaging" }, { "Name": "org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd", "Accessor": "Modem3gppUssd", "Type": "modem3gppUssd" }, { "Name": "org.freedesktop.ModemManager1.Modem.Modem3gpp", "Accessor": "Modem3gpp", "Type": "modem3gpp" }, { "Name": "org.freedesktop.ModemManager1.Modem.ModemCdma", "Accessor": "Cdma", "Type": "modemCdma" }, { "Name": "org.freedesktop.ModemManager1.Modem.Oma", "Accessor": "Oma", "Type": "modemOma", "Fixes": { "p/PendingNetworkInitiatedSessions": { "Type": "PropModemOmaPendingNetworkInitiatedSessions", "ValueType": "[]OmaSession" } } }, { "Name": "org.freedesktop.ModemManager1.Modem.Signal", "Accessor": "Signal", "Type": "modemSignal", "Fixes": { "p/Cdma": { "RefType": "PropMapStringVariant" }, "p/Evdo": { "RefType": "PropMapStringVariant" }, "p/Gsm": { "RefType": "PropMapStringVariant" }, "p/Umts": { "RefType": "PropMapStringVariant" }, "p/Lte": { "RefType": "PropMapStringVariant" } } }, { "Name": "org.freedesktop.ModemManager1.Modem.Simple", "Accessor": "Simple", "Type": "modemSimple" }, { "Name": "org.freedesktop.ModemManager1.Modem.Time", "Accessor": "Time", "Type": "modemTime", "Fixes": { "p/NetworkTimezone": { "RefType": "PropMapStringVariant" } } }, { "Name": "org.freedesktop.ModemManager1.Modem.Voice", "Accessor": "Voice", "Type": "modemVoice" } ] } ], "PropertyTypes": [ { "Type": "PropMapStringVariant", "ValueType": "map[string]dbus.Variant" } ] } go-dbus-factory-1.9.6/org.freedesktop.modemmanager1/manual.go000066400000000000000000000004271403054572700241670ustar00rootroot00000000000000package modemmanager1 type ModemPort struct { Name string Type uint32 } type ModemSignalQuality struct { Quality uint32 RecentlyTaken bool } type ModemModes struct { AllowedModes uint32 PreferredMode uint32 } type OmaSession struct { Type uint32 Id uint32 } go-dbus-factory-1.9.6/org.freedesktop.networkmanager/000077500000000000000000000000001403054572700226675ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.networkmanager/AccessPoint.xml000066400000000000000000000056361403054572700256360ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/AgentManager.xml000066400000000000000000000033671403054572700257530ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Checkpoint.xml000066400000000000000000000024101403054572700254750ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Connection.Active.xml000066400000000000000000000132141403054572700267230ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/DHCP4Config.xml000066400000000000000000000016421403054572700253440ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/DHCP6Config.xml000066400000000000000000000016421403054572700253460ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Adsl.xml000066400000000000000000000014061403054572700254730ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Bluetooth.xml000066400000000000000000000022171403054572700265560ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Bond.xml000066400000000000000000000022021403054572700254650ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Bridge.xml000066400000000000000000000022071403054572700260040ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Dummy.xml000066400000000000000000000011661403054572700257060ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Generic.xml000066400000000000000000000016701403054572700261670ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.IPTunnel.xml000066400000000000000000000045711403054572700263140ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Infiniband.xml000066400000000000000000000017221403054572700266520ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Macsec.xml000066400000000000000000000052541403054572700260100ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Macvlan.xml000066400000000000000000000023051403054572700261700ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Modem.xml000066400000000000000000000026401403054572700256520ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.OlpcMesh.xml000066400000000000000000000020571403054572700263250ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Statistics.xml000066400000000000000000000024131403054572700267410ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Team.xml000066400000000000000000000024341403054572700255000ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Tun.xml000066400000000000000000000034541403054572700253630ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Veth.xml000066400000000000000000000014011403054572700255110ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Vlan.xml000066400000000000000000000023411403054572700255070ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Vxlan.xml000066400000000000000000000067001403054572700257020ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.WiMax.xml000066400000000000000000000063251403054572700256420ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Wired.xml000066400000000000000000000027701403054572700256670ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.Wireless.xml000066400000000000000000000071651403054572700264150ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Device.xml000066400000000000000000000320631403054572700246140ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/DnsManager.xml000066400000000000000000000022311403054572700254260ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/IP4Config.xml000066400000000000000000000061511403054572700251360ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/IP6Config.xml000066400000000000000000000053221403054572700251370ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/NetworkManager.xml000066400000000000000000000513251403054572700263430ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/PPP.xml000066400000000000000000000014051403054572700240500ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/SecretAgent.xml000066400000000000000000000140031403054572700256130ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Settings.Connection.xml000066400000000000000000000112301403054572700273040ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/Settings.xml000066400000000000000000000151571403054572700252220ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/VPN.Connection.xml000066400000000000000000000031571403054572700261600ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/VPN.Plugin.xml000066400000000000000000000150721403054572700253160ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/WiMax.Nsp.xml000066400000000000000000000021611403054572700251750ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.networkmanager/auto.go000066400000000000000000003602541403054572700242000ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.networkmanager"; DO NOT EDIT. package networkmanager import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "github.com/linuxdeepin/go-dbus-factory/object_manager" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type ObjectManager struct { object_manager.ObjectManager // interface org.freedesktop.DBus.ObjectManager proxy.Object } func NewObjectManager(conn *dbus.Conn) *ObjectManager { obj := new(ObjectManager) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", "/org/freedesktop") return obj } type AccessPoint struct { accessPoint // interface org.freedesktop.NetworkManager.AccessPoint proxy.Object } func NewAccessPoint(conn *dbus.Conn, path dbus.ObjectPath) (*AccessPoint, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(AccessPoint) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } func (obj *AccessPoint) AccessPoint() *accessPoint { return &obj.accessPoint } type accessPoint struct{} func (v *accessPoint) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*accessPoint) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.AccessPoint" } // signal PropertiesChanged func (v *accessPoint) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Flags u func (v *accessPoint) Flags() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Flags", } } // property WpaFlags u func (v *accessPoint) WpaFlags() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "WpaFlags", } } // property RsnFlags u func (v *accessPoint) RsnFlags() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "RsnFlags", } } // property Ssid ay func (v *accessPoint) Ssid() proxy.PropByteArray { return proxy.PropByteArray{ Impl: v, Name: "Ssid", } } // property Frequency u func (v *accessPoint) Frequency() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Frequency", } } // property HwAddress s func (v *accessPoint) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } // property Mode u func (v *accessPoint) Mode() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Mode", } } // property MaxBitrate u func (v *accessPoint) MaxBitrate() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "MaxBitrate", } } // property Strength y func (v *accessPoint) Strength() proxy.PropByte { return proxy.PropByte{ Impl: v, Name: "Strength", } } // property LastSeen i func (v *accessPoint) LastSeen() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "LastSeen", } } type AgentManager struct { agentManager // interface org.freedesktop.NetworkManager.AgentManager proxy.Object } func NewAgentManager(conn *dbus.Conn) *AgentManager { obj := new(AgentManager) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager/AgentManager") return obj } type agentManager struct{} func (v *agentManager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*agentManager) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.AgentManager" } // method Register func (v *agentManager) GoRegister(flags dbus.Flags, ch chan *dbus.Call, identifier string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Register", flags, ch, identifier) } func (v *agentManager) Register(flags dbus.Flags, identifier string) error { return (<-v.GoRegister(flags, make(chan *dbus.Call, 1), identifier).Done).Err } // method RegisterWithCapabilities func (v *agentManager) GoRegisterWithCapabilities(flags dbus.Flags, ch chan *dbus.Call, identifier string, capabilities uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterWithCapabilities", flags, ch, identifier, capabilities) } func (v *agentManager) RegisterWithCapabilities(flags dbus.Flags, identifier string, capabilities uint32) error { return (<-v.GoRegisterWithCapabilities(flags, make(chan *dbus.Call, 1), identifier, capabilities).Done).Err } // method Unregister func (v *agentManager) GoUnregister(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Unregister", flags, ch) } func (v *agentManager) Unregister(flags dbus.Flags) error { return (<-v.GoUnregister(flags, make(chan *dbus.Call, 1)).Done).Err } type Checkpoint struct { checkpoint // interface org.freedesktop.NetworkManager.Checkpoint proxy.Object } func NewCheckpoint(conn *dbus.Conn, path dbus.ObjectPath) (*Checkpoint, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Checkpoint) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } type checkpoint struct{} func (v *checkpoint) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*checkpoint) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Checkpoint" } // signal PropertiesChanged func (v *checkpoint) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Devices ao func (v *checkpoint) Devices() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Devices", } } // property Created x func (v *checkpoint) Created() proxy.PropInt64 { return proxy.PropInt64{ Impl: v, Name: "Created", } } // property RollbackTimeout u func (v *checkpoint) RollbackTimeout() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "RollbackTimeout", } } type ActiveConnection struct { activeConnection // interface org.freedesktop.NetworkManager.Connection.Active proxy.Object } func NewActiveConnection(conn *dbus.Conn, path dbus.ObjectPath) (*ActiveConnection, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(ActiveConnection) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } type activeConnection struct{} func (v *activeConnection) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*activeConnection) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Connection.Active" } // signal StateChanged func (v *activeConnection) ConnectStateChanged(cb func(state uint32, reason uint32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "StateChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".StateChanged", } handlerFunc := func(sig *dbus.Signal) { var state uint32 var reason uint32 err := dbus.Store(sig.Body, &state, &reason) if err == nil { cb(state, reason) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal PropertiesChanged func (v *activeConnection) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Connection o func (v *activeConnection) Connection() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Connection", } } // property SpecificObject o func (v *activeConnection) SpecificObject() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "SpecificObject", } } // property Id s func (v *activeConnection) Id() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Id", } } // property Uuid s func (v *activeConnection) Uuid() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Uuid", } } // property Type s func (v *activeConnection) Type() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Type", } } // property Devices ao func (v *activeConnection) Devices() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Devices", } } // property State u func (v *activeConnection) State() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "State", } } // property Default b func (v *activeConnection) Default() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Default", } } // property Ip4Config o func (v *activeConnection) Ip4Config() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Ip4Config", } } // property Dhcp4Config o func (v *activeConnection) Dhcp4Config() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Dhcp4Config", } } // property Default6 b func (v *activeConnection) Default6() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Default6", } } // property Ip6Config o func (v *activeConnection) Ip6Config() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Ip6Config", } } // property Dhcp6Config o func (v *activeConnection) Dhcp6Config() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Dhcp6Config", } } // property Vpn b func (v *activeConnection) Vpn() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Vpn", } } // property Master o func (v *activeConnection) Master() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Master", } } type Dhcp4Config struct { dhcp4Config // interface org.freedesktop.NetworkManager.DHCP4Config proxy.Object } func NewDhcp4Config(conn *dbus.Conn, path dbus.ObjectPath) (*Dhcp4Config, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Dhcp4Config) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } type dhcp4Config struct{} func (v *dhcp4Config) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*dhcp4Config) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.DHCP4Config" } // signal PropertiesChanged func (v *dhcp4Config) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Options a{sv} func (v *dhcp4Config) Options() PropMapStringVariant { return PropMapStringVariant{ Impl: v, Name: "Options", } } type Dhcp6Config struct { dhcp6Config // interface org.freedesktop.NetworkManager.DHCP6Config proxy.Object } func NewDhcp6Config(conn *dbus.Conn, path dbus.ObjectPath) (*Dhcp6Config, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Dhcp6Config) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } type dhcp6Config struct{} func (v *dhcp6Config) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*dhcp6Config) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.DHCP6Config" } // signal PropertiesChanged func (v *dhcp6Config) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Options a{sv} func (v *dhcp6Config) Options() PropMapStringVariant { return PropMapStringVariant{ Impl: v, Name: "Options", } } type DnsManager struct { dnsManager // interface org.freedesktop.NetworkManager.DnsManager proxy.Object } func NewDnsManager(conn *dbus.Conn) *DnsManager { obj := new(DnsManager) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager/DnsManager") return obj } type dnsManager struct{} func (v *dnsManager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*dnsManager) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.DnsManager" } // property Mode s func (v *dnsManager) Mode() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Mode", } } // property RcManager s func (v *dnsManager) RcManager() proxy.PropString { return proxy.PropString{ Impl: v, Name: "RcManager", } } // property Configuration aa{sv} func (v *dnsManager) Configuration() PropMapSVSlice { return PropMapSVSlice{ Impl: v, Name: "Configuration", } } type IP4Config struct { ip4Config // interface org.freedesktop.NetworkManager.IP4Config proxy.Object } func NewIP4Config(conn *dbus.Conn, path dbus.ObjectPath) (*IP4Config, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(IP4Config) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } type ip4Config struct{} func (v *ip4Config) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*ip4Config) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.IP4Config" } // signal PropertiesChanged func (v *ip4Config) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Addresses aau func (v *ip4Config) Addresses() PropUint32SliceSlice { return PropUint32SliceSlice{ Impl: v, Name: "Addresses", } } // property AddressData aa{sv} func (v *ip4Config) AddressData() PropMapSVSlice { return PropMapSVSlice{ Impl: v, Name: "AddressData", } } // property Gateway s func (v *ip4Config) Gateway() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Gateway", } } // property Routes aau func (v *ip4Config) Routes() PropUint32SliceSlice { return PropUint32SliceSlice{ Impl: v, Name: "Routes", } } // property RouteData aa{sv} func (v *ip4Config) RouteData() PropMapSVSlice { return PropMapSVSlice{ Impl: v, Name: "RouteData", } } // property Nameservers au func (v *ip4Config) Nameservers() proxy.PropUint32Array { return proxy.PropUint32Array{ Impl: v, Name: "Nameservers", } } // property Domains as func (v *ip4Config) Domains() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Domains", } } // property Searches as func (v *ip4Config) Searches() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Searches", } } // property DnsOptions as func (v *ip4Config) DnsOptions() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "DnsOptions", } } // property DnsPriority i func (v *ip4Config) DnsPriority() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "DnsPriority", } } // property WinsServers au func (v *ip4Config) WinsServers() proxy.PropUint32Array { return proxy.PropUint32Array{ Impl: v, Name: "WinsServers", } } type IP6Config struct { ip6Config // interface org.freedesktop.NetworkManager.IP6Config proxy.Object } func NewIP6Config(conn *dbus.Conn, path dbus.ObjectPath) (*IP6Config, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(IP6Config) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } type ip6Config struct{} func (v *ip6Config) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*ip6Config) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.IP6Config" } // signal PropertiesChanged func (v *ip6Config) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Addresses a(ayuay) func (v *ip6Config) Addresses() PropIP6ConfigAddresses { return PropIP6ConfigAddresses{ Impl: v, } } type PropIP6ConfigAddresses struct { Impl proxy.Implementer } func (p PropIP6ConfigAddresses) Get(flags dbus.Flags) (value []IP6Address, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Addresses", &value) return } func (p PropIP6ConfigAddresses) ConnectChanged(cb func(hasValue bool, value []IP6Address)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []IP6Address err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Addresses", cb0) } // property AddressData aa{sv} func (v *ip6Config) AddressData() PropMapSVSlice { return PropMapSVSlice{ Impl: v, Name: "AddressData", } } // property Gateway s func (v *ip6Config) Gateway() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Gateway", } } // property Routes a(ayuayu) func (v *ip6Config) Routes() PropIP6ConfigRoutes { return PropIP6ConfigRoutes{ Impl: v, } } type PropIP6ConfigRoutes struct { Impl proxy.Implementer } func (p PropIP6ConfigRoutes) Get(flags dbus.Flags) (value []IP6Route, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Routes", &value) return } func (p PropIP6ConfigRoutes) ConnectChanged(cb func(hasValue bool, value []IP6Route)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []IP6Route err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Routes", cb0) } // property RouteData aa{sv} func (v *ip6Config) RouteData() PropMapSVSlice { return PropMapSVSlice{ Impl: v, Name: "RouteData", } } // property Nameservers aay func (v *ip6Config) Nameservers() PropIP6NameServers { return PropIP6NameServers{ Impl: v, } } type PropIP6NameServers struct { Impl proxy.Implementer } func (p PropIP6NameServers) Get(flags dbus.Flags) (value [][]byte, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Nameservers", &value) return } func (p PropIP6NameServers) ConnectChanged(cb func(hasValue bool, value [][]byte)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v [][]byte err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Nameservers", cb0) } // property Domains as func (v *ip6Config) Domains() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Domains", } } // property Searches as func (v *ip6Config) Searches() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Searches", } } // property DnsOptions as func (v *ip6Config) DnsOptions() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "DnsOptions", } } // property DnsPriority i func (v *ip6Config) DnsPriority() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "DnsPriority", } } type Manager struct { manager // interface org.freedesktop.NetworkManager proxy.Object } func NewManager(conn *dbus.Conn) *Manager { obj := new(Manager) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager") return obj } type manager struct{} func (v *manager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*manager) GetInterfaceName_() string { return "org.freedesktop.NetworkManager" } // method Reload func (v *manager) GoReload(flags dbus.Flags, ch chan *dbus.Call, flags0 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reload", flags, ch, flags0) } func (v *manager) Reload(flags dbus.Flags, flags0 uint32) error { return (<-v.GoReload(flags, make(chan *dbus.Call, 1), flags0).Done).Err } // method GetDevices func (v *manager) GoGetDevices(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDevices", flags, ch) } func (*manager) StoreGetDevices(call *dbus.Call) (devices []dbus.ObjectPath, err error) { err = call.Store(&devices) return } func (v *manager) GetDevices(flags dbus.Flags) (devices []dbus.ObjectPath, err error) { return v.StoreGetDevices( <-v.GoGetDevices(flags, make(chan *dbus.Call, 1)).Done) } // method GetAllDevices func (v *manager) GoGetAllDevices(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAllDevices", flags, ch) } func (*manager) StoreGetAllDevices(call *dbus.Call) (devices []dbus.ObjectPath, err error) { err = call.Store(&devices) return } func (v *manager) GetAllDevices(flags dbus.Flags) (devices []dbus.ObjectPath, err error) { return v.StoreGetAllDevices( <-v.GoGetAllDevices(flags, make(chan *dbus.Call, 1)).Done) } // method GetDeviceByIpIface func (v *manager) GoGetDeviceByIpIface(flags dbus.Flags, ch chan *dbus.Call, iface string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDeviceByIpIface", flags, ch, iface) } func (*manager) StoreGetDeviceByIpIface(call *dbus.Call) (device dbus.ObjectPath, err error) { err = call.Store(&device) return } func (v *manager) GetDeviceByIpIface(flags dbus.Flags, iface string) (device dbus.ObjectPath, err error) { return v.StoreGetDeviceByIpIface( <-v.GoGetDeviceByIpIface(flags, make(chan *dbus.Call, 1), iface).Done) } // method ActivateConnection func (v *manager) GoActivateConnection(flags dbus.Flags, ch chan *dbus.Call, connection dbus.ObjectPath, device dbus.ObjectPath, specific_object dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ActivateConnection", flags, ch, connection, device, specific_object) } func (*manager) StoreActivateConnection(call *dbus.Call) (active_connection dbus.ObjectPath, err error) { err = call.Store(&active_connection) return } func (v *manager) ActivateConnection(flags dbus.Flags, connection dbus.ObjectPath, device dbus.ObjectPath, specific_object dbus.ObjectPath) (active_connection dbus.ObjectPath, err error) { return v.StoreActivateConnection( <-v.GoActivateConnection(flags, make(chan *dbus.Call, 1), connection, device, specific_object).Done) } // method AddAndActivateConnection func (v *manager) GoAddAndActivateConnection(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant, device dbus.ObjectPath, specific_object dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddAndActivateConnection", flags, ch, connection, device, specific_object) } func (*manager) StoreAddAndActivateConnection(call *dbus.Call) (path dbus.ObjectPath, active_connection dbus.ObjectPath, err error) { err = call.Store(&path, &active_connection) return } func (v *manager) AddAndActivateConnection(flags dbus.Flags, connection map[string]map[string]dbus.Variant, device dbus.ObjectPath, specific_object dbus.ObjectPath) (path dbus.ObjectPath, active_connection dbus.ObjectPath, err error) { return v.StoreAddAndActivateConnection( <-v.GoAddAndActivateConnection(flags, make(chan *dbus.Call, 1), connection, device, specific_object).Done) } // method DeactivateConnection func (v *manager) GoDeactivateConnection(flags dbus.Flags, ch chan *dbus.Call, active_connection dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeactivateConnection", flags, ch, active_connection) } func (v *manager) DeactivateConnection(flags dbus.Flags, active_connection dbus.ObjectPath) error { return (<-v.GoDeactivateConnection(flags, make(chan *dbus.Call, 1), active_connection).Done).Err } // method Sleep func (v *manager) GoSleep(flags dbus.Flags, ch chan *dbus.Call, sleep bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Sleep", flags, ch, sleep) } func (v *manager) Sleep(flags dbus.Flags, sleep bool) error { return (<-v.GoSleep(flags, make(chan *dbus.Call, 1), sleep).Done).Err } // method Enable func (v *manager) GoEnable(flags dbus.Flags, ch chan *dbus.Call, enable bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Enable", flags, ch, enable) } func (v *manager) Enable(flags dbus.Flags, enable bool) error { return (<-v.GoEnable(flags, make(chan *dbus.Call, 1), enable).Done).Err } // method GetPermissions func (v *manager) GoGetPermissions(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetPermissions", flags, ch) } func (*manager) StoreGetPermissions(call *dbus.Call) (permissions map[string]string, err error) { err = call.Store(&permissions) return } func (v *manager) GetPermissions(flags dbus.Flags) (permissions map[string]string, err error) { return v.StoreGetPermissions( <-v.GoGetPermissions(flags, make(chan *dbus.Call, 1)).Done) } // method SetLogging func (v *manager) GoSetLogging(flags dbus.Flags, ch chan *dbus.Call, level string, domains string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLogging", flags, ch, level, domains) } func (v *manager) SetLogging(flags dbus.Flags, level string, domains string) error { return (<-v.GoSetLogging(flags, make(chan *dbus.Call, 1), level, domains).Done).Err } // method GetLogging func (v *manager) GoGetLogging(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetLogging", flags, ch) } func (*manager) StoreGetLogging(call *dbus.Call) (level string, domains string, err error) { err = call.Store(&level, &domains) return } func (v *manager) GetLogging(flags dbus.Flags) (level string, domains string, err error) { return v.StoreGetLogging( <-v.GoGetLogging(flags, make(chan *dbus.Call, 1)).Done) } // method CheckConnectivity func (v *manager) GoCheckConnectivity(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CheckConnectivity", flags, ch) } func (*manager) StoreCheckConnectivity(call *dbus.Call) (connectivity uint32, err error) { err = call.Store(&connectivity) return } func (v *manager) CheckConnectivity(flags dbus.Flags) (connectivity uint32, err error) { return v.StoreCheckConnectivity( <-v.GoCheckConnectivity(flags, make(chan *dbus.Call, 1)).Done) } // method state //func (v *manager) GoState(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { // return v.GetObject_().Go_(v.GetInterfaceName_()+".state", flags, ch) //} // //func (*manager) StoreState(call *dbus.Call) (state uint32, err error) { // err = call.Store(&state) // return //} // //func (v *manager) State(flags dbus.Flags) (state uint32, err error) { // return v.StoreState( // <-v.GoState(flags, make(chan *dbus.Call, 1)).Done) //} // method CheckpointCreate func (v *manager) GoCheckpointCreate(flags dbus.Flags, ch chan *dbus.Call, devices []dbus.ObjectPath, rollback_timeout uint32, flags0 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CheckpointCreate", flags, ch, devices, rollback_timeout, flags0) } func (*manager) StoreCheckpointCreate(call *dbus.Call) (checkpoint dbus.ObjectPath, err error) { err = call.Store(&checkpoint) return } func (v *manager) CheckpointCreate(flags dbus.Flags, devices []dbus.ObjectPath, rollback_timeout uint32, flags0 uint32) (checkpoint dbus.ObjectPath, err error) { return v.StoreCheckpointCreate( <-v.GoCheckpointCreate(flags, make(chan *dbus.Call, 1), devices, rollback_timeout, flags0).Done) } // method CheckpointDestroy func (v *manager) GoCheckpointDestroy(flags dbus.Flags, ch chan *dbus.Call, checkpoint dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CheckpointDestroy", flags, ch, checkpoint) } func (v *manager) CheckpointDestroy(flags dbus.Flags, checkpoint dbus.ObjectPath) error { return (<-v.GoCheckpointDestroy(flags, make(chan *dbus.Call, 1), checkpoint).Done).Err } // method CheckpointRollback func (v *manager) GoCheckpointRollback(flags dbus.Flags, ch chan *dbus.Call, checkpoint dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CheckpointRollback", flags, ch, checkpoint) } func (*manager) StoreCheckpointRollback(call *dbus.Call) (result map[string]uint32, err error) { err = call.Store(&result) return } func (v *manager) CheckpointRollback(flags dbus.Flags, checkpoint dbus.ObjectPath) (result map[string]uint32, err error) { return v.StoreCheckpointRollback( <-v.GoCheckpointRollback(flags, make(chan *dbus.Call, 1), checkpoint).Done) } // signal CheckPermissions func (v *manager) ConnectCheckPermissions(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "CheckPermissions", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".CheckPermissions", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal StateChanged func (v *manager) ConnectStateChanged(cb func(state uint32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "StateChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".StateChanged", } handlerFunc := func(sig *dbus.Signal) { var state uint32 err := dbus.Store(sig.Body, &state) if err == nil { cb(state) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal PropertiesChanged func (v *manager) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal DeviceAdded func (v *manager) ConnectDeviceAdded(cb func(device_path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "DeviceAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".DeviceAdded", } handlerFunc := func(sig *dbus.Signal) { var device_path dbus.ObjectPath err := dbus.Store(sig.Body, &device_path) if err == nil { cb(device_path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal DeviceRemoved func (v *manager) ConnectDeviceRemoved(cb func(device_path dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "DeviceRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".DeviceRemoved", } handlerFunc := func(sig *dbus.Signal) { var device_path dbus.ObjectPath err := dbus.Store(sig.Body, &device_path) if err == nil { cb(device_path) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Devices ao func (v *manager) Devices() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Devices", } } // property AllDevices ao func (v *manager) AllDevices() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "AllDevices", } } // property NetworkingEnabled b func (v *manager) NetworkingEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "NetworkingEnabled", } } // property WirelessEnabled b func (v *manager) WirelessEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "WirelessEnabled", } } // property WirelessHardwareEnabled b func (v *manager) WirelessHardwareEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "WirelessHardwareEnabled", } } // property WwanEnabled b func (v *manager) WwanEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "WwanEnabled", } } // property WwanHardwareEnabled b func (v *manager) WwanHardwareEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "WwanHardwareEnabled", } } // property WimaxEnabled b func (v *manager) WimaxEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "WimaxEnabled", } } // property WimaxHardwareEnabled b func (v *manager) WimaxHardwareEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "WimaxHardwareEnabled", } } // property ActiveConnections ao func (v *manager) ActiveConnections() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "ActiveConnections", } } // property PrimaryConnection o func (v *manager) PrimaryConnection() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "PrimaryConnection", } } // property PrimaryConnectionType s func (v *manager) PrimaryConnectionType() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PrimaryConnectionType", } } // property Metered u func (v *manager) Metered() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Metered", } } // property ActivatingConnection o func (v *manager) ActivatingConnection() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "ActivatingConnection", } } // property Startup b func (v *manager) Startup() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Startup", } } // property Version s func (v *manager) Version() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Version", } } // property Capabilities au func (v *manager) Capabilities() proxy.PropUint32Array { return proxy.PropUint32Array{ Impl: v, Name: "Capabilities", } } // property State u func (v *manager) State() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "State", } } // property Connectivity u func (v *manager) Connectivity() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Connectivity", } } // property GlobalDnsConfiguration a{sv} func (v *manager) GlobalDnsConfiguration() PropMapStringVariant { return PropMapStringVariant{ Impl: v, Name: "GlobalDnsConfiguration", } } type PPP struct { ppp // interface org.freedesktop.NetworkManager.PPP proxy.Object } func NewPPP(conn *dbus.Conn, path dbus.ObjectPath) (*PPP, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(PPP) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } type ppp struct{} func (v *ppp) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*ppp) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.PPP" } // method NeedSecrets func (v *ppp) GoNeedSecrets(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".NeedSecrets", flags, ch) } func (*ppp) StoreNeedSecrets(call *dbus.Call) (username string, password string, err error) { err = call.Store(&username, &password) return } func (v *ppp) NeedSecrets(flags dbus.Flags) (username string, password string, err error) { return v.StoreNeedSecrets( <-v.GoNeedSecrets(flags, make(chan *dbus.Call, 1)).Done) } // method SetIp4Config func (v *ppp) GoSetIp4Config(flags dbus.Flags, ch chan *dbus.Call, config map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetIp4Config", flags, ch, config) } func (v *ppp) SetIp4Config(flags dbus.Flags, config map[string]dbus.Variant) error { return (<-v.GoSetIp4Config(flags, make(chan *dbus.Call, 1), config).Done).Err } // method SetIp6Config func (v *ppp) GoSetIp6Config(flags dbus.Flags, ch chan *dbus.Call, config map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetIp6Config", flags, ch, config) } func (v *ppp) SetIp6Config(flags dbus.Flags, config map[string]dbus.Variant) error { return (<-v.GoSetIp6Config(flags, make(chan *dbus.Call, 1), config).Done).Err } // method SetState func (v *ppp) GoSetState(flags dbus.Flags, ch chan *dbus.Call, state uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetState", flags, ch, state) } func (v *ppp) SetState(flags dbus.Flags, state uint32) error { return (<-v.GoSetState(flags, make(chan *dbus.Call, 1), state).Done).Err } type SecretAgent struct { secretAgent // interface org.freedesktop.NetworkManager.SecretAgent proxy.Object } func NewSecretAgent(conn *dbus.Conn, path dbus.ObjectPath) (*SecretAgent, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(SecretAgent) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } type secretAgent struct{} func (v *secretAgent) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*secretAgent) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.SecretAgent" } // method GetSecrets func (v *secretAgent) GoGetSecrets(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant, connection_path dbus.ObjectPath, setting_name string, hints []string, flags0 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetSecrets", flags, ch, connection, connection_path, setting_name, hints, flags0) } func (*secretAgent) StoreGetSecrets(call *dbus.Call) (secrets map[string]map[string]dbus.Variant, err error) { err = call.Store(&secrets) return } func (v *secretAgent) GetSecrets(flags dbus.Flags, connection map[string]map[string]dbus.Variant, connection_path dbus.ObjectPath, setting_name string, hints []string, flags0 uint32) (secrets map[string]map[string]dbus.Variant, err error) { return v.StoreGetSecrets( <-v.GoGetSecrets(flags, make(chan *dbus.Call, 1), connection, connection_path, setting_name, hints, flags0).Done) } // method CancelGetSecrets func (v *secretAgent) GoCancelGetSecrets(flags dbus.Flags, ch chan *dbus.Call, connection_path dbus.ObjectPath, setting_name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CancelGetSecrets", flags, ch, connection_path, setting_name) } func (v *secretAgent) CancelGetSecrets(flags dbus.Flags, connection_path dbus.ObjectPath, setting_name string) error { return (<-v.GoCancelGetSecrets(flags, make(chan *dbus.Call, 1), connection_path, setting_name).Done).Err } // method SaveSecrets func (v *secretAgent) GoSaveSecrets(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant, connection_path dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SaveSecrets", flags, ch, connection, connection_path) } func (v *secretAgent) SaveSecrets(flags dbus.Flags, connection map[string]map[string]dbus.Variant, connection_path dbus.ObjectPath) error { return (<-v.GoSaveSecrets(flags, make(chan *dbus.Call, 1), connection, connection_path).Done).Err } // method DeleteSecrets func (v *secretAgent) GoDeleteSecrets(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant, connection_path dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DeleteSecrets", flags, ch, connection, connection_path) } func (v *secretAgent) DeleteSecrets(flags dbus.Flags, connection map[string]map[string]dbus.Variant, connection_path dbus.ObjectPath) error { return (<-v.GoDeleteSecrets(flags, make(chan *dbus.Call, 1), connection, connection_path).Done).Err } type ConnectionSettings struct { connectionSettings // interface org.freedesktop.NetworkManager.Settings.Connection proxy.Object } func NewConnectionSettings(conn *dbus.Conn, path dbus.ObjectPath) (*ConnectionSettings, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(ConnectionSettings) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } type connectionSettings struct{} func (v *connectionSettings) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*connectionSettings) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Settings.Connection" } // method Update func (v *connectionSettings) GoUpdate(flags dbus.Flags, ch chan *dbus.Call, properties map[string]map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Update", flags, ch, properties) } func (v *connectionSettings) Update(flags dbus.Flags, properties map[string]map[string]dbus.Variant) error { return (<-v.GoUpdate(flags, make(chan *dbus.Call, 1), properties).Done).Err } // method UpdateUnsaved func (v *connectionSettings) GoUpdateUnsaved(flags dbus.Flags, ch chan *dbus.Call, properties map[string]map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UpdateUnsaved", flags, ch, properties) } func (v *connectionSettings) UpdateUnsaved(flags dbus.Flags, properties map[string]map[string]dbus.Variant) error { return (<-v.GoUpdateUnsaved(flags, make(chan *dbus.Call, 1), properties).Done).Err } // method Delete func (v *connectionSettings) GoDelete(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Delete", flags, ch) } func (v *connectionSettings) Delete(flags dbus.Flags) error { return (<-v.GoDelete(flags, make(chan *dbus.Call, 1)).Done).Err } // method GetSettings func (v *connectionSettings) GoGetSettings(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetSettings", flags, ch) } func (*connectionSettings) StoreGetSettings(call *dbus.Call) (settings map[string]map[string]dbus.Variant, err error) { err = call.Store(&settings) return } func (v *connectionSettings) GetSettings(flags dbus.Flags) (settings map[string]map[string]dbus.Variant, err error) { return v.StoreGetSettings( <-v.GoGetSettings(flags, make(chan *dbus.Call, 1)).Done) } // method GetSecrets func (v *connectionSettings) GoGetSecrets(flags dbus.Flags, ch chan *dbus.Call, setting_name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetSecrets", flags, ch, setting_name) } func (*connectionSettings) StoreGetSecrets(call *dbus.Call) (secrets map[string]map[string]dbus.Variant, err error) { err = call.Store(&secrets) return } func (v *connectionSettings) GetSecrets(flags dbus.Flags, setting_name string) (secrets map[string]map[string]dbus.Variant, err error) { return v.StoreGetSecrets( <-v.GoGetSecrets(flags, make(chan *dbus.Call, 1), setting_name).Done) } // method ClearSecrets func (v *connectionSettings) GoClearSecrets(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ClearSecrets", flags, ch) } func (v *connectionSettings) ClearSecrets(flags dbus.Flags) error { return (<-v.GoClearSecrets(flags, make(chan *dbus.Call, 1)).Done).Err } // method Save func (v *connectionSettings) GoSave(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Save", flags, ch) } func (v *connectionSettings) Save(flags dbus.Flags) error { return (<-v.GoSave(flags, make(chan *dbus.Call, 1)).Done).Err } // signal Updated func (v *connectionSettings) ConnectUpdated(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Updated", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Updated", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Removed func (v *connectionSettings) ConnectRemoved(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Removed", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Removed", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal PropertiesChanged func (v *connectionSettings) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Unsaved b func (v *connectionSettings) Unsaved() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Unsaved", } } type Settings struct { settings // interface org.freedesktop.NetworkManager.Settings proxy.Object } func NewSettings(conn *dbus.Conn) *Settings { obj := new(Settings) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager/Settings") return obj } type settings struct{} func (v *settings) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*settings) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Settings" } // method ListConnections func (v *settings) GoListConnections(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListConnections", flags, ch) } func (*settings) StoreListConnections(call *dbus.Call) (connections []dbus.ObjectPath, err error) { err = call.Store(&connections) return } func (v *settings) ListConnections(flags dbus.Flags) (connections []dbus.ObjectPath, err error) { return v.StoreListConnections( <-v.GoListConnections(flags, make(chan *dbus.Call, 1)).Done) } // method GetConnectionByUuid func (v *settings) GoGetConnectionByUuid(flags dbus.Flags, ch chan *dbus.Call, uuid string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetConnectionByUuid", flags, ch, uuid) } func (*settings) StoreGetConnectionByUuid(call *dbus.Call) (connection dbus.ObjectPath, err error) { err = call.Store(&connection) return } func (v *settings) GetConnectionByUuid(flags dbus.Flags, uuid string) (connection dbus.ObjectPath, err error) { return v.StoreGetConnectionByUuid( <-v.GoGetConnectionByUuid(flags, make(chan *dbus.Call, 1), uuid).Done) } // method AddConnection func (v *settings) GoAddConnection(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddConnection", flags, ch, connection) } func (*settings) StoreAddConnection(call *dbus.Call) (path dbus.ObjectPath, err error) { err = call.Store(&path) return } func (v *settings) AddConnection(flags dbus.Flags, connection map[string]map[string]dbus.Variant) (path dbus.ObjectPath, err error) { return v.StoreAddConnection( <-v.GoAddConnection(flags, make(chan *dbus.Call, 1), connection).Done) } // method AddConnectionUnsaved func (v *settings) GoAddConnectionUnsaved(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddConnectionUnsaved", flags, ch, connection) } func (*settings) StoreAddConnectionUnsaved(call *dbus.Call) (path dbus.ObjectPath, err error) { err = call.Store(&path) return } func (v *settings) AddConnectionUnsaved(flags dbus.Flags, connection map[string]map[string]dbus.Variant) (path dbus.ObjectPath, err error) { return v.StoreAddConnectionUnsaved( <-v.GoAddConnectionUnsaved(flags, make(chan *dbus.Call, 1), connection).Done) } // method LoadConnections func (v *settings) GoLoadConnections(flags dbus.Flags, ch chan *dbus.Call, filenames []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LoadConnections", flags, ch, filenames) } func (*settings) StoreLoadConnections(call *dbus.Call) (status bool, failures []string, err error) { err = call.Store(&status, &failures) return } func (v *settings) LoadConnections(flags dbus.Flags, filenames []string) (status bool, failures []string, err error) { return v.StoreLoadConnections( <-v.GoLoadConnections(flags, make(chan *dbus.Call, 1), filenames).Done) } // method ReloadConnections func (v *settings) GoReloadConnections(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReloadConnections", flags, ch) } func (*settings) StoreReloadConnections(call *dbus.Call) (status bool, err error) { err = call.Store(&status) return } func (v *settings) ReloadConnections(flags dbus.Flags) (status bool, err error) { return v.StoreReloadConnections( <-v.GoReloadConnections(flags, make(chan *dbus.Call, 1)).Done) } // method SaveHostname func (v *settings) GoSaveHostname(flags dbus.Flags, ch chan *dbus.Call, hostname string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SaveHostname", flags, ch, hostname) } func (v *settings) SaveHostname(flags dbus.Flags, hostname string) error { return (<-v.GoSaveHostname(flags, make(chan *dbus.Call, 1), hostname).Done).Err } // signal PropertiesChanged func (v *settings) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal NewConnection func (v *settings) ConnectNewConnection(cb func(connection dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NewConnection", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NewConnection", } handlerFunc := func(sig *dbus.Signal) { var connection dbus.ObjectPath err := dbus.Store(sig.Body, &connection) if err == nil { cb(connection) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ConnectionRemoved func (v *settings) ConnectConnectionRemoved(cb func(connection dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ConnectionRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ConnectionRemoved", } handlerFunc := func(sig *dbus.Signal) { var connection dbus.ObjectPath err := dbus.Store(sig.Body, &connection) if err == nil { cb(connection) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Connections ao func (v *settings) Connections() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Connections", } } // property Hostname s func (v *settings) Hostname() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Hostname", } } // property CanModify b func (v *settings) CanModify() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanModify", } } type VpnConnection struct { vpnConnection // interface org.freedesktop.NetworkManager.VPN.Connection proxy.Object } func NewVpnConnection(conn *dbus.Conn, path dbus.ObjectPath) (*VpnConnection, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(VpnConnection) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } type vpnConnection struct{} func (v *vpnConnection) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*vpnConnection) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.VPN.Connection" } // signal PropertiesChanged func (v *vpnConnection) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal VpnStateChanged func (v *vpnConnection) ConnectVpnStateChanged(cb func(state uint32, reason uint32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "VpnStateChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".VpnStateChanged", } handlerFunc := func(sig *dbus.Signal) { var state uint32 var reason uint32 err := dbus.Store(sig.Body, &state, &reason) if err == nil { cb(state, reason) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property VpnState u func (v *vpnConnection) VpnState() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "VpnState", } } // property Banner s func (v *vpnConnection) Banner() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Banner", } } type VpnPlugin struct { vpnPlugin // interface org.freedesktop.NetworkManager.VPN.Plugin proxy.Object } func NewVpnPlugin(conn *dbus.Conn, path dbus.ObjectPath) (*VpnPlugin, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(VpnPlugin) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } type vpnPlugin struct{} func (v *vpnPlugin) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*vpnPlugin) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.VPN.Plugin" } // method Connect func (v *vpnPlugin) GoConnect(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Connect", flags, ch, connection) } func (v *vpnPlugin) Connect(flags dbus.Flags, connection map[string]map[string]dbus.Variant) error { return (<-v.GoConnect(flags, make(chan *dbus.Call, 1), connection).Done).Err } // method ConnectInteractive func (v *vpnPlugin) GoConnectInteractive(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant, details map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ConnectInteractive", flags, ch, connection, details) } func (v *vpnPlugin) ConnectInteractive(flags dbus.Flags, connection map[string]map[string]dbus.Variant, details map[string]dbus.Variant) error { return (<-v.GoConnectInteractive(flags, make(chan *dbus.Call, 1), connection, details).Done).Err } // method NeedSecrets func (v *vpnPlugin) GoNeedSecrets(flags dbus.Flags, ch chan *dbus.Call, settings map[string]map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".NeedSecrets", flags, ch, settings) } func (*vpnPlugin) StoreNeedSecrets(call *dbus.Call) (setting_name string, err error) { err = call.Store(&setting_name) return } func (v *vpnPlugin) NeedSecrets(flags dbus.Flags, settings map[string]map[string]dbus.Variant) (setting_name string, err error) { return v.StoreNeedSecrets( <-v.GoNeedSecrets(flags, make(chan *dbus.Call, 1), settings).Done) } // method Disconnect func (v *vpnPlugin) GoDisconnect(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Disconnect", flags, ch) } func (v *vpnPlugin) Disconnect(flags dbus.Flags) error { return (<-v.GoDisconnect(flags, make(chan *dbus.Call, 1)).Done).Err } // method SetConfig func (v *vpnPlugin) GoSetConfig(flags dbus.Flags, ch chan *dbus.Call, config map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetConfig", flags, ch, config) } func (v *vpnPlugin) SetConfig(flags dbus.Flags, config map[string]dbus.Variant) error { return (<-v.GoSetConfig(flags, make(chan *dbus.Call, 1), config).Done).Err } // method SetIp4Config func (v *vpnPlugin) GoSetIp4Config(flags dbus.Flags, ch chan *dbus.Call, config map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetIp4Config", flags, ch, config) } func (v *vpnPlugin) SetIp4Config(flags dbus.Flags, config map[string]dbus.Variant) error { return (<-v.GoSetIp4Config(flags, make(chan *dbus.Call, 1), config).Done).Err } // method SetIp6Config func (v *vpnPlugin) GoSetIp6Config(flags dbus.Flags, ch chan *dbus.Call, config map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetIp6Config", flags, ch, config) } func (v *vpnPlugin) SetIp6Config(flags dbus.Flags, config map[string]dbus.Variant) error { return (<-v.GoSetIp6Config(flags, make(chan *dbus.Call, 1), config).Done).Err } // method SetFailure func (v *vpnPlugin) GoSetFailure(flags dbus.Flags, ch chan *dbus.Call, reason string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetFailure", flags, ch, reason) } func (v *vpnPlugin) SetFailure(flags dbus.Flags, reason string) error { return (<-v.GoSetFailure(flags, make(chan *dbus.Call, 1), reason).Done).Err } // method NewSecrets func (v *vpnPlugin) GoNewSecrets(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".NewSecrets", flags, ch, connection) } func (v *vpnPlugin) NewSecrets(flags dbus.Flags, connection map[string]map[string]dbus.Variant) error { return (<-v.GoNewSecrets(flags, make(chan *dbus.Call, 1), connection).Done).Err } // signal StateChanged func (v *vpnPlugin) ConnectStateChanged(cb func(state uint32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "StateChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".StateChanged", } handlerFunc := func(sig *dbus.Signal) { var state uint32 err := dbus.Store(sig.Body, &state) if err == nil { cb(state) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal SecretsRequired func (v *vpnPlugin) ConnectSecretsRequired(cb func(message string, secrets []string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "SecretsRequired", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".SecretsRequired", } handlerFunc := func(sig *dbus.Signal) { var message string var secrets []string err := dbus.Store(sig.Body, &message, &secrets) if err == nil { cb(message, secrets) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Config func (v *vpnPlugin) ConnectConfig(cb func(config map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Config", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Config", } handlerFunc := func(sig *dbus.Signal) { var config map[string]dbus.Variant err := dbus.Store(sig.Body, &config) if err == nil { cb(config) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Ip4Config func (v *vpnPlugin) ConnectIp4Config(cb func(ip4config map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Ip4Config", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Ip4Config", } handlerFunc := func(sig *dbus.Signal) { var ip4config map[string]dbus.Variant err := dbus.Store(sig.Body, &ip4config) if err == nil { cb(ip4config) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Ip6Config func (v *vpnPlugin) ConnectIp6Config(cb func(ip6config map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Ip6Config", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Ip6Config", } handlerFunc := func(sig *dbus.Signal) { var ip6config map[string]dbus.Variant err := dbus.Store(sig.Body, &ip6config) if err == nil { cb(ip6config) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal LoginBanner func (v *vpnPlugin) ConnectLoginBanner(cb func(banner string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "LoginBanner", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".LoginBanner", } handlerFunc := func(sig *dbus.Signal) { var banner string err := dbus.Store(sig.Body, &banner) if err == nil { cb(banner) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Failure func (v *vpnPlugin) ConnectFailure(cb func(reason uint32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Failure", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Failure", } handlerFunc := func(sig *dbus.Signal) { var reason uint32 err := dbus.Store(sig.Body, &reason) if err == nil { cb(reason) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property State u func (v *vpnPlugin) State() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "State", } } type Device struct { device // interface org.freedesktop.NetworkManager.Device deviceAdsl // interface org.freedesktop.NetworkManager.Device.Adsl deviceBluetooth // interface org.freedesktop.NetworkManager.Device.Bluetooth deviceBond // interface org.freedesktop.NetworkManager.Device.Bond deviceBridge // interface org.freedesktop.NetworkManager.Device.Bridge deviceGeneric // interface org.freedesktop.NetworkManager.Device.Generic deviceInfiniband // interface org.freedesktop.NetworkManager.Device.Infiniband deviceIPTunnel // interface org.freedesktop.NetworkManager.Device.IPTunnel deviceMacsec // interface org.freedesktop.NetworkManager.Device.Macsec deviceMacvlan // interface org.freedesktop.NetworkManager.Device.Macvlan deviceModem // interface org.freedesktop.NetworkManager.Device.Modem deviceOlpcMesh // interface org.freedesktop.NetworkManager.Device.OlpcMesh deviceStatistics // interface org.freedesktop.NetworkManager.Device.Statistics deviceTeam // interface org.freedesktop.NetworkManager.Device.Team deviceTun // interface org.freedesktop.NetworkManager.Device.Tun deviceVeth // interface org.freedesktop.NetworkManager.Device.Veth deviceVlan // interface org.freedesktop.NetworkManager.Device.Vlan deviceVxlan // interface org.freedesktop.NetworkManager.Device.Vxlan deviceWiMax // interface org.freedesktop.NetworkManager.Device.WiMax deviceWired // interface org.freedesktop.NetworkManager.Device.Wired deviceWireless // interface org.freedesktop.NetworkManager.Device.Wireless proxy.Object } func NewDevice(conn *dbus.Conn, path dbus.ObjectPath) (*Device, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Device) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } func (obj *Device) Device() *device { return &obj.device } type device struct{} func (v *device) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*device) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device" } // method Reapply func (v *device) GoReapply(flags dbus.Flags, ch chan *dbus.Call, connection map[string]map[string]dbus.Variant, version_id uint64, flags0 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reapply", flags, ch, connection, version_id, flags0) } func (v *device) Reapply(flags dbus.Flags, connection map[string]map[string]dbus.Variant, version_id uint64, flags0 uint32) error { return (<-v.GoReapply(flags, make(chan *dbus.Call, 1), connection, version_id, flags0).Done).Err } // method GetAppliedConnection func (v *device) GoGetAppliedConnection(flags dbus.Flags, ch chan *dbus.Call, flags0 uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAppliedConnection", flags, ch, flags0) } func (*device) StoreGetAppliedConnection(call *dbus.Call) (connection map[string]map[string]dbus.Variant, version_id uint64, err error) { err = call.Store(&connection, &version_id) return } func (v *device) GetAppliedConnection(flags dbus.Flags, flags0 uint32) (connection map[string]map[string]dbus.Variant, version_id uint64, err error) { return v.StoreGetAppliedConnection( <-v.GoGetAppliedConnection(flags, make(chan *dbus.Call, 1), flags0).Done) } // method Disconnect func (v *device) GoDisconnect(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Disconnect", flags, ch) } func (v *device) Disconnect(flags dbus.Flags) error { return (<-v.GoDisconnect(flags, make(chan *dbus.Call, 1)).Done).Err } // method Delete func (v *device) GoDelete(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Delete", flags, ch) } func (v *device) Delete(flags dbus.Flags) error { return (<-v.GoDelete(flags, make(chan *dbus.Call, 1)).Done).Err } // signal StateChanged func (v *device) ConnectStateChanged(cb func(new_state uint32, old_state uint32, reason uint32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "StateChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".StateChanged", } handlerFunc := func(sig *dbus.Signal) { var new_state uint32 var old_state uint32 var reason uint32 err := dbus.Store(sig.Body, &new_state, &old_state, &reason) if err == nil { cb(new_state, old_state, reason) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Udi s func (v *device) Udi() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Udi", } } // property Interface s func (v *device) Interface() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Interface", } } // property IpInterface s func (v *device) IpInterface() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IpInterface", } } // property Driver s func (v *device) Driver() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Driver", } } // property DriverVersion s func (v *device) DriverVersion() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DriverVersion", } } // property FirmwareVersion s func (v *device) FirmwareVersion() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FirmwareVersion", } } // property Capabilities u func (v *device) Capabilities() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Capabilities", } } // property Ip4Address u func (v *device) Ip4Address() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Ip4Address", } } // property State u func (v *device) State() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "State", } } // property StateReason (uu) func (v *device) StateReason() PropDeviceStateReason { return PropDeviceStateReason{ Impl: v, } } type PropDeviceStateReason struct { Impl proxy.Implementer } func (p PropDeviceStateReason) Get(flags dbus.Flags) (value DeviceStateReason, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "StateReason", &value) return } func (p PropDeviceStateReason) ConnectChanged(cb func(hasValue bool, value DeviceStateReason)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v DeviceStateReason err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, DeviceStateReason{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "StateReason", cb0) } // property ActiveConnection o func (v *device) ActiveConnection() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "ActiveConnection", } } // property Ip4Config o func (v *device) Ip4Config() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Ip4Config", } } // property Dhcp4Config o func (v *device) Dhcp4Config() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Dhcp4Config", } } // property Ip6Config o func (v *device) Ip6Config() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Ip6Config", } } // property Dhcp6Config o func (v *device) Dhcp6Config() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Dhcp6Config", } } // property Managed b func (v *device) Managed() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Managed", } } // property Autoconnect b func (v *device) Autoconnect() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Autoconnect", } } // property FirmwareMissing b func (v *device) FirmwareMissing() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "FirmwareMissing", } } // property NmPluginMissing b func (v *device) NmPluginMissing() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "NmPluginMissing", } } // property DeviceType u func (v *device) DeviceType() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "DeviceType", } } // property AvailableConnections ao func (v *device) AvailableConnections() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "AvailableConnections", } } // property PhysicalPortId s func (v *device) PhysicalPortId() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PhysicalPortId", } } // property Mtu u func (v *device) Mtu() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Mtu", } } // property Metered u func (v *device) Metered() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Metered", } } // property LldpNeighbors aa{sv} func (v *device) LldpNeighbors() PropMapSVSlice { return PropMapSVSlice{ Impl: v, Name: "LldpNeighbors", } } // property Real b func (v *device) Real() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Real", } } func (obj *Device) Adsl() *deviceAdsl { return &obj.deviceAdsl } type deviceAdsl struct{} func (v *deviceAdsl) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceAdsl) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Adsl" } // signal PropertiesChanged func (v *deviceAdsl) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Carrier b func (v *deviceAdsl) Carrier() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Carrier", } } func (obj *Device) Bluetooth() *deviceBluetooth { return &obj.deviceBluetooth } type deviceBluetooth struct{} func (v *deviceBluetooth) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceBluetooth) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Bluetooth" } // signal PropertiesChanged func (v *deviceBluetooth) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property HwAddress s func (v *deviceBluetooth) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } // property Name s func (v *deviceBluetooth) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property BtCapabilities u func (v *deviceBluetooth) BtCapabilities() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "BtCapabilities", } } func (obj *Device) Bond() *deviceBond { return &obj.deviceBond } type deviceBond struct{} func (v *deviceBond) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceBond) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Bond" } // signal PropertiesChanged func (v *deviceBond) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property HwAddress s func (v *deviceBond) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } // property Carrier b func (v *deviceBond) Carrier() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Carrier", } } // property Slaves ao func (v *deviceBond) Slaves() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Slaves", } } func (obj *Device) Bridge() *deviceBridge { return &obj.deviceBridge } type deviceBridge struct{} func (v *deviceBridge) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceBridge) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Bridge" } // signal PropertiesChanged func (v *deviceBridge) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property HwAddress s func (v *deviceBridge) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } // property Carrier b func (v *deviceBridge) Carrier() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Carrier", } } // property Slaves ao func (v *deviceBridge) Slaves() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Slaves", } } func (obj *Device) Generic() *deviceGeneric { return &obj.deviceGeneric } type deviceGeneric struct{} func (v *deviceGeneric) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceGeneric) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Generic" } // signal PropertiesChanged func (v *deviceGeneric) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property HwAddress s func (v *deviceGeneric) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } // property TypeDescription s func (v *deviceGeneric) TypeDescription() proxy.PropString { return proxy.PropString{ Impl: v, Name: "TypeDescription", } } func (obj *Device) Infiniband() *deviceInfiniband { return &obj.deviceInfiniband } type deviceInfiniband struct{} func (v *deviceInfiniband) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceInfiniband) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Infiniband" } // signal PropertiesChanged func (v *deviceInfiniband) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property HwAddress s func (v *deviceInfiniband) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } // property Carrier b func (v *deviceInfiniband) Carrier() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Carrier", } } func (obj *Device) IPTunnel() *deviceIPTunnel { return &obj.deviceIPTunnel } type deviceIPTunnel struct{} func (v *deviceIPTunnel) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceIPTunnel) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.IPTunnel" } // signal PropertiesChanged func (v *deviceIPTunnel) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Mode u func (v *deviceIPTunnel) Mode() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Mode", } } // property Parent o func (v *deviceIPTunnel) Parent() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Parent", } } // property Local s func (v *deviceIPTunnel) Local() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Local", } } // property Remote s func (v *deviceIPTunnel) Remote() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Remote", } } // property Ttl y func (v *deviceIPTunnel) Ttl() proxy.PropByte { return proxy.PropByte{ Impl: v, Name: "Ttl", } } // property Tos y func (v *deviceIPTunnel) Tos() proxy.PropByte { return proxy.PropByte{ Impl: v, Name: "Tos", } } // property PathMtuDiscovery b func (v *deviceIPTunnel) PathMtuDiscovery() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PathMtuDiscovery", } } // property InputKey s func (v *deviceIPTunnel) InputKey() proxy.PropString { return proxy.PropString{ Impl: v, Name: "InputKey", } } // property OutputKey s func (v *deviceIPTunnel) OutputKey() proxy.PropString { return proxy.PropString{ Impl: v, Name: "OutputKey", } } // property EncapsulationLimit y func (v *deviceIPTunnel) EncapsulationLimit() proxy.PropByte { return proxy.PropByte{ Impl: v, Name: "EncapsulationLimit", } } // property FlowLabel u func (v *deviceIPTunnel) FlowLabel() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "FlowLabel", } } func (obj *Device) Macsec() *deviceMacsec { return &obj.deviceMacsec } type deviceMacsec struct{} func (v *deviceMacsec) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceMacsec) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Macsec" } // signal PropertiesChanged func (v *deviceMacsec) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Parent o func (v *deviceMacsec) Parent() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Parent", } } // property Sci t func (v *deviceMacsec) Sci() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Sci", } } // property IcvLength y func (v *deviceMacsec) IcvLength() proxy.PropByte { return proxy.PropByte{ Impl: v, Name: "IcvLength", } } // property CipherSuite t func (v *deviceMacsec) CipherSuite() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "CipherSuite", } } // property Window u func (v *deviceMacsec) Window() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Window", } } // property EncodingSa y func (v *deviceMacsec) EncodingSa() proxy.PropByte { return proxy.PropByte{ Impl: v, Name: "EncodingSa", } } // property Validation s func (v *deviceMacsec) Validation() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Validation", } } // property Encrypt b func (v *deviceMacsec) Encrypt() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Encrypt", } } // property Protect b func (v *deviceMacsec) Protect() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Protect", } } // property IncludeSci b func (v *deviceMacsec) IncludeSci() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IncludeSci", } } // property Es b func (v *deviceMacsec) Es() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Es", } } // property Scb b func (v *deviceMacsec) Scb() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Scb", } } // property ReplayProtect b func (v *deviceMacsec) ReplayProtect() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ReplayProtect", } } func (obj *Device) Macvlan() *deviceMacvlan { return &obj.deviceMacvlan } type deviceMacvlan struct{} func (v *deviceMacvlan) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceMacvlan) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Macvlan" } // signal PropertiesChanged func (v *deviceMacvlan) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Parent o func (v *deviceMacvlan) Parent() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Parent", } } // property Mode s func (v *deviceMacvlan) Mode() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Mode", } } // property NoPromisc b func (v *deviceMacvlan) NoPromisc() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "NoPromisc", } } // property Tap b func (v *deviceMacvlan) Tap() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Tap", } } func (obj *Device) Modem() *deviceModem { return &obj.deviceModem } type deviceModem struct{} func (v *deviceModem) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceModem) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Modem" } // signal PropertiesChanged func (v *deviceModem) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property ModemCapabilities u func (v *deviceModem) ModemCapabilities() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "ModemCapabilities", } } // property CurrentCapabilities u func (v *deviceModem) CurrentCapabilities() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "CurrentCapabilities", } } func (obj *Device) OlpcMesh() *deviceOlpcMesh { return &obj.deviceOlpcMesh } type deviceOlpcMesh struct{} func (v *deviceOlpcMesh) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceOlpcMesh) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.OlpcMesh" } // signal PropertiesChanged func (v *deviceOlpcMesh) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property HwAddress s func (v *deviceOlpcMesh) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } // property Companion o func (v *deviceOlpcMesh) Companion() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Companion", } } // property ActiveChannel u func (v *deviceOlpcMesh) ActiveChannel() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "ActiveChannel", } } func (obj *Device) Statistics() *deviceStatistics { return &obj.deviceStatistics } type deviceStatistics struct{} func (v *deviceStatistics) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceStatistics) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Statistics" } // signal PropertiesChanged func (v *deviceStatistics) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property RefreshRateMs u func (v *deviceStatistics) RefreshRateMs() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "RefreshRateMs", } } // property TxBytes t func (v *deviceStatistics) TxBytes() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TxBytes", } } // property RxBytes t func (v *deviceStatistics) RxBytes() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "RxBytes", } } func (obj *Device) Team() *deviceTeam { return &obj.deviceTeam } type deviceTeam struct{} func (v *deviceTeam) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceTeam) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Team" } // signal PropertiesChanged func (v *deviceTeam) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property HwAddress s func (v *deviceTeam) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } // property Carrier b func (v *deviceTeam) Carrier() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Carrier", } } // property Slaves ao func (v *deviceTeam) Slaves() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Slaves", } } // property Config s func (v *deviceTeam) Config() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Config", } } func (obj *Device) Tun() *deviceTun { return &obj.deviceTun } type deviceTun struct{} func (v *deviceTun) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceTun) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Tun" } // signal PropertiesChanged func (v *deviceTun) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Owner x func (v *deviceTun) Owner() proxy.PropInt64 { return proxy.PropInt64{ Impl: v, Name: "Owner", } } // property Group x func (v *deviceTun) Group() proxy.PropInt64 { return proxy.PropInt64{ Impl: v, Name: "Group", } } // property Mode s func (v *deviceTun) Mode() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Mode", } } // property NoPi b func (v *deviceTun) NoPi() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "NoPi", } } // property VnetHdr b func (v *deviceTun) VnetHdr() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "VnetHdr", } } // property MultiQueue b func (v *deviceTun) MultiQueue() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "MultiQueue", } } // property HwAddress s func (v *deviceTun) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } func (obj *Device) Veth() *deviceVeth { return &obj.deviceVeth } type deviceVeth struct{} func (v *deviceVeth) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceVeth) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Veth" } // signal PropertiesChanged func (v *deviceVeth) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Peer o func (v *deviceVeth) Peer() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Peer", } } func (obj *Device) Vlan() *deviceVlan { return &obj.deviceVlan } type deviceVlan struct{} func (v *deviceVlan) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceVlan) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Vlan" } // signal PropertiesChanged func (v *deviceVlan) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property HwAddress s func (v *deviceVlan) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } // property Carrier b func (v *deviceVlan) Carrier() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Carrier", } } // property Parent o func (v *deviceVlan) Parent() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Parent", } } // property VlanId u func (v *deviceVlan) VlanId() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "VlanId", } } func (obj *Device) Vxlan() *deviceVxlan { return &obj.deviceVxlan } type deviceVxlan struct{} func (v *deviceVxlan) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceVxlan) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Vxlan" } // signal PropertiesChanged func (v *deviceVxlan) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Parent o func (v *deviceVxlan) Parent() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Parent", } } // property HwAddress s func (v *deviceVxlan) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } // property Id u func (v *deviceVxlan) Id() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Id", } } // property Group s func (v *deviceVxlan) Group() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Group", } } // property Local s func (v *deviceVxlan) Local() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Local", } } // property Tos y func (v *deviceVxlan) Tos() proxy.PropByte { return proxy.PropByte{ Impl: v, Name: "Tos", } } // property Ttl y func (v *deviceVxlan) Ttl() proxy.PropByte { return proxy.PropByte{ Impl: v, Name: "Ttl", } } // property Learning b func (v *deviceVxlan) Learning() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Learning", } } // property Ageing u func (v *deviceVxlan) Ageing() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Ageing", } } // property Limit u func (v *deviceVxlan) Limit() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Limit", } } // property DstPort q func (v *deviceVxlan) DstPort() proxy.PropUint16 { return proxy.PropUint16{ Impl: v, Name: "DstPort", } } // property SrcPortMin q func (v *deviceVxlan) SrcPortMin() proxy.PropUint16 { return proxy.PropUint16{ Impl: v, Name: "SrcPortMin", } } // property SrcPortMax q func (v *deviceVxlan) SrcPortMax() proxy.PropUint16 { return proxy.PropUint16{ Impl: v, Name: "SrcPortMax", } } // property Proxy b func (v *deviceVxlan) Proxy() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Proxy", } } // property Rsc b func (v *deviceVxlan) Rsc() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Rsc", } } // property L2miss b func (v *deviceVxlan) L2miss() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "L2miss", } } // property L3miss b func (v *deviceVxlan) L3miss() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "L3miss", } } func (obj *Device) WiMax() *deviceWiMax { return &obj.deviceWiMax } type deviceWiMax struct{} func (v *deviceWiMax) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceWiMax) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.WiMax" } // method GetNspList func (v *deviceWiMax) GoGetNspList(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetNspList", flags, ch) } func (*deviceWiMax) StoreGetNspList(call *dbus.Call) (nsps []dbus.ObjectPath, err error) { err = call.Store(&nsps) return } func (v *deviceWiMax) GetNspList(flags dbus.Flags) (nsps []dbus.ObjectPath, err error) { return v.StoreGetNspList( <-v.GoGetNspList(flags, make(chan *dbus.Call, 1)).Done) } // signal PropertiesChanged func (v *deviceWiMax) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal NspAdded func (v *deviceWiMax) ConnectNspAdded(cb func(nsp dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NspAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NspAdded", } handlerFunc := func(sig *dbus.Signal) { var nsp dbus.ObjectPath err := dbus.Store(sig.Body, &nsp) if err == nil { cb(nsp) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal NspRemoved func (v *deviceWiMax) ConnectNspRemoved(cb func(nsp dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NspRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NspRemoved", } handlerFunc := func(sig *dbus.Signal) { var nsp dbus.ObjectPath err := dbus.Store(sig.Body, &nsp) if err == nil { cb(nsp) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Nsps ao func (v *deviceWiMax) Nsps() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Nsps", } } // property HwAddress s func (v *deviceWiMax) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } // property CenterFrequency u func (v *deviceWiMax) CenterFrequency() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "CenterFrequency", } } // property Rssi i func (v *deviceWiMax) Rssi() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "Rssi", } } // property Cinr i func (v *deviceWiMax) Cinr() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "Cinr", } } // property TxPower i func (v *deviceWiMax) TxPower() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "TxPower", } } // property Bsid s func (v *deviceWiMax) Bsid() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Bsid", } } // property ActiveNsp o func (v *deviceWiMax) ActiveNsp() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "ActiveNsp", } } func (obj *Device) Wired() *deviceWired { return &obj.deviceWired } type deviceWired struct{} func (v *deviceWired) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceWired) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Wired" } // signal PropertiesChanged func (v *deviceWired) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property HwAddress s func (v *deviceWired) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } // property PermHwAddress s func (v *deviceWired) PermHwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PermHwAddress", } } // property Speed u func (v *deviceWired) Speed() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Speed", } } // property S390Subchannels as func (v *deviceWired) S390Subchannels() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "S390Subchannels", } } // property Carrier b func (v *deviceWired) Carrier() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Carrier", } } func (obj *Device) Wireless() *deviceWireless { return &obj.deviceWireless } type deviceWireless struct{} func (v *deviceWireless) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*deviceWireless) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.Device.Wireless" } // method GetAccessPoints func (v *deviceWireless) GoGetAccessPoints(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAccessPoints", flags, ch) } func (*deviceWireless) StoreGetAccessPoints(call *dbus.Call) (access_points []dbus.ObjectPath, err error) { err = call.Store(&access_points) return } func (v *deviceWireless) GetAccessPoints(flags dbus.Flags) (access_points []dbus.ObjectPath, err error) { return v.StoreGetAccessPoints( <-v.GoGetAccessPoints(flags, make(chan *dbus.Call, 1)).Done) } // method GetAllAccessPoints func (v *deviceWireless) GoGetAllAccessPoints(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetAllAccessPoints", flags, ch) } func (*deviceWireless) StoreGetAllAccessPoints(call *dbus.Call) (access_points []dbus.ObjectPath, err error) { err = call.Store(&access_points) return } func (v *deviceWireless) GetAllAccessPoints(flags dbus.Flags) (access_points []dbus.ObjectPath, err error) { return v.StoreGetAllAccessPoints( <-v.GoGetAllAccessPoints(flags, make(chan *dbus.Call, 1)).Done) } // method RequestScan func (v *deviceWireless) GoRequestScan(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RequestScan", flags, ch, options) } func (v *deviceWireless) RequestScan(flags dbus.Flags, options map[string]dbus.Variant) error { return (<-v.GoRequestScan(flags, make(chan *dbus.Call, 1), options).Done).Err } // signal PropertiesChanged func (v *deviceWireless) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal AccessPointAdded func (v *deviceWireless) ConnectAccessPointAdded(cb func(access_point dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "AccessPointAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".AccessPointAdded", } handlerFunc := func(sig *dbus.Signal) { var access_point dbus.ObjectPath err := dbus.Store(sig.Body, &access_point) if err == nil { cb(access_point) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal AccessPointRemoved func (v *deviceWireless) ConnectAccessPointRemoved(cb func(access_point dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "AccessPointRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".AccessPointRemoved", } handlerFunc := func(sig *dbus.Signal) { var access_point dbus.ObjectPath err := dbus.Store(sig.Body, &access_point) if err == nil { cb(access_point) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property HwAddress s func (v *deviceWireless) HwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HwAddress", } } // property PermHwAddress s func (v *deviceWireless) PermHwAddress() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PermHwAddress", } } // property Mode u func (v *deviceWireless) Mode() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Mode", } } // property Bitrate u func (v *deviceWireless) Bitrate() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Bitrate", } } // property AccessPoints ao func (v *deviceWireless) AccessPoints() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "AccessPoints", } } // property ActiveAccessPoint o func (v *deviceWireless) ActiveAccessPoint() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "ActiveAccessPoint", } } // property WirelessCapabilities u func (v *deviceWireless) WirelessCapabilities() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "WirelessCapabilities", } } type WiMaxNsp struct { wiMaxNsp // interface org.freedesktop.NetworkManager.WiMax.Nsp proxy.Object } func NewWiMaxNsp(conn *dbus.Conn, path dbus.ObjectPath) (*WiMaxNsp, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(WiMaxNsp) obj.Object.Init_(conn, "org.freedesktop.NetworkManager", path) return obj, nil } type wiMaxNsp struct{} func (v *wiMaxNsp) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*wiMaxNsp) GetInterfaceName_() string { return "org.freedesktop.NetworkManager.WiMax.Nsp" } // signal PropertiesChanged func (v *wiMaxNsp) ConnectPropertiesChanged(cb func(properties map[string]dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "PropertiesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".PropertiesChanged", } handlerFunc := func(sig *dbus.Signal) { var properties map[string]dbus.Variant err := dbus.Store(sig.Body, &properties) if err == nil { cb(properties) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Name s func (v *wiMaxNsp) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property SignalQuality u func (v *wiMaxNsp) SignalQuality() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "SignalQuality", } } // property NetworkType u func (v *wiMaxNsp) NetworkType() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "NetworkType", } } type PropMapStringVariant struct { Impl proxy.Implementer Name string } func (p PropMapStringVariant) Get(flags dbus.Flags) (value map[string]dbus.Variant, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropMapStringVariant) Set(flags dbus.Flags, value map[string]dbus.Variant) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropMapStringVariant) ConnectChanged(cb func(hasValue bool, value map[string]dbus.Variant)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[string]dbus.Variant err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } type PropMapSVSlice struct { Impl proxy.Implementer Name string } func (p PropMapSVSlice) Get(flags dbus.Flags) (value []map[string]dbus.Variant, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropMapSVSlice) Set(flags dbus.Flags, value []map[string]dbus.Variant) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropMapSVSlice) ConnectChanged(cb func(hasValue bool, value []map[string]dbus.Variant)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []map[string]dbus.Variant err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } type PropUint32SliceSlice struct { Impl proxy.Implementer Name string } func (p PropUint32SliceSlice) Get(flags dbus.Flags) (value [][]uint32, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropUint32SliceSlice) Set(flags dbus.Flags, value [][]uint32) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropUint32SliceSlice) ConnectChanged(cb func(hasValue bool, value [][]uint32)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v [][]uint32 err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } go-dbus-factory-1.9.6/org.freedesktop.networkmanager/config.json000066400000000000000000000221751403054572700250360ustar00rootroot00000000000000{ "Service": "org.freedesktop.NetworkManager", "Objects": [ { "Type": "ObjectManager", "XMLFile": "-", "Path": "/org/freedesktop", "Interfaces": [ { "Name": "org.freedesktop.DBus.ObjectManager" } ] }, { "Type": "AccessPoint", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.AccessPoint", "Type": "accessPoint", "Accessor": "AccessPoint" } ] }, { "Type": "AgentManager", "Path": "/org/freedesktop/NetworkManager/AgentManager", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.AgentManager", "Type": "agentManager" } ] }, { "Type": "Checkpoint", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.Checkpoint", "Type": "checkpoint" } ] }, { "Type": "ActiveConnection", "XMLFile": "Connection.Active", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.Connection.Active", "Type": "activeConnection" } ] }, { "Type": "Dhcp4Config", "XMLFile": "DHCP4Config", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.DHCP4Config", "Type": "dhcp4Config", "Fixes": { "p/Options": { "RefType": "PropMapStringVariant" } } } ] }, { "Type": "Dhcp6Config", "XMLFile": "DHCP6Config", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.DHCP6Config", "Type": "dhcp6Config", "Fixes": { "p/Options": { "RefType": "PropMapStringVariant" } } } ] }, { "Type": "DnsManager", "Path": "/org/freedesktop/NetworkManager/DnsManager", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.DnsManager", "Type": "dnsManager", "Fixes": { "p/Configuration": { "RefType": "PropMapSVSlice" } } } ] }, { "Type": "IP4Config", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.IP4Config", "Type": "ip4Config", "Fixes": { "p/Addresses": { "RefType": "PropUint32SliceSlice" }, "p/Routes": { "RefType": "PropUint32SliceSlice" }, "p/AddressData": { "RefType": "PropMapSVSlice" }, "p/RouteData": { "RefType": "PropMapSVSlice" } } } ] }, { "Type": "IP6Config", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.IP6Config", "Type": "ip6Config", "Fixes": { "p/AddressData": { "RefType": "PropMapSVSlice" }, "p/RouteData": { "RefType": "PropMapSVSlice" }, "p/Addresses": { "Type": "PropIP6ConfigAddresses", "ValueType": "[]IP6Address" }, "p/Routes": { "Type": "PropIP6ConfigRoutes", "ValueType": "[]IP6Route" }, "p/Nameservers": { "Type": "PropIP6NameServers", "ValueType": "[][]byte" } } } ] }, { "Type": "Manager", "XMLFile": "NetworkManager", "Path": "/org/freedesktop/NetworkManager", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager", "Type": "manager", "Fixes": { "p/GlobalDnsConfiguration": { "RefType": "PropMapStringVariant" } } } ] }, { "Type": "PPP", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.PPP", "Type": "ppp" } ] }, { "Type": "SecretAgent", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.SecretAgent", "Type": "secretAgent" } ] }, { "Type": "ConnectionSettings", "XMLFile": "Settings.Connection", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.Settings.Connection", "Type": "connectionSettings" } ] }, { "Type": "Settings", "Path": "/org/freedesktop/NetworkManager/Settings", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.Settings", "Type": "settings" } ] }, { "Type": "VpnConnection", "XMLFile": "VPN.Connection", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.VPN.Connection", "Type": "vpnConnection" } ] }, { "Type": "VpnPlugin", "XMLFile": "VPN.Plugin", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.VPN.Plugin", "Type": "vpnPlugin" } ] }, { "Type": "Device", "XmlFiles": ["Device*"], "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.Device", "Accessor": "Device", "Type": "device", "Fixes": { "p/StateReason": { "Type": "PropDeviceStateReason", "ValueType": "DeviceStateReason", "EmptyValue": "$T{}" }, "p/LldpNeighbors": { "RefType": "PropMapSVSlice" } } }, { "Name": "org.freedesktop.NetworkManager.Device.Adsl", "Accessor": "Adsl", "Type": "deviceAdsl" }, { "Name": "org.freedesktop.NetworkManager.Device.Bluetooth", "Accessor": "Bluetooth", "Type": "deviceBluetooth" }, { "Name": "org.freedesktop.NetworkManager.Device.Bond", "Accessor": "Bond", "Type": "deviceBond" }, { "Name": "org.freedesktop.NetworkManager.Device.Bridge", "Accessor": "Bridge", "Type": "deviceBridge" }, { "Name": "org.freedesktop.NetworkManager.Device.Generic", "Accessor": "Generic", "Type": "deviceGeneric" }, { "Name": "org.freedesktop.NetworkManager.Device.Infiniband", "Accessor": "Infiniband", "Type": "deviceInfiniband" }, { "Name": "org.freedesktop.NetworkManager.Device.IPTunnel", "Accessor": "IPTunnel", "Type": "deviceIPTunnel" }, { "Name": "org.freedesktop.NetworkManager.Device.Macsec", "Accessor": "Macsec", "Type": "deviceMacsec" }, { "Name": "org.freedesktop.NetworkManager.Device.Macvlan", "Accessor": "Macvlan", "Type": "deviceMacvlan" }, { "Name": "org.freedesktop.NetworkManager.Device.Modem", "Accessor": "Modem", "Type": "deviceModem" }, { "Name": "org.freedesktop.NetworkManager.Device.OlpcMesh", "Accessor": "OlpcMesh", "Type": "deviceOlpcMesh" }, { "Name": "org.freedesktop.NetworkManager.Device.Statistics", "Accessor": "Statistics", "Type": "deviceStatistics" }, { "Name": "org.freedesktop.NetworkManager.Device.Team", "Accessor": "Team", "Type": "deviceTeam" }, { "Name": "org.freedesktop.NetworkManager.Device.Tun", "Accessor": "Tun", "Type": "deviceTun" }, { "Name": "org.freedesktop.NetworkManager.Device.Veth", "Accessor": "Veth", "Type": "deviceVeth" }, { "Name": "org.freedesktop.NetworkManager.Device.Vlan", "Accessor": "Vlan", "Type": "deviceVlan" }, { "Name": "org.freedesktop.NetworkManager.Device.Vxlan", "Accessor": "Vxlan", "Type": "deviceVxlan" }, { "Name": "org.freedesktop.NetworkManager.Device.WiMax", "Accessor": "WiMax", "Type": "deviceWiMax" }, { "Name": "org.freedesktop.NetworkManager.Device.Wired", "Accessor": "Wired", "Type": "deviceWired" }, { "Name": "org.freedesktop.NetworkManager.Device.Wireless", "Accessor": "Wireless", "Type": "deviceWireless" } ] }, { "Type": "WiMaxNsp", "XmlFile": "WiMax.Nsp", "Interfaces": [ { "Name": "org.freedesktop.NetworkManager.WiMax.Nsp", "Type": "wiMaxNsp" } ] } ], "PropertyTypes": [ { "Type": "PropMapStringVariant", "ValueType": "map[string]dbus.Variant" }, { "Type": "PropMapSVSlice", "ValueType": "[]map[string]dbus.Variant" }, { "Type": "PropUint32SliceSlice", "ValueType": "[][]uint32" } ] } go-dbus-factory-1.9.6/org.freedesktop.networkmanager/manual.go000066400000000000000000000003761403054572700245010ustar00rootroot00000000000000package networkmanager type IP6Address struct { Address []byte Prefix uint32 Gateway []byte } type IP6Route struct { Route []byte Prefix uint32 NextHop []byte Metric uint32 } type DeviceStateReason struct { State uint32 Reason uint32 } go-dbus-factory-1.9.6/org.freedesktop.notifications/000077500000000000000000000000001403054572700225145ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.notifications/Notifications.xml000066400000000000000000000053421403054572700260530ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.notifications/auto.go000066400000000000000000000112011403054572700240060ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.notifications"; DO NOT EDIT. package notifications import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Notifications struct { notifications // interface org.freedesktop.Notifications proxy.Object } func NewNotifications(conn *dbus.Conn) *Notifications { obj := new(Notifications) obj.Object.Init_(conn, "org.freedesktop.Notifications", "/org/freedesktop/Notifications") return obj } type notifications struct{} func (v *notifications) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*notifications) GetInterfaceName_() string { return "org.freedesktop.Notifications" } // method GetCapabilities func (v *notifications) GoGetCapabilities(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetCapabilities", flags, ch) } func (*notifications) StoreGetCapabilities(call *dbus.Call) (capabilities []string, err error) { err = call.Store(&capabilities) return } func (v *notifications) GetCapabilities(flags dbus.Flags) (capabilities []string, err error) { return v.StoreGetCapabilities( <-v.GoGetCapabilities(flags, make(chan *dbus.Call, 1)).Done) } // method Notify func (v *notifications) GoNotify(flags dbus.Flags, ch chan *dbus.Call, app_name string, replaces_id uint32, app_icon string, summary string, body string, actions []string, hints map[string]dbus.Variant, expire_timeout int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Notify", flags, ch, app_name, replaces_id, app_icon, summary, body, actions, hints, expire_timeout) } func (*notifications) StoreNotify(call *dbus.Call) (id uint32, err error) { err = call.Store(&id) return } func (v *notifications) Notify(flags dbus.Flags, app_name string, replaces_id uint32, app_icon string, summary string, body string, actions []string, hints map[string]dbus.Variant, expire_timeout int32) (id uint32, err error) { return v.StoreNotify( <-v.GoNotify(flags, make(chan *dbus.Call, 1), app_name, replaces_id, app_icon, summary, body, actions, hints, expire_timeout).Done) } // method CloseNotification func (v *notifications) GoCloseNotification(flags dbus.Flags, ch chan *dbus.Call, id uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CloseNotification", flags, ch, id) } func (v *notifications) CloseNotification(flags dbus.Flags, id uint32) error { return (<-v.GoCloseNotification(flags, make(chan *dbus.Call, 1), id).Done).Err } // method GetServerInformation func (v *notifications) GoGetServerInformation(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetServerInformation", flags, ch) } func (*notifications) StoreGetServerInformation(call *dbus.Call) (name string, vendor string, version string, spec_version string, err error) { err = call.Store(&name, &vendor, &version, &spec_version) return } func (v *notifications) GetServerInformation(flags dbus.Flags) (name string, vendor string, version string, spec_version string, err error) { return v.StoreGetServerInformation( <-v.GoGetServerInformation(flags, make(chan *dbus.Call, 1)).Done) } // signal NotificationClosed func (v *notifications) ConnectNotificationClosed(cb func(id uint32, reason uint32)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "NotificationClosed", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".NotificationClosed", } handlerFunc := func(sig *dbus.Signal) { var id uint32 var reason uint32 err := dbus.Store(sig.Body, &id, &reason) if err == nil { cb(id, reason) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ActionInvoked func (v *notifications) ConnectActionInvoked(cb func(id uint32, action_key string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ActionInvoked", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ActionInvoked", } handlerFunc := func(sig *dbus.Signal) { var id uint32 var action_key string err := dbus.Store(sig.Body, &id, &action_key) if err == nil { cb(id, action_key) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/org.freedesktop.notifications/config.json000066400000000000000000000004471403054572700246610ustar00rootroot00000000000000{ "Service": "org.freedesktop.Notifications", "Objects": [ { "Type": "Notifications", "Path": "/org/freedesktop/Notifications", "Interfaces": [ { "Name": "org.freedesktop.Notifications", "Type": "notifications" } ] } ] } go-dbus-factory-1.9.6/org.freedesktop.policykit1/000077500000000000000000000000001403054572700217335ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.policykit1/Authority.xml000066400000000000000000000103251403054572700244460ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.policykit1/auto.go000066400000000000000000000200021403054572700232240ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.policykit1"; DO NOT EDIT. package policykit1 import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Authority struct { authority // interface org.freedesktop.PolicyKit1.Authority proxy.Object } func NewAuthority(conn *dbus.Conn) *Authority { obj := new(Authority) obj.Object.Init_(conn, "org.freedesktop.PolicyKit1", "/org/freedesktop/PolicyKit1/Authority") return obj } type authority struct{} func (v *authority) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*authority) GetInterfaceName_() string { return "org.freedesktop.PolicyKit1.Authority" } // method EnumerateActions func (v *authority) GoEnumerateActions(flags dbus.Flags, ch chan *dbus.Call, locale string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnumerateActions", flags, ch, locale) } func (*authority) StoreEnumerateActions(call *dbus.Call) (action_descriptions []ActionDescription, err error) { err = call.Store(&action_descriptions) return } func (v *authority) EnumerateActions(flags dbus.Flags, locale string) (action_descriptions []ActionDescription, err error) { return v.StoreEnumerateActions( <-v.GoEnumerateActions(flags, make(chan *dbus.Call, 1), locale).Done) } // method CheckAuthorization func (v *authority) GoCheckAuthorization(flags dbus.Flags, ch chan *dbus.Call, subject Subject, action_id string, details map[string]string, flags0 uint32, cancellation_id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CheckAuthorization", flags, ch, subject, action_id, details, flags0, cancellation_id) } func (*authority) StoreCheckAuthorization(call *dbus.Call) (result AuthorizationResult, err error) { err = call.Store(&result) return } func (v *authority) CheckAuthorization(flags dbus.Flags, subject Subject, action_id string, details map[string]string, flags0 uint32, cancellation_id string) (result AuthorizationResult, err error) { return v.StoreCheckAuthorization( <-v.GoCheckAuthorization(flags, make(chan *dbus.Call, 1), subject, action_id, details, flags0, cancellation_id).Done) } // method CancelCheckAuthorization func (v *authority) GoCancelCheckAuthorization(flags dbus.Flags, ch chan *dbus.Call, cancellation_id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CancelCheckAuthorization", flags, ch, cancellation_id) } func (v *authority) CancelCheckAuthorization(flags dbus.Flags, cancellation_id string) error { return (<-v.GoCancelCheckAuthorization(flags, make(chan *dbus.Call, 1), cancellation_id).Done).Err } // method RegisterAuthenticationAgent func (v *authority) GoRegisterAuthenticationAgent(flags dbus.Flags, ch chan *dbus.Call, subject Subject, locale string, object_path string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterAuthenticationAgent", flags, ch, subject, locale, object_path) } func (v *authority) RegisterAuthenticationAgent(flags dbus.Flags, subject Subject, locale string, object_path string) error { return (<-v.GoRegisterAuthenticationAgent(flags, make(chan *dbus.Call, 1), subject, locale, object_path).Done).Err } // method RegisterAuthenticationAgentWithOptions func (v *authority) GoRegisterAuthenticationAgentWithOptions(flags dbus.Flags, ch chan *dbus.Call, subject Subject, locale string, object_path string, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RegisterAuthenticationAgentWithOptions", flags, ch, subject, locale, object_path, options) } func (v *authority) RegisterAuthenticationAgentWithOptions(flags dbus.Flags, subject Subject, locale string, object_path string, options map[string]dbus.Variant) error { return (<-v.GoRegisterAuthenticationAgentWithOptions(flags, make(chan *dbus.Call, 1), subject, locale, object_path, options).Done).Err } // method UnregisterAuthenticationAgent func (v *authority) GoUnregisterAuthenticationAgent(flags dbus.Flags, ch chan *dbus.Call, subject Subject, object_path string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnregisterAuthenticationAgent", flags, ch, subject, object_path) } func (v *authority) UnregisterAuthenticationAgent(flags dbus.Flags, subject Subject, object_path string) error { return (<-v.GoUnregisterAuthenticationAgent(flags, make(chan *dbus.Call, 1), subject, object_path).Done).Err } // method AuthenticationAgentResponse func (v *authority) GoAuthenticationAgentResponse(flags dbus.Flags, ch chan *dbus.Call, cookie string, identity Identity) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AuthenticationAgentResponse", flags, ch, cookie, identity) } func (v *authority) AuthenticationAgentResponse(flags dbus.Flags, cookie string, identity Identity) error { return (<-v.GoAuthenticationAgentResponse(flags, make(chan *dbus.Call, 1), cookie, identity).Done).Err } // method AuthenticationAgentResponse2 func (v *authority) GoAuthenticationAgentResponse2(flags dbus.Flags, ch chan *dbus.Call, uid uint32, cookie string, identity Identity) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AuthenticationAgentResponse2", flags, ch, uid, cookie, identity) } func (v *authority) AuthenticationAgentResponse2(flags dbus.Flags, uid uint32, cookie string, identity Identity) error { return (<-v.GoAuthenticationAgentResponse2(flags, make(chan *dbus.Call, 1), uid, cookie, identity).Done).Err } // method EnumerateTemporaryAuthorizations func (v *authority) GoEnumerateTemporaryAuthorizations(flags dbus.Flags, ch chan *dbus.Call, subject Subject) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnumerateTemporaryAuthorizations", flags, ch, subject) } func (*authority) StoreEnumerateTemporaryAuthorizations(call *dbus.Call) (temporary_authorizations TemporaryAuthorization, err error) { err = call.Store(&temporary_authorizations) return } func (v *authority) EnumerateTemporaryAuthorizations(flags dbus.Flags, subject Subject) (temporary_authorizations TemporaryAuthorization, err error) { return v.StoreEnumerateTemporaryAuthorizations( <-v.GoEnumerateTemporaryAuthorizations(flags, make(chan *dbus.Call, 1), subject).Done) } // method RevokeTemporaryAuthorizations func (v *authority) GoRevokeTemporaryAuthorizations(flags dbus.Flags, ch chan *dbus.Call, subject Subject) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RevokeTemporaryAuthorizations", flags, ch, subject) } func (v *authority) RevokeTemporaryAuthorizations(flags dbus.Flags, subject Subject) error { return (<-v.GoRevokeTemporaryAuthorizations(flags, make(chan *dbus.Call, 1), subject).Done).Err } // method RevokeTemporaryAuthorizationById func (v *authority) GoRevokeTemporaryAuthorizationById(flags dbus.Flags, ch chan *dbus.Call, id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RevokeTemporaryAuthorizationById", flags, ch, id) } func (v *authority) RevokeTemporaryAuthorizationById(flags dbus.Flags, id string) error { return (<-v.GoRevokeTemporaryAuthorizationById(flags, make(chan *dbus.Call, 1), id).Done).Err } // signal Changed func (v *authority) ConnectChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Changed", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Changed", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property BackendName s func (v *authority) BackendName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "BackendName", } } // property BackendVersion s func (v *authority) BackendVersion() proxy.PropString { return proxy.PropString{ Impl: v, Name: "BackendVersion", } } // property BackendFeatures u func (v *authority) BackendFeatures() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "BackendFeatures", } } go-dbus-factory-1.9.6/org.freedesktop.policykit1/config.json000066400000000000000000000040271403054572700240760ustar00rootroot00000000000000{ "Service": "org.freedesktop.PolicyKit1", "Objects": [ { "Type": "Authority", "Path": "/org/freedesktop/PolicyKit1/Authority", "Interfaces": [ { "Name": "org.freedesktop.PolicyKit1.Authority", "Type": "authority", "Fixes": { "m/EnumerateActions": [ { "Name": "action_descriptions", "Type": "[]ActionDescription" } ], "m/CheckAuthorization": [ { "Name": "subject", "Type": "Subject" }, { "Name": "result", "Type": "AuthorizationResult" } ], "m/RegisterAuthenticationAgent": [ { "Name": "subject", "Type": "Subject" } ], "m/RegisterAuthenticationAgentWithOptions": [ { "Name":"subject", "Type": "Subject" } ], "m/UnregisterAuthenticationAgent": [ { "Name":"subject", "Type": "Subject" } ], "m/AuthenticationAgentResponse": [ { "Name": "identity", "Type": "Identity" } ], "m/AuthenticationAgentResponse2": [ { "Name": "identity", "Type": "Identity" } ], "m/EnumerateTemporaryAuthorizations": [ { "Name":"subject", "Type": "Subject" }, { "Name": "temporary_authorizations", "Type": "TemporaryAuthorization " } ], "m/RevokeTemporaryAuthorizations": [ { "Name":"subject", "Type": "Subject" } ] } } ] } ] } go-dbus-factory-1.9.6/org.freedesktop.policykit1/manual.go000066400000000000000000000024521403054572700235420ustar00rootroot00000000000000package policykit1 import "github.com/godbus/dbus" type ActionDescription struct { ActionId string Description string Message string VendorName string VendorURL string IconName string ImplicitAny ImplicitAuthorization ImplicitInactive ImplicitAuthorization ImplicitActive ImplicitAuthorization } type ImplicitAuthorization uint32 type Subject struct { Kind string Details map[string]dbus.Variant } type Identity struct { Kind string Details map[string]dbus.Variant } type AuthorizationResult struct { IsAuthorized bool IsChallenge bool Details map[string]dbus.Variant } type TemporaryAuthorization struct { Id string ActionId string Subject Subject TimeObtained uint64 TimeExpires uint64 } // SubjectKind const ( SubjectKindUnixProcess = "unix-process" SubjectKindUnixSession = "unix-session" SubjectKindSystemBusName = "system-bus-name" ) func MakeSubject(kind string) Subject { return Subject{ Kind: kind, Details: make(map[string]dbus.Variant), } } func (s *Subject) SetDetail(key string, value interface{}) { s.Details[key] = dbus.MakeVariant(value) } // CheckAuthorizationFlags const ( CheckAuthorizationFlagsNone = 0 CheckAuthorizationFlagsAllowUserInteraction = 1 ) go-dbus-factory-1.9.6/org.freedesktop.screensaver/000077500000000000000000000000001403054572700221635ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.screensaver/ScreenSaver.xml000066400000000000000000000045771403054572700251420ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.screensaver/auto.go000066400000000000000000000100331403054572700234570ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.screensaver"; DO NOT EDIT. package screensaver import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type ScreenSaver struct { screenSaver // interface org.freedesktop.ScreenSaver proxy.Object } func NewScreenSaver(conn *dbus.Conn) *ScreenSaver { obj := new(ScreenSaver) obj.Object.Init_(conn, "org.freedesktop.ScreenSaver", "/org/freedesktop/ScreenSaver") return obj } type screenSaver struct{} func (v *screenSaver) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*screenSaver) GetInterfaceName_() string { return "org.freedesktop.ScreenSaver" } // method Inhibit func (v *screenSaver) GoInhibit(flags dbus.Flags, ch chan *dbus.Call, name string, reason string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Inhibit", flags, ch, name, reason) } func (*screenSaver) StoreInhibit(call *dbus.Call) (cookie uint32, err error) { err = call.Store(&cookie) return } func (v *screenSaver) Inhibit(flags dbus.Flags, name string, reason string) (cookie uint32, err error) { return v.StoreInhibit( <-v.GoInhibit(flags, make(chan *dbus.Call, 1), name, reason).Done) } // method SetTimeout func (v *screenSaver) GoSetTimeout(flags dbus.Flags, ch chan *dbus.Call, seconds uint32, interval uint32, blank bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetTimeout", flags, ch, seconds, interval, blank) } func (v *screenSaver) SetTimeout(flags dbus.Flags, seconds uint32, interval uint32, blank bool) error { return (<-v.GoSetTimeout(flags, make(chan *dbus.Call, 1), seconds, interval, blank).Done).Err } // method SimulateUserActivity func (v *screenSaver) GoSimulateUserActivity(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SimulateUserActivity", flags, ch) } func (v *screenSaver) SimulateUserActivity(flags dbus.Flags) error { return (<-v.GoSimulateUserActivity(flags, make(chan *dbus.Call, 1)).Done).Err } // method UnInhibit func (v *screenSaver) GoUnInhibit(flags dbus.Flags, ch chan *dbus.Call, cookie uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnInhibit", flags, ch, cookie) } func (v *screenSaver) UnInhibit(flags dbus.Flags, cookie uint32) error { return (<-v.GoUnInhibit(flags, make(chan *dbus.Call, 1), cookie).Done).Err } // signal IdleOn func (v *screenSaver) ConnectIdleOn(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "IdleOn", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".IdleOn", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal CycleActive func (v *screenSaver) ConnectCycleActive(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "CycleActive", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".CycleActive", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal IdleOff func (v *screenSaver) ConnectIdleOff(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "IdleOff", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".IdleOff", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/org.freedesktop.screensaver/config.json000066400000000000000000000004351403054572700243250ustar00rootroot00000000000000{ "Service": "org.freedesktop.ScreenSaver", "Objects": [ { "Type": "ScreenSaver", "Path": "/org/freedesktop/ScreenSaver", "Interfaces": [ { "Name": "org.freedesktop.ScreenSaver", "Type": "screenSaver" } ] } ] } go-dbus-factory-1.9.6/org.freedesktop.secrets/000077500000000000000000000000001403054572700213135ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.secrets/Collection.xml000066400000000000000000000047741403054572700241440ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.secrets/Item.xml000066400000000000000000000041611403054572700227350ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.secrets/Prompt.xml000066400000000000000000000032631403054572700233220ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.secrets/Service.xml000066400000000000000000000107061403054572700234410ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.secrets/Session.xml000066400000000000000000000027341403054572700234660ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.secrets/auto.go000066400000000000000000000467361403054572700226320ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.secrets"; DO NOT EDIT. package secrets import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Service struct { service // interface org.freedesktop.Secret.Service proxy.Object } func NewService(conn *dbus.Conn) *Service { obj := new(Service) obj.Object.Init_(conn, "org.freedesktop.secrets", "/org/freedesktop/secrets") return obj } type service struct{} func (v *service) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*service) GetInterfaceName_() string { return "org.freedesktop.Secret.Service" } // method OpenSession func (v *service) GoOpenSession(flags dbus.Flags, ch chan *dbus.Call, algorithm string, input dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".OpenSession", flags, ch, algorithm, input) } func (*service) StoreOpenSession(call *dbus.Call) (output dbus.Variant, result dbus.ObjectPath, err error) { err = call.Store(&output, &result) return } func (v *service) OpenSession(flags dbus.Flags, algorithm string, input dbus.Variant) (output dbus.Variant, result dbus.ObjectPath, err error) { return v.StoreOpenSession( <-v.GoOpenSession(flags, make(chan *dbus.Call, 1), algorithm, input).Done) } // method CreateCollection func (v *service) GoCreateCollection(flags dbus.Flags, ch chan *dbus.Call, properties map[string]dbus.Variant, alias string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateCollection", flags, ch, properties, alias) } func (*service) StoreCreateCollection(call *dbus.Call) (collection dbus.ObjectPath, prompt dbus.ObjectPath, err error) { err = call.Store(&collection, &prompt) return } func (v *service) CreateCollection(flags dbus.Flags, properties map[string]dbus.Variant, alias string) (collection dbus.ObjectPath, prompt dbus.ObjectPath, err error) { return v.StoreCreateCollection( <-v.GoCreateCollection(flags, make(chan *dbus.Call, 1), properties, alias).Done) } // method SearchItems func (v *service) GoSearchItems(flags dbus.Flags, ch chan *dbus.Call, attributes map[string]string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SearchItems", flags, ch, attributes) } func (*service) StoreSearchItems(call *dbus.Call) (unlocked []dbus.ObjectPath, locked []dbus.ObjectPath, err error) { err = call.Store(&unlocked, &locked) return } func (v *service) SearchItems(flags dbus.Flags, attributes map[string]string) (unlocked []dbus.ObjectPath, locked []dbus.ObjectPath, err error) { return v.StoreSearchItems( <-v.GoSearchItems(flags, make(chan *dbus.Call, 1), attributes).Done) } // method Unlock func (v *service) GoUnlock(flags dbus.Flags, ch chan *dbus.Call, objects []dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Unlock", flags, ch, objects) } func (*service) StoreUnlock(call *dbus.Call) (unlocked []dbus.ObjectPath, prompt dbus.ObjectPath, err error) { err = call.Store(&unlocked, &prompt) return } func (v *service) Unlock(flags dbus.Flags, objects []dbus.ObjectPath) (unlocked []dbus.ObjectPath, prompt dbus.ObjectPath, err error) { return v.StoreUnlock( <-v.GoUnlock(flags, make(chan *dbus.Call, 1), objects).Done) } // method Lock func (v *service) GoLock(flags dbus.Flags, ch chan *dbus.Call, objects []dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Lock", flags, ch, objects) } func (*service) StoreLock(call *dbus.Call) (locked []dbus.ObjectPath, Prompt dbus.ObjectPath, err error) { err = call.Store(&locked, &Prompt) return } func (v *service) Lock(flags dbus.Flags, objects []dbus.ObjectPath) (locked []dbus.ObjectPath, Prompt dbus.ObjectPath, err error) { return v.StoreLock( <-v.GoLock(flags, make(chan *dbus.Call, 1), objects).Done) } // method LockService func (v *service) GoLockService(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LockService", flags, ch) } func (v *service) LockService(flags dbus.Flags) error { return (<-v.GoLockService(flags, make(chan *dbus.Call, 1)).Done).Err } // method ChangeLock func (v *service) GoChangeLock(flags dbus.Flags, ch chan *dbus.Call, collection dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ChangeLock", flags, ch, collection) } func (*service) StoreChangeLock(call *dbus.Call) (prompt dbus.ObjectPath, err error) { err = call.Store(&prompt) return } func (v *service) ChangeLock(flags dbus.Flags, collection dbus.ObjectPath) (prompt dbus.ObjectPath, err error) { return v.StoreChangeLock( <-v.GoChangeLock(flags, make(chan *dbus.Call, 1), collection).Done) } // method GetSecrets func (v *service) GoGetSecrets(flags dbus.Flags, ch chan *dbus.Call, items []dbus.ObjectPath, session dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetSecrets", flags, ch, items, session) } func (*service) StoreGetSecrets(call *dbus.Call) (secrets map[dbus.ObjectPath]Secret, err error) { err = call.Store(&secrets) return } func (v *service) GetSecrets(flags dbus.Flags, items []dbus.ObjectPath, session dbus.ObjectPath) (secrets map[dbus.ObjectPath]Secret, err error) { return v.StoreGetSecrets( <-v.GoGetSecrets(flags, make(chan *dbus.Call, 1), items, session).Done) } // method ReadAlias func (v *service) GoReadAlias(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReadAlias", flags, ch, name) } func (*service) StoreReadAlias(call *dbus.Call) (collection dbus.ObjectPath, err error) { err = call.Store(&collection) return } func (v *service) ReadAlias(flags dbus.Flags, name string) (collection dbus.ObjectPath, err error) { return v.StoreReadAlias( <-v.GoReadAlias(flags, make(chan *dbus.Call, 1), name).Done) } // method SetAlias func (v *service) GoSetAlias(flags dbus.Flags, ch chan *dbus.Call, name string, collection dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetAlias", flags, ch, name, collection) } func (v *service) SetAlias(flags dbus.Flags, name string, collection dbus.ObjectPath) error { return (<-v.GoSetAlias(flags, make(chan *dbus.Call, 1), name, collection).Done).Err } // signal CollectionCreated func (v *service) ConnectCollectionCreated(cb func(collection dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "CollectionCreated", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".CollectionCreated", } handlerFunc := func(sig *dbus.Signal) { var collection dbus.ObjectPath err := dbus.Store(sig.Body, &collection) if err == nil { cb(collection) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal CollectionDeleted func (v *service) ConnectCollectionDeleted(cb func(collection dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "CollectionDeleted", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".CollectionDeleted", } handlerFunc := func(sig *dbus.Signal) { var collection dbus.ObjectPath err := dbus.Store(sig.Body, &collection) if err == nil { cb(collection) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal CollectionChanged func (v *service) ConnectCollectionChanged(cb func(collection dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "CollectionChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".CollectionChanged", } handlerFunc := func(sig *dbus.Signal) { var collection dbus.ObjectPath err := dbus.Store(sig.Body, &collection) if err == nil { cb(collection) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Collections ao func (v *service) Collections() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Collections", } } type Collection struct { collection // interface org.freedesktop.Secret.Collection proxy.Object } func NewCollection(conn *dbus.Conn, path dbus.ObjectPath) (*Collection, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Collection) obj.Object.Init_(conn, "org.freedesktop.secrets", path) return obj, nil } type collection struct{} func (v *collection) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*collection) GetInterfaceName_() string { return "org.freedesktop.Secret.Collection" } // method Delete func (v *collection) GoDelete(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Delete", flags, ch) } func (*collection) StoreDelete(call *dbus.Call) (prompt dbus.ObjectPath, err error) { err = call.Store(&prompt) return } func (v *collection) Delete(flags dbus.Flags) (prompt dbus.ObjectPath, err error) { return v.StoreDelete( <-v.GoDelete(flags, make(chan *dbus.Call, 1)).Done) } // method SearchItems func (v *collection) GoSearchItems(flags dbus.Flags, ch chan *dbus.Call, attributes map[string]string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SearchItems", flags, ch, attributes) } func (*collection) StoreSearchItems(call *dbus.Call) (results []dbus.ObjectPath, err error) { err = call.Store(&results) return } func (v *collection) SearchItems(flags dbus.Flags, attributes map[string]string) (results []dbus.ObjectPath, err error) { return v.StoreSearchItems( <-v.GoSearchItems(flags, make(chan *dbus.Call, 1), attributes).Done) } // method CreateItem func (v *collection) GoCreateItem(flags dbus.Flags, ch chan *dbus.Call, properties map[string]dbus.Variant, secret Secret, replace bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreateItem", flags, ch, properties, secret, replace) } func (*collection) StoreCreateItem(call *dbus.Call) (item dbus.ObjectPath, prompt dbus.ObjectPath, err error) { err = call.Store(&item, &prompt) return } func (v *collection) CreateItem(flags dbus.Flags, properties map[string]dbus.Variant, secret Secret, replace bool) (item dbus.ObjectPath, prompt dbus.ObjectPath, err error) { return v.StoreCreateItem( <-v.GoCreateItem(flags, make(chan *dbus.Call, 1), properties, secret, replace).Done) } // signal ItemCreated func (v *collection) ConnectItemCreated(cb func(item dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ItemCreated", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ItemCreated", } handlerFunc := func(sig *dbus.Signal) { var item dbus.ObjectPath err := dbus.Store(sig.Body, &item) if err == nil { cb(item) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ItemDeleted func (v *collection) ConnectItemDeleted(cb func(item dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ItemDeleted", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ItemDeleted", } handlerFunc := func(sig *dbus.Signal) { var item dbus.ObjectPath err := dbus.Store(sig.Body, &item) if err == nil { cb(item) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal ItemChanged func (v *collection) ConnectItemChanged(cb func(item dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "ItemChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".ItemChanged", } handlerFunc := func(sig *dbus.Signal) { var item dbus.ObjectPath err := dbus.Store(sig.Body, &item) if err == nil { cb(item) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Items ao func (v *collection) Items() proxy.PropObjectPathArray { return proxy.PropObjectPathArray{ Impl: v, Name: "Items", } } // property Label s func (v *collection) Label() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Label", } } // property Locked b func (v *collection) Locked() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Locked", } } // property Created t func (v *collection) Created() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Created", } } // property Modified t func (v *collection) Modified() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Modified", } } type Item struct { item // interface org.freedesktop.Secret.Item proxy.Object } func NewItem(conn *dbus.Conn, path dbus.ObjectPath) (*Item, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Item) obj.Object.Init_(conn, "org.freedesktop.secrets", path) return obj, nil } type item struct{} func (v *item) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*item) GetInterfaceName_() string { return "org.freedesktop.Secret.Item" } // method Delete func (v *item) GoDelete(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Delete", flags, ch) } func (*item) StoreDelete(call *dbus.Call) (Prompt dbus.ObjectPath, err error) { err = call.Store(&Prompt) return } func (v *item) Delete(flags dbus.Flags) (Prompt dbus.ObjectPath, err error) { return v.StoreDelete( <-v.GoDelete(flags, make(chan *dbus.Call, 1)).Done) } // method GetSecret func (v *item) GoGetSecret(flags dbus.Flags, ch chan *dbus.Call, session dbus.ObjectPath) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetSecret", flags, ch, session) } func (*item) StoreGetSecret(call *dbus.Call) (secret Secret, err error) { err = call.Store(&secret) return } func (v *item) GetSecret(flags dbus.Flags, session dbus.ObjectPath) (secret Secret, err error) { return v.StoreGetSecret( <-v.GoGetSecret(flags, make(chan *dbus.Call, 1), session).Done) } // method SetSecret func (v *item) GoSetSecret(flags dbus.Flags, ch chan *dbus.Call, secret Secret) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetSecret", flags, ch, secret) } func (v *item) SetSecret(flags dbus.Flags, secret Secret) error { return (<-v.GoSetSecret(flags, make(chan *dbus.Call, 1), secret).Done).Err } // property Locked b func (v *item) Locked() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Locked", } } // property Attributes a{ss} func (v *item) Attributes() PropItemAttributes { return PropItemAttributes{ Impl: v, } } type PropItemAttributes struct { Impl proxy.Implementer } func (p PropItemAttributes) Get(flags dbus.Flags) (value map[string]string, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Attributes", &value) return } func (p PropItemAttributes) Set(flags dbus.Flags, value map[string]string) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), "Attributes", value) } func (p PropItemAttributes) ConnectChanged(cb func(hasValue bool, value map[string]string)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[string]string err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Attributes", cb0) } // property Label s func (v *item) Label() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Label", } } // property Type s func (v *item) Type() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Type", } } // property Created t func (v *item) Created() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Created", } } // property Modified t func (v *item) Modified() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Modified", } } type Session struct { session // interface org.freedesktop.Secret.Session proxy.Object } func NewSession(conn *dbus.Conn, path dbus.ObjectPath) (*Session, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Session) obj.Object.Init_(conn, "org.freedesktop.secrets", path) return obj, nil } type session struct{} func (v *session) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*session) GetInterfaceName_() string { return "org.freedesktop.Secret.Session" } // method Close func (v *session) GoClose(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Close", flags, ch) } func (v *session) Close(flags dbus.Flags) error { return (<-v.GoClose(flags, make(chan *dbus.Call, 1)).Done).Err } type Prompt struct { prompt // interface org.freedesktop.Secret.Prompt proxy.Object } func NewPrompt(conn *dbus.Conn, path dbus.ObjectPath) (*Prompt, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Prompt) obj.Object.Init_(conn, "org.freedesktop.secrets", path) return obj, nil } type prompt struct{} func (v *prompt) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*prompt) GetInterfaceName_() string { return "org.freedesktop.Secret.Prompt" } // method Prompt func (v *prompt) GoPrompt(flags dbus.Flags, ch chan *dbus.Call, window_id string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Prompt", flags, ch, window_id) } func (v *prompt) Prompt(flags dbus.Flags, window_id string) error { return (<-v.GoPrompt(flags, make(chan *dbus.Call, 1), window_id).Done).Err } // method Dismiss func (v *prompt) GoDismiss(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Dismiss", flags, ch) } func (v *prompt) Dismiss(flags dbus.Flags) error { return (<-v.GoDismiss(flags, make(chan *dbus.Call, 1)).Done).Err } // signal Completed func (v *prompt) ConnectCompleted(cb func(dismissed bool, result dbus.Variant)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Completed", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Completed", } handlerFunc := func(sig *dbus.Signal) { var dismissed bool var result dbus.Variant err := dbus.Store(sig.Body, &dismissed, &result) if err == nil { cb(dismissed, result) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } go-dbus-factory-1.9.6/org.freedesktop.secrets/config.json000066400000000000000000000033531403054572700234570ustar00rootroot00000000000000{ "Service": "org.freedesktop.secrets", "Objects": [ { "Type": "Service", "Path": "/org/freedesktop/secrets", "Interfaces": [ { "Name": "org.freedesktop.Secret.Service", "Type": "service", "Fixes": { "m/GetSecrets": [ { "Name": "secrets", "Type": "map[dbus.ObjectPath]Secret" } ] } } ] }, { "Type": "Collection", "Interfaces": [ { "Name": "org.freedesktop.Secret.Collection", "Type": "collection", "Fixes": { "m/CreateItem": [ { "Name": "secret", "Type": "Secret" } ] } } ] }, { "Type": "Item", "Interfaces": [ { "Name": "org.freedesktop.Secret.Item", "Type": "item", "Fixes": { "p/Attributes": { "Type": "PropItemAttributes", "ValueType": "map[string]string" }, "m/GetSecret": [ { "Name": "secret", "Type": "Secret" } ], "m/SetSecret": [ { "Name": "secret", "Type": "Secret" } ] } } ] }, { "Type": "Session", "Interfaces": [ { "Name": "org.freedesktop.Secret.Session", "Type": "session" } ] }, { "Type": "Prompt", "Interfaces": [ { "Name": "org.freedesktop.Secret.Prompt", "Type": "prompt" } ] } ] } go-dbus-factory-1.9.6/org.freedesktop.secrets/manual.go000066400000000000000000000002421403054572700231150ustar00rootroot00000000000000package secrets import "github.com/godbus/dbus" type Secret struct { Session dbus.ObjectPath Parameters []byte Value []byte ContentType string } go-dbus-factory-1.9.6/org.freedesktop.systemd1/000077500000000000000000000000001403054572700214145ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.systemd1/Manager.xml000066400000000000000000000733731403054572700235250ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.systemd1/Unit.Service.xml000066400000000000000000001036311403054572700244600ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.systemd1/Unit.xml000066400000000000000000000313571403054572700230660ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.systemd1/auto.go000066400000000000000000003655171403054572700227340ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.systemd1"; DO NOT EDIT. package systemd1 import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Manager struct { manager // interface org.freedesktop.systemd1.Manager proxy.Object } func NewManager(conn *dbus.Conn) *Manager { obj := new(Manager) obj.Object.Init_(conn, "org.freedesktop.systemd1", "/org/freedesktop/systemd1") return obj } type manager struct{} func (v *manager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*manager) GetInterfaceName_() string { return "org.freedesktop.systemd1.Manager" } // method GetUnit func (v *manager) GoGetUnit(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetUnit", flags, ch, name) } func (*manager) StoreGetUnit(call *dbus.Call) (unit dbus.ObjectPath, err error) { err = call.Store(&unit) return } func (v *manager) GetUnit(flags dbus.Flags, name string) (unit dbus.ObjectPath, err error) { return v.StoreGetUnit( <-v.GoGetUnit(flags, make(chan *dbus.Call, 1), name).Done) } // method GetUnitByPID func (v *manager) GoGetUnitByPID(flags dbus.Flags, ch chan *dbus.Call, pid uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetUnitByPID", flags, ch, pid) } func (*manager) StoreGetUnitByPID(call *dbus.Call) (unit dbus.ObjectPath, err error) { err = call.Store(&unit) return } func (v *manager) GetUnitByPID(flags dbus.Flags, pid uint32) (unit dbus.ObjectPath, err error) { return v.StoreGetUnitByPID( <-v.GoGetUnitByPID(flags, make(chan *dbus.Call, 1), pid).Done) } // method GetUnitByInvocationID func (v *manager) GoGetUnitByInvocationID(flags dbus.Flags, ch chan *dbus.Call, invocationID []uint8) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetUnitByInvocationID", flags, ch, invocationID) } func (*manager) StoreGetUnitByInvocationID(call *dbus.Call) (unit dbus.ObjectPath, err error) { err = call.Store(&unit) return } func (v *manager) GetUnitByInvocationID(flags dbus.Flags, invocationID []uint8) (unit dbus.ObjectPath, err error) { return v.StoreGetUnitByInvocationID( <-v.GoGetUnitByInvocationID(flags, make(chan *dbus.Call, 1), invocationID).Done) } // method GetUnitByControlGroup func (v *manager) GoGetUnitByControlGroup(flags dbus.Flags, ch chan *dbus.Call, ctrlGroup string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetUnitByControlGroup", flags, ch, ctrlGroup) } func (*manager) StoreGetUnitByControlGroup(call *dbus.Call) (unit dbus.ObjectPath, err error) { err = call.Store(&unit) return } func (v *manager) GetUnitByControlGroup(flags dbus.Flags, ctrlGroup string) (unit dbus.ObjectPath, err error) { return v.StoreGetUnitByControlGroup( <-v.GoGetUnitByControlGroup(flags, make(chan *dbus.Call, 1), ctrlGroup).Done) } // method LoadUnit func (v *manager) GoLoadUnit(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LoadUnit", flags, ch, name) } func (*manager) StoreLoadUnit(call *dbus.Call) (unit dbus.ObjectPath, err error) { err = call.Store(&unit) return } func (v *manager) LoadUnit(flags dbus.Flags, name string) (unit dbus.ObjectPath, err error) { return v.StoreLoadUnit( <-v.GoLoadUnit(flags, make(chan *dbus.Call, 1), name).Done) } // method StartUnit func (v *manager) GoStartUnit(flags dbus.Flags, ch chan *dbus.Call, name string, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StartUnit", flags, ch, name, mode) } func (*manager) StoreStartUnit(call *dbus.Call) (unit dbus.ObjectPath, err error) { err = call.Store(&unit) return } func (v *manager) StartUnit(flags dbus.Flags, name string, mode string) (unit dbus.ObjectPath, err error) { return v.StoreStartUnit( <-v.GoStartUnit(flags, make(chan *dbus.Call, 1), name, mode).Done) } // method StartUnitReplace func (v *manager) GoStartUnitReplace(flags dbus.Flags, ch chan *dbus.Call, oldUnit string, newUnit string, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StartUnitReplace", flags, ch, oldUnit, newUnit, mode) } func (*manager) StoreStartUnitReplace(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) StartUnitReplace(flags dbus.Flags, oldUnit string, newUnit string, mode string) (job dbus.ObjectPath, err error) { return v.StoreStartUnitReplace( <-v.GoStartUnitReplace(flags, make(chan *dbus.Call, 1), oldUnit, newUnit, mode).Done) } // method StopUnit func (v *manager) GoStopUnit(flags dbus.Flags, ch chan *dbus.Call, name string, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StopUnit", flags, ch, name, mode) } func (*manager) StoreStopUnit(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) StopUnit(flags dbus.Flags, name string, mode string) (job dbus.ObjectPath, err error) { return v.StoreStopUnit( <-v.GoStopUnit(flags, make(chan *dbus.Call, 1), name, mode).Done) } // method ReloadUnit func (v *manager) GoReloadUnit(flags dbus.Flags, ch chan *dbus.Call, name string, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReloadUnit", flags, ch, name, mode) } func (*manager) StoreReloadUnit(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) ReloadUnit(flags dbus.Flags, name string, mode string) (job dbus.ObjectPath, err error) { return v.StoreReloadUnit( <-v.GoReloadUnit(flags, make(chan *dbus.Call, 1), name, mode).Done) } // method RestartUnit func (v *manager) GoRestartUnit(flags dbus.Flags, ch chan *dbus.Call, name string, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RestartUnit", flags, ch, name, mode) } func (*manager) StoreRestartUnit(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) RestartUnit(flags dbus.Flags, name string, mode string) (job dbus.ObjectPath, err error) { return v.StoreRestartUnit( <-v.GoRestartUnit(flags, make(chan *dbus.Call, 1), name, mode).Done) } // method TryRestartUnit func (v *manager) GoTryRestartUnit(flags dbus.Flags, ch chan *dbus.Call, name string, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TryRestartUnit", flags, ch, name, mode) } func (*manager) StoreTryRestartUnit(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) TryRestartUnit(flags dbus.Flags, name string, mode string) (job dbus.ObjectPath, err error) { return v.StoreTryRestartUnit( <-v.GoTryRestartUnit(flags, make(chan *dbus.Call, 1), name, mode).Done) } // method ReloadOrRestartUnit func (v *manager) GoReloadOrRestartUnit(flags dbus.Flags, ch chan *dbus.Call, name string, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReloadOrRestartUnit", flags, ch, name, mode) } func (*manager) StoreReloadOrRestartUnit(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) ReloadOrRestartUnit(flags dbus.Flags, name string, mode string) (job dbus.ObjectPath, err error) { return v.StoreReloadOrRestartUnit( <-v.GoReloadOrRestartUnit(flags, make(chan *dbus.Call, 1), name, mode).Done) } // method ReloadOrTryRestartUnit func (v *manager) GoReloadOrTryRestartUnit(flags dbus.Flags, ch chan *dbus.Call, name string, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReloadOrTryRestartUnit", flags, ch, name, mode) } func (*manager) StoreReloadOrTryRestartUnit(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) ReloadOrTryRestartUnit(flags dbus.Flags, name string, mode string) (job dbus.ObjectPath, err error) { return v.StoreReloadOrTryRestartUnit( <-v.GoReloadOrTryRestartUnit(flags, make(chan *dbus.Call, 1), name, mode).Done) } // method KillUnit func (v *manager) GoKillUnit(flags dbus.Flags, ch chan *dbus.Call, name string, who string, signal int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".KillUnit", flags, ch, name, who, signal) } func (v *manager) KillUnit(flags dbus.Flags, name string, who string, signal int32) error { return (<-v.GoKillUnit(flags, make(chan *dbus.Call, 1), name, who, signal).Done).Err } // method ResetFailedUnit func (v *manager) GoResetFailedUnit(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ResetFailedUnit", flags, ch, name) } func (v *manager) ResetFailedUnit(flags dbus.Flags, name string) error { return (<-v.GoResetFailedUnit(flags, make(chan *dbus.Call, 1), name).Done).Err } // method SetUnitProperties func (v *manager) GoSetUnitProperties(flags dbus.Flags, ch chan *dbus.Call, name string, runtime bool, properties []Property) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetUnitProperties", flags, ch, name, runtime, properties) } func (v *manager) SetUnitProperties(flags dbus.Flags, name string, runtime bool, properties []Property) error { return (<-v.GoSetUnitProperties(flags, make(chan *dbus.Call, 1), name, runtime, properties).Done).Err } // method RefUnit func (v *manager) GoRefUnit(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RefUnit", flags, ch, name) } func (v *manager) RefUnit(flags dbus.Flags, name string) error { return (<-v.GoRefUnit(flags, make(chan *dbus.Call, 1), name).Done).Err } // method UnrefUnit func (v *manager) GoUnrefUnit(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnrefUnit", flags, ch, name) } func (v *manager) UnrefUnit(flags dbus.Flags, name string) error { return (<-v.GoUnrefUnit(flags, make(chan *dbus.Call, 1), name).Done).Err } // method StartTransientUnit func (v *manager) GoStartTransientUnit(flags dbus.Flags, ch chan *dbus.Call, name string, mode string, properties []Property, aux []PropertyCollection) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".StartTransientUnit", flags, ch, name, mode, properties, aux) } func (*manager) StoreStartTransientUnit(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) StartTransientUnit(flags dbus.Flags, name string, mode string, properties []Property, aux []PropertyCollection) (job dbus.ObjectPath, err error) { return v.StoreStartTransientUnit( <-v.GoStartTransientUnit(flags, make(chan *dbus.Call, 1), name, mode, properties, aux).Done) } // method GetUnitProcesses func (v *manager) GoGetUnitProcesses(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetUnitProcesses", flags, ch, name) } func (*manager) StoreGetUnitProcesses(call *dbus.Call) (processes []UnitProcess, err error) { err = call.Store(&processes) return } func (v *manager) GetUnitProcesses(flags dbus.Flags, name string) (processes []UnitProcess, err error) { return v.StoreGetUnitProcesses( <-v.GoGetUnitProcesses(flags, make(chan *dbus.Call, 1), name).Done) } // method AttachProcessesToUnit func (v *manager) GoAttachProcessesToUnit(flags dbus.Flags, ch chan *dbus.Call, name string, path string, pids []uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AttachProcessesToUnit", flags, ch, name, path, pids) } func (v *manager) AttachProcessesToUnit(flags dbus.Flags, name string, path string, pids []uint32) error { return (<-v.GoAttachProcessesToUnit(flags, make(chan *dbus.Call, 1), name, path, pids).Done).Err } // method AbandonScope func (v *manager) GoAbandonScope(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AbandonScope", flags, ch, name) } func (v *manager) AbandonScope(flags dbus.Flags, name string) error { return (<-v.GoAbandonScope(flags, make(chan *dbus.Call, 1), name).Done).Err } // method GetJob func (v *manager) GoGetJob(flags dbus.Flags, ch chan *dbus.Call, id uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetJob", flags, ch, id) } func (*manager) StoreGetJob(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *manager) GetJob(flags dbus.Flags, id uint32) (job dbus.ObjectPath, err error) { return v.StoreGetJob( <-v.GoGetJob(flags, make(chan *dbus.Call, 1), id).Done) } // method GetJobAfter func (v *manager) GoGetJobAfter(flags dbus.Flags, ch chan *dbus.Call, id uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetJobAfter", flags, ch, id) } func (*manager) StoreGetJobAfter(call *dbus.Call) (jobs []JobInfo, err error) { err = call.Store(&jobs) return } func (v *manager) GetJobAfter(flags dbus.Flags, id uint32) (jobs []JobInfo, err error) { return v.StoreGetJobAfter( <-v.GoGetJobAfter(flags, make(chan *dbus.Call, 1), id).Done) } // method GetJobBefore func (v *manager) GoGetJobBefore(flags dbus.Flags, ch chan *dbus.Call, id uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetJobBefore", flags, ch, id) } func (*manager) StoreGetJobBefore(call *dbus.Call) (jobs []JobInfo, err error) { err = call.Store(&jobs) return } func (v *manager) GetJobBefore(flags dbus.Flags, id uint32) (jobs []JobInfo, err error) { return v.StoreGetJobBefore( <-v.GoGetJobBefore(flags, make(chan *dbus.Call, 1), id).Done) } // method CancelJob func (v *manager) GoCancelJob(flags dbus.Flags, ch chan *dbus.Call, id uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CancelJob", flags, ch, id) } func (v *manager) CancelJob(flags dbus.Flags, id uint32) error { return (<-v.GoCancelJob(flags, make(chan *dbus.Call, 1), id).Done).Err } // method ClearJobs func (v *manager) GoClearJobs(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ClearJobs", flags, ch) } func (v *manager) ClearJobs(flags dbus.Flags) error { return (<-v.GoClearJobs(flags, make(chan *dbus.Call, 1)).Done).Err } // method ResetFailed func (v *manager) GoResetFailed(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ResetFailed", flags, ch) } func (v *manager) ResetFailed(flags dbus.Flags) error { return (<-v.GoResetFailed(flags, make(chan *dbus.Call, 1)).Done).Err } // method ListUnits func (v *manager) GoListUnits(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListUnits", flags, ch) } func (*manager) StoreListUnits(call *dbus.Call) (units []UnitInfo, err error) { err = call.Store(&units) return } func (v *manager) ListUnits(flags dbus.Flags) (units []UnitInfo, err error) { return v.StoreListUnits( <-v.GoListUnits(flags, make(chan *dbus.Call, 1)).Done) } // method ListUnitsFiltered func (v *manager) GoListUnitsFiltered(flags dbus.Flags, ch chan *dbus.Call, states []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListUnitsFiltered", flags, ch, states) } func (*manager) StoreListUnitsFiltered(call *dbus.Call) (units []UnitInfo, err error) { err = call.Store(&units) return } func (v *manager) ListUnitsFiltered(flags dbus.Flags, states []string) (units []UnitInfo, err error) { return v.StoreListUnitsFiltered( <-v.GoListUnitsFiltered(flags, make(chan *dbus.Call, 1), states).Done) } // method ListUnitsByPatterns func (v *manager) GoListUnitsByPatterns(flags dbus.Flags, ch chan *dbus.Call, states []string, patterns []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListUnitsByPatterns", flags, ch, states, patterns) } func (*manager) StoreListUnitsByPatterns(call *dbus.Call) (units []UnitInfo, err error) { err = call.Store(&units) return } func (v *manager) ListUnitsByPatterns(flags dbus.Flags, states []string, patterns []string) (units []UnitInfo, err error) { return v.StoreListUnitsByPatterns( <-v.GoListUnitsByPatterns(flags, make(chan *dbus.Call, 1), states, patterns).Done) } // method ListUnitsByNames func (v *manager) GoListUnitsByNames(flags dbus.Flags, ch chan *dbus.Call, names []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListUnitsByNames", flags, ch, names) } func (*manager) StoreListUnitsByNames(call *dbus.Call) (units []UnitInfo, err error) { err = call.Store(&units) return } func (v *manager) ListUnitsByNames(flags dbus.Flags, names []string) (units []UnitInfo, err error) { return v.StoreListUnitsByNames( <-v.GoListUnitsByNames(flags, make(chan *dbus.Call, 1), names).Done) } // method ListJobs func (v *manager) GoListJobs(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListJobs", flags, ch) } func (*manager) StoreListJobs(call *dbus.Call) (jobs []JobInfo, err error) { err = call.Store(&jobs) return } func (v *manager) ListJobs(flags dbus.Flags) (jobs []JobInfo, err error) { return v.StoreListJobs( <-v.GoListJobs(flags, make(chan *dbus.Call, 1)).Done) } // method Subscribe func (v *manager) GoSubscribe(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Subscribe", flags, ch) } func (v *manager) Subscribe(flags dbus.Flags) error { return (<-v.GoSubscribe(flags, make(chan *dbus.Call, 1)).Done).Err } // method Unsubscribe func (v *manager) GoUnsubscribe(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Unsubscribe", flags, ch) } func (v *manager) Unsubscribe(flags dbus.Flags) error { return (<-v.GoUnsubscribe(flags, make(chan *dbus.Call, 1)).Done).Err } // method Dump func (v *manager) GoDump(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Dump", flags, ch) } func (*manager) StoreDump(call *dbus.Call) (arg0 string, err error) { err = call.Store(&arg0) return } func (v *manager) Dump(flags dbus.Flags) (arg0 string, err error) { return v.StoreDump( <-v.GoDump(flags, make(chan *dbus.Call, 1)).Done) } // method DumpByFileDescriptor func (v *manager) GoDumpByFileDescriptor(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DumpByFileDescriptor", flags, ch) } func (*manager) StoreDumpByFileDescriptor(call *dbus.Call) (fd dbus.UnixFD, err error) { err = call.Store(&fd) return } func (v *manager) DumpByFileDescriptor(flags dbus.Flags) (fd dbus.UnixFD, err error) { return v.StoreDumpByFileDescriptor( <-v.GoDumpByFileDescriptor(flags, make(chan *dbus.Call, 1)).Done) } // method Reload func (v *manager) GoReload(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reload", flags, ch) } func (v *manager) Reload(flags dbus.Flags) error { return (<-v.GoReload(flags, make(chan *dbus.Call, 1)).Done).Err } // method Reexecute func (v *manager) GoReexecute(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reexecute", flags, ch) } func (v *manager) Reexecute(flags dbus.Flags) error { return (<-v.GoReexecute(flags, make(chan *dbus.Call, 1)).Done).Err } // method Exit func (v *manager) GoExit(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Exit", flags, ch) } func (v *manager) Exit(flags dbus.Flags) error { return (<-v.GoExit(flags, make(chan *dbus.Call, 1)).Done).Err } // method Reboot func (v *manager) GoReboot(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reboot", flags, ch) } func (v *manager) Reboot(flags dbus.Flags) error { return (<-v.GoReboot(flags, make(chan *dbus.Call, 1)).Done).Err } // method PowerOff func (v *manager) GoPowerOff(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PowerOff", flags, ch) } func (v *manager) PowerOff(flags dbus.Flags) error { return (<-v.GoPowerOff(flags, make(chan *dbus.Call, 1)).Done).Err } // method Halt func (v *manager) GoHalt(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Halt", flags, ch) } func (v *manager) Halt(flags dbus.Flags) error { return (<-v.GoHalt(flags, make(chan *dbus.Call, 1)).Done).Err } // method KExec func (v *manager) GoKExec(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".KExec", flags, ch) } func (v *manager) KExec(flags dbus.Flags) error { return (<-v.GoKExec(flags, make(chan *dbus.Call, 1)).Done).Err } // method SwitchRoot func (v *manager) GoSwitchRoot(flags dbus.Flags, ch chan *dbus.Call, newRoot string, init string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SwitchRoot", flags, ch, newRoot, init) } func (v *manager) SwitchRoot(flags dbus.Flags, newRoot string, init string) error { return (<-v.GoSwitchRoot(flags, make(chan *dbus.Call, 1), newRoot, init).Done).Err } // method SetEnvironment func (v *manager) GoSetEnvironment(flags dbus.Flags, ch chan *dbus.Call, names []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetEnvironment", flags, ch, names) } func (v *manager) SetEnvironment(flags dbus.Flags, names []string) error { return (<-v.GoSetEnvironment(flags, make(chan *dbus.Call, 1), names).Done).Err } // method UnsetEnvironment func (v *manager) GoUnsetEnvironment(flags dbus.Flags, ch chan *dbus.Call, names []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnsetEnvironment", flags, ch, names) } func (v *manager) UnsetEnvironment(flags dbus.Flags, names []string) error { return (<-v.GoUnsetEnvironment(flags, make(chan *dbus.Call, 1), names).Done).Err } // method UnsetAndSetEnvironment func (v *manager) GoUnsetAndSetEnvironment(flags dbus.Flags, ch chan *dbus.Call, unset []string, set []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnsetAndSetEnvironment", flags, ch, unset, set) } func (v *manager) UnsetAndSetEnvironment(flags dbus.Flags, unset []string, set []string) error { return (<-v.GoUnsetAndSetEnvironment(flags, make(chan *dbus.Call, 1), unset, set).Done).Err } // method ListUnitFiles func (v *manager) GoListUnitFiles(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListUnitFiles", flags, ch) } func (*manager) StoreListUnitFiles(call *dbus.Call) (files []UnitFile, err error) { err = call.Store(&files) return } func (v *manager) ListUnitFiles(flags dbus.Flags) (files []UnitFile, err error) { return v.StoreListUnitFiles( <-v.GoListUnitFiles(flags, make(chan *dbus.Call, 1)).Done) } // method ListUnitFilesByPatterns func (v *manager) GoListUnitFilesByPatterns(flags dbus.Flags, ch chan *dbus.Call, states []string, patterns []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ListUnitFilesByPatterns", flags, ch, states, patterns) } func (*manager) StoreListUnitFilesByPatterns(call *dbus.Call) (files []UnitFile, err error) { err = call.Store(&files) return } func (v *manager) ListUnitFilesByPatterns(flags dbus.Flags, states []string, patterns []string) (files []UnitFile, err error) { return v.StoreListUnitFilesByPatterns( <-v.GoListUnitFilesByPatterns(flags, make(chan *dbus.Call, 1), states, patterns).Done) } // method GetUnitFileState func (v *manager) GoGetUnitFileState(flags dbus.Flags, ch chan *dbus.Call, unit string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetUnitFileState", flags, ch, unit) } func (*manager) StoreGetUnitFileState(call *dbus.Call) (state string, err error) { err = call.Store(&state) return } func (v *manager) GetUnitFileState(flags dbus.Flags, unit string) (state string, err error) { return v.StoreGetUnitFileState( <-v.GoGetUnitFileState(flags, make(chan *dbus.Call, 1), unit).Done) } // method EnableUnitFiles func (v *manager) GoEnableUnitFiles(flags dbus.Flags, ch chan *dbus.Call, files []string, runtime bool, force bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".EnableUnitFiles", flags, ch, files, runtime, force) } func (*manager) StoreEnableUnitFiles(call *dbus.Call) (carriesInstallInfo bool, changes []UnitFileChange, err error) { err = call.Store(&carriesInstallInfo, &changes) return } func (v *manager) EnableUnitFiles(flags dbus.Flags, files []string, runtime bool, force bool) (carriesInstallInfo bool, changes []UnitFileChange, err error) { return v.StoreEnableUnitFiles( <-v.GoEnableUnitFiles(flags, make(chan *dbus.Call, 1), files, runtime, force).Done) } // method DisableUnitFiles func (v *manager) GoDisableUnitFiles(flags dbus.Flags, ch chan *dbus.Call, files []string, runtime bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".DisableUnitFiles", flags, ch, files, runtime) } func (*manager) StoreDisableUnitFiles(call *dbus.Call) (changes []UnitFileChange, err error) { err = call.Store(&changes) return } func (v *manager) DisableUnitFiles(flags dbus.Flags, files []string, runtime bool) (changes []UnitFileChange, err error) { return v.StoreDisableUnitFiles( <-v.GoDisableUnitFiles(flags, make(chan *dbus.Call, 1), files, runtime).Done) } // method ReenableUnitFiles func (v *manager) GoReenableUnitFiles(flags dbus.Flags, ch chan *dbus.Call, files []string, runtime bool, force bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReenableUnitFiles", flags, ch, files, runtime, force) } func (*manager) StoreReenableUnitFiles(call *dbus.Call) (carriesInstallInfo bool, changes []UnitFileChange, err error) { err = call.Store(&carriesInstallInfo, &changes) return } func (v *manager) ReenableUnitFiles(flags dbus.Flags, files []string, runtime bool, force bool) (carriesInstallInfo bool, changes []UnitFileChange, err error) { return v.StoreReenableUnitFiles( <-v.GoReenableUnitFiles(flags, make(chan *dbus.Call, 1), files, runtime, force).Done) } // method LinkUnitFiles func (v *manager) GoLinkUnitFiles(flags dbus.Flags, ch chan *dbus.Call, files []string, runtime bool, force bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LinkUnitFiles", flags, ch, files, runtime, force) } func (*manager) StoreLinkUnitFiles(call *dbus.Call) (changes []UnitFileChange, err error) { err = call.Store(&changes) return } func (v *manager) LinkUnitFiles(flags dbus.Flags, files []string, runtime bool, force bool) (changes []UnitFileChange, err error) { return v.StoreLinkUnitFiles( <-v.GoLinkUnitFiles(flags, make(chan *dbus.Call, 1), files, runtime, force).Done) } // method PresetUnitFiles func (v *manager) GoPresetUnitFiles(flags dbus.Flags, ch chan *dbus.Call, files []string, runtime bool, force bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PresetUnitFiles", flags, ch, files, runtime, force) } func (*manager) StorePresetUnitFiles(call *dbus.Call) (carriesInstallInfo bool, changes []UnitFileChange, err error) { err = call.Store(&carriesInstallInfo, &changes) return } func (v *manager) PresetUnitFiles(flags dbus.Flags, files []string, runtime bool, force bool) (carriesInstallInfo bool, changes []UnitFileChange, err error) { return v.StorePresetUnitFiles( <-v.GoPresetUnitFiles(flags, make(chan *dbus.Call, 1), files, runtime, force).Done) } // method PresetUnitFilesWithMode func (v *manager) GoPresetUnitFilesWithMode(flags dbus.Flags, ch chan *dbus.Call, files []string, mode string, runtime bool, force bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PresetUnitFilesWithMode", flags, ch, files, mode, runtime, force) } func (*manager) StorePresetUnitFilesWithMode(call *dbus.Call) (carriesInstallInfo bool, changes []UnitFileChange, err error) { err = call.Store(&carriesInstallInfo, &changes) return } func (v *manager) PresetUnitFilesWithMode(flags dbus.Flags, files []string, mode string, runtime bool, force bool) (carriesInstallInfo bool, changes []UnitFileChange, err error) { return v.StorePresetUnitFilesWithMode( <-v.GoPresetUnitFilesWithMode(flags, make(chan *dbus.Call, 1), files, mode, runtime, force).Done) } // method MaskUnitFiles func (v *manager) GoMaskUnitFiles(flags dbus.Flags, ch chan *dbus.Call, files []string, runtime bool, force bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".MaskUnitFiles", flags, ch, files, runtime, force) } func (*manager) StoreMaskUnitFiles(call *dbus.Call) (changes []UnitFileChange, err error) { err = call.Store(&changes) return } func (v *manager) MaskUnitFiles(flags dbus.Flags, files []string, runtime bool, force bool) (changes []UnitFileChange, err error) { return v.StoreMaskUnitFiles( <-v.GoMaskUnitFiles(flags, make(chan *dbus.Call, 1), files, runtime, force).Done) } // method UnmaskUnitFiles func (v *manager) GoUnmaskUnitFiles(flags dbus.Flags, ch chan *dbus.Call, files []string, runtime bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UnmaskUnitFiles", flags, ch, files, runtime) } func (*manager) StoreUnmaskUnitFiles(call *dbus.Call) (changes []UnitFileChange, err error) { err = call.Store(&changes) return } func (v *manager) UnmaskUnitFiles(flags dbus.Flags, files []string, runtime bool) (changes []UnitFileChange, err error) { return v.StoreUnmaskUnitFiles( <-v.GoUnmaskUnitFiles(flags, make(chan *dbus.Call, 1), files, runtime).Done) } // method RevertUnitFiles func (v *manager) GoRevertUnitFiles(flags dbus.Flags, ch chan *dbus.Call, files []string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RevertUnitFiles", flags, ch, files) } func (*manager) StoreRevertUnitFiles(call *dbus.Call) (changes []UnitFileChange, err error) { err = call.Store(&changes) return } func (v *manager) RevertUnitFiles(flags dbus.Flags, files []string) (changes []UnitFileChange, err error) { return v.StoreRevertUnitFiles( <-v.GoRevertUnitFiles(flags, make(chan *dbus.Call, 1), files).Done) } // method SetDefaultTarget func (v *manager) GoSetDefaultTarget(flags dbus.Flags, ch chan *dbus.Call, name string, force bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetDefaultTarget", flags, ch, name, force) } func (*manager) StoreSetDefaultTarget(call *dbus.Call) (changes []UnitFileChange, err error) { err = call.Store(&changes) return } func (v *manager) SetDefaultTarget(flags dbus.Flags, name string, force bool) (changes []UnitFileChange, err error) { return v.StoreSetDefaultTarget( <-v.GoSetDefaultTarget(flags, make(chan *dbus.Call, 1), name, force).Done) } // method GetDefaultTarget func (v *manager) GoGetDefaultTarget(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDefaultTarget", flags, ch) } func (*manager) StoreGetDefaultTarget(call *dbus.Call) (name string, err error) { err = call.Store(&name) return } func (v *manager) GetDefaultTarget(flags dbus.Flags) (name string, err error) { return v.StoreGetDefaultTarget( <-v.GoGetDefaultTarget(flags, make(chan *dbus.Call, 1)).Done) } // method PresetAllUnitFiles func (v *manager) GoPresetAllUnitFiles(flags dbus.Flags, ch chan *dbus.Call, mode string, runtime bool, force bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PresetAllUnitFiles", flags, ch, mode, runtime, force) } func (*manager) StorePresetAllUnitFiles(call *dbus.Call) (changes []UnitFileChange, err error) { err = call.Store(&changes) return } func (v *manager) PresetAllUnitFiles(flags dbus.Flags, mode string, runtime bool, force bool) (changes []UnitFileChange, err error) { return v.StorePresetAllUnitFiles( <-v.GoPresetAllUnitFiles(flags, make(chan *dbus.Call, 1), mode, runtime, force).Done) } // method AddDependencyUnitFiles func (v *manager) GoAddDependencyUnitFiles(flags dbus.Flags, ch chan *dbus.Call, files []string, target string, type0 string, runtime bool, force bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddDependencyUnitFiles", flags, ch, files, target, type0, runtime, force) } func (*manager) StoreAddDependencyUnitFiles(call *dbus.Call) (changes []UnitFileChange, err error) { err = call.Store(&changes) return } func (v *manager) AddDependencyUnitFiles(flags dbus.Flags, files []string, target string, type0 string, runtime bool, force bool) (changes []UnitFileChange, err error) { return v.StoreAddDependencyUnitFiles( <-v.GoAddDependencyUnitFiles(flags, make(chan *dbus.Call, 1), files, target, type0, runtime, force).Done) } // method GetUnitFileLinks func (v *manager) GoGetUnitFileLinks(flags dbus.Flags, ch chan *dbus.Call, name string, runtime bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetUnitFileLinks", flags, ch, name, runtime) } func (*manager) StoreGetUnitFileLinks(call *dbus.Call) (links []string, err error) { err = call.Store(&links) return } func (v *manager) GetUnitFileLinks(flags dbus.Flags, name string, runtime bool) (links []string, err error) { return v.StoreGetUnitFileLinks( <-v.GoGetUnitFileLinks(flags, make(chan *dbus.Call, 1), name, runtime).Done) } // method SetExitCode func (v *manager) GoSetExitCode(flags dbus.Flags, ch chan *dbus.Call, exitCode uint8) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetExitCode", flags, ch, exitCode) } func (v *manager) SetExitCode(flags dbus.Flags, exitCode uint8) error { return (<-v.GoSetExitCode(flags, make(chan *dbus.Call, 1), exitCode).Done).Err } // method LookupDynamicUserByName func (v *manager) GoLookupDynamicUserByName(flags dbus.Flags, ch chan *dbus.Call, name string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LookupDynamicUserByName", flags, ch, name) } func (*manager) StoreLookupDynamicUserByName(call *dbus.Call) (user uint32, err error) { err = call.Store(&user) return } func (v *manager) LookupDynamicUserByName(flags dbus.Flags, name string) (user uint32, err error) { return v.StoreLookupDynamicUserByName( <-v.GoLookupDynamicUserByName(flags, make(chan *dbus.Call, 1), name).Done) } // method LookupDynamicUserByUID func (v *manager) GoLookupDynamicUserByUID(flags dbus.Flags, ch chan *dbus.Call, uid uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LookupDynamicUserByUID", flags, ch, uid) } func (*manager) StoreLookupDynamicUserByUID(call *dbus.Call) (user string, err error) { err = call.Store(&user) return } func (v *manager) LookupDynamicUserByUID(flags dbus.Flags, uid uint32) (user string, err error) { return v.StoreLookupDynamicUserByUID( <-v.GoLookupDynamicUserByUID(flags, make(chan *dbus.Call, 1), uid).Done) } // method GetDynamicUsers func (v *manager) GoGetDynamicUsers(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetDynamicUsers", flags, ch) } func (*manager) StoreGetDynamicUsers(call *dbus.Call) (users []DynamicUser, err error) { err = call.Store(&users) return } func (v *manager) GetDynamicUsers(flags dbus.Flags) (users []DynamicUser, err error) { return v.StoreGetDynamicUsers( <-v.GoGetDynamicUsers(flags, make(chan *dbus.Call, 1)).Done) } // signal UnitNew func (v *manager) ConnectUnitNew(cb func(id string, unit dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "UnitNew", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".UnitNew", } handlerFunc := func(sig *dbus.Signal) { var id string var unit dbus.ObjectPath err := dbus.Store(sig.Body, &id, &unit) if err == nil { cb(id, unit) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal UnitRemoved func (v *manager) ConnectUnitRemoved(cb func(id string, unit dbus.ObjectPath)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "UnitRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".UnitRemoved", } handlerFunc := func(sig *dbus.Signal) { var id string var unit dbus.ObjectPath err := dbus.Store(sig.Body, &id, &unit) if err == nil { cb(id, unit) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal JobNew func (v *manager) ConnectJobNew(cb func(id uint32, job dbus.ObjectPath, unit string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "JobNew", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".JobNew", } handlerFunc := func(sig *dbus.Signal) { var id uint32 var job dbus.ObjectPath var unit string err := dbus.Store(sig.Body, &id, &job, &unit) if err == nil { cb(id, job, unit) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal JobRemoved func (v *manager) ConnectJobRemoved(cb func(id uint32, job dbus.ObjectPath, unit string, result string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "JobRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".JobRemoved", } handlerFunc := func(sig *dbus.Signal) { var id uint32 var job dbus.ObjectPath var unit string var result string err := dbus.Store(sig.Body, &id, &job, &unit, &result) if err == nil { cb(id, job, unit, result) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal StartupFinished func (v *manager) ConnectStartupFinished(cb func(firmware uint64, loader uint64, kernel uint64, initrd uint64, userspace uint64, total uint64)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "StartupFinished", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".StartupFinished", } handlerFunc := func(sig *dbus.Signal) { var firmware uint64 var loader uint64 var kernel uint64 var initrd uint64 var userspace uint64 var total uint64 err := dbus.Store(sig.Body, &firmware, &loader, &kernel, &initrd, &userspace, &total) if err == nil { cb(firmware, loader, kernel, initrd, userspace, total) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal UnitFilesChanged func (v *manager) ConnectUnitFilesChanged(cb func()) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "UnitFilesChanged", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".UnitFilesChanged", } handlerFunc := func(sig *dbus.Signal) { cb() } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal Reloading func (v *manager) ConnectReloading(cb func(active bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Reloading", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Reloading", } handlerFunc := func(sig *dbus.Signal) { var active bool err := dbus.Store(sig.Body, &active) if err == nil { cb(active) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property Version s func (v *manager) Version() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Version", } } // property Features s func (v *manager) Features() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Features", } } // property Virtualization s func (v *manager) Virtualization() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Virtualization", } } // property Architecture s func (v *manager) Architecture() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Architecture", } } // property Tainted s func (v *manager) Tainted() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Tainted", } } // property FirmwareTimestamp t func (v *manager) FirmwareTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "FirmwareTimestamp", } } // property FirmwareTimestampMonotonic t func (v *manager) FirmwareTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "FirmwareTimestampMonotonic", } } // property LoaderTimestamp t func (v *manager) LoaderTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LoaderTimestamp", } } // property LoaderTimestampMonotonic t func (v *manager) LoaderTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LoaderTimestampMonotonic", } } // property KernelTimestamp t func (v *manager) KernelTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "KernelTimestamp", } } // property KernelTimestampMonotonic t func (v *manager) KernelTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "KernelTimestampMonotonic", } } // property InitRDTimestamp t func (v *manager) InitRDTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDTimestamp", } } // property InitRDTimestampMonotonic t func (v *manager) InitRDTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDTimestampMonotonic", } } // property UserspaceTimestamp t func (v *manager) UserspaceTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "UserspaceTimestamp", } } // property UserspaceTimestampMonotonic t func (v *manager) UserspaceTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "UserspaceTimestampMonotonic", } } // property FinishTimestamp t func (v *manager) FinishTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "FinishTimestamp", } } // property FinishTimestampMonotonic t func (v *manager) FinishTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "FinishTimestampMonotonic", } } // property SecurityStartTimestamp t func (v *manager) SecurityStartTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "SecurityStartTimestamp", } } // property SecurityStartTimestampMonotonic t func (v *manager) SecurityStartTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "SecurityStartTimestampMonotonic", } } // property SecurityFinishTimestamp t func (v *manager) SecurityFinishTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "SecurityFinishTimestamp", } } // property SecurityFinishTimestampMonotonic t func (v *manager) SecurityFinishTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "SecurityFinishTimestampMonotonic", } } // property GeneratorsStartTimestamp t func (v *manager) GeneratorsStartTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "GeneratorsStartTimestamp", } } // property GeneratorsStartTimestampMonotonic t func (v *manager) GeneratorsStartTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "GeneratorsStartTimestampMonotonic", } } // property GeneratorsFinishTimestamp t func (v *manager) GeneratorsFinishTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "GeneratorsFinishTimestamp", } } // property GeneratorsFinishTimestampMonotonic t func (v *manager) GeneratorsFinishTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "GeneratorsFinishTimestampMonotonic", } } // property UnitsLoadStartTimestamp t func (v *manager) UnitsLoadStartTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "UnitsLoadStartTimestamp", } } // property UnitsLoadStartTimestampMonotonic t func (v *manager) UnitsLoadStartTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "UnitsLoadStartTimestampMonotonic", } } // property UnitsLoadFinishTimestamp t func (v *manager) UnitsLoadFinishTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "UnitsLoadFinishTimestamp", } } // property UnitsLoadFinishTimestampMonotonic t func (v *manager) UnitsLoadFinishTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "UnitsLoadFinishTimestampMonotonic", } } // property InitRDSecurityStartTimestamp t func (v *manager) InitRDSecurityStartTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDSecurityStartTimestamp", } } // property InitRDSecurityStartTimestampMonotonic t func (v *manager) InitRDSecurityStartTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDSecurityStartTimestampMonotonic", } } // property InitRDSecurityFinishTimestamp t func (v *manager) InitRDSecurityFinishTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDSecurityFinishTimestamp", } } // property InitRDSecurityFinishTimestampMonotonic t func (v *manager) InitRDSecurityFinishTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDSecurityFinishTimestampMonotonic", } } // property InitRDGeneratorsStartTimestamp t func (v *manager) InitRDGeneratorsStartTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDGeneratorsStartTimestamp", } } // property InitRDGeneratorsStartTimestampMonotonic t func (v *manager) InitRDGeneratorsStartTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDGeneratorsStartTimestampMonotonic", } } // property InitRDGeneratorsFinishTimestamp t func (v *manager) InitRDGeneratorsFinishTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDGeneratorsFinishTimestamp", } } // property InitRDGeneratorsFinishTimestampMonotonic t func (v *manager) InitRDGeneratorsFinishTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDGeneratorsFinishTimestampMonotonic", } } // property InitRDUnitsLoadStartTimestamp t func (v *manager) InitRDUnitsLoadStartTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDUnitsLoadStartTimestamp", } } // property InitRDUnitsLoadStartTimestampMonotonic t func (v *manager) InitRDUnitsLoadStartTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDUnitsLoadStartTimestampMonotonic", } } // property InitRDUnitsLoadFinishTimestamp t func (v *manager) InitRDUnitsLoadFinishTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDUnitsLoadFinishTimestamp", } } // property InitRDUnitsLoadFinishTimestampMonotonic t func (v *manager) InitRDUnitsLoadFinishTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InitRDUnitsLoadFinishTimestampMonotonic", } } // property LogLevel s func (v *manager) LogLevel() proxy.PropString { return proxy.PropString{ Impl: v, Name: "LogLevel", } } // property LogTarget s func (v *manager) LogTarget() proxy.PropString { return proxy.PropString{ Impl: v, Name: "LogTarget", } } // property NNames u func (v *manager) NNames() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "NNames", } } // property NFailedUnits u func (v *manager) NFailedUnits() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "NFailedUnits", } } // property NJobs u func (v *manager) NJobs() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "NJobs", } } // property NInstalledJobs u func (v *manager) NInstalledJobs() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "NInstalledJobs", } } // property NFailedJobs u func (v *manager) NFailedJobs() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "NFailedJobs", } } // property Progress d func (v *manager) Progress() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Progress", } } // property Environment as func (v *manager) Environment() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Environment", } } // property ConfirmSpawn b func (v *manager) ConfirmSpawn() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ConfirmSpawn", } } // property ShowStatus b func (v *manager) ShowStatus() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ShowStatus", } } // property UnitPath as func (v *manager) UnitPath() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "UnitPath", } } // property DefaultStandardOutput s func (v *manager) DefaultStandardOutput() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DefaultStandardOutput", } } // property DefaultStandardError s func (v *manager) DefaultStandardError() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DefaultStandardError", } } // property RuntimeWatchdogUSec t func (v *manager) RuntimeWatchdogUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "RuntimeWatchdogUSec", } } // property ShutdownWatchdogUSec t func (v *manager) ShutdownWatchdogUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "ShutdownWatchdogUSec", } } // property ServiceWatchdogs b func (v *manager) ServiceWatchdogs() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ServiceWatchdogs", } } // property ControlGroup s func (v *manager) ControlGroup() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ControlGroup", } } // property SystemState s func (v *manager) SystemState() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SystemState", } } // property ExitCode y func (v *manager) ExitCode() proxy.PropByte { return proxy.PropByte{ Impl: v, Name: "ExitCode", } } // property DefaultTimerAccuracyUSec t func (v *manager) DefaultTimerAccuracyUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultTimerAccuracyUSec", } } // property DefaultTimeoutStartUSec t func (v *manager) DefaultTimeoutStartUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultTimeoutStartUSec", } } // property DefaultTimeoutStopUSec t func (v *manager) DefaultTimeoutStopUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultTimeoutStopUSec", } } // property DefaultRestartUSec t func (v *manager) DefaultRestartUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultRestartUSec", } } // property DefaultStartLimitIntervalUSec t func (v *manager) DefaultStartLimitIntervalUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultStartLimitIntervalUSec", } } // property DefaultStartLimitBurst u func (v *manager) DefaultStartLimitBurst() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "DefaultStartLimitBurst", } } // property DefaultCPUAccounting b func (v *manager) DefaultCPUAccounting() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "DefaultCPUAccounting", } } // property DefaultBlockIOAccounting b func (v *manager) DefaultBlockIOAccounting() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "DefaultBlockIOAccounting", } } // property DefaultMemoryAccounting b func (v *manager) DefaultMemoryAccounting() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "DefaultMemoryAccounting", } } // property DefaultTasksAccounting b func (v *manager) DefaultTasksAccounting() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "DefaultTasksAccounting", } } // property DefaultLimitCPU t func (v *manager) DefaultLimitCPU() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitCPU", } } // property DefaultLimitCPUSoft t func (v *manager) DefaultLimitCPUSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitCPUSoft", } } // property DefaultLimitFSIZE t func (v *manager) DefaultLimitFSIZE() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitFSIZE", } } // property DefaultLimitFSIZESoft t func (v *manager) DefaultLimitFSIZESoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitFSIZESoft", } } // property DefaultLimitDATA t func (v *manager) DefaultLimitDATA() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitDATA", } } // property DefaultLimitDATASoft t func (v *manager) DefaultLimitDATASoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitDATASoft", } } // property DefaultLimitSTACK t func (v *manager) DefaultLimitSTACK() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitSTACK", } } // property DefaultLimitSTACKSoft t func (v *manager) DefaultLimitSTACKSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitSTACKSoft", } } // property DefaultLimitCORE t func (v *manager) DefaultLimitCORE() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitCORE", } } // property DefaultLimitCORESoft t func (v *manager) DefaultLimitCORESoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitCORESoft", } } // property DefaultLimitRSS t func (v *manager) DefaultLimitRSS() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitRSS", } } // property DefaultLimitRSSSoft t func (v *manager) DefaultLimitRSSSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitRSSSoft", } } // property DefaultLimitNOFILE t func (v *manager) DefaultLimitNOFILE() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitNOFILE", } } // property DefaultLimitNOFILESoft t func (v *manager) DefaultLimitNOFILESoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitNOFILESoft", } } // property DefaultLimitAS t func (v *manager) DefaultLimitAS() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitAS", } } // property DefaultLimitASSoft t func (v *manager) DefaultLimitASSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitASSoft", } } // property DefaultLimitNPROC t func (v *manager) DefaultLimitNPROC() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitNPROC", } } // property DefaultLimitNPROCSoft t func (v *manager) DefaultLimitNPROCSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitNPROCSoft", } } // property DefaultLimitMEMLOCK t func (v *manager) DefaultLimitMEMLOCK() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitMEMLOCK", } } // property DefaultLimitMEMLOCKSoft t func (v *manager) DefaultLimitMEMLOCKSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitMEMLOCKSoft", } } // property DefaultLimitLOCKS t func (v *manager) DefaultLimitLOCKS() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitLOCKS", } } // property DefaultLimitLOCKSSoft t func (v *manager) DefaultLimitLOCKSSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitLOCKSSoft", } } // property DefaultLimitSIGPENDING t func (v *manager) DefaultLimitSIGPENDING() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitSIGPENDING", } } // property DefaultLimitSIGPENDINGSoft t func (v *manager) DefaultLimitSIGPENDINGSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitSIGPENDINGSoft", } } // property DefaultLimitMSGQUEUE t func (v *manager) DefaultLimitMSGQUEUE() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitMSGQUEUE", } } // property DefaultLimitMSGQUEUESoft t func (v *manager) DefaultLimitMSGQUEUESoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitMSGQUEUESoft", } } // property DefaultLimitNICE t func (v *manager) DefaultLimitNICE() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitNICE", } } // property DefaultLimitNICESoft t func (v *manager) DefaultLimitNICESoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitNICESoft", } } // property DefaultLimitRTPRIO t func (v *manager) DefaultLimitRTPRIO() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitRTPRIO", } } // property DefaultLimitRTPRIOSoft t func (v *manager) DefaultLimitRTPRIOSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitRTPRIOSoft", } } // property DefaultLimitRTTIME t func (v *manager) DefaultLimitRTTIME() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitRTTIME", } } // property DefaultLimitRTTIMESoft t func (v *manager) DefaultLimitRTTIMESoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultLimitRTTIMESoft", } } // property DefaultTasksMax t func (v *manager) DefaultTasksMax() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DefaultTasksMax", } } // property TimerSlackNSec t func (v *manager) TimerSlackNSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TimerSlackNSec", } } type Unit struct { unit // interface org.freedesktop.systemd1.Unit service // interface org.freedesktop.systemd1.Service proxy.Object } func NewUnit(conn *dbus.Conn, path dbus.ObjectPath) (*Unit, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Unit) obj.Object.Init_(conn, "org.freedesktop.systemd1", path) return obj, nil } func (obj *Unit) Unit() *unit { return &obj.unit } type unit struct{} func (v *unit) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*unit) GetInterfaceName_() string { return "org.freedesktop.systemd1.Unit" } // method Start func (v *unit) GoStart(flags dbus.Flags, ch chan *dbus.Call, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Start", flags, ch, mode) } func (*unit) StoreStart(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *unit) Start(flags dbus.Flags, mode string) (job dbus.ObjectPath, err error) { return v.StoreStart( <-v.GoStart(flags, make(chan *dbus.Call, 1), mode).Done) } // method Stop func (v *unit) GoStop(flags dbus.Flags, ch chan *dbus.Call, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Stop", flags, ch, mode) } func (*unit) StoreStop(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *unit) Stop(flags dbus.Flags, mode string) (job dbus.ObjectPath, err error) { return v.StoreStop( <-v.GoStop(flags, make(chan *dbus.Call, 1), mode).Done) } // method Reload func (v *unit) GoReload(flags dbus.Flags, ch chan *dbus.Call, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Reload", flags, ch, mode) } func (*unit) StoreReload(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *unit) Reload(flags dbus.Flags, mode string) (job dbus.ObjectPath, err error) { return v.StoreReload( <-v.GoReload(flags, make(chan *dbus.Call, 1), mode).Done) } // method Restart func (v *unit) GoRestart(flags dbus.Flags, ch chan *dbus.Call, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Restart", flags, ch, mode) } func (*unit) StoreRestart(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *unit) Restart(flags dbus.Flags, mode string) (job dbus.ObjectPath, err error) { return v.StoreRestart( <-v.GoRestart(flags, make(chan *dbus.Call, 1), mode).Done) } // method TryRestart func (v *unit) GoTryRestart(flags dbus.Flags, ch chan *dbus.Call, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".TryRestart", flags, ch, mode) } func (*unit) StoreTryRestart(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *unit) TryRestart(flags dbus.Flags, mode string) (job dbus.ObjectPath, err error) { return v.StoreTryRestart( <-v.GoTryRestart(flags, make(chan *dbus.Call, 1), mode).Done) } // method ReloadOrRestart func (v *unit) GoReloadOrRestart(flags dbus.Flags, ch chan *dbus.Call, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReloadOrRestart", flags, ch, mode) } func (*unit) StoreReloadOrRestart(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *unit) ReloadOrRestart(flags dbus.Flags, mode string) (job dbus.ObjectPath, err error) { return v.StoreReloadOrRestart( <-v.GoReloadOrRestart(flags, make(chan *dbus.Call, 1), mode).Done) } // method ReloadOrTryRestart func (v *unit) GoReloadOrTryRestart(flags dbus.Flags, ch chan *dbus.Call, mode string) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ReloadOrTryRestart", flags, ch, mode) } func (*unit) StoreReloadOrTryRestart(call *dbus.Call) (job dbus.ObjectPath, err error) { err = call.Store(&job) return } func (v *unit) ReloadOrTryRestart(flags dbus.Flags, mode string) (job dbus.ObjectPath, err error) { return v.StoreReloadOrTryRestart( <-v.GoReloadOrTryRestart(flags, make(chan *dbus.Call, 1), mode).Done) } // method Kill func (v *unit) GoKill(flags dbus.Flags, ch chan *dbus.Call, who string, signal int32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Kill", flags, ch, who, signal) } func (v *unit) Kill(flags dbus.Flags, who string, signal int32) error { return (<-v.GoKill(flags, make(chan *dbus.Call, 1), who, signal).Done).Err } // method ResetFailed func (v *unit) GoResetFailed(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".ResetFailed", flags, ch) } func (v *unit) ResetFailed(flags dbus.Flags) error { return (<-v.GoResetFailed(flags, make(chan *dbus.Call, 1)).Done).Err } // method SetProperties func (v *unit) GoSetProperties(flags dbus.Flags, ch chan *dbus.Call, runtime bool, properties []Property) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetProperties", flags, ch, runtime, properties) } func (v *unit) SetProperties(flags dbus.Flags, runtime bool, properties []Property) error { return (<-v.GoSetProperties(flags, make(chan *dbus.Call, 1), runtime, properties).Done).Err } // method Ref func (v *unit) GoRef(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Ref", flags, ch) } func (v *unit) Ref(flags dbus.Flags) error { return (<-v.GoRef(flags, make(chan *dbus.Call, 1)).Done).Err } // method Unref func (v *unit) GoUnref(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Unref", flags, ch) } func (v *unit) Unref(flags dbus.Flags) error { return (<-v.GoUnref(flags, make(chan *dbus.Call, 1)).Done).Err } // property Id s func (v *unit) Id() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Id", } } // property Names as func (v *unit) Names() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Names", } } // property Following s func (v *unit) Following() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Following", } } // property Requires as func (v *unit) Requires() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Requires", } } // property Requisite as func (v *unit) Requisite() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Requisite", } } // property Wants as func (v *unit) Wants() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Wants", } } // property BindsTo as func (v *unit) BindsTo() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "BindsTo", } } // property PartOf as func (v *unit) PartOf() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "PartOf", } } // property RequiredBy as func (v *unit) RequiredBy() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "RequiredBy", } } // property RequisiteOf as func (v *unit) RequisiteOf() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "RequisiteOf", } } // property WantedBy as func (v *unit) WantedBy() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "WantedBy", } } // property BoundBy as func (v *unit) BoundBy() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "BoundBy", } } // property ConsistsOf as func (v *unit) ConsistsOf() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "ConsistsOf", } } // property Conflicts as func (v *unit) Conflicts() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Conflicts", } } // property ConflictedBy as func (v *unit) ConflictedBy() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "ConflictedBy", } } // property Before as func (v *unit) Before() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Before", } } // property After as func (v *unit) After() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "After", } } // property OnFailure as func (v *unit) OnFailure() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "OnFailure", } } // property Triggers as func (v *unit) Triggers() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Triggers", } } // property TriggeredBy as func (v *unit) TriggeredBy() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "TriggeredBy", } } // property PropagatesReloadTo as func (v *unit) PropagatesReloadTo() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "PropagatesReloadTo", } } // property ReloadPropagatedFrom as func (v *unit) ReloadPropagatedFrom() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "ReloadPropagatedFrom", } } // property JoinsNamespaceOf as func (v *unit) JoinsNamespaceOf() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "JoinsNamespaceOf", } } // property RequiresMountsFor as func (v *unit) RequiresMountsFor() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "RequiresMountsFor", } } // property Documentation as func (v *unit) Documentation() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Documentation", } } // property Description s func (v *unit) Description() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Description", } } // property LoadState s func (v *unit) LoadState() proxy.PropString { return proxy.PropString{ Impl: v, Name: "LoadState", } } // property ActiveState s func (v *unit) ActiveState() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ActiveState", } } // property SubState s func (v *unit) SubState() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SubState", } } // property FragmentPath s func (v *unit) FragmentPath() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FragmentPath", } } // property SourcePath s func (v *unit) SourcePath() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SourcePath", } } // property DropInPaths as func (v *unit) DropInPaths() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "DropInPaths", } } // property UnitFileState s func (v *unit) UnitFileState() proxy.PropString { return proxy.PropString{ Impl: v, Name: "UnitFileState", } } // property UnitFilePreset s func (v *unit) UnitFilePreset() proxy.PropString { return proxy.PropString{ Impl: v, Name: "UnitFilePreset", } } // property StateChangeTimestamp t func (v *unit) StateChangeTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "StateChangeTimestamp", } } // property StateChangeTimestampMonotonic t func (v *unit) StateChangeTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "StateChangeTimestampMonotonic", } } // property InactiveExitTimestamp t func (v *unit) InactiveExitTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InactiveExitTimestamp", } } // property InactiveExitTimestampMonotonic t func (v *unit) InactiveExitTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InactiveExitTimestampMonotonic", } } // property ActiveEnterTimestamp t func (v *unit) ActiveEnterTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "ActiveEnterTimestamp", } } // property ActiveEnterTimestampMonotonic t func (v *unit) ActiveEnterTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "ActiveEnterTimestampMonotonic", } } // property ActiveExitTimestamp t func (v *unit) ActiveExitTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "ActiveExitTimestamp", } } // property ActiveExitTimestampMonotonic t func (v *unit) ActiveExitTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "ActiveExitTimestampMonotonic", } } // property InactiveEnterTimestamp t func (v *unit) InactiveEnterTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InactiveEnterTimestamp", } } // property InactiveEnterTimestampMonotonic t func (v *unit) InactiveEnterTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "InactiveEnterTimestampMonotonic", } } // property CanStart b func (v *unit) CanStart() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanStart", } } // property CanStop b func (v *unit) CanStop() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanStop", } } // property CanReload b func (v *unit) CanReload() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanReload", } } // property CanIsolate b func (v *unit) CanIsolate() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanIsolate", } } // property Job (uo) func (v *unit) Job() PropUnitJob { return PropUnitJob{ Impl: v, } } type PropUnitJob struct { Impl proxy.Implementer } func (p PropUnitJob) Get(flags dbus.Flags) (value JobIdPath, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Job", &value) return } func (p PropUnitJob) ConnectChanged(cb func(hasValue bool, value JobIdPath)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v JobIdPath err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, JobIdPath{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Job", cb0) } // property StopWhenUnneeded b func (v *unit) StopWhenUnneeded() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "StopWhenUnneeded", } } // property RefuseManualStart b func (v *unit) RefuseManualStart() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "RefuseManualStart", } } // property RefuseManualStop b func (v *unit) RefuseManualStop() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "RefuseManualStop", } } // property AllowIsolate b func (v *unit) AllowIsolate() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "AllowIsolate", } } // property DefaultDependencies b func (v *unit) DefaultDependencies() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "DefaultDependencies", } } // property OnFailureJobMode s func (v *unit) OnFailureJobMode() proxy.PropString { return proxy.PropString{ Impl: v, Name: "OnFailureJobMode", } } // property IgnoreOnIsolate b func (v *unit) IgnoreOnIsolate() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IgnoreOnIsolate", } } // property NeedDaemonReload b func (v *unit) NeedDaemonReload() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "NeedDaemonReload", } } // property JobTimeoutUSec t func (v *unit) JobTimeoutUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "JobTimeoutUSec", } } // property JobRunningTimeoutUSec t func (v *unit) JobRunningTimeoutUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "JobRunningTimeoutUSec", } } // property JobTimeoutAction s func (v *unit) JobTimeoutAction() proxy.PropString { return proxy.PropString{ Impl: v, Name: "JobTimeoutAction", } } // property JobTimeoutRebootArgument s func (v *unit) JobTimeoutRebootArgument() proxy.PropString { return proxy.PropString{ Impl: v, Name: "JobTimeoutRebootArgument", } } // property ConditionResult b func (v *unit) ConditionResult() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ConditionResult", } } // property AssertResult b func (v *unit) AssertResult() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "AssertResult", } } // property ConditionTimestamp t func (v *unit) ConditionTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "ConditionTimestamp", } } // property ConditionTimestampMonotonic t func (v *unit) ConditionTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "ConditionTimestampMonotonic", } } // property AssertTimestamp t func (v *unit) AssertTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "AssertTimestamp", } } // property AssertTimestampMonotonic t func (v *unit) AssertTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "AssertTimestampMonotonic", } } // property Conditions a(sbbsi) func (v *unit) Conditions() PropUnitConditions { return PropUnitConditions{ Impl: v, } } type PropUnitConditions struct { Impl proxy.Implementer } func (p PropUnitConditions) Get(flags dbus.Flags) (value []Condition, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Conditions", &value) return } func (p PropUnitConditions) ConnectChanged(cb func(hasValue bool, value []Condition)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []Condition err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Conditions", cb0) } // property Asserts a(sbbsi) func (v *unit) Asserts() PropUnitAsserts { return PropUnitAsserts{ Impl: v, } } type PropUnitAsserts struct { Impl proxy.Implementer } func (p PropUnitAsserts) Get(flags dbus.Flags) (value []Assert, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Asserts", &value) return } func (p PropUnitAsserts) ConnectChanged(cb func(hasValue bool, value []Assert)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []Assert err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Asserts", cb0) } // property LoadError (ss) func (v *unit) LoadError() PropUnitLoadError { return PropUnitLoadError{ Impl: v, } } type PropUnitLoadError struct { Impl proxy.Implementer } func (p PropUnitLoadError) Get(flags dbus.Flags) (value LoadError, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "LoadError", &value) return } func (p PropUnitLoadError) ConnectChanged(cb func(hasValue bool, value LoadError)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v LoadError err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, LoadError{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "LoadError", cb0) } // property Transient b func (v *unit) Transient() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Transient", } } // property Perpetual b func (v *unit) Perpetual() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Perpetual", } } // property StartLimitIntervalUSec t func (v *unit) StartLimitIntervalUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "StartLimitIntervalUSec", } } // property StartLimitBurst u func (v *unit) StartLimitBurst() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "StartLimitBurst", } } // property StartLimitAction s func (v *unit) StartLimitAction() proxy.PropString { return proxy.PropString{ Impl: v, Name: "StartLimitAction", } } // property FailureAction s func (v *unit) FailureAction() proxy.PropString { return proxy.PropString{ Impl: v, Name: "FailureAction", } } // property FailureActionExitStatus i func (v *unit) FailureActionExitStatus() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "FailureActionExitStatus", } } // property SuccessAction s func (v *unit) SuccessAction() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SuccessAction", } } // property SuccessActionExitStatus i func (v *unit) SuccessActionExitStatus() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "SuccessActionExitStatus", } } // property RebootArgument s func (v *unit) RebootArgument() proxy.PropString { return proxy.PropString{ Impl: v, Name: "RebootArgument", } } // property InvocationID ay func (v *unit) InvocationID() proxy.PropByteArray { return proxy.PropByteArray{ Impl: v, Name: "InvocationID", } } // property CollectMode s func (v *unit) CollectMode() proxy.PropString { return proxy.PropString{ Impl: v, Name: "CollectMode", } } // property Refs as func (v *unit) Refs() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Refs", } } func (obj *Unit) Service() *service { return &obj.service } type service struct{} func (v *service) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*service) GetInterfaceName_() string { return "org.freedesktop.systemd1.Service" } // method GetProcesses func (v *service) GoGetProcesses(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetProcesses", flags, ch) } func (*service) StoreGetProcesses(call *dbus.Call) (processes []UnitProcess, err error) { err = call.Store(&processes) return } func (v *service) GetProcesses(flags dbus.Flags) (processes []UnitProcess, err error) { return v.StoreGetProcesses( <-v.GoGetProcesses(flags, make(chan *dbus.Call, 1)).Done) } // method AttachProcesses func (v *service) GoAttachProcesses(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 []uint32) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AttachProcesses", flags, ch, arg0, arg1) } func (v *service) AttachProcesses(flags dbus.Flags, arg0 string, arg1 []uint32) error { return (<-v.GoAttachProcesses(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // property Type s func (v *service) Type() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Type", } } // property Restart s func (v *service) Restart() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Restart", } } // property PIDFile s func (v *service) PIDFile() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PIDFile", } } // property NotifyAccess s func (v *service) NotifyAccess() proxy.PropString { return proxy.PropString{ Impl: v, Name: "NotifyAccess", } } // property RestartUSec t func (v *service) RestartUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "RestartUSec", } } // property TimeoutStartUSec t func (v *service) TimeoutStartUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TimeoutStartUSec", } } // property TimeoutStopUSec t func (v *service) TimeoutStopUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TimeoutStopUSec", } } // property RuntimeMaxUSec t func (v *service) RuntimeMaxUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "RuntimeMaxUSec", } } // property WatchdogUSec t func (v *service) WatchdogUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "WatchdogUSec", } } // property WatchdogTimestamp t func (v *service) WatchdogTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "WatchdogTimestamp", } } // property WatchdogTimestampMonotonic t func (v *service) WatchdogTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "WatchdogTimestampMonotonic", } } // property RootDirectoryStartOnly b func (v *service) RootDirectoryStartOnly() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "RootDirectoryStartOnly", } } // property RemainAfterExit b func (v *service) RemainAfterExit() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "RemainAfterExit", } } // property GuessMainPID b func (v *service) GuessMainPID() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "GuessMainPID", } } // property RestartPreventExitStatus (aiai) func (v *service) RestartPreventExitStatus() PropExitStatus { return PropExitStatus{ Impl: v, Name: "RestartPreventExitStatus", } } // property RestartForceExitStatus (aiai) func (v *service) RestartForceExitStatus() PropExitStatus { return PropExitStatus{ Impl: v, Name: "RestartForceExitStatus", } } // property SuccessExitStatus (aiai) func (v *service) SuccessExitStatus() PropExitStatus { return PropExitStatus{ Impl: v, Name: "SuccessExitStatus", } } // property MainPID u func (v *service) MainPID() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "MainPID", } } // property ControlPID u func (v *service) ControlPID() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "ControlPID", } } // property BusName s func (v *service) BusName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "BusName", } } // property FileDescriptorStoreMax u func (v *service) FileDescriptorStoreMax() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "FileDescriptorStoreMax", } } // property NFileDescriptorStore u func (v *service) NFileDescriptorStore() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "NFileDescriptorStore", } } // property StatusText s func (v *service) StatusText() proxy.PropString { return proxy.PropString{ Impl: v, Name: "StatusText", } } // property StatusErrno i func (v *service) StatusErrno() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "StatusErrno", } } // property Result s func (v *service) Result() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Result", } } // property USBFunctionDescriptors s func (v *service) USBFunctionDescriptors() proxy.PropString { return proxy.PropString{ Impl: v, Name: "USBFunctionDescriptors", } } // property USBFunctionStrings s func (v *service) USBFunctionStrings() proxy.PropString { return proxy.PropString{ Impl: v, Name: "USBFunctionStrings", } } // property UID u func (v *service) UID() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "UID", } } // property GID u func (v *service) GID() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "GID", } } // property NRestarts u func (v *service) NRestarts() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "NRestarts", } } // property ExecMainStartTimestamp t func (v *service) ExecMainStartTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "ExecMainStartTimestamp", } } // property ExecMainStartTimestampMonotonic t func (v *service) ExecMainStartTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "ExecMainStartTimestampMonotonic", } } // property ExecMainExitTimestamp t func (v *service) ExecMainExitTimestamp() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "ExecMainExitTimestamp", } } // property ExecMainExitTimestampMonotonic t func (v *service) ExecMainExitTimestampMonotonic() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "ExecMainExitTimestampMonotonic", } } // property ExecMainPID u func (v *service) ExecMainPID() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "ExecMainPID", } } // property ExecMainCode i func (v *service) ExecMainCode() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "ExecMainCode", } } // property ExecMainStatus i func (v *service) ExecMainStatus() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "ExecMainStatus", } } // property ExecStartPre a(sasbttttuii) func (v *service) ExecStartPre() PropExecInfos { return PropExecInfos{ Impl: v, Name: "ExecStartPre", } } // property ExecStart a(sasbttttuii) func (v *service) ExecStart() PropExecInfos { return PropExecInfos{ Impl: v, Name: "ExecStart", } } // property ExecStartPost a(sasbttttuii) func (v *service) ExecStartPost() PropExecInfos { return PropExecInfos{ Impl: v, Name: "ExecStartPost", } } // property ExecReload a(sasbttttuii) func (v *service) ExecReload() PropExecInfos { return PropExecInfos{ Impl: v, Name: "ExecReload", } } // property ExecStop a(sasbttttuii) func (v *service) ExecStop() PropExecInfos { return PropExecInfos{ Impl: v, Name: "ExecStop", } } // property ExecStopPost a(sasbttttuii) func (v *service) ExecStopPost() PropExecInfos { return PropExecInfos{ Impl: v, Name: "ExecStopPost", } } // property Slice s func (v *service) Slice() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Slice", } } // property ControlGroup s func (v *service) ControlGroup() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ControlGroup", } } // property MemoryCurrent t func (v *service) MemoryCurrent() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "MemoryCurrent", } } // property CPUUsageNSec t func (v *service) CPUUsageNSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "CPUUsageNSec", } } // property TasksCurrent t func (v *service) TasksCurrent() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TasksCurrent", } } // property IPIngressBytes t func (v *service) IPIngressBytes() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IPIngressBytes", } } // property IPIngressPackets t func (v *service) IPIngressPackets() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IPIngressPackets", } } // property IPEgressBytes t func (v *service) IPEgressBytes() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IPEgressBytes", } } // property IPEgressPackets t func (v *service) IPEgressPackets() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IPEgressPackets", } } // property Delegate b func (v *service) Delegate() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Delegate", } } // property DelegateControllers as func (v *service) DelegateControllers() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "DelegateControllers", } } // property CPUAccounting b func (v *service) CPUAccounting() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CPUAccounting", } } // property CPUWeight t func (v *service) CPUWeight() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "CPUWeight", } } // property StartupCPUWeight t func (v *service) StartupCPUWeight() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "StartupCPUWeight", } } // property CPUShares t func (v *service) CPUShares() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "CPUShares", } } // property StartupCPUShares t func (v *service) StartupCPUShares() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "StartupCPUShares", } } // property CPUQuotaPerSecUSec t func (v *service) CPUQuotaPerSecUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "CPUQuotaPerSecUSec", } } // property IOAccounting b func (v *service) IOAccounting() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IOAccounting", } } // property IOWeight t func (v *service) IOWeight() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "IOWeight", } } // property StartupIOWeight t func (v *service) StartupIOWeight() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "StartupIOWeight", } } // property IODeviceWeight a(st) func (v *service) IODeviceWeight() PropIOParams { return PropIOParams{ Impl: v, Name: "IODeviceWeight", } } // property IOReadBandwidthMax a(st) func (v *service) IOReadBandwidthMax() PropIOParams { return PropIOParams{ Impl: v, Name: "IOReadBandwidthMax", } } // property IOWriteBandwidthMax a(st) func (v *service) IOWriteBandwidthMax() PropIOParams { return PropIOParams{ Impl: v, Name: "IOWriteBandwidthMax", } } // property IOReadIOPSMax a(st) func (v *service) IOReadIOPSMax() PropIOParams { return PropIOParams{ Impl: v, Name: "IOReadIOPSMax", } } // property IOWriteIOPSMax a(st) func (v *service) IOWriteIOPSMax() PropIOParams { return PropIOParams{ Impl: v, Name: "IOWriteIOPSMax", } } // property IODeviceLatencyTargetUSec a(st) func (v *service) IODeviceLatencyTargetUSec() PropIOParams { return PropIOParams{ Impl: v, Name: "IODeviceLatencyTargetUSec", } } // property BlockIOAccounting b func (v *service) BlockIOAccounting() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "BlockIOAccounting", } } // property BlockIOWeight t func (v *service) BlockIOWeight() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "BlockIOWeight", } } // property StartupBlockIOWeight t func (v *service) StartupBlockIOWeight() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "StartupBlockIOWeight", } } // property BlockIODeviceWeight a(st) func (v *service) BlockIODeviceWeight() PropIOParams { return PropIOParams{ Impl: v, Name: "BlockIODeviceWeight", } } // property BlockIOReadBandwidth a(st) func (v *service) BlockIOReadBandwidth() PropIOParams { return PropIOParams{ Impl: v, Name: "BlockIOReadBandwidth", } } // property BlockIOWriteBandwidth a(st) func (v *service) BlockIOWriteBandwidth() PropIOParams { return PropIOParams{ Impl: v, Name: "BlockIOWriteBandwidth", } } // property MemoryAccounting b func (v *service) MemoryAccounting() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "MemoryAccounting", } } // property MemoryMin t func (v *service) MemoryMin() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "MemoryMin", } } // property MemoryLow t func (v *service) MemoryLow() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "MemoryLow", } } // property MemoryHigh t func (v *service) MemoryHigh() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "MemoryHigh", } } // property MemoryMax t func (v *service) MemoryMax() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "MemoryMax", } } // property MemorySwapMax t func (v *service) MemorySwapMax() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "MemorySwapMax", } } // property MemoryLimit t func (v *service) MemoryLimit() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "MemoryLimit", } } // property DevicePolicy s func (v *service) DevicePolicy() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DevicePolicy", } } // property DeviceAllow a(ss) func (v *service) DeviceAllow() PropServiceDeviceAllow { return PropServiceDeviceAllow{ Impl: v, } } type PropServiceDeviceAllow struct { Impl proxy.Implementer } func (p PropServiceDeviceAllow) Get(flags dbus.Flags) (value []DeviceAllowItem, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "DeviceAllow", &value) return } func (p PropServiceDeviceAllow) ConnectChanged(cb func(hasValue bool, value []DeviceAllowItem)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []DeviceAllowItem err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "DeviceAllow", cb0) } // property TasksAccounting b func (v *service) TasksAccounting() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "TasksAccounting", } } // property TasksMax t func (v *service) TasksMax() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TasksMax", } } // property IPAccounting b func (v *service) IPAccounting() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IPAccounting", } } // property IPAddressAllow a(iayu) func (v *service) IPAddressAllow() PropServiceIPAddressAllow { return PropServiceIPAddressAllow{ Impl: v, } } type PropServiceIPAddressAllow struct { Impl proxy.Implementer } func (p PropServiceIPAddressAllow) Get(flags dbus.Flags) (value []IPAddressAllowItem, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "IPAddressAllow", &value) return } func (p PropServiceIPAddressAllow) ConnectChanged(cb func(hasValue bool, value []IPAddressAllowItem)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []IPAddressAllowItem err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "IPAddressAllow", cb0) } // property IPAddressDeny a(iayu) func (v *service) IPAddressDeny() PropServiceIPAddressDeny { return PropServiceIPAddressDeny{ Impl: v, } } type PropServiceIPAddressDeny struct { Impl proxy.Implementer } func (p PropServiceIPAddressDeny) Get(flags dbus.Flags) (value []IPAddressDenyItem, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "IPAddressDeny", &value) return } func (p PropServiceIPAddressDeny) ConnectChanged(cb func(hasValue bool, value []IPAddressDenyItem)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []IPAddressDenyItem err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "IPAddressDeny", cb0) } // property DisableControllers as func (v *service) DisableControllers() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "DisableControllers", } } // property Environment as func (v *service) Environment() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "Environment", } } // property EnvironmentFiles a(sb) func (v *service) EnvironmentFiles() PropEnvironmentFiles { return PropEnvironmentFiles{ Impl: v, Name: "EnvironmentFiles", } } // property PassEnvironment as func (v *service) PassEnvironment() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "PassEnvironment", } } // property UnsetEnvironment as func (v *service) UnsetEnvironment() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "UnsetEnvironment", } } // property UMask u func (v *service) UMask() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "UMask", } } // property LimitCPU t func (v *service) LimitCPU() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitCPU", } } // property LimitCPUSoft t func (v *service) LimitCPUSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitCPUSoft", } } // property LimitFSIZE t func (v *service) LimitFSIZE() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitFSIZE", } } // property LimitFSIZESoft t func (v *service) LimitFSIZESoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitFSIZESoft", } } // property LimitDATA t func (v *service) LimitDATA() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitDATA", } } // property LimitDATASoft t func (v *service) LimitDATASoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitDATASoft", } } // property LimitSTACK t func (v *service) LimitSTACK() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitSTACK", } } // property LimitSTACKSoft t func (v *service) LimitSTACKSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitSTACKSoft", } } // property LimitCORE t func (v *service) LimitCORE() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitCORE", } } // property LimitCORESoft t func (v *service) LimitCORESoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitCORESoft", } } // property LimitRSS t func (v *service) LimitRSS() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitRSS", } } // property LimitRSSSoft t func (v *service) LimitRSSSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitRSSSoft", } } // property LimitNOFILE t func (v *service) LimitNOFILE() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitNOFILE", } } // property LimitNOFILESoft t func (v *service) LimitNOFILESoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitNOFILESoft", } } // property LimitAS t func (v *service) LimitAS() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitAS", } } // property LimitASSoft t func (v *service) LimitASSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitASSoft", } } // property LimitNPROC t func (v *service) LimitNPROC() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitNPROC", } } // property LimitNPROCSoft t func (v *service) LimitNPROCSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitNPROCSoft", } } // property LimitMEMLOCK t func (v *service) LimitMEMLOCK() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitMEMLOCK", } } // property LimitMEMLOCKSoft t func (v *service) LimitMEMLOCKSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitMEMLOCKSoft", } } // property LimitLOCKS t func (v *service) LimitLOCKS() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitLOCKS", } } // property LimitLOCKSSoft t func (v *service) LimitLOCKSSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitLOCKSSoft", } } // property LimitSIGPENDING t func (v *service) LimitSIGPENDING() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitSIGPENDING", } } // property LimitSIGPENDINGSoft t func (v *service) LimitSIGPENDINGSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitSIGPENDINGSoft", } } // property LimitMSGQUEUE t func (v *service) LimitMSGQUEUE() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitMSGQUEUE", } } // property LimitMSGQUEUESoft t func (v *service) LimitMSGQUEUESoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitMSGQUEUESoft", } } // property LimitNICE t func (v *service) LimitNICE() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitNICE", } } // property LimitNICESoft t func (v *service) LimitNICESoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitNICESoft", } } // property LimitRTPRIO t func (v *service) LimitRTPRIO() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitRTPRIO", } } // property LimitRTPRIOSoft t func (v *service) LimitRTPRIOSoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitRTPRIOSoft", } } // property LimitRTTIME t func (v *service) LimitRTTIME() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitRTTIME", } } // property LimitRTTIMESoft t func (v *service) LimitRTTIMESoft() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LimitRTTIMESoft", } } // property WorkingDirectory s func (v *service) WorkingDirectory() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WorkingDirectory", } } // property RootDirectory s func (v *service) RootDirectory() proxy.PropString { return proxy.PropString{ Impl: v, Name: "RootDirectory", } } // property RootImage s func (v *service) RootImage() proxy.PropString { return proxy.PropString{ Impl: v, Name: "RootImage", } } // property OOMScoreAdjust i func (v *service) OOMScoreAdjust() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "OOMScoreAdjust", } } // property Nice i func (v *service) Nice() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "Nice", } } // property IOSchedulingClass i func (v *service) IOSchedulingClass() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "IOSchedulingClass", } } // property IOSchedulingPriority i func (v *service) IOSchedulingPriority() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "IOSchedulingPriority", } } // property CPUSchedulingPolicy i func (v *service) CPUSchedulingPolicy() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "CPUSchedulingPolicy", } } // property CPUSchedulingPriority i func (v *service) CPUSchedulingPriority() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "CPUSchedulingPriority", } } // property CPUAffinity ay func (v *service) CPUAffinity() proxy.PropByteArray { return proxy.PropByteArray{ Impl: v, Name: "CPUAffinity", } } // property TimerSlackNSec t func (v *service) TimerSlackNSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TimerSlackNSec", } } // property CPUSchedulingResetOnFork b func (v *service) CPUSchedulingResetOnFork() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CPUSchedulingResetOnFork", } } // property NonBlocking b func (v *service) NonBlocking() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "NonBlocking", } } // property StandardInput s func (v *service) StandardInput() proxy.PropString { return proxy.PropString{ Impl: v, Name: "StandardInput", } } // property StandardInputFileDescriptorName s func (v *service) StandardInputFileDescriptorName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "StandardInputFileDescriptorName", } } // property StandardInputData ay func (v *service) StandardInputData() proxy.PropByteArray { return proxy.PropByteArray{ Impl: v, Name: "StandardInputData", } } // property StandardOutput s func (v *service) StandardOutput() proxy.PropString { return proxy.PropString{ Impl: v, Name: "StandardOutput", } } // property StandardOutputFileDescriptorName s func (v *service) StandardOutputFileDescriptorName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "StandardOutputFileDescriptorName", } } // property StandardError s func (v *service) StandardError() proxy.PropString { return proxy.PropString{ Impl: v, Name: "StandardError", } } // property StandardErrorFileDescriptorName s func (v *service) StandardErrorFileDescriptorName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "StandardErrorFileDescriptorName", } } // property TTYPath s func (v *service) TTYPath() proxy.PropString { return proxy.PropString{ Impl: v, Name: "TTYPath", } } // property TTYReset b func (v *service) TTYReset() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "TTYReset", } } // property TTYVHangup b func (v *service) TTYVHangup() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "TTYVHangup", } } // property TTYVTDisallocate b func (v *service) TTYVTDisallocate() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "TTYVTDisallocate", } } // property SyslogPriority i func (v *service) SyslogPriority() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "SyslogPriority", } } // property SyslogIdentifier s func (v *service) SyslogIdentifier() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SyslogIdentifier", } } // property SyslogLevelPrefix b func (v *service) SyslogLevelPrefix() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SyslogLevelPrefix", } } // property SyslogLevel i func (v *service) SyslogLevel() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "SyslogLevel", } } // property SyslogFacility i func (v *service) SyslogFacility() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "SyslogFacility", } } // property LogLevelMax i func (v *service) LogLevelMax() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "LogLevelMax", } } // property LogRateLimitIntervalUSec t func (v *service) LogRateLimitIntervalUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "LogRateLimitIntervalUSec", } } // property LogRateLimitBurst u func (v *service) LogRateLimitBurst() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "LogRateLimitBurst", } } // property LogExtraFields aay func (v *service) LogExtraFields() PropServiceLogExtraFields { return PropServiceLogExtraFields{ Impl: v, } } type PropServiceLogExtraFields struct { Impl proxy.Implementer } func (p PropServiceLogExtraFields) Get(flags dbus.Flags) (value [][]byte, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "LogExtraFields", &value) return } func (p PropServiceLogExtraFields) ConnectChanged(cb func(hasValue bool, value [][]byte)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v [][]byte err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "LogExtraFields", cb0) } // property SecureBits i func (v *service) SecureBits() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "SecureBits", } } // property CapabilityBoundingSet t func (v *service) CapabilityBoundingSet() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "CapabilityBoundingSet", } } // property AmbientCapabilities t func (v *service) AmbientCapabilities() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "AmbientCapabilities", } } // property User s func (v *service) User() proxy.PropString { return proxy.PropString{ Impl: v, Name: "User", } } // property Group s func (v *service) Group() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Group", } } // property DynamicUser b func (v *service) DynamicUser() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "DynamicUser", } } // property RemoveIPC b func (v *service) RemoveIPC() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "RemoveIPC", } } // property SupplementaryGroups as func (v *service) SupplementaryGroups() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "SupplementaryGroups", } } // property PAMName s func (v *service) PAMName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PAMName", } } // property ReadWritePaths as func (v *service) ReadWritePaths() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "ReadWritePaths", } } // property ReadOnlyPaths as func (v *service) ReadOnlyPaths() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "ReadOnlyPaths", } } // property InaccessiblePaths as func (v *service) InaccessiblePaths() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "InaccessiblePaths", } } // property MountFlags t func (v *service) MountFlags() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "MountFlags", } } // property PrivateTmp b func (v *service) PrivateTmp() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PrivateTmp", } } // property PrivateDevices b func (v *service) PrivateDevices() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PrivateDevices", } } // property ProtectKernelTunables b func (v *service) ProtectKernelTunables() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ProtectKernelTunables", } } // property ProtectKernelModules b func (v *service) ProtectKernelModules() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ProtectKernelModules", } } // property ProtectControlGroups b func (v *service) ProtectControlGroups() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ProtectControlGroups", } } // property PrivateNetwork b func (v *service) PrivateNetwork() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PrivateNetwork", } } // property PrivateUsers b func (v *service) PrivateUsers() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PrivateUsers", } } // property PrivateMounts b func (v *service) PrivateMounts() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PrivateMounts", } } // property ProtectHome s func (v *service) ProtectHome() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ProtectHome", } } // property ProtectSystem s func (v *service) ProtectSystem() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ProtectSystem", } } // property SameProcessGroup b func (v *service) SameProcessGroup() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SameProcessGroup", } } // property UtmpIdentifier s func (v *service) UtmpIdentifier() proxy.PropString { return proxy.PropString{ Impl: v, Name: "UtmpIdentifier", } } // property UtmpMode s func (v *service) UtmpMode() proxy.PropString { return proxy.PropString{ Impl: v, Name: "UtmpMode", } } // property SELinuxContext (bs) func (v *service) SELinuxContext() PropBS { return PropBS{ Impl: v, Name: "SELinuxContext", } } // property AppArmorProfile (bs) func (v *service) AppArmorProfile() PropBS { return PropBS{ Impl: v, Name: "AppArmorProfile", } } // property SmackProcessLabel (bs) func (v *service) SmackProcessLabel() PropBS { return PropBS{ Impl: v, Name: "SmackProcessLabel", } } // property IgnoreSIGPIPE b func (v *service) IgnoreSIGPIPE() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IgnoreSIGPIPE", } } // property NoNewPrivileges b func (v *service) NoNewPrivileges() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "NoNewPrivileges", } } // property SystemCallFilter (bas) func (v *service) SystemCallFilter() PropServiceSystemCallFilter { return PropServiceSystemCallFilter{ Impl: v, } } type PropServiceSystemCallFilter struct { Impl proxy.Implementer } func (p PropServiceSystemCallFilter) Get(flags dbus.Flags) (value SystemCallFilter, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "SystemCallFilter", &value) return } func (p PropServiceSystemCallFilter) ConnectChanged(cb func(hasValue bool, value SystemCallFilter)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v SystemCallFilter err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, SystemCallFilter{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "SystemCallFilter", cb0) } // property SystemCallArchitectures as func (v *service) SystemCallArchitectures() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "SystemCallArchitectures", } } // property SystemCallErrorNumber i func (v *service) SystemCallErrorNumber() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "SystemCallErrorNumber", } } // property Personality s func (v *service) Personality() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Personality", } } // property LockPersonality b func (v *service) LockPersonality() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "LockPersonality", } } // property RestrictAddressFamilies (bas) func (v *service) RestrictAddressFamilies() PropServiceRestrictAddressFamilies { return PropServiceRestrictAddressFamilies{ Impl: v, } } type PropServiceRestrictAddressFamilies struct { Impl proxy.Implementer } func (p PropServiceRestrictAddressFamilies) Get(flags dbus.Flags) (value RestrictAddressFamilies, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "RestrictAddressFamilies", &value) return } func (p PropServiceRestrictAddressFamilies) ConnectChanged(cb func(hasValue bool, value RestrictAddressFamilies)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v RestrictAddressFamilies err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, RestrictAddressFamilies{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "RestrictAddressFamilies", cb0) } // property RuntimeDirectoryPreserve s func (v *service) RuntimeDirectoryPreserve() proxy.PropString { return proxy.PropString{ Impl: v, Name: "RuntimeDirectoryPreserve", } } // property RuntimeDirectoryMode u func (v *service) RuntimeDirectoryMode() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "RuntimeDirectoryMode", } } // property RuntimeDirectory as func (v *service) RuntimeDirectory() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "RuntimeDirectory", } } // property StateDirectoryMode u func (v *service) StateDirectoryMode() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "StateDirectoryMode", } } // property StateDirectory as func (v *service) StateDirectory() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "StateDirectory", } } // property CacheDirectoryMode u func (v *service) CacheDirectoryMode() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "CacheDirectoryMode", } } // property CacheDirectory as func (v *service) CacheDirectory() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "CacheDirectory", } } // property LogsDirectoryMode u func (v *service) LogsDirectoryMode() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "LogsDirectoryMode", } } // property LogsDirectory as func (v *service) LogsDirectory() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "LogsDirectory", } } // property ConfigurationDirectoryMode u func (v *service) ConfigurationDirectoryMode() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "ConfigurationDirectoryMode", } } // property ConfigurationDirectory as func (v *service) ConfigurationDirectory() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "ConfigurationDirectory", } } // property MemoryDenyWriteExecute b func (v *service) MemoryDenyWriteExecute() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "MemoryDenyWriteExecute", } } // property RestrictRealtime b func (v *service) RestrictRealtime() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "RestrictRealtime", } } // property RestrictNamespaces t func (v *service) RestrictNamespaces() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "RestrictNamespaces", } } // property BindPaths a(ssbt) func (v *service) BindPaths() PropBindPaths { return PropBindPaths{ Impl: v, Name: "BindPaths", } } // property BindReadOnlyPaths a(ssbt) func (v *service) BindReadOnlyPaths() PropBindPaths { return PropBindPaths{ Impl: v, Name: "BindReadOnlyPaths", } } // property TemporaryFileSystem a(ss) func (v *service) TemporaryFileSystem() PropServiceTemporaryFileSystem { return PropServiceTemporaryFileSystem{ Impl: v, } } type PropServiceTemporaryFileSystem struct { Impl proxy.Implementer } func (p PropServiceTemporaryFileSystem) Get(flags dbus.Flags) (value []TemporaryFileSystemItem, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "TemporaryFileSystem", &value) return } func (p PropServiceTemporaryFileSystem) ConnectChanged(cb func(hasValue bool, value []TemporaryFileSystemItem)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []TemporaryFileSystemItem err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "TemporaryFileSystem", cb0) } // property MountAPIVFS b func (v *service) MountAPIVFS() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "MountAPIVFS", } } // property KeyringMode s func (v *service) KeyringMode() proxy.PropString { return proxy.PropString{ Impl: v, Name: "KeyringMode", } } // property KillMode s func (v *service) KillMode() proxy.PropString { return proxy.PropString{ Impl: v, Name: "KillMode", } } // property KillSignal i func (v *service) KillSignal() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "KillSignal", } } // property FinalKillSignal i func (v *service) FinalKillSignal() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "FinalKillSignal", } } // property SendSIGKILL b func (v *service) SendSIGKILL() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SendSIGKILL", } } // property SendSIGHUP b func (v *service) SendSIGHUP() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SendSIGHUP", } } // property WatchdogSignal i func (v *service) WatchdogSignal() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "WatchdogSignal", } } type PropExitStatus struct { Impl proxy.Implementer Name string } func (p PropExitStatus) Get(flags dbus.Flags) (value ExitStatus, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropExitStatus) Set(flags dbus.Flags, value ExitStatus) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropExitStatus) ConnectChanged(cb func(hasValue bool, value ExitStatus)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v ExitStatus err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, ExitStatus{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } type PropExecInfos struct { Impl proxy.Implementer Name string } func (p PropExecInfos) Get(flags dbus.Flags) (value []ExecInfo, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropExecInfos) Set(flags dbus.Flags, value []ExecInfo) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropExecInfos) ConnectChanged(cb func(hasValue bool, value []ExecInfo)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []ExecInfo err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } type PropIOParams struct { Impl proxy.Implementer Name string } func (p PropIOParams) Get(flags dbus.Flags) (value []IOParam, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropIOParams) Set(flags dbus.Flags, value []IOParam) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropIOParams) ConnectChanged(cb func(hasValue bool, value []IOParam)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []IOParam err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } type PropEnvironmentFiles struct { Impl proxy.Implementer Name string } func (p PropEnvironmentFiles) Get(flags dbus.Flags) (value []EnvironmentFile, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropEnvironmentFiles) Set(flags dbus.Flags, value []EnvironmentFile) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropEnvironmentFiles) ConnectChanged(cb func(hasValue bool, value []EnvironmentFile)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []EnvironmentFile err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } type PropBS struct { Impl proxy.Implementer Name string } func (p PropBS) Get(flags dbus.Flags) (value BS, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropBS) Set(flags dbus.Flags, value BS) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropBS) ConnectChanged(cb func(hasValue bool, value BS)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v BS err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, BS{}) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } type PropBindPaths struct { Impl proxy.Implementer Name string } func (p PropBindPaths) Get(flags dbus.Flags) (value []BindPath, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropBindPaths) Set(flags dbus.Flags, value []BindPath) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropBindPaths) ConnectChanged(cb func(hasValue bool, value []BindPath)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []BindPath err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } go-dbus-factory-1.9.6/org.freedesktop.systemd1/config.json000066400000000000000000000210141403054572700235520ustar00rootroot00000000000000{ "Service": "org.freedesktop.systemd1", "Objects": [ { "Type": "Manager", "Path": "/org/freedesktop/systemd1", "Interfaces": [ { "Name": "org.freedesktop.systemd1.Manager", "Fixes": { "m/SetUnitProperties": [ { "Name": "properties", "Type": "[]Property" } ], "m/StartTransientUnit": [ { "Name": "properties", "Type": "[]Property" }, { "Name": "aux", "Type": "[]PropertyCollection" } ], "m/ListUnits": [ { "Name": "units", "Type": "[]UnitInfo" } ], "m/ListUnitsFiltered": [ { "Name": "units", "Type": "[]UnitInfo" } ], "m/ListUnitsByPatterns": [ { "Name": "units", "Type": "[]UnitInfo" } ], "m/ListUnitsByNames": [ { "Name": "units", "Type": "[]UnitInfo" } ], "m/ListJobs": [ { "Name": "jobs", "Type": "[]JobInfo" } ], "m/ListUnitFiles": [ { "Name": "files", "Type": "[]UnitFile" } ], "m/ListUnitFilesByPatterns": [ { "Name": "files", "Type": "[]UnitFile" } ], "m/EnableUnitFiles": [ { "Name": "changes", "Type": "[]UnitFileChange" } ], "m/DisableUnitFiles": [ { "Name": "changes", "Type": "[]UnitFileChange" } ], "m/ReenableUnitFiles": [ { "Name": "changes", "Type": "[]UnitFileChange" } ], "m/LinkUnitFiles": [ { "Name": "changes", "Type": "[]UnitFileChange" } ], "m/PresetUnitFiles": [ { "Name": "changes", "Type": "[]UnitFileChange" } ], "m/PresetUnitFilesWithMode": [ { "Name": "changes", "Type": "[]UnitFileChange" } ], "m/MaskUnitFiles": [ { "Name": "changes", "Type": "[]UnitFileChange" } ], "m/UnmaskUnitFiles": [ { "Name": "changes", "Type": "[]UnitFileChange" } ], "m/RevertUnitFiles": [ { "Name": "changes", "Type": "[]UnitFileChange" } ], "m/SetDefaultTarget": [ { "Name": "changes", "Type": "[]UnitFileChange" } ], "m/PresetAllUnitFiles": [ { "Name": "changes", "Type": "[]UnitFileChange" } ], "m/AddDependencyUnitFiles": [ { "Name": "changes", "Type": "[]UnitFileChange" } ], "m/GetDynamicUsers": [ { "Name": "users", "Type": "[]DynamicUser" } ], "m/GetUnitProcesses": [ { "Name": "processes", "Type": "[]UnitProcess" } ], "m/GetJobAfter": [ { "Name": "jobs", "Type": "[]JobInfo" } ], "m/GetJobBefore": [ { "Name": "jobs", "Type": "[]JobInfo" } ] } } ] }, { "Type": "Unit", "XMLFiles": [ "Unit*" ], "Interfaces": [ { "Name": "org.freedesktop.systemd1.Unit", "Fixes": { "p/Job": { "ValueType": "JobIdPath" }, "p/Conditions": { "ValueType": "[]Condition" }, "p/Asserts": { "ValueType": "[]Assert" }, "p/LoadError": { "ValueType": "LoadError" }, "m/SetProperties": [ { "Name": "properties", "Type": "[]Property" } ] } }, { "Name": "org.freedesktop.systemd1.Service", "Fixes": { "p/RestartPreventExitStatus": { "RefType": "PropExitStatus" }, "p/RestartForceExitStatus": { "RefType": "PropExitStatus" }, "p/SuccessExitStatus": { "RefType": "PropExitStatus" }, "p/ExecStartPre": { "RefType": "PropExecInfos" }, "p/ExecStart": { "RefType": "PropExecInfos" }, "p/ExecStartPost": { "RefType": "PropExecInfos" }, "p/ExecReload": { "RefType": "PropExecInfos" }, "p/ExecStop": { "RefType": "PropExecInfos" }, "p/ExecStopPre": { "RefType": "PropExecInfos" }, "p/ExecStopPost": { "RefType": "PropExecInfos" }, "p/IODeviceWeight": { "RefType": "PropIOParams" }, "p/IOReadBandwidthMax": { "RefType": "PropIOParams" }, "p/IOWriteBandwidthMax": { "RefType": "PropIOParams" }, "p/IOReadIOPSMax": { "RefType": "PropIOParams" }, "p/IOWriteIOPSMax": { "RefType": "PropIOParams" }, "p/IODeviceLatencyTargetUSec": { "RefType": "PropIOParams" }, "p/BlockIODeviceWeight": { "RefType": "PropIOParams" }, "p/BlockIOReadBandwidth": { "RefType": "PropIOParams" }, "p/BlockIOWriteBandwidth": { "RefType": "PropIOParams" }, "p/DeviceAllow": { "ValueType": "[]DeviceAllowItem" }, "p/IPAddressAllow": { "ValueType": "[]IPAddressAllowItem" }, "p/IPAddressDeny": { "ValueType": "[]IPAddressDenyItem" }, "p/EnvironmentFiles": { "RefType": "PropEnvironmentFiles" }, "p/LogExtraFields": { "ValueType": "[][]byte" }, "p/SELinuxContext": { "RefType": "PropBS" }, "p/AppArmorProfile": { "RefType": "PropBS" }, "p/SmackProcessLabel": { "RefType": "PropBS" }, "p/SystemCallFilter": { "ValueType": "SystemCallFilter" }, "p/RestrictAddressFamilies": { "ValueType": "RestrictAddressFamilies" }, "p/BindPaths": { "RefType": "PropBindPaths" }, "p/BindReadOnlyPaths": { "RefType": "PropBindPaths" }, "p/TemporaryFileSystem": { "ValueType": "[]TemporaryFileSystemItem" }, "m/GetProcesses": [ { "Name": "processes", "Type": "[]UnitProcess" } ] } } ] } ], "PropertyTypes": [ { "Type": "PropExitStatus", "ValueType": "ExitStatus" }, { "Type": "PropExecInfos", "ValueType": "[]ExecInfo" }, { "Type": "PropIOParams", "ValueType": "[]IOParam" }, { "Type": "PropEnvironmentFiles", "ValueType": "[]EnvironmentFile" }, { "Type": "PropBS", "ValueType": "BS" }, { "Type": "PropBindPaths", "ValueType": "[]BindPath" } ] } go-dbus-factory-1.9.6/org.freedesktop.systemd1/manual.go000066400000000000000000000055461403054572700232320ustar00rootroot00000000000000package systemd1 import ( "github.com/godbus/dbus" ) type Property struct { Name string Value dbus.Variant } type PropertyCollection struct { Name string Properties []Property } type UnitInfo struct { Name string Description string LoadState string // i.e. whether the unit file has been loaded successfully ActiveState string // i.e. whether the unit is currently started or not SubState string // a more fine-grained version of the active state that is specific to the unit type, which the active state is not FollowUnit string // A unit that is being followed in its state by this unit, if there is any, otherwise the empty string. Path dbus.ObjectPath JobID uint32 // If there is a job queued for the job unit the numeric job id, 0 otherwise JobType string JobPath dbus.ObjectPath } type JobInfo struct { ID uint32 Name string Type string State string Path dbus.ObjectPath UnitPath dbus.ObjectPath } type JobIdPath struct { Id uint32 Path dbus.ObjectPath } type UnitFile struct { Path string State string } type UnitFileChange struct { Type string // the type of the change (one of symlink or unlink) Filename string // the file name of the symlink Destination string // the destination of the symlink } type DynamicUser struct { ID uint32 Name string } type UnitProcess struct { ControlGroup string PID uint32 Command string } type Condition struct { Type string IsTrigger bool IsReversed bool Right string // The status can be 0, in which case the condition hasn't been checked yet, a positive value, in which case the condition passed, or a negative value, in which case the condition failed. Currently only 0, +1, and -1 are used, but additional values may be used in the future, retaining the meaning of zero/positive/negative values. Status int32 } type Assert Condition type LoadError struct { Type string Message string } type ExitStatus struct { A []int32 B []int32 } type ExecInfo struct { Path string Arguments []string ExitFailure bool BeginClockRealtime uint64 BeginClockMonotonic uint64 EndClockRealtime uint64 EndClockMonotonic uint64 PID uint32 ExistCode int32 Status int32 } type IOParam struct { Name string Value uint64 } type DeviceAllowItem struct { Name string Value string } type IPAddressAllowItem struct { I uint32 AV []dbus.Variant U uint32 } type IPAddressDenyItem IPAddressAllowItem type EnvironmentFile struct { S string B bool } type BS struct { B bool S string } type SystemCallFilter struct { B bool AS string } type RestrictAddressFamilies struct { B bool AS string } type BindPath struct { S1 string S2 string B bool T uint64 } type TemporaryFileSystemItem struct { S1 string S2 string } go-dbus-factory-1.9.6/org.freedesktop.timedate1/000077500000000000000000000000001403054572700215205ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.timedate1/Timedate.xml000066400000000000000000000051051403054572700237770ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.timedate1/auto.go000066400000000000000000000061151403054572700230220ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.timedate1"; DO NOT EDIT. package timedate1 import ( "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil/proxy" ) type Timedate struct { timedate // interface org.freedesktop.timedate1 proxy.Object } func NewTimedate(conn *dbus.Conn) *Timedate { obj := new(Timedate) obj.Object.Init_(conn, "org.freedesktop.timedate1", "/org/freedesktop/timedate1") return obj } type timedate struct{} func (v *timedate) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*timedate) GetInterfaceName_() string { return "org.freedesktop.timedate1" } // method SetTime func (v *timedate) GoSetTime(flags dbus.Flags, ch chan *dbus.Call, arg0 int64, arg1 bool, arg2 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetTime", flags, ch, arg0, arg1, arg2) } func (v *timedate) SetTime(flags dbus.Flags, arg0 int64, arg1 bool, arg2 bool) error { return (<-v.GoSetTime(flags, make(chan *dbus.Call, 1), arg0, arg1, arg2).Done).Err } // method SetTimezone func (v *timedate) GoSetTimezone(flags dbus.Flags, ch chan *dbus.Call, arg0 string, arg1 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetTimezone", flags, ch, arg0, arg1) } func (v *timedate) SetTimezone(flags dbus.Flags, arg0 string, arg1 bool) error { return (<-v.GoSetTimezone(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // method SetLocalRTC func (v *timedate) GoSetLocalRTC(flags dbus.Flags, ch chan *dbus.Call, arg0 bool, arg1 bool, arg2 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLocalRTC", flags, ch, arg0, arg1, arg2) } func (v *timedate) SetLocalRTC(flags dbus.Flags, arg0 bool, arg1 bool, arg2 bool) error { return (<-v.GoSetLocalRTC(flags, make(chan *dbus.Call, 1), arg0, arg1, arg2).Done).Err } // method SetNTP func (v *timedate) GoSetNTP(flags dbus.Flags, ch chan *dbus.Call, arg0 bool, arg1 bool) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetNTP", flags, ch, arg0, arg1) } func (v *timedate) SetNTP(flags dbus.Flags, arg0 bool, arg1 bool) error { return (<-v.GoSetNTP(flags, make(chan *dbus.Call, 1), arg0, arg1).Done).Err } // property Timezone s func (v *timedate) Timezone() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Timezone", } } // property LocalRTC b func (v *timedate) LocalRTC() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "LocalRTC", } } // property CanNTP b func (v *timedate) CanNTP() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanNTP", } } // property NTP b func (v *timedate) NTP() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "NTP", } } // property NTPSynchronized b func (v *timedate) NTPSynchronized() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "NTPSynchronized", } } // property TimeUSec t func (v *timedate) TimeUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TimeUSec", } } // property RTCTimeUSec t func (v *timedate) RTCTimeUSec() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "RTCTimeUSec", } } go-dbus-factory-1.9.6/org.freedesktop.timedate1/config.json000066400000000000000000000004211403054572700236550ustar00rootroot00000000000000{ "Service": "org.freedesktop.timedate1", "Objects": [ { "Type": "Timedate", "Path": "/org/freedesktop/timedate1", "Interfaces": [ { "Name": "org.freedesktop.timedate1", "Type": "timedate" } ] } ] } go-dbus-factory-1.9.6/org.freedesktop.udisks2/000077500000000000000000000000001403054572700212275ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.freedesktop.udisks2/Block.xml000066400000000000000000000144731403054572700230140ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.udisks2/Block1.xml000066400000000000000000000112651403054572700230710ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.udisks2/Drive.xml000066400000000000000000000143351403054572700230300ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.udisks2/Manager.xml000066400000000000000000000040661403054572700233310ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.udisks2/UDisks.xml000066400000000000000000000037111403054572700231550ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.freedesktop.udisks2/auto.go000066400000000000000000001034451403054572700225350ustar00rootroot00000000000000// Code generated by "./generator ./org.freedesktop.udisks2"; DO NOT EDIT. package udisks2 import ( "errors" "unsafe" "github.com/godbus/dbus" "github.com/linuxdeepin/go-dbus-factory/object_manager" "pkg.deepin.io/lib/dbusutil/proxy" ) type UDisks struct { object_manager.ObjectManager // interface org.freedesktop.DBus.ObjectManager proxy.Object } func NewUDisks(conn *dbus.Conn) *UDisks { obj := new(UDisks) obj.Object.Init_(conn, "org.freedesktop.UDisks2", "/org/freedesktop/UDisks2") return obj } type Manager struct { manager // interface org.freedesktop.UDisks2.Manager proxy.Object } func NewManager(conn *dbus.Conn) *Manager { obj := new(Manager) obj.Object.Init_(conn, "org.freedesktop.UDisks2", "/org/freedesktop/UDisks2/Manager") return obj } type manager struct{} func (v *manager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*manager) GetInterfaceName_() string { return "org.freedesktop.UDisks2.Manager" } // method LoopSetup func (v *manager) GoLoopSetup(flags dbus.Flags, ch chan *dbus.Call, fd dbus.UnixFD, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".LoopSetup", flags, ch, fd, options) } func (*manager) StoreLoopSetup(call *dbus.Call) (resulting_device dbus.ObjectPath, err error) { err = call.Store(&resulting_device) return } func (v *manager) LoopSetup(flags dbus.Flags, fd dbus.UnixFD, options map[string]dbus.Variant) (resulting_device dbus.ObjectPath, err error) { return v.StoreLoopSetup( <-v.GoLoopSetup(flags, make(chan *dbus.Call, 1), fd, options).Done) } // method MDRaidCreate func (v *manager) GoMDRaidCreate(flags dbus.Flags, ch chan *dbus.Call, blocks []dbus.ObjectPath, level string, name string, chunk uint64, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".MDRaidCreate", flags, ch, blocks, level, name, chunk, options) } func (*manager) StoreMDRaidCreate(call *dbus.Call) (resulting_array dbus.ObjectPath, err error) { err = call.Store(&resulting_array) return } func (v *manager) MDRaidCreate(flags dbus.Flags, blocks []dbus.ObjectPath, level string, name string, chunk uint64, options map[string]dbus.Variant) (resulting_array dbus.ObjectPath, err error) { return v.StoreMDRaidCreate( <-v.GoMDRaidCreate(flags, make(chan *dbus.Call, 1), blocks, level, name, chunk, options).Done) } // property Version s func (v *manager) Version() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Version", } } type Drive struct { drive // interface org.freedesktop.UDisks2.Drive driveAta // interface org.freedesktop.UDisks2.Drive.Ata proxy.Object } func NewDrive(conn *dbus.Conn, path dbus.ObjectPath) (*Drive, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Drive) obj.Object.Init_(conn, "org.freedesktop.UDisks2", path) return obj, nil } func (obj *Drive) Drive() *drive { return &obj.drive } type drive struct{} func (v *drive) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*drive) GetInterfaceName_() string { return "org.freedesktop.UDisks2.Drive" } // method Eject func (v *drive) GoEject(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Eject", flags, ch, options) } func (v *drive) Eject(flags dbus.Flags, options map[string]dbus.Variant) error { return (<-v.GoEject(flags, make(chan *dbus.Call, 1), options).Done).Err } // method SetConfiguration func (v *drive) GoSetConfiguration(flags dbus.Flags, ch chan *dbus.Call, value map[string]dbus.Variant, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetConfiguration", flags, ch, value, options) } func (v *drive) SetConfiguration(flags dbus.Flags, value map[string]dbus.Variant, options map[string]dbus.Variant) error { return (<-v.GoSetConfiguration(flags, make(chan *dbus.Call, 1), value, options).Done).Err } // method PowerOff func (v *drive) GoPowerOff(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PowerOff", flags, ch, options) } func (v *drive) PowerOff(flags dbus.Flags, options map[string]dbus.Variant) error { return (<-v.GoPowerOff(flags, make(chan *dbus.Call, 1), options).Done).Err } // property Vendor s func (v *drive) Vendor() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Vendor", } } // property Model s func (v *drive) Model() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Model", } } // property Revision s func (v *drive) Revision() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Revision", } } // property Serial s func (v *drive) Serial() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Serial", } } // property WWN s func (v *drive) WWN() proxy.PropString { return proxy.PropString{ Impl: v, Name: "WWN", } } // property Id s func (v *drive) Id() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Id", } } // property Configuration a{sv} func (v *drive) Configuration() PropDriveConfiguration { return PropDriveConfiguration{ Impl: v, } } type PropDriveConfiguration struct { Impl proxy.Implementer } func (p PropDriveConfiguration) Get(flags dbus.Flags) (value map[string]dbus.Variant, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Configuration", &value) return } func (p PropDriveConfiguration) ConnectChanged(cb func(hasValue bool, value map[string]dbus.Variant)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[string]dbus.Variant err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Configuration", cb0) } // property Media s func (v *drive) Media() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Media", } } // property MediaCompatibility as func (v *drive) MediaCompatibility() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "MediaCompatibility", } } // property MediaRemovable b func (v *drive) MediaRemovable() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "MediaRemovable", } } // property MediaAvailable b func (v *drive) MediaAvailable() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "MediaAvailable", } } // property MediaChangeDetected b func (v *drive) MediaChangeDetected() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "MediaChangeDetected", } } // property Size t func (v *drive) Size() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Size", } } // property TimeDetected t func (v *drive) TimeDetected() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TimeDetected", } } // property TimeMediaDetected t func (v *drive) TimeMediaDetected() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "TimeMediaDetected", } } // property Optical b func (v *drive) Optical() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Optical", } } // property OpticalBlank b func (v *drive) OpticalBlank() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "OpticalBlank", } } // property OpticalNumTracks u func (v *drive) OpticalNumTracks() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "OpticalNumTracks", } } // property OpticalNumAudioTracks u func (v *drive) OpticalNumAudioTracks() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "OpticalNumAudioTracks", } } // property OpticalNumDataTracks u func (v *drive) OpticalNumDataTracks() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "OpticalNumDataTracks", } } // property OpticalNumSessions u func (v *drive) OpticalNumSessions() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "OpticalNumSessions", } } // property RotationRate i func (v *drive) RotationRate() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "RotationRate", } } // property ConnectionBus s func (v *drive) ConnectionBus() proxy.PropString { return proxy.PropString{ Impl: v, Name: "ConnectionBus", } } // property Seat s func (v *drive) Seat() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Seat", } } // property Removable b func (v *drive) Removable() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Removable", } } // property Ejectable b func (v *drive) Ejectable() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "Ejectable", } } // property SortKey s func (v *drive) SortKey() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SortKey", } } // property CanPowerOff b func (v *drive) CanPowerOff() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanPowerOff", } } // property SiblingId s func (v *drive) SiblingId() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SiblingId", } } func (obj *Drive) DriveAta() *driveAta { return &obj.driveAta } type driveAta struct{} func (v *driveAta) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*driveAta) GetInterfaceName_() string { return "org.freedesktop.UDisks2.Drive.Ata" } // method SmartUpdate func (v *driveAta) GoSmartUpdate(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SmartUpdate", flags, ch, options) } func (v *driveAta) SmartUpdate(flags dbus.Flags, options map[string]dbus.Variant) error { return (<-v.GoSmartUpdate(flags, make(chan *dbus.Call, 1), options).Done).Err } // method SmartGetAttributes func (v *driveAta) GoSmartGetAttributes(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SmartGetAttributes", flags, ch, options) } func (*driveAta) StoreSmartGetAttributes(call *dbus.Call) (attributes []Attribute, err error) { err = call.Store(&attributes) return } func (v *driveAta) SmartGetAttributes(flags dbus.Flags, options map[string]dbus.Variant) (attributes []Attribute, err error) { return v.StoreSmartGetAttributes( <-v.GoSmartGetAttributes(flags, make(chan *dbus.Call, 1), options).Done) } // method SmartSelftestStart func (v *driveAta) GoSmartSelftestStart(flags dbus.Flags, ch chan *dbus.Call, type0 string, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SmartSelftestStart", flags, ch, type0, options) } func (v *driveAta) SmartSelftestStart(flags dbus.Flags, type0 string, options map[string]dbus.Variant) error { return (<-v.GoSmartSelftestStart(flags, make(chan *dbus.Call, 1), type0, options).Done).Err } // method SmartSelftestAbort func (v *driveAta) GoSmartSelftestAbort(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SmartSelftestAbort", flags, ch, options) } func (v *driveAta) SmartSelftestAbort(flags dbus.Flags, options map[string]dbus.Variant) error { return (<-v.GoSmartSelftestAbort(flags, make(chan *dbus.Call, 1), options).Done).Err } // method SmartSetEnabled func (v *driveAta) GoSmartSetEnabled(flags dbus.Flags, ch chan *dbus.Call, value bool, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SmartSetEnabled", flags, ch, value, options) } func (v *driveAta) SmartSetEnabled(flags dbus.Flags, value bool, options map[string]dbus.Variant) error { return (<-v.GoSmartSetEnabled(flags, make(chan *dbus.Call, 1), value, options).Done).Err } // method PmGetState func (v *driveAta) GoPmGetState(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PmGetState", flags, ch, options) } func (*driveAta) StorePmGetState(call *dbus.Call) (state uint8, err error) { err = call.Store(&state) return } func (v *driveAta) PmGetState(flags dbus.Flags, options map[string]dbus.Variant) (state uint8, err error) { return v.StorePmGetState( <-v.GoPmGetState(flags, make(chan *dbus.Call, 1), options).Done) } // method PmStandby func (v *driveAta) GoPmStandby(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PmStandby", flags, ch, options) } func (v *driveAta) PmStandby(flags dbus.Flags, options map[string]dbus.Variant) error { return (<-v.GoPmStandby(flags, make(chan *dbus.Call, 1), options).Done).Err } // method PmWakeup func (v *driveAta) GoPmWakeup(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PmWakeup", flags, ch, options) } func (v *driveAta) PmWakeup(flags dbus.Flags, options map[string]dbus.Variant) error { return (<-v.GoPmWakeup(flags, make(chan *dbus.Call, 1), options).Done).Err } // method SecurityEraseUnit func (v *driveAta) GoSecurityEraseUnit(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SecurityEraseUnit", flags, ch, options) } func (v *driveAta) SecurityEraseUnit(flags dbus.Flags, options map[string]dbus.Variant) error { return (<-v.GoSecurityEraseUnit(flags, make(chan *dbus.Call, 1), options).Done).Err } // property SmartSupported b func (v *driveAta) SmartSupported() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SmartSupported", } } // property SmartEnabled b func (v *driveAta) SmartEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SmartEnabled", } } // property SmartUpdated t func (v *driveAta) SmartUpdated() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "SmartUpdated", } } // property SmartFailing b func (v *driveAta) SmartFailing() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SmartFailing", } } // property SmartPowerOnSeconds t func (v *driveAta) SmartPowerOnSeconds() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "SmartPowerOnSeconds", } } // property SmartTemperature d func (v *driveAta) SmartTemperature() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "SmartTemperature", } } // property SmartNumAttributesFailing i func (v *driveAta) SmartNumAttributesFailing() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "SmartNumAttributesFailing", } } // property SmartNumAttributesFailedInThePast i func (v *driveAta) SmartNumAttributesFailedInThePast() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "SmartNumAttributesFailedInThePast", } } // property SmartNumBadSectors x func (v *driveAta) SmartNumBadSectors() proxy.PropInt64 { return proxy.PropInt64{ Impl: v, Name: "SmartNumBadSectors", } } // property SmartSelftestStatus s func (v *driveAta) SmartSelftestStatus() proxy.PropString { return proxy.PropString{ Impl: v, Name: "SmartSelftestStatus", } } // property SmartSelftestPercentRemaining i func (v *driveAta) SmartSelftestPercentRemaining() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "SmartSelftestPercentRemaining", } } // property PmSupported b func (v *driveAta) PmSupported() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PmSupported", } } // property PmEnabled b func (v *driveAta) PmEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "PmEnabled", } } // property ApmSupported b func (v *driveAta) ApmSupported() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ApmSupported", } } // property ApmEnabled b func (v *driveAta) ApmEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ApmEnabled", } } // property AamSupported b func (v *driveAta) AamSupported() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "AamSupported", } } // property AamEnabled b func (v *driveAta) AamEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "AamEnabled", } } // property AamVendorRecommendedValue i func (v *driveAta) AamVendorRecommendedValue() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "AamVendorRecommendedValue", } } // property WriteCacheSupported b func (v *driveAta) WriteCacheSupported() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "WriteCacheSupported", } } // property WriteCacheEnabled b func (v *driveAta) WriteCacheEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "WriteCacheEnabled", } } // property ReadLookaheadSupported b func (v *driveAta) ReadLookaheadSupported() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ReadLookaheadSupported", } } // property ReadLookaheadEnabled b func (v *driveAta) ReadLookaheadEnabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ReadLookaheadEnabled", } } // property SecurityEraseUnitMinutes i func (v *driveAta) SecurityEraseUnitMinutes() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "SecurityEraseUnitMinutes", } } // property SecurityEnhancedEraseUnitMinutes i func (v *driveAta) SecurityEnhancedEraseUnitMinutes() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "SecurityEnhancedEraseUnitMinutes", } } // property SecurityFrozen b func (v *driveAta) SecurityFrozen() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "SecurityFrozen", } } type Block struct { block // interface org.freedesktop.UDisks2.Block partitionTable // interface org.freedesktop.UDisks2.PartitionTable partition // interface org.freedesktop.UDisks2.Partition filesystem // interface org.freedesktop.UDisks2.Filesystem proxy.Object } func NewBlock(conn *dbus.Conn, path dbus.ObjectPath) (*Block, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(Block) obj.Object.Init_(conn, "org.freedesktop.UDisks2", path) return obj, nil } func (obj *Block) Block() *block { return &obj.block } type block struct{} func (v *block) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*block) GetInterfaceName_() string { return "org.freedesktop.UDisks2.Block" } // method AddConfigurationItem func (v *block) GoAddConfigurationItem(flags dbus.Flags, ch chan *dbus.Call, item ConfigurationItem, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".AddConfigurationItem", flags, ch, item, options) } func (v *block) AddConfigurationItem(flags dbus.Flags, item ConfigurationItem, options map[string]dbus.Variant) error { return (<-v.GoAddConfigurationItem(flags, make(chan *dbus.Call, 1), item, options).Done).Err } // method RemoveConfigurationItem func (v *block) GoRemoveConfigurationItem(flags dbus.Flags, ch chan *dbus.Call, item ConfigurationItem, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".RemoveConfigurationItem", flags, ch, item, options) } func (v *block) RemoveConfigurationItem(flags dbus.Flags, item ConfigurationItem, options map[string]dbus.Variant) error { return (<-v.GoRemoveConfigurationItem(flags, make(chan *dbus.Call, 1), item, options).Done).Err } // method UpdateConfigurationItem func (v *block) GoUpdateConfigurationItem(flags dbus.Flags, ch chan *dbus.Call, old_item ConfigurationItem, new_item ConfigurationItem, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".UpdateConfigurationItem", flags, ch, old_item, new_item, options) } func (v *block) UpdateConfigurationItem(flags dbus.Flags, old_item ConfigurationItem, new_item ConfigurationItem, options map[string]dbus.Variant) error { return (<-v.GoUpdateConfigurationItem(flags, make(chan *dbus.Call, 1), old_item, new_item, options).Done).Err } // method GetSecretConfiguration func (v *block) GoGetSecretConfiguration(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".GetSecretConfiguration", flags, ch, options) } func (*block) StoreGetSecretConfiguration(call *dbus.Call) (configuration []ConfigurationItem, err error) { err = call.Store(&configuration) return } func (v *block) GetSecretConfiguration(flags dbus.Flags, options map[string]dbus.Variant) (configuration []ConfigurationItem, err error) { return v.StoreGetSecretConfiguration( <-v.GoGetSecretConfiguration(flags, make(chan *dbus.Call, 1), options).Done) } // method Format func (v *block) GoFormat(flags dbus.Flags, ch chan *dbus.Call, type0 string, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Format", flags, ch, type0, options) } func (v *block) Format(flags dbus.Flags, type0 string, options map[string]dbus.Variant) error { return (<-v.GoFormat(flags, make(chan *dbus.Call, 1), type0, options).Done).Err } // method OpenForBackup func (v *block) GoOpenForBackup(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".OpenForBackup", flags, ch, options) } func (*block) StoreOpenForBackup(call *dbus.Call) (fd dbus.UnixFD, err error) { err = call.Store(&fd) return } func (v *block) OpenForBackup(flags dbus.Flags, options map[string]dbus.Variant) (fd dbus.UnixFD, err error) { return v.StoreOpenForBackup( <-v.GoOpenForBackup(flags, make(chan *dbus.Call, 1), options).Done) } // method OpenForRestore func (v *block) GoOpenForRestore(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".OpenForRestore", flags, ch, options) } func (*block) StoreOpenForRestore(call *dbus.Call) (fd dbus.UnixFD, err error) { err = call.Store(&fd) return } func (v *block) OpenForRestore(flags dbus.Flags, options map[string]dbus.Variant) (fd dbus.UnixFD, err error) { return v.StoreOpenForRestore( <-v.GoOpenForRestore(flags, make(chan *dbus.Call, 1), options).Done) } // method OpenForBenchmark func (v *block) GoOpenForBenchmark(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".OpenForBenchmark", flags, ch, options) } func (*block) StoreOpenForBenchmark(call *dbus.Call) (fd dbus.UnixFD, err error) { err = call.Store(&fd) return } func (v *block) OpenForBenchmark(flags dbus.Flags, options map[string]dbus.Variant) (fd dbus.UnixFD, err error) { return v.StoreOpenForBenchmark( <-v.GoOpenForBenchmark(flags, make(chan *dbus.Call, 1), options).Done) } // method Rescan func (v *block) GoRescan(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Rescan", flags, ch, options) } func (v *block) Rescan(flags dbus.Flags, options map[string]dbus.Variant) error { return (<-v.GoRescan(flags, make(chan *dbus.Call, 1), options).Done).Err } // property Device ay func (v *block) Device() proxy.PropByteArray { return proxy.PropByteArray{ Impl: v, Name: "Device", } } // property PreferredDevice ay func (v *block) PreferredDevice() proxy.PropByteArray { return proxy.PropByteArray{ Impl: v, Name: "PreferredDevice", } } // property Symlinks aay func (v *block) Symlinks() PropByteSliceSlice { return PropByteSliceSlice{ Impl: v, Name: "Symlinks", } } // property DeviceNumber t func (v *block) DeviceNumber() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "DeviceNumber", } } // property Id s func (v *block) Id() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Id", } } // property Size t func (v *block) Size() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Size", } } // property ReadOnly b func (v *block) ReadOnly() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "ReadOnly", } } // property Drive o func (v *block) Drive() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Drive", } } // property MDRaid o func (v *block) MDRaid() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "MDRaid", } } // property MDRaidMember o func (v *block) MDRaidMember() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "MDRaidMember", } } // property IdUsage s func (v *block) IdUsage() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IdUsage", } } // property IdType s func (v *block) IdType() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IdType", } } // property IdVersion s func (v *block) IdVersion() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IdVersion", } } // property IdLabel s func (v *block) IdLabel() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IdLabel", } } // property IdUUID s func (v *block) IdUUID() proxy.PropString { return proxy.PropString{ Impl: v, Name: "IdUUID", } } // property Configuration a(sa{sv}) func (v *block) Configuration() PropBlockConfiguration { return PropBlockConfiguration{ Impl: v, } } type PropBlockConfiguration struct { Impl proxy.Implementer } func (p PropBlockConfiguration) Get(flags dbus.Flags) (value []ConfigurationItem, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Configuration", &value) return } func (p PropBlockConfiguration) ConnectChanged(cb func(hasValue bool, value []ConfigurationItem)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v []ConfigurationItem err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Configuration", cb0) } // property CryptoBackingDevice o func (v *block) CryptoBackingDevice() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "CryptoBackingDevice", } } // property HintPartitionable b func (v *block) HintPartitionable() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "HintPartitionable", } } // property HintSystem b func (v *block) HintSystem() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "HintSystem", } } // property HintIgnore b func (v *block) HintIgnore() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "HintIgnore", } } // property HintAuto b func (v *block) HintAuto() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "HintAuto", } } // property HintName s func (v *block) HintName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HintName", } } // property HintIconName s func (v *block) HintIconName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HintIconName", } } // property HintSymbolicIconName s func (v *block) HintSymbolicIconName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "HintSymbolicIconName", } } func (obj *Block) PartitionTable() *partitionTable { return &obj.partitionTable } type partitionTable struct{} func (v *partitionTable) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*partitionTable) GetInterfaceName_() string { return "org.freedesktop.UDisks2.PartitionTable" } // method CreatePartition func (v *partitionTable) GoCreatePartition(flags dbus.Flags, ch chan *dbus.Call, offset uint64, size uint64, type0 string, name string, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".CreatePartition", flags, ch, offset, size, type0, name, options) } func (*partitionTable) StoreCreatePartition(call *dbus.Call) (created_partition dbus.ObjectPath, err error) { err = call.Store(&created_partition) return } func (v *partitionTable) CreatePartition(flags dbus.Flags, offset uint64, size uint64, type0 string, name string, options map[string]dbus.Variant) (created_partition dbus.ObjectPath, err error) { return v.StoreCreatePartition( <-v.GoCreatePartition(flags, make(chan *dbus.Call, 1), offset, size, type0, name, options).Done) } // property Type s func (v *partitionTable) Type() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Type", } } func (obj *Block) Partition() *partition { return &obj.partition } type partition struct{} func (v *partition) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*partition) GetInterfaceName_() string { return "org.freedesktop.UDisks2.Partition" } // method SetType func (v *partition) GoSetType(flags dbus.Flags, ch chan *dbus.Call, type0 string, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetType", flags, ch, type0, options) } func (v *partition) SetType(flags dbus.Flags, type0 string, options map[string]dbus.Variant) error { return (<-v.GoSetType(flags, make(chan *dbus.Call, 1), type0, options).Done).Err } // method SetName func (v *partition) GoSetName(flags dbus.Flags, ch chan *dbus.Call, name string, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetName", flags, ch, name, options) } func (v *partition) SetName(flags dbus.Flags, name string, options map[string]dbus.Variant) error { return (<-v.GoSetName(flags, make(chan *dbus.Call, 1), name, options).Done).Err } // method SetFlags func (v *partition) GoSetFlags(flags dbus.Flags, ch chan *dbus.Call, flags0 uint64, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetFlags", flags, ch, flags0, options) } func (v *partition) SetFlags(flags dbus.Flags, flags0 uint64, options map[string]dbus.Variant) error { return (<-v.GoSetFlags(flags, make(chan *dbus.Call, 1), flags0, options).Done).Err } // method Delete func (v *partition) GoDelete(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Delete", flags, ch, options) } func (v *partition) Delete(flags dbus.Flags, options map[string]dbus.Variant) error { return (<-v.GoDelete(flags, make(chan *dbus.Call, 1), options).Done).Err } // property Number u func (v *partition) Number() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "Number", } } // property Type s func (v *partition) Type() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Type", } } // property Flags t func (v *partition) Flags() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Flags", } } // property Offset t func (v *partition) Offset() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Offset", } } // property Size t func (v *partition) Size() proxy.PropUint64 { return proxy.PropUint64{ Impl: v, Name: "Size", } } // property Name s func (v *partition) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Name", } } // property UUID s func (v *partition) UUID() proxy.PropString { return proxy.PropString{ Impl: v, Name: "UUID", } } // property Table o func (v *partition) Table() proxy.PropObjectPath { return proxy.PropObjectPath{ Impl: v, Name: "Table", } } // property IsContainer b func (v *partition) IsContainer() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IsContainer", } } // property IsContained b func (v *partition) IsContained() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "IsContained", } } func (obj *Block) Filesystem() *filesystem { return &obj.filesystem } type filesystem struct{} func (v *filesystem) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*filesystem) GetInterfaceName_() string { return "org.freedesktop.UDisks2.Filesystem" } // method SetLabel func (v *filesystem) GoSetLabel(flags dbus.Flags, ch chan *dbus.Call, label string, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetLabel", flags, ch, label, options) } func (v *filesystem) SetLabel(flags dbus.Flags, label string, options map[string]dbus.Variant) error { return (<-v.GoSetLabel(flags, make(chan *dbus.Call, 1), label, options).Done).Err } // method Mount func (v *filesystem) GoMount(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Mount", flags, ch, options) } func (*filesystem) StoreMount(call *dbus.Call) (mount_path string, err error) { err = call.Store(&mount_path) return } func (v *filesystem) Mount(flags dbus.Flags, options map[string]dbus.Variant) (mount_path string, err error) { return v.StoreMount( <-v.GoMount(flags, make(chan *dbus.Call, 1), options).Done) } // method Unmount func (v *filesystem) GoUnmount(flags dbus.Flags, ch chan *dbus.Call, options map[string]dbus.Variant) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Unmount", flags, ch, options) } func (v *filesystem) Unmount(flags dbus.Flags, options map[string]dbus.Variant) error { return (<-v.GoUnmount(flags, make(chan *dbus.Call, 1), options).Done).Err } // property MountPoints aay func (v *filesystem) MountPoints() PropByteSliceSlice { return PropByteSliceSlice{ Impl: v, Name: "MountPoints", } } type PropByteSliceSlice struct { Impl proxy.Implementer Name string } func (p PropByteSliceSlice) Get(flags dbus.Flags) (value [][]byte, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, &value) return } func (p PropByteSliceSlice) Set(flags dbus.Flags, value [][]byte) error { return p.Impl.GetObject_().SetProperty_(flags, p.Impl.GetInterfaceName_(), p.Name, value) } func (p PropByteSliceSlice) ConnectChanged(cb func(hasValue bool, value [][]byte)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v [][]byte err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), p.Name, cb0) } go-dbus-factory-1.9.6/org.freedesktop.udisks2/config.json000066400000000000000000000060251403054572700233720ustar00rootroot00000000000000{ "Service": "org.freedesktop.UDisks2", "Objects": [ { "Type": "UDisks", "Path": "/org/freedesktop/UDisks2", "Interfaces": [ { "Name": "org.freedesktop.DBus.ObjectManager" } ] }, { "Type": "Manager", "Path": "/org/freedesktop/UDisks2/Manager", "Interfaces": [ { "Name": "org.freedesktop.UDisks2.Manager", "Type": "manager" } ] }, { "Type": "Drive", "Interfaces": [ { "Name": "org.freedesktop.UDisks2.Drive", "Type": "drive", "Accessor": "Drive", "Fixes": { "p/Configuration": { "Type": "PropDriveConfiguration", "ValueType": "map[string]dbus.Variant" } } }, { "Name": "org.freedesktop.UDisks2.Drive.Ata", "Type": "driveAta", "Accessor": "DriveAta", "Fixes": { "m/SmartGetAttributes": [ { "Name": "attributes", "Type": "[]Attribute" } ] } } ] }, { "Type": "Block", "Interfaces": [ { "Name": "org.freedesktop.UDisks2.Block", "Type": "block", "Accessor": "Block", "Fixes": { "p/Symlinks": { "RefType": "PropByteSliceSlice" }, "p/Configuration": { "Type": "PropBlockConfiguration", "ValueType": "[]ConfigurationItem" }, "m/AddConfigurationItem": [ { "Name": "item", "Type": "ConfigurationItem" } ], "m/RemoveConfigurationItem": [ { "Name": "item", "Type": "ConfigurationItem" } ], "m/UpdateConfigurationItem": [ { "Name": "old_item", "Type": "ConfigurationItem" }, { "Name": "new_item", "Type": "ConfigurationItem" } ], "m/GetSecretConfiguration": [ { "Name": "configuration", "Type": "[]ConfigurationItem" } ] } }, { "Name": "org.freedesktop.UDisks2.PartitionTable", "Type": "partitionTable", "Accessor": "PartitionTable" }, { "Name": "org.freedesktop.UDisks2.Partition", "Type": "partition", "Accessor": "Partition" }, { "Name": "org.freedesktop.UDisks2.Filesystem", "Type": "filesystem", "Accessor": "Filesystem", "Fixes": { "p/MountPoints": { "RefType": "PropByteSliceSlice" } } } ] } ], "PropertyTypes": [ { "Type": "PropByteSliceSlice", "ValueType": "[][]byte" } ] } go-dbus-factory-1.9.6/org.freedesktop.udisks2/manual.go000066400000000000000000000005251403054572700230350ustar00rootroot00000000000000package udisks2 import "github.com/godbus/dbus" type Attribute struct { Id byte Name string Flags uint16 Value int32 Worst int32 Threshold int32 Pretty int64 PrettyUnit int32 Expansion map[string]dbus.Variant } type ConfigurationItem struct { Type string Details map[string]dbus.Variant } go-dbus-factory-1.9.6/org.kde.kwin/000077500000000000000000000000001403054572700170435ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.kde.kwin/Compositor.xml000066400000000000000000000043351403054572700217300ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.kde.kwin/InputDevice.xml000066400000000000000000000117541403054572700220140ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.kde.kwin/InputDeviceManager.xml000066400000000000000000000007511403054572700233020ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.kde.kwin/auto.go000066400000000000000000000424051403054572700203470ustar00rootroot00000000000000// Code generated by "./generator ./org.kde.kwin"; DO NOT EDIT. package kwin import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type Compositor struct { compositing // interface org.kde.kwin.Compositing proxy.Object } func NewCompositor(conn *dbus.Conn) *Compositor { obj := new(Compositor) obj.Object.Init_(conn, "org.kde.KWin", "/Compositor") return obj } type compositing struct{} func (v *compositing) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*compositing) GetInterfaceName_() string { return "org.kde.kwin.Compositing" } // method suspend func (v *compositing) GoSuspend(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".suspend", flags, ch) } func (v *compositing) Suspend(flags dbus.Flags) error { return (<-v.GoSuspend(flags, make(chan *dbus.Call, 1)).Done).Err } // method resume func (v *compositing) GoResume(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".resume", flags, ch) } func (v *compositing) Resume(flags dbus.Flags) error { return (<-v.GoResume(flags, make(chan *dbus.Call, 1)).Done).Err } // signal compositingToggled func (v *compositing) ConnectCompositingToggled(cb func(active bool)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "compositingToggled", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".compositingToggled", } handlerFunc := func(sig *dbus.Signal) { var active bool err := dbus.Store(sig.Body, &active) if err == nil { cb(active) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property active b func (v *compositing) Active() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "active", } } // property compositingPossible b func (v *compositing) CompositingPossible() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "compositingPossible", } } // property compositingNotPossibleReason s func (v *compositing) CompositingNotPossibleReason() proxy.PropString { return proxy.PropString{ Impl: v, Name: "compositingNotPossibleReason", } } // property openGLIsBroken b func (v *compositing) OpenGLIsBroken() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "openGLIsBroken", } } // property compositingType s func (v *compositing) CompositingType() proxy.PropString { return proxy.PropString{ Impl: v, Name: "compositingType", } } // property supportedOpenGLPlatformInterfaces as func (v *compositing) SupportedOpenGLPlatformInterfaces() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "supportedOpenGLPlatformInterfaces", } } // property platformRequiresCompositing b func (v *compositing) PlatformRequiresCompositing() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "platformRequiresCompositing", } } type InputDeviceManager struct { inputDeviceManager // interface org.kde.KWin.InputDeviceManager proxy.Object } func NewInputDeviceManager(conn *dbus.Conn) *InputDeviceManager { obj := new(InputDeviceManager) obj.Object.Init_(conn, "org.kde.KWin", "/org/kde/KWin/InputDevice") return obj } type inputDeviceManager struct{} func (v *inputDeviceManager) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*inputDeviceManager) GetInterfaceName_() string { return "org.kde.KWin.InputDeviceManager" } // signal deviceAdded func (v *inputDeviceManager) ConnectDeviceAdded(cb func(sysName string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "deviceAdded", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".deviceAdded", } handlerFunc := func(sig *dbus.Signal) { var sysName string err := dbus.Store(sig.Body, &sysName) if err == nil { cb(sysName) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // signal deviceRemoved func (v *inputDeviceManager) ConnectDeviceRemoved(cb func(sysName string)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "deviceRemoved", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".deviceRemoved", } handlerFunc := func(sig *dbus.Signal) { var sysName string err := dbus.Store(sig.Body, &sysName) if err == nil { cb(sysName) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property devicesSysNames as func (v *inputDeviceManager) DevicesSysNames() proxy.PropStringArray { return proxy.PropStringArray{ Impl: v, Name: "devicesSysNames", } } type InputDevice struct { inputDevice // interface org.kde.KWin.InputDevice proxy.Object } func NewInputDevice(conn *dbus.Conn, path dbus.ObjectPath) (*InputDevice, error) { if !path.IsValid() { return nil, errors.New("path is invalid") } obj := new(InputDevice) obj.Object.Init_(conn, "org.kde.KWin", path) return obj, nil } type inputDevice struct{} func (v *inputDevice) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*inputDevice) GetInterfaceName_() string { return "org.kde.KWin.InputDevice" } // property keyboard b func (v *inputDevice) Keyboard() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "keyboard", } } // property alphaNumericKeyboard b func (v *inputDevice) AlphaNumericKeyboard() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "alphaNumericKeyboard", } } // property pointer b func (v *inputDevice) Pointer() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "pointer", } } // property touchpad b func (v *inputDevice) Touchpad() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "touchpad", } } // property touch b func (v *inputDevice) Touch() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "touch", } } // property tabletTool b func (v *inputDevice) TabletTool() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "tabletTool", } } // property tabletPad b func (v *inputDevice) TabletPad() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "tabletPad", } } // property gestureSupport b func (v *inputDevice) GestureSupport() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "gestureSupport", } } // property name s func (v *inputDevice) Name() proxy.PropString { return proxy.PropString{ Impl: v, Name: "name", } } // property sysName s func (v *inputDevice) SysName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "sysName", } } // property outputName s func (v *inputDevice) OutputName() proxy.PropString { return proxy.PropString{ Impl: v, Name: "outputName", } } // property product u func (v *inputDevice) Product() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "product", } } // property vendor u func (v *inputDevice) Vendor() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "vendor", } } // property supportsDisableEvents b func (v *inputDevice) SupportsDisableEvents() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsDisableEvents", } } // property enabled b func (v *inputDevice) Enabled() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "enabled", } } // property supportedButtons i func (v *inputDevice) SupportedButtons() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "supportedButtons", } } // property supportsCalibrationMatrix b func (v *inputDevice) SupportsCalibrationMatrix() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsCalibrationMatrix", } } // property supportsLeftHanded b func (v *inputDevice) SupportsLeftHanded() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsLeftHanded", } } // property leftHandedEnabledByDefault b func (v *inputDevice) LeftHandedEnabledByDefault() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "leftHandedEnabledByDefault", } } // property leftHanded b func (v *inputDevice) LeftHanded() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "leftHanded", } } // property supportsDisableEventsOnExternalMouse b func (v *inputDevice) SupportsDisableEventsOnExternalMouse() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsDisableEventsOnExternalMouse", } } // property supportsDisableWhileTyping b func (v *inputDevice) SupportsDisableWhileTyping() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsDisableWhileTyping", } } // property disableWhileTypingEnabledByDefault b func (v *inputDevice) DisableWhileTypingEnabledByDefault() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "disableWhileTypingEnabledByDefault", } } // property disableWhileTyping b func (v *inputDevice) DisableWhileTyping() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "disableWhileTyping", } } // property supportsPointerAcceleration b func (v *inputDevice) SupportsPointerAcceleration() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsPointerAcceleration", } } // property defaultPointerAcceleration d func (v *inputDevice) DefaultPointerAcceleration() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "defaultPointerAcceleration", } } // property pointerAcceleration d func (v *inputDevice) PointerAcceleration() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "pointerAcceleration", } } // property supportsPointerAccelerationProfileFlat b func (v *inputDevice) SupportsPointerAccelerationProfileFlat() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsPointerAccelerationProfileFlat", } } // property defaultPointerAccelerationProfileFlat b func (v *inputDevice) DefaultPointerAccelerationProfileFlat() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "defaultPointerAccelerationProfileFlat", } } // property pointerAccelerationProfileFlat b func (v *inputDevice) PointerAccelerationProfileFlat() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "pointerAccelerationProfileFlat", } } // property supportsPointerAccelerationProfileAdaptive b func (v *inputDevice) SupportsPointerAccelerationProfileAdaptive() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsPointerAccelerationProfileAdaptive", } } // property defaultPointerAccelerationProfileAdaptive b func (v *inputDevice) DefaultPointerAccelerationProfileAdaptive() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "defaultPointerAccelerationProfileAdaptive", } } // property pointerAccelerationProfileAdaptive b func (v *inputDevice) PointerAccelerationProfileAdaptive() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "pointerAccelerationProfileAdaptive", } } // property tapFingerCount i func (v *inputDevice) TapFingerCount() proxy.PropInt32 { return proxy.PropInt32{ Impl: v, Name: "tapFingerCount", } } // property tapToClickEnabledByDefault b func (v *inputDevice) TapToClickEnabledByDefault() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "tapToClickEnabledByDefault", } } // property tapToClick b func (v *inputDevice) TapToClick() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "tapToClick", } } // property supportsLmrTapButtonMap b func (v *inputDevice) SupportsLmrTapButtonMap() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsLmrTapButtonMap", } } // property lmrTapButtonMapEnabledByDefault b func (v *inputDevice) LmrTapButtonMapEnabledByDefault() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "lmrTapButtonMapEnabledByDefault", } } // property lmrTapButtonMap b func (v *inputDevice) LmrTapButtonMap() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "lmrTapButtonMap", } } // property tapAndDragEnabledByDefault b func (v *inputDevice) TapAndDragEnabledByDefault() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "tapAndDragEnabledByDefault", } } // property tapAndDrag b func (v *inputDevice) TapAndDrag() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "tapAndDrag", } } // property tapDragLockEnabledByDefault b func (v *inputDevice) TapDragLockEnabledByDefault() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "tapDragLockEnabledByDefault", } } // property tapDragLock b func (v *inputDevice) TapDragLock() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "tapDragLock", } } // property supportsMiddleEmulation b func (v *inputDevice) SupportsMiddleEmulation() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsMiddleEmulation", } } // property middleEmulationEnabledByDefault b func (v *inputDevice) MiddleEmulationEnabledByDefault() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "middleEmulationEnabledByDefault", } } // property middleEmulation b func (v *inputDevice) MiddleEmulation() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "middleEmulation", } } // property supportsNaturalScroll b func (v *inputDevice) SupportsNaturalScroll() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsNaturalScroll", } } // property naturalScrollEnabledByDefault b func (v *inputDevice) NaturalScrollEnabledByDefault() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "naturalScrollEnabledByDefault", } } // property naturalScroll b func (v *inputDevice) NaturalScroll() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "naturalScroll", } } // property supportsScrollTwoFinger b func (v *inputDevice) SupportsScrollTwoFinger() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsScrollTwoFinger", } } // property scrollTwoFingerEnabledByDefault b func (v *inputDevice) ScrollTwoFingerEnabledByDefault() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "scrollTwoFingerEnabledByDefault", } } // property scrollTwoFinger b func (v *inputDevice) ScrollTwoFinger() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "scrollTwoFinger", } } // property supportsScrollEdge b func (v *inputDevice) SupportsScrollEdge() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsScrollEdge", } } // property scrollEdgeEnabledByDefault b func (v *inputDevice) ScrollEdgeEnabledByDefault() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "scrollEdgeEnabledByDefault", } } // property scrollEdge b func (v *inputDevice) ScrollEdge() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "scrollEdge", } } // property supportsScrollOnButtonDown b func (v *inputDevice) SupportsScrollOnButtonDown() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsScrollOnButtonDown", } } // property scrollOnButtonDownEnabledByDefault b func (v *inputDevice) ScrollOnButtonDownEnabledByDefault() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "scrollOnButtonDownEnabledByDefault", } } // property defaultScrollButton u func (v *inputDevice) DefaultScrollButton() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "defaultScrollButton", } } // property scrollOnButtonDown b func (v *inputDevice) ScrollOnButtonDown() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "scrollOnButtonDown", } } // property scrollButton u func (v *inputDevice) ScrollButton() proxy.PropUint32 { return proxy.PropUint32{ Impl: v, Name: "scrollButton", } } // property switchDevice b func (v *inputDevice) SwitchDevice() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "switchDevice", } } // property lidSwitch b func (v *inputDevice) LidSwitch() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "lidSwitch", } } // property tabletModeSwitch b func (v *inputDevice) TabletModeSwitch() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "tabletModeSwitch", } } // property supportsClickMethodAreas b func (v *inputDevice) SupportsClickMethodAreas() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsClickMethodAreas", } } // property defaultClickMethodAreas b func (v *inputDevice) DefaultClickMethodAreas() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "defaultClickMethodAreas", } } // property clickMethodAreas b func (v *inputDevice) ClickMethodAreas() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "clickMethodAreas", } } // property supportsClickMethodClickfinger b func (v *inputDevice) SupportsClickMethodClickfinger() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "supportsClickMethodClickfinger", } } // property defaultClickMethodClickfinger b func (v *inputDevice) DefaultClickMethodClickfinger() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "defaultClickMethodClickfinger", } } // property clickMethodClickfinger b func (v *inputDevice) ClickMethodClickfinger() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "clickMethodClickfinger", } } go-dbus-factory-1.9.6/org.kde.kwin/config.json000066400000000000000000000012151403054572700212020ustar00rootroot00000000000000{ "Service": "org.kde.KWin", "Objects": [ { "Type": "Compositor", "Path": "/Compositor", "Interfaces": [ { "Name": "org.kde.kwin.Compositing", "Type": "compositing" } ] }, { "Type": "InputDeviceManager", "Path": "/org/kde/KWin/InputDevice", "Interfaces": [ { "Name": "org.kde.KWin.InputDeviceManager", "Type": "inputDeviceManager" } ] }, { "Type": "InputDevice", "Interfaces": [ { "Name": "org.kde.KWin.InputDevice", "Type": "inputDevice" } ] } ] } go-dbus-factory-1.9.6/org.mpris.mediaplayer2/000077500000000000000000000000001403054572700210405ustar00rootroot00000000000000go-dbus-factory-1.9.6/org.mpris.mediaplayer2/MediaPlayer.xml000066400000000000000000000054561403054572700237700ustar00rootroot00000000000000 go-dbus-factory-1.9.6/org.mpris.mediaplayer2/auto.go000066400000000000000000000164361403054572700223510ustar00rootroot00000000000000// Code generated by "./generator ./org.mpris.mediaplayer2"; DO NOT EDIT. package mediaplayer2 import ( "errors" "fmt" "unsafe" "github.com/godbus/dbus" "pkg.deepin.io/lib/dbusutil" "pkg.deepin.io/lib/dbusutil/proxy" ) type MediaPlayer struct { mediaPlayer // interface org.mpris.MediaPlayer2 player // interface org.mpris.MediaPlayer2.Player proxy.Object } func NewMediaPlayer(conn *dbus.Conn, serviceName string) *MediaPlayer { obj := new(MediaPlayer) obj.Object.Init_(conn, serviceName, "/org/mpris/MediaPlayer2") return obj } func (obj *MediaPlayer) MediaPlayer2() *mediaPlayer { return &obj.mediaPlayer } type mediaPlayer struct{} func (v *mediaPlayer) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*mediaPlayer) GetInterfaceName_() string { return "org.mpris.MediaPlayer2" } // method Quit func (v *mediaPlayer) GoQuit(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Quit", flags, ch) } func (v *mediaPlayer) Quit(flags dbus.Flags) error { return (<-v.GoQuit(flags, make(chan *dbus.Call, 1)).Done).Err } // method Raise func (v *mediaPlayer) GoRaise(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Raise", flags, ch) } func (v *mediaPlayer) Raise(flags dbus.Flags) error { return (<-v.GoRaise(flags, make(chan *dbus.Call, 1)).Done).Err } // property CanQuit b func (v *mediaPlayer) CanQuit() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanQuit", } } // property CanRaise b func (v *mediaPlayer) CanRaise() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanRaise", } } // property DesktopEntry s func (v *mediaPlayer) DesktopEntry() proxy.PropString { return proxy.PropString{ Impl: v, Name: "DesktopEntry", } } // property Identity s func (v *mediaPlayer) Identity() proxy.PropString { return proxy.PropString{ Impl: v, Name: "Identity", } } func (obj *MediaPlayer) Player() *player { return &obj.player } type player struct{} func (v *player) GetObject_() *proxy.Object { return (*proxy.Object)(unsafe.Pointer(v)) } func (*player) GetInterfaceName_() string { return "org.mpris.MediaPlayer2.Player" } // method Next func (v *player) GoNext(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Next", flags, ch) } func (v *player) Next(flags dbus.Flags) error { return (<-v.GoNext(flags, make(chan *dbus.Call, 1)).Done).Err } // method Pause func (v *player) GoPause(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Pause", flags, ch) } func (v *player) Pause(flags dbus.Flags) error { return (<-v.GoPause(flags, make(chan *dbus.Call, 1)).Done).Err } // method Play func (v *player) GoPlay(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Play", flags, ch) } func (v *player) Play(flags dbus.Flags) error { return (<-v.GoPlay(flags, make(chan *dbus.Call, 1)).Done).Err } // method PlayPause func (v *player) GoPlayPause(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".PlayPause", flags, ch) } func (v *player) PlayPause(flags dbus.Flags) error { return (<-v.GoPlayPause(flags, make(chan *dbus.Call, 1)).Done).Err } // method Previous func (v *player) GoPrevious(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Previous", flags, ch) } func (v *player) Previous(flags dbus.Flags) error { return (<-v.GoPrevious(flags, make(chan *dbus.Call, 1)).Done).Err } // method Seek func (v *player) GoSeek(flags dbus.Flags, ch chan *dbus.Call, Offset int64) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Seek", flags, ch, Offset) } func (v *player) Seek(flags dbus.Flags, Offset int64) error { return (<-v.GoSeek(flags, make(chan *dbus.Call, 1), Offset).Done).Err } // method SetPosition func (v *player) GoSetPosition(flags dbus.Flags, ch chan *dbus.Call, TrackId dbus.ObjectPath, Position int64) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".SetPosition", flags, ch, TrackId, Position) } func (v *player) SetPosition(flags dbus.Flags, TrackId dbus.ObjectPath, Position int64) error { return (<-v.GoSetPosition(flags, make(chan *dbus.Call, 1), TrackId, Position).Done).Err } // method Stop func (v *player) GoStop(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call { return v.GetObject_().Go_(v.GetInterfaceName_()+".Stop", flags, ch) } func (v *player) Stop(flags dbus.Flags) error { return (<-v.GoStop(flags, make(chan *dbus.Call, 1)).Done).Err } // signal Seeked func (v *player) ConnectSeeked(cb func(Position int64)) (dbusutil.SignalHandlerId, error) { if cb == nil { return 0, errors.New("nil callback") } obj := v.GetObject_() rule := fmt.Sprintf( "type='signal',interface='%s',member='%s',path='%s',sender='%s'", v.GetInterfaceName_(), "Seeked", obj.Path_(), obj.ServiceName_()) sigRule := &dbusutil.SignalRule{ Path: obj.Path_(), Name: v.GetInterfaceName_() + ".Seeked", } handlerFunc := func(sig *dbus.Signal) { var Position int64 err := dbus.Store(sig.Body, &Position) if err == nil { cb(Position) } } return obj.ConnectSignal_(rule, sigRule, handlerFunc) } // property CanControl b func (v *player) CanControl() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanControl", } } // property CanGoNext b func (v *player) CanGoNext() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanGoNext", } } // property CanGoPrevious b func (v *player) CanGoPrevious() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanGoPrevious", } } // property CanPause b func (v *player) CanPause() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanPause", } } // property CanPlay b func (v *player) CanPlay() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanPlay", } } // property CanSeek b func (v *player) CanSeek() proxy.PropBool { return proxy.PropBool{ Impl: v, Name: "CanSeek", } } // property Metadata a{sv} func (v *player) Metadata() PropPlayerMetadata { return PropPlayerMetadata{ Impl: v, } } type PropPlayerMetadata struct { Impl proxy.Implementer } func (p PropPlayerMetadata) Get(flags dbus.Flags) (value map[string]dbus.Variant, err error) { err = p.Impl.GetObject_().GetProperty_(flags, p.Impl.GetInterfaceName_(), "Metadata", &value) return } func (p PropPlayerMetadata) ConnectChanged(cb func(hasValue bool, value map[string]dbus.Variant)) error { if cb == nil { return errors.New("nil callback") } cb0 := func(hasValue bool, value interface{}) { if hasValue { var v map[string]dbus.Variant err := dbus.Store([]interface{}{value}, &v) if err != nil { return } cb(true, v) } else { cb(false, nil) } } return p.Impl.GetObject_().ConnectPropertyChanged_(p.Impl.GetInterfaceName_(), "Metadata", cb0) } // property PlaybackStatus s func (v *player) PlaybackStatus() proxy.PropString { return proxy.PropString{ Impl: v, Name: "PlaybackStatus", } } // property Position x func (v *player) Position() proxy.PropInt64 { return proxy.PropInt64{ Impl: v, Name: "Position", } } // property Volume d func (v *player) Volume() proxy.PropDouble { return proxy.PropDouble{ Impl: v, Name: "Volume", } } go-dbus-factory-1.9.6/org.mpris.mediaplayer2/config.json000066400000000000000000000010371403054572700232010ustar00rootroot00000000000000{ "Service1": "org.mpris.MediaPlayer2", "Objects": [ { "Type": "MediaPlayer", "Path": "/org/mpris/MediaPlayer2", "Interfaces": [ { "Name": "org.mpris.MediaPlayer2", "Type": "mediaPlayer" }, { "Name": "org.mpris.MediaPlayer2.Player", "Type": "player", "Fixes": { "p/Metadata": { "Type": "PropPlayerMetadata", "ValueType": "map[string]dbus.Variant" } } } ] } ] } go-dbus-factory-1.9.6/rpm/000077500000000000000000000000001403054572700153415ustar00rootroot00000000000000go-dbus-factory-1.9.6/rpm/golang-github-linuxdeepin-dbus-factory.spec000066400000000000000000000027751403054572700257010ustar00rootroot00000000000000# Run tests in check section # disable for bootstrapping %bcond_with check %global pkgname github.com/linuxdeepin/go-dbus-factory #2020-04-26增加%global with_debug 1 %global with_debug 1 %if 0%{?with_debug} %global debug_package %{nil} %endif Name: golang-github-linuxdeepin-go-dbus-factory Version: 1.9.2 Release: 1 Summary: GO DBus factory for Deepin Desktop Environment License: GPLv3 URL: %{gourl} Source0: %{name}-%{version}.tar.gz BuildRequires: compiler(go-compiler) BuildRequires: go-srpm-macros %description %{summary}. %package -n %{name}-devel Summary: %{summary} BuildArch: noarch %description -n %{name}-devel %{summary}. %prep %forgeautosetup %install install -d -p %{buildroot}%{gopath}/src/%{pkgname}/ for file in $(find . -iname "*.go" | grep -v "_tool") ; do install -d -p %{buildroot}%{gopath}/src/%{pkgname}/$(dirname $file) cp -pav $file %{buildroot}%{gopath}/src/%{pkgname}/$file echo "%%{gopath}/src/%%{pkgname}/$file" >> devel.file-list done cp -pav README.md %{buildroot}%{gopath}/src/%{pkgname}/README.md cp -pav CHANGELOG.md %{buildroot}%{gopath}/src/%{pkgname}/CHANGELOG.md echo "%%{gopath}/src/%%{pkgname}/README.md" >> devel.file-list echo "%%{gopath}/src/%%{pkgname}/CHANGELOG.md" >> devel.file-list %if %{with check} %check %gochecks %endif %files -n %{name}-devel -f devel.file-list %doc README.md CHANGELOG.md %changelog * Thu Mar 18 2021 uoser - 1.9.2-1 - Update to 1.9.2