If more than one
version is available use the one appearing first in the search path
Plugin file names must be of the format:
lib<pluginname>.so
Internationalisation i18n
Uses QT-Translation mechanism.
translation files located at packagesearch/translations/
one file per plugin, one for main application, names: <pluginname>_<lang>.ts
To add a new language
add reference to "ts"-file to each .pro file (i.e. each plugin and packagesearch.pro)
run lupdate packagesearch.pro and lupdate plugins/plugins.pro
To compile the translations:
run make debug or make release within packagesearch/
Naming Conventions
Typenames/Const
typenames start with a capital letter - each word in it again
constants are written in capital letters, different words are
seperated by an underscorde _
Variables
varibles start with a lower case letter
member variables start with a underscore _
pointers start with a p
Filenames
filenames and directories are written lowercase without
underscores
Source files .cpp, Headerfiles .h
Functions
if the functions argument list goes over more then two lines,
the closing braclet will appear on a separate line and the line with
the function name will not contain a parameter e.g.
// this is OK func(aVeryLongVariableName1, aMuchMoreLongerVariableNameWhichFillsAllTheLine2, aVeryLongVariableNameWhichIsReallyLong3, aVeryLongVariableNameWhichIsReallyLong4); // if more than this: func ( aVeryLongVariableNameWhichIsReallyLong1, aMuchMuchLongerVariableName2 aVeryLongVariableNameWhichIsReallyLong3, aMuchMuchLongerVariableName4 aVeryLongVariableNameWhichIsReallyLong5, aMuchMuchLongerVariableName5 );
Documentation
tool tips and status tips start with a capital letter, all
following words are capitalized normally e.g. "Choose a package"
What's this consist of normal text (i.e. sentences)
User Interface
options listed are to be formated as tool tips i.e. with a
leading
capital character an the rest capitalized normally
Doxygen
Doxygen comments look like this:
/** @brief This holds the package collection ready to be used. * * Use the output function for your consumers */
If they need only one line the closing */ must be
on the same line:
/** This manages the include widgets (but not the labels belonging to them. */
Includes
#include <...> proceeds
#include "..."
include order:
- stl includes
- opengl includes
- qt includes
- other global includes (those with <>)
- the corresponding header for the cpp file
("xmldata.h" for xmldata.cpp)
- other local includes
Grouping:
- local includes from the same namespace are
grouped together (followed by an
empty line
- includes from the same external library or
directory are grouped together
Saving
Saving happens in XML
Error handling:
- if something wasn't loaded
properly we will try to set a reasonable default value
- We will not go to the next
entry if loading of an element failed, so if there is a
broken tag (e.g. wrong
spelling) this will break all following parts. This is done
because if we added a new
item in the DTD and we have an incorrect XML file where
this entry is missing, it
will use a default value and the next tag will read the
correct entry.
Saving in packagesearch:
- comments in the configuration
file are not allowed
packagesearch-2.7.4/doc/COPYING.txt 0000644 0000000 0000000 00000035433 10042747470 013626 0 ustar GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, 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
packagesearch-2.7.4/doc/index.html 0000644 0000000 0000000 00000013270 10103753162 013736 0 ustar
Help - Debian Package Search
Debian Package Search Help Page
This tool is aimed to help you searching the packages you need. It should make the task of searching
a pleasant experience. Originally I designed it for the purpose of finding a single package where
you have a clear imagination of what you want. But you can also use it to simply browse your packages
to explore. Perhaps there is something in the database that you simply must have :-).
The program is not meant to be a package managment tool like synaptic. This is far beyond
its purpose. It is not able to install a single package, but if you have found the one you
where searching for, you can simply type "apt-get install packagename" and install it.
The program consists of the main dialog only. The main window is split into two parts:
The upper part where you can enter the search you want to perform.
The lower part which shows the results of your current search.
A More Detailed View on the Search
In the upper pane you can enter the search criterias you want to perform.
There are three main criterias you can use for searching:
Search by Categories (Debtags Search)
The debtags search is based on the debtags system developed by Enrico Zini. The main idea
behind it is, that every package is characterized by a number of categories called tags.
Each package is given a number of such tags. E.g. the image editor gimp is tagged by
junior, media, media::rasterimage, suite, uitoolkit, uitoolkit::gtk.
You can select the tags you want to search for on the right side under the page
Debtags. If you want to exclude some tags, check the Exclude Tags box,
and a second list will appear. Here you can select the tags you do not want to
have on the package.
The tags are organized in a hierarchy, where each tag is inside a so
called "facet". As tagging is still under development, not all tags are inside
facets yet, but this will change in time.
The tags you selected will be showen on the left side were you can easily remove
them again.
Search Related Packages (Related Search)
You can search for packages related to another package using the related search.
You can select this on the right side under the page Related.
Here you can enter a package name. The search will
find all packages which have similar tags as the given one.
The packages may only differ in the number of "Maximum Distance" tags from the one you entered.
Or more formal:
|(A union B) difference (A intersect B)| <= MaxDistance
Search by Pattern (Apt Search)
You can enter a pattern to search the package names and descriptions for
on the left side below the Search pattern text. The names of all
packages available will be searched for the
expression you enter there. If the "Search Descriptions" box is checked,
the descriptions will be included in the full text search. Note: Currently the use of regular expressions is not supported.
Additionally you can select to search the installed or not installed packages only.
The Result View
The bottom pane shows the results of your current serach. The result contains all packages
matching all the searches you have specified, i.e. debtags search as well as related search
as well as apt search. It shows the results in realtime, i.e. every change you
perform in the search will be evaluated immidiately (except if you type a text, where it
delays the evaluation a little to see if you will type another character).
The packages are shown with a short description in the list on the
left. If you click an item a full description will be shown in right pane. There you can also choose
to see some details like: dependencies, author,...
You can right-click on a package (request a context menu) in a result and choose to generate a
apt-get line for it. This creates a line apt-get install packagename and copies the
content to your clipboard. Note that this is not the clipboard available via the middle mouse
button but the other clipboard often accesable via "Ctrl+C".
In the details view can browse the dependencies by clicking the underlined packages.
Additional Features
You can perform a debtags update via the GUI. This updates your tag database. This is where the
information about the tags that are assigned to each package is stored. For accessing this functionality
choose System->Debtags Update from the menu.
If you have further questions please contact me at bensmail@gmx.net
This tool is aimed to help you find the packages you need. It should make the task of searching
a pleasant experience. Originally I designed it for the purpose of finding a single package where
you have a clear imagination of what you want. But you can also use it to simply browse and explore
your packages. Perhaps there is something in the database that you simply must have :-).
The program is not meant to be a package managment tool like synaptic, though it is capable of installing individual packages.
The User Interface
The main window is split into two parts:
The upper part where you can enter the search you want to perform.
The lower part which shows the results of your current search on the left, and
information about the selected package on the right
The different types of search and informations available are offered by plugins.
Every plugin offers a number of different search and information types.
In the following we will take a closer look on the search types offerd by the plugins
distributed with the application.
A More Detailed View on the Search
In the upper pane you can enter the search criterias you want to search for. The
result consists of the packages which match all your active searches.
All the active searches are shown in the top left pane, so you always have an overview
over the active search.
By default there are five main criterias you can use for searching:
Search by Categories (Debtags Search)
The main idea here is, that every package is characterised by a
number of categories called tags. The tags are organised in
a hierarchy, where each tag is inside a so called facet
(group of categories).
Each package is given a number of such tags. E.g. the image editor
gimp has among others the tags: interface::x11, works-with-format::jpg, uitoolkit::gtk,
use::editing.
As tagging is still under development not all packages might be tagged
completely, and some may not be tagged as you would expect them to be.
You can select the tags you want to search for on the right side under the page
Debtags.
To select a tag simply double-click it.
The currently selected tags will be shown on the left side.
They can be removed by double-clicking them or by using the context menu.
In the list on the right side only the tags that will not produce an
empty search result will be shown (this calculation does not take other
types of search into account yet). So if you select a tag, the list of
tags on the right will be significantly reduced.
Search Similar Packages (Similar Search)
You can search for packages similar to another package using this search.
To do this select the tab Similar in the top-right pane.
The search will find packages similar to the one you select.
Similarity is calculated based on how similar the descriptions and other aspects are.
This plugin calculates scores for the result packages, based on the degree of similarity.
Search by Pattern (Apt Search)
On the left side below the Search for pattern
text you can enter on or more patterns seperated by a spaces. If the
"Search Descriptions" option is not checked, only the package names
will be searched for the patterns, otherwise the descriptions will be
searched too. All the patterns you have entered must be found. You can
search for exact phrases enclosing them with double quotes and you can
exclude patterns or phrases by preceding them with a minus ('-'). The
use of wildcards or regular expressions is not supported. Note:
The search uses an index of the packages as backend. This database
should get updated on a weekly bases (see apt-xapian-index for more
details). So the search results might not contain the latest changes to
the archive.
This search calculates scores based on how well the search patterns where matched.
Exact matches and a high number of matches results in higher scores.
Search by Filename (Filename Search)
With
this search you can search for patterns in filenames contained in the
packages. You can enter the pattern on the right side under the page Filenames.
You can check the search installed packages only option if you
want to search only in the packages locally installed. This is
generally faster than searching all packages. Additional information: Searching installed packages only
uses dpkg -S as backend, while searching all packages
uses apt-file search.
Search Orphans (Orphan Search)
This search allows to search for orphaned packages. Orphaned packages are
packages, were no other package depends on. Additional information: The orphan search uses deborphan
as backend so make sure it is installed on your system.
Additionally you can select to search the installed, upgradable or not installed packages only.
The Result View
The bottom left pane shows the results of your current search. The result contains the packages
matching all the searches you have specified. The packages are shown with some short
information in the list on the left.
If you select a package you can view its details in the bottom right pane. You can either select
a package from the result list, or choose it from the dropdown list above the package
information.
The result list contains a special column named Scores.
This column shows a value, indicating how likely it is, that you where
searching for this package. To sort by scores, simply click on the head
of the column (like you can do it with all the other columns). The
scores are calculated based on criterias offered by the plugins. This
can be based on the degree of a match between an active search and the
packages found, or data independend of the search (like popcon data).
You can right-click on a package (request a context menu) in the result
and choose an action to perform on it (like installing and removing).
Configuring Debian Package Search
Different settings can be customized for packagesearch.
The main settings dialog can be reached through the Packagesearch -> Preferences menu.
The columns displayed in the list on the bottom left can be modified by selecting
Customise Columns from the context menu of the list. The order can be changed through
drag-and-drop.
All settings made within packagesearch are be saved in the file $HOME/.packagesearch.
The Plugin System
Plugins can be controlled through the plugin menu. They can be enabled/disabled
through Plugins -> Control Plugins.
The following table shows the plugins distibuted with the application.
For information about external plugins consult the documentation distributed together with those.
The table lists the search and information types offered by the plugins.
Apt Plugin
search by pattern
calculate scores based on how well the packages match the search patter
show package description
show information like author, installed version, available version etc
in the detailed section
search by installed status
show installed status in the package list (i inidicates installed, and u upgradable)
allows to install and remove packages
Debtags Plugin
search by tags
search packages similar to an other
calculate scores based on how similar the packages are to the selected one
show the tags for packages in the detailed section
Filename Plugin
search by filenames
show filenames for packages
The filenames for the packages are displayed in the bottom
right under the Files tab.
It is possible to view the files by double clicking on their
entry or by choosing View file from the
context menu. Viewing files depends on the settings in your
mailcap file ($HOME/.mailcap and /etc/mailcap).
Orphan Plugin
search for orphaned packages
Screenshot Plugin
displays screenshot for the selected package
Screenshots are loaded from http://screenshots.debian.net
Other Plugin Specific Notes
Debtags Plugin
To reduce the complexity of the list of tags, you can hide facets (groups of categories) you are not interested in.
Go to Packagesearch -> Preferences and select the
Debtags tab there.
Apt-File Plugin
From time to time you should update the file database which is used to perform
searches for files. It can be updated either via the command line
(apt-file update) or using the GUI choosing
System->Update File Database.
If you have further questions please contact me at bensmail@gmx.net.
Date: 2012-05-12
packagesearch-2.7.4/src/ 0000755 0000000 0000000 00000000000 12233542400 011755 5 ustar packagesearch-2.7.4/src/.ui/ 0000755 0000000 0000000 00000000000 12233542121 012450 5 ustar packagesearch-2.7.4/src/.moc/ 0000755 0000000 0000000 00000000000 12233542121 012611 5 ustar packagesearch-2.7.4/src/.obj/ 0000755 0000000 0000000 00000000000 12233542121 012605 5 ustar packagesearch-2.7.4/src/runcommandwidget.ui 0000644 0000000 0000000 00000005047 10310100212 015652 0 ustar RunCommandWidget00600526RunCommandWidget106Courier1250falsefalsefalsefalseQt::PlainTextQ3TextEdit::NoWraptrue06AbortQt::HorizontalQSizePolicy::Expanding33020falseCloseqPixmapFromMimeSourceQ3TextEditq3textedit.h0
packagesearch-2.7.4/src/replace_in_files.pl 0000755 0000000 0000000 00000001071 10157636230 015607 0 ustar #!/usr/bin/perl -w
# this script replaces a regexp by a string
sub replaceFunc;
replaceFunc();
exit 0;
sub replaceFunc
{
foreach $filename (@ARGV)
{
print "Processing file $filename\n";
open( FILE, $filename);
@lines = ;
close( FILE );
`cp $filename $filename.0~`;
open(FILE, ">$filename"); # overwrite the exiting file
foreach $line (@lines)
{
$line =~ s/Tagcoll::Tagcoll::/Tagcoll::/g;
# $line =~ s/InputMerger/Tagcoll::InputMerger/g;
print FILE $line;
# print $line;
}
print "\n--------------\n\n";
}
}
packagesearch-2.7.4/src/runcommandinxterm.h 0000644 0000000 0000000 00000003366 11355454614 015725 0 ustar //
// C++ Interface: runcommandinxterm
//
// Description:
//
//
// Author: Benjamin Mesing , (C) 2004
//
// Copyright: See COPYING file that comes with this distribution
//
//
#ifndef __RUNCOMMANDINXTERM_H_2004_05_12
#define __RUNCOMMANDINXTERM_H_2004_05_12
#include
#include
#include "extalgorithm.h"
#include "runcommand.h"
using namespace std;
class QProcess;
namespace NApplication
{
/** This class runs a command in an XTerm. The XTerm is closes as soon as the started program is active.
* @author Benjamin Mesing
*/
class RunCommandInXterm : public RunCommand
{
Q_OBJECT
QStringList _arguments;
/** @brief The process currently executed. 0 if no process is currently executed. */
QProcess* _pProcess;
/** @brief The title of the window where the output is shown. */
QString _title;
private slots:
void onProcessExited();
protected:
/** @brief This is a helper function implementing start() and startAsRoot()
*
* It does what is described in either start() or startAsRoot().
* @param root if true, the command will be started as root
* @see start(), startAsRoot()
*/
bool start(bool root);
public:
RunCommandInXterm();
~RunCommandInXterm();
virtual void addArgument(const QString& arg);
virtual bool start();
virtual bool startAsRoot();
/** @brief This returns always true as I do not see a way to get hold of the exit status using an xterm. */
virtual bool processExitedSuccessful() const { return true; };
virtual void setTitle(const QString& title);
/** @see RunCommand::waitForFinished()
* @pre a process must be started
*/
virtual bool waitForFinished(int msecs = 30000 );
virtual bool finished();
};
}; // namespace NApplication
#endif // __RUNCOMMANDINXTERM_H_2004_05_12
packagesearch-2.7.4/src/columncontroldlg.ui 0000644 0000000 0000000 00000014745 10735532621 015725 0 ustar ColumnControlDlg00476356Control Columns610101010600006000000Shown6000000>><<6000000Hidden60000Qt::HorizontalQSizePolicy::Expanding14120&OKAlt+O&CancelAlt+CqPixmapFromMimeSource_pHideButton_pShowButton_pOkButton_pCancelButton_pOkButtonclicked()ColumnControlDlgaccept()322327267350_pCancelButtonclicked()ColumnControlDlgreject()437322474334
packagesearch-2.7.4/src/iprovider.h 0000644 0000000 0000000 00000007040 11427072364 014145 0 ustar #ifndef __PLUGINMANAGER_H_2004_06_21
#define __PLUGINMANAGER_H_2004_06_21
#include
#include
#include
#include
#include
class QNetworkAccessManager;
class QPushButton;
class QStatusBar;
class QWidget;
namespace Xapian {
class Database;
}
namespace ept
{
namespace apt {
class Apt;
}
namespace debtags {
class Vocabulary;
}
}
namespace Xapian
{
class Database;
}
using namespace std;
namespace NUtil
{
class IProgressObserver;
}
namespace NPlugin
{
class IPluginUser;
class PluginContainer;
class Plugin;
/** @brief This is the interface which provides informations for the plugins.
*
*
*/
class IProvider
{
public:
virtual ~IProvider() {}
/** @brief Returns the path were the icons are located. */
virtual QString iconDir() const = 0;
/**
* @brief Disables the whole search window.
*
* This might be used if all updating should be locked.
* @param enabled
*/
virtual void setEnabled (bool enabled) = 0;
/** Returns the currently active package. */
virtual QString currentPackage() const = 0;
/** @brief Creates a button which can be used as to clear the input of a line.
*
* The button will only have an icon which looks like this:
*
+------
| \
| \/ \
| /\ /
| /
+------
*/
virtual QPushButton* createClearButton(QWidget* pParent = 0, const char* name = 0) const = 0;
/**
* @brief Reports an error to the user.
* @param title a title for the error
* @param message a description of what went wrong
*/
virtual void reportError (const QString& title, const QString& message) = 0;
/**
* @brief Reports a warning to the user.
* @param title a title for the warning
* @param message a description of what happened
*/
virtual void reportWarning(const QString& title, const QString& message) = 0;
/** @brief This can be used by the plugins to report that they are currently busy.
*
* It must be followed by a report ready.
* @param pPlugin the plugin which report busy
* @param message a short description of the activity (it can be used to display
* whats currently going on, e.g. using the status bar).
*/
virtual void reportBusy(Plugin* pPlugin, const QString& message) = 0;
/** This can be used by a busy plugins to report that it is ready.
* It must be procceeded by a report ready. */
virtual void reportReady(Plugin* pPlugin) = 0;
/** @brief Returns a list of all packages available.
*
* Only real packages will be listed here i.e. no virtuals, or missing dependencies.
*/
virtual const set& packages() const = 0;
/** Returns a pointer to the main window for the plugins. */
virtual QMainWindow* mainWindow() = 0;
/** Returns a pointer to the status bar. */
virtual QStatusBar* statusBar() = 0;
/** Allows access to the loader interface to report back loading progress. */
virtual NUtil::IProgressObserver* progressObserver() const = 0;
/** Returns a reference to the apt object. */
virtual const ept::apt::Apt& apt() const = 0;
/** Returns a reference to the debtags vocabulary object. */
virtual const ept::debtags::Vocabulary& vocabulary() const = 0;
/** Returns a reference to the apt-xapian database. */
virtual const Xapian::Database& xapian() const = 0;
/** @brief Returns the central network manager which can be used to access the network. */
virtual QNetworkAccessManager* network() = 0;
/** @brief Reloads the package database. */
virtual void reloadAptFrontCache() = 0;
};
} // namespace NPlugin
#endif // __PLUGINMANAGER_H_2004_06_21
packagesearch-2.7.4/src/packagesearchaboutdlg.h 0000644 0000000 0000000 00000001246 10317251651 016442 0 ustar //
// C++ Interface: packagesearchaboutdlg
//
// Description:
//
//
// Author: Benjamin Mesing , (C) 2005
//
// Copyright: See COPYING file that comes with this distribution
//
//
#ifndef __NPACKAGESEARCH_PACKAGESEARCHABOUTDLG_H_2005_09_30
#define __NPACKAGESEARCH_PACKAGESEARCHABOUTDLG_H_2005_09_30
#include
#include
namespace NPackageSearch
{
/**
@author Benjamin Mesing
*/
class PackageSearchAboutDlg : public QDialog, public Ui::PackageSearchAboutDlg
{
public:
PackageSearchAboutDlg();
~PackageSearchAboutDlg();
};
} // namespace NPackageSearch
#endif // __NPACKAGESEARCH_PACKAGESEARCHABOUTDLG_H_2005_09_30
packagesearch-2.7.4/src/runcommandwidget.cpp 0000644 0000000 0000000 00000001763 10735744544 016061 0 ustar //
// C++ Implementation: runcommandwidget
//
// Description:
//
//
// Author: Benjamin Mesing , (C) 2005
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include "runcommandwidget.h"
RunCommandWidget::RunCommandWidget(QWidget *parent, const char *name)
: QDialog(parent)
{
if (name)
setObjectName(name);
setupUi(this);
}
RunCommandWidget::~RunCommandWidget()
{
}
void RunCommandWidget::onClose()
{
close();
emit quit();
}
void RunCommandWidget::replaceLastLine( const QString line )
{
// change the last line
QString text = _pConsoleOutput->text();
int lastLine = text.lastIndexOf("\n");
if (lastLine != -1)
{
text.truncate(lastLine+1);
text.append(line);
}
else
text = line;
_pConsoleOutput->setText(text);
/* _pOutput->_pConsoleOutput->removeParagraph(_pOutput->_pConsoleOutput->paragraphs()-1);
_pOutput->_pConsoleOutput->append(line);*/
}
void RunCommandWidget::append( const QString line )
{
_pConsoleOutput->append(line);
}
packagesearch-2.7.4/src/packagedisplaywidget.cpp 0000644 0000000 0000000 00000035242 11711275554 016671 0 ustar //
// C++ Implementation: packagedisplaywidget
//
// Description:
//
//
// Author: Benjamin Mesing , (C) 2007
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include "packagedisplaywidget.h"
#include
#include
#include
#include
#include
#include
#include
// NXml
#include
// NPlugin
#include "shortinformationplugin.h"
#include "actionplugin.h"
#include "packagenotfoundexception.h"
#include "columncontroldlg.h"
#include
namespace NPackageSearch {
const int PackageDisplayWidget::CHAR_WIDTH = 7;
const int PackageDisplayWidget::MARGIN = 10;
PackageDisplayWidget::PackageDisplayWidget(QWidget * pParent)
: QTableWidget(pParent)
{
verticalHeader()->hide();
QFontMetrics font = fontMetrics();
verticalHeader()->setDefaultSectionSize(1.07*font.height());
horizontalHeader()->setClickable(true);
horizontalHeader()->setSortIndicatorShown(true);
horizontalHeader()->setMovable(true);
connect(this, SIGNAL(itemSelectionChanged()), SLOT(onItemSelectionChanged()));
setSelectionMode(SingleSelection);
setSelectionBehavior(SelectRows);
horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
horizontalHeader()->setContextMenuPolicy(Qt::CustomContextMenu);
connect(horizontalHeader(), SIGNAL(customContextMenuRequested(const QPoint&)), SLOT(onHeaderContextMenuRequested(const QPoint&)));
_pCustomizeColumnsAction = new QAction(tr("Customize Columns"), this);
connect(_pCustomizeColumnsAction, SIGNAL(triggered()), SLOT(showColumnControlDialog()));
setShowGrid(false);
}
PackageDisplayWidget::~PackageDisplayWidget()
{
}
void PackageDisplayWidget::setPackages(const set& packages)
{
using namespace NPlugin;
// TODO: reimplement selecting the package which was selectd before
clearContents();
// temporary deactivate sorting because of 1. performance reasons and 2. a stable item order
setSortingEnabled(false);
setRowCount(packages.size());
int row = 0;
for (set::const_iterator it = packages.begin(); it != packages.end(); ++it)
{
const string& package = *it;
// add the item with its name
int column = 0;
const vector& plugins = _siPlugins;
for (vector::const_iterator jt = plugins.begin();
jt != plugins.end(); ++jt)
{
try
{
// TODO: do not set the text for columns which are hidden
QString text = (*jt)->shortInformationText(package);
setItem(row, column, new QTableWidgetItem(text));
}
// simply ignore it if the package was not available for this plugin
catch (NPlugin::PackageNotFoundException& e) {}
catch (std::exception& e) {
qWarning() << "Plugin " << (*jt)->name() << " failed provide short information\n"
<< "e.what(): " << e.what();
}
catch (...) {
qWarning() << "Plugin " << (*jt)->name() << " failed provide short information description (unknown exception thrown)";
}
++column;
}
++row;
}
/* if (pSelectItem)
{
_pPackageView->ensureItemVisible(pSelectItem);
_pPackageView->setSelected(pSelectItem, true);
}
// select the first item of the site to be shown
else if (_pPackageView->firstChild())
{
_pPackageView->setSelected(_pPackageView->firstChild(), true);
}*/
setSortingEnabled(true);
}
/////////////////////////////////////////////////////
// IPluginUser Interface
/////////////////////////////////////////////////////
void PackageDisplayWidget::addPlugin(NPlugin::Plugin* pPlugin)
{
qStrDebug("PackageDisplayWidget::addPlugin(" + pPlugin->name() + ")");
using namespace NPlugin;
if (dynamic_cast(pPlugin) != 0)
{
ShortInformationPlugin* pSIPlugin = dynamic_cast(pPlugin);
_siPlugins.push_back(pSIPlugin);
updateColumnDisplay();
int loadedColumnPosition = -1;
int columnIndex = columnForName(pSIPlugin->shortInformationCaption());
// if there are loaded settings for the column available
if (_loadedColumnSettings.find(pSIPlugin->shortInformationCaption()) != _loadedColumnSettings.end())
{
//qDebug("Applying settings for column " + pSIPlugin->shortInformationCaption() );
Column column = _loadedColumnSettings.find(pSIPlugin->shortInformationCaption())->second;
setColumnWidth(columnIndex, column._width);
loadedColumnPosition = column._position;
horizontalHeader()->setSectionHidden(columnIndex, column._hidden);
}
else
{
setColumnWidth(columnIndex, pSIPlugin->preferredColumnWidth() * CHAR_WIDTH + MARGIN);
}
//qDebug("Order before reordering");
//debugPrintOrder();
int visualIndex = columnPosition(loadedColumnPosition, columnIndex, pSIPlugin);
//qDebug("Target visual Index of " + pSIPlugin->shortInformationCaption() + " is %d", visualIndex);
if (visualIndex != -1)
{
horizontalHeader()->moveSection(horizontalHeader()->visualIndex(columnIndex), visualIndex);
//qDebug("Order after reordering");
//debugPrintOrder();
}
}
if (dynamic_cast(pPlugin))
{
_actionPlugins.push_back(dynamic_cast(pPlugin));
}
}
void PackageDisplayWidget::removePlugin(NPlugin::Plugin* pPlugin)
{
using namespace NPlugin;
ShortInformationPlugin* pSIPlugin = dynamic_cast(pPlugin);
if (pSIPlugin)
{
vector::iterator it = std::find(_siPlugins.begin(), _siPlugins.end(), pSIPlugin);
if (it != _siPlugins.end())
_siPlugins.erase(it);
updateColumnDisplay();
}
ActionPlugin* pAPlugin = dynamic_cast(pPlugin);
if (pAPlugin)
{
vector::iterator it = std::find(_actionPlugins.begin(), _actionPlugins.end(), pAPlugin);
if (it != _actionPlugins.end())
_actionPlugins.erase(it);
}
}
/////////////////////////////////////////////////////
// Other funtions
/////////////////////////////////////////////////////
void PackageDisplayWidget::initialize()
{
int scoreColumn = columnForName("Score");
// (Qt::SortOrder) sortOrder
if (scoreColumn != -1)
sortByColumn(scoreColumn, Qt::DescendingOrder);
else
sortByColumn(0, Qt::AscendingOrder);
setSortingEnabled(true);
}
void PackageDisplayWidget::onItemSelectionChanged()
{
emit(packageSelected(selectedPackage()));
}
void PackageDisplayWidget::onHeaderContextMenuRequested(const QPoint& pos)
{
QMenu menu;
QAction* pHideColumn = menu.addAction(tr("Hide Column"));
menu.insertAction(0, _pCustomizeColumnsAction);
QPoint globalPos = mapToGlobal(pos);
QAction* pAction = menu.exec(globalPos);
QHeaderView* pHeader = horizontalHeader();
if (pAction == pHideColumn)
{
int column = pHeader->logicalIndexAt(globalPos);
if (column == -1)
qWarning("Unexpected column selected");
else
pHeader->hideSection(column);
}
}
void PackageDisplayWidget::showColumnControlDialog()
{
QHeaderView* pHeader = horizontalHeader();
ColumnControlDlg dlg(this);
QStringList shownColumns;
QStringList hiddenColumns;
for (int i = 0; i < pHeader->count(); ++i)
{
int logicalIndex = pHeader->logicalIndex(i);
QString colCaption = horizontalHeaderItem(logicalIndex)->text();
if (pHeader->isSectionHidden(logicalIndex))
hiddenColumns.push_back(colCaption);
else
shownColumns.push_back(colCaption);
}
dlg.setContent(shownColumns, hiddenColumns);
dlg.exec();
shownColumns = dlg.shownColumns();
hiddenColumns = dlg.hiddenColumns();
for (QStringList::const_iterator it = shownColumns.begin();
it != shownColumns.end(); ++it)
{
int col = columnForName(*it);
if (pHeader->isSectionHidden(col))
{
pHeader->showSection(col);
if (pHeader->sectionSize(col)==0)
{
ShortInformationPlugin* pSIPlugin = _siPlugins[col];
int width = pSIPlugin->preferredColumnWidth() * CHAR_WIDTH + MARGIN;
setColumnWidth(col, width);
}
}
}
for (QStringList::const_iterator it = hiddenColumns.begin();
it != hiddenColumns.end(); ++it)
{
int col = columnForName(*it);
if (!pHeader->isSectionHidden(col))
pHeader->hideSection(col);
}
}
QString PackageDisplayWidget::selectedPackage() const
{
// TODO the const_casts here are neccessary because QT fails to declare selectedItems() as const
// currently this method assumes a maximum of one selected item
if (!const_cast(this)->selectedItems().isEmpty())
{
QTableWidgetItem* pSelectedItem = const_cast(this)->selectedItems().first();
return packageForRow(pSelectedItem->row());
}
else
{
return QString();
}
}
QString PackageDisplayWidget::packageForRow(int row) const
{
// TODO this relies on the package name column to be present and filled
// translation _must_ match the translation of the column title!
int nameColumn = columnForName(tr("Name"));
QString packageName = item(row, nameColumn)->text();
return packageName;
}
bool PackageDisplayWidget::scoreColumnVisible() const
{
// translation _must_ match the translation of the column title!
int scoreColumn = columnForName(tr("Score"));
if (scoreColumn == -1)
return false;
else
return !horizontalHeader()->isSectionHidden(scoreColumn);
}
void PackageDisplayWidget::contextMenuEvent(QContextMenuEvent * pEvent)
{
QList actions = packageActions();
actions.push_back(_pCustomizeColumnsAction);
QMenu::exec(actions, pEvent->globalPos());
}
void PackageDisplayWidget::updateColumnDisplay()
{
const vector& plugins = _siPlugins;
QStringList labels;
setColumnCount(_siPlugins.size());
for (vector::const_iterator it = plugins.begin();
it != plugins.end(); ++it)
{
labels.push_back((*it)->shortInformationCaption());
}
setHorizontalHeaderLabels(labels);
}
/////////////////////////////////////////////////////
// IXmlStorable Interface
/////////////////////////////////////////////////////
void PackageDisplayWidget::saveSettings(NXml::XmlData& outData, QDomElement parent) const
{
QDomElement listView = outData.addElement(parent, "customListView");
// in settings version 1, we had a shownColumns and and a hiddenColumns element
outData.addAttribute(listView, QString("2"), "settingsVersion");
QDomElement columns = outData.addElement(listView, "columns");
const vector& plugins = _siPlugins;
for (vector::const_iterator it = plugins.begin();
it != plugins.end(); ++it)
{
QDomElement column = outData.addElement(columns, "column");
int columnIndex = columnForName((*it)->shortInformationCaption());
outData.addAttribute(column, (*it)->shortInformationCaption(), "caption");
outData.addAttribute(column, columnWidth(columnIndex), "width");
outData.addAttribute(column, horizontalHeader()->visualIndex(columnIndex), "position");
outData.addAttribute(column, horizontalHeader()->isSectionHidden(columnIndex), "hidden");
}
}
QDomElement PackageDisplayWidget::loadSettings(const QDomElement source)
{
if (source.tagName() != "customListView")
return source;
QString settingsVersion;
NXml::getAttribute(source, settingsVersion, "settingsVersion", "0.1");
// dismiss old settings, we don't want to carry around backward compatibility for an eternity
if (settingsVersion >= QString("2"))
{
//qDebug("Loading column setup");
QDomElement element = NXml::getFirstElement(source.firstChild());
assert(element.tagName() == "columns");
// iterate over each element
QDomElement e = NXml::getFirstElement(element.firstChild());
while (!e.isNull())
{
Column column;
NXml::getAttribute(e, column._caption, "caption", "");
NXml::getAttribute(e, column._width, "width", 50);
NXml::getAttribute(e, column._position, "position", 0);
NXml::getAttribute(e, column._hidden, "hidden", false);
_loadedColumnSettings.insert(make_pair(column._caption, column));
e = NXml::getNextElement(e);
//qDebug("Settings for column " + column._caption + ": width %d, position %d", column._width, column._position);
}
// note that we set the sort column, _after_ adding all the columns.
// QString sortColumn;
// int sortOrder;
// NXml::getAttribute(element, sortColumn, "shortSortColumn", _sortColumn);
// NXml::getAttribute(element, sortOrder, "shortSortOrder", _sortOrder);
// if (!sortColumn.isEmpty())
// setSorting(sortColumn, (Qt::SortOrder) sortOrder);
}
return NXml::getNextElement(source);
}
/////////////////////////////////////////////////////
// Query functions
/////////////////////////////////////////////////////
int PackageDisplayWidget::columnPosition(int position, int logicalIndex, const NPlugin::ShortInformationPlugin* pPlugin) const
{
// iterate over all columns by visual index (i.e. starting with the one with visible index 0)
for (int visualColIndex = 0; visualColIndex < columnCount(); ++visualColIndex)
{
int logicalColIndex = horizontalHeader()->logicalIndex(visualColIndex);
// skip the column if it is the requested column
if (logicalColIndex == logicalIndex)
continue;
QString colCaption = horizontalHeaderItem(logicalColIndex)->text();
// if the requested column has no position information or the current column has no position information
if (position == -1 || _loadedColumnSettings.find(colCaption) == _loadedColumnSettings.end())
{
uint colPriority = pluginForCaption(colCaption)->shortInformationPriority();
if (colPriority > pPlugin->shortInformationPriority())
return visualColIndex;
}
else
{
int colPosition = _loadedColumnSettings.find(colCaption)->second._position;
// if the given position is before the current one, return the index of the current column
if (colPosition > position)
{
return visualColIndex;
}
}
}
return -1;
}
int PackageDisplayWidget::columnForName(const QString& name) const
{
for (int i=0; i < columnCount(); ++i)
{
if (horizontalHeaderItem(i)->text() == name)
return i;
}
return -1;
}
NPlugin::ShortInformationPlugin* PackageDisplayWidget::pluginForCaption(const QString& caption) const
{
for (vector::const_iterator it = _siPlugins.begin();
it != _siPlugins.end(); ++it)
{
if ((*it)->shortInformationCaption() == caption)
return *it;
}
return 0;
}
QList PackageDisplayWidget::packageActions() const
{
QList result;
for (vector::const_iterator it = _actionPlugins.begin();
it != _actionPlugins.end(); ++it)
{
vector actions = (*it)->actions();
for (vector::const_iterator jt = actions.begin(); jt != actions.end(); ++jt)
{
const NPlugin::Action* pAction = *jt;
if (pAction->packageAction())
result.push_back(pAction->action());
}
}
return result;
}
void PackageDisplayWidget::debugPrintOrder() const
{
QHeaderView& header = *horizontalHeader();
QString headerLabel;
for (int i=0; i < header.count(); ++i)
{
int index = header.logicalIndex(i);
headerLabel += horizontalHeaderItem(index)->text() + " | ";
}
qStrDebug(headerLabel);
}
}
packagesearch-2.7.4/src/packagenotfoundexception.h 0000644 0000000 0000000 00000002045 10316006675 017227 0 ustar //
// C++ Interface: %{MODULE}
//
// Description:
//
//
// Author: %{AUTHOR} <%{EMAIL}>, (C) %{YEAR}
//
// Copyright: See COPYING file that comes with this distribution
//
//
#ifndef __NPLUGIN_PACKAGENOTFOUNDEXCEPTION_H_2005_03_01
#define __NPLUGIN_PACKAGENOTFOUNDEXCEPTION_H_2005_03_01
#include
#include "exception.h"
using namespace std;
namespace NPlugin {
/** @brief This exception is thrown if information for the requested package was not
* found in a plugin.
*
* @author Benjamin Mesing
*/
class PackageNotFoundException : public NException::Exception
{
/** The name of the package not found. */
string _name;
public:
/** @param packageName the name of the package that was not found*/
PackageNotFoundException(const string& packageName) :
_name(packageName)
{}
virtual ~PackageNotFoundException();
virtual string description() const
{
return "Package " + _name + "not found\n";
}
/** Returns #_name. */
const string& name() { return _name; }
};
};
#endif // __NPLUGIN_PACKAGENOTFOUNDEXCEPTION_H_2005_03_01
packagesearch-2.7.4/src/scorecalculationstrategybase.cpp 0000644 0000000 0000000 00000002073 11631745160 020444 0 ustar //
// C++ Implementation: scorecalculationstrategybase
//
// Description:
//
//
// Author: Benjamin Mesing , (C) 2005
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include "scorecalculationstrategybase.h"
#include
namespace NPlugin {
ScoreCalculationStrategyBase::ScoreCalculationStrategyBase()
: NPlugin::IScoreCalculationStrategy()
{
}
ScoreCalculationStrategyBase::~ScoreCalculationStrategyBase()
{
}
/////////////////////////////////////////////////////
// IScoreCalculationStrategy Interface
/////////////////////////////////////////////////////
float ScoreCalculationStrategyBase::getScore(const string& package) const
{
map::const_iterator it = _packagesToScore.find(package);
if (it == _packagesToScore.end()) {
qWarning("No scores for package %s", package.c_str());
return 1;
}
return it->second;
}
const map& ScoreCalculationStrategyBase::getScore() const
{
return _packagesToScore;
}
void ScoreCalculationStrategyBase::clear()
{
_packagesToScore.clear();
};
}
packagesearch-2.7.4/src/packagenotfoundexception.cpp 0000644 0000000 0000000 00000000460 10211151102 017535 0 ustar //
// C++ Implementation: %{MODULE}
//
// Description:
//
//
// Author: %{AUTHOR} <%{EMAIL}>, (C) %{YEAR}
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include "packagenotfoundexception.h"
namespace NPlugin {
PackageNotFoundException::~PackageNotFoundException()
{
}
};
packagesearch-2.7.4/src/packagesearch-german.sh 0000755 0000000 0000000 00000000345 11165470575 016366 0 ustar #!/bin/bash
export LANG=de_DE.UTF-8
export LC_ALL=de_DE.UTF-8
export LC_MESSAGES=de_DE.UTF-8
export LC_CTYPE=de_DE.UTF-8
export LC_MONETARY=de_DE.UTF-8
export LC_TIME=de_DE.UTF-8
export LC_NUMERIC=de_DE.UTF-8
./packagesearch $@
packagesearch-2.7.4/src/xmldata.cpp 0000644 0000000 0000000 00000017545 10437522353 014140 0 ustar //
// C++ Implementation: xmldata
//
// Description:
//
//
// Author: Benjamin Mesing,,, , (C) 2004
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include
#include
#include
#include "xmldata.h"
#include "helpers.h"
using namespace std;
namespace NXml
{
QDomElement getFirstChild(QDomNode node)
{
while (!node.isNull())
{
if (!node.toElement().isNull()) // if the node is an element
return node.toElement();
node = node.nextSibling();
}
return node.toElement(); // returns the null element
}
QDomElement getFirstElement(QDomNode node)
{
while (!node.isNull())
{
if (node.isElement()) // if the node is an element
return node.toElement();
node = node.nextSibling();
}
return node.toElement(); // returns the null element
}
QDomElement getNextElement(QDomNode node)
{
return getFirstElement(node.nextSibling());
}
XmlData::XmlData()
{
}
XmlData::XmlData(const QString& name)
{
_domDocument = QDomDocument(name);
_domDocument.appendChild(_domDocument.createElement(name));
}
XmlData::XmlData(QDomDocument document)
{
_domDocument = document;
}
XmlData::~XmlData()
{
}
bool XmlData::loadFile(const QString& filename)
{
QFile file(filename);
_domDocument = QDomDocument();
if (!_domDocument.setContent(&file, false)) // parse das XML Document
{
return false;
}
return true;
}
QDomElement XmlData::startDocument(const QString& name)
{
_domDocument = QDomDocument(name);
QDomElement root = _domDocument.createElement(name);
_domDocument.appendChild(root);
return root;
}
void XmlData::xmlifyString(QString& string)
{
string.replace('&', "&");
string.replace('<', "<");
string.replace('>', ">");
string.replace('\'', "&apos");
string.replace('\"', """);
}
void XmlData::xmlifyStringList(QStringList& stringList)
{
QStringList::iterator end=stringList.end();
for (QStringList::iterator i=stringList.begin(); i!=end; ++i)
xmlifyString( *i );
}
QDomElement XmlData::addElement(QDomElement parent, const QString& tagName)
{
QDomElement element = _domDocument.createElement(tagName);
parent.appendChild(element);
return element;
}
QDomText XmlData::addText(QDomElement element, QString text)
{
xmlifyString(text);
QDomText textNode = _domDocument.createTextNode(text);
element.appendChild(textNode);
return textNode;
}
QDomText XmlData::addText(QDomElement element, const string& text)
{
QString newText = toQString(text);
xmlifyString(newText);
QDomText textNode = _domDocument.createTextNode(newText);
element.appendChild(textNode);
return textNode;
}
void XmlData::addText(QDomElement element, QString tagName, QStringList text)
{
for (QStringList::iterator it = text.begin(); it != text.end(); ++it)
{
QDomElement subElement = addElement(element, tagName);
addText(subElement, *it);
}
}
QDomAttr XmlData::addAttribute(QDomElement node, const QString& value, const QString& name )
{
QDomAttr attribute = _domDocument.createAttribute(name);
QString copyValue(value);
xmlifyString(copyValue);
attribute.setValue(copyValue);
node.setAttributeNode(attribute);
return attribute;
}
QDomAttr XmlData::addAttribute(QDomElement node, const string& value, const QString& name)
{
return addAttribute(node, toQString(value), name);
}
QDomAttr XmlData::addAttribute(QDomElement node, uint value, const QString& name)
{
QString tmp;
tmp.setNum(value);
return addAttribute(node, tmp, name);
}
QDomAttr XmlData::addAttribute(QDomElement node, int value, const QString& name)
{
QString tmp;
tmp.setNum(value);
return addAttribute(node, tmp, name);
}
QDomAttr XmlData::addAttribute(QDomElement node, double value, const QString& name)
{
QString tmp;
tmp.setNum(value);
return addAttribute(node, tmp, name);
}
QDomAttr XmlData::addAttribute(QDomElement node, bool value, const QString& name)
{
return addAttribute(node, (value==false)? 0 : 1, name);
}
QDomElement XmlData::importNode(QDomElement src, QDomElement dst, bool deep)
{
QDomElement imported = _domDocument.importNode(src, deep).toElement();
dst.appendChild(imported);
return imported;
}
bool XmlData::skipComments(QDomNode& node)
{
if (node.nodeType() != QDomNode::CommentNode ) return false;
node = node.nextSibling();
while (node.nodeType() == QDomNode::CommentNode) // skip the comments
node = node.nextSibling();
return true;
}
bool XmlData::writeFile(const QString& filename) const
{
ofstream out(filename.toAscii(), ios::out);
if (!out.good()) out.close();
if (!out.is_open())
{
QString errorMsg(filename);
errorMsg="Couldn't open file "+errorMsg;
return false;
}
out << toString(_domDocument.toString());
out.close();
return true;
}
/////////////////////////////////////////////////////
// getAttribute functions
/////////////////////////////////////////////////////
bool getAttribute(QDomElement element, QString& loadInto, const QString& name, QString def)
{
const QDomAttr attribute = element.attributeNode(name);
if (attribute.isNull())
{
loadInto=def;
#ifdef DEBUG
cout << "Attribute "< 255)
success = false;
loadInto = uchar(tmp); // 0 becomes false everything else true
if (!success)
loadInto = def;
return success;
}
QStringList getTextList(QDomElement element)
{
QStringList result;
QDomElement child = getFirstElement(element.firstChild());
while (!child.isNull())
{
QDomText text = child.firstChild().toText();
// if the first child was a text node
if (!text.isNull())
{
result.push_back(text.nodeValue());
}
child = getNextElement(child);
}
return result;
}
} // NXml
packagesearch-2.7.4/src/packagenameplugin.cpp 0000644 0000000 0000000 00000001514 10316006675 016146 0 ustar //
// C++ Implementation: %{MODULE}
//
// Description:
//
//
// Author: %{AUTHOR} <%{EMAIL}>, (C) %{YEAR}
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include "packagenameplugin.h"
#include "helpers.h"
namespace NPlugin
{
const QString PackageNamePlugin::PLUGIN_NAME = "PackageNamePlugin";
PackageNamePlugin::PackageNamePlugin()
: ShortInformationPlugin(),
_title(tr("Package Name Plugin")),
_briefDescription(tr("Displays the package names")),
_description(tr("Displays the package names"))
{
}
PackageNamePlugin::~PackageNamePlugin()
{
}
/////////////////////////////////////////////////////
// Short Information Plugin Interface
/////////////////////////////////////////////////////
const QString PackageNamePlugin::shortInformationText(const string& package)
{
return toQString(package);
}
};
packagesearch-2.7.4/src/plugininformer.cpp 0000644 0000000 0000000 00000001446 10270253342 015531 0 ustar //
// C++ Implementation: plugininformer
//
// Description:
//
//
// Author: Benjamin Mesing , (C) 2004
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include
#include
#include "plugininformer.h"
#include "ipluginuser.h"
namespace NPlugin
{
PluginInformer::PluginInformer()
{
}
PluginInformer::~PluginInformer()
{
}
void PluginInformer::removePluginUser(IPluginUser* pUser)
{
_users.erase(pUser);
}
void PluginInformer::informAddPlugin(Plugin* pPlugin)
{
for_each(_users.begin(), _users.end(),
bind2nd(mem_fun(&IPluginUser::addPlugin), pPlugin) );
}
void PluginInformer::informRemovePlugin(Plugin* pPlugin)
{
for_each(_users.begin(), _users.end(),
bind2nd(mem_fun(&IPluginUser::removePlugin), pPlugin) );
}
};
packagesearch-2.7.4/src/.kdev_include_paths 0000644 0000000 0000000 00000000165 11705630175 015625 0 ustar /usr/include/qt4/Qt
/usr/include/qt4/QtCore
/usr/include/qt4/QtXml
/usr/include/qt4/QtGui
/usr/include/qt4/QtNetwork
packagesearch-2.7.4/src/plugininformer.h 0000644 0000000 0000000 00000002056 10270253342 015174 0 ustar //
// C++ Interface: plugininformer
//
// Description:
//
//
// Author: Benjamin Mesing , (C) 2004
//
// Copyright: See COPYING file that comes with this distribution
//
//
#ifndef __PLUGININFORMER_H_2004_09_08
#define __PLUGININFORMER_H_2004_09_08
#include
#include "iplugininformer.h"
using namespace std;
namespace NPlugin
{
class IPluginUser;
class Plugin;
/** @brief Used to manage and inform plugin users.
*
* Do not have too many observers as it has linear complexity in
* the operation.
* @author Benjamin Mesing
*/
class PluginInformer : public IPluginInformer
{
typedef set PluginUserContainer;
PluginUserContainer _users;
public:
PluginInformer();
~PluginInformer();
// documented in base class
virtual void addPluginUser(IPluginUser* pUser) { _users.insert(pUser); };
// documented in base class
virtual void removePluginUser(IPluginUser* pUser);
virtual void informAddPlugin(Plugin* pPlugin);
virtual void informRemovePlugin(Plugin* pPlugin);
};
};
#endif // __PLUGININFORMER_H_2004_09_08
packagesearch-2.7.4/src/settingsdlg.h 0000644 0000000 0000000 00000002501 11732444264 014467 0 ustar //
// C++ Interface: pluginsettingsdlg
//
// Description:
//
//
// Author: Benjamin Mesing , (C) 2004
//
// Copyright: See COPYING file that comes with this distribution
//
//
#ifndef __PLUGINSETTINGSDLG_H_2004_08_31
#define __PLUGINSETTINGSDLG_H_2004_08_31
#include
#include
#include
#include "ui_settingsdlg.h"
class QTabWidget;
namespace NPlugin {
class PluginContainer;
}
namespace NPackageSearch
{
/** @brief Class which controls different plugin containers.
*
* @todo Rename to "SettingsDlg"
* @author Benjamin Mesing
*/
class SettingsDlg : public QDialog, public Ui::SettingsDlg
{
Q_OBJECT
public:
/** Initialises the dialog.
*
* Initially the settings from the proxy are applied.
*/
SettingsDlg(const NUtil::NetworkSettings& network, QWidget *parent = 0, const char *name = 0);
~SettingsDlg();
/** @brief Adds a plugin to show settings for. */
void addPlugin(NPlugin::PluginContainer* pPluginContainer);
/** @brief Applies the proxy settings configured within this GUI to the QNetworkProxy configuration.
*
* Returns the proxy configured through this dialog.
*/
NUtil::NetworkSettings networkSettings();
public Q_SLOTS:
void on__pProxyServerEnabledCheck_stateChanged(int state);
};
};
#endif // __PLUGINSETTINGSDLG_H_2004_08_31
packagesearch-2.7.4/src/pluginmanager.cpp 0000644 0000000 0000000 00000030221 11166203142 015311 0 ustar //
// C++ Implementation: pluginmanager
//
// Description:
//
//
// Author: Benjamin Mesing , (C) 2004
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include // for dl*()
#include "extalgorithm.h"
// NPlugin
#include "pluginmanager.h"
#include "plugincontainer.h"
#include "ipluginuser.h"
#include "iprovider.h"
#include "plugincontroldlgmeditator.h"
// NXml
#include "xmldata.h"
// NUtil
#include "progressdisplaydlg.h"
#include "helpers.h"
namespace NPlugin
{
PluginManager::PluginManager(vector directories, IProvider* pProvider)
: _settingsVersion("0.2")
{
_pProvider = pProvider;
_pProgressDlg = 0;
_directories = directories;
_pControlDialog = 0;
}
PluginManager::~PluginManager()
{
}
/////////////////////////////////////////////////////
// IPluginUser Interface
/////////////////////////////////////////////////////
void PluginManager::addPlugin(Plugin* pPlugin)
{
informAddPlugin(pPlugin);
}
void PluginManager::removePlugin(Plugin* pPlugin)
{
informRemovePlugin(pPlugin);
}
/////////////////////////////////////////////////////
// Other functions
/////////////////////////////////////////////////////
void PluginManager::loadPlugins()
{
NUtil::ProgressDisplayDlg dlg(_pProvider->mainWindow(), "PluginProgressDlg", true);
_pProgressDlg = &dlg;
dlg.show();
vector plugins = getAvailablePlugins();
for (vector::const_iterator it = plugins.begin(); it != plugins.end(); ++it)
{
// if the plugin is not disabled and no such plugin is already loaded
if (_disabledPlugins.find(it->name())==_disabledPlugins.end() && it->pPlugin==0)
{
dlg.setText("Loading " + toQString(it->name()));
dlg.setProgress(0);
qApp->processEvents();
loadPlugin(it->directory, it->name());
dlg.setProgressRange(0, 100, false);
dlg.setProgress(100);
dlg.setText("");
qApp->processEvents();
}
}
_pProgressDlg = 0;
}
vector PluginManager::getLoadedPlugins() const
{
vector result;
for (map::const_iterator it = _plugins.begin();
it != _plugins.end(); ++it)
{
if (it->second.pPlugin != 0)
result.push_back(it->second.pPlugin);
}
return result;
}
// This function first collects the plugins available in the plugin directories.
// Afterwards it checks the loaded plugins and searches those in the ones collected
// above where it appends the load specific information. If a loaded plugin is
// not available in the available ones it will be appended at the result.
vector PluginManager::getAvailablePlugins() const
{
vector result;
set collectedPlugins;
// iterate through the plugins and add the loaded plugins to result and loadedPlugins
{
for (map::const_iterator it = _plugins.begin();
it != _plugins.end(); ++it )
{
// if the plugin is loaded
if (it->second.pPlugin != 0)
{
result.push_back(it->second);
collectedPlugins.insert(it->first);
}
}
}
for (vector::const_iterator it = _directories.begin(); it != _directories.end(); ++it)
{
const string& directory = *it;
dlerror(); // clear error messages
QDir pluginDir(toQString(directory), "lib*.so"); // only care for library files
QStringList pluginFiles = pluginDir.entryList(QDir::Files);
// try to load the library and fetch the creator function for each file
// in the current directory, if both is possible the plugin is available
for (QStringList::iterator jt = pluginFiles.begin(); jt != pluginFiles.end(); ++jt)
{
qStrDebug("opening plugin file " + pluginDir.absolutePath() + "/" + *jt);
PluginData pluginData;
string libraryFile = toString(*jt);
string pluginName = libraryFile.substr(3,libraryFile.length() - 6); // remove "lib" and ".so"
// skip this library file if the plugin was already found
if (collectedPlugins.find(pluginName) != collectedPlugins.end())
continue;
void* libraryHandle = dlopen((directory + libraryFile).c_str(), RTLD_NOW);
checkDlError();
if (libraryHandle) // loading was possible
{
typedef PluginInformation (*GetPluginDataFkt)();
GetPluginDataFkt getInformation = GetPluginDataFkt(dlsym(libraryHandle, "get_pluginInformation"));
// if the function could be received this libary seems to contain a plugin
if (getInformation != 0)
{
pluginData.directory = directory;
if (getInformation != 0)
pluginData.information = getInformation();
result.push_back(pluginData);
// this prevents a reload of the plugin information, if the plugin is also
// existent in a plugin path later in the list
collectedPlugins.insert(pluginData.name());
}
dlclose(libraryHandle); // close the library again
}
}
dlerror(); // dismiss possible error messages
}
return result;
}
PluginContainer* PluginManager::loadPlugin(
const string& directory, const string& pluginName)
{
if (isLoaded(toQString(pluginName)))
return 0;
typedef PluginContainer* (*NewPluginFkt)();
typedef PluginInformation (*GetPluginDataFkt)();
// holds if a progress dialog was available when calling this method
bool progressDialogAvailable = (_pProgressDlg != 0);
if (!progressDialogAvailable)
{
_pProgressDlg = new NUtil::ProgressDisplayDlg(_pProvider->mainWindow(), "PluginProgressDlg", true);
// _pProgressDlg->show();
}
PluginContainer* pPlugin = 0;
dlerror(); // dismiss pending errors
void* libraryHandle = dlopen((directory + "lib" + pluginName + ".so").c_str(), RTLD_LAZY);
if (!checkDlError()) // if no error occured
{
assert(libraryHandle != 0);
PluginData pluginData;
// get the function for creating the plugin
NewPluginFkt func = NewPluginFkt(dlsym(libraryHandle, ("new_" + pluginName).c_str() ));
if (func != 0) // if no error occured on load (i.e. the symbol was present)
{
// setup translation
QString locale = QLocale::system().name();
qDebug() << "Translation dir " << _translationDir.path();
QTranslator* pTranslator = new QTranslator();
if (pTranslator->load(_translationDir.filePath( toQString(pluginName) + "_" + locale)))
{
qDebug() << "Loaded translation " << toQString(pluginName) + "_" + locale;
QApplication::installTranslator(pTranslator);
pluginData.pTranslator = pTranslator;
}
else
{
delete pTranslator;
pTranslator = 0;
// warn if we have non-english and no translation
if (!locale.startsWith("en_"))
qWarning() << tr("No translation for plugin ") << toQString(pluginName) <<
tr(" found for current locale ") << locale;
}
pPlugin = func(); // fetch the plugin
qDebug() << "Loaded plugin: " << pPlugin->title();
pluginData.directory = directory;
pluginData.libraryHandle = libraryHandle;
GetPluginDataFkt getInformation = GetPluginDataFkt(
dlsym(libraryHandle, "get_pluginInformation"));
if (getInformation != 0)
pluginData.information = getInformation();
if (pPlugin) // if loading was successful, add the plugin to the map
// and remove it from the disbled plugins if necessary
{
pPlugin->addPluginUser(this);
if (pPlugin->init(_pProvider)) // if the container initializes successfully
{
pluginData.pPlugin = pPlugin;
map::const_iterator it = _pluginSettings.find(pPlugin->name());
if ( it != _pluginSettings.end() )
pPlugin->loadSettings(it->second);
_plugins[pluginName] = pluginData;
}
else
{
QApplication::removeTranslator(pluginData.pTranslator);
delete pluginData.pTranslator;
pluginData.pTranslator = 0;
delete pPlugin;
pPlugin = 0;
}
}
}
else // an error while trying to load the lib.so file
{
dlclose(libraryHandle);
dlerror(); // dismiss possible errors
}
}
if (!progressDialogAvailable)
{
delete _pProgressDlg;
_pProgressDlg = 0;
}
return pPlugin;
}
void PluginManager::unloadPlugin(PluginContainer* pPlugin)
{
QString pluginTitle = pPlugin->title();
map::iterator it = _plugins.find(pPlugin->name());
PluginData& pluginData = it->second;
assert(pluginData.pPlugin != 0);
delete pluginData.pTranslator;
pluginData.pTranslator = 0;
// add the settings of the plugin in _pluginSettings
{
NXml::XmlData data("SettingsDocument");
pPlugin->saveSettings(data, data.root());
// if the plugin has settings
if (!data.root().firstChild().isNull())
// can not use operator[] because this would have violated the const specification
_pluginSettings.insert(
make_pair(pPlugin->name(), data.root().firstChild().toElement()) );
}
delete pPlugin;
pluginData.pPlugin = 0;
dlclose(pluginData.libraryHandle);
_pProvider->statusBar()->showMessage("Unloaded plugin " + pluginTitle, 3000);
}
void PluginManager::unloadPlugin(const string& pluginName)
{
PluginToDataMap::iterator it = _plugins.find(pluginName);
unloadPlugin(it->second.pPlugin);
}
void PluginManager::saveSettings(NXml::XmlData& outData, QDomElement parent) const
{
// take a look at the pluginmanager.dtd file for the XML structure
QDomElement pluginManager = outData.addElement(parent, "PluginManager");
outData.addAttribute(pluginManager, _settingsVersion, "settingsVersion");
QDomElement disabledPlugins = outData.addElement(pluginManager, "DisabledPlugins");
QDomElement pluginSettings = outData.addElement(pluginManager, "PluginSettings");
vector availablePlugins = getAvailablePlugins();
for (vector::const_iterator it = availablePlugins.begin();
it != availablePlugins.end(); ++it)
{
const PluginData& pluginData = *it;
// if the plugin was loaded
if (pluginData.pPlugin != 0)
{
qDebug() << "Saving " << pluginData.name().c_str();
pluginData.pPlugin->saveSettings(outData, pluginSettings);
}
// the plugin was not loaded
else
{
QDomElement plugin = outData.addElement(disabledPlugins, "Plugin");
{
outData.addAttribute(plugin, pluginData.name(), "name");
}
// store the loaded settings for the disabled plugins if available
map::const_iterator jt = _pluginSettings.find(pluginData.name());
if ( jt != _pluginSettings.end() )
{
outData.importNode(jt->second, pluginSettings, true);
}
}
}
}
QDomElement PluginManager::loadSettings(QDomElement source)
{
if (source.tagName() != "PluginManager")
return source;
// take a look at the pluginmanager.dtd file for the XML structure
QDomElement disabledPlugins = NXml::getFirstElement(source.firstChild());
{
QDomElement plugin = NXml::getFirstElement(disabledPlugins.firstChild());
while (!plugin.isNull())
{
string disabledPlugin;
NXml::getAttribute(plugin, disabledPlugin, "name");
_disabledPlugins.insert(disabledPlugin);
plugin = NXml::getNextElement(plugin);
}
}
// the node which holds all settings of the different plugins
QDomElement pluginSettings = NXml::getNextElement(disabledPlugins);
{
QDomElement settings = NXml::getFirstElement(pluginSettings.firstChild());
while (!settings.isNull())
{
// qDebug() << "Loaded " << settings.tagName() << " settings";
// the settings for the current plugin
_pluginSettings.insert( make_pair(toString(settings.tagName()),settings) );
settings = NXml::getNextElement(settings);
}
}
return NXml::getNextElement(source);
}
void PluginManager::showControlDialog(QWidget* pParent)
{
PluginControlDlgMeditator mediator(this);
mediator.displayDialog(pParent);
}
bool PluginManager::checkDlError() const
{
const char* error = dlerror();
if (error)
{
cerr << "Dynamic Library error: " << error <second.pPlugin != 0 )
return true;
return false;
}
void PluginManager::setTranslationDir(const QDir& dir)
{
_translationDir = dir;
}
} // namespace NPlugin
packagesearch-2.7.4/src/pluginmanager.dtd 0000644 0000000 0000000 00000002000 10260324006 015271 0 ustar
packagesearch-2.7.4/src/exception.cpp 0000644 0000000 0000000 00000000456 10064377157 014503 0 ustar //
// C++ Implementation: exception
//
// Description:
//
//
// Author: Benjamin Mesing , (C) 2004
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include "exception.h"
namespace NException {
Exception::Exception()
{
}
Exception::~Exception()
{
}
};
packagesearch-2.7.4/src/iscorecalculationstrategy.h 0000644 0000000 0000000 00000003346 11361146723 017433 0 ustar //
// C++ Interface: iscorecalculationstrategy
//
// Description:
//
//
// Author: Benjamin Mesing , (C) 2005
//
// Copyright: See COPYING file that comes with this distribution
//
//
#ifndef __NPLUGIN_ISCORECALCULATIONSTRATEGY_H_2005_07_30
#define __NPLUGIN_ISCORECALCULATIONSTRATEGY_H_2005_07_30
#include
#include