From fb8b3a0fec44b8df7a1c30b611ff28982978278d Mon Sep 17 00:00:00 2001 From: a-sansara Date: Tue, 20 Apr 2010 10:29:27 +0000 Subject: [PATCH] 0.31 --- 0.3x/doc/gpl.txt | 674 ++++++++++++++++ 0.3x/gpyfsa | 5 + 0.3x/gpyfsa.pot | 217 +++++ 0.3x/locale/fr/LC_MESSAGES/gpyfsa.mo | Bin 0 -> 2778 bytes 0.3x/locale/fr/LC_MESSAGES/gpyfsa.po | 220 ++++++ 0.3x/res/gpyfsa.glade | 1100 ++++++++++++++++++++++++++ 0.3x/res/gpyfsa.glade.h | 32 + 0.3x/res/img/gpyfsa.png | Bin 0 -> 12204 bytes 0.3x/res/img/gpyfsa.svg | 71 ++ 0.3x/res/img/gpyfsa_dev.png | Bin 0 -> 12204 bytes 0.3x/res/img/gpyfsa_dev.svg | 70 ++ 0.3x/res/img/gpyfsa_devlocked.png | Bin 0 -> 12204 bytes 0.3x/res/img/gpyfsa_devlocked.svg | 68 ++ 0.3x/res/img/gpyfsa_refresh.svg | 68 ++ 0.3x/res/img/gpyfsa_tab1.png | Bin 0 -> 12204 bytes 0.3x/res/img/gpyfsa_tab1.svg | 68 ++ 0.3x/res/img/gpyfsa_tab2.png | Bin 0 -> 12204 bytes 0.3x/res/img/gpyfsa_tab2.svg | 68 ++ 0.3x/res/img/gpyfsa_tab3.png | Bin 0 -> 12204 bytes 0.3x/res/img/gpyfsa_tab3.svg | 68 ++ 0.3x/src/gpyfsa_conf.py | 91 +++ 0.3x/src/gpyfsa_devlistmanager.py | 203 +++++ 0.3x/src/gpyfsa_fsa.py | 188 +++++ 0.3x/src/gpyfsa_main.py | 244 ++++++ 0.3x/src/gpyfsa_savefs.py | 32 + 0.3x/src/gpyfsa_shell.py | 65 ++ 0.3x/src/gpyfsa_ui.py | 162 ++++ 27 files changed, 3714 insertions(+) create mode 100755 0.3x/doc/gpl.txt create mode 100755 0.3x/gpyfsa create mode 100644 0.3x/gpyfsa.pot create mode 100644 0.3x/locale/fr/LC_MESSAGES/gpyfsa.mo create mode 100644 0.3x/locale/fr/LC_MESSAGES/gpyfsa.po create mode 100644 0.3x/res/gpyfsa.glade create mode 100644 0.3x/res/gpyfsa.glade.h create mode 100644 0.3x/res/img/gpyfsa.png create mode 100644 0.3x/res/img/gpyfsa.svg create mode 100644 0.3x/res/img/gpyfsa_dev.png create mode 100644 0.3x/res/img/gpyfsa_dev.svg create mode 100644 0.3x/res/img/gpyfsa_devlocked.png create mode 100644 0.3x/res/img/gpyfsa_devlocked.svg create mode 100644 0.3x/res/img/gpyfsa_refresh.svg create mode 100644 0.3x/res/img/gpyfsa_tab1.png create mode 100644 0.3x/res/img/gpyfsa_tab1.svg create mode 100644 0.3x/res/img/gpyfsa_tab2.png create mode 100644 0.3x/res/img/gpyfsa_tab2.svg create mode 100644 0.3x/res/img/gpyfsa_tab3.png create mode 100644 0.3x/res/img/gpyfsa_tab3.svg create mode 100644 0.3x/src/gpyfsa_conf.py create mode 100644 0.3x/src/gpyfsa_devlistmanager.py create mode 100644 0.3x/src/gpyfsa_fsa.py create mode 100644 0.3x/src/gpyfsa_main.py create mode 100644 0.3x/src/gpyfsa_savefs.py create mode 100644 0.3x/src/gpyfsa_shell.py create mode 100755 0.3x/src/gpyfsa_ui.py diff --git a/0.3x/doc/gpl.txt b/0.3x/doc/gpl.txt new file mode 100755 index 0000000..94a9ed0 --- /dev/null +++ b/0.3x/doc/gpl.txt @@ -0,0 +1,674 @@ + 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 +. diff --git a/0.3x/gpyfsa b/0.3x/gpyfsa new file mode 100755 index 0000000..86bea89 --- /dev/null +++ b/0.3x/gpyfsa @@ -0,0 +1,5 @@ +#!/bin/sh + +dn=$(dirname $0) +cd $dn +gksu python "src/gpyfsa_main.py" diff --git a/0.3x/gpyfsa.pot b/0.3x/gpyfsa.pot new file mode 100644 index 0000000..f266475 --- /dev/null +++ b/0.3x/gpyfsa.pot @@ -0,0 +1,217 @@ +# GPyFSA - a gtk+ GUI front-end of fsarchiver +# Copyright (C) 2010 +# This file is distributed under the same license as the gpyfsa package. +# a-sansara , 2010. +# +msgid "" +msgstr "" +"Project-Id-Version: PACKAGE VERSION\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2010-04-19 13:13+0200\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: a-Sansara \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=CHARSET\n" +"Content-Transfer-Encoding: 8bit\n" + +#: res/gpyfsa.glade.h:1 +msgid "(1: very fast to 9: very good)" +msgstr "" + +#: res/gpyfsa.glade.h:2 +msgid "(usefull on multi-core cpu)" +msgstr "" + +#: res/gpyfsa.glade.h:3 +msgid "Main Options" +msgstr "" + +#: res/gpyfsa.glade.h:4 +msgid "Advanced Options" +msgstr "" + +#: res/gpyfsa.glade.h:5 +msgid "Archives" +msgstr "" + +#: res/gpyfsa.glade.h:6 +msgid "E_dit" +msgstr "" + +#: res/gpyfsa.glade.h:7 +msgid "GPyFSA" +msgstr "" + +#: res/gpyfsa.glade.h:8 +msgid "H_elp" +msgstr "" + +#: res/gpyfsa.glade.h:9 +msgid "MB each" +msgstr "" + +#: res/gpyfsa.glade.h:10 +msgid "Restore FS" +msgstr "" + +#: res/gpyfsa.glade.h:11 +msgid "Save FS" +msgstr "" + +#: res/gpyfsa.glade.h:12 +msgid "_Files" +msgstr "" + +#: res/gpyfsa.glade.h:13 +msgid "archive description :" +msgstr "" + +#: res/gpyfsa.glade.h:14 +msgid "archive path :" +msgstr "" + +#: res/gpyfsa.glade.h:15 +msgid "browse" +msgstr "" + +#: res/gpyfsa.glade.h:16 +msgid "compression level :" +msgstr "" + +#: res/gpyfsa.glade.h:17 +msgid "compression thread :" +msgstr "" + +#: res/gpyfsa.glade.h:18 +msgid "confirm :" +msgstr "" + +#: res/gpyfsa.glade.h:19 +msgid "debug mode" +msgstr "" + +#: res/gpyfsa.glade.h:20 +msgid "devices" +msgstr "" + +#: res/gpyfsa.glade.h:21 +msgid "don't confirm" +msgstr "" + +#: res/gpyfsa.glade.h:22 +msgid "encrypt data in archive (6 to 64 characters max) :" +msgstr "" + +#: res/gpyfsa.glade.h:23 +msgid "exclude files and directories that match the pattern :" +msgstr "" + +#: res/gpyfsa.glade.h:24 +msgid "force .fsa extension" +msgstr "" + +#: res/gpyfsa.glade.h:25 +msgid "log" +msgstr "" + +#: res/gpyfsa.glade.h:26 +msgid "overwrite existing archive" +msgstr "" + +#: res/gpyfsa.glade.h:27 +msgid "password :" +msgstr "" + +#: res/gpyfsa.glade.h:28 +msgid "refresh" +msgstr "" + +#: res/gpyfsa.glade.h:29 +msgid "running..." +msgstr "" + +#: res/gpyfsa.glade.h:30 +msgid "show password" +msgstr "" + +#: res/gpyfsa.glade.h:31 +msgid "split archive into several files of :" +msgstr "" + +#: res/gpyfsa.glade.h:32 +msgid "verboose mode" +msgstr "" + +#: src/gpyfsa_conf.py:65 +msgid "device" +msgstr "" + +#: src/gpyfsa_conf.py:65 +msgid "type" +msgstr "" + +#: src/gpyfsa_conf.py:65 +msgid "label" +msgstr "" + +#: src/gpyfsa_conf.py:65 +msgid "size" +msgstr "" + +#: src/gpyfsa_conf.py:65 +msgid "used" +msgstr "" + +#: src/gpyfsa_conf.py:65 +msgid "free" +msgstr "" + +#: src/gpyfsa_conf.py:65 +#, python-format +msgid "%used" +msgstr "" + +#: src/gpyfsa_conf.py:65 +msgid "mount point" +msgstr "" + +#: src/gpyfsa_conf.py:72 +msgid "Save archive" +msgstr "" + +#: src/gpyfsa_conf.py:72 +msgid "all" +msgstr "" + +#: src/gpyfsa_conf.py:72 +msgid "fsa archive" +msgstr "" + +#: src/gpyfsa_conf.py:76 +msgid "pls wait ..." +msgstr "" + +#: src/gpyfsa_conf.py:77 +msgid "work in progress - " +msgstr "" + +#: src/gpyfsa_conf.py:78 +#, python-format +msgid "mount %s" +msgstr "" + +#: src/gpyfsa_conf.py:79 +#, python-format +msgid "mount %s read-only" +msgstr "" + +#: src/gpyfsa_conf.py:80 +#, python-format +msgid "remount %s read-only" +msgstr "" + +#: src/gpyfsa_conf.py:81 +#, python-format +msgid "unmount %s" +msgstr "" diff --git a/0.3x/locale/fr/LC_MESSAGES/gpyfsa.mo b/0.3x/locale/fr/LC_MESSAGES/gpyfsa.mo new file mode 100644 index 0000000000000000000000000000000000000000..12061cab7abe6f3f2fc2104305fd4a6a795fae58 GIT binary patch literal 2778 zcmZ{kyKfvt9LI+c9yuUD2oN42KL{pvoOOIoVv_R%oWuuFVrx*YWN&7f znLXQS5fY-Hi$sGIC?FP(f+9+)AYDO&kSHiVu zS^jNs0Q?K&b336NuRjCwz865Y=MZ=SK7Ji!dp?6u0>1?JgI$pC{}X&1+y*6C&)xWg zXt5XMbNj(Z!2o3WQ{a=}+2Xqd`TmO_+n0i@*N5QK;HTgo@GFr0ezW-g3&`?+2l@Wn z;A`OD;3RkqANjlmS>7ig`|WZu{{qBMe2YJ};~L2M@hkWW_y@@M?Z9D{zX#;=2SLui zagg;|0^uT&fQLW_avZLJP(^%K%&&n@VcrGdRxyOP{|pub_7D4({l$9;FF*V6zKECa z=|3F9JZ{AT`;;GqBfmeN;E!$MrzjKga&Madvz;(A&y#~7*A3gqdUFnN{jiN}FZ+o7 zZ~!mImt)2L8OFO8FU-p81IQot{YyL=$efDAV7WpaW!I=7ohNVTL@{p~6Ag($Y-(gl zLPk?NOMD!J#wrTaY)DMjr{`p>X+HI_(Qfi^eOk;!9jQYV^%uqLauj><=CVpsF?W)b z3|nGRInPq6OJYfOHYsh`iaSaySK~xEA(KQDOO#6AqKc?nv*MHpO*^&9Ib2JL>Zk;t zwyyb>RWiyKbtATIj3QOfn$$Lt!mtyEfYAp$g(lx2ln(7$>M4?55{&9!JUGry89z#4 zOIjIvWgWHU>JUV#)iB8-MGe-Lq>d)(r}X0 zs#lt=5Dlx8;HAC~5?NP?Xq!xX8gLr}V#5NXleJ=>AcQM6_6j0n=VRU65R^*i zR*YqDq=};y8G9NT84*_DPS*namu!*kT4n_*_f85IUsA%Q2~PIif=dlKxZcX7aDZvx zicI&Vi9Efqp>B**Jybq@ZXQJRdoC{}EXkq5m*_k(H>HO^C z(wX_UN{cEr)(3O08Arj%tm%T9sZeQQz80K}ZRLVz& zN5@7-u`yUg&{_C@>>H~bd$qUk9BLq_S*cwj5ylG9B=W-}>@-s&8901F7SQSW8foRH zOXs9+X0oY*nv(4bRV~t}Rhm09H@j&}d1SP73R0AY?6nk1dc^&3nxJ+j^0acwPrY5M z2FEw|u?`JogIOJ#2;r>I@p|k_3rPlt2UTO+u0lG^r*3L&f_lTLK~2+C9-1hjynUR+ zuDhO>xVPP_j;u^$By7M%-dm{~%|(u_NKunn4o!&2C=C1cj&WY>MV-@vjdd8O5?P!TL!VUoYflrLuLedTl+yp^g4ngrSJMs)PGN-3W^Fx^IjoR zX?@I!3J!a}QREx@-9kZ6lsY-(BJU{dLEeqr7SN-+9$M%`4r!4$yI!Y;Ke^pNLj=8T&^@`)A$z#l zz*9(hb%|Uj?R6a4u(JC-f@$-v^S>I%2Kyv;E|l1mD!hynXc$2qlfhA2d<`>D0xm|f jZn%`y;mw<7Z#XEAGdCxdtqO0^6jdAA_VR;8pfmjg^|QDC literal 0 HcmV?d00001 diff --git a/0.3x/locale/fr/LC_MESSAGES/gpyfsa.po b/0.3x/locale/fr/LC_MESSAGES/gpyfsa.po new file mode 100644 index 0000000..702759f --- /dev/null +++ b/0.3x/locale/fr/LC_MESSAGES/gpyfsa.po @@ -0,0 +1,220 @@ +# GPyFSA - a gtk+ GUI front-end of fsarchiver +# Copyright (C) 2010 +# This file is distributed under the same license as the gpyfsa package. +# a-sansara , 2010. +# +msgid "" +msgstr "" +"Project-Id-Version: PACKAGE VERSION\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2010-04-19 13:13+0200\n" +"PO-Revision-Date: 2010-04-19 12:57+0200\n" +"Last-Translator: \n" +"Language-Team: French\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n > 1);\n" + +#: res/gpyfsa.glade.h:1 +msgid "(1: very fast to 9: very good)" +msgstr "(1: très rapide - 9: très bon)" + +#: res/gpyfsa.glade.h:2 +msgid "(usefull on multi-core cpu)" +msgstr "(utile pour processeur multi-coeur)" + +#: res/gpyfsa.glade.h:3 +msgid "Main Options" +msgstr "Options Principales" + +#: res/gpyfsa.glade.h:4 +msgid "Advanced Options" +msgstr "Options Avancées" + +#: res/gpyfsa.glade.h:5 +msgid "Archives" +msgstr "" + +#: res/gpyfsa.glade.h:6 +msgid "E_dit" +msgstr "E_dition" + +#: res/gpyfsa.glade.h:7 +msgid "GPyFSA" +msgstr "" + +#: res/gpyfsa.glade.h:8 +msgid "H_elp" +msgstr "Aid_e" + +#: res/gpyfsa.glade.h:9 +msgid "MB each" +msgstr "MB chacun" + +#: res/gpyfsa.glade.h:10 +msgid "Restore FS" +msgstr "Restauration SF" + +#: res/gpyfsa.glade.h:11 +msgid "Save FS" +msgstr "Sauvegarde SF" + +#: res/gpyfsa.glade.h:12 +msgid "_Files" +msgstr "_Fichiers" + +#: res/gpyfsa.glade.h:13 +#, fuzzy +msgid "archive description :" +msgstr "chemin d'archive :" + +#: res/gpyfsa.glade.h:14 +msgid "archive path :" +msgstr "chemin d'archive :" + +#: res/gpyfsa.glade.h:15 +msgid "browse" +msgstr "choisir..." + +#: res/gpyfsa.glade.h:16 +msgid "compression level :" +msgstr "niveau de compression :" + +#: res/gpyfsa.glade.h:17 +msgid "compression thread :" +msgstr "threads en compression :" + +#: res/gpyfsa.glade.h:18 +msgid "confirm :" +msgstr "confirmation :" + +#: res/gpyfsa.glade.h:19 +msgid "debug mode" +msgstr "mode debug" + +#: res/gpyfsa.glade.h:20 +#, fuzzy +msgid "devices" +msgstr "partition" + +#: res/gpyfsa.glade.h:21 +msgid "don't confirm" +msgstr "sans confirmation" + +#: res/gpyfsa.glade.h:22 +msgid "encrypt data in archive (6 to 64 characters max) :" +msgstr "encrypter les données dans l'archive (6 à 64 caractères max)" + +#: res/gpyfsa.glade.h:23 +msgid "exclude files and directories that match the pattern :" +msgstr "exclure les fichiers et répertoires répondant au pattern :" + +#: res/gpyfsa.glade.h:24 +msgid "force .fsa extension" +msgstr "forcer l'extension .fsa" + +#: res/gpyfsa.glade.h:25 +msgid "log" +msgstr "" + +#: res/gpyfsa.glade.h:26 +msgid "overwrite existing archive" +msgstr "réécrire sur les archives existantes" + +#: res/gpyfsa.glade.h:27 +msgid "password :" +msgstr "mot de passe :" + +#: res/gpyfsa.glade.h:28 +msgid "refresh" +msgstr "rafraîchir" + +#: res/gpyfsa.glade.h:29 +msgid "running..." +msgstr "" + +#: res/gpyfsa.glade.h:30 +msgid "show password" +msgstr "afficher le mot de passe" + +#: res/gpyfsa.glade.h:31 +msgid "split archive into several files of :" +msgstr "découper l'archive en plusieurs fichier de " + +#: res/gpyfsa.glade.h:32 +msgid "verboose mode" +msgstr "mode verbeux" + +#: src/gpyfsa_conf.py:65 +msgid "device" +msgstr "partition" + +#: src/gpyfsa_conf.py:65 +msgid "type" +msgstr "" + +#: src/gpyfsa_conf.py:65 +msgid "label" +msgstr "étiquette" + +#: src/gpyfsa_conf.py:65 +msgid "size" +msgstr "taille" + +#: src/gpyfsa_conf.py:65 +msgid "used" +msgstr "utilisé" + +#: src/gpyfsa_conf.py:65 +msgid "free" +msgstr "inutilisé" + +#: src/gpyfsa_conf.py:65 +#, python-format +msgid "%used" +msgstr "%utilisé" + +#: src/gpyfsa_conf.py:65 +msgid "mount point" +msgstr "point de montage" + +#: src/gpyfsa_conf.py:72 +msgid "Save archive" +msgstr "Sauvegarder l'archive" + +#: src/gpyfsa_conf.py:72 +msgid "all" +msgstr "tous" + +#: src/gpyfsa_conf.py:72 +msgid "fsa archive" +msgstr "archive fsa" + +#: src/gpyfsa_conf.py:76 +msgid "pls wait ..." +msgstr "patientez svp ..." + +#: src/gpyfsa_conf.py:77 +msgid "work in progress - " +msgstr "traitement en cours - " + +#: src/gpyfsa_conf.py:78 +#, python-format +msgid "mount %s" +msgstr "monter %s" + +#: src/gpyfsa_conf.py:79 +#, python-format +msgid "mount %s read-only" +msgstr "monter %s en lecture seule" + +#: src/gpyfsa_conf.py:80 +#, python-format +msgid "remount %s read-only" +msgstr "remonter %s en lecture seule" + +#: src/gpyfsa_conf.py:81 +#, python-format +msgid "unmount %s" +msgstr "démonter %s" diff --git a/0.3x/res/gpyfsa.glade b/0.3x/res/gpyfsa.glade new file mode 100644 index 0000000..32b48af --- /dev/null +++ b/0.3x/res/gpyfsa.glade @@ -0,0 +1,1100 @@ + + + + + + + GPyFSA + center + 900 + 680 + True + img/gpyfsa.svg + + + + True + vertical + + + True + + + True + _Files + True + + + True + + + gtk-new + True + True + True + + + + + gtk-open + True + True + True + + + + + gtk-save + True + True + True + + + + + gtk-save-as + True + True + True + + + + + True + + + + + gtk-quit + True + True + True + + + + + + + + + True + E_dit + True + + + True + + + gtk-cut + True + True + True + + + + + gtk-copy + True + True + True + + + + + gtk-paste + True + True + True + + + + + gtk-delete + True + True + True + + + + + + + + + True + H_elp + True + + + True + + + gtk-about + True + True + True + + + + + + + + + False + 0 + + + + + True + 10 + 10 + 10 + 10 + + + True + True + left + + + True + 0 + none + + + True + 10 + 10 + 10 + + + True + vertical + + + True + 0.029999999329447746 + + + True + 10 + 10 + + + True + vertical + + + True + 4 + 8 + + + True + 4 + 3 + 8 + 3 + + + True + 1 + archive path : + + + GTK_FILL + + 5 + + + + + True + 1 + compression level : + + + 1 + 2 + GTK_FILL + + 5 + + + + + True + 1 + compression thread : + + + 2 + 3 + GTK_FILL + + 5 + + + + + overwrite existing archive + True + True + False + 0 + True + True + + + 2 + 3 + GTK_FILL + + + + + + True + + + True + + + 0 + + + + + browse + True + True + True + + + False + False + 1 + + + + + 1 + 2 + + + + + + True + + + True + + + False + 0 + + + + + True + 0 + (1: very fast to 9: very good) + + + 4 + 1 + + + + + 1 + 2 + 1 + 2 + + + + + + True + + + True + True + ● + 2 1 4 1 2 0 + + + False + False + 0 + + + + + True + 0 + (usefull on multi-core cpu) + + + 4 + 1 + + + + + 1 + 2 + 2 + 3 + + + + + + verboose mode + True + True + False + 0 + True + + + 2 + 3 + 2 + 3 + GTK_FILL + + + + + + force .fsa extension + True + True + False + 0 + True + True + + + 2 + 3 + 1 + 2 + GTK_FILL + + + + + + 142 + True + 1 + archive description : + + + 3 + 4 + GTK_FILL + 5 + + + + + True + True + ● + + + 1 + 3 + 3 + 4 + + + + + + + False + False + 0 + + + + + True + + + False + 1 + + + + + True + True + + + True + 18 + + + True + vertical + + + True + + + False + 0 + + + + + True + vertical + + + True + 6 + 3 + + + debug mode + True + True + False + 0 + 1 + True + + + + + 0 + + + + + True + + + split archive into several files of : + True + True + False + True + + + False + False + 0 + + + + + True + False + True + ● + 500 5 5000 5 50 0 + + + False + 5 + 1 + + + + + True + MB each + + + False + 2 + + + + + False + False + 4 + 1 + + + + + True + + + exclude files and directories that match the pattern : + True + True + False + True + + + False + False + 0 + + + + + True + False + True + ● + + + 4 + 1 + + + + + 2 + + + + + True + 6 + + + encrypt data in archive (6 to 64 characters max) : + True + True + False + True + + + + + 3 + + + + + True + 2 + 4 + 2 + + + show password + True + False + True + False + 1 + True + + + GTK_FILL + + 40 + + + + + True + False + 1 + password : + + + 1 + 2 + GTK_FILL + + 5 + + + + + True + False + 1 + confirm : + + + 1 + 2 + 1 + 2 + GTK_FILL + + 5 + + + + + True + False + True + False + ● + gtk-dialog-authentication + + + 2 + 3 + GTK_FILL + + + + + + True + False + True + False + ● + gtk-dialog-authentication + + + 2 + 3 + 1 + 2 + GTK_FILL + + + + + + don't confirm + 28 + True + False + True + False + True + + + 1 + 2 + GTK_FILL + + 40 + + + + + True + False + 0 + gtk-yes + + + 3 + 4 + GTK_FILL + + 5 + + + + + + + + False + False + 4 + 4 + + + + + 1 + + + + + + + + + True + Advanced Options + + + label_item + + + + + 2 + + + + + + + + + True + <b>Main Options</b> + True + + + label_item + + + + + False + False + 0 + + + + + True + + + True + + + True + refresh + + + 0 + + + + + 25 + True + img/gpyfsa_refresh.svg + + + 3 + 1 + + + + + False + False + 0 + + + + + + + + False + False + 2 + 1 + + + + + True + True + bottom + False + + + True + True + automatic + automatic + + + True + True + + + + + + + True + devices + + + False + tab + + + + + True + True + automatic + + + True + True + False + 5 + 5 + False + + + + + 1 + + + + + True + log + + + 1 + False + tab + + + + + 2 + 2 + + + + + True + + + gtk-media-record + True + False + True + True + True + + + False + 0 + + + + + True + True + 0.050000000000000003 + running... + + + 1 + + + + + gtk-cancel + True + True + True + True + + + False + False + 5 + 2 + + + + + False + False + 5 + 3 + + + + + + + + + + + True + + + True + 0 + img/gpyfsa_tab1.svg + + + False + 0 + + + + + True + 1 + Save FS + + + 8 + 1 + + + + + False + tab + + + + + True + 0 + none + + + True + 10 + 10 + 10 + 10 + + + + + + + + + label_item + + + + + 1 + + + + + True + + + True + 0 + img/gpyfsa_tab2.svg + + + False + 0 + + + + + True + 1 + Restore FS + + + 8 + 1 + + + + + 1 + False + tab + + + + + True + 0 + none + + + True + 10 + 10 + 10 + 10 + + + + + + + + + label_item + + + + + 2 + + + + + True + + + True + 0 + img/gpyfsa_tab3.svg + + + False + 0 + + + + + True + 1 + Archives + + + 8 + 1 + + + + + 2 + False + tab + + + + + + + 1 + + + + + True + 2 + + + False + 2 + + + + + + diff --git a/0.3x/res/gpyfsa.glade.h b/0.3x/res/gpyfsa.glade.h new file mode 100644 index 0000000..4917b2f --- /dev/null +++ b/0.3x/res/gpyfsa.glade.h @@ -0,0 +1,32 @@ +char *s = N_("(1: very fast to 9: very good)"); +char *s = N_("(usefull on multi-core cpu)"); +char *s = N_("Main Options"); +char *s = N_("Advanced Options"); +char *s = N_("Archives"); +char *s = N_("E_dit"); +char *s = N_("GPyFSA"); +char *s = N_("H_elp"); +char *s = N_("MB each"); +char *s = N_("Restore FS"); +char *s = N_("Save FS"); +char *s = N_("_Files"); +char *s = N_("archive description :"); +char *s = N_("archive path :"); +char *s = N_("browse"); +char *s = N_("compression level :"); +char *s = N_("compression thread :"); +char *s = N_("confirm :"); +char *s = N_("debug mode"); +char *s = N_("devices"); +char *s = N_("don't confirm"); +char *s = N_("encrypt data in archive (6 to 64 characters max) :"); +char *s = N_("exclude files and directories that match the pattern :"); +char *s = N_("force .fsa extension"); +char *s = N_("log"); +char *s = N_("overwrite existing archive"); +char *s = N_("password :"); +char *s = N_("refresh"); +char *s = N_("running..."); +char *s = N_("show password"); +char *s = N_("split archive into several files of :"); +char *s = N_("verboose mode"); diff --git a/0.3x/res/img/gpyfsa.png b/0.3x/res/img/gpyfsa.png new file mode 100644 index 0000000000000000000000000000000000000000..5243fb0f194105a8bc847769eee09a0d99fd6b0f GIT binary patch literal 12204 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 J^Rk + + + + + + + image/svg+xml + + + + + + + + + + + diff --git a/0.3x/res/img/gpyfsa_dev.png b/0.3x/res/img/gpyfsa_dev.png new file mode 100644 index 0000000000000000000000000000000000000000..c05f0a8e1793a3a1d3f3b7f6199794ddd068c22a GIT binary patch literal 12204 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 literal 0 HcmV?d00001 diff --git a/0.3x/res/img/gpyfsa_dev.svg b/0.3x/res/img/gpyfsa_dev.svg new file mode 100644 index 0000000..0cf5582 --- /dev/null +++ b/0.3x/res/img/gpyfsa_dev.svg @@ -0,0 +1,70 @@ + + + + + + + + image/svg+xml + + + + + + + + + + + diff --git a/0.3x/res/img/gpyfsa_devlocked.png b/0.3x/res/img/gpyfsa_devlocked.png new file mode 100644 index 0000000000000000000000000000000000000000..816b7489a010460a867411418e66e31b4d9925fd GIT binary patch literal 12204 zcmeHNYj9NOd4A8?UF~XDtGiY*x`2=n0^=AkX2z|Z0Ko=gzz&Yv=_Egr%yi+wuGZpWQA^-TRE>94e7Pg{pf+?J_-;7g2S;w0EILJGFTO+vy#mt9FKt+e+∓#T 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 I`ugAfANnOnKmY&$ literal 0 HcmV?d00001 diff --git a/0.3x/res/img/gpyfsa_devlocked.svg b/0.3x/res/img/gpyfsa_devlocked.svg new file mode 100644 index 0000000..b13ea35 --- /dev/null +++ b/0.3x/res/img/gpyfsa_devlocked.svg @@ -0,0 +1,68 @@ + + + + + + + + image/svg+xml + + + + + + + + + + + diff --git a/0.3x/res/img/gpyfsa_refresh.svg b/0.3x/res/img/gpyfsa_refresh.svg new file mode 100644 index 0000000..22e1b84 --- /dev/null +++ b/0.3x/res/img/gpyfsa_refresh.svg @@ -0,0 +1,68 @@ + + + + + + + + image/svg+xml + + + + + + + + + + + diff --git a/0.3x/res/img/gpyfsa_tab1.png b/0.3x/res/img/gpyfsa_tab1.png new file mode 100644 index 0000000000000000000000000000000000000000..06e9e9709edf57430c84d327d6301e2f515d0538 GIT binary patch literal 12204 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 literal 0 HcmV?d00001 diff --git a/0.3x/res/img/gpyfsa_tab1.svg b/0.3x/res/img/gpyfsa_tab1.svg new file mode 100644 index 0000000..1e701cf --- /dev/null +++ b/0.3x/res/img/gpyfsa_tab1.svg @@ -0,0 +1,68 @@ + + + + + + + + image/svg+xml + + + + + + + + + + + diff --git a/0.3x/res/img/gpyfsa_tab2.png b/0.3x/res/img/gpyfsa_tab2.png new file mode 100644 index 0000000000000000000000000000000000000000..8744fde6614d334a002c821f220e496394690b26 GIT binary patch literal 12204 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 H{jdHX*(ev_ literal 0 HcmV?d00001 diff --git a/0.3x/res/img/gpyfsa_tab2.svg b/0.3x/res/img/gpyfsa_tab2.svg new file mode 100644 index 0000000..a8f5b52 --- /dev/null +++ b/0.3x/res/img/gpyfsa_tab2.svg @@ -0,0 +1,68 @@ + + + + + + + + image/svg+xml + + + + + + + + + + + diff --git a/0.3x/res/img/gpyfsa_tab3.png b/0.3x/res/img/gpyfsa_tab3.png new file mode 100644 index 0000000000000000000000000000000000000000..4e16e7f656bb5e8ab422bfcc28112ef44a75ce55 GIT binary patch literal 12204 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 iWSsXdC|L9-^ + + + + + + + image/svg+xml + + + + + + + + + + + diff --git a/0.3x/src/gpyfsa_conf.py b/0.3x/src/gpyfsa_conf.py new file mode 100644 index 0000000..d154cf6 --- /dev/null +++ b/0.3x/src/gpyfsa_conf.py @@ -0,0 +1,91 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # +# software : GPyFSA # +# version : 0.31 # +# date : 2010 # +# licence : GPLv3.0 # +# author : a-Sansara # +# copyright : pluie.org # +# # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# +# This file is part of GPyFSA. +# +# GPyFSA is free software (free as in speech) : 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. +# +# GPyFSA 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 GPyFSA. If not, see . + +import sys, os, os.path, locale, gettext, gtk.glade +from gpyfsa_shell import Shell + +PATH_SRC = os.path.abspath(os.path.dirname(sys.argv[0])) +PATH_INIT = "/home" +PATH_LOCAL = '../locale' +PATH_MOUNT = '/mnt/gpyfsa/' +PATH_RES = '../res/' +PATH_IMG = PATH_RES+'img/' +PATH_LOG = '/var/log/gpyfsa.log' +APP_NAME = 'gpyfsa' +sys.path.insert(0, PATH_SRC) +os.chdir(PATH_SRC) + +locale.setlocale(locale.LC_ALL, '') +for module in (gettext,gtk.glade): + module.bindtextdomain(APP_NAME, PATH_LOCAL) + module.textdomain(APP_NAME) +_ = gettext.gettext + +K_DEV_NAME = K_NAME = K_DISK = 0 +K_DEV_TYPE = K_NOVAL = K_DEVICE = 1 +K_DEV_LABEL = K_SELFVAL = 2 +K_DEV_SIZE = 3 +K_DEV_USIZE = 4 +K_DEV_FSIZE = 5 +K_DEV_PSIZE = 6 +K_DEV_MOUNT = 7 +K_DEV_RWRIT = 8 + +####################### (K_NAME , K_NOVAL, K_SELFVAL) +SAVEOPT = (('o' , True , ),('v',True,),('d',True,),('L',False,True),('s',False,False),('e',False,False),('c',False,False),('z',False,True),('j',False,True)) +K_DEV_PIX = 0 +K_DEV_ACTIVATABLE = 1 +K_DEV_ACTIVE = 2 +K_DEV = 3 +L_COLSNAME = ('',_('device'),_('type'),_('label'),_('size'),_('used'),_('free'),_('%used'),_('mount point')) +IMG_TV_DEVICE = PATH_IMG+'gpyfsa_dev.svg' +IMG_TV_DEVICE_LOCKED = PATH_IMG+'gpyfsa_devlocked.svg' + +K_TYPE = K_FILTER_NAME = PAGE_SAVE = 0 +K_TITLE = K_FILTER_PATTERN = PAGE_REST = 1 +K_FILTER = PAGE_ARCH = 2 +CBDT_SAVEFS = 'SAVE', _('Save archive') , ((_('all'),'*'),(_('fsa archive'),'*.fsa')) + +COMPRESSION_LEVEL = ['lzo -3', 'gzip -2', 'gzip -6', 'gzip -9', 'bzip2 -2', 'bzip2 -5', 'lzma -1', 'lzma -6', 'lzma -9'] + +labelProgressWait = _("pls wait ...") +labelWorkInProgress = _("work in progress - ") +labelMountDev = _("mount %s") +labelMountroDev = _("mount %s read-only") +labelRemountDev = _("remount %s read-only") +labelUmountDev = _("unmount %s") + +sh = Shell() + +def getClDev(key) : return K_DEV+key + +def getGladeXML() : return gtk.glade.XML(PATH_RES+APP_NAME+".glade",APP_NAME) + +def chdir(path) : return os.chdir(path) + +def getShell() : return sh diff --git a/0.3x/src/gpyfsa_devlistmanager.py b/0.3x/src/gpyfsa_devlistmanager.py new file mode 100644 index 0000000..705ac3a --- /dev/null +++ b/0.3x/src/gpyfsa_devlistmanager.py @@ -0,0 +1,203 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # +# software : GPyFSA # +# version : 0.31 # +# date : 2010 # +# licence : GPLv3.0 # +# author : a-Sansara # +# copyright : pluie.org # +# # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# +# This file is part of GPyFSA. +# +# GPyFSA is free software (free as in speech) : 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. +# +# GPyFSA 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 GPyFSA. If not, see . + +import gtk, os, os.path +from gpyfsa_fsa import ProbeReader +from gpyfsa_ui import getNewWidget, insertWidget +from operator import itemgetter + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +class DevListManager(): + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + dicseldev = {} + bseldev = False + dcount = 1 + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def evt_refreshDevicesList(self,widget=None): + self.gpyfsa.doBeforeManageDevices() + self.gpyfsa['w_treedev'].set_model(self.getTreeStoreDevices(self.gpyfsa['w_treedev'].get_model())) + self.gpyfsa['w_treedev'].expand_all() + self.gpyfsa.doAfterManageDevices() + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def evt_mountDevice(self, w, name, type, label, prevmountp, mountOpt): + if mountOpt==None: cmd = ["umount","/dev/"+name] + else: + if type=="ntfs": type = "ntfs-3g" + if prevmountp == "": + prevmountp = self.conf.PATH_MOUNT+name + if not os.path.exists(prevmountp):os.makedirs(prevmountp,0755) + cmd = ["mount","-o",mountOpt,"-t",type,"/dev/"+name, prevmountp] + self.conf.getShell().call(cmd,self.gpyfsa.logFile,True) + self.evt_refreshDevicesList() + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def evt_selectDevice(self, widget): + if not self.bseldev: + (model, miter) = self.gpyfsa['w_treedev'].get_selection().get_selected() + path = model.get_path(miter) + # disk expand + if len(path)==1 : + if self.gpyfsa['w_treedev'].row_expanded(path): self.gpyfsa['w_treedev'].collapse_row(path) + else : self.gpyfsa['w_treedev'].expand_row(path,True) + # device selection + elif miter != None and not model.get_value(miter, self.conf.getClDev(self.conf.K_DEV_RWRIT)): + toggled = model.get_value(miter, self.conf.K_DEV_ACTIVE) + model.set_value(miter, self.conf.K_DEV_ACTIVE, not toggled) + self.setDevicesSelection(model.get_value(miter, self.conf.K_DEV),not toggled) + self.bseldev = False + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def evt_treeviewPressedButton(self, treeview, event): + bcontinue = False + if event.button == 3: + x = int(event.x) + y = int(event.y) + time = event.time + pathinfo = treeview.get_path_at_pos(x, y) + if pathinfo is not None: + path, col, cellx, celly = pathinfo + self.bseldev = True + #treeview.grab_focus() + treeview.set_cursor( path, col, 0) + if(len(path)>1):self.buildDeviceContextMenu(event,path,treeview.get_model()) + bcontinue = True + return bcontinue + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def buildDeviceContextMenu(self, event, path, model): + miter = model.get_iter(path) + self.gpyfsa.doBeforeManageDevices() + if miter != None : + mountp = model.get_value(miter, self.conf.getClDev(self.conf.K_DEV_MOUNT)) + dev = model.get_value(miter, self.conf.getClDev(self.conf.K_DEV_NAME)) + devlabel = model.get_value(miter, self.conf.getClDev(self.conf.K_DEV_LABEL)) + devtype = model.get_value(miter, self.conf.getClDev(self.conf.K_DEV_TYPE)) + mrw = model.get_value(miter, self.conf.getClDev(self.conf.K_DEV_RWRIT)) + notSwap = devtype!="swap" + entries = [ (self.conf.labelMountDev % devlabel, bool(notSwap and mountp=="") , self.evt_mountDevice, "rw" ), + (self.conf.labelMountroDev % devlabel, bool(notSwap and mountp=="") , self.evt_mountDevice, "ro,acl,user_xattr" ), + (self.conf.labelRemountDev % devlabel, bool(notSwap and mountp!="/" and mrw) , self.evt_mountDevice, "remount,ro,acl,user_xattr" ), + (self.conf.labelUmountDev % devlabel, bool(notSwap and mountp!="/" and mountp!=""), self.evt_mountDevice, None ) + ] + menu = gtk.Menu() + for label,sensitivity,callback,mountOpt in entries: + item = gtk.ImageMenuItem(label) + if callback: item.connect("activate",callback,dev,devtype,devlabel,mountp,mountOpt) + item.set_sensitive(sensitivity) + item.show() + menu.append(item) + menu.popup(None,None,None,event.button,event.time) + self.gpyfsa.doAfterManageDevices() + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def getDeviceOrder(self): + self.dcount += 1 + return self.dcount + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def setDevicesSelection(self,dev,add): + if(add):self.dicseldev[dev] = self.getDeviceOrder() + else: del self.dicseldev[dev] + self.gpyfsa.doAfterDeviceSelection() + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def getSortedSelDevList(self): + ldev = self.dicseldev.items() + ldev.sort(key=itemgetter(1),reverse=False) + return ["/dev/%s" % k for k,v in ldev] + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def preformatStoreData(self,ldata,activatable,imgFileName,active=False): + ldata.insert(0,active) + ldata.insert(0,activatable) + ldata.insert(0,gtk.gdk.pixbuf_new_from_file(imgFileName)) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def getTreeStoreDevices(self,oldModel=None): + # ICO ACTIVATABLE ACTIVE _K_DEV_ NO READ-WRITE + store = gtk.TreeStore(gtk.gdk.Pixbuf, 'gboolean', 'gboolean', str, str, str, str, str, str, str, str, 'gboolean') + ldev = ProbeReader(self.conf).getListDevices() + for i,l in enumerate(ldev): + hasntLockedDev = True + self.preformatStoreData(l[self.conf.K_DISK],False,self.conf.IMG_TV_DEVICE) + diter = store.append(None,l[self.conf.K_DISK]) + for j,dev in enumerate(l[self.conf.K_DEVICE]): + imgn = self.conf.IMG_TV_DEVICE + if dev[self.conf.K_DEV_RWRIT]: + imgn = self.conf.IMG_TV_DEVICE_LOCKED + if hasntLockedDev: store.set_value(diter, self.conf.K_DEV_PIX, gtk.gdk.pixbuf_new_from_file(imgn)) + hasntLockedDev = False + active = False + if(oldModel != None): + try: + oiter = oldModel.get_iter((i,j)) + if oiter != None: active = oldModel.get_value(oiter,self.conf.K_DEV_ACTIVE) + except : + pass + self.preformatStoreData(dev,not dev[self.conf.K_DEV_RWRIT],imgn,active) + store.append(diter,dev) + return store + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def buildTreeDevices(self): + self.gpyfsa['w_treedev'].set_model(self.getTreeStoreDevices()) + crtog = getNewWidget(gtk.CellRendererToggle(),(('activatable',False),('active',False))) + crtxt = getNewWidget(gtk.CellRendererText() ,(('scale',1.0),('foreground','#6C6C6C'))) + for i,col in enumerate(self.conf.L_COLSNAME): + if i == 0: + tvcol = gtk.TreeViewColumn(col, gtk.CellRendererPixbuf(), pixbuf=0) + tvcol.pack_start(gtk.CellRendererPixbuf(),True) + tvcol.pack_start(crtog,True) + tvcol.set_attributes(crtog, active=self.conf.K_DEV_ACTIVE, visible=self.conf.K_DEV_ACTIVATABLE) + tvcol.set_clickable(True) + insertWidget(self.gpyfsa['w_refresh_devices'],tvcol) + else : + tvcol = gtk.TreeViewColumn(col) + tvcol.pack_start(crtxt,True) + tvcol.set_attributes(crtxt, text=i+2, foreground_set=self.conf.getClDev(self.conf.K_DEV_RWRIT)) + self.gpyfsa['w_treedev'].append_column(tvcol) + + self.gpyfsa['w_treedev'].set_rules_hint(True) + self.gpyfsa['w_treedev'].set_enable_search(False) + self.gpyfsa['w_treedev'].expand_all() + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def bindEvents(self): + self.gpyfsa['w_refresh_devices']._gpyfsa_parent.connect('clicked', self.evt_refreshDevicesList) + self.gpyfsa['w_treedev'].connect('cursor-changed', self.evt_selectDevice) + self.gpyfsa['w_treedev'].connect('button-press-event', self.evt_treeviewPressedButton) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def __init__(self, gpyfsa, conf): + self.gpyfsa = gpyfsa + self.conf = conf + self.buildTreeDevices() + self.bindEvents() diff --git a/0.3x/src/gpyfsa_fsa.py b/0.3x/src/gpyfsa_fsa.py new file mode 100644 index 0000000..14f2d89 --- /dev/null +++ b/0.3x/src/gpyfsa_fsa.py @@ -0,0 +1,188 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # +# software : GPyFSA # +# version : 0.31 # +# date : 2010 # +# licence : GPLv3.0 # +# author : a-Sansara # +# copyright : pluie.org # +# # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# +# This file is part of GPyFSA. +# +# GPyFSA is free software (free as in speech) : 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. +# +# GPyFSA 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 GPyFSA. If not, see . + +import re, os.path + + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +class ProbeReader(): + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def __init__(self, conf): + self.conf = conf + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def __getListDevices(self): + sh = self.conf.getShell() + ostr = sh.call([sh.CMD_FSA,"probe"]).stderr.read() + ostr = re.sub(r'\n\n','\n',ostr) + ostr = re.sub(r'\ ?[\[\ =]','',ostr) + return ostr.split('\n') + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def getListDevices(self): + lines, isDisk, ldev, ldisk, dic, ltmp = self.__getListDevices(), True, [], [], {}, ['','','','',False] + for l in lines: + l = l.split(']') + if isDisk: + if l[0]=="DISK" : continue + if l[0]=="DEVICE": + isDisk = False + continue + ldisk.append(l[0]) + l = l[0:3] + l.insert(1,'') + l.extend(ltmp) + ldev.append([l,[]]) + elif l: + if not dic : dic = self.__getDicMountInfo(ldisk) + idd = -1 + for i in range(len(ldisk)): + if l[0].startswith(ldisk[i]): + idd = i + break + if idd !=-1: + ldevi = l[0:4] + if dic.has_key(l[0]): ldevi.extend(dic[l[0]]) + else : ldevi.extend(ltmp) + ldev[idd][1].append(ldevi) + + return ldev + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def __getDicMountInfo(self,ldisk): + dic = {} + grepStr = "/\("+"\)\|\(".join(ldisk)+"\)" + sh = self.conf.getShell() + ldev = sh.getGrepPipeOut([sh.CMD_DF,"-h"],grepStr) + i = len("/dev/") + for l in ldev: + l = re.sub(r' +','$',l).split('$') + if l[0]: dic[l[0][i:]]= l[2:] + ldev = sh.getGrepPipeOut([sh.CMD_MOUNT],grepStr) + for l in ldev: + dev = l[5:l.find(' ',5)] + if dev : dic[dev].append(not l.find('(rw')==-1) + return dic + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def traceDevicesList(self,dlist): + for i in range(len(dlist)): + print "###############################\n % s (%d)\n###############################" % (dlist[i][self.conf.K_DISK],len(dlist[i][self.conf.K_DEVICE])) + for j in range(len(dlist[i][self.conf.K_DEVICE])): + print "%d - %s " % (j,dlist[i][self.conf.K_DEVICE][j]) + + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +class LogReader: + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + _READSIZE, _ENDSIZE, _STARTFILE, _ENDFILE, _PERCENTPOS = 400, 400, 0, 2, 9 + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def __init__(self,pathFile,textview): + self.textview = textview + self.path = pathFile + if not os.path.isfile(pathFile): + f = open(pathFile,'w') + f.close() + self.log = open(pathFile,'r') + self.buf = self.textview.get_buffer() + self.clear() + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def __readLastLine(self): + if not self.stopPercent: + size = os.path.getsize(self.path) + if self.lastpos < size : + if size > self._READSIZE : size = self._READSIZE + self.log.seek(-size,self._ENDFILE) + l = self.log.read() + self.pos = self.log.tell() + l = l.split('\n') + self.entry = l[len(l)-2] + hasPercent = self.entry[self._PERCENTPOS:self._PERCENTPOS+1] == "%" + if (not self.startPercent) and hasPercent : self.startPercent = hasPercent + if hasPercent : + self.percent = self.entry[self._PERCENTPOS-3:self._PERCENTPOS].strip() + if not self.startPercent: self.startPercent = True + self.lastpos = self.pos + elif self.startPercent: self.stopPercent = True + else : pass # waiting new entries + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def clear(self,msg=""): + self.startPercent = self.stopPercent = self.end = False + self.pos = self.bufpos = self.lastpos = 0 + self.entry = self.percent = "" + self.buf.set_text(msg) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def hasPercent(self): + self.__readLastLine() + return self.startPercent and not self.stopPercent + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def setVerbooseMode(self,verboose): + self.verboose = verboose + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def isDone(self): + return self.startPercent and self.stopPercent + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def __readStats(self): + size = os.path.getsize(self.path) + self.log.seek(self.lastpos,self._STARTFILE) + for l in self.log.readlines(): + if not l[self._PERCENTPOS:self._PERCENTPOS+1] == "%" : + if l.startswith('==='): l = "\n"+l + self.buf.insert(self.buf.get_end_iter(),l) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def readStats(self): + self.__readStats() + self.textview.scroll_to_iter(self.buf.get_end_iter(),0) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def read(self): + if self.verboose and not self.end : + if(self.pos > self.bufpos): + self.lastbufpos = self.bufpos + self.log.seek(self.bufpos,0) + for l in self.log.readlines(): + hasPercent = l[self._PERCENTPOS:self._PERCENTPOS+1] == "%" + if not self.stopPercent or hasPercent: + self.buf.insert(self.buf.get_end_iter(),l) + self.textview.scroll_to_iter(self.buf.get_end_iter(),0) + self.bufpos = self.log.tell() + if self.isDone() and not self.end: + self.textview.scroll_to_iter(self.buf.get_start_iter(),0) + self.textview.scroll_to_iter(self.buf.get_end_iter(),0) + self.end = True + diff --git a/0.3x/src/gpyfsa_main.py b/0.3x/src/gpyfsa_main.py new file mode 100644 index 0000000..4b7b105 --- /dev/null +++ b/0.3x/src/gpyfsa_main.py @@ -0,0 +1,244 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # +# software : GPyFSA # +# version : 0.31 # +# date : 2010 # +# licence : GPLv3.0 # +# author : a-Sansara # +# copyright : pluie.org # +# # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# +# This file is part of GPyFSA. +# +# GPyFSA is free software (free as in speech) : 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. +# +# GPyFSA 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 GPyFSA. If not, see . + +import sys + +try: + import pygtk + pygtk.require("2.0") +except: + print "You need to install pyGTK 2.0 or set your PYTHONPATH correctly" + sys.exit(1) + +import gtk, pango, re #, thread, threading +from time import sleep +from gpyfsa_devlistmanager import DevListManager +import gpyfsa_conf as conf +import gpyfsa_ui as ui +import gpyfsa_fsa as fsa + +#gtk.gdk.threads_init() + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +class GPyFSA(gtk.Window): + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def bugFix_GladeComboBoxEntry(self): + self.w_saveArchiveHistory,combo,browse = gtk.combo_box_entry_new_text(),self.xml.get_widget('w_saveArchiveHistory'),self['w_saveArchiveBrowse'] + self['w_saveArchiveHistory'].set_model(gtk.ListStore(str)) + box = browse.get_parent() + box.remove(combo) + box.remove(browse) + box.pack_start(self['w_saveArchiveHistory'],True,True,0) + box.pack_start(browse,False,False,0) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def cleaningSaveFS(self): + self.switchControlSaveFS(False) + ui.clearTimeout(self.timer) + self.logReader.setVerbooseMode(True) + self.logReader.readStats() + self.timer = 0 + if self.pfsa.poll()==0: self['w_nb_savefs'].set_current_page(0) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def checkCleaningSaveFS(self): + self.endTime+=100 + return self.endTime > self.endSaveFSTime + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def terminateSaveFS(self): + ui.clearTimeout(self.timer) + self.endTime = 0 + self.endSaveFSTime = 500 + self.timer = ui.setTimeout(100, ui.endSaveFS, self.cleaningSaveFS, self.checkCleaningSaveFS, self['w_progress_savefs']) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def switchControlSaveFS(self,active): + self['w_nb_savefs'].set_show_tabs(True) + ui.setSensitivity(not active,(self['w_treedev'],self['w_saveArchiveHistory'],self['w_saveArchiveBrowse'],self['w_fsaOpt_c'],self['w_fsaOptValue_c'],self['w_fsaOptValueConfirm_c'],self['w_fsaOpt_c_showpass'],self['l_password'],self['l_confirmPassword'],self['w_fsaOpt_c_noconfirm'])) + self['w_treedev'].set_sensitive(not active) + self['w_saveArchiveHistory'].set_sensitive(not active) + self['w_saveArchiveBrowse'].set_sensitive(not active) + sl,hl = l1,l2 = ('w_progress_savefs','w_cancel_savefs'),('w_savefs',) + if not active: l1,l2 = hl,sl + for n in l2: self[n].hide() + for n in l1: self[n].show() + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def evt_cancelSaveFS(self,widget,data=None): + self.pfsa.terminate() + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def evt_browseFile(self,widget,data,callback): + return ui.browseFile(data[conf.K_TYPE],data[conf.K_TITLE],data[conf.K_FILTER],callback) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def evt_setArchivePath(self,path): + self.archivePath = path.rpartition('/') + if(self.archivePath[2]!=""):conf.chdir(self.archivePath[0]) + self['w_saveArchiveHistory'].insert_text(0, path) + self['w_saveArchiveHistory'].set_active(0) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def evt_editComboBoxEntry(self,txt): + self['w_savefs'].set_sensitive(bool(self.dlm.dicseldev and txt and self.checkPassword(None,None,False))) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def evt_saveFS(self,widget): + cmd = ui.buildFsaOptions(self,conf) + path = self['w_saveArchiveHistory'].get_model().get_value(self['w_saveArchiveHistory'].get_active_iter(),0) + self.archivePath = path.rpartition('/') + filen = path + if(not path.endswith(".fsa") and self['w_force_ext'].get_active()): + if self.archivePath[2]!="":filen = self.archivePath[2] + filen = re.sub(r'\.[^.]+$',"",filen)+".fsa" + if self.archivePath[2]!="":path = "".join(self.archivePath[0:1])+"/"+filen + self['w_saveArchiveHistory'].get_model().set_value(self['w_saveArchiveHistory'].get_active_iter(), 0, path) + cmd.append(path) + cmd.extend(self.dlm.getSortedSelDevList()) + pcmd = cmd + if self.tmp!=0: pcmd[self.tmp] = "-c"+re.sub(r".","*",pcmd[self.tmp][2:]) + del self.tmp + self.logReader.clear("\n"+" ".join(pcmd)+"\n\n") + self.logReader.setVerbooseMode(self['w_fsaOpt_v'].get_active()) + self.timer = ui.setTimeout(100, ui.progressTimeout, self.terminateSaveFS, self.checkProgressAborting, (self.logReader, self['w_progress_savefs'], conf.labelProgressWait, conf.labelWorkInProgress )) + self.switchControlSaveFS(True) + self['w_nb_savefs'].set_current_page(1) + self.logFile.close() + self.logFile = open(conf.PATH_LOG, 'w') + self.pfsa = conf.getShell().call(cmd,self.logFile,True) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def setDefaultArchivePath(self): + if(hasattr(self,"archivePath") and self.archivePath[2]!=""):conf.chdir(self.archivePath[0]) + else:conf.chdir(conf.PATH_INIT) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def checkProgressAborting(self): + poll = self.pfsa.poll() + return poll==0 or poll==1 + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def doBeforeManageDevices(self): conf.chdir(conf.PATH_SRC) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def doAfterManageDevices(self): self.setDefaultArchivePath() + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def doAfterDeviceSelection(self): self.switchStateSaveFS() + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def switchStateSaveFS(self,password=None): + if password is None : password = self.checkPassword(None,None,False) + aiter = self['w_saveArchiveHistory'].get_active_iter() + if(aiter != None): self['w_savefs'].set_sensitive(bool(self.dlm.dicseldev and self['w_saveArchiveHistory'].get_model().get_value(aiter,0) and password)) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def setCompressionStore(self): + liststore = gtk.ListStore(int, str) + for i,name in enumerate (conf.COMPRESSION_LEVEL):liststore.append([i+1,str(i+1)+': '+name]) + crt = gtk.CellRendererText() + crt.set_property('family','Liberation mono') + self['w_fsaOpt_z'].set_model(liststore) + self['w_fsaOpt_z'].pack_start(crt, True) + self['w_fsaOpt_z'].add_attribute(crt, 'text', 1) + self['w_fsaOpt_z'].set_active(2) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def manageStyle(self): + self['w_log'].modify_base(gtk.STATE_NORMAL,gtk.gdk.color_parse('#2E3436')) + self['w_log'].modify_text(gtk.STATE_NORMAL,gtk.gdk.color_parse('#FFF7BA')) + self['w_log'].modify_font(pango.FontDescription("Liberation mono normal 10")) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def checkPassword(self,widget=None,data=None,testRefresh=True): + bvalid, stockid, pass1, pass2 = not self['w_fsaOpt_c'].get_active(), gtk.STOCK_NO, self['w_fsaOptValue_c'].get_text(), self['w_fsaOptValueConfirm_c'].get_text() + self['w_validPassword'].set_sensitive(not bvalid) + if not bvalid and len(pass1)>5 and len(pass1)<65 and (self['w_fsaOpt_c_noconfirm'].get_active() or pass1==pass2): + stockid = gtk.STOCK_YES + bvalid = True + self['w_validPassword'].set_from_stock(stockid, gtk.ICON_SIZE_BUTTON) + if(testRefresh): self.switchStateSaveFS(bvalid) + return bvalid + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def bindEvents(self): + for opt in conf.SAVEOPT : + if opt[conf.K_NAME] == 'e' or opt[conf.K_NAME] == 's' : + self['w_fsaOpt_'+opt[conf.K_NAME]].connect("toggled", ui.setSensitivity, self['w_fsaOptValue_'+opt[conf.K_NAME]]) + if opt[conf.K_NAME] == 'c' : + self['w_fsaOpt_c'].connect("toggled", ui.setSensitivity, (self['w_fsaOptValue_c'],self['w_fsaOptValueConfirm_c'],self['w_fsaOpt_c_showpass'],self['l_password'],self['l_confirmPassword'],self['w_fsaOpt_c_noconfirm'])) + self['w_fsaOpt_c_showpass' ].connect("toggled", ui.setInvisibleChar, (self['w_fsaOptValue_c'],self['w_fsaOptValueConfirm_c']) ) + self['w_fsaOpt_c_showpass' ].connect("toggled", lambda w : self['w_fsaOpt_c_noconfirm'].set_active(w.get_active()) ) + self['w_fsaOpt_c_noconfirm'].connect("toggled", ui.setInvisibility , (self['w_fsaOptValueConfirm_c'],self['l_confirmPassword']) ) + self['w_fsaOpt_c'].connect("toggled", self.checkPassword) + self['w_fsaOpt_c_showpass' ].connect("toggled", self.checkPassword) + self['w_fsaOpt_c_noconfirm'].connect("toggled", self.checkPassword) + self['w_fsaOptValue_c'].connect("changed", self.checkPassword) + self['w_fsaOptValueConfirm_c'].connect("changed", self.checkPassword) + self['w_saveArchiveHistory'].child.connect('changed', ui.onEditComboBoxEntry, self.evt_editComboBoxEntry) + self['w_saveArchiveBrowse'].connect("clicked", self.evt_browseFile, conf.CBDT_SAVEFS, self.evt_setArchivePath) + self['w_savefs'].connect('clicked', self.evt_saveFS) + self['w_cancel_savefs'].connect('clicked', self.evt_cancelSaveFS) + self['gpyfsa'].connect("delete_event", gtk.main_quit) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def __getitem__(self, key): + # # # # > BUG FIX ! see bugFix_GladeComboBoxEntry() # # # # + if key == 'w_saveArchiveHistory': return self.w_saveArchiveHistory + # # # # < BUG FIX # # # # # # # # # # # # # # # # # # # # # + return self.xml.get_widget(key) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def __init__(self): + self.xml = conf.getGladeXML() + self.dlm = DevListManager(self,conf) + self.bugFix_GladeComboBoxEntry() + self.setCompressionStore() + self.manageStyle() + self.bindEvents() + self.logReader = fsa.LogReader(conf.PATH_LOG,self['w_log']) + self.logFile = open(conf.PATH_LOG, 'w') + self[conf.APP_NAME].show_all() + conf.chdir(conf.PATH_INIT) + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def main(): + GPyFSA() + gtk.main() + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +if __name__ == '__main__': + main() + +# xgettext --language=Python --keyword=_ --keyword=N_ --output=gpyfsa.pot res/gpyfsa.glade.h src/*.py +# msginit -i gpyfsa.pot -o locale/fr/LC_MESSAGES/gpyfsa.po +# msgfmt gpyfsa.po -o gpyfsa.mo +# intltool-extract --type=gettext/glade res/*.glade +# msgmerge -U locale/fr/LC_MESSAGES/gpyfsa.po gpyfsa.pot diff --git a/0.3x/src/gpyfsa_savefs.py b/0.3x/src/gpyfsa_savefs.py new file mode 100644 index 0000000..0eaed4c --- /dev/null +++ b/0.3x/src/gpyfsa_savefs.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # +# software : GPyFSA # +# version : 0.31 # +# date : 2010 # +# licence : GPLv3.0 # +# author : a-Sansara # +# copyright : pluie.org # +# # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# +# This file is part of GPyFSA. +# +# GPyFSA is free software (free as in speech) : 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. +# +# GPyFSA 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 GPyFSA. If not, see . + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +class SaveFS(gtk.Window): + + pass diff --git a/0.3x/src/gpyfsa_shell.py b/0.3x/src/gpyfsa_shell.py new file mode 100644 index 0000000..837209e --- /dev/null +++ b/0.3x/src/gpyfsa_shell.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # +# software : GPyFSA # +# version : 0.31 # +# date : 2010 # +# licence : GPLv3.0 # +# author : a-Sansara # +# copyright : pluie.org # +# # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# +# This file is part of GPyFSA. +# +# GPyFSA is free software (free as in speech) : 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. +# +# GPyFSA 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 GPyFSA. If not, see . + +import subprocess as subp + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +class Shell: + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + PIPE, CMD_DF, CMD_GREP, CMD_FSA, CMD_MOUNT, CMD_UMOUNT = subp.PIPE, "df", "grep", "fsarchiver", "mount", "umount" + authCmd = { CMD_DF:1, CMD_GREP:1, CMD_FSA:1, CMD_MOUNT:1, CMD_UMOUNT:1 } + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def getGrepPipeOut(self,args,grepStr): + return self.__getGrepPipeOut(args,grepStr) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def pipe(self,cmd1,cmd2): + return self.__pipe(cmd1,cmd2) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def call(self,cmd,stdoe=subp.PIPE,fdsClose=False): + return self.__call(cmd,stdoe,fdsClose) + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def __call(self,cmd,stdoe=subp.PIPE,fdsClose=False): + p = None + if self.authCmd.has_key(cmd[0]): p = subp.Popen(cmd, stdout=stdoe, stderr=stdoe, close_fds=fdsClose) + return p + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def __pipe(self,cmd1,cmd2): + p = None + if self.authCmd.has_key(cmd1[0]) and self.authCmd.has_key(cmd2[0]): p = subp.Popen(cmd2, stdin=self.__call(cmd1).stdout, stdout=subp.PIPE, stderr=subp.PIPE) + return p + + # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # + def __getGrepPipeOut(self,cmd,grepStr): + try : return self.__pipe(cmd, [self.CMD_GREP, grepStr]).stdout.read().split("\n") + except : return "" diff --git a/0.3x/src/gpyfsa_ui.py b/0.3x/src/gpyfsa_ui.py new file mode 100755 index 0000000..fda9884 --- /dev/null +++ b/0.3x/src/gpyfsa_ui.py @@ -0,0 +1,162 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # +# software : GPyFSA # +# version : 0.31 # +# date : 2010 # +# licence : GPLv3.0 # +# author : a-Sansara # +# copyright : pluie.org # +# # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# +# This file is part of GPyFSA. +# +# GPyFSA is free software (free as in speech) : 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. +# +# GPyFSA 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 GPyFSA. If not, see . + +import gtk, gobject, re + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def setSensitivity(checkBoxOrBool,target): + if type(checkBoxOrBool)==bool:active = checkBoxOrBool + else : active = checkBoxOrBool.get_active() + if(type(target) != tuple): target = (target,) + for w in target : w.set_sensitive(active) + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def setVisibility(widget,hide=False): + if hide: widget.hide_all() + else: widget.show_all() + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def setInvisibility(widget,target): + active = widget.get_active() + if(type(target) != tuple): target = (target,) + for w in target : setVisibility(w,active) + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def setInvisibleChar(widget,target): + active = widget.get_active() + if(type(target) != tuple): target = (target,) + for w in target : w.set_visibility(active) + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def onEditComboBoxEntry(entry, callback=None): + combo = entry.get_parent() + index = combo.get_active() + if(index > -1): + combo._activeIndex = index + combo._activeIter = combo.get_active_iter() + elif not hasattr(combo,"_activeIter"): + combo._activeIndex = 0 + combo._activeIter = (combo.get_model()).insert_after(None,None) + (combo.get_model()).set_value(combo._activeIter, 0, entry.get_text()) + combo.set_active(combo._activeIndex) + if(callback != None):callback(entry.get_text()) + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def browseFile(typeBrowse,title="",filterList=None,callback=None): + dialog = gtk.FileChooserDialog(title = title, + action = eval('gtk.FILE_CHOOSER_ACTION_'+typeBrowse), + buttons = (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, eval('gtk.STOCK_'+typeBrowse), gtk.RESPONSE_OK)) + if(filterList!=None): + _K_FILTER_NAME,_K_FILTER_PATTERN = 0,1 + for elmt in filterList: + f = gtk.FileFilter() + f.set_name(elmt[_K_FILTER_NAME]) + f.add_pattern(elmt[_K_FILTER_PATTERN]) + dialog.add_filter(f) + if dialog.run() == gtk.RESPONSE_OK and callback!=None: callback(dialog.get_filename()) + dialog.destroy() + return + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def getNewWidget(widget,propList): + for i,prop in enumerate(propList):widget.set_property(prop[0],prop[1]) + return widget + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def insertWidget(widget,wp=None,add=False): + w = widget + widget.get_parent().remove(widget) + w.unparent() + if wp!=None: + if not add: wp.set_widget(w) + else: wp.add(w) + w._gpyfsa_parent = wp + return + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def buildFsaOptions(gpyfsa,conf): + cmd = ['fsarchiver', 'savefs'] + gpyfsa.tmp = 0 + for opt in conf.SAVEOPT : + noAdd = False + v, wname, applyMethod = '','w_fsaOpt_'+opt[conf.K_NAME], None + if isinstance(gpyfsa[wname], gtk.CheckButton): noAdd = not gpyfsa[wname].get_active() + if opt[conf.K_NAME]=="v": noAdd = False + if not noAdd and not opt[conf.K_NOVAL]: + if not opt[conf.K_SELFVAL]: wname = 'w_fsaOptValue_'+opt[conf.K_NAME] + v = getWidgetValue(gpyfsa[wname],applyMethod) + if opt[conf.K_NAME]=="c": gpyfsa.tmp = len(cmd) + if not noAdd : noAdd = v.strip() == '' + if not noAdd : cmd.append('-'+opt[conf.K_NAME]+v) + return cmd + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def getWidgetValue(widget,applyMethod): + value = '' + if isinstance(widget, gtk.Entry) : value = widget.get_text() + elif isinstance(widget, gtk.SpinButton): value = str(int(widget.get_value())) + elif isinstance(widget, gtk.ComboBox) : value = str(widget.get_model().get_value(widget.get_active_iter(),0)) + if applyMethod is not None: value = applyMethod(value) + return value + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def formatDoubleQuote(value): + #value = re.sub(r"'","\\'",value) + if(value.rfind('"')!=-1): value = re.sub(r'"','\\"',value) + return '"'+value+'"' + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def progressTimeout(callBack, clearCallback, fsaLogReader, progressbar, msgWait="", msgInProgress=""): + progress, txt, pulse, fraction = not clearCallback(), msgWait, True, 0.0 + if fsaLogReader.hasPercent() : txt, pulse, fraction = msgInProgress+fsaLogReader.percent+"%", False, float(fsaLogReader.percent)/100.0 + fsaLogReader.read() + progressbar.set_text(txt) + if pulse : progressbar.pulse() + else : progressbar.set_fraction(fraction) + if not progress : callBack() + return progress + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def endSaveFS(callBack,clearCallback,progressbar): + progressbar.pulse() + bnotclear = not clearCallback() + if(bnotclear):callBack() + return bnotclear + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def clearTimeout(timer): + gobject.source_remove(timer) + timer = 0 + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +def setTimeout(ms, bind, callback, clearCallback, data=None): + params = "" + if data is not None : + if(type(data) != tuple): data = (data,) + for i in range(len(data)): params += ", data["+str(i)+"]" + return eval("gobject.timeout_add(ms, bind, callback, clearCallback "+params+")")