git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kstreamripper@1239912 283d02a7-25f6-0310-bc7c-ecb5cbfe19dav3.5.13-sru
@ -0,0 +1,2 @@ | |||
Michael Goettsche <mail@tuxipuxi.org> | |||
William Entriken <william.entriken@villanova.edu> |
@ -0,0 +1,340 @@ | |||
GNU GENERAL PUBLIC LICENSE | |||
Version 2, June 1991 | |||
Copyright (C) 1989, 1991 Free Software Foundation, Inc. | |||
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |||
Everyone is permitted to copy and distribute verbatim copies | |||
of this license document, but changing it is not allowed. | |||
Preamble | |||
The licenses for most software are designed to take away your | |||
freedom to share and change it. By contrast, the GNU General Public | |||
License is intended to guarantee your freedom to share and change free | |||
software--to make sure the software is free for all its users. This | |||
General Public License applies to most of the Free Software | |||
Foundation's software and to any other program whose authors commit to | |||
using it. (Some other Free Software Foundation software is covered by | |||
the GNU Library General Public License instead.) You can apply it to | |||
your programs, too. | |||
When we speak of free software, we are referring to freedom, not | |||
price. Our General Public Licenses are designed to make sure that you | |||
have the freedom to distribute copies of free software (and charge for | |||
this service if you wish), that you receive source code or can get it | |||
if you want it, that you can change the software or use pieces of it | |||
in new free programs; and that you know you can do these things. | |||
To protect your rights, we need to make restrictions that forbid | |||
anyone to deny you these rights or to ask you to surrender the rights. | |||
These restrictions translate to certain responsibilities for you if you | |||
distribute copies of the software, or if you modify it. | |||
For example, if you distribute copies of such a program, whether | |||
gratis or for a fee, you must give the recipients all the rights that | |||
you have. You must make sure that they, too, receive or can get the | |||
source code. And you must show them these terms so they know their | |||
rights. | |||
We protect your rights with two steps: (1) copyright the software, and | |||
(2) offer you this license which gives you legal permission to copy, | |||
distribute and/or modify the software. | |||
Also, for each author's protection and ours, we want to make certain | |||
that everyone understands that there is no warranty for this free | |||
software. If the software is modified by someone else and passed on, we | |||
want its recipients to know that what they have is not the original, so | |||
that any problems introduced by others will not reflect on the original | |||
authors' reputations. | |||
Finally, any free program is threatened constantly by software | |||
patents. We wish to avoid the danger that redistributors of a free | |||
program will individually obtain patent licenses, in effect making the | |||
program proprietary. To prevent this, we have made it clear that any | |||
patent must be licensed for everyone's free use or not licensed at all. | |||
The precise terms and conditions for copying, distribution and | |||
modification follow. | |||
GNU GENERAL PUBLIC LICENSE | |||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION | |||
0. This License applies to any program or other work which contains | |||
a notice placed by the copyright holder saying it may be distributed | |||
under the terms of this General Public License. The "Program", below, | |||
refers to any such program or work, and a "work based on the Program" | |||
means either the Program or any derivative work under copyright law: | |||
that is to say, a work containing the Program or a portion of it, | |||
either verbatim or with modifications and/or translated into another | |||
language. (Hereinafter, translation is included without limitation in | |||
the term "modification".) Each licensee is addressed as "you". | |||
Activities other than copying, distribution and modification are not | |||
covered by this License; they are outside its scope. The act of | |||
running the Program is not restricted, and the output from the Program | |||
is covered only if its contents constitute a work based on the | |||
Program (independent of having been made by running the Program). | |||
Whether that is true depends on what the Program does. | |||
1. You may copy and distribute verbatim copies of the Program's | |||
source code as you receive it, in any medium, provided that you | |||
conspicuously and appropriately publish on each copy an appropriate | |||
copyright notice and disclaimer of warranty; keep intact all the | |||
notices that refer to this License and to the absence of any warranty; | |||
and give any other recipients of the Program a copy of this License | |||
along with the Program. | |||
You may charge a fee for the physical act of transferring a copy, and | |||
you may at your option offer warranty protection in exchange for a fee. | |||
2. You may modify your copy or copies of the Program or any portion | |||
of it, thus forming a work based on the Program, and copy and | |||
distribute such modifications or work under the terms of Section 1 | |||
above, provided that you also meet all of these conditions: | |||
a) You must cause the modified files to carry prominent notices | |||
stating that you changed the files and the date of any change. | |||
b) You must cause any work that you distribute or publish, that in | |||
whole or in part contains or is derived from the Program or any | |||
part thereof, to be licensed as a whole at no charge to all third | |||
parties under the terms of this License. | |||
c) If the modified program normally reads commands interactively | |||
when run, you must cause it, when started running for such | |||
interactive use in the most ordinary way, to print or display an | |||
announcement including an appropriate copyright notice and a | |||
notice that there is no warranty (or else, saying that you provide | |||
a warranty) and that users may redistribute the program under | |||
these conditions, and telling the user how to view a copy of this | |||
License. (Exception: if the Program itself is interactive but | |||
does not normally print such an announcement, your work based on | |||
the Program is not required to print an announcement.) | |||
These requirements apply to the modified work as a whole. If | |||
identifiable sections of that work are not derived from the Program, | |||
and can be reasonably considered independent and separate works in | |||
themselves, then this License, and its terms, do not apply to those | |||
sections when you distribute them as separate works. But when you | |||
distribute the same sections as part of a whole which is a work based | |||
on the Program, the distribution of the whole must be on the terms of | |||
this License, whose permissions for other licensees extend to the | |||
entire whole, and thus to each and every part regardless of who wrote it. | |||
Thus, it is not the intent of this section to claim rights or contest | |||
your rights to work written entirely by you; rather, the intent is to | |||
exercise the right to control the distribution of derivative or | |||
collective works based on the Program. | |||
In addition, mere aggregation of another work not based on the Program | |||
with the Program (or with a work based on the Program) on a volume of | |||
a storage or distribution medium does not bring the other work under | |||
the scope of this License. | |||
3. You may copy and distribute the Program (or a work based on it, | |||
under Section 2) in object code or executable form under the terms of | |||
Sections 1 and 2 above provided that you also do one of the following: | |||
a) Accompany it with the complete corresponding machine-readable | |||
source code, which must be distributed under the terms of Sections | |||
1 and 2 above on a medium customarily used for software interchange; or, | |||
b) Accompany it with a written offer, valid for at least three | |||
years, to give any third party, for a charge no more than your | |||
cost of physically performing source distribution, a complete | |||
machine-readable copy of the corresponding source code, to be | |||
distributed under the terms of Sections 1 and 2 above on a medium | |||
customarily used for software interchange; or, | |||
c) Accompany it with the information you received as to the offer | |||
to distribute corresponding source code. (This alternative is | |||
allowed only for noncommercial distribution and only if you | |||
received the program in object code or executable form with such | |||
an offer, in accord with Subsection b above.) | |||
The source code for a work means the preferred form of the work for | |||
making modifications to it. For an executable work, complete source | |||
code means all the source code for all modules it contains, plus any | |||
associated interface definition files, plus the scripts used to | |||
control compilation and installation of the executable. However, as a | |||
special exception, the source code distributed need not include | |||
anything that is normally distributed (in either source or binary | |||
form) with the major components (compiler, kernel, and so on) of the | |||
operating system on which the executable runs, unless that component | |||
itself accompanies the executable. | |||
If distribution of executable or object code is made by offering | |||
access to copy from a designated place, then offering equivalent | |||
access to copy the source code from the same place counts as | |||
distribution of the source code, even though third parties are not | |||
compelled to copy the source along with the object code. | |||
4. You may not copy, modify, sublicense, or distribute the Program | |||
except as expressly provided under this License. Any attempt | |||
otherwise to copy, modify, sublicense or distribute the Program is | |||
void, and will automatically terminate your rights under this License. | |||
However, parties who have received copies, or rights, from you under | |||
this License will not have their licenses terminated so long as such | |||
parties remain in full compliance. | |||
5. You are not required to accept this License, since you have not | |||
signed it. However, nothing else grants you permission to modify or | |||
distribute the Program or its derivative works. These actions are | |||
prohibited by law if you do not accept this License. Therefore, by | |||
modifying or distributing the Program (or any work based on the | |||
Program), you indicate your acceptance of this License to do so, and | |||
all its terms and conditions for copying, distributing or modifying | |||
the Program or works based on it. | |||
6. Each time you redistribute the Program (or any work based on the | |||
Program), the recipient automatically receives a license from the | |||
original licensor to copy, distribute or modify the Program subject to | |||
these terms and conditions. You may not impose any further | |||
restrictions on the recipients' exercise of the rights granted herein. | |||
You are not responsible for enforcing compliance by third parties to | |||
this License. | |||
7. If, as a consequence of a court judgment or allegation of patent | |||
infringement or for any other reason (not limited to patent issues), | |||
conditions are imposed on you (whether by court order, agreement or | |||
otherwise) that contradict the conditions of this License, they do not | |||
excuse you from the conditions of this License. If you cannot | |||
distribute so as to satisfy simultaneously your obligations under this | |||
License and any other pertinent obligations, then as a consequence you | |||
may not distribute the Program at all. For example, if a patent | |||
license would not permit royalty-free redistribution of the Program by | |||
all those who receive copies directly or indirectly through you, then | |||
the only way you could satisfy both it and this License would be to | |||
refrain entirely from distribution of the Program. | |||
If any portion of this section is held invalid or unenforceable under | |||
any particular circumstance, the balance of the section is intended to | |||
apply and the section as a whole is intended to apply in other | |||
circumstances. | |||
It is not the purpose of this section to induce you to infringe any | |||
patents or other property right claims or to contest validity of any | |||
such claims; this section has the sole purpose of protecting the | |||
integrity of the free software distribution system, which is | |||
implemented by public license practices. Many people have made | |||
generous contributions to the wide range of software distributed | |||
through that system in reliance on consistent application of that | |||
system; it is up to the author/donor to decide if he or she is willing | |||
to distribute software through any other system and a licensee cannot | |||
impose that choice. | |||
This section is intended to make thoroughly clear what is believed to | |||
be a consequence of the rest of this License. | |||
8. If the distribution and/or use of the Program is restricted in | |||
certain countries either by patents or by copyrighted interfaces, the | |||
original copyright holder who places the Program under this License | |||
may add an explicit geographical distribution limitation excluding | |||
those countries, so that distribution is permitted only in or among | |||
countries not thus excluded. In such case, this License incorporates | |||
the limitation as if written in the body of this License. | |||
9. The Free Software Foundation may publish revised and/or new versions | |||
of the General Public License from time to time. Such new versions will | |||
be similar in spirit to the present version, but may differ in detail to | |||
address new problems or concerns. | |||
Each version is given a distinguishing version number. If the Program | |||
specifies a version number of this License which applies to it and "any | |||
later version", you have the option of following the terms and conditions | |||
either of that version or of any later version published by the Free | |||
Software Foundation. If the Program does not specify a version number of | |||
this License, you may choose any version ever published by the Free Software | |||
Foundation. | |||
10. If you wish to incorporate parts of the Program into other free | |||
programs whose distribution conditions are different, write to the author | |||
to ask for permission. For software which is copyrighted by the Free | |||
Software Foundation, write to the Free Software Foundation; we sometimes | |||
make exceptions for this. Our decision will be guided by the two goals | |||
of preserving the free status of all derivatives of our free software and | |||
of promoting the sharing and reuse of software generally. | |||
NO WARRANTY | |||
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY | |||
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN | |||
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES | |||
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED | |||
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS | |||
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE | |||
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, | |||
REPAIR OR CORRECTION. | |||
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING | |||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR | |||
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, | |||
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING | |||
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED | |||
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY | |||
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER | |||
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE | |||
POSSIBILITY OF SUCH DAMAGES. | |||
END OF TERMS AND CONDITIONS | |||
How to Apply These Terms to Your New Programs | |||
If you develop a new program, and you want it to be of the greatest | |||
possible use to the public, the best way to achieve this is to make it | |||
free software which everyone can redistribute and change under these terms. | |||
To do so, attach the following notices to the program. It is safest | |||
to attach them to the start of each source file to most effectively | |||
convey the exclusion of warranty; and each file should have at least | |||
the "copyright" line and a pointer to where the full notice is found. | |||
<one line to give the program's name and a brief idea of what it does.> | |||
Copyright (C) <year> <name of author> | |||
This program is free software; you can redistribute it and/or modify | |||
it under the terms of the GNU General Public License as published by | |||
the Free Software Foundation; either version 2 of the License, or | |||
(at your option) any later version. | |||
This program is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
GNU General Public License for more details. | |||
You should have received a copy of the GNU General Public License | |||
along with this program; if not, write to the Free Software | |||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |||
Also add information on how to contact you by electronic and paper mail. | |||
If the program is interactive, make it output a short notice like this | |||
when it starts in an interactive mode: | |||
Gnomovision version 69, Copyright (C) year name of author | |||
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. | |||
This is free software, and you are welcome to redistribute it | |||
under certain conditions; type `show c' for details. | |||
The hypothetical commands `show w' and `show c' should show the appropriate | |||
parts of the General Public License. Of course, the commands you use may | |||
be called something other than `show w' and `show c'; they could even be | |||
mouse-clicks or menu items--whatever suits your program. | |||
You should also get your employer (if you work as a programmer) or your | |||
school, if any, to sign a "copyright disclaimer" for the program, if | |||
necessary. Here is a sample; alter the names: | |||
Yoyodyne, Inc., hereby disclaims all copyright interest in the program | |||
`Gnomovision' (which makes passes at compilers) written by James Hacker. | |||
<signature of Ty Coon>, 1 April 1989 | |||
Ty Coon, President of Vice | |||
This General Public License does not permit incorporating your program into | |||
proprietary programs. If your program is a subroutine library, you may | |||
consider it more useful to permit linking proprietary applications with the | |||
library. If this is what you want to do, use the GNU Library General | |||
Public License instead of this License. |
@ -0,0 +1 @@ | |||
@ -0,0 +1,234 @@ | |||
# Doxyfile 1.3.3-Gideon | |||
#--------------------------------------------------------------------------- | |||
# Project related configuration options | |||
#--------------------------------------------------------------------------- | |||
PROJECT_NAME = kstreamripper.kdevelop | |||
PROJECT_NUMBER = 0.1 | |||
OUTPUT_DIRECTORY = | |||
OUTPUT_LANGUAGE = English | |||
USE_WINDOWS_ENCODING = NO | |||
BRIEF_MEMBER_DESC = YES | |||
REPEAT_BRIEF = YES | |||
ALWAYS_DETAILED_SEC = NO | |||
INLINE_INHERITED_MEMB = NO | |||
FULL_PATH_NAMES = NO | |||
STRIP_FROM_PATH = | |||
SHORT_NAMES = NO | |||
JAVADOC_AUTOBRIEF = NO | |||
MULTILINE_CPP_IS_BRIEF = NO | |||
DETAILS_AT_TOP = NO | |||
INHERIT_DOCS = YES | |||
DISTRIBUTE_GROUP_DOC = NO | |||
TAB_SIZE = 8 | |||
ALIASES = | |||
OPTIMIZE_OUTPUT_FOR_C = NO | |||
OPTIMIZE_OUTPUT_JAVA = NO | |||
SUBGROUPING = YES | |||
#--------------------------------------------------------------------------- | |||
# Build related configuration options | |||
#--------------------------------------------------------------------------- | |||
EXTRACT_ALL = NO | |||
EXTRACT_PRIVATE = NO | |||
EXTRACT_STATIC = NO | |||
EXTRACT_LOCAL_CLASSES = YES | |||
HIDE_UNDOC_MEMBERS = NO | |||
HIDE_UNDOC_CLASSES = NO | |||
HIDE_FRIEND_COMPOUNDS = NO | |||
HIDE_IN_BODY_DOCS = NO | |||
INTERNAL_DOCS = NO | |||
CASE_SENSE_NAMES = YES | |||
HIDE_SCOPE_NAMES = NO | |||
SHOW_INCLUDE_FILES = YES | |||
INLINE_INFO = YES | |||
SORT_MEMBER_DOCS = YES | |||
GENERATE_TODOLIST = YES | |||
GENERATE_TESTLIST = YES | |||
GENERATE_BUGLIST = YES | |||
GENERATE_DEPRECATEDLIST= YES | |||
ENABLED_SECTIONS = | |||
MAX_INITIALIZER_LINES = 30 | |||
SHOW_USED_FILES = YES | |||
#--------------------------------------------------------------------------- | |||
# configuration options related to warning and progress messages | |||
#--------------------------------------------------------------------------- | |||
QUIET = NO | |||
WARNINGS = YES | |||
WARN_IF_UNDOCUMENTED = YES | |||
WARN_IF_DOC_ERROR = YES | |||
WARN_FORMAT = "$file:$line: $text" | |||
WARN_LOGFILE = | |||
#--------------------------------------------------------------------------- | |||
# configuration options related to the input files | |||
#--------------------------------------------------------------------------- | |||
INPUT = /home/tuxipuxi/Documents/cpp/kde/kstreamripper | |||
FILE_PATTERNS = *.c \ | |||
*.cc \ | |||
*.cxx \ | |||
*.cpp \ | |||
*.c++ \ | |||
*.java \ | |||
*.ii \ | |||
*.ixx \ | |||
*.ipp \ | |||
*.i++ \ | |||
*.inl \ | |||
*.h \ | |||
*.hh \ | |||
*.hxx \ | |||
*.hpp \ | |||
*.h++ \ | |||
*.idl \ | |||
*.odl \ | |||
*.cs \ | |||
*.php \ | |||
*.php3 \ | |||
*.inc \ | |||
*.C \ | |||
*.H \ | |||
*.tlh \ | |||
*.diff \ | |||
*.patch \ | |||
*.moc \ | |||
*.xpm \ | |||
*.dox | |||
RECURSIVE = yes | |||
EXCLUDE = | |||
EXCLUDE_SYMLINKS = NO | |||
EXCLUDE_PATTERNS = | |||
EXAMPLE_PATH = | |||
EXAMPLE_PATTERNS = * | |||
EXAMPLE_RECURSIVE = NO | |||
IMAGE_PATH = | |||
INPUT_FILTER = | |||
FILTER_SOURCE_FILES = NO | |||
#--------------------------------------------------------------------------- | |||
# configuration options related to source browsing | |||
#--------------------------------------------------------------------------- | |||
SOURCE_BROWSER = NO | |||
INLINE_SOURCES = NO | |||
STRIP_CODE_COMMENTS = YES | |||
REFERENCED_BY_RELATION = YES | |||
REFERENCES_RELATION = YES | |||
VERBATIM_HEADERS = YES | |||
#--------------------------------------------------------------------------- | |||
# configuration options related to the alphabetical class index | |||
#--------------------------------------------------------------------------- | |||
ALPHABETICAL_INDEX = NO | |||
COLS_IN_ALPHA_INDEX = 5 | |||
IGNORE_PREFIX = | |||
#--------------------------------------------------------------------------- | |||
# configuration options related to the HTML output | |||
#--------------------------------------------------------------------------- | |||
GENERATE_HTML = YES | |||
HTML_OUTPUT = html | |||
HTML_FILE_EXTENSION = .html | |||
HTML_HEADER = | |||
HTML_FOOTER = | |||
HTML_STYLESHEET = | |||
HTML_ALIGN_MEMBERS = YES | |||
GENERATE_HTMLHELP = NO | |||
CHM_FILE = | |||
HHC_LOCATION = | |||
GENERATE_CHI = NO | |||
BINARY_TOC = NO | |||
TOC_EXPAND = NO | |||
DISABLE_INDEX = NO | |||
ENUM_VALUES_PER_LINE = 4 | |||
GENERATE_TREEVIEW = NO | |||
TREEVIEW_WIDTH = 250 | |||
#--------------------------------------------------------------------------- | |||
# configuration options related to the LaTeX output | |||
#--------------------------------------------------------------------------- | |||
GENERATE_LATEX = YES | |||
LATEX_OUTPUT = latex | |||
LATEX_CMD_NAME = latex | |||
MAKEINDEX_CMD_NAME = makeindex | |||
COMPACT_LATEX = NO | |||
PAPER_TYPE = a4wide | |||
EXTRA_PACKAGES = | |||
LATEX_HEADER = | |||
PDF_HYPERLINKS = NO | |||
USE_PDFLATEX = NO | |||
LATEX_BATCHMODE = NO | |||
LATEX_HIDE_INDICES = NO | |||
#--------------------------------------------------------------------------- | |||
# configuration options related to the RTF output | |||
#--------------------------------------------------------------------------- | |||
GENERATE_RTF = NO | |||
RTF_OUTPUT = rtf | |||
COMPACT_RTF = NO | |||
RTF_HYPERLINKS = NO | |||
RTF_STYLESHEET_FILE = | |||
RTF_EXTENSIONS_FILE = | |||
#--------------------------------------------------------------------------- | |||
# configuration options related to the man page output | |||
#--------------------------------------------------------------------------- | |||
GENERATE_MAN = NO | |||
MAN_OUTPUT = man | |||
MAN_EXTENSION = .3 | |||
MAN_LINKS = NO | |||
#--------------------------------------------------------------------------- | |||
# configuration options related to the XML output | |||
#--------------------------------------------------------------------------- | |||
GENERATE_XML = yes | |||
XML_OUTPUT = xml | |||
XML_SCHEMA = | |||
XML_DTD = | |||
#--------------------------------------------------------------------------- | |||
# configuration options for the AutoGen Definitions output | |||
#--------------------------------------------------------------------------- | |||
GENERATE_AUTOGEN_DEF = NO | |||
#--------------------------------------------------------------------------- | |||
# configuration options related to the Perl module output | |||
#--------------------------------------------------------------------------- | |||
GENERATE_PERLMOD = NO | |||
PERLMOD_LATEX = NO | |||
PERLMOD_PRETTY = YES | |||
PERLMOD_MAKEVAR_PREFIX = | |||
#--------------------------------------------------------------------------- | |||
# Configuration options related to the preprocessor | |||
#--------------------------------------------------------------------------- | |||
ENABLE_PREPROCESSING = YES | |||
MACRO_EXPANSION = NO | |||
EXPAND_ONLY_PREDEF = NO | |||
SEARCH_INCLUDES = YES | |||
INCLUDE_PATH = | |||
INCLUDE_FILE_PATTERNS = | |||
PREDEFINED = | |||
EXPAND_AS_DEFINED = | |||
SKIP_FUNCTION_MACROS = YES | |||
#--------------------------------------------------------------------------- | |||
# Configuration::addtions related to external references | |||
#--------------------------------------------------------------------------- | |||
TAGFILES = | |||
GENERATE_TAGFILE = | |||
ALLEXTERNALS = NO | |||
EXTERNAL_GROUPS = YES | |||
PERL_PATH = /usr/bin/perl | |||
#--------------------------------------------------------------------------- | |||
# Configuration options related to the dot tool | |||
#--------------------------------------------------------------------------- | |||
CLASS_DIAGRAMS = YES | |||
HIDE_UNDOC_RELATIONS = YES | |||
HAVE_DOT = NO | |||
CLASS_GRAPH = YES | |||
COLLABORATION_GRAPH = YES | |||
UML_LOOK = NO | |||
TEMPLATE_RELATIONS = NO | |||
INCLUDE_GRAPH = YES | |||
INCLUDED_BY_GRAPH = YES | |||
CALL_GRAPH = NO | |||
GRAPHICAL_HIERARCHY = YES | |||
DOT_IMAGE_FORMAT = png | |||
DOT_PATH = | |||
DOTFILE_DIRS = | |||
MAX_DOT_GRAPH_WIDTH = 1024 | |||
MAX_DOT_GRAPH_HEIGHT = 1024 | |||
MAX_DOT_GRAPH_DEPTH = 1000 | |||
GENERATE_LEGEND = YES | |||
DOT_CLEANUP = YES | |||
#--------------------------------------------------------------------------- | |||
# Configuration::addtions related to the search engine | |||
#--------------------------------------------------------------------------- | |||
SEARCHENGINE = NO |
@ -0,0 +1,84 @@ | |||
sctest REQUIREMENTS | |||
------------------------ | |||
kde >= 3.2 is needed to run sctest | |||
To compile sctest, the kde development packages | |||
are needed: kdelibs-devel, kdebase-devel and python | |||
scons is also needed http://www.scons.org | |||
(this tool also used by Blender, ..) | |||
Make sure scons is at least v0.96.1, otherwise | |||
the compilation will fail. In case if you do not have | |||
it, a minimum distribution is provided (see SCONS below) | |||
-> One should only have to run : | |||
$ scons | |||
# scons install | |||
(do "scons install" as root - the menus may not | |||
show up if you skip this step) | |||
SCONS | |||
----- | |||
-> If scons is missing, use the one bundled with PROGRAMNAME : | |||
./unpack_local_scons.sh | |||
python scons.py | |||
python scons.py install | |||
(run the last command as root) | |||
-> For your convenience, a quick makefile is created : | |||
./unpack_local_scons.sh | |||
make | |||
make install | |||
USEFUL SCONS COMMANDS | |||
--------------------- | |||
build the targets : scons | |||
install them : scons install | |||
clean the project : scons -c | |||
uninstall : scons -c install | |||
build in parallel : scons -j2 | |||
CONFIGURATION NOTES | |||
------------------- | |||
The installation scripts are relying on the kde-config program. | |||
The programs kde-config, qmake, uic and moc must be accesssible | |||
through your PATH. | |||
Qt and kde may not be installed as expected (in QTDIR and KDEDIR) | |||
So until kde-config is able to give that information, you may | |||
have to give those paths. | |||
Here are some examples : | |||
On Fedora/Redhat | |||
scons configure kdeincludes=/usr/include/kde/ | |||
On Debian | |||
scons configure qtincludes=/usr/include/qt/ kdeinclude=/usr/include/kde/ | |||
To install in some particular location with additional include paths | |||
scons configure prefix=~/tmp extraincludes=/tmp/include:/usr/local/include | |||
For more options to tune the build look at the .py files available on | |||
the top-level directory : | |||
generic.py, kde.py, ... | |||
The build system is based on bksys, a build system that replaces | |||
autoconf, automake and make in a row. Feel free to report your opinion | |||
about it to the authors. | |||
BUILDING RPMS OR DEBS WITH CHECKINSTALL | |||
--------------------------------------- | |||
With checkinstall 1.6, use | |||
$ scons | |||
# checkinstall --fstrans=no --nodoc scons install | |||
# scons uninstall | |||
--------------------------------------- | |||
enjoy KStreamRipper | |||
Michael Goettsche |
@ -0,0 +1,20 @@ | |||
all: | |||
@/usr/bin/scons -Q | |||
# it is also possible to use | |||
# @/usr/bin/scons -Q -j4 | |||
install: | |||
@/usr/bin/scons -Q install | |||
clean: | |||
@/usr/bin/scons -Q -c | |||
uninstall: | |||
@/usr/bin/scons -Q -c install | |||
dist: | |||
@/usr/bin/scons -Q dist | |||
distclean: | |||
@/usr/bin/scons -Q distclean |
@ -0,0 +1 @@ | |||
@ -0,0 +1 @@ | |||
see INSTALL |
@ -0,0 +1,234 @@ | |||
#! /usr/bin/env python | |||
## The kde detection is located in kde.py (have a look!) | |||
## Delete the comments following as you see it fit | |||
""" | |||
scons files are python scripts, comments begin by a "#" symbol | |||
or are enclosed between sequences of triple quotes, so | |||
this is a comment :) | |||
There is a lot of documentation and comments, but you can | |||
remove them when you convert your program | |||
""" | |||
""" | |||
---------------------------------- | |||
How to enjoy bksys full and plenty | |||
(and forget about the autohell ? :) | |||
----------------------------------- | |||
The program scons is usually launched as "scons" | |||
When it is not intalled globally, one can run | |||
"python scons.py" instead (ie : to use the local scons | |||
that comes with bksys - try ./unpack_local_scons.sh) | |||
To compile the project, you will then only need to launch | |||
scons on the top-level directory, the scripts find and | |||
cache the proper environment automatically : | |||
-> scons | |||
(or python scons.py) | |||
To clean the project | |||
-> scons -c | |||
(or python scons.py -c) | |||
To install the project | |||
-> scons install | |||
(or python scons.py scons install) | |||
To uninstall the project | |||
-> scons -c install | |||
To compile while being in a subdirectory | |||
-> cd src; scons -u | |||
To (re)configure the project and give particular arguments, use ie : | |||
-> scons configure debug=1 | |||
-> scons configure prefix=/tmp/ita debug=full extraincludes=/usr/local/include:/tmp/include prefix=/usr/local | |||
or -> python scons.py configure debug=1 | |||
etc .. | |||
The variables are saved automatically after the first run | |||
(look at kde.cache.py, ..) | |||
Here is a quick list of options used (look at generic.py and kde.py) : | |||
prefix | |||
exec_prefix | |||
datadir | |||
libdir | |||
kdeincludes | |||
qtincludes | |||
kdelibs | |||
qtlibs | |||
extraincludes (a list of paths separated by ':') | |||
""" | |||
########################################### | |||
## Common section, for loading the tools | |||
## Load the builders in config | |||
env = Environment(TARGS=COMMAND_LINE_TARGETS, ARGS=ARGUMENTS, tools=['default', 'generic', 'kde'], toolpath=['./', './admin']) | |||
#env = Environment(TARGS=COMMAND_LINE_TARGETS, ARGS=ARGUMENTS, tools=['default', 'generic', 'kde', 'cg'], toolpath=['./']) | |||
#env = Environment(TARGS=COMMAND_LINE_TARGETS, ARGS=ARGUMENTS, tools=['default', 'generic', 'kde', 'sound'], toolpath=['./']) | |||
#env = Environment(TARGS=COMMAND_LINE_TARGETS, ARGS=ARGUMENTS, tools=['default', 'generic', 'kde', 'libxml'], toolpath=['./']) | |||
## the configuration should be done by now, quit | |||
if 'configure' in COMMAND_LINE_TARGETS: | |||
env.Exit(0) | |||
""" | |||
Overview of the module system : | |||
Each module (kde.py, generic.py, sound.py..) tries to load a stored | |||
configuration when run. If the stored configuration does not exist | |||
or if 'configure' is given on the command line (scons configure), | |||
the module launches the verifications and detectioins and stores | |||
the results. Modules also call exit when the detection fail. | |||
For example, kde.py stores its config into kde.cache.py | |||
This has several advantages for both developers and users : | |||
- Users do not have to run ./configure to compile | |||
- The build is insensitive to environment changes | |||
- The cache maintains the objects so the config can be changed often | |||
- Each module adds its own help via env.Help("message") | |||
""" | |||
## Use the variables available in the environment - unsafe, but moc, meinproc need it :-/ | |||
import os | |||
env.AppendUnique( ENV = os.environ ) | |||
## The target make dist requires the python module shutil which is in 2.3 | |||
env.EnsurePythonVersion(2, 3) | |||
## Bksys requires scons 0.96 | |||
env.EnsureSConsVersion(0, 96) | |||
""" | |||
Explanation of the 'env = Environment...' line : | |||
* the command line arguments and targets are stored in env['TARGS'] and env['ARGS'] for use by the tools | |||
* the part 'tools=['default', 'generic ..' detect and load the necessary functions for doing the things | |||
* the part "toolpath=['./']" tells that the tools can be found in the current directory (generic.py, kde.py ..) | |||
""" | |||
""" | |||
To load more configuration modules one should only have to add the appropriate tool | |||
ie: to detect alsa and add the proper cflags, ldflags .. | |||
a file alsa.py file will be needed, and one should then use : | |||
env = Environment(TARGS=COMMAND_LINE_TARGETS, ARGS=ARGUMENTS, tools=['default', 'generic', 'kde', 'alsa'], toolpath=['./']) | |||
You can also load environments that are targetted to different platforms | |||
ie: if os.sys.platform = "darwin": | |||
env = Environment(... | |||
elsif os.sys.platform = "linux": | |||
env = Environment(... | |||
""" | |||
## Setup the cache directory - this avoids recompiling the same files over and over again | |||
## this is very handy when working with cvs | |||
env.CacheDir('cache') | |||
## Avoid spreading .sconsign files everywhere - keep this line | |||
env.SConsignFile('scons_signatures') | |||
## If you need more libs and they rely on pkg-config | |||
## ie: add support for GTK (source: the scons wiki on www.scons.org) | |||
# env.ParseConfig('pkg-config --cflags --libs gtk+-2.0') | |||
""" | |||
This tell scons that there are no rcs or sccs files - this trick | |||
can speed up things a bit when having lots of #include | |||
in the source code and for network file systems | |||
""" | |||
env.SourceCode(".", None) | |||
dirs = [ '.', 'src', 'po', 'doc'] | |||
for dir in dirs: | |||
env.SourceCode(dir, None) | |||
## If we had only one program (named kvigor) to build, | |||
## we could add before exporting the env (some kde | |||
## helpers in kde.py need it) : | |||
# env['APPNAME'] = 'kvigor' | |||
## Use this define if you are using the kde translation scheme (.po files) | |||
env.Append( CPPFLAGS = ['-DQT_NO_TRANSLATION'] ) | |||
## Add this define if you want to use qthreads | |||
#env.Append( CPPFLAGS = ['-DQT_THREAD_SUPPORT', '-D_REENTRANT'] ) | |||
## To use kdDebug(intvalue)<<"some trace"<<endl; you need to define -DDEBUG - it is done | |||
## in generic.py automatically when you do scons configure debug=1 | |||
## There are also many other defines : | |||
### -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -DQT_CLEAN_NAMESPACE -DQT_NO_ASCII_CAST -DQT_NO_STL -DQT_NO_COMPAT -DQT_NO_TRANSLATION | |||
# where are they documented ? if you know, mail tnagyemail-mail@yahoo@fr please | |||
## Important : export the environment so that SConscript files can the | |||
## configuration and builders in it | |||
Export("env") | |||
#################################################### | |||
## Process the SConscript files to build the targets | |||
## the sconscript files are comparable to Makefile.am_s | |||
## except that no makefile is generated here :) | |||
env.SConscript("src/SConscript") | |||
env.SConscript("doc/SConscript") | |||
env.SConscript("po/SConscript") | |||
#################################################### | |||
## Quick helper to distribute the program | |||
""" | |||
'scons dist' creates a tarball named bksys-version.tar.bz2 | |||
containing the source code - this is handy | |||
do not forget to remove the object files by scons -c | |||
""" | |||
### To make a tarball of your sctest | |||
if 'dist' in COMMAND_LINE_TARGETS: | |||
APPNAME = 'sctest' | |||
VERSION = os.popen("cat VERSION").read().rstrip() | |||
FOLDER = APPNAME+'-'+VERSION | |||
ARCHIVE = FOLDER+'.tar.bz2' | |||
GREEN ="\033[92m" | |||
NORMAL ="\033[0m" | |||
import shutil | |||
import glob | |||
## check if the temporary directory already exists | |||
if os.path.isdir(FOLDER): | |||
shutil.rmtree(FOLDER) | |||
## create a temporary directory | |||
startdir = os.getcwd() | |||
shutil.copytree(startdir, FOLDER) | |||
## remove the unnecessary files | |||
os.popen("find "+FOLDER+" -name \"{arch}\" | xargs rm -rf") | |||
os.popen("find "+FOLDER+" -name \".arch-ids\" | xargs rm -rf") | |||
os.popen("find "+FOLDER+" -name \".arch-inventory\" | xargs rm -f") | |||
os.popen("find "+FOLDER+" -name \"sconsign*\" | xargs rm -f") | |||
os.popen("find "+FOLDER+" -name \"*cache*\" | xargs rm -rf") | |||
os.popen("find "+FOLDER+" -name \"kdiss*-data\" | xargs rm -rf") | |||
os.popen("find "+FOLDER+" -name \"*.pyc\" | xargs rm -f") | |||
os.popen("rm -f "+FOLDER+"/config.py*") | |||
## make the tarball | |||
print GREEN+"Writing archive "+ARCHIVE+NORMAL | |||
os.popen("tar cjf "+ARCHIVE+" "+FOLDER) | |||
## remove the temporary directory | |||
if os.path.isdir(FOLDER): | |||
shutil.rmtree(FOLDER) | |||
env.Default(None) | |||
env.Exit(0) | |||
@ -0,0 +1,7 @@ | |||
--TODO-- | |||
-implement stats widget | |||
-implement filtering( just ripping a special artist/song ) | |||
-(receiving shoutcast list via web) | |||
@ -0,0 +1,161 @@ | |||
## Thomas Nagy, 2005 | |||
""" | |||
Detect and store the most common options | |||
* kdecxxflags : debug=1 (-g) or debug=full (-g3, slower) | |||
else use the user CXXFLAGS if any, - or -O2 by default | |||
* prefix : the installation path | |||
* extraincludes : a list of paths separated by ':' | |||
ie: scons configure debug=full prefix=/usr/local extraincludes=/tmp/include:/usr/local | |||
""" | |||
BOLD ="\033[1m" | |||
RED ="\033[91m" | |||
GREEN ="\033[92m" | |||
YELLOW ="\033[1m" #"\033[93m" # unreadable on white backgrounds | |||
CYAN ="\033[96m" | |||
NORMAL ="\033[0m" | |||
import os | |||
def exists(env): | |||
return true | |||
def generate(env): | |||
env.Help(""" | |||
"""+BOLD+ | |||
"""*** Generic options *** | |||
-----------------------"""+NORMAL+""" | |||
"""+BOLD+"""* debug """+NORMAL+""": debug=1 (-g) or debug=full (-g3, slower) else use environment CXXFLAGS, or -O2 by default | |||
"""+BOLD+"""* prefix """+NORMAL+""": the installation path | |||
"""+BOLD+"""* extraincludes """+NORMAL+""": a list of paths separated by ':' | |||
ie: """+BOLD+"""scons configure debug=full prefix=/usr/local extraincludes=/tmp/include:/usr/local | |||
"""+NORMAL) | |||
## Bksys requires scons 0.96 | |||
env.EnsureSConsVersion(0, 96) | |||
## Global cache directory | |||
## Put all project files in it so a rm -rf cache will clean up the config | |||
if not env.has_key('CACHEDIR'): | |||
env['CACHEDIR'] = os.getcwd()+'/cache/' | |||
if not os.path.isdir(env['CACHEDIR']): | |||
os.mkdir(env['CACHEDIR']) | |||
## SCons cache directory | |||
## this avoids recompiling the same files over and over again: very handy when working with cvs | |||
env.CacheDir(os.getcwd()+'/cache/objects') | |||
## Avoid spreading .sconsign files everywhere - keep this line | |||
env.SConsignFile(env['CACHEDIR']+'/scons_signatures') | |||
# Special trick for installing rpms ... | |||
env['DESTDIR']='' | |||
if 'install' in env['TARGS'] and os.environ.has_key('DESTDIR'): | |||
env['DESTDIR']=os.environ['DESTDIR']+'/' | |||
print CYAN+'** Enabling DESTDIR for the project ** ' + NORMAL + env['DESTDIR'] | |||
# load the options | |||
from SCons.Options import Options, PathOption | |||
cachefile=env['CACHEDIR']+'generic.cache.py' | |||
opts = Options(cachefile) | |||
opts.AddOptions( | |||
( 'KDECCFLAGS', 'C flags' ), | |||
( 'KDECXXFLAGS', 'debug level for the project : full or just anything' ), | |||
( 'KDELINKFLAGS', 'additional link flags' ), | |||
( 'PREFIX', 'prefix for installation' ), | |||
( 'EXTRAINCLUDES', 'extra include paths for the project' ), | |||
( 'ISCONFIGURED', 'is the project configured' ), | |||
) | |||
opts.Update(env) | |||
# use this to avoid an error message 'how to make target configure ?' | |||
env.Alias('configure', None) | |||
import SCons.Util | |||
# configure the environment if needed | |||
if 'configure' in env['TARGS'] or not env.has_key('ISCONFIGURED'): | |||
# be paranoid, unset existing variables | |||
if env.has_key('KDECXXFLAGS'): | |||
env.__delitem__('KDECXXFLAGS') | |||
if env.has_key('KDECCFLAGS'): | |||
env.__delitem__('KDECCFLAGS') | |||
if env.has_key('KDELINKFLAGS'): | |||
env.__delitem__('KDELINKFLAGS') | |||
if env.has_key('PREFIX'): | |||
env.__delitem__('PREFIX') | |||
if env.has_key('EXTRAINCLUDES'): | |||
env.__delitem__('EXTRAINCLUDES') | |||
if env.has_key('ISCONFIGURED'): | |||
env.__delitem__('ISCONFIGURED') | |||
if env['ARGS'].get('debug', None): | |||
debuglevel = env['ARGS'].get('debug', None) | |||
print CYAN+'** Enabling debug for the project **' + NORMAL | |||
if (debuglevel == "full"): | |||
env['KDECXXFLAGS'] = ['-DDEBUG', '-g3'] | |||
else: | |||
env['KDECXXFLAGS'] = ['-DDEBUG', '-g'] | |||
else: | |||
if os.environ.has_key('CXXFLAGS'): | |||
# user-defined flags (gentooers will be elighted) | |||
env['KDECXXFLAGS'] = SCons.Util.CLVar( os.environ['CXXFLAGS'] ) | |||
env.Append( KDECXXFLAGS = ['-DNDEBUG', '-DNO_DEBUG'] ) | |||
else: | |||
env.Append(KDECXXFLAGS = ['-O2', '-DNDEBUG', '-DNO_DEBUG']) | |||
if os.environ.has_key('CFLAGS'): | |||
env['KDECCFLAGS'] = SCons.Util.CLVar( os.environ['CFLAGS'] ) | |||
## FreeBSD settings (contributed by will at freebsd dot org) | |||
if os.uname()[0] == "FreeBSD": | |||
if os.environ.has_key('PTHREAD_LIBS'): | |||
env.AppendUnique( KDELINKFLAGS = SCons.Util.CLVar( os.environ['PTHREAD_LIBS'] ) ) | |||
else: | |||
syspf = os.popen('/sbin/sysctl kern.osreldate') | |||
osreldate = int(syspf.read().split()[1]) | |||
syspf.close() | |||
if osreldate < 500016: | |||
env.AppendUnique( KDELINKFLAGS = ['-pthread']) | |||
env.AppendUnique( KDECXXFLAGS = ['-D_THREAD_SAFE']) | |||
elif osreldate < 502102: | |||
env.AppendUnique( KDELINKFLAGS = ['-lc_r']) | |||
env.AppendUnique( KDECXXFLAGS = ['-D_THREAD_SAFE']) | |||
else: | |||
env.AppendUnique( KDELINKFLAGS = ['-pthread']) | |||
# User-specified prefix | |||
if env['ARGS'].get('prefix', None): | |||
env['PREFIX'] = env['ARGS'].get('prefix', None) | |||
print CYAN+'** set the installation prefix for the project : ' + env['PREFIX'] +' **'+ NORMAL | |||
elif env.has_key('PREFIX'): | |||
env.__delitem__('PREFIX') | |||
# User-specified include paths | |||
env['EXTRAINCLUDES'] = env['ARGS'].get('extraincludes', None) | |||
if env['ARGS'].get('extraincludes', None): | |||
print CYAN+'** set extra include paths for the project : ' + env['EXTRAINCLUDES'] +' **'+ NORMAL | |||
elif env.has_key('EXTRAINCLUDES'): | |||
env.__delitem__('EXTRAINCLUDES') | |||
env['ISCONFIGURED']=1 | |||
# And finally save the options in the cache | |||
opts.Save(cachefile, env) | |||
if env.has_key('KDECXXFLAGS'): | |||
env.AppendUnique( CPPFLAGS = env['KDECXXFLAGS'] ) | |||
if env.has_key('KDECCFLAGS'): | |||
env.AppendUnique( CCFLAGS = env['KDECCFLAGS'] ) | |||
if env.has_key('KDELINKFLAGS'): | |||
env.AppendUnique( LINKFLAGS = env['KDELINKFLAGS'] ) | |||
if env.has_key('EXTRAINCLUDES'): | |||
incpaths = [] | |||
for dir in str(env['EXTRAINCLUDES']).split(':'): | |||
incpaths.append( dir ) | |||
env.Append(CPPPATH = incpaths) | |||
@ -0,0 +1,683 @@ | |||
#! /usr/bin/env python | |||
# more or less derived from scons qt.py | |||
# this version makes less scans over the data and is thus faster | |||
# it is less accurate however (when mocable classes become unmocable) | |||
# Thomas Nagy, 2004, 2005 <tnagy2^8@yahoo.fr> | |||
from time import * | |||
import SCons.Util | |||
import string | |||
import os, re | |||
BOLD ="\033[1m" | |||
RED ="\033[91m" | |||
GREEN ="\033[92m" | |||
YELLOW ="\033[1m" #"\033[93m" # unreadable on white backgrounds | |||
CYAN ="\033[96m" | |||
NORMAL ="\033[0m" | |||
# Returns the name of the shared object (i.e. libkdeui.so.4) | |||
# referenced by a libtool archive (like libkdeui.la) | |||
def getSOfromLA(lafile): | |||
contents = open(lafile, 'r').read() | |||
match = re.search("^dlname='([^']*)'$", contents, re.M) | |||
if match: | |||
return match.group(1) | |||
return None | |||
def exists(env): | |||
return True | |||
def detect_kde(env): | |||
""" Detect the qt and kde environment using kde-config mostly """ | |||
prefix = env['ARGS'].get('prefix', None) | |||
execprefix = env['ARGS'].get('execprefix', None) | |||
datadir = env['ARGS'].get('datadir', None) | |||
libdir = env['ARGS'].get('libdir', None) | |||
kdeincludes= env['ARGS'].get('kdeincludes', None) | |||
kdelibs = env['ARGS'].get('kdelibs', None) | |||
qtincludes = env['ARGS'].get('qtincludes', None) | |||
qtlibs = env['ARGS'].get('qtlibs', None) | |||
## Detect the kde libraries | |||
print "Checking for kde-config : ", | |||
kde_config = os.popen("which kde-config 2>/dev/null").read().strip() | |||
if len(kde_config): | |||
print GREEN + "kde-config was found" + NORMAL | |||
else: | |||
print RED + "kde-config was NOT found in your PATH"+ NORMAL | |||
print "Make sure kde is installed properly" | |||
print "(missing package kdebase-devel?)" | |||
env.Exit(1) | |||
env['KDEDIR'] = os.popen('kde-config -prefix').read().strip() | |||
print "Checking for kde version : ", | |||
kde_version = os.popen("kde-config --version|grep KDE").read().strip().split()[1] | |||
if int(kde_version[0]) != 3 or int(kde_version[2]) < 2: | |||
print RED + kde_version | |||
print RED + "Your kde version can be too old" + NORMAL | |||
print RED + "Please make sure kde is at least 3.2" + NORMAL | |||
else: | |||
print GREEN + kde_version + NORMAL | |||
## Detect the qt library | |||
print "Checking for the qt library : ", | |||
qtdir = os.getenv("QTDIR") | |||
if qtdir: | |||
print GREEN + "qt is in " + qtdir + NORMAL | |||
else: | |||
libdir = os.popen('kde-config --expandvars --install lib').read().strip() | |||
libkdeuiSO = libdir+'/'+getSOfromLA(libdir+'/libkdeui.la') | |||
m = re.search('(.*)/lib/libqt.*', os.popen('ldd '+libkdeuiSO+' | grep libqt').read().strip().split()[2]) | |||
if m: | |||
qtdir = m.group(1) | |||
print YELLOW+"qt was found as " + m.group(1) + NORMAL | |||
else: | |||
print RED+"qt was not found"+NORMAL | |||
print RED+"Please set QTDIR first (/usr/lib/qt3?)"+NORMAL | |||
env.Exit(1) | |||
env['QTDIR'] = qtdir.strip() | |||
## Find the necessary programs uic and moc | |||
print "Checking for uic : ", | |||
uic = qtdir + "/bin/uic" | |||
if os.path.isfile(uic): | |||
print GREEN+"uic was found as "+uic+NORMAL | |||
else: | |||
uic = os.popen("which uic 2>/dev/null").read().strip() | |||
if len(uic): | |||
print YELLOW+"uic was found as "+uic+NORMAL | |||
else: | |||
uic = os.popen("which uic 2>/dev/null").read().strip() | |||
if len(uic): | |||
print YELLOW+"uic was found as "+uic+NORMAL | |||
else: | |||
print RED+"uic was not found - set QTDIR put it in your PATH ?"+NORMAL | |||
env.Exit(1) | |||
env['QT_UIC'] = uic | |||
print "Checking for moc : ", | |||
moc = qtdir + "/bin/moc" | |||
if os.path.isfile(moc): | |||
print GREEN+"moc was found as "+moc+NORMAL | |||
else: | |||
moc = os.popen("which moc 2>/dev/null").read().strip() | |||
if len(moc): | |||
print YELLOW+"moc was found as "+moc+NORMAL | |||
elif os.path.isfile("/usr/share/qt3/bin/moc"): | |||
moc = "/usr/share/qt3/bin/moc" | |||
print YELLOW+"moc was found as "+moc+NORMAL | |||
else: | |||
print RED+"moc was not found - set QTDIR or put it in your PATH ?"+NORMAL | |||
env.Exit(1) | |||
env['QT_MOC'] = moc | |||
## check for the qt and kde includes | |||
print "Checking for the qt includes : ", | |||
if qtincludes and os.path.isfile(qtincludes + "/qlayout.h"): | |||
# The user told where to look for and it looks valid | |||
print GREEN+"ok "+qtincludes+NORMAL | |||
else: | |||
if os.path.isfile(qtdir + "/include/qlayout.h"): | |||
# Automatic detection | |||
print GREEN+"ok "+qtdir + "/include/ "+NORMAL | |||
qtincludes = qtdir + "/include/" | |||
elif os.path.isfile("/usr/include/qt3/qlayout.h"): | |||
# Debian probably | |||
print YELLOW+"the qt headers were found in /usr/include/qt3/ "+NORMAL | |||
qtincludes = "/usr/include/qt3" | |||
else: | |||
print RED+"the qt headers were not found"+NORMAL | |||
env.Exit(1) | |||
print "Checking for the kde includes : ", | |||
kdeprefix = os.popen("kde-config --prefix").read().strip() | |||
if not kdeincludes: | |||
kdeincludes = kdeprefix+"/include/" | |||
if os.path.isfile(kdeincludes + "/klineedit.h"): | |||
print GREEN+"ok "+kdeincludes+NORMAL | |||
else: | |||
if os.path.isfile(kdeprefix+"/include/kde/klineedit.h"): | |||
# Debian, Fedora probably | |||
print YELLOW+"the kde headers were found in "+kdeprefix+"/include/kde/"+NORMAL | |||
kdeincludes = kdeprefix + "/include/kde/" | |||
else: | |||
print RED+"The kde includes were NOT found"+NORMAL | |||
env.Exit(1) | |||
if prefix: | |||
## use the user-specified prefix | |||
if not execprefix: | |||
execprefix = prefix | |||
if not datadir: | |||
datadir = prefix+"/share" | |||
if not libdir: | |||
libdir = execprefix+"/lib" | |||
subst_vars = lambda x: x.replace('${exec_prefix}',execprefix).replace('${datadir}',datadir).replace('${libdir}',libdir) | |||
env['KDEBIN'] = subst_vars(os.popen('kde-config --install exe').read().strip()) | |||
env['KDEAPPS'] = subst_vars(os.popen('kde-config --install apps').read().strip()) | |||
env['KDEDATA'] = subst_vars(os.popen('kde-config --install data').read().strip()) | |||
env['KDEMODULE']= subst_vars(os.popen('kde-config --install module').read().strip()) | |||
env['KDELOCALE']= subst_vars(os.popen('kde-config --install locale').read().strip()) | |||
env['KDEDOC'] = subst_vars(os.popen('kde-config --install html').read().strip()) | |||
env['KDEKCFG'] = subst_vars(os.popen('kde-config --install kcfg').read().strip()) | |||
env['KDEXDG'] = subst_vars(os.popen('kde-config --install xdgdata-apps').read().strip()) | |||
env['KDEMENU'] = subst_vars(os.popen('kde-config --install apps').read().strip()) | |||
env['KDEMIME'] = subst_vars(os.popen('kde-config --install mime').read().strip()) | |||
env['KDEICONS'] = subst_vars(os.popen('kde-config --install icon').read().strip()) | |||
env['KDESERV'] = subst_vars(os.popen('kde-config --install services').read().strip()) | |||
else: | |||
# the user has given no prefix, install as a normal kde app | |||
env['PREFIX'] = os.popen('kde-config --prefix').read().strip() | |||
env['KDEBIN'] = os.popen('kde-config --expandvars --install exe').read().strip() | |||
env['KDEAPPS'] = os.popen('kde-config --expandvars --install apps').read().strip() | |||
env['KDEDATA'] = os.popen('kde-config --expandvars --install data').read().strip() | |||
env['KDEMODULE']= os.popen('kde-config --expandvars --install module').read().strip() | |||
env['KDELOCALE']= os.popen('kde-config --expandvars --install locale').read().strip() | |||
env['KDEDOC'] = os.popen('kde-config --expandvars --install html').read().strip() | |||
env['KDEKCFG'] = os.popen('kde-config --expandvars --install kcfg').read().strip() | |||
env['KDEXDG'] = os.popen('kde-config --expandvars --install xdgdata-apps').read().strip() | |||
env['KDEMENU'] = os.popen('kde-config --expandvars --install apps').read().strip() | |||
env['KDEMIME'] = os.popen('kde-config --expandvars --install mime').read().strip() | |||
env['KDEICONS'] = os.popen('kde-config --expandvars --install icon').read().strip() | |||
env['KDESERV'] = os.popen('kde-config --expandvars --install services').read().strip() | |||
env['QTPLUGINS']=os.popen('kde-config --expandvars --install qtplugins').read().strip() | |||
## kde libs and includes | |||
env['KDEINCLUDEPATH']= kdeincludes | |||
if not kdelibs: | |||
kdelibs = os.popen('kde-config --expandvars --install lib').read().strip() | |||
env['KDELIBPATH']= kdelibs | |||
## qt libs and includes | |||
env['QTINCLUDEPATH']= qtincludes | |||
if not qtlibs: | |||
qtlibs = qtdir+"/lib" | |||
env['QTLIBPATH']= qtlibs | |||
def mocscan(target, source, env): | |||
splitext = SCons.Util.splitext | |||
q_object_search = re.compile(r'[^A-Za-z0-9]Q_OBJECT[^A-Za-z0-9]') | |||
for obj in source: | |||
if not obj.has_builder(): | |||
# binary obj file provided | |||
continue | |||
cpp = obj.sources[0] | |||
if not splitext(str(cpp))[1] == '.cpp': | |||
# not a cplusplus source | |||
continue | |||
# if we have a .ui file, it is automatically handled by Uic | |||
uiname = string.split(cpp.abspath, '.cpp')[0] + ".ui" | |||
if os.path.isfile(uiname): | |||
continue | |||
hname = splitext(cpp.name)[0] + ".h" | |||
h = SCons.Node.FS.find_file(hname, (cpp.get_dir(),) ) | |||
if h: | |||
# h file with the Q_OBJECT macro found -> add .moc file | |||
mocfile = string.split(cpp.abspath, '.cpp')[0] + ".moc" | |||
# trick : check if the moc file already exists (avoid a scan) | |||
if os.path.isfile(mocfile): | |||
env.Moc(h) | |||
elif q_object_search.search(h.get_contents()): | |||
# FIXME : strong assumption | |||
env.Moc(h) | |||
return (target, source) | |||
def generate(env): | |||
import SCons.Defaults | |||
import SCons.Tool | |||
env.Help(""" | |||
"""+BOLD+ | |||
"""*** KDE options *** | |||
-------------------"""+NORMAL+""" | |||
"""+BOLD+"""* prefix """+NORMAL+""": base install path, ie: /usr/local | |||
"""+BOLD+"""* execprefix """+NORMAL+""": install path for binaries, ie: /usr/bin | |||
"""+BOLD+"""* datadir """+NORMAL+""": install path for the data, ie: /usr/local/share | |||
"""+BOLD+"""* libdir """+NORMAL+""": install path for the libs, ie: /usr/lib | |||
"""+BOLD+"""* kdeincludes"""+NORMAL+""": path to the kde includes (/usr/include/kde on debian, ...) | |||
"""+BOLD+"""* qtincludes """+NORMAL+""": same punishment, for qt includes (/usr/include/qt on debian, ...) | |||
"""+BOLD+"""* kdelibs """+NORMAL+""": path to the kde libs, for linking the programs | |||
"""+BOLD+"""* qtlibs """+NORMAL+""": same punishment, for qt libraries | |||
ie: """+BOLD+"""scons configure libdir=/usr/local/lib qtincludes=/usr/include/qt | |||
"""+NORMAL) | |||
CLVar = SCons.Util.CLVar | |||
splitext = SCons.Util.splitext | |||
Builder = SCons.Builder.Builder | |||
# Detect the environment - replaces ./configure implicitely | |||
# and store the options into a cache | |||
from SCons.Options import Options | |||
cachefile=env['CACHEDIR']+'/kde.cache.py' | |||
opts = Options(cachefile) | |||
opts.AddOptions( | |||
( 'QTDIR', 'root of qt directory' ), | |||
( 'QTLIBPATH', 'path to the qt libraries' ), | |||
( 'QTINCLUDEPATH', 'path to the qt includes' ), | |||
( 'QT_UIC', 'moc directory'), | |||
( 'QT_MOC', 'moc executable command'), | |||
( 'QTPLUGINS', 'uic executable command'), | |||
( 'KDEDIR', 'root of kde directory' ), | |||
( 'KDELIBPATH', 'path to the kde libs' ), | |||
( 'KDEINCLUDEPATH', 'path to the kde includes' ), | |||
( 'PREFIX', 'root of the program installation'), | |||
( 'KDEBIN', 'installation path of the kde binaries'), | |||
( 'KDEMODULE', 'installation path of the parts and libs'), | |||
( 'KDEAPPS', ''), | |||
( 'KDEDATA', 'installation path of the application data'), | |||
( 'KDELOCALE', ''), | |||
( 'KDEDOC', 'installation path of the application documentation'), | |||
( 'KDEKCFG', 'installation path of the .kcfg files'), | |||
( 'KDEXDG', 'installation path of the service types'), | |||
( 'KDEMENU', ''), | |||
( 'KDEMIME', 'installation path of to the mimetypes'), | |||
( 'KDEICONS', ''), | |||
( 'KDESERV', ''), | |||
) | |||
opts.Update(env) | |||
# reconfigure when things are missing | |||
if 'configure' in env['TARGS'] or not env.has_key('QTDIR') or not env.has_key('KDEDIR'): | |||
detect_kde(env) | |||
# finally save the configuration | |||
opts.Save(cachefile, env) | |||
## set default variables, one can override them in sconscript files | |||
env.Append(CXXFLAGS = ['-I'+env['KDEINCLUDEPATH'], '-I'+env['QTINCLUDEPATH'] ]) | |||
env.Append(LIBPATH = [env['KDELIBPATH'], env['QTLIBPATH'] ]) | |||
env['STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME'] = 1 | |||
env['QT_AUTOSCAN'] = 1 | |||
env['QT_DEBUG'] = 0 | |||
env['QT_UIC_HFLAGS'] = '-L $QTPLUGINS -nounload' | |||
env['QT_UIC_CFLAGS'] = '$QT_UIC_HFLAGS -tr tr2i18n' | |||
env['QT_LIBS'] = 'qt-mt' | |||
env['LIBTOOL_FLAGS'] = '--silent --mode=compile --tag=CXX' | |||
env['QT_UICIMPLPREFIX'] = '' | |||
env['QT_UICIMPLSUFFIX'] = '.cpp' | |||
env['QT_MOCHPREFIX'] = '' | |||
env['QT_MOCHSUFFIX'] = '.moc' | |||
env['KDE_KCFG_IMPLPREFIX'] = '' | |||
env['KDE_KCFG_IMPL_HSUFFIX'] = '.h' | |||
env['KDE_KCFG_IMPL_CSUFFIX'] = '.cpp' | |||
env['KDE_SKEL_IMPL_SUFFIX'] = '.skel' | |||
env['MEINPROC'] = 'meinproc' | |||
env['MSGFMT'] = 'msgfmt' | |||
###### ui file processing | |||
def uicGenerator(target, source, env, for_signature): | |||
act=[] | |||
act.append('$QT_UIC $QT_UIC_HFLAGS -o '+target[0].path+' '+source[0].path) | |||
act.append('rm -f ' +target[1].path) | |||
act.append('echo \'#include <klocale.h>\' >> '+target[1].path) | |||
act.append('echo \'#include <kdialog.h>\' >> '+target[1].path) | |||
act.append('$QT_UIC $QT_UIC_CFLAGS -impl '+target[0].path+' -o '+target[1].path+'.tmp '+source[0].path) | |||
act.append('cat '+target[1].path+'.tmp >> '+target[1].path) | |||
act.append('rm -f '+target[1].path+'.tmp') | |||
act.append('echo \'#include "' + target[2].name + '"\' >> '+target[1].path) | |||
act.append('$QT_MOC -o '+target[2].path+' '+target[0].path) | |||
return act | |||
def uicEmitter(target, source, env): | |||
adjustixes = SCons.Util.adjustixes | |||
bs = SCons.Util.splitext(str(source[0].name))[0] | |||
bs = os.path.join(str(target[0].get_dir()),bs) | |||
# first target is automatically added by builder (.h file) | |||
if len(target) < 2: | |||
# second target is .cpp file | |||
target.append(adjustixes(bs, | |||
env.subst('$QT_UICIMPLPREFIX'), | |||
env.subst('$QT_UICIMPLSUFFIX'))) | |||
if len(target) < 3: | |||
# third target is .moc file | |||
target.append(adjustixes(bs, | |||
env.subst('$QT_MOCHPREFIX'), | |||
env.subst('$QT_MOCHSUFFIX'))) | |||
return target, source | |||
UIC_BUILDER = Builder( | |||
generator = uicGenerator, | |||
emitter = uicEmitter, | |||
suffix = '.h', | |||
src_suffix = '.ui' ) | |||
###### moc file processing | |||
env['QT_MOCCOM'] = ('$QT_MOC -o ${TARGETS[0]} $SOURCE') | |||
MOC_BUILDER = Builder( | |||
action = '$QT_MOCCOM', | |||
suffix = '.moc', | |||
src_suffix = '.h' ) | |||
MOCCPP_BUILDER = Builder( | |||
action = '$QT_MOCCOM', | |||
suffix = '_moc.cpp', | |||
src_suffix = '.h' ) | |||
###### kcfg file processing | |||
def kcfgGenerator(target, source, env, for_signature): | |||
act=[] | |||
act.append('kconfig_compiler -d'+str(source[0].get_dir())+' '+source[1].path+' '+source[0].path) | |||
return act | |||
def kcfgEmitter(target, source, env): | |||
adjustixes = SCons.Util.adjustixes | |||
bs = SCons.Util.splitext(str(source[0].name))[0] | |||
bs = os.path.join(str(target[0].get_dir()),bs) | |||
# first target is automatically added by builder (.h file) | |||
if len(target) < 2: | |||
# second target is .cpp file | |||
target.append(adjustixes(bs, env.subst('$KDE_KCFG_IMPLPREFIX'), env.subst('$KDE_KCFG_IMPL_CSUFFIX'))) | |||
if len(source) <2: | |||
kcfgfilename = os.popen("cat "+str(source[0])+"|grep File|sed 's/File.*=//i'").read().rstrip() | |||
source.append( str(source[0].get_dir())+'/'+kcfgfilename ) | |||
return target, source | |||
KCFG_BUILDER = Builder( | |||
generator = kcfgGenerator, | |||
emitter = kcfgEmitter, | |||
suffix = '.h', | |||
src_suffix = '.kcfgc' ) | |||
###### dcop processing | |||
def dcopGenerator(target, source, env, for_signature): | |||
act=[] | |||
act.append('dcopidl '+source[0].path+' > '+target[1].path+'|| ( rm -f '+target[1].path+' ; false )') | |||
act.append('dcopidl2cpp --c++-suffix cpp --no-signals --no-stub '+target[1].path) | |||
return act | |||
def dcopEmitter(target, source, env): | |||
bs = SCons.Util.splitext(str(source[0].name))[0] | |||
bs = os.path.join(str(target[0].get_dir()),bs) | |||
target.append(bs+'.kidl') | |||
#target.append(bs+'_skel.cpp') | |||
return target, source | |||
DCOP_BUILDER = Builder( | |||
generator = dcopGenerator, | |||
emitter = dcopEmitter, | |||
suffix = '_skel.cpp', | |||
src_suffix = '.h' ) | |||
###### documentation (meinproc) processing | |||
MEINPROC_BUILDER = Builder( | |||
action = '$MEINPROC --check --cache $TARGET $SOURCE', | |||
suffix = '.cache.bz2', | |||
src_suffix = '.docbook' ) | |||
###### translation files builder | |||
TRANSFILES_BUILDER = Builder( | |||
action = '$MSGFMT $SOURCE -o $TARGET', | |||
suffix = '.gmo', | |||
src_suffix = '.po' ) | |||
###### libtool file builder | |||
def laGenerator(target, source, env, for_signature): | |||
act=[] | |||
act.append('echo "dlname=\''+source[0].name+'\'" > '+target[0].path) | |||
act.append('echo "library_names=\''+source[0].name+' '+source[0].name+' '+source[0].name+'\'" >> '+target[0].path) | |||
act.append('echo "old_library=\'\'">> '+target[0].path) | |||
act.append('echo "dependency_libs=\'\'">> '+target[0].path) | |||
act.append('echo "current=0">> '+target[0].path) | |||
act.append('echo "age=0">> '+target[0].path) | |||
act.append('echo "revision=0">> '+target[0].path) | |||
act.append('echo "installed=yes">> '+target[0].path) | |||
act.append('echo "shouldnotlink=no">> '+target[0].path) | |||
act.append('echo "dlopen=\'\'">> '+target[0].path) | |||
act.append('echo "dlpreopen=\'\'">> '+target[0].path) | |||
act.append('echo "libdir=\''+env['KDEMODULE']+'\'" >> '+target[0].path) | |||
return act | |||
LA_BUILDER = Builder( | |||
generator = laGenerator, | |||
suffix = '.la', | |||
src_suffix = '.so' ) | |||
##### register the builders | |||
env['BUILDERS']['Uic'] = UIC_BUILDER | |||
env['BUILDERS']['Moc'] = MOC_BUILDER | |||
env['BUILDERS']['Moccpp'] = MOCCPP_BUILDER | |||
env['BUILDERS']['Dcop'] = DCOP_BUILDER | |||
env['BUILDERS']['Kcfg'] = KCFG_BUILDER | |||
env['BUILDERS']['LaFile'] = LA_BUILDER | |||
env['BUILDERS']['Meinproc'] = MEINPROC_BUILDER | |||
env['BUILDERS']['Transfiles'] = TRANSFILES_BUILDER | |||
static_obj, shared_obj = SCons.Tool.createObjBuilders(env) | |||
static_obj.src_builder.append('Uic') | |||
shared_obj.src_builder.append('Uic') | |||
static_obj.src_builder.append('Kcfg') | |||
shared_obj.src_builder.append('Kcfg') | |||
static_obj.src_builder.append('LaFile') | |||
shared_obj.src_builder.append('LaFile') | |||
static_obj.src_builder.append('Meinproc') | |||
shared_obj.src_builder.append('Meinproc') | |||
static_obj.src_builder.append('Transfiles') | |||
shared_obj.src_builder.append('Transfiles') | |||
## find the files to moc, dcop, and link against kde and qt | |||
env.AppendUnique(PROGEMITTER=[mocscan], SHLIBEMITTER=[mocscan], LIBEMITTER =[mocscan]) | |||
########################################### | |||
## Handy helpers for building kde programs | |||
## You should not have to modify them .. | |||
#import SCons.Util | |||
skel_ext = [".skel", ".SKEL"] | |||
def KDEfiles(lenv, target, source): | |||
""" Returns a list of files for scons (handles kde tricks like .skel) | |||
It also makes custom checks against double includes like : ['file.ui', 'file.cpp'] | |||
(file.cpp is already included because of file.ui) """ | |||
src=[] | |||
ui_files=[] | |||
kcfg_files=[] | |||
skel_files=[] | |||
other_files=[] | |||
# For each file, check wether it is a dcop file or not, and create the complete list of sources | |||
for file in source: | |||
bs = SCons.Util.splitext(file)[0] | |||
ext = SCons.Util.splitext(file)[1] | |||
if ext in skel_ext: | |||
lenv.Dcop(bs+'.h') | |||
src.append(bs+'_skel.cpp') | |||
elif ext == ".moch": | |||
lenv.Moccpp(bs+'.h') | |||
src.append(bs+'_moc.cpp') | |||
else: | |||
src.append(file) | |||
if ext == '.ui': | |||
ui_files.append(bs) | |||
elif ext == '.kcfgc': | |||
kcfg_files.append(bs) | |||
elif ext == '.skel': | |||
skel_files.append(bs) | |||
else: | |||
other_files.append(bs) | |||
return |