RPM Packaging: rename directories

1 files changed, 39683 insertions, 0 deletions

diff --git a/redhat/tdesdk/kdesdk-3.5.13.1-fix_kdecachegrind_ftbfs.patch b/redhat/tdesdk/kdesdk-3.5.13.1-fix_kdecachegrind_ftbfs.patch
new file mode 100644
index 000000000..80ca10ff8
--- /dev/null
+++ b/redhat/tdesdk/kdesdk-3.5.13.1-fix_kdecachegrind_ftbfs.patch
@@ -0,0 +1,39683 @@
+commit cfccedd9c8db3af36d7c5635ca212fa170bb6ff5
+Author: Timothy Pearson <kb9vqf@pearsoncomputing.net>
+Date:   1327976424 -0600
+
+    Part 2 of prior commit
+
+diff --git a/kdecachegrind/AUTHORS b/kdecachegrind/AUTHORS
+new file mode 100644
+index 0000000..ded6005
+--- /dev/null
++++ b/kdecachegrind/AUTHORS
+@@ -0,0 +1 @@
++Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
+diff --git a/kdecachegrind/COPYING b/kdecachegrind/COPYING
+new file mode 100644
+index 0000000..c13faf0
+--- /dev/null
++++ b/kdecachegrind/COPYING
+@@ -0,0 +1,340 @@
++		    GNU GENERAL PUBLIC LICENSE
++		       Version 2, June 1991
++
++ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
++                       51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  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.
+diff --git a/kdecachegrind/ChangeLog b/kdecachegrind/ChangeLog
+new file mode 100644
+index 0000000..05f3081
+--- /dev/null
++++ b/kdecachegrind/ChangeLog
+@@ -0,0 +1,89 @@
++2004/06/30
++	* Leak fixes
++	* Crash fixes on reload (make setData() synchroneous)
++	* Some update fixes in the data model (tracedata.cpp)
++	* Fix update problems in Function Profile
++	* Reselect active function on refresh in function profile
++	  with grouping on
++
++2004/04/28
++	* toplevel.h/cpp, kdecachegrindui.rc
++	  - Switching Layouts
++	* multiview.cpp: Removed some qDebug's
++	* Same term fixes
++
++2004/04/26
++	* cachegrindloader.cpp, fixcost.cpp:
++	  - Allow Ranges in Subposition Spec, currently not used
++	  - Correctly parse "Desc: Trigger:"
++	  - Allow Event Spec (Long Name, Formula) with "event:"
++	* listutils.cpp:
++	  - make level meters for costs only 1 bar
++	    (2 with upper from 0..50%, lower 50%..100% is really confusing)
++	  - Besides from Call graph and Tree maps, truncate bars to
++	    only use needed size (removes lots of empty rectangles)
++	* CallGraphView:
++	  - some fixes when no data is loaded
++	* functionselection.cpp (Function Profile)
++	  - activation on mouse release to allow for context menu
++	* tracedata.cpp
++	  - more robust parsing of events lists
++	  - Introduction of Ranges (not currently used)
++	* utils.cpp:
++	  - more robust parsing functions	
++
++2004/04/05
++	* CallGraphView:
++	  - Add Context menu item "Export as Image"
++	  - Hide Birdseye-View if call-graph fits into widget
++	  - Error messages in Canvas when something goes wrong
++        * Some Fixes, qDebug->kdDebug
++
++2004/04/02
++	* In most views columns for 2nd Event Type added
++	* Context menus modified to allow quick change of 2nd Event Type
++	* Toolbar simplified (only most used actions)
++	* Terminology fixes ("cost type"->"event type",
++          "trace data"->"profile data", long names of Ir,Dr,...)
++	* Sorting costs in lists is always descending now
++	* New File menu item: "Add..." other profile data to current window
++        * Detect Cachegrind format by "events:" content, not file name
++	  Allows for arbitrary names of profile data files.
++
++2004/03/25
++	* New Class Addr as wrapper for memory addresses. Use 64bit
++	  to allow loading of data produced on 64bit architectures
++
++2004/03/17
++
++	* costtypeview.cpp, tracedata.h/cpp:
++	  Fixed deletion of custom types
++	* cachegrindloader.cpp, tracedata.h/cpp:
++	  Moved String compression handling in Cachegrind files
++	  to CachegrindLoader
++	* Do not show inclusive cost column in FunctionSelection
++	  side bar if not available
++	* Remove "isPartOfTrace" from Loader interface
++	  (we allow parts from multiple experiments for comp.)
++	* partview.cpp, partlistitem.h/cpp:
++	  Remove Column Callees, add Trigger
++
++2003/05/10
++
++	* Status progress on loading and cycle calculation
++	* Corrected order of trace parts (PID/PartNo/ThreadID)
++	* Allow adding traces (BUGGY...)
++
++2003/02/06
++
++	* Version 0.3a
++	* Bugfixes:
++	  - Compiles with KDE 3.0.x
++	  - Always select a first cost type
++	  - Loading from another directory
++
++
++2002/11/28
++
++	* Version 0.3
++	
+diff --git a/kdecachegrind/INSTALL b/kdecachegrind/INSTALL
+new file mode 100644
+index 0000000..02a4a07
+--- /dev/null
++++ b/kdecachegrind/INSTALL
+@@ -0,0 +1,167 @@
++Basic Installation
++==================
++
++   These are generic installation instructions.
++
++   The `configure' shell script attempts to guess correct values for
++various system-dependent variables used during compilation.  It uses
++those values to create a `Makefile' in each directory of the package.
++It may also create one or more `.h' files containing system-dependent
++definitions.  Finally, it creates a shell script `config.status' that
++you can run in the future to recreate the current configuration, a file
++`config.cache' that saves the results of its tests to speed up
++reconfiguring, and a file `config.log' containing compiler output
++(useful mainly for debugging `configure').
++
++   If you need to do unusual things to compile the package, please try
++to figure out how `configure' could check whether to do them, and mail
++diffs or instructions to the address given in the `README' so they can
++be considered for the next release.  If at some point `config.cache'
++contains results you don't want to keep, you may remove or edit it.
++
++   The file `configure.in' is used to create `configure' by a program
++called `autoconf'.  You only need `configure.in' if you want to change
++it or regenerate `configure' using a newer version of `autoconf'.
++
++The simplest way to compile this package is:
++
++  1. `cd' to the directory containing the package's source code and type
++     `./configure' to configure the package for your system.  If you're
++     using `csh' on an old version of System V, you might need to type
++     `sh ./configure' instead to prevent `csh' from trying to execute
++     `configure' itself.
++
++     Running `configure' takes a while.  While running, it prints some
++     messages telling which features it is checking for.
++
++  2. Type `make' to compile the package.
++
++  3. Type `make install' to install the programs and any data files and
++     documentation.
++
++  4. You can remove the program binaries and object files from the
++     source code directory by typing `make clean'.  
++
++Compilers and Options
++=====================
++
++   Some systems require unusual options for compilation or linking that
++the `configure' script does not know about.  You can give `configure'
++initial values for variables by setting them in the environment.  Using
++a Bourne-compatible shell, you can do that on the command line like
++this:
++     CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure
++
++Or on systems that have the `env' program, you can do it like this:
++     env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure
++
++Compiling For Multiple Architectures
++====================================
++
++   You can compile the package for more than one kind of computer at the
++same time, by placing the object files for each architecture in their
++own directory.  To do this, you must use a version of `make' that
++supports the `VPATH' variable, such as GNU `make'.  `cd' to the
++directory where you want the object files and executables to go and run
++the `configure' script.  `configure' automatically checks for the
++source code in the directory that `configure' is in and in `..'.
++
++   If you have to use a `make' that does not supports the `VPATH'
++variable, you have to compile the package for one architecture at a time
++in the source code directory.  After you have installed the package for
++one architecture, use `make distclean' before reconfiguring for another
++architecture.
++
++Installation Names
++==================
++
++   By default, `make install' will install the package's files in
++`/usr/local/bin', `/usr/local/man', etc.  You can specify an
++installation prefix other than `/usr/local' by giving `configure' the
++option `--prefix=PATH'.
++
++   You can specify separate installation prefixes for
++architecture-specific files and architecture-independent files.  If you
++give `configure' the option `--exec-prefix=PATH', the package will use
++PATH as the prefix for installing programs and libraries.
++Documentation and other data files will still use the regular prefix.
++
++   If the package supports it, you can cause programs to be installed
++with an extra prefix or suffix on their names by giving `configure' the
++option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
++
++Optional Features
++=================
++
++   Some packages pay attention to `--enable-FEATURE' options to
++`configure', where FEATURE indicates an optional part of the package.
++They may also pay attention to `--with-PACKAGE' options, where PACKAGE
++is something like `gnu-as' or `x' (for the X Window System).  The
++`README' should mention any `--enable-' and `--with-' options that the
++package recognizes.
++
++   For packages that use the X Window System, `configure' can usually
++find the X include and library files automatically, but if it doesn't,
++you can use the `configure' options `--x-includes=DIR' and
++`--x-libraries=DIR' to specify their locations.
++
++Specifying the System Type
++==========================
++
++   There may be some features `configure' can not figure out
++automatically, but needs to determine by the type of host the package
++will run on.  Usually `configure' can figure that out, but if it prints
++a message saying it can not guess the host type, give it the
++`--host=TYPE' option.  TYPE can either be a short name for the system
++type, such as `sun4', or a canonical name with three fields:
++     CPU-COMPANY-SYSTEM
++
++See the file `config.sub' for the possible values of each field.  If
++`config.sub' isn't included in this package, then this package doesn't
++need to know the host type.
++
++   If you are building compiler tools for cross-compiling, you can also
++use the `--target=TYPE' option to select the type of system they will
++produce code for and the `--build=TYPE' option to select the type of
++system on which you are compiling the package.
++
++Sharing Defaults
++================
++
++   If you want to set default values for `configure' scripts to share,
++you can create a site shell script called `config.site' that gives
++default values for variables like `CC', `cache_file', and `prefix'.
++`configure' looks for `PREFIX/share/config.site' if it exists, then
++`PREFIX/etc/config.site' if it exists.  Or, you can set the
++`CONFIG_SITE' environment variable to the location of the site script.
++A warning: not all `configure' scripts look for a site script.
++
++Operation Controls
++==================
++
++   `configure' recognizes the following options to control how it
++operates.
++
++`--cache-file=FILE'
++     Use and save the results of the tests in FILE instead of
++     `./config.cache'.  Set FILE to `/dev/null' to disable caching, for
++     debugging `configure'.
++
++`--help'
++     Print a summary of the options to `configure', and exit.
++
++`--quiet'
++`--silent'
++`-q'
++     Do not print messages saying which checks are being made.
++
++`--srcdir=DIR'
++     Look for the package's source code in directory DIR.  Usually
++     `configure' can determine that directory automatically.
++
++`--version'
++     Print the version of Autoconf used to generate the `configure'
++     script, and exit.
++
++`configure' also accepts some other, not widely useful, options.
++
+diff --git a/kdecachegrind/Makefile.am b/kdecachegrind/Makefile.am
+new file mode 100644
+index 0000000..e93f6af
+--- /dev/null
++++ b/kdecachegrind/Makefile.am
+@@ -0,0 +1,6 @@
++SUBDIRS = kdecachegrind pics converters
++
++EXTRA_DIST = \
++	AUTHORS COPYING NEWS ChangeLog INSTALL README TODO \
++	kdecachegrind.lsm kdecachegrind.spec version.h 
++
+diff --git a/kdecachegrind/NEWS b/kdecachegrind/NEWS
+new file mode 100644
+index 0000000..e69de29
+diff --git a/kdecachegrind/README b/kdecachegrind/README
+new file mode 100644
+index 0000000..0866eb8
+--- /dev/null
++++ b/kdecachegrind/README
+@@ -0,0 +1,62 @@
++KCachegrind
++===========
++
++
++What is all this about ?
++-------------------------
++
++Profiling, i.e. determinating most time consuming execution parts,
++is an important last step when developing applications.
++KCachegrind visualizes traces, generated by profiling, in various ways;  
++most notable is the TreeMap visualization of the calls happening
++and a condensed version of it, the Coverage analysis.
++KCachegrind is designed to allow fast browsing and to provide a quick
++overview of very large programs, such as KDE applications (but not
++limited to!). 
++  
++At the moment, it uses Cachegrind as profiling backend, which is using
++the excellent CPU simulator in Valgrind. Thus, profiling does not 
++need any preparation, can cope with shared libraries and plugin
++architectures, and allows for profile runs to not influence the measuring
++by the profile itself (all in contrast to e.g. GProf). Disadvantage is 
++slower profile runs, unfortunately. 
++ 
++For Cachegrind to provide call tree information, a patch is provided.  
++This enables the most interesting visualization features of KCachegrind. 
++
++
++Requirements
++------------
++
++A call-tree version of Cachegrind:
++  - X86 Linux
++  - Valgrind 1.0.x with call-tree patch from KCachegrind Website
++  - Valgrind 2.0.x with call-tree skin installed
++
++Cachegrind runs on x86 platforms, KCachegrind on all KDE enabled
++platforms (KDE 3.0.x). 
++
++
++Compilation and Installation
++----------------------------
++
++Simple do the command sequence
++
++  ./configure --prefix=<KDE base directory>
++  make
++  make install
++
++
++
++KCachegrind features
++--------------------
++
++Most important: TreeMap calltree visualisation.
++For the rest, see the detailed "What's this?" help for
++each part of KCachegrind and the quick starter on the
++WWW page ( http://kcachegrind.sourceforge.net/cgi-bin/show.cgi )
++
++
++
++Happy Profiling,
++ Josef Weidendorfer
+diff --git a/kdecachegrind/TODO b/kdecachegrind/TODO
+new file mode 100644
+index 0000000..1eca67e
+--- /dev/null
++++ b/kdecachegrind/TODO
+@@ -0,0 +1,100 @@
++TODO/Wishlist Items
++===================
++
++
++KCachegrind
++-----------
++
++All cost Lists:
++* Show up to a number of items, not down to a threadshold.
++  If more, add a "..." with number of items not shown, and context option
++  to show more
++* "Copy from Top" converts lists into ASCII, puts into clipboard
++
++
++Configuration:
++ Source dirs per ELF object
++
++Layout:
++* 1/2/3/4 vertical/horizontal FunctionInfos
++  with Shift/Wraparound selection mode
++* Inside each FunctionInfo different Layouts
++ - tabbed layout
++ - top: info, bottom left: calls/coverage, bottom right: graph/source
++* Long/short info tab
++
++General:
++* Selected Item can be a object/file/class/function/line
++* Configuration Dlg
++ - Local config (?)
++ - Cost Types
++ - function colors
++ - Try to reload source after config.
++* Session Management
++
++
++
++Annotation Views:
++
++ BUGS:
++  * Draw problem with multiple srcs to one target
++  * REP case...
++
++ TODO:
++  * Selectable Jumps (Arrows)
++  * Tooltip for Jumps (Kind, from/to, jump count) 
++  * Show direction (arrows) on jump lines
++
++ Source view TODO:
++  * Implicit jumps (green) [needs support from the tool?]
++
++
++
++Callgraph:
++* Fix Arrows for back-arcs
++* Less "Jumps" for minimap
++* Correct Keyboard navigation (how?)
++
++Types:
++* Ratios
++* Automatic subtypes
++
++WISHS:
++* Support for Data tracing
++  Which variables are touched how often from which function?
++  - Some graphical visualisation...
++
++* GCC -pg (gmon.out) as Profiling Backend
++* Demangler (use c++filt)
++* Calculation of call weights (if not given)
++* OProfile, DynaProf
++
++Support for KCachegrind in Calltree
++-----------------------------------
++
++WISHS:
++- store more details of calltree
++  - for every function call: executed from shared lib
++    (Not needed, if function names are unique in whole app)
++  - adaptive call chain context (Really needed ? MUCH Data!)
++- dump at
++  - breakpoints
++  - watchpoints (with data tracing!)
++  - every xxx BBs (DONE)
++- dump around
++  - function invocation
++  - KAction event
++  - DCOP event
++
++- data accesses from (instr address/count)
++  stack:   -> (function, stackframe-offset)
++  dynamic: -> (mem region start, [type], offset)
++              type can be get when a constructor is called for region
++  static:  -> (mem region start, type, offset)
++
++* Generate full instr/data access trace for offline analysis.
++
++* Appending mode
++
++
++
+diff --git a/kdecachegrind/configure.in.in b/kdecachegrind/configure.in.in
+new file mode 100644
+index 0000000..dfc8508
+--- /dev/null
++++ b/kdecachegrind/configure.in.in
+@@ -0,0 +1,8 @@
++KCACHEGRIND_VERSION=0.4.6kde
++AC_SUBST(KCACHEGRIND_VERSION)
++
++AC_FUNC_MMAP
++
++dnl AC_OUTPUT( kdecachegrind/version.h )
++dnl AC_OUTPUT( kdecachegrind/kdecachegrind.spec )
++dnl AC_OUTPUT( kdecachegrind/kdecachegrind.lsm )
+diff --git a/kdecachegrind/converters/Makefile.am b/kdecachegrind/converters/Makefile.am
+new file mode 100644
+index 0000000..08b3696
+--- /dev/null
++++ b/kdecachegrind/converters/Makefile.am
+@@ -0,0 +1,2 @@
++bin_SCRIPTS = hotshot2calltree op2calltree pprof2calltree dprof2calltree \
++	memprof2calltree
+diff --git a/kdecachegrind/converters/README b/kdecachegrind/converters/README
+new file mode 100644
+index 0000000..c27d3c6
+--- /dev/null
++++ b/kdecachegrind/converters/README
+@@ -0,0 +1,24 @@
++This directory contains some scripts to convert output of different
++profiling tools into the format which can be loaded by KCachegrind.
++See the comment at start of every script for details.
++
++In the long run, these should be replaced by import filters in
++KCachegrind directly, but I can't promise anything. Partly, this
++is because some scripts are provided as contribution from others.
++
++hotshot2calltree   Converter from Python Hotshot Profiler.
++op2calltree        Converter from OProfile sampling data. 
++dprof2calltree     Converter from PERL::DProf Profiler.
++pprof2calltree     Converter from APD PHP Profiler.
++
++Thanks go to
++* George Schlossnagle <george@omniti.com> for
++  dprof2calltree and pprof2calltree,
++* J�rg Beyer <job@webde-ag.de> for
++  hotshot2calltree
++
++If you want to write a converter, have a look at the calltree format
++description on the web site (kdecachegrind.sf.net).
++
++Josef
++
+diff --git a/kdecachegrind/converters/dprof2calltree b/kdecachegrind/converters/dprof2calltree
+new file mode 100644
+index 0000000..f276e18
+--- /dev/null
++++ b/kdecachegrind/converters/dprof2calltree
+@@ -0,0 +1,199 @@
++#!/usr/bin/perl
++#
++# Redistribution and use in source and binary forms, with or without
++# modification, are permitted provided that the following conditions are met:
++# 
++# - Redistributions of source code must retain the above copyright notice,
++# this list of conditions and the following disclaimer.
++# 
++# - Redistributions in binary form must reproduce the above copyright
++# notice, this list of conditions and the following disclaimer in the
++# documentation and/or other materials provided with the distribution.
++# 
++# - All advertising materials mentioning features or use of this software
++# must display the following acknowledgement: This product includes software
++# developed by OmniTI Computer Consulting.
++# 
++# - Neither name of the company nor the names of its contributors may be
++# used to endorse or promote products derived from this software without
++# specific prior written permission.
++# 
++# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS `AS IS'' AND ANY
++# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
++# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
++# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
++# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
++# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
++# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
++# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++#
++# Copyright (c) 2004 OmniTI Computer Consulting 
++# All rights reserved
++# The following code was written by George Schlossnagle <george@omniti.com>
++# and is provided completely free and without any warranty.
++#
++
++#
++# This script is designed to convert the tmon.out output emitted 
++# from Perl's Devel::DProf profiling package.  To use this:
++#
++# 1) Run your perl script as 
++#    > perl -d:DProf yoursript.pl
++#    This will create a file called tmon.out.  If you want to
++#    inspect it on the command line, look at the man page
++#    for dprofp for details.
++#
++# 2) Run  
++#    > dprof2calltree -f tmon.out
++#    or
++#    > dprof2calltree -f tmon.out -o cachegrind.out.foo
++#
++#    This creates a cachegrind-style file called cachgrind.out.tmon.out or
++#    cachegrind.out.foo, respecitvely.
++#
++# 3) Run kdecachegrind cachegrind.out.foo
++#
++# 4) Enjoy!
++
++use strict;
++use Config;
++use Getopt::Std;
++use IO::File;
++
++my @callstack;
++my %function_info;
++my $tree = {};
++my $total_cost = 0;
++my %opts;
++
++getopt('f:o:', \%opts);
++
++my $infd;
++usage() unless ($opts{'f'} && ($infd = IO::File->new($opts{'f'}, "r")));
++
++my $outfd;
++my $outfile = $opts{'o'};
++unless($outfile) {
++  $opts{'f'} =~ m!([^/]+)$!;
++  $outfile = "cachegrind.out.$1";
++}
++$outfd = new IO::File $outfile, "w";
++usage() unless defined $outfd;
++  
++while(<$infd>) {
++  last if /^PART2/;
++}
++while(<$infd>) {
++  chomp;
++  my @args = split;
++  if($args[0] eq '@') {
++    # record timing event
++    my $call_element = pop @callstack;
++    if($call_element) {
++      $call_element->{'cost'} += $args[3];
++      $call_element->{'cumm_cost'} += $args[3];
++      $total_cost += $args[3];
++      push @callstack, $call_element;
++    }
++  }
++  elsif($args[0] eq '&') {  
++    # declare function
++    $function_info{$args[1]}->{'package'} = $args[2];
++    if($args[2] ne 'main') {
++      $function_info{$args[1]}->{'name'} = $args[2]."::".$args[3];
++    } else {
++      $function_info{$args[1]}->{'name'} = $args[3];
++    }
++  }
++  elsif($args[0] eq '+') {
++    # push myself onto the stack
++    my $call_element = { 'specifier' => $args[1], 'cost' => 0 };
++    push @callstack, $call_element;
++  }
++  elsif($args[0] eq '-') {
++    my $called = pop @callstack;
++    my $called_id = $called->{'specifier'};
++    my $caller = pop @callstack;
++    if (exists $tree->{$called_id}) {
++      $tree->{$called_id}->{'cost'} += $called->{'cost'};
++    }
++    else {
++      $tree->{$called_id} = $called;
++    } 
++    if($caller) {
++      $caller->{'child_calls'}++;
++      my $caller_id = $caller->{'specifier'};
++      if(! exists $tree->{$caller_id} ) {
++        $tree->{$caller_id} = { 'specifier' => $caller_id, 'cost' => 0 };
++#        $tree->{$caller_id} = $caller;
++      }
++      $caller->{'cumm_cost'} += $called->{'cumm_cost'};
++      $tree->{$caller_id}->{'called_funcs'}->[$tree->{$caller_id}->{'call_counter'}++]->{$called_id} += $called->{'cumm_cost'};
++      push @callstack, $caller;
++    }
++  }
++  elsif($args[0] eq '*') {
++    # goto &func
++    # replace last caller with self
++    my $call_element = pop @callstack;
++    $call_element->{'specifier'} = $args[1];
++    push @callstack, $call_element;
++  }
++  else {print STDERR "Unexpected line: $_\n";}
++}
++
++#
++# Generate output
++#
++my $output = '';
++$output .= "events: Tick\n";
++$output .= "summary: $total_cost\n";
++$output .= "cmd: your script\n\n";
++foreach my $specifier ( keys %$tree ) {
++  my $caller_package = $function_info{$specifier}->{'package'} || '???';
++  my $caller_name = $function_info{$specifier}->{'name'} || '???';
++  my $include = find_include($caller_package);
++  $output .= "ob=\n";
++  $output .= sprintf "fl=%s\n", find_include($caller_package);
++  $output .= sprintf "fn=%s\n", $caller_name;
++  $output .= sprintf "1 %d\n", $tree->{$specifier}->{'cost'};
++  if(exists $tree->{$specifier}->{'called_funcs'}) {
++    foreach my $items (@{$tree->{$specifier}->{'called_funcs'}}) {
++      while(my ($child_specifier, $costs) = each %$items) {
++        $output .= sprintf "cfn=%s\n", $function_info{$child_specifier}->{'name'};
++        $output .= sprintf "cfi=%s\n", find_include($function_info{$child_specifier}->{'package'});
++        $output .= "calls=1\n";
++        $output .= sprintf "1 %d\n", $costs;
++      }
++    }
++  }
++  $output .= "\n";
++}
++print STDERR "Writing kdecachegrind output to $outfile\n";
++$outfd->print($output);
++
++
++
++sub find_include {
++  my $module = shift;
++  $module =~ s!::!/!g;
++  for (@INC) {
++    if ( -f "$_/$module.pm" ) {
++      return "$_/$module.pm";
++    }
++    if ( -f "$_/$module.so" ) {
++      return "$_/$module.so";
++    }
++  }
++  return "???";
++}
++
++sub usage() {
++  print STDERR "dprof2calltree -f <tmon.out> [-o outfile]\n";
++  exit -1;
++}
++
++
++# vim: set sts=2 ts=2 bs ai expandtab :
+diff --git a/kdecachegrind/converters/hotshot2calltree b/kdecachegrind/converters/hotshot2calltree
+new file mode 100644
+index 0000000..f62a46e
+--- /dev/null
++++ b/kdecachegrind/converters/hotshot2calltree
+@@ -0,0 +1,394 @@
++#!/usr/bin/env python
++# _*_ coding: latin1 _*_
++
++#
++# Copyright (c) 2003 by WEB.DE, Karlsruhe
++# Autor: J�rg Beyer <job@webde-ag.de>
++#
++# hotshot2cachegrind 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, version 2.
++#
++# 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; see the file COPYING.  If not, write to
++# the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++# Boston, MA 02110-1301, USA.
++#
++#
++# This script transforms the pstat output of the hotshot
++# python profiler into the input of kdecachegrind. 
++#
++# example usage:
++# modify you python script to run this code:
++#
++# import hotshot
++# filename = "pythongrind.prof"
++# prof = hotshot.Profile(filename, lineevents=1)
++# prof.runcall(run) # assuming that "run" should be called.
++# prof.close()
++#
++# it will run the "run"-method under profiling and write
++# the results in a file, called "pythongrind.prof".
++#
++# then call this script:
++# hotshot2cachegrind -o <output> <input>
++# or here:
++# hotshot2cachegrind cachegrind.out.0 pythongrind.prof
++#
++# then call kdecachegrind:
++# kdecachegrind cachegrind.out.0
++#
++# TODO: 
++#  * es gibt Probleme mit rekursiven (direkt und indirekt) Aufrufen - dann
++#    stimmen die Kosten nicht.
++#
++#  * einige Funktionen werden mit "?" als Name angezeigt. Evtl sind
++#    das nur die C/C++ extensions.
++#
++#  * es fehlt noch ein Funktionsnamen Mangling, dass die Filenamen ber�cksichtigt,
++#    zZ sind alle __init__'s und alle run's schwer unterscheidbar :-(
++#
++version = "$Revision$"
++progname = "hotshot2cachegrind"
++
++import os, sys
++from hotshot import stats,log
++import os.path 
++
++file_limit=0
++
++what2text = { 
++    log.WHAT_ADD_INFO    : "ADD_INFO", 
++    log.WHAT_DEFINE_FUNC : "DEFINE_FUNC", 
++    log.WHAT_DEFINE_FILE : "DEFINE_FILE", 
++    log.WHAT_LINENO      : "LINENO", 
++    log.WHAT_EXIT        : "EXIT", 
++    log.WHAT_ENTER       : "ENTER"}
++
++# a pseudo caller on the caller stack. This represents
++# the Python interpreter that executes the given python 
++# code.
++root_caller = ("PythonInterpreter",0,"execute")
++
++class CallStack:
++    """A tiny Stack implementation, based on python lists"""
++    def __init__(self):
++       self.stack = []
++       self.recursion_counter = {}
++    def push(self, elem):
++        """put something on the stack"""
++        self.stack.append(elem)
++        rc = self.recursion_counter.get(elem, 0)
++        self.recursion_counter[elem] = rc + 1
++
++    def pop(self):
++        """get the head element of the stack and remove it from teh stack"""
++        elem = self.stack[-1:][0]
++        rc = self.recursion_counter.get(elem) - 1
++        if rc>0:
++            self.recursion_counter[elem] = rc
++        else:
++            del self.recursion_counter[elem]
++        return self.stack.pop()
++
++    def top(self):
++        """get the head element of the stack, stack is unchanged."""
++        return self.stack[-1:][0]
++    def handleLineCost(self, tdelta):
++        p, c = self.stack.pop()
++        self.stack.append( (p,c + tdelta) )
++    def size(self):
++        """ return how many elements the stack has"""
++        return len(self.stack)
++
++    def __str__(self):
++        return "[stack: %s]" % self.stack
++
++    def recursion(self, pos):
++        return self.recursion_counter.get(pos, 0)
++        #return self.recursion_dict.has_key((entry[0][0], entry[0][2]))
++
++def return_from_call(caller_stack, call_dict, cost_now):
++    """return from a function call
++       remove the function from the caller stack,
++       add the costs to the calling function.
++    """
++    called, cost_at_enter = caller_stack.pop()
++    caller, caller_cost = caller_stack.top()
++
++    #print "return_from_call: %s ruft %s" % (caller, called,)
++
++    per_file_dict = call_dict.get(called[0], {})
++    per_caller_dict = per_file_dict.get(called[2], {})
++    cost_so_far, call_counter = per_caller_dict.get(caller, (0, 0))
++
++    if caller_stack.recursion(called):
++        per_caller_dict[caller] = (cost_so_far, call_counter + 1)
++    else:
++        per_caller_dict[caller] = (cost_so_far + cost_now - cost_at_enter, call_counter + 1)
++
++    per_file_dict[called[2]] = per_caller_dict
++    call_dict[called[0]] = per_file_dict
++
++
++def updateStatus(filecount):
++    sys.stdout.write("reading File #%d    \r" % filecount)
++    sys.stdout.flush()
++def convertProfFiles(output, inputfilenames):
++    """convert all the given input files into one kdecachegrind 
++       input file.
++    """
++    call_dict = {}
++    cost_per_pos = {}
++    cost_per_function = {}
++    caller_stack = CallStack()
++    caller_stack.push((root_caller, 0))
++
++    total_cost = 0
++    filecount = 1
++    number_of_files = len(inputfilenames)
++    for inputfilename in inputfilenames:
++        updateStatus(filecount)
++        cost, filecount = convertHandleFilename(inputfilename, caller_stack, call_dict, cost_per_pos, cost_per_function, filecount)
++        total_cost += cost
++        if (file_limit > 0) and (filecount > file_limit):
++            break
++    
++    print
++    print "total_cost: % d Ticks",total_cost
++    dumpResults(output, call_dict, total_cost, cost_per_pos, cost_per_function)
++
++def convertHandleFilename(inputfilename, caller_stack, call_dict, cost_per_pos, cost_per_function, filecount):
++    updateStatus(filecount)
++    if not ((file_limit > 0) and (filecount > file_limit)):
++        if os.path.isdir(inputfilename):
++            cost, filecount = convertProfDir(inputfilename, caller_stack, call_dict, cost_per_pos, cost_per_function, filecount)
++        elif os.path.isfile(inputfilename):
++            cost = convertProfFile(inputfilename, caller_stack, call_dict, cost_per_pos, cost_per_function)
++            filecount += 1 
++        else:
++            sys.stderr.write("warn: ignoring '%s', is no file and no directory\n" % inputfilename)
++            cost = 0
++    return (cost, filecount)
++
++def convertProfDir(start, caller_stack, call_dict, cost_per_pos, cost_per_function, filecount):
++    cost = 0
++    filenames = os.listdir(start)
++    for f in filenames:
++        if (file_limit > 0) and (filecount > file_limit): 
++            break
++        full = os.path.join(start, f)
++        c, filecount = convertHandleFilename(full, caller_stack, call_dict, cost_per_pos, cost_per_function, filecount)
++        cost += c;
++    return (cost, filecount)
++
++def handleCostPerPos(cost_per_pos, pos, current_cost):
++    """
++       the cost per source position are managed in a dict in a dict.
++
++       the cost are handled per file and there per function.
++       so, the per-file-dict contains some per-function-dicts
++       which sum up the cost per line (in this function and in 
++       this file).
++    """
++    filename  = pos[0]
++    lineno    = pos[1]
++    funcname  = pos[2]
++    file_dict = cost_per_pos.get(filename, {})
++    func_dict = file_dict.get(funcname, {})
++    func_dict.setdefault(lineno, 0)
++    func_dict[lineno] += current_cost
++    file_dict[funcname] = func_dict
++    cost_per_pos[filename] = file_dict
++
++def convertProfFile(inputfilename, caller_stack, call_dict, cost_per_pos, cost_per_function):
++    """convert a single input file into one kdecachegrind
++       data.
++
++       this is the most expensive function in this python source :-)
++    """
++
++    total_cost = 0
++    try:
++        logreader = log.LogReader(inputfilename)
++        current_cost = 0
++        hc = handleCostPerPos # shortcut
++        for item in logreader:
++            what, pos ,tdelta = item
++            (file, lineno, func) = pos
++            #line = "%s %s %d %s %d" % (what2text[what], file, lineno, func, tdelta)
++            #print line
++            # most common cases first
++            if what == log.WHAT_LINENO:
++                # add the current cost to the current function
++                hc(cost_per_pos, pos, tdelta)
++                total_cost += tdelta
++            elif what == log.WHAT_ENTER:
++                caller_stack.push((pos, total_cost))
++                hc(cost_per_pos, pos, tdelta)
++                total_cost += tdelta
++            elif what == log.WHAT_EXIT:
++                hc(cost_per_pos, pos, tdelta)
++                total_cost += tdelta
++                return_from_call(caller_stack, call_dict, total_cost)
++            else:
++                assert 0, "duh: %d" % what
++
++
++        # I have no idea, why sometimes the stack is not empty - we
++        # have to rewind the stack to get 100% for the root_caller
++        while caller_stack.size() > 1:
++            return_from_call(caller_stack, call_dict, total_cost)
++
++    except IOError:
++        print "could not open inputfile '%s', ignore this." % inputfilename
++    except EOFError, m:
++        print "EOF: %s" % (m,)
++    return total_cost
++
++def pretty_name(file, function):
++    #pfile = os.path.splitext(os.path.basename(file)) [0]
++    #return "%s_[%s]" % (function, file)
++    return "%s" % function
++    #return "%s::%s" % (file, function)
++    #return "%s_%s" % (pfile, function)
++
++class TagWriter:
++    def __init__(self, output):
++        self.output = output
++        self.last_values = {}
++
++    def clearTag(self, tag):
++        if self.last_values.has_key(tag):
++            del self.last_values[ tag ]
++    def clear(self):
++        self.last_values = {}
++
++    def write(self, tag, value):
++        self.output.write("%s=%s\n" % (tag, value))
++        #if (not self.last_values.has_key(tag)) or self.last_values[tag] != value:
++        #    self.last_values[ tag ] = value
++        #    self.output.write("%s=%s\n" % (tag, value))
++
++def dumpResults(output, call_dict, total_cost, cost_per_pos, cost_per_function):
++    """write the collected results in the format kdecachegrind
++       could read.
++    """
++    # the intro
++    output.write("events: Tick\n")
++    output.write("summary: %d\n" % total_cost)
++    output.write("cmd: your python script\n")
++    output.write("\n")
++    tagwriter = TagWriter(output)
++
++    # now the costs per line
++    for file in cost_per_pos.keys():
++        func_dict = cost_per_pos[file]
++        for func in func_dict.keys():
++            line_dict = func_dict[func]
++            tagwriter.write("ob", file)
++            tagwriter.write("fn", func)# pretty_name(file, func)) ; output.write("# ^--- 2\n")
++            tagwriter.write("fl", file)
++            for line in line_dict:
++                output.write("%d %d\n" %( line, line_dict[line] ))
++
++    output.write("\n\n")
++    # now the function calls. For each caller all the called
++    # functions and their costs are written.
++    for file in call_dict.keys():
++        per_file_dict = call_dict[file]
++        #print "file %s -> %s" % (file, per_file_dict)
++        for called_x in per_file_dict.keys():
++            #print "called_x:",called_x
++            per_caller_dict = per_file_dict[called_x]
++            #print "called_x %s wird gerufen von: %s" % (called_x, per_caller_dict)
++            for caller_x in per_caller_dict.keys():
++                tagwriter.write("ob", caller_x[0])
++                tagwriter.write("fn", caller_x[2])# pretty_name(caller_x[2], caller_x[0])) ; output.write("# ^--- 1\n")
++                tagwriter.write("fl", caller_x[0])
++                tagwriter.write("cob", file)
++                tagwriter.write("cfn", called_x) #pretty_name(file, called_x))
++                tagwriter.write("cfl", file)
++                cost, count = per_caller_dict[caller_x]
++                #print "called_x:",called_x
++                output.write("calls=%d\n%d %d\n" % (count, caller_x[1], cost))
++                tagwriter.clear()
++                #tagwriter.clearTag("cob")
++                # is it a bug in kdecachegrind, that the "cob=xxx" line has
++                # to be rewritten after a calls entry with costline ?
++                #assert cost <= total_cost, "caller_x: %s, per_caller_dict: %s " % (caller_x, per_caller_dict, )
++                #output.write("calls=%d\n%d %d\n" % (count, caller_x[1], cost))
++                output.write("\n")
++
++def run_without_optparse():
++    """parse the options without optparse, use sys.argv"""
++    if  len(sys.argv) < 4 or sys.argv[1] != "-o" :
++        print "usage: hotshot2cachegrind -o outputfile in1 [in2 [in3 [...]]]"
++        return
++    outputfilename = sys.argv[2]
++    try:
++        output = file(outputfilename, "w")
++        args = sys.argv[3:]
++        convertProfFiles(output, args)
++        output.close()
++    except IOError:
++        print "could not open '%s' for writing." % outputfilename
++
++def run_with_optparse():
++    """parse the options with optparse"""
++
++    global file_limit
++
++    versiontext = "%s version: %s" % ( progname, version.split()[1], )
++    parser = OptionParser(version=versiontext)
++    parser.add_option("-o", "--output",
++      action="store", type="string", dest="outputfilename",
++      help="write output into FILE")
++    parser.add_option("--file-limit",
++      action="store", dest="file_limit", default=0,
++      help="stop after given number of input files")
++    output = sys.stdout
++    close_output = 0
++    (options, args) = parser.parse_args()
++    file_limit = int(options.file_limit)
++    try:
++        if options.outputfilename and options.outputfilename != "-":
++            output = file(options.outputfilename, "w")
++            close_output = 1
++    except IOError:
++        print "could not open '%s' for writing." % options.outputfilename
++    if output:
++        convertProfFiles(output, args)
++        if close_output:
++            output.close()
++
++
++def profile_myself():
++    import hotshot
++    filename = "self.prof"
++    if not os.path.exists(filename):
++        prof = hotshot.Profile(filename, lineevents=1)
++        prof.runcall(run)
++        prof.close()
++    else:
++        print "not profiling myself, since '%s' exists, running normal" % filename
++        run()
++
++# check if optparse is available.
++try:
++    from optparse import OptionParser
++    run = run_with_optparse
++except ImportError:
++    run = run_without_optparse
++
++if __name__ == "__main__":
++    try:
++        run()
++        #profile_myself()
++    except KeyboardInterrupt:
++        sys.exit(1)
+diff --git a/kdecachegrind/converters/memprof2calltree b/kdecachegrind/converters/memprof2calltree
+new file mode 100755
+index 0000000..e82d6e8
+--- /dev/null
++++ b/kdecachegrind/converters/memprof2calltree
+@@ -0,0 +1,38 @@
++#!/usr/bin/perl
++#
++# Convert the memory profiles of memprof to calltree format,
++# loadable with KCachegrind
++#
++# (C) 2004, Josef Weidendorfer
++
++print "events: Allocated\n";
++
++while(<>) {
++  if (/^(\S.*)$/) {
++    $next = 0;
++    print "\nfn=$1\n";
++    next;
++  }
++  if (/^  children:/) {
++    $next = 1; #children
++    next;
++  }
++  if (/^  inherited:/) {
++    $next = 2; #inherited
++    next;
++  }
++  if (/^  total:/) {
++    # ignore, is calculated
++    next;
++  }
++  if (/^  self:\s*(\d+)/) {
++    if ($1 ne "0") {
++      print "0 $1\n";
++    }
++    next;
++  }
++  if (/^\s+(\S.*?):\s*(\d+)$/) {
++    if ($next < 2) { next; }
++    print "cfn=$1\ncalls=0 0\n0 $2\n";
++  }
++}
+diff --git a/kdecachegrind/converters/op2calltree b/kdecachegrind/converters/op2calltree
+new file mode 100755
+index 0000000..ca121a2
+--- /dev/null
++++ b/kdecachegrind/converters/op2calltree
+@@ -0,0 +1,238 @@
++#!/usr/bin/perl
++#
++# Copyright (c) 2004
++# Author: Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++#
++# op2calltree 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, version 2.
++#
++# 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; see the file COPYING.  If not, write to
++# the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++# Boston, MA 02110-1301, USA.
++#
++#
++# Converter from OProfile's output of "opreport -gdf" (v 0.8)
++# into callgrind format.
++#
++# Generate a OProfile report with opreport and flags -gdf
++# and pipe this as standard input into this script.
++# This will generate separate cachegrind files for every application.
++#
++
++
++# parse symbol line. example (with 1 event type, $has_image==0):
++#   308  0.1491  /path/source.c:6 /path/app main
++sub parseSymSpec {
++  $e = 0;
++  while($e < $eventCount) {
++    ($line) = ($line =~ /\d+\s+\S+\s+(.*)/);
++    $e++;
++  }
++  if ($line =~ s/^\(no location information\)\s+//) {
++    $file = "???";
++    $linenr = 0;
++  }
++  else {
++    ($file,$linenr) = ($line =~ s/(\S+?):(\d+)\s+//);
++  }
++  if ($has_image) {
++    if ($line =~ s/^(\S+)\s+//) { $img = $1; }
++  }
++  if ($has_app) {
++    if ($line =~ s/^(\S+)\s+//) { $app = $1; }
++    if (!$has_image) { $img = $app; }
++  }
++  $sym = $line;
++
++  $app =~ s/^.*\///;
++  if ($sym eq "(no symbols)") { $sym = "???"; }
++  $file{$sym} = $file;
++  $linenr{$sym} = $linenr;
++  $app{$sym} = $app;
++  $img{$app,$sym} = $img;
++  $syms{$app}++;
++
++  if ($app ne $oldApp) {
++    $oldApp = $app;
++    print "\n\nApp $app\n";
++  }
++  print " Symbol $sym (Image $img)\n";
++}
++
++
++
++$eventCount = 0;
++$descCount = 0;
++$lnr = 0;
++$has_image = 0;
++$has_app = 0;
++$app = "unnamed";
++$img = "???";
++
++# first loop till first symbol specification
++while(<>) {
++  $lnr++;
++  chomp;
++  if (/^CPU:/) {
++    $desc[$descCount++] = $_;
++    next;
++  }
++  if (/^Counted\s*(\S+)/) {
++    $desc[$descCount++] = $_;
++    $eventCount++;
++    $events[$eventCount] = $1;
++    next;
++  }
++  if (/^(Profiling through timer.*)/) {
++    $desc[$descCount++] = $_;
++    $eventCount++;
++    $events[$eventCount] = "Timer";
++    next;
++  }
++  if (/^vma/) {
++    # title row: adapt to separation options of OProfile
++    if (/image/) { $has_image = 1; }
++    if (/app/) { $has_app = 1; }
++    next;
++  }
++  if (/^([0-9a-fA-F]+)\s*(.*)$/) {
++    $vmaSym = $1;
++    $line = $2;
++    last;
++  }
++}
++
++if ($eventCount == 0) {
++  die "No Events found";
++}
++
++print "Description:\n";
++foreach $d (@desc) { print " $d\n"; }
++print "\n";
++
++print "Events:";
++foreach $e (@events) { print " $e"; }
++print "\n";
++
++parseSymSpec;
++
++while(<>) {
++  $lnr++;
++  if (/^([0-9a-fA-F]+)\s*(.*)$/) {
++    $vmaSym = $1;
++    $line = $2;
++
++    parseSymSpec;
++    next;
++  }
++  if (/^\s+([0-9a-fA-F]+)\s*(.*)$/) {
++
++    $sampleCount{$app,$sym}++;
++    $sc = $sampleCount{$app,$sym};
++
++    $vma{$app,$sym,$sc} = $1;
++    $line = $2;
++
++    $e = 1;
++    while($e <= $eventCount) {
++      ($cost, $line) = ($line =~ /(\d+)\s+\S+\s+(.*)/);
++      $summary{$app,$e} += $cost;
++      $cost{"$app,$sym,$sc,$e"} = $cost;
++      $e++;
++    }
++    if ($line =~ /\(no location information\)/) {
++      $file = "???";
++      $linenr = 0;
++    }
++    else {
++      ($file,$linenr) = ($line =~ /(\S+?):(\d+)/);
++    }
++    $sFile{$app,$sym,$sc} = $file;
++    $linenr{$app,$sym,$sc} = $linenr;
++
++    $file =~ s/^.*\///;
++    print "  Sample $sc: $vma{$app,$sym,$sc} ($file:$linenr):";
++    foreach $e (1 .. $eventCount) { $c = $cost{"$app,$sym,$sc,$e"} ; print " $c"; }
++    print "\n";
++    next;
++  }
++  die "ERROR: Reading line $lnr '$_'\n";
++}
++
++foreach $app (keys %syms) {
++  if ($app eq "") { next; }
++  print "Generating dump for App '$app'...\n";
++
++  $out = "# Generated by op2cg, using OProfile with opreport -gdf\n";
++  $out .= "positions: instr line\n";
++
++  $out .= "events:";
++  foreach $e (@events) { $out .= " $e"; }
++  $out .= "\n";
++
++  $out .= "summary:";
++  foreach $e (1 .. $eventCount) { $out .= " $summary{$app,$e}"; }
++  $out .= "\n\n";
++
++  %fileNum = ();
++  $fileNum = 1;
++  $sf = "";
++
++  $img = "";
++
++  foreach $sym (keys %file) {
++    if ($sampleCount{$app,$sym} eq "") { next; }
++
++    if ($img{$app,$sym} ne $img) {
++      $img = $img{$app,$sym};
++      $out .= "ob=$img\n";
++    }
++
++    $file = $file{$sym};
++    if ($sf ne $file) {
++      if ($fileNum{$file} eq "") {
++	$fileNum{$file} = $fileNum;
++	$out .= "fl=($fileNum) $file\n";
++	$fileNum++;
++      }
++      else {
++	$out .= "fl=($fileNum{$file})\n";
++      }
++      $sf = $file;
++    }
++
++    $out .= "fn=$sym\n";
++    foreach $sc (1 .. $sampleCount{$app,$sym}) {
++      if ($sf ne $sFile{$app,$sym,$sc}) {
++	$sf = $sFile{$app,$sym,$sc};
++	if ($sf eq $file) {
++	  $out .= "fe=($fileNum{$file})\n";
++	}
++	else {
++	  if ($fileNum{$sf} eq "") {
++	    $fileNum{$sf} = $fileNum;
++	    $out .= "fi=($fileNum) $sf\n";
++	    $fileNum++;
++	  }
++	  else {
++	    $out .= "fi=($fileNum{$sf})\n";
++	  }
++	}
++      }
++      $out .= "0x$vma{$app,$sym,$sc} $linenr{$app,$sym,$sc}";
++      foreach $e (1 .. $eventCount) { $c = $cost{"$app,$sym,$sc,$e"} ; $out .= " $c"; }
++      $out .= "\n";
++    }
++  }
++
++  open OUT, ">oprof.out.$app";
++  print OUT $out;
++  close OUT;
++}
+diff --git a/kdecachegrind/converters/pprof2calltree b/kdecachegrind/converters/pprof2calltree
+new file mode 100644
+index 0000000..0e70e1c
+--- /dev/null
++++ b/kdecachegrind/converters/pprof2calltree
+@@ -0,0 +1,218 @@
++#!/usr/bin/env php
++# Redistribution and use in source and binary forms, with or without
++# modification, are permitted provided that the following conditions are met:
++#
++# - Redistributions of source code must retain the above copyright notice,
++# this list of conditions and the following disclaimer.
++#
++# - Redistributions in binary form must reproduce the above copyright
++# notice, this list of conditions and the following disclaimer in the
++# documentation and/or other materials provided with the distribution.
++#
++# - All advertising materials mentioning features or use of this software
++# must display the following acknowledgement: This product includes software
++# developed by OmniTI Computer Consulting.
++#
++# - Neither name of the company nor the names of its contributors may be
++# used to endorse or promote products derived from this software without
++# specific prior written permission.
++#
++# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS `AS IS'' AND ANY
++# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
++# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
++# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
++# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
++# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
++# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
++# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++#
++# Copyright (c) 2004 OmniTI Computer Consulting
++# All rights reserved
++# The following code was written by George Schlossnagle <george@omniti.com>
++# and is provided completely free and without any warranty.
++#
++# This script is designed to convert the pprof output from 
++# APD (http://pecl.php.net/apd/) to one readable by kdecachegrind. To use
++# this script:
++#
++# 1) Install APD.
++# 2) Profile your script with APD accordingto the directions in it's
++#    README file.
++# 3) Take the pprof trace file for your script (pprof.XXXXX.Y) and run it 
++#    through this script as follows:
++#    > pprof2calltree -f pprof.12345.1 
++#    This creates a new file cachegrind.out.12345.1
++# 4) View your trace with pprof2calltree cachegrind.out.12345.1
++
++<?php
++
++require "Console/Getopt.php";
++
++$con = new Console_Getopt;
++$args = $con->readPHPArgv();
++array_shift($args);
++$shortoptions = 'f:';
++$retval = $con->getopt( $args, $shortoptions);
++if(is_object($retval)) {
++	usage();
++}
++foreach ($retval[0] as $kv_array) {
++    $opt[$kv_array[0]] = $kv_array[1];
++}
++if(!$opt['f']) {
++	usage();
++}
++if(!file_exists($opt['f'])) {
++	print "Trace file ${opt['f']} does not exist\n";
++	exit;
++}
++$IN = fopen($opt['f'], "r");
++if(!$IN) {
++	print "Trace file ${opt['f']} could not be opened\n";
++	exit;
++}
++
++$path_parts = pathinfo($opt['f']);
++$outfile = "cachegrind.out.".$path_parts['basename'];
++$OUT = fopen($outfile, "w");
++if(!$OUT) {
++	print "Destination file $outfile could not be opened.\n";
++	exit;
++}
++
++while(($line = fgets($IN)) !== false) {
++	$line = rtrim($line);
++	if($line == "END_HEADER") {
++		break;
++	}
++}
++$tree = array();
++$callstack = array();
++while(($line = fgets($IN)) !== false) {
++	$line = rtrim($line);
++	$args = explode(" ", $line);
++	if($args[0] == '!') {
++		$file_lookup[$args[1]] = $args[2];
++	}
++	else if($args[0] == '&') {
++		$function_lookup[$args[1]] = $args[2];
++		$function_type[$args[1]] = ($args[3] == 2)?"USER":"INTERNAL";
++	}
++	else if($args[0] == '+') {
++		$val = array(function_id => $args[1], 
++		             file_id => $args[2],
++					 line => $args[3], 
++					 cost => 0);
++		array_push($callstack, $val);
++	}
++	else if($args[0] == '-') {
++		// retrieve $called to discard
++		$called = array_pop($callstack);
++		// retrieve $caller for reference
++		$caller = array_pop($callstack);
++		$called_id = $called['function_id'];
++		
++		// Set meta data if not already set'
++		if(!array_key_exists($called_id, $tree)) {
++			$tree[$called_id] = $called;
++			// initialize these to 0
++			$tree[$called_id]['cost_per_line'] = array();
++		}
++		if($caller !== null) {
++			$caller['child_calls']++;
++			$caller_id = $caller['function_id'];
++			if(!array_key_exists($caller_id, $tree)) {
++				$tree[$caller_id] = $caller;
++			}
++			$caller['cost'] += $called['cost'];
++			$tree[$caller_id]['called_funcs'][$tree[$caller_id]['call_counter']++][$called_id][$called['file_id']][$called['line']] += $called['cost'];
++			array_push($callstack, $caller);
++		}
++		if(is_array($called['cost_per_line'])) {
++			foreach($called[cost_per_line] as $file => $lines) {
++				foreach($lines as $line => $cost) {
++					$tree[$called_id]['cost_per_line'][$file][$line] += $cost;
++				}
++			}
++		}
++	}
++	else if($args[0] == '@') {
++		$called = array_pop($callstack);
++		switch(count($args)) {
++			// support new and old-style pprof data
++			case 6:
++				$file = $args[1];
++				$line = $args[2];
++				$real_tm = $args[5];
++				break;
++			case 4:
++				$file = $called['file_id'];
++				$line = $called['line'];
++				$real_tm = $args[3];
++				break;
++				
++		}
++		$called['cost_per_line'][$file][$line] += $real_tm;
++		$called['cost'] += $real_tm;
++		$total_cost += $real_tm;
++		array_push($callstack, $called);
++	}
++}
++
++ob_start();
++print "events: Tick\n";
++print "summary: $total_cost\n";
++printf("cmd: %s\n", $file_lookup[1]);
++print "\n";
++
++foreach($tree as $caller => $data) {
++	$filename = $file_lookup[$data['file_id']]?$file_lookup[$data['file_id']]:"???";
++	printf("ob=%s\n", $function_type[$caller]);
++	printf("fl=%s\n", $filename);
++	printf("fn=%s\n", $function_lookup[$caller]);
++	if(is_array($data['cost_per_line'])) {
++		foreach($data['cost_per_line'] as $file => $lines) {
++			foreach($lines as $line => $cost) {
++				print "$line $cost\n";
++			}
++		}
++	}
++	else if ($data['cost']) {
++		printf("COST %s %s\n", $items['line'], $items['cost']);
++	}
++	else {
++		print_r($items);
++	}
++	if(is_array($data['called_funcs'])) {
++		foreach($data['called_funcs'] as $counter => $items) {
++			foreach($items as $called_id => $costs) {
++				if(is_array($costs)) {
++					printf("cfn=%s\n", $function_lookup[$called_id]);
++					foreach($costs as $file => $lines) {
++						printf("cfi=%s\ncalls=1\n", $file_lookup[$file]);
++						foreach($lines as $line => $cost) {
++							print "$line $cost\n";
++						}
++					}
++				}
++			}
++		}
++	}
++	print "\n";
++}
++print "\ntotals=$total_cost\n";
++$buffer = ob_get_clean();
++print "Writing kdecachegrind compatible output to $outfile\n";
++fwrite($OUT, $buffer);
++
++function usage()
++{
++	print <<<EOD
++pprof2calltree -f <tracefile>
++
++EOD;
++	exit(1);
++}
++?>
+diff --git a/kdecachegrind/pics/Makefile.am b/kdecachegrind/pics/Makefile.am
+new file mode 100644
+index 0000000..f4a3186
+--- /dev/null
++++ b/kdecachegrind/pics/Makefile.am
+@@ -0,0 +1,3 @@
++kdecachegrindicondir = $(kde_datadir)/kdecachegrind/icons
++kdecachegrindicon_ICON = AUTO
++SUBDIRS = hicolor
+diff --git a/kdecachegrind/pics/hicolor/Makefile.am b/kdecachegrind/pics/hicolor/Makefile.am
+new file mode 100644
+index 0000000..068e319
+--- /dev/null
++++ b/kdecachegrind/pics/hicolor/Makefile.am
+@@ -0,0 +1,2 @@
++kdecachegrindicondir = $(kde_datadir)/kdecachegrind/icons
++kdecachegrindicon_ICON = AUTO
+diff --git a/kdecachegrind/pics/hicolor/hi16-action-fromrec.png b/kdecachegrind/pics/hicolor/hi16-action-fromrec.png
+new file mode 100644
+index 0000000..a5cb430
+Binary files /dev/null and b/kdecachegrind/pics/hicolor/hi16-action-fromrec.png differ
+diff --git a/kdecachegrind/pics/hicolor/hi16-action-percent.png b/kdecachegrind/pics/hicolor/hi16-action-percent.png
+new file mode 100644
+index 0000000..7a4ba47
+Binary files /dev/null and b/kdecachegrind/pics/hicolor/hi16-action-percent.png differ
+diff --git a/kdecachegrind/pics/hicolor/hi16-action-recrec.png b/kdecachegrind/pics/hicolor/hi16-action-recrec.png
+new file mode 100644
+index 0000000..ec11bfa
+Binary files /dev/null and b/kdecachegrind/pics/hicolor/hi16-action-recrec.png differ
+diff --git a/kdecachegrind/pics/hicolor/hi16-action-torec.png b/kdecachegrind/pics/hicolor/hi16-action-torec.png
+new file mode 100644
+index 0000000..c092c01
+Binary files /dev/null and b/kdecachegrind/pics/hicolor/hi16-action-torec.png differ
+diff --git a/kdecachegrind/pics/hicolor/hi22-action-percent.png b/kdecachegrind/pics/hicolor/hi22-action-percent.png
+new file mode 100644
+index 0000000..c64a378
+Binary files /dev/null and b/kdecachegrind/pics/hicolor/hi22-action-percent.png differ
+diff --git a/kdecachegrind/pics/hicolor/hi32-action-percent.png b/kdecachegrind/pics/hicolor/hi32-action-percent.png
+new file mode 100644
+index 0000000..e876c30
+Binary files /dev/null and b/kdecachegrind/pics/hicolor/hi32-action-percent.png differ
+diff --git a/kdecachegrind/kdecachegrind.lsm.in b/kdecachegrind/kdecachegrind.lsm.in
+new file mode 100644
+index 0000000..fab7ced
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind.lsm.in
+@@ -0,0 +1,11 @@
++Begin3
++Title:          kdecachegrind
++Version:        @KCACHEGRIND_VERSION@
++Description:    KDE Profiling Visualisation Tool
++Keywords:       Profiling, Performance Analysis, Visualisation, Development
++Author:         Josef Weidendorfer <Josef.Weidendorfer@gmx.de> 
++Maintained-by:  Josef Weidendorfer <Josef.Weidendorfer@gmx.de> 
++Home-page:      http://kcachegrind.sourceforge.net
++Platforms:      Linux and other Unices
++Copying-policy: GNU Public License
++End
+diff --git a/kdecachegrind/kdecachegrind.spec.in b/kdecachegrind/kdecachegrind.spec.in
+new file mode 100644
+index 0000000..42b3e24
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind.spec.in
+@@ -0,0 +1,55 @@
++Summary:   KDE Profiling Visualisation Tool
++Name:      kdecachegrind
++Version:   @KCACHEGRIND_VERSION@
++Release:   1
++Copyright: GPL
++Group:     Development/Tools
++Vendor:    (none)
++URL:       http://kcachegrind.sourceforge.net
++Packager:  Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++Source:    kdecachegrind-@KCACHEGRIND_VERSION@.tar.gz
++BuildRoot: /var/tmp/build
++
++%description
++KCachegrind is a GPL'd tool for quick browsing in and visualisation
++of performance data of an application run. This data is produced by
++profiling tools and typically includes distribution of cost events
++to source code ranges (instructions, source lines, functions, C++ classes)
++and call relationship of functions.
++KCachegrind has a list of functions sorted according to different cost
++types, and can provide various performance views for a function like
++direct/indirect callers/callees, TreeMap visualisation of cost distribution
++among callees, call graph sectors centered around the function and
++annotated source/assembler.
++Currently, KCachegrind depends on data delivered by the profiling tool
++calltree, powered by the Valgrind runtime instrumentation framework.
++
++%prep
++%setup
++CFLAGS="$RPM_OPT_FLAGS" CXXFLAGS="$RPM_OPT_FLAGS" ./configure \
++                 \
++                $LOCALFLAGS
++%build
++# Setup for parallel builds
++numprocs=`egrep -c ^cpu[0-9]+ /proc/stat || :`
++if [ "$numprocs" = "0" ]; then
++  numprocs=1
++fi
++
++make -j$numprocs
++
++%install
++make install-strip DESTDIR=$RPM_BUILD_ROOT
++
++cd $RPM_BUILD_ROOT
++find . -type d | sed '1,2d;s,^\.,\%attr(-\,root\,root) \%dir ,' > $RPM_BUILD_DIR/file.list.kdecachegrind
++find . -type f | sed 's,^\.,\%attr(-\,root\,root) ,' >> $RPM_BUILD_DIR/file.list.kdecachegrind
++find . -type l | sed 's,^\.,\%attr(-\,root\,root) ,' >> $RPM_BUILD_DIR/file.list.kdecachegrind
++
++%clean
++rm -rf $RPM_BUILD_ROOT/*
++rm -rf $RPM_BUILD_DIR/kdecachegrind
++rm -rf ../file.list.kdecachegrind
++
++
++%files -f ../file.list.kdecachegrind
+diff --git a/kdecachegrind/kdecachegrind/Doxyfile b/kdecachegrind/kdecachegrind/Doxyfile
+new file mode 100644
+index 0000000..9d5d050
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/Doxyfile
+@@ -0,0 +1,157 @@
++# Doxygen configuration generated by Doxywizard version 0.1
++#---------------------------------------------------------------------------
++# General configuration options
++#---------------------------------------------------------------------------
++PROJECT_NAME           = kdecachegrind
++PROJECT_NUMBER         = 
++OUTPUT_DIRECTORY       = 
++OUTPUT_LANGUAGE        = English
++EXTRACT_ALL            = YES
++EXTRACT_PRIVATE        = YES
++EXTRACT_STATIC         = YES
++HIDE_UNDOC_MEMBERS     = 
++HIDE_UNDOC_CLASSES     = 
++BRIEF_MEMBER_DESC      = 
++REPEAT_BRIEF           = 
++ALWAYS_DETAILED_SEC    = 
++FULL_PATH_NAMES        = 
++STRIP_FROM_PATH        = 
++INTERNAL_DOCS          = 
++CLASS_DIAGRAMS         = 
++SOURCE_BROWSER         = 
++INLINE_SOURCES         = 
++STRIP_CODE_COMMENTS    = 
++CASE_SENSE_NAMES       = 
++SHORT_NAMES            = 
++HIDE_SCOPE_NAMES       = 
++VERBATIM_HEADERS       = 
++SHOW_INCLUDE_FILES     = 
++JAVADOC_AUTOBRIEF      = 
++INHERIT_DOCS           = 
++INLINE_INFO            = 
++SORT_MEMBER_DOCS       = 
++DISTRIBUTE_GROUP_DOC   = 
++TAB_SIZE               = 
++ENABLED_SECTIONS       = 
++GENERATE_TODOLIST      = 
++GENERATE_TESTLIST      = 
++GENERATE_BUGLIST       = 
++ALIASES                = 
++MAX_INITIALIZER_LINES  = 
++OPTIMIZE_OUTPUT_FOR_C  = 
++SHOW_USED_FILES        = 
++#---------------------------------------------------------------------------
++# configuration options related to warning and progress messages
++#---------------------------------------------------------------------------
++QUIET                  = 
++WARNINGS               = 
++WARN_IF_UNDOCUMENTED   = 
++WARN_FORMAT            = "$file:$line: $text"
++WARN_LOGFILE           = 
++#---------------------------------------------------------------------------
++# configuration options related to the input files
++#---------------------------------------------------------------------------
++INPUT                  = .
++FILE_PATTERNS          = *.cpp \
++                         *.h
++RECURSIVE              = no
++EXCLUDE                = 
++EXCLUDE_PATTERNS       = 
++EXAMPLE_PATH           = 
++EXAMPLE_PATTERNS       = 
++IMAGE_PATH             = 
++INPUT_FILTER           = 
++FILTER_SOURCE_FILES    = 
++#---------------------------------------------------------------------------
++# configuration options related to the alphabetical class index
++#---------------------------------------------------------------------------
++ALPHABETICAL_INDEX     = 
++COLS_IN_ALPHA_INDEX    = 
++IGNORE_PREFIX          = 
++#---------------------------------------------------------------------------
++# configuration options related to the HTML output
++#---------------------------------------------------------------------------
++GENERATE_HTML          = 
++HTML_OUTPUT            = html
++HTML_HEADER            = 
++HTML_FOOTER            = 
++HTML_STYLESHEET        = 
++HTML_ALIGN_MEMBERS     = 
++GENERATE_HTMLHELP      = 
++GENERATE_CHI           = 
++BINARY_TOC             = 
++TOC_EXPAND             = 
++DISABLE_INDEX          = 
++ENUM_VALUES_PER_LINE   = 
++GENERATE_TREEVIEW      = 
++TREEVIEW_WIDTH         = 
++#---------------------------------------------------------------------------
++# configuration options related to the LaTeX output
++#---------------------------------------------------------------------------
++GENERATE_LATEX         = NO
++LATEX_OUTPUT           = latex
++COMPACT_LATEX          = 
++PAPER_TYPE             = a4wide
++EXTRA_PACKAGES         = 
++LATEX_HEADER           = 
++PDF_HYPERLINKS         = 
++USE_PDFLATEX           = 
++LATEX_BATCHMODE        = 
++#---------------------------------------------------------------------------
++# configuration options related to the RTF output
++#---------------------------------------------------------------------------
++GENERATE_RTF           = NO
++RTF_OUTPUT             = rtf
++COMPACT_RTF            = 
++RTF_HYPERLINKS         = 
++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              = 
++#---------------------------------------------------------------------------
++# Configuration options related to the preprocessor   
++#---------------------------------------------------------------------------
++ENABLE_PREPROCESSING   = 
++MACRO_EXPANSION        = 
++EXPAND_ONLY_PREDEF     = 
++SEARCH_INCLUDES        = 
++INCLUDE_PATH           = 
++INCLUDE_FILE_PATTERNS  = 
++PREDEFINED             = 
++EXPAND_AS_DEFINED      = 
++#---------------------------------------------------------------------------
++# Configuration::addtions related to external references   
++#---------------------------------------------------------------------------
++TAGFILES               = 
++GENERATE_TAGFILE       = 
++ALLEXTERNALS           = 
++PERL_PATH              = /usr/bin/perl
++#---------------------------------------------------------------------------
++# Configuration options related to the dot tool   
++#---------------------------------------------------------------------------
++HAVE_DOT               = 
++CLASS_GRAPH            = 
++COLLABORATION_GRAPH    = 
++INCLUDE_GRAPH          = 
++INCLUDED_BY_GRAPH      = 
++GRAPHICAL_HIERARCHY    = 
++DOT_PATH               = 
++MAX_DOT_GRAPH_WIDTH    = 
++MAX_DOT_GRAPH_HEIGHT   = 
++GENERATE_LEGEND        = 
++DOT_CLEANUP            = 
++#---------------------------------------------------------------------------
++# Configuration::addtions related to the search engine   
++#---------------------------------------------------------------------------
++SEARCHENGINE           = 
++CGI_NAME               = search.cgi
++CGI_URL                = 
++DOC_URL                = 
++DOC_ABSPATH            = 
++BIN_ABSPATH            = /usr/local/bin/
++EXT_DOC_PATHS          = 
+diff --git a/kdecachegrind/kdecachegrind/Makefile.am b/kdecachegrind/kdecachegrind/Makefile.am
+new file mode 100644
+index 0000000..53cd35d
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/Makefile.am
+@@ -0,0 +1,62 @@
++bin_PROGRAMS = kdecachegrind
++
++kdecachegrind_SOURCES = \
++ functionselectionbase.ui \
++ stackselectionbase.ui \
++ partselectionbase.ui \
++ configdlgbase.ui \
++ loader.cpp cachegrindloader.cpp treemap.cpp pool.cpp \
++ main.cpp configuration.cpp \
++ functionselection.cpp coverage.cpp partgraph.cpp \
++ toplevel.cpp stackselection.cpp stackbrowser.cpp \
++ subcost.cpp tracedata.cpp partselection.cpp configdlg.cpp \
++ utils.cpp fixcost.cpp \
++ traceitemview.cpp instrview.cpp tabview.cpp \
++ sourceview.cpp callmapview.cpp callview.cpp \
++ coverageview.cpp costtypeview.cpp partview.cpp \
++ listutils.cpp costtypeitem.cpp multiview.cpp \
++ callitem.cpp coverageitem.cpp sourceitem.cpp \
++ costlistitem.cpp partlistitem.cpp functionitem.cpp \
++ instritem.cpp stackitem.cpp callgraphview.cpp
++
++kdecachegrind_COMPILE_FIRST = ../version.h
++
++kdecachegrind_LDADD   =  $(LIB_KIO)
++
++KDE_ICON = AUTO
++
++xdg_apps_DATA = kdecachegrind.desktop
++
++mimeapplicationdir = $(kde_mimedir)/application
++mimeapplication_DATA = x-kcachegrind.desktop
++
++EXTRA_DIST =              \
++ kdecachegrind.desktop      \
++ x-kcachegrind.desktop    \
++ hi32-app-kcachegrind.png \
++ hi48-app-kcachegrind.png \
++ Doxyfile                 \
++ kdecachegrindui.rc
++
++# set the include path for X, qt and KDE
++INCLUDES= $(all_includes)
++
++METASOURCES = AUTO
++
++# the library search path. 
++kdecachegrind_LDFLAGS = $(all_libraries) $(KDE_RPATH) $(LIB_QT) -lDCOP $(LIB_KDECORE) $(LIB_KDEUI) -lkdefx $(LIB_KIO) -lktexteditor
++
++rcdir = $(kde_datadir)/kdecachegrind
++rc_DATA = kdecachegrindui.rc
++
++tipdir = $(kde_datadir)/kdecachegrind
++tip_DATA = tips
++
++messages: rc.cpp
++	$(PREPARETIPS) > tips.txt
++	LIST=`find . -name \*.h -o -name \*.cpp -o -name \*.txt`; \
++	if test -n "$$LIST"; then \
++	 $(XGETTEXT) $$LIST -o $(podir)/kdecachegrind.pot; \
++	fi
++	rm -f tips.txt
++
+diff --git a/kdecachegrind/kdecachegrind/cachegrindloader.cpp b/kdecachegrind/kdecachegrind/cachegrindloader.cpp
+new file mode 100644
+index 0000000..4fe57d3
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/cachegrindloader.cpp
+@@ -0,0 +1,1323 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++#include <errno.h>
++
++#include <tqfile.h>
++#include <tqcstring.h>
++
++#include <klocale.h>
++#include <kdebug.h>
++
++#include "loader.h"
++#include "tracedata.h"
++#include "utils.h"
++#include "fixcost.h"
++
++
++#define TRACE_LOADER 0
++
++/*
++ * Loader for Callgrind Profile data (format based on Cachegrind format).
++ * See Callgrind documentation for the file format.
++ */
++
++class CachegrindLoader: public Loader
++{
++public:
++  CachegrindLoader();
++  
++  bool canLoadTrace(TQFile* file);  
++  bool loadTrace(TracePart*);
++  bool isPartOfTrace(TQString file, TraceData*);
++  
++private:
++  bool loadTraceInternal(TracePart*);
++
++  enum lineType { SelfCost, CallCost, BoringJump, CondJump };
++  
++  bool parsePosition(FixString& s, PositionSpec& newPos);
++
++  // position setters
++  void clearPosition();
++  void ensureObject();
++  void ensureFile();
++  void ensureFunction();
++  void setObject(const TQString&);
++  void setCalledObject(const TQString&);
++  void setFile(const TQString&);
++  void setCalledFile(const TQString&);
++  void setFunction(const TQString&);
++  void setCalledFunction(const TQString&);
++
++  TQString _emptyString;
++  
++  // current line in file to read in
++  TQString _filename;
++  int _lineNo;
++
++  TraceSubMapping* subMapping;
++  TraceData* _data;
++  TracePart* _part;
++
++  // current position
++  lineType nextLineType;
++  bool hasLineInfo, hasAddrInfo;
++  PositionSpec currentPos;
++  
++    // current function/line
++  TraceObject* currentObject;
++  TracePartObject* currentPartObject;
++  TraceFile* currentFile;
++  TracePartFile* currentPartFile;
++  TraceFunction* currentFunction;
++  TracePartFunction* currentPartFunction;
++  TraceFunctionSource* currentFunctionSource;
++  TraceInstr* currentInstr;
++  TracePartInstr* currentPartInstr;
++  TraceLine* currentLine;
++  TracePartLine* currentPartLine;
++
++  // current call
++  TraceObject* currentCalledObject;
++  TracePartObject* currentCalledPartObject;
++  TraceFile* currentCalledFile;
++  TracePartFile* currentCalledPartFile;
++  TraceFunction* currentCalledFunction;
++  TracePartFunction* currentCalledPartFunction;
++  SubCost currentCallCount;
++  
++  // current jump
++  TraceFile* currentJumpToFile;
++  TraceFunction* currentJumpToFunction;
++  PositionSpec targetPos;
++  SubCost jumpsFollowed, jumpsExecuted;
++  
++  /** Support for compressed string format
++   * This uses the following string compression model
++   * for objects, files, functions:
++   * If the name matches
++   *   "(<Integer>) Name": this is a compression specification,
++   *                       mapping the integer number to Name and using Name.
++   *   "(<Integer>)"     : this is a compression reference.
++   *                       Assumes previous compression specification of the
++   *                       integer number to a name, uses this name.
++   *   "Name"            : Regular name
++   */
++  void clearCompression();
++  const TQString& checkUnknown(const TQString& n);
++  TraceObject* compressedObject(const TQString& name);
++  TraceFile* compressedFile(const TQString& name);
++  TraceFunction* compressedFunction(const TQString& name,
++                                    TraceFile*, TraceObject*);
++
++  TQPtrVector<TraceCostItem> _objectVector, _fileVector, _functionVector;
++};
++
++
++
++/**********************************************************
++ * Loader
++ */
++
++
++CachegrindLoader::CachegrindLoader()
++  : Loader("Callgrind",
++           i18n( "Import filter for Cachegrind/Callgrind generated profile data files") )
++{
++    _emptyString = TQString("");
++}
++
++bool CachegrindLoader::canLoadTrace(TQFile* file)
++{
++  if (!file) return false;
++
++  if (!file->isOpen()) {
++    if (!file->open( IO_ReadOnly ) ) {
++      kdDebug() << TQFile::encodeName(_filename).data() << ": "
++		<< strerror( errno ) << endl;
++      return false;
++    }
++  }
++
++  /* 
++   * We recognize this as cachegrind/callgrind format if in the first
++   * 2047 bytes we see the string "\nevents:"
++   */
++  char buf[2048];
++  int read = file->readBlock(buf,2047);
++  if (read < 0)
++	return false;
++  buf[read] = 0;
++
++  TQCString s;
++  s.setRawData(buf, read+1);
++  int pos = s.find("events:");
++  if (pos>0 && buf[pos-1] != '\n') pos = -1;
++  s.resetRawData(buf, read+1);
++  return (pos>=0);
++}
++
++bool CachegrindLoader::loadTrace(TracePart* p)
++{
++  /* do the loading in a new object so parallel load
++   * operations do not interfere each other.
++   */
++  CachegrindLoader l;
++
++  /* emit progress signals via the singleton loader */
++  connect(&l, TQT_SIGNAL(updateStatus(TQString, int)),
++	  this, TQT_SIGNAL(updateStatus(TQString, int)));
++
++  return l.loadTraceInternal(p);
++}
++
++Loader* createCachegrindLoader()
++{
++  return new CachegrindLoader();
++}
++
++
++
++/**
++ * Return false if this is no position specification
++ */
++bool CachegrindLoader::parsePosition(FixString& line,
++				     PositionSpec& newPos)
++{
++    char c;
++    uint diff;
++
++    if (hasAddrInfo) {
++      
++      if (!line.first(c)) return false;
++
++      if (c == '*') {
++	// nothing changed
++	line.stripFirst(c);
++	newPos.fromAddr = currentPos.fromAddr;
++	newPos.toAddr = currentPos.toAddr;
++      }
++      else if (c == '+') {
++	line.stripFirst(c);
++	line.stripUInt(diff, false);
++	newPos.fromAddr = currentPos.fromAddr + diff;
++	newPos.toAddr = newPos.fromAddr;
++      }
++      else if (c == '-') {
++	line.stripFirst(c);
++	line.stripUInt(diff, false);
++	newPos.fromAddr = currentPos.fromAddr - diff;
++	newPos.toAddr = newPos.fromAddr;
++      }
++      else if (c >= '0') {
++	uint64 v;
++	line.stripUInt64(v, false);
++	newPos.fromAddr = Addr(v);
++	newPos.toAddr = newPos.fromAddr;
++      }
++      else return false;
++
++      // Range specification
++      if (line.first(c)) {
++	if (c == '+') {
++	  line.stripFirst(c);
++	  line.stripUInt(diff);
++	  newPos.toAddr = newPos.fromAddr + diff;
++	}
++	else if ((c == '-') || (c == ':')) {
++	  line.stripFirst(c);
++	  uint64 v;
++	  line.stripUInt64(v);
++	  newPos.toAddr = Addr(v);
++	}
++      }
++      line.stripSpaces();
++
++#if TRACE_LOADER
++      if (newPos.fromAddr == newPos.toAddr)
++	kdDebug() << " Got Addr " << newPos.fromAddr.toString() << endl;
++      else
++	kdDebug() << " Got AddrRange " << newPos.fromAddr.toString()
++		  << ":" << newPos.toAddr.toString() << endl;
++#endif
++
++    }
++    
++    if (hasLineInfo) {
++
++      if (!line.first(c)) return false;
++
++      if (c > '9') return false;
++      else if (c == '*') {
++	// nothing changed
++	line.stripFirst(c);
++	newPos.fromLine = currentPos.fromLine;
++	newPos.toLine   = currentPos.toLine;
++      }
++      else if (c == '+') {
++	line.stripFirst(c);
++	line.stripUInt(diff, false);
++	newPos.fromLine = currentPos.fromLine + diff;
++	newPos.toLine = newPos.fromLine;
++      }
++      else if (c == '-') {
++	line.stripFirst(c);
++	line.stripUInt(diff, false);
++	if (currentPos.fromLine < diff) {
++	    kdError() << _filename << ":" << _lineNo
++		      << " - Negative line number "
++		      << (int)currentPos.fromLine - (int)diff << endl;
++	  diff = currentPos.fromLine;
++	}
++	newPos.fromLine = currentPos.fromLine - diff;
++	newPos.toLine = newPos.fromLine;
++      }
++      else if (c >= '0') {
++	line.stripUInt(newPos.fromLine, false);
++	newPos.toLine = newPos.fromLine;
++      }
++      else return false;
++
++      // Range specification
++      if (line.first(c)) {
++	if (c == '+') {
++	  line.stripFirst(c);
++	  line.stripUInt(diff);
++	  newPos.toLine = newPos.fromLine + diff;
++	}
++	else if ((c == '-') || (c == ':')) {
++	  line.stripFirst(c);
++	  line.stripUInt(newPos.toLine);
++	}
++      }
++      line.stripSpaces();
++
++#if TRACE_LOADER
++      if (newPos.fromLine == newPos.toLine)
++	kdDebug() << " Got Line " << newPos.fromLine << endl;
++      else
++	kdDebug() << " Got LineRange " << newPos.fromLine
++		  << ":" << newPos.toLine << endl;
++#endif
++
++    }
++
++    return true;
++}
++
++// Support for compressed strings
++void CachegrindLoader::clearCompression()
++{
++  // this doesn't delete previous contained objects
++  _objectVector.clear();
++  _fileVector.clear();
++  _functionVector.clear();
++
++  // reset to reasonable init size. We double lengths if needed.
++  _objectVector.resize(100);
++  _fileVector.resize(1000);
++  _functionVector.resize(10000);
++}
++
++const TQString& CachegrindLoader::checkUnknown(const TQString& n)
++{
++    if (n == "???") return _emptyString;
++    return n;
++}
++
++TraceObject* CachegrindLoader::compressedObject(const TQString& name)
++{
++  if ((name[0] != '(') || !name[1].isDigit()) return _data->object(checkUnknown(name));
++
++  // compressed format using _objectVector
++  int p = name.find(')');
++  if (p<2) {
++      kdError() << _filename << ":" << _lineNo
++		<< " - Invalid compressed ELF object ('" 
++		<< name << "')" << endl;
++    return 0;
++  }
++  unsigned index = name.mid(1, p-1).toInt();
++  TraceObject* o = 0;
++  p++;
++  if ((int)name.length()>p) {
++    while(name.at(p).isSpace()) p++;
++
++    if (_objectVector.size() <= index) {
++      int newSize = index * 2;
++#if TRACE_LOADER
++      kdDebug() << " CachegrindLoader: objectVector enlarged to "
++		<< newSize << endl;
++#endif
++      _objectVector.resize(newSize);
++    }
++
++    TQString realName = checkUnknown(name.mid(p));
++    o = (TraceObject*) _objectVector.at(index);
++    if (o && (o->name() != realName)) {
++	kdError() << _filename << ":" << _lineNo
++		  << " - Redefinition of compressed ELF object index " << index
++		  << " (was '" << o->name()
++		  << "') to '" << realName << "'" << endl;
++    }
++
++    o = _data->object(realName);
++    _objectVector.insert(index, o);
++  }
++  else {
++    if ((_objectVector.size() <= index) ||
++	( (o=(TraceObject*)_objectVector.at(index)) == 0)) {
++	kdError() << _filename << ":" << _lineNo
++		  << " - Undefined compressed ELF object index " << index << endl;
++      return 0;
++    }    
++  }
++
++  return o;
++}
++
++
++// Note: Callgrind sometimes gives different IDs for same file
++// (when references to same source file come from different ELF objects)
++TraceFile* CachegrindLoader::compressedFile(const TQString& name)
++{
++  if ((name[0] != '(') || !name[1].isDigit()) return _data->file(checkUnknown(name));
++
++  // compressed format using _fileVector
++  int p = name.find(')');
++  if (p<2) {
++      kdError() << _filename << ":" << _lineNo
++		<< " - Invalid compressed file ('" 
++		<< name << "')" << endl;
++    return 0;
++  }
++  unsigned int index = name.mid(1, p-1).toUInt();
++  TraceFile* f = 0;
++  p++;
++  if ((int)name.length()>p) {
++    while(name.at(p).isSpace()) p++;
++
++    if (_fileVector.size() <= index) {
++      int newSize = index * 2;
++#if TRACE_LOADER
++      kdDebug() << " CachegrindLoader::fileVector enlarged to "
++		<< newSize << endl;
++#endif
++      _fileVector.resize(newSize);
++    }
++
++    TQString realName = checkUnknown(name.mid(p));
++    f = (TraceFile*) _fileVector.at(index);
++    if (f && (f->name() != realName)) {
++	kdError() << _filename << ":" << _lineNo
++		  << " - Redefinition of compressed file index " << index
++		  << " (was '" << f->name()
++		  << "') to '" << realName << "'" << endl;
++    }
++
++    f = _data->file(realName);
++    _fileVector.insert(index, f);
++  }
++  else {
++    if ((_fileVector.size() <= index) ||
++	( (f=(TraceFile*)_fileVector.at(index)) == 0)) {
++	kdError() << _filename << ":" << _lineNo
++		  << " - Undefined compressed file index " << index << endl;
++      return 0;
++    }
++  }
++
++  return f;
++}
++
++// Note: Callgrind gives different IDs even for same function
++// when parts of the function are from different source files.
++// Thus, it is no error when multiple indexes map to same function.
++TraceFunction* CachegrindLoader::compressedFunction(const TQString& name,
++						    TraceFile* file,
++						    TraceObject* object)
++{
++  if ((name[0] != '(') || !name[1].isDigit())
++    return _data->function(checkUnknown(name), file, object);
++
++  // compressed format using _functionVector
++  int p = name.find(')');
++  if (p<2) {
++      kdError() << _filename << ":" << _lineNo
++		<< " - Invalid compressed function ('" 
++		<< name << "')" << endl;
++    return 0;
++  }
++
++
++  unsigned int index = name.mid(1, p-1).toUInt();
++  TraceFunction* f = 0;
++  p++;
++  if ((int)name.length()>p) {
++    while(name.at(p).isSpace()) p++;
++
++    if (_functionVector.size() <= index) {
++      int newSize = index * 2;
++#if TRACE_LOADER
++      kdDebug() << " CachegrindLoader::functionVector enlarged to "
++		<< newSize << endl;
++#endif
++      _functionVector.resize(newSize);
++    }
++
++    TQString realName = checkUnknown(name.mid(p));
++    f = (TraceFunction*) _functionVector.at(index);
++    if (f && (f->name() != realName)) {
++	    kdError() << _filename << ":" << _lineNo
++		      << " - Redefinition of compressed function index " << index
++		      << " (was '" << f->name()
++		      << "') to '" << realName << "'" << endl;
++    }
++
++    f = _data->function(realName, file, object);
++    _functionVector.insert(index, f);
++
++#if TRACE_LOADER
++    kdDebug() << "compressedFunction: Inserted at Index " << index
++	      << "\n  " << f->fullName()
++	      << "\n  in " << f->cls()->fullName()
++	      << "\n  in " << f->file()->fullName()
++	      << "\n  in " << f->object()->fullName() << endl;
++#endif
++  }
++  else {
++    if ((_functionVector.size() <= index) ||
++	( (f=(TraceFunction*)_functionVector.at(index)) == 0)) {
++	    kdError() << _filename << ":" << _lineNo
++		      << " - Undefined compressed function index " 
++		      << index << endl;
++      return 0;
++    }
++
++    // there was a check if the used function (returned from KCachegrinds
++    // model) has the same object and file as here given to us, but that was wrong:
++    // that holds only if we make this assumption on the model...
++  }
++
++  return f;
++}
++
++
++// make sure that a valid object is set, at least dummy with empty name
++void CachegrindLoader::ensureObject()
++{
++  if (currentObject) return;
++
++  currentObject = _data->object(_emptyString);
++  currentPartObject = currentObject->partObject(_part);
++}
++
++void CachegrindLoader::setObject(const TQString& name)
++{
++  currentObject = compressedObject(name);
++  if (!currentObject) {
++    kdError() << _filename << ":" << _lineNo
++	      << " - Invalid object specification, setting to unknown" << endl;
++
++    currentObject = _data->object(_emptyString);
++  }
++
++  currentPartObject = currentObject->partObject(_part);
++  currentFunction = 0;
++  currentPartFunction = 0;
++}
++
++void CachegrindLoader::setCalledObject(const TQString& name)
++{
++  currentCalledObject = compressedObject(name);
++
++  if (!currentCalledObject) {
++    kdError() << _filename << ":" << _lineNo
++	      << " - Invalid called specification, setting to unknown" << endl;
++
++    currentCalledObject = _data->object(_emptyString);
++  }
++
++  currentCalledPartObject = currentCalledObject->partObject(_part);
++}
++
++
++// make sure that a valid file is set, at least dummy with empty name
++void CachegrindLoader::ensureFile()
++{
++  if (currentFile) return;
++
++  currentFile = _data->file(_emptyString);
++  currentPartFile = currentFile->partFile(_part);
++}
++
++void CachegrindLoader::setFile(const TQString& name)
++{
++  currentFile = compressedFile(name);
++
++  if (!currentFile) {
++    kdWarning() << _filename << ":" << _lineNo
++		<< " - Invalid file specification, setting to unknown" << endl;
++
++    currentFile = _data->file(_emptyString);
++  }
++
++  currentPartFile = currentFile->partFile(_part);
++  currentLine = 0;
++  currentPartLine = 0;
++}
++
++void CachegrindLoader::setCalledFile(const TQString& name)
++{
++  currentCalledFile = compressedFile(name);
++
++  if (!currentCalledFile) {
++    kdError() << _filename << ":" << _lineNo
++	      << " - Invalid called file specification, setting to unknown" << endl;
++
++    currentCalledFile = _data->file(_emptyString);
++  }
++
++  currentCalledPartFile = currentCalledFile->partFile(_part);
++}
++
++// make sure that a valid function is set, at least dummy with empty name
++void CachegrindLoader::ensureFunction()
++{
++  if (currentFunction) return;
++
++  kdWarning() << _filename << ":" << _lineNo
++	      << " - Function name not set" << endl;
++
++  ensureFile();
++  ensureObject();
++
++  currentFunction = _data->function(_emptyString,
++				    currentFile,
++				    currentObject);
++  currentPartFunction = currentFunction->partFunction(_part,
++						      currentPartFile,
++						      currentPartObject);
++}
++
++void CachegrindLoader::setFunction(const TQString& name)
++{
++  ensureFile();
++  ensureObject();
++  
++  currentFunction = compressedFunction( name,
++					currentFile,
++					currentObject);
++
++  if (!currentFunction) {
++    kdWarning() << _filename << ":" << _lineNo
++		<< " - Invalid function, setting to unknown" << endl;
++
++    currentFunction = _data->function(_emptyString,
++				      currentFile,
++				      currentObject);
++  }
++
++  currentPartFunction = currentFunction->partFunction(_part,
++						      currentPartFile,
++						      currentPartObject);
++
++  currentFunctionSource = 0;
++  currentLine = 0;
++  currentPartLine = 0;
++}
++
++void CachegrindLoader::setCalledFunction(const TQString& name)
++{
++  // if called object/file not set, use current object/file
++  if (!currentCalledObject) {
++    currentCalledObject = currentObject;
++    currentCalledPartObject = currentPartObject;
++  }
++
++  if (!currentCalledFile) {
++    // !=0 as functions needs file
++    currentCalledFile = currentFile;
++    currentCalledPartFile = currentPartFile;
++  }
++
++  currentCalledFunction = compressedFunction(name,
++					     currentCalledFile,
++					     currentCalledObject);
++  if (!currentCalledFunction) {
++    kdWarning() << _filename << ":" << _lineNo
++		<< " - Invalid called function, setting to unknown" << endl;
++
++    currentCalledFunction = _data->function(_emptyString,
++					    currentCalledFile,
++					    currentCalledObject);
++  }
++
++  currentCalledPartFunction =
++    currentCalledFunction->partFunction(_part,
++					currentCalledPartFile,
++					currentCalledPartObject);
++}
++
++
++void CachegrindLoader::clearPosition()
++{
++  currentPos = PositionSpec();
++
++  // current function/line
++  currentFunction = 0;
++  currentPartFunction = 0;
++  currentFunctionSource = 0;
++  currentFile = 0;
++  currentPartFile = 0;
++  currentObject = 0;
++  currentPartObject = 0;
++  currentLine = 0;
++  currentPartLine = 0;
++  currentInstr = 0;
++  currentPartInstr = 0;
++
++  // current call
++  currentCalledObject = 0;
++  currentCalledPartObject = 0;
++  currentCalledFile = 0;
++  currentCalledPartFile = 0;
++  currentCalledFunction = 0;
++  currentCalledPartFunction = 0;
++  currentCallCount = 0;
++
++  // current jump
++  currentJumpToFile = 0;
++  currentJumpToFunction = 0;
++  targetPos = PositionSpec();
++  jumpsFollowed = 0;
++  jumpsExecuted = 0;
++
++  subMapping = 0;
++}
++
++
++/**
++ * The main import function...
++ */
++bool CachegrindLoader::loadTraceInternal(TracePart* part)
++{
++  clearCompression();
++  clearPosition();
++
++  _part     = part;
++  _data     = part->data();
++  TQFile* pFile = part->file();
++
++  if (!pFile) return false;
++    
++  _filename = pFile->name();
++
++  FixFile file(pFile);
++  if (!file.exists()) {
++    kdError() << "File doesn't exist\n" << endl;
++    return false;
++  }
++  kdDebug() << "Loading " << _filename << " ..." << endl;
++  TQString statusMsg = i18n("Loading %1").arg(_filename);
++  int statusProgress = 0;
++  emit updateStatus(statusMsg,statusProgress);
++
++
++#if USE_FIXCOST
++  // FixCost Memory Pool
++  FixPool* pool = _data->fixPool();
++#endif
++
++  _lineNo = 0;
++  FixString line;
++  char c;
++  bool totalsSet = false;
++
++  // current position
++  nextLineType  = SelfCost;
++  // default if there's no "positions:" line
++  hasLineInfo = true;
++  hasAddrInfo = false;
++
++  while (file.nextLine(line)) {
++
++      _lineNo++;
++
++#if TRACE_LOADER
++      kdDebug() << "[CachegrindLoader] " << _filename << ":" << _lineNo
++		<< " - '" << TQString(line) << "'" << endl;
++#endif
++
++      // if we cannot strip a character, this was an empty line
++      if (!line.first(c)) continue;
++
++      if (c <= '9') {
++
++	  if (c == '#') continue;
++
++	  // parse position(s)
++	  if (!parsePosition(line, currentPos)) {
++	      kdError() << _filename << ":" << _lineNo
++			<< " - Invalid position specification ('"
++			<< TQString(line) << "')" << endl;
++	      continue;
++	  }
++
++	  // go through after big switch
++      }
++      else { // if (c > '9')
++
++	line.stripFirst(c);
++
++	/* in order of probability */
++	switch(c) {
++
++	case 'f':
++
++	    // fl=, fi=, fe=
++	    if (line.stripPrefix("l=") ||
++		line.stripPrefix("i=") ||
++		line.stripPrefix("e=")) {
++
++	      setFile(line);
++	      continue;
++	    }
++
++	    // fn=
++	    if (line.stripPrefix("n=")) {
++
++	      setFunction(line);
++
++	      // on a new function, update status
++	      int progress = (int)(100.0 * file.current() / file.len() +.5);
++	      if (progress != statusProgress) {
++		statusProgress = progress;
++
++		/* When this signal is connected, it most probably
++		 * should lead to GUI update. Thus, when multiple
++		 * "long operations" (like file loading) are in progress,
++		 * this can temporarly switch to another operation.
++		 */
++		emit updateStatus(statusMsg,statusProgress);
++	      }
++
++	      continue;
++	    }
++
++	    break;
++
++	case 'c':
++	    // cob=
++	    if (line.stripPrefix("ob=")) {
++	      setCalledObject(line);
++	      continue;
++	    }
++
++	    // cfi= / cfl=
++	    if (line.stripPrefix("fl=") ||
++		line.stripPrefix("fi=")) {
++	      setCalledFile(line);
++	      continue;
++	    }
++
++	    // cfn=
++	    if (line.stripPrefix("fn=")) {
++
++	      setCalledFunction(line);
++	      continue;
++	    }
++
++	    // calls=
++	    if (line.stripPrefix("alls=")) {
++		// ignore long lines...
++		line.stripUInt64(currentCallCount);
++		nextLineType = CallCost;
++		continue;
++	    }
++
++	    // cmd:
++	    if (line.stripPrefix("md:")) {
++		TQString command = TQString(line).stripWhiteSpace();
++		if (!_data->command().isEmpty() &&
++		    _data->command() != command) {
++
++		  kdWarning() << _filename << ":" << _lineNo
++			      << " - Redefined command, was '"
++			      << _data->command()
++			      << "'" << endl;
++		}
++		_data->setCommand(command);
++		continue;
++	    }
++
++	    // creator:
++	    if (line.stripPrefix("reator:")) {
++		// ignore ...
++	        continue;
++	    }
++
++	    break;
++
++	case 'j':
++
++	    // jcnd=
++	    if (line.stripPrefix("cnd=")) {
++		bool valid;
++
++		valid = line.stripUInt64(jumpsFollowed) &&
++		    line.stripPrefix("/") &&
++		    line.stripUInt64(jumpsExecuted) &&
++		    parsePosition(line, targetPos);
++
++		if (!valid) {
++		  kdError() << _filename << ":" << _lineNo
++			    << " - Invalid jcnd line" << endl;
++		}
++		else
++		    nextLineType = CondJump;
++		continue;
++	    }
++
++	    if (line.stripPrefix("ump=")) {
++		bool valid;
++
++		valid = line.stripUInt64(jumpsExecuted) &&
++		    parsePosition(line, targetPos);
++
++		if (!valid) {
++		  kdError() << _filename << ":" << _lineNo
++			    << " - Invalid jump line" << endl;
++		}
++		else
++		    nextLineType = BoringJump;
++		continue;
++	    }
++
++	    // jfi=
++	    if (line.stripPrefix("fi=")) {
++		currentJumpToFile = compressedFile(line);
++		continue;
++	    }
++
++	    // jfn=
++	    if (line.stripPrefix("fn=")) {
++
++		if (!currentJumpToFile) {
++		    // !=0 as functions needs file
++		    currentJumpToFile = currentFile;
++		}
++
++		currentJumpToFunction =
++		    compressedFunction(line,
++				       currentJumpToFile,
++				       currentObject);
++		continue;
++	    }
++
++	    break;
++
++	case 'o':
++
++	    // ob=
++	    if (line.stripPrefix("b=")) {
++	      setObject(line);
++	      continue;
++	    }
++
++	    break;
++
++	case '#':
++	    continue;
++
++	case 't':
++
++	    // totals:
++	    if (line.stripPrefix("otals:")) continue;
++
++	    // thread:
++	    if (line.stripPrefix("hread:")) {
++		part->setThreadID(TQString(line).toInt());
++		continue;
++	    }
++
++	    // timeframe (BB):
++	    if (line.stripPrefix("imeframe (BB):")) {
++		part->setTimeframe(line);
++		continue;
++	    }
++
++	    break;
++
++	case 'd':
++
++	    // desc:
++	    if (line.stripPrefix("esc:")) {
++
++	      line.stripSurroundingSpaces();
++
++	      // desc: Trigger:
++	      if (line.stripPrefix("Trigger:")) {
++		part->setTrigger(line);
++	      }
++	      
++	      continue;
++	    }
++	    break;
++
++	case 'e':
++
++	    // events:
++	    if (line.stripPrefix("vents:")) {
++		subMapping = _data->mapping()->subMapping(line);
++                part->setFixSubMapping(subMapping);
++		continue;
++	    }
++
++	    // event:<name>[=<formula>][:<long name>]
++	    if (line.stripPrefix("vent:")) {
++	      line.stripSurroundingSpaces();
++
++	      FixString e, f, l;
++	      if (!line.stripName(e)) {
++		kdError() << _filename << ":" << _lineNo
++			  << " - Invalid event" << endl;
++		continue;
++	      }
++	      line.stripSpaces();
++	      if (!line.stripFirst(c)) continue;
++
++	      if (c=='=') f = line.stripUntil(':');
++	      line.stripSpaces();
++
++	      // add to known cost types
++	      if (line.isEmpty()) line = e;
++	      TraceCostType::add(new TraceCostType(e,line,f));
++	      continue;
++	    }
++	    break;
++
++	case 'p':
++
++	    // part:
++	    if (line.stripPrefix("art:")) {
++		part->setPartNumber(TQString(line).toInt());
++		continue;
++	    }
++
++	    // pid:
++	    if (line.stripPrefix("id:")) {
++		part->setProcessID(TQString(line).toInt());
++		continue;
++	    }
++
++	    // positions:
++	    if (line.stripPrefix("ositions:")) {
++		TQString positions(line);
++		hasLineInfo = (positions.find("line")>=0);
++		hasAddrInfo = (positions.find("instr")>=0);
++		continue;
++	    }
++	    break;
++
++	case 'v':
++
++	    // version:
++	    if (line.stripPrefix("ersion:")) {
++		part->setVersion(line);
++		continue;
++	    }
++	    break;
++
++	case 's':
++
++	    // summary:
++	    if (line.stripPrefix("ummary:")) {
++		if (!subMapping) {
++		  kdError() << "No event line found. Skipping '" << _filename << endl;
++		  return false;
++		}
++
++		part->totals()->set(subMapping, line);
++		continue;
++	    }
++
++	case 'r':
++
++	    // rcalls= (deprecated)
++	    if (line.stripPrefix("calls=")) {
++		// handle like normal calls: we need the sum of call count
++		// recursive cost is discarded in cycle detection
++		line.stripUInt64(currentCallCount);
++		nextLineType = CallCost;
++
++		kdDebug() << "WARNING: This trace dump was generated by an old "
++		  "version\n of the call-tree skin. Use a new one!" << endl;
++
++		continue;
++	    }
++	    break;
++
++	default:
++	    break;
++	}
++
++	kdError() << _filename << ":" << _lineNo
++		  << " - Invalid line '" << c << TQString(line) << "'" << endl;
++	continue;
++      }
++
++      if (!subMapping) {
++	kdError() << "No event line found. Skipping '" << _filename << "'" << endl;
++	return false;
++      }
++
++      // for a cost line, we always need a current function
++      ensureFunction();
++
++
++#if USE_FIXCOST
++      if (!currentFunctionSource ||
++	  (currentFunctionSource->file() != currentFile))
++	  currentFunctionSource = currentFunction->sourceFile(currentFile,
++							      true);
++#else
++      if (hasAddrInfo) {
++	  if (!currentInstr ||
++	      (currentInstr->addr() != currentPos.fromAddr)) {
++	      currentInstr = currentFunction->instr(currentPos.fromAddr,
++						    true);
++
++	      if (!currentInstr) {
++		kdError() << _filename << ":" << _lineNo
++			  << " - Invalid address "
++			  << currentPos.fromAddr.toString() << endl;
++
++		continue;
++	      }
++
++	      currentPartInstr = currentInstr->partInstr(part,
++							 currentPartFunction);
++	  }
++      }
++
++      if (hasLineInfo) {
++	  if (!currentLine ||
++	      (currentLine->lineno() != currentPos.fromLine)) {
++	    
++	    currentLine = currentFunction->line(currentFile,
++						currentPos.fromLine,
++						true);
++	    currentPartLine = currentLine->partLine(part,
++						    currentPartFunction);
++	  }
++	  if (hasAddrInfo && currentInstr)
++	      currentInstr->setLine(currentLine);
++      }
++#endif
++
++#if TRACE_LOADER
++      kdDebug() << _filename << ":" << _lineNo
++		<< endl << "  currentInstr "
++		<< (currentInstr ? currentInstr->toString().ascii() : ".")
++		<< endl << "  currentLine "
++		<< (currentLine ? currentLine->toString().ascii() : ".")
++		<< "( file " << currentFile->name() << ")"
++		<< endl << "  currentFunction "
++		<< currentFunction->prettyName().ascii()
++		<< endl << "  currentCalled "
++		<< (currentCalledFunction ? currentCalledFunction->prettyName().ascii() : ".")
++		<< endl;
++#endif
++
++    // create cost item
++
++    if (nextLineType == SelfCost) {
++
++#if USE_FIXCOST
++      new (pool) FixCost(part, pool,
++			 currentFunctionSource,
++			 currentPos,
++                         currentPartFunction,
++                         line);
++#else
++      if (hasAddrInfo) {
++	  TracePartInstr* partInstr;
++	  partInstr = currentInstr->partInstr(part, currentPartFunction);
++
++	  if (hasLineInfo) {
++	      // we need to set <line> back after reading for the line
++	      int l = line.len();
++	      const char* s = line.ascii();
++
++	      partInstr->addCost(subMapping, line);
++	      line.set(s,l);
++	  }
++	  else
++	      partInstr->addCost(subMapping, line);
++      }
++
++      if (hasLineInfo) {
++	  TracePartLine* partLine;
++	  partLine = currentLine->partLine(part, currentPartFunction);
++	  partLine->addCost(subMapping, line);
++      }
++#endif
++
++      if (!line.isEmpty()) {
++	kdError() << _filename << ":" << _lineNo
++		  << " - Garbage at end of cost line ('" 
++		  << TQString(line) << "')" << endl;
++      }
++    }
++    else if (nextLineType == CallCost) {
++      nextLineType = SelfCost;
++
++      TraceCall* calling = currentFunction->calling(currentCalledFunction);
++      TracePartCall* partCalling =
++        calling->partCall(part, currentPartFunction,
++                          currentCalledPartFunction);
++
++#if USE_FIXCOST
++      FixCallCost* fcc;
++      fcc = new (pool) FixCallCost(part, pool,
++				   currentFunctionSource,
++				   hasLineInfo ? currentPos.fromLine : 0,
++				   hasAddrInfo ? currentPos.fromAddr : Addr(0),
++				   partCalling,
++				   currentCallCount, line);
++      fcc->setMax(_data->callMax());
++#else
++      if (hasAddrInfo) {
++	  TraceInstrCall* instrCall;
++	  TracePartInstrCall* partInstrCall;
++
++	  instrCall = calling->instrCall(currentInstr);
++	  partInstrCall = instrCall->partInstrCall(part, partCalling);
++	  partInstrCall->addCallCount(currentCallCount);
++
++	  if (hasLineInfo) {
++	      // we need to set <line> back after reading for the line
++	      int l = line.len();
++	      const char* s = line.ascii();
++
++	      partInstrCall->addCost(subMapping, line);
++	      line.set(s,l);
++	  }
++	  else
++	      partInstrCall->addCost(subMapping, line);
++
++	  // update maximum of call cost
++	  _data->callMax()->maxCost(partInstrCall);
++      }
++
++      if (hasLineInfo) {
++	  TraceLineCall* lineCall;
++	  TracePartLineCall* partLineCall;
++
++	  lineCall = calling->lineCall(currentLine);
++	  partLineCall = lineCall->partLineCall(part, partCalling);
++
++	  partLineCall->addCallCount(currentCallCount);
++	  partLineCall->addCost(subMapping, line);
++
++	  // update maximum of call cost
++	  _data->callMax()->maxCost(partLineCall);
++      }
++#endif
++      currentCalledFile = 0;
++      currentCalledPartFile = 0;
++      currentCalledObject = 0;
++      currentCalledPartObject = 0;
++      currentCallCount = 0;
++
++      if (!line.isEmpty()) {
++	kdError() << _filename << ":" << _lineNo
++		  << " - Garbage at end of call cost line ('"
++		  << TQString(line) << "')" << endl;
++      }
++    }
++    else { // (nextLineType == BoringJump || nextLineType == CondJump)
++
++	TraceFunctionSource* targetSource;
++
++	if (!currentJumpToFunction)
++	    currentJumpToFunction = currentFunction;
++
++	targetSource = (currentJumpToFile) ?
++	    currentJumpToFunction->sourceFile(currentJumpToFile, true) :
++	    currentFunctionSource;
++
++#if USE_FIXCOST
++      new (pool) FixJump(part, pool,
++			 /* source */
++			 hasLineInfo ? currentPos.fromLine : 0,
++			 hasAddrInfo ? currentPos.fromAddr : 0,
++			 currentPartFunction,
++			 currentFunctionSource,
++			 /* target */
++			 hasLineInfo ? targetPos.fromLine : 0,
++			 hasAddrInfo ? targetPos.fromAddr : Addr(0),
++			 currentJumpToFunction,
++			 targetSource,
++			 (nextLineType == CondJump),
++			 jumpsExecuted, jumpsFollowed);
++#endif
++
++      if (0) {
++	kdDebug() << _filename << ":" << _lineNo
++		  << " - jump from 0x" << currentPos.fromAddr.toString()
++		  << " (line " << currentPos.fromLine
++		  << ") to 0x" << targetPos.fromAddr.toString()
++		  << " (line " << targetPos.fromLine << ")" << endl;
++
++	if (nextLineType == BoringJump)
++	  kdDebug() << " Boring Jump, count " << jumpsExecuted.pretty() << endl;
++	else
++	  kdDebug() << " Cond. Jump, followed " << jumpsFollowed.pretty()
++		    << ", executed " << jumpsExecuted.pretty() << endl;
++      }
++
++      nextLineType = SelfCost;
++      currentJumpToFunction = 0;
++      currentJumpToFile = 0;
++
++      if (!line.isEmpty()) {
++	kdError() << _filename << ":" << _lineNo
++		  << " - Garbage at end of jump cost line ('"
++		  << TQString(line) << "')" << endl;
++      }
++
++    }
++  }
++
++
++  emit updateStatus(statusMsg,100);
++
++  _part->invalidate();
++  if (!totalsSet) {
++    _part->totals()->clear();
++    _part->totals()->addCost(_part);
++  }
++  
++  pFile->close();
++
++  return true;
++}
++
+diff --git a/kdecachegrind/kdecachegrind/callgraphview.cpp b/kdecachegrind/kdecachegrind/callgraphview.cpp
+new file mode 100644
+index 0000000..bc01da8
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/callgraphview.cpp
+@@ -0,0 +1,2734 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Callgraph View
++ */
++
++#include <stdlib.h>
++#include <math.h>
++
++#include <tqtooltip.h>
++#include <tqfile.h>
++#include <tqtextstream.h>
++#include <tqwhatsthis.h>
++#include <tqcanvas.h>
++#include <tqwmatrix.h>
++#include <tqpair.h>
++#include <tqpainter.h>
++#include <tqpopupmenu.h>
++#include <tqstyle.h>
++#include <tqprocess.h>
++
++#include <kdebug.h>
++#include <klocale.h>
++#include <kconfig.h>
++#include <ktempfile.h>
++#include <kapplication.h>
++#include <kiconloader.h>
++#include <kfiledialog.h>
++
++#include "configuration.h"
++#include "callgraphview.h"
++#include "toplevel.h"
++#include "listutils.h"
++
++
++/*
++ * TODO:
++ * - Zooming option for work canvas? (e.g. 1:1 - 1:3)
++ */
++
++#define DEBUG_GRAPH 0
++
++// CallGraphView defaults
++
++#define DEFAULT_FUNCLIMIT   .05
++#define DEFAULT_CALLLIMIT   .05
++#define DEFAULT_MAXCALLER    2
++#define DEFAULT_MAXCALLING   -1
++#define DEFAULT_SHOWSKIPPED  false
++#define DEFAULT_EXPANDCYCLES false
++#define DEFAULT_CLUSTERGROUPS false
++#define DEFAULT_DETAILLEVEL  1
++#define DEFAULT_LAYOUT       GraphOptions::TopDown
++#define DEFAULT_ZOOMPOS      Auto
++
++
++//
++// GraphEdgeList
++//
++
++GraphEdgeList::GraphEdgeList()
++    : _sortCallerPos(true)
++{}
++
++int GraphEdgeList::compareItems(Item item1, Item item2)
++{
++    CanvasEdge* e1 = ((GraphEdge*)item1)->canvasEdge();
++    CanvasEdge* e2 = ((GraphEdge*)item2)->canvasEdge();
++
++    // edges without arrow visualisations are sorted as low
++    if (!e1) return -1;
++    if (!e2) return 1;
++
++    int dx1, dy1, dx2, dy2;
++    int x, y;
++    if (_sortCallerPos) {
++	e1->controlPoints().point(0,&x,&y);
++	e2->controlPoints().point(0,&dx1,&dy1);
++	dx1 -= x; dy1 -= y;
++    }
++    else {
++	TQPointArray a1 = e1->controlPoints();
++	TQPointArray a2 = e2->controlPoints();
++	a1.point(a1.count()-2,&x,&y);
++	a2.point(a2.count()-1,&dx2,&dy2);
++	dx2 -= x; dy2 -= y;
++    }
++    double at1 = atan2(double(dx1), double(dy1));
++    double at2 = atan2(double(dx2), double(dy2));
++
++    return (at1 < at2) ? 1:-1;
++}
++
++
++
++
++//
++// GraphNode
++//
++
++GraphNode::GraphNode()
++{
++    _f=0;
++    self = incl = 0;
++    _cn = 0;
++
++    _visible = false;
++    _lastCallerIndex = _lastCallingIndex = -1;
++
++    callers.setSortCallerPos(false);
++    callings.setSortCallerPos(true);
++    _lastFromCaller = true;
++}
++
++TraceCall* GraphNode::visibleCaller()
++{
++    if (0) qDebug("GraphNode::visibleCaller %s: last %d, count %d",
++		  _f->prettyName().ascii(), _lastCallerIndex, callers.count());
++
++    GraphEdge* e = callers.at(_lastCallerIndex);
++    if (e && !e->isVisible()) e = 0;
++    if (!e) {
++	double maxCost = 0.0;
++	GraphEdge* maxEdge = 0;
++	int idx = 0;
++	for(e = callers.first();e; e=callers.next(),idx++)
++	    if (e->isVisible() && (e->cost > maxCost)) {
++		maxCost = e->cost;
++		maxEdge = e;
++		_lastCallerIndex = idx;
++	    }
++	e = maxEdge;
++    }
++    return e ? e->call() : 0;
++}
++
++TraceCall* GraphNode::visibleCalling()
++{
++    if (0) qDebug("GraphNode::visibleCalling %s: last %d, count %d",
++		  _f->prettyName().ascii(), _lastCallingIndex, callings.count());
++
++    GraphEdge* e = callings.at(_lastCallingIndex);
++    if (e && !e->isVisible()) e = 0;
++    if (!e) {
++	double maxCost = 0.0;
++	GraphEdge* maxEdge = 0;
++	int idx = 0;
++	for(e = callings.first();e; e=callings.next(),idx++)
++	    if (e->isVisible() && (e->cost > maxCost)) {
++		maxCost = e->cost;
++		maxEdge = e;
++		_lastCallingIndex = idx;
++	    }
++	e = maxEdge;
++    }
++    return e ? e->call() : 0;
++}
++
++void GraphNode::setCalling(GraphEdge* e)
++{
++    _lastCallingIndex = callings.findRef(e);
++    _lastFromCaller = false;
++}
++
++void GraphNode::setCaller(GraphEdge* e)
++{
++    _lastCallerIndex = callers.findRef(e);
++    _lastFromCaller = true;
++}
++
++TraceFunction* GraphNode::nextVisible()
++{
++  TraceCall* c;
++  if (_lastFromCaller) {
++    c = nextVisibleCaller(callers.at(_lastCallerIndex));
++    if (c) return c->called(true);
++    c = nextVisibleCalling(callings.at(_lastCallingIndex));
++    if (c) return c->caller(true);
++  }
++  else {
++    c = nextVisibleCalling(callings.at(_lastCallingIndex));
++    if (c) return c->caller(true);
++    c = nextVisibleCaller(callers.at(_lastCallerIndex));
++    if (c) return c->called(true);
++  }
++  return 0;
++}
++
++TraceFunction* GraphNode::priorVisible()
++{
++  TraceCall* c;
++  if (_lastFromCaller) {
++    c = priorVisibleCaller(callers.at(_lastCallerIndex));
++    if (c) return c->called(true);
++    c = priorVisibleCalling(callings.at(_lastCallingIndex));
++    if (c) return c->caller(true);
++  }
++  else {
++    c = priorVisibleCalling(callings.at(_lastCallingIndex));
++    if (c) return c->caller(true);
++    c = priorVisibleCaller(callers.at(_lastCallerIndex));
++    if (c) return c->called(true);
++  }
++  return 0;
++}
++
++TraceCall* GraphNode::nextVisibleCaller(GraphEdge* last)
++{
++    GraphEdge* e;
++    bool found = false;
++    int idx = 0;
++    for(e = callers.first();e; e=callers.next(),idx++) {
++	if (found && e->isVisible()) {
++	    _lastCallerIndex = idx;
++	    return e->call();
++	}
++	if (e == last) found = true;
++    }
++    return 0;
++}
++
++TraceCall* GraphNode::nextVisibleCalling(GraphEdge* last)
++{
++    GraphEdge* e;
++    bool found = false;
++    int idx = 0;
++    for(e = callings.first();e; e=callings.next(),idx++) {
++	if (found && e->isVisible()) {
++	    _lastCallingIndex = idx;
++	    return e->call();
++	}
++	if (e == last) found = true;
++    }
++    return 0;
++}
++
++TraceCall* GraphNode::priorVisibleCaller(GraphEdge* last)
++{
++    GraphEdge *e, *prev = 0;
++    int prevIdx = -1, idx = 0;
++    for(e = callers.first(); e; e=callers.next(),idx++) {
++	if (e == last) {
++	    _lastCallerIndex = prevIdx;
++	    return prev ? prev->call() : 0;
++	}
++	if (e->isVisible()) {
++	    prev = e;
++	    prevIdx = idx;
++	}
++    }
++    return 0;
++}
++
++TraceCall* GraphNode::priorVisibleCalling(GraphEdge* last)
++{
++    GraphEdge *e, *prev = 0;
++    int prevIdx = -1, idx = 0;
++    for(e = callings.first(); e; e=callings.next(),idx++) {
++	if (e == last) {
++	    _lastCallingIndex = prevIdx;
++	    return prev ? prev->call() : 0;
++	}
++	if (e->isVisible()) {
++	    prev = e;
++	    prevIdx = idx;
++	}
++    }
++    return 0;
++}
++
++//
++// GraphEdge
++//
++
++GraphEdge::GraphEdge()
++{
++    _c=0;
++    _from = _to = 0;
++    _fromNode = _toNode = 0;
++    cost = count = 0;
++    _ce = 0;
++
++    _visible = false;
++    _lastFromCaller = true;
++}
++
++TQString GraphEdge::prettyName()
++{
++    if (_c) return _c->prettyName();
++    if (_from) return i18n("Call(s) from %1").arg(_from->prettyName());
++    if (_to) return i18n("Call(s) to %1").arg(_to->prettyName());
++    return i18n("(unknown call)");
++}
++
++
++TraceFunction* GraphEdge::visibleCaller()
++{
++    if (_from) {
++	_lastFromCaller = true;
++	if (_fromNode) _fromNode->setCalling(this);
++	return _from;
++    }
++    return 0;
++}
++
++TraceFunction* GraphEdge::visibleCalling()
++{
++    if (_to) {
++	_lastFromCaller = false;
++	if (_toNode) _toNode->setCaller(this);
++	return _to;
++    }
++    return 0;
++}
++
++TraceCall* GraphEdge::nextVisible()
++{
++    TraceCall* res = 0;
++
++    if (_lastFromCaller && _fromNode) {
++	res = _fromNode->nextVisibleCalling(this);
++	if (!res && _toNode)
++	    res = _toNode->nextVisibleCaller(this);
++    }
++    else if (_toNode) {
++	res = _toNode->nextVisibleCaller(this);
++	if (!res && _fromNode)
++	    res = _fromNode->nextVisibleCalling(this);
++    }
++    return res;
++}
++
++TraceCall* GraphEdge::priorVisible()
++{
++    TraceCall* res = 0;
++
++    if (_lastFromCaller && _fromNode) {
++	res = _fromNode->priorVisibleCalling(this);
++	if (!res && _toNode)
++	    res = _toNode->priorVisibleCaller(this);
++    }
++    else if (_toNode) {
++	res = _toNode->priorVisibleCaller(this);
++	if (!res && _fromNode)
++	    res = _fromNode->priorVisibleCalling(this);
++    }
++    return res;
++}
++
++
++
++//
++// GraphOptions
++//
++
++TQString GraphOptions::layoutString(Layout l)
++{
++    if (l == Circular) return TQString("Circular");
++    if (l == LeftRight) return TQString("LeftRight");
++    return TQString("TopDown");
++}
++
++GraphOptions::Layout GraphOptions::layout(TQString s)
++{
++    if (s == TQString("Circular")) return Circular;
++    if (s == TQString("LeftRight")) return LeftRight;
++    return TopDown;
++}
++
++
++//
++// StorableGraphOptions
++//
++
++StorableGraphOptions::StorableGraphOptions()
++{
++  // default options
++  _funcLimit         = DEFAULT_FUNCLIMIT;
++  _callLimit         = DEFAULT_CALLLIMIT;
++  _maxCallerDepth    = DEFAULT_MAXCALLER;
++  _maxCallingDepth   = DEFAULT_MAXCALLING;
++  _showSkipped       = DEFAULT_SHOWSKIPPED;
++  _expandCycles      = DEFAULT_EXPANDCYCLES;
++  _detailLevel       = DEFAULT_DETAILLEVEL;
++  _layout            = DEFAULT_LAYOUT;
++}
++
++
++
++
++//
++// GraphExporter
++//
++
++GraphExporter::GraphExporter()
++{
++    _go = this;
++    _tmpFile = 0;
++    _item = 0;
++    reset(0, 0, 0, TraceItem::NoCostType, TQString());
++}
++
++
++GraphExporter::GraphExporter(TraceData* d, TraceFunction* f, TraceCostType* ct,
++                             TraceItem::CostType gt, TQString filename)
++{
++    _go = this;
++    _tmpFile = 0;
++    _item = 0;
++    reset(d, f, ct, gt, filename);
++}
++
++
++GraphExporter::~GraphExporter()
++{
++  if (_item && _tmpFile) {
++#if DEBUG_GRAPH
++    _tmpFile->unlink();
++#endif
++    delete _tmpFile;
++  }
++}
++
++
++void GraphExporter::reset(TraceData*, TraceItem* i, TraceCostType* ct,
++                          TraceItem::CostType gt, TQString filename)
++{
++  _graphCreated = false;
++  _nodeMap.clear();
++  _edgeMap.clear();
++
++  if (_item && _tmpFile) {
++    _tmpFile->unlink();
++    delete _tmpFile;
++  }
++
++  if (i) {
++    switch(i->type()) {
++    case TraceItem::Function:
++    case TraceItem::FunctionCycle:
++    case TraceItem::Call:
++      break;
++    default:
++      i = 0;
++    }
++  }
++
++  _item = i;
++  _costType = ct;
++  _groupType = gt;
++  if (!i) return;
++
++  if (filename.isEmpty()) {
++    _tmpFile = new KTempFile(TQString(), ".dot");
++    _dotName = _tmpFile->name();
++    _useBox = true;
++  }
++  else {
++    _tmpFile = 0;
++    _dotName = filename;
++    _useBox = false;
++  }
++}
++
++
++
++void GraphExporter::setGraphOptions(GraphOptions* go)
++{
++    if (go == 0) go = this;
++    _go = go;
++}
++
++void GraphExporter::createGraph()
++{
++  if (!_item) return;
++  if (_graphCreated) return;
++  _graphCreated = true;
++
++  if ((_item->type() == TraceItem::Function) ||
++      (_item->type() == TraceItem::FunctionCycle)) {
++    TraceFunction* f = (TraceFunction*) _item;
++
++    double incl = f->inclusive()->subCost(_costType);
++    _realFuncLimit = incl * _go->funcLimit();
++    _realCallLimit = incl * _go->callLimit();
++
++    buildGraph(f, 0, true, 1.0); // down to callings
++
++    // set costs of function back to 0, as it will be added again
++    GraphNode& n = _nodeMap[f];
++    n.self = n.incl = 0.0;
++
++    buildGraph(f, 0, false, 1.0); // up to callers
++  }
++  else {
++    TraceCall* c = (TraceCall*) _item;
++
++    double incl = c->subCost(_costType);
++    _realFuncLimit = incl * _go->funcLimit();
++    _realCallLimit = incl * _go->callLimit();
++
++    // create edge
++    TraceFunction *caller, *called;
++    caller = c->caller(false);
++    called = c->called(false);
++    TQPair<TraceFunction*,TraceFunction*> p(caller, called);
++    GraphEdge& e = _edgeMap[p];
++    e.setCall(c);
++    e.setCaller(p.first);
++    e.setCalling(p.second);
++    e.cost  = c->subCost(_costType);
++    e.count = c->callCount();
++
++    SubCost s = called->inclusive()->subCost(_costType);
++    buildGraph(called, 0, true,  e.cost / s); // down to callings
++    s = caller->inclusive()->subCost(_costType);
++    buildGraph(caller, 0, false, e.cost / s); // up to callers
++  }
++}
++
++void GraphExporter::writeDot()
++{
++  if (!_item) return;
++
++  TQFile* file = 0;
++  TQTextStream* stream = 0;
++
++  if (_tmpFile)
++    stream = _tmpFile->textStream();
++  else {
++    file = new TQFile(_dotName);
++    if ( !file->open( IO_WriteOnly ) ) {
++      kdError() << "Can't write dot file '" << _dotName << "'" << endl;
++      return;
++    }
++    stream = new TQTextStream(file);
++  }
++
++  if (!_graphCreated) createGraph();
++
++  /* Generate dot format...
++   * When used for the CallGraphView (in contrast to "Export Callgraph..."),
++   * the labels are only dummy placeholders to reserve space for our own
++   * drawings.
++   */
++
++  *stream << "digraph \"callgraph\" {\n";
++
++  if (_go->layout() == LeftRight) {
++      *stream << TQString("  rankdir=LR;\n");
++  }
++  else if (_go->layout() == Circular) {
++    TraceFunction *f = 0;
++    switch(_item->type()) {
++    case TraceItem::Function:
++    case TraceItem::FunctionCycle:
++      f = (TraceFunction*) _item;
++      break;
++    case TraceItem::Call:
++      f = ((TraceCall*)_item)->caller(true);
++      break;
++    default:
++      break;
++    }
++    if (f)
++      *stream << TQString("  center=F%1;\n").arg((long)f, 0, 16);
++    *stream << TQString("  overlap=false;\n  splines=true;\n");
++  }
++
++  // for clustering
++  TQMap<TraceCostItem*,TQPtrList<GraphNode> > nLists;
++
++  GraphNodeMap::Iterator nit;
++  for ( nit = _nodeMap.begin();
++        nit != _nodeMap.end(); ++nit ) {
++    GraphNode& n = *nit;
++
++    if (n.incl <= _realFuncLimit) continue;
++
++    // for clustering: get cost item group of function
++    TraceCostItem* g;
++    TraceFunction* f = n.function();
++    switch(_groupType) {
++    case TraceItem::Object: g = f->object(); break;
++    case TraceItem::Class:  g = f->cls(); break;
++    case TraceItem::File:   g = f->file(); break;
++    case TraceItem::FunctionCycle: g = f->cycle();  break;
++    default: g = 0; break;
++    }
++    nLists[g].append(&n);
++  }
++
++  TQMap<TraceCostItem*,TQPtrList<GraphNode> >::Iterator lit;
++  int cluster = 0;
++  for ( lit = nLists.begin();
++        lit != nLists.end(); ++lit, cluster++ ) {
++    TQPtrList<GraphNode>& l = lit.data();
++    TraceCostItem* i = lit.key();
++
++    if (_go->clusterGroups() && i) {
++      TQString iabr = i->prettyName();
++      if ((int)iabr.length() > Configuration::maxSymbolLength())
++	iabr = iabr.left(Configuration::maxSymbolLength()) + "...";
++
++      *stream << TQString("subgraph \"cluster%1\" { label=\"%2\";\n")
++	.arg(cluster).arg(iabr);
++    }
++
++    GraphNode* np;
++    for(np = l.first(); np; np = l.next() ) {
++      TraceFunction* f = np->function();
++
++      TQString abr = f->prettyName();
++      if ((int)abr.length() > Configuration::maxSymbolLength())
++	abr = abr.left(Configuration::maxSymbolLength()) + "...";
++      
++      *stream << TQString("  F%1 [").arg((long)f, 0, 16);
++      if (_useBox) {
++	// make label 3 lines for CallGraphView
++	*stream << TQString("shape=box,label=\"** %1 **\\n**\\n%2\"];\n")
++	  .arg(abr)
++	  .arg(SubCost(np->incl).pretty());
++      }
++      else
++	*stream << TQString("label=\"%1\\n%2\"];\n")
++	  .arg(abr)
++	  .arg(SubCost(np->incl).pretty());
++    }
++
++    if (_go->clusterGroups() && i)
++      *stream << TQString("}\n");
++  }
++
++  GraphEdgeMap::Iterator eit;
++  for ( eit = _edgeMap.begin();
++        eit != _edgeMap.end(); ++eit ) {
++    GraphEdge& e = *eit;
++
++    if (e.cost < _realCallLimit) continue;
++    if (!_go->expandCycles()) {
++      // don't show inner cycle calls
++      if (e.call()->inCycle()>0) continue;
++    }
++
++
++    GraphNode& from = _nodeMap[e.from()];
++    GraphNode& to   = _nodeMap[e.to()];
++
++    e.setCallerNode(&from);
++    e.setCallingNode(&to);
++
++    if ((from.incl <= _realFuncLimit) ||
++        (to.incl <= _realFuncLimit)) continue;
++
++    // remove dumped edges from n.callers/n.callings
++    from.callings.removeRef(&e);
++    to.callers.removeRef(&e);
++    from.callingSet.remove(&e);
++    to.callerSet.remove(&e);
++
++    *stream << TQString("  F%1 -> F%2 [weight=%3")
++      .arg((long)e.from(), 0, 16)
++      .arg((long)e.to(), 0, 16)
++      .arg((long)log(log(e.cost)));
++
++    if (_go->detailLevel() ==1)
++	*stream << TQString(",label=\"%1\"")
++	    .arg(SubCost(e.cost).pretty());
++    else if (_go->detailLevel() ==2)
++	*stream << TQString(",label=\"%3\\n%4 x\"")
++	    .arg(SubCost(e.cost).pretty())
++	    .arg(SubCost(e.count).pretty());
++
++    *stream << TQString("];\n");
++  }
++
++  if (_go->showSkipped()) {
++
++      // Create sum-edges for skipped edges
++      GraphEdge* e;
++      double costSum, countSum;
++      for ( nit = _nodeMap.begin();
++	    nit != _nodeMap.end(); ++nit ) {
++	  GraphNode& n = *nit;
++	  if (n.incl <= _realFuncLimit) continue;
++
++	  costSum = countSum = 0.0;
++	  for (e=n.callers.first();e;e=n.callers.next()) {
++	      costSum += e->cost;
++	      countSum += e->count;
++	  }
++	  if (costSum > _realCallLimit) {
++
++	      TQPair<TraceFunction*,TraceFunction*> p(0, n.function());
++	      e = &(_edgeMap[p]);
++	      e->setCalling(p.second);
++	      e->cost = costSum;
++	      e->count = countSum;
++
++	      *stream << TQString("  R%1 [shape=point,label=\"\"];\n")
++		  .arg((long)n.function(), 0, 16);
++	      *stream << TQString("  R%1 -> F%2 [label=\"%3\\n%4 x\",weight=%5];\n")
++		  .arg((long)n.function(), 0, 16)
++		  .arg((long)n.function(), 0, 16)
++		  .arg(SubCost(costSum).pretty())
++		  .arg(SubCost(countSum).pretty())
++		  .arg((int)log(costSum));
++	  }
++
++	  costSum = countSum = 0.0;
++	  for (e=n.callings.first();e;e=n.callings.next()) {
++	      costSum += e->cost;
++	      countSum += e->count;
++	  }
++	  if (costSum > _realCallLimit) {
++
++	      TQPair<TraceFunction*,TraceFunction*> p(n.function(), 0);
++	      e = &(_edgeMap[p]);
++	      e->setCaller(p.first);
++	      e->cost = costSum;
++	      e->count = countSum;
++
++	      *stream << TQString("  S%1 [shape=point,label=\"\"];\n")
++		  .arg((long)n.function(), 0, 16);
++	      *stream << TQString("  F%1 -> S%2 [label=\"%3\\n%4 x\",weight=%5];\n")
++		  .arg((long)n.function(), 0, 16)
++		  .arg((long)n.function(), 0, 16)
++		  .arg(SubCost(costSum).pretty())
++		  .arg(SubCost(countSum).pretty())
++		  .arg((int)log(costSum));
++	  }
++      }
++  }
++
++  // clear edges here completely.
++  // Visible edges are inserted again on parsing in CallGraphView::refresh
++  for ( nit = _nodeMap.begin();
++	nit != _nodeMap.end(); ++nit ) {
++      GraphNode& n = *nit;
++      n.callers.clear();
++      n.callings.clear();
++      n.callerSet.clear();
++      n.callingSet.clear();
++  }
++
++  *stream << "}\n";
++
++  if (_tmpFile) {
++    _tmpFile->close();
++  }
++  else {
++    file->close();
++    delete file;
++    delete stream;
++  }
++}
++
++void GraphExporter::sortEdges()
++{
++    GraphNodeMap::Iterator nit;
++    for ( nit = _nodeMap.begin();
++	  nit != _nodeMap.end(); ++nit ) {
++	GraphNode& n = *nit;
++
++	n.callers.sort();
++	n.callings.sort();
++  }
++}
++
++TraceFunction* GraphExporter::toFunc(TQString s)
++{
++  if (s[0] != 'F') return 0;
++  bool ok;
++  TraceFunction* f = (TraceFunction*) s.mid(1).toULong(&ok, 16);
++  if (!ok) return 0;
++
++  return f;
++}
++
++GraphNode* GraphExporter::node(TraceFunction* f)
++{
++  if (!f) return 0;
++
++  GraphNodeMap::Iterator it = _nodeMap.find(f);
++  if (it == _nodeMap.end()) return 0;
++
++  return &(*it);
++}
++
++GraphEdge* GraphExporter::edge(TraceFunction* f1, TraceFunction* f2)
++{
++  GraphEdgeMap::Iterator it = _edgeMap.find(tqMakePair(f1, f2));
++  if (it == _edgeMap.end()) return 0;
++
++  return &(*it);
++}
++
++
++/**
++ * We do a DFS and don't stop on already visited nodes/edges,
++ * but add up costs. We only stop if limits/max depth is reached.
++ *
++ * For a node/edge, it can happen that the first time visited the
++ * cost will below the limit, so the search is stopped.
++ * If on a further visit of the node/edge the limit is reached,
++ * we use the whole node/edge cost and continue search.
++ */
++void GraphExporter::buildGraph(TraceFunction* f, int d,
++                               bool toCallings, double factor)
++{
++#if DEBUG_GRAPH
++  kdDebug() << "buildGraph(" << f->prettyName() << "," << d << "," << factor
++	    << ") [to " << (toCallings ? "Callings":"Callers") << "]" << endl;
++#endif
++
++  double oldIncl = 0.0;
++  GraphNode& n = _nodeMap[f];
++  if (n.function() == 0) {
++    n.setFunction(f);
++  }
++  else
++    oldIncl = n.incl;
++
++  double incl = f->inclusive()->subCost(_costType) * factor;
++  n.incl  += incl;
++  n.self += f->subCost(_costType) * factor;
++  if (0) qDebug("  Added Incl. %f, now %f", incl, n.incl);
++
++  // A negative depth limit means "unlimited"
++  int maxDepth = toCallings ? _go->maxCallingDepth() : _go->maxCallerDepth();
++  if ((maxDepth>=0) && (d >= maxDepth)) {
++    if (0) qDebug("  Cutoff, max depth reached");
++    return;
++  }
++
++  // if we just reached the limit by summing, do a DFS
++  // from here with full incl. cost because of previous cutoffs
++  if ((n.incl >= _realFuncLimit) && (oldIncl < _realFuncLimit)) incl = n.incl;
++
++  if (f->cycle()) {
++    // for cycles members, we never stop on first visit, but always on 2nd
++    // note: a 2nd visit never should happen, as we don't follow inner-cycle
++    //       calls
++    if (oldIncl > 0.0) {
++      if (0) qDebug("  Cutoff, 2nd visit to Cycle Member");
++      // and takeback cost addition, as it's added twice
++      n.incl  = oldIncl;
++      n.self -= f->subCost(_costType) * factor;
++      return;
++    }
++  }
++  else if (incl <= _realFuncLimit) {
++    if (0) qDebug("  Cutoff, below limit");
++    return;
++  }
++
++  TraceCall* call;
++  TraceFunction* f2;
++
++
++  // on entering a cycle, only go the FunctionCycle
++  TraceCallList l = toCallings ?
++    f->callings(false) : f->callers(false);
++
++  for (call=l.first();call;call=l.next()) {
++
++    f2 = toCallings ? call->called(false) : call->caller(false);
++
++    double count = call->callCount() * factor;
++    double cost = call->subCost(_costType) * factor;
++
++    // ignore function calls with absolute cost < 3 per call
++    // No: This would skip a lot of functions e.g. with L2 cache misses
++    // if (count>0.0 && (cost/count < 3)) continue;
++
++    double oldCost = 0.0;
++    TQPair<TraceFunction*,TraceFunction*> p(toCallings ? f:f2,
++					   toCallings ? f2:f);
++    GraphEdge& e = _edgeMap[p];
++    if (e.call() == 0) {
++      e.setCall(call);
++      e.setCaller(p.first);
++      e.setCalling(p.second);
++    }
++    else
++      oldCost = e.cost;
++
++    e.cost  += cost;
++    e.count += count;
++    if (0) qDebug("  Edge to %s, added cost %f, now %f",
++                  f2->prettyName().ascii(), cost, e.cost);
++
++    // if this call goes into a FunctionCycle, we also show the real call
++    if (f2->cycle() == f2) {
++      TraceFunction* realF;
++      realF = toCallings ? call->called(true) : call->caller(true);
++      TQPair<TraceFunction*,TraceFunction*> realP(toCallings ? f:realF,
++						 toCallings ? realF:f);
++      GraphEdge& e = _edgeMap[realP];
++      if (e.call() == 0) {
++	e.setCall(call);
++	e.setCaller(realP.first);
++	e.setCalling(realP.second);
++      }
++      e.cost  += cost;
++      e.count += count;
++    }
++
++    // - don't do a DFS on calls in recursion/cycle
++    if (call->inCycle()>0) continue;
++    if (call->isRecursion()) continue;
++
++    if (toCallings) {
++	GraphEdgeSet::Iterator it = n.callingSet.find(&e);
++	if (it == n.callingSet.end()) {
++	    n.callings.append(&e);
++	    n.callingSet.insert(&e, 1 );
++	}
++    }
++    else {
++	GraphEdgeSet::Iterator it = n.callerSet.find(&e);
++	if (it == n.callerSet.end()) {
++	    n.callers.append(&e);
++	    n.callerSet.insert(&e, 1 );
++	}
++    }
++
++    // if we just reached the call limit (=func limit by summing, do a DFS
++    // from here with full incl. cost because of previous cutoffs
++    if ((e.cost >= _realCallLimit) && (oldCost < _realCallLimit)) cost = e.cost;
++    if (cost < _realCallLimit) {
++      if (0) qDebug("  Edge Cutoff, limit not reached");
++      continue;
++    }
++
++    SubCost s;
++    if (call->inCycle())
++      s = f2->cycle()->inclusive()->subCost(_costType);
++    else
++      s = f2->inclusive()->subCost(_costType);
++    SubCost v = call->subCost(_costType);
++    buildGraph(f2, d+1, toCallings, factor * v / s);
++  }
++}
++
++
++//
++// PannerView
++//
++PannerView::PannerView(TQWidget * parent, const char * name)
++  : TQCanvasView(parent, name, WNoAutoErase | WStaticContents)
++{
++  _movingZoomRect = false;
++
++  // why doesn't this avoid flicker ?
++  viewport()->setBackgroundMode(TQt::NoBackground);
++  setBackgroundMode(TQt::NoBackground);
++}
++
++void PannerView::setZoomRect(TQRect r)
++{
++  TQRect oldRect = _zoomRect;
++  _zoomRect = r;
++  updateContents(oldRect);
++  updateContents(_zoomRect);
++}
++
++void PannerView::drawContents(TQPainter * p, int clipx, int clipy, int clipw, int cliph)
++{
++  // save/restore around TQCanvasView::drawContents seems to be needed
++  // for QT 3.0 to get the red rectangle drawn correct
++  p->save();
++  TQCanvasView::drawContents(p,clipx,clipy,clipw,cliph);
++  p->restore();
++  if (_zoomRect.isValid()) {
++    p->setPen(red.dark());
++    p->drawRect(_zoomRect);
++    p->setPen(red);
++    p->drawRect(TQRect(_zoomRect.x()+1, _zoomRect.y()+1,
++		      _zoomRect.width()-2, _zoomRect.height()-2));
++  }
++}
++
++void PannerView::contentsMousePressEvent(TQMouseEvent* e)
++{
++  if (_zoomRect.isValid()) {
++    if (!_zoomRect.contains(e->pos()))
++      emit zoomRectMoved(e->pos().x() - _zoomRect.center().x(),
++                         e->pos().y() - _zoomRect.center().y());
++
++    _movingZoomRect = true;
++    _lastPos = e->pos();
++  }
++}
++
++void PannerView::contentsMouseMoveEvent(TQMouseEvent* e)
++{
++  if (_movingZoomRect) {
++    emit zoomRectMoved(e->pos().x() - _lastPos.x(), e->pos().y() - _lastPos.y());
++    _lastPos = e->pos();
++  }
++}
++
++void PannerView::contentsMouseReleaseEvent(TQMouseEvent*)
++{
++    _movingZoomRect = false;
++    emit zoomRectMoveFinished();
++}
++
++
++
++
++
++//
++// CanvasNode
++//
++
++CanvasNode::CanvasNode(CallGraphView* v, GraphNode* n,
++		       int x, int y, int w, int h, TQCanvas* c)
++    : TQCanvasRectangle(x, y, w, h, c), _node(n), _view(v)
++{
++    setPosition(0, DrawParams::TopCenter);
++    setPosition(1, DrawParams::BottomCenter);
++
++    updateGroup();
++
++    if (!_node || !_view) return;
++
++    if (_node->function())
++	setText(0, _node->function()->prettyName());
++
++    TraceCost* totalCost;
++    if (_view->topLevel()->showExpanded()) {
++      if (_view->activeFunction()) {
++        if (_view->activeFunction()->cycle())
++          totalCost = _view->activeFunction()->cycle()->inclusive();
++        else
++          totalCost = _view->activeFunction()->inclusive();
++      }
++      else
++        totalCost = (TraceCost*) _view->activeItem();
++    }
++    else
++	totalCost = _view->TraceItemView::data();
++    double total = totalCost->subCost(_view->costType());
++    double inclP  = 100.0 * n->incl / total;
++    if (_view->topLevel()->showPercentage())
++	setText(1, TQString("%1 %")
++		.arg(inclP, 0, 'f', Configuration::percentPrecision()));
++    else
++	setText(1, SubCost(n->incl).pretty());
++    setPixmap(1, percentagePixmap(25,10,(int)(inclP+.5), TQt::blue, true));
++}
++
++void CanvasNode::setSelected(bool s)
++{
++  StoredDrawParams::setSelected(s);
++  update();
++}
++
++void CanvasNode::updateGroup()
++{
++    if (!_view || !_node) return;
++
++    TQColor c = Configuration::functionColor(_view->groupType(),
++					    _node->function());
++    setBackColor(c);
++    update();
++}
++
++void CanvasNode::drawShape(TQPainter& p)
++{
++    TQRect r = rect(), origRect = r;
++
++  r.setRect(r.x()+1, r.y()+1, r.width()-2, r.height()-2);
++
++  RectDrawing d(r);
++  d.drawBack(&p, this);
++  r.setRect(r.x()+2, r.y()+2, r.width()-4, r.height()-4);
++
++  if (StoredDrawParams::selected() && _view->hasFocus()) {
++    _view->style().tqdrawPrimitive( TQStyle::PE_FocusRect, &p, r,
++				  _view->colorGroup());
++  }
++
++  // draw afterwards to always get a frame even when zoomed
++  p.setPen(StoredDrawParams::selected() ? red : black);
++  p.drawRect(origRect);
++
++  d.setRect(r);
++  d.drawField(&p, 0, this);
++  d.drawField(&p, 1, this);
++}
++
++
++//
++// CanvasEdgeLabel
++//
++
++CanvasEdgeLabel::CanvasEdgeLabel(CallGraphView* v, CanvasEdge* ce,
++                                 int x, int y, int w, int h, TQCanvas* c)
++    : TQCanvasRectangle(x, y, w, h, c), _ce(ce), _view(v)
++{
++    GraphEdge* e = ce->edge();
++    if (!e) return;
++
++    setPosition(1, DrawParams::TopCenter);
++    setText(1, TQString("%1 x").arg(SubCost(e->count).pretty()));
++
++    setPosition(0, DrawParams::BottomCenter);
++
++    TraceCost* totalCost;
++    if (_view->topLevel()->showExpanded()) {
++      if (_view->activeFunction()) {
++        if (_view->activeFunction()->cycle())
++          totalCost = _view->activeFunction()->cycle()->inclusive();
++        else
++          totalCost = _view->activeFunction()->inclusive();
++      }
++      else
++        totalCost = (TraceCost*) _view->activeItem();
++    }
++    else
++        totalCost = _view->TraceItemView::data();
++    double total = totalCost->subCost(_view->costType());
++    double inclP  = 100.0 * e->cost / total;
++    if (_view->topLevel()->showPercentage())
++        setText(0, TQString("%1 %")
++		.arg(inclP, 0, 'f', Configuration::percentPrecision()));
++    else
++        setText(0, SubCost(e->cost).pretty());
++    setPixmap(0, percentagePixmap(25,10,(int)(inclP+.5), TQt::blue, true));
++
++    if (e->call() && (e->call()->isRecursion() || e->call()->inCycle())) {
++	TQString icon = "undo";
++	KIconLoader* loader = KApplication::kApplication()->iconLoader();
++	TQPixmap p= loader->loadIcon(icon, KIcon::Small, 0,
++				      KIcon::DefaultState, 0, true);
++	setPixmap(0, p);
++    }
++}
++
++void CanvasEdgeLabel::drawShape(TQPainter& p)
++{
++  TQRect r = rect();
++  //p.setPen(blue);
++  //p.drawRect(r);
++  RectDrawing d(r);
++  d.drawField(&p, 0, this);
++  d.drawField(&p, 1, this);
++}
++
++//
++// CanvasEdgeArrow
++
++CanvasEdgeArrow::CanvasEdgeArrow(CanvasEdge* ce, TQCanvas* c)
++    : TQCanvasPolygon(c), _ce(ce)
++{}
++
++void CanvasEdgeArrow::drawShape(TQPainter& p)
++{
++    if (_ce->isSelected()) p.setBrush(TQt::red);
++
++    TQCanvasPolygon::drawShape(p);
++}
++
++//
++// CanvasEdge
++//
++
++CanvasEdge::CanvasEdge(GraphEdge* e, TQCanvas* c)
++  : TQCanvasSpline(c), _edge(e)
++{
++    _label = 0;
++    _arrow = 0;
++}
++
++void CanvasEdge::setSelected(bool s)
++{
++    TQCanvasItem::setSelected(s);
++    update();
++    if (_arrow) _arrow->setSelected(s);
++}
++
++TQPointArray CanvasEdge::areaPoints() const
++{
++  int minX = poly[0].x(), minY = poly[0].y();
++  int maxX = minX, maxY = minY;
++  int i;
++
++  if (0) qDebug("CanvasEdge::areaPoints\n  P 0: %d/%d", minX, minY);
++  int len = poly.count();
++  for (i=1;i<len;i++) {
++    if (poly[i].x() < minX) minX = poly[i].x();
++    if (poly[i].y() < minY) minY = poly[i].y();
++    if (poly[i].x() > maxX) maxX = poly[i].x();
++    if (poly[i].y() > maxY) maxY = poly[i].y();
++    if (0) qDebug("  P %d: %d/%d", i, poly[i].x(), poly[i].y());
++  }
++  TQPointArray a = poly.copy(),  b = poly.copy();
++  if (minX == maxX) {
++    a.translate(-2, 0);
++    b.translate(2, 0);
++  }
++  else {
++    a.translate(0, -2);
++    b.translate(0, 2);
++  }
++  a.resize(2*len);
++  for (i=0;i<len;i++)
++    a[2 * len - 1 -i] = b[i];
++
++  if (0) {
++      qDebug(" Result:");
++      for (i=0;i<2*len;i++)
++	  qDebug("  P %d: %d/%d", i, a[i].x(), a[i].y());
++  }
++
++  return a;
++}
++
++void CanvasEdge::drawShape(TQPainter& p)
++{
++    if (isSelected()) p.setPen(TQt::red);
++
++    p.drawPolyline(poly);
++}
++
++
++//
++// CanvasFrame
++//
++
++TQPixmap* CanvasFrame::_p = 0;
++
++CanvasFrame::CanvasFrame(CanvasNode* n, TQCanvas* c)
++ : TQCanvasRectangle(c)
++{
++  if (!_p) {
++
++    int d = 5;
++    float v1 = 130.0, v2 = 10.0, v = v1, f = 1.03;
++
++    // calculate pix size
++    TQRect r(0, 0, 30, 30);
++    while (v>v2) {
++      r.setRect(r.x()-d, r.y()-d, r.width()+2*d, r.height()+2*d);
++      v /= f;
++    }
++
++    _p = new TQPixmap(r.size());
++    _p->fill(TQt::white);
++    TQPainter p(_p);
++    p.setPen(TQt::NoPen);
++
++    r.moveBy(-r.x(), -r.y());
++
++    while (v<v1) {
++      v *= f;
++      p.setBrush(TQColor(265-(int)v, 265-(int)v, 265-(int)v));
++
++      p.drawRect(TQRect(r.x(), r.y(), r.width(), d));
++      p.drawRect(TQRect(r.x(), r.bottom()-d, r.width(), d));
++      p.drawRect(TQRect(r.x(), r.y()+d, d, r.height()-2*d));
++      p.drawRect(TQRect(r.right()-d, r.y()+d, d, r.height()-2*d));
++
++      r.setRect(r.x()+d, r.y()+d, r.width()-2*d, r.height()-2*d);
++    }
++  }
++
++  setSize(_p->width(), _p->height());
++  move(n->rect().center().x()-_p->width()/2,
++       n->rect().center().y()-_p->height()/2);
++}
++
++
++void CanvasFrame::drawShape(TQPainter& p)
++{
++  p.drawPixmap( int(x()), int(y()), *_p );
++}
++
++
++
++
++//
++// Tooltips for CallGraphView
++//
++
++class CallGraphTip: public TQToolTip
++{
++public:
++  CallGraphTip( TQWidget* p ):TQToolTip(p) {}
++
++protected:
++    void maybeTip( const TQPoint & );
++};
++
++void CallGraphTip::maybeTip( const TQPoint& pos )
++{
++  if (!parentWidget()->inherits( "CallGraphView" )) return;
++  CallGraphView* cgv = (CallGraphView*)parentWidget();
++
++  TQPoint cPos = cgv->viewportToContents(pos);
++
++  if (0) qDebug("CallGraphTip for (%d/%d) -> (%d/%d) ?",
++		pos.x(), pos.y(), cPos.x(), cPos.y());
++
++  TQCanvasItemList l = cgv->canvas()->collisions(cPos);
++  if (l.count() == 0) return;
++  TQCanvasItem* i = l.first();
++
++  if (i->rtti() == CANVAS_NODE) {
++      CanvasNode* cn = (CanvasNode*)i;
++      GraphNode* n = cn->node();
++      if (0) qDebug("CallGraphTip: Mouse on Node '%s'",
++		    n->function()->prettyName().ascii());
++
++      TQString tipStr = TQString("%1 (%2)").arg(cn->text(0)).arg(cn->text(1));
++      TQPoint vPosTL = cgv->contentsToViewport(i->boundingRect().topLeft());
++      TQPoint vPosBR = cgv->contentsToViewport(i->boundingRect().bottomRight());
++      tip(TQRect(vPosTL, vPosBR), tipStr);
++
++      return;
++  }
++
++  // redirect from label / arrow to edge
++  if (i->rtti() == CANVAS_EDGELABEL)
++      i = ((CanvasEdgeLabel*)i)->canvasEdge();
++  if (i->rtti() == CANVAS_EDGEARROW)
++      i = ((CanvasEdgeArrow*)i)->canvasEdge();
++
++  if (i->rtti() == CANVAS_EDGE) {
++      CanvasEdge* ce = (CanvasEdge*)i;
++      GraphEdge* e = ce->edge();
++      if (0) qDebug("CallGraphTip: Mouse on Edge '%s'",
++		    e->prettyName().ascii());
++
++      TQString tipStr;
++      if (!ce->label())
++	  tipStr = e->prettyName();
++      else
++	  tipStr = TQString("%1 (%2)")
++	      .arg(ce->label()->text(0)).arg(ce->label()->text(1));
++      tip(TQRect(pos.x()-5,pos.y()-5,pos.x()+5,pos.y()+5), tipStr);
++  }
++}
++
++
++
++
++//
++// CallGraphView
++//
++CallGraphView::CallGraphView(TraceItemView* parentView,
++                             TQWidget* parent, const char* name)
++  : TQCanvasView(parent, name), TraceItemView(parentView)
++{
++    _zoomPosition = DEFAULT_ZOOMPOS;
++    _lastAutoPosition = TopLeft;
++
++  _canvas = 0;
++  _xMargin = _yMargin = 0;
++  _completeView = new PannerView(this);
++  _cvZoom = 1;
++  _selectedNode = 0;
++  _selectedEdge = 0;
++
++  _exporter.setGraphOptions(this);
++
++  _completeView->setVScrollBarMode(TQScrollView::AlwaysOff);
++  _completeView->setHScrollBarMode(TQScrollView::AlwaysOff);
++  _completeView->raise();
++  _completeView->hide();
++
++  setFocusPolicy(TQ_StrongFocus);
++  setBackgroundMode(TQt::NoBackground);
++
++  connect(this, TQT_SIGNAL(contentsMoving(int,int)),
++          this, TQT_SLOT(contentsMovingSlot(int,int)));
++  connect(_completeView, TQT_SIGNAL(zoomRectMoved(int,int)),
++          this, TQT_SLOT(zoomRectMoved(int,int)));
++  connect(_completeView, TQT_SIGNAL(zoomRectMoveFinished()),
++          this, TQT_SLOT(zoomRectMoveFinished()));
++
++  TQWhatsThis::add( this, whatsThis() );
++
++  // tooltips...
++  _tip = new CallGraphTip(this);
++
++  _renderProcess = 0;
++  _prevSelectedNode = 0;
++  connect(&_renderTimer, TQT_SIGNAL(timeout()),
++          this, TQT_SLOT(showRenderWarning()));
++}
++
++CallGraphView::~CallGraphView()
++{
++  delete _completeView;
++  delete _tip;
++
++  if (_canvas) {
++    setCanvas(0);
++    delete _canvas;
++  }
++}
++
++TQString CallGraphView::whatsThis() const
++{
++    return i18n( "<b>Call Graph around active Function</b>"
++                 "<p>Depending on configuration, this view shows "
++                 "the call graph environment of the active function. "
++		 "Note: the shown cost is <b>only</b> the cost which is "
++		 "spent while the active function was actually running; "
++		 "i.e. the cost shown for main() - if it's visible - should "
++		 "be the same as the cost of the active function, as that's "
++		 "the part of inclusive cost of main() spent while the active "
++		 "function was running.</p>"
++		 "<p>For cycles, blue call arrows indicate that this is an "
++		 "artificial call added for correct drawing which "
++		 "actually never happened.</p>"
++                 "<p>If the graph is larger than the widget area, an overview "
++                 "panner is shown in one edge. "
++                 "There are similar visualization options to the "
++                 "Call Treemap; the selected function is highlighted.<p>");
++}
++
++void CallGraphView::updateSizes(TQSize s)
++{
++  if (!_canvas) return;
++
++    if (s == TQSize(0,0)) s = size();
++
++    // the part of the canvas that should be visible
++    int cWidth  = _canvas->width()  - 2*_xMargin + 100;
++    int cHeight = _canvas->height() - 2*_yMargin + 100;
++
++    // hide birds eye view if no overview needed
++    if (!_data || !_activeItem ||
++	((cWidth < s.width()) && cHeight < s.height())) {
++      _completeView->hide();
++      return;
++    }
++    _completeView->show();
++
++    // first, assume use of 1/3 of width/height (possible larger)
++    double zoom = .33 * s.width() / cWidth;
++    if (zoom * cHeight < .33 * s.height()) zoom = .33 * s.height() / cHeight;
++
++    // fit to widget size
++    if (cWidth  * zoom  > s.width())   zoom = s.width() / (double)cWidth;
++    if (cHeight * zoom  > s.height())  zoom = s.height() / (double)cHeight;
++
++    // scale to never use full height/width
++    zoom = zoom * 3/4;
++
++    // at most a zoom of 1/3
++    if (zoom > .33) zoom = .33;
++
++    if (zoom != _cvZoom) {
++      _cvZoom = zoom;
++      if (0) qDebug("Canvas Size: %dx%d, Visible: %dx%d, Zoom: %f",
++		    _canvas->width(), _canvas->height(),
++		    cWidth, cHeight, zoom);
++
++      TQWMatrix wm;
++      wm.scale( zoom, zoom );
++      _completeView->setWorldMatrix(wm);
++
++      // make it a little bigger to compensate for widget frame
++      _completeView->resize(int(cWidth * zoom) + 4,
++                            int(cHeight * zoom) + 4);
++
++      // update ZoomRect in completeView
++      contentsMovingSlot(contentsX(), contentsY());
++    }
++
++    _completeView->setContentsPos(int(zoom*(_xMargin-50)),
++				  int(zoom*(_yMargin-50)));
++
++    int cvW = _completeView->width();
++    int cvH = _completeView->height();
++    int x = width()- cvW - verticalScrollBar()->width()    -2;
++    int y = height()-cvH - horizontalScrollBar()->height() -2;
++    TQPoint oldZoomPos = _completeView->pos();
++    TQPoint newZoomPos = TQPoint(0,0);
++    ZoomPosition zp = _zoomPosition;
++    if (zp == Auto) {
++	TQPoint tl1Pos = viewportToContents(TQPoint(0,0));
++	TQPoint tl2Pos = viewportToContents(TQPoint(cvW,cvH));
++	TQPoint tr1Pos = viewportToContents(TQPoint(x,0));
++	TQPoint tr2Pos = viewportToContents(TQPoint(x+cvW,cvH));
++	TQPoint bl1Pos = viewportToContents(TQPoint(0,y));
++	TQPoint bl2Pos = viewportToContents(TQPoint(cvW,y+cvH));
++	TQPoint br1Pos = viewportToContents(TQPoint(x,y));
++	TQPoint br2Pos = viewportToContents(TQPoint(x+cvW,y+cvH));
++	int tlCols = _canvas->collisions(TQRect(tl1Pos,tl2Pos)).count();
++	int trCols = _canvas->collisions(TQRect(tr1Pos,tr2Pos)).count();
++	int blCols = _canvas->collisions(TQRect(bl1Pos,bl2Pos)).count();
++	int brCols = _canvas->collisions(TQRect(br1Pos,br2Pos)).count();
++	int minCols = tlCols;
++	zp = _lastAutoPosition;
++	switch(zp) {
++	case TopRight:    minCols = trCols; break;
++	case BottomLeft:  minCols = blCols; break;
++	case BottomRight: minCols = brCols; break;
++	default:
++	case TopLeft:     minCols = tlCols; break;
++	}
++	if (minCols > tlCols) { minCols = tlCols; zp = TopLeft; }
++	if (minCols > trCols) { minCols = trCols; zp = TopRight; }
++	if (minCols > blCols) { minCols = blCols; zp = BottomLeft; }
++	if (minCols > brCols) { minCols = brCols; zp = BottomRight; }
++
++	_lastAutoPosition = zp;
++    }
++
++    switch(zp) {
++    case TopRight:
++	newZoomPos = TQPoint(x,0);
++	break;
++    case BottomLeft:
++	newZoomPos = TQPoint(0,y);
++	break;
++    case BottomRight:
++	newZoomPos = TQPoint(x,y);
++	break;
++    default:
++	break;
++    }
++    if (newZoomPos != oldZoomPos) _completeView->move(newZoomPos);
++}
++
++void CallGraphView::focusInEvent(TQFocusEvent*)
++{
++    if (!_canvas) return;
++
++    if (_selectedNode && _selectedNode->canvasNode()) {
++	_selectedNode->canvasNode()->setSelected(true); // requests item update
++	_canvas->update();
++    }
++}
++
++void CallGraphView::focusOutEvent(TQFocusEvent* e)
++{
++    // trigger updates as in focusInEvent
++    focusInEvent(e);
++}
++
++void CallGraphView::keyPressEvent(TQKeyEvent* e)
++{
++    if (!_canvas) {
++	e->ignore();
++	return;
++    }
++
++    if ((e->key() == Key_Return) ||
++	(e->key() == Key_Space)) {
++	if (_selectedNode)
++	    activated(_selectedNode->function());
++	else if (_selectedEdge && _selectedEdge->call())
++	    activated(_selectedEdge->call());
++	return;
++    }
++
++    // move selected node/edge
++    if (!(e->state() & (ShiftButton | ControlButton)) &&
++	(_selectedNode || _selectedEdge) &&
++	((e->key() == Key_Up) ||
++	 (e->key() == Key_Down) ||
++	 (e->key() == Key_Left) ||
++	 (e->key() == Key_Right))) {
++
++	TraceFunction* f = 0;
++	TraceCall* c = 0;
++
++	// rotate arrow key meaning for LeftRight layout
++	int key = e->key();
++	if (_layout == LeftRight) {
++	    switch(key) {
++	    case Key_Up:    key = Key_Left; break;
++	    case Key_Down:  key = Key_Right; break;
++	    case Key_Left:  key = Key_Up; break;
++	    case Key_Right: key = Key_Down; break;
++	    default: break;
++	    }
++	}
++
++	if (_selectedNode) {
++	    if (key == Key_Up)    c = _selectedNode->visibleCaller();
++	    if (key == Key_Down)  c = _selectedNode->visibleCalling();
++	    if (key == Key_Right) f = _selectedNode->nextVisible();
++	    if (key == Key_Left)  f = _selectedNode->priorVisible();
++	}
++	else if (_selectedEdge) {
++	    if (key == Key_Up)    f = _selectedEdge->visibleCaller();
++	    if (key == Key_Down)  f = _selectedEdge->visibleCalling();
++	    if (key == Key_Right) c = _selectedEdge->nextVisible();
++	    if (key == Key_Left)  c = _selectedEdge->priorVisible();
++	}
++
++	if (c) selected(c);
++	if (f) selected(f);
++	return;
++    }
++
++    // move canvas...
++    if (e->key() == Key_Home)
++	scrollBy(-_canvas->width(),0);
++    else if (e->key() == Key_End)
++	scrollBy(_canvas->width(),0);
++    else if (e->key() == Key_Prior)
++	scrollBy(0,-visibleHeight()/2);
++    else if (e->key() == Key_Next)
++	scrollBy(0,visibleHeight()/2);
++    else if (e->key() == Key_Left)
++	scrollBy(-visibleWidth()/10,0);
++    else if (e->key() == Key_Right)
++	scrollBy(visibleWidth()/10,0);
++    else if (e->key() == Key_Down)
++	scrollBy(0,visibleHeight()/10);
++    else if (e->key() == Key_Up)
++	scrollBy(0,-visibleHeight()/10);
++    else e->ignore();
++}
++
++void CallGraphView::resizeEvent(TQResizeEvent* e)
++{
++  TQCanvasView::resizeEvent(e);
++  if (_canvas) updateSizes(e->size());
++}
++
++TraceItem* CallGraphView::canShow(TraceItem* i)
++{
++  if (i) {
++    switch(i->type()) {
++    case TraceItem::Function:
++    case TraceItem::FunctionCycle:
++    case TraceItem::Call:
++      return i;
++    default:
++      break;
++    }
++  }
++  return 0;
++}
++
++void CallGraphView::doUpdate(int changeType)
++{
++  // Special case ?
++  if (changeType == costType2Changed) return;
++
++  if (changeType == selectedItemChanged) {
++    if (!_canvas) return;
++
++    if (!_selectedItem) return;
++
++    GraphNode* n = 0;
++    GraphEdge* e = 0;
++    if ((_selectedItem->type() == TraceItem::Function) ||
++        (_selectedItem->type() == TraceItem::FunctionCycle)) {
++	n = _exporter.node((TraceFunction*)_selectedItem);
++	if (n == _selectedNode) return;
++    }
++    else if (_selectedItem->type() == TraceItem::Call) {
++	TraceCall* c = (TraceCall*)_selectedItem;
++	e = _exporter.edge(c->caller(false), c->called(false));
++	if (e == _selectedEdge) return;
++    }
++
++    // unselected any selected item
++    if (_selectedNode && _selectedNode->canvasNode()) {
++	_selectedNode->canvasNode()->setSelected(false);
++    }
++    _selectedNode = 0;
++    if (_selectedEdge && _selectedEdge->canvasEdge()) {
++	_selectedEdge->canvasEdge()->setSelected(false);
++    }
++    _selectedEdge = 0;
++
++    // select
++    CanvasNode* sNode = 0;
++    if (n && n->canvasNode()) {
++	_selectedNode = n;
++	_selectedNode->canvasNode()->setSelected(true);
++
++	if (!_isMoving) sNode = _selectedNode->canvasNode();
++    }
++    if (e && e->canvasEdge()) {
++	_selectedEdge = e;
++	_selectedEdge->canvasEdge()->setSelected(true);
++
++#if 0 // don't change position when selecting edge
++	if (!_isMoving) {
++	    if (_selectedEdge->fromNode())
++		sNode = _selectedEdge->fromNode()->canvasNode();
++	    if (!sNode && _selectedEdge->toNode())
++		sNode = _selectedEdge->toNode()->canvasNode();
++	}
++#endif
++    }
++    if (sNode) {
++	double x = sNode->x() + sNode->width()/2;
++	double y = sNode->y() + sNode->height()/2;
++
++	ensureVisible(int(x),int(y),
++                      sNode->width()/2+50, sNode->height()/2+50);
++    }
++
++    _canvas->update();
++    return;
++  }
++
++  if (changeType == groupTypeChanged) {
++    if (!_canvas) return;
++
++    if (_clusterGroups) { 
++      refresh(); 
++      return;
++    }
++
++    TQCanvasItemList l = _canvas->allItems();
++    TQCanvasItemList::iterator it;
++    for (it = l.begin();it != l.end(); ++it)
++	if ((*it)->rtti() == CANVAS_NODE)
++	    ((CanvasNode*) (*it))->updateGroup();
++
++    _canvas->update();
++    return;
++  }
++
++  if (changeType & dataChanged) {
++      // invalidate old selection and graph part
++    _exporter.reset(_data, _activeItem, _costType, _groupType);
++      _selectedNode = 0;
++      _selectedEdge = 0;
++  }
++
++  refresh();
++}
++
++void CallGraphView::clear()
++{
++  if (!_canvas) return;
++
++  delete _canvas;
++  _canvas = 0;
++  _completeView->setCanvas(0);
++  setCanvas(0);
++}
++
++void CallGraphView::showText(TQString s)
++{
++  clear();
++  _renderTimer.stop();
++
++  _canvas = new TQCanvas(TQApplication::desktop()->width(),
++			TQApplication::desktop()->height());
++
++  TQCanvasText* t = new TQCanvasText(s, _canvas);
++  t->move(5, 5);
++  t->show();
++  center(0,0);
++  setCanvas(_canvas);
++  _canvas->update();
++  _completeView->hide();
++}
++
++void CallGraphView::showRenderWarning()
++{
++  TQString s;
++
++  if (_renderProcess)
++    s =i18n("Warning: a long lasting graph layouting is in progress.\n"
++	    "Reduce node/edge limits for speedup.\n");
++  else
++    s = i18n("Layouting stopped.\n");
++  
++  s.append(i18n("The call graph has %1 nodes and %2 edges.\n")
++	   .arg(_exporter.nodeCount())
++	   .arg(_exporter.edgeCount()));
++
++  showText(s);
++}
++
++void CallGraphView::stopRendering()
++{
++  if (!_renderProcess) return;
++
++  _renderProcess->kill();
++  delete _renderProcess;
++  _renderProcess = 0;
++  _unparsedOutput = TQString();
++
++  _renderTimer.start(200, true);
++}
++
++void CallGraphView::refresh()
++{
++  // trigger start of background rendering
++  if (_renderProcess) stopRendering();
++
++  // we want to keep a selected node item at the same global position
++  _prevSelectedNode = _selectedNode;
++  _prevSelectedPos = TQPoint(-1,-1);
++  if (_selectedNode) {
++    TQPoint center = _selectedNode->canvasNode()->boundingRect().center();
++    _prevSelectedPos  = contentsToViewport(center);
++  }
++
++  if (!_data || !_activeItem) {
++    showText(i18n("No item activated for which to draw the call graph."));
++    return;
++  }
++
++  TraceItem::CostType t = _activeItem->type();
++  switch(t) {
++  case TraceItem::Function:
++  case TraceItem::FunctionCycle:
++  case TraceItem::Call:
++    break;
++  default:
++    showText(i18n("No call graph can be drawn for the active item."));
++    return;
++  }
++
++  if (1) kdDebug() << "CallGraphView::refresh" << endl;
++
++  _selectedNode = 0;
++  _selectedEdge = 0;
++  _exporter.reset(_data, _activeItem, _costType, _groupType);
++  _exporter.writeDot();
++
++  _renderProcess = new TQProcess(TQT_TQOBJECT(this));
++  if (_layout == GraphOptions::Circular)
++    _renderProcess->addArgument( "twopi" );
++  else
++    _renderProcess->addArgument( "dot" );
++  _renderProcess->addArgument(_exporter.filename());
++  _renderProcess->addArgument( "-Tplain" );
++
++  connect( _renderProcess, TQT_SIGNAL(readyReadStdout()),
++	   this, TQT_SLOT(readDotOutput()) );
++  connect( _renderProcess, TQT_SIGNAL(processExited()),
++	   this, TQT_SLOT(dotExited()) );
++
++  if (1) kdDebug() << "Running '" 
++		   << _renderProcess->arguments().join(" ")
++		   << "'..." << endl;
++
++  if ( !_renderProcess->start() ) {
++    TQString e = i18n("No call graph is available because the following\n"
++		     "command cannot be run:\n'%1'\n")
++      .arg(_renderProcess->arguments().join(" "));
++    e += i18n("Please check that 'dot' is installed (package GraphViz).");
++    showText(e);
++
++    delete _renderProcess;
++    _renderProcess = 0;
++
++    return;
++  }
++
++  _unparsedOutput = TQString();
++
++  // layouting of more than seconds is dubious
++  _renderTimer.start(1000, true);  
++}
++
++void CallGraphView::readDotOutput()
++{
++  _unparsedOutput.append( _renderProcess->readStdout() );
++}
++
++void CallGraphView::dotExited()
++{
++  TQString line, cmd;
++  CanvasNode *rItem;
++  TQCanvasEllipse* eItem;
++  CanvasEdge* sItem;
++  CanvasEdgeLabel* lItem;
++  TQTextStream* dotStream;
++  double scale = 1.0, scaleX = 1.0, scaleY = 1.0;
++  double dotWidth, dotHeight;
++  GraphNode* activeNode = 0;
++  GraphEdge* activeEdge = 0;
++
++  _renderTimer.stop();
++  viewport()->setUpdatesEnabled(false);
++  clear();
++  dotStream = new TQTextStream(_unparsedOutput, IO_ReadOnly);
++
++  int lineno = 0;
++  while (1) {
++    line = dotStream->readLine();
++    if (line.isNull()) break;
++    lineno++;
++    if (line.isEmpty()) continue;
++
++    TQTextStream lineStream(line, IO_ReadOnly);
++    lineStream >> cmd;
++
++    if (0) qDebug("%s:%d - line '%s', cmd '%s'",
++                  _exporter.filename().ascii(), lineno,
++                  line.ascii(), cmd.ascii());
++
++    if (cmd == "stop") break;
++
++    if (cmd == "graph") {
++      TQString dotWidthString, dotHeightString;
++      lineStream >> scale >> dotWidthString >> dotHeightString;
++      dotWidth = dotWidthString.toDouble();
++      dotHeight = dotHeightString.toDouble();
++
++      if (_detailLevel == 0)      { scaleX = scale * 70; scaleY = scale * 40; }
++      else if (_detailLevel == 1) { scaleX = scale * 80; scaleY = scale * 70; }
++      else                        { scaleX = scale * 60; scaleY = scale * 100; }
++
++      if (!_canvas) {
++        int w = (int)(scaleX * dotWidth);
++        int h = (int)(scaleY * dotHeight);
++
++	// We use as minimum canvas size the desktop size.
++	// Otherwise, the canvas would have to be resized on widget resize.
++	_xMargin = 50;
++	if (w < TQApplication::desktop()->width())
++	    _xMargin += (TQApplication::desktop()->width()-w)/2;
++
++	_yMargin = 50;
++	if (h < TQApplication::desktop()->height())
++	    _yMargin += (TQApplication::desktop()->height()-h)/2;
++
++        _canvas = new TQCanvas(int(w+2*_xMargin), int(h+2*_yMargin));
++
++#if DEBUG_GRAPH
++        kdDebug() << _exporter.filename().ascii() << ":" << lineno
++		  << " - graph (" << dotWidth << " x " << dotHeight
++		  << ") => (" << w << " x " << h << ")" << endl;
++#endif
++      }
++      else
++        kdWarning() << "Ignoring 2nd 'graph' from dot ("
++		    << _exporter.filename() << ":" << lineno << ")" << endl;
++      continue;
++    }
++
++    if ((cmd != "node") && (cmd != "edge")) {
++      kdWarning() << "Ignoring unknown command '" << cmd << "' from dot ("
++		    << _exporter.filename() << ":" << lineno << ")" << endl;
++      continue;
++    }
++
++    if (_canvas == 0) {
++      kdWarning() << "Ignoring '" << cmd << "' without 'graph' from dot ("
++		  << _exporter.filename() << ":" << lineno << ")" << endl;
++      continue;
++    }
++
++    if (cmd == "node") {
++      // x, y are centered in node
++      TQString nodeName, label, nodeX, nodeY, nodeWidth, nodeHeight;
++      double x, y, width, height;
++      lineStream >> nodeName >> nodeX >> nodeY >> nodeWidth >> nodeHeight;
++      x = nodeX.toDouble();
++      y = nodeY.toDouble();
++      width = nodeWidth.toDouble();
++      height = nodeHeight.toDouble();
++
++      GraphNode* n = _exporter.node(_exporter.toFunc(nodeName));
++
++      int xx = (int)(scaleX * x + _xMargin);
++      int yy = (int)(scaleY * (dotHeight - y) + _yMargin);
++      int w = (int)(scaleX * width);
++      int h = (int)(scaleY * height);
++
++#if DEBUG_GRAPH
++      kdDebug() << _exporter.filename() << ":" << lineno
++		<< " - node '" << nodeName << "' ( "
++		<< x << "/" << y << " - "
++		<< width << "x" << height << " ) => ("
++		<< xx-w/2 << "/" << yy-h/2 << " - "
++		<< w << "x" << h << ")" << endl;
++#endif
++
++
++      // Unnamed nodes with collapsed edges (with 'R' and 'S')
++      if (nodeName[0] == 'R' || nodeName[0] == 'S') {
++	  w = 10, h = 10;
++        eItem = new TQCanvasEllipse(w, h, _canvas);
++        eItem->move(xx, yy);
++        eItem->setBrush(TQt::gray);
++        eItem->setZ(1.0);
++        eItem->show();
++        continue;
++      }
++
++      if (!n) {
++	  qDebug("Warning: Unknown function '%s' ?!", nodeName.ascii());
++	  continue;
++      }
++      n->setVisible(true);
++
++      rItem = new CanvasNode(this, n, xx-w/2, yy-h/2, w, h, _canvas);
++      n->setCanvasNode(rItem);
++
++      if (n) {
++        if (n->function() == activeItem()) activeNode = n;
++        if (n->function() == selectedItem()) _selectedNode = n;
++        rItem->setSelected(n == _selectedNode);
++      }
++
++      rItem->setZ(1.0);
++      rItem->show();
++
++      continue;
++    }
++
++    // edge
++
++    TQString node1Name, node2Name, label, edgeX, edgeY;
++    double x, y;
++    TQPointArray pa;
++    int points, i;
++    lineStream >> node1Name >> node2Name >> points;
++
++    GraphEdge* e = _exporter.edge(_exporter.toFunc(node1Name),
++                                  _exporter.toFunc(node2Name));
++    if (!e) {
++      kdWarning() << "Unknown edge '" << node1Name << "'-'"
++		  << node2Name << "' from dot ("
++		  << _exporter.filename() << ":" << lineno << ")" << endl;
++      continue;
++    }
++    e->setVisible(true);
++    if (e->fromNode()) e->fromNode()->callings.append(e);
++    if (e->toNode()) e->toNode()->callers.append(e);
++
++    if (0) qDebug("  Edge with %d points:", points);
++
++    pa.resize(points);
++    for (i=0;i<points;i++) {
++      if (lineStream.atEnd()) break;
++      lineStream >> edgeX >> edgeY;
++      x = edgeX.toDouble();
++      y = edgeY.toDouble();
++
++      int xx = (int)(scaleX * x + _xMargin);
++      int yy = (int)(scaleY * (dotHeight - y) + _yMargin);
++
++      if (0) qDebug("   P %d: ( %f / %f ) => ( %d / %d)",
++                    i, x, y, xx, yy);
++
++      pa.setPoint(i, xx, yy);
++    }
++    if (i < points) {
++      qDebug("CallGraphView: Can't read %d spline points (%s:%d)",
++             points, _exporter.filename().ascii(), lineno);
++      continue;
++    }
++
++    // calls into/out of cycles are special: make them blue
++    TQColor arrowColor = TQt::black;
++    TraceFunction* caller = e->fromNode() ? e->fromNode()->function() : 0;
++    TraceFunction* called = e->toNode() ? e->toNode()->function() : 0;
++    if ( (caller && (caller->cycle() == caller)) ||
++         (called && (called->cycle() == called)) ) arrowColor = TQt::blue;
++
++    sItem = new CanvasEdge(e, _canvas);
++    e->setCanvasEdge(sItem);
++    sItem->setControlPoints(pa, false);
++    sItem->setPen(TQPen(arrowColor, 1 /*(int)log(log(e->cost))*/ ));
++    sItem->setZ(0.5);
++    sItem->show();
++
++    if (e->call() == selectedItem()) _selectedEdge = e;
++    if (e->call() == activeItem()) activeEdge = e;
++    sItem->setSelected(e == _selectedEdge);
++
++    // Arrow head
++    TQPoint arrowDir;
++    int indexHead = -1;
++
++    // check if head is at start of spline...
++    // this is needed because dot always gives points from top to bottom
++    CanvasNode* fromNode = e->fromNode() ? e->fromNode()->canvasNode() : 0;
++    if (fromNode) {
++      TQPoint toCenter = fromNode->rect().center();
++      int dx0 = pa.point(0).x() - toCenter.x();
++      int dy0 = pa.point(0).y() - toCenter.y();
++      int dx1 = pa.point(points-1).x() - toCenter.x();
++      int dy1 = pa.point(points-1).y() - toCenter.y();
++      if (dx0*dx0+dy0*dy0 > dx1*dx1+dy1*dy1) {
++	// start of spline is nearer to call target node
++	indexHead=-1;
++	while(arrowDir.isNull() && (indexHead<points-2)) {
++	  indexHead++;
++	  arrowDir = pa.point(indexHead) - pa.point(indexHead+1);
++	}
++      }
++    }
++
++    if (arrowDir.isNull()) {
++      indexHead = points;
++      // sometimes the last spline points from dot are the same...
++      while(arrowDir.isNull() && (indexHead>1)) {
++	indexHead--;
++	arrowDir = pa.point(indexHead) - pa.point(indexHead-1);
++      }
++    }
++
++    if (!arrowDir.isNull()) {
++	// arrow around pa.point(indexHead) with direction arrowDir
++	arrowDir *= 10.0/sqrt(double(arrowDir.x()*arrowDir.x() +
++			             arrowDir.y()*arrowDir.y()));
++	TQPointArray a(3);
++	a.setPoint(0, pa.point(indexHead) + arrowDir);
++	a.setPoint(1, pa.point(indexHead) + TQPoint(arrowDir.y()/2,
++						   -arrowDir.x()/2));
++	a.setPoint(2, pa.point(indexHead) + TQPoint(-arrowDir.y()/2,
++						   arrowDir.x()/2));
++
++	if (0) qDebug("  Arrow: ( %d/%d, %d/%d, %d/%d)",
++		      a.point(0).x(), a.point(0).y(),
++		      a.point(1).x(), a.point(1).y(),
++		      a.point(2).x(), a.point(2).y());
++
++	CanvasEdgeArrow* aItem = new CanvasEdgeArrow(sItem,_canvas);
++	aItem->setPoints(a);
++	aItem->setBrush(arrowColor);
++	aItem->setZ(1.5);
++	aItem->show();
++
++	sItem->setArrow(aItem);
++    }
++
++    if (lineStream.atEnd()) continue;
++
++    // parse quoted label
++    TQChar c;
++    lineStream >> c;
++    while (c.isSpace()) lineStream >> c;
++    if (c != '\"') {
++      lineStream >> label;
++      label = c + label;
++    }
++    else {
++      lineStream >> c;
++      while(!c.isNull() && (c != '\"')) {
++        //if (c == '\\') lineStream >> c;
++
++        label += c;
++        lineStream >> c;
++      }
++    }
++    lineStream >> edgeX >> edgeY;
++    x = edgeX.toDouble();
++    y = edgeY.toDouble();
++
++    int xx = (int)(scaleX * x + _xMargin);
++    int yy = (int)(scaleY * (dotHeight - y) + _yMargin);
++
++    if (0) qDebug("   Label '%s': ( %f / %f ) => ( %d / %d)",
++                  label.ascii(), x, y, xx, yy);
++
++    // Fixed Dimensions for Label: 100 x 40
++    int w = 100;
++    int h = _detailLevel * 20;
++    lItem = new CanvasEdgeLabel(this, sItem, xx-w/2, yy-h/2, w, h, _canvas);
++    // edge labels above nodes
++    lItem->setZ(1.5);
++    sItem->setLabel(lItem);
++    if (h>0) lItem->show();
++
++  }
++  delete dotStream;
++
++  // for keyboard navigation
++  // TODO: Edge sorting. Better keep left-to-right edge order from dot now
++  // _exporter.sortEdges();
++
++  if (!_canvas) {
++    _canvas = new TQCanvas(size().width(),size().height());
++    TQString s = i18n("Error running the graph layouting tool.\n");
++    s += i18n("Please check that 'dot' is installed (package GraphViz).");
++    TQCanvasText* t = new TQCanvasText(s, _canvas);
++    t->move(5, 5);
++    t->show();
++    center(0,0);
++  }
++  else if (!activeNode && !activeEdge) {
++    TQString s = i18n("There is no call graph available for function\n"
++		     "\t'%1'\n"
++		     "because it has no cost of the selected event type.");
++    TQCanvasText* t = new TQCanvasText(s.arg(_activeItem->name()), _canvas);
++    //    t->setTextFlags(TQt::AlignHCenter | TQt::AlignVCenter);
++    t->move(5,5);
++    t->show();
++    center(0,0);
++  }
++
++  _completeView->setCanvas(_canvas);
++  setCanvas(_canvas);
++
++  // if we don't have a selection, or the old selection is not
++  // in visible graph, make active function selected for this view
++  if ((!_selectedNode || !_selectedNode->canvasNode()) &&
++      (!_selectedEdge || !_selectedEdge->canvasEdge())) {
++    if (activeNode) {
++      _selectedNode = activeNode;
++      _selectedNode->canvasNode()->setSelected(true);
++    }
++    else if (activeEdge) {
++      _selectedEdge = activeEdge;
++      _selectedEdge->canvasEdge()->setSelected(true);
++    }
++  }
++
++  CanvasNode* sNode = 0;
++  if (_selectedNode)
++      sNode = _selectedNode->canvasNode();
++  else if (_selectedEdge) {
++      if (_selectedEdge->fromNode())
++	  sNode = _selectedEdge->fromNode()->canvasNode();
++      if (!sNode && _selectedEdge->toNode())
++	  sNode = _selectedEdge->toNode()->canvasNode();
++  }
++  if (sNode) {
++      int x = int(sNode->x() + sNode->width()/2);
++      int y = int(sNode->y() + sNode->height()/2);
++
++      if (_prevSelectedNode) {
++	  if (rect().contains(_prevSelectedPos))
++	      setContentsPos(x-_prevSelectedPos.x(),
++                             y-_prevSelectedPos.y());
++	  else
++	      ensureVisible(x,y,
++                            sNode->width()/2+50, sNode->height()/2+50);
++      }
++      else center(x,y);
++  }
++
++  if (activeNode) {
++    CanvasNode* cn = activeNode->canvasNode();
++    CanvasFrame* f = new CanvasFrame(cn, _canvas);
++    f->setZ(-1);
++    f->show();
++  }
++
++  _cvZoom = 0;
++  updateSizes();
++
++  _canvas->update();
++  viewport()->setUpdatesEnabled(true);
++
++  delete _renderProcess;
++  _renderProcess = 0;
++}
++
++void CallGraphView::contentsMovingSlot(int x, int y)
++{
++  TQRect z(int(x * _cvZoom), int(y * _cvZoom),
++          int(visibleWidth() * _cvZoom)-1, int(visibleHeight() * _cvZoom)-1);
++  if (0) qDebug("moving: (%d,%d) => (%d/%d - %dx%d)",
++                x, y, z.x(), z.y(), z.width(), z.height());
++  _completeView->setZoomRect(z);
++}
++
++void CallGraphView::zoomRectMoved(int dx, int dy)
++{
++  if (leftMargin()>0) dx = 0;
++  if (topMargin()>0) dy = 0;
++  scrollBy(int(dx/_cvZoom),int(dy/_cvZoom));
++}
++
++void CallGraphView::zoomRectMoveFinished()
++{
++    if (_zoomPosition == Auto) updateSizes();
++}
++
++void CallGraphView::contentsMousePressEvent(TQMouseEvent* e)
++{
++    // clicking on the viewport sets focus
++    setFocus();
++
++  _isMoving = true;
++
++  TQCanvasItemList l = canvas()->collisions(e->pos());
++  if (l.count()>0) {
++    TQCanvasItem* i = l.first();
++
++    if (i->rtti() == CANVAS_NODE) {
++      GraphNode* n = ((CanvasNode*)i)->node();
++      if (0) qDebug("CallGraphView: Got Node '%s'",
++                    n->function()->prettyName().ascii());
++
++      selected(n->function());
++    }
++
++    // redirect from label / arrow to edge
++    if (i->rtti() == CANVAS_EDGELABEL)
++	i = ((CanvasEdgeLabel*)i)->canvasEdge();
++    if (i->rtti() == CANVAS_EDGEARROW)
++	i = ((CanvasEdgeArrow*)i)->canvasEdge();
++
++    if (i->rtti() == CANVAS_EDGE) {
++      GraphEdge* e = ((CanvasEdge*)i)->edge();
++      if (0) qDebug("CallGraphView: Got Edge '%s'",
++                    e->prettyName().ascii());
++
++      if (e->call()) selected(e->call());
++    }
++  }
++  _lastPos = e->globalPos();
++}
++
++void CallGraphView::contentsMouseMoveEvent(TQMouseEvent* e)
++{
++  if (_isMoving) {
++    int dx = e->globalPos().x() - _lastPos.x();
++    int dy = e->globalPos().y() - _lastPos.y();
++    scrollBy(-dx, -dy);
++    _lastPos = e->globalPos();
++  }
++}
++
++void CallGraphView::contentsMouseReleaseEvent(TQMouseEvent*)
++{
++  _isMoving = false;
++  if (_zoomPosition == Auto) updateSizes();
++}
++
++void CallGraphView::contentsMouseDoubleClickEvent(TQMouseEvent* e)
++{
++  TQCanvasItemList l = canvas()->collisions(e->pos());
++  if (l.count() == 0) return;
++  TQCanvasItem* i = l.first();
++
++  if (i->rtti() == CANVAS_NODE) {
++    GraphNode* n = ((CanvasNode*)i)->node();
++    if (0) qDebug("CallGraphView: Double Clicked on Node '%s'",
++		  n->function()->prettyName().ascii());
++
++    activated(n->function());
++  }
++
++  // redirect from label / arrow to edge
++  if (i->rtti() == CANVAS_EDGELABEL)
++      i = ((CanvasEdgeLabel*)i)->canvasEdge();
++  if (i->rtti() == CANVAS_EDGEARROW)
++      i = ((CanvasEdgeArrow*)i)->canvasEdge();
++
++  if (i->rtti() == CANVAS_EDGE) {
++    GraphEdge* e = ((CanvasEdge*)i)->edge();
++    if (e->call()) {
++      if (0) qDebug("CallGraphView: Double Clicked On Edge '%s'",
++		    e->call()->prettyName().ascii());
++
++      activated(e->call());
++    }
++  }
++}
++
++void CallGraphView::contentsContextMenuEvent(TQContextMenuEvent* e)
++{
++  TQCanvasItemList l = canvas()->collisions(e->pos());
++  TQCanvasItem* i = (l.count() == 0) ? 0 : l.first();
++
++  TQPopupMenu popup;
++  TraceFunction *f = 0, *cycle = 0;
++  TraceCall* c = 0;
++
++  if (i) {
++    if (i->rtti() == CANVAS_NODE) {
++      GraphNode* n = ((CanvasNode*)i)->node();
++      if (0) qDebug("CallGraphView: Menu on Node '%s'",
++		    n->function()->prettyName().ascii());
++      f = n->function();
++      cycle = f->cycle();
++
++      TQString name = f->prettyName();
++      popup.insertItem(i18n("Go to '%1'")
++		     .arg(Configuration::shortenSymbol(name)), 93);
++      if (cycle && (cycle != f)) {
++	name = Configuration::shortenSymbol(cycle->prettyName());
++	popup.insertItem(i18n("Go to '%1'").arg(name), 94);
++      }
++      popup.insertSeparator();
++    }
++
++    // redirect from label / arrow to edge
++    if (i->rtti() == CANVAS_EDGELABEL)
++	i = ((CanvasEdgeLabel*)i)->canvasEdge();
++    if (i->rtti() == CANVAS_EDGEARROW)
++	i = ((CanvasEdgeArrow*)i)->canvasEdge();
++
++    if (i->rtti() == CANVAS_EDGE) {
++      GraphEdge* e = ((CanvasEdge*)i)->edge();
++      if (0) qDebug("CallGraphView: Menu on Edge '%s'",
++		    e->prettyName().ascii());
++      c = e->call();
++      if (c) {
++	  TQString name = c->prettyName();
++	  popup.insertItem(i18n("Go to '%1'")
++			   .arg(Configuration::shortenSymbol(name)), 95);
++
++	  popup.insertSeparator();
++      }
++    }
++  }
++
++  if (_renderProcess) {
++    popup.insertItem(i18n("Stop Layouting"), 999);
++    popup.insertSeparator();
++  }
++
++  addGoMenu(&popup);
++  popup.insertSeparator();
++
++  TQPopupMenu epopup;
++  epopup.insertItem(i18n("As PostScript"), 201);
++  epopup.insertItem(i18n("As Image ..."), 202);
++
++  popup.insertItem(i18n("Export Graph"), &epopup, 200);
++  popup.insertSeparator();
++
++  TQPopupMenu gpopup1;
++  gpopup1.setCheckable(true);
++  gpopup1.insertItem(i18n("Unlimited"), 100);
++  gpopup1.setItemEnabled(100, (_funcLimit>0.005));
++  gpopup1.insertSeparator();
++  gpopup1.insertItem(i18n("None"), 101);
++  gpopup1.insertItem(i18n("max. 2"), 102);
++  gpopup1.insertItem(i18n("max. 5"), 103);
++  gpopup1.insertItem(i18n("max. 10"), 104);
++  gpopup1.insertItem(i18n("max. 15"), 105);
++  if (_maxCallerDepth<-1) _maxCallerDepth=-1;
++  switch(_maxCallerDepth) {
++  case -1: gpopup1.setItemChecked(100,true); break;
++  case  0: gpopup1.setItemChecked(101,true); break;
++  case  2: gpopup1.setItemChecked(102,true); break;
++  case  5: gpopup1.setItemChecked(103,true); break;
++  case 10: gpopup1.setItemChecked(104,true); break;
++  case 15: gpopup1.setItemChecked(105,true); break;
++  default:
++    gpopup1.insertItem(i18n("< %1").arg(_maxCallerDepth), 106);
++    gpopup1.setItemChecked(106,true); break;
++  }
++
++  TQPopupMenu gpopup2;
++  gpopup2.setCheckable(true);
++  gpopup2.insertItem(i18n("Unlimited"), 110);
++  gpopup2.setItemEnabled(110, (_funcLimit>0.005));
++  gpopup2.insertSeparator();
++  gpopup2.insertItem(i18n("None"), 111);
++  gpopup2.insertItem(i18n("max. 2"), 112);
++  gpopup2.insertItem(i18n("max. 5"), 113);
++  gpopup2.insertItem(i18n("max. 10"), 114);
++  gpopup2.insertItem(i18n("max. 15"), 115);
++  if (_maxCallingDepth<-1) _maxCallingDepth=-1;
++  switch(_maxCallingDepth) {
++  case -1: gpopup2.setItemChecked(110,true); break;
++  case  0: gpopup2.setItemChecked(111,true); break;
++  case  2: gpopup2.setItemChecked(112,true); break;
++  case  5: gpopup2.setItemChecked(113,true); break;
++  case 10: gpopup2.setItemChecked(114,true); break;
++  case 15: gpopup2.setItemChecked(115,true); break;
++  default:
++    gpopup2.insertItem(i18n("< %1").arg(_maxCallingDepth), 116);
++    gpopup2.setItemChecked(116,true); break;
++  }
++
++  TQPopupMenu gpopup3;
++  gpopup3.setCheckable(true);
++  gpopup3.insertItem(i18n("No Minimum"), 120);
++  gpopup3.setItemEnabled(120,
++                         (_maxCallerDepth>=0) && (_maxCallingDepth>=0));
++  gpopup3.insertSeparator();
++  gpopup3.insertItem(i18n("50 %"), 121);
++  gpopup3.insertItem(i18n("20 %"), 122);
++  gpopup3.insertItem(i18n("10 %"), 123);
++  gpopup3.insertItem(i18n("5 %"), 124);
++  gpopup3.insertItem(i18n("3 %"), 125);
++  gpopup3.insertItem(i18n("2 %"), 126);
++  gpopup3.insertItem(i18n("1.5 %"), 127);
++  gpopup3.insertItem(i18n("1 %"), 128);
++  if (_funcLimit<0) _funcLimit = DEFAULT_FUNCLIMIT;
++  if (_funcLimit>.5) _funcLimit = .5;
++  if (_funcLimit == 0.0) gpopup3.setItemChecked(120,true);
++  else if (_funcLimit >= 0.5) gpopup3.setItemChecked(121,true);
++  else if (_funcLimit >= 0.2) gpopup3.setItemChecked(122,true);
++  else if (_funcLimit >= 0.1) gpopup3.setItemChecked(123,true);
++  else if (_funcLimit >= 0.05) gpopup3.setItemChecked(124,true);
++  else if (_funcLimit >= 0.03) gpopup3.setItemChecked(125,true);
++  else if (_funcLimit >= 0.02) gpopup3.setItemChecked(126,true);
++  else if (_funcLimit >= 0.015) gpopup3.setItemChecked(127,true);
++  else gpopup3.setItemChecked(128,true);
++  double oldFuncLimit = _funcLimit;
++
++  TQPopupMenu gpopup4;
++  gpopup4.setCheckable(true);
++  gpopup4.insertItem(i18n("Same as Node"), 160);
++  gpopup4.insertItem(i18n("50 % of Node"), 161);
++  gpopup4.insertItem(i18n("20 % of Node"), 162);
++  gpopup4.insertItem(i18n("10 % of Node"), 163);
++  if (_callLimit<0) _callLimit = DEFAULT_CALLLIMIT;
++  if (_callLimit >= _funcLimit) _callLimit = _funcLimit;
++  if (_callLimit == _funcLimit) gpopup4.setItemChecked(160,true);
++  else if (_callLimit >= 0.5 * _funcLimit) gpopup4.setItemChecked(161,true);
++  else if (_callLimit >= 0.2 * _funcLimit) gpopup4.setItemChecked(162,true);
++  else gpopup4.setItemChecked(163,true);
++
++  TQPopupMenu gpopup;
++  gpopup.setCheckable(true);
++  gpopup.insertItem(i18n("Caller Depth"), &gpopup1, 80);
++  gpopup.insertItem(i18n("Callee Depth"), &gpopup2, 81);
++  gpopup.insertItem(i18n("Min. Node Cost"), &gpopup3, 82);
++  gpopup.insertItem(i18n("Min. Call Cost"), &gpopup4, 83);
++  gpopup.insertSeparator();
++  gpopup.insertItem(i18n("Arrows for Skipped Calls"), 130);
++  gpopup.setItemChecked(130,_showSkipped);
++  gpopup.insertItem(i18n("Inner-cycle Calls"), 131);
++  gpopup.setItemChecked(131,_expandCycles);
++  gpopup.insertItem(i18n("Cluster Groups"), 132);
++  gpopup.setItemChecked(132,_clusterGroups);
++
++  TQPopupMenu vpopup;
++  vpopup.setCheckable(true);
++  vpopup.insertItem(i18n("Compact"), 140);
++  vpopup.insertItem(i18n("Normal"), 141);
++  vpopup.insertItem(i18n("Tall"), 142);
++  vpopup.setItemChecked(140,_detailLevel == 0);
++  vpopup.setItemChecked(141,_detailLevel == 1);
++  vpopup.setItemChecked(142,_detailLevel == 2);
++  vpopup.insertSeparator();
++  vpopup.insertItem(i18n("Top to Down"), 150);
++  vpopup.insertItem(i18n("Left to Right"), 151);
++  vpopup.insertItem(i18n("Circular"), 152);
++  vpopup.setItemChecked(150,_layout == TopDown);
++  vpopup.setItemChecked(151,_layout == LeftRight);
++  vpopup.setItemChecked(152,_layout == Circular);
++
++  TQPopupMenu opopup;
++  opopup.insertItem(i18n("TopLeft"), 170);
++  opopup.insertItem(i18n("TopRight"), 171);
++  opopup.insertItem(i18n("BottomLeft"), 172);
++  opopup.insertItem(i18n("BottomRight"), 173);
++  opopup.insertItem(i18n("Automatic"), 174);
++  opopup.setItemChecked(170,_zoomPosition == TopLeft);
++  opopup.setItemChecked(171,_zoomPosition == TopRight);
++  opopup.setItemChecked(172,_zoomPosition == BottomLeft);
++  opopup.setItemChecked(173,_zoomPosition == BottomRight);
++  opopup.setItemChecked(174,_zoomPosition == Auto);
++
++  popup.insertItem(i18n("Graph"), &gpopup, 70);
++  popup.insertItem(i18n("Visualization"), &vpopup, 71);
++  popup.insertItem(i18n("Birds-eye View"), &opopup, 72);
++
++  int r = popup.exec(e->globalPos());
++
++  switch(r) {
++  case 93: activated(f); break;
++  case 94: activated(cycle); break;
++  case 95: activated(c); break;
++
++  case 999: stopRendering(); break;
++
++  case 201:
++      {
++	  TraceFunction* f = activeFunction();
++	  if (!f) break;
++
++	  GraphExporter ge(TraceItemView::data(), f, costType(), groupType(),
++			   TQString("callgraph.dot"));
++	  ge.setGraphOptions(this);
++	  ge.writeDot();
++
++	  system("(dot callgraph.dot -Tps > callgraph.ps; kghostview callgraph.ps)&");
++      }
++      break;
++
++  case 202:    
++      // write current content of canvas as image to file
++      {
++	if (!_canvas) return;
++
++	TQString fn = KFileDialog::getSaveFileName(":","*.png");
++
++	if (!fn.isEmpty()) {
++	  TQPixmap pix(_canvas->size());
++	  TQPainter p(&pix);
++	  _canvas->drawArea( _canvas->rect(), &p );
++	  pix.save(fn,"PNG");
++	}
++      }
++      break;
++
++  case 100: _maxCallerDepth = -1; break;
++  case 101: _maxCallerDepth = 0; break;
++  case 102: _maxCallerDepth = 2; break;
++  case 103: _maxCallerDepth = 5; break;
++  case 104: _maxCallerDepth = 10; break;
++  case 105: _maxCallerDepth = 15; break;
++
++  case 110: _maxCallingDepth = -1; break;
++  case 111: _maxCallingDepth = 0; break;
++  case 112: _maxCallingDepth = 2; break;
++  case 113: _maxCallingDepth = 5; break;
++  case 114: _maxCallingDepth = 10; break;
++  case 115: _maxCallingDepth = 15; break;
++
++  case 120: _funcLimit = 0; break;
++  case 121: _funcLimit = 0.5; break;
++  case 122: _funcLimit = 0.2; break;
++  case 123: _funcLimit = 0.1; break;
++  case 124: _funcLimit = 0.05; break;
++  case 125: _funcLimit = 0.03; break;
++  case 126: _funcLimit = 0.02; break;
++  case 127: _funcLimit = 0.015; break;
++  case 128: _funcLimit = 0.01; break;
++
++  case 130: _showSkipped = !_showSkipped; break;
++  case 131: _expandCycles = !_expandCycles; break;
++  case 132: _clusterGroups = !_clusterGroups; break;
++
++  case 140: _detailLevel = 0; break;
++  case 141: _detailLevel = 1; break;
++  case 142: _detailLevel = 2; break;
++
++  case 150: _layout = TopDown; break;
++  case 151: _layout = LeftRight; break;
++  case 152: _layout = Circular; break;
++
++  case 160: _callLimit = _funcLimit; break;
++  case 161: _callLimit = .5 * _funcLimit; break;
++  case 162: _callLimit = .2 * _funcLimit; break;
++  case 163: _callLimit = .1 * _funcLimit; break;
++
++  case 170: _zoomPosition = TopLeft; break;
++  case 171: _zoomPosition = TopRight; break;
++  case 172: _zoomPosition = BottomLeft; break;
++  case 173: _zoomPosition = BottomRight; break;
++  case 174: _zoomPosition = Auto; break;
++
++  default: break;
++  }
++  if (r>=120 && r<130) _callLimit *= _funcLimit / oldFuncLimit;
++
++  if (r>99 && r<170) refresh();
++  if (r>169 && r<180) updateSizes();
++}
++
++CallGraphView::ZoomPosition CallGraphView::zoomPos(TQString s)
++{
++    if (s == TQString("TopLeft")) return TopLeft;
++    if (s == TQString("TopRight")) return TopRight;
++    if (s == TQString("BottomLeft")) return BottomLeft;
++    if (s == TQString("BottomRight")) return BottomRight;
++    if (s == TQString("Automatic")) return Auto;
++
++    return DEFAULT_ZOOMPOS;
++}
++
++TQString CallGraphView::zoomPosString(ZoomPosition p)
++{
++    if (p == TopRight) return TQString("TopRight");
++    if (p == BottomLeft) return TQString("BottomLeft");
++    if (p == BottomRight) return TQString("BottomRight");
++    if (p == Auto) return TQString("Automatic");
++
++    return TQString("TopLeft");
++}
++
++void CallGraphView::readViewConfig(KConfig* c, 
++				   TQString prefix, TQString postfix, bool)
++{
++    KConfigGroup* g = configGroup(c, prefix, postfix);
++
++    if (0) qDebug("CallGraphView::readViewConfig");
++
++    _maxCallerDepth  = g->readNumEntry("MaxCaller", DEFAULT_MAXCALLER);
++    _maxCallingDepth = g->readNumEntry("MaxCalling", DEFAULT_MAXCALLING);
++    _funcLimit       = g->readDoubleNumEntry("FuncLimit", DEFAULT_FUNCLIMIT);
++    _callLimit       = g->readDoubleNumEntry("CallLimit", DEFAULT_CALLLIMIT);
++    _showSkipped     = g->readBoolEntry("ShowSkipped", DEFAULT_SHOWSKIPPED);
++    _expandCycles    = g->readBoolEntry("ExpandCycles", DEFAULT_EXPANDCYCLES);
++    _clusterGroups   = g->readBoolEntry("ClusterGroups",
++					DEFAULT_CLUSTERGROUPS);
++    _detailLevel     = g->readNumEntry("DetailLevel", DEFAULT_DETAILLEVEL);
++    _layout          = GraphOptions::layout(g->readEntry("Layout",
++					   layoutString(DEFAULT_LAYOUT)));
++    _zoomPosition    = zoomPos(g->readEntry("ZoomPosition",
++					    zoomPosString(DEFAULT_ZOOMPOS)));
++
++    delete g;
++}
++
++void CallGraphView::saveViewConfig(KConfig* c,
++				   TQString prefix, TQString postfix, bool)
++{
++    KConfigGroup g(c, (prefix+postfix).ascii());
++
++    writeConfigEntry(&g, "MaxCaller", _maxCallerDepth, DEFAULT_MAXCALLER);
++    writeConfigEntry(&g, "MaxCalling", _maxCallingDepth, DEFAULT_MAXCALLING);
++    writeConfigEntry(&g, "FuncLimit", _funcLimit, DEFAULT_FUNCLIMIT);
++    writeConfigEntry(&g, "CallLimit", _callLimit, DEFAULT_CALLLIMIT);
++    writeConfigEntry(&g, "ShowSkipped", _showSkipped, DEFAULT_SHOWSKIPPED);
++    writeConfigEntry(&g, "ExpandCycles", _expandCycles, DEFAULT_EXPANDCYCLES);
++    writeConfigEntry(&g, "ClusterGroups", _clusterGroups,
++		     DEFAULT_CLUSTERGROUPS);
++    writeConfigEntry(&g, "DetailLevel", _detailLevel, DEFAULT_DETAILLEVEL);
++    writeConfigEntry(&g, "Layout",
++		     layoutString(_layout), layoutString(DEFAULT_LAYOUT).utf8().data());
++    writeConfigEntry(&g, "ZoomPosition",
++		     zoomPosString(_zoomPosition),
++		     zoomPosString(DEFAULT_ZOOMPOS).utf8().data());
++}
++
++#include "callgraphview.moc"
++
+diff --git a/kdecachegrind/kdecachegrind/callgraphview.h b/kdecachegrind/kdecachegrind/callgraphview.h
+new file mode 100644
+index 0000000..4db619d
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/callgraphview.h
+@@ -0,0 +1,501 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Callgraph View
++ */
++
++#ifndef CALLGRAPHVIEW_H
++#define CALLGRAPHVIEW_H
++
++#include <tqcanvas.h>
++#include <tqwidget.h>
++#include <tqmap.h>
++#include <tqtimer.h>
++
++#include "treemap.h" // for DrawParams
++#include "tracedata.h"
++#include "traceitemview.h"
++
++class TQProcess;
++
++class KTempFile;
++class CanvasNode;
++class CanvasEdge;
++class GraphEdge;
++class CallGraphView;
++
++// sorts according start/end position of a call arc
++// this depends on attached CanvasEdge's !
++class GraphEdgeList: public TQPtrList<GraphEdge>
++{
++ public:
++    GraphEdgeList();
++    void setSortCallerPos(bool b) { _sortCallerPos = b; }
++
++ protected:
++    int compareItems ( Item item1, Item item2 );
++
++ private:
++    bool _sortCallerPos;
++};
++
++
++typedef TQMap<GraphEdge*, int> GraphEdgeSet;
++
++// temporary parts of call graph to be shown
++class GraphNode
++{
++public:
++    GraphNode();
++
++  TraceFunction* function() { return _f; }
++  void setFunction(TraceFunction* f) { _f = f; }
++
++  CanvasNode* canvasNode() { return _cn; }
++  void setCanvasNode(CanvasNode* cn) { _cn = cn; }
++
++  bool isVisible() { return _visible; }
++  void setVisible(bool v) { _visible = v; }
++
++  // keyboard navigation
++  TraceCall* visibleCaller();
++  TraceCall* visibleCalling();
++  void setCalling(GraphEdge*);
++  void setCaller(GraphEdge*);
++  TraceFunction* nextVisible();
++  TraceFunction* priorVisible();
++  TraceCall* nextVisibleCaller(GraphEdge*);
++  TraceCall* nextVisibleCalling(GraphEdge*);
++  TraceCall* priorVisibleCaller(GraphEdge*);
++  TraceCall* priorVisibleCalling(GraphEdge*);
++
++  double self, incl;
++  GraphEdgeList callers, callings;
++  // for fast unique insertion of GraphEdges in above lists
++  GraphEdgeSet callerSet, callingSet;
++
++ private:
++  TraceFunction* _f;
++  CanvasNode* _cn;
++  bool _visible;
++
++  // for keyboard navigation
++  int _lastCallerIndex, _lastCallingIndex;
++  bool _lastFromCaller;
++};
++
++class GraphEdge
++{
++public:
++    GraphEdge();
++
++  CanvasEdge* canvasEdge() { return _ce; }
++  void setCanvasEdge(CanvasEdge* ce) { _ce = ce; }
++
++  TraceCall* call() { return _c; }
++  void setCall(TraceCall* c) { _c = c; }
++
++  bool isVisible() { return _visible; }
++  void setVisible(bool v) { _visible = v; }
++
++  GraphNode* fromNode() { return _fromNode; }
++  GraphNode* toNode() { return _toNode; }
++  TraceFunction* from() { return _from; }
++  TraceFunction* to() { return _to; }
++
++  // has special cases for collapsed edges
++  TQString prettyName();
++
++  void setCaller(TraceFunction* f) { _from = f; }
++  void setCalling(TraceFunction* f) { _to = f; }
++  void setCallerNode(GraphNode* n) { _fromNode = n; }
++  void setCallingNode(GraphNode* n) { _toNode = n; }
++
++  // keyboard navigation
++  TraceFunction* visibleCaller();
++  TraceFunction* visibleCalling();
++  TraceCall* nextVisible();
++  TraceCall* priorVisible();
++
++  double cost, count;
++
++ private:
++  // we have a _c *and* _from/_to because for collapsed edges,
++  // only _to or _from will be unequal NULL
++  TraceCall* _c;
++  TraceFunction * _from, * _to;
++  GraphNode *_fromNode, *_toNode;
++  CanvasEdge* _ce;
++  bool _visible;
++  // for keyboard navigation: have we last reached this edge via a caller?
++  bool _lastFromCaller;
++
++};
++
++
++typedef TQMap<TraceFunction*, GraphNode> GraphNodeMap;
++typedef TQMap<TQPair<TraceFunction*, TraceFunction*>, GraphEdge> GraphEdgeMap;
++
++
++/* Abstract Interface for graph options */
++class GraphOptions
++{
++ public:
++    enum Layout { TopDown, LeftRight, Circular};
++
++    virtual double funcLimit() = 0;
++    virtual double callLimit() = 0;
++    virtual int maxCallerDepth() = 0;
++    virtual int maxCallingDepth() = 0;
++    virtual bool showSkipped() = 0;
++    virtual bool expandCycles() = 0;
++    virtual bool clusterGroups() = 0;
++    virtual int detailLevel() = 0;
++    virtual Layout layout() = 0;
++
++    static TQString layoutString(Layout);
++    static Layout layout(TQString);
++};
++
++/* Graph Options Storage */
++class StorableGraphOptions: public GraphOptions
++{
++ public:
++    StorableGraphOptions();
++
++    // implementation of getters
++    virtual double funcLimit() { return _funcLimit; }
++    virtual double callLimit() { return _callLimit; }
++    virtual int maxCallerDepth() { return _maxCallerDepth; }
++    virtual int maxCallingDepth() { return _maxCallingDepth; }
++    virtual bool showSkipped() { return _showSkipped; }
++    virtual bool expandCycles() { return _expandCycles; }
++    virtual bool clusterGroups() { return _clusterGroups; }
++    virtual int detailLevel() { return _detailLevel; }
++    virtual Layout layout() { return _layout; }
++
++    // setters
++    void setMaxCallerDepth(int d) { _maxCallerDepth = d; }
++    void setMaxCallingDepth(int d) { _maxCallingDepth = d; }
++    void setFuncLimit(double l) { _funcLimit = l; }
++    void setCallLimit(double l) { _callLimit = l; }
++    void setShowSkipped(bool b) { _showSkipped = b; }
++    void setExpandCycles(bool b) { _expandCycles = b; }
++    void setClusterGroups(bool b) { _clusterGroups = b; }
++    void setDetailLevel(int l) { _detailLevel = l; }
++    void setLayout(Layout l) { _layout = l; }
++
++ protected:
++    double _funcLimit, _callLimit;
++    int _maxCallerDepth, _maxCallingDepth;
++    bool _showSkipped, _expandCycles, _clusterGroups;
++    int _detailLevel;
++    Layout _layout;
++};
++
++/**
++ * GraphExporter
++ *
++ * Generates a graph file for "dot"
++ * Create an instance and
++ */
++class GraphExporter: public StorableGraphOptions
++{
++public:
++  GraphExporter();
++  GraphExporter(TraceData*, TraceFunction*, TraceCostType*,
++		TraceItem::CostType, TQString filename = TQString());
++  virtual ~GraphExporter();
++
++  void reset(TraceData*, TraceItem*, TraceCostType*,
++	     TraceItem::CostType, TQString filename = TQString());
++
++  TQString filename() { return _dotName; }
++  int edgeCount() { return _edgeMap.count(); }
++  int nodeCount() { return _nodeMap.count(); }
++
++  // Set the object from which to get graph options for creation.
++  // Default is this object itself (supply 0 for default)
++  void setGraphOptions(GraphOptions* go = 0);
++
++  // Create a subgraph with given limits/maxDepths
++  void createGraph();
++
++  // calls createGraph before dumping of not already created
++  void writeDot();
++
++  // to map back to structures when parsing a layouted graph
++
++  /* <toFunc> is a helper for node() and edge().
++   * Don't use the returned pointer directly, but only with
++   * node() or edge(), because it could be a dangling pointer.
++   */
++  TraceFunction* toFunc(TQString);
++  GraphNode* node(TraceFunction*);
++  GraphEdge* edge(TraceFunction*, TraceFunction*);
++
++  /* After CanvasEdges are attached to GraphEdges, we can
++   * sort the incoming and outgoing edges of all nodes
++   * regarding start/end points for keyboard navigation
++   */
++  void sortEdges();
++
++private:
++  void buildGraph(TraceFunction*, int, bool, double);
++
++  TQString _dotName;
++  TraceItem* _item;
++  TraceCostType* _costType;
++  TraceItem::CostType _groupType;
++  KTempFile* _tmpFile;
++  double _realFuncLimit, _realCallLimit;
++  int _maxDepth;
++  bool _graphCreated;
++
++  GraphOptions* _go;
++
++  // optional graph attributes
++  bool _useBox;
++
++  // graph parts written to file
++  GraphNodeMap _nodeMap;
++  GraphEdgeMap _edgeMap;
++};
++
++/**
++ * A panner layed over a TQCanvas
++ */
++class PannerView: public TQCanvasView
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  PannerView(TQWidget * parent = 0, const char * name = 0);
++
++  void setZoomRect(TQRect r);
++
++signals:
++  void zoomRectMoved(int dx, int dy);
++  void zoomRectMoveFinished();
++
++protected:
++  void contentsMousePressEvent(TQMouseEvent*);
++  void contentsMouseMoveEvent(TQMouseEvent*);
++  void contentsMouseReleaseEvent(TQMouseEvent*);
++  void drawContents(TQPainter * p, int clipx, int clipy, int clipw, int cliph);
++
++  TQRect _zoomRect;
++  bool _movingZoomRect;
++  TQPoint _lastPos;
++};
++
++
++/*
++ * Canvas Items:
++ * - CanvasNode       (Rectangular Area)
++ * - CanvasEdge       (Spline curve)
++ * - CanvasEdgeLabel  (Label for edges)
++ * - CanvasEdgeArrow  (Arrows at the end of the edge spline)
++ * - CanvasFrame      (Grey background blending to show active node)
++ */
++
++enum {
++    CANVAS_NODE = 1122,
++    CANVAS_EDGE, CANVAS_EDGELABEL, CANVAS_EDGEARROW,
++    CANVAS_FRAME
++};
++
++class CanvasNode: public TQCanvasRectangle, public StoredDrawParams
++{
++public:
++  CanvasNode(CallGraphView*,GraphNode*, int, int, int, int, TQCanvas*);
++
++  void updateGroup();
++  void setSelected(bool);
++  void drawShape(TQPainter&);
++
++  GraphNode* node() { return _node; }
++  int rtti() const { return CANVAS_NODE; }
++
++private:
++  GraphNode* _node;
++  CallGraphView* _view;
++};
++
++class CanvasEdgeLabel: public TQCanvasRectangle, public StoredDrawParams
++{
++public:
++  CanvasEdgeLabel(CallGraphView*, CanvasEdge*, int, int, int, int, TQCanvas*);
++
++  void drawShape(TQPainter&);
++
++  CanvasEdge* canvasEdge() { return _ce; }
++  int rtti() const { return CANVAS_EDGELABEL; }
++
++private:
++  CanvasEdge* _ce;
++  CallGraphView* _view;
++};
++
++class CanvasEdgeArrow: public TQCanvasPolygon
++{
++public:
++  CanvasEdgeArrow(CanvasEdge*, TQCanvas*);
++
++  void drawShape(TQPainter&);
++
++  CanvasEdge* canvasEdge() { return _ce; }
++  int rtti() const { return CANVAS_EDGEARROW; }
++
++private:
++  CanvasEdge* _ce;
++};
++
++
++class CanvasEdge: public TQCanvasSpline
++{
++public:
++  CanvasEdge(GraphEdge*, TQCanvas*);
++
++  void setSelected(bool);
++  void drawShape(TQPainter&);
++  TQPointArray areaPoints() const;
++
++  CanvasEdgeLabel* label() { return _label; }
++  void setLabel(CanvasEdgeLabel* l) { _label = l; }
++  CanvasEdgeArrow* arrow() { return _arrow; }
++  void setArrow(CanvasEdgeArrow* a) { _arrow = a; }
++
++  GraphEdge* edge() { return _edge; }
++  int rtti() const { return CANVAS_EDGE; }
++
++private:
++  GraphEdge* _edge;
++  CanvasEdgeLabel* _label;
++  CanvasEdgeArrow* _arrow;
++};
++
++
++class CanvasFrame: public TQCanvasRectangle
++{
++public:
++  CanvasFrame( CanvasNode*, TQCanvas *canvas );
++  int rtti () const { return CANVAS_FRAME; }
++  bool hit( const TQPoint&) const { return false; }
++protected:
++    void drawShape( TQPainter & );
++private:
++    static TQPixmap* _p;
++};
++
++
++class CallGraphTip;
++
++/**
++ * A CanvasView showing a part of the call graph
++ * and another zoomed out CanvasView in a border acting as
++ * a panner to select to visible part (only if needed)
++ */
++class CallGraphView: public TQCanvasView,  public TraceItemView,
++		     public StorableGraphOptions
++{
++ Q_OBJECT
++  TQ_OBJECT
++
++public:
++ enum ZoomPosition { TopLeft, TopRight, BottomLeft, BottomRight, Auto };
++
++  CallGraphView(TraceItemView* parentView,
++                TQWidget* parent=0, const char* name=0);
++  ~CallGraphView();
++
++  void readViewConfig(KConfig*, TQString prefix, TQString postfix, bool);
++  void saveViewConfig(KConfig*, TQString prefix, TQString postfix, bool);
++
++  TQWidget* widget() { return this; }
++  TQString whatsThis() const;
++
++  ZoomPosition zoomPos() const { return _zoomPosition; }
++  static ZoomPosition zoomPos(TQString);
++  static TQString zoomPosString(ZoomPosition);
++
++public slots:
++  void contentsMovingSlot(int,int);
++  void zoomRectMoved(int,int);
++  void zoomRectMoveFinished();
++
++  void showRenderWarning();
++  void stopRendering();
++  void readDotOutput();
++  void dotExited();
++
++protected:
++  void resizeEvent(TQResizeEvent*);
++  void contentsMousePressEvent(TQMouseEvent*);
++  void contentsMouseMoveEvent(TQMouseEvent*);
++  void contentsMouseReleaseEvent(TQMouseEvent*);
++  void contentsMouseDoubleClickEvent(TQMouseEvent*);
++  void contentsContextMenuEvent(TQContextMenuEvent*);
++  void keyPressEvent(TQKeyEvent*);
++  void focusInEvent(TQFocusEvent*);
++  void focusOutEvent(TQFocusEvent*);
++
++private:
++  void updateSizes(TQSize s = TQSize(0,0));
++  TraceItem* canShow(TraceItem*);
++  void doUpdate(int);
++  void refresh();
++  void makeFrame(CanvasNode*, bool active);
++  void clear();
++  void showText(TQString);
++
++  TQCanvas *_canvas;
++  int _xMargin, _yMargin;
++  PannerView *_completeView;
++  double _cvZoom;
++
++  CallGraphTip* _tip;
++
++  bool _isMoving;
++  TQPoint _lastPos;
++
++  GraphExporter _exporter;
++
++  GraphNode* _selectedNode;
++  GraphEdge* _selectedEdge;
++
++  // widget options
++  ZoomPosition _zoomPosition, _lastAutoPosition;
++
++  // background rendering
++  TQProcess* _renderProcess;
++  TQTimer _renderTimer;
++  GraphNode* _prevSelectedNode;
++  TQPoint _prevSelectedPos;
++  TQString _unparsedOutput;
++};
++
++
++
++
++#endif
++
++
++
+diff --git a/kdecachegrind/kdecachegrind/callitem.cpp b/kdecachegrind/kdecachegrind/callitem.cpp
+new file mode 100644
+index 0000000..ebca490
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/callitem.cpp
+@@ -0,0 +1,185 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Items for caller/callee view.
++ */
++
++#include <tqpixmap.h>
++#include <klocale.h>
++#include <kapplication.h>
++#include <kiconloader.h>
++
++#include "configuration.h"
++#include "listutils.h"
++#include "callitem.h"
++#include "callview.h"
++#include "toplevel.h"
++
++// CallItem
++
++
++CallItem::CallItem(CallView* view, TQListView* parent, TraceCall* c)
++    : TQListViewItem(parent)
++{
++  _call = c;
++  _view = view;
++
++  _active = _view->activeFunction();
++  bool baseIsCycle = (_active && (_active == _active->cycle()));
++
++  TQString fName;
++  if (_view->showCallers()) {
++      _shown = _call->caller(true);
++      fName  = c->callerName(!baseIsCycle);
++  }
++  else {
++      _shown = _call->called(true);
++      fName = c->calledName(!baseIsCycle);
++  }
++
++  _shown->addPrettyLocation(fName);
++
++  setText(3, fName);
++  updateGroup();
++  updateCost();
++}
++
++void  CallItem::updateGroup()
++{
++  TQColor c = Configuration::functionColor(_view->groupType(), _shown);
++  setPixmap(3, colorPixmap(10, 10, c));
++}
++
++void CallItem::updateCost()
++{
++    bool sameCycle = _shown->cycle() && (_active->cycle() == _shown->cycle());
++    bool shownIsCycle = (_shown == _shown->cycle());
++    bool selectedIsCycle = (_active == _active->cycle());
++    if (_call->isRecursion()) sameCycle=true;
++
++    TQString cStr;
++    if ((selectedIsCycle || shownIsCycle) && sameCycle)
++	cStr = "-";
++    else {
++	_cc  = _call->callCount();
++	if (_cc == 0)
++	    cStr = i18n("(active)");
++	else
++	    cStr = _call->prettyCallCount();
++    }
++    setText(2, cStr);
++
++    TraceCost* totalCost;
++    if (_view->topLevel()->showExpanded()) {
++      if (_active->cycle())
++        totalCost = _active->cycle()->inclusive();
++      else
++	totalCost = _active->inclusive();
++    }
++    else
++	totalCost = _active->data();
++
++    TraceCostType* ct = _view->costType();
++    _sum = _call->subCost(ct);
++    double total = totalCost->subCost(ct);
++
++    if (total == 0.0) {
++	TQString str = "-";
++
++	setText(0, str);
++	setPixmap(0, TQPixmap());
++    }
++    else {
++	double sum  = 100.0 * _sum / total;
++
++	if (_view->topLevel()->showPercentage())
++	    setText(0, TQString("%1")
++		    .arg(sum, 0, 'f', Configuration::percentPrecision()));
++	else
++	    setText(0, _call->prettySubCost(ct));
++
++	setPixmap(0, costPixmap(ct, _call, total, false));
++    }
++
++    // Cost Type 2
++    TraceCostType* ct2 = _view->costType2();
++    if (ct2) {
++      _sum2 = _call->subCost(ct2);
++      double total = totalCost->subCost(ct2);
++
++      if (total == 0.0) {
++	TQString str = "-";
++
++	setText(1, str);
++	setPixmap(1, TQPixmap());
++      }
++      else {
++	double sum  = 100.0 * _sum2 / total;
++	
++	if (_view->topLevel()->showPercentage())
++	  setText(1, TQString("%1")
++		  .arg(sum, 0, 'f', Configuration::percentPrecision()));
++	else
++	  setText(1, _call->prettySubCost(ct2));
++
++	setPixmap(1, costPixmap(ct2, _call, total, false));
++      }
++    }
++
++    TQPixmap p;
++    if (sameCycle && !selectedIsCycle && !shownIsCycle) {
++
++	TQString icon = "undo";
++	KIconLoader* loader = KApplication::kApplication()->iconLoader();
++	p= loader->loadIcon(icon, KIcon::Small, 0,
++			    KIcon::DefaultState, 0, true);
++    }
++    setPixmap(2, p);
++}
++
++
++int CallItem::compare(TQListViewItem * i, int col, bool ascending ) const
++{
++  const CallItem* ci1 = this;
++  const CallItem* ci2 = (CallItem*) i;
++
++  // we always want descending order
++  if (ascending) {
++    ci1 = ci2;
++    ci2 = this;
++  }
++
++  if (col==0) {
++    if (ci1->_sum < ci2->_sum) return -1;
++    if (ci1->_sum > ci2->_sum) return 1;
++    return 0;
++  }
++  if (col==1) {
++    if (ci1->_sum2 < ci2->_sum2) return -1;
++    if (ci1->_sum2 > ci2->_sum2) return 1;
++    return 0;
++  }
++  if (col==2) {
++    if (ci1->_cc < ci2->_cc) return -1;
++    if (ci1->_cc > ci2->_cc) return 1;
++    return 0;
++  }
++  return TQListViewItem::compare(i, col, ascending);
++}
++
+diff --git a/kdecachegrind/kdecachegrind/callitem.h b/kdecachegrind/kdecachegrind/callitem.h
+new file mode 100644
+index 0000000..94191b8
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/callitem.h
+@@ -0,0 +1,50 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Items of call view.
++ */
++
++#ifndef CALLITEM_H
++#define CALLITEM_H
++
++#include <tqlistview.h>
++#include "tracedata.h"
++
++class CallView;
++
++class CallItem: public TQListViewItem
++{
++public:
++    CallItem(CallView*, TQListView*, TraceCall* c);
++
++    int compare(TQListViewItem * i, int col, bool ascending ) const;
++    TraceCall* call() { return _call; }
++    CallView* view() { return _view; }
++    void updateCost();
++    void updateGroup();
++
++private:
++    SubCost _sum, _sum2;
++    SubCost _cc;
++    TraceCall* _call;
++    CallView* _view;
++    TraceFunction *_active, *_shown;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/callmapview.cpp b/kdecachegrind/kdecachegrind/callmapview.cpp
+new file mode 100644
+index 0000000..0e4d5e3
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/callmapview.cpp
+@@ -0,0 +1,999 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Call Map View
++ */
++
++#include <tqwhatsthis.h>
++#include <tqpopupmenu.h>
++
++#include <klocale.h>
++#include <kiconloader.h>
++#include <kapplication.h>
++#include <kconfig.h>
++
++#include "callmapview.h"
++#include "configuration.h"
++#include "listutils.h"
++#include "toplevel.h"
++
++//
++// CallMapView
++//
++
++
++// defaults
++#define DEFAULT_SPLITMODE    "Rows"
++#define DEFAULT_DRAWNAME     true
++#define DEFAULT_DRAWCOST     true
++#define DEFAULT_DRAWLOCATION false
++#define DEFAULT_DRAWCALLS    false
++#define DEFAULT_FORCESTRINGS false
++#define DEFAULT_ROTATION     true
++#define DEFAULT_SHADING      true
++#define DEFAULT_MAXAREA      100
++
++
++CallMapView::CallMapView(bool showCallers, TraceItemView* parentView,
++                         TQWidget* parent, const char* name)
++  : TreeMapWidget(new CallMapBaseItem(), parent, name),  TraceItemView(parentView)
++{
++  _showCallers = showCallers;
++
++  setFieldType(0, i18n( "Name" ));
++  setFieldType(1, i18n( "Cost" ));
++  setFieldType(2, i18n( "Location" ));
++  setFieldPosition(2, TreeMapItem::TopLeft);
++  setFieldType(3, i18n( "Calls" ));
++  setFieldPosition(3, TreeMapItem::TopRight);
++
++  setSplitMode(DEFAULT_SPLITMODE);
++  setFieldVisible(0, DEFAULT_DRAWNAME);
++  setFieldVisible(1, DEFAULT_DRAWCOST);
++  setFieldVisible(2, DEFAULT_DRAWLOCATION);
++  setFieldVisible(3, DEFAULT_DRAWCALLS);
++  setFieldForced(0, DEFAULT_FORCESTRINGS);
++  setFieldForced(1, DEFAULT_FORCESTRINGS);
++  setFieldForced(2, DEFAULT_FORCESTRINGS);
++  setFieldForced(3, DEFAULT_FORCESTRINGS);
++  setAllowRotation(DEFAULT_ROTATION);
++  setShadingEnabled(DEFAULT_SHADING);
++  setMinimalArea(DEFAULT_MAXAREA);
++
++  connect(this,
++          TQT_SIGNAL(doubleClicked(TreeMapItem*)),
++          TQT_SLOT(activatedSlot(TreeMapItem*)));
++  connect(this,
++          TQT_SIGNAL(returnPressed(TreeMapItem*)),
++          TQT_SLOT(activatedSlot(TreeMapItem*)));
++  connect(this,
++          TQT_SIGNAL(currentChanged(TreeMapItem*, bool)),
++          TQT_SLOT(selectedSlot(TreeMapItem*, bool)));
++  connect(this,
++          TQT_SIGNAL(contextMenuRequested(TreeMapItem*,const TQPoint &)),
++          TQT_SLOT(context(TreeMapItem*,const TQPoint &)));
++
++  TQWhatsThis::add( this, whatsThis());
++}
++
++TQString CallMapView::whatsThis() const
++{
++  TQString s = _showCallers ?
++              i18n( "<b>Caller Map</b>"
++                    "<p>This graph shows the nested hierarchy of "
++                    "all callers of the current activated function. "
++                    "Each colored rectangle represents a function; "
++                    "its size tries to be proportional to the cost spent "
++                    "therein while the active function is running "
++                    "(however, there are drawing constrains).</p>") :
++              i18n("<b>Call Map</b>"
++                   "<p>This graph shows the nested hierarchy of "
++                   "all callees of the current activated function. "
++                   "Each colored rectangle represents a function; "
++                   "its size tries to be proportional to the cost spent "
++                   "therein while the active function is running "
++                   "(however, there are drawing constrains).</p>");
++
++  s += i18n( "<p>Appearance options can be found in the "
++             "in the context menu. To get exact size proportions, "
++             "choose 'Hide incorrect borders'. As this mode can be "
++             "<em>very</em> time consuming, you may want to limit "
++             "the maximum drawn nesting level before. "
++             "'Best' determinates the split direction for children "
++             "from the aspect ratio of the parent. "
++             "'Always Best' decides on remaining space for each "
++             "sibling. "
++             "'Ignore Proportions' takes space for function name "
++             "drawing <em>before</em> drawing children. Note that "
++             "size proportions can get <em>heavily</em> wrong.</p>"
++
++             "<p>This is a <em>TreeMap</em> widget. "
++             "Keyboard navigation is available with the left/right arrow "
++             "keys for traversing siblings, and up/down arrow keys "
++             "to go a nesting level up/down. "
++             "<em>Return</em> activates the current item.</p>");
++
++  return s;
++}
++
++void CallMapView::setData(TraceData* d)
++{
++  TraceItemView::setData(d);
++
++  ((CallMapBaseItem*)base())->setFunction(0);
++}
++
++void CallMapView::context(TreeMapItem* i,const TQPoint & p)
++{
++  if (!i) return;
++
++  TQPopupMenu popup;
++  TQPopupMenu fpopup; // select function subpopup
++  TQPopupMenu vpopup; // visualisation subpopup
++  TQPopupMenu dpopup; // split direction
++  TQPopupMenu bpopup; // border subpopup
++  TQPopupMenu l1popup; // depth limit subpopup
++  TQPopupMenu l2popup; // function limit subpopup
++  TQPopupMenu l3popup; // area limit subpopup
++
++  TreeMapItem* item = i;
++  int count;
++
++  TQString shortCurrentName;
++  if (i) {
++    shortCurrentName = i->text(0);
++    if ((int)shortCurrentName.length() > Configuration::maxSymbolLength())
++      shortCurrentName =
++        shortCurrentName.left(Configuration::maxSymbolLength()) + "...";
++  }
++
++  if (item) {
++    popup.insertItem(i18n("Go To"), &fpopup, 100);
++    count = 0;
++    while (count<Configuration::maxSymbolCount() && item) {
++      TQString name = item->text(0);
++      if ((int)name.length()>Configuration::maxSymbolLength())
++        name = name.left(Configuration::maxSymbolLength()) + "...";
++      fpopup.insertItem(name, 101+count);
++      item = item->parent();
++      count++;
++    }
++    popup.insertSeparator();
++  }
++
++  addGoMenu(&popup);
++  popup.insertSeparator();
++
++  l1popup.setCheckable(true);
++  popup.insertItem(i18n("Stop at Depth"), &l1popup, 12);
++
++  int maxDepth = maxDrawingDepth();
++  l1popup.insertItem(i18n("No Depth Limit"), 50);
++  l1popup.setItemChecked(50, maxDepth==-1);
++  l1popup.insertSeparator();
++  l1popup.insertItem(i18n("Depth 10"), 51);
++  l1popup.setItemChecked(51, maxDepth==10);
++  l1popup.insertItem(i18n("Depth 15"), 52);
++  l1popup.setItemChecked(52, maxDepth==15);
++  l1popup.insertItem(i18n("Depth 20"), 53);
++  l1popup.setItemChecked(53, maxDepth==20);
++  if (i) {
++    l1popup.insertSeparator();
++    l1popup.insertItem(i18n("Depth of '%1' (%2)")
++                       .arg(shortCurrentName).arg(i->depth()), 55);
++    l1popup.setItemChecked(55, maxDepth == i->depth());
++  }
++  if (maxDepth>0) {
++    l1popup.insertSeparator();
++    l1popup.insertItem(i18n("Decrement Depth (to %1)").arg(maxDepth-1), 56);
++    l1popup.insertItem(i18n("Increment Depth (to %1)").arg(maxDepth+1), 57);
++  }
++
++  l2popup.setCheckable(true);
++  popup.insertItem(i18n("Stop at Function"), &l2popup, 13);
++  l2popup.insertItem(i18n("No Function Limit"), 200);
++  l2popup.setItemChecked(200, fieldStop(0).isEmpty());
++  bool foundStopName = false;
++  item = i;
++  if (i) {
++    l2popup.insertSeparator();
++    count = 0;
++    while (count<Configuration::maxSymbolCount() && item) {
++      TQString name = item->text(0);
++      if ((int)name.length()>Configuration::maxSymbolLength())
++        name = name.left(Configuration::maxSymbolLength()) + "...";
++      l2popup.insertItem(name, 201+count);
++      if (item->text(0) == fieldStop(0)) {
++        l2popup.setItemChecked(201+count, true);
++        foundStopName = true;
++      }
++      item = item->parent();
++      count++;
++    }
++  }
++  if (!foundStopName && !fieldStop(0).isEmpty()) {
++    l2popup.insertSeparator();
++    TQString name = fieldStop(0);
++    if ((int)name.length()>Configuration::maxSymbolLength())
++      name = name.left(Configuration::maxSymbolLength()) + "...";
++    l2popup.insertItem(name, 199);
++    l2popup.setItemChecked(199, true);
++  }
++
++  l3popup.setCheckable(true);
++  popup.insertItem(i18n("Stop at Area"), &l3popup, 14);
++
++  int mArea = minimalArea();
++  l3popup.insertItem(i18n("No Area Limit"), 60);
++  l3popup.setItemChecked(60, mArea ==-1);
++  l3popup.insertSeparator();
++  l3popup.insertItem(i18n("50 Pixels"), 63);
++  l3popup.setItemChecked(63, mArea==50);
++  l3popup.insertItem(i18n("100 Pixels"), 64);
++  l3popup.setItemChecked(64, mArea==100);
++  l3popup.insertItem(i18n("200 Pixels"), 65);
++  l3popup.setItemChecked(65, mArea==200);
++  l3popup.insertItem(i18n("500 Pixels"), 66);
++  l3popup.setItemChecked(66, mArea==500);
++  int currentArea = 0;
++  if (i) {
++    currentArea = i->width() * i->height();
++    l3popup.insertSeparator();
++    l3popup.insertItem(i18n("Area of '%1' (%2)")
++                       .arg(shortCurrentName).arg(currentArea), 67);
++    l3popup.setItemChecked(67, mArea == currentArea);
++  }
++  if (mArea>0) {
++    l3popup.insertSeparator();
++    l3popup.insertItem(i18n("Double Area Limit (to %1)")
++                       .arg(mArea*2), 68);
++    l3popup.insertItem(i18n("Half Area Limit (to %1)")
++                       .arg(mArea/2), 69);
++  }
++
++  popup.insertSeparator();
++
++  vpopup.setCheckable(true);
++  popup.insertItem(i18n("Visualisation"), &vpopup, 10);
++
++  TQPopupMenu splitpopup;
++  addSplitDirectionItems(&splitpopup, 1001);
++  vpopup.insertItem(i18n("Split Direction"), &splitpopup, 1000);
++
++  vpopup.insertItem(i18n("Skip Incorrect Borders"), 40);
++  vpopup.setItemEnabled(40, !_showCallers);
++  vpopup.setItemChecked(40, skipIncorrectBorder());
++
++  bpopup.setCheckable(true);
++  vpopup.insertItem(i18n("Border Width"), &bpopup, 41);
++  bpopup.insertItem(i18n("Border 0"), 42);
++  bpopup.setItemEnabled(42, !_showCallers);
++  bpopup.setItemChecked(42, borderWidth()==0);
++  bpopup.insertItem(i18n("Border 1"), 43);
++  bpopup.setItemChecked(43, borderWidth()==1);
++  bpopup.insertItem(i18n("Border 2"), 44);
++  bpopup.setItemChecked(44, borderWidth()==2);
++  bpopup.insertItem(i18n("Border 3"), 45);
++  bpopup.setItemChecked(45, borderWidth()==3);
++
++  vpopup.insertSeparator();
++
++  vpopup.insertItem(i18n("Draw Symbol Names"), 20);
++  vpopup.insertItem(i18n("Draw Cost"), 21);
++  vpopup.insertItem(i18n("Draw Location"), 22);
++  vpopup.insertItem(i18n("Draw Calls"), 23);
++  vpopup.insertSeparator();
++
++  vpopup.insertItem(i18n("Ignore Proportions"), 24);
++  vpopup.insertItem(i18n("Allow Rotation"), 25);
++  if (!fieldVisible(0) &&
++      !fieldVisible(1) &&
++      !fieldVisible(2) &&
++      !fieldVisible(3)) {
++    vpopup.setItemEnabled(24, false);
++    vpopup.setItemEnabled(25, false);
++  }
++  else {
++    vpopup.setItemChecked(20,fieldVisible(0));
++    vpopup.setItemChecked(21,fieldVisible(1));
++    vpopup.setItemChecked(22,fieldVisible(2));
++    vpopup.setItemChecked(23,fieldVisible(3));
++    vpopup.setItemChecked(24,fieldForced(0));
++    vpopup.setItemChecked(25,allowRotation());
++  }
++
++  vpopup.insertItem(i18n("Shading"), 26);
++  vpopup.setItemChecked(26,isShadingEnabled());
++
++  int r = popup.exec(mapToGlobal(p));
++
++  if (r>100 && r<150) {
++    r -= 100;
++    while (i && (r>1)) {
++      i=i->parent();
++      r--;
++    }
++    activatedSlot(i);
++    return;
++  }
++
++  if (r>200 && r<250) {
++    r -= 200;
++    while (i && (r>1)) {
++      i=i->parent();
++      r--;
++    }
++    if (i)
++      setFieldStop(0, i->text(0));
++
++    return;
++  }
++
++  switch(r) {
++  case 20:
++    setFieldVisible(0, !vpopup.isItemChecked(20));
++    break;
++
++  case 21:
++    setFieldVisible(1, !vpopup.isItemChecked(21));
++    break;
++
++  case 22:
++    setFieldVisible(2, !vpopup.isItemChecked(22));
++    break;
++
++  case 23:
++    setFieldVisible(3, !vpopup.isItemChecked(23));
++    break;
++
++  case 24:
++    setFieldForced(0, !vpopup.isItemChecked(24));
++    setFieldForced(1, !vpopup.isItemChecked(24));
++    setFieldForced(2, !vpopup.isItemChecked(24));
++    setFieldForced(3, !vpopup.isItemChecked(24));
++    break;
++
++  case 25: setAllowRotation(!vpopup.isItemChecked(25)); break;
++  case 26: setShadingEnabled(!vpopup.isItemChecked(26)); break;
++
++  case 40:
++    setSkipIncorrectBorder(!vpopup.isItemChecked(40));
++    break;
++
++  case 42: setBorderWidth(0); break;
++  case 43: setBorderWidth(1); break;
++  case 44: setBorderWidth(2); break;
++  case 45: setBorderWidth(3); break;
++
++  case 50: setMaxDrawingDepth(-1); break;
++  case 51: setMaxDrawingDepth(10); break;
++  case 52: setMaxDrawingDepth(15); break;
++  case 53: setMaxDrawingDepth(20); break;
++  case 55: setMaxDrawingDepth(i->depth()); break;
++  case 56: setMaxDrawingDepth(maxDepth-1); break;
++  case 57: setMaxDrawingDepth(maxDepth+1); break;
++
++  case 200: setFieldStop(0, TQString()); break;
++
++  case 60: setMinimalArea(-1); break;
++  case 61: setMinimalArea(10); break;
++  case 62: setMinimalArea(20); break;
++  case 63: setMinimalArea(50); break;
++  case 64: setMinimalArea(100); break;
++  case 65: setMinimalArea(200); break;
++  case 66: setMinimalArea(500); break;
++  case 67: setMinimalArea(currentArea); break;
++  case 68: setMinimalArea(mArea*2); break;
++  case 69: setMinimalArea(mArea/2); break;
++  }
++}
++
++void CallMapView::activatedSlot(TreeMapItem* item)
++{
++  if (!item) return;
++
++  if (item->rtti() == 1) {
++    CallMapBaseItem* bi = (CallMapBaseItem*)item;
++    activated(bi->function());
++  }
++  else if (item->rtti() == 2) {
++    CallMapCallingItem* ci = (CallMapCallingItem*)item;
++    activated(ci->function());
++  }
++  else if (item->rtti() == 3) {
++    CallMapCallerItem* ci = (CallMapCallerItem*)item;
++    activated(ci->function());
++  }
++}
++
++void CallMapView::selectedSlot(TreeMapItem* item, bool kbd)
++{
++  if (!item) return;
++  if (item->text(0).isEmpty()) return;
++
++  if (kbd) {
++      TQString msg = i18n("Call Map: Current is '%1'").arg(item->text(0));
++      if (_topLevel)
++	  _topLevel->showMessage(msg, 5000);
++  }
++
++  TraceFunction* f = 0;
++
++  if (item->rtti() == 1) {
++    CallMapBaseItem* bi = (CallMapBaseItem*)item;
++    f = bi->function();
++  }
++  else if (item->rtti() == 2) {
++    CallMapCallingItem* ci = (CallMapCallingItem*)item;
++    f = ci->function();
++  }
++  else if (item->rtti() == 3) {
++    CallMapCallerItem* ci = (CallMapCallerItem*)item;
++    f = ci->function();
++  }
++  if (f) {
++      // this avoids marking
++      _selectedItem = f;
++      selected(f);
++  }
++}
++
++TraceItem* CallMapView::canShow(TraceItem* i)
++{
++  TraceItem::CostType t = i ? i->type() : TraceItem::NoCostType;
++
++  switch(t) {
++  case TraceItem::Function:
++  case TraceItem::FunctionCycle:
++      return i;
++  default:
++      break;
++  }
++  return 0;
++}
++
++void CallMapView::doUpdate(int changeType)
++{
++    if (changeType == costType2Changed) return;
++
++    // if there is a selected item, always draw marking...
++    if (changeType & selectedItemChanged) {
++	TraceFunction* f = 0;
++
++	if (_selectedItem) {
++	    switch(_selectedItem->type()) {
++	    case TraceItem::Function:
++	    case TraceItem::FunctionCycle:
++		f = (TraceFunction*)_selectedItem;
++		break;
++	    default:
++		break;
++	    }
++	}
++	// if this is the only change...
++	if (changeType == selectedItemChanged) {
++	    setMarked(f ? 1:0, true);
++	    return;
++	}
++	setMarked(f ? 1:0, false);
++    }
++
++
++  if (changeType & activeItemChanged) {
++      TraceFunction* f = 0;
++
++      if (_activeItem) {
++	  switch(_activeItem->type()) {
++	  case TraceItem::Function:
++	  case TraceItem::FunctionCycle:
++	      f = (TraceFunction*)_activeItem;
++	      break;
++	  default:
++	      break;
++	  }
++      }
++      ((CallMapBaseItem*)base())->setFunction(f);
++  }
++  else if ( ((changeType & partsChanged) && Configuration::showCycles()) ||
++            (changeType & dataChanged) ||
++            (changeType & configChanged)) {
++    /* regenerates the treemap because traceitems were added/removed */
++    base()->refresh();
++  }
++  else if ((changeType & partsChanged) ||
++           (changeType & costTypeChanged)) {
++    /* we need to do the draw order sorting again as the values change */
++    resort();
++    redraw();
++  }
++  else
++    redraw();
++}
++
++
++
++TQColor CallMapView::groupColor(TraceFunction* f) const
++{
++  if (!f)
++    return colorGroup().button();
++
++  return Configuration::functionColor(_groupType, f);
++}
++
++
++TQString CallMapView::tipString(TreeMapItem* i) const
++{
++  TQString tip, itemTip;
++  int count = 0;
++
++  //qDebug("CallMapView::tipString for '%s'", i->text(0).ascii());
++
++  // first, SubPartItem's
++  while (i && count<Configuration::maxSymbolCount()) {
++    itemTip = i->text(0);
++    if ((int)itemTip.length()>Configuration::maxSymbolLength())
++      itemTip = itemTip.left(Configuration::maxSymbolLength()) + "...";
++
++    if (!i->text(1).isEmpty())
++      itemTip += " (" + i->text(1) + ")";
++
++    if (!tip.isEmpty()) tip += "\n";
++
++    tip += itemTip;
++    i = i->parent();
++    count++;
++  }
++  if (count == Configuration::maxSymbolCount()) tip += "\n...";
++
++  return tip;
++}
++
++
++TraceCost* CallMapView::totalCost()
++{
++  TraceFunction* f = ((CallMapBaseItem*)base())->function();
++  if (!f) return 0;
++
++  return Configuration::showExpanded() ? f->inclusive() : f->data();
++}
++
++
++
++
++// CallMapBaseItem
++
++CallMapBaseItem::CallMapBaseItem()
++{
++  _f = 0;
++}
++
++void CallMapBaseItem::setFunction(TraceFunction* f)
++{
++  if (f == _f) return;
++
++  _f = f;
++  refresh();
++}
++
++
++TQString CallMapBaseItem::text(int textNo) const
++{
++  if (textNo == 0) {
++    if (!_f)
++      return i18n("(no function)");
++
++    return _f->prettyName();
++  }
++
++  if (!_f) return TQString();
++
++  if (textNo == 2) return _f->prettyLocation();
++  if (textNo == 3) return _f->calledCount().pretty();
++  if (textNo != 1) return TQString();
++
++  TraceCostType* ct = ((CallMapView*)widget())->costType();
++  TraceCost* t      = ((CallMapView*)widget())->totalCost();
++
++  if (Configuration::showPercentage()) {
++      double sum, total = t->subCost(ct);
++      if (total == 0.0)
++	  sum = 100.0;
++      else
++	  sum = 100.0 * _f->inclusive()->subCost(ct) / total;
++
++      return TQString("%1 %")
++	  .arg(sum, 0, 'f', Configuration::percentPrecision());
++  }
++  return _f->inclusive()->prettySubCost(ct);
++}
++
++TQPixmap CallMapBaseItem::pixmap(int i) const
++{
++    if ((i != 1) || !_f) return TQPixmap();
++
++    TraceCostType* ct = ((CallMapView*)widget())->costType();
++    TraceCost* t      = ((CallMapView*)widget())->totalCost();
++
++    // colored level meter with frame
++    return costPixmap( ct, _f->inclusive(), (double) (t->subCost(ct)), true);
++}
++
++
++double CallMapBaseItem::value() const
++{
++  if (!_f) return 0.0;
++
++  TraceCostType* ct;
++  ct = ((CallMapView*)widget())->costType();
++  return (double) _f->inclusive()->subCost(ct);
++}
++
++
++double CallMapBaseItem::sum() const
++{
++  if (!_f) return 0.0;
++
++  CallMapView* w = (CallMapView*)widget();
++
++  if (w->showCallers())
++    return 0.0;
++  else
++    return (double) _f->inclusive()->subCost(w->costType());
++}
++
++
++bool CallMapBaseItem::isMarked(int) const
++{
++    return ((CallMapView*)widget())->selectedItem() == _f;
++}
++
++TreeMapItemList* CallMapBaseItem::children()
++{
++  if (_f && !initialized()) {
++    CallMapView* w = (CallMapView*)widget();
++
++    if (0) qDebug("Create Function %s (%s)",
++		  w->showCallers() ? "Callers":"Callees",
++		  text(0).ascii());
++
++    TraceCall* call;
++
++    setSorting(-1);
++    if (w->showCallers()) {
++      TraceCallList l = _f->callers();
++      for (call=l.first();call;call=l.next()) {
++
++        // don't show calls inside of a cycle
++        if (call->inCycle()>0) continue;
++        if (call->isRecursion()) continue;
++
++        addItem(new CallMapCallerItem(1.0, call));
++      }
++
++      setSum(0);
++    }
++    else {
++      TraceCallList l = _f->callings();
++      for (call=l.first();call;call=l.next()) {
++
++        // don't show calls inside of a cycle
++        if (call->inCycle()>0) continue;
++        if (call->isRecursion()) continue;
++
++        CallMapCallingItem* i = new CallMapCallingItem(1.0, call);
++        i->init();
++        addItem(i);
++      }
++
++      setSum(_f->inclusive()->subCost(w->costType()));
++    }
++    setSorting(-2, false);
++  }
++
++  return _children;
++}
++
++TQColor CallMapBaseItem::backColor() const
++{
++  return ((CallMapView*)widget())->groupColor(_f);
++}
++
++
++
++// CallMapCallingItems
++
++CallMapCallingItem::CallMapCallingItem(double factor, TraceCall* c)
++{
++  _factor = factor;
++  _c = c;
++}
++
++void CallMapCallingItem::init()
++{
++#if 0
++  // create assoziation: if not possible, i.e. an ass. already exists
++  // for the function, we need to draw the recursive version
++  _recursive = !setFunction(_c->called());
++  _valid = true;
++#endif
++}
++
++TQString CallMapCallingItem::text(int textNo) const
++{
++  if (textNo == 0) {
++    if (!_c)
++      return i18n("(no call)");
++
++    return _c->calledName();
++  }
++
++  if (textNo == 2) return _c->called()->prettyLocation();
++  if (textNo == 3) return SubCost(_factor * _c->callCount()).pretty();
++  if (textNo != 1) return TQString();
++
++  TraceCostType* ct;
++  ct = ((CallMapView*)widget())->costType();
++
++  SubCost val = SubCost(_factor * _c->subCost(ct));
++  if (Configuration::showPercentage()) {
++    // percentage relative to function cost
++    TraceCost* t = ((CallMapView*)widget())->totalCost();
++    double p  = 100.0 * _factor * _c->subCost(ct) / t->subCost(ct);
++    return TQString("%1 %")
++      .arg(p, 0, 'f', Configuration::percentPrecision());
++  }
++  return val.pretty();
++}
++
++TQPixmap CallMapCallingItem::pixmap(int i) const
++{
++    if (i != 1) return TQPixmap();
++
++    // Cost pixmap
++    TraceCostType* ct = ((CallMapView*)widget())->costType();
++    TraceCost* t      = ((CallMapView*)widget())->totalCost();
++
++    // colored level meter with frame
++    return costPixmap( ct, _c, t->subCost(ct) / _factor, true);
++}
++
++
++double CallMapCallingItem::value() const
++{
++  TraceCostType* ct;
++  ct = ((CallMapView*)widget())->costType();
++  return _factor * _c->subCost(ct);
++}
++
++double CallMapCallingItem::sum() const
++{
++  return value();
++}
++
++bool CallMapCallingItem::isMarked(int) const
++{
++    return ((CallMapView*)widget())->selectedItem() == _c->called();
++}
++
++
++TreeMapItemList* CallMapCallingItem::children()
++{
++  if (!initialized()) {
++    if (0) qDebug("Create Calling subitems (%s)", path(0).join("/").ascii());
++
++    TraceCostType* ct;
++    ct = ((CallMapView*)widget())->costType();
++
++    // same as sum()
++    SubCost s = _c->called()->inclusive()->subCost(ct);
++    SubCost v = _c->subCost(ct);
++    if (v>s) {
++      qDebug("Warning: CallingItem subVal %u > Sum %u (%s)",
++             (unsigned)v, (unsigned)s, _c->called()->prettyName().ascii());
++      v = s;
++    }
++    double newFactor = _factor * v / s;
++
++#if 0
++    qDebug("CallingItem: Subitems of %s => %s, factor %f * %d/%d => %f",
++               _c->caller()->prettyName().ascii(),
++               _c->called()->prettyName().ascii(),
++               _factor, v, s, newFactor);
++#endif
++    setSorting(-1);
++    TraceCall* call;
++    TraceCallList l = _c->called()->callings();
++    for (call=l.first();call;call=l.next()) {
++
++      // don't show calls inside of a cycle
++      if (call->inCycle()>0) continue;
++      if (call->isRecursion()) continue;
++
++      CallMapCallingItem* i = new CallMapCallingItem(newFactor, call);
++      i->init();
++      addItem(i);
++    }
++    setSorting(-2, false);
++  }
++
++  return _children;
++}
++
++
++TQColor CallMapCallingItem::backColor() const
++{
++  CallMapView* w = (CallMapView*)widget();
++  return w->groupColor(_c->called());
++}
++
++
++// CallMapCallerItem
++
++CallMapCallerItem::CallMapCallerItem(double factor, TraceCall* c)
++{
++  _factor = factor;
++  _c = c;
++}
++
++TQString CallMapCallerItem::text(int textNo) const
++{
++  if (textNo == 0) {
++    if (!_c)
++      return i18n("(no call)");
++
++    return _c->callerName();
++  }
++
++  if (textNo == 2) return _c->caller()->prettyLocation();
++  if (textNo == 3) return SubCost(_factor * _c->callCount()).pretty();
++  if (textNo != 1) return TQString();
++
++  TraceCostType* ct;
++  ct = ((CallMapView*)widget())->costType();
++
++  SubCost val = SubCost(_factor * _c->subCost(ct));
++  if (Configuration::showPercentage()) {
++    TraceCost* t = ((CallMapView*)widget())->totalCost();
++    double p  = 100.0 * _factor * _c->subCost(ct) / t->subCost(ct);
++    return TQString("%1 %")
++      .arg(p, 0, 'f', Configuration::percentPrecision());
++  }
++  return val.pretty();
++}
++
++
++TQPixmap CallMapCallerItem::pixmap(int i) const
++{
++    if (i != 1) return TQPixmap();
++
++    // Cost pixmap
++    TraceCostType* ct = ((CallMapView*)widget())->costType();
++    TraceCost* t      = ((CallMapView*)widget())->totalCost();
++
++    // colored level meter with frame
++    return costPixmap( ct, _c, t->subCost(ct) / _factor, true );
++}
++
++
++double CallMapCallerItem::value() const
++{
++  TraceCostType* ct;
++  ct = ((CallMapView*)widget())->costType();
++  return (double) _c->subCost(ct);
++}
++
++bool CallMapCallerItem::isMarked(int) const
++{
++    return ((CallMapView*)widget())->selectedItem() == _c->caller();
++}
++
++
++TreeMapItemList* CallMapCallerItem::children()
++{
++  if (!initialized()) {
++    //qDebug("Create Caller subitems (%s)", name().ascii());
++
++    TraceCostType* ct;
++    ct = ((CallMapView*)widget())->costType();
++
++    SubCost s = _c->caller()->inclusive()->subCost(ct);
++    SubCost v = _c->subCost(ct);
++    double newFactor = _factor * v / s;
++
++
++#if 0
++    qDebug("CallerItem: Subitems of %s => %s, factor %f * %d/%d => %f",
++           _c->caller()->prettyName().ascii(),
++           _c->called()->prettyName().ascii(),
++           _factor, v, s, newFactor);
++#endif
++    setSorting(-1);
++
++    TraceCall* call;
++    TraceCallList l = _c->caller()->callers();
++    for (call=l.first();call;call=l.next()) {
++
++      // don't show calls inside of a cycle
++      if (call->inCycle()>0) continue;
++      if (call->isRecursion()) continue;
++
++      TreeMapItem* i = new CallMapCallerItem(newFactor, call);
++      addItem(i);
++    }
++    setSorting(-2, false);
++  }
++
++  return _children;
++}
++
++TQColor CallMapCallerItem::backColor() const
++{
++  CallMapView* w = (CallMapView*)widget();
++  return w->groupColor(_c->caller());
++}
++
++void CallMapView::readViewConfig(KConfig* c,
++				 TQString prefix, TQString postfix, bool)
++{
++    KConfigGroup* g = configGroup(c, prefix, postfix);
++
++    setSplitMode(g->readEntry("SplitMode", DEFAULT_SPLITMODE));
++
++    setFieldVisible(0, g->readBoolEntry("DrawName", DEFAULT_DRAWNAME));
++    setFieldVisible(1, g->readBoolEntry("DrawCost", DEFAULT_DRAWCOST));
++    setFieldVisible(2, g->readBoolEntry("DrawLocation", DEFAULT_DRAWLOCATION));
++    setFieldVisible(3, g->readBoolEntry("DrawCalls", DEFAULT_DRAWCALLS));
++
++    bool enable = g->readBoolEntry("ForceStrings", DEFAULT_FORCESTRINGS);
++    setFieldForced(0, enable);
++    setFieldForced(1, enable);
++    setFieldForced(2, enable);
++    setFieldForced(3, enable);
++
++    setAllowRotation(g->readBoolEntry("AllowRotation", DEFAULT_ROTATION));
++    setShadingEnabled(g->readBoolEntry("Shading", DEFAULT_SHADING));
++    setFieldStop(0, g->readEntry("StopName"));
++    setMaxDrawingDepth(g->readNumEntry("MaxDepth", -1));
++    setMinimalArea(g->readNumEntry("MaxArea", DEFAULT_MAXAREA));
++
++    delete g;
++}
++
++void CallMapView::saveViewConfig(KConfig* c, 
++				 TQString prefix, TQString postfix, bool)
++{
++    KConfigGroup g(c, (prefix+postfix).ascii());
++
++    writeConfigEntry(&g, "SplitMode", splitModeString(), DEFAULT_SPLITMODE);
++    writeConfigEntry(&g, "DrawName", fieldVisible(0), DEFAULT_DRAWNAME);
++    writeConfigEntry(&g, "DrawCost", fieldVisible(1), DEFAULT_DRAWCOST);
++    writeConfigEntry(&g, "DrawLocation", fieldVisible(2), DEFAULT_DRAWLOCATION);
++    writeConfigEntry(&g, "DrawCalls", fieldVisible(3), DEFAULT_DRAWCALLS);
++    // when option for all text (0-3)
++    writeConfigEntry(&g, "ForceStrings", fieldForced(0), DEFAULT_FORCESTRINGS);
++
++    writeConfigEntry(&g, "AllowRotation", allowRotation(), DEFAULT_ROTATION);
++    writeConfigEntry(&g, "Shading", isShadingEnabled(), DEFAULT_SHADING);
++
++    writeConfigEntry(&g, "StopName", fieldStop(0), "");
++    writeConfigEntry(&g, "MaxDepth", maxDrawingDepth(), -1);
++    writeConfigEntry(&g, "MaxArea", minimalArea(), DEFAULT_MAXAREA);
++}
++
++#include "callmapview.moc"
+diff --git a/kdecachegrind/kdecachegrind/callmapview.h b/kdecachegrind/kdecachegrind/callmapview.h
+new file mode 100644
+index 0000000..860743f
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/callmapview.h
+@@ -0,0 +1,130 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Call Map View
++ */
++
++#ifndef CALLMAPVIEW_H
++#define CALLMAPVIEW_H
++
++#include "treemap.h"
++#include "tracedata.h"
++#include "traceitemview.h"
++
++class CallMapView: public TreeMapWidget, public TraceItemView
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++
++  CallMapView(bool showCallers, TraceItemView* parentView,
++              TQWidget* parent=0, const char* name=0);
++
++  TQWidget* widget() { return this; }
++  TQString whatsThis() const;
++  void setData(TraceData*);
++
++  void readViewConfig(KConfig*, TQString prefix, TQString postfix, bool);
++  void saveViewConfig(KConfig*, TQString prefix, TQString postfix, bool);
++
++  bool showCallers() const { return _showCallers; }
++  TraceCost* totalCost();
++  TQString tipString(TreeMapItem*) const;
++  TQColor groupColor(TraceFunction*) const;
++
++private slots:
++  void context(TreeMapItem*,const TQPoint &);
++  void selectedSlot(TreeMapItem*, bool);
++  void activatedSlot(TreeMapItem*);
++
++private:
++  TraceItem* canShow(TraceItem*);
++  void doUpdate(int);
++
++  bool _showCallers;
++};
++
++
++
++// Subitems of CallMap
++
++class CallMapBaseItem: public TreeMapItem
++{
++public:
++  CallMapBaseItem();
++
++  void setFunction(TraceFunction* f);
++  TraceFunction* function() { return _f; }
++  int rtti() const { return 1; }
++  double sum() const;
++  double value() const ;
++  bool isMarked(int) const;
++  TQString text(int) const;
++  TQPixmap pixmap(int) const;
++  TreeMapItemList* children();
++  TQColor backColor() const;
++
++private:
++  TraceFunction* _f;
++};
++
++
++class CallMapCallingItem: public TreeMapItem
++{
++public:
++  CallMapCallingItem(double factor, TraceCall* c);
++  void init();
++  int rtti() const { return 2; }
++  int borderWidth() const { return widget()->borderWidth(); }
++  TraceFunction* function() { return _c->called(); }
++  double value() const;
++  double sum() const;
++  bool isMarked(int) const;
++  TQString text(int) const;
++  TQPixmap pixmap(int) const;
++  TreeMapItemList* children();
++  TQColor backColor() const;
++
++private:
++  TraceCall* _c;
++  double _factor;
++};
++
++class CallMapCallerItem: public TreeMapItem
++{
++public:
++  CallMapCallerItem(double factor, TraceCall* c);
++  int rtti() const { return 3; }
++  int borderWidth() const { return widget()->borderWidth(); }
++  TraceFunction* function() { return _c->caller(); }
++  double value() const;
++  bool isMarked(int) const;
++  TQString text(int) const;
++  TQPixmap pixmap(int) const;
++  TreeMapItemList* children();
++  TQColor backColor() const;
++
++private:
++  TraceCall* _c;
++  double _factor;
++};
++
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/callview.cpp b/kdecachegrind/kdecachegrind/callview.cpp
+new file mode 100644
+index 0000000..317d137
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/callview.cpp
+@@ -0,0 +1,256 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Call Views
++ */
++
++#include <tqwhatsthis.h>
++#include <tqpopupmenu.h>
++#include <klocale.h>
++
++#include "configuration.h"
++#include "callitem.h"
++#include "callview.h"
++
++
++
++//
++// CallView
++//
++
++
++CallView::CallView(bool showCallers, TraceItemView* parentView,
++		   TQWidget* parent, const char* name)
++  : TQListView(parent, name), TraceItemView(parentView)
++{
++    _showCallers = showCallers;
++
++    addColumn( i18n( "Cost" ) );
++    addColumn( i18n( "Cost 2" ) );
++    if (_showCallers) {
++	addColumn( i18n( "Count" ) );
++	addColumn( i18n( "Caller" ) );
++    }
++    else {
++	addColumn( i18n( "Count" ) );
++	addColumn( i18n( "Callee" ) );
++    }
++
++    setSorting(0,false);
++    setColumnAlignment(0, TQt::AlignRight);
++    setColumnAlignment(1, TQt::AlignRight);
++    setColumnAlignment(2, TQt::AlignRight);
++    setAllColumnsShowFocus(true);
++    setResizeMode(TQListView::LastColumn);
++    setMinimumHeight(50);
++
++    connect( this,
++	     TQT_SIGNAL( selectionChanged(TQListViewItem*) ),
++	     TQT_SLOT( selectedSlot(TQListViewItem*) ) );
++
++    connect( this,
++	     TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint &, int)),
++	     TQT_SLOT(context(TQListViewItem*, const TQPoint &, int)));
++
++    connect(this,
++	    TQT_SIGNAL(doubleClicked(TQListViewItem*)),
++	    TQT_SLOT(activatedSlot(TQListViewItem*)));
++
++    connect(this,
++	    TQT_SIGNAL(returnPressed(TQListViewItem*)),
++	    TQT_SLOT(activatedSlot(TQListViewItem*)));
++
++    TQWhatsThis::add( this, whatsThis() );
++}
++
++TQString CallView::whatsThis() const
++{
++    return _showCallers ?
++	i18n( "<b>List of direct Callers</b>"
++	      "<p>This list shows all functions calling the "
++	      "current selected one directly, together with "
++	      "a call count and the cost spent in the current "
++	      "selected function while being called from the "
++	      "function from the list.</p>"
++	      "<p>An icon instead of an inclusive cost specifies "
++	      "that this is a call inside of a recursive cycle. "
++	      "An inclusive cost makes no sense here.</p>"
++	      "<p>Selecting a function makes it the current selected "
++	      "one of this information panel. "
++	      "If there are two panels (Split mode), the "
++	      "function of the other panel is changed instead.</p>") :
++	i18n( "<b>List of direct Callees</b>"
++	      "<p>This list shows all functions called by the "
++	      "current selected one directly, together with "
++	      "a call count and the cost spent in this function "
++	      "while being called from the selected function.</p>"
++	      "<p>Selecting a function makes it the current selected "
++	      "one of this information panel. "
++	      "If there are two panels (Split mode), the "
++	      "function of the other panel is changed instead.</p>");
++}
++
++
++void CallView::context(TQListViewItem* i, const TQPoint & p, int col)
++{
++  TQPopupMenu popup;
++
++  // Menu entry:
++  TraceCall* c = i ? ((CallItem*) i)->call() : 0;
++  TraceFunction *f = 0, *cycle = 0;
++
++  if (c) {
++    TQString name  = _showCallers ? c->callerName(true) : c->calledName(true);
++    f = _showCallers ? c->caller(true) : c->called(true);
++    cycle = f->cycle();
++
++    popup.insertItem(i18n("Go to '%1'")
++		     .arg(Configuration::shortenSymbol(name)), 93);
++
++    if (cycle) {
++	name = Configuration::shortenSymbol(cycle->prettyName());
++	popup.insertItem(i18n("Go to '%1'").arg(name), 94);
++    }
++
++    popup.insertSeparator();
++  }
++
++  if ((col == 0) || (col == 1)) {
++    addCostMenu(&popup);
++    popup.insertSeparator();
++  }
++  addGoMenu(&popup);
++
++  int r = popup.exec(p);
++  if (r == 93) activated(f);
++  else if (r == 94) activated(cycle);
++}
++
++void CallView::selectedSlot(TQListViewItem * i)
++{
++  if (!i) return;
++  TraceCall* c = ((CallItem*) i)->call();
++  // Should we skip cycles here?
++  TraceItem* f = _showCallers ? c->caller(false) : c->called(false);
++
++  _selectedItem = f;
++  selected(f);
++}
++
++void CallView::activatedSlot(TQListViewItem * i)
++{
++  if (!i) return;
++  TraceCall* c = ((CallItem*) i)->call();
++  // skip cycles: use the context menu to get to the cycle...
++  TraceItem* f = _showCallers ? c->caller(true) : c->called(true);
++
++  activated(f);
++}
++
++TraceItem* CallView::canShow(TraceItem* i)
++{
++  TraceItem::CostType t = i ? i->type() : TraceItem::NoCostType;
++
++  switch(t) {
++  case TraceItem::Function:
++  case TraceItem::FunctionCycle:
++      return i;
++  default:
++      break;
++  }
++  return 0;
++}
++
++void CallView::doUpdate(int changeType)
++{
++    // Special case ?
++    if (changeType == selectedItemChanged) {
++
++	if (!_selectedItem) {
++	    clearSelection();
++	    return;
++	}
++
++	CallItem* ci = (CallItem*) TQListView::selectedItem();
++	TraceCall* c;
++	TraceItem* ti;
++	if (ci) {
++	    c = ci->call();
++	    ti = _showCallers ? c->caller() : c->called();
++	    if (ti == _selectedItem) return;
++	}
++
++	TQListViewItem *item;
++	for (item = firstChild();item;item = item->nextSibling()) {
++	    c = ((CallItem*) item)->call();
++	    ti = _showCallers ? c->caller() : c->called();
++	    if (ti == _selectedItem) {
++		ensureItemVisible(item);
++		setSelected(item,  true);
++		break;
++	    }
++	}
++        if (!item && ci) clearSelection();
++	return;
++    }
++    
++    if (changeType == groupTypeChanged) {
++	TQListViewItem *item;
++	for (item = firstChild();item;item = item->nextSibling())
++	    ((CallItem*)item)->updateGroup();
++	return;
++    }
++
++    refresh();
++}
++
++void CallView::refresh()
++{
++    clear();
++    setColumnWidth(0, 50);
++    setColumnWidth(1, _costType2 ? 50:0);
++    setColumnWidth(2, 50);
++    if (_costType)
++      setColumnText(0, _costType->name());
++    if (_costType2)
++      setColumnText(1, _costType2->name());
++
++    if (!_data || !_activeItem) return;
++
++    TraceFunction* f = activeFunction();
++    if (!f) return;
++
++    TraceCall* call;
++    // In the call lists, we skip cycles to show the real call relations
++    TraceCallList l = _showCallers ? f->callers(true) : f->callings(true);
++
++    // Allow resizing of column 1
++    setColumnWidthMode(1, TQListView::Maximum);
++
++    for (call=l.first();call;call=l.next())
++	if (call->subCost(_costType)>0)
++	    new CallItem(this, this, call);
++
++    if (!_costType2) {
++      setColumnWidthMode(1, TQListView::Manual);
++      setColumnWidth(1, 0);
++    }
++}
++
++#include "callview.moc"
+diff --git a/kdecachegrind/kdecachegrind/callview.h b/kdecachegrind/kdecachegrind/callview.h
+new file mode 100644
+index 0000000..be644f9
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/callview.h
+@@ -0,0 +1,56 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Call Views
++ */
++
++#ifndef CALLVIEW_H
++#define CALLVIEW_H
++
++#include <tqlistview.h>
++#include "tracedata.h"
++#include "traceitemview.h"
++
++class CallView: public TQListView, public TraceItemView
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  CallView(bool showCallers, TraceItemView* parentView,
++	   TQWidget* parent=0, const char* name=0);
++
++  virtual TQWidget* widget() { return this; }
++  TQString whatsThis() const;
++  bool showCallers() const { return _showCallers; }
++
++private slots:
++  void context(TQListViewItem*,const TQPoint &, int);
++  void selectedSlot(TQListViewItem*);
++  void activatedSlot(TQListViewItem*);
++
++private:
++  TraceItem* canShow(TraceItem*);
++  void doUpdate(int);
++  void refresh();
++
++  bool _showCallers;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/configdlg.cpp b/kdecachegrind/kdecachegrind/configdlg.cpp
+new file mode 100644
+index 0000000..e0b4547
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/configdlg.cpp
+@@ -0,0 +1,398 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Configuration Dialog for KCachegrind
++ */
++
++#include <tqcombobox.h>
++#include <tqcheckbox.h>
++#include <tqlineedit.h>
++#include <tqlistview.h>
++#include <tqdict.h>
++#include <tqmessagebox.h>
++
++#include <kcolorbutton.h>
++#include <kfiledialog.h>
++#include <klocale.h>
++#include <knumvalidator.h>
++
++#include "configdlg.h"
++#include "tracedata.h"
++#include "configuration.h"
++
++
++ConfigDlg::ConfigDlg(Configuration* c, TraceData* data,
++                     TQWidget* parent, const char* name)
++  :ConfigDlgBase(parent, name)
++{
++  _config = c;
++  _data = data;
++  _objectCS = 0;
++  _classCS = 0;
++  _fileCS = 0;
++  KIntValidator * numValidator = new KIntValidator( this );
++  maxListEdit->setValidator(numValidator );
++  symbolCount->setValidator(numValidator );
++  symbolLength->setValidator(numValidator );
++  precisionEdit->setValidator(numValidator );
++  contextEdit->setValidator(numValidator );
++
++#if 0
++  TQListViewItem *oItem, *fItem, *cItem, *fnItem;
++  oItem = new(colorList, i18n("ELF Objects"));
++
++  fItem = new(colorList, i18n("Source Files"));
++  cItem = new(colorList, i18n("C++ Classes"));
++  fnItem = new(colorList, i18n("Function (no Grouping)"));
++#endif
++
++  connect(objectCombo, TQT_SIGNAL(activated(const TQString &)),
++          this, TQT_SLOT(objectActivated(const TQString &)));
++  connect(objectCombo, TQT_SIGNAL(textChanged(const TQString &)),
++          this, TQT_SLOT(objectActivated(const TQString &)));
++  connect(objectCheck, TQT_SIGNAL(toggled(bool)),
++          this, TQT_SLOT(objectCheckChanged(bool)));
++  connect(objectColor, TQT_SIGNAL(changed(const TQColor &)),
++          this, TQT_SLOT(objectColorChanged(const TQColor &)));
++
++  connect(classCombo, TQT_SIGNAL(activated(const TQString &)),
++          this, TQT_SLOT(classActivated(const TQString &)));
++  connect(classCombo, TQT_SIGNAL(textChanged(const TQString &)),
++          this, TQT_SLOT(classActivated(const TQString &)));
++  connect(classCheck, TQT_SIGNAL(toggled(bool)),
++          this, TQT_SLOT(classCheckChanged(bool)));
++  connect(classColor, TQT_SIGNAL(changed(const TQColor &)),
++          this, TQT_SLOT(classColorChanged(const TQColor &)));
++
++  connect(fileCombo, TQT_SIGNAL(activated(const TQString &)),
++          this, TQT_SLOT(fileActivated(const TQString &)));
++  connect(fileCombo, TQT_SIGNAL(textChanged(const TQString &)),
++          this, TQT_SLOT(fileActivated(const TQString &)));
++  connect(fileCheck, TQT_SIGNAL(toggled(bool)),
++          this, TQT_SLOT(fileCheckChanged(bool)));
++  connect(fileColor, TQT_SIGNAL(changed(const TQColor &)),
++          this, TQT_SLOT(fileColorChanged(const TQColor &)));
++
++  TQString objectPrefix = TraceCost::typeName(TraceCost::Object);
++  TQString classPrefix = TraceCost::typeName(TraceCost::Class);
++  TQString filePrefix = TraceCost::typeName(TraceCost::File);
++
++  objectCombo->setDuplicatesEnabled(false);
++  classCombo->setDuplicatesEnabled(false);
++  fileCombo->setDuplicatesEnabled(false);
++  objectCombo->setAutoCompletion(true);
++  classCombo->setAutoCompletion(true);
++  fileCombo->setAutoCompletion(true);
++
++  // first unspecified cost items from data
++  TraceObjectMap::Iterator oit;
++  TQStringList oList;
++  for ( oit = data->objectMap().begin();
++        oit != data->objectMap().end(); ++oit )
++    oList.append((*oit).prettyName());
++
++  TraceClassMap::Iterator cit;
++  TQStringList cList;
++  for ( cit = data->classMap().begin();
++        cit != data->classMap().end(); ++cit )
++    cList.append((*cit).prettyName());
++
++  TraceFileMap::Iterator fit;
++  TQStringList fList;
++  for ( fit = data->fileMap().begin();
++        fit != data->fileMap().end(); ++fit )
++    fList.append((*fit).prettyName());
++
++  // then already defined colors (have to check for duplicates!)
++  TQDictIterator<Configuration::ColorSetting> it( c->_colors );
++  for( ; it.current(); ++it ) {
++    if ((*it)->automatic) continue;
++
++    TQString n = it.currentKey();
++    if (n.startsWith(objectPrefix)) {
++      n = n.remove(0, objectPrefix.length()+1);
++      if (oList.findIndex(n) == -1) oList.append(n);
++    }
++    else if (n.startsWith(classPrefix)) {
++      n = n.remove(0, classPrefix.length()+1);
++      if (cList.findIndex(n) == -1) cList.append(n);
++    }
++    else if (n.startsWith(filePrefix)) {
++      n = n.remove(0, filePrefix.length()+1);
++      if (fList.findIndex(n) == -1) fList.append(n);
++    }
++  }
++
++  oList.sort();
++  cList.sort();
++  fList.sort();
++  objectCombo->insertStringList(oList);
++  classCombo->insertStringList(cList);
++  fileCombo->insertStringList(fList);
++
++  objectActivated(objectCombo->currentText());
++  classActivated(classCombo->currentText());
++  fileActivated(fileCombo->currentText());
++
++  maxListEdit->setText(TQString::number(c->_maxListCount));
++
++  _dirItem = 0;
++
++  TQListViewItem* i = new TQListViewItem(dirList, i18n("(always)"));
++  i->setOpen(true);
++  TQStringList::Iterator sit = c->_generalSourceDirs.begin();
++  for(; sit != c->_generalSourceDirs.end(); ++sit ) {
++    TQString d = (*sit);
++    if (d.isEmpty()) d = "/";
++    new TQListViewItem(i, d);
++  }
++  for ( oit = data->objectMap().begin();
++        oit != data->objectMap().end(); ++oit ) {
++    TQString n = (*oit).name();
++    i = new TQListViewItem(dirList, n);
++    i->setOpen(true);
++    TQStringList* dirs = c->_objectSourceDirs[n];
++    if (!dirs) continue;
++
++    sit = dirs->begin();
++    for(; sit != dirs->end(); ++sit ) {
++      TQString d = (*sit);
++      if (d.isEmpty()) d = "/";
++      new TQListViewItem(i, d);
++    }
++  }
++
++  connect(dirList, TQT_SIGNAL(selectionChanged(TQListViewItem*)),
++          this, TQT_SLOT(dirsItemChanged(TQListViewItem*)));
++  connect(addDirButton, TQT_SIGNAL(clicked()),
++          this, TQT_SLOT(dirsAddPressed()));
++  connect(deleteDirButton, TQT_SIGNAL(clicked()),
++          this, TQT_SLOT(dirsDeletePressed()));
++  dirList->setSelected(dirList->firstChild(), true);
++
++  symbolCount->setText(TQString::number(c->_maxSymbolCount));
++  symbolLength->setText(TQString::number(c->_maxSymbolLength));
++  precisionEdit->setText(TQString::number(c->_percentPrecision));
++  contextEdit->setText(TQString::number(c->_context));
++}
++
++ConfigDlg::~ConfigDlg()
++{
++}
++
++bool ConfigDlg::configure(Configuration* c, TraceData* d, TQWidget* p)
++{
++  ConfigDlg dlg(c, d, p);
++
++  if (dlg.exec()) {
++
++    bool ok;
++    int newValue = dlg.maxListEdit->text().toUInt(&ok);
++    if (ok && newValue < 500)
++      c->_maxListCount = newValue;
++    else
++      TQMessageBox::warning(p, i18n("KCachegrind Configuration"),
++                           i18n("The Maximum Number of List Items should be below 500."
++                                "The previous set value (%1) will still be used.")
++                           .arg(TQString::number(c->_maxListCount)),
++                           TQMessageBox::Ok, 0);
++
++    c->_maxSymbolCount = dlg.symbolCount->text().toInt();
++    c->_maxSymbolLength = dlg.symbolLength->text().toInt();
++    c->_percentPrecision = dlg.precisionEdit->text().toInt();
++    c->_context = dlg.contextEdit->text().toInt();
++    return true;
++  }
++  return false;
++}
++
++void ConfigDlg::objectActivated(const TQString & s)
++{
++//  qDebug("objectActivated: %s", s.ascii());
++
++  if (s.isEmpty()) { _objectCS=0; return; }
++
++  TQString n = TraceCost::typeName(TraceCost::Object) + "-" + s;
++
++  Configuration* c = Configuration::config();
++  Configuration::ColorSetting* cs = c->_colors[n];
++  if (!cs)
++    cs = Configuration::color(n);
++//  else
++//    qDebug("found color %s", n.ascii());
++
++  _objectCS = cs;
++
++  objectCheck->setChecked(cs->automatic);
++  objectColor->setColor(cs->color);
++
++  /*
++  qDebug("Found Color %s, automatic to %s",
++         _objectCS->name.ascii(),
++         _objectCS->automatic ? "true":"false");
++  */
++}
++
++
++void ConfigDlg::objectCheckChanged(bool b)
++{
++  if (_objectCS) {
++    _objectCS->automatic = b;
++    /*
++    qDebug("Set Color %s automatic to %s",
++           _objectCS->name.ascii(),
++           _objectCS->automatic ? "true":"false");
++    */
++  }
++}
++
++void ConfigDlg::objectColorChanged(const TQColor & c)
++{
++  if (_objectCS) _objectCS->color = c;
++}
++
++void ConfigDlg::classActivated(const TQString & s)
++{
++//  qDebug("classActivated: %s", s.ascii());
++
++  if (s.isEmpty()) { _classCS=0; return; }
++
++  TQString n = TraceCost::typeName(TraceCost::Class) + "-" + s;
++
++  Configuration* c = Configuration::config();
++  Configuration::ColorSetting* cs = c->_colors[n];
++  if (!cs)
++    cs = Configuration::color(n);
++
++  _classCS = cs;
++
++  classCheck->setChecked(cs->automatic);
++  classColor->setColor(cs->color);
++
++}
++
++
++void ConfigDlg::classCheckChanged(bool b)
++{
++  if (_classCS) _classCS->automatic = b;
++}
++
++void ConfigDlg::classColorChanged(const TQColor & c)
++{
++  if (_classCS) _classCS->color = c;
++}
++
++
++void ConfigDlg::fileActivated(const TQString & s)
++{
++//  qDebug("fileActivated: %s", s.ascii());
++
++  if (s.isEmpty()) { _fileCS=0; return; }
++
++  TQString n = TraceCost::typeName(TraceCost::File) + "-" + s;
++
++  Configuration* c = Configuration::config();
++  Configuration::ColorSetting* cs = c->_colors[n];
++  if (!cs)
++    cs = Configuration::color(n);
++
++  _fileCS = cs;
++
++  fileCheck->setChecked(cs->automatic);
++  fileColor->setColor(cs->color);
++}
++
++
++void ConfigDlg::fileCheckChanged(bool b)
++{
++  if (_fileCS) _fileCS->automatic = b;
++}
++
++void ConfigDlg::fileColorChanged(const TQColor & c)
++{
++  if (_fileCS) _fileCS->color = c;
++}
++
++
++void ConfigDlg::dirsItemChanged(TQListViewItem* i)
++{
++  _dirItem = i;
++  deleteDirButton->setEnabled(i->depth() == 1);
++  addDirButton->setEnabled(i->depth() == 0);
++}
++
++void ConfigDlg::dirsDeletePressed()
++{
++  if (!_dirItem || (_dirItem->depth() == 0)) return;
++  TQListViewItem* p = _dirItem->parent();
++  if (!p) return;
++
++  Configuration* c = Configuration::config();
++  TQString objName = p->text(0);
++
++  TQStringList* dirs;
++  if (objName == i18n("(always)"))
++    dirs = &(c->_generalSourceDirs);
++  else
++    dirs = c->_objectSourceDirs[objName];
++  if (!dirs) return;
++
++  dirs->remove(_dirItem->text(0));
++  delete _dirItem;
++  _dirItem = 0;
++
++  deleteDirButton->setEnabled(false);
++}
++
++void ConfigDlg::dirsAddPressed()
++{
++  if (!_dirItem || (_dirItem->depth() >0)) return;
++
++  Configuration* c = Configuration::config();
++  TQString objName = _dirItem->text(0);
++
++  TQStringList* dirs;
++  if (objName == i18n("(always)"))
++    dirs = &(c->_generalSourceDirs);
++  else {
++    dirs = c->_objectSourceDirs[objName];
++    if (!dirs) {
++      dirs = new TQStringList;
++      c->_objectSourceDirs.insert(objName, dirs);
++    }
++  }
++
++  TQString newDir;
++  newDir = KFileDialog::getExistingDirectory(TQString(),
++                                             this,
++                                             i18n("Choose Source Folder"));
++  if (newDir.isEmpty()) return;
++
++  // even for "/", we strip the tailing slash
++  if (newDir.endsWith("/"))
++    newDir = newDir.left(newDir.length()-1);
++
++  if (dirs->findIndex(newDir)>=0) return;
++
++  dirs->append(newDir);
++  if (newDir.isEmpty()) newDir = TQString("/");
++  new TQListViewItem(_dirItem, newDir);
++}
++
++#include "configdlg.moc"
+diff --git a/kdecachegrind/kdecachegrind/configdlg.h b/kdecachegrind/kdecachegrind/configdlg.h
+new file mode 100644
+index 0000000..5ef6bab
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/configdlg.h
+@@ -0,0 +1,65 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Configuration Dialog for KCachegrind
++ */
++
++#ifndef CONFIGDLG_H
++#define CONFIGDLG_H
++
++#include "configdlgbase.h"
++#include "configuration.h"
++
++class TraceData;
++
++class ConfigDlg : public ConfigDlgBase
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  ConfigDlg(Configuration*, TraceData*,
++            TQWidget* parent = 0, const char* name = 0);
++  ~ConfigDlg();
++
++  static bool configure(Configuration*, TraceData*, TQWidget*);
++
++protected slots:
++  void objectActivated(const TQString &);
++  void objectCheckChanged(bool);
++  void objectColorChanged(const TQColor &);
++  void classActivated(const TQString &);
++  void classCheckChanged(bool);
++  void classColorChanged(const TQColor &);
++  void fileActivated(const TQString &);
++  void fileCheckChanged(bool);
++  void fileColorChanged(const TQColor &);
++  void dirsItemChanged(TQListViewItem*);
++  void dirsDeletePressed();
++  void dirsAddPressed();
++
++private:
++  Configuration* _config;
++  TraceData* _data;
++
++  Configuration::ColorSetting *_objectCS, *_classCS, *_fileCS;
++  TQListViewItem* _dirItem;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/configdlgbase.ui b/kdecachegrind/kdecachegrind/configdlgbase.ui
+new file mode 100644
+index 0000000..dc0ee9e
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/configdlgbase.ui
+@@ -0,0 +1,653 @@
++<!DOCTYPE UI><UI version="3.1" stdsetdef="1">
++<class>ConfigDlgBase</class>
++<widget class="TQDialog">
++    <property name="name">
++        <cstring>configDlgBase</cstring>
++    </property>
++    <property name="geometry">
++        <rect>
++            <x>0</x>
++            <y>0</y>
++            <width>447</width>
++            <height>378</height>
++        </rect>
++    </property>
++    <property name="caption">
++        <string>Configuration</string>
++    </property>
++    <vbox>
++        <property name="name">
++            <cstring>unnamed</cstring>
++        </property>
++        <property name="margin">
++            <number>11</number>
++        </property>
++        <property name="spacing">
++            <number>6</number>
++        </property>
++        <widget class="TQTabWidget">
++            <property name="name">
++                <cstring>tabWidget2</cstring>
++            </property>
++            <widget class="TQWidget">
++                <property name="name">
++                    <cstring>tab</cstring>
++                </property>
++                <attribute name="title">
++                    <string>General</string>
++                </attribute>
++                <vbox>
++                    <property name="name">
++                        <cstring>unnamed</cstring>
++                    </property>
++                    <widget class="TQLayoutWidget">
++                        <property name="name">
++                            <cstring>layout10</cstring>
++                        </property>
++                        <grid>
++                            <property name="name">
++                                <cstring>unnamed</cstring>
++                            </property>
++                            <widget class="TQLineEdit" row="3" column="2" rowspan="1" colspan="2">
++                                <property name="name">
++                                    <cstring>precisionEdit</cstring>
++                                </property>
++                                <property name="sizePolicy">
++                                    <sizepolicy>
++                                        <hsizetype>7</hsizetype>
++                                        <vsizetype>0</vsizetype>
++                                        <horstretch>2</horstretch>
++                                        <verstretch>0</verstretch>
++                                    </sizepolicy>
++                                </property>
++                            </widget>
++                            <widget class="TQLabel" row="2" column="1">
++                                <property name="name">
++                                    <cstring>TextLabel2</cstring>
++                                </property>
++                                <property name="text">
++                                    <string>Truncated when more/longer than:</string>
++                                </property>
++                            </widget>
++                            <widget class="TQLabel" row="3" column="0" rowspan="1" colspan="2">
++                                <property name="name">
++                                    <cstring>TextLabel4_3</cstring>
++                                </property>
++                                <property name="text">
++                                    <string>Precision of percentage values:</string>
++                                </property>
++                            </widget>
++                            <widget class="TQLabel" row="1" column="0" rowspan="1" colspan="3">
++                                <property name="name">
++                                    <cstring>TextLabel3</cstring>
++                                </property>
++                                <property name="text">
++                                    <string>Symbols in tooltips and context menus</string>
++                                </property>
++                            </widget>
++                            <widget class="TQLineEdit" row="2" column="3">
++                                <property name="name">
++                                    <cstring>symbolLength</cstring>
++                                </property>
++                                <property name="sizePolicy">
++                                    <sizepolicy>
++                                        <hsizetype>4</hsizetype>
++                                        <vsizetype>0</vsizetype>
++                                        <horstretch>0</horstretch>
++                                        <verstretch>0</verstretch>
++                                    </sizepolicy>
++                                </property>
++                            </widget>
++                            <spacer row="2" column="0">
++                                <property name="name">
++                                    <cstring>Spacer6_2_2_2</cstring>
++                                </property>
++                                <property name="orientation">
++                                    <enum>Horizontal</enum>
++                                </property>
++                                <property name="sizeType">
++                                    <enum>Fixed</enum>
++                                </property>
++                                <property name="sizeHint">
++                                    <size>
++                                        <width>16</width>
++                                        <height>20</height>
++                                    </size>
++                                </property>
++                            </spacer>
++                            <widget class="TQLineEdit" row="0" column="2" rowspan="1" colspan="2">
++                                <property name="name">
++                                    <cstring>maxListEdit</cstring>
++                                </property>
++                            </widget>
++                            <widget class="TQLineEdit" row="2" column="2">
++                                <property name="name">
++                                    <cstring>symbolCount</cstring>
++                                </property>
++                                <property name="sizePolicy">
++                                    <sizepolicy>
++                                        <hsizetype>4</hsizetype>
++                                        <vsizetype>0</vsizetype>
++                                        <horstretch>0</horstretch>
++                                        <verstretch>0</verstretch>
++                                    </sizepolicy>
++                                </property>
++                            </widget>
++                            <widget class="TQLabel" row="0" column="0" rowspan="1" colspan="2">
++                                <property name="name">
++                                    <cstring>TextLabel5</cstring>
++                                </property>
++                                <property name="text">
++                                    <string>Maximum number of items in lists:</string>
++                                </property>
++                            </widget>
++                        </grid>
++                    </widget>
++                    <widget class="TQLabel">
++                        <property name="name">
++                            <cstring>TextLabel1</cstring>
++                        </property>
++                        <property name="font">
++                            <font>
++                                <bold>1</bold>
++                            </font>
++                        </property>
++                        <property name="frameShape">
++                            <enum>NoFrame</enum>
++                        </property>
++                        <property name="frameShadow">
++                            <enum>Plain</enum>
++                        </property>
++                        <property name="text">
++                            <string>Cost Item Colors</string>
++                        </property>
++                    </widget>
++                    <widget class="TQLayoutWidget">
++                        <property name="name">
++                            <cstring>Layout9</cstring>
++                        </property>
++                        <grid>
++                            <property name="name">
++                                <cstring>unnamed</cstring>
++                            </property>
++                            <property name="margin">
++                                <number>0</number>
++                            </property>
++                            <property name="spacing">
++                                <number>6</number>
++                            </property>
++                            <spacer row="1" column="1">
++                                <property name="name">
++                                    <cstring>Spacer9</cstring>
++                                </property>
++                                <property name="orientation">
++                                    <enum>Vertical</enum>
++                                </property>
++                                <property name="sizeType">
++                                    <enum>Fixed</enum>
++                                </property>
++                                <property name="sizeHint">
++                                    <size>
++                                        <width>20</width>
++                                        <height>16</height>
++                                    </size>
++                                </property>
++                            </spacer>
++                            <spacer row="0" column="0">
++                                <property name="name">
++                                    <cstring>Spacer6</cstring>
++                                </property>
++                                <property name="orientation">
++                                    <enum>Horizontal</enum>
++                                </property>
++                                <property name="sizeType">
++                                    <enum>Fixed</enum>
++                                </property>
++                                <property name="sizeHint">
++                                    <size>
++                                        <width>16</width>
++                                        <height>20</height>
++                                    </size>
++                                </property>
++                            </spacer>
++                            <widget class="TQLayoutWidget" row="0" column="1">
++                                <property name="name">
++                                    <cstring>Layout9</cstring>
++                                </property>
++                                <grid>
++                                    <property name="name">
++                                        <cstring>unnamed</cstring>
++                                    </property>
++                                    <property name="margin">
++                                        <number>0</number>
++                                    </property>
++                                    <property name="spacing">
++                                        <number>6</number>
++                                    </property>
++                                    <widget class="TQComboBox" row="1" column="1">
++                                        <property name="name">
++                                            <cstring>classCombo</cstring>
++                                        </property>
++                                        <property name="maximumSize">
++                                            <size>
++                                                <width>300</width>
++                                                <height>32767</height>
++                                            </size>
++                                        </property>
++                                        <property name="editable">
++                                            <bool>true</bool>
++                                        </property>
++                                    </widget>
++                                    <widget class="TQCheckBox" row="2" column="2">
++                                        <property name="name">
++                                            <cstring>fileCheck</cstring>
++                                        </property>
++                                        <property name="text">
++                                            <string>Automatic</string>
++                                        </property>
++                                    </widget>
++                                    <widget class="TQLabel" row="0" column="0">
++                                        <property name="name">
++                                            <cstring>TextLabel4</cstring>
++                                        </property>
++                                        <property name="text">
++                                            <string>Object:</string>
++                                        </property>
++                                    </widget>
++                                    <widget class="TQLabel" row="1" column="0">
++                                        <property name="name">
++                                            <cstring>TextLabel4_2_2</cstring>
++                                        </property>
++                                        <property name="text">
++                                            <string>Class:</string>
++                                        </property>
++                                    </widget>
++                                    <widget class="KColorButton" row="2" column="3">
++                                        <property name="name">
++                                            <cstring>fileColor</cstring>
++                                        </property>
++                                        <property name="sizePolicy">
++                                            <sizepolicy>
++                                                <hsizetype>0</hsizetype>
++                                                <vsizetype>0</vsizetype>
++                                                <horstretch>0</horstretch>
++                                                <verstretch>0</verstretch>
++                                            </sizepolicy>
++                                        </property>
++                                        <property name="text">
++                                            <string></string>
++                                        </property>
++                                    </widget>
++                                    <widget class="TQCheckBox" row="1" column="2">
++                                        <property name="name">
++                                            <cstring>classCheck</cstring>
++                                        </property>
++                                        <property name="text">
++                                            <string>Automatic</string>
++                                        </property>
++                                    </widget>
++                                    <widget class="KColorButton" row="0" column="3">
++                                        <property name="name">
++                                            <cstring>objectColor</cstring>
++                                        </property>
++                                        <property name="text">
++                                            <string></string>
++                                        </property>
++                                    </widget>
++                                    <widget class="TQCheckBox" row="0" column="2">
++                                        <property name="name">
++                                            <cstring>objectCheck</cstring>
++                                        </property>
++                                        <property name="text">
++                                            <string>Automatic</string>
++                                        </property>
++                                    </widget>
++                                    <widget class="TQLabel" row="2" column="0">
++                                        <property name="name">
++                                            <cstring>TextLabel4_2</cstring>
++                                        </property>
++                                        <property name="text">
++                                            <string>File:</string>
++                                        </property>
++                                    </widget>
++                                    <widget class="KColorButton" row="1" column="3">
++                                        <property name="name">
++                                            <cstring>classColor</cstring>
++                                        </property>
++                                        <property name="sizePolicy">
++                                            <sizepolicy>
++                                                <hsizetype>0</hsizetype>
++                                                <vsizetype>0</vsizetype>
++                                                <horstretch>0</horstretch>
++                                                <verstretch>0</verstretch>
++                                            </sizepolicy>
++                                        </property>
++                                        <property name="text">
++                                            <string></string>
++                                        </property>
++                                    </widget>
++                                    <widget class="TQComboBox" row="2" column="1">
++                                        <property name="name">
++                                            <cstring>fileCombo</cstring>
++                                        </property>
++                                        <property name="maximumSize">
++                                            <size>
++                                                <width>300</width>
++                                                <height>32767</height>
++                                            </size>
++                                        </property>
++                                        <property name="editable">
++                                            <bool>true</bool>
++                                        </property>
++                                    </widget>
++                                    <widget class="TQComboBox" row="0" column="1">
++                                        <property name="name">
++                                            <cstring>objectCombo</cstring>
++                                        </property>
++                                        <property name="sizePolicy">
++                                            <sizepolicy>
++                                                <hsizetype>3</hsizetype>
++                                                <vsizetype>0</vsizetype>
++                                                <horstretch>0</horstretch>
++                                                <verstretch>0</verstretch>
++                                            </sizepolicy>
++                                        </property>
++                                        <property name="maximumSize">
++                                            <size>
++                                                <width>300</width>
++                                                <height>32767</height>
++                                            </size>
++                                        </property>
++                                        <property name="editable">
++                                            <bool>true</bool>
++                                        </property>
++                                    </widget>
++                                </grid>
++                            </widget>
++                        </grid>
++                    </widget>
++                </vbox>
++            </widget>
++            <widget class="TQWidget">
++                <property name="name">
++                    <cstring>tab</cstring>
++                </property>
++                <attribute name="title">
++                    <string>Annotations</string>
++                </attribute>
++                <vbox>
++                    <property name="name">
++                        <cstring>unnamed</cstring>
++                    </property>
++                    <widget class="TQLayoutWidget">
++                        <property name="name">
++                            <cstring>layout8</cstring>
++                        </property>
++                        <hbox>
++                            <property name="name">
++                                <cstring>unnamed</cstring>
++                            </property>
++                            <widget class="TQLabel">
++                                <property name="name">
++                                    <cstring>TextLabel4_3_2</cstring>
++                                </property>
++                                <property name="text">
++                                    <string>Context lines in annotations:</string>
++                                </property>
++                            </widget>
++                            <widget class="TQLineEdit">
++                                <property name="name">
++                                    <cstring>contextEdit</cstring>
++                                </property>
++                                <property name="sizePolicy">
++                                    <sizepolicy>
++                                        <hsizetype>7</hsizetype>
++                                        <vsizetype>0</vsizetype>
++                                        <horstretch>2</horstretch>
++                                        <verstretch>0</verstretch>
++                                    </sizepolicy>
++                                </property>
++                            </widget>
++                        </hbox>
++                    </widget>
++                    <widget class="TQLabel">
++                        <property name="name">
++                            <cstring>TextLabel1_2</cstring>
++                        </property>
++                        <property name="font">
++                            <font>
++                                <bold>1</bold>
++                            </font>
++                        </property>
++                        <property name="text">
++                            <string>Source Folders</string>
++                        </property>
++                    </widget>
++                    <widget class="TQLayoutWidget">
++                        <property name="name">
++                            <cstring>layout11</cstring>
++                        </property>
++                        <grid>
++                            <property name="name">
++                                <cstring>unnamed</cstring>
++                            </property>
++                            <spacer row="0" column="0">
++                                <property name="name">
++                                    <cstring>Spacer6_2</cstring>
++                                </property>
++                                <property name="orientation">
++                                    <enum>Horizontal</enum>
++                                </property>
++                                <property name="sizeType">
++                                    <enum>Fixed</enum>
++                                </property>
++                                <property name="sizeHint">
++                                    <size>
++                                        <width>16</width>
++                                        <height>20</height>
++                                    </size>
++                                </property>
++                            </spacer>
++                            <widget class="TQListView" row="0" column="1">
++                                <column>
++                                    <property name="text">
++                                        <string>Object / Related Source Base</string>
++                                    </property>
++                                    <property name="clickable">
++                                        <bool>true</bool>
++                                    </property>
++                                    <property name="resizable">
++                                        <bool>true</bool>
++                                    </property>
++                                </column>
++                                <property name="name">
++                                    <cstring>dirList</cstring>
++                                </property>
++                                <property name="rootIsDecorated">
++                                    <bool>true</bool>
++                                </property>
++                            </widget>
++                            <widget class="TQLayoutWidget" row="0" column="2">
++                                <property name="name">
++                                    <cstring>layout10</cstring>
++                                </property>
++                                <vbox>
++                                    <property name="name">
++                                        <cstring>unnamed</cstring>
++                                    </property>
++                                    <widget class="TQPushButton">
++                                        <property name="name">
++                                            <cstring>addDirButton</cstring>
++                                        </property>
++                                        <property name="text">
++                                            <string>Add...</string>
++                                        </property>
++                                    </widget>
++                                    <spacer>
++                                        <property name="name">
++                                            <cstring>Spacer5</cstring>
++                                        </property>
++                                        <property name="orientation">
++                                            <enum>Vertical</enum>
++                                        </property>
++                                        <property name="sizeType">
++                                            <enum>Expanding</enum>
++                                        </property>
++                                        <property name="sizeHint">
++                                            <size>
++                                                <width>16</width>
++                                                <height>49</height>
++                                            </size>
++                                        </property>
++                                    </spacer>
++                                    <widget class="TQPushButton">
++                                        <property name="name">
++                                            <cstring>deleteDirButton</cstring>
++                                        </property>
++                                        <property name="text">
++                                            <string>Delete</string>
++                                        </property>
++                                    </widget>
++                                </vbox>
++                            </widget>
++                            <spacer row="1" column="1">
++                                <property name="name">
++                                    <cstring>Spacer9_2</cstring>
++                                </property>
++                                <property name="orientation">
++                                    <enum>Vertical</enum>
++                                </property>
++                                <property name="sizeType">
++                                    <enum>Fixed</enum>
++                                </property>
++                                <property name="sizeHint">
++                                    <size>
++                                        <width>20</width>
++                                        <height>16</height>
++                                    </size>
++                                </property>
++                            </spacer>
++                        </grid>
++                    </widget>
++                </vbox>
++            </widget>
++        </widget>
++        <widget class="Line">
++            <property name="name">
++                <cstring>Line1</cstring>
++            </property>
++            <property name="frameShape">
++                <enum>HLine</enum>
++            </property>
++            <property name="frameShadow">
++                <enum>Sunken</enum>
++            </property>
++            <property name="orientation">
++                <enum>Horizontal</enum>
++            </property>
++        </widget>
++        <widget class="TQLayoutWidget">
++            <property name="name">
++                <cstring>Layout4</cstring>
++            </property>
++            <hbox>
++                <property name="name">
++                    <cstring>unnamed</cstring>
++                </property>
++                <property name="margin">
++                    <number>0</number>
++                </property>
++                <property name="spacing">
++                    <number>6</number>
++                </property>
++                <spacer>
++                    <property name="name">
++                        <cstring>Spacer2</cstring>
++                    </property>
++                    <property name="orientation">
++                        <enum>Horizontal</enum>
++                    </property>
++                    <property name="sizeType">
++                        <enum>Expanding</enum>
++                    </property>
++                    <property name="sizeHint">
++                        <size>
++                            <width>210</width>
++                            <height>0</height>
++                        </size>
++                    </property>
++                </spacer>
++                <widget class="TQPushButton">
++                    <property name="name">
++                        <cstring>PushButton2</cstring>
++                    </property>
++                    <property name="text">
++                        <string>&amp;OK</string>
++                    </property>
++                    <property name="default">
++                        <bool>true</bool>
++                    </property>
++                </widget>
++                <widget class="TQPushButton">
++                    <property name="name">
++                        <cstring>PushButton1</cstring>
++                    </property>
++                    <property name="text">
++                        <string>&amp;Cancel</string>
++                    </property>
++                </widget>
++            </hbox>
++        </widget>
++    </vbox>
++</widget>
++<connections>
++    <connection>
++        <sender>PushButton2</sender>
++        <signal>clicked()</signal>
++        <receiver>configDlgBase</receiver>
++        <slot>accept()</slot>
++    </connection>
++    <connection>
++        <sender>PushButton1</sender>
++        <signal>clicked()</signal>
++        <receiver>configDlgBase</receiver>
++        <slot>reject()</slot>
++    </connection>
++    <connection>
++        <sender>classCheck</sender>
++        <signal>toggled(bool)</signal>
++        <receiver>classColor</receiver>
++        <slot>setDisabled(bool)</slot>
++    </connection>
++    <connection>
++        <sender>fileCheck</sender>
++        <signal>toggled(bool)</signal>
++        <receiver>fileColor</receiver>
++        <slot>setDisabled(bool)</slot>
++    </connection>
++    <connection>
++        <sender>objectCheck</sender>
++        <signal>toggled(bool)</signal>
++        <receiver>objectColor</receiver>
++        <slot>setDisabled(bool)</slot>
++    </connection>
++</connections>
++<tabstops>
++    <tabstop>objectCombo</tabstop>
++    <tabstop>objectCheck</tabstop>
++    <tabstop>classCombo</tabstop>
++    <tabstop>classCheck</tabstop>
++    <tabstop>classColor</tabstop>
++    <tabstop>fileCombo</tabstop>
++    <tabstop>fileCheck</tabstop>
++    <tabstop>fileColor</tabstop>
++    <tabstop>maxListEdit</tabstop>
++    <tabstop>PushButton1</tabstop>
++    <tabstop>PushButton2</tabstop>
++</tabstops>
++<includes>
++    <include location="global" impldecl="in implementation">kcolorbutton.h</include>
++</includes>
++<pixmapinproject/>
++<layoutdefaults spacing="6" margin="11"/>
++</UI>
+diff --git a/kdecachegrind/kdecachegrind/configuration.cpp b/kdecachegrind/kdecachegrind/configuration.cpp
+new file mode 100644
+index 0000000..02d5c09
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/configuration.cpp
+@@ -0,0 +1,490 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Configuration for KCachegrind
++ */
++
++#include <kconfig.h>
++#include <klocale.h>
++#include <kdebug.h>
++
++#include "configuration.h"
++#include "tracedata.h"
++#include "configdlgbase.h"
++
++#include "traceitemview.h"
++
++//
++// Some predefined cost types...
++//
++
++static TQStringList knownTypes()
++{
++  TQStringList l;
++
++  l << "Ir"   << "Dr"   << "Dw"
++    << "I1mr" << "D1mr" << "D1mw"
++    << "I2mr" << "D2mr" << "D2mw"
++
++    << "Smp"  << "Sys"  << "User"
++    << "L1m"  << "L2m"  << "CEst";
++
++  return l;
++}
++
++
++static TQString knownFormula(TQString name)
++{
++  if (name =="L1m") return TQString("I1mr + D1mr + D1mw");
++  if (name =="L2m") return TQString("I2mr + D2mr + D2mw");
++  if (name =="CEst") return TQString("Ir + 10 L1m + 100 L2m");
++
++  return TQString();
++}
++
++static TQString knownLongName(TQString name)
++{
++    if (name == "Ir") return i18n("Instruction Fetch");
++    if (name =="Dr") return i18n("Data Read Access");
++    if (name =="Dw") return i18n("Data Write Access");
++    if (name =="I1mr") return i18n("L1 Instr. Fetch Miss");
++    if (name =="D1mr") return i18n("L1 Data Read Miss");
++    if (name =="D1mw") return i18n("L1 Data Write Miss");
++    if (name =="I2mr") return i18n("L2 Instr. Fetch Miss");
++    if (name =="D2mr") return i18n("L2 Data Read Miss");
++    if (name =="D2mw") return i18n("L2 Data Write Miss");
++    if (name =="Smp") return i18n("Samples");
++    if (name =="Sys") return i18n("System Time");
++    if (name =="User") return i18n("User Time");
++    if (name =="L1m") return i18n("L1 Miss Sum");
++    if (name =="L2m") return i18n("L2 Miss Sum");
++    if (name =="CEst") return i18n("Cycle Estimation");
++
++    return TQString();
++}
++
++
++
++
++//
++// Configuration
++//
++
++Configuration* Configuration::_config = 0;
++
++Configuration::Configuration()
++  :_colors(517)
++{
++  _config = 0;
++
++  _colors.setAutoDelete(true);
++  _objectSourceDirs.setAutoDelete(true);
++
++  // defaults
++  _showPercentage = true;
++  _showExpanded = false;
++  _showCycles = true;
++  _cycleCut = 0.0;
++  _percentPrecision = 2;
++
++  // max symbol count/length in tooltip/popup
++  _maxSymbolLength = 30;
++  _maxSymbolCount = 10;
++  _maxListCount = 100;
++
++  // annotation behaviour
++  _context = 3;
++  _noCostInside   = 20;
++}
++
++Configuration* Configuration::config()
++{
++  if (!_config)
++    _config = new Configuration();
++
++  return _config;
++}
++
++
++void Configuration::saveOptions(KConfig* kconfig)
++{
++  Configuration* c = config();
++
++  // color options
++  KConfigGroup colorConfig(kconfig, TQCString("CostColors"));
++  TQDictIterator<ColorSetting> it( c->_colors );
++  int count = 1;
++  for( ; it.current(); ++it ) {
++    if ( !(*it)->automatic ) {
++      colorConfig.writeEntry( TQString("Name%1").arg(count),
++                              it.currentKey());
++      colorConfig.writeEntry( TQString("Color%1").arg(count),
++                              (*it)->color);
++      //qDebug("Written Color %s (%d)", it.currentKey().ascii(), count);
++
++      count++;
++    }
++  }
++  colorConfig.writeEntry( "Count", count-1);
++
++  // source options
++  KConfigGroup sourceConfig(kconfig, TQCString("Source"));
++  sourceConfig.writeEntry("Dirs", c->_generalSourceDirs, ':');
++  TQDictIterator<TQStringList> it2( c->_objectSourceDirs );
++  count = 1;
++  for( ; it2.current(); ++it2 ) {
++    sourceConfig.writeEntry( TQString("Object%1").arg(count),
++			     it2.currentKey());
++    sourceConfig.writeEntry( TQString("Dirs%1").arg(count),
++			     *(*it2), ':');
++    count++;
++  }
++  sourceConfig.writeEntry( "Count", count-1);
++
++  // general options
++  KConfigGroup generalConfig(kconfig, TQCString("General"));
++  generalConfig.writeEntry("ShowPercentage", c->_showPercentage);
++  generalConfig.writeEntry("ShowExpanded", c->_showExpanded);
++  generalConfig.writeEntry("ShowCycles", c->_showCycles);
++  generalConfig.writeEntry("CycleCut", c->_cycleCut);
++  generalConfig.writeEntry("MaxSymbolCount", c->_maxSymbolCount);
++  generalConfig.writeEntry("MaxListCount", c->_maxListCount);
++  generalConfig.writeEntry("MaxSymbolLength", c->_maxSymbolLength);
++  generalConfig.writeEntry("PercentPrecision", c->_percentPrecision);
++
++  generalConfig.writeEntry("Context", c->_context);
++  generalConfig.writeEntry("NoCostInside", c->_noCostInside);
++
++  KConfigGroup ctConfig(kconfig, TQCString("CostTypes"));
++  int ctCount = TraceCostType::knownTypeCount();
++  ctConfig.writeEntry( "Count", ctCount);
++  for (int i=0; i<ctCount; i++) {
++    TraceCostType* t = TraceCostType::knownType(i);
++    ctConfig.writeEntry( TQString("Name%1").arg(i+1), t->name());
++
++    // Use localized key
++    TraceItemView::writeConfigEntry(&ctConfig,
++                                    TQString("Longname%1").arg(i+1).ascii(),
++                                    t->longName(),
++                                    knownLongName(t->name()).utf8().data() /*, true */ );
++    TraceItemView::writeConfigEntry(&ctConfig,
++                                    TQString("Formula%1").arg(i+1).ascii(),
++                                    t->formula(), knownFormula(t->name()).utf8().data());
++  }
++}
++
++
++
++
++void Configuration::readOptions(KConfig* kconfig)
++{
++  int i, count;
++  Configuration* c = config();
++
++  // color options
++  c->_colors.clear();
++
++  // colors for default cost types:
++  //  red for L2 misses, green for L1 misses, blue for normal accesses
++  c->color("CostType-I2mr")->color = TQColor(240, 0, 0);
++  c->color("CostType-D2mr")->color = TQColor(180,40,40);
++  c->color("CostType-D2mw")->color = TQColor(120,80,80);
++
++  c->color("CostType-I1mr")->color = TQColor(0, 240, 0);
++  c->color("CostType-D1mr")->color = TQColor(40,180,40);
++  c->color("CostType-D1mw")->color = TQColor(80,120,80);
++
++  c->color("CostType-Ir")->color = TQColor(0, 0, 240);
++  c->color("CostType-Dr")->color = TQColor(40,40,180);
++  c->color("CostType-Dw")->color = TQColor(80,80,120);
++
++  KConfigGroup colorConfig(kconfig, TQCString("CostColors"));
++  count = colorConfig.readNumEntry("Count", 0);
++  for (i=1;i<=count;i++) {
++    TQString n = colorConfig.readEntry(TQString("Name%1").arg(i));
++    TQColor color = colorConfig.readColorEntry(TQString("Color%1").arg(i));
++
++    if (n.isEmpty()) continue;
++
++    ColorSetting* cs = new ColorSetting;
++    cs->name = n;
++    cs->automatic = false;
++    cs->color = color;
++
++    c->_colors.insert(n, cs);
++
++    //qDebug("Read Color %s", n.ascii());
++  }
++
++  // source options
++  KConfigGroup sourceConfig(kconfig, TQCString("Source"));
++  TQStringList dirs;
++  dirs = sourceConfig.readListEntry("Dirs", ':');
++  if (dirs.count()>0) c->_generalSourceDirs = dirs;
++  count = sourceConfig.readNumEntry("Count", 0);
++  c->_objectSourceDirs.clear();
++  if (count>17) c->_objectSourceDirs.resize(count);
++  for (i=1;i<=count;i++) {
++    TQString n = sourceConfig.readEntry(TQString("Object%1").arg(i));
++    dirs = sourceConfig.readListEntry(TQString("Dirs%1").arg(i), ':');
++
++    if (n.isEmpty() || (dirs.count()==0)) continue;
++
++    c->_objectSourceDirs.insert(n, new TQStringList(dirs));
++  }
++
++
++  // general options
++  KConfigGroup generalConfig(kconfig, TQCString("General"));
++  c->_showPercentage = generalConfig.readBoolEntry("ShowPercentage", true);
++  c->_showExpanded = generalConfig.readBoolEntry("ShowExpanded", false);
++  c->_showCycles = generalConfig.readBoolEntry("ShowCycles", true);
++  c->_cycleCut = generalConfig.readDoubleNumEntry("CycleCut", 0.0);
++  c->_maxSymbolCount = generalConfig.readNumEntry("MaxSymbolCount", 10);
++  c->_maxListCount = generalConfig.readNumEntry("MaxListCount", 100);
++  c->_maxSymbolLength = generalConfig.readNumEntry("MaxSymbolLength", 30);
++  c->_percentPrecision = generalConfig.readNumEntry("PercentPrecision", 2);
++
++  c->_context = generalConfig.readNumEntry("Context", 3);
++  c->_noCostInside   = generalConfig.readNumEntry("NoCostInside", 20);
++
++  // known cost types
++  if (TraceCostType::knownTypeCount()==0) {
++
++    KConfigGroup ctConfig(kconfig, TQCString("CostTypes"));
++    int ctCount = ctConfig.readNumEntry("Count", 0);
++    if (ctCount>0) {
++      for (int i=1;i<=ctCount;i++) {
++        TQString n = ctConfig.readEntry(TQString("Name%1").arg(i));
++        TQString l = ctConfig.readEntry(TQString("Longname%1").arg(i));
++	if (l.isEmpty()) l = knownLongName(n);
++        TQString f = ctConfig.readEntry(TQString("Formula%1").arg(i));
++	if (f.isEmpty()) f = knownFormula(n);
++
++        TraceCostType::add(new TraceCostType(n, l, f));
++      }
++    }
++    else {
++      // add default types
++
++      TQString longName, formula;
++      TraceCostType* ct;
++      TQStringList l = knownTypes();
++      for ( TQStringList::Iterator it = l.begin();
++            it != l.end(); ++it ) {
++        longName = knownLongName(*it);
++        formula  = knownFormula(*it);
++        ct = new TraceCostType(*it, longName, formula);
++        TraceCostType::add(ct);
++      }
++    }
++  }
++}
++
++TQColor Configuration::groupColor(TraceItem* cost)
++{
++   TQString n;
++
++  if (!cost)
++    n = TQString("default");
++  else
++    n = TraceCost::typeName(cost->type()) + "-" + cost->prettyName();
++
++  return color(n)->color;
++}
++
++TQColor Configuration::costTypeColor(TraceCostType* t)
++{
++   TQString n;
++
++   if (!t)
++     n = TQString("CostType-default");
++   else
++     n = TQString("CostType-%1").arg(t->name());
++
++   return color(n)->color;
++}
++
++TQColor Configuration::functionColor(TraceCost::CostType gt,
++                                    TraceFunction* f)
++{
++  TraceCost* group = f;
++  TQString n;
++
++  switch(gt) {
++  case TraceCost::Object: group = f->object(); break;
++  case TraceCost::Class:  group = f->cls(); break;
++  case TraceCost::File:   group = f->file(); break;
++  default:
++    break;
++  }
++
++  if (group != f) {
++    // first look for manual color of a function in a group
++    n = TraceCost::typeName(group->type()) +
++        "-" + group->prettyName() +
++        "-" + f->prettyName();
++
++    ColorSetting* cs = color(n, false);
++    if (cs) return cs->color;
++  }
++  return groupColor(group);
++}
++
++Configuration::ColorSetting* Configuration::color(TQString n, bool createNew)
++{
++//  qDebug("Color for %s", n.latin1());
++
++  // predefined ?
++  Configuration* c = config();
++  ColorSetting* cs = c->_colors[n];
++  if (cs || !createNew) return cs;
++
++  // automatic colors...
++  int h = 0, s = 100;
++  const char* str = n.ascii();
++  while (*str) {
++    h = (h * 37 + s* (unsigned)*str) % 256;
++    s = (s * 17 + h* (unsigned)*str) % 192;
++    str++;
++  }
++
++  //qDebug("New color for %s: H %d, S %d", n.ascii(), h, 64+s);
++  TQColor color = TQColor(h, 64+s, 192, TQColor::Hsv);
++
++  cs = new ColorSetting;
++  cs->name = n;
++  cs->automatic = true;
++  cs->color = color;
++  c->_colors.insert(n, cs);
++
++  //qDebug("new Color %s", n.ascii());
++
++  return cs;
++}
++
++/* Gives back a list of all Source Base Directories of Objects in
++ * current trace. If a special object is given in 2nd argument,
++ * put its Source Base in front.
++ */
++TQStringList Configuration::sourceDirs(TraceData* data, TraceObject* o)
++{
++  TQStringList l = config()->_generalSourceDirs, *ol, *ol2 = 0;
++  TraceObjectMap::Iterator oit;
++  for ( oit = data->objectMap().begin();
++        oit != data->objectMap().end(); ++oit ) {
++    ol = config()->_objectSourceDirs[(*oit).name()];
++    if (&(*oit) == o) {
++      ol2 = ol;
++      continue;
++    }
++    if (!ol) continue;
++
++    for(unsigned int i=0;i<ol->count();i++)
++      l.prepend( (*ol)[i] );
++  }
++  if (ol2) {
++    for(unsigned int i=0;i<ol2->count();i++)
++      l.prepend( (*ol2)[i] );
++  }
++  if (0) kdDebug() << "Configuration::sourceDirs: " << l.join(":") << endl;
++
++  return l;
++}
++
++bool Configuration::showPercentage()
++{
++  return config()->_showPercentage;
++}
++
++bool Configuration::showExpanded()
++{
++  return config()->_showExpanded;
++}
++
++bool Configuration::showCycles()
++{
++  return config()->_showCycles;
++}
++
++void Configuration::setShowPercentage(bool s)
++{
++  Configuration* c = config();
++  if (c->_showPercentage == s) return;
++
++  c->_showPercentage = s;
++}
++
++void Configuration::setShowExpanded(bool s)
++{
++  Configuration* c = config();
++  if (c->_showExpanded == s) return;
++
++  c->_showExpanded = s;
++}
++
++void Configuration::setShowCycles(bool s)
++{
++  Configuration* c = config();
++  if (c->_showCycles == s) return;
++
++  c->_showCycles = s;
++}
++
++double Configuration::cycleCut()
++{
++  return config()->_cycleCut;
++}
++
++int Configuration::percentPrecision()
++{
++  return config()->_percentPrecision;
++}
++
++int Configuration::maxSymbolLength()
++{
++  return config()->_maxSymbolLength;
++}
++
++TQString Configuration::shortenSymbol(TQString s)
++{
++    if ((int)s.length() > maxSymbolLength())
++	s = s.left(maxSymbolLength()) + "...";
++    return s;
++}
++
++int Configuration::maxListCount()
++{
++  return config()->_maxListCount;
++}
++
++int Configuration::maxSymbolCount()
++{
++  return config()->_maxSymbolCount;
++}
++
++int Configuration::context()
++{
++  return config()->_context;
++}
++
++int Configuration::noCostInside()
++{
++  return config()->_noCostInside;
++}
+diff --git a/kdecachegrind/kdecachegrind/configuration.h b/kdecachegrind/kdecachegrind/configuration.h
+new file mode 100644
+index 0000000..478f617
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/configuration.h
+@@ -0,0 +1,101 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Configuration for KCachegrind
++ */
++
++#ifndef CONFIGURATION_H
++#define CONFIGURATION_H
++
++#include <tqcolor.h>
++#include <tqstringlist.h>
++#include <tqdict.h>
++
++#include "tracedata.h"
++
++class KConfig;
++
++class Configuration
++{
++  friend class ConfigDlg;
++
++public:
++  Configuration();
++
++  static Configuration* config();
++
++  static void saveOptions(KConfig*);
++  static void readOptions(KConfig*);
++
++  // color for visualisation of an object
++  static TQColor functionColor(TraceItem::CostType gt, TraceFunction*);
++  static TQColor groupColor(TraceItem*);
++  static TQColor costTypeColor(TraceCostType*);
++  static TQStringList sourceDirs(TraceData*, TraceObject* o = 0);
++  static bool showPercentage();
++  static bool showExpanded();
++  static bool showCycles();
++
++  // lower percentage limit of cost items filled into lists
++  static int percentPrecision();
++  // max symbol lengths/count in tooltip/popup
++  static int maxSymbolLength();
++  // strip a symbol name according to <maxSymbolLength>
++  static TQString shortenSymbol(TQString);
++  static int maxSymbolCount();
++  // max. number of items in lists
++  static int maxListCount();
++  
++  // how many lines of context to show before/after annotated source/assembler
++  static int context();
++  // how many lines without cost are still regarded as inside a function
++  static int noCostInside();
++
++  static void setShowPercentage(bool);
++  static void setShowExpanded(bool);
++
++  static void setShowCycles(bool);
++  // upper limit for cutting of a call in cycle detection
++  static double cycleCut();
++
++private:
++  struct ColorSetting {
++    TQString name;
++    TQColor color;
++    bool automatic;
++  };
++
++  static ColorSetting* color(TQString, bool createNew = true);
++
++  TQDict<ColorSetting> _colors;
++
++  TQStringList _generalSourceDirs;
++  TQDict<TQStringList> _objectSourceDirs;
++
++  bool _showPercentage, _showExpanded, _showCycles;
++  double _cycleCut;
++  int _percentPrecision;
++  int _maxSymbolLength, _maxSymbolCount, _maxListCount;
++  int _context, _noCostInside;
++
++  static Configuration* _config;
++};
++
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/costlistitem.cpp b/kdecachegrind/kdecachegrind/costlistitem.cpp
+new file mode 100644
+index 0000000..1e777b0
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/costlistitem.cpp
+@@ -0,0 +1,136 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++#include <math.h>
++
++#include <tqpainter.h>
++#include <tqregexp.h>
++
++#include <klocale.h>
++#include <kiconloader.h>
++#include <kapplication.h>
++
++#include "listutils.h"
++#include "costlistitem.h"
++#include "coverage.h"
++#include "configuration.h"
++
++// CostListItem
++
++
++CostListItem::CostListItem(TQListView* parent, TraceCostItem* costItem,
++                           TraceCostType* ct, int size)
++  :TQListViewItem(parent)
++{
++  _groupSize = size;
++  _skipped = 0;
++  _costItem = costItem;
++  setCostType(ct);
++
++  if (costItem) {
++    updateName();
++    setPixmap(1, colorPixmap(10, 10,
++			     Configuration::groupColor(_costItem)));
++  }
++}
++
++CostListItem::CostListItem(TQListView* parent, int skipped,
++			   TraceCostItem* costItem, TraceCostType* ct)
++  :TQListViewItem(parent)
++{
++  _skipped = skipped;
++  _costItem = costItem;
++  setCostType(ct);
++
++  setText(1, i18n("(%n item skipped)", "(%n items skipped)", _skipped));
++}
++
++void CostListItem::setCostType(TraceCostType* ct)
++{
++  _costType = ct;
++  update();
++}
++
++void CostListItem::updateName()
++{
++  if (!_costItem) return;
++
++  TQString n = _costItem->prettyName();
++  if (_groupSize>=0) n += TQString(" (%1)").arg(_groupSize);
++
++  setText(1, n);
++}
++
++void CostListItem::setSize(int s)
++{
++  _groupSize = s;
++  updateName();
++}
++
++void CostListItem::update()
++{
++  if (!_costItem) return;
++  TraceData* d = _costItem->data();
++
++  double total = d->subCost(_costType);
++  if (total == 0.0) {
++    setText(0, TQString("---"));
++    setPixmap(0, TQPixmap());
++    return;
++  }
++
++  _pure = _costItem->subCost(_costType);
++  double pure  = 100.0 * _pure / total;
++  TQString str;
++  if (Configuration::showPercentage())
++    str = TQString("%1").arg(pure, 0, 'f', Configuration::percentPrecision());
++  else
++    str = _costItem->prettySubCost(_costType);
++
++  if (_skipped) {
++    // special handling for skip entries...
++    setText(0, TQString("< %1").arg(str));
++    return;
++  }
++
++  setText(0, str);
++  setPixmap(0, costPixmap(_costType, _costItem, total, false));
++}
++
++int CostListItem::compare(TQListViewItem * i, int col, bool ascending ) const
++{
++  const CostListItem* fi1 = this;
++  const CostListItem* fi2 = (CostListItem*) i;
++
++  // we always want descending order
++  if (ascending) {
++    fi1 = fi2;
++    fi2 = this;
++  }
++
++  // a skip entry is always sorted last
++  if (fi1->_skipped) return -1;
++  if (fi2->_skipped) return 1;
++
++  if (col==0) {
++    if (fi1->_pure < fi2->_pure) return -1;
++    if (fi1->_pure > fi2->_pure) return 1;
++    return 0;
++  }
++  return TQListViewItem::compare(i, col, ascending);
++}
+diff --git a/kdecachegrind/kdecachegrind/costlistitem.h b/kdecachegrind/kdecachegrind/costlistitem.h
+new file mode 100644
+index 0000000..99f654e
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/costlistitem.h
+@@ -0,0 +1,52 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++#ifndef COSTLISTITEM_H
++#define COSTLISTITEM_H
++
++#include <tqlistview.h>
++#include "tracedata.h"
++
++class CostListItem: public TQListViewItem
++{
++public:
++  CostListItem(TQListView* parent, TraceCostItem* cost,
++               TraceCostType* ct, int size = -1);
++  // entry with multiple skipped items
++  CostListItem(TQListView* parent, int skipped, TraceCostItem* cost,
++               TraceCostType* ct);
++
++  int compare(TQListViewItem * i, int col, bool ascending ) const;
++  TraceCostItem* costItem() { return (_skipped) ? 0 : _costItem; }
++  void setCostType(TraceCostType* ct);
++  void update();
++  void setSize(int s);
++
++private:
++  void updateName();
++
++  SubCost _pure;
++  TraceCostType* _costType;
++  TraceCostItem* _costItem;
++  // >0 only for last item in list, if items are skipped 
++  int _skipped;
++  // number of items in group, is put in parenthesis after name
++  int _groupSize;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/costtypeitem.cpp b/kdecachegrind/kdecachegrind/costtypeitem.cpp
+new file mode 100644
+index 0000000..dc35cb2
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/costtypeitem.cpp
+@@ -0,0 +1,149 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Items of cost type view.
++ */
++
++#include <tqpixmap.h>
++#include <klocale.h>
++
++#include "configuration.h"
++#include "listutils.h"
++#include "costtypeitem.h"
++
++
++// CostTypeItem
++
++
++CostTypeItem::CostTypeItem(TQListView* parent, TraceCostItem* costItem,
++                           TraceCostType* ct, TraceCost::CostType gt)
++  :TQListViewItem(parent)
++{
++  _costItem = costItem;
++  _costType = ct;
++  _groupType = gt;
++
++  if (ct) {
++      setText(0, ct->longName());
++      setText(3, ct->name());
++      TQString formula = ct->formula();
++      setText(5, formula);
++      if (!formula.isEmpty()) {
++	  setText(4, "=");
++	  // we have a virtual type: allow editing
++	  setRenameEnabled(0, true);
++	  setRenameEnabled(3, true);
++	  setRenameEnabled(5, true);
++      } 
++  }
++  else {
++      setText(0, i18n("Unknown Type"));
++  }
++  update();
++}
++
++void CostTypeItem::setGroupType(TraceCost::CostType gt)
++{
++    if (_groupType == gt) return;
++
++    _groupType = gt;
++    update();
++}
++
++void CostTypeItem::update()
++{
++  TraceData* d = _costItem ? _costItem->data() : 0;
++  double total = d ? ((double)d->subCost(_costType)) : 0.0;
++
++  if (total == 0.0) {
++    setText(1, "-");
++    setPixmap(1, TQPixmap());
++    setText(2, "-");
++    setPixmap(2, TQPixmap());
++    return;
++  }
++
++  TraceFunction* f = (_costItem->type()==TraceCost::Function) ?
++                     (TraceFunction*)_costItem : 0;
++
++  TraceCost* selfTotalCost = f ? f->data() : d;
++  if (f && Configuration::showExpanded()) {
++      switch(_groupType) {
++      case TraceCost::Object: selfTotalCost = f->object(); break;
++      case TraceCost::Class:  selfTotalCost = f->cls(); break;
++      case TraceCost::File:   selfTotalCost = f->file(); break;
++      case TraceCost::FunctionCycle: selfTotalCost = f->cycle(); break;
++      default: break;
++      }
++  }
++  if (_costItem->type()==TraceCost::FunctionCycle) {
++      f = (TraceFunction*)_costItem;
++      selfTotalCost = f->data();
++  }
++
++  double selfTotal = selfTotalCost->subCost(_costType);
++
++  // for all cost items there's a self cost
++  _pure = _costItem ? _costItem->subCost(_costType) : SubCost(0);
++  double pure  = 100.0 * _pure / selfTotal;
++  if (Configuration::showPercentage()) {
++    setText(2, TQString("%1")
++            .arg(pure, 0, 'f', Configuration::percentPrecision()));
++  }
++  else
++    setText(2, _costItem->prettySubCost(_costType));
++
++  setPixmap(2, costPixmap(_costType, _costItem, selfTotal, false));
++
++  if (!f) {
++    setText(1, "-");
++    setPixmap(1, TQPixmap());
++    return;
++  }
++
++  _sum = f->inclusive()->subCost(_costType);
++  double sum  = 100.0 * _sum / total;
++  if (Configuration::showPercentage()) {
++    setText(1, TQString("%1")
++            .arg(sum, 0, 'f', Configuration::percentPrecision()));
++  }
++  else
++    setText(1, _sum.pretty());
++
++  setPixmap(1, costPixmap(_costType, f->inclusive(), total, false));
++}
++
++
++int CostTypeItem::compare(TQListViewItem * i, int col, bool ascending ) const
++{
++  CostTypeItem* fi = (CostTypeItem*) i;
++  if (col==0) {
++    if (_sum < fi->_sum) return -1;
++    if (_sum > fi->_sum) return 1;
++    return 0;
++  }
++  if (col==1) {
++    if (_pure < fi->_pure) return -1;
++    if (_pure > fi->_pure) return 1;
++    return 0;
++  }
++  return TQListViewItem::compare(i, col, ascending);
++}
++
++
+diff --git a/kdecachegrind/kdecachegrind/costtypeitem.h b/kdecachegrind/kdecachegrind/costtypeitem.h
+new file mode 100644
+index 0000000..d34973d
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/costtypeitem.h
+@@ -0,0 +1,50 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Items of cost type view.
++ */
++
++#ifndef COSTTYEPITEM_H
++#define COSTTYEPITEM_H
++
++#include <tqlistview.h>
++#include "tracedata.h"
++
++
++class CostTypeItem: public TQListViewItem
++{
++public:
++  CostTypeItem(TQListView* parent, TraceCostItem* costItem,
++               TraceCostType* ct, TraceCost::CostType gt);
++
++  int compare(TQListViewItem * i, int col, bool ascending ) const;
++  void setGroupType(TraceCost::CostType);
++  TraceCostItem* costItem() { return _costItem; }
++  TraceCostType* costType() { return _costType; }
++  void update();
++
++private:
++  SubCost _sum, _pure;
++  TraceCostType* _costType;
++  TraceCostItem* _costItem;
++  TraceCost::CostType _groupType;
++};
++
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/costtypeview.cpp b/kdecachegrind/kdecachegrind/costtypeview.cpp
+new file mode 100644
+index 0000000..3f5417e
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/costtypeview.cpp
+@@ -0,0 +1,310 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Cost Type View
++ */
++
++#include <tqwhatsthis.h>
++#include <tqpopupmenu.h>
++#include <klocale.h>
++
++#include "configuration.h"
++#include "costtypeitem.h"
++#include "costtypeview.h"
++#include "toplevel.h"
++
++
++//
++// CostTypeView
++//
++
++
++CostTypeView::CostTypeView(TraceItemView* parentView,
++			   TQWidget* parent, const char* name)
++  : TQListView(parent, name), TraceItemView(parentView)
++{
++    addColumn( i18n( "Event Type" ) );
++    addColumn( i18n( "Incl." ) );
++    addColumn( i18n( "Self" ) );
++    addColumn( i18n( "Short" ) );
++    addColumn( TQString() );
++    addColumn( i18n( "Formula" ) );
++
++    setSorting(-1);
++    setAllColumnsShowFocus(true);
++    setColumnAlignment(1, TQt::AlignRight);
++    setColumnAlignment(2, TQt::AlignRight);
++    setColumnAlignment(3, TQt::AlignRight);
++    setMinimumHeight(50);
++
++    connect( this,
++	     TQT_SIGNAL( selectionChanged(TQListViewItem*) ),
++	     TQT_SLOT( selectedSlot(TQListViewItem*) ) );
++
++    connect( this,
++	     TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint &, int)),
++	     TQT_SLOT(context(TQListViewItem*, const TQPoint &, int)));
++
++    connect(this,
++	    TQT_SIGNAL(doubleClicked(TQListViewItem*)),
++	    TQT_SLOT(activatedSlot(TQListViewItem*)));
++
++    connect(this,
++	    TQT_SIGNAL(returnPressed(TQListViewItem*)),
++	    TQT_SLOT(activatedSlot(TQListViewItem*)));
++
++    connect(this,
++	    TQT_SIGNAL(itemRenamed(TQListViewItem*,int,const TQString&)),
++	    TQT_SLOT(renamedSlot(TQListViewItem*,int,const TQString&)));
++
++    TQWhatsThis::add( this, whatsThis() );
++}
++
++TQString CostTypeView::whatsThis() const
++{
++    return i18n( "<b>Cost Types List</b>"
++		 "<p>This list shows all cost types available "
++		 "and what the self/inclusive cost of the "
++		 "current selected function is for that cost type.</p>"
++		 "<p>By choosing a cost type from the list, "
++		 "you change the cost type of costs shown "
++		 "all over KCachegrind to be the selected one.</p>");
++}
++
++
++void CostTypeView::context(TQListViewItem* i, const TQPoint & p, int)
++{
++  TQPopupMenu popup;
++
++  TraceCostType* ct = i ? ((CostTypeItem*) i)->costType() : 0;
++
++  if (ct)
++    popup.insertItem(i18n("Set Secondary Event Type"), 99);
++  if (_costType2)
++    popup.insertItem(i18n("Remove Secondary Event Type"), 98);
++  if (popup.count()>0)
++    popup.insertSeparator();
++
++  if (ct && !ct->isReal()) {
++      popup.insertItem(i18n("Edit Long Name"), 93);
++      popup.insertItem(i18n("Edit Short Name"), 94);
++      popup.insertItem(i18n("Edit Formula"), 95);
++      popup.insertItem(i18n("Remove"), 96);
++      popup.insertSeparator();
++  }
++
++  addGoMenu(&popup);
++
++  popup.insertSeparator();
++  popup.insertItem(i18n("New Cost Type ..."), 97);
++
++  int r = popup.exec(p);
++  if (r == 98) selectedCostType2(0);
++  else if (r == 99) selectedCostType2(ct);
++  else if (r == 93) i->startRename(0);
++  else if (r == 94) i->startRename(3);
++  else if (r == 95) i->startRename(5);
++  else if (r == 96) {
++
++    // search for a previous type 
++    TraceCostType* prev = 0, *ct = 0;
++    TraceCostMapping* m = _data->mapping();
++    for (int i=0;i<m->realCount();i++) {
++	ct = m->realType(i);
++	if (ct) prev = ct;
++    }
++    for (int i=0;i<m->virtualCount();i++) {
++	ct = m->virtualType(i);
++	if (ct == _costType) break;
++	if (ct) prev = ct;
++    }
++
++    if (_data->mapping()->remove(ct)) {
++      // select previous cost type
++      selectedCostType(prev);
++      if (_costType2 == ct)
++	selectedCostType2(prev);
++      refresh();
++    }
++  }
++  else if (r == 97) {
++    int i = 1;
++    while(1) {
++      if (!TraceCostType::knownVirtualType(i18n("New%1").arg(i)))
++	break;
++      i++;
++    }
++    // add same new cost type to this mapping and to known types
++    TQString shortName = i18n("New%1").arg(i);
++    TQString longName  = i18n("New Cost Type %1").arg(i);
++    TraceCostType::add(new TraceCostType(shortName, longName, "0"));
++    _data->mapping()->add(new TraceCostType(shortName, longName, "0"));
++    refresh();
++  }
++}
++
++void CostTypeView::selectedSlot(TQListViewItem * i)
++{
++    TraceCostType* ct = i ? ((CostTypeItem*) i)->costType() : 0;
++    if (ct)
++	selectedCostType(ct);
++}
++
++void CostTypeView::activatedSlot(TQListViewItem * i)
++{
++  TraceCostType* ct = i ? ((CostTypeItem*) i)->costType() : 0;
++  if (ct)
++      selectedCostType2(ct);
++}
++
++TraceItem* CostTypeView::canShow(TraceItem* i)
++{
++    if (!i) return 0;
++
++    switch(i->type()) {
++    case TraceCost::Object:
++    case TraceCost::Class:
++    case TraceCost::File:
++    case TraceCost::Call:
++    case TraceCost::FunctionCycle:
++    case TraceCost::Function:
++	break;
++    default:
++	return 0;
++    }
++    return i;
++}
++
++void CostTypeView::doUpdate(int changeType)
++{
++    // Special case ?
++    if (changeType == selectedItemChanged) return;
++
++    if (changeType == costType2Changed) return;
++
++    if (changeType == groupTypeChanged) {
++	TQListViewItem *item;
++	for (item = firstChild();item;item = item->nextSibling())
++	    ((CostTypeItem*)item)->setGroupType(_groupType);
++
++	return;
++    }
++
++    if (changeType == costTypeChanged) {
++	TQListViewItem *item;
++	for (item = firstChild();item;item = item->nextSibling())
++	    if ( ((CostTypeItem*)item)->costType() == _costType) {
++		setSelected(item, true);
++		ensureItemVisible(item);
++		break;
++	    }
++
++	return;
++    }
++
++    if (changeType == partsChanged) {
++	TQListViewItem *item;
++	for (item = firstChild();item;item = item->nextSibling())
++	    ((CostTypeItem*)item)->update();
++
++	return;
++    }
++
++
++    refresh();
++}
++
++void CostTypeView::refresh()
++{
++    clear();
++    setColumnWidth(1, 50);
++    setColumnWidth(2, 50);
++
++    if (!_data || !_activeItem) return;
++    switch(_activeItem->type()) {
++    case TraceCost::Object:
++    case TraceCost::Class:
++    case TraceCost::File:
++    case TraceCost::FunctionCycle:
++    case TraceCost::Function:
++	break;
++    default:
++	return;
++    }
++    TraceCostItem* c = (TraceCostItem*) _activeItem;
++
++    TraceCostType* ct =0 ;
++    TQListViewItem* item = 0;
++    TQString sumStr, pureStr;
++    TQListViewItem* costItem=0;
++
++    TraceCostMapping* m = _data->mapping();
++    for (int i=m->virtualCount()-1;i>=0;i--) {
++	ct = m->virtualType(i);
++	if (!ct) continue;
++	item = new CostTypeItem(this, c, ct, _groupType);
++	if (ct == _costType) costItem = item;
++    }
++    for (int i=m->realCount()-1;i>=0;i--) {
++	ct = m->realType(i);
++	item = new CostTypeItem(this, c, ct, _groupType);
++	if (ct == _costType) costItem = item;
++    }
++
++    if (costItem) {
++	setSelected(costItem, true);
++	ensureItemVisible(costItem);
++    }
++
++    if (item) setMinimumHeight(3*item->height());
++}
++
++
++void CostTypeView::renamedSlot(TQListViewItem* item,int c,const TQString& t)
++{
++  TraceCostType* ct = item ? ((CostTypeItem*) item)->costType() : 0;
++  if (!ct || ct->isReal()) return;
++
++  // search for matching known Type
++  int knownCount = TraceCostType::knownTypeCount();
++  TraceCostType* known = 0;
++  for (int i=0; i<knownCount; i++) {
++      known = TraceCostType::knownType(i);
++      if (known->name() == ct->name()) break;
++  }
++
++  if (c == 0) {
++      ct->setLongName(t);
++      if (known) known->setLongName(t);
++  }
++  else if (c == 3) {
++      ct->setName(t);
++      if (known) known->setName(t);
++  }
++  else if (c == 5) {
++      ct->setFormula(t);
++      if (known) known->setFormula(t);
++  }
++  else return;
++
++  if (_topLevel) _topLevel->configChanged();
++  refresh();
++}
++
++#include "costtypeview.moc"
+diff --git a/kdecachegrind/kdecachegrind/costtypeview.h b/kdecachegrind/kdecachegrind/costtypeview.h
+new file mode 100644
+index 0000000..ee9963e
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/costtypeview.h
+@@ -0,0 +1,54 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Cost Type View
++ */
++
++#ifndef COSTTYPEVIEW_H
++#define COSTTYPEVIEW_H
++
++#include <tqlistview.h>
++#include "tracedata.h"
++#include "traceitemview.h"
++
++class CostTypeView: public TQListView, public TraceItemView
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  CostTypeView(TraceItemView* parentView,
++	       TQWidget* parent=0, const char* name=0);
++
++  virtual TQWidget* widget() { return this; }
++  TQString whatsThis() const;
++
++private slots:
++  void context(TQListViewItem*,const TQPoint &, int);
++  void selectedSlot(TQListViewItem*);
++  void activatedSlot(TQListViewItem*);
++  void renamedSlot(TQListViewItem*,int,const TQString&);
++
++private:
++  TraceItem* canShow(TraceItem*);
++  void doUpdate(int);
++  void refresh();
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/coverage.cpp b/kdecachegrind/kdecachegrind/coverage.cpp
+new file mode 100644
+index 0000000..86e6f7f
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/coverage.cpp
+@@ -0,0 +1,329 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Function Coverage Analysis
++ */
++
++#include "coverage.h"
++
++//#define DEBUG_COVERAGE 1
++
++TraceCostType* Coverage::_costType;
++
++const int Coverage::maxHistogramDepth = maxHistogramDepthValue;
++const int Coverage::Rtti = 1;
++
++Coverage::Coverage()
++{
++}
++
++void Coverage::init()
++{
++  _self = 0.0;
++  _incl  = 0.0;
++  _callCount = 0.0;
++  // should always be overwritten before usage
++  _firstPercentage = 1.0;
++  _minDistance = 9999;
++  _maxDistance = 0;
++  _active = false;
++  _inRecursion = false;
++  for (int i = 0;i<maxHistogramDepth;i++) {
++    _selfHisto[i] = 0.0;
++    _inclHisto[i] = 0.0;
++  }
++
++  _valid = true;
++}
++
++int Coverage::inclusiveMedian()
++{
++  double maxP = _inclHisto[0];
++  int medD = 0;
++  for (int i = 1;i<maxHistogramDepth;i++)
++    if (_inclHisto[i]>maxP) {
++      maxP = _inclHisto[i];
++      medD = i;
++    }
++
++  return medD;
++}
++
++int Coverage::selfMedian()
++{
++  double maxP = _selfHisto[0];
++  int medD = 0;
++  for (int i = 1;i<maxHistogramDepth;i++)
++    if (_selfHisto[i]>maxP) {
++      maxP = _selfHisto[i];
++      medD = i;
++    }
++
++  return medD;
++}
++
++TraceFunctionList Coverage::coverage(TraceFunction* f, CoverageMode m,
++                                      TraceCostType* ct)
++{
++  invalidate(f->data(), Coverage::Rtti);
++
++  _costType = ct;
++
++  // function f takes ownership over c!
++  Coverage* c = new Coverage();
++  c->setFunction(f);
++  c->init();
++
++  TraceFunctionList l;
++
++  if (m == Caller)
++    c->addCallerCoverage(l, 1.0, 0);
++  else
++    c->addCallingCoverage(l, 1.0, 1.0, 0);
++
++  return l;
++}
++
++void Coverage::addCallerCoverage(TraceFunctionList& fList,
++                                 double pBack, int d)
++{
++  TraceCallList cList;
++  TraceCall* call;
++  Coverage* c;
++
++  if (_inRecursion) return;
++
++  double incl;
++  incl  = (double) (_function->inclusive()->subCost(_costType));
++
++  if (_active) {
++#ifdef DEBUG_COVERAGE
++    qDebug("CallerCov: D %d, %s (was active, incl %f, self %f): newP %f", d,
++           _function->prettyName().ascii(), _incl, _self, pBack);
++#endif
++    _inRecursion = true;
++  }
++  else {
++    _active = true;
++
++    // only add cost if this is no recursion
++
++    _incl += pBack;
++    _firstPercentage = pBack;
++
++    if (_minDistance > d) _minDistance = d;
++    if (_maxDistance < d) _maxDistance = d;
++    if (d<maxHistogramDepth) {
++      _inclHisto[d] += pBack;
++    }
++    else {
++      _inclHisto[maxHistogramDepth-1] += pBack;
++    }
++
++#ifdef DEBUG_COVERAGE
++    qDebug("CallerCov: D %d, %s (now active, new incl %f): newP %f",
++           d, _function->prettyName().ascii(), _incl, pBack);
++#endif
++  }
++
++  double callVal, pBackNew;
++
++  cList = _function->callers();
++  for (call=cList.first();call;call=cList.next()) {
++    if (call->inCycle()>0) continue;
++    if (call->isRecursion()) continue;
++
++    if (call->subCost(_costType)>0) {
++      TraceFunction* caller = call->caller();
++
++      c = (Coverage*) caller->assoziation(rtti());
++      if (!c) {
++        c = new Coverage();
++        c->setFunction(caller);
++      }
++      if (!c->isValid()) {
++        c->init();
++        fList.append(caller);
++      }
++
++      if (c->isActive()) continue;
++      if (c->inRecursion()) continue;
++
++      callVal = (double) call->subCost(_costType);
++      pBackNew = pBack * (callVal / incl);
++
++      // FIXME ?!?
++
++      if (!c->isActive()) {
++	  if (d>=0)
++	      c->callCount() += (double)call->callCount();
++	  else
++	      c->callCount() += _callCount;
++      }
++      else {
++        // adjust pNew by sum of geometric series of recursion factor.
++        // Thus we can avoid endless recursion here
++        pBackNew *= 1.0 / (1.0 - pBackNew / c->firstPercentage());
++      }
++
++      // Limit depth
++      if (pBackNew > 0.0001)
++        c->addCallerCoverage(fList, pBackNew, d+1);
++    }
++  }
++
++  if (_inRecursion)
++    _inRecursion = false;
++  else if (_active)
++    _active = false;
++}
++
++/**
++ * pForward is time on percent used,
++ * pBack is given to allow for calculation of call counts
++ */
++void Coverage::addCallingCoverage(TraceFunctionList& fList,
++                                  double pForward, double pBack, int d)
++{
++  TraceCallList cList;
++  TraceCall* call;
++  Coverage* c;
++
++  if (_inRecursion) return;
++
++#ifdef DEBUG_COVERAGE
++  static const char* spaces = "                                            ";
++#endif
++
++  double self, incl;
++  incl  = (double) (_function->inclusive()->subCost(_costType));
++
++#ifdef DEBUG_COVERAGE
++    qDebug("CngCov:%s - %s (incl %f, self %f): forward %f, back %f",
++	   spaces+strlen(spaces)-d,
++           _function->prettyName().ascii(), _incl, _self, pForward, pBack);
++#endif
++
++
++  if (_active) {
++    _inRecursion = true;
++
++#ifdef DEBUG_COVERAGE
++    qDebug("CngCov:%s < %s: STOP (is active)",
++	   spaces+strlen(spaces)-d,
++           _function->prettyName().ascii());
++#endif
++
++  }
++  else {
++    _active = true;
++
++    // only add cost if this is no recursion
++    self = pForward * (_function->subCost(_costType)) / incl;
++    _incl += pForward;
++    _self += self;
++    _firstPercentage = pForward;
++
++    if (_minDistance > d) _minDistance = d;
++    if (_maxDistance < d) _maxDistance = d;
++     if (d<maxHistogramDepth) {
++      _inclHisto[d] += pForward;
++      _selfHisto[d] += self;
++    }
++    else {
++      _inclHisto[maxHistogramDepth-1] += pForward;
++      _selfHisto[maxHistogramDepth-1] += self;
++    }
++
++#ifdef DEBUG_COVERAGE
++    qDebug("CngCov:%s < %s (incl %f, self %f)",
++	   spaces+strlen(spaces)-d,
++           _function->prettyName().ascii(), _incl, _self);
++#endif
++  }
++
++  double callVal, pForwardNew, pBackNew;
++
++  cList = _function->callings();
++  for (call=cList.first();call;call=cList.next()) {
++    if (call->inCycle()>0) continue;
++    if (call->isRecursion()) continue;
++
++    if (call->subCost(_costType)>0) {
++      TraceFunction* calling = call->called();
++
++      c = (Coverage*) calling->assoziation(rtti());
++      if (!c) {
++        c = new Coverage();
++        c->setFunction(calling);
++      }
++      if (!c->isValid()) {
++        c->init();
++        fList.append(calling);
++      }
++
++      if (c->isActive()) continue;
++      if (c->inRecursion()) continue;
++
++      callVal = (double) call->subCost(_costType);
++      pForwardNew = pForward * (callVal / incl);
++      pBackNew    = pBack * (callVal / 
++			     calling->inclusive()->subCost(_costType));
++
++      if (!c->isActive()) {
++	  c->callCount() += pBack * call->callCount();
++
++#ifdef DEBUG_COVERAGE
++        qDebug("CngCov:%s  > %s: forward %f, back %f, calls %f -> %f, now %f",
++	       spaces+strlen(spaces)-d,
++               calling->prettyName().ascii(),
++	       pForwardNew, pBackNew,
++	       (double)call->callCount(),
++	       pBack * call->callCount(),
++	       c->callCount());
++#endif
++      }
++      else {
++        // adjust pNew by sum of geometric series of recursion factor.
++        // Thus we can avoid endless recursion here
++        double fFactor = 1.0 / (1.0 - pForwardNew / c->firstPercentage());
++        double bFactor = 1.0 / (1.0 - pBackNew);
++#ifdef DEBUG_COVERAGE
++        qDebug("CngCov:%s Recursion - origP %f, actP %f => factor %f, newP %f",
++	       spaces+strlen(spaces)-d,
++               c->firstPercentage(), pForwardNew,
++	       fFactor, pForwardNew * fFactor);
++#endif
++        pForwardNew *= fFactor;
++        pBackNew *= bFactor;
++
++      }
++
++      // Limit depth
++      if (pForwardNew > 0.0001)
++        c->addCallingCoverage(fList, pForwardNew, pBackNew, d+1);
++    }
++  }
++
++  if (_inRecursion)
++    _inRecursion = false;
++  else if (_active)
++    _active = false;
++}
++
+diff --git a/kdecachegrind/kdecachegrind/coverage.h b/kdecachegrind/kdecachegrind/coverage.h
+new file mode 100644
+index 0000000..50c5936
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/coverage.h
+@@ -0,0 +1,102 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Function Coverage Analysis
++ */
++
++#ifndef COVERAGE_H
++#define COVERAGE_H
++
++#include "tracedata.h"
++
++/**
++ * Coverage of a function.
++ * When analysis is done, every function involved will have a
++ * pointer to an object of this class.
++ *
++ * This function also holds the main routine for coverage analysis,
++ * Coverage::coverage(), as static method.
++ */
++class Coverage : public TraceAssoziation
++{
++public:
++  /* Direction of coverage analysis */
++  enum CoverageMode { Caller, Called };
++
++  // max depth for distance histogram
++#define maxHistogramDepthValue 40
++  static const int maxHistogramDepth;
++
++  static const int Rtti;
++
++  Coverage();
++
++  virtual int rtti() { return Rtti; }
++  void init();
++
++  TraceFunction* function() { return _function; }
++  double self() { return _self; }
++  double inclusive() { return _incl; }
++  double firstPercentage() { return _firstPercentage; }
++  double& callCount() { return _callCount; }
++  int minDistance() { return _minDistance; }
++  int maxDistance() { return _maxDistance; }
++  int inclusiveMedian();
++  int selfMedian();
++  double* selfHistogram() { return _selfHisto; }
++  double* inclusiveHistogram() { return _inclHisto; }
++  bool isActive() { return _active; }
++  bool inRecursion() { return _inRecursion; }
++
++  void setSelf(float p) { _self = p; }
++  void setInclusive(float p) { _incl = p; }
++  void setCallCount(float cc) { _callCount = cc; }
++  void setActive(bool a) { _active = a; }
++  void setInRecursion(bool r) { _inRecursion = r; }
++
++  /**
++   * Calculate coverage of all functions based on function f.
++   * If mode is Called, the coverage of functions called by
++   * f is calculated, otherwise that of functions calling f.
++   * SubCost type ct is used for the analysis.
++   * Self values are undefined for Caller mode.
++   *
++   * Returns list of functions covered.
++   * Coverage degree of returned functions can be get
++   * with function->coverage()->percentage()
++   */
++  static TraceFunctionList coverage(TraceFunction* f, CoverageMode m,
++                                    TraceCostType* ct);
++
++private:
++  void addCallerCoverage(TraceFunctionList& l, double, int d);
++  void addCallingCoverage(TraceFunctionList& l, double, double, int d);
++
++  double _self, _incl, _firstPercentage, _callCount;
++  int _minDistance, _maxDistance;
++  bool _active, _inRecursion;
++  double _selfHisto[maxHistogramDepthValue];
++  double _inclHisto[maxHistogramDepthValue];
++
++  // temporary set for one coverage analysis
++  static TraceCostType* _costType;
++};
++
++#endif
++
+diff --git a/kdecachegrind/kdecachegrind/coverageitem.cpp b/kdecachegrind/kdecachegrind/coverageitem.cpp
+new file mode 100644
+index 0000000..26e5b36
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/coverageitem.cpp
+@@ -0,0 +1,343 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Items of coverage view.
++ */
++
++#include <tqpixmap.h>
++#include <klocale.h>
++
++#include "configuration.h"
++#include "listutils.h"
++#include "coverage.h"
++#include "coverageitem.h"
++
++
++// CallerCoverageItem
++
++
++CallerCoverageItem::CallerCoverageItem(TQListView* parent, Coverage* c,
++                                       TraceFunction* base,
++                                       TraceCostType* ct,
++                                       TraceCost::CostType gt)
++    : TQListViewItem(parent)
++{
++  _skipped = 0;
++  _coverage = c;
++  _function = c ? c->function() : 0;
++  _base = base;
++  _groupType = TraceCost::NoCostType;
++
++  setText(3, _function->prettyNameWithLocation());
++
++  setCostType(ct);
++  setGroupType(gt);
++}
++
++CallerCoverageItem::CallerCoverageItem(TQListView* parent, int skipped, Coverage* c,
++                                       TraceFunction* base,
++                                       TraceCostType* ct,
++                                       TraceCost::CostType gt)
++    : TQListViewItem(parent)
++{
++  _skipped = skipped;
++  _coverage = c;
++  _function = c ? c->function() : 0;
++  _base = base;
++  _groupType = TraceCost::NoCostType;
++
++  setText(3, i18n("(%n function skipped)", "(%n functions skipped)", _skipped));
++
++  setCostType(ct);
++  setGroupType(gt);
++}
++
++void CallerCoverageItem::setGroupType(TraceCost::CostType gt)
++{
++  if (_skipped) return;
++  if (_groupType == gt) return;
++  _groupType = gt;
++
++  TQColor c = Configuration::functionColor(_groupType, _function);
++  setPixmap(3, colorPixmap(10, 10, c));
++}
++
++void CallerCoverageItem::setCostType(TraceCostType* ct)
++{
++  _costType = ct;
++  update();
++}
++
++void CallerCoverageItem::update()
++{
++  if (!_coverage) {
++    setText(0, TQString());
++    setText(1, TQString());
++    return;
++  }
++
++  _pSum = 100.0 * _coverage->inclusive();
++  SubCost realSum = _base->inclusive()->subCost(_costType);
++  _sum = SubCost(realSum * _coverage->inclusive());
++  TQString str;
++  if (Configuration::showPercentage())
++    str = TQString("%1").arg(_pSum, 0, 'f', Configuration::percentPrecision());
++  else
++    str = _sum.pretty();
++
++  if (_skipped) {
++    setText(0, TQString("< %1").arg(str));
++    return;
++  }
++
++  setText(0, str);
++  setPixmap(0, partitionPixmap(25, 10, _coverage->inclusiveHistogram(), 0,
++                               Coverage::maxHistogramDepth, false));
++
++  // call count
++  _cc  = SubCost(_coverage->callCount());
++  setText(2, _cc ? _cc.pretty() : TQString("(0)"));
++
++  // distance (min/max/median)
++  _distance = _coverage->inclusiveMedian();
++  TQString distString;
++  if (_coverage->minDistance() == _coverage->maxDistance())
++    distString = TQString::number(_distance);
++  else
++    distString = TQString("%1-%2 (%3)")
++                 .arg(_coverage->minDistance())
++                 .arg(_coverage->maxDistance())
++                 .arg(_distance);
++  setText(1, distString);
++}
++
++
++int CallerCoverageItem::compare(TQListViewItem * i,
++                                int col, bool ascending ) const
++{
++  const CallerCoverageItem* ci1 = this;
++  const CallerCoverageItem* ci2 = (CallerCoverageItem*) i;
++
++  // we always want descending order
++  if (ascending) {
++    ci1 = ci2;
++    ci2 = this;
++  }
++
++  // a skip entry is always sorted last
++  if (ci1->_skipped) return -1;
++  if (ci2->_skipped) return 1;
++
++  if (col==0) {
++    if (ci1->_pSum < ci2->_pSum) return -1;
++    if (ci1->_pSum > ci2->_pSum) return 1;
++
++    // for same percentage (e.g. all 100%), use distance info
++    if (ci1->_distance < ci2->_distance) return -1;
++    if (ci1->_distance > ci2->_distance) return 1;
++    return 0;
++  }
++
++  if (col==1) {
++    if (ci1->_distance < ci2->_distance) return -1;
++    if (ci1->_distance > ci2->_distance) return 1;
++    return 0;
++  }
++
++  if (col==2) {
++    if (ci1->_cc < ci2->_cc) return -1;
++    if (ci1->_cc > ci2->_cc) return 1;
++    return 0;
++  }
++  return TQListViewItem::compare(i, col, ascending);
++}
++
++
++// CalleeCoverageItem
++
++
++CalleeCoverageItem::CalleeCoverageItem(TQListView* parent, Coverage* c,
++                                       TraceFunction* base,
++                                       TraceCostType* ct,
++                                       TraceCost::CostType gt)
++    : TQListViewItem(parent)
++{
++  _skipped = 0;
++  _coverage = c;
++  _function = c ? c->function() : 0;
++  _base = base;
++  _groupType = TraceCost::NoCostType;
++
++  setText(4, _function->prettyNameWithLocation());
++
++  setCostType(ct);
++  setGroupType(gt);
++}
++
++CalleeCoverageItem::CalleeCoverageItem(TQListView* parent, int skipped, Coverage* c,
++                                       TraceFunction* base,
++                                       TraceCostType* ct,
++                                       TraceCost::CostType gt)
++    : TQListViewItem(parent)
++{
++  _skipped = skipped;
++  _coverage = c;
++  _function = c ? c->function() : 0;
++  _base = base;
++  _groupType = TraceCost::NoCostType;
++
++  setText(4, i18n("(%n function skipped)", "(%n functions skipped)", _skipped));
++
++  setCostType(ct);
++  setGroupType(gt);
++}
++
++void CalleeCoverageItem::setGroupType(TraceCost::CostType gt)
++{
++  if (_skipped) return;
++  if (_groupType == gt) return;
++  _groupType = gt;
++
++  TQColor c = Configuration::functionColor(_groupType, _function);
++  setPixmap(4, colorPixmap(10, 10, c));
++}
++
++void CalleeCoverageItem::setCostType(TraceCostType* ct)
++{
++  _costType = ct;
++  update();
++}
++
++void CalleeCoverageItem::update()
++{
++  if (!_coverage) {
++    setText(0, TQString());
++    setText(1, TQString());
++    setText(2, TQString());
++    return;
++  }
++
++  _pSum = 100.0 * _coverage->inclusive();
++
++  // pSum/pSelf are percentages of inclusive cost of base
++  SubCost realSum = _base->inclusive()->subCost(_costType);
++  _sum = SubCost(realSum * _coverage->inclusive());
++
++
++  TQString str;
++  if (Configuration::showPercentage())
++    str = TQString("%1").arg(_pSum, 0, 'f', Configuration::percentPrecision());
++  else
++    str = _sum.pretty();
++
++  if (_skipped) {
++    str = TQString("< %1").arg(str);
++    setText(0, str);
++    setText(1, str);
++    return;
++  }
++ setText(0, str);
++
++ _pSelf = 100.0 * _coverage->self();
++ _self = SubCost(realSum * _coverage->self());
++
++ if (Configuration::showPercentage()) {
++    setText(1, TQString("%1")
++            .arg(_pSelf, 0, 'f', Configuration::percentPrecision()));
++  }
++  else {
++    setText(1, _self.pretty());
++  }
++
++  setPixmap(0, partitionPixmap(25, 10, _coverage->inclusiveHistogram(), 0,
++                               Coverage::maxHistogramDepth, false));
++  setPixmap(1, partitionPixmap(25, 10, _coverage->selfHistogram(), 0,
++                               Coverage::maxHistogramDepth, false));
++
++
++  _cc  = SubCost(_coverage->callCount());
++  setText(3, _cc ? _cc.pretty() : TQString("(0)"));
++
++  // for comparations
++  _distance = _coverage->inclusiveMedian();
++  TQString distString;
++  if (_coverage->minDistance() == _coverage->maxDistance())
++    distString = TQString::number(_distance);
++  else {
++    int sMed = _coverage->selfMedian();
++    TQString med;
++    if (_distance == sMed)
++      med = TQString::number(_distance);
++    else
++      med = TQString("%1/%2").arg(_distance).arg(sMed);
++
++    distString = TQString("%1-%2 (%3)")
++                 .arg(_coverage->minDistance())
++                 .arg(_coverage->maxDistance())
++                 .arg(med);
++  }
++  setText(2, distString);
++}
++
++
++int CalleeCoverageItem::compare(TQListViewItem * i,
++                                int col, bool ascending ) const
++{
++  CalleeCoverageItem* ci = (CalleeCoverageItem*) i;
++
++  // a skip entry is always sorted last
++  if (_skipped) return -1;
++  if (ci->_skipped) return 1;
++
++  if (col==0) {
++    if (_pSum < ci->_pSum) return -1;
++    if (_pSum > ci->_pSum) return 1;
++
++    // for same percentage (e.g. all 100%), use distance info
++    if (_distance < ci->_distance) return -1;
++    if (_distance > ci->_distance) return 1;
++    return 0;
++  }
++
++  if (col==1) {
++    if (_pSelf < ci->_pSelf) return -1;
++    if (_pSelf > ci->_pSelf) return 1;
++
++    // for same percentage (e.g. all 100%), use distance info
++    if (_distance < ci->_distance) return -1;
++    if (_distance > ci->_distance) return 1;
++    return 0;
++  }
++
++  if (col==2) {
++    // we want to sort the distance in contra direction to costs
++    if (_distance < ci->_distance) return  1;
++    if (_distance > ci->_distance) return -1;
++    return 0;
++  }
++
++  if (col==3) {
++    if (_cc < ci->_cc) return -1;
++    if (_cc > ci->_cc) return 1;
++    return 0;
++  }
++  return TQListViewItem::compare(i, col, ascending);
++}
++
++
+diff --git a/kdecachegrind/kdecachegrind/coverageitem.h b/kdecachegrind/kdecachegrind/coverageitem.h
+new file mode 100644
+index 0000000..ba442aa
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/coverageitem.h
+@@ -0,0 +1,82 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Items of coverage view.
++ */
++
++#ifndef COVERAGEITEM_H
++#define COVERAGEITEM_H
++
++#include <tqlistview.h>
++#include "tracedata.h"
++
++class Coverage;
++
++class CallerCoverageItem: public TQListViewItem
++{
++public:
++  CallerCoverageItem(TQListView* parent, Coverage* c, TraceFunction* base,
++                     TraceCostType* ct, TraceCost::CostType gt);
++  CallerCoverageItem(TQListView* parent, int skipped, Coverage* c, TraceFunction* base,
++                     TraceCostType* ct, TraceCost::CostType gt);
++
++  int compare(TQListViewItem * i, int col, bool ascending ) const;
++  TraceFunction* function() { return (_skipped) ? 0 : _function; }
++  void setCostType(TraceCostType* ct);
++  void setGroupType(TraceCost::CostType);
++  void update();
++
++private:
++  float _pSum;
++  SubCost _sum;
++  TraceCostType* _costType;
++  TraceCost::CostType _groupType;
++  SubCost _cc;
++  int _distance, _skipped;
++  TraceFunction *_function, *_base;
++  Coverage* _coverage;
++};
++
++
++class CalleeCoverageItem: public TQListViewItem
++{
++public:
++  CalleeCoverageItem(TQListView* parent, Coverage* c, TraceFunction* base,
++                     TraceCostType* ct, TraceCost::CostType gt);
++  CalleeCoverageItem(TQListView* parent, int skipped, Coverage* c, TraceFunction* base,
++                     TraceCostType* ct, TraceCost::CostType gt);
++
++  int compare(TQListViewItem * i, int col, bool ascending ) const;
++  TraceFunction* function() { return (_skipped) ? 0 : _function; }
++  void setCostType(TraceCostType* ct);
++  void setGroupType(TraceCost::CostType);
++  void update();
++
++private:
++  float _pSum, _pSelf;
++  SubCost _sum, _self;
++  TraceCostType* _costType;
++  TraceCost::CostType _groupType;
++  SubCost _cc;
++  int _distance, _skipped;
++  TraceFunction *_function, *_base;
++  Coverage* _coverage;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/coverageview.cpp b/kdecachegrind/kdecachegrind/coverageview.cpp
+new file mode 100644
+index 0000000..6657e92
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/coverageview.cpp
+@@ -0,0 +1,321 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Coverage Views
++ */
++
++#include <tqwhatsthis.h>
++#include <tqpopupmenu.h>
++#include <klocale.h>
++
++#include "configuration.h"
++#include "coverageitem.h"
++#include "coverage.h"
++#include "coverageview.h"
++
++
++
++//
++// CoverageView
++//
++
++
++CoverageView::CoverageView(bool showCallers, TraceItemView* parentView,
++			   TQWidget* parent, const char* name)
++  : TQListView(parent, name), TraceItemView(parentView)
++{
++    _showCallers = showCallers;
++
++
++    addColumn( i18n( "Incl." ) );
++    if (_showCallers) {
++	addColumn( i18n( "Distance" ) );
++	addColumn( i18n( "Called" ) );
++	addColumn( i18n( "Caller" ) );
++    }
++    else {
++	addColumn( i18n( "Self" ) );
++	addColumn( i18n( "Distance" ) );
++	addColumn( i18n( "Calling" ) );
++	addColumn( i18n( "Callee" ) );
++	setColumnAlignment(3, TQt::AlignRight);
++    }
++
++    setSorting(0,false);
++    setColumnAlignment(0, TQt::AlignRight);
++    setColumnAlignment(1, TQt::AlignRight);
++    setColumnAlignment(2, TQt::AlignRight);
++    setAllColumnsShowFocus(true);
++    setResizeMode(TQListView::LastColumn);
++    setMinimumHeight(50);
++
++    connect( this,
++	     TQT_SIGNAL( selectionChanged(TQListViewItem*) ),
++	     TQT_SLOT( selectedSlot(TQListViewItem*) ) );
++
++    connect( this,
++	     TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint &, int)),
++	     TQT_SLOT(context(TQListViewItem*, const TQPoint &, int)));
++
++    connect(this,
++	    TQT_SIGNAL(doubleClicked(TQListViewItem*)),
++	    TQT_SLOT(activatedSlot(TQListViewItem*)));
++
++    connect(this,
++	    TQT_SIGNAL(returnPressed(TQListViewItem*)),
++	    TQT_SLOT(activatedSlot(TQListViewItem*)));
++
++    TQWhatsThis::add( this, whatsThis() );
++}
++
++TQString CoverageView::whatsThis() const
++{
++    return _showCallers ?
++	i18n( "<b>List of all Callers</b>"
++	      "<p>This list shows all functions calling the "
++	      "current selected one, either directly or with "
++	      "several functions in-between on the stack; the "
++	      "number of functions in-between plus one "
++	      "is called the <em>Distance</em> (e.g. "
++	      "for function A,B,C there exists a call from "
++	      "A to C when A calls B and B calls C, i.e. "
++	      "A => B => C. The distance here is 2).</p>"
++
++	      "<p>Absolute cost shown is the cost spent in the "
++	      "selected function while a listed function is active; "
++	      "relative cost is the percentage of all cost spent in "
++	      "the selected function while the listed one is "
++	      "active. The cost graphic shows logarithmic "
++	      "percentage with a different color for each "
++	      "distance.</p>"
++
++	      "<p>As there can be many calls from the same function, "
++	      "the distance column sometimes shows "
++	      "the range of distances for all "
++	      "calls happening; then, in parentheses, there is the "
++	      "medium distance, i.e. the distance where most of the "
++	      "call costs happened.</p>"
++
++	      "<p>Selecting a function makes it the current selected "
++	      "one of this information panel. "
++	      "If there are two panels (Split mode), the "
++	      "function of the other panel is changed instead.</p>") :
++
++	i18n( "<b>List of all Callees</b>"
++	      "<p>This list shows all functions called by the "
++	      "current selected one, either directly or with "
++	      "several function in-between on the stack; the "
++	      "number of function in-between plus one "
++	      "is called the <em>Distance</em> (e.g. "
++	      "for function A,B,C there exists a call from "
++	      "A to C when A calls B and B calls C, i.e. "
++	      "A => B => C. The distance here is 2).</p>"
++
++	      "<p>Absolute cost shown is the cost spent in the "
++	      "listed function while the selected is active; "
++	      "relative cost is the percentage of all cost spent in "
++	      "the listed function while the selected one is active. "
++	      "The cost graphic always shows logarithmic "
++	      "percentage with a different color for each "
++	      "distance.</p>"
++
++	      "<p>As there can be many calls to the same function, "
++	      "the distance column sometimes shows "
++	      "the range of distances for all "
++	      "calls happening; then, in parentheses, there is the "
++	      "medium distance, i.e. the distance where most of the "
++	      "call costs happened.</p>"
++
++	      "<p>Selecting a function makes it the current selected "
++	      "one of this information panel. "
++	      "If there are two panels (Split mode), the "
++	      "function of the other panel is changed instead.</p>");
++}
++
++void CoverageView::context(TQListViewItem* i, const TQPoint & p, int c)
++{
++  TQPopupMenu popup;
++
++  TraceFunction* f = 0;
++  if (i) {
++      f = _showCallers ?
++	  ((CallerCoverageItem*)i)->function() :
++	  ((CalleeCoverageItem*)i)->function();
++  }
++
++  if (f) {
++    TQString name = f->name();
++    if ((int)name.length()>Configuration::maxSymbolLength())
++	name = name.left(Configuration::maxSymbolLength()) + "...";
++    popup.insertItem(i18n("Go to '%1'").arg(name), 93);
++    popup.insertSeparator();
++  }
++
++   if ((c == 0) || (!_showCallers && c == 1)) {
++    addCostMenu(&popup, false);
++    popup.insertSeparator();
++  }
++  addGoMenu(&popup); 
++
++  int r = popup.exec(p);
++  if (r == 93) activated(f);
++}
++
++void CoverageView::selectedSlot(TQListViewItem * i)
++{
++  TraceFunction* f = 0;
++  if (i) {
++      f = _showCallers ?
++	  ((CallerCoverageItem*)i)->function() :
++	  ((CalleeCoverageItem*)i)->function();
++  }
++
++  if (f) {
++      _selectedItem = f;
++      selected(f);
++  }
++}
++
++void CoverageView::activatedSlot(TQListViewItem * i)
++{
++  TraceFunction* f = 0;
++  if (i) {
++      f = _showCallers ?
++	  ((CallerCoverageItem*)i)->function() :
++	  ((CalleeCoverageItem*)i)->function();
++  }
++
++  if (f) activated(f);
++}
++
++TraceItem* CoverageView::canShow(TraceItem* i)
++{
++  TraceItem::CostType t = i ? i->type() : TraceItem::NoCostType;
++
++  switch(t) {
++  case TraceItem::Function:
++  case TraceItem::FunctionCycle:
++      return i;
++  default:
++      break;
++  }
++  return 0;
++}
++
++void CoverageView::doUpdate(int changeType)
++{
++    // Special case ?
++    if (changeType == selectedItemChanged) {
++
++	if (!_selectedItem) {
++	    clearSelection();
++	    return;
++	}
++
++	TraceFunction* f = 0;
++	TQListViewItem* i = TQListView::selectedItem();
++	if (i) {
++	    f = _showCallers ?
++		((CallerCoverageItem*)i)->function() :
++		((CalleeCoverageItem*)i)->function();
++	}
++	if (f == _selectedItem) return;
++
++	TQListViewItem *item;
++	for (item = firstChild();item;item = item->nextSibling()) {
++	    f = _showCallers ?
++		((CallerCoverageItem*)item)->function() :
++		((CalleeCoverageItem*)item)->function();
++	    if (f == _selectedItem) {
++		ensureItemVisible(item);
++		setCurrentItem(item);
++		break;
++	    }
++	}
++	return;
++    }
++
++    if (changeType == groupTypeChanged) {
++	TQListViewItem *item;
++	for (item = firstChild();item;item = item->nextSibling()) {
++	    if (_showCallers)
++		((CallerCoverageItem*)item)->setGroupType(_groupType);
++	    else
++		((CalleeCoverageItem*)item)->setGroupType(_groupType);
++	}
++	return;
++    }
++
++    refresh();
++}
++
++void CoverageView::refresh()
++{
++    clear();
++    setColumnWidth(0, 50);
++    if (!_showCallers)
++	setColumnWidth(1, 50);
++
++    if (!_data || !_activeItem) return;
++
++    TraceItem::CostType t = _activeItem->type();
++    TraceFunction* f = 0;
++    if (t == TraceItem::Function) f = (TraceFunction*) _activeItem;
++    if (t == TraceItem::FunctionCycle) f = (TraceFunction*) _activeItem;
++    if (!f) return;
++
++    TraceFunction* ff;
++    TraceFunctionList l;
++
++    _hc.clear(Configuration::maxListCount());
++    SubCost realSum = f->inclusive()->subCost(_costType);
++
++    if (_showCallers)
++      l = Coverage::coverage(f, Coverage::Caller, _costType);
++    else
++      l = Coverage::coverage(f, Coverage::Called, _costType);
++
++    for (ff=l.first();ff;ff=l.next()) {
++      Coverage* c = (Coverage*) ff->assoziation(Coverage::Rtti);
++      if (c && (c->inclusive()>0.0))
++	_hc.addCost(ff, SubCost(realSum * c->inclusive()));
++    }
++
++    for(int i=0;i<_hc.realCount();i++) {
++      ff = (TraceFunction*) _hc[i];
++      Coverage* c = (Coverage*) ff->assoziation(Coverage::Rtti);
++      if (_showCallers)
++	new CallerCoverageItem(this, c, f, _costType, _groupType);
++      else
++	new CalleeCoverageItem(this, c, f, _costType, _groupType);
++    }
++    if (_hc.hasMore()) {
++      // a placeholder for all the functions skipped ...
++      ff = (TraceFunction*) _hc[_hc.maxSize()-1];
++      Coverage* c = (Coverage*) ff->assoziation(Coverage::Rtti);
++      if (_showCallers)
++	new CallerCoverageItem(this, _hc.count() - _hc.maxSize(),
++			       c, f, _costType, _groupType);
++      else
++	new CalleeCoverageItem(this, _hc.count() - _hc.maxSize(),
++			       c, f, _costType, _groupType);
++    }
++}
++
++#include "coverageview.moc"
+diff --git a/kdecachegrind/kdecachegrind/coverageview.h b/kdecachegrind/kdecachegrind/coverageview.h
+new file mode 100644
+index 0000000..09c5de0
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/coverageview.h
+@@ -0,0 +1,57 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Coverage Views
++ */
++
++#ifndef COVERAGEVIEW_H
++#define COVERAGEVIEW_H
++
++#include <tqlistview.h>
++#include "tracedata.h"
++#include "traceitemview.h"
++#include "listutils.h"
++
++class CoverageView: public TQListView, public TraceItemView
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  CoverageView(bool showCallers, TraceItemView* parentView,
++	       TQWidget* parent=0, const char* name=0);
++
++  virtual TQWidget* widget() { return this; }
++  TQString whatsThis() const;
++
++private slots:
++  void context(TQListViewItem*,const TQPoint &, int);
++  void selectedSlot(TQListViewItem*);
++  void activatedSlot(TQListViewItem*);
++
++private:
++  TraceItem* canShow(TraceItem*);
++  void doUpdate(int);
++  void refresh();
++
++  HighestCostList _hc;
++  bool _showCallers;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/dumpmanager.cpp b/kdecachegrind/kdecachegrind/dumpmanager.cpp
+new file mode 100644
+index 0000000..2f0891a
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/dumpmanager.cpp
+@@ -0,0 +1,50 @@
++/**
++ * DumpManager
++ * Part of KCachegrind
++ * 2003, Josef Weidendorfer (GPL V2)
++ */
++
++#include "dumpmanager.h"
++
++
++//
++// Dump
++//
++
++Dump::Dump(TQString file)
++{
++  _filename = file;
++}
++
++
++//
++// DumpManager
++//
++
++DumpManager* DumpManager::_self = 0;
++
++
++DumpManager::DumpManager()
++{
++}
++
++DumpManager* DumpManager::self()
++{
++  if (!_self)
++    _self = new DumpManager();
++
++  return _self;
++}
++
++
++DumpList DumpManager::loadableDumps()
++{
++  DumpList res;
++
++  return res;
++}
++
++TraceData* DumpManager::load(Dump*)
++{
++  return 0;
++}
+diff --git a/kdecachegrind/kdecachegrind/dumpmanager.h b/kdecachegrind/kdecachegrind/dumpmanager.h
+new file mode 100644
+index 0000000..4925819
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/dumpmanager.h
+@@ -0,0 +1,59 @@
++/**
++ * DumpManager
++ * Part of KCachegrind
++ * 2003, Josef Weidendorfer (GPL V2)
++ *
++ * DumpManager is a Singleton.
++ * - Has List of current loaded dumps / loadable dumps
++ * - Does "communication" with current running profiles
++ *   for dump selection dockable
++ */
++
++#ifndef DUMPMANAGER_H
++#define DUMPMANAGER_H
++
++#include <tqstring.h>
++#include <tqptrlist.h>
++
++class Dump;
++class TraceData;
++
++typedef TQPtrList<Dump> DumpList;
++
++
++/**
++ * A loadable profile Dump
++ */
++class Dump
++{
++public:
++  Dump(TQString);
++
++  TQString filename() { return _filename; }
++
++private:
++  TQString _filename;
++};
++
++
++/*
++ * TODO:
++ * - Everything
++ *
++ */
++
++class DumpManager
++{
++public:
++  DumpManager();
++
++  DumpManager* self();
++
++  DumpList loadableDumps();
++  TraceData* load(Dump*);
++
++private:
++  static DumpManager* _self;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/dumpselection.cpp b/kdecachegrind/kdecachegrind/dumpselection.cpp
+new file mode 100644
+index 0000000..4d812ef
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/dumpselection.cpp
+@@ -0,0 +1,33 @@
++/**
++ * DumpSelection Dockable
++ * Part of KCachegrind
++ * 2003, Josef Weidendorfer (GPL V2)
++ *
++ * - Fast Selection of dumps to load/activate/use for comparing
++ * - Start a profile run from GUI (current supported: Callgrind)
++ * - View state of running profile runs.
++ *
++ */
++
++#include "dumpselection.h"
++
++/*
++ * TODO:
++ *  - Everything !!
++ *  - Request State info on current function..
++ *
++ */
++
++
++DumpSelection::DumpSelection( TopLevel* top,
++                              TQWidget* parent, const char* name)
++    : DumpSelectionBase(parent, name), TraceItemView(0, top)
++{
++}
++
++DumpSelection::~DumpSelection()
++{}
++
++
++#include "dumpselection.moc"
++
+diff --git a/kdecachegrind/kdecachegrind/dumpselection.h b/kdecachegrind/kdecachegrind/dumpselection.h
+new file mode 100644
+index 0000000..49ca532
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/dumpselection.h
+@@ -0,0 +1,30 @@
++/**
++ * DumpSelection Dockable
++ * Part of KCachegrind
++ * 2003, Josef Weidendorfer (GPL V2)
++ *
++ * - Fast Selection of dumps to load/activate/use for comparing
++ * - Start a profile run from GUI (current supported: Callgrind)
++ * - View state of running profile runs.
++ *
++ */
++
++#ifndef DUMPSELECTION_H
++#define DUMPSELECTION_H
++
++#include "dumpselectionbase.h"
++#include "traceitemview.h"
++
++class DumpSelection : public DumpSelectionBase, public TraceItemView
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  DumpSelection( TopLevel*, TQWidget* parent = 0, const char* name = 0);
++  virtual ~DumpSelection();
++
++  TQWidget* widget() { return this; }
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/dumpselectionbase.ui b/kdecachegrind/kdecachegrind/dumpselectionbase.ui
+new file mode 100644
+index 0000000..b8ad1b0
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/dumpselectionbase.ui
+@@ -0,0 +1,1082 @@
++<!DOCTYPE UI><UI version="3.2" stdsetdef="1">
++<class>DumpSelectionBase</class>
++<widget class="TQWidget">
++    <property name="name">
++        <cstring>DumpSelectionBase</cstring>
++    </property>
++    <property name="geometry">
++        <rect>
++            <x>0</x>
++            <y>0</y>
++            <width>349</width>
++            <height>832</height>
++        </rect>
++    </property>
++    <property name="caption">
++        <string>Profile Dumps</string>
++    </property>
++    <vbox>
++        <property name="name">
++            <cstring>unnamed</cstring>
++        </property>
++        <widget class="TQSplitter">
++            <property name="name">
++                <cstring>splitter1</cstring>
++            </property>
++            <property name="orientation">
++                <enum>Vertical</enum>
++            </property>
++            <widget class="TQListView">
++                <column>
++                    <property name="text">
++                        <string>Target</string>
++                    </property>
++                    <property name="clickable">
++                        <bool>true</bool>
++                    </property>
++                    <property name="resizable">
++                        <bool>true</bool>
++                    </property>
++                </column>
++                <column>
++                    <property name="text">
++                        <string></string>
++                    </property>
++                    <property name="clickable">
++                        <bool>true</bool>
++                    </property>
++                    <property name="resizable">
++                        <bool>true</bool>
++                    </property>
++                </column>
++                <column>
++                    <property name="text">
++                        <string>Time</string>
++                    </property>
++                    <property name="clickable">
++                        <bool>true</bool>
++                    </property>
++                    <property name="resizable">
++                        <bool>true</bool>
++                    </property>
++                </column>
++                <column>
++                    <property name="text">
++                        <string>Path</string>
++                    </property>
++                    <property name="clickable">
++                        <bool>true</bool>
++                    </property>
++                    <property name="resizable">
++                        <bool>true</bool>
++                    </property>
++                </column>
++                <property name="name">
++                    <cstring>listView1</cstring>
++                </property>
++            </widget>
++            <widget class="TQTabWidget">
++                <property name="name">
++                    <cstring>tabWidget2</cstring>
++                </property>
++                <widget class="TQWidget">
++                    <property name="name">
++                        <cstring>tab</cstring>
++                    </property>
++                    <attribute name="title">
++                        <string>Options</string>
++                    </attribute>
++                    <vbox>
++                        <property name="name">
++                            <cstring>unnamed</cstring>
++                        </property>
++                        <widget class="TQLabel">
++                            <property name="name">
++                                <cstring>textLabel1</cstring>
++                            </property>
++                            <property name="sizePolicy">
++                                <sizepolicy>
++                                    <hsizetype>5</hsizetype>
++                                    <vsizetype>5</vsizetype>
++                                    <horstretch>1</horstretch>
++                                    <verstretch>0</verstretch>
++                                </sizepolicy>
++                            </property>
++                            <property name="text">
++                                <string>Target command:</string>
++                            </property>
++                        </widget>
++                        <widget class="TQLineEdit">
++                            <property name="name">
++                                <cstring>lineEdit1</cstring>
++                            </property>
++                        </widget>
++                        <widget class="TQLabel">
++                            <property name="name">
++                                <cstring>textLabel2</cstring>
++                            </property>
++                            <property name="text">
++                                <string>Profiler options:</string>
++                            </property>
++                        </widget>
++                        <widget class="TQListView">
++                            <column>
++                                <property name="text">
++                                    <string>Option</string>
++                                </property>
++                                <property name="clickable">
++                                    <bool>true</bool>
++                                </property>
++                                <property name="resizable">
++                                    <bool>true</bool>
++                                </property>
++                            </column>
++                            <column>
++                                <property name="text">
++                                    <string>Value</string>
++                                </property>
++                                <property name="clickable">
++                                    <bool>true</bool>
++                                </property>
++                                <property name="resizable">
++                                    <bool>true</bool>
++                                </property>
++                            </column>
++                        <item>
++                            <property name="text">
++                                <string>Trace</string>
++                            </property>
++                            <property name="text">
++                                <string></string>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <item>
++                                <property name="text">
++                                    <string>Jumps</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                            <item>
++                                <property name="text">
++                                    <string>Instructions</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                        </item>
++                        <item>
++                            <property name="text">
++                                <string>Events</string>
++                            </property>
++                            <property name="text">
++                                <string></string>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <item>
++                                <property name="text">
++                                    <string>Full Cache</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                            <item>
++                                <property name="text">
++                                    <string>Custom</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                        </item>
++                        <item>
++                            <property name="text">
++                                <string>Collect</string>
++                            </property>
++                            <property name="text">
++                                <string></string>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <item>
++                                <property name="text">
++                                    <string>At Startup</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                            <item>
++                                <property name="text">
++                                    <string>While In</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                        </item>
++                        <item>
++                            <property name="text">
++                                <string>Skip</string>
++                            </property>
++                            <property name="text">
++                                <string></string>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <item>
++                                <property name="text">
++                                    <string>PLT</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                            <item>
++                                <property name="text">
++                                    <string>Function</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                        </item>
++                        <item>
++                            <property name="text">
++                                <string>Dump Profile</string>
++                            </property>
++                            <property name="text">
++                                <string></string>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <item>
++                                <property name="text">
++                                    <string>Every BBs</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                            <item>
++                                <property name="text">
++                                    <string>On Entering</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                            <item>
++                                <property name="text">
++                                    <string>On Leaving</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                        </item>
++                        <item>
++                            <property name="text">
++                                <string>Zero Events</string>
++                            </property>
++                            <property name="text">
++                                <string></string>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <item>
++                                <property name="text">
++                                    <string>On Entering</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                        </item>
++                        <item>
++                            <property name="text">
++                                <string>Separate</string>
++                            </property>
++                            <property name="text">
++                                <string></string>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <item>
++                                <property name="text">
++                                    <string>Threads</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                            <item>
++                                <property name="text">
++                                    <string>Recursions</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                            <item>
++                                <property name="text">
++                                    <string>Call Chain</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                        </item>
++                            <property name="name">
++                                <cstring>listView3</cstring>
++                            </property>
++                        </widget>
++                        <widget class="TQLabel">
++                            <property name="name">
++                                <cstring>textLabel1_2</cstring>
++                            </property>
++                            <property name="sizePolicy">
++                                <sizepolicy>
++                                    <hsizetype>5</hsizetype>
++                                    <vsizetype>5</vsizetype>
++                                    <horstretch>1</horstretch>
++                                    <verstretch>0</verstretch>
++                                </sizepolicy>
++                            </property>
++                            <property name="text">
++                                <string>Custom profiler options:</string>
++                            </property>
++                        </widget>
++                        <widget class="TQLineEdit">
++                            <property name="name">
++                                <cstring>lineEdit1_2</cstring>
++                            </property>
++                        </widget>
++                        <widget class="TQLayoutWidget">
++                            <property name="name">
++                                <cstring>layout3</cstring>
++                            </property>
++                            <hbox>
++                                <property name="name">
++                                    <cstring>unnamed</cstring>
++                                </property>
++                                <spacer>
++                                    <property name="name">
++                                        <cstring>spacer1</cstring>
++                                    </property>
++                                    <property name="orientation">
++                                        <enum>Horizontal</enum>
++                                    </property>
++                                    <property name="sizeType">
++                                        <enum>Expanding</enum>
++                                    </property>
++                                    <property name="sizeHint">
++                                        <size>
++                                            <width>21</width>
++                                            <height>20</height>
++                                        </size>
++                                    </property>
++                                </spacer>
++                                <widget class="TQPushButton">
++                                    <property name="name">
++                                        <cstring>pushButton2</cstring>
++                                    </property>
++                                    <property name="text">
++                                        <string>Run New Profile</string>
++                                    </property>
++                                </widget>
++                            </hbox>
++                        </widget>
++                    </vbox>
++                </widget>
++                <widget class="TQWidget">
++                    <property name="name">
++                        <cstring>tab</cstring>
++                    </property>
++                    <attribute name="title">
++                        <string>Info</string>
++                    </attribute>
++                    <vbox>
++                        <property name="name">
++                            <cstring>unnamed</cstring>
++                        </property>
++                        <widget class="TQLabel">
++                            <property name="name">
++                                <cstring>textLabel8</cstring>
++                            </property>
++                            <property name="text">
++                                <string>Dump reason:</string>
++                            </property>
++                        </widget>
++                        <widget class="TQLineEdit">
++                            <property name="name">
++                                <cstring>lineEdit3</cstring>
++                            </property>
++                        </widget>
++                        <widget class="TQLabel">
++                            <property name="name">
++                                <cstring>textLabel6</cstring>
++                            </property>
++                            <property name="text">
++                                <string>Event summary:</string>
++                            </property>
++                        </widget>
++                        <widget class="TQListView">
++                            <column>
++                                <property name="text">
++                                    <string>Name</string>
++                                </property>
++                                <property name="clickable">
++                                    <bool>true</bool>
++                                </property>
++                                <property name="resizable">
++                                    <bool>true</bool>
++                                </property>
++                            </column>
++                            <column>
++                                <property name="text">
++                                    <string>Sum</string>
++                                </property>
++                                <property name="clickable">
++                                    <bool>true</bool>
++                                </property>
++                                <property name="resizable">
++                                    <bool>true</bool>
++                                </property>
++                            </column>
++                            <property name="name">
++                                <cstring>listView4</cstring>
++                            </property>
++                        </widget>
++                        <widget class="TQLabel">
++                            <property name="name">
++                                <cstring>textLabel7</cstring>
++                            </property>
++                            <property name="text">
++                                <string>Miscellaneous:</string>
++                            </property>
++                        </widget>
++                        <widget class="TQTextEdit">
++                            <property name="name">
++                                <cstring>textEdit2</cstring>
++                            </property>
++                        </widget>
++                        <widget class="TQLayoutWidget">
++                            <property name="name">
++                                <cstring>layout7</cstring>
++                            </property>
++                            <hbox>
++                                <property name="name">
++                                    <cstring>unnamed</cstring>
++                                </property>
++                                <spacer>
++                                    <property name="name">
++                                        <cstring>spacer3</cstring>
++                                    </property>
++                                    <property name="orientation">
++                                        <enum>Horizontal</enum>
++                                    </property>
++                                    <property name="sizeType">
++                                        <enum>Expanding</enum>
++                                    </property>
++                                    <property name="sizeHint">
++                                        <size>
++                                            <width>50</width>
++                                            <height>20</height>
++                                        </size>
++                                    </property>
++                                </spacer>
++                                <widget class="TQPushButton">
++                                    <property name="name">
++                                        <cstring>pushButton6</cstring>
++                                    </property>
++                                    <property name="text">
++                                        <string>Show</string>
++                                    </property>
++                                </widget>
++                                <widget class="TQPushButton">
++                                    <property name="name">
++                                        <cstring>pushButton5</cstring>
++                                    </property>
++                                    <property name="text">
++                                        <string>Compare</string>
++                                    </property>
++                                </widget>
++                            </hbox>
++                        </widget>
++                    </vbox>
++                </widget>
++                <widget class="TQWidget">
++                    <property name="name">
++                        <cstring>tab</cstring>
++                    </property>
++                    <attribute name="title">
++                        <string>State</string>
++                    </attribute>
++                    <vbox>
++                        <property name="name">
++                            <cstring>unnamed</cstring>
++                        </property>
++                        <widget class="TQLayoutWidget">
++                            <property name="name">
++                                <cstring>layout2</cstring>
++                            </property>
++                            <hbox>
++                                <property name="name">
++                                    <cstring>unnamed</cstring>
++                                </property>
++                                <widget class="TQPushButton">
++                                    <property name="name">
++                                        <cstring>pushButton1</cstring>
++                                    </property>
++                                    <property name="text">
++                                        <string>Update</string>
++                                    </property>
++                                </widget>
++                                <widget class="TQCheckBox">
++                                    <property name="name">
++                                        <cstring>checkBox1</cstring>
++                                    </property>
++                                    <property name="text">
++                                        <string>Every [s]:</string>
++                                    </property>
++                                </widget>
++                                <widget class="TQLineEdit">
++                                    <property name="name">
++                                        <cstring>lineEdit3_2</cstring>
++                                    </property>
++                                </widget>
++                            </hbox>
++                        </widget>
++                        <widget class="TQListView">
++                            <column>
++                                <property name="text">
++                                    <string>Counter</string>
++                                </property>
++                                <property name="clickable">
++                                    <bool>true</bool>
++                                </property>
++                                <property name="resizable">
++                                    <bool>true</bool>
++                                </property>
++                            </column>
++                            <column>
++                                <property name="text">
++                                    <string>Value</string>
++                                </property>
++                                <property name="clickable">
++                                    <bool>true</bool>
++                                </property>
++                                <property name="resizable">
++                                    <bool>true</bool>
++                                </property>
++                            </column>
++                        <item>
++                            <property name="text">
++                                <string>Dumps Done</string>
++                            </property>
++                            <property name="text">
++                                <string></string>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                        </item>
++                        <item>
++                            <property name="text">
++                                <string>Is Collecting</string>
++                            </property>
++                            <property name="text">
++                                <string></string>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                        </item>
++                        <item>
++                            <property name="text">
++                                <string>Executed</string>
++                            </property>
++                            <property name="text">
++                                <string></string>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <item>
++                                <property name="text">
++                                    <string>Basic Blocks</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                            <item>
++                                <property name="text">
++                                    <string>Calls</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                            <item>
++                                <property name="text">
++                                    <string>Jumps</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                        </item>
++                        <item>
++                            <property name="text">
++                                <string>Events</string>
++                            </property>
++                            <property name="text">
++                                <string></string>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <item>
++                                <property name="text">
++                                    <string>Ir</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                        </item>
++                        <item>
++                            <property name="text">
++                                <string>Distinct</string>
++                            </property>
++                            <property name="text">
++                                <string></string>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <property name="pixmap">
++                                <pixmap></pixmap>
++                            </property>
++                            <item>
++                                <property name="text">
++                                    <string>ELF Objects</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                            <item>
++                                <property name="text">
++                                    <string>Functions</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                            <item>
++                                <property name="text">
++                                    <string>Contexts</string>
++                                </property>
++                                <property name="text">
++                                    <string></string>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                                <property name="pixmap">
++                                    <pixmap></pixmap>
++                                </property>
++                            </item>
++                        </item>
++                            <property name="name">
++                                <cstring>listView4_3</cstring>
++                            </property>
++                        </widget>
++                        <widget class="TQLayoutWidget">
++                            <property name="name">
++                                <cstring>layout4</cstring>
++                            </property>
++                            <hbox>
++                                <property name="name">
++                                    <cstring>unnamed</cstring>
++                                </property>
++                                <widget class="TQLabel">
++                                    <property name="name">
++                                        <cstring>textLabel4</cstring>
++                                    </property>
++                                    <property name="sizePolicy">
++                                        <sizepolicy>
++                                            <hsizetype>5</hsizetype>
++                                            <vsizetype>5</vsizetype>
++                                            <horstretch>1</horstretch>
++                                            <verstretch>0</verstretch>
++                                        </sizepolicy>
++                                    </property>
++                                    <property name="text">
++                                        <string>Stack trace:</string>
++                                    </property>
++                                </widget>
++                                <widget class="TQCheckBox">
++                                    <property name="name">
++                                        <cstring>checkBox2</cstring>
++                                    </property>
++                                    <property name="text">
++                                        <string>Sync.</string>
++                                    </property>
++                                </widget>
++                            </hbox>
++                        </widget>
++                        <widget class="TQListView">
++                            <column>
++                                <property name="text">
++                                    <string>#</string>
++                                </property>
++                                <property name="clickable">
++                                    <bool>true</bool>
++                                </property>
++                                <property name="resizable">
++                                    <bool>true</bool>
++                                </property>
++                            </column>
++                            <column>
++                                <property name="text">
++                                    <string>Incl.</string>
++                                </property>
++                                <property name="clickable">
++                                    <bool>true</bool>
++                                </property>
++                                <property name="resizable">
++                                    <bool>true</bool>
++                                </property>
++                            </column>
++                            <column>
++                                <property name="text">
++                                    <string>Called</string>
++                                </property>
++                                <property name="clickable">
++                                    <bool>true</bool>
++                                </property>
++                                <property name="resizable">
++                                    <bool>true</bool>
++                                </property>
++                            </column>
++                            <column>
++                                <property name="text">
++                                    <string>Function</string>
++                                </property>
++                                <property name="clickable">
++                                    <bool>true</bool>
++                                </property>
++                                <property name="resizable">
++                                    <bool>true</bool>
++                                </property>
++                            </column>
++                            <column>
++                                <property name="text">
++                                    <string>Location</string>
++                                </property>
++                                <property name="clickable">
++                                    <bool>true</bool>
++                                </property>
++                                <property name="resizable">
++                                    <bool>true</bool>
++                                </property>
++                            </column>
++                            <property name="name">
++                                <cstring>listView7</cstring>
++                            </property>
++                        </widget>
++                        <widget class="TQLayoutWidget">
++                            <property name="name">
++                                <cstring>layout6</cstring>
++                            </property>
++                            <hbox>
++                                <property name="name">
++                                    <cstring>unnamed</cstring>
++                                </property>
++                                <widget class="TQPushButton">
++                                    <property name="name">
++                                        <cstring>pushButton7</cstring>
++                                    </property>
++                                    <property name="text">
++                                        <string>Start</string>
++                                    </property>
++                                </widget>
++                                <spacer>
++                                    <property name="name">
++                                        <cstring>spacer2</cstring>
++                                    </property>
++                                    <property name="orientation">
++                                        <enum>Horizontal</enum>
++                                    </property>
++                                    <property name="sizeType">
++                                        <enum>Expanding</enum>
++                                    </property>
++                                    <property name="sizeHint">
++                                        <size>
++                                            <width>20</width>
++                                            <height>20</height>
++                                        </size>
++                                    </property>
++                                </spacer>
++                                <widget class="TQPushButton">
++                                    <property name="name">
++                                        <cstring>pushButton6_2</cstring>
++                                    </property>
++                                    <property name="text">
++                                        <string>Zero</string>
++                                    </property>
++                                </widget>
++                                <widget class="TQPushButton">
++                                    <property name="name">
++                                        <cstring>pushButton4</cstring>
++                                    </property>
++                                    <property name="text">
++                                        <string>Dump</string>
++                                    </property>
++                                </widget>
++                            </hbox>
++                        </widget>
++                    </vbox>
++                </widget>
++                <widget class="TQWidget">
++                    <property name="name">
++                        <cstring>tab</cstring>
++                    </property>
++                    <attribute name="title">
++                        <string>Messages</string>
++                    </attribute>
++                    <vbox>
++                        <property name="name">
++                            <cstring>unnamed</cstring>
++                        </property>
++                        <widget class="TQTextEdit">
++                            <property name="name">
++                                <cstring>textEdit2_2</cstring>
++                            </property>
++                        </widget>
++                        <widget class="TQLayoutWidget">
++                            <property name="name">
++                                <cstring>layout6</cstring>
++                            </property>
++                            <hbox>
++                                <property name="name">
++                                    <cstring>unnamed</cstring>
++                                </property>
++                                <widget class="TQPushButton">
++                                    <property name="name">
++                                        <cstring>pushButton9</cstring>
++                                    </property>
++                                    <property name="text">
++                                        <string>Kill Run</string>
++                                    </property>
++                                </widget>
++                                <spacer>
++                                    <property name="name">
++                                        <cstring>spacer4</cstring>
++                                    </property>
++                                    <property name="orientation">
++                                        <enum>Horizontal</enum>
++                                    </property>
++                                    <property name="sizeType">
++                                        <enum>Expanding</enum>
++                                    </property>
++                                    <property name="sizeHint">
++                                        <size>
++                                            <width>21</width>
++                                            <height>20</height>
++                                        </size>
++                                    </property>
++                                </spacer>
++                                <widget class="TQPushButton">
++                                    <property name="name">
++                                        <cstring>pushButton8</cstring>
++                                    </property>
++                                    <property name="text">
++                                        <string>Clear</string>
++                                    </property>
++                                </widget>
++                            </hbox>
++                        </widget>
++                    </vbox>
++                </widget>
++            </widget>
++        </widget>
++    </vbox>
++</widget>
++<layoutdefaults spacing="6" margin="11"/>
++</UI>
+diff --git a/kdecachegrind/kdecachegrind/fixcost.cpp b/kdecachegrind/kdecachegrind/fixcost.cpp
+new file mode 100644
+index 0000000..4102926
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/fixcost.cpp
+@@ -0,0 +1,174 @@
++/*
++ * Part of KCacheGrind
++ *
++ * 2003, Josef Weidendorfer
++ */
++
++#include "fixcost.h"
++#include "utils.h"
++
++
++// FixCost
++
++FixCost::FixCost(TracePart* part, FixPool* pool,
++		 TraceFunctionSource* functionSource,
++		 PositionSpec& pos,
++                 TracePartFunction* partFunction,
++		 FixString& s)
++{
++    int maxCount = part->fixSubMapping()->count();
++
++    _part = part;
++    _functionSource = functionSource;
++    _pos = pos;
++
++    _cost = (SubCost*) pool->reserve(sizeof(SubCost) * maxCount);
++    s.stripSpaces();
++    int i = 0;
++    while(i<maxCount) {
++	if (!s.stripUInt64(_cost[i])) break;
++	i++;
++    }
++    _count = i;
++
++    if (!pool->allocateReserved(sizeof(SubCost) * _count))
++	_count = 0;
++
++    _nextCostOfPartFunction = partFunction ?
++	partFunction->setFirstFixCost(this) : 0;
++}
++
++void* FixCost::operator new(size_t size, FixPool* pool)
++{
++    return pool->allocate(size);
++}
++
++void FixCost::addTo(TraceCost* c)
++{
++    TraceSubMapping* sm = _part->fixSubMapping();
++
++    int i, realIndex;
++
++    for(i=0; i<_count; i++) {
++	realIndex = sm->realIndex(i);
++	c->addCost(realIndex, _cost[i]);
++    }
++}
++
++
++
++// FixCallCost
++
++FixCallCost::FixCallCost(TracePart* part, FixPool* pool,
++			 TraceFunctionSource* functionSource,
++                         unsigned int line, Addr addr,
++                         TracePartCall* partCall,
++                         SubCost callCount, FixString& s)
++{
++  if (0) qDebug("Got FixCallCost (addr 0x%s, line %d): calls %s",
++                addr.toString().ascii(), line,
++		callCount.pretty().ascii());
++
++  int maxCount = part->fixSubMapping()->count();
++
++    _part = part;
++    _functionSource = functionSource;
++    _line = line;
++    _addr = addr;
++
++    _cost = (SubCost*) pool->reserve(sizeof(SubCost) * (maxCount+1));
++    s.stripSpaces();
++    int i = 0;
++    while(i<maxCount) {
++	if (!s.stripUInt64(_cost[i])) break;
++	i++;
++    }
++    _count = i;
++
++    if (!pool->allocateReserved(sizeof(SubCost) * (_count+1) ))
++      _count = 0;
++    else
++      _cost[_count] = callCount;
++
++    _nextCostOfPartCall = partCall ? partCall->setFirstFixCallCost(this) : 0;
++}
++
++void* FixCallCost::operator new(size_t size, FixPool* pool)
++{
++    return pool->allocate(size);
++}
++
++void FixCallCost::addTo(TraceCallCost* c)
++{
++    TraceSubMapping* sm = _part->fixSubMapping();
++
++    int i, realIndex;
++
++    for(i=0; i<_count; i++) {
++	realIndex = sm->realIndex(i);
++	c->addCost(realIndex, _cost[i]);
++    }
++    c->addCallCount(_cost[_count]);
++
++    if (0) qDebug("Adding from (addr 0x%s, ln %d): calls %s",
++                  _addr.toString().ascii(), _line,
++		  _cost[_count].pretty().ascii());
++}
++
++void FixCallCost::setMax(TraceCost* c)
++{
++    TraceSubMapping* sm = _part->fixSubMapping();
++
++    int i, realIndex;
++
++    for(i=0; i<_count; i++) {
++	realIndex = sm->realIndex(i);
++	c->maxCost(realIndex, _cost[i]);
++    }
++}
++
++
++// FixJump
++
++FixJump::FixJump(TracePart* part, FixPool* pool,
++		 unsigned int line, Addr addr,
++		 TracePartFunction* partFunction,
++		 TraceFunctionSource* source,
++		 unsigned int targetLine, Addr targetAddr,
++		 TraceFunction* targetFunction,
++		 TraceFunctionSource* targetSource,
++		 bool isCondJump,
++		 SubCost executed, SubCost followed)
++{
++    _part   = part;
++    _source = source;
++    _line   = line;
++    _addr   = addr;
++
++    _targetFunction = targetFunction;
++    _targetSource   = targetSource;
++    _targetLine     = targetLine;
++    _targetAddr     = targetAddr;
++    
++    _isCondJump = isCondJump;
++
++    int size = (isCondJump ? 2 : 1) * sizeof(SubCost);
++    _cost = (SubCost*) pool->allocate(size);
++    _cost[0] = executed;
++    if (isCondJump) _cost[1] = followed;
++
++    _nextJumpOfPartFunction = partFunction ?
++	partFunction->setFirstFixJump(this) : 0;
++}
++
++void* FixJump::operator new(size_t size, FixPool* pool)
++{
++    return pool->allocate(size);
++}
++
++void FixJump::addTo(TraceJumpCost* jc)
++{
++    jc->addExecutedCount(_cost[0]);
++    if (_isCondJump) 
++	jc->addFollowedCount(_cost[1]);
++}
+diff --git a/kdecachegrind/kdecachegrind/fixcost.h b/kdecachegrind/kdecachegrind/fixcost.h
+new file mode 100644
+index 0000000..7e90fb4
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/fixcost.h
+@@ -0,0 +1,171 @@
++/*
++ * Part of KCacheGrind
++ *
++ * 2003, Josef Weidendorfer
++ */
++
++#ifndef FIXCOST_H
++#define FIXCOST_H
++
++/**
++ * Setting USE_FIXCOST to 1 enables a memory space hack:
++ * For some data, build up internal data model lazy by using
++ * the Fix*Cost classes, which are simple copies from input data.
++ */
++#define USE_FIXCOST 1
++
++#include "tracedata.h"
++#include "pool.h"
++
++class PositionSpec
++{
++ public:
++  PositionSpec()
++    { fromLine = 0, toLine = 0, fromAddr = 0, toAddr = 0; }
++  PositionSpec(uint l1, uint l2, Addr a1, Addr a2)
++    { fromLine = l1, toLine = l2, fromAddr = a1, toAddr = a2; }
++
++  bool isLineRegion() const { return (fromLine != toLine); }
++  bool isAddrRegion() const { return (fromAddr != toAddr); }
++
++  uint fromLine, toLine;
++  Addr fromAddr, toAddr;
++};
++
++/**
++ * A class holding an unchangable cost item of an input file.
++ *
++ * As there can be a lot of such cost items, we use our own
++ * allocator which uses FixPool
++ */
++class FixCost
++{
++
++ public:
++    FixCost(TracePart*, FixPool*,
++	    TraceFunctionSource*,
++	    PositionSpec&,
++            TracePartFunction*,
++	    FixString&);
++
++    void *operator new(size_t size, FixPool*);
++
++    void addTo(TraceCost*);
++
++    TracePart* part() const { return _part; }
++    bool isLineRegion() const { return _pos.isLineRegion(); }
++    bool isAddrRegion() const { return _pos.isAddrRegion(); }
++    uint fromLine() const { return _pos.fromLine; }
++    uint line() const { return _pos.fromLine; }
++    uint toLine() const { return _pos.toLine; }
++    Addr fromAddr() const { return _pos.fromAddr; }
++    Addr addr() const { return _pos.fromAddr; }
++    Addr toAddr() const { return _pos.toAddr; }
++    TraceFunctionSource* functionSource() const { return _functionSource; }
++
++    FixCost* nextCostOfPartFunction() const
++	{ return _nextCostOfPartFunction; }
++
++ private:
++    int _count;
++    SubCost*  _cost;
++    PositionSpec _pos;
++
++    TracePart* _part;
++    TraceFunctionSource* _functionSource;
++    FixCost *_nextCostOfPartFunction;
++};
++
++/**
++ * A FixCallCost will be inserted into a
++ * - TracePartCall to keep source/target function info
++ * - TraceFunctionSourceFile to keep file info of call source
++ */
++class FixCallCost
++{
++
++ public:
++    FixCallCost(TracePart*, FixPool*,
++                TraceFunctionSource*,
++                unsigned int line,
++		Addr addr,
++                TracePartCall*,
++                SubCost, FixString&);
++
++    void *operator new(size_t size, FixPool*);
++
++    void addTo(TraceCallCost*);
++    void setMax(TraceCost*);
++
++    TracePart* part() const { return _part; }
++    unsigned int line() const { return _line; }
++    Addr addr() const { return _addr; }
++    SubCost callCount() const { return _cost[_count]; }
++    TraceFunctionSource* functionSource() const	{ return _functionSource; }
++    FixCallCost* nextCostOfPartCall() const
++	{ return _nextCostOfPartCall; }
++
++ private:
++    // we use 1 SubCost more than _count: _cost[_count] is the call count
++    int _count;
++    SubCost*  _cost;
++    unsigned int _line;
++    Addr _addr;
++
++    TracePart* _part;
++    TraceFunctionSource* _functionSource;
++    FixCallCost* _nextCostOfPartCall;
++};
++
++/**
++ * A class holding a jump (mostly) inside of a function
++ */
++class FixJump
++{
++
++ public:
++    FixJump(TracePart*, FixPool*,
++	    /* source position */
++	    unsigned int line, Addr addr,
++	    TracePartFunction*, TraceFunctionSource*,
++	    /* target position */
++	    unsigned int targetLine, Addr targetAddr,
++	    TraceFunction*, TraceFunctionSource*,
++	    bool isCondJump,
++	    SubCost, SubCost);
++
++    void *operator new(size_t size, FixPool*);
++
++    void addTo(TraceJumpCost*);
++
++    TracePart* part() const { return _part; }
++    unsigned int line() const { return _line; }
++    Addr addr() const { return _addr; }
++    TraceFunctionSource* source() const { return _source; }
++    TraceFunction* targetFunction() const { return _targetFunction; }
++    unsigned int targetLine() const { return _targetLine; }
++    Addr targetAddr() const { return _targetAddr; }
++    TraceFunctionSource* targetSource() const { return _targetSource; }
++    bool isCondJump() { return _isCondJump; }
++    SubCost executedCount() const { return _cost[0]; }
++    SubCost followedCount() const
++	{ return _isCondJump ? _cost[1] : SubCost(0); }
++
++    FixJump* nextJumpOfPartFunction() const
++	{ return _nextJumpOfPartFunction; }
++
++ private:
++    bool _isCondJump;
++    SubCost*  _cost;
++    unsigned int _line, _targetLine;
++    Addr _addr, _targetAddr;
++    
++    TracePart* _part;
++    TraceFunctionSource *_source, *_targetSource;
++    TraceFunction* _targetFunction;
++    FixJump *_nextJumpOfPartFunction;
++};
++
++#endif
++
++
+diff --git a/kdecachegrind/kdecachegrind/functionitem.cpp b/kdecachegrind/kdecachegrind/functionitem.cpp
+new file mode 100644
+index 0000000..3b694dd
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/functionitem.cpp
+@@ -0,0 +1,236 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * List Item for the FunctionSelection list
++ */
++
++
++//#include <math.h>
++
++//#include <tqpainter.h>
++//#include <tqregexp.h>
++
++#include <klocale.h>
++#include <kiconloader.h>
++#include <kapplication.h>
++
++#include "listutils.h"
++#include "functionitem.h"
++#include "configuration.h"
++
++
++// FunctionItem
++
++FunctionItem::FunctionItem(TQListView* parent, TraceFunction* f,
++                           TraceCostType* ct, TraceCost::CostType gt)
++  :TQListViewItem(parent)
++{
++#if 0
++    _costPixValid = false;
++    _groupPixValid = false;
++#endif
++
++    _function = f;
++    _skipped = 0;
++    _groupType = TraceCost::NoCostType;
++    setGroupType(gt);
++    setCostType(ct);
++
++    setText(3, f->prettyName());
++    setText(4, f->prettyLocation());
++}
++
++FunctionItem::FunctionItem(TQListView* parent, int skipped,
++			   TraceFunction* f, TraceCostType* ct)
++  :TQListViewItem(parent)
++{
++#if 0
++    _costPixValid = false;
++    _groupPixValid = false;
++#endif
++    _skipped = skipped;
++    _function = f;
++    _groupType = TraceCost::NoCostType;
++    setCostType(ct);
++
++    setText(3, i18n("(%n function skipped)", "(%n functions skipped)", skipped));
++}
++
++#if 0
++const TQPixmap* FunctionItem::pixmap(int column) const
++{
++    if (column == 3) {
++	if (!_groupPixValid) {
++	    TQColor c = Configuration::functionColor(_groupType, _function);
++	    _groupPix = colorPixmap(10, 10, c);
++	    _groupPixValid = true;
++	}
++	return &_groupPix;
++    }
++    if (column == 1) {
++	if (!_costPixValid) {
++	    _costPix = colorPixmap(10, 10, c);
++	    _costPixValid = true;
++	}
++	return &_costPix;
++    }
++    return 0;
++}
++#endif
++
++void  FunctionItem::setGroupType(TraceCost::CostType gt)
++{
++  if (_skipped) return;
++  if (_groupType == gt) return;
++  _groupType = gt;
++
++
++#if 0
++  _groupPixValid = false;
++  viewList()->repaint();
++#else
++  TQColor c = Configuration::functionColor(_groupType, _function);
++  setPixmap(3, colorPixmap(10, 10, c));
++#endif
++}
++
++void FunctionItem::setCostType(TraceCostType* c)
++{
++  _costType = c;
++  update();
++}
++
++void FunctionItem::update()
++{
++  double inclTotal = _function->data()->subCost(_costType);
++  TQString str;
++
++  TraceCost* selfCost = _function->data();
++  if (Configuration::showExpanded()) {
++      switch(_groupType) {
++      case TraceCost::Object: selfCost = _function->object(); break;
++      case TraceCost::Class:  selfCost = _function->cls(); break;
++      case TraceCost::File:   selfCost = _function->file(); break;
++      default: break;
++      }
++  }
++  double selfTotal = selfCost->subCost(_costType);
++
++  if (_skipped) {
++    // special handling for skip entries...
++
++    // only text updates of incl./self
++
++    // for all skipped functions, cost is below the given function
++    _sum  = _function->inclusive()->subCost(_costType);
++    double incl  = 100.0 * _sum / inclTotal;
++    if (Configuration::showPercentage())
++      str = TQString("%1").arg(incl, 0, 'f', Configuration::percentPrecision());
++    else
++      str = _function->inclusive()->prettySubCost(_costType);
++    str = "< " + str;
++    setText(0, str);
++    setText(1, str);
++    return;
++  }
++
++  // Call count...
++  if (_function->calledCount() >0)
++    str = _function->prettyCalledCount();
++  else {
++    if (_function == _function->cycle())
++      str = TQString("-");
++    else
++      str = TQString("(0)");
++  }
++  setText(2, str);
++
++  // Incl. cost
++  _sum  = _function->inclusive()->subCost(_costType);
++  if (inclTotal == 0.0) {
++    setPixmap(0, TQPixmap());
++    setText(0, "-");
++  }
++  else {
++      double incl  = 100.0 * _sum / inclTotal;
++      if (Configuration::showPercentage())
++	  setText(0, TQString("%1")
++		  .arg(incl, 0, 'f', Configuration::percentPrecision()));
++      else
++	  setText(0, _function->inclusive()->prettySubCost(_costType));
++
++      setPixmap(0, costPixmap(_costType, _function->inclusive(), inclTotal, false));
++  }
++
++  // self
++  _pure = _function->subCost(_costType);
++  if (selfTotal == 0.0) {
++    setPixmap(1, TQPixmap());
++    setText(1, "-");
++  }
++  else {
++      double self  = 100.0 * _pure / selfTotal;
++
++      if (Configuration::showPercentage())
++	  setText(1, TQString("%1")
++		  .arg(self, 0, 'f', Configuration::percentPrecision()));
++      else
++	  setText(1, _function->prettySubCost(_costType));
++
++      setPixmap(1, costPixmap(_costType, _function, selfTotal, false));
++  }
++}
++
++
++int FunctionItem::compare(TQListViewItem * i, int col, bool ascending ) const
++{
++  const FunctionItem* fi1 = this;
++  const FunctionItem* fi2 = (FunctionItem*) i;
++
++  // we always want descending order
++  if (ascending) {
++    fi1 = fi2;
++    fi2 = this;
++  }
++
++  // a skip entry is always sorted last
++  if (fi1->_skipped) return -1;
++  if (fi2->_skipped) return 1;
++
++  if (col==0) {
++    if (fi1->_sum < fi2->_sum) return -1;
++    if (fi1->_sum > fi2->_sum) return 1;
++    return 0;
++  }
++  if (col==1) {
++    if (fi1->_pure < fi2->_pure) return -1;
++    if (fi1->_pure > fi2->_pure) return 1;
++    return 0;
++  }
++  if (col==2) {
++    if (fi1->_function->calledCount() <
++	fi2->_function->calledCount()) return -1;
++    if (fi1->_function->calledCount() >
++	fi2->_function->calledCount()) return 1;
++    return 0;
++  }
++
++  return TQListViewItem::compare(i, col, ascending);
++}
++
+diff --git a/kdecachegrind/kdecachegrind/functionitem.h b/kdecachegrind/kdecachegrind/functionitem.h
+new file mode 100644
+index 0000000..d8f98f4
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/functionitem.h
+@@ -0,0 +1,58 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * List Item for the FunctionSelection list
++ */
++
++#ifndef FUNCTIONITEM_H
++#define FUNCTIONITEM_H
++
++#include <tqlistview.h>
++#include "tracedata.h"
++
++class FunctionItem: public TQListViewItem
++{
++public:    
++  FunctionItem(TQListView* parent, TraceFunction* function,
++	       TraceCostType* ct, TraceCost::CostType gt);
++  // constructor for a "Skipped ... " entry
++  FunctionItem(TQListView* parent, int skipped,
++	       TraceFunction* function, TraceCostType* ct);
++
++  int compare(TQListViewItem * i, int col, bool ascending ) const;
++  TraceFunction* function() { return (_skipped) ? 0 : _function; }
++  void setCostType(TraceCostType* ct);
++  void setGroupType(TraceCost::CostType);
++  void update();
++
++#if 0
++  const TQPixmap* pixmap (int column) const;
++  bool _costPixValid, _groupPixValid;
++  TQPixMap _costPix, _groupPix;
++#endif
++
++private:
++  SubCost _sum, _pure;
++  TraceCostType* _costType;
++  TraceCost::CostType _groupType;
++  TraceFunction* _function;
++  int _skipped;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/functionselection.cpp b/kdecachegrind/kdecachegrind/functionselection.cpp
+new file mode 100644
+index 0000000..c5646dd
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/functionselection.cpp
+@@ -0,0 +1,871 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * For function selection, to be put into a TQDockWindow
++ */
++
++#include <tqtimer.h>
++#include <tqlistview.h>
++#include <tqlabel.h>
++#include <tqpushbutton.h>
++#include <tqcombobox.h>
++#include <tqlineedit.h>
++#include <tqregexp.h>
++#include <tqpopupmenu.h>
++
++#include <klocale.h>
++
++#include "traceitemview.h"
++#include "stackbrowser.h"
++#include "functionselection.h"
++#include "partgraph.h"
++#include "functionitem.h"
++#include "costlistitem.h"
++#include "configuration.h"
++#include "toplevel.h"
++
++FunctionSelection::FunctionSelection( TopLevel* top,
++				      TQWidget* parent, const char* name)
++    : FunctionSelectionBase(parent, name), TraceItemView(0, top)
++{
++  _group = 0;
++  _inSetGroup = false;
++  _inSetFunction = false;
++
++  TQStringList args;
++  args << i18n("(No Grouping)")
++       << TraceCost::i18nTypeName(TraceItem::Object)
++       << TraceCost::i18nTypeName(TraceItem::File)
++       << TraceCost::i18nTypeName(TraceItem::Class)
++       << TraceCost::i18nTypeName(TraceItem::FunctionCycle);
++  
++  groupBox->insertStringList(args);
++  // this needs same order of grouptype actionlist!
++  connect(groupBox, TQT_SIGNAL(activated(int)),
++	  top, TQT_SLOT(groupTypeSelected(int)));
++
++  // search while typing...
++  connect(searchEdit, TQT_SIGNAL(textChanged(const TQString&)),
++	  this, TQT_SLOT(searchChanged(const TQString&)));
++  connect(&_searchTimer, TQT_SIGNAL(timeout()),
++	  this, TQT_SLOT(queryDelayed()));
++  // select first matching group/function on return
++  connect(searchEdit, TQT_SIGNAL(returnPressed()),
++	  this, TQT_SLOT(searchReturnPressed()));
++  searchEdit->setMinimumWidth(50);
++
++  // we start with desending cost sorting
++  functionList->setSorting(0,false);
++  functionList->setColumnAlignment(0, TQt::AlignRight);
++  functionList->setColumnAlignment(1, TQt::AlignRight);
++  functionList->setColumnAlignment(2, TQt::AlignRight);
++  functionList->setAllColumnsShowFocus(true);
++  // functionList->setShowSortIndicator(true);
++  // we can have very long function and location names
++  functionList->setColumnWidthMode(3, TQListView::Manual);
++  functionList->setColumnWidth(3, 200);
++  functionList->setColumnWidthMode(4, TQListView::Manual);
++  functionList->setColumnWidth(4, 200);
++
++  groupList->setSorting(0,false);
++  groupList->setColumnAlignment(0, TQt::AlignRight);
++  groupList->setAllColumnsShowFocus(true);
++  // groupList->setShowSortIndicator(true);
++  groupList->setResizeMode(TQListView::LastColumn);
++
++#if 0
++  // single click press activation
++  connect(functionList, TQT_SIGNAL(selectionChanged(TQListViewItem*)),
++          this, TQT_SLOT(functionActivated(TQListViewItem*)));
++  connect(functionList,
++	  TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint &, int)),
++          this, TQT_SLOT(functionContext(TQListViewItem*, const TQPoint &, int)));
++#else
++  // single click release activation
++  connect(functionList, TQT_SIGNAL(selectionChanged(TQListViewItem*)),
++          this, TQT_SLOT(functionSelected(TQListViewItem*)));
++  connect(functionList, TQT_SIGNAL(clicked(TQListViewItem*)),
++	  this, TQT_SLOT(functionActivated(TQListViewItem*)));
++  connect(functionList, TQT_SIGNAL(returnPressed(TQListViewItem*)),
++	  this, TQT_SLOT(functionActivated(TQListViewItem*)));
++  connect(functionList,
++	  TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint &, int)),
++          this, TQT_SLOT(functionContext(TQListViewItem*, const TQPoint &, int)));
++#endif
++
++  connect(groupList, TQT_SIGNAL(selectionChanged(TQListViewItem*)),
++          this, TQT_SLOT(groupSelected(TQListViewItem*)));
++  connect(groupList, TQT_SIGNAL(doubleClicked(TQListViewItem*)),
++	  this, TQT_SLOT(groupDoubleClicked(TQListViewItem*)));
++  connect(groupList, TQT_SIGNAL(returnPressed(TQListViewItem*)),
++	  this, TQT_SLOT(groupDoubleClicked(TQListViewItem*)));
++  connect(groupList,
++	  TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint &, int)),
++          this, TQT_SLOT(groupContext(TQListViewItem*, const TQPoint &, int)));
++
++  // start hidden
++  groupList->hide();
++}
++
++FunctionSelection::~FunctionSelection()
++{
++}
++
++void FunctionSelection::searchReturnPressed()
++{
++  query(searchEdit->text());
++
++  TQListViewItem* item;
++  if (_groupType != TraceItem::Function) {
++      // if current group not matching, select first matching group
++      item  = groupList->currentItem();
++      if (!item || !item->isVisible()) {
++	  item  = groupList->firstChild();
++	  for (;item;item = item->nextSibling())
++	      if (item->isVisible()) break;
++	  if (!item) return;
++
++	  setGroup(((CostListItem*)item)->costItem());
++	  return;
++      }
++  }
++
++  functionActivated(functionList->firstChild());
++}
++
++// trigger the query after some delay, dependent on length
++void FunctionSelection::searchChanged(const TQString& q)
++{
++  _searchDelayed = q;
++  int ms = 100;
++  if (q.length()<5) ms = 200;
++  if (q.length()<2) ms = 300;
++  _searchTimer.start(ms,true);
++}
++
++void FunctionSelection::queryDelayed()
++{
++  query(_searchDelayed);
++}
++
++void FunctionSelection::functionContext(TQListViewItem* i,
++					const TQPoint & p, int c)
++{
++  TQPopupMenu popup;
++  TraceFunction* f = 0;
++
++  if (i) {
++      f = ((FunctionItem*) i)->function();
++      if (f) {
++	  popup.insertItem(i18n("Go to %1").arg(f->prettyName()), 93);
++	  popup.insertSeparator();
++      }
++  }
++
++  if ((c == 0) || (c == 1)) {
++    addCostMenu(&popup,false);
++    popup.insertSeparator();
++  }
++  addGroupMenu(&popup);  
++  popup.insertSeparator();
++  addGoMenu(&popup);
++
++  int r = popup.exec(p);
++  if (r == 93) activated(f);
++}
++
++void FunctionSelection::groupContext(TQListViewItem* /*i*/,
++				     const TQPoint & p, int c)
++{
++  TQPopupMenu popup;
++
++#if 0
++  TraceCostItem* g = 0;
++  if (i) {
++      g = ((CostListItem*) i)->costItem();
++      if (!g) {
++	popup.insertItem(i18n("Show All Items"), 93);
++	popup.insertSeparator();
++      }
++  }
++#endif
++  if (c == 0) {
++    addCostMenu(&popup,false);
++    popup.insertSeparator();
++  }
++  addGroupMenu(&popup);  
++  popup.insertSeparator();
++  addGoMenu(&popup);
++
++  popup.exec(p);
++}
++
++
++void FunctionSelection::addGroupMenu(TQPopupMenu* popup)
++{
++  TQPopupMenu *popup1 = new TQPopupMenu(popup);
++  popup1->setCheckable(true);
++
++  if (_groupType != TraceItem::Function) {
++    popup1->insertItem(i18n("No Grouping"),0);
++    popup1->insertSeparator();
++  }
++  popup1->insertItem(TraceCost::i18nTypeName(TraceItem::Object),1);
++  popup1->insertItem(TraceCost::i18nTypeName(TraceItem::File),2);
++  popup1->insertItem(TraceCost::i18nTypeName(TraceItem::Class),3);
++  popup1->insertItem(TraceCost::i18nTypeName(TraceItem::FunctionCycle),4);
++  switch(_groupType) {
++  case TraceItem::Object:        popup1->setItemChecked(1, true); break;
++  case TraceItem::File:          popup1->setItemChecked(2, true); break;
++  case TraceItem::Class:         popup1->setItemChecked(3, true); break;
++  case TraceItem::FunctionCycle: popup1->setItemChecked(4, true); break;
++  default: break;
++  }
++  connect(popup1,TQT_SIGNAL(activated(int)),
++	  _topLevel,TQT_SLOT(groupTypeSelected(int)));
++
++  popup->insertItem(i18n("Grouping"), popup1);
++}    
++
++
++TraceItem* FunctionSelection::canShow(TraceItem* i)
++{
++    TraceItem::CostType t = i ? i->type() : TraceItem::NoCostType;
++
++    switch(t) {
++    case TraceItem::Function:
++    case TraceItem::FunctionCycle:
++    case TraceItem::Object:
++    case TraceItem::File:
++    case TraceItem::Class:
++	break;
++
++    case TraceItem::Instr:
++	i = ((TraceInstr*)i)->function();
++	break;
++
++    case TraceItem::Line:
++	i = ((TraceLine*)i)->functionSource()->function();
++	break;
++
++    default:
++	i = 0;
++	break;
++  }
++  return i;
++}
++
++
++void FunctionSelection::doUpdate(int changeType)
++{
++    // Special case ?
++    if (changeType == selectedItemChanged) return;
++
++    // we don't show cost 2 at all...
++    if (changeType == costType2Changed) return;
++
++    if (changeType == activeItemChanged) {
++	if (_activeItem ==0) {
++	    functionList->clearSelection();
++	    return;
++	}
++	switch(_activeItem->type()) {
++	case TraceItem::Object:
++	case TraceItem::File:
++	case TraceItem::Class:
++	    setGroup((TraceCostItem*)_activeItem);
++	    return;
++	default: break;
++	}
++
++	// active item is a function
++	TraceFunction* f = (TraceFunction*) _activeItem;
++
++	// if already current, nothing to do
++	TQListViewItem* i = functionList->currentItem();
++	if (i && (((FunctionItem*)i)->function() == f)) {
++	    functionList->setSelected(i,true);
++	    return;	    
++	}
++
++	// reset searchEdit (as not activated from this view)
++	_searchString = TQString();
++	query(TQString());
++
++	// select cost item group of function
++	switch(_groupType) {
++	case TraceItem::Object: setGroup(f->object()); break;
++	case TraceItem::Class:  setGroup(f->cls()); break;
++	case TraceItem::File:   setGroup(f->file());  break;
++	case TraceItem::FunctionCycle: setGroup(f->cycle());  break;
++	default:
++	    break;
++	}
++
++	TQListViewItem* item  = functionList->firstChild();
++	for (;item;item = item->nextSibling())
++	    if (((FunctionItem*)item)->function() == f)
++		break;
++
++	if (!item)
++	    item = new FunctionItem(functionList, f, _costType, _groupType);
++
++	functionList->ensureItemVisible(item);
++	// prohibit signalling of a function selection
++	_inSetFunction = true;
++	functionList->setSelected(item, true);
++	_inSetFunction = false;
++
++	return;
++    }
++
++    if (changeType & groupTypeChanged) {
++	if (_activeItem && (_activeItem->type() == TraceItem::Function)) {
++	    TraceFunction* f = (TraceFunction*) _activeItem;
++
++	    // select cost item group of function
++	    switch(_groupType) {
++	    case TraceItem::Object: _group = f->object(); break;
++	    case TraceItem::Class:  _group = f->cls(); break;
++	    case TraceItem::File:   _group = f->file();  break;
++	    case TraceItem::FunctionCycle: _group = f->cycle();  break;
++	    default:
++		_group = 0;
++		break;
++	    }
++	}
++
++	int id;
++	switch(_groupType) {
++	case TraceItem::Object: id = 1; break;
++	case TraceItem::File:   id = 2; break;
++	case TraceItem::Class:  id = 3; break;
++	case TraceItem::FunctionCycle: id = 4; break;
++	default: id = 0; break;
++	}
++	groupBox->setCurrentItem(id);
++
++	if (_groupType == TraceItem::Function)
++	    groupList->hide();
++	else
++	    groupList->show();
++    }
++
++    // reset searchEdit
++    _searchString = TQString();
++    query(TQString());
++
++    refresh();
++}
++
++
++/*
++ * This set/selects a group of the set available within the
++ * current group type
++ */
++void FunctionSelection::setGroup(TraceCostItem* g)
++{
++  if (!g) return;
++  if (g->type() != _groupType) return;
++  if (g == _group) return;
++  _group = g;
++
++  TQListViewItem* item  = groupList->firstChild();
++  for (;item;item = item->nextSibling())
++    if (((CostListItem*)item)->costItem() == g)
++      break;
++
++  if (item) {
++    groupList->ensureItemVisible(item);
++    // prohibit signalling of a group selection
++    _inSetGroup = true;
++    groupList->setSelected(item, true);
++    _inSetGroup = false;
++  }
++  else
++    groupList->clearSelection();
++}
++
++
++void FunctionSelection::refresh()
++{
++    groupList->setUpdatesEnabled(false);
++    groupList->clear();
++
++    // make cost columns as small as possible:
++    // the new functions make them as wide as needed
++    groupList->setColumnWidth(0, 50);
++
++    groupList->setColumnText(1, TraceItem::i18nTypeName(_groupType));
++
++    if (!_data || _data->parts().count()==0) {
++	functionList->clear();
++	groupList->setUpdatesEnabled(true);
++	groupList->repaint();
++
++	// this clears all other lists
++	functionList->setSelected(functionList->firstChild(), true);
++	return;
++    }
++
++  /*
++  qDebug("FunctionSelection::fillLists (%s)",
++         _data->command().ascii());
++  */
++
++  TraceObjectMap::Iterator oit;
++  TraceClassMap::Iterator cit;
++  TraceFileMap::Iterator fit;
++  TQListViewItem *i = 0, *item = 0, *fitem = 0;
++
++  // Fill up group list.
++  // Always show group of current function, even if cost below low limit.
++  //
++
++  _hc.clear(Configuration::maxListCount());
++
++  TraceCostItem *group;
++
++  // update group from _activeItem if possible
++  if (_activeItem && (_activeItem->type() == _groupType))
++    _group = (TraceCostItem*) _activeItem;
++
++  switch(_groupType) {
++  case TraceItem::Object:
++
++    for ( oit = _data->objectMap().begin();
++          oit != _data->objectMap().end(); ++oit )
++      _hc.addCost(&(*oit), (*oit).subCost(_costType));
++    break;
++
++  case TraceItem::Class:
++
++    for ( cit = _data->classMap().begin();
++          cit != _data->classMap().end(); ++cit )
++      _hc.addCost(&(*cit), (*cit).subCost(_costType));
++    break;
++
++  case TraceItem::File:
++
++    for ( fit = _data->fileMap().begin();
++          fit != _data->fileMap().end(); ++fit )
++      _hc.addCost(&(*fit), (*fit).subCost(_costType));
++    break;
++
++  case TraceItem::FunctionCycle:
++    {
++      // add all cycles
++      TraceFunctionCycleList l =  _data->functionCycles();
++      for (group=l.first();group;group=l.next())
++	_hc.addCost(group, group->subCost(_costType));
++    }
++
++  break;
++
++  default:
++    {
++      TQListViewItem* oldItem = functionList->selectedItem();
++      TraceFunction* oldFunction = 0;
++      int oldPos = 0;
++      if (oldItem) {
++	oldFunction = ((FunctionItem*)oldItem)->function();
++	oldPos = oldItem->itemPos();
++	oldPos -= functionList->contentsY();
++	if (oldPos < 0 || oldPos > functionList->height())
++	  oldFunction = 0;
++      }
++
++      // switching off TQListView updates is buggy with some QT versions...
++      //functionList->setUpdatesEnabled(false);
++      functionList->clear();
++      setCostColumnWidths();
++
++      if (0) qDebug("Function %s at %d, Item %p",
++		    oldFunction ? oldFunction->name().ascii() : "-",
++		    oldPos, (void*)oldItem);
++
++      TraceFunctionMap::Iterator it;
++      TraceFunction *f;
++      i = 0;
++      fitem = 0;
++      for ( it = _data->functionMap().begin();
++	    it != _data->functionMap().end(); ++it )
++	_hc.addCost(&(*it), (*it).inclusive()->subCost(_costType));
++
++      TraceFunctionCycleList l =  _data->functionCycles();
++      for (f=l.first();f;f=l.next())
++	_hc.addCost(f, f->inclusive()->subCost(_costType));
++
++      if (_activeItem &&
++	  ((_activeItem->type() == TraceItem::Function) ||
++	   (_activeItem->type() == TraceItem::FunctionCycle)))
++	fitem = new FunctionItem(functionList, (TraceFunction*)_activeItem,
++				 _costType, _groupType);
++
++      for(int i=0;i<_hc.realCount();i++) {
++	f = (TraceFunction*)_hc[i];
++	if (f == _activeItem) continue;
++	new FunctionItem(functionList, f, _costType, _groupType);
++      }
++      if (_hc.hasMore()) {
++	// a placeholder for all the cost items skipped ...
++	new FunctionItem(functionList, _hc.count() - _hc.maxSize(),
++			 (TraceFunction*)_hc[_hc.maxSize()-1], _costType);
++      }
++      functionList->sort();
++
++      if (fitem && oldFunction) {
++        _inSetFunction = true;
++	functionList->setSelected(fitem, true);
++        _inSetFunction = false;
++	int newPos = functionList->itemPos(fitem) - functionList->contentsY();
++	functionList->scrollBy(0, newPos-oldPos);
++      }
++      else if (fitem) {
++	functionList->ensureItemVisible(fitem);
++        _inSetFunction = true;
++	functionList->setSelected(fitem, true);
++        _inSetFunction = false;
++      }
++      else
++	functionList->clearSelection();
++
++      //functionList->setUpdatesEnabled(true);
++      //functionList->repaint();
++      groupList->setUpdatesEnabled(true);
++      groupList->repaint();
++      return;
++    }
++  }
++
++  // we always put group of active item in list, even if
++  // it would be skipped because of small costs
++  if (_group)
++    item = new CostListItem(groupList, _group, _costType);
++
++  for(int i=0;i<_hc.realCount();i++) {
++    group = (TraceCostItem*)_hc[i];
++    // don't put group of active item twice into list
++    if (group == _group) continue;
++    new CostListItem(groupList, group, _costType);
++  }
++  if (_hc.hasMore()) {
++      // a placeholder for all the cost items skipped ...
++    new CostListItem(groupList, _hc.count() - _hc.maxSize(),
++		     (TraceCostItem*)_hc[_hc.maxSize()-1], _costType);
++  }
++  groupList->sort();
++  if (item) {
++    groupList->ensureItemVisible(item);
++    _inSetGroup = true;
++    groupList->setSelected(item, true);
++    _inSetGroup = false;
++  }
++  else
++    groupList->clearSelection();
++
++  groupList->setUpdatesEnabled(true);
++  groupList->repaint();
++}
++
++
++void FunctionSelection::groupSelected(TQListViewItem* i)
++{
++  if (!i) return;
++  if (!_data) return;
++
++  TraceCostItem* g = ((CostListItem*) i)->costItem();
++  if (!g) return;
++
++  _group = g;
++
++  TraceFunctionList list;
++
++  switch(g->type()) {
++  case TraceItem::Object:
++    list = ((TraceObject*)g)->functions();
++    break;
++  case TraceItem::Class:
++    list = ((TraceClass*)g)->functions();
++    break;
++  case TraceItem::File:
++    list = ((TraceFile*)g)->functions();
++    break;
++  case TraceItem::FunctionCycle:
++    list = ((TraceFunctionCycle*)g)->members();
++    break;
++  default:
++    return;
++  }
++
++  // switching off TQListView updates is buggy with some QT versions...
++  //functionList->setUpdatesEnabled(false);
++
++  functionList->clear();
++  setCostColumnWidths();
++
++  double total;
++  if (Configuration::showExpanded())
++      total = (double) g->subCost(_costType);
++  else
++      total = (double) _data->subCost(_costType);
++#if 0
++  if (total == 0.0) {
++      functionList->setUpdatesEnabled(true);
++      functionList->repaint();
++      return;
++  }
++#endif
++
++  TQRegExp re(_searchString, false, true);
++
++  FunctionItem* fitem = 0;
++  TraceFunction *f;
++  _hc.clear(Configuration::maxListCount());
++  for (f=list.first();f;f=list.next()) {
++    if (re.search(f->prettyName())<0) continue;
++
++    _hc.addCost(f, f->inclusive()->subCost(_costType));
++    if (_activeItem == f)
++      fitem = new FunctionItem(functionList, (TraceFunction*)_activeItem,
++			       _costType, _groupType);
++  }
++
++  for(int i=0;i<_hc.realCount();i++) {
++    if (_activeItem == (TraceFunction*)_hc[i]) continue;
++    new FunctionItem(functionList, (TraceFunction*)_hc[i],
++		     _costType, _groupType);
++  }
++
++  if (_hc.hasMore()) {
++    // a placeholder for all the functions skipped ...
++    new FunctionItem(functionList, _hc.count() - _hc.maxSize(),
++		     (TraceFunction*)_hc[_hc.maxSize()-1], _costType);
++  }
++  functionList->sort();
++
++  if (fitem) {
++    functionList->ensureItemVisible(fitem);
++    _inSetFunction = true;
++    functionList->setSelected(fitem, true);
++    _inSetFunction = false;
++  }
++
++  //functionList->setUpdatesEnabled(true);
++  //functionList->repaint();
++
++  // Don't emit signal if cost item was changed programatically
++  if (!_inSetGroup) {
++      _selectedItem = g;
++      selected(g);
++  }
++}
++
++void FunctionSelection::groupDoubleClicked(TQListViewItem* i)
++{
++  if (!i) return;
++  if (!_data) return;
++  TraceCostItem* g = ((CostListItem*) i)->costItem();
++
++  if (!g) return;
++  // group must be selected first
++  if (g != _group) return;
++
++  activated(g);
++}
++
++
++TraceCostItem* FunctionSelection::group(TQString s)
++{
++  TQListViewItem *item;
++  item  = groupList->firstChild();
++  for(;item;item = item->nextSibling())
++    if (((CostListItem*)item)->costItem()->name() == s)
++      return ((CostListItem*)item)->costItem();
++
++  return 0;
++}
++
++
++
++void FunctionSelection::functionSelected(TQListViewItem* i)
++{
++  if (!i) return;
++  if (!_data) return;
++
++  TraceFunction* f = ((FunctionItem*) i)->function();
++  if (!f) return;
++
++  //qDebug("FunctionSelection::functionSelected %s", f->name().ascii());
++
++  // Don't emit signal if function was changed programatically
++  if (!_inSetFunction) {
++      _selectedItem = f;
++      selected(f);
++  }
++}
++
++void FunctionSelection::functionActivated(TQListViewItem* i)
++{
++  if (!i) return;
++  if (!_data) return;
++  TraceFunction* f = ((FunctionItem*) i)->function();
++
++  if (!f) return;
++
++  if (!_inSetFunction)
++    activated(f);
++}
++
++void FunctionSelection::updateGroupSizes(bool hideEmpty)
++{
++  TQListViewItem* item  = groupList->firstChild();
++  for (;item;item = item->nextSibling()) {
++    CostListItem* i = (CostListItem*)item;
++    int size = (_groupSize.contains(i->costItem())) ?
++	_groupSize[i->costItem()] : -1;    
++    i->setSize(size);
++    i->setVisible(!hideEmpty || (size>0));
++  }
++}
++
++void FunctionSelection::query(TQString query)
++{
++  if (searchEdit->text() != query)
++    searchEdit->setText(query);
++  if (_searchString == query) {
++    // when resetting query, get rid of group sizes
++    if (query.isEmpty()) {
++      _groupSize.clear();
++      updateGroupSizes(false);
++    }
++    return;
++  }
++  _searchString = query;
++
++  TQRegExp re(query, false, true);
++  _groupSize.clear();
++
++  TraceFunction* f = 0;
++  TraceFunctionList list2;
++
++  _hc.clear(Configuration::maxListCount());
++
++  TraceFunctionMap::Iterator it;
++  for ( it = _data->functionMap().begin();
++	it != _data->functionMap().end(); ++it ) {
++    f = &(*it);
++    if (re.search(f->prettyName())>=0) {
++      if (_group) {
++	if (_groupType==TraceItem::Object) {
++	  if (_groupSize.contains(f->object()))
++	    _groupSize[f->object()]++;
++	  else
++	    _groupSize[f->object()] = 1;
++	  if (f->object() != _group) continue;
++	}
++	else if (_groupType==TraceItem::Class) {
++	  if (_groupSize.contains(f->cls()))
++	    _groupSize[f->cls()]++;
++	  else
++	    _groupSize[f->cls()] = 1;
++	  if (f->cls() != _group) continue;
++	}
++	else if (_groupType==TraceItem::File) {
++	  if (_groupSize.contains(f->file()))
++	    _groupSize[f->file()]++;
++	  else
++	    _groupSize[f->file()] = 1;
++	  if (f->file() != _group) continue;
++	}
++	else if (_groupType==TraceItem::FunctionCycle) {
++	  if (_groupSize.contains(f->cycle()))
++	    _groupSize[f->cycle()]++;
++	  else
++	    _groupSize[f->cycle()] = 1;
++	  if (f->cycle() != _group) continue;
++	}
++      }
++      _hc.addCost(f, f->inclusive()->subCost(_costType));
++    }
++  }
++
++  updateGroupSizes(true);
++
++  FunctionItem *fi, *item = 0;
++
++  functionList->clear();
++  setCostColumnWidths();
++
++  for(int i=0;i<_hc.realCount();i++) {
++      fi = new FunctionItem(functionList, (TraceFunction*)_hc[i],
++			    _costType, _groupType);
++      if (_activeItem == f) item = fi;
++  }
++  if (_hc.hasMore()) {
++      // a placeholder for all the functions skipped ...
++      new FunctionItem(functionList, _hc.count() - _hc.maxSize(),
++		       (TraceFunction*)_hc[_hc.maxSize()-1], _costType);
++  }
++
++  functionList->sort();
++
++
++  if (item) {
++    functionList->ensureItemVisible(item);
++    _inSetFunction = true;
++    functionList->setSelected(item, true);
++    _inSetFunction = false;
++  }
++  else {
++    // this emits a function selection
++    functionList->setSelected(functionList->firstChild(), true);
++  }
++}
++
++bool FunctionSelection::setTopFunction()
++{
++  TQListViewItem* i = functionList->firstChild();
++  // this emits a function selection
++  functionList->setSelected(i, true);
++  functionActivated(i);
++  return i!=0;
++}
++
++void FunctionSelection::setCostColumnWidths()
++{
++  if (_costType && (_costType->subCost(_data->callMax())>0) ) {
++    functionList->setColumnWidthMode(0, TQListView::Maximum);
++    functionList->setColumnWidth(0,50);
++    functionList->setColumnWidthMode(2, TQListView::Maximum);
++    functionList->setColumnWidth(2,50);
++  }
++  else {
++    functionList->setColumnWidthMode(0, TQListView::Manual);
++    functionList->setColumnWidth(0,0);
++    functionList->setColumnWidthMode(2, TQListView::Manual);
++    functionList->setColumnWidth(2,0);
++  }
++
++  functionList->setColumnWidth(1, 50);
++}
++
++
++
++#include "functionselection.moc"
+diff --git a/kdecachegrind/kdecachegrind/functionselection.h b/kdecachegrind/kdecachegrind/functionselection.h
+new file mode 100644
+index 0000000..c5f7810
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/functionselection.h
+@@ -0,0 +1,86 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * For function selection, to be put into a TQDockWindow
++ */
++
++#ifndef FUNCTIONSELECTION_H
++#define FUNCTIONSELECTION_H
++
++#include "functionselectionbase.h"
++#include "traceitemview.h"
++#include "tracedata.h"
++#include "listutils.h"
++
++class TQPopupMenu;
++
++class TraceFunction;
++class TraceData;
++class StackBrowser;
++class NestedAreaItem;
++
++class FunctionSelection : public FunctionSelectionBase, public TraceItemView
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  FunctionSelection( TopLevel*, TQWidget* parent = 0, const char* name = 0);
++  ~FunctionSelection();
++
++  TraceCostItem* group(TQString);
++  void setGroup(TraceCostItem*);
++  void query(TQString);
++  bool setTopFunction();
++
++  TQWidget* widget() { return this; }
++
++  void addGroupMenu(TQPopupMenu*);
++
++public slots:
++  void searchReturnPressed();
++  void searchChanged(const TQString&);
++  void queryDelayed();
++  void groupDoubleClicked( TQListViewItem* );
++  void functionActivated( TQListViewItem* );
++  void groupSelected( TQListViewItem* );
++  void functionSelected( TQListViewItem* );
++  void functionContext(TQListViewItem*, const TQPoint &, int);
++  void groupContext(TQListViewItem*, const TQPoint &, int);
++
++private:
++  TraceItem* canShow(TraceItem* i);
++  void doUpdate(int);
++  void selectFunction();
++  void refresh();
++  void setCostColumnWidths();
++  void updateGroupSizes(bool hideEmpty);
++
++  TraceCostItem* _group;
++
++  TQString _searchString, _searchDelayed;
++  TQTimer _searchTimer;
++  TQMap<TraceCostItem*,int> _groupSize;
++
++  HighestCostList _hc;
++  // when setting a
++  bool _inSetGroup, _inSetFunction;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/functionselectionbase.ui b/kdecachegrind/kdecachegrind/functionselectionbase.ui
+new file mode 100644
+index 0000000..eec019d
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/functionselectionbase.ui
+@@ -0,0 +1,163 @@
++<!DOCTYPE UI><UI version="3.1" stdsetdef="1">
++<class>FunctionSelectionBase</class>
++<widget class="TQWidget">
++    <property name="name">
++        <cstring>FunctionSelectionBase</cstring>
++    </property>
++    <property name="geometry">
++        <rect>
++            <x>0</x>
++            <y>0</y>
++            <width>223</width>
++            <height>485</height>
++        </rect>
++    </property>
++    <property name="caption">
++        <string>Function Profile</string>
++    </property>
++    <vbox>
++        <property name="name">
++            <cstring>unnamed</cstring>
++        </property>
++        <property name="margin">
++            <number>3</number>
++        </property>
++        <property name="spacing">
++            <number>6</number>
++        </property>
++        <widget class="TQLayoutWidget">
++            <property name="name">
++                <cstring>layout1</cstring>
++            </property>
++            <hbox>
++                <property name="name">
++                    <cstring>unnamed</cstring>
++                </property>
++                <widget class="TQLabel">
++                    <property name="name">
++                        <cstring>searchLabel</cstring>
++                    </property>
++                    <property name="text">
++                        <string>&amp;Search:</string>
++                    </property>
++                    <property name="buddy" stdset="0">
++                        <cstring>searchEdit</cstring>
++                    </property>
++                </widget>
++                <widget class="TQLineEdit">
++                    <property name="name">
++                        <cstring>searchEdit</cstring>
++                    </property>
++                </widget>
++                <widget class="TQComboBox">
++                    <property name="name">
++                        <cstring>groupBox</cstring>
++                    </property>
++                </widget>
++            </hbox>
++        </widget>
++        <widget class="TQListView">
++            <column>
++                <property name="text">
++                    <string>Self</string>
++                </property>
++                <property name="clickable">
++                    <bool>true</bool>
++                </property>
++                <property name="resizable">
++                    <bool>true</bool>
++                </property>
++            </column>
++            <column>
++                <property name="text">
++                    <string>Group</string>
++                </property>
++                <property name="clickable">
++                    <bool>true</bool>
++                </property>
++                <property name="resizable">
++                    <bool>true</bool>
++                </property>
++            </column>
++            <property name="name">
++                <cstring>groupList</cstring>
++            </property>
++            <property name="sizePolicy">
++                <sizepolicy>
++                    <hsizetype>7</hsizetype>
++                    <vsizetype>5</vsizetype>
++                    <horstretch>0</horstretch>
++                    <verstretch>0</verstretch>
++                </sizepolicy>
++            </property>
++            <property name="maximumSize">
++                <size>
++                    <width>32767</width>
++                    <height>150</height>
++                </size>
++            </property>
++        </widget>
++        <widget class="TQListView">
++            <column>
++                <property name="text">
++                    <string>Incl.</string>
++                </property>
++                <property name="clickable">
++                    <bool>true</bool>
++                </property>
++                <property name="resizable">
++                    <bool>true</bool>
++                </property>
++            </column>
++            <column>
++                <property name="text">
++                    <string>Self</string>
++                </property>
++                <property name="clickable">
++                    <bool>true</bool>
++                </property>
++                <property name="resizable">
++                    <bool>true</bool>
++                </property>
++            </column>
++            <column>
++                <property name="text">
++                    <string>Called</string>
++                </property>
++                <property name="clickable">
++                    <bool>true</bool>
++                </property>
++                <property name="resizable">
++                    <bool>true</bool>
++                </property>
++            </column>
++            <column>
++                <property name="text">
++                    <string>Function</string>
++                </property>
++                <property name="clickable">
++                    <bool>true</bool>
++                </property>
++                <property name="resizable">
++                    <bool>true</bool>
++                </property>
++            </column>
++            <column>
++                <property name="text">
++                    <string>Location</string>
++                </property>
++                <property name="clickable">
++                    <bool>true</bool>
++                </property>
++                <property name="resizable">
++                    <bool>true</bool>
++                </property>
++            </column>
++            <property name="name">
++                <cstring>functionList</cstring>
++            </property>
++        </widget>
++    </vbox>
++</widget>
++<layoutdefaults spacing="6" margin="11"/>
++</UI>
+diff --git a/kdecachegrind/kdecachegrind/hi32-app-kcachegrind.png b/kdecachegrind/kdecachegrind/hi32-app-kcachegrind.png
+new file mode 100644
+index 0000000..bd41dae
+Binary files /dev/null and b/kdecachegrind/kdecachegrind/hi32-app-kcachegrind.png differ
+diff --git a/kdecachegrind/kdecachegrind/hi48-app-kcachegrind.png b/kdecachegrind/kdecachegrind/hi48-app-kcachegrind.png
+new file mode 100644
+index 0000000..58c2efd
+Binary files /dev/null and b/kdecachegrind/kdecachegrind/hi48-app-kcachegrind.png differ
+diff --git a/kdecachegrind/kdecachegrind/instritem.cpp b/kdecachegrind/kdecachegrind/instritem.cpp
+new file mode 100644
+index 0000000..ce5e81b
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/instritem.cpp
+@@ -0,0 +1,469 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Items of instruction view.
++ */
++
++#include <tqpixmap.h>
++#include <tqpainter.h>
++
++#include <klocale.h>
++#include <kapplication.h>
++#include <kiconloader.h>
++#include <kdebug.h>
++
++#include "configuration.h"
++#include "listutils.h"
++#include "instritem.h"
++#include "instrview.h"
++
++
++// InstrItem
++
++// for messages
++InstrItem::InstrItem(InstrView* iv, TQListView* parent,
++		     Addr addr, const TQString& msg)
++    : TQListViewItem(parent)
++{
++  _view = iv;
++  _addr = addr;
++  _instr = 0;
++  _instrCall = 0;
++  _instrJump = 0;
++  _inside = false;
++  
++  setText(0, addr.pretty());
++  setText(6, msg);
++  
++  updateGroup();
++  updateCost();
++}
++
++// for code lines
++InstrItem::InstrItem(InstrView* iv, TQListView* parent,
++		     Addr addr, bool inside,
++		     const TQString& code, const TQString& cmd,
++		     const TQString& args, TraceInstr* instr)
++    : TQListViewItem(parent)
++{
++  _view = iv;
++  _addr = addr;
++  _instr = instr;
++  _instrCall = 0;
++  _instrJump = 0;
++  _inside = inside;
++
++  if (args == "...")
++      setText(0, args);
++  else
++      setText(0, addr.pretty());
++  setText(4, code);
++  setText(5, cmd);
++  setText(6, args);
++
++  TraceLine* l;
++  if (instr && (l = instr->line()))
++      setText(7, l->name());
++
++  updateGroup();
++  updateCost();
++}
++
++// for call lines
++InstrItem::InstrItem(InstrView* iv, TQListViewItem* parent, Addr addr,
++		     TraceInstr* instr, TraceInstrCall* instrCall)
++    : TQListViewItem(parent)
++{
++  _view = iv;
++  _addr = addr;
++  _instr = instr;
++  _instrCall = instrCall;
++  _instrJump = 0;
++  _inside = true;
++
++  //qDebug("InstrItem: (file %d, line %d) Linecall to %s",
++  //       fileno, lineno, _lineCall->call()->called()->prettyName().ascii());
++
++  SubCost cc = _instrCall->callCount();
++  TQString templ = "  ";
++  if (cc==0)
++    templ += i18n("Active call to '%1'");
++  else
++    templ += i18n("%n call to '%1'", "%n calls to '%1'", cc);
++
++  TQString callStr = templ.arg(_instrCall->call()->calledName());
++  TraceFunction* calledF = _instrCall->call()->called();
++  calledF->addPrettyLocation(callStr);
++
++  setText(6, callStr);
++
++  updateGroup();
++  updateCost();
++}
++
++// for jump lines
++InstrItem::InstrItem(InstrView* iv, TQListViewItem* parent, Addr addr,
++		     TraceInstr* instr, TraceInstrJump* instrJump)
++    : TQListViewItem(parent)
++{
++  _view = iv;
++  _addr = addr;
++  _inside = true;
++  _instr = instr;
++  _instrCall = 0;
++  _instrJump = instrJump;
++
++  //qDebug("SourceItem: (file %d, line %d) Linecall to %s",
++  //       fileno, lineno, _lineCall->call()->called()->prettyName().ascii());
++
++  TQString jStr;
++  if (_instrJump->isCondJump())
++      jStr = i18n("Jump %1 of %2 times to 0x%3")
++	  .arg(_instrJump->followedCount().pretty())
++	  .arg(_instrJump->executedCount().pretty())
++	  .arg(_instrJump->instrTo()->addr().toString());
++  else
++      jStr = i18n("Jump %1 times to 0x%2")
++	  .arg(_instrJump->executedCount().pretty())
++	  .arg(_instrJump->instrTo()->addr().toString());
++
++  setText(6, jStr);
++
++  updateGroup();
++  updateCost();
++}
++
++
++void InstrItem::updateGroup()
++{
++  if (!_instrCall) return;
++
++  TraceFunction* f = _instrCall->call()->called();
++  TQColor c = Configuration::functionColor(_view->groupType(), f);
++  setPixmap(6, colorPixmap(10, 10, c));
++}
++
++void InstrItem::updateCost()
++{
++  _pure = SubCost(0);
++  _pure2 = SubCost(0);
++
++  if (!_instr) return;
++  if (_instrJump) return;
++
++  TraceCost* instrCost = _instrCall ?
++      (TraceCost*)_instrCall : (TraceCost*)_instr;
++
++  // don't show any cost inside of cycles
++  if (_instrCall &&
++      ((_instrCall->call()->inCycle()>0) ||
++       (_instrCall->call()->isRecursion()>0))) {
++    TQString str;
++    TQPixmap p;
++
++    TQString icon = "undo";
++    KIconLoader* loader = KApplication::kApplication()->iconLoader();
++    p= loader->loadIcon(icon, KIcon::Small, 0,
++                        KIcon::DefaultState, 0, true);
++    if (p.isNull())
++      str = i18n("(cycle)");
++
++    setText(1, str);
++    setPixmap(1, p);
++    setText(2, str);
++    setPixmap(2, p);
++    return;
++  }
++
++  TraceCost* totalCost;
++  if (Configuration::showExpanded())
++      totalCost = _instr->function()->inclusive();
++  else
++      totalCost = _instr->function()->data();
++
++  TraceCostType *ct = _view->costType();
++  _pure = ct ? instrCost->subCost(ct) : SubCost(0);
++  if (_pure == 0) {
++    setText(1, TQString());
++    setPixmap(1, TQPixmap());
++  }
++  else {
++    double total = totalCost->subCost(ct);
++    double pure  = 100.0 * _pure / total;
++
++    if (Configuration::showPercentage())
++      setText(1, TQString("%1")
++	      .arg(pure, 0, 'f', Configuration::percentPrecision()));
++    else
++      setText(1, _pure.pretty());
++    
++    setPixmap(1, costPixmap(ct, instrCost, total, false));
++  }
++
++  TraceCostType *ct2 = _view->costType2();
++  _pure2 = ct2 ? instrCost->subCost(ct2) : SubCost(0);
++  if (_pure2 == 0) {
++    setText(2, TQString());
++    setPixmap(2, TQPixmap());
++  }
++  else {
++    double total = totalCost->subCost(ct2);
++    double pure  = 100.0 * _pure2 / total;
++
++    if (Configuration::showPercentage())
++      setText(2, TQString("%1")
++	      .arg(pure, 0, 'f', Configuration::percentPrecision()));
++    else
++      setText(2, _pure2.pretty());
++    
++    setPixmap(2, costPixmap(ct2, instrCost, total, false));
++  }
++}
++
++
++int InstrItem::compare(TQListViewItem * i, int col, bool ascending ) const
++{
++  const InstrItem* ii1 = this;
++  const InstrItem* ii2 = (InstrItem*) i;
++
++  // we always want descending order
++  if (((col>0) && ascending) ||
++      ((col==0) && !ascending) ) {
++    ii1 = ii2;
++    ii2 = this;
++  }
++
++  if (col==1) {
++    if (ii1->_pure < ii2->_pure) return -1;
++    if (ii1->_pure > ii2->_pure) return 1;
++    return 0;
++  }
++  if (col==2) {
++    if (ii1->_pure2 < ii2->_pure2) return -1;
++    if (ii1->_pure2 > ii2->_pure2) return 1;
++    return 0;
++  }
++  if (col==0) {
++    if (ii1->_addr < ii2->_addr) return -1;
++    if (ii1->_addr > ii2->_addr) return 1;
++
++    // Same address: code gets above calls/jumps
++    if (!ii1->_instrCall && !ii1->_instrJump) return -1;
++    if (!ii2->_instrCall && !ii2->_instrJump) return 1;
++
++    // calls above jumps
++    if (ii1->_instrCall && !ii2->_instrCall) return -1;
++    if (ii2->_instrCall && !ii1->_instrCall) return 1;
++
++    if (ii1->_instrCall && ii2->_instrCall) {
++	// Two calls: desending sort according costs
++	if (ii1->_pure < ii2->_pure) return 1;
++	if (ii1->_pure > ii2->_pure) return -1;
++
++	// Two calls: sort according function names
++	TraceFunction* f1 = ii1->_instrCall->call()->called();
++	TraceFunction* f2 = ii2->_instrCall->call()->called();
++	if (f1->prettyName() > f2->prettyName()) return 1;
++	return -1;
++    }
++
++    // Two jumps: descending sort according target address
++    if (ii1->_instrJump->instrTo()->addr() <
++	ii2->_instrJump->instrTo()->addr())
++	return -1;
++    if (ii1->_instrJump->instrTo()->addr() >
++	ii2->_instrJump->instrTo()->addr())
++	return 1;
++    return 0;
++
++  }
++  return TQListViewItem::compare(i, col, ascending);
++}
++
++void InstrItem::paintCell( TQPainter *p, const TQColorGroup &cg,
++			   int column, int width, int alignment )
++{
++  TQColorGroup _cg( cg );
++
++  if ( !_inside || ((column==1) || column==2))
++    _cg.setColor( TQColorGroup::Base, cg.button() );
++  else if ((_instrCall || _instrJump) && column>2)
++    _cg.setColor( TQColorGroup::Base, cg.midlight() );
++
++  if (column == 3)
++    paintArrows(p, _cg, width);
++  else
++    TQListViewItem::paintCell( p, _cg, column, width, alignment );
++}
++
++void InstrItem::setJumpArray(const TQMemArray<TraceInstrJump*>& a)
++{
++    _jump.duplicate(a);
++}
++
++void InstrItem::paintArrows(TQPainter *p, const TQColorGroup &cg, int width)
++{
++  TQListView *lv = listView();
++  if ( !lv ) return;
++  InstrView* iv = (InstrView*) lv;
++
++  const BackgroundMode bgmode = lv->viewport()->backgroundMode();
++  const TQColorGroup::ColorRole crole
++    = TQPalette::backgroundRoleFromMode( bgmode );
++  if ( cg.brush( crole ) != lv->colorGroup().brush( crole ) )
++    p->fillRect( 0, 0, width, height(), cg.brush( crole ) );
++  else
++    iv->paintEmptyArea( p, TQRect( 0, 0, width, height() ) );
++
++  if ( isSelected() && lv->allColumnsShowFocus() )
++    p->fillRect( 0, 0, width, height(), cg.brush( TQColorGroup::Highlight ) );
++
++  int marg = lv->itemMargin();
++  int yy = height()/2, y1, y2;
++  TQColor c;
++
++  int start = -1, end = -1;
++
++  // draw line borders, detect start/stop of a line
++  for(int i=0;i< (int)_jump.size();i++) {
++      if (_jump[i] == 0) continue;
++
++      y1 = 0;
++      y2 = height();
++      if ((_instrJump == _jump[i]) &&
++	  (_jump[i]->instrFrom()->addr() == _addr)) {
++
++	  //kdDebug() << "InstrItem " << _addr.toString() << ": start " << i << endl;
++	  if (start<0) start = i;
++	  if (_jump[i]->instrTo()->addr() <= _addr)
++	      y2 = yy;
++	  else
++	      y1 = yy;
++      }
++      else if (!_instrJump && !_instrCall &&
++	       (_jump[i]->instrTo()->addr() == _addr)) {
++
++	  //kdDebug() << "InstrItem " << _addr.toString() << ": end " << i << endl;
++	  if (end<0) end = i;
++	  if (_jump[i]->instrFrom()->addr() < _addr)
++	      y2 = yy;
++	  else
++	      y1 = yy;
++      }
++
++      c = _jump[i]->isCondJump() ? red : blue;
++#if 0
++      if (_jump[i] == ((TraceItemView*)_view)->selectedItem()) {	  
++	  p->fillRect( marg + 6*i-2, (y1==0) ? y1: y1-2,
++		       8, (y2-y1==height())? y2:y2+2,
++		       cg.brush( TQColorGroup::Highlight ) );
++	  c = lv->colorGroup().highlightedText();
++      }
++#endif
++      p->fillRect( marg + 6*i, y1, 4, y2, c);
++      p->setPen(c.light());
++      p->drawLine( marg + 6*i, y1, marg + 6*i, y2);
++      p->setPen(c.dark());
++      p->drawLine( marg + 6*i +3, y1, marg + 6*i +3, y2);
++  }
++
++  // draw start/stop horizontal line
++  int x, y = yy-2, w, h = 4;
++  if (start >= 0) {
++#if 0
++      if (_jump[start] == ((TraceItemView*)_view)->selectedItem()) {	  
++	  c = lv->colorGroup().highlightedText();
++      }
++#endif
++      c = _jump[start]->isCondJump() ? red : blue;
++      x = marg + 6*start;
++      w = 6*(iv->arrowLevels() - start) + 10;
++      p->fillRect( x, y, w, h, c);
++      p->setPen(c.light());
++      p->drawLine(x, y, x+w-1, y);
++      p->drawLine(x, y, x, y+h-1);
++      p->setPen(c.dark());
++      p->drawLine(x+w-1, y, x+w-1, y+h-1);
++      p->drawLine(x+1, y+h-1, x+w-1, y+h-1);
++  }
++  if (end >= 0) {
++      c = _jump[end]->isCondJump() ? red : blue;
++      x = marg + 6*end;
++      w = 6*(iv->arrowLevels() - end) + 10;
++
++      TQPointArray a;
++      a.putPoints(0, 7, x, y+h,
++		  x,y, x+w-8, y, x+w-8, y-2,
++		  x+w, yy,
++		  x+w-8, y+h+2, x+w-8, y+h);
++      p->setBrush(c);
++      p->drawConvexPolygon(a);
++
++      p->setPen(c.light());
++      p->drawPolyline(a, 0, 5);
++      p->setPen(c.dark());
++      p->drawPolyline(a, 4, 2);
++      p->setPen(c.light());
++      p->drawPolyline(a, 5, 2);
++      p->setPen(c.dark());
++      p->drawPolyline(a, 6, 2);
++  }
++
++  // draw inner vertical line for start/stop
++  // this overwrites borders of horizontal line
++  for(int i=0;i< (int)_jump.size();i++) {
++      if (_jump[i] == 0) continue;
++
++      c = _jump[i]->isCondJump() ? red : blue;
++
++      if (_jump[i]->instrFrom()->addr() == _addr) {
++	  bool drawUp = true;
++	  if (_jump[i]->instrTo()->addr() == _addr)
++	      if (start<0) drawUp=false;	  
++	  if (_jump[i]->instrTo()->addr() > _addr) drawUp=false;
++	  if (drawUp)
++	      p->fillRect( marg + 6*i +1, 0, 2, yy, c);
++	  else
++	      p->fillRect( marg + 6*i +1, yy, 2, height()-yy, c);
++      }
++      else if (_jump[i]->instrTo()->addr() == _addr) {
++	  if (end<0) end = i;
++	  if (_jump[i]->instrFrom()->addr() < _addr)
++	      p->fillRect( marg + 6*i +1, 0, 2, yy, c);
++	  else
++	      p->fillRect( marg + 6*i +1, yy, 2, height()-yy, c);
++      }
++  }
++
++}
++
++int InstrItem::width( const TQFontMetrics& fm,
++                      const TQListView* lv, int c ) const
++{
++  if (c != 3) return TQListViewItem::width(fm, lv, c);
++
++  InstrView* iv = (InstrView*) lv;
++  int levels = iv->arrowLevels();
++
++  if (levels == 0) return 0;
++
++  // 10 pixels for the arrow
++  return 10 + 6*levels + lv->itemMargin() * 2;
++}
++
+diff --git a/kdecachegrind/kdecachegrind/instritem.h b/kdecachegrind/kdecachegrind/instritem.h
+new file mode 100644
+index 0000000..2bbce71
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/instritem.h
+@@ -0,0 +1,86 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Items of instruction view.
++ */
++
++#ifndef INSTRITEM_H
++#define INSTRITEM_H
++
++#include <tqlistview.h>
++#include "tracedata.h"
++
++class InstrView;
++
++class InstrItem: public TQListViewItem
++{
++
++public:
++  // for messages
++  InstrItem(InstrView* iv, TQListView* parent,
++	    Addr addr, const TQString&);
++
++  // for instruction lines
++  InstrItem(InstrView* iv, TQListView* parent,
++	    Addr addr, bool inside,
++	    const TQString&, const TQString&, const TQString&,
++	    TraceInstr* instr);
++
++  // for call instr
++  InstrItem(InstrView* iv, TQListViewItem* parent, Addr addr,
++	    TraceInstr* instr, TraceInstrCall* instrCall);
++
++  // for jump lines
++  InstrItem(InstrView* iv, TQListViewItem* parent, Addr addr,
++	    TraceInstr* instr, TraceInstrJump* instrJump);
++
++  Addr addr() const { return _addr; }
++  TraceInstr* instr() const { return _instr; }
++  TraceInstrCall* instrCall() const { return _instrCall; }
++  TraceInstrJump* instrJump() const { return _instrJump; }
++
++  int compare(TQListViewItem * i, int col, bool ascending ) const;
++
++  void paintCell(TQPainter *p, const TQColorGroup &cg,
++                 int column, int width, int alignment );
++  int width( const TQFontMetrics& fm,
++             const TQListView* lv, int c ) const;
++
++  void updateGroup();
++  void updateCost();
++
++  // arrow lines
++  void setJumpArray(const TQMemArray<TraceInstrJump*>& a);
++
++protected:
++  void paintArrows(TQPainter *p, const TQColorGroup &cg, int width);
++  TQMemArray<TraceInstrJump*> _jump;
++
++private:
++  InstrView* _view;
++  SubCost _pure, _pure2;
++  Addr _addr;
++  TraceInstr* _instr;
++  TraceInstrJump* _instrJump;
++  TraceInstrCall* _instrCall;
++  bool _inside;
++};
++
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/instrview.cpp b/kdecachegrind/kdecachegrind/instrview.cpp
+new file mode 100644
+index 0000000..3df1679
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/instrview.cpp
+@@ -0,0 +1,949 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Instruction View
++ */
++
++#include <tqfile.h>
++#include <tqregexp.h>
++#include <tqwhatsthis.h>
++#include <tqpopupmenu.h>
++#include <klocale.h>
++#include <kconfig.h>
++#include <kdebug.h>
++
++#include "configuration.h"
++#include "instritem.h"
++#include "instrview.h"
++
++// InstrView defaults
++
++#define DEFAULT_SHOWHEXCODE true
++
++
++// Helpers for parsing output of 'objdump'
++
++static Addr parseAddr(char* buf)
++{
++    Addr addr;
++    uint pos = 0;
++
++    // check for instruction line: <space>* <hex address> ":" <space>*
++    while(buf[pos]==' ' || buf[pos]=='\t') pos++;
++
++    int digits = addr.set(buf + pos);
++    if ((digits==0) || (buf[pos+digits] != ':')) return Addr(0);
++
++    return addr;
++}
++
++
++static bool parseLine(char* buf, Addr& addr,
++                      uint& pos1, uint& pos2, uint& pos3)
++{
++    // check for instruction line: <space>* <hex address> ":" <space>*
++
++    pos1 = 0;
++    while(buf[pos1]==' ' || buf[pos1]=='\t') pos1++;
++
++    int digits = addr.set(buf + pos1);
++    pos1 += digits;
++    if ((digits==0) || (buf[pos1] != ':')) return false;
++
++    // further parsing of objdump output...
++    pos1++;
++    while(buf[pos1]==' ' || buf[pos1]=='\t') pos1++;
++
++    // skip code, pattern "xx "*
++    pos2 = pos1;
++    while(1) {
++	if (! ((buf[pos2]>='0' && buf[pos2]<='9') ||
++	       (buf[pos2]>='a' && buf[pos2]<='f')) ) break;
++	if (! ((buf[pos2+1]>='0' && buf[pos2+1]<='9') ||
++	       (buf[pos2+1]>='a' && buf[pos2+1]<='f')) ) break;
++	if (buf[pos2+2] != ' ') break;
++	pos2 += 3;
++    }
++    buf[pos2-1]=0;
++    while(buf[pos2]==' '|| buf[pos2]=='\t') pos2++;
++
++    // skip mnemonic
++    pos3 = pos2;
++    while(buf[pos3] && buf[pos3]!=' ' && buf[pos3]!='\t') pos3++;
++    if (buf[pos3] != 0) {
++	buf[pos3] = 0;
++	pos3++;
++	while(buf[pos3]==' '|| buf[pos3]=='\t') pos3++;
++    }
++
++    // maximal 50 chars
++    if (strlen(buf+pos2) > 50)
++	strcpy(buf+pos2+47, "...");
++
++    if (0) qDebug("For 0x%s: Code '%s', Mnc '%s', Args '%s'",
++		  addr.toString().ascii(), buf+pos1, buf+pos2, buf+pos3);
++
++    return true;
++}
++
++
++
++
++//
++// InstrView
++//
++
++
++InstrView::InstrView(TraceItemView* parentView,
++                     TQWidget* parent, const char* name)
++  : TQListView(parent, name), TraceItemView(parentView)
++{
++  _showHexCode = DEFAULT_SHOWHEXCODE;
++  _lastHexCodeWidth = 50;
++
++  _inSelectionUpdate = false;
++  _arrowLevels = 0;
++  _lowList.setSortLow(true);
++  _highList.setSortLow(false);
++
++  addColumn( i18n( "#" ) );
++  addColumn( i18n( "Cost" ) );
++  addColumn( i18n( "Cost 2" ) );
++  addColumn( "" );
++  addColumn( i18n( "Hex" ) );
++  addColumn( "" ); // Instruction
++  addColumn( i18n( "Assembler" ) );
++  addColumn( i18n( "Source Position" ) );
++
++  setAllColumnsShowFocus(true);
++  setColumnAlignment(1, TQt::AlignRight);
++  setColumnAlignment(2, TQt::AlignRight);
++
++  connect(this,
++          TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint &, int)),
++          TQT_SLOT(context(TQListViewItem*, const TQPoint &, int)));
++
++  connect(this, TQT_SIGNAL(selectionChanged(TQListViewItem*)),
++          TQT_SLOT(selectedSlot(TQListViewItem*)));
++
++  connect(this,
++          TQT_SIGNAL(doubleClicked(TQListViewItem*)),
++          TQT_SLOT(activatedSlot(TQListViewItem*)));
++
++  connect(this,
++          TQT_SIGNAL(returnPressed(TQListViewItem*)),
++          TQT_SLOT(activatedSlot(TQListViewItem*)));
++
++  TQWhatsThis::add( this, whatsThis());
++}
++
++void InstrView::paintEmptyArea( TQPainter * p, const TQRect & r)
++{
++  TQListView::paintEmptyArea(p, r);
++}
++
++TQString InstrView::whatsThis() const
++{
++    return i18n( "<b>Annotated Assembler</b>"
++		 "<p>The annotated assembler list shows the "
++		 "machine code instructions of the current selected "
++		 "function together with (self) cost spent while "
++		 "executing an instruction. If this is a call "
++		 "instruction, lines with details on the "
++		 "call happening are inserted into the source: "
++		 "the cost spent inside of the call, the "
++		 "number of calls happening, and the call destination.</p>"
++		 "<p>The disassembler output shown is generated with "
++		 "the 'objdump' utility from the 'binutils' package.</p>"
++		 "<p>Select a line with call information to "
++		 "make the destination function of this call current.</p>");
++}
++
++void InstrView::context(TQListViewItem* i, const TQPoint & p, int c)
++{
++  TQPopupMenu popup;
++
++  TraceInstrCall* ic = i ? ((InstrItem*) i)->instrCall() : 0;
++  TraceInstrJump* ij = i ? ((InstrItem*) i)->instrJump() : 0;
++  TraceFunction* f = ic ? ic->call()->called() : 0;
++  TraceInstr* instr = ij ? ij->instrTo() : 0;
++
++  if (f) {
++    TQString name = f->name();
++    if ((int)name.length()>Configuration::maxSymbolLength())
++      name = name.left(Configuration::maxSymbolLength()) + "...";
++    popup.insertItem(i18n("Go to '%1'").arg(name), 93);
++    popup.insertSeparator();
++  }
++  else if (instr) {
++    popup.insertItem(i18n("Go to Address %1").arg(instr->name()), 93);
++    popup.insertSeparator();
++  }
++
++  if ((c == 1) || (c == 2)) {
++    addCostMenu(&popup);
++    popup.insertSeparator();
++  }
++  addGoMenu(&popup);
++
++  popup.insertSeparator();
++  popup.setCheckable(true);
++  popup.insertItem(i18n("Hex Code"), 94);
++  if (_showHexCode) popup.setItemChecked(94,true);
++
++  int r = popup.exec(p);
++  if (r == 93) {
++    if (f) activated(f);
++    if (instr) activated(instr);
++  }
++  else if (r == 94) {
++    _showHexCode = !_showHexCode;
++    // remember width when hiding
++    if (!_showHexCode)
++      _lastHexCodeWidth = columnWidth(4);
++    setColumnWidths();
++  }
++}
++
++
++void InstrView::selectedSlot(TQListViewItem * i)
++{
++  if (!i) return;
++  // programatically selected items are not signalled
++  if (_inSelectionUpdate) return;
++
++  TraceInstrCall* ic = ((InstrItem*) i)->instrCall();
++  TraceInstrJump* ij = ((InstrItem*) i)->instrJump();
++
++  if (!ic && !ij) {
++      TraceInstr* instr = ((InstrItem*) i)->instr();
++      if (instr) {
++	  _selectedItem = instr;
++	  selected(instr);
++      }
++      return;
++  }
++
++  if (ic) {
++      _selectedItem = ic;
++      selected(ic);
++  }
++  else if (ij) {
++      _selectedItem = ij;
++      selected(ij);
++  }
++}
++
++void InstrView::activatedSlot(TQListViewItem * i)
++{
++  if (!i) return;
++  TraceInstrCall* ic = ((InstrItem*) i)->instrCall();
++  TraceInstrJump* ij = ((InstrItem*) i)->instrJump();
++
++  if (!ic && !ij) {
++      TraceInstr* instr = ((InstrItem*) i)->instr();
++      if (instr) activated(instr);
++      return;
++  }
++
++  if (ic) {
++    TraceFunction* f = ic->call()->called();
++    if (f) activated(f);
++  }
++  else if (ij) {
++    TraceInstr* instr = ij->instrTo();
++    if (instr) activated(instr);
++  }
++}
++
++
++TraceItem* InstrView::canShow(TraceItem* i)
++{
++  TraceItem::CostType t = i ? i->type() : TraceItem::NoCostType;
++  TraceFunction* f = 0;
++
++  switch(t) {
++  case TraceItem::Function:
++      f = (TraceFunction*) i;
++      break;
++
++  case TraceItem::Instr:
++      f = ((TraceInstr*)i)->function();
++      select(i);
++      break;
++
++  case TraceItem::Line:
++      f = ((TraceLine*)i)->functionSource()->function();
++      select(i);
++      break;
++
++  default:
++      break;
++  }
++
++  return f;
++}
++
++
++void InstrView::doUpdate(int changeType)
++{
++  // Special case ?
++  if (changeType == selectedItemChanged) {
++
++      if (!_selectedItem) {
++	  clearSelection();
++	  return;
++      }
++
++      InstrItem *ii = (InstrItem*)TQListView::selectedItem();
++      if (ii) {
++	  if ((ii->instr() == _selectedItem) ||
++	      (ii->instr() && (ii->instr()->line() == _selectedItem))) return;
++      }
++
++      TQListViewItem *item, *item2;
++      for (item = firstChild();item;item = item->nextSibling()) {
++	  ii = (InstrItem*)item;
++	  if ((ii->instr() == _selectedItem) ||
++	      (ii->instr() && (ii->instr()->line() == _selectedItem))) {
++	      ensureItemVisible(item);
++              _inSelectionUpdate = true;
++	      setCurrentItem(item);
++              _inSelectionUpdate = false;
++	      break;
++	  }
++	  item2 = item->firstChild();
++	  for (;item2;item2 = item2->nextSibling()) {
++	      ii = (InstrItem*)item2;
++	      if (!ii->instrCall()) continue;
++	      if (ii->instrCall()->call()->called() == _selectedItem) {
++		  ensureItemVisible(item2);
++                  _inSelectionUpdate = true;
++		  setCurrentItem(item2);
++                  _inSelectionUpdate = false;
++		  break;
++	      }
++	  }
++	  if (item2) break;
++      }
++      return;
++  }
++
++  if (changeType == groupTypeChanged) {
++    TQListViewItem *item, *item2;
++    for (item = firstChild();item;item = item->nextSibling())
++      for (item2 = item->firstChild();item2;item2 = item2->nextSibling())
++        ((InstrItem*)item2)->updateGroup();
++    return;
++  }
++
++  refresh();
++}
++
++void InstrView::setColumnWidths()
++{
++  if (_showHexCode) {
++    setColumnWidthMode(4, TQListView::Maximum);
++    setColumnWidth(4, _lastHexCodeWidth);
++  }
++  else {
++    setColumnWidthMode(4, TQListView::Manual);
++    setColumnWidth(4, 0);
++  }
++}
++
++void InstrView::refresh()
++{
++    _arrowLevels = 0;
++
++    // reset to automatic sizing to get column width
++    setColumnWidthMode(4, TQListView::Maximum);
++
++    clear();
++    setColumnWidth(0, 20);
++    setColumnWidth(1, 50);
++    setColumnWidth(2, _costType2 ? 50:0);
++    setColumnWidth(3, 0);   // arrows, defaults to invisible
++    setColumnWidth(4, 0);   // hex code column
++    setColumnWidth(5, 20);  // command column
++    setColumnWidth(6, 200); // arg column
++    setSorting(0); // always reset to address number sort
++    if (_costType)
++      setColumnText(1, _costType->name());
++    if (_costType2)
++      setColumnText(2, _costType2->name());
++
++    if (!_data || !_activeItem) return;
++
++    TraceItem::CostType t = _activeItem->type();
++    TraceFunction* f = 0;
++    if (t == TraceItem::Function) f = (TraceFunction*) _activeItem;
++    if (t == TraceItem::Instr) {
++	f = ((TraceInstr*)_activeItem)->function();
++	if (!_selectedItem) _selectedItem = _activeItem;
++    }
++    if (t == TraceItem::Line) {
++	f = ((TraceLine*)_activeItem)->functionSource()->function();
++	if (!_selectedItem) _selectedItem = _activeItem;
++    }
++
++    if (!f) return;
++
++    // Allow resizing of column 2
++    setColumnWidthMode(2, TQListView::Maximum);
++
++    // check for instruction map
++    TraceInstrMap::Iterator itStart, it, tmpIt, itEnd;
++    TraceInstrMap* instrMap = f->instrMap();
++    if (instrMap) {
++	it    = instrMap->begin();
++	itEnd = instrMap->end();
++	// get first instruction with cost of selected type
++	while(it != itEnd) {
++	  if ((*it).hasCost(_costType)) break;
++	  if (_costType2 && (*it).hasCost(_costType2)) break;
++	  ++it;
++	}
++    }
++    if (!instrMap || (it == itEnd)) {
++	new InstrItem(this, this, 1,
++		      i18n("There is no instruction info in the profile data file."));
++	new InstrItem(this, this, 2,
++		      i18n("For the Valgrind Calltree Skin, rerun with option"));
++	new InstrItem(this, this, 3, i18n("      --dump-instr=yes"));
++	new InstrItem(this, this, 4, i18n("To see (conditional) jumps, additionally specify"));
++	new InstrItem(this, this, 5, i18n("      --trace-jump=yes"));
++	return;
++    }
++
++    // initialisation for arrow drawing
++    // create sorted list of jumps (for jump arrows)
++    _lowList.clear();
++    _highList.clear();
++    itStart = it;
++    while(1) {
++	TraceInstrJumpList jlist = (*it).instrJumps();
++	TraceInstrJump* ij;
++	for (ij=jlist.first();ij;ij=jlist.next()) {
++	    if (ij->executedCount()==0) continue;
++	    _lowList.append(ij);
++	    _highList.append(ij);
++	}
++	++it;
++	while(it != itEnd) {
++	  if ((*it).hasCost(_costType)) break;
++	  if (_costType2 && (*it).hasCost(_costType2)) break;
++	  ++it;
++	}
++	if (it == itEnd) break;
++    }
++    _lowList.sort();
++    _highList.sort();
++    _lowList.first(); // iterators to list start
++    _highList.first();
++    _arrowLevels = 0;
++    _jump.resize(0);
++
++
++    // do multiple calls to 'objdump' if there are large gaps in addresses
++    it = itStart;
++    while(1) {
++	itStart = it;
++	while(1) {
++	    tmpIt = it;
++	    ++it;
++	    while(it != itEnd) {
++	      if ((*it).hasCost(_costType)) break;
++	      if (_costType2 && (*it).hasCost(_costType2)) break;
++	      ++it;
++	    }
++	    if (it == itEnd) break;
++	    if (!(*it).addr().isInRange( (*tmpIt).addr(),10000) ) break;
++	}
++
++	// tmpIt is always last instruction with cost
++	if (!fillInstrRange(f, itStart, ++tmpIt)) break;
++	if (it == itEnd) break;
++    }
++
++    _lastHexCodeWidth = columnWidth(4);
++    setColumnWidths();
++
++    if (!_costType2) {
++      setColumnWidthMode(2, TQListView::Manual);
++      setColumnWidth(2, 0);
++    }
++}
++
++/* This is called after adding instrItems, for each of them in
++ * address order. _jump is the global array of valid jumps
++ * for a line while we iterate downwards.
++ * The existing jumps, sorted in lowList according lower address,
++ * is iterated in the same way.
++ */
++void InstrView::updateJumpArray(Addr addr, InstrItem* ii,
++				bool ignoreFrom, bool ignoreTo)
++{
++    TraceInstrJump* ij;
++    Addr lowAddr, highAddr;
++    int iEnd = -1, iStart = -1;
++
++    if (0) qDebug("updateJumpArray(addr 0x%s, jump to %s)",
++		  addr.toString().ascii(),
++		  ii->instrJump()
++		  ? ii->instrJump()->instrTo()->name().ascii() : "?" );
++
++    // check for new arrows starting from here downwards
++    ij=_lowList.current();
++    while(ij) {
++	lowAddr = ij->instrFrom()->addr();
++	if (ij->instrTo()->addr() < lowAddr)
++	    lowAddr = ij->instrTo()->addr();
++
++	if (lowAddr > addr) break;
++
++	// if target is downwards but we draw no source, break
++	if (ignoreFrom && (lowAddr < ij->instrTo()->addr())) break;
++	// if source is downward but we draw no target, break
++	if (ignoreTo && (lowAddr < ij->instrFrom()->addr())) break;
++	// if this is another jump start, break
++	if (ii->instrJump() && (ij != ii->instrJump())) break;
++
++#if 0
++	for(iStart=0;iStart<_arrowLevels;iStart++)
++	    if (_jump[iStart] &&
++		(_jump[iStart]->instrTo() == ij->instrTo())) break;
++#else
++	iStart = _arrowLevels;
++#endif
++
++	if (iStart==_arrowLevels) {
++	    for(iStart=0;iStart<_arrowLevels;iStart++)
++		if (_jump[iStart] == 0) break;
++	    if (iStart==_arrowLevels) {
++		_arrowLevels++;
++		_jump.resize(_arrowLevels);
++	    }
++	    if (0) qDebug("  new start at %d for %s", iStart, ij->name().ascii());
++	    _jump[iStart] = ij;
++	}
++	ij=_lowList.next();
++    }
++
++    ii->setJumpArray(_jump);
++
++    // check for active arrows ending here
++    ij=_highList.current();
++    while(ij) {
++	highAddr = ij->instrFrom()->addr();
++	if (ij->instrTo()->addr() > highAddr) {
++	    highAddr = ij->instrTo()->addr();
++	    if (ignoreTo) break;
++	}
++	else if (ignoreFrom) break;
++
++	if (highAddr > addr) break;
++
++	for(iEnd=0;iEnd<_arrowLevels;iEnd++)
++	    if (_jump[iEnd] == ij) break;
++	if (iEnd==_arrowLevels) {
++	  kdDebug() << "InstrView: no jump start for end at 0x"
++		    << highAddr.toString() << " ?" << endl;
++	  iEnd = -1;
++	}
++
++	if (0 && (iEnd>=0))
++	    qDebug(" end %d (%s to %s)",
++		   iEnd,
++		   _jump[iEnd]->instrFrom()->name().ascii(),
++		   _jump[iEnd]->instrTo()->name().ascii());
++
++	if (0 && ij) qDebug("next end: %s to %s",
++			    ij->instrFrom()->name().ascii(),
++			    ij->instrTo()->name().ascii());
++
++	ij=_highList.next();
++	if (highAddr > addr)
++	    break;
++	else {
++	    if (iEnd>=0) _jump[iEnd] = 0;
++	    iEnd = -1;
++	}
++    }
++    if (iEnd>=0) _jump[iEnd] = 0;
++}
++
++
++
++/**
++ * Fill up with instructions from cost range [it;itEnd[
++ */
++bool InstrView::fillInstrRange(TraceFunction* function,
++                               TraceInstrMap::Iterator it,
++                               TraceInstrMap::Iterator itEnd)
++{
++    Addr costAddr, nextCostAddr, objAddr, addr;
++    Addr dumpStartAddr, dumpEndAddr;
++    TraceInstrMap::Iterator costIt;
++
++    // shouldn't happen
++    if (it == itEnd) return false;
++
++    // calculate address range for call to objdump
++    TraceInstrMap::Iterator tmpIt = itEnd;
++    --tmpIt;
++    nextCostAddr = (*it).addr();
++    dumpStartAddr = (nextCostAddr<20) ? Addr(0) : nextCostAddr -20;
++    dumpEndAddr   = (*tmpIt).addr() +20;
++
++    // generate command
++    TQString popencmd, objfile;
++    objfile = function->object()->name();
++    objfile = objfile.replace(TQRegExp("[\"']"), ""); // security...
++    popencmd = TQString("objdump -C -d "
++                       "--start-address=0x%1 --stop-address=0x%2 \"%3\"")
++	.arg(dumpStartAddr.toString()).arg(dumpEndAddr.toString())
++	.arg(objfile);
++    if (1) qDebug("Running '%s'...", popencmd.ascii());
++
++    // and run...
++    FILE* iFILE = popen(TQFile::encodeName( popencmd ), "r");
++    if (iFILE == 0) {
++	new InstrItem(this, this, 1,
++		      i18n("There is an error trying to execute the command"));
++	new InstrItem(this, this, 2, "");
++	new InstrItem(this, this, 3, popencmd);
++	new InstrItem(this, this, 4, "");
++	new InstrItem(this, this, 5,
++		      i18n("Check that you have installed 'objdump'."));
++	new InstrItem(this, this, 6,
++		      i18n("This utility can be found in the 'binutils' package."));
++	return false;
++    }
++    TQFile file;
++    file.open(IO_ReadOnly, iFILE);
++
++#define BUF_SIZE  256
++
++    char buf[BUF_SIZE];
++    bool inside = false, skipLineWritten = true;
++    int readBytes = -1;
++    int objdumpLineno = 0, dumpedLines = 0, noAssLines = 0;
++    SubCost most = 0;
++    TraceInstr* currInstr;
++    InstrItem *ii, *ii2, *item = 0, *first = 0, *selected = 0;
++    TQString code, cmd, args;
++    bool needObjAddr = true, needCostAddr = true;
++
++    costAddr = 0;
++    objAddr  = 0;
++
++    while (1) {
++
++      if (needObjAddr) {
++	  needObjAddr = false;
++
++        // read next objdump line
++        while (1) {
++          readBytes=file.readLine(buf, BUF_SIZE);
++          if (readBytes<=0) { 
++	    objAddr = 0; 
++	    break;
++	  }
++
++          objdumpLineno++;
++          if (readBytes == BUF_SIZE) {
++	    qDebug("ERROR: Line %d of '%s' too long\n",
++                   objdumpLineno, popencmd.ascii());
++          }
++          else if ((readBytes>0) && (buf[readBytes-1] == '\n'))
++	    buf[readBytes-1] = 0;
++
++          objAddr = parseAddr(buf);
++          if ((objAddr<dumpStartAddr) || (objAddr>dumpEndAddr))
++            objAddr = 0;
++          if (objAddr != 0) break;
++        }
++
++        if (0) kdDebug() << "Got ObjAddr: 0x" << objAddr.toString() << endl;
++      }
++
++      // try to keep objAddr in [costAddr;nextCostAddr]
++      if (needCostAddr &&
++	  (nextCostAddr > 0) &&
++	  ((objAddr == Addr(0)) || (objAddr >= nextCostAddr)) ) {
++	  needCostAddr = false;
++
++	  costIt = it;
++	  ++it;
++	  while(it != itEnd) {
++	    if ((*it).hasCost(_costType)) break;
++	    if (_costType2 && (*it).hasCost(_costType2)) break;
++	    ++it;
++	  }
++	  costAddr = nextCostAddr;
++	  nextCostAddr = (it == itEnd) ? Addr(0) : (*it).addr();
++
++	  if (0) kdDebug() << "Got nextCostAddr: 0x" << nextCostAddr.toString()
++			   << ", costAddr 0x" << costAddr.toString() << endl;
++      }
++
++      // if we have no more address from objdump, stop
++      if (objAddr == 0) break;
++
++      if ((nextCostAddr==0) || (costAddr == 0) ||
++	  (objAddr < nextCostAddr)) {
++	  // next line is objAddr
++
++	  uint pos1, pos2, pos3;
++
++	  // this sets addr
++	  parseLine(buf, addr, pos1, pos2, pos3);
++	  code = TQString(buf + pos1);
++	  cmd  = TQString(buf + pos2);
++	  args = TQString(buf + pos3);
++
++	  if (costAddr == objAddr) {
++	      currInstr = &(*costIt);
++	      needCostAddr = true;
++	  }
++	  else
++	      currInstr = 0;
++
++	  needObjAddr = true;
++
++	  if (0) kdDebug() << "Dump Obj Addr: 0x" << addr.toString()
++			   << " [" << cmd << " " << args << "], cost (0x"
++			   << costAddr.toString() << ", next 0x"
++			   << nextCostAddr.toString() << ")" << endl;
++      }
++      else {
++	  addr = costAddr;
++	  code = cmd = TQString();
++	  args = i18n("(No Assembler)");
++
++	  currInstr = &(*costIt);
++	  needCostAddr = true;
++
++	  noAssLines++;
++	  if (0) kdDebug() << "Dump Cost Addr: 0x" << addr.toString()
++			   << " (no ass), objAddr 0x" << objAddr.toString() << endl;
++      }
++
++      // update inside
++      if (!inside) {
++	  if (currInstr) inside = true;
++      }
++      else {
++	if (0) kdDebug() << "Check if 0x" << addr.toString() << " is in ]0x"
++			 << costAddr.toString() << ",0x"
++			 << (nextCostAddr - 3*Configuration::noCostInside()).toString()
++			 << "[" << endl;
++
++	  // Suppose a average instruction len of 3 bytes
++	  if ( (addr > costAddr) &&
++	       ((nextCostAddr==0) ||
++		(addr < nextCostAddr - 3*Configuration::noCostInside()) ))
++	      inside = false;
++      }
++
++      int context = Configuration::context();
++
++      if ( ((costAddr==0)     || (addr > costAddr + 3*context)) &&
++           ((nextCostAddr==0) || (addr < nextCostAddr - 3*context)) ) {
++
++	  // the very last skipLine can be ommitted
++	  if ((it == itEnd) &&
++	      (itEnd == function->instrMap()->end())) skipLineWritten=true;
++
++	  if (!skipLineWritten) {
++	      skipLineWritten = true;
++	      // a "skipping" line: print "..." instead of a line number
++	      code = cmd = TQString();
++	      args = TQString("...");
++	  }
++	  else
++	      continue;
++      }
++      else
++	  skipLineWritten = false;
++
++
++      ii = new InstrItem(this, this, addr, inside,
++                         code, cmd, args, currInstr);
++      dumpedLines++;
++      if (0) kdDebug() << "Dumped 0x" << addr.toString() << " "
++		       << (inside ? "Inside " : "Outside")
++		       << (currInstr ? "Cost" : "") << endl;
++
++      // no calls/jumps if we have no cost for this line
++      if (!currInstr) continue;
++
++      if (!selected &&
++	  (currInstr == _selectedItem) ||
++	  (currInstr->line() == _selectedItem)) selected = ii;
++
++      if (!first) first = ii;
++
++      if (currInstr->subCost(_costType) > most) {
++        item = ii;
++        most = currInstr->subCost(_costType);
++      }
++
++      ii->setOpen(true);
++      TraceInstrCallList list = currInstr->instrCalls();
++      TraceInstrCall* ic;
++      for (ic=list.first();ic;ic=list.next()) {
++	  if ((ic->subCost(_costType)==0) &&
++	      (ic->subCost(_costType2)==0)) continue;
++
++	  if (ic->subCost(_costType) > most) {
++	      item = ii;
++	      most = ic->subCost(_costType);
++	  }
++
++	  ii2 = new InstrItem(this, ii, addr, currInstr, ic);
++
++	  if (!selected && (ic->call()->called() == _selectedItem))
++	      selected = ii2;
++      }
++
++      TraceInstrJumpList jlist = currInstr->instrJumps();
++      TraceInstrJump* ij;
++      for (ij=jlist.first();ij;ij=jlist.next()) {
++	  if (ij->executedCount()==0) continue;
++
++	  new InstrItem(this, ii, addr, currInstr, ij);
++      }
++    }
++
++    if (selected) item = selected;
++    if (item) first = item;
++    if (first) {
++	ensureItemVisible(first);
++        _inSelectionUpdate = true;
++        setCurrentItem(first);
++        _inSelectionUpdate = false;
++    }
++
++    file.close();
++    pclose(iFILE);
++
++    // for arrows: go down the list according to list sorting
++    sort();
++    TQListViewItem *item1, *item2;
++    for (item1=firstChild();item1;item1 = item1->nextSibling()) {
++	ii = (InstrItem*)item1;
++	updateJumpArray(ii->addr(), ii, true, false);
++
++	for (item2=item1->firstChild();item2;item2 = item2->nextSibling()) {
++	    ii2 = (InstrItem*)item2;
++	    if (ii2->instrJump())
++		updateJumpArray(ii->addr(), ii2, false, true);
++	    else
++		ii2->setJumpArray(_jump);
++	}
++    }
++
++    if (arrowLevels())
++	setColumnWidth(3, 10 + 6*arrowLevels() + itemMargin() * 2);
++    else
++	setColumnWidth(3, 0);
++
++
++    if (noAssLines > 1) {
++	// trace cost not machting code
++
++	new InstrItem(this, this, 1,
++		      i18n("There is %n cost line without assembler code.",
++                           "There are %n cost lines without assembler code.", noAssLines));
++	new InstrItem(this, this, 2,
++		      i18n("This happens because the code of"));
++	new InstrItem(this, this, 3, TQString("        %1").arg(objfile));
++	new InstrItem(this, this, 4,
++		      i18n("does not seem to match the profile data file."));
++	new InstrItem(this, this, 5, "");
++	new InstrItem(this, this, 6,
++		      i18n("Are you using an old profile data file or is the above mentioned"));
++	new InstrItem(this, this, 7,
++		      i18n("ELF object from an updated installation/another machine?"));
++	new InstrItem(this, this, 8, "");
++	return false;
++    }
++
++    if (dumpedLines == 0) {
++	// no matching line read from popen
++	new InstrItem(this, this, 1,
++		      i18n("There seems to be an error trying to execute the command"));
++	new InstrItem(this, this, 2, "");
++	new InstrItem(this, this, 3, popencmd);
++	new InstrItem(this, this, 4, "");
++	new InstrItem(this, this, 5,
++		      i18n("Check that the ELF object used in the command exists."));
++	new InstrItem(this, this, 6,
++		      i18n("Check that you have installed 'objdump'."));
++	new InstrItem(this, this, 7,
++		      i18n("This utility can be found in the 'binutils' package."));
++	return false;
++    }
++
++    return true;
++}
++
++
++void InstrView::updateInstrItems()
++{
++    InstrItem* ii;
++    TQListViewItem* item  = firstChild();
++    for (;item;item = item->nextSibling()) {
++	ii = (InstrItem*)item;
++	TraceInstr* instr = ii->instr();
++	if (!instr) continue;
++
++	ii->updateCost();
++
++	TQListViewItem *next, *i  = ii->firstChild();
++	for (;i;i = next) {
++	    next = i->nextSibling();
++	    ((InstrItem*)i)->updateCost();
++	}
++    }
++}
++
++void InstrView::readViewConfig(KConfig* c, 
++			       TQString prefix, TQString postfix, bool)
++{
++    KConfigGroup* g = configGroup(c, prefix, postfix);
++
++    if (0) qDebug("InstrView::readViewConfig");
++
++    _showHexCode  = g->readBoolEntry("ShowHexCode", DEFAULT_SHOWHEXCODE);
++
++    delete g;
++}
++
++void InstrView::saveViewConfig(KConfig* c,
++			       TQString prefix, TQString postfix, bool)
++{
++    KConfigGroup g(c, (prefix+postfix).ascii());
++
++    writeConfigEntry(&g, "ShowHexCode", _showHexCode, DEFAULT_SHOWHEXCODE);
++}
++
++#include "instrview.moc"
+diff --git a/kdecachegrind/kdecachegrind/instrview.h b/kdecachegrind/kdecachegrind/instrview.h
+new file mode 100644
+index 0000000..79d3d76
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/instrview.h
+@@ -0,0 +1,83 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Instruction View
++ */
++
++#ifndef INSTRVIEW_H
++#define INSTRVIEW_H
++
++#include <tqlistview.h>
++#include "traceitemview.h"
++
++class InstrItem;
++
++class InstrView : public TQListView, public TraceItemView
++{
++  friend class InstrItem;
++
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  InstrView(TraceItemView* parentView,
++            TQWidget* parent = 0, const char* name = 0);
++
++  virtual TQWidget* widget() { return this; }
++  TQString whatsThis() const;
++
++  void readViewConfig(KConfig*, TQString prefix, TQString postfix, bool);
++  void saveViewConfig(KConfig*, TQString prefix, TQString postfix, bool);
++
++protected:
++  int arrowLevels() { return _arrowLevels; }
++  void paintEmptyArea( TQPainter *, const TQRect & );
++
++private slots:
++  void context(TQListViewItem*, const TQPoint &, int);
++  void selectedSlot(TQListViewItem *);
++  void activatedSlot(TQListViewItem *);
++
++private:
++  TraceItem* canShow(TraceItem*);
++  void doUpdate(int);
++  void refresh();
++  void setColumnWidths();
++  void fillInstr();
++  void updateJumpArray(Addr,InstrItem*,bool,bool);
++  bool fillInstrRange(TraceFunction*,
++                      TraceInstrMap::Iterator,TraceInstrMap::Iterator);
++  void updateInstrItems();
++
++  bool _inSelectionUpdate;
++
++  // arrows
++  int _arrowLevels;
++  // temporary needed on creation...
++  TQMemArray<TraceInstrJump*> _jump;
++  TraceInstrJumpList _lowList, _highList;
++
++  // remember width of hex code column if hidden
++  int _lastHexCodeWidth;
++
++  // widget options
++  bool _showHexCode;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/listutils.cpp b/kdecachegrind/kdecachegrind/listutils.cpp
+new file mode 100644
+index 0000000..0053646
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/listutils.cpp
+@@ -0,0 +1,266 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Some helper functions for TQListViewItem derivates
++ */
++
++#include <tqpainter.h>
++#include "listutils.h"
++
++#define COSTPIX_WIDTH 25
++
++TQPixmap colorPixmap(int w, int h, TQColor c)
++{
++  static TQPixmap* pixs[37];
++  static TQColor cols[37];
++  static bool inited = false;
++
++  if (!inited) {
++    for (int i=0;i<37;i++) pixs[i]=0;
++    inited = true;
++  }
++  int hash = (w+h+c.red()+c.green()+c.blue()) % 37;
++  if (pixs[hash]) {
++    if ((pixs[hash]->width() == w) &&
++        (pixs[hash]->height() == h) &&
++        (cols[hash] == c))
++      return *pixs[hash];
++
++    delete pixs[hash];
++  }
++
++
++  TQPixmap* pix = new TQPixmap(w, h);
++  pix->fill(c);
++  TQPainter p(pix);
++  p.setPen(c.light());
++  p.drawLine(0, 0, w-1, 0);
++  p.drawLine(0, 0, 0, h-1);
++  p.setPen(c.dark());
++  p.drawLine(w-1, 0, w-1, h-1);
++  p.drawLine(0, h-1, w-1, h-1);
++
++  pixs[hash] = pix;
++  cols[hash] = c;
++  return *pix;
++}
++
++/**
++ * Create a percentage pixmap with a filling rate of p percent (0-100).
++ * When withFrame==false, the pixmap is truncated to only the filled portion.
++ */
++TQPixmap percentagePixmap(int w, int h, int percent, TQColor c, bool framed)
++{
++  int iw, ix1, ix2, ih, iy1, iy2;
++
++  // inner rectangle to fill with bar
++  if (framed) {
++    iw = w-2, ix1 = 1, ix2 = w-2;
++    ih = h-2, iy1 = 1, iy2 = h-2;
++  }
++  else {
++    iw = w; ix1 = 0; ix2 = w-1;
++    ih = h; iy1 = 0; iy2 = h-1;
++  }
++
++  /* Limit bar to 100%  */
++  int filled = (percent>100) ? iw+1 : iw*percent/100+1;
++  if (!framed) w=filled-1;
++  if (w<3) return TQPixmap();
++
++  TQPixmap pix(w, h);
++  pix.fill(TQt::white);
++  TQPainter p(&pix);
++  p.setPen(TQt::black);
++  if (framed)
++    p.drawRect(0, 0, w, h);
++
++  // inside
++  p.setPen(TQt::NoPen);
++  p.setBrush(c);
++  p.drawRect(ix1, iy1, filled-1,ih);
++
++  // frame
++  ix2 = ix1+filled-2;
++  p.setPen(c.light());
++  p.drawLine(ix1, iy1, ix2, iy1);
++  p.drawLine(ix1, iy1, ix1, iy2);
++  p.setPen(c.dark());
++  p.drawLine(ix1+1, iy2, ix2, iy2);
++  p.drawLine(ix2, iy1, ix2, iy2);
++
++  return pix;
++}
++
++inline TQColor partitionColor(int d, int max)
++{
++  return TQColor( (720*d/max) % 360,
++                 255-(128*d/max), 192, TQColor::Hsv);
++}
++
++
++TQPixmap partitionPixmap(int w, int h,
++                        double* hist, TQColor* cArray, int maxIndex, bool framed)
++{
++  int lastPos = 0, nextPos;
++  double val=0.0, sum=0.0;
++  int d, dmin=maxIndex, dmax=0;
++  for (d = 0;d<maxIndex;d++)
++    if (hist[d]>0.0) {
++      sum += hist[d];
++      if (dmin>d) dmin = d;
++      if (dmax<d) dmax = d;
++    }
++
++  // inner rectangle to fill with bar
++  int iw, ix1, ix2, ih, iy1, iy2;
++  if (framed) {
++    iw = w-2, ix1 = 1, ix2 = w-2;
++    ih = h-2, iy1 = 1, iy2 = h-2;
++  }
++  else {
++    iw = w; ix1 = 0; ix2 = w-1;
++    ih = h; iy1 = 0; iy2 = h-1;
++  }
++
++  int filled = (int)(iw*sum+1);
++  if (!framed && (filled < w)) w=filled;
++  if (w<3) return TQPixmap();
++
++  TQPixmap pix(w, h);
++  pix.fill(TQt::white);
++  TQPainter p(&pix);
++  p.setPen(TQt::black);
++  if (framed)
++    p.drawRect(0, 0, w, h);
++
++  //qDebug("Sum %f, dw %d", sum,dw);
++
++  TQColor c, cLast;
++  bool leftDrawn = false;
++  int x1, x2=0;
++  int lastDiff=0, diff;
++  d=dmin;
++  while (d<dmax+1) {
++    val += hist[d];
++    nextPos = (int)(filled * val/sum);
++
++    //qDebug(" hist[%d] %f, val %f, nextPos %d", d, hist[d], val, nextPos);
++
++    diff = nextPos-lastPos;
++    if (diff==0) { d++; continue; }
++
++    c = cArray ? cArray[d] : partitionColor(d,maxIndex);
++
++    x1 = ix1+lastPos;
++    x2 = ix1+nextPos;
++    if (x2>=iw) x2=iw-1;
++
++    // inside
++    p.setPen(TQt::NoPen);
++    p.setBrush(c);
++    p.drawRect(x1, iy1, x2-x1+1, ih);
++
++    // lighter top border
++    p.setPen(c.light());
++    p.drawLine(x1, iy1, x2-1, iy1);
++
++    // when width for last and current distance >2, draw full 3D effect...
++    if (!leftDrawn) {
++      p.drawLine(x1, iy1+1, x1, iy2);
++      leftDrawn = true;
++    }
++
++    // darker bottom border
++    p.setPen(c.dark());
++    p.drawLine(x1, iy2, x2-1, iy2);
++
++    lastPos = nextPos;
++    lastDiff = diff;
++    cLast = c;
++    d++;
++  }
++
++  // right border (in last color)
++  if (x2>0)
++    p.drawLine(x2, iy1, x2, iy2);
++
++  return pix;
++}
++
++
++TQPixmap costPixmap(TraceCostType* ct, TraceCost* cost, double total, bool framed)
++{
++    if (ct->isReal()) {
++	TQColor color = ct->color();
++	double p = 100.0 * cost->subCost(ct) / total;
++	return percentagePixmap(COSTPIX_WIDTH, 10, (int)(p+.5), color, framed);
++    }
++
++    int maxIndex;
++    double h[MaxRealIndexValue];
++    TQColor* cs = ct->mapping()->realColors();
++    maxIndex = ct->histCost(cost, total, h);
++
++    if (maxIndex ==0) return TQPixmap();    
++    return partitionPixmap(COSTPIX_WIDTH, 10, h, cs, maxIndex, framed);
++}
++
++
++
++// HighestCostList
++
++HighestCostList::HighestCostList()
++{
++    _maxSize = 0;
++    _count = 0;
++    _costType = 0;
++}
++
++void HighestCostList::clear(int maxSize)
++{
++    _maxSize = maxSize;
++    _count = 0;
++    _item.resize(maxSize);
++    _cost.resize(maxSize);
++}
++
++void HighestCostList::addCost(TraceCost* c, SubCost cost)
++{
++    int i;
++
++    _count++;
++    if (_count > _maxSize) {
++	if (_cost[_maxSize-1] >= cost) return;
++	i = _maxSize-1;
++    }
++    else i = _count-1;
++
++    for(; i>0; i--) {
++	if (_cost[i-1] >= cost) break;
++	else {
++	    _cost[i] = _cost[i-1];
++	    _item[i] = _item[i-1];
++	}
++    }
++    _cost[i] = cost;
++    _item[i] = c;
++}
++
++	    
+diff --git a/kdecachegrind/kdecachegrind/listutils.h b/kdecachegrind/kdecachegrind/listutils.h
+new file mode 100644
+index 0000000..e3e13fb
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/listutils.h
+@@ -0,0 +1,65 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Some helper functions for TQListViewItem derivates
++ */
++
++#ifndef LISTUTILS_H
++#define LISTUTILS_H
++
++#include <tqpixmap.h>
++#include <tqstring.h>
++#include <tqcolor.h>
++#include "tracedata.h"
++
++TQString bigNum(SubCost);
++TQPixmap colorPixmap(int w, int h, TQColor c);
++TQPixmap percentagePixmap(int w, int h, int percent, TQColor c, bool framed);
++TQPixmap partitionPixmap(int w, int h, double* hist, TQColor*,
++			int maxIndex, bool framed);
++TQPixmap costPixmap(TraceCostType* ct, TraceCost* cost, double total, bool framed);
++
++/**
++ * A class to calculate the <maxSize> TraceCost items
++ * with highest cost.
++ */
++
++class HighestCostList
++{
++ public:
++    HighestCostList();
++    
++    void clear(int maxSize);
++    void addCost(TraceCost*, SubCost);
++    int count() { return _count; }
++    int realCount() { return (_count > _maxSize) ? _maxSize:_count; }
++    int maxSize() { return _maxSize; }
++    bool hasMore() { return _count > _maxSize; }
++    TraceCost* operator[] (int i)
++	{ return (i>=0 && i<_count && i<_maxSize) ? _item[i] : 0; }
++    
++ private:
++    TraceCostList _list;
++    int _maxSize, _count;
++    TraceCostType* _costType;
++    TQMemArray<TraceCost*> _item;
++    TQMemArray<SubCost> _cost;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/lo16-app-kcachegrind.png b/kdecachegrind/kdecachegrind/lo16-app-kcachegrind.png
+new file mode 100644
+index 0000000..0985586
+Binary files /dev/null and b/kdecachegrind/kdecachegrind/lo16-app-kcachegrind.png differ
+diff --git a/kdecachegrind/kdecachegrind/lo32-app-kcachegrind.png b/kdecachegrind/kdecachegrind/lo32-app-kcachegrind.png
+new file mode 100644
+index 0000000..12542c8
+Binary files /dev/null and b/kdecachegrind/kdecachegrind/lo32-app-kcachegrind.png differ
+diff --git a/kdecachegrind/kdecachegrind/loader.cpp b/kdecachegrind/kdecachegrind/loader.cpp
+new file mode 100644
+index 0000000..a4aecf5
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/loader.cpp
+@@ -0,0 +1,85 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Base class for loaders of profiling data.
++ */
++
++#include "loader.h"
++
++
++/// Loader
++
++LoaderList Loader::_loaderList;
++
++Loader::Loader(TQString name, TQString desc)
++{
++  _name = name;
++  _description = desc;
++}
++
++Loader::~Loader()
++{}
++
++bool Loader::canLoadTrace(TQFile*)
++{
++  return false;
++}
++
++bool Loader::loadTrace(TracePart*)
++{
++  return false;
++}
++
++Loader* Loader::matchingLoader(TQFile* file)
++{
++  Loader* l;
++  for (l=_loaderList.first(); l; l = _loaderList.next())
++    if (l->canLoadTrace(file))
++      return l;
++
++  return 0;
++}
++
++Loader* Loader::loader(TQString name)
++{
++  Loader* l;
++  for (l=_loaderList.first(); l; l = _loaderList.next())
++    if (l->name() == name)
++      return l;
++
++  return 0;
++}
++
++// factories of available loaders
++Loader* createCachegrindLoader();
++
++void Loader::initLoaders()
++{
++  _loaderList.append(createCachegrindLoader());
++  //_loaderList.append(GProfLoader::createLoader());
++}
++
++void Loader::deleteLoaders()
++{
++  _loaderList.setAutoDelete(true);
++  _loaderList.clear();
++}
++
++
++#include "loader.moc"
+diff --git a/kdecachegrind/kdecachegrind/loader.h b/kdecachegrind/kdecachegrind/loader.h
+new file mode 100644
+index 0000000..f79f13d
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/loader.h
+@@ -0,0 +1,80 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Base class for loaders of profiling data.
++ */
++
++#ifndef LOADER_H
++#define LOADER_H
++
++#include <tqobject.h>
++#include <tqptrlist.h>
++#include <tqstring.h>
++
++class TQFile;
++class TraceData;
++class TracePart;
++class Loader;
++
++
++typedef TQPtrList<Loader> LoaderList;
++
++/**
++ * To implement a new loader, inherit from the Loader class
++ * and implement canLoadTrace(), loadTrace() and if a trace in
++ * this format can consist out of multiple parts, implement
++ * isPartOfTrace(), too.
++ * For registration, put into the static initLoaders() function
++ * of this base class a _loaderList.append(new MyLoader()).
++ *
++ * KCachegrind will use the first matching loader.
++ */
++
++class Loader: public TQObject
++{
++    Q_OBJECT
++  TQ_OBJECT
++
++public:
++  Loader(TQString name, TQString desc);
++  virtual ~Loader();
++
++  virtual bool canLoadTrace(TQFile* file);
++  virtual bool loadTrace(TracePart*);
++
++  static Loader* matchingLoader(TQFile* file);
++  static Loader* loader(TQString name);
++  static void initLoaders();
++  static void deleteLoaders();
++
++  TQString name() const { return _name; }
++  TQString description() const { return _description; }
++
++signals:
++  void updateStatus(TQString, int);
++
++private:
++  TQString _name, _description;
++
++  static LoaderList _loaderList;
++};
++
++
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/main.cpp b/kdecachegrind/kdecachegrind/main.cpp
+new file mode 100644
+index 0000000..fd9df1b
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/main.cpp
+@@ -0,0 +1,95 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * KCachegrind startup
++ */
++
++// for KCACHEGRIND_VERSION
++#include "../version.h"
++
++#include <tqfile.h>
++#include <kapplication.h>
++#include <kcmdlineargs.h>
++#include <kaboutdata.h>
++#include <klocale.h>
++
++#include "toplevel.h"
++#include "tracedata.h"
++#include "loader.h"
++
++static KCmdLineOptions options[] =
++{
++  { "r <exec>", I18N_NOOP("Run <exec> under cachegrind"), 0 },
++  { "+[trace]", I18N_NOOP("Show information of this trace"), 0 },
++  KCmdLineLastOption // End of options.
++};
++
++int main( int argc, char ** argv )
++{
++  KAboutData aboutData("kdecachegrind",
++                       I18N_NOOP("KCachegrind"),
++                       KCACHEGRIND_VERSION,
++                       I18N_NOOP("KDE Frontend for Cachegrind"),
++                       KAboutData::License_GPL,
++                       I18N_NOOP("(C) 2002, 2003, 2004"), 0,
++		       "http://kdecachegrind.sf.net");
++  aboutData.addAuthor("Josef Weidendorfer",
++                      I18N_NOOP("Author/Maintainer"),
++                      "Josef.Weidendorfer@gmx.de");
++
++  KCmdLineArgs::init(argc, argv, &aboutData);
++  KCmdLineArgs::addCmdLineOptions( options );
++
++  KApplication a;
++  TopLevel* t;
++  Loader::initLoaders();
++
++  if (a.isRestored()){
++    int n = 1;
++    while (KMainWindow::canBeRestored(n)){
++      (new TopLevel())->restore(n);
++      n++;
++    }
++  }
++  else {
++    KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
++    if (args->count()>0) {
++      for(int i = 0; i < args->count(); i++) {
++        t = new TopLevel();
++        t->show();
++        t->loadDelayed(TQFile::decodeName(args->arg(i)));
++      }
++    }
++    else {
++      // load trace in current dir
++      t = new TopLevel();
++      t->show();
++      t->loadDelayed(".");
++    }
++  }
++
++  a.connect( &a, TQT_SIGNAL( lastWindowClosed() ), &a, TQT_SLOT( quit() ) );
++  int res = a.exec();
++
++  // to make leak checking in valgrind happy...
++  Loader::deleteLoaders();
++  TraceItem::cleanup();
++
++  return res;
++}
+diff --git a/kdecachegrind/kdecachegrind/multiview.cpp b/kdecachegrind/kdecachegrind/multiview.cpp
+new file mode 100644
+index 0000000..4288e2d
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/multiview.cpp
+@@ -0,0 +1,224 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * MultiView, enclosing multiple TabView's with a user choosable
++ * active view (i.e. focus), separated by a splitter.
++ * Selection of the active view is shown in the next to the right view
++ * (with wrap around).
++ */
++
++#include <tqobjectlist.h>
++#include <kconfig.h>
++#include <kdebug.h>
++
++#include "multiview.h"
++#include "tabview.h"
++
++//
++// MultiView
++//
++
++MultiView::MultiView(TopLevel* top, TQWidget* parent, const char* name)
++    : TQSplitter(parent, name), TraceItemView(0, top)
++{
++  // default
++  setOrientation(Qt::Horizontal);
++
++    appendView();
++    _active = _views.first();
++    _active->setActive(true);
++}
++
++void MultiView::setData(TraceData* d)
++{
++  TraceItemView::setData(d);
++
++  TabView* tv;
++  for(tv=_views.first(); tv; tv=_views.next())
++    tv->setData(d);
++}
++
++void MultiView::setChildCount(int n)
++{
++    while(n< (int)_views.count()) removeView();
++    while(n> (int)_views.count()) appendView();
++}
++
++void MultiView::appendView()
++{
++    int n = _views.count()+1;
++
++    TabView* tv = new TabView(this, this,
++			      TQString("TabView-%1").arg(n).ascii());
++    connect(tv, TQT_SIGNAL(activated(TabView*)),
++	    this, TQT_SLOT(tabActivated(TabView*)) );
++    _views.append(tv);
++    tv->show();
++
++    // set same attributes as in active view
++    tv->set(0, _data, _costType, _costType2,
++	    _groupType, _partList, _activeItem, 0);
++    tv->updateView();
++
++    if (0) kdDebug() << "MultiView::appendView, now "
++		     << _views.count() << endl;
++}
++
++void MultiView::removeView()
++{
++    if (_views.count()<=1) return;
++
++    TabView* last = _views.last();
++
++    // if last tab is active, make first active
++    if (last == _active) {
++	TabView* newActive = _views.first();
++	newActive->setActive(true);
++	tabActivated(newActive);
++    }
++
++    _views.removeRef(last);
++    delete last;
++
++    if (0) kdDebug() << "MultiView::removeView, now "
++		     << _views.count() << endl;
++}
++
++
++void MultiView::tabActivated(TabView* newActiveTab)
++{
++    if (_active == newActiveTab) return;
++
++    if (0) kdDebug() << "MultiView::tabActivated " 
++		     << newActiveTab->name() << endl;
++
++    TraceItem* oldActiveItem = 0;
++    if (_active) {
++	oldActiveItem = _active->activeItem();
++	_active->setActive(false);
++    }
++    _active = newActiveTab;
++
++    // make the active item of the new TabView active
++    if (_active && (oldActiveItem != _active->activeItem()))
++	TraceItemView::activated(_active->activeItem());
++}
++
++void MultiView::selected(TraceItemView* sender, TraceItem* i)
++{
++    if (0) kdDebug() << "MultiView::selected " << i->name()
++		     << ", sender " << sender->widget()->name() << endl;
++
++     // we react only on selection changes of the active TabView
++    if (sender != (TraceItemView*)_active) return;
++
++    _views.findRef(_active);
++    TabView* next = _views.next();
++    if (!next) next = _views.first();
++
++    // don't change item of active tab
++    if (next == _active) return;
++
++    next->activate(i);
++    next->updateView();
++}
++
++void MultiView::activated(TraceItemView* sender, TraceItem* i)
++{
++    if (0) kdDebug() << "MultiView::activated " << i->name()
++		     << ", sender " << sender->widget()->name() << endl;
++
++    // we react only on selection changes of the active TabView
++    if (sender != (TraceItemView*)_active) return;
++
++    TraceItemView::activated(sender,i);
++}
++
++void MultiView::doUpdate(int changeType)
++{
++    TabView* tv;
++    for(tv=_views.first(); tv; tv=_views.next()) {
++	tv->set(changeType, _data, _costType, _costType2,
++		_groupType, _partList,
++		(tv == _active) ? _activeItem : tv->activeItem(),
++		tv->selectedItem());
++	tv->notifyChange(changeType);
++	if (tv->isViewVisible())
++	    tv->updateView();
++    }
++}
++
++
++void MultiView::readViewConfig(KConfig* c,
++			       TQString prefix, TQString postfix,
++			       bool withOptions)
++{
++  if (0) qDebug("%s::readConfig(%s%s)", name(),
++		prefix.ascii(), postfix.ascii());
++
++  TQString active;
++  KConfigGroup* g = configGroup(c, prefix, postfix);
++  int n = g->readNumEntry("Panels", 1);
++  setChildCount(n);
++  setOrientation( (g->readEntry("Orientation") == TQString("Horizontal")) ?
++		  Qt::Horizontal : Qt::Vertical );
++  
++  setSizes(g->readIntListEntry("PanelSizes"));
++  
++  active = g->readEntry("ActivePanel", "");
++  delete g;
++
++  TabView* tv, *activeTV = 0;
++  for(tv=_views.first();tv;tv=_views.next()) {
++    if (tv->name() == active) activeTV=tv;
++    tv->readViewConfig(c, TQString("%1-%2").arg(prefix).arg(tv->name()),
++		       postfix, withOptions);
++  }
++
++  // activate panel after restoring
++  if (!activeTV) activeTV = _views.first();
++  
++  if (_active == activeTV)
++    TraceItemView::activated(_active->activeItem());
++  else
++    activeTV->setActive(true);
++}
++
++void MultiView::saveViewConfig(KConfig* c, 
++			       TQString prefix, TQString postfix,
++			       bool withOptions)
++{
++  KConfigGroup g(c, (prefix+postfix).ascii());
++  
++  g.writeEntry("Panels", childCount());
++  g.writeEntry("Orientation",
++	       (orientation() == Qt::Horizontal) ?
++	       "Horizontal" : "Vertical");
++  
++  g.writeEntry("PanelSizes", sizes());
++  g.writeEntry("ActivePanel", _active ? _active->name() : "none");
++
++  TabView* tv;
++  for(tv=_views.first();tv;tv=_views.next())
++    tv->saveViewConfig(c, TQString("%1-%2").arg(prefix).arg(tv->name()),
++		       postfix, withOptions);
++}
++
++
++#include "multiview.moc"
+diff --git a/kdecachegrind/kdecachegrind/multiview.h b/kdecachegrind/kdecachegrind/multiview.h
+new file mode 100644
+index 0000000..9d77101
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/multiview.h
+@@ -0,0 +1,67 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * MultiView, enclosing multiple (default: 2) TabView's with a user
++ * choosable active view (i.e. focus). This is a splitter itself.
++ * Selection of the active view is shown in the next to the right view
++ * (with wrap around).
++ */
++
++#ifndef MULTIVIEW_H
++#define MULTIVIEW_H
++
++#include <tqsplitter.h>
++#include <tqptrlist.h>
++#include "traceitemview.h"
++#include "tabview.h" // because of TQPtrList<TabView>
++
++class MultiView : public TQSplitter, public TraceItemView
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  MultiView(TopLevel* top, TQWidget* parent = 0, const char* name = 0);
++
++  TQWidget* widget() { return this; }
++  TabView* activeTabView() const { return _active; }
++  void setData(TraceData*);
++
++  void appendView();
++  void removeView();
++  void setChildCount(int);
++  int childCount() { return _views.count(); }
++
++  void selected(TraceItemView*, TraceItem*);
++  void activated(TraceItemView*, TraceItem*);
++
++  void readViewConfig(KConfig*, TQString prefix, TQString postfix, bool);
++  void saveViewConfig(KConfig*, TQString prefix, TQString postfix, bool);
++
++public slots:
++    void tabActivated(TabView*);
++
++ private:
++  void doUpdate(int);
++
++  TabView* _active;
++  TQPtrList<TabView> _views;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/partgraph.cpp b/kdecachegrind/kdecachegrind/partgraph.cpp
+new file mode 100644
+index 0000000..a20f53d
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/partgraph.cpp
+@@ -0,0 +1,534 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * TracePart as Nested Area
++ */
++
++#include <klocale.h>
++
++#include "partgraph.h"
++#include "configuration.h"
++#include "listutils.h"
++
++
++// PartAreaWidget
++
++PartAreaWidget::PartAreaWidget(TQWidget* parent, const char* name)
++    : TreeMapWidget(new BasePartItem(), parent, name)
++{
++  _data = 0;
++  _function = 0;
++
++  _costType = 0;
++  _groupType = TraceCost::NoCostType;
++  _visualisation = NoVisualisation;
++  _zoomFunction = false;
++  _callLevels = 1;
++}
++
++void PartAreaWidget::setData(TraceData* data)
++{
++  if (data == _data) return;
++
++  _data = data;
++  _function = 0;
++  _hiddenParts.clear();
++
++  ((BasePartItem*)base())->setData(data);
++}
++
++void PartAreaWidget::changeHidden(const TracePartList& list)
++{
++  _hiddenParts = list;
++  base()->refresh();
++}
++
++
++void PartAreaWidget::setCostType(TraceCostType* ct)
++{
++  _costType = ct;
++
++  // this resizes items
++  base()->redraw();
++}
++
++void PartAreaWidget::setVisualisation(VisualisationMode m)
++{
++  _visualisation = m;
++  refreshParts();
++}
++
++void PartAreaWidget::setZoomFunction(bool zoomFunction)
++{
++  _zoomFunction = zoomFunction;
++  refreshParts();
++}
++
++void PartAreaWidget::setCallLevels(int callLevels)
++{
++  _callLevels = callLevels;
++  refreshParts();
++}
++
++void PartAreaWidget::refreshParts()
++{
++  // rebuild only subparts to keep part selection state
++  TreeMapItem* i;
++  TreeMapItemList* l = base()->children();
++  if (l)
++    for (i=l->first();i;i=l->next())
++      i->refresh();
++
++  // but resize part areas
++  base()->redraw();
++}
++
++
++void PartAreaWidget::setFunction(TraceFunction* f)
++{
++  _function = f;
++
++  if (_visualisation == PartAreaWidget::Inclusive)
++    refreshParts();
++}
++
++void PartAreaWidget::setGroupType(TraceCost::CostType gt)
++{
++  _groupType = gt;
++
++  // rebuild hierarchy below parts.
++  // thus, selected parts stay selected
++  TreeMapItem* i;
++  TreeMapItemList* l = base()->children();
++  if (l)
++    for (i=l->first();i;i=l->next())
++      i->refresh();
++
++  base()->redraw();
++}
++
++bool PartAreaWidget::isHidden(TracePart* part) const
++{
++  return (_hiddenParts.containsRef(part)>0);
++}
++
++TQColor PartAreaWidget::groupColor(TraceFunction* f) const
++{
++  if (!f)
++    return colorGroup().button();
++
++  return Configuration::functionColor(_groupType, f);
++}
++
++TQString PartAreaWidget::tipString(TreeMapItem* i) const
++{
++  TQString tip, itemTip;
++  int count = 0;
++
++  //qDebug("PartAreaWidget::tipString for '%s'", i->name().ascii());
++
++  // first, SubPartItem's
++  while (i && count<Configuration::maxSymbolCount() && i->rtti() == 3) {
++    itemTip = i->text(0);
++    if ((int)itemTip.length()>Configuration::maxSymbolLength())
++      itemTip = itemTip.left(Configuration::maxSymbolLength()) + "...";
++
++    if (!i->text(1).isEmpty())
++      itemTip += " (" + i->text(1) + ")";
++
++    if (!tip.isEmpty())
++      itemTip += "\n";
++
++    tip = itemTip + tip;
++    i = i->parent();
++    count++;
++  }
++
++  // skip to part
++  while (i && i->rtti()==3) i = i->parent();
++
++  if (i && i->rtti()==2) {
++    itemTip = i18n("Profile Part %1").arg(i->text(0));
++    if (!i->text(1).isEmpty())
++        itemTip += " (" + i->text(1) + ")";
++
++    if (!tip.isEmpty())
++      itemTip += "\n";
++
++    tip = itemTip + tip;
++  }
++
++//  qDebug("PartAreaWidget:: tip %s, itemTip %s",
++//         tip.ascii(), itemTip.ascii());
++
++  return tip;
++}
++
++
++
++
++
++// BasePartItem
++
++BasePartItem::BasePartItem()
++  : TreeMapItem()
++{
++  _data = 0;
++  setSorting(-1);
++}
++
++void BasePartItem::setData(TraceData* data)
++{
++  if (data == _data) return;
++
++  _data = data;
++  refresh();
++}
++
++TreeMapItemList* BasePartItem::children()
++{
++  if (!_data) return _children;
++
++  if (!initialized()) {
++//    qDebug("Create Parts (%s)", name().ascii());
++
++    PartAreaWidget* w = (PartAreaWidget*) widget();
++    TracePart* part;
++    TracePartList l = _data->parts();
++    for (part=l.first();part;part=l.next())
++      if (!w->isHidden(part))
++        addItem(new PartItem(part));
++  }
++
++  return _children;
++}
++
++TQString BasePartItem::text(int textNo) const
++{
++  if (textNo == 0) {
++    if (!_data)
++      return i18n("(no trace)");
++
++    if (_data->parts().count() == 0)
++      return i18n("(no part)");
++  }
++  return TQString();
++}
++
++
++TQColor BasePartItem::backColor() const
++{
++  return widget()->colorGroup().base();
++}
++
++double BasePartItem::value() const
++{
++  if (!_data) return 0;
++
++  PartAreaWidget* w = (PartAreaWidget*) widget();
++  return (double)_data->subCost(w->costType());
++}
++
++
++
++
++
++// PartItem
++
++PartItem::PartItem(TracePart* p)
++{
++  _p = p;
++  _factor=1;
++}
++
++TQString PartItem::text(int textNo) const
++{
++  if (textNo == 0)
++    return _p->prettyName();
++
++  if (textNo != 1)
++    return TQString();
++
++  TraceCostType* ct;
++  PartAreaWidget* w = (PartAreaWidget*)widget();
++  SubCost v;
++
++  ct = w->costType();
++  v = _p->subCost(ct);
++
++  if (Configuration::showPercentage()) {
++    TraceCost* t = _p->data()->totals();
++    double p  = 100.0 * v / t->subCost(ct);
++    return TQString("%1 %")
++      .arg(p, 0, 'f', Configuration::percentPrecision());
++  }
++  return v.pretty();
++}
++
++
++TQPixmap PartItem::pixmap(int i) const
++{
++    if (i != 1) return TQPixmap();
++
++    // Cost pixmap
++
++    TraceCostType* ct = ((PartAreaWidget*)widget())->costType();
++    return costPixmap( ct, _p, (double) (_p->data()->totals()->subCost(ct)), false );
++}
++
++
++double PartItem::value() const
++{
++  PartAreaWidget* w = (PartAreaWidget*)widget();
++  TraceCostType* ct = w->costType();
++  if ((w->visualisation() == PartAreaWidget::Inclusive) &&
++      w->zoomFunction()) {
++
++    // use value of zoomed function
++    TraceFunction* f = w->function();
++    if (f) {
++      TracePartFunction* pf = (TracePartFunction*) f->findDepFromPart(_p);
++      if (pf)
++        return (double) pf->inclusive()->subCost(ct);
++      // when function is not available in part, hide part
++      return 0.0;
++    }
++  }
++  return (double) _p->subCost(ct);
++}
++
++double PartItem::sum() const
++{
++  PartAreaWidget* w = (PartAreaWidget*)widget();
++  if (w->visualisation() == PartAreaWidget::Inclusive) {
++    double s = value();
++    //qDebug("PartItem::sum [part %s]: %d", _p->name().ascii(), s);
++    return s;
++  }
++  return 0.0;
++}
++
++TreeMapItemList* PartItem::children()
++{
++  if (initialized()) return _children;
++
++  TraceCost* c;
++//    qDebug("Create Part subitems (%s)", name().ascii());
++
++  PartAreaWidget* w = (PartAreaWidget*)widget();
++  if (w->visualisation() == PartAreaWidget::Inclusive) {
++    TraceFunction* f = w->function();
++    if (f) {
++      c = f->findDepFromPart(_p);
++      if (c) addItem(new SubPartItem(c));
++    }
++
++    return _children;
++  }
++
++
++  switch( ((PartAreaWidget*)widget())->groupType() ) {
++
++  case TraceCost::Object:
++  {
++    TraceObjectMap::Iterator it;
++    for ( it = _p->data()->objectMap().begin();
++          it != _p->data()->objectMap().end(); ++it ) {
++      c = (*it).findDepFromPart(_p);
++      if (c)
++        addItem(new SubPartItem(c));
++    }
++  }
++  break;
++
++  case TraceCost::Class:
++  {
++    TraceClassMap::Iterator it;
++    for ( it = _p->data()->classMap().begin();
++          it != _p->data()->classMap().end(); ++it ) {
++      c = (*it).findDepFromPart(_p);
++      if (c)
++        addItem(new SubPartItem(c));
++    }
++  }
++  break;
++
++  case TraceCost::File:
++  {
++    TraceFileMap::Iterator it;
++    for ( it = _p->data()->fileMap().begin();
++          it != _p->data()->fileMap().end(); ++it ) {
++      c = (*it).findDepFromPart(_p);
++      if (c)
++        addItem(new SubPartItem(c));
++    }
++  }
++  break;
++
++  case TraceCost::Function:
++  {
++    TraceFunctionMap::Iterator it;
++    for ( it = _p->data()->functionMap().begin();
++          it != _p->data()->functionMap().end(); ++it ) {
++      c = (*it).findDepFromPart(_p);
++      if (c)
++        addItem(new SubPartItem(c));
++    }
++  }
++  break;
++
++  default:
++    break;
++  }
++
++  return _children;
++}
++
++
++TQColor PartItem::backColor() const
++{
++  PartAreaWidget* w = (PartAreaWidget*)widget();
++  return w->groupColor(0);
++}
++
++
++// SubPartItem
++
++SubPartItem::SubPartItem(TraceCost* c)
++{
++  _partCostItem = c;
++  _factor=1;
++}
++
++TQString SubPartItem::text(int textNo) const
++{
++  if (textNo == 0) {
++    if (!_partCostItem)
++      return i18n("(unknown)");
++
++    return _partCostItem->dependant()->prettyName();
++  }
++
++  if (textNo != 1)
++    return TQString();
++
++  TraceCostType* ct;
++  PartAreaWidget* w = (PartAreaWidget*)widget();
++  SubCost v;
++
++  ct = w->costType();
++  if (w->visualisation() == PartAreaWidget::Inclusive)
++    v = ((TracePartFunction*)_partCostItem)->inclusive()->subCost(ct);
++  else
++    v = _partCostItem->subCost(ct);
++
++  if (Configuration::showPercentage()) {
++    TraceCost* t = Configuration::showExpanded() ?
++	_partCostItem->part() : _partCostItem->part()->data()->totals();
++    double p  = 100.0 * v / t->subCost(ct);
++    return TQString("%1 %")
++      .arg(p, 0, 'f', Configuration::percentPrecision());
++  }
++  return v.pretty();
++}
++
++TQPixmap SubPartItem::pixmap(int i) const
++{
++    if (i != 1) return TQPixmap();
++
++    // Cost pixmap
++
++    PartAreaWidget* w = (PartAreaWidget*)widget();
++    TraceCostType* ct = w->costType();
++    TraceCost* t = Configuration::showExpanded() ?
++	_partCostItem->part() : _partCostItem->part()->data()->totals();
++    TraceCost* c;
++    if (w->visualisation() == PartAreaWidget::Inclusive)
++	c = ((TracePartFunction*)_partCostItem)->inclusive();
++    else
++	c = _partCostItem;
++
++    return costPixmap( ct, c, (double) (t->subCost(ct)), false );
++}
++
++double SubPartItem::value() const
++{
++  TraceCostType* ct;
++  PartAreaWidget* w = (PartAreaWidget*)widget();
++
++  ct = w->costType();
++  if (w->visualisation() == PartAreaWidget::Inclusive)
++    return (double)
++	((TracePartFunction*)_partCostItem)->inclusive()->subCost(ct);
++
++  return (double) _partCostItem->subCost(ct);
++}
++
++double SubPartItem::sum() const
++{
++  PartAreaWidget* w = (PartAreaWidget*)widget();
++  if (w->visualisation() == PartAreaWidget::Inclusive) {
++    double s = value();
++    //qDebug("SubPartItem::sum [Cost %s]: %d", _cost->name().ascii(), s);
++    return s;
++  }
++  return 0.0;
++}
++
++TreeMapItemList* SubPartItem::children()
++{
++  if (!initialized()) {
++//    qDebug("Create Part sub-subitems (%s)", name().ascii());
++
++    PartAreaWidget* w = (PartAreaWidget*)widget();
++
++    if (depth()-2 > w->callLevels())
++      return _children;
++
++    if (w->visualisation() == PartAreaWidget::Inclusive) {
++      TracePartCall* call;
++      TracePartCallList l;
++
++      setSum(value());
++
++      l = ((TracePartFunction*)_partCostItem)->partCallings();
++      for (call=l.first();call;call=l.next()) {
++        TraceFunction* called = call->call()->called();
++        TraceCost* partCalled = called->findDepFromPart(call->part());
++        if (partCalled)
++          addItem(new SubPartItem(partCalled));
++      }
++    }
++  }
++
++  return _children;
++}
++
++
++TQColor SubPartItem::backColor() const
++{
++  PartAreaWidget* w = (PartAreaWidget*)widget();
++  if (w->visualisation() == PartAreaWidget::Inclusive)
++    return w->groupColor((TraceFunction*)(_partCostItem->dependant()));
++
++  return Configuration::groupColor(_partCostItem->dependant());
++}
++
++
++#include "partgraph.moc"
+diff --git a/kdecachegrind/kdecachegrind/partgraph.h b/kdecachegrind/kdecachegrind/partgraph.h
+new file mode 100644
+index 0000000..f28f12e
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/partgraph.h
+@@ -0,0 +1,132 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * TracePart Graph
++ */
++
++#ifndef PARTGRAPH_H
++#define PARTGRAPH_H
++
++#include "treemap.h"
++#include "tracedata.h"
++
++class PartAreaWidget: public TreeMapWidget
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  // Visualisation inside of trace parts
++  enum VisualisationMode { NoVisualisation, Partitioning, Inclusive };
++
++  PartAreaWidget(TQWidget* parent=0, const char* name=0);
++
++  void setData(TraceData* d);
++  void setCostType(TraceCostType* ct);
++  void setGroupType(TraceCost::CostType gt);
++  void setVisualisation(VisualisationMode);
++  void setZoomFunction(bool zoomFunction);
++  void setCallLevels(int callLevels);
++  void setFunction(TraceFunction* f);
++
++  TraceCostType* costType() const { return _costType; }
++  TraceCost::CostType groupType() const { return _groupType; }
++  TraceFunction* function() const { return _function; }
++  VisualisationMode visualisation() const { return _visualisation; }
++  bool zoomFunction() const { return _zoomFunction; }
++  int callLevels() const { return _callLevels; }
++
++  TQColor groupColor(TraceFunction*) const;
++  TQString tipString(TreeMapItem*) const;
++
++  void changeHidden(const TracePartList& list);
++  bool isHidden(TracePart*) const;
++
++private:
++  void refreshParts();
++
++  TraceData* _data;
++  TraceCostType* _costType;
++  TraceCost::CostType _groupType;
++  TraceFunction* _function;
++  VisualisationMode _visualisation;
++  bool _zoomFunction;
++  int _callLevels;
++
++  TracePartList _hiddenParts;
++};
++
++class BasePartItem: public TreeMapItem
++{
++public:
++  BasePartItem();
++
++  void setData(TraceData* d);
++
++  int rtti() const { return 1; }
++  double value() const;
++  TQString text(int) const;
++  int borderWidth() const { return 0; }
++  TreeMapItemList* children();
++  TQColor backColor() const;
++
++private:
++  TraceData* _data;
++};
++
++class PartItem: public TreeMapItem
++{
++public:
++  PartItem(TracePart* p);
++  int rtti() const { return 2; }
++  TracePart* part() { return _p; }
++  double value() const;
++  double sum() const;
++  int borderWidth() const { return 0; }
++  TQString text(int) const;
++  TQPixmap pixmap(int) const;
++  TreeMapItemList* children();
++  TQColor backColor() const;
++
++private:
++  TracePart* _p;
++  unsigned int _factor;
++};
++
++class SubPartItem: public TreeMapItem
++{
++public:
++  SubPartItem(TraceCost*);
++  int rtti() const { return 3; }
++  TraceCost* partCostItem() { return _partCostItem; }
++  double value() const;
++  double sum() const;
++  SplitMode splitMode() const { return Vertical; }
++  TQString text(int) const;
++  TQPixmap pixmap(int) const;
++  TreeMapItemList* children();
++  TQColor backColor() const;
++
++private:
++  TraceCost* _partCostItem;
++  unsigned int _factor;
++};
++
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/partlistitem.cpp b/kdecachegrind/kdecachegrind/partlistitem.cpp
+new file mode 100644
+index 0000000..40c2db3
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/partlistitem.cpp
+@@ -0,0 +1,189 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++#include <math.h>
++
++#include <tqpainter.h>
++#include <tqregexp.h>
++
++#include <klocale.h>
++#include <kiconloader.h>
++#include <kapplication.h>
++
++#include "listutils.h"
++#include "partlistitem.h"
++#include "coverage.h"
++#include "configuration.h"
++
++
++// PartListItem
++
++PartListItem::PartListItem(TQListView* parent, TraceCostItem* costItem,
++                           TraceCostType* ct, TraceCost::CostType gt,
++			   TracePart* part)
++  :TQListViewItem(parent)
++{
++  _partCostItem = costItem->findDepFromPart(part);
++  _part = part;
++  _groupType = gt;
++  _costType = ct;
++
++#if 0
++  TQString partName = TQString::number(part->partNumber());
++  if (part->data()->maxThreadID() >1)
++      partName += i18n(" (Thread %1)").arg(part->threadID());
++  setText(0, partName);
++#else
++  setText(0, _part->prettyName());
++#endif
++
++  if (_part->trigger().isEmpty())
++    setText(4,i18n("(none)"));
++  else
++    setText(4, _part->trigger());
++
++  update();
++}
++
++void PartListItem::setCostType(TraceCostType* ct)
++{
++    if (_costType == ct) return;
++
++    _costType = ct;
++    update();
++}
++
++void PartListItem::setGroupType(TraceCost::CostType gt)
++{
++    if (_groupType == gt) return;
++
++    _groupType = gt;
++    update();
++}
++
++void PartListItem::update()
++{
++  TracePartFunction* pf;
++  pf = !_partCostItem ? 0 :
++       (_partCostItem->type()==TraceCost::PartFunction) ?
++       ((TracePartFunction*)_partCostItem) : 0;
++
++  double total = _part->subCost(_costType);
++
++  TraceCost* selfTotalCost = _part;
++  if (pf && Configuration::showExpanded()) {
++      switch(_groupType) {
++      case TraceCost::Object: selfTotalCost = pf->partObject(); break;
++      case TraceCost::Class:  selfTotalCost = pf->partClass(); break;
++      case TraceCost::File:   selfTotalCost = pf->partFile(); break;
++      default: break;
++      }
++  }
++  double selfTotal = selfTotalCost->subCost(_costType);
++
++  _pure = _partCostItem ? _partCostItem->subCost(_costType) : SubCost(0);
++  _sum = pf ? pf->inclusive()->subCost(_costType) : SubCost(0);
++
++  if (selfTotal == 0 || !_partCostItem) {
++    setText(2, TQString("-"));
++    setPixmap(2, TQPixmap());
++  }
++  else {
++    double pure  = 100.0 * _pure / selfTotal;
++    if (Configuration::showPercentage()) {
++      setText(2, TQString("%1")
++              .arg(pure, 0, 'f', Configuration::percentPrecision()));
++    }
++    else
++      setText(2, _partCostItem->prettySubCost(_costType));
++
++    setPixmap(2, costPixmap(_costType, _partCostItem, selfTotal, false));
++  }
++
++  if (total == 0 || !pf) {
++    setText(1, TQString("-"));
++    setPixmap(1, TQPixmap());
++  }
++  else {
++    double sum  = 100.0 * _sum / total;
++    if (Configuration::showPercentage()) {
++      setText(1, TQString("%1")
++              .arg(sum, 0, 'f', Configuration::percentPrecision()));
++    }
++    else
++      setText(1, _sum.pretty());
++
++    setPixmap(1, costPixmap(_costType, pf->inclusive(), total, false));
++  }
++
++  if (!pf) {
++    setText(3, TQString("-"));
++    _callers = 0;
++    return;
++  }
++
++  TracePartCall* pc;
++  TracePartCallList pl;
++  SubCost callers, callees;
++  TQString str;
++
++  callers = 0;
++  pl = pf->partCallers();
++  for (pc=pl.first();pc;pc=pl.next()) {
++    callers += pc->callCount();
++  }
++
++  if ((callers == 0) && (pf->calledContexts()>0))
++    str = i18n("(active)");
++  else
++    str = callers.pretty();
++
++  _callers = callers;
++  setText(3, str);
++}
++
++
++int PartListItem::compare(TQListViewItem * i, int col, bool ascending ) const
++{
++  PartListItem* fi = (PartListItem*) i;
++  if (col==0) {
++      int mTID = _part->data()->maxThreadID()+1;
++      int mNum = _part->data()->maxPartNumber()+1;
++
++      return
++	  (_part->processID()  - fi->_part->processID()) * mTID * mNum +
++	  (_part->partNumber() - fi->_part->partNumber()) * mTID +
++	  (_part->threadID()   - fi->_part->threadID());
++  }
++  if (col==1) {
++    if (_sum < fi->_sum) return -1;
++    if (_sum > fi->_sum) return 1;
++    return 0;
++  }
++  if (col==2) {
++    if (_pure < fi->_pure) return -1;
++    if (_pure > fi->_pure) return 1;
++    return 0;
++  }
++  if (col==3) {
++    if (_callers < fi->_callers) return -1;
++    if (_callers > fi->_callers) return 1;
++    return 0;
++  }
++  return TQListViewItem::compare(i, col, ascending);
++}
+diff --git a/kdecachegrind/kdecachegrind/partlistitem.h b/kdecachegrind/kdecachegrind/partlistitem.h
+new file mode 100644
+index 0000000..0ab99a9
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/partlistitem.h
+@@ -0,0 +1,54 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++#ifndef PARTLISTITEM_H
++#define PARTLISTITEM_H
++
++#include <tqlistview.h>
++#include "tracedata.h"
++
++/**
++ * For info tab, trace part list.
++ * Needs update on
++ * - cost type change
++ *
++ * Note: on a cost item / percentage change, the list is rebuild
++ */
++class PartListItem: public TQListViewItem
++{
++public:
++  PartListItem(TQListView* parent, TraceCostItem* costItem,
++               TraceCostType* ct, TraceCost::CostType gt, TracePart* part);
++
++  int compare(TQListViewItem * i, int col, bool ascending ) const;
++  TraceCost* partCostItem() { return _partCostItem; }
++  void setCostType(TraceCostType* ct);
++  void setGroupType(TraceCost::CostType);
++  TracePart* part() { return _part; }
++  void update();
++
++private:
++  SubCost _sum, _pure;
++  SubCost _callers;
++  TraceCostType* _costType;
++  TraceCost* _partCostItem;
++  TracePart* _part;
++  TraceCost::CostType _groupType;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/partselection.cpp b/kdecachegrind/kdecachegrind/partselection.cpp
+new file mode 100644
+index 0000000..703dd75
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/partselection.cpp
+@@ -0,0 +1,567 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * For part file selection, to be put into a TQDockWindow
++ */
++
++#include <tqtimer.h>
++#include <tqlistview.h>
++#include <tqlabel.h>
++#include <tqpushbutton.h>
++#include <tqcombobox.h>
++#include <tqlineedit.h>
++#include <tqpopupmenu.h>
++#include <tqlayout.h>
++
++#include <klocale.h>
++#include <kconfig.h>
++#include <kdebug.h>
++
++#include "partselection.h"
++#include "partgraph.h"
++
++PartSelection::PartSelection( TQWidget* parent, const char* name)
++  : PartSelectionBase(parent, name)
++{
++  _data = 0;
++  _costType = 0;
++  _costType2 = 0;
++  _groupType = TraceItem::NoCostType;
++  _group = 0;
++  _function = 0;
++  _inSelectionUpdate = false;
++
++  _diagramMode = false;
++  _drawFrames = true;
++
++  partAreaWidget->setAllowRotation(false);
++  partAreaWidget->setMaxSelectDepth(2);
++  partAreaWidget->setSelectionMode(TreeMapWidget::Extended);
++  partAreaWidget->setSplitMode(TreeMapItem::HAlternate);
++  partAreaWidget->setVisibleWidth(2, true);
++  partAreaWidget->setFieldType(0, i18n( "Name" ));
++  partAreaWidget->setFieldType(1, i18n( "Cost" ));
++
++  connect(partAreaWidget, TQT_SIGNAL(selectionChanged()),
++          this, TQT_SLOT(selectionChanged()));
++  connect(partAreaWidget, TQT_SIGNAL(currentChanged(TreeMapItem*, bool)),
++          this, TQT_SLOT(currentChangedSlot(TreeMapItem*, bool)));
++  connect(partAreaWidget, TQT_SIGNAL(doubleClicked(TreeMapItem*)),
++          this, TQT_SLOT(doubleClicked(TreeMapItem*)));
++  connect(partAreaWidget,
++          TQT_SIGNAL(contextMenuRequested(TreeMapItem*,const TQPoint &)),
++          this,
++          TQT_SLOT(contextMenuRequested(TreeMapItem*,const TQPoint &)));
++
++  _showInfo = true;
++  showInfo(false);
++}
++
++PartSelection::~PartSelection()
++{
++}
++
++void PartSelection::setData(TraceData* data)
++{
++  if (_data == data) return;
++
++  _data = data;
++  partAreaWidget->setData(data);
++  fillInfo();
++}
++
++
++void PartSelection::refresh()
++{
++  partAreaWidget->redraw();
++  fillInfo();
++}
++
++void PartSelection::setCostType(TraceCostType* ct)
++{
++  if (ct == _costType) return;
++  _costType = ct;
++
++  partAreaWidget->setCostType(ct);
++}
++
++void PartSelection::setCostType2(TraceCostType* ct)
++{  
++  if (ct == _costType2) return;
++  _costType2 = ct;
++  if (!_diagramMode) return;
++
++  //TODO: get max cost(type1)/cost(type2) of shown parts
++  //partAreaWidget->setCostType(ct);
++}
++
++void PartSelection::setGroupType(TraceItem::CostType gt)
++{
++  if (gt == _groupType) return;
++  _groupType = gt;
++
++  partAreaWidget->setGroupType(gt);
++}
++
++void PartSelection::setGroup(TraceCostItem*)
++{
++}
++
++void PartSelection::setFunction(TraceFunction* f)
++{
++  if (_function == f) return;
++  _function = f;
++
++  //kdDebug() << "PartSelection::setFunction " << f->name() << endl;
++
++  // FIXME: The TreeMap shouldn't produce spurious selectionChanged events
++  _inSelectionUpdate = true;
++  partAreaWidget->setFunction(_function);
++  _inSelectionUpdate = false;
++}
++
++void PartSelection::setPart(TracePart*)
++{}
++
++void PartSelection::currentChangedSlot(TreeMapItem* i, bool kbd)
++{
++  if (!i) return;
++  if (!kbd) return;
++  if (i->text(0).isEmpty()) return;
++
++  TQString str = i->text(0);
++  if (!i->text(1).isEmpty())
++    str += " (" + i->text(1) + ")";
++  TQString msg = i18n("Profile Part Overview: Current is '%1'").arg(str);
++  emit showMessage(msg, 5000);
++
++  if (_showInfo) fillInfo();
++}
++
++
++void PartSelection::doubleClicked(TreeMapItem* i)
++{
++  if (!i || i->rtti() != 3) return;
++
++  TraceCost* c = ((SubPartItem*) i)->partCostItem();
++  TraceCostItem* ci = 0;
++
++  switch(c->type()) {
++  case TraceItem::PartFunction:
++  {
++    TraceFunction* f = ((TracePartFunction*)c)->function();
++    if (f)
++      emit functionChanged(f);
++  }
++  return;
++
++  case TraceItem::PartObject:
++    ci = ((TracePartObject*)c)->object();
++    break;
++  case TraceItem::PartClass:
++    ci = ((TracePartClass*)c)->cls();
++    break;
++  case TraceItem::PartFile:
++    ci = ((TracePartFile*)c)->file();
++    break;
++  default:
++    break;
++  }
++
++  if (ci)
++    emit groupChanged(ci);
++}
++
++
++void PartSelection::selectionChanged()
++{
++  if (_inSelectionUpdate) return;
++  
++  kdDebug() << "PartSelection::selectionChanged" << endl;
++
++  bool something_changed = false;
++  bool nothingSelected = true;
++
++  TracePartList pList;
++  TreeMapItem* i;
++  TracePart* part;
++
++  // if nothing is selected, activate all parts
++  TreeMapItemList* list = partAreaWidget->base()->children();
++  if (!list) return;
++
++  for (i=list->first();i;i=list->next())
++    if (partAreaWidget->isSelected(i)) {
++      nothingSelected = false;
++      break;
++    }
++
++  for (i=list->first();i;i=list->next()) {
++    part = ((PartItem*)i)->part();
++    bool active = nothingSelected || partAreaWidget->isSelected(i);
++    if (active) {
++      pList.append(part);
++      something_changed = true;
++    }
++  }
++
++  if (something_changed) {
++    //qDebug("PartSelection: Something changed.");
++    emit activePartsChanged(pList);
++  }
++}
++
++/* this makes the graph selection the same to the parts in the list */
++void PartSelection::activePartsChangedSlot(const TracePartList& list)
++{
++  _inSelectionUpdate = true;
++
++  kdDebug() << "Entering PartSelection::activePartsChangedSlot" << endl;
++
++  TreeMapItem* i;
++  TreeMapItemList l = *partAreaWidget->base()->children();
++  // first deselect inactive, then select active (makes current active)
++  for (i=l.first();i;i=l.next()) {
++    TracePart* part = ((PartItem*)i)->part();
++    bool active = (list.containsRef(part)>0);
++    if (!active && partAreaWidget->isSelected(i)) {
++#if 0
++      qDebug("PartSelection::partsChangedSlot: Part %s changed to unselected.",
++             ((PartItem*)i)->part()->shortName().ascii());
++#endif
++
++      partAreaWidget->setSelected(i, false);
++    }
++  }
++  for (i=l.first();i;i=l.next()) {
++    TracePart* part = ((PartItem*)i)->part();
++    bool active = (list.containsRef(part)>0);
++    if (active && !partAreaWidget->isSelected(i)) {
++#if 0
++      qDebug("PartSelection::partsChangedSlot: Part %s changed to selected.",
++             ((PartItem*)i)->part()->shortName().ascii());
++#endif
++      partAreaWidget->setSelected(i, true);
++    }
++  }
++
++  _inSelectionUpdate = false;
++
++  kdDebug() << "Leaving PartSelection::activePartsChangedSlot" << endl;
++
++  fillInfo();
++}
++
++void PartSelection::contextMenuRequested(TreeMapItem* i,
++                                         const TQPoint & p)
++{
++  if (!i) return;
++
++  TQPopupMenu popup;
++  TQPopupMenu ppopup;
++  TQPopupMenu vpopup;
++
++  TQString str;
++  TreeMapItem* s = 0;
++
++  if (_data && (_data->parts().count()>1)) {
++    s = partAreaWidget->possibleSelection(i);
++    if (!s->text(0).isEmpty()) {
++      str = (partAreaWidget->isSelected(s)) ?
++            i18n("Deselect") : i18n("Select");
++      str += " '" + s->text(0) + "'";
++      popup.insertItem(str, 1);
++    }
++
++    popup.insertItem(i18n("Select All Parts"), 2);
++
++    popup.insertItem(i18n("Visible Parts"), &ppopup, 10);
++
++    ppopup.insertItem(i18n("Hide Selected Parts"), 3);
++    ppopup.insertItem(i18n("Unhide Hidden Parts"), 4);
++
++    popup.insertSeparator();
++  }
++
++  popup.insertItem(i18n("Go Back"), 99);
++  if (i->rtti() == 3) {
++    TreeMapItem* ni = i;
++    int id = 100;
++    while (ni && ni->rtti() == 3) {
++      TraceCost* c = ((SubPartItem*)ni)->partCostItem();
++      if (c->type() == TraceItem::PartFunction)
++        if ( ((TracePartFunction*)c)->function() == _function) break;
++
++      str = i18n("Select") + " '" + ni->text(0) + "'";
++      popup.insertItem(str, id);
++      ni = ni->parent();
++      id++;
++    }
++  }
++  popup.insertSeparator();
++
++  vpopup.setCheckable(true);
++  popup.insertItem(i18n("Visualization"), &vpopup, 10);
++
++  vpopup.insertItem(i18n("Partitioning Mode"), 30);
++  vpopup.insertItem(i18n("Diagram Mode"), 34);
++  vpopup.insertItem(i18n("Zoom Function"), 31);
++  vpopup.insertItem(i18n("Show Direct Calls"), 32);
++  vpopup.insertItem(i18n("Increment Shown Call Levels"), 33);
++  if (partAreaWidget->visualisation() == PartAreaWidget::Partitioning) {
++    vpopup.setItemChecked(30, true);
++    vpopup.setItemEnabled(31, false);
++    vpopup.setItemEnabled(32, false);
++    vpopup.setItemEnabled(33, false);
++  }
++  else {
++    vpopup.setItemChecked(31, partAreaWidget->zoomFunction());
++  }
++  vpopup.setItemChecked(34, _diagramMode);
++
++  vpopup.insertSeparator();
++
++  vpopup.insertItem(i18n("Draw Names"), 20);
++  vpopup.insertItem(i18n("Draw Costs"), 21);
++  vpopup.insertItem(i18n("Ignore Proportions"), 22);
++  vpopup.insertItem(i18n("Draw Frames"), 24);
++  vpopup.insertItem(i18n("Allow Rotation"), 23);
++  if (!partAreaWidget->fieldVisible(0) &&
++      !partAreaWidget->fieldVisible(1)) {
++    vpopup.setItemEnabled(22, false);
++    vpopup.setItemEnabled(23, false);
++  }
++  else {
++    vpopup.setItemChecked(20,partAreaWidget->fieldVisible(0));
++    vpopup.setItemChecked(21,partAreaWidget->fieldVisible(1));
++    vpopup.setItemChecked(22,partAreaWidget->fieldForced(0));
++    vpopup.setItemChecked(23,partAreaWidget->allowRotation());
++    vpopup.setItemChecked(24,_drawFrames);
++  }
++
++  if (_showInfo)
++    popup.insertItem(i18n("Hide Info"), 40);
++  else
++    popup.insertItem(i18n("Show Info"), 41);
++
++  int r = popup.exec(partAreaWidget->mapToGlobal(p));
++
++  if (r>=100) {
++    TreeMapItem* ci = i;
++    while (ci && r>100) {
++      ci = ci->parent();
++      r--;
++    }
++    doubleClicked(ci);
++    return;
++  }
++
++  switch(r) {
++  case 1:
++    // select/deselect part under mouse
++    partAreaWidget->setSelected(s, !partAreaWidget->isSelected(s));
++    break;
++
++  case 2:
++    // select all parts
++  {
++    TreeMapItemList list = *partAreaWidget->base()->children();
++    partAreaWidget->setRangeSelection(list.first(), list.last(), true);
++  }
++  break;
++
++  case 3:
++    emit partsHideSelected();
++    break;
++
++  case 4:
++    emit partsUnhideAll();
++    break;
++
++  case 99:
++    // last selected function
++    emit goBack();
++    break;
++
++  case 20:
++    partAreaWidget->setFieldVisible(0, !vpopup.isItemChecked(20));
++    break;
++
++  case 21:
++    partAreaWidget->setFieldVisible(1, !vpopup.isItemChecked(21));
++    break;
++
++  case 22:
++      partAreaWidget->setFieldForced(0, !vpopup.isItemChecked(22));
++      partAreaWidget->setFieldForced(1, !vpopup.isItemChecked(22));
++      break;
++
++  case 23: partAreaWidget->setAllowRotation(!vpopup.isItemChecked(23));  break;
++
++  case 24: 
++    _drawFrames = !_drawFrames;
++    partAreaWidget->drawFrame(2,_drawFrames);
++    partAreaWidget->drawFrame(3,_drawFrames);
++    break;
++
++  case 30:
++    partAreaWidget->setVisualisation(!vpopup.isItemChecked(30) ?
++                                     PartAreaWidget::Partitioning :
++                                     PartAreaWidget::Inclusive);
++    break;
++
++  case 31:
++    // zoom/unzoom function
++    partAreaWidget->setZoomFunction(!vpopup.isItemChecked(31));
++    break;
++
++  case 32:
++  case 33:
++    // change call Levels
++  {
++    int l = (r==32) ? 1 : partAreaWidget->callLevels()+1;
++    partAreaWidget->setCallLevels(l);
++  }
++  break;
++
++  case 34: 
++    _diagramMode = !_diagramMode;
++    partAreaWidget->setTransparent(2,_diagramMode);
++    break;
++
++
++  case 40:
++  case 41:
++    showInfo(r==41);
++    break;
++
++  default:
++    break;
++  }
++}
++
++void PartSelection::hiddenPartsChangedSlot(const TracePartList& list)
++{
++  partAreaWidget->changeHidden(list);
++}
++
++void PartSelection::readVisualisationConfig(KConfigGroup* config)
++{
++  bool enable;
++
++  TQString mode = config->readEntry("PartitionMode", "Inclusive");
++  if (mode == "Inclusive")
++    partAreaWidget->setVisualisation(PartAreaWidget::Inclusive);
++  else
++    partAreaWidget->setVisualisation(PartAreaWidget::Partitioning);
++
++  _diagramMode = config->readBoolEntry("DiagramMode", false);
++  partAreaWidget->setTransparent(2,_diagramMode);
++
++  _drawFrames = config->readBoolEntry("DrawFrames", true);
++  partAreaWidget->drawFrame(2,_drawFrames);
++  partAreaWidget->drawFrame(3,_drawFrames);
++
++  enable = config->readBoolEntry("GraphZoom", false);
++  partAreaWidget->setZoomFunction(enable);
++
++  int levels = config->readNumEntry("GraphLevels", 1);
++  partAreaWidget->setCallLevels(levels);
++
++  enable = config->readBoolEntry("GraphDrawName", true);
++  partAreaWidget->setFieldVisible(0, enable);
++
++  enable = config->readBoolEntry("GraphDrawCost", true);
++  partAreaWidget->setFieldVisible(1, enable);
++
++  enable = config->readBoolEntry("GraphForceStrings", false);
++  partAreaWidget->setFieldForced(0, enable);
++  partAreaWidget->setFieldForced(1, enable);
++
++  enable = config->readBoolEntry("GraphAllowRotation", true);
++  partAreaWidget->setAllowRotation(enable);
++
++  showInfo(config->readBoolEntry("ShowInfo", false));
++}
++
++void PartSelection::saveVisualisationConfig(KConfigGroup* config)
++{
++  TQString mode;
++  if (partAreaWidget->visualisation() == PartAreaWidget::Inclusive)
++    mode = "Inclusive";
++  else
++    mode = "Partitioning";
++  config->writeEntry("PartitionMode", mode);
++
++  config->writeEntry("DiagramMode", _diagramMode);
++  config->writeEntry("DrawFrames", _drawFrames);
++
++  config->writeEntry("GraphZoom", partAreaWidget->zoomFunction());
++  config->writeEntry("GraphLevels", partAreaWidget->callLevels());
++  config->writeEntry("GraphDrawName", partAreaWidget->fieldVisible(0));
++  config->writeEntry("GraphDrawCosts", partAreaWidget->fieldVisible(1));
++  config->writeEntry("GraphForceStrings", partAreaWidget->fieldForced(0));
++  config->writeEntry("GraphAllowRotation", partAreaWidget->allowRotation());
++
++  config->writeEntry("ShowInfo", _showInfo);
++}
++
++void PartSelection::showInfo(bool enable)
++{
++  if (_showInfo == enable) return;
++
++  _showInfo = enable;
++  if (enable) {
++    rangeLabel->show();
++    fillInfo();
++  }
++  else
++    rangeLabel->hide();
++}
++
++void PartSelection::fillInfo()
++{
++  if (!_data) {
++    rangeLabel->setText(i18n("(no trace loaded)"));
++    return;
++  }
++
++  TQString info = _data->activePartRange();
++
++  TreeMapItem* i = partAreaWidget->current();
++  while (i && i->rtti()!=2) i = i->parent();
++  if (i) {
++    TracePart* part = ((PartItem*)i)->part();
++
++    //if (!part->trigger().isEmpty()) info += ", " + part->trigger();
++    if (!part->timeframe().isEmpty())
++      info += ", Time " + part->timeframe() + " BBs";
++  }
++  else {
++    TracePart* part = _data->parts().first();
++
++    if (part && !part->version().isEmpty())
++      info += ", Cachegrind " + part->version();
++  }
++
++
++  rangeLabel->setText(info);
++}
++
++#include "partselection.moc"
+diff --git a/kdecachegrind/kdecachegrind/partselection.h b/kdecachegrind/kdecachegrind/partselection.h
+new file mode 100644
+index 0000000..b8a195f
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/partselection.h
+@@ -0,0 +1,96 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * PartSelection for KCachegrind
++ * For part file selection, to be put into a TQDockWindow
++ */
++
++#ifndef PARTSELECTION_H
++#define PARTSELECTION_H
++
++#include <tqobject.h>
++
++#include "partselectionbase.h"
++#include "partgraph.h"
++#include "tracedata.h"
++
++class KConfigGroup;
++class TraceFunction;
++class TraceData;
++class TreeMapItem;
++
++class PartSelection: public PartSelectionBase
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  PartSelection( TQWidget* parent = 0, const char* name = 0);
++  ~PartSelection();
++
++  TraceData* data() { return _data; }
++  void setData(TraceData*);
++
++  PartAreaWidget* graph() { return partAreaWidget; }
++
++  void readVisualisationConfig(KConfigGroup*);
++  void saveVisualisationConfig(KConfigGroup*);
++
++signals:
++  void activePartsChanged(const TracePartList& list);
++  void partsHideSelected();
++  void partsUnhideAll();
++  void groupChanged(TraceCostItem*);
++  void functionChanged(TraceItem*);
++  void showMessage(const TQString&, int);
++  void goBack();
++
++public slots:
++  void selectionChanged();
++  void doubleClicked(TreeMapItem*);
++  void contextMenuRequested(TreeMapItem*, const TQPoint &);
++  void currentChangedSlot(TreeMapItem*, bool);
++
++  void setPart(TracePart*);
++  void setCostType(TraceCostType*);
++  void setCostType2(TraceCostType*);
++  void setGroupType(TraceItem::CostType);
++  void setGroup(TraceCostItem*);
++  void setFunction(TraceFunction*);
++  void activePartsChangedSlot(const TracePartList& list);
++  void hiddenPartsChangedSlot(const TracePartList& list);
++  void refresh();
++  void showInfo(bool);
++
++private:
++  void fillInfo();
++
++  TraceData* _data;
++  TraceCostType *_costType, *_costType2;
++  TraceItem::CostType _groupType;
++  TraceCostItem* _group;
++  TraceFunction* _function;
++  bool _showInfo;
++  bool _diagramMode;
++  bool _drawFrames;
++
++  bool _inSelectionUpdate;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/partselectionbase.ui b/kdecachegrind/kdecachegrind/partselectionbase.ui
+new file mode 100644
+index 0000000..53320d5
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/partselectionbase.ui
+@@ -0,0 +1,89 @@
++<!DOCTYPE UI><UI version="3.0" stdsetdef="1">
++<class>PartSelectionBase</class>
++<widget class="TQWidget">
++    <property name="name">
++        <cstring>PartSelectionBase</cstring>
++    </property>
++    <property name="geometry">
++        <rect>
++            <x>0</x>
++            <y>0</y>
++            <width>460</width>
++            <height>402</height>
++        </rect>
++    </property>
++    <property name="caption">
++        <string>Parts Overview</string>
++    </property>
++    <vbox>
++        <property name="name">
++            <cstring>unnamed</cstring>
++        </property>
++        <property name="margin">
++            <number>6</number>
++        </property>
++        <property name="spacing">
++            <number>6</number>
++        </property>
++        <widget class="PartAreaWidget">
++            <property name="name">
++                <cstring>partAreaWidget</cstring>
++            </property>
++            <property name="sizePolicy">
++                <sizepolicy>
++                    <hsizetype>5</hsizetype>
++                    <vsizetype>7</vsizetype>
++                    <horstretch>0</horstretch>
++                    <verstretch>0</verstretch>
++                </sizepolicy>
++            </property>
++            <property name="minimumSize">
++                <size>
++                    <width>0</width>
++                    <height>50</height>
++                </size>
++            </property>
++        </widget>
++        <widget class="TQLabel">
++            <property name="name">
++                <cstring>rangeLabel</cstring>
++            </property>
++            <property name="sizePolicy">
++                <sizepolicy>
++                    <hsizetype>7</hsizetype>
++                    <vsizetype>5</vsizetype>
++                    <horstretch>0</horstretch>
++                    <verstretch>0</verstretch>
++                </sizepolicy>
++            </property>
++            <property name="text">
++                <string>(no trace parts)</string>
++            </property>
++        </widget>
++    </vbox>
++</widget>
++<customwidgets>
++    <customwidget>
++        <class>PartAreaWidget</class>
++        <header location="local">partgraph.h</header>
++        <sizehint>
++            <width>-1</width>
++            <height>-1</height>
++        </sizehint>
++        <container>0</container>
++        <sizepolicy>
++            <hordata>5</hordata>
++            <verdata>7</verdata>
++            <horstretch>0</horstretch>
++            <verstretch>0</verstretch>
++        </sizepolicy>
++        <pixmap>image0</pixmap>
++    </customwidget>
++</customwidgets>
++<images>
++    <image name="image0">
++        <data format="XPM.GZ" length="5230">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</data>
++    </image>
++</images>
++<layoutdefaults spacing="6" margin="11"/>
++</UI>
+diff --git a/kdecachegrind/kdecachegrind/partview.cpp b/kdecachegrind/kdecachegrind/partview.cpp
+new file mode 100644
+index 0000000..3f344bb
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/partview.cpp
+@@ -0,0 +1,235 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Part View
++ */
++
++#include <tqwhatsthis.h>
++#include <tqpopupmenu.h>
++#include <tqheader.h>
++#include <klocale.h>
++
++#include "configuration.h"
++#include "partlistitem.h"
++#include "toplevel.h"
++#include "partview.h"
++
++
++
++//
++// PartView
++//
++
++
++PartView::PartView(TraceItemView* parentView,
++		   TQWidget* parent, const char* name)
++  : TQListView(parent, name), TraceItemView(parentView)
++{
++    _inSelectionUpdate = false;
++
++    addColumn( i18n( "Profile Part" ) );
++    addColumn( i18n( "Incl." ) );
++    addColumn( i18n( "Self" ) );
++    addColumn( i18n( "Called" ) );
++    //addColumn( i18n( "Fixed" ) );
++    addColumn( i18n( "Comment" ) );
++
++    setAllColumnsShowFocus(true);
++    setColumnAlignment(1, TQt::AlignRight);
++    setColumnAlignment(2, TQt::AlignRight);
++    setColumnAlignment(3, TQt::AlignRight);
++    setMinimumHeight(50);
++    setSelectionMode(Extended);
++
++    connect( this,
++	     TQT_SIGNAL( selectionChanged() ),
++	     TQT_SLOT( selectionChangedSlot() ) );
++
++    connect( this,
++	     TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint &, int)),
++	     TQT_SLOT(context(TQListViewItem*, const TQPoint &, int)));
++
++    TQWhatsThis::add( this, whatsThis() );
++}
++
++TQString PartView::whatsThis() const
++{
++    return i18n( "<b>Trace Part List</b>"
++		 "<p>This list shows all trace parts of the loaded "
++		 "trace. For each part, the "
++		 "self/inclusive cost of the current selected "
++		 "function, spent in the part, is shown; "
++		 "percentage costs are always relative to the "
++		 "total cost <em>of the part</em> (not to the whole "
++		 "trace as in the Trace Part Overview). "
++		 "Also shown are the calls happening to/from the "
++		 "current function inside of the trace part.</p>"
++		 "<p>By choosing one or more trace parts from the "
++		 "list, the costs shown all over KCachegrind will "
++		 "only be the ones spent in the selected part(s). "
++		 "If no list selection is shown, in fact all trace "
++		 "parts are selected implicitly.</p>"
++		 "<p>This is a multi-selection list. You can select "
++		 "ranges by dragging the mouse or use SHIFT/CTRL "
++		 "modifiers. "
++		 "Selection/Deselection of trace parts can also be "
++		 "done by using the Trace Part Overview Dockable. "
++		 "This one also supports multiple selection.</p>"
++		 "<p>Note that the list is hidden if only one trace "
++		 "part is loaded.</p>");
++}
++
++
++void PartView::context(TQListViewItem* i, const TQPoint & pos, int)
++{
++  TQPopupMenu popup;
++
++  TracePart* p = i ? ((PartListItem*) i)->part() : 0;
++
++  if (p) {
++    popup.insertItem(i18n("Select '%1'").arg(p->name()), 93);
++    popup.insertItem(i18n("Hide '%1'").arg(p->name()), 94);
++    popup.insertSeparator();
++  }
++
++  popup.insertItem(i18n("Hide Selected"), 95);
++  popup.insertItem(i18n("Show All"), 96);
++  popup.insertSeparator();
++
++  addGoMenu(&popup);
++
++  int r = popup.exec(pos);
++  if (r == 95) {
++    ;
++  }
++
++  // TODO: ...
++}
++
++void PartView::selectionChangedSlot()
++{
++    if (_inSelectionUpdate) return;
++
++    TracePartList l;
++    TQListViewItem* item  = firstChild();
++    for(;item;item = item->nextSibling())
++      if (item->isSelected())
++        l.append( ((PartListItem*)item)->part() );
++
++    selected(l);
++}
++
++
++TraceItem* PartView::canShow(TraceItem* i)
++{
++  if (!TraceItemView::data()) return 0;
++  if (TraceItemView::data()->parts().count()>1) return i;
++  return 0;
++}
++
++void PartView::doUpdate(int changeType)
++{
++    // Special case ?
++    if (changeType == costType2Changed) return;
++    if (changeType == selectedItemChanged) return;
++
++    if (changeType == groupTypeChanged) {
++	TQListViewItem *item;
++	for (item = firstChild();item;item = item->nextSibling())
++	    ((PartListItem*)item)->setGroupType(_groupType);
++
++	return;
++    }
++
++    if (changeType == costTypeChanged) {
++	TQListViewItem *item;
++	for (item = firstChild();item;item = item->nextSibling())
++	  ((PartListItem*)item)->setCostType(_costType);
++
++	return;
++    }
++
++    if (changeType == partsChanged) {
++
++      TracePart* part;
++
++      TQListViewItem* item;
++      _inSelectionUpdate = true;
++      item  = firstChild();
++      for(;item;item = item->nextSibling()) {
++        part = ((PartListItem*)item)->part();
++
++        if (_partList.containsRef(part)>0) {
++          setSelected(item, true);
++          ensureItemVisible(item);
++        }
++        else
++          setSelected(item, false);
++      }
++      _inSelectionUpdate = false;
++
++      return;
++    }
++
++    refresh();
++}
++
++void PartView::refresh()
++{
++    clear();
++    setColumnWidth(1, 50);
++    setColumnWidth(2, 50);
++
++    if (!_data || !_activeItem) return;
++
++    TraceItem::CostType t = _activeItem->type();
++    TraceFunction* f = 0;
++    if (t == TraceItem::Function) f = (TraceFunction*) _activeItem;
++    if (!f) return;
++
++    TracePart* part;
++    TracePartList hidden;
++    if (_topLevel)
++	hidden = _topLevel->hiddenParts();
++
++    TracePartList allParts = _data->parts();
++
++    _inSelectionUpdate = true;
++
++    TQListViewItem* item = 0;
++    for (part = allParts.first(); part; part = allParts.next()) {
++	if (hidden.findRef(part)>=0) continue;
++	item = new PartListItem(this, f, _costType, _groupType, part);
++
++	if (part->isActive()) {
++	    setSelected(item, true);
++	    ensureItemVisible(item);
++	}
++    }
++
++    _inSelectionUpdate = false;
++
++    if (item) {
++	int headerHeight = header()->height();
++	int itemHeight = item->height();
++	setMinimumHeight(headerHeight + 2*itemHeight + 2);
++    }
++}
++
++#include "partview.moc"
+diff --git a/kdecachegrind/kdecachegrind/partview.h b/kdecachegrind/kdecachegrind/partview.h
+new file mode 100644
+index 0000000..92761cc
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/partview.h
+@@ -0,0 +1,55 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Part View
++ */
++
++#ifndef PARTVIEW_H
++#define PARTVIEW_H
++
++#include <tqlistview.h>
++#include "tracedata.h"
++#include "traceitemview.h"
++
++class PartView: public TQListView, public TraceItemView
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  PartView(TraceItemView* parentView,
++	   TQWidget* parent=0, const char* name=0);
++
++  virtual TQWidget* widget() { return this; }
++  TQString whatsThis() const;
++
++  void refresh();
++
++private slots:
++  void context(TQListViewItem*,const TQPoint &, int);
++  void selectionChangedSlot();
++
++private:
++  TraceItem* canShow(TraceItem*);
++  void doUpdate(int);
++
++  bool _inSelectionUpdate;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/pool.cpp b/kdecachegrind/kdecachegrind/pool.cpp
+new file mode 100644
+index 0000000..d4a89a7
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/pool.cpp
+@@ -0,0 +1,258 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002-2004 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++#include <string.h>
++#include <stdlib.h>
++#include <tqglobal.h>
++#include "pool.h"
++
++// FixPool
++
++#define CHUNK_SIZE 100000
++
++struct SpaceChunk
++{
++    struct SpaceChunk* next;
++    unsigned int used;
++    char space[1];
++};
++
++FixPool::FixPool()
++{
++    _first = _last = 0;
++    _reservation = 0;
++    _count = 0;
++    _size = 0;
++}
++
++FixPool::~FixPool()
++{
++    struct SpaceChunk* chunk = _first, *next;
++
++    while(chunk) {
++	next = chunk->next;
++	free(chunk);
++	chunk = next;
++    }
++
++    if (0) qDebug("~FixPool: Had %d objects with total size %d\n",
++		  _count, _size);
++}
++
++void* FixPool::allocate(unsigned int size)
++{
++    if (!ensureSpace(size)) return 0;
++
++    _reservation = 0;
++    void* result = _last->space + _last->used;
++    _last->used += size;
++
++    _count++;
++    _size += size;
++
++    return result;
++}
++
++void* FixPool::reserve(unsigned int size)
++{
++    if (!ensureSpace(size)) return 0;
++    _reservation = size;
++
++    return _last->space + _last->used;
++}
++
++
++bool FixPool::allocateReserved(unsigned int size)
++{
++    if (_reservation < size) return false;
++
++    _reservation = 0;
++    _last->used += size;
++
++    _count++;
++    _size += size;
++
++    return true;
++}
++
++bool FixPool::ensureSpace(unsigned int size)
++{
++    if (_last && _last->used + size <= CHUNK_SIZE) return true;
++
++    struct SpaceChunk* newChunk;
++
++    // we don't allow allocation sizes > CHUNK_SIZE
++    if (size > CHUNK_SIZE) return false;
++
++    newChunk = (struct SpaceChunk*) malloc(sizeof(struct SpaceChunk) +
++					   CHUNK_SIZE);
++    newChunk->next = 0;
++    newChunk->used = 0;
++
++    if (!_last) {
++	_last = _first = newChunk;
++    }
++    else {
++	_last->next = newChunk;
++	_last = newChunk;
++    }
++    return true;
++}
++
++
++// DynPool
++
++DynPool::DynPool()
++{
++  _data = (char*) malloc(CHUNK_SIZE);
++  _used = 0;
++  _size = CHUNK_SIZE;
++
++  // end marker
++  *(int*)_data = 0;
++}
++
++DynPool::~DynPool()
++{
++  // we could check for correctness by iteration over all objects
++
++  ::free(_data);
++}
++
++bool DynPool::allocate(char** ptr, unsigned int size)
++{
++  // round up to multiple of 4
++  size = (size+3) & ~3;
++
++  /* need 12 bytes more:
++   * - 4 bytes for forward chain
++   * - 4 bytes for pointer to ptr
++   * - 4 bytes as end marker (not used for new object)
++   */
++  if (!ensureSpace(size + 12)) return false;
++
++  char** obj = (char**) (_data+_used);
++  obj[0] = (char*)(_data + _used + size + 8);
++  obj[1] = (char*)ptr;
++  *(int*)(_data+_used+size+8) = 0;
++  *ptr = _data+_used+8;
++
++  _used += size + 8;
++
++  return true;
++}
++
++void DynPool::free(char** ptr)
++{
++  if (!ptr ||
++      !*ptr ||
++      (*(char**)(*ptr - 4)) != (char*)ptr )
++    qFatal("Chaining error in DynPool::free");
++
++  (*(char**)(*ptr - 4)) = 0;
++  *ptr = 0;
++}
++
++bool DynPool::ensureSpace(unsigned int size)
++{
++  if (_used + size <= _size) return true;
++
++  unsigned int newsize = _size *3/2 + CHUNK_SIZE;
++  char* newdata = (char*) malloc(newsize);
++
++  unsigned int freed = 0, len;
++  char **p, **pnext, **pnew;
++
++  qDebug("DynPool::ensureSpace size: %d => %d, used %d. %p => %p",
++	 _size, newsize, _used, _data, newdata);
++
++  pnew = (char**) newdata;
++  p = (char**) _data;
++  while(*p) {
++    pnext = (char**) *p;
++    len = (char*)pnext - (char*)p;
++
++    if (0) qDebug(" [%8p] Len %d (ptr %p), freed %d (=> %p)",
++		  p, len, p[1], freed, pnew);
++
++    /* skip freed space ? */
++    if (p[1] == 0) {
++      freed += len;
++      p = pnext;
++      continue;
++    }
++    
++    // new and old still at same address ?
++    if (pnew == p) {
++      pnew = p = pnext;
++      continue;
++    }
++
++    // copy object
++    pnew[0] = (char*)pnew + len;
++    pnew[1] = p[1];
++    memcpy((char*)pnew + 8, (char*)p + 8, len-8);
++
++    // update pointer to object
++    char** ptr = (char**) p[1];
++    if (*ptr != ((char*)p)+8)
++      qFatal("Chaining error in DynPool::ensureSpace");
++    *ptr = ((char*)pnew)+8;
++
++    pnew = (char**) pnew[0];
++    p = pnext;
++  }
++  pnew[0] = 0;
++
++  unsigned int newused = (char*)pnew - (char*)newdata;
++  qDebug("DynPool::ensureSpace size: %d => %d, used %d => %d (%d freed)",
++	 _size, newsize, _used, newused, freed);
++  
++  ::free(_data);
++  _data = newdata;
++  _size = newsize;
++  _used = newused;
++
++  return true;
++}
++
++/* Testing the DynPool
++int main()
++{
++  char* bufs[CHUNK_SIZE];
++  int i;
++
++  DynPool p;
++
++  for(i=0;i<CHUNK_SIZE;i++) {
++    p.allocate(bufs+i, 10+i%10);
++    if (((i%3)==0) && (i>20))
++      p.free(bufs+i-20);
++  }
++
++  for(i=0;i<CHUNK_SIZE;i++) {
++    if ((bufs[i]==0) || ((i%7)==0)) continue;
++    p.free(bufs+i);
++  }
++
++  for(i=0;i<CHUNK_SIZE;i++) {
++    if (bufs[i]) continue;
++    p.allocate(bufs+i, 10+i%10);
++  }
++}
++*/
+diff --git a/kdecachegrind/kdecachegrind/pool.h b/kdecachegrind/kdecachegrind/pool.h
+new file mode 100644
+index 0000000..c9d70c1
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/pool.h
+@@ -0,0 +1,107 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002-2004 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++#ifndef POOL_H
++#define POOL_H
++
++/**
++ * Pool objects: containers for many small objects.
++ */
++
++struct SpaceChunk;
++
++/**
++ * FixPool
++ *
++ * For objects with fixed size and life time
++ * ending with that of the pool.
++ */
++class FixPool
++{
++ public:
++    FixPool();
++    ~FixPool();
++
++    /**
++     * Take <size> bytes from the pool
++     */
++    void* allocate(unsigned int size);
++
++    /**
++     * Reserve space. If you call allocateReservedSpace(realsize)
++     * with realSize < reserved size directly after, you
++     * will get the same memory area.
++     */
++    void* reserve(unsigned int size);
++
++    /**
++     * Before calling this, you have to reserve at least <size> bytes
++     * with reserveSpace().
++     */
++    bool allocateReserved(unsigned int size);
++
++ private:
++    /* Checks that there is enough space in the last chunk.
++     * Returns false if this is not possible.
++     */
++    bool ensureSpace(unsigned int);
++
++    struct SpaceChunk *_first, *_last;
++    unsigned int _reservation;
++    int _count, _size;
++};
++
++/**
++ * DynPool
++ *
++ * For objects which probably need to be resized
++ * in the future. Objects also can be deleted to free up space.
++ * As objects can also be moved in a defragmentation step,
++ * access has to be done via the given pointer object.
++ */
++class DynPool
++{
++ public:
++    DynPool();
++    ~DynPool();
++
++    /**
++     * Take <size> bytes from the pool, changing <*ptr>
++     * to point to this allocated space.
++     * <*ptr> will be changed if the object is moved.
++     * Returns false if no space available.
++     */
++    bool allocate(char** ptr, unsigned int size);
++
++    /**
++     * To resize, first allocate new space, and free old
++     * afterwards.
++     */
++    void free(char** ptr);
++
++ private:
++    /* Checks that there is enough space. If not,
++     * it compactifies, possibly moving objects.
++     */
++    bool ensureSpace(unsigned int);
++
++    char* _data;
++    unsigned int _used, _size;
++};
++
++#endif // POOL_H
+diff --git a/kdecachegrind/kdecachegrind/sourceitem.cpp b/kdecachegrind/kdecachegrind/sourceitem.cpp
+new file mode 100644
+index 0000000..305b824
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/sourceitem.cpp
+@@ -0,0 +1,444 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Items of source view.
++ */
++
++#include <tqpixmap.h>
++#include <tqregexp.h>
++#include <tqpainter.h>
++
++#include <klocale.h>
++#include <kiconloader.h>
++#include <kapplication.h>
++
++#include "configuration.h"
++#include "listutils.h"
++#include "sourceview.h"
++#include "sourceitem.h"
++
++
++// SourceItem
++
++// for source lines
++SourceItem::SourceItem(SourceView* sv, TQListView* parent,
++		       int fileno, unsigned int lineno,
++                       bool inside, const TQString& src,
++                       TraceLine* line)
++    : TQListViewItem(parent)
++{
++  _view = sv;
++  _lineno = lineno;
++  _fileno = fileno;
++  _inside = inside;
++  _line = line;
++  _lineCall = 0;
++  _lineJump = 0;
++
++  if (src == "...")
++      setText(0, src);
++  else
++      setText(0, TQString::number(lineno));
++
++  TQString s = src;
++  setText(4, s.replace( TQRegExp("\t"), "        " ));
++
++  updateGroup();
++  updateCost();
++}
++
++// for call lines
++SourceItem::SourceItem(SourceView* sv, TQListViewItem* parent,
++		       int fileno, unsigned int lineno,
++                       TraceLine* line, TraceLineCall* lineCall)
++    : TQListViewItem(parent)
++{
++  _view = sv;
++  _lineno = lineno;
++  _fileno = fileno;
++  _inside = true;
++  _line = line;
++  _lineCall = lineCall;
++  _lineJump = 0;
++
++  //qDebug("SourceItem: (file %d, line %d) Linecall to %s",
++  //       fileno, lineno, _lineCall->call()->called()->prettyName().ascii());
++
++  SubCost cc = _lineCall->callCount();
++  TQString templ = "  ";
++  if (cc==0)
++    templ += i18n("Active call to '%1'");
++  else
++    templ += i18n("%n call to '%1'", "%n calls to '%1'", cc);
++
++  TQString callStr = templ.arg(_lineCall->call()->calledName());
++  TraceFunction* calledF = _lineCall->call()->called();
++  calledF->addPrettyLocation(callStr);
++
++  setText(4, callStr);
++
++  updateGroup();
++  updateCost();
++}
++
++// for jump lines
++SourceItem::SourceItem(SourceView* sv, TQListViewItem* parent,
++		       int fileno, unsigned int lineno,
++                       TraceLine* line, TraceLineJump* lineJump)
++    : TQListViewItem(parent)
++{
++  _view = sv;
++  _lineno = lineno;
++  _fileno = fileno;
++  _inside = true;
++  _line = line;
++  _lineCall = 0;
++  _lineJump = lineJump;
++
++  //qDebug("SourceItem: (file %d, line %d) Linecall to %s",
++  //       fileno, lineno, _lineCall->call()->called()->prettyName().ascii());
++
++  TQString to;
++  if (_lineJump->lineTo()->functionSource() == _line->functionSource())
++      to = _lineJump->lineTo()->name();
++  else
++      to = _lineJump->lineTo()->prettyName();
++
++  TQString jStr;
++  if (_lineJump->isCondJump())
++      jStr = i18n("Jump %1 of %2 times to %3")
++	  .arg(_lineJump->followedCount().pretty())
++	  .arg(_lineJump->executedCount().pretty())
++	  .arg(to);
++  else
++      jStr = i18n("Jump %1 times to %2")
++	  .arg(_lineJump->executedCount().pretty())
++	  .arg(to);
++
++  setText(4, jStr);
++}
++
++
++void SourceItem::updateGroup()
++{
++  if (!_lineCall) return;
++
++  TraceFunction* f = _lineCall->call()->called();
++  TQColor c = Configuration::functionColor(_view->groupType(), f);
++  setPixmap(4, colorPixmap(10, 10, c));
++}
++
++void SourceItem::updateCost()
++{
++  _pure = SubCost(0);
++  _pure2 = SubCost(0);
++
++  if (!_line) return;
++  if (_lineJump) return;
++
++  TraceCost* lineCost = _lineCall ? (TraceCost*)_lineCall : (TraceCost*)_line;
++
++  // don't show any cost inside of cycles
++  if (_lineCall &&
++      ((_lineCall->call()->inCycle()>0) ||
++       (_lineCall->call()->isRecursion()>0))) {
++    TQString str;
++    TQPixmap p;
++
++    TQString icon = "undo";
++    KIconLoader* loader = KApplication::kApplication()->iconLoader();
++    p= loader->loadIcon(icon, KIcon::Small, 0,
++                        KIcon::DefaultState, 0, true);
++    if (p.isNull())
++      str = i18n("(cycle)");
++
++    setText(1, str);
++    setPixmap(1, p);
++    setText(2, str);
++    setPixmap(2, p);
++    return;
++  }
++
++  TraceCost* totalCost;
++  if (Configuration::showExpanded())
++    totalCost = _line->functionSource()->function()->inclusive();
++  else
++    totalCost = _line->functionSource()->function()->data();
++
++  TraceCostType* ct = _view->costType();
++  _pure = ct ? lineCost->subCost(ct) : SubCost(0);
++  if (_pure == 0) {
++    setText(1, TQString());
++    setPixmap(1, TQPixmap());
++  }
++  else {
++    double total = totalCost->subCost(ct);
++    double pure  = 100.0 * _pure / total;
++
++    if (Configuration::showPercentage())
++      setText(1, TQString("%1")
++	      .arg(pure, 0, 'f', Configuration::percentPrecision()));
++    else
++      setText(1, _pure.pretty());
++
++    setPixmap(1, costPixmap(ct, lineCost, total, false));
++  }
++
++  TraceCostType* ct2 = _view->costType2();
++  _pure2 = ct2 ? lineCost->subCost(ct2) : SubCost(0);
++  if (_pure2 == 0) {
++    setText(2, TQString());
++    setPixmap(2, TQPixmap());
++  }
++  else {
++    double total = totalCost->subCost(ct2);
++    double pure2  = 100.0 * _pure2 / total;
++
++    if (Configuration::showPercentage())
++      setText(2, TQString("%1")
++	      .arg(pure2, 0, 'f', Configuration::percentPrecision()));
++    else
++      setText(2, _pure2.pretty());
++
++    setPixmap(2, costPixmap(ct2, lineCost, total, false));
++  }
++}
++
++
++int SourceItem::compare(TQListViewItem * i, int col, bool ascending ) const
++{
++  const SourceItem* si1 = this;
++  const SourceItem* si2 = (SourceItem*) i;
++
++  // we always want descending order
++  if (((col>0) && ascending) ||
++      ((col==0) && !ascending) ) {
++    si1 = si2;
++    si2 = this;
++  }
++
++  if (col==1) {
++    if (si1->_pure < si2->_pure) return -1;
++    if (si1->_pure > si2->_pure) return 1;
++    return 0;
++  }
++  if (col==2) {
++    if (si1->_pure2 < si2->_pure2) return -1;
++    if (si1->_pure2 > si2->_pure2) return 1;
++    return 0;
++  }
++  if (col==0) {
++    // Sort file numbers
++    if (si1->_fileno < si2->_fileno) return -1;
++    if (si1->_fileno > si2->_fileno) return 1;
++
++    // Sort line numbers
++    if (si1->_lineno < si2->_lineno) return -1;
++    if (si1->_lineno > si2->_lineno) return 1;
++
++    // Same line: code gets above calls/jumps
++    if (!si1->_lineCall && !si1->_lineJump) return -1;
++    if (!si2->_lineCall && !si2->_lineJump) return 1;
++
++    // calls above jumps
++    if (si1->_lineCall && !si2->_lineCall) return -1;
++    if (si2->_lineCall && !si1->_lineCall) return 1;
++
++    if (si1->_lineCall && si2->_lineCall) {
++	// Two calls: desending sort according costs
++	if (si1->_pure < si2->_pure) return 1;
++	if (si1->_pure > si2->_pure) return -1;
++
++	// Two calls: sort according function names
++	TraceFunction* f1 = si1->_lineCall->call()->called();
++	TraceFunction* f2 = si2->_lineCall->call()->called();
++	if (f1->prettyName() > f2->prettyName()) return 1;
++	return -1;
++    }
++
++    // Two jumps: descending sort according target line
++    if (si1->_lineJump->lineTo()->lineno() <
++	si2->_lineJump->lineTo()->lineno())
++	return -1;
++    if (si1->_lineJump->lineTo()->lineno() >
++	si2->_lineJump->lineTo()->lineno())
++	return 1;
++    return 0;
++  }
++  return TQListViewItem::compare(i, col, ascending);
++}
++
++void SourceItem::paintCell( TQPainter *p, const TQColorGroup &cg,
++                            int column, int width, int alignment )
++{
++  TQColorGroup _cg( cg );
++
++  if ( !_inside || ((column==1) || (column==2)))
++    _cg.setColor( TQColorGroup::Base, cg.button() );
++  else if ((_lineCall || _lineJump) && column>2)
++   _cg.setColor( TQColorGroup::Base, cg.midlight() );
++
++  if (column == 3)
++      paintArrows(p, _cg, width);
++  else
++      TQListViewItem::paintCell( p, _cg, column, width, alignment );
++}
++
++void SourceItem::setJumpArray(const TQMemArray<TraceLineJump*>& a)
++{
++    _jump.duplicate(a);
++}
++
++void SourceItem::paintArrows(TQPainter *p, const TQColorGroup &cg, int width)
++{
++  TQListView *lv = listView();
++  if ( !lv ) return;
++  SourceView* sv = (SourceView*) lv;
++
++  const BackgroundMode bgmode = lv->viewport()->backgroundMode();
++  const TQColorGroup::ColorRole crole
++    = TQPalette::backgroundRoleFromMode( bgmode );
++  if ( cg.brush( crole ) != lv->colorGroup().brush( crole ) )
++    p->fillRect( 0, 0, width, height(), cg.brush( crole ) );
++  else
++    sv->paintEmptyArea( p, TQRect( 0, 0, width, height() ) );
++
++  if ( isSelected() && lv->allColumnsShowFocus() )
++    p->fillRect( 0, 0, width, height(), cg.brush( TQColorGroup::Highlight ) );
++
++  int marg = lv->itemMargin();
++  int yy = height()/2, y1, y2;
++  TQColor c;
++
++  int start = -1, end = -1;
++
++  // draw line borders, detect start/stop of a line
++  for(int i=0;i< (int)_jump.size();i++) {
++      if (_jump[i] == 0) continue;
++
++      y1 = 0;
++      y2 = height();
++      if (_lineJump &&
++	  (_lineJump->lineTo() == _jump[i]->lineTo()) &&
++	  (_jump[i]->lineFrom()->lineno() == _lineno)) {
++
++	  if (start<0) start = i;
++	  if (_lineJump == _jump[i]) {
++	      if (_jump[i]->lineTo()->lineno() <= _lineno)
++		  y2 = yy;
++	      else
++		  y1 = yy;
++	  }
++      }
++      else if (!_lineJump && !_lineCall &&
++	       (_jump[i]->lineTo()->lineno() == _lineno)) {
++	  if (end<0) end = i;
++	  if (_jump[i]->lineFrom()->lineno() < _lineno)
++	      y2 = yy;
++	  else
++	      y1 = yy;
++      }
++
++      c = _jump[i]->isCondJump() ? red : blue;
++      p->fillRect( marg + 6*i, y1, 4, y2, c);
++      p->setPen(c.light());
++      p->drawLine( marg + 6*i, y1, marg + 6*i, y2);
++      p->setPen(c.dark());
++      p->drawLine( marg + 6*i +3, y1, marg + 6*i +3, y2);
++  }
++
++  // draw start/stop horizontal line
++  int x, y = yy-2, w, h = 4;
++  if (start >= 0) {
++      c = _jump[start]->isCondJump() ? red : blue;
++      x = marg + 6*start;
++      w = 6*(sv->arrowLevels() - start) + 10;
++      p->fillRect( x, y, w, h, c);
++      p->setPen(c.light());
++      p->drawLine(x, y, x+w-1, y);
++      p->drawLine(x, y, x, y+h-1);
++      p->setPen(c.dark());
++      p->drawLine(x+w-1, y, x+w-1, y+h-1);
++      p->drawLine(x+1, y+h-1, x+w-1, y+h-1);
++  }
++  if (end >= 0) {
++      c = _jump[end]->isCondJump() ? red : blue;
++      x = marg + 6*end;
++      w = 6*(sv->arrowLevels() - end) + 10;
++
++      TQPointArray a;
++      a.putPoints(0, 7, x, y+h,
++		  x,y, x+w-8, y, x+w-8, y-2,
++		  x+w, yy,
++		  x+w-8, y+h+2, x+w-8, y+h);
++      p->setBrush(c);
++      p->drawConvexPolygon(a);
++
++      p->setPen(c.light());
++      p->drawPolyline(a, 0, 5);
++      p->setPen(c.dark());
++      p->drawPolyline(a, 4, 2);
++      p->setPen(c.light());
++      p->drawPolyline(a, 5, 2);
++      p->setPen(c.dark());
++      p->drawPolyline(a, 6, 2);
++  }
++
++  // draw inner vertical line for start/stop
++  // this overwrites borders of horizontal line
++  for(int i=0;i< (int)_jump.size();i++) {
++      if (_jump[i] == 0) continue;
++
++      c = _jump[i]->isCondJump() ? red : blue;
++
++      if (_jump[i]->lineFrom()->lineno() == _lineno) {
++	  bool drawUp = true;
++	  if (_jump[i]->lineTo()->lineno() == _lineno)
++	      if (start<0) drawUp = false;
++	  if (_jump[i]->lineTo()->lineno() > _lineno) drawUp = false;
++	  if (drawUp)
++	      p->fillRect( marg + 6*i +1, 0, 2, yy, c);
++	  else
++	      p->fillRect( marg + 6*i +1, yy, 2, height()-yy, c);
++      }
++      else if (_jump[i]->lineTo()->lineno() == _lineno) {
++	  if (end<0) end = i;
++	  if (_jump[i]->lineFrom()->lineno() < _lineno)
++	      p->fillRect( marg + 6*i +1, 0, 2, yy, c);
++	  else
++	      p->fillRect( marg + 6*i +1, yy, 2, height()-yy, c);
++      }
++  }
++
++}
++
++int SourceItem::width( const TQFontMetrics& fm,
++		       const TQListView* lv, int c ) const
++{
++  if (c != 3) return TQListViewItem::width(fm, lv, c);
++
++  SourceView* sv = (SourceView*) lv;
++  int levels = sv->arrowLevels();
++
++  if (levels == 0) return 0;
++
++  // 10 pixels for the arrow
++  return 10 + 6*levels + lv->itemMargin() * 2;
++}
++
+diff --git a/kdecachegrind/kdecachegrind/sourceitem.h b/kdecachegrind/kdecachegrind/sourceitem.h
+new file mode 100644
+index 0000000..925e575
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/sourceitem.h
+@@ -0,0 +1,84 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Items of source view.
++ */
++
++#ifndef SOURCEITEM_H
++#define SOURCEITEM_H
++
++#include <tqlistview.h>
++#include "tracedata.h"
++
++class SourceView;
++
++class SourceItem: public TQListViewItem
++{
++public:
++  // for source lines
++  SourceItem(SourceView* sv, TQListView* parent, 
++	     int fileno, unsigned int lineno,
++	     bool inside, const TQString& src,
++             TraceLine* line = 0);
++
++  // for call lines
++  SourceItem(SourceView* sv, TQListViewItem* parent, 
++	     int fileno, unsigned int lineno,
++             TraceLine* line, TraceLineCall* lineCall);
++
++  // for jump lines
++  SourceItem(SourceView* sv, TQListViewItem* parent, 
++	     int fileno, unsigned int lineno,
++             TraceLine* line, TraceLineJump* lineJump);
++
++  uint lineno() const { return _lineno; }
++  int fileNumber() const { return _fileno; }
++  bool inside() const { return _inside; }
++  TraceLine* line() const { return _line; }
++  TraceLineCall* lineCall() const { return _lineCall; }
++  TraceLineJump* lineJump() const { return _lineJump; }
++
++  int compare(TQListViewItem * i, int col, bool ascending ) const;
++
++  void paintCell( TQPainter *p, const TQColorGroup &cg,
++                  int column, int width, int alignment );
++  int width( const TQFontMetrics& fm,
++             const TQListView* lv, int c ) const;
++  void updateGroup();
++  void updateCost();
++
++  // arrow lines
++  void setJumpArray(const TQMemArray<TraceLineJump*>& a);
++
++protected:
++  void paintArrows(TQPainter *p, const TQColorGroup &cg, int width);
++  TQMemArray<TraceLineJump*> _jump;
++
++private:
++  SourceView* _view;
++  SubCost _pure, _pure2;
++  uint _lineno;
++  int _fileno; // for line sorting (even with multiple files)
++  bool _inside;
++  TraceLine* _line;
++  TraceLineJump* _lineJump;
++  TraceLineCall* _lineCall;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/sourceview.cpp b/kdecachegrind/kdecachegrind/sourceview.cpp
+new file mode 100644
+index 0000000..dde291e
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/sourceview.cpp
+@@ -0,0 +1,813 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Source View
++ */
++
++#include <tqdir.h>
++#include <tqfile.h>
++#include <tqwhatsthis.h>
++#include <tqpopupmenu.h>
++#include <klocale.h>
++#include <kdebug.h>
++
++#include "configuration.h"
++#include "sourceitem.h"
++#include "sourceview.h"
++
++
++//
++// SourceView
++//
++
++
++SourceView::SourceView(TraceItemView* parentView,
++                       TQWidget* parent, const char* name)
++  : TQListView(parent, name), TraceItemView(parentView)
++{
++  _inSelectionUpdate = false;
++
++  _arrowLevels = 0;
++  _lowList.setSortLow(true);
++  _highList.setSortLow(false);
++
++  addColumn( i18n( "#" ) );
++  addColumn( i18n( "Cost" ) );
++  addColumn( i18n( "Cost 2" ) );
++  addColumn( "" );
++  addColumn( i18n( "Source (unknown)" ) );
++
++  setAllColumnsShowFocus(true);
++  setColumnAlignment(0, TQt::AlignRight);
++  setColumnAlignment(1, TQt::AlignRight);
++  setColumnAlignment(2, TQt::AlignRight);
++  setResizeMode(TQListView::LastColumn);
++
++  connect(this,
++          TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint &, int)),
++          TQT_SLOT(context(TQListViewItem*, const TQPoint &, int)));
++
++  connect(this,
++          TQT_SIGNAL(selectionChanged(TQListViewItem*)),
++          TQT_SLOT(selectedSlot(TQListViewItem*)));
++
++  connect(this,
++          TQT_SIGNAL(doubleClicked(TQListViewItem*)),
++          TQT_SLOT(activatedSlot(TQListViewItem*)));
++
++  connect(this,
++          TQT_SIGNAL(returnPressed(TQListViewItem*)),
++          TQT_SLOT(activatedSlot(TQListViewItem*)));
++
++  TQWhatsThis::add( this, whatsThis());
++}
++
++void SourceView::paintEmptyArea( TQPainter * p, const TQRect & r)
++{
++  TQListView::paintEmptyArea(p, r);
++}
++
++
++TQString SourceView::whatsThis() const
++{
++    return i18n( "<b>Annotated Source</b>"
++		 "<p>The annotated source list shows the "
++		 "source lines of the current selected function "
++		 "together with (self) cost spent while executing the "
++		 "code of this source line. If there was a call "
++		 "in a source line, lines with details on the "
++		 "call happening are inserted into the source: "
++		 "the cost spent inside of the call, the "
++		 "number of calls happening, and the call destination.</p>"
++		 "<p>Select a inserted call information line to "
++		 "make the destination function current.</p>");
++}
++
++void SourceView::context(TQListViewItem* i, const TQPoint & p, int c)
++{
++  TQPopupMenu popup;
++
++  // Menu entry:
++  TraceLineCall* lc = i ? ((SourceItem*) i)->lineCall() : 0;
++  TraceLineJump* lj = i ? ((SourceItem*) i)->lineJump() : 0;
++  TraceFunction* f = lc ? lc->call()->called() : 0;
++  TraceLine* line = lj ? lj->lineTo() : 0;
++
++  if (f) {
++    TQString name = f->name();
++    if ((int)name.length()>Configuration::maxSymbolLength())
++      name = name.left(Configuration::maxSymbolLength()) + "...";
++    popup.insertItem(i18n("Go to '%1'").arg(name), 93);
++    popup.insertSeparator();
++  }
++  else if (line) {
++    popup.insertItem(i18n("Go to Line %1").arg(line->name()), 93);
++    popup.insertSeparator();
++  }
++
++  if ((c == 1) || (c == 2)) {
++    addCostMenu(&popup);
++    popup.insertSeparator();
++  }
++  addGoMenu(&popup);
++
++  int r = popup.exec(p);
++  if (r == 93) {
++    if (f) activated(f);
++    if (line) activated(line);
++  }
++}
++
++
++void SourceView::selectedSlot(TQListViewItem * i)
++{
++  if (!i) return;
++  // programatically selected items are not signalled
++  if (_inSelectionUpdate) return;
++
++  TraceLineCall* lc = ((SourceItem*) i)->lineCall();
++  TraceLineJump* lj = ((SourceItem*) i)->lineJump();
++
++  if (!lc && !lj) {
++      TraceLine* l = ((SourceItem*) i)->line();
++      if (l) {
++	  _selectedItem = l;
++	  selected(l);
++      }
++      return;
++  }
++
++  TraceFunction* f = lc ? lc->call()->called() : 0;
++  if (f) {
++      _selectedItem = f;
++      selected(f);
++  }
++  else {
++    TraceLine* line = lj ? lj->lineTo() : 0;
++    if (line) {
++	_selectedItem = line;
++	selected(line);
++    }
++  }
++}
++
++void SourceView::activatedSlot(TQListViewItem * i)
++{
++  if (!i) return;
++  TraceLineCall* lc = ((SourceItem*) i)->lineCall();
++  TraceLineJump* lj = ((SourceItem*) i)->lineJump();
++
++  if (!lc && !lj) {
++      TraceLine* l = ((SourceItem*) i)->line();
++      if (l) activated(l);
++      return;
++  }
++
++  TraceFunction* f = lc ? lc->call()->called() : 0;
++  if (f) activated(f);
++  else {
++    TraceLine* line = lj ? lj->lineTo() : 0;
++    if (line) activated(line);
++  }
++}
++
++TraceItem* SourceView::canShow(TraceItem* i)
++{
++  TraceItem::CostType t = i ? i->type() : TraceItem::NoCostType;
++  TraceFunction* f = 0;
++
++  switch(t) {
++  case TraceItem::Function:
++      f = (TraceFunction*) i;
++      break;
++
++  case TraceItem::Instr:
++      f = ((TraceInstr*)i)->function();
++      select(i);
++      break;
++
++  case TraceItem::Line:
++      f = ((TraceLine*)i)->functionSource()->function();
++      select(i);
++      break;
++
++  default:
++      break;
++  }
++
++  return f;
++}
++
++void SourceView::doUpdate(int changeType)
++{
++  // Special case ?
++  if (changeType == selectedItemChanged) {
++
++      if (!_selectedItem) {
++	  clearSelection();
++	  return;
++      }
++
++      TraceLine* sLine = 0;
++      if (_selectedItem->type() == TraceItem::Line)
++	  sLine = (TraceLine*) _selectedItem;
++      if (_selectedItem->type() == TraceItem::Instr)
++	  sLine = ((TraceInstr*)_selectedItem)->line();
++
++      SourceItem* si = (SourceItem*)TQListView::selectedItem();
++      if (si) {
++	  if (si->line() == sLine) return;
++	  if (si->lineCall() &&
++	      (si->lineCall()->call()->called() == _selectedItem)) return;
++      }
++
++      TQListViewItem *item, *item2;
++      for (item = firstChild();item;item = item->nextSibling()) {
++	  si = (SourceItem*)item;
++	  if (si->line() == sLine) {
++	      ensureItemVisible(item);
++              _inSelectionUpdate = true;
++	      setCurrentItem(item);
++              _inSelectionUpdate = false;
++	      break;
++	  }
++	  item2 = item->firstChild();
++	  for (;item2;item2 = item2->nextSibling()) {
++	      si = (SourceItem*)item2;
++	      if (!si->lineCall()) continue;
++	      if (si->lineCall()->call()->called() == _selectedItem) {
++		  ensureItemVisible(item2);
++                  _inSelectionUpdate = true;
++		  setCurrentItem(item2);
++                  _inSelectionUpdate = false;
++		  break;
++	      }
++	  }
++	  if (item2) break;
++      }
++      return;
++  }
++
++  if (changeType == groupTypeChanged) {
++    TQListViewItem *item, *item2;
++    for (item = firstChild();item;item = item->nextSibling())
++      for (item2 = item->firstChild();item2;item2 = item2->nextSibling())
++        ((SourceItem*)item2)->updateGroup();
++  }
++
++  refresh();
++}
++
++void SourceView::refresh()
++{
++  clear();
++  setColumnWidth(0, 20);
++  setColumnWidth(1, 50);
++  setColumnWidth(2, _costType2 ? 50:0);
++  setColumnWidth(3, 0); // arrows, defaults to invisible
++  setSorting(0); // always reset to line number sort
++  if (_costType)
++    setColumnText(1, _costType->name());
++  if (_costType2)
++    setColumnText(2, _costType2->name());
++
++  _arrowLevels = 0;
++
++  if (!_data || !_activeItem) {
++    setColumnText(4, i18n("(No Source)"));
++    return;
++  }
++
++  TraceItem::CostType t = _activeItem->type();
++  TraceFunction* f = 0;
++  if (t == TraceItem::Function) f = (TraceFunction*) _activeItem;
++  if (t == TraceItem::Instr) {
++    f = ((TraceInstr*)_activeItem)->function();
++    if (!_selectedItem) _selectedItem = _activeItem;
++  }
++  if (t == TraceItem::Line) {
++    f = ((TraceLine*)_activeItem)->functionSource()->function();
++    if (!_selectedItem) _selectedItem = _activeItem;
++  }
++
++  if (!f) return;
++
++  // Allow resizing of column 2
++  setColumnWidthMode(2, TQListView::Maximum);
++
++  TraceFunctionSource* mainSF = f->sourceFile();
++
++  // skip first source if there's no debug info and there are more sources
++  // (this is for a bug in GCC 2.95.x giving unknown source for prologs)
++  if (mainSF &&
++      (mainSF->firstLineno() == 0) &&
++      (mainSF->lastLineno() == 0) &&
++      (f->sourceFiles().count()>1) ) {
++	  // skip
++  }
++  else
++      fillSourceFile(mainSF, 0);
++
++  TraceFunctionSource* sf;
++  int fileno = 1;
++  TraceFunctionSourceList l = f->sourceFiles();
++  for (sf=l.first();sf;sf=l.next(), fileno++)
++    if (sf != mainSF)
++      fillSourceFile(sf, fileno);
++
++  if (!_costType2) {
++    setColumnWidthMode(2, TQListView::Manual);
++    setColumnWidth(2, 0);
++  }
++}
++
++
++// helper for fillSourceList:
++// search recursive for a file, starting from a base dir
++static bool checkFileExistance(TQString& dir, const TQString& name)
++{
++  // we leave this in...
++  qDebug("Checking %s/%s", dir.ascii(), name.ascii());
++
++  if (TQFile::exists(dir + "/" + name)) return true;
++
++  // check in subdirectories
++  TQDir d(dir);
++  d.setFilter( TQDir::Dirs | TQDir::NoSymLinks );
++  d.setSorting( TQDir::Unsorted );
++  TQStringList subdirs = d.entryList();
++  TQStringList::Iterator it =subdirs.begin();
++  for(; it != subdirs.end(); ++it ) {
++    if (*it == "." || *it == ".." || *it == "CVS") continue;
++
++    dir = d.filePath(*it);
++    if (checkFileExistance(dir, name)) return true;
++  }
++  return false;
++}
++
++
++void SourceView::updateJumpArray(uint lineno, SourceItem* si,
++				 bool ignoreFrom, bool ignoreTo)
++{
++    TraceLineJump* lj;
++    uint lowLineno, highLineno;
++    int iEnd = -1, iStart = -1;
++
++    if (0) qDebug("updateJumpArray(line %d, jump to %s)",
++		  lineno,
++		  si->lineJump()
++		  ? si->lineJump()->lineTo()->name().ascii() : "?" );
++
++
++    lj=_lowList.current();
++    while(lj) {
++	lowLineno = lj->lineFrom()->lineno();
++	if (lj->lineTo()->lineno() < lowLineno)
++	    lowLineno = lj->lineTo()->lineno();
++
++	if (lowLineno > lineno) break;
++
++	if (ignoreFrom && (lowLineno < lj->lineTo()->lineno())) break;
++	if (ignoreTo && (lowLineno < lj->lineFrom()->lineno())) break;
++
++	if (si->lineJump() && (lj != si->lineJump())) break;
++
++	int asize = (int)_jump.size();
++#if 0
++	for(iStart=0;iStart<asize;iStart++)
++	    if (_jump[iStart] &&
++		(_jump[iStart]->lineTo() == lj->lineTo())) break;
++#else
++	iStart = asize;
++#endif
++
++	if (iStart == asize) {
++	    for(iStart=0;iStart<asize;iStart++)
++		if (_jump[iStart] == 0) break;
++
++	    if (iStart== asize) {
++		asize++;
++		_jump.resize(asize);
++		if (asize > _arrowLevels) _arrowLevels = asize;
++	    }
++
++	    if (0) qDebug(" start %d (%s to %s)",
++			  iStart,
++			  lj->lineFrom()->name().ascii(),
++			  lj->lineTo()->name().ascii());
++
++	    _jump[iStart] = lj;
++	}
++	lj=_lowList.next();
++    }
++
++    si->setJumpArray(_jump);
++
++    lj=_highList.current();
++    while(lj) {
++	highLineno = lj->lineFrom()->lineno();
++	if (lj->lineTo()->lineno() > highLineno) {
++	    highLineno = lj->lineTo()->lineno();
++	    if (ignoreTo) break;
++	}
++	else if (ignoreFrom) break;
++
++	if (highLineno > lineno) break;
++
++	for(iEnd=0;iEnd< (int)_jump.size();iEnd++)
++	    if (_jump[iEnd] == lj) break;
++	if (iEnd == (int)_jump.size()) {
++	    qDebug("LineView: no jump start for end at %x ?", highLineno);
++	    iEnd = -1;
++	}
++	lj=_highList.next();
++
++	if (0 && (iEnd>=0))
++	    qDebug(" end %d (%s to %s)",
++		   iEnd,
++		   _jump[iEnd]->lineFrom()->name().ascii(),
++		   _jump[iEnd]->lineTo()->name().ascii());
++
++	if (0 && lj) qDebug("next end: %s to %s",
++			    lj->lineFrom()->name().ascii(),
++			    lj->lineTo()->name().ascii());
++
++	if (highLineno > lineno)
++	    break;
++	else {
++	    if (iEnd>=0) _jump[iEnd] = 0;
++	    iEnd = -1;
++	}
++    }
++    if (iEnd>=0) _jump[iEnd] = 0;
++}
++
++
++/* If sourceList is empty we set the source file name into the header,
++ * else this code is of a inlined function, and we add "inlined from..."
++ */
++void SourceView::fillSourceFile(TraceFunctionSource* sf, int fileno)
++{
++  if (!sf) return;
++
++  if (0) qDebug("Selected Item %s", 
++		_selectedItem ? _selectedItem->name().ascii() : "(none)");
++
++  TraceLineMap::Iterator lineIt, lineItEnd;
++  int nextCostLineno = 0, lastCostLineno = 0;
++
++  bool validSourceFile = (!sf->file()->name().isEmpty());
++
++  TraceLine* sLine = 0;
++  if (_selectedItem) {
++    if (_selectedItem->type() == TraceItem::Line)
++      sLine = (TraceLine*) _selectedItem;
++    if (_selectedItem->type() == TraceItem::Instr)
++      sLine = ((TraceInstr*)_selectedItem)->line();
++  }
++
++  if (validSourceFile) {
++      TraceLineMap* lineMap = sf->lineMap();
++      if (lineMap) {
++	  lineIt    = lineMap->begin();
++	  lineItEnd = lineMap->end();
++	  // get first line with cost of selected type
++	  while(lineIt != lineItEnd) {
++	    if (&(*lineIt) == sLine) break;
++	    if ((*lineIt).hasCost(_costType)) break;
++	    if (_costType2 && (*lineIt).hasCost(_costType2)) break;
++	    ++lineIt;
++	  }
++
++	  nextCostLineno     = (lineIt == lineItEnd) ? 0 : (*lineIt).lineno();
++	  if (nextCostLineno<0) {
++	    kdError() << "SourceView::fillSourceFile: Negative line number "
++		      << nextCostLineno << endl
++		      << "  Function '" << sf->function()->name() << "'" << endl
++		      << "  File '" << sf->file()->name() << "'" << endl;
++	    nextCostLineno = 0;
++	  }
++	    
++      }
++
++      if (nextCostLineno == 0) {
++	  new SourceItem(this, this, fileno, 0, false,
++			 i18n("There is no cost of current selected type associated"));
++	  new SourceItem(this, this, fileno, 1, false,
++			 i18n("with any source line of this function in file"));
++	  new SourceItem(this, this, fileno, 2, false,
++			 TQString("    '%1'").arg(sf->function()->prettyName()));
++	  new SourceItem(this, this, fileno, 3, false,
++			 i18n("Thus, no annotated source can be shown."));
++	  return;
++      }
++  }
++
++  TQString filename = sf->file()->shortName();
++  TQString dir = sf->file()->directory();
++  if (!dir.isEmpty())
++    filename = dir + "/" + filename;
++
++  if (nextCostLineno>0) {
++    // we have debug info... search for source file
++    if (!TQFile::exists(filename)) {
++      TQStringList list = Configuration::sourceDirs(_data,
++						   sf->function()->object());
++      TQStringList::Iterator it;
++
++      for ( it = list.begin(); it != list.end(); ++it ) {
++        dir = *it;
++        if (checkFileExistance(dir, sf->file()->shortName())) break;
++      }
++
++      if (it == list.end())
++	  nextCostLineno = 0;
++      else {
++        filename = dir + "/" + sf->file()->shortName();
++        // no need to search again
++        sf->file()->setDirectory(dir);
++      }
++    }
++  }
++
++  // do it here, because the source directory could have been set before
++  if (childCount()==0) {
++    setColumnText(4, validSourceFile ?
++                  i18n("Source ('%1')").arg(filename) :
++                  i18n("Source (unknown)"));
++  }
++  else {
++    new SourceItem(this, this, fileno, 0, true,
++                   validSourceFile ?
++                   i18n("--- Inlined from '%1' ---").arg(filename) :
++                   i18n("--- Inlined from unknown source ---"));
++  }
++
++  if (nextCostLineno == 0) {
++    new SourceItem(this, this, fileno, 0, false,
++                   i18n("There is no source available for the following function:"));
++    new SourceItem(this, this, fileno, 1, false,
++                   TQString("    '%1'").arg(sf->function()->prettyName()));
++    if (sf->file()->name().isEmpty()) {
++      new SourceItem(this, this, fileno, 2, false,
++                     i18n("This is because no debug information is present."));
++      new SourceItem(this, this, fileno, 3, false,
++                     i18n("Recompile source and redo the profile run."));
++      if (sf->function()->object()) {
++        new SourceItem(this, this, fileno, 4, false,
++                       i18n("The function is located in this ELF object:"));
++        new SourceItem(this, this, fileno, 5, false,
++                       TQString("    '%1'")
++                       .arg(sf->function()->object()->prettyName()));
++      }
++    }
++    else {
++      new SourceItem(this, this, fileno, 2, false,
++                     i18n("This is because its source file cannot be found:"));
++      new SourceItem(this, this, fileno, 3, false,
++                     TQString("    '%1'").arg(sf->file()->name()));
++      new SourceItem(this, this, fileno, 4, false,
++                     i18n("Add the folder of this file to the source folder list."));
++      new SourceItem(this, this, fileno, 5, false,
++                     i18n("The list can be found in the configuration dialog."));
++    }
++    return;
++  }
++
++
++  // initialisation for arrow drawing
++  // create sorted list of jumps (for jump arrows)
++  TraceLineMap::Iterator it = lineIt, nextIt;
++  _lowList.clear();
++  _highList.clear();
++  while(1) {
++
++      nextIt = it;
++      ++nextIt;
++      while(nextIt != lineItEnd) {
++	if (&(*nextIt) == sLine) break;
++	if ((*nextIt).hasCost(_costType)) break;
++	if (_costType2 && (*nextIt).hasCost(_costType2)) break;
++	++nextIt;
++      }
++
++      TraceLineJumpList jlist = (*it).lineJumps();
++      TraceLineJump* lj;
++      for (lj=jlist.first();lj;lj=jlist.next()) {
++	  if (lj->executedCount()==0) continue;
++	  // skip jumps to next source line with cost
++	  //if (lj->lineTo() == &(*nextIt)) continue;
++
++	  _lowList.append(lj);
++	  _highList.append(lj);
++      }
++      it = nextIt;
++      if (it == lineItEnd) break;
++  }
++  _lowList.sort();
++  _highList.sort();
++  _lowList.first(); // iterators to list start
++  _highList.first();
++  _jump.resize(0);
++
++
++  char buf[256];
++  bool inside = false, skipLineWritten = true;
++  int readBytes;
++  int fileLineno = 0;
++  SubCost most = 0;
++
++  TraceLine* currLine;
++  SourceItem *si, *si2, *item = 0, *first = 0, *selected = 0;
++  TQFile file(filename);
++  if (!file.open(IO_ReadOnly)) return;
++  while (1) {
++    readBytes=file.readLine(buf, sizeof( buf ));
++    if (readBytes<=0) {
++      // for nice empty 4 lines after function with EOF
++      buf[0] = 0;
++    }
++
++    if (readBytes >= (int) sizeof( buf )) {
++      qDebug("%s:%d  Line too long\n",
++	     sf->file()->name().ascii(), fileLineno);
++    }
++    else if ((readBytes>0) && (buf[readBytes-1] == '\n'))
++      buf[readBytes-1] = 0;
++
++
++    // keep fileLineno inside [lastCostLineno;nextCostLineno]
++    fileLineno++;
++    if (fileLineno == nextCostLineno) {
++	currLine = &(*lineIt);
++
++	// get next line with cost of selected type
++	++lineIt;
++	while(lineIt != lineItEnd) {
++	  if (&(*lineIt) == sLine) break;
++	  if ((*lineIt).hasCost(_costType)) break;
++	  if (_costType2 && (*lineIt).hasCost(_costType2)) break;
++	  ++lineIt;
++	}
++
++	lastCostLineno = nextCostLineno;
++	nextCostLineno = (lineIt == lineItEnd) ? 0 : (*lineIt).lineno();
++    }
++    else
++	currLine = 0;
++
++    // update inside
++    if (!inside) {
++	if (currLine) inside = true;
++    }
++    else {
++	if ( (fileLineno > lastCostLineno) &&
++	     ((nextCostLineno == 0) ||
++	      (fileLineno < nextCostLineno - Configuration::noCostInside()) ))
++	    inside = false;
++    }
++
++    int context = Configuration::context();
++
++    if ( ((lastCostLineno==0) || (fileLineno > lastCostLineno + context)) &&
++	 ((nextCostLineno==0) || (fileLineno < nextCostLineno - context))) {
++	if (lineIt == lineItEnd) break;
++
++	if (!skipLineWritten) {
++	    skipLineWritten = true;
++	    // a "skipping" line: print "..." instead of a line number
++	    strcpy(buf,"...");
++	}
++	else
++	    continue;
++    }
++    else
++	skipLineWritten = false;
++
++    si = new SourceItem(this, this, 
++			fileno, fileLineno, inside, TQString(buf),
++                        currLine);
++
++    if (!currLine) continue;
++
++    if (!selected && (currLine == sLine)) selected = si;
++    if (!first) first = si;
++
++    if (currLine->subCost(_costType) > most) {
++      item = si;
++      most = currLine->subCost(_costType);
++    }
++
++    si->setOpen(true);
++    TraceLineCallList list = currLine->lineCalls();
++    TraceLineCall* lc;
++    for (lc=list.first();lc;lc=list.next()) {
++	if ((lc->subCost(_costType)==0) &&
++	    (lc->subCost(_costType2)==0)) continue;
++
++      if (lc->subCost(_costType) > most) {
++        item = si;
++        most = lc->subCost(_costType);
++      }
++
++      si2 = new SourceItem(this, si, fileno, fileLineno, currLine, lc);
++
++      if (!selected && (lc->call()->called() == _selectedItem))
++	  selected = si2;
++    }
++
++    TraceLineJumpList jlist = currLine->lineJumps();
++    TraceLineJump* lj;
++    for (lj=jlist.first();lj;lj=jlist.next()) {
++	if (lj->executedCount()==0) continue;
++
++	new SourceItem(this, si, fileno, fileLineno, currLine, lj);
++    }
++  }
++
++  if (selected) item = selected;
++  if (item) first = item;
++  if (first) {
++      ensureItemVisible(first);
++      _inSelectionUpdate = true;
++      setCurrentItem(first);
++      _inSelectionUpdate = false;
++  }
++
++  file.close();
++
++  // for arrows: go down the list according to list sorting
++  sort();
++  TQListViewItem *item1, *item2;
++  for (item1=firstChild();item1;item1 = item1->nextSibling()) {
++      si = (SourceItem*)item1;
++      updateJumpArray(si->lineno(), si, true, false);
++
++      for (item2=item1->firstChild();item2;item2 = item2->nextSibling()) {
++	  si2 = (SourceItem*)item2;
++	  if (si2->lineJump())
++	      updateJumpArray(si->lineno(), si2, false, true);
++	  else
++	      si2->setJumpArray(_jump);
++      }
++  }
++
++  if (arrowLevels())
++      setColumnWidth(3, 10 + 6*arrowLevels() + itemMargin() * 2);
++  else
++      setColumnWidth(3, 0);
++}
++
++
++void SourceView::updateSourceItems()
++{
++    setColumnWidth(1, 50);
++    setColumnWidth(2, _costType2 ? 50:0);
++    // Allow resizing of column 2
++    setColumnWidthMode(2, TQListView::Maximum);
++    
++    if (_costType)
++      setColumnText(1, _costType->name());
++    if (_costType2)
++      setColumnText(2, _costType2->name());
++
++    SourceItem* si;
++    TQListViewItem* item  = firstChild();
++    for (;item;item = item->nextSibling()) {
++	si = (SourceItem*)item;
++	TraceLine* l = si->line();
++	if (!l) continue;
++
++	si->updateCost();
++
++	TQListViewItem *next, *i  = si->firstChild();
++	for (;i;i = next) {
++	    next = i->nextSibling();
++	    ((SourceItem*)i)->updateCost();
++	}
++    }
++
++    if (!_costType2) {
++      setColumnWidthMode(2, TQListView::Manual);
++      setColumnWidth(2, 0);
++    }
++}
++
++#include "sourceview.moc"
+diff --git a/kdecachegrind/kdecachegrind/sourceview.h b/kdecachegrind/kdecachegrind/sourceview.h
+new file mode 100644
+index 0000000..b72fc7a
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/sourceview.h
+@@ -0,0 +1,71 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Source View
++ */
++
++#ifndef SOURCEVIEW_H
++#define SOURCEVIEW_H
++
++#include <tqlistview.h>
++#include "traceitemview.h"
++
++class SourceItem;
++
++class SourceView : public TQListView, public TraceItemView
++{
++  friend class SourceItem;
++
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  SourceView(TraceItemView* parentView,
++            TQWidget* parent = 0, const char* name = 0);
++
++  TQWidget* widget() { return this; }
++  TQString whatsThis() const;
++
++protected:
++  int arrowLevels() { return _arrowLevels; }
++  void paintEmptyArea( TQPainter *, const TQRect & );
++
++private slots:
++  void context(TQListViewItem*, const TQPoint &, int);
++  void selectedSlot(TQListViewItem *);
++  void activatedSlot(TQListViewItem *);
++
++private:
++  TraceItem* canShow(TraceItem*);
++  void doUpdate(int);
++  void refresh();
++  void updateJumpArray(uint,SourceItem*,bool,bool);
++  void fillSourceFile(TraceFunctionSource*, int);
++  void updateSourceItems();
++
++  bool _inSelectionUpdate;
++
++  // arrows
++  int _arrowLevels;
++  // temporary needed on creation...
++  TQMemArray<TraceLineJump*> _jump;
++  TraceLineJumpList _lowList, _highList;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/stackbrowser.cpp b/kdecachegrind/kdecachegrind/stackbrowser.cpp
+new file mode 100644
+index 0000000..78095eb
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/stackbrowser.cpp
+@@ -0,0 +1,417 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++#include <tqlistview.h>
++
++#include "stackbrowser.h"
++
++// Stack
++
++Stack::Stack(TraceFunction* top, TraceCallList calls)
++{
++  _refCount = 0;
++  _top = top;
++  _calls = calls;
++
++  extendBottom();
++}
++
++Stack::Stack(TraceFunction* f)
++{
++  _refCount = 0;
++  _top = f;
++
++  extendBottom();
++  extendTop();
++}
++
++void Stack::extendBottom()
++{
++  TraceCallList l;
++  TraceCall *c,  *call;
++  SubCost most;
++  TraceFunction* f;
++
++  if (_calls.last())
++    f = _calls.last()->called();
++  else
++    f = _top;
++
++  if (!f) return;
++  // don't follow calls from cycles
++  if (f->cycle() == f) return;
++
++
++  int max = 30;
++
++  // try to extend to lower stack frames
++  while (f && (max-- >0)) {
++    l = f->callings();
++    call = 0;
++    most = 0;
++    for (c=l.first();c;c=l.next()) {
++	// no cycle calls in stack: could be deleted without notice
++	if (c->called()->cycle() == c->called()) continue;
++	// no simple recursions
++	if (c->called() == _top) continue;
++
++      if (c->called()->name().isEmpty()) continue;
++      SubCost sc = c->subCost(0); // FIXME
++      if (sc == 0) continue;
++
++      if (sc > most) {
++        most = sc;
++        call = c;
++      }
++    }
++    if (!call)
++      break;
++
++    _calls.append(call);
++    f = call->called();
++  }
++}
++
++
++void Stack::extendTop()
++{
++  TraceCallList l;
++  TraceCall *c,  *call;
++  SubCost most;
++
++  int max = 10;
++
++  // don't follow calls from cycles
++  if (_top->cycle() == _top) return;
++
++  // try to extend to upper stack frames
++  while (_top && (max-- >0)) {
++    l = _top->callers();
++    call = 0;
++    most = 0;
++    for (c=l.first();c;c=l.next()) {
++	// no cycle calls in stack: could be deleted without notice
++	if (c->caller()->cycle() == c->caller()) continue;
++	// no simple recursions
++	if (c->caller() == _top) continue;
++
++      if (c->caller()->name().isEmpty()) continue;
++      SubCost sc = c->subCost(0); // FIXME
++      if (sc == 0) continue;
++
++      if (sc > most) {
++        most = sc;
++        call = c;
++      }
++    }
++    if (!call)
++      break;
++
++    _calls.prepend(call);
++    _top = call->caller();
++  }
++}
++
++TraceFunction* Stack::caller(TraceFunction* fn, bool extend)
++{
++  TraceFunction* f;
++  TraceCall* c;
++
++  if (extend && (_top == fn)) {
++    // extend at top
++    extendTop();
++    f = _top;
++  }
++
++  for (c=_calls.first();c;c=_calls.next()) {
++    f = c->called();
++    if (f == fn)
++      return c->caller();
++  }
++  return 0;
++}
++
++TraceFunction* Stack::called(TraceFunction* fn, bool extend)
++{
++  TraceFunction* f;
++  TraceCall* c;
++
++  for (c=_calls.first();c;c=_calls.next()) {
++    f = c->caller();
++    if (f == fn)
++      return c->called();
++  }
++
++  if (extend && (c->called() == fn)) {
++    // extend at bottom
++    extendBottom();
++
++    // and search again
++    for (c=_calls.first();c;c=_calls.next()) {
++      f = c->caller();
++      if (f == fn)
++        return c->called();
++    }
++  }
++
++  return 0;
++}
++
++bool Stack::contains(TraceFunction* fn)
++{
++    // cycles are listed on there own
++    if (fn->cycle() == fn) return false;
++    if (_top->cycle() == _top) return false;
++
++  if (fn == _top)
++    return true;
++
++  TraceFunction* f = _top;
++  TraceCall* c;
++
++  for (c=_calls.first();c;c=_calls.next()) {
++    f = c->called();
++    if (f == fn)
++      return true;
++  }
++
++  TraceCallList l;
++
++  // try to extend at bottom (even if callCount 0)
++  l = f->callings();
++  for (c=l.first();c;c=l.next()) {
++    f = c->called();
++    if (f == fn)
++      break;
++  }
++
++  if (c) {
++    _calls.append(c);
++
++    // extend at bottom after found one
++    extendBottom();
++    return true;
++  }
++
++  // try to extend at top (even if callCount 0)
++  l = _top->callers();
++  for (c=l.first();c;c=l.next()) {
++    f = c->caller();
++    if (f == fn)
++      break;
++  }
++
++  if (c) {
++    _calls.prepend(c);
++
++    // extend at top after found one
++    extendTop();
++    return true;
++  }
++
++  return false;
++}
++
++Stack* Stack::split(TraceFunction* f)
++{
++  TraceCallList calls = _calls;
++  TraceCall *c, *c2;
++
++  // cycles are listed on there own
++  if (f->cycle() == f) return 0;
++  if (_top->cycle() == _top) return false;
++
++  for (c=calls.first();c;c=calls.next()) {
++    TraceCallList l = c->called()->callings();
++    for (c2=l.first();c2;c2=l.next()) {
++      if (c2 == c) continue;
++      if (c2->called() == f)
++        break;
++    }
++    if (c2)
++      break;
++  }
++
++  if (!c)
++    return 0;
++
++  // remove bottom part
++  calls.last();
++  while (calls.current() && calls.current()!=c)
++    calls.removeLast();
++
++  calls.append(c2);
++  return new Stack(_top, calls );
++}
++
++TQString Stack::toString()
++{
++  TQString res = _top->name();
++  TraceCall *c;
++  for (c=_calls.first();c;c=_calls.next())
++    res += "\n > " + c->called()->name();
++
++  return res;
++}
++
++
++// HistoryItem
++
++HistoryItem::HistoryItem(Stack* stack, TraceFunction* function)
++{
++  _stack = stack;
++  _function = function;
++  if (_stack)
++    _stack->ref();
++
++  _last = 0;
++  _next = 0;
++
++/*
++  qDebug("New Stack History Item (sRef %d): %s\n  %s",
++         _stack->refCount(), _function->name().ascii(),
++         _stack->toString().ascii());
++*/
++}
++
++HistoryItem::~HistoryItem()
++{
++  if (0) qDebug("Deleting Stack History Item (sRef %d): %s",
++         _stack->refCount(),
++         _function->name().ascii());
++
++  if (_last)
++    _last->_next = _next;
++  if (_stack) {
++    if (_stack->deref() == 0)
++      delete _stack;
++  }
++}
++
++
++// StackBrowser
++
++StackBrowser::StackBrowser()
++{
++  _current = 0;
++}
++
++StackBrowser::~StackBrowser()
++{
++  delete _current;
++}
++
++HistoryItem* StackBrowser::select(TraceFunction* f)
++{
++  if (!_current) {
++    Stack* s = new Stack(f);
++    _current = new HistoryItem(s, f);
++  }
++  else if (_current->function() != f) {
++    // make current item the last one
++    HistoryItem* item = _current;
++    if (item->next()) {
++      item = item->next();
++      item->last()->setNext(0);
++
++      while (item->next()) {
++        item = item->next();
++        delete item->last();
++      }
++      delete item;
++    }
++
++    Stack* s = _current->stack();
++    if (!s->contains(f)) {
++      s = s->split(f);
++      if (!s)
++        s = new Stack(f);
++    }
++
++    item = _current;
++    _current = new HistoryItem(s, f);
++    item->setNext(_current);
++    _current->setLast(item);
++  }
++
++  // qDebug("Selected %s in StackBrowser", f->name().ascii());
++
++  return _current;
++}
++
++HistoryItem* StackBrowser::goBack()
++{
++  if (_current && _current->last())
++    _current = _current->last();
++
++  return _current;
++}
++
++HistoryItem* StackBrowser::goForward()
++{
++  if (_current && _current->next())
++    _current = _current->next();
++
++  return _current;
++}
++
++HistoryItem* StackBrowser::goUp()
++{
++  if (_current) {
++    TraceFunction* f = _current->stack()->caller(_current->function(), true);
++    if (f)
++      _current = select(f);
++  }
++
++  return _current;
++}
++
++HistoryItem* StackBrowser::goDown()
++{
++  if (_current) {
++    TraceFunction* f = _current->stack()->called(_current->function(), true);
++    if (f)
++      _current = select(f);
++  }
++
++  return _current;
++}
++
++bool StackBrowser::canGoBack()
++{
++  return _current && _current->last();
++}
++
++bool StackBrowser::canGoForward()
++{
++  return _current && _current->next();
++}
++
++bool StackBrowser::canGoUp()
++{
++  if (!_current) return false;
++
++  return _current->stack()->caller(_current->function(), false);
++}
++
++bool StackBrowser::canGoDown()
++  {
++  if (!_current) return false;
++
++  return _current->stack()->called(_current->function(), false);
++}
+diff --git a/kdecachegrind/kdecachegrind/stackbrowser.h b/kdecachegrind/kdecachegrind/stackbrowser.h
+new file mode 100644
+index 0000000..e7d6b80
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/stackbrowser.h
+@@ -0,0 +1,109 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++#ifndef STACKBROWSER_H
++#define STACKBROWSER_H
++
++#include "tracedata.h"
++
++// A history of selected functions within stacks
++
++class Stack
++{
++public:
++  Stack(TraceFunction*);
++
++  // extend the stack at top/bottom if possible
++  bool contains(TraceFunction*);
++
++  void extendBottom();
++  void extendTop();
++
++  // search for a function on stack calling specified function.
++  // if found, return upper part with new function call
++  Stack* split(TraceFunction*);
++
++  // increment reference count
++  void ref() { _refCount++; }
++  // decrement reference count
++  bool deref() { return --_refCount; }
++  int refCount() { return _refCount; }
++
++  TraceFunction* top() { return _top; }
++  TraceCallList calls() { return _calls; }
++  TraceFunction* caller(TraceFunction*, bool extend);
++  TraceFunction* called(TraceFunction*, bool extend);
++
++  TQString toString();
++
++private:
++  Stack(TraceFunction* top, TraceCallList list);
++
++  // at the top of the stack we have a function...
++  TraceFunction* _top;
++  // list ordered from top to bottom
++  TraceCallList _calls;
++  int _refCount;
++};
++
++class HistoryItem
++{
++public:
++  HistoryItem(Stack*, TraceFunction*);
++  ~HistoryItem();
++
++  Stack* stack() { return _stack; }
++  TraceFunction* function() { return _function; }
++  HistoryItem* last() { return _last; }
++  HistoryItem* next() { return _next; }
++  void setLast(HistoryItem* h) { _last = h; }
++  void setNext(HistoryItem* h) { _next = h; }
++
++private:
++
++  HistoryItem *_last, *_next;
++  Stack* _stack;
++  TraceFunction* _function;
++};
++
++
++class StackBrowser
++{
++public:
++  StackBrowser();
++  ~StackBrowser();
++
++  // A function was selected. This creates a new history entry
++  HistoryItem* select(TraceFunction*);
++
++  HistoryItem* current() { return _current; }
++  bool canGoBack();
++  bool canGoForward();
++  bool canGoUp();
++  bool canGoDown();
++  HistoryItem* goBack();
++  HistoryItem* goForward();
++  HistoryItem* goUp();
++  HistoryItem* goDown();
++
++private:
++  HistoryItem* _current;
++};
++
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/stackitem.cpp b/kdecachegrind/kdecachegrind/stackitem.cpp
+new file mode 100644
+index 0000000..e3763ab
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/stackitem.cpp
+@@ -0,0 +1,116 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Items of stack dockable.
++ */
++
++#include <tqpixmap.h>
++#include <klocale.h>
++
++#include "configuration.h"
++#include "listutils.h"
++#include "stackitem.h"
++#include "stackselection.h"
++
++// StackItem
++
++StackItem::StackItem(StackSelection* ss, 
++		     TQListView* parent, TraceFunction* f)
++  :TQListViewItem(parent)
++{
++  _view = ss;
++  _function = f;
++  _call = 0;
++
++  updateGroup();
++  updateCost();
++
++  setText(2, TQString("-- "));
++  setText(3, f->prettyName());
++}
++
++StackItem::StackItem(StackSelection* ss,
++		     TQListView* parent, TraceCall* call)
++  :TQListViewItem(parent)
++{
++  _view = ss;
++  _call = call;
++  _function = call->called();
++
++  updateGroup();
++  updateCost();
++
++  setText(3, _function->prettyName());
++}
++
++
++void StackItem::updateGroup()
++{
++  TQColor c = Configuration::functionColor(_view->groupType(),
++					  _function);
++  setPixmap(3, colorPixmap(10, 10, c));
++}
++
++void StackItem::updateCost()
++{
++  if (!_call) return;
++
++  setText(2, _call->prettyCallCount());
++
++  TraceCostType* ct = _view->costType();
++  _sum = _call->subCost(ct);
++  double total = _call->called()->data()->subCost(ct);
++  if (total == 0.0) {
++    setText(0, "-");
++    setPixmap(0, TQPixmap());
++  }
++  else {
++    double sum  = 100.0 * _sum / total;
++
++    if (Configuration::showPercentage())
++      setText(0, TQString("%1")
++	      .arg(sum, 0, 'f', Configuration::percentPrecision()));
++    else
++      setText(0, _call->prettySubCost(ct));
++    
++    setPixmap(0, costPixmap(ct, _call, total, false));
++  }
++
++  // if _costType2 is 0, column1 is hidden, no change needed
++  TraceCostType* ct2 = _view->costType2();
++  if (!ct2) return;
++
++  _sum = _call->subCost(ct2);
++  total = _call->called()->data()->subCost(ct2);
++  if (total == 0.0) {
++    setText(1, "-");
++    setPixmap(1, TQPixmap());
++  }
++  else {
++    double sum  = 100.0 * _sum / total;
++
++    if (Configuration::showPercentage())
++      setText(1, TQString("%1")
++	      .arg(sum, 0, 'f', Configuration::percentPrecision()));
++    else
++      setText(1, _call->prettySubCost(ct2));
++    
++    setPixmap(1, costPixmap(ct2, _call, total, false));
++  }
++}
+diff --git a/kdecachegrind/kdecachegrind/stackitem.h b/kdecachegrind/kdecachegrind/stackitem.h
+new file mode 100644
+index 0000000..250e9f6
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/stackitem.h
+@@ -0,0 +1,56 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003, 2004
++   Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Items of stack dockable.
++ */
++
++#ifndef STACKITEM_H
++#define STACKITEM_H
++
++#include <tqlistview.h>
++#include "tracedata.h"
++
++class StackSelection;
++
++
++// for the stack browser
++
++class StackItem: public TQListViewItem
++{
++public:
++  // for top
++  StackItem(StackSelection* ss, TQListView* parent, TraceFunction* f);
++  StackItem(StackSelection* ss, TQListView* parent, TraceCall* c);
++
++  TraceFunction* function() { return _function; }
++  TraceCall* call() { return _call; }
++  void updateGroup();
++  void updateCost();
++
++private:
++  StackSelection* _view;
++  SubCost _sum;
++  TraceFunction* _function;
++  TraceCall* _call;
++};
++
++
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/stackselection.cpp b/kdecachegrind/kdecachegrind/stackselection.cpp
+new file mode 100644
+index 0000000..5909475
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/stackselection.cpp
+@@ -0,0 +1,230 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * StackSelection for KCachegrind
++ * For function selection of a most expected stack,
++ *  to be put into a TQDockWindow
++ */
++
++#include <tqtimer.h>
++#include <tqlistview.h>
++#include <tqlabel.h>
++#include <tqpushbutton.h>
++#include <tqcombobox.h>
++#include <tqlineedit.h>
++
++#include <kdebug.h>
++
++#include "stackbrowser.h"
++#include "stackselection.h"
++#include "stackitem.h"
++
++StackSelection::StackSelection( TQWidget* parent, const char* name)
++  : StackSelectionBase(parent, name)
++{
++  _data = 0;
++  _browser = new StackBrowser();
++  _item = 0;
++  _function = 0;
++  _costType = 0;
++  _costType2 = 0;
++  _groupType = TraceItem::Function;
++
++  stackList->setSorting(-1);
++  stackList->setAllColumnsShowFocus(true);
++  stackList->setResizeMode(TQListView::LastColumn);
++  stackList->setColumnAlignment(0, TQt::AlignRight);
++  stackList->setColumnAlignment(1, TQt::AlignRight);
++  stackList->setColumnAlignment(2, TQt::AlignRight);
++  stackList->setColumnWidth(0, 50);
++  // 2nd cost column hidden at first (_costType2 == 0)
++  stackList->setColumnWidth(1, 0);
++  stackList->setColumnWidth(2, 50);
++
++  connect(stackList, TQT_SIGNAL(selectionChanged(TQListViewItem*)),
++          this, TQT_SLOT(stackSelected(TQListViewItem*)));
++}
++
++StackSelection::~StackSelection()
++{
++  delete _browser;
++}
++
++void StackSelection::setData(TraceData* data)
++{
++  if (_data == data) return;
++
++  _data = data;
++
++  stackList->clear();
++   delete _browser;
++  _browser = new StackBrowser();
++  _function = 0;
++}
++
++
++void StackSelection::setFunction(TraceFunction* f)
++{
++  if (_function == f) return;
++  _function = f;
++
++  if (!_data || !_function) return;
++
++  //kdDebug() << "StackSelection::setFunction " << f->name() << endl;
++
++  HistoryItem* item = _browser->current();
++  if (!item || item->function() != f) {
++    _browser->select(f);
++    rebuildStackList();
++  }
++}
++
++
++void StackSelection::rebuildStackList()
++{
++  HistoryItem* item = _browser->current();
++  stackList->clear();
++  stackList->setColumnWidth(0, 50);
++  stackList->setColumnWidth(1, _costType2 ? 50:0);
++  stackList->setColumnWidth(2, 50);
++  if (!item || !item->stack()) return;
++
++  TraceFunction* top = item->stack()->top();
++  if (!top) return;
++
++  stackList->setColumnWidthMode(1, TQListView::Maximum);
++
++  TraceCallList l = item->stack()->calls();
++  TraceCall* call;
++  for (call=l.last();call;call=l.prev())
++    new StackItem(this, stackList, call);
++
++  new StackItem(this, stackList, top);
++
++  // select current function
++  TQListViewItem* i = stackList->firstChild();
++  for (;i;i=i->nextSibling())
++    if (((StackItem*)i)->function() == item->function())
++      break;
++
++  if (i) {
++    // this calls stackFunctionSelected()
++    stackList->setCurrentItem(i);
++    stackList->ensureItemVisible(i);
++  }
++
++  if (!_costType2) {
++    stackList->setColumnWidthMode(1, TQListView::Manual);
++    stackList->setColumnWidth(1, 0);
++  }
++}
++
++void StackSelection::stackSelected(TQListViewItem* i)
++{
++  if (!i) return;
++
++  TraceFunction* f = ((StackItem*)i)->function();
++  emit functionSelected(f);
++}
++
++
++void StackSelection::browserBack()
++{
++  if (_browser && _browser->canGoBack()) {
++    _browser->goBack();
++    rebuildStackList();
++  }
++}
++
++void StackSelection::browserForward()
++{
++  if (_browser && _browser->canGoForward()) {
++    _browser->goForward();
++    rebuildStackList();
++  }
++}
++
++void StackSelection::browserUp()
++{
++  if (_browser) {
++    _browser->goUp();
++    rebuildStackList();
++  }
++}
++
++void StackSelection::browserDown()
++{
++  if (_browser) {
++    _browser->goDown();
++    rebuildStackList();
++  }
++}
++
++void StackSelection::refresh()
++{
++  TQListViewItem* item  = stackList->firstChild();
++  for(;item;item = item->nextSibling())
++    ((StackItem*)item)->updateCost();
++}
++
++void StackSelection::setCostType(TraceCostType* ct)
++{
++  if (ct == _costType) return;
++  _costType = ct;
++
++  stackList->setColumnWidth(0, 50);
++  if (_costType)
++    stackList->setColumnText(0, _costType->name());
++
++  TQListViewItem* item  = stackList->firstChild();
++  for(;item;item = item->nextSibling())
++    ((StackItem*)item)->updateCost();
++}
++
++void StackSelection::setCostType2(TraceCostType* ct)
++{
++  if (ct == _costType2) return;
++  _costType2 = ct;
++
++  stackList->setColumnWidth(1, 50);
++  stackList->setColumnWidthMode(1, TQListView::Maximum);
++  if (_costType2)
++    stackList->setColumnText(1, _costType2->name());
++
++  TQListViewItem* item  = stackList->firstChild();
++  for(;item;item = item->nextSibling())
++    ((StackItem*)item)->updateCost();
++
++  if (!_costType2) {
++    stackList->setColumnWidthMode(1, TQListView::Manual);
++    stackList->setColumnWidth(1, 0);
++  }
++}
++
++void StackSelection::setGroupType(TraceItem::CostType gt)
++{
++  if (_groupType == gt) return;
++  _groupType = gt;
++
++  TQListViewItem* item  = stackList->firstChild();
++  for(;item;item = item->nextSibling())
++    ((StackItem*)item)->updateGroup();
++}
++
++#include "stackselection.moc"
+diff --git a/kdecachegrind/kdecachegrind/stackselection.h b/kdecachegrind/kdecachegrind/stackselection.h
+new file mode 100644
+index 0000000..2bb3a75
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/stackselection.h
+@@ -0,0 +1,81 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * StackSelection for KCachegrind
++ * For function selection of a most expected stack,
++ *  to be put into a TQDockWindow
++ */
++
++#ifndef STACKSELECTION_H
++#define STACKSELECTION_H
++
++#include "stackselectionbase.h"
++#include "tracedata.h"
++
++class TraceFunction;
++class TraceData;
++class StackBrowser;
++class NestedAreaItem;
++
++class StackSelection : public StackSelectionBase
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  StackSelection( TQWidget* parent = 0, const char* name = 0);
++  ~StackSelection();
++
++  TraceData* data() const { return _data; }
++  void setData(TraceData*);
++  StackBrowser* browser() const { return _browser; }
++  TraceCostType* costType() { return _costType; }
++  TraceCostType* costType2() { return _costType2; }
++  TraceItem::CostType groupType() { return _groupType; }
++
++signals:
++  void functionSelected(TraceItem*);
++
++public slots:
++  void setFunction(TraceFunction*);
++  void setCostType(TraceCostType*);
++  void setCostType2(TraceCostType*);
++  void setGroupType(TraceItem::CostType);
++
++  void stackSelected( TQListViewItem* );
++  void browserBack();
++  void browserForward();
++  void browserUp();
++  void browserDown();
++  void refresh();
++  void rebuildStackList();
++
++private:
++  void selectFunction();
++
++  TraceData* _data;
++  StackBrowser* _browser;
++  TQListViewItem* _item;
++  TraceFunction* _function;
++  TraceCostType* _costType;
++  TraceCostType* _costType2;
++  TraceItem::CostType _groupType;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/stackselectionbase.ui b/kdecachegrind/kdecachegrind/stackselectionbase.ui
+new file mode 100644
+index 0000000..c61010f
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/stackselectionbase.ui
+@@ -0,0 +1,80 @@
++<!DOCTYPE UI><UI version="3.0" stdsetdef="1">
++<class>StackSelectionBase</class>
++<widget class="TQWidget">
++    <property name="name">
++        <cstring>StackSelectionBase</cstring>
++    </property>
++    <property name="geometry">
++        <rect>
++            <x>0</x>
++            <y>0</y>
++            <width>168</width>
++            <height>108</height>
++        </rect>
++    </property>
++    <property name="caption">
++        <string>Stack Selection</string>
++    </property>
++    <vbox>
++        <property name="name">
++            <cstring>unnamed</cstring>
++        </property>
++        <property name="margin">
++            <number>3</number>
++        </property>
++        <property name="spacing">
++            <number>6</number>
++        </property>
++        <widget class="TQListView">
++            <column>
++                <property name="text">
++                    <string>Cost</string>
++                </property>
++                <property name="clickable">
++                    <bool>true</bool>
++                </property>
++                <property name="resizeable">
++                    <bool>true</bool>
++                </property>
++            </column>
++            <column>
++                <property name="text">
++                    <string>Cost2</string>
++                </property>
++                <property name="clickable">
++                    <bool>true</bool>
++                </property>
++                <property name="resizeable">
++                    <bool>true</bool>
++                </property>
++            </column>
++            <column>
++                <property name="text">
++                    <string>Calls</string>
++                </property>
++                <property name="clickable">
++                    <bool>true</bool>
++                </property>
++                <property name="resizeable">
++                    <bool>true</bool>
++                </property>
++            </column>
++            <column>
++                <property name="text">
++                    <string>Function</string>
++                </property>
++                <property name="clickable">
++                    <bool>true</bool>
++                </property>
++                <property name="resizeable">
++                    <bool>true</bool>
++                </property>
++            </column>
++            <property name="name">
++                <cstring>stackList</cstring>
++            </property>
++        </widget>
++    </vbox>
++</widget>
++<layoutdefaults spacing="6" margin="11"/>
++</UI>
+diff --git a/kdecachegrind/kdecachegrind/subcost.cpp b/kdecachegrind/kdecachegrind/subcost.cpp
+new file mode 100644
+index 0000000..7b5034e
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/subcost.cpp
+@@ -0,0 +1,62 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2004 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++#include <tqstring.h>
++
++#include "subcost.h"
++
++//---------------------------------------------------
++// SubCost
++
++bool SubCost::set(const char** ps)
++{
++    const char* s = *ps;
++    if (!s || (*s < '0') || (*s > '9')) return false;
++
++    v = *s - '0';
++    s++;
++    while(*s >= '0' && *s <= '9') {
++	v = 10* v + (*s-'0');
++	s++;
++    }
++    while(*s == ' ') s++;
++    *ps = s;
++
++    return true;
++}
++
++TQString SubCost::pretty()
++{
++    unsigned long long n = v;
++
++    if (n==0) return TQString(" 0");
++
++    int i = 0;
++    TQString res = "";
++
++    while (n) {
++	if ((i>0) && !(i%3)) res = " " + res;
++	i++;
++	res = TQChar('0'+int(n%10)) + res;
++	n /= 10;
++    }
++    res = " " + res;
++    return res;
++}
++
++
+diff --git a/kdecachegrind/kdecachegrind/subcost.h b/kdecachegrind/kdecachegrind/subcost.h
+new file mode 100644
+index 0000000..8169280
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/subcost.h
+@@ -0,0 +1,66 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002-2004 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++#ifndef SUBCOST_H
++#define SUBCOST_H
++
++#include "utils.h"
++
++typedef unsigned long long uint64;
++
++/**
++ * Cost event counter, simple wrapper around a 64bit entity
++ */
++class SubCost
++{
++ public:
++    SubCost() {}
++    SubCost(uint64 i) { v=i; }
++    SubCost(unsigned i) { v=i; }
++    SubCost(int i) { v=(unsigned)i; }
++    SubCost(double d) { v= (uint64)(d + .5); }
++
++    SubCost& operator=(uint64 i) { v = i; return *this; }
++    SubCost& operator=(unsigned i) { v = i; return *this; }
++    SubCost& operator=(int i) { v = i; return *this; }
++    SubCost& operator=(double d) { v = (uint64)(d + .5); return *this; }
++
++    bool set(const char** s);
++    bool set(FixString& s) { return s.stripUInt64(v); }
++
++    operator uint64&() { return v; }
++
++    bool operator==(unsigned i) const { return v == i; }
++    bool operator==(int i) const { return v == (unsigned)i; }
++    bool operator<(unsigned i) const { return v < i; }
++    bool operator<(int i) const { return v < (unsigned)i; }
++    bool operator<(const SubCost& s) const { return v < s.v; }
++    bool operator>(unsigned i) const { return v > i; }
++    bool operator>(int i) const { return v > (unsigned)i; }
++    bool operator>(const SubCost& s) const { return v > s.v; }
++
++    /**
++     * Convert SubCost value into a TQString,
++     * spaced every 3 digits.
++     */
++    TQString pretty();
++
++    uint64 v;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/tabview.cpp b/kdecachegrind/kdecachegrind/tabview.cpp
+new file mode 100644
+index 0000000..0049d1e
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/tabview.cpp
+@@ -0,0 +1,890 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Tab View, enclosing detailed views for one trace item in
++ * two tab widgets, separated by a splitter
++ */
++
++#include <tqobjectlist.h>
++#include <tqsplitter.h>
++#include <tqtabwidget.h>
++#include <tqlayout.h>
++#include <tqwhatsthis.h>
++#include <tqpopupmenu.h>
++
++#include <klocale.h>
++#include <kconfig.h>
++
++#include "tabview.h"
++#include "costtypeview.h"
++#include "partview.h"
++#include "callview.h"
++#include "coverageview.h"
++#include "callmapview.h"
++#include "instrview.h"
++#include "sourceview.h"
++#include "callgraphview.h"
++
++// TabBar
++
++TabBar::TabBar(TabView* v, TQTabWidget* parent, const char *name)
++    : TQTabBar(parent, name)
++{
++    _tabWidget = parent;
++    _tabView = v;
++}
++
++void TabBar::mousePressEvent(TQMouseEvent *e)
++{
++  if (e->button() == Qt::RightButton) {
++      TQTab *tab = selectTab( e->pos() );
++      TQWidget* page;
++      page = tab ? _tabWidget->page( indexOf( tab->identifier() ) ) :0;
++
++      TQPopupMenu popup, popup1, popup2, popup3;
++      if (page) {
++        TraceItemView::Position p = _tabView->tabPosition(page);
++        if (p != TraceItemView::Top) {
++          popup.insertItem(i18n("Move to Top"), 81);
++          popup2.insertItem(i18n("Top"), 91);
++        }
++        if (p != TraceItemView::Right) {
++          popup.insertItem(i18n("Move to Right"), 82);
++          popup2.insertItem(i18n("Right"), 92);
++        }
++        if (p != TraceItemView::Bottom) {
++          popup.insertItem(i18n("Move to Bottom"), 83);
++          popup2.insertItem(i18n("Bottom"), 93);
++        }
++        if (p != TraceItemView::Left) {
++          popup.insertItem(i18n("Move to Bottom Left"), 84);
++          popup2.insertItem(i18n("Bottom Left"), 94);
++        }
++        popup.insertItem(i18n("Move Area To"), &popup2, 2);
++        popup.insertSeparator();
++        popup.insertItem(i18n("Hide This Tab"), 80);
++        popup.insertItem(i18n("Hide Area"), 90);
++
++        if (_tabView->visibleTabs() <2) {
++          popup.setItemEnabled(80, false);
++          popup.setItemEnabled(90, false);
++        }
++        else if (_tabView->visibleAreas() <2)
++          popup.setItemEnabled(90, false);
++      }
++      popup3.insertItem(i18n("Top"), 101);
++      popup3.insertItem(i18n("Right"), 102);
++      popup3.insertItem(i18n("Bottom"), 103);
++      popup3.insertItem(i18n("Bottom Left"), 104);
++      popup.insertItem(i18n("Show Hidden On"), &popup3, 3);
++
++      int r = popup.exec( mapToGlobal( e->pos() ) );
++
++      TraceItemView::Position p = TraceItemView::Hidden;
++      if ((r % 10) == 1) p = TraceItemView::Top;
++      if ((r % 10) == 2) p = TraceItemView::Right;
++      if ((r % 10) == 3) p = TraceItemView::Bottom;
++      if ((r % 10) == 4) p = TraceItemView::Left;
++
++      if (r>=80 && r<100) _tabView->moveTab(page, p, r>=90);
++      if (r>=100 && r<110) _tabView->moveTab(0, p, true);
++  }
++
++  TQTabBar::mousePressEvent( e );
++}
++
++
++//
++// Splitter
++//
++
++Splitter::Splitter(Qt::Orientation o, TQWidget* parent, const char* name)
++  : TQSplitter(o, parent, name)
++{}
++
++void Splitter::moveEvent(TQMoveEvent* e)
++{
++  TQSplitter::moveEvent(e);
++
++  if (0) qDebug("Splitter %s: Move", name());
++  checkVisiblity();
++}
++
++void Splitter::checkVisiblity()
++{
++  const TQObjectList l = childrenListObject();
++  TQObjectListIt it( l );
++  TQObject *obj;
++  while ( (obj = it.current()) != 0 ) {
++    ++it;
++    if (obj->isA("Splitter")) ((Splitter*)obj)->checkVisiblity();
++    else if (obj->isA("TabWidget")) ((TabWidget*)obj)->checkVisibility();
++  }
++}
++
++
++
++
++//
++// TabWidget
++//
++
++TabWidget::TabWidget(TabView* v, TQWidget* parent,
++                     const char* name, WFlags f)
++    : TQTabWidget(parent, name, f)
++{
++    _hasVisibleRect = false;
++    setTabBar(new TabBar(v, this));
++}
++
++void TabWidget::checkVisibility()
++{
++  bool hasVisibleRect = (visibleRect().width()>1) &&
++                        (visibleRect().height()>1);
++
++  if (0) qDebug("TabWidget %s: VR (%dx%d) HasVisibleRect: %s => %s",
++                name(),
++                visibleRect().width(), visibleRect().height(),
++                _hasVisibleRect ? "Yes":"No",
++                hasVisibleRect ? "Yes":"No");
++
++  if (hasVisibleRect != _hasVisibleRect) {
++    _hasVisibleRect = hasVisibleRect;
++    emit visibleRectChanged(this);
++  }
++}
++
++void TabWidget::resizeEvent(TQResizeEvent *e)
++{
++  TQTabWidget::resizeEvent(e);
++  if (0) qDebug("TabWidget %s:\n  Resize from (%d/%d) to (%d/%d)",
++                name(),
++                e->oldSize().width(), e->oldSize().height(),
++                e->size().width(), e->size().height());
++  checkVisibility();
++}
++
++void TabWidget::showEvent(TQShowEvent* e)
++{
++  TQTabWidget::showEvent(e);
++
++  if (0) qDebug("TabWidget %s: Show", name());
++  checkVisibility();
++}
++
++void TabWidget::hideEvent(TQHideEvent* e)
++{
++  TQTabWidget::hideEvent(e);
++
++  if (0) qDebug("TabWidget %s: Hide", name());
++  checkVisibility();
++}
++
++void TabWidget::moveEvent(TQMoveEvent* e)
++{
++  TQTabWidget::moveEvent(e);
++
++  if (0) qDebug("TabWidget %s: Move", name());
++  checkVisibility();
++}
++
++
++
++//
++// TabView
++//
++
++/*
++ * Areas for child views
++ *
++ * leftSplitter
++ * |
++ * |    -----                 -----
++ * |  _/     \_______________/     \____
++ * |  | Top                 | TopRight |
++ * |  |                     |          |
++ * -> |---------------------|          |
++ *    | BottomLeft | Bottom |          |
++ *    |            |        |          |
++ *    -\_____/------\____/--------------
++ *
++ *                 ^        ^
++ *      bottomSplitter    mainSplitter
++ */
++
++TabView::TabView(TraceItemView* parentView,
++                 TQWidget* parent, const char* name)
++  : TQWidget(parent, name), TraceItemView(parentView)
++{
++    setFocusPolicy(TQ_StrongFocus);
++
++  _isCollapsed = true;
++
++  TQVBoxLayout* vbox = new TQVBoxLayout( this, 6, 6);
++
++  _nameLabel = new KSqueezedTextLabel( this, "nameLabel" );
++  _nameLabel->setText(i18n("(No profile data file loaded)"));
++  vbox->addWidget( _nameLabel );
++
++  _mainSplitter   = new TQSplitter(Qt::Horizontal, this);
++  _leftSplitter   = new Splitter(Qt::Vertical, _mainSplitter, "Left");
++  vbox->addWidget( _mainSplitter );
++
++  _rightTW = new TabWidget(this, _mainSplitter, "Right");
++  connect(_rightTW, TQT_SIGNAL(currentChanged(TQWidget*)),
++          this, TQT_SLOT(tabChanged(TQWidget*)));
++  connect(_rightTW, TQT_SIGNAL(visibleRectChanged(TabWidget*)),
++          this, TQT_SLOT(visibleRectChangedSlot(TabWidget*)));
++
++  _topTW = new TabWidget(this, _leftSplitter, "Top");
++  connect(_topTW, TQT_SIGNAL(currentChanged(TQWidget*)),
++          this, TQT_SLOT(tabChanged(TQWidget*)));
++  connect(_topTW, TQT_SIGNAL(visibleRectChanged(TabWidget*)),
++          this, TQT_SLOT(visibleRectChangedSlot(TabWidget*)));
++
++  _bottomSplitter = new Splitter(Qt::Horizontal,
++                                  _leftSplitter, "Bottom");
++
++  _leftTW = new TabWidget(this, _bottomSplitter, "Left");
++  _leftTW->setTabPosition(TQTabWidget::Bottom);
++  connect(_leftTW, TQT_SIGNAL(currentChanged(TQWidget*)),
++          this, TQT_SLOT(tabChanged(TQWidget*)));
++  connect(_leftTW, TQT_SIGNAL(visibleRectChanged(TabWidget*)),
++          this, TQT_SLOT(visibleRectChangedSlot(TabWidget*)));
++
++  _bottomTW = new TabWidget(this, _bottomSplitter, "Bottom");
++  _bottomTW->setTabPosition(TQTabWidget::Bottom);
++  connect(_bottomTW, TQT_SIGNAL(currentChanged(TQWidget*)),
++          this, TQT_SLOT(tabChanged(TQWidget*)));
++  connect(_bottomTW, TQT_SIGNAL(visibleRectChanged(TabWidget*)),
++          this, TQT_SLOT(visibleRectChangedSlot(TabWidget*)));
++
++
++  // default positions...
++
++  addTop( addTab( i18n("Types"),
++		  new CostTypeView(this, _topTW,
++				   "CostTypeView")));
++  addTop( addTab( i18n("Callers"),
++		  new CallView(true, this, _topTW,
++			       "CallerView")));
++  addTop( addTab( i18n("All Callers"),
++		  new CoverageView(true, this, _topTW,
++				   "AllCallerView")));
++  addTop( addTab( i18n("Caller Map"),
++		  new CallMapView(true, this, _bottomTW,
++				  "CallerMapView")));
++  addTop( addTab( i18n("Source"),
++		  new SourceView(this, _topTW,
++				 "SourceView")));
++
++  addBottom( addTab( i18n("Parts"),
++		     new PartView(this, _bottomTW,
++				  "PartView")));
++  addBottom( addTab( i18n("Call Graph"),
++		     new CallGraphView(this, _bottomTW,
++				       "CallGraphView")));
++  addBottom( addTab( i18n("Callees"),
++		     new CallView(false, this, _bottomTW,
++				  "CalleeView")));
++  addBottom( addTab( i18n("All Callees"),
++		     new CoverageView(false, this, _bottomTW,
++				      "AllCalleeView")));
++
++  addBottom( addTab( i18n("Callee Map"),
++		     new CallMapView(false, this, _topTW,
++				     "CalleeMapView")));
++  addBottom( addTab( i18n("Assembler"),
++		     new InstrView(this, _bottomTW,
++				   "InstrView")));
++
++  // after all child widgets are created...
++  _lastFocus = 0;
++  _active = false;
++  installFocusFilters();
++
++  updateVisibility();
++
++  TQWhatsThis::add( this, whatsThis() );
++}
++
++void TabView::setData(TraceData* d)
++{
++  TraceItemView::setData(d);
++
++  TraceItemView* v;
++  for (v=_tabs.first();v;v=_tabs.next())
++    v->setData(d);  
++}
++
++TraceItemView* TabView::addTab(TQString label, TraceItemView* view)
++{
++    view->setTitle(label);
++    _tabs.append(view);
++    return view;
++}
++
++void TabView::addTop(TraceItemView* view)
++{
++  view->setPosition(TraceItemView::Top);
++  _topTW->insertTab(view->widget(), view->title());
++}
++
++void TabView::addBottom(TraceItemView* view)
++{
++  view->setPosition(TraceItemView::Bottom);
++  _bottomTW->insertTab(view->widget(), view->title());
++}
++
++TraceItemView::Position TabView::tabPosition(TQWidget* w)
++{
++  TraceItemView* v;
++  for (v=_tabs.first();v;v=_tabs.next())
++    if (v->widget() == w) return v->position();
++
++  return Hidden;
++}
++
++int TabView::visibleTabs()
++{
++  int c = 0;
++  TraceItemView* v;
++  for (v=_tabs.first();v;v=_tabs.next()) {
++    if (v->position() == Hidden) continue;
++    c++;
++  }
++  return c;
++}
++
++
++int TabView::visibleAreas()
++{
++  int c = 0, t = 0, b = 0, r = 0, l = 0;
++  TraceItemView* v;
++  for (v=_tabs.first();v;v=_tabs.next()) {
++    switch(v->position()) {
++    case TraceItemView::Top:    t++; break;
++    case TraceItemView::Bottom: b++; break;
++    case TraceItemView::Left:   l++; break;
++    case TraceItemView::Right:  r++; break;
++    default: break;
++    }
++  }
++  if (t>0) c++;
++  if (b>0) c++;
++  if (l>0) c++;
++  if (r>0) c++;
++
++  return c;
++}
++
++
++
++// This hides/shows splitters and tabwidgets according to tab childs
++void TabView::updateVisibility()
++{
++  // calculate count of tabs in areas
++  int t = 0, b = 0, r = 0, l = 0;
++  TraceItemView* v;
++  for (v=_tabs.first();v;v=_tabs.next()) {
++    switch(v->position()) {
++    case TraceItemView::Top:    t++; break;
++    case TraceItemView::Bottom: b++; break;
++    case TraceItemView::Left:   l++; break;
++    case TraceItemView::Right:  r++; break;
++    default: break;
++    }
++  }
++
++  if (0) qDebug("TabView::updateVisiblity t %d, b %d, l %d, r %d",
++		t, b, l, r);
++
++  TQValueList<int> s;
++  s.append(100);
++
++
++  // children of mainSplitter
++  if (_rightTW->isHidden() != (r == 0)) {
++    if (r == 0) {
++      _rightTW->hide();
++
++      if (!_topTW->hasVisibleRect() &&
++          !_bottomTW->hasVisibleRect() &&
++          !_leftTW->hasVisibleRect())  _mainSplitter->setSizes(s);
++    }
++    else
++      _rightTW->show();
++  }
++  if (_leftSplitter->isHidden() != (t+b+l == 0)) {
++    if (t+b+l == 0) {
++      _leftSplitter->hide();
++
++      if (!_rightTW->hasVisibleRect()) _mainSplitter->setSizes(s);
++    }
++    else
++      _leftSplitter->show();
++  }
++
++  // children of leftSplitter
++  if (_topTW->isHidden() != (t == 0)) {
++    if (t == 0) {
++      _topTW->hide();
++
++      if (!_bottomTW->hasVisibleRect() &&
++          !_leftTW->hasVisibleRect()) _leftSplitter->setSizes(s);
++    }
++    else
++      _topTW->show();
++  }
++
++  if (_bottomSplitter->isHidden() != (b+l == 0)) {
++    if (b+l == 0) {
++      _bottomSplitter->hide();
++
++      if (!_topTW->hasVisibleRect()) _leftSplitter->setSizes(s);
++    }
++    else
++      _bottomSplitter->show();
++  }
++
++  // children of bottomSplitter
++  if (_bottomTW->isHidden() != (b == 0)) {
++    if (b == 0) {
++      _bottomTW->hide();
++
++      if (!_leftTW->hasVisibleRect()) _bottomSplitter->setSizes(s);
++    }
++    else
++      _bottomTW->show();
++  }
++  if (_leftTW->isHidden() != (l == 0)) {
++    if (l == 0) {
++      _leftTW->hide();
++
++      if (!_bottomTW->hasVisibleRect()) _bottomSplitter->setSizes(s);
++    }
++    else
++      _leftTW->show();
++  }
++}
++
++TabWidget* TabView::tabWidget(Position p)
++{
++  switch(p) {
++  case TraceItemView::Top:    return _topTW;
++  case TraceItemView::Bottom: return _bottomTW;
++  case TraceItemView::Left:   return _leftTW;
++  case TraceItemView::Right:  return _rightTW;
++  default: break;
++  }
++  return 0;
++}
++
++void TabView::moveTab(TQWidget* w, Position p, bool wholeArea)
++{
++    TraceItemView *v;
++    Position origPos = Hidden;
++    if (w) {
++      for (v=_tabs.first();v;v=_tabs.next())
++        if (v->widget() == w) break;
++
++      if (!v) return;
++      origPos = v->position();
++    }
++    if (origPos == p) return;
++
++    TabWidget *from, *to;
++    from = tabWidget(origPos);
++    to = tabWidget(p);
++
++    TQPtrList<TraceItemView> tabs;
++    for (v=_tabs.first();v;v=_tabs.next())
++      if ((v->position() == origPos) &&
++          (wholeArea || (v->widget() == w))) tabs.append(v);
++
++    bool isEnabled;
++    for (v=tabs.first();v;v=tabs.next()) {
++      v->setPosition(p);
++      w = v->widget();
++
++      if (from) {
++        isEnabled = from->isTabEnabled(w);
++        from->removePage(w);
++      }
++      else isEnabled = (v->canShow(_activeItem)!=0);
++
++      if (to) {
++        TraceItemView *vv;
++        int idx = -1, i;
++        for(vv = _tabs.first(); vv && (vv!=v); vv = _tabs.next()) {
++          i = to->indexOf(vv->widget());
++          if (i>=0) idx = i;
++        }
++        to->insertTab(w, v->title(), idx+1);
++        to->setTabEnabled(w, isEnabled);
++        if (isEnabled) {
++          to->showPage(w);
++          v->updateView();
++        }
++      }
++    }
++    updateVisibility();
++}
++
++
++TQString TabView::whatsThis() const
++{
++    return i18n( "<b>Information Tabs</b>"
++		 "<p>This widget shows information for the "
++		 "current selected function in different tabs: "
++		 "<ul>"
++		 "<li>The Costs tab shows a list of available event types "
++		 "and the inclusive and self costs regarding to these types.</li>"
++		 "<li>The Parts tab shows a list of trace parts "
++		 "if the trace consists of more than one part (otherwise, "
++		 "this tab is hided). "
++		 "The cost of the selected function spent in the different "
++		 "parts together with the calls happening is shown.</li>"
++		 "<li>The Call Lists tab shows direct callers and "
++		 "callees of the function in more detail.</li>"
++		 "<li>The Coverage tab shows the same is the Call "
++		 "Lists tab, but not only direct callers and callees "
++		 "but also indirect ones.</li>"
++		 "<li>The Call Graph tab shows a graphical "
++		 "visualization of the calls done by this function.</li>"
++		 "<li>The Source tab presents annotated source code "
++		 "if debugging information and the source file "
++		 "is available.</li>"
++		 "<li>The Assembler tab presents annotated assembler code "
++		 "if trace information on instruction level "
++		 "is available.</li></ul>"
++		 "For more information, see the <em>What's This?</em> "
++		 "help of the corresponding tab widget</p>");
++}
++
++void TabView::installFocusFilters()
++{
++    TQObjectList *l = queryList(TQWIDGET_OBJECT_NAME_STRING);
++    TQObjectListIt it( *l );
++    TQObject *obj;
++
++    while ( (obj = it.current()) != 0 ) {
++        ++it;
++	if ( ((TQWidget*)obj)->isFocusEnabled() )
++	    obj->installEventFilter(this);
++    }
++    delete l;
++}
++
++
++bool TabView::eventFilter(TQObject* o, TQEvent* e)
++{
++    if (e->type() == TQEvent::FocusIn) {
++	_lastFocus = o->isWidgetType() ? (TQWidget*) o : 0;
++	setActive(_lastFocus != 0);
++    }
++    return TQWidget::eventFilter(o,e);
++}
++
++void TabView::mousePressEvent(TQMouseEvent*)
++{
++    if (_lastFocus)
++	_lastFocus->setFocus();
++    setActive(true);
++}
++
++void TabView::setActive(bool a)
++{
++    if (a == _active) return;
++    _active = a;
++
++    TQFont nameLabel_font(  _nameLabel->font() );
++    nameLabel_font.setBold(a);
++    _nameLabel->setFont( nameLabel_font );
++
++    if (0) qDebug("%s::setActive(%s)", name(), a ? "true":"false");
++
++    if (a) emit activated(this);
++}
++
++void TabView::doUpdate(int changeType)
++{
++    if (changeType & (activeItemChanged | configChanged | dataChanged))
++
++	_nameLabel->setText( !_data ? i18n("(No Data loaded)") :
++			     !_activeItem ? i18n("(No function selected)") :
++			     _activeItem->prettyName());
++
++
++    // we use our own list iterators because setTabEnabled can
++    // invoke tabChanged, which mangles with the lists, too
++    bool canShow;
++    TraceItemView *v;
++    TQPtrListIterator<TraceItemView> it( _tabs );
++    while ( (v=it.current()) != 0) {
++      ++it;
++
++      TabWidget *tw = 0;
++      switch(v->position()) {
++      case TraceItemView::Top:    tw = _topTW; break;
++      case TraceItemView::Bottom: tw = _bottomTW; break;
++      case TraceItemView::Left:   tw = _leftTW; break;
++      case TraceItemView::Right:  tw = _rightTW; break;
++      default: break;
++      }
++
++      // update even if hidden
++      if (tw) {
++        if (!tw->hasVisibleRect()) continue;
++      }
++      canShow = v->set(changeType, _data, _costType, _costType2,
++		       _groupType, _partList,
++                       _activeItem, _selectedItem);
++      v->notifyChange(changeType);
++
++      if (!tw) continue;
++      if (tw->isTabEnabled(v->widget()) != canShow)
++        tw->setTabEnabled(v->widget(), canShow);
++
++      if (v->widget() == tw->currentPage())
++        v->updateView();
++    }
++}
++
++
++void TabView::tabChanged(TQWidget* w)
++{
++  TraceItemView *v;
++  for (v=_tabs.first();v;v=_tabs.next())
++    if (v->widget() == w) v->updateView();
++}
++
++void TabView::visibleRectChangedSlot(TabWidget* tw)
++{
++  if (0) qDebug("%s: %svisible !",
++                tw->name(), tw->hasVisibleRect() ? "":"un");
++
++  if (tw->hasVisibleRect()) doUpdate(0);
++}
++
++void TabView::resizeEvent(TQResizeEvent* e)
++{
++  TQWidget::resizeEvent(e);
++
++  bool collapsed = (e->size().width()<=1) || (e->size().height()<=1);
++  if (_isCollapsed != collapsed) {
++    _isCollapsed = collapsed;
++    updateView();
++  }
++
++  if (0) qDebug("TabView::Resize from (%d/%d) to (%d/%d)",
++         e->oldSize().width(), e->oldSize().height(),
++         e->size().width(), e->size().height());
++}
++
++void TabView::selected(TraceItemView*, TraceItem* s)
++{
++    // we set selected item for our own children
++    select(s);
++    updateView();
++
++    // still forward to parent
++    if (_parentView) _parentView->selected(this, s);
++}
++
++
++void TabView::readViewConfig(KConfig* c,
++			     TQString prefix, TQString postfix,
++			     bool withOptions)
++{
++    if (0) qDebug("%s::readConfig(%s%s)", name(),
++		  prefix.ascii(), postfix.ascii());
++
++    KConfigGroup* g = configGroup(c, prefix, postfix);
++
++    _mainSplitter->setSizes(g->readIntListEntry("MainSizes"));
++    _leftSplitter->setSizes(g->readIntListEntry("LeftSizes"));
++    _bottomSplitter->setSizes(g->readIntListEntry("BottomSizes"));
++
++    TQString activeT = g->readEntry("ActiveTop", "CallerView");
++    TQString activeB = g->readEntry("ActiveBottom", "CalleeView");
++    TQString activeL = g->readEntry("ActiveLeft", "");
++    TQString activeR = g->readEntry("ActiveRight", "");
++
++    TQStringList topTabs    = g->readListEntry("TopTabs");
++    TQStringList bottomTabs = g->readListEntry("BottomTabs");
++    TQStringList leftTabs   = g->readListEntry("LeftTabs");
++    TQStringList rightTabs  = g->readListEntry("RightTabs");
++
++    if (topTabs.isEmpty() && bottomTabs.isEmpty() &&
++        rightTabs.isEmpty() && leftTabs.isEmpty()) {
++      // no tabs visible ?! Reset to default
++      topTabs << "CostTypeView" << "CallerView" << "AllCallerView"
++              << "CalleeMapView" << "SourceView";
++      bottomTabs << "PartView" << "CalleeView" << "CallGraphView"
++                 << "AllCalleeView" << "CallerMapView" << "InstrView";
++    }
++
++    TraceItemView *activeTop = 0, *activeBottom = 0;
++    TraceItemView *activeLeft = 0, *activeRight = 0;
++
++    moveTab(0, TraceItemView::Top, true);
++    TraceItemView *v;
++    TQPtrListIterator<TraceItemView> it( _tabs );
++    while ( (v=it.current()) != 0) {
++      ++it;
++
++      TQString n = TQString(v->widget()->name());
++      if (topTabs.contains(n)) {
++        moveTab(v->widget(), TraceItemView::Top);
++        if (n == activeT) activeTop = v;
++      }
++      else if (bottomTabs.contains(n)) {
++        moveTab(v->widget(), TraceItemView::Bottom);
++        if (n == activeB) activeBottom = v;
++      }
++      else if (leftTabs.contains(n)) {
++        moveTab(v->widget(), TraceItemView::Left);
++        if (n == activeL) activeLeft = v;
++      }
++      else if (rightTabs.contains(n)) {
++        moveTab(v->widget(), TraceItemView::Right);
++        if (n == activeR) activeRight = v;
++      }
++      else moveTab(v->widget(), Hidden);
++
++      if (withOptions)
++	v->readViewConfig(c, TQString("%1-%2")
++			  .arg(prefix).arg(v->widget()->name()),
++			  postfix, true);
++    }
++    if (activeTop)   _topTW->showPage(activeTop->widget());
++    if (activeBottom)_bottomTW->showPage(activeBottom->widget());
++    if (activeLeft)  _leftTW->showPage(activeLeft->widget());
++    if (activeRight) _rightTW->showPage(activeRight->widget());
++
++    TQString activeType = g->readEntry("ActiveItemType", "");
++    TQString activeName = g->readEntry("ActiveItemName", "");
++    TQString selectedType = g->readEntry("SelectedItemType", "");
++    TQString selectedName = g->readEntry("SelectedItemName", "");
++    delete g;
++    
++    if (!_data) return;
++    
++    if (withOptions) {  
++      // restore active item
++      TraceItem::CostType t = TraceItem::costType(activeType);
++      if (t==TraceItem::NoCostType) t = TraceItem::Function;
++      TraceCost* activeItem = _data->search(t, activeName, _costType);
++      if (!activeItem) return;
++      activate(activeItem);
++      
++      // restore selected item
++      t = TraceItem::costType(selectedType);
++      if (t==TraceItem::NoCostType) t = TraceItem::Function;
++      TraceCost* selectedItem = _data->search(t, selectedName,
++					      _costType, activeItem);
++      if (selectedItem) select(selectedItem);
++    }
++
++    updateView();
++}
++
++void TabView::saveViewConfig(KConfig* c,
++			     TQString prefix, TQString postfix,
++			     bool withOptions)
++{
++    KConfigGroup g(c, (prefix+postfix).ascii());
++
++    g.writeEntry("MainSizes", _mainSplitter->sizes());
++    g.writeEntry("LeftSizes", _leftSplitter->sizes());
++    g.writeEntry("BottomSizes", _bottomSplitter->sizes());
++
++    TQString a;
++    if ((_topTW->count()>0) &&
++        (_topTW->isTabEnabled(_topTW->currentPage())))
++      a = TQString(_topTW->currentPage()->name());
++    g.writeEntry("ActiveTop", a);
++
++    a.setLength(0);
++    if ((_bottomTW->count()>0) &&
++        (_bottomTW->isTabEnabled(_bottomTW->currentPage())))
++      a = TQString(_bottomTW->currentPage()->name());
++    g.writeEntry("ActiveBottom", a);
++
++    a.setLength(0);
++    if ((_leftTW->count()>0) &&
++        (_leftTW->isTabEnabled(_leftTW->currentPage())))
++      a = TQString(_leftTW->currentPage()->name());
++    g.writeEntry("ActiveLeft", a);
++
++    a.setLength(0);
++    if ((_rightTW->count()>0) &&
++        (_rightTW->isTabEnabled(_rightTW->currentPage())))
++      a = TQString(_rightTW->currentPage()->name());
++    g.writeEntry("ActiveRight", a);
++
++    if (withOptions)
++      if (_activeItem) {
++	g.writeEntry("ActiveItemType",
++                     TraceItem::typeName(_activeItem->type()));
++	g.writeEntry("ActiveItemName", _activeItem->name());
++	if (_selectedItem) {
++	  g.writeEntry("SelectedItemType",
++		       TraceItem::typeName(_selectedItem->type()));
++	  g.writeEntry("SelectedItemName", _selectedItem->name());
++	}
++      }
++
++    TQStringList topList, bottomList, leftList, rightList;
++    TraceItemView *v;
++    for (v=_tabs.first();v;v=_tabs.next()) {
++      switch(v->position()) {
++      case TraceItemView::Top:
++        topList << TQString(v->widget()->name());
++        break;
++
++      case TraceItemView::Bottom:
++        bottomList << TQString(v->widget()->name());
++        break;
++
++      case TraceItemView::Left:
++        leftList << TQString(v->widget()->name());
++        break;
++
++      case TraceItemView::Right:
++        rightList << TQString(v->widget()->name());
++        break;
++
++      default: break;
++      }
++    }
++
++    g.writeEntry("TopTabs", topList);
++    g.writeEntry("BottomTabs", bottomList);
++    g.writeEntry("LeftTabs", leftList);
++    g.writeEntry("RightTabs", rightList);
++
++    if (withOptions)
++      for (v=_tabs.first();v;v=_tabs.next())
++	v->saveViewConfig(c, TQString("%1-%2").arg(prefix)
++			  .arg(v->widget()->name()), postfix, true);
++}
++
++#include "tabview.moc"
+diff --git a/kdecachegrind/kdecachegrind/tabview.h b/kdecachegrind/kdecachegrind/tabview.h
+new file mode 100644
+index 0000000..b9b4026
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/tabview.h
+@@ -0,0 +1,174 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Tab View, enclosing detailed views for one trace item in
++ * two tab widgets, separated by a splitter
++ */
++
++#ifndef TABVIEW_H
++#define TABVIEW_H
++
++#include <tqptrlist.h>
++#include <tqwidget.h>
++#include <tqtabwidget.h>
++#include <tqtabbar.h>
++#include <ksqueezedtextlabel.h>
++#include "traceitemview.h"
++
++class TQSplitter;
++class TabView;
++
++/**
++ * Subclass of TQTabBar to enable context menu on tabs
++ */
++class TabBar : public TQTabBar
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++ public:
++  TabBar(TabView*, TQTabWidget* parent, const char *name = 0);
++ protected:
++  void mousePressEvent(TQMouseEvent *e);
++
++ private:
++  TQTabWidget* _tabWidget;
++  TabView* _tabView;
++};
++
++
++/**
++ * Own Splitter:
++ * Call checkVisiblity for all TabWidget children of the splitter
++ * on a MoveEvent. This typically is produced when collapsing the widget
++ * inside of another splitter.
++ */
++class Splitter: public TQSplitter
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  Splitter(Qt::Orientation o, TQWidget* parent = 0, const char* name = 0);
++  void checkVisiblity();
++
++protected:
++  void moveEvent(TQMoveEvent *);
++};
++
++
++/**
++ * Own TabView:
++ * - A TQTabWidget able to track its visible rect via resizeEvents.
++ *   This is needed to track if this widget is collapsed in a TQSplitter.
++ * - Use own TabBar for context menu
++ */
++class TabWidget: public TQTabWidget
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++
++  TabWidget(TabView*, TQWidget* parent = 0,
++            const char* name = 0, WFlags f = 0);
++
++  bool hasVisibleRect() { return _hasVisibleRect; }
++  void checkVisibility();
++
++signals:
++  void visibleRectChanged(TabWidget*);
++
++protected:
++  void resizeEvent(TQResizeEvent *);
++  void showEvent(TQShowEvent *);
++  void hideEvent(TQHideEvent *);
++  void moveEvent(TQMoveEvent *);
++
++private:
++  bool _hasVisibleRect;
++};
++
++
++
++class TabView : public TQWidget, public TraceItemView
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++
++  TabView(TraceItemView* parentView,
++          TQWidget* parent = 0, const char* name = 0);
++
++  virtual TQWidget* widget() { return this; }
++  TQString whatsThis() const ;
++  void setData(TraceData*);
++  bool isViewVisible() const { return !_isCollapsed; }
++  void selected(TraceItemView*, TraceItem*);
++  bool active() const { return _active; }
++  void setActive(bool);
++
++  /**
++   * Rearrange tabs
++   * if <w> == 0, move hidden tabs
++   */
++  void moveTab(TQWidget* w, Position, bool wholeArea = false);
++
++  Position tabPosition(TQWidget*);
++  int visibleTabs();
++  int visibleAreas();
++
++  void readViewConfig(KConfig*, TQString prefix, TQString postfix, bool);
++  void saveViewConfig(KConfig*, TQString prefix, TQString postfix, bool);
++
++public slots:
++  void tabChanged(TQWidget*);
++  void visibleRectChangedSlot(TabWidget*);
++
++signals:
++  void activated(TabView*);
++
++protected:
++  void resizeEvent(TQResizeEvent *);
++  bool eventFilter(TQObject*, TQEvent*);
++  void mousePressEvent(TQMouseEvent*);
++
++private:
++  TraceItemView* addTab(TQString, TraceItemView*);
++  void addTop(TraceItemView*);
++  void addBottom(TraceItemView*);
++  TabWidget* tabWidget(Position);
++  void updateVisibility();
++  void doUpdate(int);
++  void installFocusFilters();
++
++  // this is true if width or height <= 1, and no child updates are done
++  bool _isCollapsed;
++
++  KSqueezedTextLabel* _nameLabel;
++  TQSplitter *_mainSplitter, *_leftSplitter, *_bottomSplitter;
++  TabWidget *_topTW, *_leftTW, *_bottomTW, *_rightTW;
++  TQPtrList<TraceItemView> _tabs;
++
++  TQWidget* _lastFocus;
++  bool _active;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/kdecachegrind.desktop b/kdecachegrind/kdecachegrind/kdecachegrind.desktop
+new file mode 100644
+index 0000000..7089370
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/kdecachegrind.desktop
+@@ -0,0 +1,103 @@
++# KDE Config File
++[Desktop Entry]
++Type=Application
++Exec=kdecachegrind -caption "%c" %i %m %u
++MimeType=application/x-kcachegrind;
++Icon=kdecachegrind
++DocPath=kdecachegrind/index.html
++Terminal=false
++Name=KCachegrind
++Name[hi]=के-केश-ग्रिंड
++Name[sv]=Kcachegrind
++Name[ta]=  இடைமாற்றகட்டம்
++GenericName=Profiler Frontend
++GenericName[bs]=Profiler frontend
++GenericName[ca]=Interfície de Profiler
++GenericName[cs]=Rozhraní pro profilaci
++GenericName[cy]=Blaen-wyneb Proffilydd
++GenericName[da]=Grænseflade til profilering
++GenericName[de]=Profiler Oberfläche
++GenericName[el]=Πρόγραμμα προφίλ
++GenericName[eo]=Fasado de Profililo
++GenericName[es]=Interfaz para Profiler
++GenericName[et]=Profileerimisrakendus
++GenericName[eu]=Profilatzailearen interfazea
++GenericName[fa]=پایانۀ گزارش‌گیر
++GenericName[fi]=Profiloijan käyttöliittymä
++GenericName[fr]=Interface de profilage
++GenericName[ga]=Comhéadan ar Phróifíleoir
++GenericName[gl]=Interface para o profiler
++GenericName[hi]=प्रोफ़ाइलर फ्रन्टएण्ड
++GenericName[hu]=Profilozó
++GenericName[is]=Myndrænt viðmót á afkastakönnuð
++GenericName[it]=Interfaccia a profiler
++GenericName[ja]=プロファイラフロントエンド
++GenericName[ka]=პროფილერის Frontend
++GenericName[kk]=Профильдеткіштің интерфейсі
++GenericName[lt]=Profiliuoklio naudotojo sąsaja
++GenericName[nb]=Grensesnitt for profilvisning
++GenericName[nds]=Profiler-Böversiet
++GenericName[ne]=प्रोफाइलर फ्रन्टइन्ड
++GenericName[nl]=Profiler-hulpprogramma
++GenericName[nn]=Grensesnitt for profilvising
++GenericName[pa]=ਪਰੋਫਾਇਲਰ ਮੁੱਖ ਭੂਮੀ
++GenericName[pl]=Interfejs do profilera
++GenericName[pt]=Interface de Profiler
++GenericName[pt_BR]=Interface para o Profiler
++GenericName[ru]=Профилировщик
++GenericName[sk]=Rozhranie pre profiler
++GenericName[sl]=Vmesnik profilnika
++GenericName[sr]=Графички интерфејс за профајлер
++GenericName[sr@Latn]=Grafički interfejs za profajler
++GenericName[sv]=Profileringsgränssnitt
++GenericName[ta]= விவரக்குறிப்பு முன்பகுதி
++GenericName[tg]=Интерфейс ба профилкунанда
++GenericName[tr]=Profil Önyüzü
++GenericName[uk]=Інтерфейс до Profiler
++GenericName[zh_CN]=个性数据前端
++GenericName[zh_TW]=分析器前端
++Comment=Visualization of Performance Profiling Data
++Comment[bg]=Визуализация на данните за производителност
++Comment[bs]=Vizualizacija podataka za profiliranje performansi
++Comment[ca]=Visualizació de dades de perfilat de rendiment
++Comment[cs]=Vizualizace profilovacích dat výkonu
++Comment[da]=Visualisering af profileringsdata
++Comment[de]=Visualisierung von Daten des Laufzeitverhaltens eines Programmes
++Comment[el]=Αναπαράσταση δεδομένων ταχύτητας προφίλ
++Comment[en_GB]=Visualisation of Performance Profiling Data
++Comment[es]=Visualización de datos de análisis de rendimiento
++Comment[et]=Jõudluse profileerimise andmete visualiseerimise vahend
++Comment[eu]=Errendimendu profil datuen bistaratzea
++Comment[fa]=تجسم کارایی گزارش داده‌ها
++Comment[fi]=Visualisointi tehokkuusprofiloinnin tiedoista
++Comment[fr]=Visualisation des données de performance de profilage
++Comment[gl]=Visualización dos datos da análise de rendimento
++Comment[hi]=परफार्मेस प्रोफाइलिंग डाटा का विजुअलाइज़ेशन
++Comment[hu]=Teljesítményprofil-adatok megjelenítése
++Comment[is]=Sjónræn framsetning gagna úr afkastakönnun
++Comment[it]=Visualizzazione dei dati di profiling delle prestazioni
++Comment[ja]=パフォーマンスプロファイルデータを視覚化
++Comment[ka]=წარმადობის მაპროფფილებელი მონაცემების ვიზუალიზაცია
++Comment[kk]=Деректерді профильдеудің визуализациясы
++Comment[lt]=Veikimo profiliavimo duomenų vizualizacija
++Comment[nb]=Vis informasjon om ytelse.
++Comment[nds]=Visualiseren vun Programmleisten-Looptietdaten
++Comment[ne]=सम्पादन प्रोफाइलिङ डाटाको दृष्टिकरण
++Comment[nl]=Visualisatie van Performance Profiling Data
++Comment[nn]=Vis informasjon om yting
++Comment[pl]=Wizualizacja danych profilowania wydajności
++Comment[pt]=Visualização dos Dados de Análise de Performance
++Comment[pt_BR]=Visualização de Dados de Perfil de Desempenho
++Comment[ru]=Утилита для визуального профилирования приложений
++Comment[sk]=Vizualizácia dát o výkone
++Comment[sl]=Vizualizacija podatkov profilnih zmogljivosti
++Comment[sr]=Визуелизација података о профилисању перформанси
++Comment[sr@Latn]=Vizuelizacija podataka o profilisanju performansi
++Comment[sv]=Åskådliggörande av profileringsdata för prestanda
++Comment[ta]= விவர தகவலை செயல்பாட்டு காட்சியாளிப்பு
++Comment[tg]=Утилита барои гузориши профили визуалӣ
++Comment[uk]=Візуалізація даних профілювання швидкодії
++Comment[zh_CN]=性能个性数据的可视化表现
++Comment[zh_TW]=效能分析資料視覺化
++X-DCOP-ServiceType=Multi
++Categories=Qt;KDE;Development;
+diff --git a/kdecachegrind/kdecachegrind/kdecachegrindui.rc b/kdecachegrind/kdecachegrind/kdecachegrindui.rc
+new file mode 100644
+index 0000000..9531829
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/kdecachegrindui.rc
+@@ -0,0 +1,57 @@
++<!DOCTYPE kpartgui>
++<kpartgui name="kdecachegrind" version="4">
++ <MenuBar>
++  <Menu name="file"><text>&amp;File</text>
++   <Action name="file_add" append="open_merge"/>
++   <Action name="reload" append="revert_merge"/>
++   <Action name="dump" append="revert_merge"/>
++   <Action name="export"/>
++  </Menu>
++  <Menu name="view"><text>&amp;View</text>
++   <Action name="view_cost_type"/>
++   <Action name="view_cost_type2"/>
++   <Action name="view_group_type"/>
++   <Separator/>
++   <Menu name="layouts"><text>&amp;Layout</text>
++     <Action name="layout_next"/>
++     <Action name="layout_previous"/>
++     <Action name="layout_duplicate"/>
++     <Action name="layout_remove"/>
++     <Separator/>
++     <Action name="layout_restore"/>
++     <Action name="layout_save"/>
++   </Menu>
++   <Action name="view_split"/>
++   <Action name="view_split_dir"/>
++   <Separator/>
++   <Action name="view_percentage"/>
++   <Action name="view_expanded"/>
++   <Action name="view_cycles"/>
++  </Menu>
++  <Menu name="settings">
++   <Menu append="show_toolbar_merge"><text>Sidebars</text>
++    <Action name="settings_show_dumpdock"/>
++    <Action name="settings_show_partdock"/>
++    <Action name="settings_show_stackdock"/>
++    <Action name="settings_show_profiledock"/>
++   </Menu>
++  </Menu>
++ </MenuBar>
++
++ <ToolBar name="mainToolBar" noMerge="1"><text>Main Toolbar</text>
++  <Action name="file_open"/>
++  <Action name="reload"/>
++  <Action name="dump"/> 
++  <Separator/>
++  <Action name="go_up"/>
++  <Action name="go_back"/>
++  <Action name="go_forward"/>
++  <Separator/>
++  <Action name="view_percentage"/>
++  <Action name="view_expanded"/>
++  <Action name="view_cycles"/>
++ </ToolBar>
++ <ToolBar name="stateToolBar" noMerge="1"><text>State Toolbar</text> 
++  <Action name="view_cost_type"/>
++ </ToolBar>
++</kpartgui>
+diff --git a/kdecachegrind/kdecachegrind/tips b/kdecachegrind/kdecachegrind/tips
+new file mode 100644
+index 0000000..1f555c0
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/tips
+@@ -0,0 +1,141 @@
++<tip category="KCachegrind|Help">
++<html>
++<p>...that the <em>What's This?</em> help for every GUI widget
++in KCachegrind contains detailed usage information for this widget?
++It is highly recommended to read at least these help texts on first
++use. Request <em>What's This?</em> help by pressing
++Shift+F1 and clicking on the widget.</p>
++</html>
++</tip>
++
++<tip category="KCachegrind|Explanation">
++<html>
++<p>...that you can get profile information at instruction level
++with Calltree when you provide the option <em>--dump-instr=yes</em>?
++Use the Assembler View for the instruction annotations.
++</p>
++</html>
++</tip>
++
++<tip category="KCachegrind|Keyboard">
++<html>
++<p>...that you can use Alt-Left/Right keys of your keyboard to go
++back/forward in the active object history ?</p>
++</html>
++</tip>
++
++<tip category="KCachegrind|Keyboard">
++<html>
++<p>...that you can navigate in the Callee/Caller Map View using
++arrow keys? Use Left/Right to change to siblings of the current
++item; use Up/Down to go one nesting level up/down. To select
++the current item, press Space, and to activate it, press Return.
++</p>
++</html>
++</tip>
++
++<tip category="KCachegrind|Keyboard">
++<html>
++<p>...that you can navigate in the Call Graph View using
++arrow keys? Use Up/Down to go one calling level up/down, alternating
++between calls and functions. Use Left/Right to change to siblings of a current
++selected call. To activate the current item, press Return.
++</p>
++</html>
++</tip>
++
++<tip category="KCachegrind|Filters">
++<html>
++<p>...that you can rapidly locate a function by entering part of its
++name (case-insensitive) into the edit line of the toolbar
++and hit return?</p>
++</html>
++</tip>
++
++<tip category="KCachegrind|Appearance">
++<html>
++<p>...that you can assign custom colors to 
++ELF objects/C++ Classes/Source Files for graph coloring
++in <em>Settings->Configure KCachegrind...</em>?</p>
++</html>
++</tip>
++
++<tip category="KCachegrind|Configuration">
++<html>
++<p>...that you can see if debug info is available for a selected 
++function by looking at the location label in the Info tab or
++the source listing header in the source tab?</p>
++<p>There must be the name of the source file (with extension).
++If KCachegrind still doesn't show the source, make sure that you
++have added the directory of the source file to the
++<em>Source Directories</em> list in the configuration.
++</html>
++</tip>
++
++<tip category="KCachegrind|Appearance">
++<html>
++<p>...that you can configure whether KCachgrind should
++show absolute event counts or relative ones (percentage display)?</p>
++</html>
++</tip>
++
++<tip category="KCachegrind|Appearance">
++<html>
++<p>...that you can configure the maximum number of items
++for all function lists in KCachegrind? Limiting the number
++of items is done to get a fast reacting GUI. The last item in
++the list will show you the number of skipped functions, together
++with a cost condition for these skipped functions.</p>
++<p>To activate a function with small costs, search for it and select
++it in the flat profile. Selecting functions with small cost will
++temporarily add them to the flat profile list.</p>
++</html>
++</tip>
++
++<tip category="KCachegrind|Explanation">
++<html>
++<p>...that the Coverage tab - in contrast to the Call Lists tab -
++shows <em>all</em> functions that are calling the selected function
++(upper part) / are called by the selected function (bottom part),
++no matter how many function are between them on the stack?</p>
++<p>Examples:</p>
++<p>An entry in the upper list for function foo1() with a value of 50%
++with function bar() selected means that 50% of all the cost of function
++bar() happened while called from function foo1().</p>
++<p>An entry in the bottom list for function foo2() with a value of 50%
++with function bar() selected means that 50% of all the cost of function
++bar() happened while calling foo2() from bar().</p>
++</html>
++</tip>
++
++<tip category="KCachegrind|Explanation">
++<html>
++<p>...that waiting for the tool tip inside of a tree map
++shows the list of names of the nested rectangles the mouse
++pointer is over?</p>
++<p>Items from this list can be selected by pressing the right
++mouse button.</p>
++</html>
++</tip>
++
++<tip category="KCachegrind|Explanation">
++<html>
++<p>...that you can constrain the cost counts shown to only a
++few parts of the whole trace by selecting these parts in the
++"Trace Selection" Dockable?</p>
++<p>To generate multiple parts in a profiling run with
++cachegrind, use e.g. option --cachedumps=xxx for parts
++of a length of xxx basic blocks (A basic block is a run
++of not-branching assembler statements inside of your program
++code).</p>
++</html>
++</tip>
++
++<tip category="KCachegrind|Explanation">
++<p>...that by splitting the view to show information of 
++two functions simultaniously, selecting a function in
++one panel shows the information for that function
++in the other panel?</p>
++</html>
++</tip>
++
+diff --git a/kdecachegrind/kdecachegrind/toplevel.cpp b/kdecachegrind/kdecachegrind/toplevel.cpp
+new file mode 100644
+index 0000000..5a2e1de
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/toplevel.cpp
+@@ -0,0 +1,2389 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * KCachegrind top level window
++ */
++
++#define TRACE_UPDATES 0
++#define ENABLE_DUMPDOCK 0
++
++#include <stdlib.h> // for system()
++
++#include <tqvbox.h>
++#include <tqtimer.h>
++#include <tqwhatsthis.h>
++#include <tqlineedit.h>
++#include <tqtextstream.h>
++#include <tqsizepolicy.h>
++#include <tqprogressbar.h>
++#include <tqfile.h>
++#include <tqeventloop.h>
++
++#include <kapplication.h>
++#include <klocale.h>
++#include <kstatusbar.h>
++#include <kstdaccel.h>
++#include <kstdaction.h>
++#include <kaction.h>
++#include <kurl.h>
++#include <kfiledialog.h>
++#include <kio/netaccess.h>
++#include <kedittoolbar.h>
++#include <kkeydialog.h>
++#include <ktip.h>
++#include <kpopupmenu.h>
++#include <kdebug.h>
++
++#if ENABLE_DUMPDOCK
++#include "dumpselection.h"
++#endif
++
++#include "toplevel.h"
++#include "partselection.h"
++#include "functionselection.h"
++#include "stackselection.h"
++#include "stackbrowser.h"
++#include "tracedata.h"
++#include "configuration.h"
++#include "configdlg.h"
++#include "multiview.h"
++#include "callgraphview.h"
++
++
++TopLevel::TopLevel(const char *name)
++  : KMainWindow(0, name), DCOPObject("KCachegrindIface")
++{
++  init();
++
++  createDocks();
++
++  _multiView = new MultiView(this, this, "MultiView");
++  setCentralWidget(_multiView);
++
++  createActions();
++
++  _partDockShown->setChecked(!_partDock->isHidden());
++  _stackDockShown->setChecked(!_stackDock->isHidden());
++  _functionDockShown->setChecked(!_functionDock->isHidden());
++
++  connect(_partDock, TQT_SIGNAL(visibilityChanged(bool)),
++          TQT_TQOBJECT(this), TQT_SLOT(partVisibilityChanged(bool)));
++  connect(_stackDock, TQT_SIGNAL(visibilityChanged(bool)),
++          TQT_TQOBJECT(this), TQT_SLOT(stackVisibilityChanged(bool)));
++  connect(_functionDock, TQT_SIGNAL(visibilityChanged(bool)),
++          TQT_TQOBJECT(this), TQT_SLOT(functionVisibilityChanged(bool)));
++
++#if ENABLE_DUMPDOCK
++  _dumpDockShown->setChecked(!_dumpDock->isHidden());
++  connect(_dumpDock, TQT_SIGNAL(visibilityChanged(bool)),
++          TQT_TQOBJECT(this), TQT_SLOT(dumpVisibilityChanged(bool)));
++#endif
++
++  _statusbar = statusBar();
++  _statusLabel = new TQLabel(_statusbar);
++#if 0
++  // how to do avoid main window resizing on large statusbar label?
++  TQSizePolicy p(TQSizePolicy::Fixed, TQSizePolicy::Expanding);
++  _statusLabel->setSizePolicy(p);
++  _statusbar->setSizePolicy(p);
++#endif
++  _statusbar->addWidget(_statusLabel, 1);
++
++  KConfig* kconfig = KGlobal::config();
++  Configuration::readOptions( kconfig );
++  _openRecent->loadEntries( kconfig );
++
++  // set toggle after reading configuration
++  _showPercentage = Configuration::showPercentage();
++  _showExpanded   = Configuration::showExpanded();
++  _showCycles     = Configuration::showCycles();
++  _taPercentage->setChecked(_showPercentage);
++  _taExpanded->setChecked(_showExpanded);
++  _taCycles->setChecked(_showCycles);
++
++  setupPartSelection(_partSelection);
++
++  // KCachegrind for KDE 3.0.x does not allow to hide toolbars...
++#if KDE_VERSION >= 308 // KDE 3.1
++  setStandardToolBarMenuEnabled(true);
++#endif
++
++  // QT dock windows are created before (using QT position restoring)
++  createGUI();
++
++  setAutoSaveSettings();
++
++  // restore current state settings (not configuration options)
++  restoreCurrentState(TQString());
++
++  // if this is the first toplevel, show tip of day
++  if (memberList->count() == 1)
++    TQTimer::singleShot( 200, TQT_TQOBJECT(this), TQT_SLOT(slotShowTipOnStart()) );
++}
++
++void TopLevel::init()
++{
++  _activeParts.clear();
++  _hiddenParts.clear();
++
++  _progressBar = 0;
++
++  _data = 0;
++  _function = 0;
++  _costType = 0;
++  _costType2 = 0;
++  _groupType = TraceCost::NoCostType;
++  _group = 0;
++
++  _layoutCurrent = 0;
++  _layoutCount = 1;
++
++  // for delayed slots
++  _traceItemDelayed = 0;
++  _costTypeDelayed = 0;
++  _costType2Delayed = 0;
++  _groupTypeDelayed = TraceCost::NoCostType;
++  _groupDelayed = 0;
++  _directionDelayed = TraceItemView::None;
++  _lastSender = 0;
++}
++
++
++/**
++ * Setup the part selection widget.
++ * Statusbar has to be created before.
++ */
++void TopLevel::setupPartSelection(PartSelection* ps)
++{
++  // setup connections from the part selection widget
++
++  connect(ps, TQT_SIGNAL(activePartsChanged(const TracePartList&)),
++          TQT_TQOBJECT(this), TQT_SLOT(activePartsChangedSlot(const TracePartList&)));
++  connect(ps, TQT_SIGNAL(groupChanged(TraceCostItem*)),
++          TQT_TQOBJECT(this), TQT_SLOT(setGroupDelayed(TraceCostItem*)));
++  connect(ps, TQT_SIGNAL(functionChanged(TraceItem*)),
++          TQT_TQOBJECT(this), TQT_SLOT(setTraceItemDelayed(TraceItem*)));
++
++  connect(ps, TQT_SIGNAL(goBack()),
++          _stackSelection, TQT_SLOT(browserBack()));
++
++  connect(ps, TQT_SIGNAL(partsHideSelected()),
++          TQT_TQOBJECT(this), TQT_SLOT(partsHideSelectedSlotDelayed()));
++  connect(ps, TQT_SIGNAL(partsUnhideAll()),
++          TQT_TQOBJECT(this), TQT_SLOT(partsUnhideAllSlotDelayed()));
++
++  connect(ps, TQT_SIGNAL(showMessage(const TQString&, int)),
++          _statusbar, TQT_SLOT(message(const TQString&, int)));
++}
++
++/**
++ * This saves the current state of the main window and
++ * sub widgets.
++ *
++ * No positions are saved. These is done automatically for
++ * KToolbar, and manually in queryExit() for QT docks.
++ */
++void TopLevel::saveCurrentState(TQString postfix)
++{
++  KConfig* kconfig = KGlobal::config();
++  TQCString pf = postfix.ascii();
++
++  KConfigGroup psConfig(kconfig, TQCString("PartOverview")+pf);
++  _partSelection->saveVisualisationConfig(&psConfig);
++
++  KConfigGroup stateConfig(kconfig, TQCString("CurrentState")+pf);
++  stateConfig.writeEntry("CostType",
++			 _costType ? _costType->name() : TQString("?"));
++  stateConfig.writeEntry("CostType2",
++			 _costType2 ? _costType2->name() : TQString("?"));
++  stateConfig.writeEntry("GroupType", TraceItem::typeName(_groupType));
++
++  _multiView->saveViewConfig(kconfig, TQString("MainView"), postfix, true);
++}
++
++/**
++ * This function is called when a trace is closed.
++ * Save browsing position for later restoring
++ */
++void TopLevel::saveTraceSettings()
++{
++  TQString key = traceKey();
++
++  KConfigGroup pConfig(KGlobal::config(), TQCString("TracePositions"));
++  pConfig.writeEntry(TQString("CostType%1").arg(key),
++                     _costType ? _costType->name() : TQString("?"));
++  pConfig.writeEntry(TQString("CostType2%1").arg(key),
++                     _costType2 ? _costType2->name() : TQString("?"));
++  pConfig.writeEntry(TQString("GroupType%1").arg(key),
++                     TraceItem::typeName(_groupType));
++
++  if (!_data) return;
++
++  KConfigGroup aConfig(KGlobal::config(), TQCString("Layouts"));
++  aConfig.writeEntry(TQString("Count%1").arg(key), _layoutCount);
++  aConfig.writeEntry(TQString("Current%1").arg(key), _layoutCurrent);
++
++  saveCurrentState(key);
++  pConfig.writeEntry(TQString("Group%1").arg(key),
++                     _group ? _group->name() : TQString());
++}
++
++/**
++ * This restores the current state of the main window and
++ * sub widgets.
++ *
++ * This does NOT restore any positions. This is done automatically for
++ * KToolbar, and manually in the createDocks() for QT docks..
++ */
++void TopLevel::restoreCurrentState(TQString postfix)
++{
++  KConfig* kconfig = KGlobal::config();
++  TQStringList gList = kconfig->groupList();
++  TQCString pf = postfix.ascii();
++
++  // dock properties (not position, this should be have done before)
++  TQCString group = TQCString("PartOverview");
++  if (gList.contains(group+pf)) group += pf;
++  KConfigGroup psConfig(kconfig, group);
++  _partSelection->readVisualisationConfig(&psConfig);
++
++  _multiView->readViewConfig(kconfig, TQString("MainView"), postfix, true);
++  _taSplit->setChecked(_multiView->childCount()>1);
++  _taSplitDir->setEnabled(_multiView->childCount()>1);
++  _taSplitDir->setChecked(_multiView->orientation() == Qt::Horizontal);
++}
++
++
++void TopLevel::createDocks()
++{
++  _partDock = new TQDockWindow(TQDockWindow::InDock, this);
++  _partDock->setCaption(i18n("Parts Overview"));
++  _partDock->setCloseMode( TQDockWindow::Always );
++  _partSelection = new PartSelection(_partDock, "partSelection");
++  _partDock->setWidget(_partSelection);
++  _partDock->setResizeEnabled(true);
++  _partDock->setFixedExtentWidth(200);
++  TQWhatsThis::add( _partSelection, i18n(
++                   "<b>The Parts Overview</b>"
++                   "<p>A trace consists of multiple trace parts when "
++                   "there are several profile data files from one profile run. "
++                   "The Trace Part Overview dockable shows these, "
++                   "horizontally ordered in execution time; "
++                   "the rectangle sizes are proportional to the total "
++                   "cost spent in the parts. You can select one or several "
++                   "parts to constrain all costs shown to these parts only."
++                   "</p>"
++                   "<p>The parts are further subdivided: there is a "
++                   "partitioning and an callee split mode: "
++                   "<ul><li>Partitioning: You see the "
++                   "partitioning into groups for a trace part, according to "
++                   "the group type selected. E.g. if ELF object groups are "
++                   "selected, you see colored rectangles for each "
++                   "used ELF object (shared library or executable), sized "
++                   "according to the cost spent therein.</li>"
++                   "<li>Callee: A rectangle showing the inclusive "
++                   "cost of the current selected function in the trace part "
++                   "is shown. "
++                   "This is split up into smaller rectangles to show the costs of its "
++                   "callees.</li></ul></p>"));
++
++  _stackDock = new TQDockWindow(TQDockWindow::InDock, this);
++  _stackDock->setResizeEnabled(true);
++  // Why is the caption only correct with a close button?
++  _stackDock->setCloseMode( TQDockWindow::Always );
++  _stackSelection = new StackSelection(_stackDock, "stackSelection");
++  _stackDock->setWidget(_stackSelection);
++  _stackDock->setFixedExtentWidth(200);
++  _stackDock->setCaption(i18n("Top Cost Call Stack"));
++  TQWhatsThis::add( _stackSelection, i18n(
++                   "<b>The Top Cost Call Stack</b>"
++                   "<p>This is a purely fictional 'most probable' call stack. "
++                   "It is built up by starting with the current selected "
++                   "function and adds the callers/callees with highest cost "
++                   "at the top and to bottom.</p>"
++                   "<p>The <b>Cost</b> and <b>Calls</b> columns show the "
++                   "cost used for all calls from the function in the line "
++                   "above.</p>"));
++
++  connect(_stackSelection, TQT_SIGNAL(functionSelected(TraceItem*)),
++          TQT_TQOBJECT(this), TQT_SLOT(setTraceItemDelayed(TraceItem*)));
++
++  _functionDock = new TQDockWindow(TQDockWindow::InDock, this);
++  _functionDock->setCaption(i18n("Flat Profile"));
++  _functionDock->setCloseMode( TQDockWindow::Always );
++  _functionSelection = new FunctionSelection(this, _functionDock,
++                                             "functionSelection");
++  _functionSelection->setTopLevel(this);
++
++  _functionDock->setWidget(_functionSelection);
++  _functionDock->setResizeEnabled(true);
++  _functionDock->setFixedExtentWidth(200);
++  TQWhatsThis::add( _functionSelection, i18n(
++                   "<b>The Flat Profile</b>"
++                   "<p>The flat profile contains a group and a function "
++                   "selection list. The group list contains all groups "
++                   "where costs "
++                   "are spent in, depending on the chosen group type. "
++                   "The group list is hidden when group type 'Function' "
++                   "is selected.<p>"
++                   "<p>The function list contains the functions of the "
++                   "selected group (or all for 'Function' group type), "
++                   "ordered by the costs spent therein. Functions with "
++                   "costs less than 1% are hidden on default.</p>"));
++
++#if ENABLE_DUMPDOCK
++  _dumpDock = new TQDockWindow(TQDockWindow::InDock, this);
++  _dumpDock->setCaption(i18n("Profile Dumps"));
++  _dumpDock->setCloseMode( TQDockWindow::Always );
++  _dumpSelection = new DumpSelection(this, _dumpDock,
++                                     "dumpSelection");
++  _dumpSelection->setTopLevel(this);
++
++  _dumpDock->setWidget(_dumpSelection);
++  _dumpDock->setResizeEnabled(true);
++  _dumpDock->setFixedExtentWidth(200);
++  TQWhatsThis::add( _dumpSelection, i18n(
++                   "<b>Profile Dumps</b>"
++                   "<p>This dockable shows in the top part the list of "
++                   "loadable profile dumps in all subdirectories of: "
++                   "<ul><li>current working directory of KCachegrind, "
++                   "i.e. where it was started from, and "
++                   "<li>the default profile dump directory given in the "
++                   "configuration.</ul> "
++                   "The list is sorted according the the target command "
++                   "profiled in the corresponding dump.</p>"
++                   "<p>On selecting a profile dump, information for it "
++                   "is shown in the bottom area of the dockable: "
++                   "<ul><li><b>Options</b> allows you to view the profiled "
++                   "command and profile options of this dump. By changing "
++                   "any item, a new (yet unexisting) profile template "
++                   "is created. Press <b>Run Profile</b> to start a"
++                   "profile run with these options in the background. "
++                   "<li><b>Info</b> gives detailed info on the selected "
++                   "dump like event cost summary and properties of the "
++                   "simulated cache. "
++                   "<li><b>State</b> is only available for current happening "
++                   "profiles runs. Press <b>Update</b> to see different "
++                   "counters of the run, and a stack trace of the current "
++                   "position in the program profiled. Check the <b>Every</b> "
++                   "option to let KCachegrind regularly poll these data. "
++                   "Check the <b>Sync</b> option to let the dockable activate "
++                   "the top function in the current loaded dump.</ul></p>"));
++#endif
++
++  // Restore QT Dock positions...
++  KConfigGroup dockConfig(KGlobal::config(), TQCString("Docks"));
++  TQString str = dockConfig.readEntry("Position", TQString());
++  if (0) qDebug("Docks/Position: '%s'", str.ascii());
++  if (str.isEmpty()) {
++    // default positions
++    addDockWindow(_partDock, DockLeft);
++    addDockWindow(_stackDock, DockLeft);
++    addDockWindow(_functionDock, DockLeft);
++    _stackDock->hide();
++#if ENABLE_DUMPDOCK
++    addDockWindow(_dumpDock, DockLeft);
++    _dumpDock->hide();
++#endif
++  }
++  else {
++    TQTextStream ts( &str, IO_ReadOnly );
++    ts >> *this;
++  }
++  _forcePartDock = dockConfig.readBoolEntry("ForcePartDockVisible", false);
++
++#if 0
++  // dock context menu
++  setAppropriate(_partDock, true);
++  setAppropriate(_stackDock, true);
++  setAppropriate(_dumpDock, true);
++  setAppropriate(_functionDock, true);
++
++  connect( _partDock, TQT_SIGNAL(contextMenuRequested(const TQPoint &)),
++           TQT_TQOBJECT(this), TQT_SLOT(showDockMenu(const TQPoint &)));
++#endif
++}
++
++
++TopLevel::~TopLevel()
++{
++  delete _data;
++}
++
++
++void TopLevel::saveProperties(KConfig* c)
++{
++  c->writeEntry("TraceName", _data->traceName());
++}
++
++void TopLevel::readProperties(KConfig* c)
++{
++  TQString traceName = c->readEntry("TraceName");
++  if (!traceName.isEmpty()) {
++      TraceData* d = new TraceData(this);
++      d->load(traceName);
++      setData(d);
++  }
++}
++
++void TopLevel::createLayoutActions()
++{
++  TQString hint;
++  KAction* action;
++
++  action = new KAction( i18n( "&Duplicate" ),
++			KShortcut(KKey("Ctrl+Plus")),
++                        TQT_TQOBJECT(this), TQT_SLOT(layoutDuplicate()),
++                        actionCollection(), "layout_duplicate" );
++  hint = i18n("<b>Duplicate Current Layout</b>"
++              "<p>Make a copy of the current layout.</p>");
++  action->setWhatsThis( hint );
++
++  action = new KAction( i18n( "&Remove" ), KShortcut(),
++                        TQT_TQOBJECT(this), TQT_SLOT(layoutRemove()),
++                        actionCollection(), "layout_remove" );
++  hint = i18n("<b>Remove Current Layout</b>"
++              "<p>Delete current layout and make the previous active.</p>");
++  action->setWhatsThis( hint );
++
++  action = new KAction( i18n( "&Go to Next" ),
++			KShortcut(KKey("Ctrl+Right")),
++                        TQT_TQOBJECT(this), TQT_SLOT(layoutNext()),
++                        actionCollection(), "layout_next" );
++  hint = i18n("Go to Next Layout");
++  action->setWhatsThis( hint );
++
++  action = new KAction( i18n( "&Go to Previous" ),
++			KShortcut(KKey("Ctrl+Left")),
++                        TQT_TQOBJECT(this), TQT_SLOT(layoutPrevious()),
++                        actionCollection(), "layout_previous" );
++  hint = i18n("Go to Previous Layout");
++  action->setWhatsThis( hint );
++
++  action = new KAction( i18n( "&Restore to Default" ), KShortcut(),
++                        TQT_TQOBJECT(this), TQT_SLOT(layoutRestore()),
++                        actionCollection(), "layout_restore" );
++  hint = i18n("Restore Layouts to Default");
++  action->setWhatsThis( hint );
++
++  action = new KAction( i18n( "&Save as Default" ), KShortcut(),
++                        TQT_TQOBJECT(this), TQT_SLOT(layoutSave()),
++                        actionCollection(), "layout_save" );
++  hint = i18n("Save Layouts as Default");
++  action->setWhatsThis( hint );
++}
++
++// TODO: split this up...
++void TopLevel::createMiscActions()
++{
++  TQString hint;
++  KAction* action;
++
++  action = KStdAction::openNew(TQT_TQOBJECT(this), TQT_SLOT(newWindow()), actionCollection());
++  hint = i18n("<b>New</b><p>Open new empty KCachegrind window.</p>");
++  action->setWhatsThis( hint );
++
++  action = new KAction( i18n( "&Add..." ), KShortcut(),
++                        TQT_TQOBJECT(this), TQT_SLOT(addTrace()),
++                        actionCollection(), "file_add" );
++  hint = i18n("<b>Add Profile Data</b>"
++              "<p>This opens an additional profile data file in the current window.</p>");
++  action->setWhatsThis( hint );
++
++  action = new KAction( i18n( "&Reload" ), "reload",
++#if KDE_VERSION > 0x030190
++  // for KDE 3.2: KStdAccel::key is deprecated
++			KStdAccel::shortcut(KStdAccel::Reload),
++#else
++                        KStdAccel::key(KStdAccel::Reload),
++#endif
++                        TQT_TQOBJECT(this), TQT_SLOT( reload() ), actionCollection(), "reload" );
++  hint = i18n("<b>Reload Profile Data</b>"
++              "<p>This loads any new created parts, too.</p>");
++  action->setWhatsThis( hint );
++
++  action = new KAction( i18n( "&Export Graph" ), KShortcut(),
++                        TQT_TQOBJECT(this), TQT_SLOT(exportGraph()),
++                        actionCollection(), "export" );
++
++  hint = i18n("<b>Export Call Graph</b>"
++              "<p>Generates a file with extension .dot for the tools "
++              "of the GraphViz package.</p>");
++  action->setWhatsThis( hint );
++
++
++  _taDump = new KToggleAction( i18n( "&Force Dump" ), "redo",
++#if KDE_VERSION > 0x030190
++  // for KDE 3.2: KStdAccel::key is deprecated
++			       KStdAccel::shortcut(KStdAccel::Redo),
++#else
++                               KStdAccel::key(KStdAccel::Redo),
++#endif
++                               TQT_TQOBJECT(this), TQT_SLOT( forceTrace() ),
++                               actionCollection(), "dump" );
++  hint = i18n("<b>Force Dump</b>"
++              "<p>This forces a dump for a Callgrind profile run "
++              "in the current directory. This action is checked while "
++              "KCachegrind looks for the dump. If the dump is "
++              "finished, it automatically reloads the current trace. "
++              "If this is the one from the running Callgrind, the new "
++              "created trace part will be loaded, too.</p>"
++              "<p>Force dump creates a file 'callgrind.cmd', and "
++              "checks every second for its existence. A running "
++              "Callgrind will detect this file, dump a trace part, "
++              "and delete 'callgrind.cmd'. "
++              "The deletion is detected by KCachegrind, "
++              "and it does a Reload. If there's <em>no</em> Callgrind "
++              "running, press 'Force Dump' again to cancel the dump "
++              "request. This deletes 'callgrind.cmd' itself and "
++              "stops polling for a new dump.</p>"
++              "<p>Note: A Callgrind run <em>only</em> detects "
++              "existence of 'callgrind.cmd' when actively running "
++              "a few milliseconds, i.e. "
++              "<em>not</em> sleeping. Tip: For a profiled GUI program, "
++              "you can awake Callgrind e.g. by resizing a window "
++              "of the program.</p>");
++  _taDump->setWhatsThis( hint );
++
++  action = KStdAction::open(TQT_TQOBJECT(this), TQT_SLOT(loadTrace()), actionCollection());
++  hint = i18n("<b>Open Profile Data</b>"
++              "<p>This opens a profile data file, with possible multiple parts</p>");
++  action->setToolTip( hint );
++  action->setWhatsThis( hint );
++
++  _openRecent = KStdAction::openRecent(TQT_TQOBJECT(this), TQT_SLOT(loadTrace(const KURL&)),
++                                       actionCollection());
++
++  KStdAction::showStatusbar(TQT_TQOBJECT(this),
++                            TQT_SLOT(toggleStatusBar()), actionCollection());
++
++  _partDockShown = new KToggleAction(i18n("Parts Overview"), KShortcut(),
++                                     TQT_TQOBJECT(this), TQT_SLOT(togglePartDock()),
++                                     actionCollection(),
++                                     "settings_show_partdock");
++
++  hint = i18n("Show/Hide the Parts Overview Dockable");
++  _partDockShown->setToolTip( hint );
++  _partDockShown->setWhatsThis( hint );
++
++  _stackDockShown = new KToggleAction(i18n("Call Stack"), KShortcut(),
++                                     TQT_TQOBJECT(this), TQT_SLOT(toggleStackDock()),
++                                     actionCollection(),
++                                     "settings_show_stackdock");
++
++  hint = i18n("Show/Hide the Call Stack Dockable");
++  _stackDockShown->setToolTip( hint );
++  _stackDockShown->setWhatsThis( hint );
++
++  _functionDockShown = new KToggleAction(i18n("Function Profile"), KShortcut(),
++                                         TQT_TQOBJECT(this), TQT_SLOT(toggleFunctionDock()),
++                                         actionCollection(),
++                                         "settings_show_profiledock");
++
++  hint = i18n("Show/Hide the Function Profile Dockable");
++  _functionDockShown->setToolTip( hint );
++  _functionDockShown->setWhatsThis( hint );
++
++#if ENABLE_DUMPDOCK
++  _dumpDockShown = new KToggleAction(i18n("Profile Dumps"), KShortcut(),
++                                     TQT_TQOBJECT(this), TQT_SLOT(toggleDumpDock()),
++                                     actionCollection(),
++                                     "settings_show_dumpdock");
++
++  hint = i18n("Show/Hide the Profile Dumps Dockable");
++  _dumpDockShown->setToolTip( hint );
++  _dumpDockShown->setWhatsThis( hint );
++#endif
++
++  _taPercentage = new KToggleAction(i18n("Show Relative Costs"), "percent",
++				    KShortcut(),
++				    TQT_TQOBJECT(this), TQT_SLOT(togglePercentage()),
++				    actionCollection(),
++				    "view_percentage");
++#if KDE_VERSION >= 0x030290
++  // for KDE 3.3: show another text instead of a checkmark
++  _taPercentage->setCheckedState(i18n("Show Absolute Costs"));
++#endif
++
++  hint = i18n("Show relative instead of absolute costs");
++  _taPercentage->setToolTip( hint );
++  _taPercentage->setWhatsThis( hint );
++
++  _taExpanded = new KToggleAction(i18n("Percentage Relative to Parent"), "move",
++				  KShortcut(),
++				  TQT_TQOBJECT(this), TQT_SLOT(toggleExpanded()),
++				  actionCollection(),
++				  "view_expanded");
++
++  hint = i18n("Show percentage costs relative to parent");
++  _taExpanded->setToolTip( hint );
++  _taExpanded->setWhatsThis( hint );
++
++  hint = i18n("<b>Show percentage costs relative to parent</b>"
++              "<p>If this is switched off, percentage costs are always shown "
++	      "relative to the total cost of the profile part(s) that are "
++	      "currently browsed. By turning on this option, percentage cost "
++	      "of shown cost items will be relative to the parent cost item."
++	      "<ul><table>"
++	      "<tr><td><b>Cost Type</td><td><b>Parent Cost</td></tr>"
++	      "<tr><td>Function Cumulative</td><td>Total</td></tr>"
++	      "<tr><td>Function Self</td><td>Function Group (*) / Total</td></tr>"
++	      "<tr><td>Call</td><td>Function Cumulative</td></tr>"
++	      "<tr><td>Source Line</td><td>Function Cumulative</td></tr>"
++	      "</table>"
++	      "<p>(*) Only if function grouping is switched on (e.g. ELF object grouping).");
++  _taExpanded->setWhatsThis( hint );
++
++  _taCycles = new KToggleAction( i18n( "Do Cycle Detection" ), "undo",
++				 KShortcut(),
++				 TQT_TQOBJECT(this), TQT_SLOT( toggleCycles() ), actionCollection(),
++				 "view_cycles" );
++#if KDE_VERSION >= 0x030290
++  // for KDE 3.3: show another text instead of a checkmark
++  _taCycles->setCheckedState(i18n("Skip Cycle Detection"));
++#endif
++
++  hint = i18n("<b>Detect recursive cycles</b>"
++              "<p>If this is switched off, the treemap drawing will show "
++	      "black areas when a recursive call is made instead of drawing the "
++	      "recursion ad infinitum. Note that "
++	      "the size of black areas often will be wrong, as inside recursive "
++              "cycles the cost of calls cannot be determined; the error is small, "
++              "however, for false cycles (see documentation)."
++	      "<p>The correct handling for cycles is to detect them and collapse all "
++              "functions of a cycle into a virtual function, which is done when this "
++              "option is selected. Unfortunately, with GUI applications, this often will "
++              "lead to huge false cycles, making the analysis impossible; therefore, there "
++              "is the option to switch this off.");
++  _taCycles->setWhatsThis( hint );
++
++  KStdAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection());
++  KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(configure()), actionCollection());
++  KStdAction::keyBindings(TQT_TQOBJECT(this), TQT_SLOT(configureKeys()), actionCollection());
++  KStdAction::configureToolbars(TQT_TQOBJECT(this),TQT_SLOT(configureToolbars()),
++                                actionCollection());
++#if 0
++  action = KStdAction::back(_stackSelection, TQT_SLOT(browserBack()),
++                            actionCollection());
++  hint = i18n("Go back in function selection history");
++  action->setToolTip( hint );
++  action->setWhatsThis( hint );
++
++  action = KStdAction::forward(_stackSelection, TQT_SLOT(browserForward()),
++                      actionCollection());
++  hint = i18n("Go forward in function selection history");
++  action->setToolTip( hint );
++  action->setWhatsThis( hint );
++
++  action = KStdAction::up(_stackSelection, TQT_SLOT(browserUp()),
++                      actionCollection());
++  hint = i18n("<b>Go Up</b>"
++              "<p>Go to last selected caller of current function. "
++              "If no caller was visited, use that with highest cost.</p>");
++  action->setToolTip( hint );
++  action->setWhatsThis( hint );
++#else
++  _paUp = new KToolBarPopupAction( i18n( "&Up" ), "up",
++                                   ALT+Key_Up,
++                                   TQT_TQOBJECT(_stackSelection), TQT_SLOT( browserUp() ),
++                                   actionCollection(), "go_up" );
++  connect( _paUp->popupMenu(), TQT_SIGNAL( aboutToShow() ),
++           TQT_TQOBJECT(this), TQT_SLOT( upAboutToShow() ) );
++  connect( _paUp->popupMenu(), TQT_SIGNAL( activated( int ) ),
++           TQT_TQOBJECT(this), TQT_SLOT( upActivated( int ) ) );
++  hint = i18n("<b>Go Up</b>"
++              "<p>Go to last selected caller of current function. "
++              "If no caller was visited, use that with highest cost.</p>");
++  _paUp->setToolTip( hint );
++  _paUp->setWhatsThis( hint );
++
++  TQPair< KGuiItem, KGuiItem > backForward = KStdGuiItem::backAndForward();
++  _paBack = new KToolBarPopupAction( backForward.first, ALT+Key_Left,
++                                     TQT_TQOBJECT(_stackSelection), TQT_SLOT(browserBack()),
++                                     actionCollection(), "go_back" );
++  connect( _paBack->popupMenu(), TQT_SIGNAL( aboutToShow() ),
++           TQT_TQOBJECT(this), TQT_SLOT( backAboutToShow() ) );
++  connect( _paBack->popupMenu(), TQT_SIGNAL( activated( int ) ),
++           TQT_TQOBJECT(this), TQT_SLOT( backActivated( int ) ) );
++  hint = i18n("Go back in function selection history");
++  _paBack->setToolTip( hint );
++  _paBack->setWhatsThis( hint );
++
++  _paForward = new KToolBarPopupAction( backForward.second, ALT+Key_Right,
++                                        TQT_TQOBJECT(_stackSelection),
++                                        TQT_SLOT(browserForward()),
++                                        actionCollection(), "go_forward" );
++  connect( _paForward->popupMenu(), TQT_SIGNAL( aboutToShow() ),
++           this, TQT_SLOT( forwardAboutToShow() ) );
++  connect( _paForward->popupMenu(), TQT_SIGNAL( activated( int ) ),
++           this, TQT_SLOT( forwardActivated( int ) ) );
++  hint = i18n("Go forward in function selection history");
++  _paForward->setToolTip( hint );
++  _paForward->setWhatsThis( hint );
++#endif
++
++  _saCost = new KSelectAction( i18n("Primary Event Type"), KShortcut(),
++			       actionCollection(), "view_cost_type");
++  hint = i18n("Select primary event type of costs");
++  _saCost->setComboWidth(300);
++  _saCost->setToolTip( hint );
++  _saCost->setWhatsThis( hint );
++
++  // cost types are dependent on loaded data, thus KSelectAction
++  // is filled in setData()
++  connect( _saCost, TQT_SIGNAL(activated(const TQString&)),
++           TQT_TQOBJECT(this), TQT_SLOT(costTypeSelected(const TQString&)));
++
++  _saCost2 = new KSelectAction( i18n("Secondary Event Type"), KShortcut(),
++				actionCollection(), "view_cost_type2");
++  hint = i18n("Select secondary event type for cost e.g. shown in annotations");
++  _saCost2->setComboWidth(300);
++  _saCost2->setToolTip( hint );
++  _saCost2->setWhatsThis( hint );
++
++  connect( _saCost2, TQT_SIGNAL(activated(const TQString&)),
++           TQT_TQOBJECT(this), TQT_SLOT(costType2Selected(const TQString&)));
++
++  saGroup = new KSelectAction( i18n("Grouping"), KShortcut(),
++                               actionCollection(), "view_group_type");
++
++  hint = i18n("Select how functions are grouped into higher level cost items");
++  saGroup->setToolTip( hint );
++  saGroup->setWhatsThis( hint );
++
++  TQStringList args;
++
++  args << i18n("(No Grouping)")
++       << TraceCost::i18nTypeName(TraceItem::Object)
++       << TraceCost::i18nTypeName(TraceItem::File)
++       << TraceCost::i18nTypeName(TraceItem::Class)
++       << TraceCost::i18nTypeName(TraceItem::FunctionCycle);
++
++  saGroup->setItems(args);
++  connect( saGroup, TQT_SIGNAL(activated(int)),
++           TQT_TQOBJECT(this), TQT_SLOT(groupTypeSelected(int)));
++
++  _taSplit = new KToggleAction(i18n("Split"), "view_left_right", KShortcut(),
++                               TQT_TQOBJECT(this), TQT_SLOT(splitSlot()),
++                               actionCollection(), "view_split");
++
++  hint = i18n("Show two information panels");
++  _taSplit->setToolTip( hint );
++  _taSplit->setWhatsThis( hint );
++
++ _taSplitDir = new KToggleAction(i18n("SplitQt::Horizontal"),
++                                  "view_left_right", KShortcut(),
++                                  TQT_TQOBJECT(this), TQT_SLOT(splitDirSlot()),
++                                  actionCollection(), "view_split_dir");
++
++  hint = i18n("Change Split Qt::Orientation when main window is split.");
++  _taSplitDir->setToolTip( hint );
++  _taSplitDir->setWhatsThis( hint );
++
++  // copied from KMail...
++#if KDE_VERSION >= 308 // KDE 3.1
++  KStdAction::tipOfDay( TQT_TQOBJECT(this), TQT_SLOT( slotShowTip() ), actionCollection() );
++#else
++  (void) new KAction( KGuiItem( i18n("Tip of the &Day..."), "idea",
++                                i18n("Show \"Tip of the Day\"") ),
++                      0, TQT_TQOBJECT(this), TQT_SLOT(slotShowTip()),
++                      actionCollection(), "help_show_tip" );
++#endif
++}
++
++void TopLevel::createActions()
++{
++  createMiscActions();
++  createLayoutActions();
++}
++
++void TopLevel::toggleStatusBar()
++{
++  if (statusBar()->isVisible())
++    statusBar()->hide();
++  else
++    statusBar()->show();
++}
++
++void TopLevel::togglePartDock()
++{
++  if (!_partDock->isVisible())
++    _partDock->show();
++  else
++    _partDock->hide();
++}
++
++void TopLevel::toggleStackDock()
++{
++  if (!_stackDock->isVisible())
++    _stackDock->show();
++  else
++    _stackDock->hide();
++}
++
++void TopLevel::toggleDumpDock()
++{
++#if ENABLE_DUMPDOCK
++  if (!_dumpDock->isVisible())
++    _dumpDock->show();
++  else
++    _dumpDock->hide();
++#endif
++}
++
++void TopLevel::toggleFunctionDock()
++{
++  if (!_functionDock->isVisible())
++    _functionDock->show();
++  else
++    _functionDock->hide();
++}
++
++void TopLevel::togglePercentage()
++{
++  setPercentage(_taPercentage->isChecked());
++}
++
++void TopLevel::setAbsoluteCost()
++{
++  setPercentage(false);
++}
++
++void TopLevel::setRelativeCost()
++{
++  setPercentage(true);
++}
++
++void TopLevel::setPercentage(bool show)
++{
++  if (_showPercentage == show) return;
++  _showPercentage = show;
++  if (_taPercentage->isChecked() != show)
++    _taPercentage->setChecked(show);
++
++  // FIXME: Delete when no view gets this config from Configuration
++  Configuration::setShowPercentage(_showPercentage);
++
++  _partSelection->refresh();
++  _stackSelection->refresh();
++
++  _functionSelection->notifyChange(TraceItemView::configChanged);
++  _functionSelection->updateView();
++
++  _multiView->notifyChange(TraceItemView::configChanged);
++  _multiView->updateView();
++}
++
++void TopLevel::toggleExpanded()
++{
++  bool show = _taExpanded->isChecked();
++  if (_showExpanded == show) return;
++  _showExpanded = show;
++
++  // FIXME: Delete when no view gets this config from Configuration
++  Configuration::setShowExpanded(_showExpanded);
++
++  _partSelection->refresh();
++  _stackSelection->refresh();
++
++  _functionSelection->notifyChange(TraceItemView::configChanged);
++  _functionSelection->updateView();
++
++  _multiView->notifyChange(TraceItemView::configChanged);
++  _multiView->updateView();
++}
++
++void TopLevel::toggleCycles()
++{
++  bool show = _taCycles->isChecked();
++  if (_showCycles == show) return;
++  _showCycles = show;
++
++  // FIXME: Delete when no view gets this config from Configuration
++  Configuration::setShowCycles(_showCycles);
++
++  if (!_data) return;
++
++  _data->invalidateDynamicCost();
++  _data->updateFunctionCycles();
++
++  _partSelection->refresh();
++  _stackSelection->rebuildStackList();
++
++  _functionSelection->notifyChange(TraceItemView::configChanged);
++  _functionSelection->updateView();
++
++  _multiView->notifyChange(TraceItemView::configChanged);
++  _multiView->updateView();
++}
++
++void TopLevel::partVisibilityChanged(bool v)
++{
++  _partDockShown->setChecked(v);
++}
++
++void TopLevel::stackVisibilityChanged(bool v)
++{
++  _stackDockShown->setChecked(v);
++}
++
++#if ENABLE_DUMPDOCK
++void TopLevel::dumpVisibilityChanged(bool v)
++#else
++void TopLevel::dumpVisibilityChanged(bool)
++#endif
++{
++#if ENABLE_DUMPDOCK
++  _dumpDockShown->setChecked(v);
++#endif
++}
++
++void TopLevel::functionVisibilityChanged(bool v)
++{
++  _functionDockShown->setChecked(v);
++  if (v)
++    _functionSelection->updateView();
++}
++
++
++void TopLevel::querySlot()
++{
++  _functionSelection->query(queryLineEdit->text());
++}
++
++void TopLevel::configureKeys()
++{
++#if KDE_VERSION > 0x030190
++  // for KDE 3.2: KKeyDialog::configureKeys is deprecated
++  KKeyDialog::configure(actionCollection(), this, true);
++#else
++  KKeyDialog::configureKeys(actionCollection(), xmlFile(), true, this);
++#endif
++}
++
++
++void TopLevel::configureToolbars()
++{
++  KEditToolbar *dlg = new KEditToolbar(guiFactory(),this);
++
++  if (dlg->exec())
++    createGUI();
++
++  delete dlg;
++}
++
++
++void TopLevel::newTrace()
++{
++  // start cachegrind on command...
++}
++
++void TopLevel::newWindow()
++{
++  TopLevel* t = new TopLevel(0);
++  t->show();
++}
++
++
++void TopLevel::loadTrace()
++{
++    KURL url = KFileDialog::getOpenURL(":",
++                                       i18n("cachegrind.out* callgrind.out*|Callgrind Profile Data\n*|All Files"),
++                                       this,
++                                       i18n("Select Callgrind Profile Data"));
++    loadTrace(url);
++}
++
++void TopLevel::loadTrace(const KURL& url)
++{
++  if (url.isEmpty()) return;
++
++  // network transparancy
++  TQString tmpFile;
++#if KDE_VERSION > 0x030190
++  // for KDE 3.2: KIO::NetAccess::download with 2 args is deprecated
++  if(KIO::NetAccess::download( url, tmpFile, this )) {
++#else
++  if(KIO::NetAccess::download( url, tmpFile )) {
++#endif
++    _openRecent->addURL(url);
++    _openRecent->saveEntries( KGlobal::config() );
++
++    loadTrace(tmpFile);
++    KIO::NetAccess::removeTempFile( tmpFile );
++  }
++}
++
++void TopLevel::loadTrace(TQString file)
++{
++  if (file.isEmpty()) return;
++
++  if (_data && _data->parts().count()>0) {
++
++    // In new window
++    TopLevel* t = new TopLevel();
++    t->show();
++    t->loadDelayed(file);
++    return;
++  }
++
++  // this constructor enables progress bar callbacks
++  TraceData* d = new TraceData(this);
++  d->load(file);
++  setData(d);
++}
++
++
++void TopLevel::addTrace()
++{
++    KURL url = KFileDialog::getOpenURL(TQString(),
++                                       i18n("cachegrind.out* callgrind.out*|Callgrind Profile Data\n*|All Files"),
++                                       this,
++                                       i18n("Add Callgrind Profile Data"));
++    addTrace(url);
++}
++
++void TopLevel::addTrace(const KURL& url)
++{
++  if (url.isEmpty()) return;
++
++  // network transparancy
++  TQString tmpFile;
++#if KDE_VERSION > 0x030190
++  // for KDE 3.2: KIO::NetAccess::download with 2 args is deprecated
++  if(KIO::NetAccess::download( url, tmpFile, this )) {
++#else
++  if(KIO::NetAccess::download( url, tmpFile )) {
++#endif
++    _openRecent->addURL(url);
++    _openRecent->saveEntries( KGlobal::config() );
++
++    addTrace(tmpFile);
++    KIO::NetAccess::removeTempFile( tmpFile );
++  }
++}
++
++void TopLevel::addTrace(TQString file)
++{
++  if (file.isEmpty()) return;
++
++  if (_data) {
++    _data->load(file);
++
++    // GUI update for added data
++    configChanged();
++    return;
++  }
++
++  // this constructor enables progress bar callbacks
++  TraceData* d = new TraceData(this);
++  d->load(file);
++  setData(d);
++}
++
++
++
++void TopLevel::loadDelayed(TQString file)
++{
++  _loadTraceDelayed = file;
++  TQTimer::singleShot(0, TQT_TQOBJECT(this), TQT_SLOT(loadTraceDelayed()));
++}
++
++void TopLevel::loadTraceDelayed()
++{
++  if (_loadTraceDelayed.isEmpty()) return;
++
++  loadTrace(_loadTraceDelayed);
++  _loadTraceDelayed = TQString();
++}
++
++
++void TopLevel::reload()
++{
++  TQString trace;
++  if (!_data || _data->parts().count()==0)
++    trace = "."; // open first trace found in dir
++  else
++    trace = _data->traceName();
++
++  // this also keeps sure we have the same browsing position...
++  TraceData* d = new TraceData(this);
++  d->load(trace);
++  setData(d);
++}
++
++void TopLevel::exportGraph()
++{
++  if (!_data || !_function) return;
++
++  TQString n = TQString("callgraph.dot");
++  GraphExporter ge(_data, _function, _costType, _groupType, n);
++  ge.writeDot();
++
++  TQString cmd = TQString("(dot %1 -Tps > %2.ps; kghostview %3.ps)&")
++                .arg(n).arg(n).arg(n);
++  system(TQFile::encodeName( cmd ));
++}
++
++
++bool TopLevel::setCostType(TQString s)
++{
++  TraceCostType* ct;
++
++  ct = (_data) ? _data->mapping()->type(s) : 0;
++
++  // if costtype with given name not found, use first available
++  if (!ct && _data) ct = _data->mapping()->type(0);
++
++  return setCostType(ct);
++}
++
++bool TopLevel::setCostType2(TQString s)
++{
++  TraceCostType* ct;
++
++  // Special type i18n("(Hidden)") gives 0
++  ct = (_data) ? _data->mapping()->type(s) : 0;
++
++  return setCostType2(ct);
++}
++
++void TopLevel::costTypeSelected(const TQString& s)
++{
++  TraceCostType* ct;
++
++  ct = (_data) ? _data->mapping()->typeForLong(s) : 0;
++  setCostType(ct);
++}
++
++void TopLevel::costType2Selected(const TQString& s)
++{
++  TraceCostType* ct;
++
++  ct = (_data) ? _data->mapping()->typeForLong(s) : 0;
++  setCostType2(ct);
++}
++
++bool TopLevel::setCostType(TraceCostType* ct)
++{
++  if (_costType == ct) return false;
++  _costType = ct;
++
++  if (ct) {
++      int idx=0;
++      TQStringList l = _saCost->items();
++      for (TQStringList::Iterator it = l.begin(); it != l.end(); ++it, ++idx ) {
++	  if (*it == ct->longName())
++	      _saCost->setCurrentItem(idx);
++      }
++  }
++
++  _partSelection->setCostType(_costType);
++  _stackSelection->setCostType(_costType);
++
++  _functionSelection->setCostType(_costType);
++  _functionSelection->updateView();
++
++  _multiView->setCostType(_costType);
++  _multiView->updateView();
++
++  updateStatusBar();
++
++  return true;
++}
++
++bool TopLevel::setCostType2(TraceCostType* ct)
++{
++  if (_costType2 == ct) return false;
++  _costType2 = ct;
++
++  TQString longName = ct ? ct->longName() : i18n("(Hidden)");
++
++  int idx=0;
++  TQStringList l = _saCost2->items();
++  for (TQStringList::Iterator it = l.begin(); it != l.end(); ++it, ++idx ) {
++    if (*it == longName)
++      _saCost2->setCurrentItem(idx);
++  }
++
++  _partSelection->setCostType2(_costType2);
++  _stackSelection->setCostType2(_costType2);
++
++  _functionSelection->setCostType2(_costType2);
++  _functionSelection->updateView();
++
++  _multiView->setCostType2(_costType2);
++  _multiView->updateView();
++
++  updateStatusBar();
++
++  return true;
++}
++
++
++void TopLevel::groupTypeSelected(int cg)
++{
++  switch(cg) {
++  case 0: setGroupType( TraceItem::Function ); break;
++  case 1: setGroupType( TraceItem::Object ); break;
++  case 2: setGroupType( TraceItem::File ); break;
++  case 3: setGroupType( TraceItem::Class ); break;
++  case 4: setGroupType( TraceItem::FunctionCycle ); break;
++  default: break;
++  }
++}
++
++bool TopLevel::setGroupType(TQString s)
++{
++  TraceItem::CostType gt;
++
++  gt = (_data) ? _data->costType(s) : TraceData::costType(s);
++  // only allow Function/Object/File/Class as grouptype
++  switch(gt) {
++  case TraceItem::Object:
++  case TraceItem::File:
++  case TraceItem::Class:
++  case TraceItem::FunctionCycle:
++    break;
++  default:
++    gt = TraceItem::Function;
++  }
++
++  return setGroupType(gt);
++}
++
++bool TopLevel::setGroupType(TraceItem::CostType gt)
++{
++  if (_groupType == gt) return false;
++  _groupType = gt;
++
++  int idx = -1;
++  switch(gt) {
++  case TraceItem::Function: idx = 0; break;
++  case TraceItem::Object: idx = 1; break;
++  case TraceItem::File: idx = 2; break;
++  case TraceItem::Class: idx = 3; break;
++  case TraceItem::FunctionCycle: idx = 4; break;
++  default:
++    break;
++  }
++
++  if (idx==-1) return false;
++
++  if (saGroup->currentItem() != idx)
++    saGroup->setCurrentItem(idx);
++
++  _stackSelection->setGroupType(_groupType);
++  _partSelection->setGroupType(_groupType);
++
++  _functionSelection->set(_groupType);
++  _functionSelection->updateView();
++
++  _multiView->set(_groupType);
++  _multiView->updateView();
++
++  updateStatusBar();
++
++  return true;
++}
++
++bool TopLevel::setGroup(TQString s)
++{
++    return true;
++  TraceCostItem* ci = _functionSelection->group(s);
++  if (!ci)
++    return false;
++
++  return setGroup(ci);
++}
++
++
++bool TopLevel::setGroup(TraceCostItem* g)
++{
++  _multiView->activate(g);
++  _multiView->updateView();
++  _functionSelection->activate(g);
++  _functionSelection->updateView();
++
++  if (_group == g) return false;
++  _group = g;
++
++
++  updateStatusBar();
++
++  return true;
++}
++
++bool TopLevel::setFunction(TQString s)
++{
++  if (!_data) return false;
++
++  TraceCost* f = _data->search(TraceItem::Function, s, _costType);
++  if (!f) return false;
++
++  return setFunction((TraceFunction*)f);
++}
++
++bool TopLevel::setFunction(TraceFunction* f)
++{
++  _multiView->activate(f);
++  _multiView->updateView();
++
++  _functionSelection->activate(f);
++  _functionSelection->updateView();
++
++  if (_function == f) return false;
++  _function = f;
++
++  _partSelection->setFunction(_function);
++  _stackSelection->setFunction(_function);
++
++  StackBrowser* b = _stackSelection->browser();
++  if (b) {
++    // don't disable up: a press forces stack-up extending...
++    _paForward->setEnabled(b->canGoForward());
++    _paBack->setEnabled(b->canGoBack());
++  }
++
++#if TRACE_UPDATES
++  qDebug("TopLevel::setFunction(%s), lastSender %s",
++         f ? f->prettyName().ascii() : "0",
++         _lastSender ? _lastSender->name() :"0" );
++#endif
++
++  return true;
++}
++
++
++/**
++ * Delayed versions.
++ * We always have a pair of slots: One receiver to start the
++ * delay with a singleShot Timer. It stores the parameter into a
++ * temporary variable. And one parameterless slot for
++ * forwarding, using this temporary.
++ */
++void TopLevel::setCostTypeDelayed(TraceCostType* ct)
++{
++  _costTypeDelayed = ct;
++  TQTimer::singleShot (0, TQT_TQOBJECT(this), TQT_SLOT(setCostTypeDelayed()));
++}
++
++void TopLevel::setCostType2Delayed(TraceCostType* ct)
++{
++  _costType2Delayed = ct;
++  TQTimer::singleShot (0, TQT_TQOBJECT(this), TQT_SLOT(setCostType2Delayed()));
++}
++
++void TopLevel::setCostTypeDelayed()
++{
++  setCostType(_costTypeDelayed);
++}
++
++void TopLevel::setCostType2Delayed()
++{
++  setCostType2(_costType2Delayed);
++}
++
++void TopLevel::setGroupTypeDelayed(TraceItem::CostType gt)
++{
++  _groupTypeDelayed = gt;
++  TQTimer::singleShot (0, TQT_TQOBJECT(this), TQT_SLOT(setGroupTypeDelayed()));
++}
++
++void TopLevel::setGroupTypeDelayed()
++{
++  setGroupType(_groupTypeDelayed);
++}
++
++void TopLevel::setGroupDelayed(TraceCostItem* g)
++{
++#if TRACE_UPDATES
++  qDebug("TopLevel::setGroupDelayed(%s), sender %s",
++         g ? g->prettyName().ascii() : "0",
++         _lastSender ? _lastSender->name() :"0" );
++#endif
++
++  _groupDelayed = g;
++  TQTimer::singleShot (0, TQT_TQOBJECT(this), TQT_SLOT(setGroupDelayed()));
++}
++
++void TopLevel::setGroupDelayed()
++{
++  setGroup(_groupDelayed);
++}
++
++void TopLevel::setDirectionDelayed(TraceItemView::Direction d)
++{
++  _directionDelayed = d;
++  TQTimer::singleShot (0, TQT_TQOBJECT(this), TQT_SLOT(setDirectionDelayed()));
++}
++
++void TopLevel::setDirectionDelayed()
++{
++    switch(_directionDelayed) {
++    case TraceItemView::Back:
++	_stackSelection->browserBack();
++	break;
++
++    case TraceItemView::Forward:
++    	_stackSelection->browserForward();
++	break;
++
++    case TraceItemView::Up:
++	{
++	    StackBrowser* b = _stackSelection ? _stackSelection->browser() : 0;
++	    HistoryItem* hi = b ? b->current() : 0;
++	    TraceFunction* f = hi ? hi->function() : 0;
++
++	    if (!f) break;
++	    f = hi->stack()->caller(f, false);
++	    if (f) setFunction(f);
++	}
++    break;
++
++    default: break;
++    }
++
++    _directionDelayed = TraceItemView::None;
++}
++
++
++void TopLevel::setTraceItemDelayed(TraceItem* i)
++{
++  // no need to select same item a 2nd time...
++  if (_traceItemDelayed == i) return;
++  _traceItemDelayed = i;
++  _lastSender = TQT_TQOBJECT(const_cast<TQT_BASE_OBJECT_NAME*>(sender()));
++
++  kdDebug() << "Selected " << (i ? i->prettyName() : "(none)") << endl;
++
++#if TRACE_UPDATES
++  qDebug("TopLevel::setTraceItemDelayed(%s), sender %s",
++         i ? i->prettyName().ascii() : "0",
++         _lastSender ? _lastSender->name() :"0" );
++#endif
++
++  TQTimer::singleShot (0, TQT_TQOBJECT(this), TQT_SLOT(setTraceItemDelayed()));
++}
++
++void TopLevel::setTraceItemDelayed()
++{
++    if (!_traceItemDelayed) return;
++
++    switch(_traceItemDelayed->type()) {
++    case TraceItem::Function:
++    case TraceItem::FunctionCycle:
++      setFunction((TraceFunction*)_traceItemDelayed);
++      break;
++
++    case TraceItem::Object:
++    case TraceItem::File:
++    case TraceItem::Class:
++	setGroup((TraceCostItem*)_traceItemDelayed);
++	break;
++
++#if 0
++	// this conflicts with the selection policy of InstrView ?!?
++    case TraceItem::Instr:
++    case TraceItem::Line:
++	// only for multiview
++	_multiView->activate(_traceItemDelayed);
++	_multiView->updateView();
++	break;
++#endif
++
++    default: break;
++    }
++
++    _traceItemDelayed = 0;
++    _lastSender = 0;
++}
++
++/**
++ * A TraceData object cannot be viewed many times in different
++ * toplevel windows. Thus, this toplevel window takes ownership
++ * of the TraceData object: on closing the window or opening
++ * another trace, the object is destroyed.
++ */
++void TopLevel::setData(TraceData* data)
++{
++  if (data == _data) return;
++
++  _lastSender = 0;
++
++  saveTraceSettings();
++
++  if (_data) {
++    _partSelection->setData(0);
++    _stackSelection->setData(0);
++
++    _functionSelection->setData(0);
++    _functionSelection->updateView();
++    _multiView->setData(0);
++    _multiView->updateView();
++
++    // we are the owner...
++    delete _data;
++  }
++
++  // reset members
++  init();
++
++  _data = data;
++
++  // fill cost type list
++  TQStringList types;
++
++  if (_data) {
++      /* add all supported virtual types */
++      TraceCostMapping* m = _data->mapping();
++      m->addKnownVirtualTypes();
++
++      /* first, fill selection list with available cost types */
++      for (int i=0;i<m->realCount();i++)
++	  types << m->realType(i)->longName();
++      for (int i=0;i<m->virtualCount();i++)
++	  types << m->virtualType(i)->longName();
++  }
++  _saCost->setItems(types);
++  _saCost->setComboWidth(300);
++
++  if (types.count()>0) {
++    // second type list gets an additional "(Hidden)"
++    types.prepend(i18n("(Hidden)"));
++  }
++  _saCost2->setItems(types);
++  _saCost2->setComboWidth(300);
++  // default is hidden
++  if (types.count()>0)
++    _saCost2->setCurrentItem(0);
++
++  _partSelection->setData(_data);
++  _stackSelection->setData(_data);
++  _functionSelection->setData(_data);
++  _functionSelection->updateView();
++  _multiView->setData(_data);
++  _multiView->updateView();
++
++  /* this is needed to let the other widgets know the types */
++  restoreTraceTypes();
++
++  restoreTraceSettings();
++
++  TQString caption;
++  if (_data) {
++    caption = _data->traceName();
++    if (!_data->command().isEmpty())
++      caption += " [" + _data->command() + "]";
++  }
++  setCaption(caption);
++
++  if (!_data || (!_forcePartDock && _data->parts().count()<2)) {
++    _partDock->hide();
++    _partDockShown->setChecked(false);
++  }
++  else {
++    _partDock->show();
++    _partDockShown->setChecked(true);
++  }
++
++  updateStatusBar();
++}
++
++void TopLevel::addCostMenu(TQPopupMenu* popup, bool withCost2)
++{
++  if (_data) {
++    TQPopupMenu *popup1 = new TQPopupMenu(popup);
++    TQPopupMenu *popup2 = 0;
++    popup1->setCheckable(true);
++
++    if (withCost2) {
++      popup2 = new TQPopupMenu(popup);
++      popup2->setCheckable(true);
++
++      if (_costType2) {
++	popup2->insertItem(i18n("Hide"),199);
++	popup2->insertSeparator();
++      }
++    }
++
++    TraceCostMapping* m = _data->mapping();
++    TraceCostType* ct;
++    for (int i=0;i<m->realCount();i++) {
++      ct = m->realType(i);
++      popup1->insertItem(ct->longName(), 100+i);
++      if (_costType == ct) popup1->setItemChecked(100+i,true);
++      if (popup2) {
++	popup2->insertItem(ct->longName(), 100+i);
++	if (_costType2 == ct) popup2->setItemChecked(100+i,true);
++      }
++    }
++    for (int i=0;i<m->virtualCount();i++) {
++      ct = m->virtualType(i);
++      popup1->insertItem(ct->longName(), 200+i);
++      if (_costType == ct) popup1->setItemChecked(200+i,true);
++      if (popup2) {
++	popup2->insertItem(ct->longName(), 200+i);
++	if (_costType2 == ct) popup2->setItemChecked(200+i,true);
++      }
++    }
++    popup->insertItem(i18n("Primary Event Type"), popup1);
++    connect(popup1,TQT_SIGNAL(activated(int)),this,TQT_SLOT(setCostType(int)));
++    if (popup2) {
++      popup->insertItem(i18n("Secondary Event Type"), popup2);
++      connect(popup2,TQT_SIGNAL(activated(int)),this,TQT_SLOT(setCostType2(int)));
++    }
++  }
++  if (_showPercentage)
++    popup->insertItem(i18n("Show Absolute Cost"),
++		      TQT_TQOBJECT(this), TQT_SLOT(setAbsoluteCost()));
++  else
++    popup->insertItem(i18n("Show Relative Cost"),
++		      TQT_TQOBJECT(this), TQT_SLOT(setRelativeCost()));
++}
++
++bool TopLevel::setCostType(int id)
++{
++  if (!_data) return false;
++
++  TraceCostMapping* m = _data->mapping();
++  TraceCostType* ct=0;
++  if (id >=100 && id<199) ct = m->realType(id-100);
++  if (id >=200 && id<299) ct = m->virtualType(id-200);
++
++  return ct ? setCostType(ct) : false;
++}
++
++bool TopLevel::setCostType2(int id)
++{
++  if (!_data) return false;
++
++  TraceCostMapping* m = _data->mapping();
++  TraceCostType* ct=0;
++  if (id >=100 && id<199) ct = m->realType(id-100);
++  if (id >=200 && id<299) ct = m->virtualType(id-200);
++
++  return setCostType2(ct);
++}
++
++void TopLevel::addGoMenu(TQPopupMenu* popup)
++{
++  popup->insertItem(i18n("Go Back"), TQT_TQOBJECT(this), TQT_SLOT(goBack()));
++  popup->insertItem(i18n("Go Forward"), TQT_TQOBJECT(this), TQT_SLOT(goForward()));
++  popup->insertItem(i18n("Go Up"), TQT_TQOBJECT(this), TQT_SLOT(goUp()));
++}
++
++void TopLevel::goBack()
++{
++  setDirectionDelayed(TraceItemView::Back);
++}
++
++void TopLevel::goForward()
++{
++  setDirectionDelayed(TraceItemView::Forward);
++}
++
++void TopLevel::goUp()
++{
++  setDirectionDelayed(TraceItemView::Up);
++}
++
++TQString TopLevel::traceKey()
++{
++  if (!_data || _data->command().isEmpty()) return TQString();
++
++  TQString name = _data->command();
++  TQString key;
++  for (unsigned int l=0;l<name.length();l++)
++    if (name[l].isLetterOrNumber()) key += name[l];
++
++  return TQString("-") + key;
++}
++
++
++void TopLevel::restoreTraceTypes()
++{
++  TQString key = traceKey();
++
++  KConfigGroup cConfig(KGlobal::config(), TQCString("CurrentState"));
++  KConfigGroup pConfig(KGlobal::config(), TQCString("TracePositions"));
++
++  TQString groupType, costType, costType2;
++  groupType =  pConfig.readEntry(TQString("GroupType%1").arg(key));
++  costType  =  pConfig.readEntry(TQString("CostType%1").arg(key));
++  costType2 =  pConfig.readEntry(TQString("CostType2%1").arg(key));
++
++  if (groupType.isEmpty()) groupType = cConfig.readEntry("GroupType");
++  if (costType.isEmpty()) costType = cConfig.readEntry("CostType");
++  if (costType2.isEmpty()) costType2 = cConfig.readEntry("CostType2");
++
++  setGroupType(groupType);
++  setCostType(costType);
++  setCostType2(costType2);
++
++  // if still no cost type set, use first available
++  if (!_costType && !_saCost->items().isEmpty())
++      costTypeSelected(_saCost->items().first());
++
++  KConfigGroup aConfig(KGlobal::config(), TQCString("Layouts"));
++  _layoutCount = aConfig.readNumEntry(TQString("Count%1").arg(key), 0);
++  _layoutCurrent = aConfig.readNumEntry(TQString("Current%1").arg(key), 0);
++  if (_layoutCount == 0) layoutRestore();
++  updateLayoutActions();
++}
++
++
++/**
++ * This must be called after setting group/cost types in the function
++ * selection widget, because the group/function choosing depends on
++ * filled lists in the function selection widget
++ */
++void TopLevel::restoreTraceSettings()
++{
++  if (!_data) return;
++
++  TQString key = traceKey();
++
++  KConfigGroup pConfig(KGlobal::config(), TQCString("TracePositions"));
++  TQString group = pConfig.readEntry(TQString("Group%1").arg(key));
++  if (!group.isEmpty()) setGroup(group);
++
++  restoreCurrentState(key);
++
++  // restoreCurrentState() usually leads to a call to setTraceItemDelayed()
++  // to restore last active item...
++  if (!_traceItemDelayed) {
++    // function not available any more.. try with "main"
++    if (!setFunction("main"))
++      _functionSelection->setTopFunction();
++  }
++}
++
++
++/* Layout */
++
++void TopLevel::layoutDuplicate()
++{
++  // save current and allocate a new slot
++  _multiView->saveViewConfig(KGlobal::config(),
++			     TQString("Layout%1-MainView").arg(_layoutCurrent),
++			     traceKey(), false);
++  _layoutCurrent = _layoutCount;
++  _layoutCount++;
++
++  updateLayoutActions();
++
++  kdDebug() << "TopLevel::layoutDuplicate: count " << _layoutCount << endl;
++}
++
++void TopLevel::layoutRemove()
++{
++  if (_layoutCount <2) return;
++
++  int from = _layoutCount-1;
++  if (_layoutCurrent == from) { _layoutCurrent--; from--; }
++  // restore from last and decrement count
++  _multiView->readViewConfig(KGlobal::config(),
++			     TQString("Layout%1-MainView").arg(from),
++			     traceKey(), false);
++  _layoutCount--;
++
++  updateLayoutActions();
++}
++
++void TopLevel::layoutNext()
++{
++  if (_layoutCount <2) return;
++
++  KConfig* config = KGlobal::config();
++  TQString key = traceKey();
++
++  _multiView->saveViewConfig(config,
++			     TQString("Layout%1-MainView").arg(_layoutCurrent),
++			     key, false);
++  _layoutCurrent++;
++  if (_layoutCurrent == _layoutCount) _layoutCurrent = 0;
++
++  _multiView->readViewConfig(config,
++			     TQString("Layout%1-MainView").arg(_layoutCurrent),
++			     key, false);
++
++  if (0) kdDebug() << "TopLevel::layoutNext: current "
++		   << _layoutCurrent << endl;
++}
++
++void TopLevel::layoutPrevious()
++{
++  if (_layoutCount <2) return;
++
++  KConfig* config = KGlobal::config();
++  TQString key = traceKey();
++
++  _multiView->saveViewConfig(config,
++			     TQString("Layout%1-MainView").arg(_layoutCurrent),
++			     key, false);
++  _layoutCurrent--;
++  if (_layoutCurrent <0) _layoutCurrent = _layoutCount-1;
++
++  _multiView->readViewConfig(config,
++			     TQString("Layout%1-MainView").arg(_layoutCurrent),
++			     key, false);
++
++  if (0) kdDebug() << "TopLevel::layoutPrevious: current "
++		   << _layoutCurrent << endl;
++}
++
++void TopLevel::layoutSave()
++{
++  KConfig* config = KGlobal::config();
++  TQString key = traceKey();
++
++  _multiView->saveViewConfig(config,
++			     TQString("Layout%1-MainView").arg(_layoutCurrent),
++			     key, false);
++
++  for(int i=0;i<_layoutCount;i++) {
++    _multiView->readViewConfig(config,
++			       TQString("Layout%1-MainView").arg(i),
++			       key, false);
++    _multiView->saveViewConfig(config,
++			       TQString("Layout%1-MainView").arg(i),
++			       TQString(), false);
++  }
++
++  _multiView->readViewConfig(config,
++			     TQString("Layout%1-MainView").arg(_layoutCurrent),
++			     key, false);
++
++  KConfigGroup aConfig(config, TQCString("Layouts"));
++  aConfig.writeEntry("DefaultCount", _layoutCount);
++  aConfig.writeEntry("DefaultCurrent", _layoutCurrent);
++}
++
++void TopLevel::layoutRestore()
++{
++  KConfig* config = KGlobal::config();
++  KConfigGroup aConfig(config, TQCString("Layouts"));
++  _layoutCount = aConfig.readNumEntry("DefaultCount", 0);
++  _layoutCurrent = aConfig.readNumEntry("DefaultCurrent", 0);
++  if (_layoutCount == 0) {
++    _layoutCount++;
++    return;
++  }
++
++  TQString key = traceKey();
++  for(int i=0;i<_layoutCount;i++) {
++    _multiView->readViewConfig(config,
++			       TQString("Layout%1-MainView").arg(i),
++			       TQString(), false);
++    _multiView->saveViewConfig(config,
++			       TQString("Layout%1-MainView").arg(i),
++			       key, false);
++  }
++
++  _multiView->readViewConfig(config,
++			     TQString("Layout%1-MainView").arg(_layoutCurrent),
++			     key, false);
++
++  updateLayoutActions();
++}
++
++
++void TopLevel::updateLayoutActions()
++{
++  KAction* ka;
++
++  ka = actionCollection()->action("layout_next");
++  if (ka) ka->setEnabled(_layoutCount>1);
++
++  ka = actionCollection()->action("layout_previous");
++  if (ka) ka->setEnabled(_layoutCount>1);
++
++  ka = actionCollection()->action("layout_remove");
++  if (ka) ka->setEnabled(_layoutCount>1);
++
++  _statusbar->message(i18n("Layout Count: %1").arg(_layoutCount), 1000);
++}
++
++
++void TopLevel::updateStatusBar()
++{
++  if (!_data || _data->parts().count()==0) {
++    _statusLabel->setText(i18n("No profile data file loaded."));
++    return;
++  }
++
++  TQString status = TQString("%1 [%2] - ")
++                   .arg(_data->shortTraceName())
++                   .arg(_data->activePartRange());
++
++  if (_costType) {
++    status += i18n("Total %1 Cost: %2")
++      .arg(_costType->longName())
++      .arg(_data->prettySubCost(_costType));
++
++    /* this gets too long...
++    if (_costType2 && (_costType2 != _costType))
++      status += i18n(", %1 Cost: %2")
++	.arg(_costType2->longName())
++	.arg(_data->prettySubCost(_costType2));
++    */
++  }
++  else
++    status += i18n("No event type selected");
++
++  /* Not working... should give group of selected function
++  
++  if (_groupType != TraceItem::Function) {
++    status += TQString(" - %1 '%2'")
++              .arg(TraceItem::i18nTypeName(_groupType))
++              .arg(_group ? _group->prettyName() : i18n("(None)"));
++  }
++  */
++
++  _statusLabel->setText(status);
++}
++
++void TopLevel::configure()
++{
++  if (ConfigDlg::configure(Configuration::config(), _data, this)) {
++    Configuration::saveOptions(KGlobal::config());
++
++    configChanged();
++  }
++  else
++    Configuration::readOptions(KGlobal::config());
++}
++
++bool TopLevel::queryClose()
++{
++  saveTraceSettings();
++
++  return true;
++}
++
++bool TopLevel::queryExit()
++{
++    // save current toplevel options as defaults...
++    Configuration::setShowPercentage(_showPercentage);
++    Configuration::setShowExpanded(_showExpanded);
++    Configuration::setShowCycles(_showCycles);
++    Configuration::saveOptions(KGlobal::config());
++
++    saveCurrentState(TQString());
++
++  // save QT dock positions...
++
++  // We don't want to save the KToolbar position here.
++  // Its already stored.
++  delete toolBar();
++
++  KConfigGroup dockConfig(KGlobal::config(), TQCString("Docks"));
++  TQString str;
++  TQTextStream ts( &str, IO_WriteOnly );
++  ts << *this;
++#if 1
++  dockConfig.writeEntry("Position", str);
++#else
++  /* We store this with a localized key because for dock positions,
++   * QT uses the localized captions of docks.
++   * This way, when changing languages, you don't loose dock position
++   * settings.
++   * For the retrieval to work, we need to store a non-localized.
++   */
++  dockConfig.writeEntry("Position", str, true, false, true);
++#endif
++
++  // if part dock was chosen visible even for only 1 part loaded,
++  // keep this choice...
++  _forcePartDock = false;
++  if (_data && (_data->parts().count()<2) && _partDock->isVisible())
++    _forcePartDock=true;
++  dockConfig.writeEntry("ForcePartDockVisible", _forcePartDock);
++
++  return true;
++}
++
++
++void TopLevel::splitSlot()
++{
++    int count = _multiView->childCount();
++    if (count<1) count = 1;
++    if (count>2) count = 2;
++    count = 3-count;
++    _multiView->setChildCount(count);
++
++    _taSplit->setChecked(count>1);
++    _taSplitDir->setEnabled(count>1);
++    _taSplitDir->setChecked(_multiView->orientation() == Qt::Horizontal);
++}
++
++void TopLevel::splitDirSlot()
++{
++  _multiView->setOrientation( _taSplitDir->isChecked() ?
++                              Qt::Horizontal : Qt::Vertical );
++}
++
++
++
++// this is called after a config change in the dialog
++void TopLevel::configChanged()
++{
++  //qDebug("TopLevel::configChanged");
++  //_showPercentage->setChecked(Configuration::showPercentage());
++
++  // invalidate found/cached dirs of source files
++  _data->resetSourceDirs();
++
++  _partSelection->refresh();
++  _stackSelection->refresh();
++
++  _functionSelection->notifyChange(TraceItemView::configChanged);
++  _functionSelection->updateView();
++
++  _multiView->notifyChange(TraceItemView::configChanged);
++  _multiView->updateView();
++}
++
++void TopLevel::slotShowTipOnStart() {
++  KTipDialog::showTip(this);
++}
++
++void TopLevel::slotShowTip() {
++  KTipDialog::showTip( this, TQString(), true );
++}
++
++void TopLevel::dummySlot()
++{
++}
++
++void TopLevel::activePartsChangedSlot(const TracePartList& list)
++{
++  if (!_data) return;
++
++  if (!_data->activateParts(list)) {
++//    qDebug("TopLevel::activePartsChangedSlot: No Change!");
++    return;
++  }
++  _activeParts = list;
++
++  _partSelection->activePartsChangedSlot(list);
++
++  _multiView->set(list);
++  _multiView->updateView();
++
++  _functionSelection->set(list);
++  _functionSelection->updateView();
++
++  _stackSelection->refresh();
++
++  updateStatusBar();
++}
++
++void TopLevel::partsHideSelectedSlotDelayed()
++{
++  TQTimer::singleShot( 0, TQT_TQOBJECT(this), TQT_SLOT(partsHideSelectedSlot()) );
++}
++
++// this puts selected parts into hidden list,
++// deselects them and makes the remaining parts selected
++void TopLevel::partsHideSelectedSlot()
++{
++  if (!_data) return;
++
++  TracePart* part;
++  TracePartList newHidden, newActive;
++  TracePartList l = _data->parts();
++  for (part=l.first();part;part=l.next()) {
++    if ((_activeParts.findRef(part)>=0) ||
++        (_hiddenParts.findRef(part)>=0))
++      newHidden.append(part);
++    else
++      newActive.append(part);
++  }
++
++  _hiddenParts = newHidden;
++  _partSelection->hiddenPartsChangedSlot(_hiddenParts);
++
++#if 0
++  _mainWidget1->hiddenPartsChangedSlot(_hiddenParts);
++  _mainWidget2->hiddenPartsChangedSlot(_hiddenParts);
++#endif
++
++  activePartsChangedSlot(newActive);
++}
++
++void TopLevel::partsUnhideAllSlotDelayed()
++{
++  TQTimer::singleShot( 0, TQT_TQOBJECT(this), TQT_SLOT(partsUnhideAllSlot()) );
++}
++
++// this unhides all hidden parts. Does NOT change selection
++void TopLevel::partsUnhideAllSlot()
++{
++  if (!_data) return;
++
++  _hiddenParts.clear();
++  _partSelection->hiddenPartsChangedSlot(_hiddenParts);
++#if 0
++  _mainWidget1->hiddenPartsChangedSlot(_hiddenParts);
++  _mainWidget2->hiddenPartsChangedSlot(_hiddenParts);
++#endif
++}
++
++void TopLevel::forceTrace()
++{
++//  qDebug("forceTrace");
++
++  // Needs Callgrind now...
++  TQFile cmd("callgrind.cmd");
++  if (!cmd.exists()) {
++    cmd.open(IO_WriteOnly);
++    cmd.writeBlock("DUMP\n", 5);
++    cmd.close();
++  }
++  if (_taDump->isChecked())
++    TQTimer::singleShot( 1000, TQT_TQOBJECT(this), TQT_SLOT(forceTraceReload()) );
++  else {
++    // cancel request
++    cmd.remove();
++  }
++
++}
++
++void TopLevel::forceTraceReload()
++{
++//  qDebug("forceTraceReload");
++
++  TQFile cmd("callgrind.cmd");
++  if (cmd.exists()) {
++    if (_taDump->isChecked())
++      TQTimer::singleShot( 1000, TQT_TQOBJECT(this), TQT_SLOT(forceTraceReload()) );
++    return;
++  }
++  _taDump->setChecked(false);
++  reload();
++}
++
++void TopLevel::forwardAboutToShow()
++{
++  TQPopupMenu *popup = _paForward->popupMenu();
++
++  popup->clear();
++  StackBrowser* b = _stackSelection ? _stackSelection->browser() : 0;
++  HistoryItem* hi = b ? b->current() : 0;
++  TraceFunction* f;
++
++  if (!hi) {
++    popup->insertItem(i18n("(No Stack)"));
++    return;
++  }
++
++  hi = hi->next();
++  if (!hi) {
++    popup->insertItem(i18n("(No next function)"));
++    return;
++  }
++
++  int count = 1;
++  while (count<Configuration::maxSymbolCount() && hi) {
++    f = hi->function();
++    if (!f) break;
++
++    TQString name = f->prettyName();
++    if ((int)name.length()>Configuration::maxSymbolLength())
++      name = name.left(Configuration::maxSymbolLength()) + "...";
++
++    //qDebug("forward: Adding %s", name.ascii());
++    popup->insertItem(name, count);
++    hi = hi->next();
++    count++;
++  }
++}
++
++void TopLevel::backAboutToShow()
++{
++  TQPopupMenu *popup = _paBack->popupMenu();
++
++  popup->clear();
++  StackBrowser* b = _stackSelection ? _stackSelection->browser() : 0;
++  HistoryItem* hi = b ? b->current() : 0;
++  TraceFunction* f;
++
++  if (!hi) {
++    popup->insertItem(i18n("(No Stack)"));
++    return;
++  }
++
++  hi = hi->last();
++  if (!hi) {
++    popup->insertItem(i18n("(No previous function)"));
++    return;
++  }
++
++  int count = 1;
++  while (count<Configuration::maxSymbolCount() && hi) {
++    f = hi->function();
++    if (!f) break;
++
++    TQString name = f->prettyName();
++    if ((int)name.length()>Configuration::maxSymbolLength())
++      name = name.left(Configuration::maxSymbolLength()) + "...";
++
++    //qDebug("back: Adding %s", name.ascii());
++    popup->insertItem(name, count);
++    hi = hi->last();
++    count++;
++  }
++}
++
++void TopLevel::upAboutToShow()
++{
++  TQPopupMenu *popup = _paUp->popupMenu();
++
++  popup->clear();
++  StackBrowser* b = _stackSelection ? _stackSelection->browser() : 0;
++  HistoryItem* hi = b ? b->current() : 0;
++  TraceFunction* f = hi ? hi->function() : 0;
++
++  if (!f) {
++    popup->insertItem(i18n("(No Stack)"));
++    return;
++  }
++  f = hi->stack()->caller(f, false);
++  if (!f) {
++    popup->insertItem(i18n("(No Function Up)"));
++    return;
++  }
++
++  int count = 1;
++  while (count<Configuration::maxSymbolCount() && f) {
++    TQString name = f->prettyName();
++    if ((int)name.length()>Configuration::maxSymbolLength())
++      name = name.left(Configuration::maxSymbolLength()) + "...";
++
++    popup->insertItem(name, count);
++    f = hi->stack()->caller(f, false);
++    count++;
++  }
++
++}
++
++void TopLevel::forwardActivated(int id)
++{
++  //qDebug("forwardActivated: %d", id);
++
++  StackBrowser* b = _stackSelection ? _stackSelection->browser() : 0;
++  if (!b) return;
++
++  while (id>1) {
++    b->goForward();
++    id--;
++  }
++  _stackSelection->browserForward();
++}
++
++void TopLevel::backActivated(int id)
++{
++  //qDebug("backActivated: %d", id);
++
++  StackBrowser* b = _stackSelection ? _stackSelection->browser() : 0;
++  if (!b) return;
++
++  while (id>1) {
++    b->goBack();
++    id--;
++  }
++  _stackSelection->browserBack();
++}
++
++void TopLevel::upActivated(int id)
++{
++  //qDebug("upActivated: %d", id);
++
++  StackBrowser* b = _stackSelection ? _stackSelection->browser() : 0;
++  HistoryItem* hi = b ? b->current() : 0;
++  if (!hi) return;
++
++  TraceFunction* f = hi->function();
++
++  while (id>0 && f) {
++    f = hi->stack()->caller(f, false);
++    id--;
++  }
++
++  //qDebug("upActivated: %s", f ? f->prettyName().ascii() : "??" );
++  if (f)
++    setFunction(f);
++
++}
++
++void TopLevel::showMessage(const TQString& msg, int ms)
++{
++  if (_statusbar)
++    _statusbar->message(msg, ms);
++}
++
++void TopLevel::showStatus(TQString msg, int progress)
++{
++    static bool msgUpdateNeeded = true;
++
++    if (msg.isEmpty()) {
++	if (_progressBar) {
++	    _statusbar->removeWidget(_progressBar);
++	    delete _progressBar;
++	    _progressBar = 0;
++	}
++	_statusbar->clear();
++	_progressMsg = msg;
++	return;
++    }
++
++    if (_progressMsg.isEmpty())	_progressStart.start();
++
++    if (msg != _progressMsg) {
++	_progressMsg = msg;
++	msgUpdateNeeded = true;
++    }
++
++    // do nothing if last change was less than 0.5 seconds ago
++    if (_progressStart.elapsed() < 500) return;
++
++    if (!_progressBar) {
++	_progressBar = new TQProgressBar(_statusbar);
++	_progressBar->setMaximumSize(200, _statusbar->height()-4);
++	_statusbar->addWidget(_progressBar, 1, true);
++	_progressBar->show();
++	msgUpdateNeeded = true;
++    }
++
++    _progressStart.restart();
++
++    if (msgUpdateNeeded) {
++	_statusbar->message(msg);
++	msgUpdateNeeded = false;
++    }
++    _progressBar->setProgress(progress);
++
++    // let the progress bar update itself
++    TQEventLoop* l = tqApp->eventLoop();
++    if (l) l->processEvents(TQEventLoop::ExcludeUserInput);
++}
++
++#include "toplevel.moc"
+diff --git a/kdecachegrind/kdecachegrind/toplevel.h b/kdecachegrind/kdecachegrind/toplevel.h
+new file mode 100644
+index 0000000..10e7cde
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/toplevel.h
+@@ -0,0 +1,275 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * KCachegrind top level window
++ */
++
++#ifndef TOPLEVEL_H
++#define TOPLEVEL_H
++
++#include <tqdatetime.h>
++
++#include <dcopobject.h>
++#include <kmainwindow.h>
++
++#include "traceitemview.h"
++#include "tracedata.h"
++
++class MultiView;
++class TQLineEdit;
++class TQDockWidget;
++class TQLabel;
++class TQProgressBar;
++class TQPopupMenu;
++
++class KURL;
++class KSelectAction;
++class KToggleAction;
++class KToolBarPopupAction;
++
++class TraceData;
++class KRecentFilesAction;
++class MainWidget;
++class PartSelection;
++class FunctionSelection;
++class DumpSelection;
++class StackSelection;
++class TraceFunction;
++
++class TopLevel : public KMainWindow, public DCOPObject
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++  TopLevel(const char *name = 0);
++  ~TopLevel();
++
++  TraceData* data() { return _data; }
++  void setData(TraceData*);
++
++  virtual void saveProperties(KConfig*);
++  virtual void readProperties(KConfig*);
++
++  void createActions();
++  void createDocks();
++
++  TraceItem::CostType groupType() { return _groupType; }
++  TraceCostType* costType() { return _costType; }
++  TraceCostType* costType2() { return _costType2; }
++  TracePartList activeParts() { return _activeParts; }
++  TracePartList hiddenParts() { return _hiddenParts; }
++
++  // current config
++  bool showPercentage() const { return _showPercentage; }
++  bool showExpanded() const { return _showExpanded; }
++  bool showCycles() const { return _showCycles; }
++
++  /* convenience functions for often used context menu items */
++  void addCostMenu(TQPopupMenu*,bool);
++  void addGoMenu(TQPopupMenu*);
++
++public slots:
++  void newTrace();
++  void loadTrace();
++  void loadTrace(const KURL&);
++  void loadTrace(TQString);
++  void addTrace();
++  void addTrace(const KURL&);
++  void addTrace(TQString);
++
++  // for quick showing the main window...
++  void loadDelayed(TQString);
++
++  void reload();
++  void exportGraph();
++  void newWindow();
++  void configure();
++  void querySlot();
++  void dummySlot();
++
++  // layouts
++  void layoutDuplicate();
++  void layoutRemove();
++  void layoutNext();
++  void layoutPrevious();
++  void layoutSave();
++  void layoutRestore();
++  void updateLayoutActions();
++
++  void updateStatusBar();
++  void costTypeSelected(const TQString&);
++  void costType2Selected(const TQString&);
++  void groupTypeSelected(int);
++  void splitSlot();
++  void splitDirSlot();
++  void configureToolbars();
++  void configureKeys();
++  bool queryExit();
++  bool queryClose();
++  void togglePartDock();
++  void toggleStackDock();
++  void toggleFunctionDock();
++  void toggleDumpDock();
++  void toggleStatusBar();
++  void partVisibilityChanged(bool);
++  void dumpVisibilityChanged(bool);
++  void stackVisibilityChanged(bool);
++  void functionVisibilityChanged(bool);
++  void togglePercentage();
++  void setPercentage(bool);
++  void setAbsoluteCost();
++  void setRelativeCost();
++  void toggleExpanded();
++  void toggleCycles();
++  void forceTrace();
++  void forceTraceReload();
++  void forwardAboutToShow();
++  void backAboutToShow();
++  void upAboutToShow();
++  void forwardActivated(int);
++  void backActivated(int);
++  void upActivated(int);
++
++  bool setCostType(TraceCostType*);
++  bool setCostType2(TraceCostType*);
++  bool setCostType(TQString);
++  bool setCostType2(TQString);
++  bool setCostType(int);
++  bool setCostType2(int);
++  bool setGroupType(TraceItem::CostType);
++  bool setGroupType(TQString);
++  bool setGroup(TraceCostItem*);
++  bool setGroup(TQString);
++  bool setFunction(TraceFunction*);
++  bool setFunction(TQString);
++  void activePartsChangedSlot(const TracePartList& list);
++  void partsHideSelectedSlot();
++  void partsUnhideAllSlot();
++
++  /* These go back to mainloop first by using a timer.
++   * So they can be called from event handlers that
++   * aren't allowed to delete list entries.
++   */
++  void setCostTypeDelayed(TraceCostType*);
++  void setCostType2Delayed(TraceCostType*);
++  void setGroupTypeDelayed(TraceItem::CostType);
++  void setGroupDelayed(TraceCostItem*);
++  void setTraceItemDelayed(TraceItem*);
++  void partsHideSelectedSlotDelayed();
++  void partsUnhideAllSlotDelayed();
++  void goBack();
++  void goForward();
++  void goUp();
++  void setDirectionDelayed(TraceItemView::Direction);
++
++  /* SingleShot Slots (without parameters) for the delayed versions */
++  void setCostTypeDelayed();
++  void setCostType2Delayed();
++  void setGroupTypeDelayed();
++  void setGroupDelayed();
++  void setTraceItemDelayed();
++  void loadTraceDelayed();
++  void setDirectionDelayed();
++
++  // configuration has changed
++  void configChanged();
++
++  //void refresh();
++  void slotShowTipOnStart();
++  void slotShowTip();
++
++  // progress in status bar, empty message disables progress display
++  void showStatus(TQString msg, int progress);
++  void showMessage(const TQString&, int msec);
++
++private:
++  void init();
++  void createLayoutActions();
++  void createMiscActions();
++  void setupMainWidget(MainWidget*);
++  void setupPartSelection(PartSelection*);
++  void restoreCurrentState(TQString postfix);
++  void saveCurrentState(TQString postfix);
++  void saveTraceSettings();
++  TQString traceKey();
++  void restoreTraceTypes();
++  void restoreTraceSettings();
++
++  KStatusBar* _statusbar;
++  TQLabel* _statusLabel;
++  KRecentFilesAction* _openRecent;
++  bool _twoMainWidgets;
++  Qt::Orientation _spOrientation;
++
++  MultiView* _multiView;
++  FunctionSelection* _functionSelection;
++  DumpSelection* _dumpSelection;
++  PartSelection* _partSelection;
++  StackSelection* _stackSelection;
++  TQLineEdit* queryLineEdit;
++
++  TQDockWindow *_partDock, *_stackDock, *_functionDock, *_dumpDock;
++  bool _forcePartDock;
++
++  KSelectAction *_saCost, *_saCost2, *saGroup;
++  KToggleAction *_partDockShown, *_stackDockShown;
++  KToggleAction *_functionDockShown, *_dumpDockShown;
++  KToggleAction *_taPercentage, *_taExpanded, *_taCycles;
++  KToggleAction *_taDump, *_taSplit, *_taSplitDir;
++  KToolBarPopupAction *_paForward, *_paBack, *_paUp;
++
++  TraceFunction* _function;
++  const TQObject* _lastSender;
++
++  // trace data shown in this window
++  TraceData* _data;
++  // subcost types used for visualisation
++  TraceCostType* _costType;
++  TraceCostType* _costType2;
++  // grouping of function list
++  TraceItem::CostType _groupType;
++  // selected group
++  TraceCostItem* _group;
++  // selected parts
++  TracePartList _activeParts;
++  // hidden parts
++  TracePartList _hiddenParts;
++  // layouts
++  int _layoutCurrent, _layoutCount;
++
++  // for delayed slots
++  TraceCostType* _costTypeDelayed;
++  TraceCostType* _costType2Delayed;
++  TraceItem::CostType _groupTypeDelayed;
++  TraceCostItem* _groupDelayed;
++  TraceItem* _traceItemDelayed;
++  TQString _loadTraceDelayed;
++  TraceItemView::Direction _directionDelayed;
++
++  // for status progress display
++  TQString _progressMsg;
++  TQTime _progressStart;
++  TQProgressBar* _progressBar;
++
++  // toplevel configuration options
++  bool _showPercentage, _showExpanded, _showCycles;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/tracedata.cpp b/kdecachegrind/kdecachegrind/tracedata.cpp
+new file mode 100644
+index 0000000..f129c2e
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/tracedata.cpp
+@@ -0,0 +1,5068 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++
++#include <stdlib.h>
++
++#include <tqfile.h>
++#include <tqdir.h>
++#include <tqfileinfo.h>
++#include <tqregexp.h>
++
++#include <klocale.h>
++#include <kdebug.h>
++
++#include "tracedata.h"
++#include "toplevel.h"
++#include "loader.h"
++#include "configuration.h"
++#include "utils.h"
++#include "fixcost.h"
++
++
++#define TRACE_DEBUG      0
++#define TRACE_ASSERTIONS 0
++
++const int TraceCost::MaxRealIndex = MaxRealIndexValue;
++const int TraceCost::InvalidIndex = -1;
++
++//---------------------------------------------------
++// Addr
++
++bool Addr::set(FixString& s)
++{
++  return s.stripUInt64(_v); 
++}
++
++int Addr::set(const char *s)
++{
++  int n = 0;
++  _v = 0;
++
++  while((n<16) && *s) {
++    if ((*s>='0') && (*s<='9'))
++      _v = 16*_v + (*s-'0');
++    else if ((*s>='a') && (*s<='f'))
++      _v = 16*_v + 10 + (*s-'a');
++    else if ((*s>='A') && (*s<='F'))
++      _v = 16*_v + 10 + (*s-'A');    
++    else break;
++    s++;
++    n++;
++  }
++  
++  return n;
++}
++
++
++TQString Addr::toString() const
++{
++  if (_v == 0) return TQString("0");
++
++  uint64 n = _v;
++  TQString hex;
++  hex.reserve(16);
++
++  while(n>0) {
++    int d = (n & 15);
++    hex = TQChar((d<10) ? ('0'+d) : ('A'-10+d)) + hex;
++    n /= 16;
++  }
++
++  return hex;
++}
++
++TQString Addr::pretty() const
++{
++  if (_v == 0) return TQString("0");
++
++  uint64 n = _v;
++  int p = 0;
++  TQString hex;
++  hex.reserve(20);
++
++  while(n>0) {
++    int d = (n & 15);
++    if ((p>0) && ((p%4)==0)) hex = " " + hex;
++    hex = TQChar((d<10) ? ('0'+d) : ('A'-10+d)) + hex;
++    n /= 16;
++    p++;
++  }
++
++  return hex;
++}
++
++bool Addr::isInRange(Addr a, int distance)
++{
++  uint64 diff = (a._v > _v) ? (a._v - _v) : (_v - a._v);
++  uint64 dist = (distance<0) ? distance : -distance;
++  return (diff < dist);
++}
++
++//---------------------------------------------------
++// TraceItem
++
++TQString* TraceItem::_typeName = 0;
++TQString* TraceItem::_i18nTypeName = 0;
++
++TraceItem::TraceItem()
++{
++  _position = 0;
++  _dep = 0;
++  _dirty = true;
++}
++
++TraceItem::~TraceItem()
++{}
++
++void TraceItem::cleanup()
++{
++  if (_typeName) {
++    delete [] _typeName;
++    _typeName = 0;
++  }
++  if (_i18nTypeName) {
++    delete [] _i18nTypeName;
++    _i18nTypeName = 0;
++  }
++}
++
++TQString TraceItem::typeName(CostType t)
++{
++    if (!_typeName) {
++      _typeName = new TQString [MaxCostType+1];
++      TQString* strs = _typeName;
++      for(int i=0;i<=MaxCostType;i++)
++	strs[i] = TQString("?");
++
++       strs[Item] = I18N_NOOP("Abstract Item");
++       strs[Cost] = I18N_NOOP("Cost Item");
++       strs[PartLine] = I18N_NOOP("Part Source Line");
++       strs[Line] = I18N_NOOP("Source Line");
++       strs[PartLineCall] = I18N_NOOP("Part Line Call");
++       strs[LineCall] = I18N_NOOP("Line Call");
++       strs[PartLineJump] = I18N_NOOP("Part Jump");
++       strs[LineJump] = I18N_NOOP("Jump");
++       strs[PartInstr] = I18N_NOOP("Part Instruction");
++       strs[Instr] = I18N_NOOP("Instruction");
++       strs[PartInstrJump] = I18N_NOOP("Part Instruction Jump");
++       strs[InstrJump] = I18N_NOOP("Instruction Jump");
++       strs[PartInstrCall] = I18N_NOOP("Part Instruction Call");
++       strs[InstrCall] = I18N_NOOP("Instruction Call");
++       strs[PartCall] = I18N_NOOP("Part Call");
++       strs[Call] = I18N_NOOP("Call");
++       strs[PartFunction] = I18N_NOOP("Part Function");
++       strs[FunctionSource] = I18N_NOOP("Function Source File");
++       strs[Function] = I18N_NOOP("Function");
++       strs[FunctionCycle] = I18N_NOOP("Function Cycle");
++       strs[PartClass] = I18N_NOOP("Part Class");
++       strs[Class] = I18N_NOOP("Class");
++       strs[PartFile] = I18N_NOOP("Part Source File");
++       strs[File] = I18N_NOOP("Source File");
++       strs[PartObject] = I18N_NOOP("Part ELF Object");
++       strs[Object] = I18N_NOOP("ELF Object");
++       strs[Part] = I18N_NOOP("Profile Part");
++       strs[Data] = I18N_NOOP("Program Trace");
++    }
++    if (t<0 || t> MaxCostType) t = MaxCostType;
++    return _typeName[t];
++}
++
++TraceItem::CostType TraceItem::costType(TQString s)
++{
++  // This is the default cost Type
++  if (s.isEmpty()) return Function;
++
++  CostType type;
++  for (int i=0; i<MaxCostType;i++) {
++    type = (CostType) i;
++    if (typeName(type) == s)
++      return type;
++  }
++  return NoCostType;
++}
++
++// all strings of typeName() are translatable because of I18N_NOOP there
++TQString TraceItem::i18nTypeName(CostType t)
++{
++    if (!_i18nTypeName) {
++	_i18nTypeName = new TQString [MaxCostType+1];
++	for(int i=0;i<=MaxCostType;i++)
++	    _i18nTypeName[i] = i18n(typeName((CostType)i).utf8().data());
++    }
++    if (t<0 || t> MaxCostType) t = MaxCostType;
++    return _i18nTypeName[t];
++}
++
++TraceItem::CostType TraceItem::i18nCostType(TQString s)
++{
++  // This is the default cost Type
++  if (s.isEmpty()) return Function;
++
++  CostType type;
++  for (int i=0; i<MaxCostType;i++) {
++    type = (CostType) i;
++    if (i18nTypeName(type) == s)
++      return type;
++  }
++  return NoCostType;
++}
++
++
++void TraceItem::clear()
++{
++    invalidate();
++}
++
++
++TQString TraceItem::costString(TraceCostMapping*)
++{
++    return TQString("(no cost)");
++}
++
++TQString TraceItem::name() const
++{
++  if (part()) {
++    return i18n("%1 from %2")
++      .arg(_dep->name())
++      .arg(part()->name());
++  }
++
++  if (_dep)
++    return _dep->name();
++
++  return i18n("(unknown)");
++}
++
++TQString TraceItem::prettyName() const
++{
++    if (name().isEmpty()) return i18n("(unknown)");
++    return name();
++}
++
++
++TQString TraceItem::fullName() const
++{
++  return TQString("%1 %2")
++    .arg(typeName(type())).arg(prettyName());
++}
++
++TQString TraceItem::toString()
++{
++  return TQString("%1\n  [%3]").arg(fullName()).arg(costString(0));
++}
++
++void TraceItem::invalidate()
++{
++  if (_dirty) return;
++  _dirty = true;
++
++  if (_dep)
++    _dep->invalidate();
++}
++
++void TraceItem::update()
++{
++  _dirty = false;
++}
++
++TracePart* TraceItem::part()
++{
++  return _position ? _position->part() : 0; 
++}
++
++const TracePart* TraceItem::part() const
++{
++  return _position ? _position->part() : 0; 
++}
++
++TraceData* TraceItem::data()
++{
++  return _position ? _position->data() : 0;
++}
++
++const TraceData* TraceItem::data() const
++{
++  return _position ? _position->data() : 0; 
++}
++
++
++//---------------------------------------------------
++// TraceCost
++
++TraceCost::TraceCost()
++    : TraceItem()
++{
++  _cachedType = 0; // no virtual value cached
++
++  TraceCost::clear();
++}
++
++TraceCost::~TraceCost()
++{}
++
++
++void TraceCost::clear()
++{
++    // simple set usage count to 0
++    _count = 0;
++
++    TraceItem::clear();
++}
++
++
++
++void TraceCost::set(TraceSubMapping* sm, const char* s)
++{
++    if (!sm) return;
++    if (!s) {
++	if (_count>0) clear();
++	return;
++    }
++
++    while(*s == ' ') s++;
++
++    if (sm->isIdentity()) {
++	int i = 0;
++	while(i<sm->count()) {
++	    if (!_cost[i].set(&s)) break;
++	    i++;
++	}
++	_count = i;
++    }
++    else {
++	int i = 0, maxIndex = 0, index;
++	while(1) {
++	    index = sm->realIndex(i);
++	    if (maxIndex<index) maxIndex=index;
++	    if (index == TraceCost::InvalidIndex) break;
++	    if (!_cost[index].set(&s)) break;
++	    i++;
++	}
++	// we have to set all costs of unused indexes till maxIndex to zero
++	for(i=sm->firstUnused(); i<=maxIndex; i=sm->nextUnused(i))
++	    _cost[i] = 0;
++	_count = maxIndex;
++    }
++    // a cost change has to be propagated (esp. in subclasses)
++    invalidate();
++}
++
++void TraceCost::set(TraceSubMapping* sm, FixString & s)
++{
++    if (!sm) return;
++
++    s.stripSpaces();
++
++    if (sm->isIdentity()) {
++	int i = 0;
++	while(i<sm->count()) {
++	    if (!s.stripUInt64(_cost[i])) break;
++	    i++;
++	}
++	_count = i;
++    }
++    else {
++	int i = 0, maxIndex = 0, index;
++	while(1) {
++	    index = sm->realIndex(i);
++	    if (maxIndex<index) maxIndex=index;
++	    if (index == TraceCost::InvalidIndex) break;
++	    if (!s.stripUInt64(_cost[index])) break;
++	    i++;
++	}
++	// we have to set all costs of unused indexes till maxIndex to zero
++	for(i=sm->firstUnused(); i<=maxIndex; i=sm->nextUnused(i))
++	    _cost[i] = 0;
++	_count = maxIndex+1;
++    }
++    invalidate();
++}
++
++
++void TraceCost::addCost(TraceSubMapping* sm, const char* s)
++{
++    if (!sm || !s) return;
++
++    SubCost v;
++
++    if (sm->isIdentity()) {
++	int i = 0;
++	while(i<sm->count()) {
++	    if (!v.set(&s)) break;
++	    if (i<_count)
++		_cost[i] += v;
++	    else
++		_cost[i] = v;
++	    i++;
++	}
++	if (i > _count) _count = i;
++    }
++    else {
++	int i = 0, maxIndex = 0, index;
++	while(1) {
++	    if (!v.set(&s)) break;
++	    index = sm->realIndex(i);
++	    if (maxIndex<index) maxIndex=index;
++	    if (index == TraceCost::InvalidIndex) break;
++	    if (index<_count)
++		_cost[index] += v;
++	    else
++		_cost[index] = v;
++	    i++;
++	}
++	if (maxIndex >= _count) {
++	    /* we have to set all costs of unused indexes in the interval
++	     *  [_count;maxIndex] to zero */
++	    for(i=sm->nextUnused(_count-1); i<=maxIndex; i=sm->nextUnused(i))
++		_cost[i] = 0;
++	    _count = maxIndex+1;
++	}
++    }
++
++    // a cost change has to be propagated (esp. in subclasses)
++    invalidate();
++
++#if TRACE_DEBUG
++    _dirty = false; // don't recurse !
++    qDebug("%s\n now %s", fullName().ascii(),
++	   TraceCost::costString(0).ascii());
++    _dirty = true; // because of invalidate()
++#endif
++}
++
++void TraceCost::addCost(TraceSubMapping* sm, FixString & s)
++{
++    if (!sm) return;
++
++    s.stripSpaces();
++
++    SubCost v;
++
++    if (sm->isIdentity()) {
++	int i = 0;
++	while(i<sm->count()) {
++	    if (!s.stripUInt64(v)) break;
++	    if (i<_count)
++		_cost[i] += v;
++	    else
++		_cost[i] = v;
++	    i++;
++	}
++	if (i > _count) _count = i;
++    }
++    else {
++	int i = 0, maxIndex = 0, index;
++	while(1) {
++	    if (!s.stripUInt64(v)) break;
++	    index = sm->realIndex(i);
++	    if (maxIndex<index) maxIndex=index;
++	    if (index == TraceCost::InvalidIndex) break;
++	    if (index<_count)
++		_cost[index] += v;
++	    else
++		_cost[index] = v;
++	    i++;
++	}
++	if (maxIndex >= _count) {
++	    /* we have to set all costs of unused indexes in the interval
++	     *  [_count;maxIndex] to zero */
++	    for(i=sm->nextUnused(_count-1); i<=maxIndex; i=sm->nextUnused(i))
++		_cost[i] = 0;
++	    _count = maxIndex+1;
++	}
++    }
++
++    invalidate();
++
++#if TRACE_DEBUG
++    _dirty = false; // don't recurse !
++    qDebug("%s\n now %s", fullName().ascii(),
++	   TraceCost::costString(0).ascii());
++    _dirty = true; // because of invalidate()
++#endif
++}
++
++
++// update each subcost to be maximum of old and given costs
++void TraceCost::maxCost(TraceSubMapping* sm, FixString & s)
++{
++    if (!sm) return;
++
++    s.stripSpaces();
++
++    SubCost v;
++
++    if (sm->isIdentity()) {
++	int i = 0;
++	while(i<sm->count()) {
++	    if (!s.stripUInt64(v)) break;
++	    if (i<_count) {
++	      if (v>_cost[i]) _cost[i] = v;
++	    }
++	    else
++		_cost[i] = v;
++	    i++;
++	}
++	if (i > _count) _count = i;
++    }
++    else {
++	int i = 0, maxIndex = 0, index;
++	while(1) {
++	    if (!s.stripUInt64(v)) break;
++	    index = sm->realIndex(i);
++	    if (maxIndex<index) maxIndex=index;
++	    if (index == TraceCost::InvalidIndex) break;
++	    if (index<_count) {
++	      if (v>_cost[index]) _cost[index] = v;
++	    }
++	    else
++		_cost[index] = v;
++	    i++;
++	}
++	if (maxIndex >= _count) {
++	    /* we have to set all costs of unused indexes in the interval
++	     *  [_count;maxIndex] to zero */
++	    for(i=sm->nextUnused(_count-1); i<=maxIndex; i=sm->nextUnused(i))
++		_cost[i] = 0;
++	    _count = maxIndex+1;
++	}
++    }
++
++    invalidate();
++
++#if TRACE_DEBUG
++    _dirty = false; // don't recurse !
++    qDebug("%s\n now %s", fullName().ascii(),
++	   TraceCost::costString(0).ascii());
++    _dirty = true; // because of invalidate()
++#endif
++}
++
++
++void TraceCost::addCost(TraceCost* item)
++{
++    int i;
++
++    if (!item) return;
++
++    // we have to update the other item if needed
++    // because we access the item costs directly
++    if (item->_dirty) item->update();
++
++    if (item->_count < _count) {
++	for (i = 0; i<item->_count; i++)
++	    _cost[i] += item->_cost[i];
++    }
++    else {
++	for (i = 0; i<_count; i++)
++	    _cost[i] += item->_cost[i];
++	for (; i<item->_count; i++)
++	    _cost[i] = item->_cost[i];
++	_count = item->_count;
++    }
++
++    // a cost change has to be propagated (esp. in subclasses)
++    invalidate();
++
++#if TRACE_DEBUG
++    _dirty = false; // don't recurse !
++    qDebug("%s added cost item\n %s\n  now %s",
++	   fullName().ascii(), item->fullName().ascii(),
++	   TraceCost::costString(0).ascii());
++    _dirty = true; // because of invalidate()
++#endif
++}
++
++void TraceCost::maxCost(TraceCost* item)
++{
++    int i;
++
++    if (!item) return;
++
++    // we have to update the other item if needed
++    // because we access the item costs directly
++    if (item->_dirty) item->update();
++
++    if (item->_count < _count) {
++	for (i = 0; i<item->_count; i++)
++	  if (_cost[i] < item->_cost[i]) _cost[i] = item->_cost[i];
++    }
++    else {
++	for (i = 0; i<_count; i++)
++	  if (_cost[i] < item->_cost[i]) _cost[i] = item->_cost[i];
++	for (; i<item->_count; i++)
++	    _cost[i] = item->_cost[i];
++	_count = item->_count;
++    }
++
++    // a cost change has to be propagated (esp. in subclasses)
++    invalidate();
++
++#if TRACE_DEBUG
++    _dirty = false; // don't recurse !
++    qDebug("%s added cost item\n %s\n  now %s",
++	   fullName().ascii(), item->fullName().ascii(),
++	   TraceCost::costString(0).ascii());
++    _dirty = true; // because of invalidate()
++#endif
++}
++
++void TraceCost::addCost(int type, SubCost value)
++{
++    if (type<0 || type>=MaxRealIndex) return;
++    if (type<_count)
++	_cost[type] += value;
++    else {
++	for(int i=_count;i<type;i++)
++	    _cost[i] = 0;
++	_cost[type] = value;
++	_count = type+1;
++    }
++
++    // a cost change has to be propagated (esp. in subclasses)
++    invalidate();
++}
++
++void TraceCost::maxCost(int type, SubCost value)
++{
++    if (type<0 || type>=MaxRealIndex) return;
++    if (type<_count) {
++      if (value>_cost[type]) _cost[type] = value;
++    }
++    else {
++	for(int i=_count;i<type;i++)
++	    _cost[i] = 0;
++	_cost[type] = value;
++	_count = type+1;
++    }
++
++    // a cost change has to be propagated (esp. in subclasses)
++    invalidate();
++}
++
++
++TraceCost TraceCost::diff(TraceCost* item)
++{
++  TraceCost res;
++
++  // we have to update the other item if needed
++  // because we access the item costs directly
++  if (item->_dirty) item->update();
++
++  int maxCount = (item->_count > _count) ? item->_count : _count;
++
++  res._count = maxCount;
++  for (int i=0; i<maxCount;i++)
++    res._cost[i] = item->subCost(i) - subCost(i);
++
++  return res;
++}
++
++TQString TraceCost::costString(TraceCostMapping* m)
++{
++  TQString res;
++
++  if (_dirty) update();
++
++  int maxIndex = m ? m->realCount() : TraceCost::MaxRealIndex;
++  for (int i = 0; i<maxIndex; i++) {
++    if (!res.isEmpty()) res += ", ";
++    if (m) res += m->type(i)->name() + " ";
++
++    res += subCost(i).pretty();
++  }
++  return res;
++}
++
++
++void TraceCost::invalidate()
++{
++  if (_dirty) return;
++  _dirty = true;
++  _cachedType = 0; // cached value is invalid, too
++
++  if (_dep)
++    _dep->invalidate();
++}
++
++void TraceCost::update()
++{
++  _dirty = false;
++}
++
++// this is only for real types
++SubCost TraceCost::subCost(int idx)
++{
++    if (idx<0) return 0;
++
++    /* update if needed as cost could be calculated dynamically in subclasses
++     * this can change _count !! */
++    if (_dirty) update();
++    if (idx>=_count) return 0;
++
++    return _cost[idx];
++}
++
++SubCost TraceCost::subCost(TraceCostType* t)
++{
++  if (!t) return 0;
++  if (_cachedType != t) {
++      _cachedType = t;
++      _cachedCost = t->subCost(this);
++  }
++  return _cachedCost;
++}
++
++TQString TraceCost::prettySubCost(TraceCostType* t)
++{
++    return subCost(t).pretty();
++}
++
++
++
++//---------------------------------------------------
++// TraceJumpCost
++
++TraceJumpCost::TraceJumpCost()
++    :TraceItem()
++{
++    TraceJumpCost::clear();
++}
++
++TraceJumpCost::~TraceJumpCost()
++{}
++
++SubCost TraceJumpCost::executedCount()
++{
++    if (_dirty) update();
++
++    return _executedCount;
++}
++
++SubCost TraceJumpCost::followedCount()
++{
++    if (_dirty) update();
++
++    return _followedCount;
++}
++
++TQString TraceJumpCost::costString(TraceCostMapping*)
++{
++  if (_dirty) update();
++
++  return TQString("%1/%2")
++      .arg(_followedCount.pretty())
++      .arg(_executedCount.pretty());
++}
++
++void TraceJumpCost::clear()
++{
++    _followedCount = 0;
++    _executedCount = 0;
++}
++
++void TraceJumpCost::addCost(TraceJumpCost* item)
++{
++    if (item->_dirty) item->update();
++
++    _followedCount += item->followedCount();
++    _executedCount += item->executedCount();
++}
++
++
++//---------------------------------------------------
++// TraceCostType
++
++TQPtrList<TraceCostType>* TraceCostType::_knownTypes = 0;
++
++TraceCostType::TraceCostType(TQString name,  TQString longName, TQString formula)
++{
++  _name = name;
++  _longName = longName;
++  _formula = formula;
++  _mapping = 0;
++  _realIndex = TraceCost::InvalidIndex;
++  _parsed = false;
++  _inParsing = false;
++
++  for (int i=0; i<TraceCost::MaxRealIndex;i++)
++    _coefficient[i] = 0;
++}
++
++void TraceCostType::setFormula(TQString formula)
++{
++  _formula = formula;
++  _realIndex = TraceCost::InvalidIndex;
++  _parsed = false;
++}
++
++void TraceCostType::setMapping(TraceCostMapping* m)
++{
++  _parsed = false;
++  _mapping = m;
++}
++
++// setting the index to TraceCost::MaxRealIndex makes it a
++// real type with unspecified index
++void TraceCostType::setRealIndex(int i)
++{
++  if (i<0 || i>TraceCost::MaxRealIndex)
++    i=TraceCost::InvalidIndex;
++
++  _realIndex = i;
++  _formula = TQString();
++}
++
++// checks for existing types and sets coefficients
++bool TraceCostType::parseFormula()
++{
++  if (_parsed) return true;
++  if (_inParsing) {
++    qDebug("TraceCostType::parseFormula: Recursion detected.");
++    return false;
++  }
++
++  if (!_mapping) {
++    qDebug("TraceCostType::parseFormula: No mapping set!");
++    return false;
++  }
++
++  _inParsing = true;
++
++  for (int i=0; i<TraceCost::MaxRealIndex;i++)
++    _coefficient[i] = 0;
++
++  TQRegExp rx( "((?:\\+|\\-)?)\\s*(\\d*)\\s*\\*?\\s*(\\w+)" );
++
++  int factor, pos;
++  TQString costName;
++  TraceCostType* costType;
++
++  pos = 0;
++  while (1) {
++    pos = rx.search(_formula, pos);
++    if (pos<0) break;
++    pos += rx.matchedLength();
++    if (rx.cap(0).isEmpty()) break;
++
++    //qDebug("parseFormula: matched '%s','%s','%s'",
++    //       rx.cap(1).ascii(), rx.cap(2).ascii(), rx.cap(3).ascii());
++
++    costName = rx.cap(3);
++    costType = _mapping->type(costName);
++    if (!costType) {
++	// qDebug("Cost type '%s': In formula cost '%s' unknown.",
++        //     _name.ascii(), costName.ascii());
++
++	_inParsing = false;
++	return false;
++    }
++
++    factor = (rx.cap(2).isEmpty()) ? 1 : rx.cap(2).toInt();
++    if (rx.cap(1) == "-") factor = -factor;
++
++    if (costType->isReal())
++      _coefficient[costType->realIndex()] += factor;
++    else {
++      costType->parseFormula();
++      for (int i=0; i<TraceCost::MaxRealIndex;i++)
++        _coefficient[i] += factor * costType->_coefficient[i];
++    }
++  }
++
++  _inParsing = false;
++  _parsed = true;
++
++  return true;
++}
++
++TQString TraceCostType::parsedFormula()
++{
++  TQString res;
++
++  if (!parseFormula()) return res;
++
++  for (int i=0; i<TraceCost::MaxRealIndex;i++) {
++    int c = _coefficient[i];
++    if (c == 0) continue;
++
++    if (!res.isEmpty()) {
++      res += " ";
++      if (c>0) res += "+ ";
++    }
++    if (c<0) { res += "- "; c = -c; }
++    res += TQString::number(c);
++
++    TraceCostType* t = _mapping->type(i);
++    if (!t) continue;
++
++    if (!t->name().isEmpty())
++      res += TQString(" * %1").arg(t->name());
++  }
++
++  return res;
++}
++
++SubCost TraceCostType::subCost(TraceCost* c)
++{
++  if (_realIndex != TraceCost::InvalidIndex)
++    return c->subCost(_realIndex);
++
++  if (!_parsed) {
++    if (!parseFormula()) return 0;
++  }
++  SubCost res = 0;
++
++  int rc = _mapping->realCount();
++  for (int i = 0;i<rc;i++)
++    if (_coefficient[i] != 0)
++      res += _coefficient[i] * c->subCost(i);
++
++  return res;
++}
++
++int TraceCostType::histCost(TraceCost* c, double total, double* hist)
++{
++  if (total == 0.0) return 0;
++
++  if (!_parsed) {
++    if (!parseFormula()) return 0;
++  }
++
++  int rc = _mapping->realCount();
++  for (int i = 0;i<rc;i++) {
++    if (_coefficient[i] != 0)
++      hist[i] = _coefficient[i] * c->subCost(i) / total;
++    else
++      hist[i] = 0.0;
++  }
++
++  return rc;
++}
++
++
++
++
++TraceCostType* TraceCostType::knownRealType(TQString n)
++{
++  if (!_knownTypes) return 0;
++
++  TraceCostType* t;
++  for (t=_knownTypes->first();t;t=_knownTypes->next())
++    if (t->isReal() && (t->name() == n)) {
++      TraceCostType* type = new TraceCostType(*t);
++      return type;
++    }
++
++  return 0;
++}
++
++TraceCostType* TraceCostType::knownVirtualType(TQString n)
++{
++  if (!_knownTypes) return 0;
++
++  TraceCostType* t;
++  for (t=_knownTypes->first();t;t=_knownTypes->next())
++    if (!t->isReal() && (t->name() == n)) {
++      TraceCostType* type = new TraceCostType(*t);
++      return type;
++    }
++
++  return 0;
++}
++
++// we take ownership
++void TraceCostType::add(TraceCostType* t)
++{
++  if (!t) return;
++
++  t->setMapping(0);
++
++  if (!_knownTypes)
++    _knownTypes = new TQPtrList<TraceCostType>;
++
++  /* Already known? */
++  TraceCostType* kt;
++  for (kt=_knownTypes->first();kt;kt=_knownTypes->next())
++    if (kt->name() == t->name()) break;
++
++  if (kt) {
++    // Overwrite old type
++    if (!t->longName().isEmpty() &&
++	(t->longName() != t->name())) kt->setLongName(t->longName());
++    if (!t->formula().isEmpty()) kt->setFormula(t->formula());
++
++    delete t;
++  }
++  else {
++    if (t->longName().isEmpty()) t->setLongName(t->name());
++    _knownTypes->append(t);
++  }
++}
++
++
++int TraceCostType::knownTypeCount()
++{
++  if (!_knownTypes) return 0;
++
++  return _knownTypes->count();
++}
++
++bool TraceCostType::remove(TQString n)
++{
++  if (!_knownTypes) return false;
++
++  TraceCostType* t;
++  for (t=_knownTypes->first();t;t=_knownTypes->next())
++    if (!t->isReal() && (t->name() == n)) {
++      _knownTypes->removeRef(t);
++      delete t;
++      return true;
++    }
++
++  return false;
++}
++
++TraceCostType* TraceCostType::knownType(int i)
++{
++  if (!_knownTypes) return 0;
++  if (i<0 || i>=(int)_knownTypes->count()) return 0;
++
++  return _knownTypes->at(i);
++}
++
++TQColor TraceCostType::color()
++{
++  if (!_mapping) return TQColor();
++  return _mapping->realColors()[_realIndex];
++}
++
++
++//---------------------------------------------------
++// TraceCostMapping
++
++TraceCostMapping::TraceCostMapping()
++{
++  _realCount = 0;
++  _virtualCount = 0;
++  for (int i=0;i<TraceCost::MaxRealIndex;i++) _real[i] = 0;
++  for (int i=0;i<TraceCost::MaxRealIndex;i++) _virtual[i] = 0;
++}
++
++TraceCostMapping::~TraceCostMapping()
++{
++  for (int i=0;i<TraceCost::MaxRealIndex;i++)
++    if (_real[i]) delete _real[i];
++
++  for (int i=0;i<TraceCost::MaxRealIndex;i++)
++    if (_virtual[i]) delete _virtual[i];
++}
++
++TraceSubMapping* TraceCostMapping::subMapping(TQString types, bool create)
++{
++  // first check if there's enough space in the mapping
++  int newCount = 0;
++  int pos = 0, pos2, len = types.length();
++
++  while (1) {
++    // skip space
++    while((pos<len) && types[pos].isSpace()) pos++;
++
++    pos2 = pos;
++    while((pos2<len) && !types[pos2].isSpace()) pos2++;
++    if (pos2 == pos) break;
++
++    if (realIndex(types.mid(pos,pos2-pos)) == TraceCost::InvalidIndex)
++      newCount++;
++
++    pos = pos2;
++  }
++
++  if (!create && (newCount>0)) return 0;
++
++  if (newCount+_realCount > TraceCost::MaxRealIndex) {
++    kdDebug() << "TraceCostMapping::subMapping: No space for " 
++	      << newCount << " sub costs." << endl;
++    return 0;
++  }
++
++  TraceSubMapping* sm = new TraceSubMapping(this);
++
++  pos = 0;
++  while (1) {
++    // skip space
++    while((pos<len) && types[pos].isSpace()) pos++;
++
++    pos2 = pos;
++    while((pos2<len) && !types[pos2].isSpace()) pos2++;
++    if (pos2 == pos) break;
++
++    sm->append(addReal(types.mid(pos,pos2-pos)));
++
++    pos = pos2;
++  }
++
++  return sm;
++}
++
++
++int TraceCostMapping::addReal(TQString t)
++{
++  int index = realIndex(t);
++  if (index>=0) return index;
++
++  TraceCostType* ct = TraceCostType::knownRealType(t);
++  if (!ct) ct = new TraceCostType(t, t);
++
++  // make it real
++  ct->setRealIndex();
++
++  return add(ct);
++}
++
++// add a cost type to a mapping
++// this transfers ownership of the type!
++int TraceCostMapping::add(TraceCostType* ct)
++{
++  if (!ct) return TraceCost::InvalidIndex;
++
++  ct->setMapping(this);
++
++  if (ct->isReal()) {
++    if (_realCount >= TraceCost::MaxRealIndex) {
++      qDebug("WARNING: Maximum for real cost types reached (on adding '%s')",
++             ct->name().ascii());
++      return TraceCost::InvalidIndex;
++    }
++    _real[_realCount] = ct;
++    ct->setRealIndex(_realCount);
++    _realColor[_realCount] = Configuration::costTypeColor(ct);
++
++    _realCount++;
++    return _realCount-1;
++  }
++
++  if (_virtualCount >= TraceCost::MaxRealIndex) {
++    qDebug("WARNING: Maximum for virtual cost types reached (on adding '%s')",
++           ct->name().ascii());
++    return TraceCost::InvalidIndex;
++  }
++  _virtual[_virtualCount] = ct;
++  _virtualCount++;
++  return _virtualCount-1;
++}
++
++// we delete the type: t is invalid when returning true!
++bool TraceCostMapping::remove(TraceCostType* t)
++{
++  if (!t) return false;
++  if (t->mapping() != this) return false;
++
++  // don't delete real types
++  if (t->isReal()) return false;
++
++  int i;
++  for(i=0;i<_virtualCount;i++)
++    if (_virtual[i] == t) break;
++  
++  // not found?
++  if (i == _virtualCount) return false;
++
++  // delete known type with same name
++  TraceCostType::remove(t->name());
++
++  // delete this type
++  _virtual[i] = 0;
++  delete t;
++  if (i+1 == _virtualCount) {
++    // we can reuse the last index
++    _virtualCount--;
++  }
++  return true;
++}
++
++
++TraceCostType* TraceCostMapping::realType(int t)
++{
++  if (t<0 || t>=_realCount) return 0;
++  return _real[t];
++}
++
++TraceCostType* TraceCostMapping::virtualType(int t)
++{
++  if (t<0 || t>=_virtualCount) return 0;
++  return _virtual[t];
++}
++
++
++TraceCostType* TraceCostMapping::type(int t)
++{
++  if (t<0) return 0;
++  if (t<_realCount) return _real[t];
++
++  t -= TraceCost::MaxRealIndex;
++  if (t<0) return 0;
++  if (t<_virtualCount) return _virtual[t];
++
++  return 0;
++}
++
++TraceCostType* TraceCostMapping::type(TQString name)
++{
++  for (int i=0;i<_realCount;i++)
++    if (_real[i] && (_real[i]->name() == name))
++      return _real[i];
++
++  for (int i=0;i<_virtualCount;i++)
++    if (_virtual[i] && (_virtual[i]->name() == name))
++      return _virtual[i];
++
++  return 0;
++}
++
++TraceCostType* TraceCostMapping::typeForLong(TQString name)
++{
++  for (int i=0;i<_realCount;i++)
++    if (_real[i] && (_real[i]->longName() == name))
++      return _real[i];
++
++  for (int i=0;i<_virtualCount;i++)
++    if (_virtual[i] && (_virtual[i]->longName() == name))
++      return _virtual[i];
++
++  return 0;
++}
++
++
++int TraceCostMapping::realIndex(TQString name)
++{
++  for (int i=0;i<_realCount;i++)
++    if (_real[i] && (_real[i]->name() == name))
++      return i;
++
++  return TraceCost::InvalidIndex;
++}
++
++int TraceCostMapping::index(TQString name)
++{
++  for (int i=0;i<_realCount;i++)
++    if (_real[i] && (_real[i]->name() == name))
++      return i;
++
++  for (int i=0;i<_virtualCount;i++)
++    if (_virtual[i] && (_virtual[i]->name() == name))
++      return TraceCost::MaxRealIndex + 1 + i;
++
++  return TraceCost::InvalidIndex;
++}
++
++int TraceCostMapping::addKnownVirtualTypes()
++{
++  int addCount = 0;
++  int addDiff, i;
++  int knownCount = TraceCostType::knownTypeCount();
++
++  while (1) {
++    addDiff = 0;
++    for (i=0; i<knownCount; i++) {
++      TraceCostType* t = TraceCostType::knownType(i);
++      if (t->isReal()) continue;
++      if (index(t->name()) != TraceCost::InvalidIndex) continue;
++      t->setMapping(this);
++      if (t->parseFormula()) {
++        addDiff++;
++        add(new TraceCostType(t->name(), t->longName(), t->formula()));
++      }
++      t->setMapping(0);
++    }
++    if (addDiff == 0) break;
++    addCount += addDiff;
++  }
++  return addCount;
++}
++
++
++//---------------------------------------------------
++// TraceSubMapping
++
++TraceSubMapping::TraceSubMapping(TraceCostMapping* mapping)
++{
++  _mapping = mapping;
++  clear();
++}
++
++void TraceSubMapping::clear()
++{
++  _count = 0;
++  _isIdentity = true;
++  _firstUnused = 0;
++  for(int i=0;i<TraceCost::MaxRealIndex;i++) {
++    _realIndex[i] = TraceCost::InvalidIndex;
++    _nextUnused[i] = i+1;
++  }
++}
++
++bool TraceSubMapping::append(TQString type, bool create)
++{
++  if (!_mapping) return false;
++  int index = create ? _mapping->addReal(type) : _mapping->realIndex(type);
++
++  return append(index);
++}
++
++bool TraceSubMapping::append(int type)
++{
++  if (!_mapping) return false;
++  if ((type<0) || (type >= _mapping->realCount())) return false;
++
++  if ( _count >=  TraceCost::MaxRealIndex) return false;
++
++  _realIndex[_count] = type;
++
++  if (_isIdentity && (_count != type)) _isIdentity = false;
++  if (type == _firstUnused)
++      _firstUnused = _nextUnused[type];
++  for(int i=0;i<type;i++)
++      if (_nextUnused[i] == type)
++	  _nextUnused[i]=_nextUnused[type];
++
++  _count++;
++  return true;
++}
++
++
++//---------------------------------------------------
++// TraceCallCost
++
++TraceCallCost::TraceCallCost()
++{
++  _callCount = 0;
++}
++
++TraceCallCost::~TraceCallCost()
++{}
++
++
++TQString TraceCallCost::costString(TraceCostMapping* m)
++{
++  return TQString("%1, Calls %2")
++      .arg(TraceCost::costString(m))
++      .arg(_callCount.pretty());
++}
++
++TQString TraceCallCost::prettyCallCount()
++{
++  return _callCount.pretty();
++}
++
++void TraceCallCost::clear()
++{
++  _callCount = 0;
++  TraceCost::clear();
++}
++
++SubCost TraceCallCost::callCount()
++{
++  if (_dirty) update();
++
++  return _callCount;
++}
++
++void TraceCallCost::addCallCount(SubCost c)
++{
++  _callCount += c;
++
++  invalidate();
++}
++
++
++//---------------------------------------------------
++// TraceInclusiveCost
++
++TraceInclusiveCost::TraceInclusiveCost()
++{}
++
++TraceInclusiveCost::~TraceInclusiveCost()
++{}
++
++TQString TraceInclusiveCost::costString(TraceCostMapping* m)
++{
++  return TQString("%1, Inclusive %2")
++    .arg(TraceCost::costString(m))
++    .arg(_inclusive.costString(m));
++}
++
++void TraceInclusiveCost::clear()
++{
++  _inclusive.clear();
++  TraceCost::clear();
++}
++
++TraceCost* TraceInclusiveCost::inclusive()
++{
++  if (_dirty) update();
++
++  return &_inclusive;
++}
++
++void TraceInclusiveCost::addInclusive(TraceCost* c)
++{
++  _inclusive.addCost(c);
++
++  invalidate();
++}
++
++
++//---------------------------------------------------
++// TraceListCost
++
++TraceListCost::TraceListCost()
++{
++  _lastDep = 0;
++}
++
++TraceListCost::~TraceListCost()
++{}
++
++void TraceListCost::addDep(TraceCost* dep)
++{
++#if TRACE_ASSERTIONS
++  if (_deps.findRef(dep)>=0) {
++    qDebug("addDep: %s already in list!",
++           dep->fullName().ascii());
++    return;
++  }
++#endif
++
++  _deps.append(dep);
++  _lastDep = dep;
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added\n %s (now %d)",
++         fullName().ascii(), dep->fullName().ascii(),
++         _deps.count());
++#endif
++}
++
++TraceCost* TraceListCost::findDepFromPart(TracePart* part)
++{
++  if (_lastDep && _lastDep->part() == part)
++    return _lastDep;
++
++  TraceCost* dep;
++  for (dep = _deps.first(); dep; dep = _deps.next())
++    if (dep->part() == part) {
++      _lastDep = dep;
++      return dep;
++    }
++  return 0;
++}
++
++
++void TraceListCost::update()
++{
++  if (!_dirty) return;
++
++#if TRACE_DEBUG
++  qDebug("update %s (count %d)",
++         fullName().ascii(), _deps.count());
++#endif
++
++  clear();
++  TraceCost* item;
++  for (item = _deps.first(); item; item = _deps.next()) {
++    if (onlyActiveParts())
++      if (!item->part() || !item->part()->isActive()) continue;
++
++    addCost(item);
++  }
++
++  _dirty = false;
++
++#if TRACE_DEBUG
++  qDebug("   > %s", costString(0).ascii());
++#endif
++}
++
++
++
++//---------------------------------------------------
++// TraceJumpListCost
++
++TraceJumpListCost::TraceJumpListCost()
++{
++  _lastDep = 0;
++}
++
++TraceJumpListCost::~TraceJumpListCost()
++{}
++
++void TraceJumpListCost::addDep(TraceJumpCost* dep)
++{
++#if TRACE_ASSERTIONS
++  if (_deps.findRef(dep)>=0) {
++    qDebug("addDep: %s already in list!",
++           dep->fullName().ascii());
++    return;
++  }
++#endif
++
++  _deps.append(dep);
++  _lastDep = dep;
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added\n %s (now %d)",
++         fullName().ascii(), dep->fullName().ascii(),
++         _deps.count());
++#endif
++}
++
++TraceJumpCost* TraceJumpListCost::findDepFromPart(TracePart* part)
++{
++  if (_lastDep && _lastDep->part() == part)
++    return _lastDep;
++
++  TraceJumpCost* dep;
++  for (dep = _deps.first(); dep; dep = _deps.next())
++    if (dep->part() == part) {
++      _lastDep = dep;
++      return dep;
++    }
++  return 0;
++}
++
++
++void TraceJumpListCost::update()
++{
++  if (!_dirty) return;
++
++#if TRACE_DEBUG
++  qDebug("update %s (count %d)",
++         fullName().ascii(), _deps.count());
++#endif
++
++  clear();
++  TraceJumpCost* item;
++  for (item = _deps.first(); item; item = _deps.next()) {
++    if (onlyActiveParts())
++      if (!item->part() || !item->part()->isActive()) continue;
++
++    addCost(item);
++  }
++
++  _dirty = false;
++
++#if TRACE_DEBUG
++  qDebug("   > %s", costString(0).ascii());
++#endif
++}
++
++
++
++//---------------------------------------------------
++// TraceCallListCost
++
++TraceCallListCost::TraceCallListCost()
++{
++  _lastDep = 0;
++}
++
++TraceCallListCost::~TraceCallListCost()
++{}
++
++void TraceCallListCost::addDep(TraceCallCost* dep)
++{
++#if TRACE_ASSERTIONS
++  if (_deps.findRef(dep)>=0) {
++    qDebug("addDep: %s already in list!",
++           dep->fullName().ascii());
++    return;
++  }
++#endif
++
++  _deps.append(dep);
++  _lastDep = dep;
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added\n %s (now %d)",
++         fullName().ascii(), dep->fullName().ascii(),
++         _deps.count());
++#endif
++}
++
++TraceCallCost* TraceCallListCost::findDepFromPart(TracePart* part)
++{
++  if (_lastDep && _lastDep->part() == part)
++    return _lastDep;
++
++  TraceCallCost* dep;
++  for (dep = _deps.first(); dep; dep = _deps.next())
++    if (dep->part() == part) {
++      _lastDep = dep;
++      return dep;
++    }
++  return 0;
++}
++
++
++void TraceCallListCost::update()
++{
++  if (!_dirty) return;
++
++#if TRACE_DEBUG
++  qDebug("update %s (count %d)",
++         fullName().ascii(), _deps.count());
++#endif
++
++  /* Without dependent cost items, assume fixed costs,
++   * i.e. don't change cost */
++  if (_deps.count()>0) {
++    clear();
++    TraceCallCost* item;
++    for (item = _deps.first(); item; item = _deps.next()) {
++      if (onlyActiveParts())
++	if (!item->part() || !item->part()->isActive()) continue;
++      
++      addCost(item);
++      addCallCount(item->callCount());
++    }
++  }
++
++  _dirty = false;
++
++#if TRACE_DEBUG
++  qDebug("   > %s", costString(0).ascii());
++#endif
++}
++
++
++//---------------------------------------------------
++// TraceInclusiveListCost
++
++TraceInclusiveListCost::TraceInclusiveListCost()
++{
++  _lastDep = 0;
++}
++
++TraceInclusiveListCost::~TraceInclusiveListCost()
++{}
++
++
++void TraceInclusiveListCost::addDep(TraceInclusiveCost* dep)
++{
++#if TRACE_ASSERTIONS
++  if (_deps.findRef(dep)>=0) {
++    qDebug("addDep: %s already in list!",
++           dep->fullName().ascii());
++    return;
++  }
++#endif
++
++  _deps.append(dep);
++  _lastDep = dep;
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added\n %s (now %d)",
++         fullName().ascii(), dep->fullName().ascii(),
++         _deps.count());
++#endif
++}
++
++TraceInclusiveCost* TraceInclusiveListCost::findDepFromPart(TracePart* part)
++{
++  if (_lastDep && _lastDep->part() == part)
++    return _lastDep;
++
++  TraceInclusiveCost* dep;
++  for (dep = _deps.first(); dep; dep = _deps.next())
++    if (dep->part() == part) {
++      _lastDep = dep;
++      return dep;
++    }
++  return 0;
++}
++
++void TraceInclusiveListCost::update()
++{
++  if (!_dirty) return;
++
++#if TRACE_DEBUG
++  qDebug("update %s (count %d)",
++         fullName().ascii(), _deps.count());
++#endif
++
++  clear();
++  TraceInclusiveCost* item;
++  for (item = _deps.first(); item; item = _deps.next()) {
++    if (onlyActiveParts())
++      if (!item->part() || !item->part()->isActive()) continue;
++
++    addCost(item);
++    addInclusive(item->inclusive());
++  }
++
++  _dirty = false;
++
++#if TRACE_DEBUG
++  qDebug("   > %s", costString(0).ascii());
++#endif
++}
++
++
++
++//---------------------------------------------------
++// TracePartInstrJump
++
++TracePartInstrJump::TracePartInstrJump(TraceInstrJump* instrJump,
++				       TracePartInstrJump* next)
++{
++  _dep = instrJump;
++  _next = next;
++}
++
++TracePartInstrJump::~TracePartInstrJump()
++{}
++
++
++//---------------------------------------------------
++// TracePartInstrCall
++
++TracePartInstrCall::TracePartInstrCall(TraceInstrCall* instrCall)
++{
++  _dep = instrCall;
++}
++
++TracePartInstrCall::~TracePartInstrCall()
++{}
++
++
++
++//---------------------------------------------------
++// TracePartInstr
++
++TracePartInstr::TracePartInstr(TraceInstr* instr)
++{
++  _dep = instr;
++}
++
++TracePartInstr::~TracePartInstr()
++{}
++
++
++
++//---------------------------------------------------
++// TracePartLineJump
++
++TracePartLineJump::TracePartLineJump(TraceLineJump* lineJump)
++{
++  _dep = lineJump;
++}
++
++TracePartLineJump::~TracePartLineJump()
++{}
++
++
++//---------------------------------------------------
++// TracePartLineCall
++
++TracePartLineCall::TracePartLineCall(TraceLineCall* lineCall)
++{
++  _dep = lineCall;
++}
++
++TracePartLineCall::~TracePartLineCall()
++{}
++
++
++//---------------------------------------------------
++// TracePartLine
++
++TracePartLine::TracePartLine(TraceLine* line)
++{
++  _dep = line;
++}
++
++TracePartLine::~TracePartLine()
++{}
++
++
++
++
++//---------------------------------------------------
++// TracePartCall
++
++TracePartCall::TracePartCall(TraceCall* call)
++{
++  _dep = call;
++
++  _firstFixCallCost = 0;
++}
++
++TracePartCall::~TracePartCall()
++{}
++
++bool TracePartCall::isRecursion()
++{
++  return call()->isRecursion();
++}
++
++void TracePartCall::update()
++{
++#if !USE_FIXCOST
++  TraceCallListCost::update();
++#else
++
++  if (!_dirty) return;
++
++#if TRACE_DEBUG
++  qDebug("update %s", fullName().ascii());
++#endif
++
++  /* Without dependent cost items, assume fixed costs,
++   * i.e. don't change cost */
++  if (_firstFixCallCost) {
++    clear();
++    FixCallCost* item;
++    for (item = _firstFixCallCost; item; item = item->nextCostOfPartCall())
++      item->addTo(this);
++  }
++
++  _dirty = false;
++
++#if TRACE_DEBUG
++  qDebug("   > %s", costString(0).ascii());
++#endif
++
++#endif // USE_FIXCOST
++}
++
++
++//---------------------------------------------------
++// TracePartFunction
++
++TracePartFunction::TracePartFunction(TraceFunction* function,
++                                     TracePartObject* partObject,
++				     TracePartFile *partFile)
++{
++  _dep = function;
++  _partObject = partObject;
++  _partFile = partFile;
++  _partClass = 0;
++
++  _calledCount     = 0;
++  _callingCount    = 0;
++  _calledContexts  = 0;
++  _callingContexts = 0;
++
++  _firstFixCost = 0;
++  _firstFixJump = 0;
++}
++
++TracePartFunction::~TracePartFunction()
++{}
++
++TQString TracePartFunction::prettyCalledCount()
++{
++  return _calledCount.pretty();
++}
++
++TQString TracePartFunction::prettyCallingCount()
++{
++  return _callingCount.pretty();
++}
++
++TQString TracePartFunction::costString(TraceCostMapping* m)
++{
++  update();
++
++  TQString res = TraceInclusiveCost::costString(m);
++  res += TQString(", called from %1: %2")
++         .arg(_calledContexts).arg(prettyCalledCount());
++  res += TQString(", calling from %1: %2")
++         .arg(_callingContexts).arg(prettyCallingCount());
++
++  return res;
++}
++
++
++void TracePartFunction::addPartInstr(TracePartInstr* ref)
++{
++#if TRACE_ASSERTIONS
++  if (_partInstr.findRef(ref)>=0) {
++    qDebug("TracePartFunction::addPartInstr: %s already in list!",
++           ref->name().ascii());
++    return;
++  }
++#endif
++
++  _partInstr.append(ref);
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added\n %s (now %d)",
++         fullName().ascii(), ref->fullName().ascii(),
++         _partInstr.count());
++#endif
++}
++
++
++void TracePartFunction::addPartLine(TracePartLine* ref)
++{
++#if TRACE_ASSERTIONS
++  if (_partLines.findRef(ref)>=0) {
++    qDebug("TracePartFunction::addPartLine: %s already in list!",
++           ref->name().ascii());
++    return;
++  }
++#endif
++
++  _partLines.append(ref);
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added\n %s (now %d)",
++         fullName().ascii(), ref->fullName().ascii(),
++         _partLines.count());
++#endif
++}
++
++
++void TracePartFunction::addPartCaller(TracePartCall* ref)
++{
++#if TRACE_ASSERTIONS
++  if (_partCallers.findRef(ref)>=0) {
++    qDebug("TracePartFunction::addPartCaller: %s already in list!",
++           ref->name().ascii());
++    return;
++  }
++#endif
++
++  _partCallers.append(ref);
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added Caller\n %s (now %d)",
++         fullName().ascii(), ref->fullName().ascii(),
++         _partCallers.count());
++#endif
++}
++
++
++void TracePartFunction::addPartCalling(TracePartCall* ref)
++{
++#if TRACE_ASSERTIONS
++  if (_partCallings.findRef(ref)>=0) {
++    qDebug("TracePartFunction::addPartCalling: %s already in list!",
++           ref->name().ascii());
++    return;
++  }
++#endif
++
++  _partCallings.append(ref);
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added Calling\n %s (now %d)",
++         fullName().ascii(), ref->fullName().ascii(),
++         _partCallings.count());
++#endif
++}
++
++SubCost TracePartFunction::calledCount()
++{
++  if (_dirty) update();
++
++  return _calledCount;
++}
++
++int TracePartFunction::calledContexts()
++{
++  if (_dirty) update();
++
++  return _calledContexts;
++}
++
++SubCost TracePartFunction::callingCount()
++{
++  if (_dirty) update();
++
++  return _callingCount;
++}
++
++
++int TracePartFunction::callingContexts()
++{
++  if (_dirty) update();
++
++  return _callingContexts;
++}
++
++
++void TracePartFunction::update()
++{
++  if (!_dirty) return;
++
++#if TRACE_DEBUG
++  qDebug("TracePartFunction::update %s (Callers %d, Callings %d, lines %d)",
++         name().ascii(), _partCallers.count(), _partCallings.count(),
++         _partLines.count());
++#endif
++
++  _calledCount     = 0;
++  _callingCount    = 0;
++  _calledContexts  = 0;
++  _callingContexts = 0;
++
++  // calculate additional cost metrics
++  TracePartCall *caller, *calling;
++  for (caller=_partCallers.first();caller;caller=_partCallers.next()) {
++
++    // FIXME
++    if (caller->subCost(0)>0)
++      _calledContexts++;
++
++    SubCost c = caller->callCount();
++    if (c>0) {
++      _calledCount += c;
++    }
++  }
++  for (calling=_partCallings.first();calling;calling=_partCallings.next()) {
++    // FIXME
++    if (calling->subCost(0)>0)
++      _callingContexts++;
++
++    SubCost c = calling->callCount();
++    if (c>0) {
++      _callingCount += c;
++    }
++  }
++
++  // self cost
++#if !USE_FIXCOST
++  if (_partLines.count()>0) {
++    TraceCost::clear();
++
++    TracePartLine* line;
++    for (line = _partLines.first(); line; line = _partLines.next())
++      addCost(line);
++  }
++#else
++  if (_firstFixCost) {
++    TraceCost::clear();
++
++    FixCost* item;
++    for (item = _firstFixCost; item; item = item->nextCostOfPartFunction())
++      item->addTo(this);
++  }
++#endif
++
++
++  /* There are two possibilities to calculate inclusive cost:
++   * 1) sum of call costs to this function
++   * 2) sum of call costs from this function + self cost
++   *
++   * 1) is wrong if a function was called spontaneous, but also by a call.
++   * This eventually can happen with thread/process startup functions,
++   * and signal handlers.
++   *
++   * 2) is wrong with "skipped PLT" and the calltree skin, because
++   *    cost of PLT is attributed to called function (?)
++   *
++   * For now, do 1) if there are callers, otherwise 2).
++   * Should this be fixed to take the maximum of 1) and 2) ?
++   */
++  _inclusive.clear();
++  if (_calledCount>0) {
++      // inclusive cost: if possible, use caller sums
++    for (caller=_partCallers.first();caller;caller=_partCallers.next()) {
++      // detect simple recursion (no cycle)
++      if (caller->isRecursion()) continue;
++
++      addInclusive(caller);
++    }
++  }
++  else {
++    // without caller info, use calling sum + line costs
++    for (calling=_partCallings.first();calling;calling=_partCallings.next()) {
++      // detect simple recursion (no cycle)
++      if (calling->isRecursion()) continue;
++
++      addInclusive(calling);
++    }
++    _dirty = false; // don't recurse!
++    addInclusive(this);
++  }
++
++  _dirty = false;
++
++#if TRACE_DEBUG
++  qDebug("   > %s", costString(0).ascii());
++#endif
++}
++
++
++
++//---------------------------------------------------
++// TracePartClass
++
++TracePartClass::TracePartClass(TraceClass* cls)
++{
++  _dep = cls;
++}
++
++TracePartClass::~TracePartClass()
++{}
++
++TQString TracePartClass::prettyName() const
++{
++  return TQString("%1 from %2")
++    .arg( _dep->name().isEmpty() ? TQString("(global)") : _dep->name())
++    .arg(part()->name());
++}
++
++//---------------------------------------------------
++// TracePartFile
++
++TracePartFile::TracePartFile(TraceFile* file)
++{
++  _dep = file;
++}
++
++TracePartFile::~TracePartFile()
++{}
++
++
++//---------------------------------------------------
++// TracePartObject
++
++TracePartObject::TracePartObject(TraceObject* object)
++{
++  _dep = object;
++}
++
++TracePartObject::~TracePartObject()
++{}
++
++
++
++
++//---------------------------------------------------
++// TraceInstrJump
++
++TraceInstrJump::TraceInstrJump(TraceInstr* instrFrom, TraceInstr* instrTo,
++			       bool isCondJump)
++{
++  _first = 0;
++
++  _instrFrom = instrFrom;
++  _instrTo = instrTo;
++  _isCondJump = isCondJump;
++}
++
++TraceInstrJump::~TraceInstrJump()
++{
++  // we are the owner of the TracePartInstrJump's generated in our factory
++  TracePartInstrJump* item = _first, *next;
++  while(item) {
++    next = item->next();
++    delete item;
++    item = next;
++  }
++}
++
++TracePartInstrJump* TraceInstrJump::partInstrJump(TracePart* part)
++{
++  static TracePartInstrJump* item = 0;
++
++  // shortcut
++  if (item && (item->instrJump()==this) && (item->part() == part)) return item;
++
++  for(item = _first; item; item = item->next())
++    if (item->part() == part) break;
++
++  if (!item) {
++    item = new TracePartInstrJump(this, _first);
++    item->setPosition(part);
++    _first = item;
++  }
++  return item;
++}
++
++void TraceInstrJump::update()
++{
++  if (!_dirty) return;
++
++  clear();
++  TracePartInstrJump* item;
++  for (item = _first; item; item = item->next()) {
++    if (!item->part() || !item->part()->isActive()) continue;
++
++    addCost(item);
++  }
++  _dirty = false;
++
++#if TRACE_DEBUG
++  qDebug("updated %s", fullName().ascii());
++#endif
++
++#if TRACE_DEBUG
++  qDebug("   > %s", costString(0).ascii());
++#endif
++}
++
++TQString TraceInstrJump::name() const
++{
++  return TQString("jump at 0x%1 to 0x%2")
++    .arg(_instrFrom->addr().toString())
++    .arg(_instrTo->addr().toString());
++}
++
++
++//---------------------------------------------------
++// TraceInstrJumpList
++
++
++int TraceInstrJumpList::compareItems ( Item item1, Item item2 )
++{
++    TraceInstrJump* ij1 = (TraceInstrJump*) item1;
++    TraceInstrJump* ij2 = (TraceInstrJump*) item2;
++
++    Addr addr1Low  = ij1->instrFrom()->addr();
++    Addr addr2Low  = ij2->instrFrom()->addr();
++    Addr addr1High = ij1->instrTo()->addr();
++    Addr addr2High = ij2->instrTo()->addr();
++    Addr t;
++
++    if (addr1Low > addr1High) {
++	t = addr1Low;
++	addr1Low = addr1High;
++	addr1High = t;
++    }
++
++    if (addr2Low > addr2High) {
++	t = addr2Low;
++	addr2Low = addr2High;
++	addr2High = t;
++    }
++
++    if (_sortLow) {
++	// we sort according to smallest instruction address
++	if (addr1Low != addr2Low) return (addr1Low > addr2Low) ? 1:-1;
++	// jump ends come before jump starts
++	if (addr1Low == ij1->instrTo()->addr()) return -1;
++	if (addr2Low == ij2->instrTo()->addr()) return 1;
++	return (addr1High > addr2High) ? 1:-1;
++    }
++
++    // we sort according to highest instruction address
++    if (addr1High != addr2High) return (addr1High > addr2High) ? 1:-1;
++    // jump ends come before jump starts
++    if (addr1High == ij1->instrTo()->addr()) return -1;
++    if (addr2High == ij2->instrTo()->addr()) return 1;
++    return (addr1Low > addr2Low) ? 1:-1;
++}
++
++
++//---------------------------------------------------
++// TraceLineJump
++
++TraceLineJump::TraceLineJump(TraceLine* lineFrom, TraceLine* lineTo,
++			     bool isCondJump)
++{
++  // we are the owner of TracePartLineJump's generated in our factory
++  _deps.setAutoDelete(true);
++
++  _lineFrom = lineFrom;
++  _lineTo   = lineTo;
++  _isCondJump = isCondJump;
++}
++
++TraceLineJump::~TraceLineJump()
++{}
++
++
++TracePartLineJump* TraceLineJump::partLineJump(TracePart* part)
++{
++  TracePartLineJump* item = (TracePartLineJump*) findDepFromPart(part);
++  if (!item) {
++    item = new TracePartLineJump(this);
++    item->setPosition(part);
++    addDep(item);
++  }
++  return item;
++}
++
++
++TQString TraceLineJump::name() const
++{
++  return TQString("jump at %1 to %2")
++      .arg(_lineFrom->prettyName())
++      .arg(_lineTo->prettyName());
++}
++
++
++//---------------------------------------------------
++// TraceLineJumpList
++
++
++int TraceLineJumpList::compareItems ( Item item1, Item item2 )
++{
++    TraceLineJump* lj1 = (TraceLineJump*) item1;
++    TraceLineJump* lj2 = (TraceLineJump*) item2;
++
++    uint line1Low  = lj1->lineFrom()->lineno();
++    uint line2Low  = lj2->lineFrom()->lineno();
++    uint line1High = lj1->lineTo()->lineno();
++    uint line2High = lj2->lineTo()->lineno();
++    uint t;
++
++    if (line1Low > line1High) {
++	t = line1Low; line1Low = line1High; line1High = t;
++    }
++    if (line2Low > line2High) {
++	t = line2Low; line2Low = line2High; line2High = t;
++    }
++
++    if (_sortLow) {
++	// we sort according to smallest line number
++	if (line1Low != line2Low) return line1Low - line2Low;
++	// jump ends come before jump starts
++	if (line1Low == lj1->lineTo()->lineno()) return -1;
++	if (line2Low == lj2->lineTo()->lineno()) return 1;
++	return line1High - line2High;
++    }
++
++    // we sort according to highest line number
++    if (line1High != line2High) return line1High - line2High;
++    // jump ends come before jump starts
++    if (line1High == lj1->lineTo()->lineno()) return -1;
++    if (line2High == lj2->lineTo()->lineno()) return 1;
++    return line1Low - line2Low;
++}
++
++
++//---------------------------------------------------
++// TraceInstrCall
++
++TraceInstrCall::TraceInstrCall(TraceCall* call, TraceInstr* instr)
++{
++  // we are the owner of TracePartInstrCall's generated in our factory
++  _deps.setAutoDelete(true);
++
++  _call  = call;
++  _instr = instr;
++}
++
++TraceInstrCall::~TraceInstrCall()
++{}
++
++
++TracePartInstrCall* TraceInstrCall::partInstrCall(TracePart* part,
++						  TracePartCall*)
++{
++  TracePartInstrCall* item = (TracePartInstrCall*) findDepFromPart(part);
++  if (!item) {
++    item = new TracePartInstrCall(this);
++    item->setPosition(part);
++    addDep(item);
++    // instruction calls are not registered in function calls
++    // as together with line calls calls are duplicated
++    //partCall->addDep(item);
++  }
++  return item;
++}
++
++
++TQString TraceInstrCall::name() const
++{
++  return TQString("%1 at %2").arg(_call->name()).arg(_instr->name());
++}
++
++
++//---------------------------------------------------
++// TraceLineCall
++
++TraceLineCall::TraceLineCall(TraceCall* call, TraceLine* line)
++{
++  // we are the owner of TracePartLineCall's generated in our factory
++  _deps.setAutoDelete(true);
++
++  _call = call;
++  _line = line;
++}
++
++TraceLineCall::~TraceLineCall()
++{}
++
++
++TracePartLineCall* TraceLineCall::partLineCall(TracePart* part,
++                                               TracePartCall* partCall)
++{
++  TracePartLineCall* item = (TracePartLineCall*) findDepFromPart(part);
++  if (!item) {
++    item = new TracePartLineCall(this);
++    item->setPosition(part);
++    addDep(item);
++    partCall->addDep(item);
++  }
++  return item;
++}
++
++
++TQString TraceLineCall::name() const
++{
++  return TQString("%1 at %2").arg(_call->name()).arg(_line->name());
++}
++
++
++//---------------------------------------------------
++// TraceCall
++
++TraceCall::TraceCall(TraceFunction* caller, TraceFunction* called)
++{
++  // we are the owner of all items generated in our factory
++  _deps.setAutoDelete(true);
++  _lineCalls.setAutoDelete(true);
++
++  _caller = caller;
++  _called = called;
++}
++
++
++TraceCall::~TraceCall()
++{}
++
++TracePartCall* TraceCall::partCall(TracePart* part,
++                                   TracePartFunction* partCaller,
++                                   TracePartFunction* partCalling)
++{
++  TracePartCall* item = (TracePartCall*) findDepFromPart(part);
++  if (!item) {
++    item = new TracePartCall(this);
++    item->setPosition(part);
++    addDep(item);
++    partCaller->addPartCalling(item);
++    partCalling->addPartCaller(item);
++  }
++  return item;
++}
++
++TraceInstrCall* TraceCall::instrCall(TraceInstr* i)
++{
++  TraceInstrCall* icall;
++  for (icall=_instrCalls.first();icall;icall=_instrCalls.next())
++    if (icall->instr() == i)
++      break;
++
++  if (!icall) {
++    icall = new TraceInstrCall(this, i);
++
++    _instrCalls.append(icall);
++    invalidate();
++
++#if TRACE_DEBUG
++    qDebug("Created %s [TraceCall::instrCall]", icall->fullName().ascii());
++#endif
++    i->addInstrCall(icall);
++  }
++  return icall;
++}
++
++
++TraceLineCall* TraceCall::lineCall(TraceLine* l)
++{
++  TraceLineCall* lcall;
++  for (lcall=_lineCalls.first();lcall;lcall=_lineCalls.next())
++    if (lcall->line() == l)
++      break;
++
++  if (!lcall) {
++    lcall = new TraceLineCall(this, l);
++
++    _lineCalls.append(lcall);
++    invalidate();
++
++#if TRACE_DEBUG
++    qDebug("Created %s [TraceCall::lineCall]", lcall->fullName().ascii());
++#endif
++    l->addLineCall(lcall);
++  }
++  return lcall;
++}
++
++
++void TraceCall::invalidateDynamicCost()
++{
++  TraceLineCall* lc;
++  for (lc=_lineCalls.first();lc;lc=_lineCalls.next())
++    lc->invalidate();
++
++  TraceInstrCall* ic;
++  for (ic=_instrCalls.first();ic;ic=_instrCalls.next())
++    ic->invalidate();
++
++  invalidate();
++}
++
++
++TQString TraceCall::name() const
++{
++  return TQString("%1 => %2")
++    .arg(_caller->name())
++    .arg(_called->name());
++}
++
++int TraceCall::inCycle()
++{
++  if (!_caller || !_called) return 0;
++  if (!_caller->cycle()) return 0;
++  if (_caller == _caller->cycle()) return 0;
++  if (_caller->cycle() != _called->cycle()) return 0;
++
++  return _caller->cycle()->cycleNo();
++}
++
++void TraceCall::update()
++{
++  if (!_dirty) return;
++
++  // special handling for cycles
++  if (_caller && _caller->cycle() && _caller==_caller->cycle()) {
++
++    // we have no part calls: use inclusive cost of called function
++    clear();
++    if (_called)
++      addCost(_called->inclusive());
++    _dirty = false;
++    return;
++  }
++
++  TraceCallListCost::update();
++}
++
++TraceFunction* TraceCall::caller(bool /*skipCycle*/) const
++{
++  return _caller;
++}
++
++TraceFunction* TraceCall::called(bool skipCycle) const
++{
++  if (!skipCycle && _called) {
++    // if this is a call to a cycle member from outside of the cycle,
++    // fake it to be a call to the whole cycle
++    if (_called->cycle() && _caller &&
++        (_caller->cycle() != _called->cycle()))
++      return _called->cycle();
++  }
++
++  return _called;
++}
++
++TQString TraceCall::callerName(bool skipCycle) const
++{
++  if (!_caller) return i18n("(no caller)");
++
++  if (!skipCycle) {
++      // if this call goes into a cycle, add the entry function
++      TraceFunctionCycle* c = _called->cycle();
++      if (c && _caller && (_caller->cycle() != c)) {
++	  TQString via = _called->prettyName();
++	  return i18n("%1 via %2").arg(_caller->prettyName()).arg(via);
++      }
++  }
++
++  return _caller->prettyName();
++}
++
++TQString TraceCall::calledName(bool skipCycle) const
++{
++  if (!_called) return i18n("(no callee)");
++
++  if (!skipCycle) {
++      // if this call goes into a cycle, add the entry function
++      TraceFunctionCycle* c = _called->cycle();
++      if (c && _caller && (_caller->cycle() != c)) {
++	  // HACK to get rid of cycle postfix...
++	  _called->setCycle(0);
++	  TQString via = _called->prettyName();
++	  _called->setCycle(c);
++	  return i18n("%1 via %2").arg(c->name()).arg(via);
++      }
++  }
++  return _called->prettyName();
++}
++
++
++//---------------------------------------------------
++// TraceInstr
++
++TraceInstr::TraceInstr()
++{
++  // we are the owner of TracePartInstr's generated in our factory
++  _deps.setAutoDelete(true);
++  _instrJumps.setAutoDelete(true);
++
++  _addr = 0;
++  _line = 0;
++  _function = 0;
++}
++
++TraceInstr::~TraceInstr()
++{}
++
++bool TraceInstr::hasCost(TraceCostType* ct)
++{
++    bool res = subCost(ct) > 0;
++    if (!res) {
++	TraceInstrCall* ic;
++	for(ic=_instrCalls.first();ic;ic=_instrCalls.next())
++	    if (ic->subCost(ct) > 0) break;
++	res = (ic != 0);
++	if (!res) {
++	    TraceInstrJump* ij;
++	    for(ij=_instrJumps.first();ij;ij=_instrJumps.next())
++		if (ij->executedCount() > 0) break;
++	    res = (ij != 0);
++	}
++    }
++
++    return res;
++}
++
++TracePartInstr* TraceInstr::partInstr(TracePart* part,
++				      TracePartFunction* partFunction)
++{
++  TracePartInstr* item = (TracePartInstr*) findDepFromPart(part);
++  if (!item) {
++    item = new TracePartInstr(this);
++    item->setPosition(part);
++    addDep(item);
++    //part->addDep(item);
++    partFunction->addPartInstr(item);
++  }
++  return item;
++}
++
++TraceInstrJump* TraceInstr::instrJump(TraceInstr* to, bool isJmpCond)
++{
++  TraceInstrJump* jump;
++  for (jump=_instrJumps.first();jump;jump=_instrJumps.next())
++    if (jump->instrTo() == to)
++      break;
++
++  if (!jump) {
++    jump = new TraceInstrJump(this, to, isJmpCond);
++
++    _instrJumps.append(jump);
++  }
++  return jump;
++}
++
++
++
++void TraceInstr::addInstrCall(TraceInstrCall* instrCall)
++{
++#if TRACE_ASSERTIONS
++  if (_instrCalls.findRef(instrCall)>=0) return;
++
++  if (instrCall->instr() != this) {
++    qDebug("Can't add instruction call to another instruction!");
++    return;
++  }
++#endif
++
++  _instrCalls.append(instrCall);
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added\n %s (now %d)",
++         fullName().ascii(),
++         instrCall->fullName().ascii(), _instrCalls.count());
++#endif
++}
++
++
++TQString TraceInstr::name() const
++{
++    return TQString("0x%1").arg(_addr.toString());
++}
++
++TQString TraceInstr::prettyName() const
++{
++    return TQString("0x%1").arg(_addr.toString());
++}
++
++
++//---------------------------------------------------
++// TraceLine
++
++TraceLine::TraceLine()
++{
++  // we are the owner of TracePartLine's generated in our factory
++  _deps.setAutoDelete(true);
++  _lineJumps.setAutoDelete(true);
++
++  _lineno = 0;
++  _sourceFile = 0;
++}
++
++TraceLine::~TraceLine()
++{}
++
++bool TraceLine::hasCost(TraceCostType* ct)
++{
++    bool res = subCost(ct) > 0;
++    if (!res) {
++	TraceLineCall* lc;
++	for(lc=_lineCalls.first();lc;lc=_lineCalls.next())
++	    if (lc->subCost(ct) > 0) break;
++	res = (lc != 0);
++	if (!res) {
++	    TraceLineJump* lj;
++	    for(lj=_lineJumps.first();lj;lj=_lineJumps.next())
++		if (lj->executedCount() > 0) break;
++	    res = (lj != 0);
++	}
++    }
++
++    return res;
++}
++
++TracePartLine* TraceLine::partLine(TracePart* part,
++                                   TracePartFunction* partFunction)
++{
++  TracePartLine* item = (TracePartLine*) findDepFromPart(part);
++  if (!item) {
++    item = new TracePartLine(this);
++    item->setPosition(part);
++    addDep(item);
++#if !USE_FIXCOST
++    part->addDep(item);
++#endif
++    partFunction->addPartLine(item);
++  }
++  return item;
++}
++
++TraceLineJump* TraceLine::lineJump(TraceLine* to, bool isJmpCond)
++{
++  TraceLineJump* jump;
++  for (jump=_lineJumps.first();jump;jump=_lineJumps.next())
++    if (jump->lineTo() == to)
++      break;
++
++  if (!jump) {
++    jump = new TraceLineJump(this, to, isJmpCond);
++
++    _lineJumps.append(jump);
++  }
++  return jump;
++}
++
++
++void TraceLine::addLineCall(TraceLineCall* lineCall)
++{
++#if TRACE_ASSERTIONS
++  if (_lineCalls.findRef(lineCall)>=0) return;
++
++  if (lineCall->line() != this) {
++    qDebug("Can't add line call to another line!");
++    return;
++  }
++#endif
++
++  TraceFunction* caller = lineCall->call()->caller();
++  TraceFunction* function = _sourceFile->function();
++  if (caller != function) {
++    // We regard 2 functions as the same if they have
++    // same class, name, object
++    if ((caller->cls() != function->cls()) ||
++        (caller->name() != function->name()) ||
++        (caller->object() != function->object())) {
++
++    qDebug("ERROR: Adding line call, line %d\n  of %s to\n  %s ?!",
++           lineCall->line()->lineno(),
++           caller->info().ascii(), function->info().ascii());
++    }
++  }
++
++  _lineCalls.append(lineCall);
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added\n %s (now %d)",
++         fullName().ascii(),
++         lineCall->fullName().ascii(), _lineCalls.count());
++#endif
++}
++
++
++TQString TraceLine::name() const
++{
++    TQString fileShortName = _sourceFile->file()->shortName();
++    if (fileShortName.isEmpty())
++	return i18n("(unknown)");
++
++    return TQString("%1:%2")
++	.arg(fileShortName).arg(_lineno);
++}
++
++TQString TraceLine::prettyName() const
++{
++  return TQString("%1 [%2]")
++    .arg(name()).arg(_sourceFile->function()->prettyName());
++}
++
++//---------------------------------------------------
++// TraceCostItem
++
++TraceCostItem::TraceCostItem()
++{
++}
++
++TraceCostItem::~TraceCostItem()
++{}
++
++
++//---------------------------------------------------
++// TraceFunctionSource
++
++TraceFunctionSource::TraceFunctionSource(TraceFunction* function,
++                                                 TraceFile* file)
++{
++  _file = file;
++  _function = function;
++
++  // the function is dependent from our cost sum
++  _dep = _function;
++
++  _lineMap = 0;
++  _lineMapFilled = false;
++  _line0 = 0;
++}
++
++TraceFunctionSource::~TraceFunctionSource()
++{
++    if (_lineMap) delete _lineMap;
++    if (_line0) delete _line0;
++}
++
++TQString TraceFunctionSource::name() const
++{
++  return TQString("%1 for %2").arg(_file->name()).arg(_function->name());
++}
++
++uint TraceFunctionSource::firstLineno()
++{
++  // lazy generate the map if not done up to now
++  TraceLineMap* map = lineMap();
++  // ignore line 0 here
++  if (!map || map->count() == 0) return 0;
++  TraceLineMap::Iterator it = map->begin();
++  return (*it).lineno();
++}
++
++uint TraceFunctionSource::lastLineno()
++{
++  // lazy generate the map if not done up to now
++  TraceLineMap* map = lineMap();
++  // ignore line 0 here
++  if (!map || map->count() == 0) return 0;
++  TraceLineMap::Iterator it = map->end();
++  --it;
++  return (*it).lineno();
++}
++
++/* factory */
++TraceLine* TraceFunctionSource::line(uint lineno, bool createNew)
++{
++    if (lineno == 0) {
++	if (!_line0) {
++	    if (!createNew) return 0;
++	    _line0 = new TraceLine;
++	    _line0->setSourceFile(this);
++	    _line0->setLineno(0);
++	}
++	return _line0;
++    }
++
++  if (!createNew) {
++    if (!_lineMap) return 0;
++    TraceLineMap::Iterator it = _lineMap->find(lineno);
++    if (it == _lineMap->end()) return 0;
++    return &(it.data());
++  }
++
++  if (!_lineMap) _lineMap = new TraceLineMap;
++
++  TraceLine& l = (*_lineMap)[lineno];
++  if (!l.isValid()) {
++    l.setSourceFile(this);
++    l.setLineno(lineno);
++
++#if TRACE_DEBUG
++    qDebug("Created %s [TraceFunctionSource::line]",
++           l.fullName().ascii());
++#endif
++  }
++  return &l;
++}
++
++void TraceFunctionSource::update()
++{
++  if (!_dirty) return;
++
++  clear();
++
++  // no need to create lineMap if not already created
++  if (_lineMap) {
++    TraceLineMap::Iterator lit;
++    for ( lit = _lineMap->begin();
++          lit != _lineMap->end(); ++lit )
++      addCost( &(*lit) );
++  }
++
++  _dirty = false;
++}
++
++void TraceFunctionSource::invalidateDynamicCost()
++{
++  // no need to create lineMap if not already created
++  if (_lineMap) {
++    TraceLineMap::Iterator lit;
++    for ( lit = _lineMap->begin();
++          lit != _lineMap->end(); ++lit )
++      (*lit).invalidate();
++  }
++
++  invalidate();
++}
++
++TraceLineMap* TraceFunctionSource::lineMap()
++{
++#if USE_FIXCOST
++
++    if (_lineMapFilled) return _lineMap;
++    _lineMapFilled = true;
++    if (!_lineMap)
++	_lineMap = new TraceLineMap;
++
++  TraceLine* l = 0;
++  TracePartLine* pl = 0;
++  TraceLineCall* lc = 0;
++  TracePartLineCall* plc = 0;
++
++  /* go over all part objects for this function, and
++   * - build TraceLines (the line map) using FixCost objects
++   * - build TraceJumpLines using FixJump objects
++   */
++  TraceInclusiveCostList pfList = _function->deps();
++  TracePartFunction* pf = (TracePartFunction*) pfList.first();
++  for(; pf; pf = (TracePartFunction*) pfList.next()) {
++
++      if (0) qDebug("PartFunction %s:%d",
++		    pf->function()->name().ascii(), pf->part()->partNumber());
++
++      FixCost* fc = pf->firstFixCost();
++      for(; fc; fc = fc->nextCostOfPartFunction()) {
++	  if (fc->line() == 0) continue;
++	  if (fc->functionSource() != this) continue;
++
++	  if (!l || l->lineno() != fc->line()) {
++	      l = &(*_lineMap)[fc->line()];
++	      if (!l->isValid()) {
++		  l->setSourceFile(this);
++		  l->setLineno(fc->line());
++	      }
++	      pl = 0;
++	  }
++	  if (!pl || pl->part() != fc->part())
++	      pl = l->partLine(fc->part(), pf);
++	  fc->addTo(pl);
++      }
++
++      TraceLine* to = 0;
++      TraceLineJump* lj;
++      TracePartLineJump* plj;
++      FixJump* fj = pf->firstFixJump();
++      for(; fj; fj = fj->nextJumpOfPartFunction()) {
++	  if (fj->line() == 0) continue;
++	  if (fj->source() != this) continue;
++	  if (!fj->targetSource()) {
++	    // be robust against buggy loaders
++	    continue;
++	  }
++
++	  // don't display jumps to same or following line
++	  if ((fj->line() == fj->targetLine()) ||
++	      (fj->line()+1 == fj->targetLine())) continue;
++
++	  if (!l || l->lineno() != fj->line()) {
++	      l = &(*_lineMap)[fj->line()];
++	      if (!l->isValid()) {
++		  l->setSourceFile(this);
++		  l->setLineno(fj->line());
++	      }
++	  }
++
++	  to = fj->targetSource()->line(fj->targetLine(), true);
++
++	  lj = l->lineJump(to, fj->isCondJump());
++	  plj = lj->partLineJump(fj->part());
++
++	  fj->addTo(plj);
++      }
++
++
++      TracePartCallList pcList = pf->partCallings();
++      TracePartCall* pc = pcList.first();
++      for(; pc; pc = pcList.next()) {
++
++	  if (0) qDebug("PartCall %s:%d",
++			pc->call()->name().ascii(),
++			pf->part()->partNumber());
++
++	  FixCallCost* fcc = pc->firstFixCallCost();
++	  for(; fcc; fcc = fcc->nextCostOfPartCall()) {
++	      if (fcc->line() == 0) continue;
++	      if (fcc->functionSource() != this) continue;
++
++	      if (!l || l->lineno() != fcc->line()) {
++		  l = &(*_lineMap)[fcc->line()];
++		  if (!l->isValid()) {
++		      l->setSourceFile(this);
++		      l->setLineno(fcc->line());
++		  }
++	      }
++	      if (!lc || lc->call() != pc->call() || lc->line() != l) {
++		  lc = pc->call()->lineCall(l);
++		  plc = 0;
++	      }
++	      if (!plc || plc->part() != fcc->part())
++		  plc = lc->partLineCall(fcc->part(), pc);
++
++	      fcc->addTo(plc);
++	      if (0) qDebug("Add FixCallCost %s:%d/0x%s, CallCount %s",
++			    fcc->functionSource()->file()->shortName().ascii(),
++			    fcc->line(), fcc->addr().toString().ascii(),
++			    fcc->callCount().pretty().ascii());
++	  }
++      }
++  }
++
++#endif
++
++  return _lineMap;
++}
++
++
++
++//---------------------------------------------------
++// TraceAssoziation
++
++TraceAssoziation::TraceAssoziation()
++{
++  _function = 0;
++  _valid = false;
++}
++
++TraceAssoziation::~TraceAssoziation()
++{
++  // don't delete from TraceFunction
++  if (_function) _function->removeAssoziation(this);
++}
++
++bool TraceAssoziation::isAssoziated()
++{
++  if (!_function) return false;
++
++  return _function->assoziation(rtti())==this;
++}
++
++bool TraceAssoziation::setFunction(TraceFunction* f)
++{
++  if (_function == f)
++    return isAssoziated();
++
++  if (_function) {
++    // don't delete ourself
++    _function->removeAssoziation(this);
++  }
++
++  _function = f;
++  if (f && f->assoziation(rtti()) == 0) {
++    f->addAssoziation(this);
++    return true;
++  }
++  return false;
++}
++
++void TraceAssoziation::clear(TraceData* d, int rtti)
++{
++  TraceFunctionMap::Iterator it;
++  for ( it = d->functionMap().begin();
++        it != d->functionMap().end(); ++it )
++    (*it).removeAssoziation(rtti);
++}
++
++void TraceAssoziation::invalidate(TraceData* d, int rtti)
++{
++  TraceFunctionMap::Iterator it;
++  for ( it = d->functionMap().begin();
++        it != d->functionMap().end(); ++it )
++    (*it).invalidateAssoziation(rtti);
++}
++
++
++//---------------------------------------------------
++// TraceFunction
++
++TraceFunction::TraceFunction()
++{
++  _object = 0;
++  _file = 0;
++  _cls = 0;
++  _cycle = 0;
++
++    // we are the owner of items generated in our factory
++  _deps.setAutoDelete(true);
++  _callings.setAutoDelete(true);
++  _sourceFiles.setAutoDelete(true);
++
++  _calledCount     = 0;
++  _callingCount    = 0;
++  _calledContexts  = 0;
++  _callingContexts = 0;
++
++  _instrMap = 0;
++  _instrMapFilled = false;
++}
++
++
++TraceFunction::~TraceFunction()
++{
++  _assoziations.setAutoDelete(true);
++  _assoziations.clear();
++
++  if (_instrMap) delete _instrMap;
++}
++
++// no unique check is done!
++void TraceFunction::addAssoziation(TraceAssoziation* a)
++{
++  if (!a) return;
++  _assoziations.append(a);
++}
++
++void TraceFunction::removeAssoziation(TraceAssoziation* a)
++{
++  _assoziations.removeRef(a);
++}
++
++void TraceFunction::removeAssoziation(int rtti, bool reallyDelete)
++{
++  if (rtti==0) {
++    if (reallyDelete)
++      _assoziations.setAutoDelete(true);
++    _assoziations.clear();
++    _assoziations.setAutoDelete(false);
++    return;
++  }
++
++  TraceAssoziation* a;
++  for (a=_assoziations.first();a;a=_assoziations.next())
++    if (a->rtti() == rtti) {
++      if (reallyDelete) delete a;
++      _assoziations.remove();
++      return;
++    }
++}
++
++void TraceFunction::invalidateAssoziation(int rtti)
++{
++  TraceAssoziation* a;
++  for (a=_assoziations.first();a;a=_assoziations.next())
++    if ((rtti==0) || (a->rtti() == rtti))
++      a->invalidate();
++}
++
++TraceAssoziation* TraceFunction::assoziation(int rtti)
++{
++  TraceAssoziation* a;
++  for (a=_assoziations.first();a;a=_assoziations.next())
++    if (a->rtti() == rtti)
++      return a;
++  return 0;
++}
++
++
++// helper for prettyName
++bool TraceFunction::isUniquePrefix(TQString prefix) const
++{
++  TraceFunctionMap::ConstIterator it, it2;
++  it = it2 = _myMapIterator;
++  if (it != data()->functionBeginIterator()) {
++    it2--;
++    if ((*it2).name().startsWith(prefix)) return false;
++  }
++  if (it != data()->functionEndIterator()) {
++    it++;
++    if ((*it).name().startsWith(prefix)) return false;
++  }
++  return true;
++}
++
++
++TQString TraceFunction::prettyName() const
++{
++  TQString res = _name;
++
++  if (_name.isEmpty())
++      return i18n("(unknown)");
++
++  int p = _name.find('(');
++  if (p>0) {
++    // handle C++ "operator()" correct
++    if ((_name[p+1] == ')') && (_name[p+2] == '(')) p+=2;
++
++    // we have a C++ symbol with argument types:
++    // check for unique function name (inclusive '(' !)    
++    if (isUniquePrefix(_name.left(p+1)))
++      res = _name.left(p);
++  }
++
++  // cycle members
++  if (_cycle) {
++    if (_cycle != this)
++      res = TQString("%1 <cycle %2>").arg(res).arg(_cycle->cycleNo());
++    else
++      res = TQString("<cycle %2>").arg(_cycle->cycleNo());
++  }
++
++
++  return res;
++}
++
++/*
++ * Returns location string: ELF object and source file(s).
++ */
++TQString TraceFunction::location(int maxFiles) const
++{
++  TQString loc;
++
++  // add object file with address range
++  if (_object) {
++    loc = _object->shortName();
++
++#if 0
++    uint from = firstAddress();
++    uint to = lastAddress();
++    if (from != 0 && to != 0) {
++      if (from == to)
++        loc += TQString(" (0x%1)").arg(to, 0, 16);
++      else
++        loc += TQString(" (0x%1-0x%2)").arg(from, 0, 16).arg(to, 0, 16);
++    }
++#endif   
++  }
++
++  // add all source files
++  int filesAdded = 0;
++  TraceFunctionSourceList list = _sourceFiles;
++  TraceFunctionSource* sourceFile = list.first();
++  for (;sourceFile;sourceFile=list.next()) {
++    if (!sourceFile->file() ||
++	(sourceFile->file()->name().isEmpty()) )
++      continue;
++
++    if (!loc.isEmpty())
++      loc += (filesAdded>0) ? ", " : ": ";
++    filesAdded++;
++
++    if ((maxFiles>0) && (filesAdded>maxFiles)) {
++	loc += "...";
++	break;
++    }
++    loc += sourceFile->file()->shortName();
++
++#if 0
++    from = sourceFile->firstLineno();
++    to = sourceFile->lastLineno();
++    if (from != 0 && to != 0) {
++      if (from == to)
++        loc += TQString(" (%1)").arg(to);
++      else
++        loc += TQString(" (%1-%2)").arg(from).arg(to);
++    }
++#endif
++  }
++
++  return loc;
++}
++
++// pretty version is allowed to mangle the string...
++TQString TraceFunction::prettyLocation(int maxFiles) const
++{
++    TQString l = location(maxFiles);
++    if (l.isEmpty()) return i18n("(unknown)");
++
++    return l;
++}
++
++void TraceFunction::addPrettyLocation(TQString& s, int maxFiles) const
++{
++    TQString l = location(maxFiles);
++    if (l.isEmpty()) return;
++
++    s += TQString(" (%1)").arg(l);
++}
++
++TQString TraceFunction::prettyNameWithLocation(int maxFiles) const
++{
++    TQString l = location(maxFiles);
++    if (l.isEmpty()) return prettyName();
++
++    return TQString("%1 (%2)").arg(prettyName()).arg(l);
++}
++
++TQString TraceFunction::info() const
++{
++    TQString l = location();
++    if (l.isEmpty())
++	return TQString("Function %1").arg(name());
++
++    return TQString("Function %1 (location %2)")
++	.arg(name()).arg(l);
++}
++
++
++Addr TraceFunction::firstAddress() const
++{
++    // ignore address 0 here
++  if (!_instrMap || _instrMap->count() == 0) return 0;
++  TraceInstrMap::ConstIterator it = _instrMap->begin();
++  return (*it).addr();
++}
++
++Addr TraceFunction::lastAddress() const
++{
++    // ignore address 0 here
++  if (!_instrMap || _instrMap->count() == 0) return 0;
++  TraceInstrMap::ConstIterator it = _instrMap->end();
++  --it;
++  return (*it).addr();
++}
++
++/* factory */
++TraceInstr* TraceFunction::instr(Addr addr, bool createNew)
++{
++    // address 0 not allowed
++    if (addr == Addr(0)) return 0;
++
++  if (!createNew) {
++      if (!_instrMap) return 0;
++      TraceInstrMap::Iterator it = _instrMap->find(addr);
++      if (it == _instrMap->end())
++	  return 0;
++      return &(it.data());
++  }
++
++  if (!_instrMap) _instrMap = new TraceInstrMap;
++
++  TraceInstr& i = (*_instrMap)[addr];
++  if (!i.isValid()) {
++    i.setAddr(addr);
++    i.setFunction(this);
++
++#if TRACE_DEBUG
++    qDebug("Created %s [TraceFunction::instr]",
++           i.fullName().ascii());
++#endif
++  }
++  return &i;
++}
++
++void TraceFunction::addCaller(TraceCall* caller)
++{
++#if TRACE_ASSERTIONS
++  if (caller->called() != this) {
++    qDebug("Can't add call to another line!\n");
++    return;
++  }
++
++  if (_callers.findRef(caller)>=0) return;
++#endif
++
++  _callers.append(caller);
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added Caller\n %s (now %d)",
++         fullName().ascii(), caller->fullName().ascii(), _callers.count());
++#endif
++}
++
++
++
++TraceCall* TraceFunction::calling(TraceFunction* called)
++{
++  TraceCallMap::Iterator it = _callingMap.find(called);
++  TraceCall* calling = (it == _callingMap.end()) ? 0 : it.data();
++
++  if (!calling) {
++    calling = new TraceCall(this, called);
++
++    _callingMap.insert(called, calling);
++    _callings.append(calling);
++
++    // we have to invalidate ourself so invalidations from item propagate up
++    invalidate();
++
++#if TRACE_DEBUG
++    qDebug("Created %s [TraceFunction::calling]", calling->fullName().ascii());
++#endif
++    called->addCaller(calling);
++  }
++  return calling;
++}
++
++TraceFunctionSource* TraceFunction::sourceFile(TraceFile* file,
++                                                   bool createNew)
++{
++  if (!file) file = _file;
++
++  TraceFunctionSource* sourceFile = _sourceFiles.first();
++  for (;sourceFile;sourceFile=_sourceFiles.next())
++    if (sourceFile->file() == file) break;
++
++  if (!sourceFile && createNew) {
++    sourceFile = new TraceFunctionSource(this, file);
++
++    _sourceFiles.append(sourceFile);
++
++    // we have to invalidate ourself so invalidations from item propagate up
++    invalidate();
++
++#if TRACE_DEBUG
++    qDebug("Created SourceFile %s [TraceFunction::line]",
++           file->name().ascii());
++#endif
++    file->addSourceFile(sourceFile);
++  }
++  return sourceFile;
++}
++
++TraceLine* TraceFunction::line(TraceFile* file, uint lineno,
++                               bool createNew)
++{
++  Q_ASSERT(file!=0);
++
++  TraceFunctionSource* sf = sourceFile(file, createNew);
++  if (!sf)
++    return 0;
++  else
++    return sf->line(lineno, createNew);
++}
++
++
++TracePartFunction* TraceFunction::partFunction(TracePart* part,
++                                               TracePartFile* partFile,
++                                               TracePartObject* partObject)
++{
++  TracePartFunction* item = (TracePartFunction*) findDepFromPart(part);
++  if (!item) {
++    item = new TracePartFunction(this, partObject, partFile);
++    item->setPosition(part);
++    addDep(item);
++#if USE_FIXCOST
++    part->addDep(item);
++#endif
++
++    if (_cls) {
++      TracePartClass* partClass = _cls->partClass(part);
++      partClass->addPartFunction(item);
++      item->setPartClass(partClass);
++    }
++
++    partFile->addPartFunction(item);
++    if (partObject)
++      partObject->addPartFunction(item);
++  }
++  else if (item->partObject()==0 && partObject) {
++    item->setPartObject(partObject);
++    partObject->addPartFunction(item);
++  }
++
++  return item;
++}
++
++
++SubCost TraceFunction::calledCount()
++{
++  if (_dirty) update();
++
++  return _calledCount;
++}
++
++int TraceFunction::calledContexts()
++{
++  if (_dirty) update();
++
++  return _calledContexts;
++}
++
++SubCost TraceFunction::callingCount()
++{
++  if (_dirty) update();
++
++  return _callingCount;
++}
++
++int TraceFunction::callingContexts()
++{
++  if (_dirty) update();
++
++  return _callingContexts;
++}
++
++TQString TraceFunction::prettyCalledCount()
++{
++  return _calledCount.pretty();
++}
++
++TQString TraceFunction::prettyCallingCount()
++{
++  return _callingCount.pretty();
++}
++
++
++TraceCallList TraceFunction::callers(bool skipCycle) const
++{
++    if (skipCycle) return _callers;
++
++  // fake the callers for cycle members
++  if (_cycle && (_cycle != this)) {
++    TraceCallList l;
++    TraceCall* c;
++
++    // inner-cycle-callers
++    TraceCallList list=_callers;
++    for (c=list.first();c;c=list.next())
++      if (c->caller()->cycle() == _cycle)
++        l.append(c);
++
++    // call from cycle itself
++    for (c=_cycle->_callings.first();c;c=_cycle->_callings.next())
++      if (c->called() == this) {
++        l.append(c);
++        return l;
++      }
++  }
++
++  return _callers;
++}
++
++const TraceCallList& TraceFunction::callings(bool /* skipCycle */) const
++{
++  return _callings;
++}
++
++void TraceFunction::invalidateDynamicCost()
++{
++  TraceCall* c;
++  for (c=_callings.first();c;c=_callings.next())
++    c->invalidateDynamicCost();
++
++  TraceFunctionSource* sf;
++  for (sf=_sourceFiles.first();sf;sf=_sourceFiles.next())
++    sf->invalidateDynamicCost();
++
++  if (_instrMap) {
++    TraceInstrMap::Iterator iit;
++    for ( iit = _instrMap->begin();
++          iit != _instrMap->end(); ++iit )
++      (*iit).invalidate();
++  }
++
++  invalidate();
++}
++
++void TraceFunction::update()
++{
++  if (!_dirty) return;
++
++#if TRACE_DEBUG
++  qDebug("Update %s (Callers %d, sourceFiles %d, instrs %d)",
++         _name.ascii(), _callers.count(),
++	 _sourceFiles.count(), _instrMap ? _instrMap->count():0);
++#endif
++
++  _calledCount    = 0;
++  _callingCount    = 0;
++  _calledContexts  = 0;
++  _callingContexts = 0;
++  clear();
++
++  // context count is NOT the sum of part contexts
++  TraceCall *caller, *calling;
++  for (caller=_callers.first();caller;caller=_callers.next()) {
++    // FIXME
++    if (caller->subCost(0)>0)
++      _calledContexts++;
++    _calledCount += caller->callCount();
++  }
++
++  for (calling=_callings.first();calling;calling=_callings.next()) {
++    // FIXME
++    if (calling->subCost(0)>0)  _callingContexts++;
++    _callingCount += calling->callCount();
++  }
++
++  if (data()->inFunctionCycleUpdate() || !_cycle) {
++      // usual case (no cycle member)
++      TraceInclusiveCost* item;
++      for (item=_deps.first();item;item=_deps.next()) {
++	  if (!item->part() || !item->part()->isActive()) continue;
++
++	  addCost(item);
++	  addInclusive(item->inclusive());
++      }
++  }
++  else {
++    // this is a cycle or cycle member
++    for (calling=_callings.first();calling;calling=_callings.next()) {
++
++	// ignore inner-cycle member calls for inclusive cost
++	if ((_cycle != this) &&
++	    (calling->inCycle()>0))  continue;
++
++	addInclusive(calling);
++    }
++
++    // self cost
++    if (type() == FunctionCycle) {
++      // cycle: self cost is sum of cycle member self costs, but
++      //        doesn't add to inclusive cost
++      TraceFunctionList mList = ((TraceFunctionCycle*)this)->members();
++      TraceFunction* m;
++      for (m=mList.first();m;m=mList.next())
++	  addCost(m);
++    }
++    else {
++      // cycle member
++      TraceInclusiveCost* item;
++      for (item=_deps.first();item;item=_deps.next()) {
++	if (!item->part() || !item->part()->isActive()) continue;
++	
++	addCost(item);
++      }
++      _dirty = false; // don't recurse
++      addInclusive(this);
++    }
++  }
++  _dirty = false;
++
++#if TRACE_DEBUG
++  qDebug("> %s", costString(0).ascii());
++#endif
++}
++
++bool TraceFunction::isCycle()
++{
++    return _cycle == this;
++}
++
++bool TraceFunction::isCycleMember()
++{
++    return _cycle && (_cycle != this);
++}
++
++void TraceFunction::cycleReset()
++{
++  _cycle = 0;
++  _cycleStackDown = 0;
++  _cycleLow = 0;
++}
++
++// this doesn't mark functions calling themself !
++void TraceFunction::cycleDFS(int d, int& pNo, TraceFunction** pTop)
++{
++  if (_cycleLow != 0) return;
++
++  if (0)
++      qDebug("%s D%02d > %s (%d)",
++	     TQString().fill(' ', d).ascii(), d, prettyName().ascii(), pNo+1);
++
++
++
++  // initialize with prefix order
++  pNo++;
++  int prefixNo = pNo;
++  _cycleLow = prefixNo;
++
++  // put myself on stack
++  _cycleStackDown = *pTop;
++  *pTop = this;
++
++  /* cycle cut heuristic:
++   * skip calls for cycle detection if they make less than _cycleCut
++   * percent of the cost of the function.
++   * FIXME: Which cost type to use for this heuristic ?!
++   */
++
++  SubCost base = 0;
++  if (_callers.count()>0) {
++      TraceCallList l = _callers;
++      TraceCall *caller;
++
++      for (caller=l.first();caller;caller=l.next())
++	  if (caller->subCost(0) > base)
++	      base = caller->subCost(0);
++  }
++  else base = inclusive()->subCost(0);
++
++  SubCost cutLimit = SubCost(base * Configuration::cycleCut());
++
++  if (0)
++      qDebug("%s       Cum. %s, Max Caller %s, cut limit %s",
++	     TQString().fill(' ', d).ascii(),
++	     inclusive()->subCost(0).pretty().ascii(),
++	     base.pretty().ascii(),
++	     cutLimit.pretty().ascii());
++
++  TraceCall *calling;
++  TraceCallList l = _callings;
++  for (calling=l.first();calling;calling=l.next()) {
++    TraceFunction* called = calling->called();
++
++      // cycle cut heuristic
++      if (calling->subCost(0) < cutLimit) {
++	  if (0) qDebug("%s       Cut call to %s (cum. %s)",
++			TQString().fill(' ', d).ascii(),
++			called->prettyName().ascii(),
++			calling->subCost(0).pretty().ascii());
++
++	  continue;
++      }
++
++    if (called->_cycleLow==0) {
++      // not visited yet
++      called->cycleDFS(d+1, pNo, pTop);
++      if (called->_cycleLow < _cycleLow)
++        _cycleLow = called->_cycleLow;
++    }
++    else if (called->_cycleStackDown) {
++	// backlink to same SCC (still in stack)
++	if (called->_cycleLow < _cycleLow)
++	    _cycleLow = called->_cycleLow;
++
++	if (0)
++	    qDebug("%s D%02d - %s (%d)",
++		   TQString().fill(' ', d+1).ascii(), d+1, 
++		   called->prettyName().ascii(), called->_cycleLow);
++    }
++    else {
++	if (0)
++	    qDebug("%s D%02d - %s (%d) [Not on stack]",
++		   TQString().fill(' ', d+1).ascii(), d+1, 
++		   called->prettyName().ascii(), called->_cycleLow);
++    }
++  }
++
++  if (prefixNo == _cycleLow) {
++    // this is the base of a SCC.
++
++    if (*pTop == this) {
++      *pTop = _cycleStackDown;
++      _cycleStackDown = 0;
++    }
++    else {
++      // a SCC with >1 members
++
++      TraceFunctionCycle* cycle = data()->functionCycle(this);
++      if (0) qDebug("BASE CYC %d %s",
++             cycle->cycleNo(), prettyName().ascii());
++      while(*pTop) {
++        TraceFunction* top = *pTop;
++        cycle->add(top);
++
++        // remove from stack
++        *pTop = top->_cycleStackDown;
++        top->_cycleStackDown = 0;
++
++        if (0) qDebug("CYC %s", top->prettyName().ascii());
++        if (top == this) break;
++      }
++    }
++  }
++  if (0)
++      qDebug("%s D%02d < %s (%d)",
++	     TQString().fill(' ', d).ascii(), d, 
++	     prettyName().ascii(), _cycleLow);
++}
++
++
++TraceInstrMap* TraceFunction::instrMap()
++{
++#if USE_FIXCOST
++
++    if (_instrMapFilled) return _instrMap;
++    _instrMapFilled = true;
++    if (!_instrMap)
++	_instrMap = new TraceInstrMap;
++
++  TraceLine* l = 0;
++  TraceInstr* i = 0;
++  TracePartInstr* pi = 0;
++  TraceInstrCall* ic = 0;
++  TracePartInstrCall* pic = 0;
++
++  TraceInclusiveCostList pfList = deps();
++  TracePartFunction* pf = (TracePartFunction*) pfList.first();
++  for(; pf; pf = (TracePartFunction*) pfList.next()) {
++
++      if (0) qDebug("PartFunction %s:%d",
++		    pf->function()->name().ascii(), pf->part()->partNumber());
++
++      FixCost* fc = pf->firstFixCost();
++      for(; fc; fc = fc->nextCostOfPartFunction()) {
++	  if (fc->addr() == 0) continue;
++
++	  if (!l || (l->lineno() != fc->line()) ||
++	      (l->functionSource() != fc->functionSource()))
++	      l = fc->functionSource()->line(fc->line(),true);
++
++	  if (!i || i->addr() != fc->addr()) {
++	      i = &(*_instrMap)[fc->addr()];
++	      if (!i->isValid()) {
++		  i->setFunction(this);
++		  i->setAddr(fc->addr());
++		  i->setLine(l);
++	      }
++	      pi = 0;
++	  }
++	  if (!pi || pi->part() != fc->part())
++	      pi = i->partInstr(fc->part(), pf);
++	  fc->addTo(pi);
++      }
++
++      TraceInstr* to = 0;
++      TraceInstrJump* ij;
++      TracePartInstrJump* pij;
++      FixJump* fj = pf->firstFixJump();
++      for(; fj; fj = fj->nextJumpOfPartFunction()) {
++	  if (fj->addr() == 0) continue;
++
++	  if (!l || (l->lineno() != fj->line()) ||
++	      (l->functionSource() != fj->source()))
++	      l = fj->source()->line(fj->line(),true);
++
++	  if (!i || i->addr() != fj->addr()) {
++	      i = &(*_instrMap)[fj->addr()];
++	      if (!i->isValid()) {
++		  i->setFunction(this);
++		  i->setAddr(fj->addr());
++		  i->setLine(l);
++	      }
++	  }
++
++	  to = fj->targetFunction()->instr(fj->targetAddr(), true);
++
++	  ij = i->instrJump(to, fj->isCondJump());
++	  pij = ij->partInstrJump(fj->part());
++
++	  fj->addTo(pij);
++      }
++
++      TracePartCallList pcList = pf->partCallings();
++      TracePartCall* pc = pcList.first();
++      for(; pc; pc = pcList.next()) {
++
++	  if (0) qDebug("PartCall %s:%d",
++			pc->call()->name().ascii(),
++			pf->part()->partNumber());
++
++	  FixCallCost* fcc = pc->firstFixCallCost();
++	  for(; fcc; fcc = fcc->nextCostOfPartCall()) {
++	      if (fcc->addr() == 0) continue;
++
++	      if (!l || (l->lineno() != fcc->line()) ||
++		  (l->functionSource() != fcc->functionSource()))
++		  l = fcc->functionSource()->line(fcc->line(),true);
++
++	      if (!i || i->addr() != fcc->addr()) {
++		  i = &(*_instrMap)[fcc->addr()];
++		  if (!i->isValid()) {
++		      i->setFunction(this);
++		      i->setAddr(fcc->addr());
++		      i->setLine(l);
++		  }
++	      }
++	      if (!ic || ic->call() != pc->call() || ic->instr() != i) {
++		  ic = pc->call()->instrCall(i);
++		  pic = 0;
++	      }
++	      if (!pic || pic->part() != fcc->part())
++		  pic = ic->partInstrCall(fcc->part(), pc);
++
++	      fcc->addTo(pic);
++	      if (0) qDebug("Add FixCallCost %s:%d/0x%s, CallCount %s",
++			    fcc->functionSource()->file()->shortName().ascii(),
++			    fcc->line(), fcc->addr().toString().ascii(),
++			    fcc->callCount().pretty().ascii());
++	  }
++      }
++  }
++
++#endif
++
++  return _instrMap;
++}
++
++
++
++//---------------------------------------------------
++// TraceFunctionCycle
++
++TraceFunctionCycle::TraceFunctionCycle(TraceFunction* f, int n)
++{
++  _base = f;
++  _cycleNo = n;
++  _cycle = this;
++
++  setPosition(f->data());
++  setName(TQString("<cycle %1>").arg(n));
++
++  // reset to attributes of base function
++  setFile(_base->file());
++  setClass(_base->cls());
++  setObject(_base->object());
++}
++
++void TraceFunctionCycle::init()
++{
++  _members.clear();
++  _memberSet.clear();
++  _callers.clear();
++  // this deletes all TraceCall's to members
++  _callings.clear();
++
++  invalidate();
++}
++
++void TraceFunctionCycle::add(TraceFunction* f)
++{
++  _members.append(f);
++  _memberSet.insert(f,1);
++}
++
++void TraceFunctionCycle::setup()
++{
++  if (_members.count()==0) return;
++
++  TraceFunction* f;
++  for (f=_members.first();f;f=_members.next()) {
++
++    // the cycle takes all outside callers from its members
++    TraceCall *call;
++    TraceCallList l = f->callers();
++    for (call=l.first();call;call=l.next()) {
++      if ( _memberSet.contains(call->caller()) ) continue;
++      _callers.append(call);
++    }
++
++    // the cycle has a call to each member
++    call = new TraceCall(this, f);
++    call->invalidate();
++    _callings.append(call);
++
++    // now do some faking...
++    f->setCycle(this);
++  }
++  invalidate();
++}
++
++
++//---------------------------------------------------
++// TraceClass
++
++TraceClass::TraceClass()
++{
++  // we are the owner of items generated in our factory
++  _deps.setAutoDelete(true);
++}
++
++TraceClass::~TraceClass()
++{}
++
++TQString TraceClass::prettyName() const
++{
++  if (_name.isEmpty())
++    return TQString("(global)");
++  return _name;
++}
++
++TracePartClass* TraceClass::partClass(TracePart* part)
++{
++  TracePartClass* item = (TracePartClass*) findDepFromPart(part);
++  if (!item) {
++    item = new TracePartClass(this);
++    item->setPosition(part);
++    addDep(item);
++  }
++  return item;
++}
++
++void TraceClass::addFunction(TraceFunction* function)
++{
++#if TRACE_ASSERTIONS
++  if (function->cls() != this) {
++    qDebug("Can't add function to a class not enclosing this function\n");
++    return;
++  }
++
++  if (_functions.findRef(function)>=0) return;
++#endif
++
++  _functions.append(function);
++
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added\n %s (now %d)",
++         fullName().ascii(),
++         function->fullName().ascii(), _functions.count());
++#endif
++}
++
++
++
++//---------------------------------------------------
++// TraceFile
++
++TraceFile::TraceFile()
++{
++  // we are the owner of items generated in our factory
++  _deps.setAutoDelete(true);
++}
++
++TraceFile::~TraceFile()
++{}
++
++TracePartFile* TraceFile::partFile(TracePart* part)
++{
++  TracePartFile* item = (TracePartFile*) findDepFromPart(part);
++  if (!item) {
++    item = new TracePartFile(this);
++    item->setPosition(part);
++    addDep(item);
++  }
++  return item;
++}
++
++void TraceFile::addFunction(TraceFunction* function)
++{
++#if TRACE_ASSERTIONS
++  if (function->file() != this) {
++    qDebug("Can't add function to a file not enclosing this function\n");
++    return;
++  }
++
++  if (_functions.findRef(function)>=0) return;
++#endif
++
++  _functions.append(function);
++
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added\n %s (now %d)",
++         fullName().ascii(),
++         function->fullName().ascii(), _functions.count());
++#endif
++}
++
++
++void TraceFile::addSourceFile(TraceFunctionSource* sourceFile)
++{
++#if TRACE_ASSERTIONS
++  if (sourceFile->file() != this) {
++    qDebug("Can't add sourceFile to a file not having lines for it\n");
++    return;
++  }
++#endif
++
++  _sourceFiles.append(sourceFile);
++  // not truely needed, as we don't use the sourceFiles for cost update
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s \n added SourceFile %s (now %d)",
++         fullName().ascii(), sourceFile->fullName().ascii(),
++         _sourceFiles.count());
++#endif
++}
++
++
++
++void TraceFile::setDirectory(const TQString& dir)
++{
++  if (dir.endsWith("/"))
++    _dir = dir.left(dir.length()-1);
++  else
++    _dir = dir;
++}
++
++TQString TraceFile::directory()
++{
++  if (!_dir.isEmpty()) return _dir;
++
++  int lastIndex = 0, index;
++  while ( (index=_name.find("/", lastIndex)) >=0)
++    lastIndex = index+1;
++
++  if (lastIndex==0) return TQString();
++
++  // without ending "/"
++  return _name.left(lastIndex-1);
++}
++
++
++TQString TraceFile::shortName() const
++{
++  int lastIndex = 0, index;
++  while ( (index=_name.find("/", lastIndex)) >=0)
++    lastIndex = index+1;
++
++  return _name.mid(lastIndex);
++}
++
++TQString TraceFile::prettyName() const
++{
++    TQString sn = shortName();
++    
++    if (sn.isEmpty())
++	return i18n("(unknown)");
++
++    return sn;
++}
++
++TQString TraceFile::prettyLongName() const
++{
++  if (_name.isEmpty())
++    return i18n("(unknown)");
++  return _name;
++}
++
++
++//---------------------------------------------------
++// TraceObject
++
++TraceObject::TraceObject()
++{
++  // we are the owner of items generated in our factory
++  _deps.setAutoDelete(true);
++}
++
++TraceObject::~TraceObject()
++{}
++
++TracePartObject* TraceObject::partObject(TracePart* part)
++{
++  TracePartObject* item = (TracePartObject*) findDepFromPart(part);
++  if (!item) {
++    item = new TracePartObject(this);
++    item->setPosition(part);
++    addDep(item);
++  }
++  return item;
++}
++
++void TraceObject::addFunction(TraceFunction* function)
++{
++#if TRACE_ASSERTIONS
++  if (function->object() != this) {
++    qDebug("Can't add function to an object not enclosing this function\n");
++    return;
++  }
++
++  if (_functions.findRef(function)>=0) return;
++#endif
++
++  _functions.append(function);
++
++  invalidate();
++
++#if TRACE_DEBUG
++  qDebug("%s added\n %s (now %d)",
++         fullName().ascii(),
++         function->fullName().ascii(), _functions.count());
++#endif
++}
++
++// strip path
++void TraceObject::setName(const TQString& name)
++{
++  _name = name;
++
++  int lastIndex = 0, index;
++  while ( (index=_name.find("/", lastIndex)) >=0)
++    lastIndex = index+1;
++
++  _shortName = _name.mid(lastIndex);
++}
++
++TQString TraceObject::prettyName() const
++{
++  if (_shortName.isEmpty())
++    return i18n("(unknown)");
++
++  return _shortName;
++}
++
++//---------------------------------------------------
++// TracePart
++
++TracePart::TracePart(TraceData* data, TQFile* file)
++{
++  setPosition(data);
++
++  _dep = data;
++  _file = file;
++  if (_file)
++    _name = _file->name();
++  _active = true;
++
++  _number = 0;
++  _tid = 0;
++  _pid = 0;
++
++  _fixSubMapping = 0;
++}
++
++TracePart::~TracePart()
++{
++  delete _file;
++
++  delete _fixSubMapping;
++}
++
++void TracePart::setPartNumber(int n)
++{
++    if (data()->maxPartNumber() <n) data()->setMaxPartNumber(n);
++    _number = n;
++}
++
++void TracePart::setThreadID(int tid)
++{
++    if (data()->maxThreadID() <tid) data()->setMaxThreadID(tid);
++    _tid = tid;
++}
++
++void TracePart::setProcessID(int pid)
++{
++    _pid = pid;
++}
++
++
++
++// strip path
++TQString TracePart::shortName() const
++{
++  int lastIndex = 0, index;
++  while ( (index=_name.find("/", lastIndex)) >=0)
++    lastIndex = index+1;
++
++  return _name.mid(lastIndex);
++}
++
++TQString TracePart::prettyName() const
++{
++    TQString name = TQString("%1.%2").arg(_pid).arg(_number);
++    if (data()->maxThreadID()>1)
++	name += TQString("-%3").arg(_tid);
++    return name;
++}
++
++bool TracePart::activate(bool active)
++{
++  if (_active == active) return false;
++  _active = active;
++
++  // to be done by the client of this function
++  //  data()->invalidateDynamicCost();
++  // So better use the TraceData functions...
++
++  return true;
++}
++
++
++
++//---------------------------------------------------
++// TracePartList
++
++int TracePartList::compareItems ( Item item1, Item item2 )
++{
++    TracePart* p1 = (TracePart*) item1;
++    TracePart* p2 = (TracePart*) item2;
++    int mTID = p1->data()->maxThreadID()+1;
++    int mNum = p1->data()->maxPartNumber()+1;
++
++    return
++	(p1->processID()  - p2->processID()) * mTID * mNum +
++	(p1->partNumber() - p2->partNumber()) * mTID +
++	(p1->threadID()   - p2->threadID());
++}
++
++TQString TracePartList::names() const
++{
++  TQString res;
++  TracePart* p;
++  TracePartList l = *this;
++  for (p=l.first();p;p=l.next()) {
++    if (!res.isEmpty()) res += ", ";
++    res += p->shortName();
++  }
++
++  return res;
++}
++
++
++
++//---------------------------------------------------
++// TraceData
++
++
++// create vectors with reasonable default sizes, but not wasting memory
++TraceData::TraceData(TopLevel* top)
++{
++    _topLevel = top;
++    init();
++}
++
++TraceData::TraceData(const TQString& base)
++{
++    _topLevel = 0;
++    init();
++    load(base);
++}
++
++void TraceData::init()
++{
++  _parts.setAutoDelete(true);
++
++  _functionCycleCount = 0;
++  _inFunctionCycleUpdate = false;
++
++  _maxThreadID = 0;
++  _maxPartNumber = 0;
++  _fixPool = 0;
++  _dynPool = 0;
++}
++
++TraceData::~TraceData()
++{
++  if (_fixPool) delete _fixPool;
++  if (_dynPool) delete _dynPool;
++}
++
++TQString TraceData::shortTraceName() const
++{
++  int lastIndex = 0, index;
++  while ( (index=_traceName.find("/", lastIndex)) >=0)
++    lastIndex = index+1;
++
++  return _traceName.mid(lastIndex);
++}
++
++FixPool* TraceData::fixPool()
++{
++  if (!_fixPool)
++    _fixPool = new FixPool();
++
++  return _fixPool;
++}
++
++DynPool* TraceData::dynPool()
++{
++  if (!_dynPool)
++    _dynPool = new DynPool();
++
++  return _dynPool;
++}
++
++
++/**
++ * Two cases:
++ *
++ * - <base> is a directory: Load first profile data file available
++ * - <base> is a file name without part/thread suffixes
++ */
++void TraceData::load(const TQString& base)
++{
++  bool baseExisting = true;
++
++  _traceName = base;
++  TQFileInfo finfo(base);
++  TQString file = finfo.fileName();
++  TQDir dir = finfo.dir();
++
++  if (!finfo.exists()) {
++    baseExisting = false;
++  }
++  else if (finfo.isDir()) {
++      // search for first profile data file in directory
++      dir = TQDir(base);
++
++      TQStringList prefixList;
++      prefixList << "callgrind.out" << "cachegrind.out";
++      for ( TQStringList::Iterator it = prefixList.begin();
++	    it != prefixList.end(); ++it ) {
++        file = *it;
++
++	// search for ".pid"
++	TQStringList strList = dir.entryList(file+".*", TQDir::Files);
++	if (strList.count()>0) {
++	  int l = file.length();
++	  file = strList.first();
++	  l++;
++	  while(file[l] >= '0' && file[l] <= '9') l++;
++	  file = file.left(l);
++	  break;
++	}
++      }
++
++      _traceName = dir.path() + "/" + file;
++  }
++
++  TQStringList strList;
++  strList += dir.entryList(file+".*", TQDir::Files);
++  strList += dir.entryList(file+"-*", TQDir::Files);
++
++  baseExisting = TQFile::exists(_traceName);
++  if (baseExisting)
++      strList << file;
++
++  if (strList.count() == 0) {
++      _traceName = base + "/" + file + " " + i18n("(not found)");
++      return;
++  }
++
++
++  // try to guess pid from file name
++  unsigned int pos = file.length();
++  unsigned int pid = 0, f=1;
++  pos--;
++  while(pos>0) {
++      if (file[pos] < '0' || file[pos] > '9') break;
++      pid += f * (file[pos].latin1() - '0');
++      pos--;
++      f *= 10;
++  }
++
++  TQStringList::Iterator it;
++  unsigned int maxNumber = 0;
++  for (it = strList.begin(); it != strList.end(); ++it ) {
++    TracePart* p = addPart( dir.path(), *it );
++
++    if (!p) {
++      kdDebug() << "Error loading " << *it << endl;
++      continue;
++    }
++
++    const TQString& str = *it;
++    unsigned int pos = file.length();
++
++    // try to guess part number from file name
++    unsigned int n = 0;
++    if ((str.length() > pos) && (str[pos] == '.')) {
++	pos++;
++	while(str.length()>pos) {
++	    if ((int)str.at(pos) < '0' || (int)str.at(pos) > '9') break;
++	    n = 10*n + (str[pos++] - '0');
++	}
++    }
++
++    // try to guess thread number from file name
++    unsigned int t = 0;
++    if ((str.length() > pos) && (str[pos] == '-')) {
++	pos++;
++	while(str.length()>pos) {
++	    if ((int)str.at(pos) < '0' || (int)str.at(pos) > '9') break;
++	    t = 10*t + (str[pos++] - '0');
++	}
++    }
++
++    //qDebug("File %s: Part %d, Thread %d", (*it).ascii(), n, t);
++
++    if (p->partNumber()>0) n = p->partNumber();
++    if (n>maxNumber) maxNumber = n;
++    if (n==0) n = maxNumber+1;
++    p->setPartNumber(n);
++
++    if (p->threadID()==0) p->setThreadID(t);
++    if (p->processID()==0) p->setProcessID(pid);
++
++    _parts.append(p);
++  }
++  _parts.sort();
++
++  invalidateDynamicCost();
++  updateFunctionCycles();
++
++  // clear loading messages from status bar
++  if (_topLevel) _topLevel->showStatus(TQString(), 0);
++}
++
++TracePart* TraceData::addPart(const TQString& dir, const TQString& name)
++{
++    TQString filename = TQString("%1/%2").arg(dir).arg(name);
++#if TRACE_DEBUG
++  qDebug("TraceData::addPart('%s')", filename.ascii());
++#endif
++
++  TQFile* file = new TQFile(filename);
++
++  Loader* l = Loader::matchingLoader(file);
++  if (!l) return 0;
++
++  if (_topLevel)
++      _topLevel->connect(l, TQT_SIGNAL(updateStatus(TQString, int)),
++			 TQT_SLOT(showStatus(TQString, int)));
++
++  TracePart* part = new TracePart(this, file);
++
++  if (! l->loadTrace(part)) {
++      delete part;
++      part = 0;
++  }
++
++  if (_topLevel) l->disconnect(_topLevel);
++
++  return part;
++}
++
++bool TraceData::activateParts(const TracePartList& l)
++{
++  bool changed = false;
++
++  TracePart* part;
++  for (part=_parts.first();part;part=_parts.next())
++    if (part->activate(l.containsRef(part)>0))
++        changed = true;
++
++  if (changed) {
++      // because active parts have changed, throw away calculated
++      // costs...
++      invalidateDynamicCost();
++      updateFunctionCycles();
++  }
++
++  return changed;
++}
++
++
++bool TraceData::activateParts(TracePartList l, bool active)
++{
++  bool changed = false;
++
++  TracePart* part;
++  for (part=l.first();part;part=l.next())
++    if (_parts.findRef(part)>=0)
++      if (part->activate(active))
++        changed = true;
++
++  if (changed) {
++      invalidateDynamicCost();
++      updateFunctionCycles();
++  }
++
++  return changed;
++}
++
++bool TraceData::activatePart(TracePart* p, bool active)
++{
++  return p->activate(active);
++}
++
++bool TraceData::activateAll(bool active)
++{
++  return activateParts(_parts, active);
++}
++
++
++TracePart* TraceData::part(TQString& name)
++{
++  TracePart* part;
++  for (part=_parts.first();part;part=_parts.next())
++    if (part->name() == name)
++      return part;
++  return 0;
++}
++
++TQString TraceData::activePartRange()
++{
++  TQString res;
++  int r1=-1, r2=-1, count=1;
++  TracePart* part;
++  for (part=_parts.first();part;part=_parts.next(), count++)
++    if (part->isActive()) {
++      if (r1<0) { r1 = r2 = count; }
++      else if (r2 == count-1) { r2 = count; }
++      else {
++        if (!res.isEmpty()) res += ";";
++        if (r1==r2) res += TQString::number(r1);
++        else res += TQString("%1-%2").arg(r1).arg(r2);
++        r1 = r2 = count;
++      }
++    }
++  if (r1>=0) {
++    if (!res.isEmpty()) res += ";";
++    if (r1==r2) res += TQString::number(r1);
++    else res += TQString("%1-%2").arg(r1).arg(r2);
++  }
++
++  return res;
++}
++
++void TraceData::invalidateDynamicCost()
++{
++  // invalidate all dynamic costs
++
++  TraceObjectMap::Iterator oit;
++  for ( oit = _objectMap.begin();
++        oit != _objectMap.end(); ++oit )
++    (*oit).invalidate();
++
++  TraceClassMap::Iterator cit;
++  for ( cit = _classMap.begin();
++        cit != _classMap.end(); ++cit )
++    (*cit).invalidate();
++
++  TraceFileMap::Iterator fit;
++  for ( fit = _fileMap.begin();
++        fit != _fileMap.end(); ++fit )
++    (*fit).invalidate();
++
++  TraceFunctionMap::Iterator it;
++  for ( it = _functionMap.begin();
++        it != _functionMap.end(); ++it ) {
++    (*it).invalidateDynamicCost();
++  }
++
++  invalidate();
++
++}
++
++
++TraceObject* TraceData::object(const TQString& name)
++{
++  TraceObject& o = _objectMap[name];
++  if (!o.data()) {
++    // was created
++    o.setPosition(this);
++    o.setName(name);
++
++#if TRACE_DEBUG
++    qDebug("Created %s [TraceData::object]",
++           o.fullName().ascii());
++#endif
++  }
++  return &o;
++}
++
++
++TraceFile* TraceData::file(const TQString& name)
++{
++  TraceFile& f = _fileMap[name];
++  if (!f.data()) {
++    // was created
++    f.setPosition(this);
++    f.setName(name);
++
++#if TRACE_DEBUG
++    qDebug("Created %s [TraceData::file]",
++           f.fullName().ascii());
++#endif
++  }
++  return &f;
++}
++
++
++// usually only called by function()
++TraceClass* TraceData::cls(const TQString& fnName, TQString& shortName)
++{
++  int lastIndex = 0, index, pIndex;
++
++  // we ignore any "::" after a '(' or a space
++  pIndex=fnName.find("(", 0);
++
++#if 0
++  int sIndex=fnName.find(" ", 0);
++  if (sIndex>=0)
++    if ((pIndex == -1) || (sIndex < pIndex))
++      pIndex = sIndex;
++#endif
++
++  while ((index=fnName.find("::", lastIndex)) >=0) {
++    if (pIndex>=0 && pIndex<index) break;
++    lastIndex = index+2;
++  }
++
++  TQString clsName = (lastIndex < 3) ? TQString() :
++                    fnName.left(lastIndex-2);
++  shortName = fnName.mid(lastIndex);
++
++  TraceClass& c = _classMap[clsName];
++  if (!c.data()) {
++    // was created
++    c.setPosition(this);
++    c.setName(clsName);
++
++#if TRACE_DEBUG
++    qDebug("Created %s [TraceData::cls]",
++           c.fullName().ascii());
++#endif
++  }
++  return &c;
++}
++
++
++// name is inclusive class/namespace prefix
++TraceFunction* TraceData::function(const TQString& name,
++                                   TraceFile* file, TraceObject* object)
++{
++  // strip class name
++  TQString shortName;
++  TraceClass* c = cls(name, shortName);
++
++  if (!file || !object || !c) {
++    qDebug("ERROR - no file/object/class for %s ?!", name.ascii());
++    return 0;
++  }
++
++  // Don't use file in key: A function can go over many files
++  // (inlined parts), but still is ONE function.
++  TQString key = name + object->shortName();
++
++  TraceFunctionMap::Iterator it;
++  it = _functionMap.find(key);
++  if (it == _functionMap.end()) {
++      it = _functionMap.insert(key, TraceFunction());
++      TraceFunction& f = it.data();
++
++      f.setPosition(this);
++      f.setName(name);
++      f.setClass(c);
++      f.setObject(object);
++      f.setFile(file);
++      f.setMapIterator(it);
++
++#if TRACE_DEBUG
++      qDebug("Created %s [TraceData::function]\n  for %s, %s, %s",
++	     f.fullName().ascii(),
++	     c->fullName().ascii(), file->fullName().ascii(),
++	     object ? object->fullName().ascii() : "(unknown object)");
++#endif
++
++      c->addFunction(&f);
++      object->addFunction(&f);
++      file->addFunction(&f);
++  }
++
++  return &(it.data());
++}
++
++TraceFunctionMap::Iterator TraceData::functionIterator(TraceFunction* f)
++{
++
++  // IMPORTANT: build as SAME key as used in function() above !!
++  TQString key;
++
++  if (f->cls()) key = f->cls()->name() + "::";
++  key += f->name();
++  key += f->object()->shortName();
++
++  return _functionMap.find(key);
++}
++
++TraceFunctionMap::ConstIterator TraceData::functionBeginIterator() const
++{
++  return _functionMap.begin();
++}
++
++TraceFunctionMap::ConstIterator TraceData::functionEndIterator() const
++{
++  return _functionMap.end();
++}
++
++
++void TraceData::resetSourceDirs()
++{
++  TraceFileMap::Iterator fit;
++  for ( fit = _fileMap.begin();
++        fit != _fileMap.end(); ++fit )
++    (*fit).resetDirectory();
++}
++
++void TraceData::update()
++{
++  if (!_dirty) return;
++
++  clear();
++  _totals.clear();
++
++  TracePart* part;
++  for (part=_parts.first();part;part=_parts.next()) {
++    _totals.addCost(part->totals());
++    if (part->isActive())
++	addCost(part->totals());
++  }
++
++  _dirty = false;
++}
++
++TraceCost* TraceData::search(TraceItem::CostType t, TQString name,
++			     TraceCostType* ct, TraceCost* parent)
++{
++    TraceCost* result = 0;
++    TraceItem::CostType pt = parent ? parent->type() : NoCostType;
++    SubCost sc, scTop = 0;
++
++    switch(t) {
++    case Function:
++	{
++	    TraceFunction *f;
++	    TraceFunctionMap::Iterator it;
++	    for ( it = _functionMap.begin();
++		  it != _functionMap.end(); ++it ) {
++		f = &(*it);
++
++		if (f->name() != name) continue;
++
++		if ((pt == Class) && (parent != f->cls())) continue;
++		if ((pt == File) && (parent != f->file())) continue;
++		if ((pt == Object) && (parent != f->object())) continue;
++
++		if (ct) {
++		    sc = f->inclusive()->subCost(ct);
++		    if (sc <= scTop) continue;
++		    scTop = sc;
++		}
++
++		result = f;
++	    }
++	}
++	break;
++
++    case File:
++	{
++	    TraceFile *f;
++	    TraceFileMap::Iterator it;
++	    for ( it = _fileMap.begin();
++		  it != _fileMap.end(); ++it ) {
++		f = &(*it);
++		if (f->name() != name) continue;
++		if (ct) {
++		    sc = f->subCost(ct);
++		    if (sc <= scTop) continue;
++		    scTop = sc;
++		}
++		result = f;
++	    }
++	}
++	break;
++
++    case Class:
++	{
++	    TraceClass *c;
++	    TraceClassMap::Iterator it;
++	    for ( it = _classMap.begin();
++		  it != _classMap.end(); ++it ) {
++		c = &(*it);
++		if (c->name() != name) continue;
++		if (ct) {
++		    sc = c->subCost(ct);
++		    if (sc <= scTop) continue;
++		    scTop = sc;
++		}
++		result = c;
++	    }
++	}
++	break;
++
++    case Object:
++	{
++	    TraceObject *o;
++	    TraceObjectMap::Iterator it;
++	    for ( it = _objectMap.begin();
++		  it != _objectMap.end(); ++it ) {
++		o = &(*it);
++		if (o->name() != name) continue;
++		if (ct) {
++		    sc = o->subCost(ct);
++		    if (sc <= scTop) continue;
++		    scTop = sc;
++		}
++		result = o;
++	    }
++	}
++	break;
++
++    case Instr:
++	if (pt == Function) {
++	    TraceInstrMap* instrMap = ((TraceFunction*)parent)->instrMap();
++	    if (!instrMap) break;
++
++	    TraceInstr *instr;
++	    TraceInstrMap::Iterator it;
++	    for ( it = instrMap->begin();
++		  it != instrMap->end(); ++it ) {
++		instr = &(*it);
++		if (instr->name() != name) continue;
++		result = instr;
++	    }
++	}
++	break;
++
++    case Line:
++	{
++	    TraceFunctionSourceList sList;
++	    if (pt == Function)
++		sList = ((TraceFunction*)parent)->sourceFiles();
++	    else if (pt == FunctionSource)
++		sList.append((TraceFunctionSource*) parent);
++	    else break;
++
++	    TraceLineMap* lineMap;
++	    TraceLine* line;
++	    TraceLineMap::Iterator it;
++	    TraceFunctionSource* fs;
++	    for(fs = sList.first(); fs; fs = sList.next()) {
++		lineMap = fs->lineMap();
++		if (!lineMap) continue;
++
++		for ( it = lineMap->begin();
++		      it != lineMap->end(); ++it ) {
++		    line = &(*it);
++		    if (line->name() != name) continue;
++		    result = line;
++		}
++	    }
++	}
++	break;
++
++    default:
++	break;
++    }
++
++    return result;
++}
++
++
++TraceFunctionCycle* TraceData::functionCycle(TraceFunction* f)
++{
++  TraceFunctionCycle* cycle;
++  for (cycle=_functionCycles.first();cycle;cycle=_functionCycles.next())
++    if (cycle->base() == f) return cycle;
++
++  _functionCycleCount++;
++  cycle = new TraceFunctionCycle(f, _functionCycleCount);
++
++  _functionCycles.append(cycle);
++  return cycle;
++}
++
++
++void TraceData::updateFunctionCycles()
++{
++    //qDebug("Updating cycles...");
++
++  // init cycle info
++  TraceFunctionCycle* cycle;
++  for (cycle=_functionCycles.first();cycle;cycle=_functionCycles.next())
++    cycle->init();
++
++  TraceFunctionMap::Iterator it;
++  for ( it = _functionMap.begin(); it != _functionMap.end(); ++it )
++    (*it).cycleReset();
++
++  if (!Configuration::showCycles()) return;
++
++  _inFunctionCycleUpdate = true;
++
++
++#if 0
++  int fCount = _functionMap.size(), fNo = 0, progress=0, p;
++  TQString msg = i18n("Recalculating Function Cycles...");
++  if (_topLevel) _topLevel->showStatus(msg,0);
++#endif
++
++  // DFS and collapse strong connected components (Tarjan)
++  int pNo = 0;
++  TraceFunction* stackTop;
++  for ( it = _functionMap.begin(); it != _functionMap.end(); ++it ) {
++
++#if 0
++      if (_topLevel) {
++	  fNo++;
++	  p = 100*fNo/fCount;
++	  if (p> progress) {
++	      progress = p;
++	      _topLevel->showStatus(msg, p);
++	  }
++      }
++#endif
++
++    stackTop = 0;
++    (*it).cycleDFS(1, pNo, &stackTop);
++  }
++
++  // postprocess cycles
++  for (cycle=_functionCycles.first();cycle;cycle=_functionCycles.next())
++    cycle->setup();
++
++  _inFunctionCycleUpdate = false;
++  // we have to invalidate costs because cycles are now taken into account
++  invalidateDynamicCost();
++
++#if 0
++  if (0) if (_topLevel) _topLevel->showStatus(TQString(),0);
++#endif
++}
++
++void TraceData::updateObjectCycles()
++{
++}
++
++
++void TraceData::updateClassCycles()
++{
++}
++
++
++void TraceData::updateFileCycles()
++{
++}
++
++
+diff --git a/kdecachegrind/kdecachegrind/tracedata.h b/kdecachegrind/kdecachegrind/tracedata.h
+new file mode 100644
+index 0000000..8fab2b6
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/tracedata.h
+@@ -0,0 +1,1967 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Classes holding profiling data for
++ * multiple tracefiles for one command.
++ * See class TraceData first.
++ */
++
++#ifndef TRACEDATA_H
++#define TRACEDATA_H
++
++#include <tqstring.h>
++#include <tqstringlist.h>
++#include <tqptrlist.h>
++#include <tqmap.h>
++#include <tqptrvector.h>
++#include <tqcolor.h>
++
++#include "subcost.h"
++#include "utils.h"
++
++class TQFile;
++
++/**
++ * All cost items are classes prefixed with "Trace".
++ * "TraceCost" holds basic cost metrics for the simplest, smallest
++ * trace entity: These are events counted for an instruction at
++ * a specific memory address of the traced program.
++ * All other cost items are derived from TraceCost, and add needed
++ * cost metrics, e.g. for a call the number of calls that happened.
++ *
++ * Abstract, i.e. never instantiated cost items are
++ * - TraceCost: Basic cost metrics (instr/read/write access + cache events)
++ * - TraceCallCost: Additional call count cost metric.
++ * - TraceInclusiveCost: Additional TraceCost aggregated.
++ * - TraceListCost: Adds dependency to a list of TraceCost's
++ * - TraceCallListCost: same for list of TraceCallCost's
++ * - TraceInclusiveListCost: same for list of TraceInclusiveCost's
++ * - TraceCostItem: Base for cost items for "interesting" costs:
++ *              TraceFunction, TraceClass, TraceFile, TraceObject
++ *
++ * The smallest Cachegrind output is trace data indexed by a source
++ * line number, a TracePartLine. Another one is a call from one
++ * source line of a function to another function, a TracePartLineCall.
++ * All other cost items derive the value by summation of cost metrics
++ * from TraceLineItem and TracePartLineCall costs; their cost is
++ * calculated lazy on demand and cached afterwards.
++ *
++ * For cost items, which are sums over all trace files read in, the
++ * summed cost metrics change when e.g. a new trace file is read.
++ * Thus, their cached costs are invalidated, and again recalculated
++ * only on demand. In the following list, theses cost items are called
++ * "dynamic", the other "fixed" (but neverless calculated lazy).
++ *
++ *  Cost Item          Type      Summation of ...
++ *
++ *  TracePartLineCall  fixed     Read from trace file
++ *  TracePartLine      fixed     Read from trace file
++ *  TracePartCall      fixed     TracePartLineCall's
++ *  TraceLineCall      dynamic   TracePartLineCall's
++ *  TraceCall          dynamic   TraceLineCall's
++ *  TraceLine          dynamic   TracePartLine's and TraceLineCall's
++ *  TracePartFunction  fixed     TracePartLine's / TracePartCall's
++ *  TraceFunction      dynamic   TraceLine's / TraceCall's (called from)
++ *  TracePartClass     fixed     TracePartFunction's
++ *  TraceClass         dynamic   TraceFunction's
++ *  TracePartFile      fixed     TracePartFunction's
++ *  TraceFile          dynamic   TraceFunction's
++ *  TracePartObject    fixed     TracePartFunction's
++ *  TraceObject        dynamic   TraceFunction's
++ *  TracePart          fixed     TracePartLine's
++ *  TraceData          dynamic   TracePart's
++ *
++ * As there exists only one TraceData object for a traced program, its the
++ * owner of some "high level" cost items. The following shows the owner
++ * relationship of the cost item classes, together with references.
++ *
++ *  Cost Item          Owner (& back ref)   Other References to
++ *
++ *  TracePartLineCall  TraceLineCall
++ *  TracePartCall      TraceCall            TracePartLineCall's
++ *  TracePartLine      TraceLine            TracePartLineCall's
++ *  TracePartFunction  TraceFunction
++ *  TracePartClass     TraceClass           TracePart
++ *  TracePartFile      TraceFile            TracePart
++ *  TracePartObject    TraceObject          TracePart
++ *  TraceLineCall      TraceCall            TracePartLineCall's
++ *  TraceCall          TraceFunction        TracePartCall's
++ *  TraceLine          TraceData            TraceLineCall's
++ *  TraceFunction      TraceData            TraceCall's (calling)
++ *  TraceClass         TraceData
++ *  TraceFile          TraceData
++ *  TraceObject        TraceData
++ *  TracePart          TraceData
++ *  TraceData          Main Application
++ *
++ * Convention:
++ * - The owner has a factory method for owned objects,
++ *   and calls addXXX() to install references in other objects
++ * - The owner is first arg in a constructor.
++ */
++
++
++class FixString;
++class FixCost;
++class FixCallCost;
++class FixJump;
++class FixPool;
++class DynPool;
++class TopLevel;
++
++class TraceCost;
++class TraceCostType;
++class TraceCostMapping;
++class TraceSubMapping;
++class TraceJumpCost;
++class TraceCallCost;
++class TraceInclusiveCost;
++
++class TracePartInstr;
++class TracePartInstrCall;
++class TracePartLine;
++class TracePartLineCall;
++class TracePartCall;
++class TracePartLineRegion;
++class TracePartFunction;
++class TracePartClass;
++class TracePartObject;
++class TracePartFile;
++
++class TraceInstr;
++class TraceInstrJump;
++class TraceInstrCall;
++class TraceLine;
++class TraceLineJump;
++class TraceLineCall;
++class TraceCall;
++class TraceLineRegion;
++class TraceFunctionSource;
++class TraceFunction;
++class TraceFunctionCycle;
++class TraceClass;
++class TraceObject;
++class TraceFile;
++class TracePart;
++class TraceData;
++
++typedef TQPtrList<TraceCost> TraceCostList;
++typedef TQPtrList<TraceJumpCost> TraceJumpCostList;
++typedef TQPtrList<TraceCallCost> TraceCallCostList;
++typedef TQPtrList<TraceInclusiveCost> TraceInclusiveCostList;
++
++typedef TQPtrList<TracePartCall>  TracePartCallList;
++typedef TQPtrList<TracePartInstr> TracePartInstrList;
++typedef TQPtrList<TracePartLine>  TracePartLineList;
++typedef TQPtrList<TracePartLineRegion>  TracePartLineRegionList;
++typedef TQPtrList<TracePartFunction>  TracePartFunctionList;
++typedef TQPtrList<TracePartInstrCall> TracePartInstrCallList;
++typedef TQPtrList<TracePartLineCall>  TracePartLineCallList;
++
++
++typedef TQPtrList<TraceInstr> TraceInstrList;
++typedef TQPtrList<TraceLine> TraceLineList;
++typedef TQPtrList<TraceInstrCall> TraceInstrCallList;
++typedef TQPtrList<TraceLineCall> TraceLineCallList;
++typedef TQPtrList<TraceCall> TraceCallList;
++typedef TQPtrList<TraceFile> TraceFileList;
++typedef TQPtrList<TraceLineRegion> TraceLineRegionList;
++typedef TQPtrList<TraceFunctionSource> TraceFunctionSourceList;
++typedef TQPtrList<TraceFunction> TraceFunctionList;
++typedef TQPtrList<TraceFunctionCycle> TraceFunctionCycleList;
++typedef TQMap<TQString, TraceObject> TraceObjectMap;
++typedef TQMap<TQString, TraceClass> TraceClassMap;
++typedef TQMap<TQString, TraceFile> TraceFileMap;
++typedef TQMap<TQString, TraceFunction> TraceFunctionMap;
++typedef TQMap<uint, TraceLine> TraceLineMap;
++
++
++/**
++ * Addresses are 64bit values like costs to be able
++ * to always load profile data produced on 64bit
++ * architectures.
++ */
++class Addr
++{
++ public:
++  Addr() { _v=0; }
++  Addr(uint64 v) { _v = v; }
++
++  // Interpretes char data at s as hex (without "0x" prefix)
++  // and return number of interpreted chars.
++  int set(const char *s);
++  bool set(FixString& s);
++  TQString toString() const;
++  // similar to toString(), but adds a space every 4 digits
++  TQString pretty() const;
++
++  // returns true if this address is in [a-distance;a+distance]
++  bool isInRange(Addr a, int distance);
++
++  bool operator==(const Addr& a) const { return (_v == a._v); }
++  bool operator!=(const Addr& a) const { return (_v != a._v); }
++  bool operator>(const Addr& a) const { return _v > a._v; }
++  bool operator>=(const Addr& a) const { return _v >= a._v; }
++  bool operator<(const Addr& a) const { return _v < a._v; }
++  bool operator<=(const Addr& a) const { return _v <= a._v; }
++
++  Addr operator+(int d) const { return Addr(_v + d); }
++  Addr operator-(int d) const { return Addr(_v - d); }
++  
++ private:
++  uint64 _v;
++};
++
++typedef TQMap<Addr, TraceInstr> TraceInstrMap;
++
++
++/**
++ * Base class for cost items.
++ */
++class TraceItem
++{
++public:
++
++  // RTTI for trace item classes, using type() method
++  enum CostType { Item, Cost,
++		  PartInstr, Instr,
++                  PartLine, Line,
++		  PartInstrJump, InstrJump,
++                  PartLineJump, LineJump,
++		  PartInstrCall, InstrCall,
++                  PartLineCall, LineCall,
++                  PartCall, Call,
++		  PartLineRegion, LineRegion,
++                  PartFunction, FunctionSource, Function, FunctionCycle,
++                  PartClass, Class, ClassCycle,
++                  PartFile, File, FileCycle,
++                  PartObject, Object, ObjectCycle,
++                  Part, Data,
++                  MaxCostType, NoCostType };
++
++  TraceItem();
++  virtual ~TraceItem();
++
++  virtual CostType type() const { return Item; }
++
++  // conversion of item type to locale independent string (e.g. for config)
++  static TQString     typeName(CostType);
++  static CostType    costType(TQString);
++  // the versions below should be used for user visible strings, as
++  // these use localisation settings
++  static TQString     i18nTypeName(CostType);
++  static CostType    i18nCostType(TQString);
++  // clean up some static data
++  static void cleanup();
++
++  /**
++   * Returns dynamic name info (without type)
++   */
++  virtual TQString name() const;
++
++  /**
++   * Same as name, but sometimes nicer for humans :-)
++   */
++  virtual TQString prettyName() const;
++
++  /**
++   * Returns text of all cost metrics
++   */
++  virtual TQString costString(TraceCostMapping*);
++
++  /**
++   * Returns type name + dynamic name
++   */
++  TQString fullName() const;
++
++  /**
++   * Returns full name + cost text
++   */
++  TQString toString();
++
++  /**
++   * Set all cost counters to zero
++   */
++  virtual void clear();
++
++  /** Invalidate the cost attributes.
++   * An invalidated object needs to be recalculated when a cost
++   * attribute is requested (e.g. by subCost()).
++   * Has to be overwritten by subclasses when the cost influences costs of
++   * other cost items. If only one item depends on the cost of this item,
++   * it can by set with setDependant() without a need for overwriting.
++   */
++  virtual void invalidate();
++
++  /**
++   * Sets a dependant to be invalidated when this cost is invalidated.
++   * Call this function directly after the constructor.
++   */
++  void setDependant(TraceItem* d) { _dep = d; }
++
++  TraceItem* dependant() { return _dep; }
++
++  /**
++   * If this item is from a single profile data file, position
++   * points to a TracePart, otherwise to a TraceData object.
++   */
++  void setPosition(TraceItem* p) { _position = p; }  
++
++  // getters for specific positions, to be overwritten
++  virtual TracePart* part();
++  virtual const TracePart* part() const;
++  virtual TraceData* data();
++  virtual const TraceData* data() const;
++
++ protected:
++  /** Updates cost attributes.
++   * This has to be called by subclasses that access cost attributes
++   * directly
++   */
++  virtual void update();
++
++  bool _dirty;
++
++  TraceItem* _position;
++  TraceItem* _dep;
++
++ private:
++  static TQString *_typeName, *_i18nTypeName;
++};
++
++
++
++/**
++ * An array of basic cost metrics for a trace item.
++ *
++ * The semantic of specific indexes is stored in the
++ * TraceCostMapping of the TraceData object holding this TraceCost.
++ */
++class TraceCost: public TraceItem
++{
++public:
++  /**
++   * The maximal number of subcosts a TraceCost can have.
++   */
++  static const int MaxRealIndex;
++#define MaxRealIndexValue 13
++  static const int InvalidIndex;
++
++
++  TraceCost();
++  virtual ~TraceCost();
++
++  virtual CostType type() const { return Cost; }
++  virtual TQString costString(TraceCostMapping*);
++
++  virtual void clear();
++
++  // set the cost according to a submapping and a list of ASCII numbers
++  void set(TraceSubMapping*, const char*);
++  void set(TraceSubMapping*, FixString&);
++  // add a cost according to a submapping and a list of ASCII numbers
++  void addCost(TraceSubMapping*, const char*);
++  void addCost(TraceSubMapping*, FixString&);
++  // add the cost of another item
++  void addCost(TraceCost* item);
++  void addCost(int index, SubCost value);
++
++  // maximal cost
++  void maxCost(TraceSubMapping*, FixString&);
++  void maxCost(TraceCost* item);
++  void maxCost(int index, SubCost value);
++  TraceCost diff(TraceCost* item);
++
++  virtual void invalidate();
++
++  /** Returns a sub cost. This automatically triggers
++   * a call to update() if needed.
++   */
++  SubCost subCost(TraceCostType*);
++
++  /**
++   * Same as above, but only for real types
++   */
++  SubCost subCost(int);
++
++  /** Returns a cost attribute converted to a string
++   * (with space after every 3 digits)
++   */
++  TQString prettySubCost(TraceCostType*);
++
++ protected:
++  virtual void update();
++
++  SubCost _cost[MaxRealIndexValue];
++  int _count; // only _count first indexes of _cost are used
++
++  // cache last virtual subcost for faster access
++  SubCost _cachedCost;
++  TraceCostType* _cachedType;
++};
++
++
++
++/**
++ * A cost type, e.g. "L1 Read Miss", short "l1rm".
++ *
++ * We distinguish "real" cost types, where the values come
++ * from the trace file, and "virtual" cost types, which
++ * are calculated from the real ones.
++ *
++ * For a virtual cost type, set a formula to calculate it:
++ * e.g. for "Read Misses" : "l1rm + l2rm".
++ * To allow for parsing, you must specify a TraceCostMapping
++ * with according cost types (e.g. "l1rm" and "l2rm" for above formula).
++ *
++ * The cost type with empty name is the "const" cost type.
++ */
++class TraceCostType
++{
++public:
++
++  /**
++   * <name> is a short (non-localized) identifier for the cost type,
++   *   e.g. "l1rm".
++   * <longName> is a long localized string, e.g. "L1 Read Miss"
++   * <formula> uses short names to reference other types
++   */
++  TraceCostType(TQString name,
++                TQString longName = TQString(),
++                TQString formula = TQString());
++
++  void setName(TQString n) { _name = n; }
++  void setLongName(TQString n) { _longName = n; }
++  void setMapping(TraceCostMapping* m);
++  void setFormula(TQString);
++  // default arg is for specifying a real type, but index unknown
++  void setRealIndex(int r = TraceCost::MaxRealIndex);
++
++  const TQString& name() { return _name; }
++  const TQString& longName() { return _longName; }
++  const TQString& formula() { return _formula; }
++  TraceCostMapping* mapping() { return _mapping; }
++  int realIndex() { return _realIndex; }
++  bool isReal() { return _formula.isEmpty(); }
++  TQColor color();
++
++  /*
++   * returns true if all cost type names can be resolved in formula
++   */
++  bool parseFormula();
++  TQString parsedFormula();
++
++  SubCost subCost(TraceCost*);
++
++  /*
++   * For virtual costs, returns a histogram for use with
++   * partitionPixmap().
++   * Returns maximal real index.
++   */
++  int histCost(TraceCost* c, double total, double* hist);
++
++  // application wide known types, referenced by short name
++  // next 2 functions return a new type object instance
++  static TraceCostType* knownRealType(TQString);
++  static TraceCostType* knownVirtualType(TQString);
++  static void add(TraceCostType*);
++  static bool remove(TQString);
++  static int knownTypeCount();
++  static TraceCostType* knownType(int);
++
++private:
++
++  TQString _name, _longName, _formula;
++  TraceCostMapping* _mapping;
++  bool _parsed, _inParsing;
++  // index MaxRealIndex is for constant addition
++  int _coefficient[MaxRealIndexValue];
++  int _realIndex;
++
++  static TQPtrList<TraceCostType>* _knownTypes;
++};
++
++
++/**
++ * A class for managing a set of cost types.
++ *
++ * Each cost type has an index:
++ * - Real costs are in range [0 .. TraceCost:MaxRealIndex[
++ * - Virtual costs are in range [MaxRealIndex, ...]
++ */
++class TraceCostMapping
++{
++public:
++  TraceCostMapping();
++  ~TraceCostMapping();
++
++  /**
++   * Defines a sub mapping with a list of real types
++   * If <create> is false, checks if this is a existing sub mapping.
++   */
++  TraceSubMapping* subMapping(TQString types, bool create = true);
++
++  // "knows" about some real types
++  int addReal(TQString);
++  int add(TraceCostType*);
++  bool remove(TraceCostType*);
++  int realCount() { return _realCount; }
++  int virtualCount() { return _virtualCount; }
++  int minVirtualIndex() { return TraceCost::MaxRealIndex; }
++  TraceCostType* type(int);
++  TraceCostType* realType(int);
++  TraceCostType* virtualType(int);
++  TraceCostType* type(TQString);
++  TraceCostType* typeForLong(TQString);
++  int realIndex(TQString);
++  int index(TQString);
++  TQColor* realColors() { return _realColor; }
++
++  /**
++   * Adds all known virtual types that can be parsed
++   */
++  int addKnownVirtualTypes();
++
++private:
++  // we support only a fixed number of real and virtual types
++  TraceCostType* _real[MaxRealIndexValue];
++  TQColor _realColor[MaxRealIndexValue];
++  TraceCostType* _virtual[MaxRealIndexValue];
++  int _realCount, _virtualCount;
++};
++
++/**
++ * A submapping of a TraceCostMapping
++ *
++ * This is a fixed ordered list of indexes for real cost types
++ * in a mapping.
++ *
++ * You can define a mapping by requesting submappings. Undefined cost
++ * types will get a new real type index.
++ *  TraceCostMapping m;
++ *  sm1 = m.subMapping("Event1 Cost1 Cost2");  // returns submap [0,1,2]
++ *  sm2 = m.subMapping("Event2 Cost3 Event1"); // returns submap [3,4,0]
++ * Real types of m will be:
++ *  (0:Event1, 1:Cost1, 2:Cost2, 3:Event2, 4:Cost3)
++ */
++class TraceSubMapping
++{
++public:
++  TraceSubMapping(TraceCostMapping*);
++
++  bool append(TQString, bool create=true);
++  bool append(int);
++  void clear();
++
++  /**
++   * Get number of used indexes
++   */
++  int count() { return _count; }
++
++  /**
++   * Is this submapping the identity( i.e. realIndex(i)=i ) ?
++   * This often allows for optimizations.
++   */
++  bool isIdentity() { return _isIdentity; }
++  int realIndex(int i)
++    { return (i<0 || i>=_count) ? TraceCost::InvalidIndex : _realIndex[i]; }
++
++  /*
++   * Allows an iteration over the sorted list of all real indexes not used in
++   * this submapping, up to topIndex (use TraceCost::MaxRealIndex for all).
++   * Usage: for(i = firstUnused(); i < topIndex; i = nextUnused(i)) { LOOP }
++   */
++  int firstUnused() { return _firstUnused; }
++  int nextUnused(int i) {
++      if (i<0 || i>=TraceCost::MaxRealIndex) return TraceCost::InvalidIndex;
++      return _nextUnused[i]; }
++
++private:
++  TraceCostMapping* _mapping;
++  int _count, _firstUnused;
++  bool _isIdentity;
++  int _realIndex[MaxRealIndexValue];
++  int _nextUnused[MaxRealIndexValue];
++};
++
++
++/**
++ * Cost of a (conditional) jump.
++ */
++class TraceJumpCost: public TraceItem
++{
++ public:
++    TraceJumpCost();
++    virtual ~TraceJumpCost();
++
++    // reimplementations for cost addition
++    virtual TQString costString(TraceCostMapping* m);
++    virtual void clear();
++
++    void addCost(TraceJumpCost*);
++
++    // additional cost metrics
++    SubCost followedCount();
++    SubCost executedCount();
++    void addFollowedCount(SubCost c) { _followedCount += c; }
++    void addExecutedCount(SubCost c) { _executedCount += c; }
++
++ protected:
++    SubCost _executedCount, _followedCount;
++};
++
++
++
++/**
++ * Cost item with additional call count metric.
++ */
++class TraceCallCost: public TraceCost
++{
++ public:
++  TraceCallCost();
++  virtual ~TraceCallCost();
++
++  // reimplementations for cost addition
++  virtual TQString costString(TraceCostMapping* m);
++  virtual void clear();
++
++  // additional cost metric
++  SubCost callCount();
++  TQString prettyCallCount();
++  void addCallCount(SubCost c);
++
++ protected:
++  SubCost _callCount;
++};
++
++
++/**
++ * Cost item with additional inclusive metric
++ */
++class TraceInclusiveCost: public TraceCost
++{
++ public:
++  TraceInclusiveCost();
++  virtual ~TraceInclusiveCost();
++
++  // reimplementations for cost addition
++  virtual TQString costString(TraceCostMapping* m);
++  virtual void clear();
++
++  // additional cost metric
++  TraceCost* inclusive();
++  void addInclusive(TraceCost*);
++
++ protected:
++  TraceCost _inclusive;
++};
++
++
++/**
++ * Cost Item
++ * dependend on a list of cost items.
++ */
++class TraceListCost: public TraceCost
++{
++ public:
++  TraceListCost();
++  virtual ~TraceListCost();
++
++  // reimplementation for dependency list
++  virtual void update();
++
++  TraceCostList& deps() { return _deps; }
++  void addDep(TraceCost*);
++  TraceCost* findDepFromPart(TracePart*);
++
++ protected:
++  // overwrite in subclass to change update behaviour
++  virtual bool onlyActiveParts() { return false; }
++
++  TraceCostList _deps;
++
++ private:
++  // very temporary: cached
++  TraceCost* _lastDep;
++};
++
++
++/**
++ * Jump Cost Item
++ * dependend on a list of Jump cost items.
++ */
++class TraceJumpListCost: public TraceJumpCost
++{
++ public:
++  TraceJumpListCost();
++  virtual ~TraceJumpListCost();
++
++  // reimplementation for dependency list
++  virtual void update();
++
++  TraceJumpCostList deps() { return _deps; }
++  void addDep(TraceJumpCost*);
++  TraceJumpCost* findDepFromPart(TracePart*);
++
++ protected:
++  // overwrite in subclass to change update behaviour
++  virtual bool onlyActiveParts() { return false; }
++
++  TraceJumpCostList _deps;
++
++ private:
++  // very temporary: cached
++  TraceJumpCost* _lastDep;
++};
++
++
++
++
++/**
++ * Call Cost Item
++ * dependend on a list of Call cost items.
++ */
++class TraceCallListCost: public TraceCallCost
++{
++ public:
++  TraceCallListCost();
++  virtual ~TraceCallListCost();
++
++  // reimplementation for dependency list
++  virtual void update();
++
++  TraceCallCostList deps() { return _deps; }
++  void addDep(TraceCallCost*);
++  TraceCallCost* findDepFromPart(TracePart*);
++
++ protected:
++  // overwrite in subclass to change update behaviour
++  virtual bool onlyActiveParts() { return false; }
++
++  TraceCallCostList _deps;
++
++ private:
++  // very temporary: cached
++  TraceCallCost* _lastDep;
++};
++
++
++/**
++ * Inclusive Cost Item dependend on a list of inclusive cost items.
++ */
++class TraceInclusiveListCost: public TraceInclusiveCost
++{
++ public:
++  TraceInclusiveListCost();
++  virtual ~TraceInclusiveListCost();
++
++  // reimplementation for dependency
++  virtual void update();
++
++  TraceInclusiveCostList deps() { return _deps; }
++  void addDep(TraceInclusiveCost*);
++  TraceInclusiveCost* findDepFromPart(TracePart*);
++
++ protected:
++  // overwrite in subclass to change update behaviour
++  virtual bool onlyActiveParts() { return false; }
++
++  TraceInclusiveCostList _deps;
++
++ private:
++  // very temporary: cached
++  TraceInclusiveCost* _lastDep;
++};
++
++
++
++
++
++/*-----------------------------------------------------------------
++ * Classes for cost items of one trace file, i.e. a "trace part"
++ *-----------------------------------------------------------------
++ */
++
++/**
++ * Cost of jump at a instruction code address from a trace file.
++ */
++class TracePartInstrJump: public TraceJumpCost
++{
++ public:
++  TracePartInstrJump(TraceInstrJump*, TracePartInstrJump*);
++  virtual ~TracePartInstrJump();
++
++    virtual CostType type() const { return PartInstrJump; }
++    // fix cost item
++    virtual void update() {}
++    TraceInstrJump* instrJump() const { return (TraceInstrJump*) _dep; }
++    TracePartInstrJump* next() const { return _next; }
++
++ private:
++    // chaining all parts for InstrJump
++    TracePartInstrJump* _next;
++};
++
++
++/**
++ * Cost of a call at a instruction code address from a trace file.
++ * Cost is always up to date, no lazy update needed.
++ */
++class TracePartInstrCall: public TraceCallCost
++{
++public:
++  TracePartInstrCall(TraceInstrCall*);
++  virtual ~TracePartInstrCall();
++
++  virtual CostType type() const { return PartInstrCall; }
++  // fix cost item
++  virtual void update() {}
++  TraceInstrCall* instrCall() const { return (TraceInstrCall*) _dep; }
++};
++
++
++/**
++ * Cost of a code instruction address from a trace file.
++ * Cost is always up to date, no lazy update needed.
++ */
++class TracePartInstr: public TraceCost
++{
++public:
++  TracePartInstr(TraceInstr*);
++  virtual ~TracePartInstr();
++
++  virtual CostType type() const { return PartInstr; }
++  // fix cost item
++  virtual void update() {}
++
++  TraceInstr* instr() const { return (TraceInstr*)_dep; }
++};
++
++
++/**
++ * Cost of jump at a source line from a trace file.
++ */
++class TracePartLineJump: public TraceJumpCost
++{
++ public:
++    TracePartLineJump(TraceLineJump*);
++    virtual ~TracePartLineJump();
++
++    virtual CostType type() const { return PartLineJump; }
++    // fix cost item
++    virtual void update() {}
++    TraceLineJump* lineJump() const { return (TraceLineJump*) _dep; }
++};
++
++
++/**
++ * Cost of a call at a line from a trace file.
++ * Cost is always up to date, no lazy update needed.
++ */
++class TracePartLineCall: public TraceCallCost
++{
++public:
++  TracePartLineCall(TraceLineCall*);
++  virtual ~TracePartLineCall();
++
++  virtual CostType type() const { return PartLineCall; }
++  // fix cost item
++  virtual void update() {}
++  TraceLineCall* lineCall() const { return (TraceLineCall*) _dep; }
++};
++
++
++
++/**
++ * Cost of a line from a trace file.
++ * Cost is always up to date, no lazy update needed.
++ */
++class TracePartLine: public TraceCost
++{
++public:
++  TracePartLine(TraceLine*);
++  virtual ~TracePartLine();
++
++  virtual CostType type() const { return PartLine; }
++  // fix cost item
++  virtual void update() {}
++
++  TraceLine* line() const { return (TraceLine*)_dep; }
++};
++
++
++/**
++ * Cost of a source region.
++ */
++class TracePartLineRegion: public TraceInclusiveCost
++{
++public:
++  TracePartLineRegion(TraceLineRegion*);
++  virtual ~TracePartLineRegion();
++
++  virtual CostType type() const { return PartLineRegion; }
++  virtual void update();
++
++  TraceLineRegion* region() const { return (TraceLineRegion*)_dep; }
++};
++
++
++/**
++ * Cost of a call at a function to another function,
++ * from a single trace file.
++ */
++class TracePartCall: public TraceCallListCost
++{
++public:
++  TracePartCall(TraceCall* call);
++  virtual ~TracePartCall();
++
++  virtual CostType type() const { return PartCall; }
++  // calls a function itself?
++  bool isRecursion();
++
++  // reimplementation for dependency list
++  virtual void update();
++
++  TraceCall* call() const { return (TraceCall*)_dep; }
++
++  FixCallCost* setFirstFixCallCost(FixCallCost* fc)
++    { FixCallCost* t = _firstFixCallCost; _firstFixCallCost = fc; return t; }
++  FixCallCost* firstFixCallCost() const { return _firstFixCallCost; }
++
++private:
++  FixCallCost* _firstFixCallCost;
++};
++
++
++/**
++ * Cost of a function,
++ * from a single trace file.
++ */
++class TracePartFunction: public TraceInclusiveCost
++{
++public:
++  TracePartFunction(TraceFunction*,
++		    TracePartObject*, TracePartFile*);
++  virtual ~TracePartFunction();
++
++  virtual CostType type() const { return PartFunction; }
++  virtual void update();
++  virtual TQString costString(TraceCostMapping* m);
++
++  void addPartInstr(TracePartInstr*);
++  void addPartLine(TracePartLine*);
++  void addPartCaller(TracePartCall*);
++  void addPartCalling(TracePartCall*);
++
++  TraceFunction* function() { return (TraceFunction*) _dep; }
++  TracePartObject* partObject() { return _partObject; }
++  TracePartClass* partClass() { return _partClass; }
++  TracePartFile* partFile() { return _partFile; }
++  const TracePartCallList& partCallers() { return _partCallers; }
++  const TracePartCallList& partCallings() { return _partCallings; }
++  void setPartObject(TracePartObject* o) { _partObject = o; }
++  void setPartClass(TracePartClass* c) { _partClass = c; }
++  void setPartFile(TracePartFile* f) { _partFile = f; }
++
++  /* for linked list of FixXXX objects */
++  FixCost* setFirstFixCost(FixCost* fc)
++      { FixCost* t = _firstFixCost; _firstFixCost = fc; return t; }
++  FixCost* firstFixCost() const { return _firstFixCost; }
++  FixJump* setFirstFixJump(FixJump* fj)
++      { FixJump* t = _firstFixJump; _firstFixJump = fj; return t; }
++  FixJump* firstFixJump() const { return _firstFixJump; }
++
++  // additional cost metrics
++  SubCost calledCount();
++  SubCost callingCount();
++  TQString prettyCalledCount();
++  TQString prettyCallingCount();
++  int calledContexts();
++  int callingContexts();
++
++private:
++  TracePartObject* _partObject;
++  TracePartClass* _partClass;
++  TracePartFile* _partFile;
++
++  TracePartCallList _partCallings;
++  TracePartCallList _partCallers;
++  TracePartInstrList _partInstr;
++  TracePartLineList _partLines;
++
++  // cached
++  SubCost _calledCount, _callingCount;
++  int _calledContexts, _callingContexts;
++
++  FixCost* _firstFixCost;
++  FixJump* _firstFixJump;
++};
++
++
++/**
++ * Cost of a class,
++ * from a single trace file.
++ */
++class TracePartClass: public TraceInclusiveListCost
++{
++public:
++  TracePartClass(TraceClass*);
++  virtual ~TracePartClass();
++
++  virtual CostType type() const { return PartClass; }
++  TQString prettyName() const;
++
++  TraceClass* cls() { return (TraceClass*)_dep; }
++  void addPartFunction(TracePartFunction* f) { addDep(f); }
++};
++
++
++/**
++ * Cost of a source file,
++ * from a single trace file.
++ */
++class TracePartFile: public TraceInclusiveListCost
++{
++public:
++  TracePartFile(TraceFile*);
++  virtual ~TracePartFile();
++
++  virtual CostType type() const { return PartFile; }
++  TraceFile* file() { return (TraceFile*)_dep; }
++  void addPartFunction(TracePartFunction* f) { addDep(f); }
++};
++
++
++/**
++ * Cost of a object,
++ * from a single trace file.
++ */
++class TracePartObject: public TraceInclusiveListCost
++{
++public:
++  TracePartObject(TraceObject*);
++  virtual ~TracePartObject();
++
++  virtual CostType type() const { return PartObject; }
++  TraceObject* object() const { return (TraceObject*)_dep; }
++  void addPartFunction(TracePartFunction* f) { addDep(f); }
++};
++
++
++
++/**
++ * A Trace Part: All data read from a trace file, containing all costs
++ * that happened in a specified time interval of the executed command.
++ */
++class TracePart: public TraceListCost
++{
++public:
++  TracePart(TraceData*, TQFile* file);
++  virtual ~TracePart();
++
++  virtual CostType type() const { return Part; }
++  virtual TracePart* part() { return this; }
++  virtual const TracePart* part() const { return this; }
++
++  TQString shortName() const;
++  TQString prettyName() const;
++  TQFile* file() const { return _file; }
++  TQString name() const { return _name; }
++  TQString description() const { return _descr; }
++  TQString trigger() const { return _trigger; }
++  TQString timeframe() const { return _timeframe; }
++  TQString version() const { return _version; }
++  int partNumber() { return _number; }
++  int threadID() { return _tid; }
++  int processID() { return _pid; }
++  void setDescription(const TQString& d) { _descr = d; }
++  void setTrigger(const TQString& t) { _trigger = t; }
++  void setTimeframe(const TQString& t) { _timeframe = t; }
++  void setVersion(const TQString& v) { _version = v; }
++  void setPartNumber(int n);
++  void setThreadID(int t);
++  void setProcessID(int p);
++  TraceCost* totals() { return &_totals; }
++  /* we get owner of the submapping */
++  void setFixSubMapping(TraceSubMapping* sm) { _fixSubMapping = sm; }
++  TraceSubMapping* fixSubMapping() { return _fixSubMapping; }
++
++  // returns true if something changed
++  bool activate(bool);
++  bool isActive() { return _active; }
++
++private:
++  TQFile* _file;
++  TQString _name;
++  TQString _descr;
++  TQString _trigger;
++  TQString _timeframe;
++  TQString _version;
++
++  int _number, _tid, _pid;
++
++  bool _active;
++
++  // the totals line
++  TraceCost _totals;
++
++  // submapping for all fix costs of this part
++  TraceSubMapping* _fixSubMapping;
++};
++
++
++class TracePartList: public TQPtrList<TracePart>
++{
++ public:
++  TQString names() const;
++ protected:
++  int compareItems ( Item item1, Item item2 );
++};
++
++
++/*-----------------------------------------------------------------
++ * Classes for cost items summed up from multiple trace parts
++ *-----------------------------------------------------------------
++ */
++
++
++/**
++ * A jump from an instruction to another inside of a function
++ */
++class TraceInstrJump: public TraceJumpCost
++{
++public:
++    TraceInstrJump(TraceInstr* instrFrom, TraceInstr* instrTo,
++		   bool isCondJump);
++    virtual ~TraceInstrJump();
++
++    virtual CostType type() const { return InstrJump; }
++    virtual TQString name() const;
++
++    virtual void update();
++
++    TraceInstr* instrFrom() const { return _instrFrom; }
++    TraceInstr* instrTo() const { return _instrTo; }
++    bool isCondJump() const { return _isCondJump; }
++
++    // part factory
++    TracePartInstrJump* partInstrJump(TracePart*);
++
++ private:
++    TraceInstr *_instrFrom, *_instrTo;
++    bool _isCondJump;
++    // list of parts for this InstrJump
++    TracePartInstrJump* _first;
++};
++
++class TraceInstrJumpList: public TQPtrList<TraceInstrJump>
++{
++ public:
++    TraceInstrJumpList() { _sortLow = true; }
++    void setSortLow(bool s) { _sortLow = s; }
++
++ protected:
++  int compareItems ( Item item1, Item item2 );
++
++ private:
++  bool _sortLow;
++};
++
++
++/**
++ * A jump from one line to another inside of a function.
++ */
++class TraceLineJump: public TraceJumpListCost
++{
++ public:
++  TraceLineJump(TraceLine* lineFrom, TraceLine* lineTo,
++		bool isCondJump);
++  virtual ~TraceLineJump();
++
++  virtual CostType type() const { return LineJump; }
++  virtual TQString name() const;
++
++  TraceLine* lineFrom() const { return _lineFrom; }
++  TraceLine* lineTo() const { return _lineTo; }
++  bool isCondJump() { return _isCondJump; }
++
++  // part factory
++  TracePartLineJump* partLineJump(TracePart*);
++
++ protected:
++  bool onlyActiveParts() { return true; }
++
++ private:
++  TraceLine *_lineFrom, *_lineTo;
++  bool _isCondJump;
++};
++
++
++class TraceLineJumpList: public TQPtrList<TraceLineJump>
++{
++ public:
++    TraceLineJumpList() { _sortLow = true; }
++    void setSortLow(bool s) { _sortLow = s; }
++
++ protected:
++  int compareItems ( Item item1, Item item2 );
++
++ private:
++  bool _sortLow;
++};
++
++
++/**
++ * A call from an instruction of one function to another function
++ */
++class TraceInstrCall: public TraceCallListCost
++{
++ public:
++  TraceInstrCall(TraceCall* call, TraceInstr* instr);
++  virtual ~TraceInstrCall();
++
++  virtual CostType type() const { return InstrCall; }
++  virtual TQString name() const;
++
++  TraceInstr* instr() const { return _instr; }
++  TraceCall* call() const { return _call; }
++
++  // part factory
++  TracePartInstrCall* partInstrCall(TracePart*, TracePartCall*);
++
++ protected:
++  bool onlyActiveParts() { return true; }
++
++ private:
++  TraceInstr* _instr;
++  TraceCall* _call;
++};
++
++
++/**
++ * A call from a line of one function to another function.
++ */
++class TraceLineCall: public TraceCallListCost
++{
++ public:
++  TraceLineCall(TraceCall* call, TraceLine* line);
++  virtual ~TraceLineCall();
++
++  virtual CostType type() const { return LineCall; }
++  virtual TQString name() const;
++
++  TraceLine* line() const { return _line; }
++  TraceCall* call() const { return _call; }
++
++  // part factory
++  TracePartLineCall* partLineCall(TracePart*, TracePartCall*);
++
++ protected:
++  bool onlyActiveParts() { return true; }
++
++ private:
++  TraceLine* _line;
++  TraceCall* _call;
++};
++
++
++/**
++ * A call from one to another function.
++ * Consists of a list a TraceLineCalls
++ */
++class TraceCall: public TraceCallListCost
++{
++ public:
++  TraceCall(TraceFunction* caller, TraceFunction* called);
++  virtual ~TraceCall();
++
++  virtual CostType type() const { return Call; }
++  virtual TQString name() const;
++
++  // calls a function itself?
++  bool isRecursion() { return _caller == _called; }
++
++  // return cycle number >0 if call is inside of a cycle
++  int inCycle();
++  // we need some special handling for cycle calls
++  void update();
++
++  void invalidateDynamicCost();
++
++  // factories
++  TracePartCall* partCall(TracePart*,
++                          TracePartFunction*, TracePartFunction*);
++  TraceLineCall* lineCall(TraceLine*);
++  TraceInstrCall* instrCall(TraceInstr*);
++
++  TraceFunction* caller(bool skipCycle=false) const;
++  TraceFunction* called(bool skipCycle=false) const;
++  TQString callerName(bool skipCycle=false) const;
++  TQString calledName(bool skipCycle=false) const;
++  const TraceLineCallList& lineCalls() const { return _lineCalls; }
++  const TraceInstrCallList& instrCalls() const { return _instrCalls; }
++
++  FixCallCost* setFirstFixCost(FixCallCost* fc)
++    { FixCallCost* t = _firstFixCost; _firstFixCost = fc; return t; }
++
++ protected:
++  bool onlyActiveParts() { return true; }
++
++ private:
++  TraceInstrCallList _instrCalls;
++  TraceLineCallList _lineCalls;
++  TraceFunction* _caller;
++  TraceFunction* _called;
++
++  FixCallCost* _firstFixCost;
++};
++
++
++/**
++ * A code instruction address of the program.
++ * Consists of a list a TracePartInstr from different trace files
++ * and a list of TraceInstrCalls if there are calls from this address.
++ */
++class TraceInstr: public TraceListCost
++{
++ public:
++  TraceInstr();
++  virtual ~TraceInstr();
++
++  virtual CostType type() const { return Instr; }
++  virtual TQString name() const;
++  TQString prettyName() const;
++
++  bool isValid() { return _addr != Addr(0); }
++
++  // factories
++  TracePartInstr* partInstr(TracePart* part,
++			    TracePartFunction* partFunction);
++  TraceInstrJump* instrJump(TraceInstr* to, bool isCondJump);
++
++  void addInstrCall(TraceInstrCall*);
++
++  Addr addr() const { return _addr; }
++  TraceFunction* function() const { return _function; }
++  TraceLine* line() const { return _line; }
++  const TraceInstrJumpList& instrJumps() const { return _instrJumps; }
++  const TraceInstrCallList& instrCalls() const { return _instrCalls; }
++  bool hasCost(TraceCostType*);
++
++  // only to be called after default constructor
++  void setAddr(const Addr addr) { _addr = addr; }
++  void setFunction(TraceFunction* f) { _function = f; }
++  void setLine(TraceLine* l) { _line = l; }
++
++ protected:
++  bool onlyActiveParts() { return true; }
++
++ private:
++  Addr _addr;
++  TraceFunction* _function;
++  TraceLine* _line;
++
++  TraceInstrJumpList _instrJumps;
++  TraceInstrCallList _instrCalls;
++};
++
++
++/**
++ * A source line of the program.
++ * Consists of a list a TracePartLines from different trace files
++ * and a list of TraceLineCalls if there are calls from this line.
++ */
++class TraceLine: public TraceListCost
++{
++public:
++  TraceLine();
++  virtual ~TraceLine();
++
++  virtual CostType type() const { return Line; }
++  virtual TQString name() const;
++  TQString prettyName() const;
++
++  // factories
++  TracePartLine* partLine(TracePart* part,
++                          TracePartFunction* partFunction);
++  TraceLineJump* lineJump(TraceLine* to, bool isCondJump);
++
++  void addLineCall(TraceLineCall*);
++
++
++  bool isValid() { return _sourceFile != 0; }
++  bool hasCost(TraceCostType*);
++  TraceFunctionSource* functionSource() const { return _sourceFile; }
++  uint lineno() const { return _lineno; }
++  const TraceLineCallList& lineCalls() const { return _lineCalls; }
++  const TraceLineJumpList& lineJumps() const { return _lineJumps; }
++
++  // only to be called after default constructor
++  void setSourceFile(TraceFunctionSource* sf) { _sourceFile = sf; }
++  void setLineno(uint lineno) { _lineno = lineno; }
++
++ protected:
++  bool onlyActiveParts() { return true; }
++
++ private:
++  TraceFunctionSource* _sourceFile;
++  uint _lineno;
++
++  TraceLineJumpList _lineJumps;
++  TraceLineCallList _lineCalls;
++};
++
++
++/*
++ * Base class for all costs which
++ * represent "interesting" items or group of items
++ * with settable name and inclusive cost
++ */
++class TraceCostItem: public TraceInclusiveListCost
++{
++ public:
++  TraceCostItem();
++  virtual ~TraceCostItem();
++
++  virtual TQString name() const { return _name; }
++  virtual void setName(const TQString& name) { _name = name; }
++
++ protected:
++  bool onlyActiveParts() { return true; }
++
++ protected:
++  TQString _name;
++};
++
++
++/**
++ * Cost of a source region.
++ */
++class TraceLineRegion: public TraceInclusiveListCost
++{
++public:
++  TraceLineRegion(uint from, uint to, TQString name);
++  virtual ~TraceLineRegion();
++
++  virtual CostType type() const { return LineRegion; }
++  virtual void update();
++
++  uint from() const { return _from; }
++  uint to() const { return _to; }
++  TQString name() const { return _name; }
++
++  // factories
++  TracePartLine* partLineRegion(TracePart* part,
++			    TracePartFunction* partFunction);
++ private:
++  uint _from, _to;
++  TQString _name;
++};
++
++
++/**
++ * A container helper class for TraceFunction for source lines
++ * where a function is implemented in.
++ * With inlining, lines of the same function can come from
++ * different source files.
++ * An instance of this class holds all lines of one source file
++ * for a function in a map
++ */
++class TraceFunctionSource: public TraceCost
++{
++public:
++  TraceFunctionSource(TraceFunction*, TraceFile*);
++  virtual ~TraceFunctionSource();
++
++  virtual CostType type() const { return FunctionSource; }
++  virtual TQString name() const;
++
++  // reimplementation for dependency map
++  virtual void update();
++
++  TraceFile* file() const { return _file; }
++  TraceFunction* function() const { return _function; }
++  uint firstLineno();
++  uint lastLineno();
++  TraceLineMap* lineMap();
++
++  void invalidateDynamicCost();
++
++  /* factories */
++  TraceLine* line(uint lineno, bool createNew = true);
++  TraceLineRegion* region(uint from, uint to, TQString name,
++		      bool createNew = true);
++
++ private:
++  TraceFile* _file;
++  TraceFunction* _function;
++  TraceLineMap* _lineMap;
++  TraceLine* _line0;
++  TraceLineRegionList* _regions;
++
++  bool _lineMapFilled;
++};
++
++
++/**
++ * For temporary assoziation of objects with TraceFunctions.
++ * Used in coverage analysis and TreeMap drawing.
++ */
++class TraceAssoziation
++{
++ public:
++  /**
++   * Creates an invalid assoziation.
++   */
++  TraceAssoziation();
++  virtual ~TraceAssoziation();
++
++  // for runtime detection
++  virtual int rtti() { return 0; }
++
++  /**
++   * Could we set the function assoziation to ourself?
++   * This only can return false if this is a unique assoziation.
++   */
++  bool isAssoziated();
++
++  /**
++   * reset function to assoziate this object to.
++   * returns true if assoziation could be established
++   */
++  bool setFunction(TraceFunction*);
++  TraceFunction* function() { return _function; }
++
++  void invalidate() { _valid = false; }
++  bool isValid() { return _valid; }
++
++  /**
++   * Delete all assoziations in TraceFunctions of data with
++   * rtti runtime info. rtti = 0: delete ALL assoziations.
++   */
++  static void clear(TraceData* data, int rtti);
++
++  /**
++   * Invalidate all assoziations in TraceFunctions of data with
++   * rtti runtime info. rtti = 0: Invalidate ALL assoziations.
++   */
++  static void invalidate(TraceData* data, int rtti);
++
++ protected:
++  TraceFunction* _function;
++  bool _valid;
++};
++
++typedef TQPtrList<TraceAssoziation> TraceAssoziationList;
++typedef TQMap<TraceFunction*, TraceCall*> TraceCallMap;
++
++/**
++ * A traced function
++ *
++ * References to functions are stored in
++ *  (1) a function map in TraceData (by value)
++ *  (2) a TraceClass
++ */
++class TraceFunction: public TraceCostItem
++{
++ public:
++  TraceFunction();
++  TraceFunction(TraceData* data, const TQString& name,
++                TraceClass* cls, TraceFile* file, TraceObject* object);
++  virtual ~TraceFunction();
++
++  virtual CostType type() const { return Function; }
++  virtual void update();
++
++  // this invalidate all subcosts of function depending on
++  // active status of parts
++  void invalidateDynamicCost();
++
++  void addCaller(TraceCall*);
++
++  // factories
++  TraceCall* calling(TraceFunction* called);
++  TraceLine* line(TraceFile*, uint lineno, bool createNew = true);
++  TraceInstr* instr(Addr addr, bool createNew = true);
++  TracePartFunction* partFunction(TracePart*,
++                                  TracePartFile*, TracePartObject*);
++
++  /**
++   * Returns empty string if location is fully unknown.
++   * Use prettyLocation for single user-visible string.
++   * A function can have a lot of code from different sources (inlined);
++   * maxItems limits this list. Default is full list
++   */
++  TQString location(int maxFiles = 0) const;
++
++  TQString prettyName() const;
++  TQString prettyLocation(int maxFiles = 0) const;
++  TQString prettyNameWithLocation(int maxFiles = 1) const;
++  void addPrettyLocation(TQString&, int maxFiles = 1) const;
++  // type + name + location
++  TQString info() const; 
++
++  TraceClass* cls() const { return _cls; }
++  TraceFile* file() const { return _file; }
++  TraceObject* object() const { return _object; }
++  // get the source file with lines from function declaration (not inlined)
++  TraceFunctionSource* sourceFile(TraceFile* file = 0,
++                                      bool createNew = false);
++  const TraceFunctionSourceList& sourceFiles() const
++    { return _sourceFiles; }
++  TraceCallList callers(bool skipCycle=false) const;
++  const TraceCallList& callings(bool skipCycle=false) const;
++
++  Addr firstAddress() const;
++  Addr lastAddress() const;
++  TraceInstrMap* instrMap();
++
++  // cost metrics
++  SubCost calledCount();
++  SubCost callingCount();
++  TQString prettyCalledCount();
++  TQString prettyCallingCount();
++  int calledContexts();
++  int callingContexts();
++
++  // only to be called after default constructor
++  void setFile(TraceFile* file) { _file = file; }
++  void setObject(TraceObject* object) { _object = object; }
++  void setClass(TraceClass* cls) { _cls = cls; }
++  void setMapIterator(TraceFunctionMap::Iterator it) { _myMapIterator = it; }
++
++  // see TraceFunctionAssoziation
++  void addAssoziation(TraceAssoziation* a);
++  void removeAssoziation(TraceAssoziation* a);
++  void removeAssoziation(int rtti, bool reallyDelete = true);
++  void invalidateAssoziation(int rtti);
++  TraceAssoziation* assoziation(int rtti);
++
++  // cycles
++  void setCycle(TraceFunctionCycle* c) { _cycle = c; }
++  TraceFunctionCycle* cycle() { return _cycle; }
++  bool isCycle();
++  bool isCycleMember();
++  void cycleReset();
++  void cycleDFS(int d, int& pNo, TraceFunction** pTop);
++
++ protected:
++  TraceCallList _callers; // list of calls we are called from
++  TraceCallList _callings; // list of calls we are calling (we are owner)
++  TraceCallMap _callingMap; // contains the same as _callings in a map
++  TraceFunctionCycle* _cycle;
++
++ private:
++  bool isUniquePrefix(TQString) const;
++  TraceFunctionMap::Iterator _myMapIterator;
++
++  TraceClass* _cls;
++  TraceObject* _object;
++  TraceFile* _file;
++
++  TraceFunctionSourceList _sourceFiles; // we are owner
++  TraceInstrMap* _instrMap; // we are owner
++  bool _instrMapFilled;
++
++  // see TraceAssoziation
++  TraceAssoziationList _assoziations;
++
++  // for cycle detection
++  int _cycleLow;
++  TraceFunction* _cycleStackDown;
++
++  // cached
++  SubCost _calledCount, _callingCount;
++  int _calledContexts, _callingContexts;
++};
++
++typedef TQMap<TraceFunction*,int> TraceFunctionSet;
++
++/**
++ * A cycle of recursive calling functions.
++ *
++ * This is itself shown as a function
++ */
++class TraceFunctionCycle: public TraceFunction
++{
++ public:
++  TraceFunctionCycle(TraceFunction*, int n);
++
++  virtual CostType type() const { return FunctionCycle; }
++
++  // this removes all members from this cycle
++  void init();
++  void add(TraceFunction*);
++  // this sets up the cycle once members are added
++  void setup();
++
++  TraceFunction* base() const { return _base; }
++  int cycleNo() const { return _cycleNo; }
++  const TraceFunctionList& members() const { return _members; }
++
++ private:
++  TraceFunction* _base;
++  int _cycleNo;
++
++  TraceFunctionList _members;
++  TraceFunctionSet _memberSet;
++};
++
++
++/**
++ * A C++ Class / Namespace
++ *
++ * If a function symbol has a prefix ending in "::",
++ * the prefix is supposed to be a class/namespace specifier.
++ * Without such a prefix, we put a symbol in the "(global)" namespace.
++ */
++class TraceClass: public TraceCostItem
++{
++ public:
++  TraceClass();
++  virtual ~TraceClass();
++
++  virtual CostType type() const { return Class; }
++  virtual TQString prettyName() const;
++
++  void addFunction(TraceFunction*);
++  const TraceFunctionList& functions() const { return _functions; }
++
++  // part factory
++  TracePartClass* partClass(TracePart*);
++
++ private:
++  TraceFunctionList _functions;
++};
++
++
++
++/**
++ * A source file containing function definitions
++ */
++class TraceFile: public TraceCostItem
++{
++ public:
++  TraceFile();
++  virtual ~TraceFile();
++
++  virtual CostType type() const { return File; }
++  void setDirectory(const TQString& dir);
++  void resetDirectory() { _dir = TQString(); }
++  TQString directory();
++
++  void addFunction(TraceFunction*);
++  void addSourceFile(TraceFunctionSource*);
++
++  // without path
++  TQString shortName() const;
++  TQString prettyName() const;
++  TQString prettyLongName() const;
++  const TraceFunctionList& functions() const { return _functions; }
++  const TraceFunctionSourceList& sourceFiles() const
++    { return _sourceFiles; }
++
++  // part factory
++  TracePartFile* partFile(TracePart*);
++
++ private:
++  TraceFunctionList _functions;
++  TraceFunctionSourceList _sourceFiles;
++  TQString _dir;
++};
++
++
++/**
++ * A object containing a text segment (shared lib/executable)
++ * with defined functions
++ */
++class TraceObject: public TraceCostItem
++{
++ public:
++  TraceObject();
++  virtual ~TraceObject();
++
++  virtual CostType type() const { return Object; }
++
++  void addFunction(TraceFunction*);
++
++  virtual void setName(const TQString& name);
++  TQString shortName() const { return _shortName; }
++  TQString prettyName() const;
++  const TraceFunctionList& functions() const { return _functions; }
++
++  // part factory
++  TracePartObject* partObject(TracePart*);
++
++ private:
++  TraceFunctionList _functions;
++  TQString _shortName;
++};
++
++
++
++/**
++ * This class holds profiling data of multiple tracefiles
++ * generated with cachegrind on one command.
++ *
++ */
++class TraceData: public TraceCost
++{
++ public:
++  TraceData(TopLevel* top = 0);
++  TraceData(const TQString& base);
++  virtual ~TraceData();
++
++  virtual CostType type() const { return Data; }
++  virtual TraceData* data() { return this; }
++  virtual const TraceData* data() const { return this; }
++
++  /**
++   * Loads a trace file.
++   *
++   * This adjusts the TraceCostMapping according to given cost types
++   */
++  void load(const TQString&);
++
++  /** returns true if something changed. These do NOT
++   * invalidate the dynamic costs on a activation change,
++   * i.e. all cost items dependend on active parts.
++   * This has to be done by the caller when true is returned by
++   * calling invalidateDynamicCost().
++   */
++  bool activateParts(const TracePartList&);
++  bool activateParts(TracePartList, bool active);
++  bool activatePart(TracePart*, bool active);
++  bool activateAll(bool active=true);
++
++  TracePartList parts() const { return _parts; }
++  TracePart* part(TQString& name);
++
++  // with path
++  TQString traceName() const { return _traceName; }
++
++  // without path
++  TQString shortTraceName() const;
++  TQString activePartRange();
++
++  TraceCostMapping* mapping() { return &_mapping; }
++
++  // memory pools
++  FixPool* fixPool();
++  DynPool* dynPool();
++
++  // factories for object/file/class/function/line instances
++  TraceObject* object(const TQString& name);
++  TraceFile* file(const TQString& name);
++  TraceClass* cls(const TQString& fnName, TQString& shortName);
++  // function creation involves class creation if needed
++  TraceFunction* function(const TQString& name, TraceFile*, TraceObject*);
++  // factory for function cycles
++  TraceFunctionCycle* functionCycle(TraceFunction*);
++
++  /**
++   * Search for item with given name and highest subcost of given cost type.
++   *
++   * For some items, they will only be found if the parent cost is given:
++   *  Instr, Line, Call  => need parent of type Function
++   * For Function, a parent of type Obj/File/Class can be given, but
++   * isn't needed.
++   */
++  TraceCost* search(TraceItem::CostType, TQString,
++		    TraceCostType* ct = 0, TraceCost* parent = 0);
++
++  // for pretty function names without signature if unique...
++  TraceFunctionMap::Iterator functionIterator(TraceFunction*);
++  TraceFunctionMap::ConstIterator functionBeginIterator() const;
++  TraceFunctionMap::ConstIterator functionEndIterator() const;
++
++  TraceObjectMap& objectMap() { return _objectMap; }
++  TraceFileMap& fileMap() { return _fileMap; }
++  TraceClassMap& classMap() { return _classMap; }
++  TraceFunctionMap& functionMap() { return _functionMap; }
++
++  const TraceFunctionCycleList& functionCycles() { return _functionCycles; }
++  
++  TraceCost* callMax() { return &_callMax; }
++
++  void setCommand(const TQString& command) { _command = command; }
++  TQString command() const { return _command; }
++  TraceCost* totals() { return &_totals; }
++  void setMaxThreadID(int tid) { _maxThreadID = tid; }
++  int maxThreadID() const { return _maxThreadID; }
++  void setMaxPartNumber(int n) { _maxPartNumber = n; }
++  int maxPartNumber() const { return _maxPartNumber; }
++
++  // reset all manually set directories for source files
++  void resetSourceDirs();
++
++  virtual void update();
++
++  // invalidates all cost items dependant on active state of parts
++  void invalidateDynamicCost();
++
++  // cycle detection
++  void updateFunctionCycles();
++  void updateObjectCycles();
++  void updateClassCycles();
++  void updateFileCycles();
++  bool inFunctionCycleUpdate() { return _inFunctionCycleUpdate; }
++
++ private:
++  void init();
++  // add trace part: events from one trace file
++  TracePart* addPart(const TQString& dir, const TQString& file);
++
++  // for progress bar callbacks
++  TopLevel* _topLevel;
++
++  TracePartList _parts;
++
++  // The mapping for all costs
++  TraceCostMapping _mapping;
++
++  FixPool* _fixPool;
++  DynPool* _dynPool;
++
++  // always the trace totals (not dependent on active parts)
++  TraceCost _totals;
++  int _maxThreadID;
++  int _maxPartNumber;
++
++  TraceObjectMap _objectMap;
++  TraceClassMap _classMap;
++  TraceFileMap _fileMap;
++  TraceFunctionMap _functionMap;
++  TQString _command;
++  TQString _traceName;
++
++  // Max of all costs of calls: This allows to see if the incl. cost can
++  // be hidden for a cost type, as it's always the same as self cost
++  TraceCost _callMax;
++
++  // cycles
++  TraceFunctionCycleList _functionCycles;
++  int _functionCycleCount;
++  bool _inFunctionCycleUpdate;
++};
++
++
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/traceitemview.cpp b/kdecachegrind/kdecachegrind/traceitemview.cpp
+new file mode 100644
+index 0000000..d11f02b
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/traceitemview.cpp
+@@ -0,0 +1,443 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Trace Item View
++ */
++
++#include <tqwidget.h>
++#include <kconfig.h>
++#include <klocale.h>
++#include <kdebug.h>
++
++#include "traceitemview.h"
++#include "toplevel.h"
++
++#define TRACE_UPDATES 0
++
++TraceItemView::TraceItemView(TraceItemView* parentView, TopLevel* top)
++{
++  _parentView = parentView;
++  _topLevel = top ? top : parentView->topLevel();
++
++  _data = _newData = 0;
++  // _partList and _newPartList is empty
++  _activeItem = _newActiveItem = 0;
++  _selectedItem = _newSelectedItem = 0;
++  _costType = _newCostType = 0;
++  _costType2 = _newCostType2 = 0;
++  _groupType = _newGroupType = TraceItem::NoCostType;
++
++  _status = nothingChanged;
++  _inUpdate = false;
++  _pos = Hidden;
++}
++
++TQString TraceItemView::whatsThis() const
++{
++    return i18n("No description available");
++}
++
++void TraceItemView::select(TraceItem* i)
++{
++    _newSelectedItem = i;
++}
++
++KConfigGroup* TraceItemView::configGroup(KConfig* c,
++					 TQString group, TQString post)
++{
++    TQStringList gList = c->groupList();
++    if (gList.contains((group+post).ascii()) ) group += post;
++    return new KConfigGroup(c, group);
++}
++
++void TraceItemView::writeConfigEntry(KConfigBase* c, const char* pKey,
++				     TQString value, const char* def, bool bNLS)
++{
++    if (!c) return;
++    if ((value.isEmpty() && ((def == 0) || (*def == 0))) ||
++	(value == TQString(def)))
++	c->deleteEntry(pKey);
++    else
++	c->writeEntry(pKey, value, true, false, bNLS);
++}
++
++void TraceItemView::writeConfigEntry(KConfigBase* c, const char* pKey,
++				     int value, int def)
++{
++    if (!c) return;
++    if (value == def)
++	c->deleteEntry(pKey);
++    else
++	c->writeEntry(pKey, value);
++}
++
++void TraceItemView::writeConfigEntry(KConfigBase* c, const char* pKey,
++				     double value, double def)
++{
++    if (!c) return;
++    if (value == def)
++	c->deleteEntry(pKey);
++    else
++	c->writeEntry(pKey, value);
++}
++
++void TraceItemView::writeConfigEntry(KConfigBase* c, const char* pKey,
++				     bool value, bool def)
++{
++    if (!c) return;
++    if (value == def)
++	c->deleteEntry(pKey);
++    else
++	c->writeEntry(pKey, value);
++}
++
++void TraceItemView::readViewConfig(KConfig*, TQString, TQString, bool)
++{}
++
++#if 1
++void TraceItemView::saveViewConfig(KConfig*, TQString, TQString, bool)
++{}
++#else
++void TraceItemView::saveViewConfig(KConfig* c, 
++				   TQString prefix, TQString postfix, bool)
++{
++    // write a dummy config entry to see missing virtual functions
++    KConfigGroup g(c, (prefix+postfix).ascii());
++    g.writeEntry("SaveNotImplemented", true);
++}
++#endif
++
++bool TraceItemView::activate(TraceItem* i)
++{
++    i = canShow(i);
++    _newActiveItem = i;
++
++    return (i != 0);
++}
++
++TraceFunction* TraceItemView::activeFunction()
++{
++    TraceItem::CostType t = _activeItem->type();
++    switch(t) {
++    case TraceItem::Function:
++    case TraceItem::FunctionCycle:
++	return (TraceFunction*) _activeItem;
++    default:
++	break;
++    }
++    return 0;
++}
++
++bool TraceItemView::set(int changeType, TraceData* d,
++			TraceCostType* t1, TraceCostType* t2,
++			TraceItem::CostType g, const TracePartList& l,
++                        TraceItem* a, TraceItem* s)
++{
++  _status |= changeType;
++  _newData = d;
++  _newGroupType = g;
++  _newCostType = t1;
++  _newCostType2 = t2;
++  _newPartList = l;
++  _newSelectedItem = s;
++  _newActiveItem = canShow(a);
++  if (!_newActiveItem) {
++      _newSelectedItem = 0;
++      return false;
++  }
++
++  return true;
++}
++
++
++bool TraceItemView::isViewVisible()
++{
++  TQWidget* w = widget();
++  if (w)
++    return w->isVisible();
++  return false;
++}
++
++void TraceItemView::setData(TraceData* d)
++{
++  _newData = d;
++
++  // invalidate all pointers to old data
++  _activeItem = _newActiveItem = 0;
++  _selectedItem = _newSelectedItem = 0;
++  _costType = _newCostType = 0;
++  _costType2 = _newCostType2 = 0;
++  _groupType = _newGroupType = TraceItem::NoCostType;
++  _partList.clear();
++  _newPartList.clear();
++
++  // updateView will change this to dataChanged
++  _status = nothingChanged;
++}
++
++void TraceItemView::updateView(bool force)
++{
++  if (!force && !isViewVisible()) return;
++
++  if (_newData != _data) {
++    _status |= dataChanged;
++    _data = _newData;
++  }
++  else {
++    _status &= ~dataChanged;
++
++    // if there's no data change and data is 0, no update needed
++    if (!_data) return;
++  }
++
++  if (!(_newPartList == _partList)) {
++    _status |= partsChanged;
++    _partList = _newPartList;
++  }
++  else
++    _status &= ~partsChanged;
++
++  if (_newActiveItem != _activeItem) {
++
++      // when setting a new active item, there's no selection
++      _selectedItem = 0;
++
++      _status |= activeItemChanged;
++      _activeItem = _newActiveItem;
++  }
++  else
++    _status &= ~activeItemChanged;
++
++  if (_newCostType != _costType) {
++    _status |= costTypeChanged;
++    _costType = _newCostType;
++  }
++  else
++    _status &= ~costTypeChanged;
++
++  if (_newCostType2 != _costType2) {
++    _status |= costType2Changed;
++    _costType2 = _newCostType2;
++  }
++  else
++    _status &= ~costType2Changed;
++
++  if (_newGroupType != _groupType) {
++    _status |= groupTypeChanged;
++    _groupType = _newGroupType;
++  }
++  else
++    _status &= ~groupTypeChanged;
++
++
++  if (_newSelectedItem != _selectedItem) {
++    _status |= selectedItemChanged;
++    _selectedItem = _newSelectedItem;
++  }
++  else
++    _status &= ~selectedItemChanged;
++
++
++  if (!force && (_status == nothingChanged)) return;
++
++#if TRACE_UPDATES
++  kdDebug() << (widget() ? widget()->name() : "TraceItemView")
++            << "::doUpdate ( "
++            << ((_status & dataChanged) ? "data ":"")
++            << ((_status & configChanged) ? "config ":"")
++            << ")" << endl;
++
++  if (_status & partsChanged)
++    kdDebug() << "  Part List "
++              << _partList.names()
++              << endl;
++
++  if (_status & costTypeChanged)
++    kdDebug() << "  Cost type "
++              << (_costType ? _costType->name().ascii() : "?")
++              << endl;
++
++  if (_status & costType2Changed)
++    kdDebug() << "  Cost type 2 "
++              << (_costType2 ? _costType2->name().ascii() : "?")
++              << endl;
++
++  if (_status & groupTypeChanged)
++    kdDebug() << "  Group type "
++              << TraceItem::typeName(_groupType)
++              << endl;
++
++  if (_status & activeItemChanged)
++    kdDebug() << "  Active: "
++              << (_activeItem ? _activeItem->fullName().ascii() : "?")
++              << endl;
++
++  if (_status & selectedItemChanged)
++    kdDebug() << "  Selected: "
++              << (_selectedItem ? _selectedItem->fullName().ascii() : "?")
++              << endl;
++#endif
++
++  int st = _status;
++  _status = nothingChanged;
++  doUpdate(st);
++  return;
++
++  if (_inUpdate) return;
++  _inUpdate = true;
++  doUpdate(_status);
++  _inUpdate = false;
++}
++
++
++void TraceItemView::selected(TraceItemView* /*sender*/, TraceItem* i)
++{
++#if TRACE_UPDATES
++  kdDebug() << (widget() ? widget()->name() : "TraceItemView")
++            << "::selected "
++            << (i ? i->name().ascii(): "(nil)")
++            << ", sender "
++            << sender->widget()->name() << endl;
++#endif
++
++  if (_parentView) _parentView->selected(this, i);
++}
++
++void TraceItemView::selected(TraceItemView* /*sender*/, const TracePartList& l)
++{
++#if TRACE_UPDATES
++  kdDebug() << (widget() ? widget()->name() : "TraceItemView")
++            << "::selected "
++            << l.names()
++            << ", sender "
++            << sender->widget()->name() << endl;
++#endif
++
++  if (_parentView)
++    _parentView->selected(this, l);
++  else
++    if (_topLevel) _topLevel->activePartsChangedSlot(l);
++}
++
++void TraceItemView::activated(TraceItemView* /*sender*/, TraceItem* i)
++{
++#if TRACE_UPDATES
++  kdDebug() << (widget() ? widget()->name() : "TraceItemView")
++            << "::activated "
++            << (i ? i->name().ascii(): "(nil)")
++            << ", sender "
++            << sender->widget()->name() << endl;
++#endif
++
++  if (_parentView)
++      _parentView->activated(this, i);
++  else
++      if (_topLevel) _topLevel->setTraceItemDelayed(i);
++}
++
++void TraceItemView::selectedCostType(TraceItemView*, TraceCostType* t)
++{
++  if (_parentView)
++      _parentView->selectedCostType(this, t);
++  else
++      if (_topLevel) _topLevel->setCostTypeDelayed(t);
++}
++
++void TraceItemView::selectedCostType2(TraceItemView*, TraceCostType* t)
++{
++  if (_parentView)
++      _parentView->selectedCostType2(this, t);
++  else
++      if (_topLevel) _topLevel->setCostType2Delayed(t);
++}
++
++void TraceItemView::activated(TraceItemView*, Direction d)
++{
++  if (_parentView)
++      _parentView->activated(this, d);
++  else
++      if (_topLevel) _topLevel->setDirectionDelayed(d);
++}
++
++void TraceItemView::doUpdate(int)
++{
++}
++
++void TraceItemView::selected(TraceItem* i)
++{
++  if (_parentView)
++      _parentView->selected(this, i);
++
++}
++
++void TraceItemView::selected(const TracePartList& l)
++{
++  if (_parentView)
++      _parentView->selected(this, l);
++  else
++      if (_topLevel) _topLevel->activePartsChangedSlot(l);
++}
++
++void TraceItemView::activated(TraceItem* i)
++{
++#if TRACE_UPDATES
++  kdDebug() << (widget() ? widget()->name() : "TraceItemView")
++            << "::activated "
++            << (i ? i->name().ascii(): "(nil)") << endl;
++#endif
++
++  if (_parentView)
++      _parentView->activated(this, i);
++  else
++      if (_topLevel) _topLevel->setTraceItemDelayed(i);
++}
++
++void TraceItemView::selectedCostType(TraceCostType* t)
++{
++  if (_parentView)
++      _parentView->selectedCostType(this, t);
++  else
++      if (_topLevel) _topLevel->setCostTypeDelayed(t);
++}
++
++void TraceItemView::selectedCostType2(TraceCostType* t)
++{
++  if (_parentView)
++      _parentView->selectedCostType2(this, t);
++  else
++      if (_topLevel) _topLevel->setCostType2Delayed(t);
++}
++
++void TraceItemView::activated(Direction d)
++{
++  if (_parentView)
++      _parentView->activated(this, d);
++  else
++      if (_topLevel) _topLevel->setDirectionDelayed(d);
++}
++
++void TraceItemView::addCostMenu(TQPopupMenu* p, bool withCost2)
++{
++  if (_topLevel) _topLevel->addCostMenu(p, withCost2);
++}
++
++void TraceItemView::addGoMenu(TQPopupMenu* p)
++{
++  if (_topLevel) _topLevel->addGoMenu(p);
++}
+diff --git a/kdecachegrind/kdecachegrind/traceitemview.h b/kdecachegrind/kdecachegrind/traceitemview.h
+new file mode 100644
+index 0000000..f83aa89
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/traceitemview.h
+@@ -0,0 +1,206 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Trace Item View
++ */
++
++#ifndef TRACEITEMVIEW_H
++#define TRACEITEMVIEW_H
++
++#include "tracedata.h"
++
++class TQWidget;
++class TQPopupMenu;
++
++class KConfig;
++class KConfigGroup;
++class KConfigBase;
++
++class TopLevel;
++
++/**
++ * Abstract Base Class for KCachegrind Views
++ *
++ * This class delivers the shared functionality of all KCachegrind
++ * Views for one TraceItem (like Function, Object...), the "active"
++ * item. Additional view attributes are current primary cost type,
++ * an optional secondary cost type, group type,
++ * and possibly a selected costitem in this view.
++ * Note that there is a difference in changing the selected item of
++ * a view (this usually changes selection in other views, too), and
++ * activating that item.
++ */
++class TraceItemView
++{
++public:
++
++  /**
++   * Change type for update functions
++   * - <dataChanged> is used if e.g. cycles are recalculated
++   */
++  enum { nothingChanged      = 0,
++	 costTypeChanged     = 1,
++	 costType2Changed    = 2,
++	 groupTypeChanged    = 4,
++	 partsChanged        = 8,
++	 activeItemChanged   = 16,
++	 selectedItemChanged = 32,
++	 dataChanged         = 64,
++	 configChanged       = 128 };
++
++  enum Direction { None, Back, Forward, Up };
++
++  // a TraceItemView can have a position in a parent container
++  enum Position { Hidden, Top, Right, Left, Bottom };
++
++  TraceItemView(TraceItemView* parentView, TopLevel* top = 0);
++  virtual ~TraceItemView() {}
++
++  virtual TQString whatsThis() const;
++
++  static KConfigGroup* configGroup(KConfig*, TQString prefix, TQString postfix);
++  static void writeConfigEntry(KConfigBase*, const char* pKey, TQString value,
++                               const char* def, bool bNLS = false);
++  static void writeConfigEntry(KConfigBase*, const char* pKey,
++                               int value, int def);
++  static void writeConfigEntry(KConfigBase*, const char* pKey,
++                               bool value, bool def);
++  static void writeConfigEntry(KConfigBase*, const char* pKey,
++                               double value, double def);
++  virtual void readViewConfig(KConfig*, TQString prefix, TQString postfix,
++			      bool withOptions);
++  virtual void saveViewConfig(KConfig*, TQString prefix, TQString postfix,
++			      bool withOptions);
++
++  // Immediate remove all references to old data, and set the new.
++  // This resets the visualization state.
++  // A GUI update has to be triggered with updateView().
++  // Overwrite in container views to also set new data for all members.
++  virtual void setData(TraceData* d);
++
++  // change from parent, call updateView() to update lazily (only if visible)
++  void setCostType(TraceCostType* t) { _newCostType = t; }
++  void setCostType2(TraceCostType* t) { _newCostType2 = t; }
++  void set(TraceItem::CostType g) { _newGroupType = g; }
++  void set(const TracePartList& l) { _newPartList = l; }
++  // returns false if nothing can be shown for this trace item
++  bool activate(TraceItem* i);
++  void select(TraceItem* i);
++  void notifyChange(int changeType) { _status |= changeType; }
++  // all in one
++  bool set(int, TraceData*, TraceCostType*, TraceCostType*,
++	   TraceItem::CostType, const TracePartList&,
++	   TraceItem*, TraceItem*);
++
++  // general update request, call if view is/gets visible
++  void updateView(bool force = false);
++
++  /**
++   * Notification from child views.
++   * Default implementation notifies parent
++   */
++  virtual void selected(TraceItemView* sender, TraceItem*);
++  virtual void selected(TraceItemView* sender, const TracePartList&);
++  virtual void activated(TraceItemView* sender, Direction);
++  virtual void selectedCostType(TraceItemView* sender, TraceCostType*);
++  virtual void selectedCostType2(TraceItemView* sender, TraceCostType*);
++  virtual void activated(TraceItemView* sender, TraceItem*);
++
++  // getters...
++  // always get the newest values
++  TraceData* data() const { return _newData; }
++  TraceItem* activeItem() const { return _newActiveItem; }
++  TraceItem* selectedItem() const { return _newSelectedItem; }
++  TraceCostType* costType() const { return _newCostType; }
++  TraceCostType* costType2() const { return _newCostType2; }
++  TraceItem::CostType groupType() const { return _newGroupType; }
++  const TracePartList& partList() const { return _newPartList; }
++
++  TraceFunction* activeFunction();
++  int status() const { return _status; }
++
++  // pointer to top level window to e.g. show status messages
++  void setTopLevel(TopLevel* t) { _topLevel = t; }
++  TopLevel* topLevel() const { return _topLevel; }
++
++  void setPosition(Position p) { _pos = p; }
++  Position position() const { return _pos; }
++
++  void setTitle(TQString t) { _title = t; }
++  TQString title() const { return _title; }
++
++  // We depend on derived class to be a widget.
++  // Force overiding by making this abstract.
++  virtual TQWidget* widget() = 0;
++
++  /**
++   * This function is called when a new item should become active.
++   * Reimplement this in subclasses.
++   *
++   * Returns the real item to become active. You can call select() here.
++   * Return 0 if nothing can be shown.
++   * Use the methods like data() instead of _data here, as
++   * _data possibly will give old/wrong information.
++   */
++  virtual TraceItem* canShow(TraceItem* i) { return i; }
++
++  /* convenience functions for often used context menu items */
++  void addCostMenu(TQPopupMenu*,bool withCost2 = true);
++  void addGoMenu(TQPopupMenu*);
++
++protected:
++  // helpers to call selected()/activated() of parentView
++  void selected(TraceItem*);
++  void selected(const TracePartList&);
++  void activated(TraceItem*);
++  void selectedCostType(TraceCostType*);
++  void selectedCostType2(TraceCostType*);
++  void activated(Direction);
++
++  /* Is this view visible?
++   * if not, doUpdate() won't be called by updateView()
++   */
++  virtual bool isViewVisible();
++
++  // update handler (to be reimplemented)
++  virtual void doUpdate(int changeType);
++
++  TraceItemView* _parentView;
++  TopLevel* _topLevel;
++
++  TraceData* _data;
++  TracePartList _partList;
++  TraceItem *_activeItem, *_selectedItem;
++  TraceCostType *_costType, *_costType2;
++  TraceItem::CostType _groupType;
++
++private:
++  TraceData* _newData;
++  TracePartList _newPartList;
++  TraceItem *_newActiveItem, *_newSelectedItem;
++  TraceCostType *_newCostType, *_newCostType2;
++  TraceItem::CostType _newGroupType;
++
++  TQString _title;
++  int _status;
++  bool _inUpdate;
++  Position _pos;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/treemap.cpp b/kdecachegrind/kdecachegrind/treemap.cpp
+new file mode 100644
+index 0000000..0d4b8dc
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/treemap.cpp
+@@ -0,0 +1,3214 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * A Widget for visualizing hierarchical metrics as areas.
++ * The API is similar to TQListView.
++ */
++
++#include <math.h>
++
++#include <tqpainter.h>
++#include <tqtooltip.h>
++#include <tqregexp.h>
++#include <tqstyle.h>
++#include <tqpopupmenu.h>
++
++#include <klocale.h>
++#include <kconfig.h>
++#include <kdebug.h>
++
++#include "treemap.h"
++
++
++// set this to 1 to enable debug output
++#define DEBUG_DRAWING 0
++#define MAX_FIELD 12
++
++
++//
++// StoredDrawParams
++//
++StoredDrawParams::StoredDrawParams()
++{
++  _selected = false;
++  _current = false;
++  _shaded = true;
++  _rotated = false;
++
++  _backColor = TQt::white;
++
++  // field array has size 0
++}
++
++StoredDrawParams::StoredDrawParams(TQColor c,
++                                   bool selected, bool current)
++{
++  _backColor = c;
++
++  _selected = selected;
++  _current = current;
++  _shaded = true;
++  _rotated = false;
++  _drawFrame = true;
++
++  // field array has size 0
++}
++
++TQString StoredDrawParams::text(int f) const
++{
++  if ((f<0) || (f >= (int)_field.size()))
++    return TQString();
++
++  return _field[f].text;
++}
++
++TQPixmap StoredDrawParams::pixmap(int f) const
++{
++  if ((f<0) || (f >= (int)_field.size()))
++    return TQPixmap();
++
++  return _field[f].pix;
++}
++
++DrawParams::Position StoredDrawParams::position(int f) const
++{
++  if ((f<0) || (f >= (int)_field.size()))
++    return Default;
++
++  return _field[f].pos;
++}
++
++int StoredDrawParams::maxLines(int f) const
++{
++  if ((f<0) || (f >= (int)_field.size()))
++    return 0;
++
++  return _field[f].maxLines;
++}
++
++const TQFont& StoredDrawParams::font() const
++{
++  static TQFont* f = 0;
++  if (!f) f = new TQFont(TQApplication::font());
++
++  return *f;
++}
++
++void StoredDrawParams::ensureField(int f)
++{
++  static Field* def = 0;
++  if (!def) {
++    def = new Field();
++    def->pos = Default;
++    def->maxLines = 0;
++  }
++
++  if (f<0 || f>=MAX_FIELD) return;
++
++  if ((int)_field.size() < f+1) _field.resize(f+1, *def);
++}
++
++
++void StoredDrawParams::setField(int f, const TQString& t, TQPixmap pm,
++                           Position p, int maxLines)
++{
++  if (f<0 || f>=MAX_FIELD) return;
++  ensureField(f);
++
++  _field[f].text = t;
++  _field[f].pix  = pm;
++  _field[f].pos  = p;
++  _field[f].maxLines = maxLines;
++}
++
++void StoredDrawParams::setText(int f, const TQString& t)
++{
++  if (f<0 || f>=MAX_FIELD) return;
++  ensureField(f);
++
++  _field[f].text = t;
++}
++
++void StoredDrawParams::setPixmap(int f, const TQPixmap& pm)
++{
++  if (f<0 || f>=MAX_FIELD) return;
++  ensureField(f);
++
++  _field[f].pix = pm;
++}
++
++void StoredDrawParams::setPosition(int f, Position p)
++{
++  if (f<0 || f>=MAX_FIELD) return;
++  ensureField(f);
++
++  _field[f].pos = p;
++}
++
++void StoredDrawParams::setMaxLines(int f, int m)
++{
++  if (f<0 || f>=MAX_FIELD) return;
++  ensureField(f);
++
++  _field[f].maxLines = m;
++}
++
++
++
++//
++// RectDrawing
++//
++
++RectDrawing::RectDrawing(TQRect r)
++{
++  _fm = 0;
++  _dp = 0;
++  setRect(r);
++}
++
++
++RectDrawing::~RectDrawing()
++{
++  delete _fm;
++  delete _dp;
++}
++
++DrawParams* RectDrawing::drawParams()
++{
++  if (!_dp)
++    _dp = new StoredDrawParams();
++
++  return _dp;
++}
++
++
++void RectDrawing::setDrawParams(DrawParams* dp)
++{
++  if (_dp) delete _dp;
++  _dp = dp;
++}
++
++void RectDrawing::setRect(TQRect r)
++{
++  _rect = r;
++
++  _usedTopLeft = 0;
++  _usedTopCenter = 0;
++  _usedTopRight = 0;
++  _usedBottomLeft = 0;
++  _usedBottomCenter = 0;
++  _usedBottomRight = 0;
++
++  _fontHeight = 0;
++}
++
++TQRect RectDrawing::remainingRect(DrawParams* dp)
++{
++  if (!dp) dp = drawParams();
++
++  if ((_usedTopLeft >0) ||
++      (_usedTopCenter >0) ||
++      (_usedTopRight >0)) {
++    if (dp->rotated())
++      _rect.setLeft(_rect.left() + _fontHeight);
++    else
++      _rect.setTop(_rect.top() + _fontHeight);
++  }
++
++  if ((_usedBottomLeft >0) ||
++      (_usedBottomCenter >0) ||
++      (_usedBottomRight >0)) {
++    if (dp->rotated())
++      _rect.setRight(_rect.right() - _fontHeight);
++    else
++      _rect.setBottom(_rect.bottom() - _fontHeight);
++  }
++  return _rect;
++}
++
++
++void RectDrawing::drawBack(TQPainter* p, DrawParams* dp)
++{
++  if (!dp) dp = drawParams();
++  if (_rect.width()<=0 || _rect.height()<=0) return;
++
++  TQRect r = _rect;
++  TQColor normal = dp->backColor();
++  if (dp->selected()) normal = normal.light();
++  bool isCurrent = dp->current();
++
++  if (dp->drawFrame() || isCurrent) {
++    // 3D raised/sunken frame effect...
++    TQColor high = normal.light();
++    TQColor low = normal.dark();
++    p->setPen( isCurrent ? low:high);
++    p->drawLine(r.left(), r.top(), r.right(), r.top());
++    p->drawLine(r.left(), r.top(), r.left(), r.bottom());
++    p->setPen( isCurrent ? high:low);
++    p->drawLine(r.right(), r.top(), r.right(), r.bottom());
++    p->drawLine(r.left(), r.bottom(), r.right(), r.bottom());
++    r.setRect(r.x()+1, r.y()+1, r.width()-2, r.height()-2);
++  }
++  if (r.width()<=0 || r.height()<=0) return;
++
++  if (dp->shaded()) {
++    // some shading
++    bool goDark = tqGray(normal.rgb())>128;
++    int rBase, gBase, bBase;
++    normal.rgb(&rBase, &gBase, &bBase);
++    p->setBrush(TQBrush::NoBrush);
++
++    // shade parameters:
++    int d = 7;
++    float factor = 0.1, forth=0.7, back1 =0.9, toBack2 = .7, back2 = 0.97;
++
++    // coefficient corrections because of rectangle size
++    int s = r.width();
++    if (s > r.height()) s = r.height();
++    if (s<100) {
++      forth -= .3  * (100-s)/100;
++      back1 -= .2  * (100-s)/100;
++      back2 -= .02 * (100-s)/100;
++    }
++
++
++    // maximal color difference
++    int rDiff = goDark ? -rBase/d : (255-rBase)/d;
++    int gDiff = goDark ? -gBase/d : (255-gBase)/d;
++    int bDiff = goDark ? -bBase/d : (255-bBase)/d;
++
++    TQColor shadeColor;
++    while (factor<.95) {
++      shadeColor.setRgb((int)(rBase+factor*rDiff+.5),
++                        (int)(gBase+factor*gDiff+.5),
++                        (int)(bBase+factor*bDiff+.5));
++      p->setPen(shadeColor);
++      p->drawRect(r);
++      r.setRect(r.x()+1, r.y()+1, r.width()-2, r.height()-2);
++      if (r.width()<=0 || r.height()<=0) return;
++      factor = 1.0 - ((1.0 - factor) * forth);
++    }
++
++    // and back (1st half)
++    while (factor>toBack2) {
++      shadeColor.setRgb((int)(rBase+factor*rDiff+.5),
++                        (int)(gBase+factor*gDiff+.5),
++                        (int)(bBase+factor*bDiff+.5));
++      p->setPen(shadeColor);
++      p->drawRect(r);
++      r.setRect(r.x()+1, r.y()+1, r.width()-2, r.height()-2);
++      if (r.width()<=0 || r.height()<=0) return;
++      factor = 1.0 - ((1.0 - factor) / back1);
++    }
++
++    // and back (2nd half)
++    while ( factor>.01) {
++      shadeColor.setRgb((int)(rBase+factor*rDiff+.5),
++                        (int)(gBase+factor*gDiff+.5),
++                        (int)(bBase+factor*bDiff+.5));
++      p->setPen(shadeColor);
++      p->drawRect(r);
++      r.setRect(r.x()+1, r.y()+1, r.width()-2, r.height()-2);
++      if (r.width()<=0 || r.height()<=0) return;
++
++      factor = factor * back2;
++    }
++  }
++
++  // fill inside
++  p->setPen(TQPen::NoPen);
++  p->setBrush(normal);
++  p->drawRect(r);
++}
++
++
++bool RectDrawing::drawField(TQPainter* p, int f, DrawParams* dp)
++{
++  if (!dp) dp = drawParams();
++
++  if (!_fm) {
++    _fm = new TQFontMetrics(dp->font());
++    _fontHeight = _fm->height();
++  }
++
++  TQRect r = _rect;
++
++  if (0) kdDebug(90100) << "DrawField: Rect " << r.x() << "/" << r.y()
++		   << " - " << r.width() << "x" << r.height() << endl;
++
++  int h = _fontHeight;
++  bool rotate = dp->rotated();
++  int width   = (rotate ? r.height() : r.width()) -4;
++  int height  = (rotate ? r.width() : r.height());
++  int lines   = height / h;
++
++  // stop if we have no space available
++  if (lines<1) return false;
++
++  // calculate free space in first line (<unused>)
++  int pos = dp->position(f);
++  if (pos == DrawParams::Default) {
++    switch(f%4) {
++    case 0: pos = DrawParams::TopLeft; break;
++    case 1: pos = DrawParams::TopRight; break;
++    case 2: pos = DrawParams::BottomRight; break;
++    case 3: pos = DrawParams::BottomLeft; break;
++    }
++  }
++
++  int unused = 0;
++  bool isBottom = false;
++  bool isCenter = false;
++  bool isRight = false;
++  int* used = 0;
++  switch(pos) {
++  case DrawParams::TopLeft:
++    used = &_usedTopLeft;
++    if (_usedTopLeft == 0) {
++      if (_usedTopCenter)
++        unused = (width - _usedTopCenter)/2;
++      else
++        unused = width - _usedTopRight;
++    }
++    break;
++
++  case DrawParams::TopCenter:
++    isCenter = true;
++    used = &_usedTopCenter;
++    if (_usedTopCenter == 0) {
++      if (_usedTopLeft > _usedTopRight)
++        unused = width - 2 * _usedTopLeft;
++      else
++        unused = width - 2 * _usedTopRight;
++    }
++    break;
++
++  case DrawParams::TopRight:
++    isRight = true;
++    used = &_usedTopRight;
++    if (_usedTopRight == 0) {
++      if (_usedTopCenter)
++        unused = (width - _usedTopCenter)/2;
++      else
++        unused = width - _usedTopLeft;
++    }
++    break;
++
++  case DrawParams::BottomLeft:
++    isBottom = true;
++    used = &_usedBottomLeft;
++    if (_usedBottomLeft == 0) {
++      if (_usedBottomCenter)
++        unused = (width - _usedBottomCenter)/2;
++      else
++        unused = width - _usedBottomRight;
++    }
++    break;
++
++  case DrawParams::BottomCenter:
++    isCenter = true;
++    isBottom = true;
++    used = &_usedBottomCenter;
++    if (_usedBottomCenter == 0) {
++      if (_usedBottomLeft > _usedBottomRight)
++        unused = width - 2 * _usedBottomLeft;
++      else
++        unused = width - 2 * _usedBottomRight;
++    }
++    break;
++
++  case DrawParams::BottomRight:
++    isRight = true;
++    isBottom = true;
++    used = &_usedBottomRight;
++    if (_usedBottomRight == 0) {
++      if (_usedBottomCenter)
++        unused = (width - _usedBottomCenter)/2;
++      else
++        unused = width - _usedBottomLeft;
++    }
++    break;
++  }
++
++  if (isBottom) {
++    if ((_usedTopLeft >0) ||
++        (_usedTopCenter >0) ||
++        (_usedTopRight >0))
++      lines--;
++  }
++  else if (!isBottom) {
++    if ((_usedBottomLeft >0) ||
++        (_usedBottomCenter >0) ||
++        (_usedBottomRight >0))
++      lines--;
++  }
++  if (lines<1) return false;
++
++
++  int y = isBottom ? height - h : 0;
++
++  if (unused < 0) unused = 0;
++  if (unused == 0) {
++    // no space available in last line at this position
++    y = isBottom ? (y-h) : (y+h);
++    lines--;
++
++    if (lines<1) return false;
++
++    // new line: reset used space
++    if (isBottom)
++      _usedBottomLeft = _usedBottomCenter = _usedBottomRight = 0;
++    else
++      _usedTopLeft = _usedTopCenter = _usedTopRight = 0;
++
++    unused = width;
++  }
++
++  // stop as soon as possible when there's no space for "..."
++  static int dotW = 0;
++  if (!dotW) dotW = _fm->width("...");
++  if (width < dotW) return false;
++
++  // get text and pixmap now, only if we need to, because it is possible
++  // that they are calculated on demand (and this can take some time)
++  TQString name = dp->text(f);
++  if (name.isEmpty()) return 0;
++  TQPixmap pix = dp->pixmap(f);
++
++  // check if pixmap can be drawn
++  int pixW = pix.width();
++  int pixH = pix.height();
++  int pixY = 0;
++  bool pixDrawn = true;
++  if (pixW>0) {
++    pixW += 2; // X distance from pix
++    if ((width < pixW + dotW) || (height < pixH)) {
++      // don't draw
++      pixW = 0;
++    }
++    else
++      pixDrawn = false;
++  }
++
++  // width of text and pixmap to be drawn
++  int w = pixW + _fm->width(name);
++
++  if (0) kdDebug(90100) << "  For '" << name << "': Unused " << unused
++		   << ", StrW " << w << ", Width " << width << endl;
++
++  // if we have limited space at 1st line:
++  // use it only if whole name does fit in last line...
++  if ((unused < width) && (w > unused)) {
++    y = isBottom ? (y-h) : (y+h);
++    lines--;
++
++    if (lines<1) return false;
++
++    // new line: reset used space
++    if (isBottom)
++      _usedBottomLeft = _usedBottomCenter = _usedBottomRight = 0;
++    else
++      _usedTopLeft = _usedTopCenter = _usedTopRight = 0;
++  }
++
++  p->save();
++  p->setPen( (tqGray(dp->backColor().rgb())>100) ? TQt::black : TQt::white);
++  p->setFont(dp->font());
++  if (rotate) {
++    //p->translate(r.x()+2, r.y()+r.height());
++    p->translate(r.x(), r.y()+r.height()-2);
++    p->rotate(270);
++  }
++  else
++    p->translate(r.x()+2, r.y());
++
++
++  // adjust available lines according to maxLines
++  int max = dp->maxLines(f);
++  if ((max > 0) && (lines>max)) lines = max;
++
++  /* loop over name parts to break up string depending on available width.
++   * every char category change is supposed a possible break,
++   * with the exception Uppercase=>Lowercase.
++   * It's good enough for numbers, Symbols...
++   *
++   * If the text is to be written at the bottom, we start with the
++   * end of the string (so everything is reverted)
++   */
++  TQString remaining;
++  int origLines = lines;
++  while (lines>0) {
++
++    if (w>width && lines>1) {
++      int lastBreakPos = name.length(), lastWidth = w;
++      int len = name.length();
++      TQChar::Category caOld, ca;
++
++      if (!isBottom) {
++        // start with comparing categories of last 2 chars
++        caOld = name[len-1].category();
++        while (len>2) {
++          len--;
++          ca = name[len-1].category();
++          if (ca != caOld) {
++            // "Aa" has no break between...
++            if (ca == TQChar::Letter_Uppercase &&
++                caOld == TQChar::Letter_Lowercase) {
++              caOld = ca;
++              continue;
++            }
++            caOld = ca;
++            lastBreakPos = len;
++            w = pixW + _fm->width(name, len);
++            lastWidth = w;
++            if (w <= width) break;
++          }
++        }
++        w = lastWidth;
++        remaining = name.mid(lastBreakPos);
++        // remove space on break point
++        if (name[lastBreakPos-1].category() == TQChar::Separator_Space)
++          name = name.left(lastBreakPos-1);
++        else
++          name = name.left(lastBreakPos);
++      }
++      else { // bottom
++        int l = len;
++        caOld = name[l-len].category();
++        while (len>2) {
++          len--;
++          ca = name[l-len].category();
++
++          if (ca != caOld) {
++            // "Aa" has no break between...
++            if (caOld == TQChar::Letter_Uppercase &&
++                ca == TQChar::Letter_Lowercase) {
++              caOld = ca;
++              continue;
++            }
++            caOld = ca;
++            lastBreakPos = len;
++            w = pixW + _fm->width(name.right(len));
++            lastWidth = w;
++            if (w <= width) break;
++          }
++        }
++        w = lastWidth;
++        remaining = name.left(l-lastBreakPos);
++        // remove space on break point
++        if (name[l-lastBreakPos].category() == TQChar::Separator_Space)
++          name = name.right(lastBreakPos-1);
++        else
++          name = name.right(lastBreakPos);
++      }
++    }
++    else
++      remaining = TQString();
++
++    /* truncate and add ... if needed */
++    if (w>width) {
++      int len = name.length();
++      w += dotW;
++      while (len>2 && (w > width)) {
++        len--;
++        w = pixW + _fm->width(name, len) + dotW;
++      }
++      // stop drawing: we cannot draw 2 chars + "..."
++      if (w>width) break;
++
++      name = name.left(len) + "...";
++    }
++
++    int x = 0;
++    if (isCenter)
++      x = (width - w)/2;
++    else if (isRight)
++      x = width - w;
++
++    if (!pixDrawn) {
++        pixY = y+(h-pixH)/2; // default: center vertically
++        if (pixH > h) pixY = isBottom ? y-(pixH-h) : y;
++
++	p->drawPixmap( x, pixY, pix);
++
++        // for distance to next text
++	pixY = isBottom ? (pixY - h - 2) : (pixY + pixH + 2);
++	pixDrawn = true;
++    }
++
++
++    if (0) kdDebug(90100) << "  Drawing '" << name << "' at " 
++		     << x+pixW << "/" << y << endl;
++
++    p->drawText( x+pixW, y,
++		 width - pixW, h,
++		 TQt::AlignLeft, name);
++    y = isBottom ? (y-h) : (y+h);
++    lines--;
++
++    if (remaining.isEmpty()) break;
++    name = remaining;
++    w = pixW + _fm->width(name);
++  }
++
++  // make sure the pix stays visible
++  if (pixDrawn && (pixY>0)) {
++    if (isBottom && (pixY<y)) y = pixY;
++    if (!isBottom && (pixY>y)) y = pixY;
++  }
++
++  if (origLines > lines) {
++    // if only 1 line written, don't reset _used* vars
++    if (lines - origLines >1) {
++      if (isBottom)
++        _usedBottomLeft = _usedBottomCenter = _usedBottomRight = 0;
++      else
++        _usedTopLeft = _usedTopCenter = _usedTopRight = 0;
++    }
++
++    // take back one line
++    y = isBottom ? (y+h) : (y-h);
++    if (used) *used = w;
++  }
++
++  // update free space
++  if (!isBottom) {
++    if (rotate)
++      _rect.setRect(r.x()+y, r.y(), r.width()-y, r.height());
++    else
++      _rect.setRect(r.x(), r.y()+y, r.width(), r.height()-y);
++  }
++  else {
++    if (rotate)
++      _rect.setRect(r.x(), r.y(), y+h, r.height());
++    else
++      _rect.setRect(r.x(), r.y(), r.width(), y+h);
++  }
++
++  p->restore();
++
++  return true;
++}
++
++
++
++
++
++
++//
++// TreeMapItemList
++//
++
++int TreeMapItemList::compareItems ( Item item1, Item item2 )
++{
++  bool ascending;
++  int result;
++
++  TreeMapItem* parent = ((TreeMapItem*)item1)->parent();
++  // shouldn't happen
++  if (!parent) return 0;
++
++  int textNo = parent->sorting(&ascending);
++
++  if (textNo < 0) {
++    double diff = ((TreeMapItem*)item1)->value() -
++                  ((TreeMapItem*)item2)->value();
++    result = (diff < -.9) ? -1 : (diff > .9) ? 1 : 0;
++  }
++  else
++    result = (((TreeMapItem*)item1)->text(textNo) <
++	      ((TreeMapItem*)item2)->text(textNo)) ? -1 : 1;
++
++  return ascending ? result : -result;
++}
++
++
++TreeMapItem* TreeMapItemList::commonParent()
++{
++  TreeMapItem* parent, *item;
++  parent = first();
++  if (parent)
++    while( (item = next()) != 0)
++      parent = parent->commonParent(item);
++
++  return parent;
++}
++
++
++// TreeMapItem
++
++TreeMapItem::TreeMapItem(TreeMapItem* parent, double value)
++{
++  _value = value;
++  _parent = parent;
++
++  _sum = 0;
++  _children = 0;
++  _widget = 0;
++  _index = -1;
++  _depth = -1; // not set
++  _unused_self = 0;
++  _freeRects = 0;
++
++  if (_parent) {
++    // take sorting from parent
++    _sortTextNo = _parent->sorting(&_sortAscending);
++    _parent->addItem(this);
++  }
++  else {
++    _sortAscending = false;
++    _sortTextNo = -1; // default: no sorting
++  }
++}
++
++
++TreeMapItem::TreeMapItem(TreeMapItem* parent, double value,
++                         TQString text1, TQString text2,
++                         TQString text3, TQString text4)
++{
++  _value = value;
++  _parent = parent;
++
++  // this resizes the text vector only if needed
++  if (!text4.isEmpty()) setText(3, text4);
++  if (!text3.isEmpty()) setText(2, text3);
++  if (!text2.isEmpty()) setText(1, text2);
++  setText(0, text1);
++
++  _sum = 0;
++  _children = 0;
++  _widget = 0;
++  _index = -1;
++  _depth = -1; // not set
++  _unused_self = 0;
++  _freeRects = 0;
++
++  if (_parent) _parent->addItem(this);
++}
++
++TreeMapItem::~TreeMapItem()
++{
++  if (_children) delete _children;
++  if (_freeRects) delete _freeRects;
++
++  // finally, notify widget about deletion
++  if (_widget) _widget->deletingItem(this);
++}
++
++void TreeMapItem::setParent(TreeMapItem* p)
++{
++  _parent = p;
++  if (p) _widget = p->_widget;
++}
++
++bool TreeMapItem::isChildOf(TreeMapItem* item)
++{
++  if (!item) return false;
++
++  TreeMapItem* i = this;
++  while (i) {
++    if (item == i) return true;
++    i = i->_parent;
++  }
++  return false;
++}
++
++TreeMapItem* TreeMapItem::commonParent(TreeMapItem* item)
++{
++  while (item && !isChildOf(item)) {
++    item = item->parent();
++  }
++  return item;
++}
++
++void TreeMapItem::redraw()
++{
++  if (_widget)
++    _widget->redraw(this);
++}
++
++void TreeMapItem::clear()
++{
++  if (_children) {
++    // delete selected items below this item from selection
++    if (_widget) _widget->clearSelection(this);
++
++    delete _children;
++    _children = 0;
++  }
++}
++
++
++// invalidates current children and forces redraw
++// this is only usefull when children are created on demand in items()
++void TreeMapItem::refresh()
++{
++  clear();
++  redraw();
++}
++
++
++TQStringList TreeMapItem::path(int textNo) const
++{
++  TQStringList list(text(textNo));
++
++  TreeMapItem* i = _parent;
++  while (i) {
++    TQString text = i->text(textNo);
++    if (!text.isEmpty())
++        list.prepend(i->text(textNo));
++    i = i->_parent;
++  }
++  return list;
++}
++
++int TreeMapItem::depth() const
++{
++  if (_depth>0) return _depth;
++
++  if (_parent)
++    return _parent->depth() + 1;
++  return 1;
++}
++
++
++bool TreeMapItem::initialized()
++{
++  if (!_children) {
++    _children = new TreeMapItemList;
++    _children->setAutoDelete(true);
++    return false;
++  }
++  return true;
++}
++
++void TreeMapItem::addItem(TreeMapItem* i)
++{
++  if (!i) return;
++
++  if (!_children) {
++    _children = new TreeMapItemList;
++    _children->setAutoDelete(true);
++  }
++  i->setParent(this);
++
++  if (sorting(0) == -1)
++    _children->append(i); // preserve insertion order
++  else
++    _children->inSort(i);
++}
++
++
++// default implementations of virtual functions
++
++double TreeMapItem::value() const
++{
++  return _value;
++}
++
++double TreeMapItem::sum() const
++{
++  return _sum;
++}
++
++DrawParams::Position TreeMapItem::position(int f) const
++{
++  Position p = StoredDrawParams::position(f);
++  if (_widget && (p == Default))
++    p = _widget->fieldPosition(f);
++
++  return p;
++}
++
++// use widget font
++const TQFont& TreeMapItem::font() const
++{
++  return _widget->currentFont();
++}
++
++
++bool TreeMapItem::isMarked(int) const
++{
++    return false;
++}
++
++
++int TreeMapItem::borderWidth() const
++{
++  if (_widget)
++    return _widget->borderWidth();
++
++  return 2;
++}
++
++int TreeMapItem::sorting(bool* ascending) const
++{
++  if (ascending) *ascending = _sortAscending;
++  return _sortTextNo;
++}
++
++// do *not* set sorting recursively
++void TreeMapItem::setSorting(int textNo, bool ascending)
++{
++    if (_sortTextNo == textNo) {
++	if(_sortAscending == ascending) return;
++	if (textNo == -1) {
++	    // when no sorting is done, order change doesn't do anything
++	    _sortAscending = ascending;
++	    return;
++	}
++    }
++    _sortAscending = ascending;
++    _sortTextNo = textNo;
++
++    if (_children && _sortTextNo != -1) _children->sort();
++}
++
++void TreeMapItem::resort(bool recursive)
++{
++  if (!_children) return;
++
++  if (_sortTextNo != -1) _children->sort();
++
++  if (recursive)
++    for (TreeMapItem* i=_children->first(); i; i=_children->next())
++      i->resort(recursive);
++}
++
++
++TreeMapItem::SplitMode TreeMapItem::splitMode() const
++{
++  if (_widget)
++    return _widget->splitMode();
++
++  return Best;
++}
++
++int TreeMapItem::rtti() const
++{
++  return 0;
++}
++
++TreeMapItemList* TreeMapItem::children()
++{
++  if (!_children) {
++    _children = new TreeMapItemList;
++    _children->setAutoDelete(true);
++  }
++  return _children;
++}
++
++void TreeMapItem::clearItemRect()
++{
++    _rect = TQRect();
++    clearFreeRects();
++}
++
++void TreeMapItem::clearFreeRects()
++{
++    if (_freeRects) _freeRects->clear();
++}
++
++void TreeMapItem::addFreeRect(const TQRect& r)
++{
++    // don't add invalid rects
++    if ((r.width() < 1) || (r.height() < 1)) return;
++
++    if (!_freeRects) {
++	_freeRects = new TQPtrList<TQRect>;
++	_freeRects->setAutoDelete(true);
++    }
++
++    if (0) kdDebug(90100) << "addFree(" << path(0).join("/") << ", "
++		     << r.x() << "/" << r.y() << "-"
++		     << r.width() << "x" << r.height() << ")" << endl;
++
++    TQRect* last = _freeRects->last();
++    if (!last) {
++	_freeRects->append(new TQRect(r));
++	return;
++    }
++
++    // join rect with last rect if possible
++    // this saves memory and doesn't make the tooltip flicker
++
++    bool replaced = false;
++    if ((last->left() == r.left()) && (last->width() == r.width())) {
++	if ((last->bottom()+1 == r.top()) || (r.bottom()+1 == last->top())) {
++	    *last |= r;
++	    replaced = true;
++	}
++    }
++    else if ((last->top() == r.top()) && (last->height() == r.height())) {
++	if ((last->right()+1 == r.left()) || (r.right()+1 == last->left())) {
++	    *last |= r;
++	    replaced = true;
++	}
++    }
++
++    if (!replaced) {
++	_freeRects->append(new TQRect(r));
++	return;
++    }
++
++    if (0) kdDebug(90100) << "  united with last to (" 
++		     << last->x() << "/" << last->y() << "-"
++		     << last->width() << "x" << last->height() << ")" << endl;
++}
++
++
++// Tooltips for TreeMapWidget
++
++class TreeMapTip: public TQToolTip
++{
++public:
++  TreeMapTip( TQWidget* p ):TQToolTip(p) {}
++
++protected:
++    void maybeTip( const TQPoint & );
++};
++
++void TreeMapTip::maybeTip( const TQPoint& pos )
++{
++  if ( !parentWidget()->inherits( "TreeMapWidget" ) )
++        return;
++
++  TreeMapWidget* p = (TreeMapWidget*)parentWidget();
++  TreeMapItem* i;
++  i = p->item(pos.x(), pos.y());
++  TQPtrList<TQRect>* rList = i ? i->freeRects() : 0;
++  if (rList) {
++      TQRect* r;
++      for(r=rList->first();r;r=rList->next())
++	  if (r->contains(pos))
++	      tip(*r, p->tipString(i));
++  }
++}
++
++
++
++// TreeMapWidget
++
++TreeMapWidget::TreeMapWidget(TreeMapItem* base,
++			     TQWidget* parent, const char* name)
++    : TQWidget(parent, name)
++{
++    _base = base;
++    _base->setWidget(this);
++
++    _font = font();
++    _fontHeight = fontMetrics().height();
++
++
++  // default behaviour
++  _selectionMode = Single;
++  _splitMode = TreeMapItem::AlwaysBest;
++  _visibleWidth = 2;
++  _reuseSpace = false;
++  _skipIncorrectBorder = false;
++  _drawSeparators = false;
++  _allowRotation = true;
++  _borderWidth = 2;
++  _shading = true; // beautiful is default!
++  _maxSelectDepth = -1; // unlimited
++  _maxDrawingDepth = -1; // unlimited
++  _minimalArea = -1; // unlimited
++  _markNo = 0;
++
++  for(int i=0;i<4;i++) {
++    _drawFrame[i] = true;
++    _transparent[i] = false;
++  }
++
++  // _stopAtText will be unset on resizing (per default)
++  // _textVisible will be true on resizing (per default)
++  // _forceText will be false on resizing (per default)
++
++  // start state: _selection is an empty list
++  _current = 0;
++  _oldCurrent = 0;
++  _pressed = 0;
++  _lastOver = 0;
++  _needsRefresh = _base;
++
++  setBackgroundMode(TQt::NoBackground);
++  setFocusPolicy(TQ_StrongFocus);
++  _tip = new TreeMapTip(this);
++}
++
++TreeMapWidget::~TreeMapWidget()
++{
++  delete _base;
++  delete _tip;
++}
++
++const TQFont& TreeMapWidget::currentFont() const
++{
++  return _font;
++}
++
++void TreeMapWidget::setSplitMode(TreeMapItem::SplitMode m)
++{
++  if (_splitMode == m) return;
++
++  _splitMode = m;
++  redraw();
++}
++
++TreeMapItem::SplitMode TreeMapWidget::splitMode() const
++{
++  return _splitMode;
++}
++
++bool TreeMapWidget::setSplitMode(TQString mode)
++{
++  if (mode == "Bisection") setSplitMode(TreeMapItem::Bisection);
++  else if (mode == "Columns") setSplitMode(TreeMapItem::Columns);
++  else if (mode == "Rows") setSplitMode(TreeMapItem::Rows);
++  else if (mode == "AlwaysBest") setSplitMode(TreeMapItem::AlwaysBest);
++  else if (mode == "Best")       setSplitMode(TreeMapItem::Best);
++  else if (mode == "HAlternate") setSplitMode(TreeMapItem::HAlternate);
++  else if (mode == "VAlternate") setSplitMode(TreeMapItem::VAlternate);
++  else if (mode == "Horizontal") setSplitMode(TreeMapItem::Horizontal);
++  else if (mode == "Vertical")   setSplitMode(TreeMapItem::Vertical);
++  else return false;
++
++  return true;
++}
++
++TQString TreeMapWidget::splitModeString() const
++{
++  TQString mode;
++  switch(splitMode()) {
++    case TreeMapItem::Bisection:  mode = "Bisection"; break;
++    case TreeMapItem::Columns:    mode = "Columns"; break;
++    case TreeMapItem::Rows:       mode = "Rows"; break;
++    case TreeMapItem::AlwaysBest: mode = "AlwaysBest"; break;
++    case TreeMapItem::Best:       mode = "Best"; break;
++    case TreeMapItem::HAlternate: mode = "HAlternate"; break;
++    case TreeMapItem::VAlternate: mode = "VAlternate"; break;
++    case TreeMapItem::Horizontal: mode = "Horizontal"; break;
++    case TreeMapItem::Vertical:   mode = "Vertical"; break;
++    default: mode = "Unknown"; break;
++  }
++  return mode;
++}
++
++
++void TreeMapWidget::setShadingEnabled(bool s)
++{
++  if (_shading == s) return;
++
++  _shading = s;
++  redraw();
++}
++
++void TreeMapWidget::drawFrame(int d, bool b)
++{
++  if ((d<0) || (d>=4) || (_drawFrame[d]==b)) return;
++
++  _drawFrame[d] = b;
++  redraw();
++}
++
++void TreeMapWidget::setTransparent(int d, bool b)
++{
++  if ((d<0) || (d>=4) || (_transparent[d]==b)) return;
++
++  _transparent[d] = b;
++  redraw();
++}
++
++void TreeMapWidget::setAllowRotation(bool enable)
++{
++  if (_allowRotation == enable) return;
++
++  _allowRotation = enable;
++  redraw();
++}
++
++void TreeMapWidget::setVisibleWidth(int width, bool reuseSpace)
++{
++  if (_visibleWidth == width && _reuseSpace == reuseSpace) return;
++
++  _visibleWidth = width;
++  _reuseSpace = reuseSpace;
++  redraw();
++}
++
++void TreeMapWidget::setSkipIncorrectBorder(bool enable)
++{
++  if (_skipIncorrectBorder == enable) return;
++
++  _skipIncorrectBorder = enable;
++  redraw();
++}
++
++void TreeMapWidget::setBorderWidth(int w)
++{
++  if (_borderWidth == w) return;
++
++  _borderWidth = w;
++  redraw();
++}
++
++void TreeMapWidget::setMaxDrawingDepth(int d)
++{
++  if (_maxDrawingDepth == d) return;
++
++  _maxDrawingDepth = d;
++  redraw();
++}
++
++TQString TreeMapWidget::defaultFieldType(int f) const
++{
++  return i18n("Text %1").arg(f+1);
++}
++
++TQString TreeMapWidget::defaultFieldStop(int) const
++{
++  return TQString();
++}
++
++bool TreeMapWidget::defaultFieldVisible(int f) const
++{
++  return (f<2);
++}
++
++bool TreeMapWidget::defaultFieldForced(int) const
++{
++  return false;
++}
++
++DrawParams::Position TreeMapWidget::defaultFieldPosition(int f) const
++{
++  switch(f%4) {
++  case 0: return DrawParams::TopLeft;
++  case 1: return DrawParams::TopRight;
++  case 2: return DrawParams::BottomRight;
++  case 3: return DrawParams::BottomLeft;
++  default:break;
++  }
++  return DrawParams::TopLeft;
++}
++
++bool TreeMapWidget::resizeAttr(int size)
++{
++  if (size<0 || size>=MAX_FIELD) return false;
++
++  if (size>(int)_attr.size()) {
++    struct FieldAttr a;
++    int oldSize = _attr.size();
++    _attr.resize(size, a);
++    while (oldSize<size) {
++      _attr[oldSize].type    = defaultFieldType(oldSize);
++      _attr[oldSize].stop    = defaultFieldStop(oldSize);
++      _attr[oldSize].visible = defaultFieldVisible(oldSize);
++      _attr[oldSize].forced  = defaultFieldForced(oldSize);
++      _attr[oldSize].pos     = defaultFieldPosition(oldSize);
++      oldSize++;
++    }
++  }
++  return true;
++}
++
++void TreeMapWidget::setFieldType(int f, TQString type)
++{
++  if (((int)_attr.size() < f+1) &&
++      (type == defaultFieldType(f))) return;
++  if (resizeAttr(f+1)) _attr[f].type = type;
++
++  // no need to redraw: the type string is not visible in the TreeMap
++}
++
++TQString TreeMapWidget::fieldType(int f) const
++{
++  if (f<0 || (int)_attr.size()<f+1) return defaultFieldType(f);
++  return _attr[f].type;
++}
++
++void TreeMapWidget::setFieldStop(int f, TQString stop)
++{
++  if (((int)_attr.size() < f+1) &&
++      (stop == defaultFieldStop(f))) return;
++  if (resizeAttr(f+1)) {
++    _attr[f].stop = stop;
++    redraw();
++  }
++}
++
++TQString TreeMapWidget::fieldStop(int f) const
++{
++  if (f<0 || (int)_attr.size()<f+1) return defaultFieldStop(f);
++  return _attr[f].stop;
++}
++
++void TreeMapWidget::setFieldVisible(int f, bool enable)
++{
++  if (((int)_attr.size() < f+1) &&
++      (enable == defaultFieldVisible(f))) return;
++
++  if (resizeAttr(f+1)) {
++    _attr[f].visible = enable;
++    redraw();
++  }
++}
++
++bool TreeMapWidget::fieldVisible(int f) const
++{
++  if (f<0 || (int)_attr.size()<f+1)
++    return defaultFieldVisible(f);
++
++  return _attr[f].visible;
++}
++
++void TreeMapWidget::setFieldForced(int f, bool enable)
++{
++  if (((int)_attr.size() < f+1) &&
++      (enable == defaultFieldForced(f))) return;
++
++  if (resizeAttr(f+1)) {
++    _attr[f].forced = enable;
++    if (_attr[f].visible) redraw();
++  }
++}
++
++bool TreeMapWidget::fieldForced(int f) const
++{
++  if (f<0 || (int)_attr.size()<f+1)
++    return defaultFieldForced(f);
++
++  return _attr[f].forced;
++}
++
++void TreeMapWidget::setFieldPosition(int f, TreeMapItem::Position pos)
++{
++  if (((int)_attr.size() < f+1) &&
++      (pos == defaultFieldPosition(f))) return;
++
++  if (resizeAttr(f+1)) {
++    _attr[f].pos = pos;
++    if (_attr[f].visible) redraw();
++  }
++}
++
++DrawParams::Position TreeMapWidget::fieldPosition(int f) const
++{
++  if (f<0 || (int)_attr.size()<f+1)
++    return defaultFieldPosition(f);
++
++  return _attr[f].pos;
++}
++
++void TreeMapWidget::setFieldPosition(int f, TQString pos)
++{
++  if (pos == "TopLeft")
++    setFieldPosition(f, DrawParams::TopLeft);
++  else if (pos == "TopCenter")
++    setFieldPosition(f, DrawParams::TopCenter);
++  else if (pos == "TopRight")
++    setFieldPosition(f, DrawParams::TopRight);
++  else if (pos == "BottomLeft")
++    setFieldPosition(f, DrawParams::BottomLeft);
++  else if (pos == "BottomCenter")
++    setFieldPosition(f, DrawParams::BottomCenter);
++  else if (pos == "BottomRight")
++    setFieldPosition(f, DrawParams::BottomRight);
++  else if (pos == "Default")
++    setFieldPosition(f, DrawParams::Default);
++}
++
++TQString TreeMapWidget::fieldPositionString(int f) const
++{
++  TreeMapItem::Position pos = fieldPosition(f);
++  if (pos == DrawParams::TopLeft) return TQString("TopLeft");
++  if (pos == DrawParams::TopCenter) return TQString("TopCenter");
++  if (pos == DrawParams::TopRight) return TQString("TopRight");
++  if (pos == DrawParams::BottomLeft) return TQString("BottomLeft");
++  if (pos == DrawParams::BottomCenter) return TQString("BottomCenter");
++  if (pos == DrawParams::BottomRight) return TQString("BottomRight");
++  if (pos == DrawParams::Default) return TQString("Default");
++  return TQString("unknown");
++}
++
++void TreeMapWidget::setMinimalArea(int area)
++{
++  if (_minimalArea == area) return;
++
++  _minimalArea = area;
++  redraw();
++}
++
++
++void TreeMapWidget::deletingItem(TreeMapItem* i)
++{
++  // remove any references to the item to be deleted
++  while(_selection.findRef(i) > -1)
++    _selection.remove();
++
++  while(_tmpSelection.findRef(i) > -1)
++    _tmpSelection.remove();
++
++  if (_current == i) _current = 0;
++  if (_oldCurrent == i) _oldCurrent = 0;
++  if (_pressed == i) _pressed = 0;
++  if (_lastOver == i) _lastOver = 0;
++
++  // don't redraw a deleted item
++  if (_needsRefresh == i) {
++    // we can savely redraw the parent, as deleting order is
++    // from child to parent; i.e. i->parent() is existing. 
++    _needsRefresh = i->parent();
++  }
++}
++
++
++TQString TreeMapWidget::tipString(TreeMapItem* i) const
++{
++  TQString tip, itemTip;
++
++  while (i) {
++    if (!i->text(0).isEmpty()) {
++      itemTip = i->text(0);
++      if (!i->text(1).isEmpty())
++        itemTip += " (" + i->text(1) + ")";
++
++      if (!tip.isEmpty())
++        tip += "\n";
++
++      tip += itemTip;
++    }
++    i = i->parent();
++  }
++  return tip;
++}
++
++TreeMapItem* TreeMapWidget::item(int x, int y) const
++{
++  TreeMapItem* p = _base;
++  TreeMapItem* i;
++
++  if (!TQT_TQRECT_OBJECT(rect()).contains(x, y)) return 0;
++  if (DEBUG_DRAWING) kdDebug(90100) << "item(" << x << "," << y << "):" << endl;
++
++  while (1) {
++    TreeMapItemList* list = p->children();
++    if (!list)
++      i = 0;
++    else {
++      int idx=0;
++      for (i=list->first();i;i=list->next(),idx++) {
++
++        if (DEBUG_DRAWING)
++	    kdDebug(90100) << "  Checking " << i->path(0).join("/") << " ("
++		      << i->itemRect().x() << "/" << i->itemRect().y()
++		      << "-" << i->itemRect().width() 
++		      << "x" << i->itemRect().height() << ")" << endl;
++
++        if (i->itemRect().contains(x, y)) {
++
++	    if (DEBUG_DRAWING) kdDebug(90100) << "  .. Got. Index " << idx << endl;
++
++	    p->setIndex(idx);
++	    break;
++        }
++      }
++    }
++
++    if (!i) {
++      static TreeMapItem* last = 0;
++      if (p != last) {
++        last = p;
++
++        if (DEBUG_DRAWING)
++	    kdDebug(90100) << "item(" << x << "," << y << "): Got " 
++		      << p->path(0).join("/") << " (Size " 
++		      << p->itemRect().width() << "x" << p->itemRect().height()
++		      << ", Val " << p->value() << ")" << endl;
++      }
++
++      return p;
++    }
++    p = i;
++  }
++  return 0;
++}
++
++TreeMapItem* TreeMapWidget::possibleSelection(TreeMapItem* i) const
++{
++  if (i) {
++    if (_maxSelectDepth>=0) {
++      int depth = i->depth();
++      while(i && depth > _maxSelectDepth) {
++        i = i->parent();
++        depth--;
++      }
++    }
++  }
++  return i;
++}
++
++TreeMapItem* TreeMapWidget::visibleItem(TreeMapItem* i) const
++{
++  if (i) {
++    /* Must have a visible area */
++    while(i && ((i->itemRect().width() <1) ||
++                (i->itemRect().height() <1))) {
++      TreeMapItem* p = i->parent();
++      if (!p) break;
++      int idx = p->children()->findRef(i);
++      idx--;
++      if (idx<0)
++        i = p;
++      else
++        i = p->children()->at(idx);
++    }
++  }
++  return i;
++}
++
++void TreeMapWidget::setSelected(TreeMapItem* item, bool selected)
++{
++    item = possibleSelection(item);
++    setCurrent(item);
++
++    TreeMapItem* changed = setTmpSelected(item, selected);
++    if (!changed) return;
++
++    _selection = _tmpSelection;
++    if (_selectionMode == Single)
++      emit selectionChanged(item);
++    emit selectionChanged();
++    redraw(changed);
++    
++    if (0) kdDebug(90100) << (selected ? "S":"Des") << "elected Item "
++		     << (item ? item->path(0).join("") : TQString("(null)"))
++		     << " (depth " << (item ? item->depth() : -1) 
++		     << ")" << endl;
++}
++
++void TreeMapWidget::setMarked(int markNo, bool redrawWidget)
++{
++    // if there's no marking, return
++    if ((_markNo == 0) && (markNo == 0)) return;
++
++    _markNo = markNo;
++    if (!clearSelection() && redrawWidget) redraw();
++}
++
++/* Returns all items which appear only in one of the given lists */
++TreeMapItemList TreeMapWidget::diff(TreeMapItemList& l1,
++				    TreeMapItemList& l2)
++{
++  TreeMapItemList l;
++  TreeMapItemListIterator it1(l1), it2(l2);
++
++  TreeMapItem* item;
++  while ( (item = it1.current()) != 0 ) {
++    ++it1;
++    if (l2.containsRef(item) > 0) continue;
++    l.append(item);
++  }
++  while ( (item = it2.current()) != 0 ) {
++    ++it2;
++    if (l1.containsRef(item) > 0) continue;
++    l.append(item);
++  }
++
++  return l;
++}
++
++/* Only modifies _tmpSelection.
++ * Returns 0 when no change happened, otherwise the TreeMapItem that has
++ * to be redrawn for all changes.
++ */
++TreeMapItem* TreeMapWidget::setTmpSelected(TreeMapItem* item, bool selected)
++{
++  if (!item) return 0;
++  if (_selectionMode == NoSelection) return 0;
++
++  TreeMapItemList old = _tmpSelection;
++
++  if (_selectionMode == Single) {
++    _tmpSelection.clear();
++    if (selected) _tmpSelection.append(item);
++  }
++  else {
++    if (selected) {
++      TreeMapItem* i=_tmpSelection.first();
++      while (i) {
++	if (i->isChildOf(item) || item->isChildOf(i)) {
++	  _tmpSelection.remove();
++	  i = _tmpSelection.current();
++	}
++	else
++	  i = _tmpSelection.next();
++      }
++      _tmpSelection.append(item);
++    }
++    else
++      _tmpSelection.removeRef(item);
++  }
++
++  return diff(old, _tmpSelection).commonParent();
++}
++
++
++bool TreeMapWidget::clearSelection(TreeMapItem* parent)
++{
++  TreeMapItemList old = _selection;
++
++  TreeMapItem* i=_selection.first();
++  while (i) {
++    if (i->isChildOf(parent)) {
++      _selection.remove();
++      i = _selection.current();
++    }
++    else
++      i = _selection.next();
++  }
++
++  TreeMapItem* changed = diff(old, _selection).commonParent();
++  if (changed) {
++    changed->redraw();
++    emit selectionChanged();
++  }
++  return (changed != 0);
++}
++
++bool TreeMapWidget::isSelected(TreeMapItem* i) const
++{
++  return _selection.containsRef(i)>0;
++}
++
++bool TreeMapWidget::isTmpSelected(TreeMapItem* i)
++{
++  return _tmpSelection.containsRef(i)>0;
++}
++
++
++void TreeMapWidget::setCurrent(TreeMapItem* i, bool kbd)
++{
++    TreeMapItem* old = _current;
++    _current = i;
++
++    if (_markNo >0) {
++	// remove mark
++	_markNo = 0;
++
++	if (1) kdDebug(90100) << "setCurrent(" << i->path(0).join("/")
++			 << ") - mark removed" << endl;
++
++	// always complete redraw needed to remove mark
++	redraw();
++
++	if (old == _current) return;
++    }
++    else {
++	if (old == _current) return;
++
++	if (old) old->redraw();
++	if (i) i->redraw();
++    }
++
++    //kdDebug(90100) << "Current Item " << (i ? i->path().ascii() : "(null)") << endl;
++
++    emit currentChanged(i, kbd);
++}
++
++void TreeMapWidget::setRangeSelection(TreeMapItem* i1,
++				      TreeMapItem* i2, bool selected)
++{
++  i1 = possibleSelection(i1);
++  i2 = possibleSelection(i2);
++  setCurrent(i2);
++
++  TreeMapItem* changed = setTmpRangeSelection(i1, i2, selected);
++  if (!changed) return;
++
++  _selection = _tmpSelection;
++  if (_selectionMode == Single)
++    emit selectionChanged(i2);
++  emit selectionChanged();
++  redraw(changed);
++}
++
++TreeMapItem* TreeMapWidget::setTmpRangeSelection(TreeMapItem* i1,
++						 TreeMapItem* i2,
++						 bool selected)
++{
++  if ((i1 == 0) && (i2 == 0)) return 0;
++  if ((i1 == 0) || i1->isChildOf(i2)) return setTmpSelected(i2, selected);
++  if ((i2 == 0) || i2->isChildOf(i1)) return setTmpSelected(i1, selected);
++
++  TreeMapItem* changed = setTmpSelected(i1, selected);
++  TreeMapItem* changed2 = setTmpSelected(i2, selected);
++  if (changed2) changed = changed2->commonParent(changed);
++
++  TreeMapItem* commonParent = i1;
++  while (commonParent && !i2->isChildOf(commonParent)) {
++    i1 = commonParent;
++    commonParent = commonParent->parent();
++  }
++  if (!commonParent) return changed;
++  while (i2 && i2->parent() != commonParent)
++    i2 = i2->parent();
++  if (!i2) return changed;
++
++  TreeMapItemList* list = commonParent->children();
++  if (!list) return changed;
++
++  TreeMapItem* i = list->first();
++  bool between = false;
++  while (i) {
++    if (between) {
++      if (i==i1 || i==i2) break;
++      changed2 = setTmpSelected(i, selected);
++      if (changed2) changed = changed2->commonParent(changed);
++    }
++    else if (i==i1 || i==i2) 
++      between = true;
++    i = list->next();
++  }
++
++  return changed;
++}
++
++void TreeMapWidget::contextMenuEvent( TQContextMenuEvent* e )
++{
++  //kdDebug(90100) << "TreeMapWidget::contextMenuEvent" << endl;
++
++  if ( receivers( TQT_SIGNAL(contextMenuRequested(TreeMapItem*, const TQPoint &)) ) )
++    e->accept();
++
++  if ( e->reason() == TQContextMenuEvent::Keyboard ) {
++    TQRect r = (_current) ? _current->itemRect() : _base->itemRect();
++    TQPoint p = TQPoint(r.left() + r.width()/2, r.top() + r.height()/2);
++    emit contextMenuRequested(_current, p);
++  }
++  else {
++    TreeMapItem* i = item(e->x(), e->y());
++    emit contextMenuRequested(i, e->pos());
++  }
++}
++
++
++void TreeMapWidget::mousePressEvent( TQMouseEvent* e )
++{
++  //kdDebug(90100) << "TreeMapWidget::mousePressEvent" << endl;
++
++  _oldCurrent = _current;
++
++  TreeMapItem* i = item(e->x(), e->y());
++
++  _pressed = i;
++
++  _inShiftDrag = e->state() & ShiftButton;
++  _inControlDrag = e->state() & ControlButton;
++  _lastOver = _pressed;
++
++  TreeMapItem* changed = 0;
++  TreeMapItem* item = possibleSelection(_pressed);
++
++  switch(_selectionMode) {
++  case Single:
++    changed = setTmpSelected(item, true);
++    break;
++  case Multi:
++    changed = setTmpSelected(item, !isTmpSelected(item));
++    break;
++  case Extended:
++    if (_inControlDrag)
++      changed = setTmpSelected(item, !isTmpSelected(item));
++    else if (_inShiftDrag) {
++      TreeMapItem* sCurrent = possibleSelection(_current);
++      changed = setTmpRangeSelection(sCurrent, item,
++                                     !isTmpSelected(item));
++    }
++    else {
++      _selectionMode = Single;
++      changed = setTmpSelected(item, true);
++      _selectionMode = Extended;
++    }
++    break;
++  default:
++    break;
++  }
++
++  // item under mouse always selected on right button press
++  if (e->button() == Qt::RightButton) {
++    TreeMapItem* changed2 = setTmpSelected(item, true);
++    if (changed2) changed = changed2->commonParent(changed);
++  }
++
++  setCurrent(_pressed);
++
++  if (changed)
++    redraw(changed);
++
++  if (e->button() == Qt::RightButton) {
++
++    // emit selection change
++    if (! (_tmpSelection == _selection)) {
++      _selection = _tmpSelection;
++      if (_selectionMode == Single)
++	emit selectionChanged(_lastOver);
++      emit selectionChanged();
++    }
++    _pressed = 0;
++    _lastOver = 0;
++    emit rightButtonPressed(i, e->pos());
++  }
++}
++
++void TreeMapWidget::mouseMoveEvent( TQMouseEvent* e )
++{
++  //kdDebug(90100) << "TreeMapWidget::mouseMoveEvent" << endl;
++
++  if (!_pressed) return;
++  TreeMapItem* over = item(e->x(), e->y());
++  if (_lastOver == over) return;
++
++  setCurrent(over);
++  if (over == 0) {
++    _lastOver = 0;
++    return;
++  }
++
++  TreeMapItem* changed = 0;
++  TreeMapItem* item = possibleSelection(over);
++
++  switch(_selectionMode) {
++  case Single:
++    changed = setTmpSelected(item, true);
++    break;
++  case Multi:
++    changed = setTmpSelected(item, !isTmpSelected(item));
++    break;
++  case Extended:
++    if (_inControlDrag)
++      changed = setTmpSelected(item, !isTmpSelected(item));
++    else {
++      TreeMapItem* sLast = possibleSelection(_lastOver);
++      changed = setTmpRangeSelection(sLast, item, true);
++    }
++    break;
++
++  default:
++    break;
++  }
++
++  _lastOver = over;
++
++  if (changed)
++    redraw(changed);
++}
++
++void TreeMapWidget::mouseReleaseEvent( TQMouseEvent* )
++{
++  //kdDebug(90100) << "TreeMapWidget::mouseReleaseEvent" << endl;
++
++  if (!_pressed) return;
++
++  if (!_lastOver) {
++    // take back
++    setCurrent(_oldCurrent);
++    TreeMapItem* changed = diff(_tmpSelection, _selection).commonParent();
++    _tmpSelection = _selection;
++    if (changed)
++      redraw(changed);
++  }
++  else {
++    if (! (_tmpSelection == _selection)) {
++      _selection = _tmpSelection;
++      if (_selectionMode == Single)
++        emit selectionChanged(_lastOver);
++      emit selectionChanged();
++    }
++    if (!_inControlDrag && !_inShiftDrag && (_pressed == _lastOver))
++      emit clicked(_lastOver);
++  }
++
++  _pressed = 0;
++  _lastOver = 0;
++}
++
++
++void TreeMapWidget::mouseDoubleClickEvent( TQMouseEvent* e )
++{
++  TreeMapItem* over = item(e->x(), e->y());
++
++  emit doubleClicked(over);
++}
++
++
++/* returns -1 if nothing visible found */
++int nextVisible(TreeMapItem* i)
++{
++  TreeMapItem* p = i->parent();
++  if (!p || p->itemRect().isEmpty()) return -1;
++
++  int idx = p->children()->findRef(i);
++  if (idx<0) return -1;
++
++  while (idx < (int)p->children()->count()-1) {
++    idx++;
++    TQRect r = p->children()->at(idx)->itemRect();
++    if (r.width()>1 && r.height()>1)
++      return idx;
++  }
++  return -1;
++}
++
++/* returns -1 if nothing visible found */
++int prevVisible(TreeMapItem* i)
++{
++  TreeMapItem* p = i->parent();
++  if (!p || p->itemRect().isEmpty()) return -1;
++
++  int idx = p->children()->findRef(i);
++  if (idx<0) return -1;
++
++  while (idx > 0) {
++    idx--;
++    TQRect r = p->children()->at(idx)->itemRect();
++    if (r.width()>1 && r.height()>1)
++      return idx;
++  }
++  return -1;
++}
++
++
++
++
++void TreeMapWidget::keyPressEvent( TQKeyEvent* e )
++{
++  if (e->key() == Key_Escape && _pressed) {
++
++    // take back
++    if (_oldCurrent != _lastOver)
++      setCurrent(_oldCurrent);
++    if (! (_tmpSelection == _selection)) {
++      TreeMapItem* changed = diff(_tmpSelection, _selection).commonParent();
++      _tmpSelection = _selection;
++      if (changed)
++	redraw(changed);
++    }
++    _pressed = 0;
++    _lastOver = 0;
++  }
++
++  if ((e->key() == Key_Space) ||
++      (e->key() == Key_Return)) {
++
++    switch(_selectionMode) {
++    case NoSelection:
++      break;
++    case Single:
++      setSelected(_current, true);
++      break;
++    case Multi:
++      setSelected(_current, !isSelected(_current));
++      break;
++    case Extended:
++      if ((e->state() & ControlButton) || (e->state() & ShiftButton))
++        setSelected(_current, !isSelected(_current));
++      else {
++        _selectionMode = Single;
++        setSelected(_current, true);
++        _selectionMode = Extended;
++      }
++    }
++
++    if (_current && (e->key() == Key_Return))
++      emit returnPressed(_current);
++
++    return;
++  }
++
++  if (!_current) {
++    if (e->key() == Key_Down) {
++      setCurrent(_base, true);
++    }
++    return;
++  }
++
++  TreeMapItem* old = _current,  *newItem;
++  TreeMapItem* p = _current->parent();
++
++  bool goBack;
++  if (_current->sorting(&goBack) == -1) {
++    // noSorting
++    goBack = false;
++  }
++
++
++  if ((e->key() == Key_Backspace) ||
++      (e->key() == Key_Up)) {
++    newItem = visibleItem(p);
++    setCurrent(newItem, true);
++  }
++  else if (e->key() == Key_Left) {
++    int newIdx = goBack ? nextVisible(_current) : prevVisible(_current);
++    if (p && newIdx>=0) {
++      p->setIndex(newIdx);
++      setCurrent(p->children()->at(newIdx), true);
++    }
++  }
++  else if (e->key() == Key_Right) {
++    int newIdx = goBack ? prevVisible(_current) : nextVisible(_current);
++    if (p && newIdx>=0) {
++      p->setIndex(newIdx);
++      setCurrent(p->children()->at(newIdx), true);
++    }
++  }
++  else if (e->key() == Key_Down) {
++    if (_current->children() && _current->children()->count()>0) {
++      int newIdx = _current->index();
++      if (newIdx<0)
++        newIdx = goBack ? (_current->children()->count()-1) : 0;
++      if (newIdx>=(int)_current->children()->count())
++        newIdx = _current->children()->count()-1;
++      newItem = visibleItem(_current->children()->at(newIdx));
++      setCurrent(newItem, true);
++    }
++  }
++
++  if (old == _current) return;
++  if (! (e->state() & ControlButton)) return;
++  if (! (e->state() & ShiftButton)) return;
++
++  switch(_selectionMode) {
++  case NoSelection:
++    break;
++  case Single:
++    setSelected(_current, true);
++    break;
++  case Multi:
++    setSelected(_current, !isSelected(_current));
++    break;
++  case Extended:
++    if (e->state() & ControlButton)
++      setSelected(_current, !isSelected(_current));
++    else
++      setSelected(_current, isSelected(old));
++  }
++}
++
++void TreeMapWidget::fontChange( const TQFont& )
++{
++  redraw();
++}
++
++
++void TreeMapWidget::resizeEvent( TQResizeEvent * )
++{
++  // this automatically redraws (as size is changed)
++  drawTreeMap();
++}
++
++void TreeMapWidget::paintEvent( TQPaintEvent * )
++{
++  drawTreeMap();
++}
++
++void TreeMapWidget::showEvent( TQShowEvent * )
++{
++  // refresh only if needed
++  drawTreeMap();
++}
++
++// Updates screen from shadow buffer,
++// but redraws before if needed
++void TreeMapWidget::drawTreeMap()
++{
++  // no need to draw if hidden
++  if (!isVisible()) return;
++
++  if (_pixmap.size() != size())
++    _needsRefresh = _base;
++
++  if (_needsRefresh) {
++
++    if (DEBUG_DRAWING)
++      kdDebug(90100) << "Redrawing " << _needsRefresh->path(0).join("/") << endl;
++    
++    if (_needsRefresh == _base) {
++      // redraw whole widget
++      _pixmap = TQPixmap(size());
++      _pixmap.fill(backgroundColor());
++    }
++    TQPainter p(&_pixmap);
++    if (_needsRefresh == _base) {
++      p.setPen(black);
++      p.drawRect(TQRect(2, 2, TQWidget::width()-4, TQWidget::height()-4));
++      _base->setItemRect(TQRect(3, 3, TQWidget::width()-6, TQWidget::height()-6));
++    }
++    else {
++      // only subitem
++      if (!_needsRefresh->itemRect().isValid()) return;
++    }
++
++    // reset cached font object; it could have been changed
++    _font = font();
++    _fontHeight = fontMetrics().height();
++
++    drawItems(&p, _needsRefresh);
++    _needsRefresh = 0;
++  }
++
++  bitBlt( TQT_TQPAINTDEVICE(this), 0, 0, TQT_TQPAINTDEVICE(&_pixmap), 0, 0,
++          TQWidget::width(), TQWidget::height(), CopyROP, true);
++
++  if (hasFocus()) {
++    TQPainter p(this);
++    style().tqdrawPrimitive( TQStyle::PE_FocusRect, &p,
++                           TQRect(0, 0, TQWidget::width(), TQWidget::height()),
++                           colorGroup() );
++  }
++}
++
++
++
++void TreeMapWidget::redraw(TreeMapItem* i)
++{
++  if (!i) return;
++
++  if (!_needsRefresh)
++    _needsRefresh = i;
++  else {
++    if (!i->isChildOf(_needsRefresh))
++      _needsRefresh = _needsRefresh->commonParent(i);
++  }
++
++  if (isVisible()) {
++    // delayed drawing if we have multiple redraw requests
++    update();
++  }
++}
++
++void TreeMapWidget::drawItem(TQPainter* p,
++                             TreeMapItem* item)
++{
++  bool isSelected = false;
++  TreeMapItem* i;
++
++  if (_markNo>0) {
++      for(i = item;i;i=i->parent())
++	  if (i->isMarked(_markNo)) break;
++
++      isSelected = (i!=0);
++  }
++  else {
++      for (i=_tmpSelection.first();i;i=_tmpSelection.next())
++	  if (item->isChildOf(i)) break;
++
++      isSelected = (i!=0);
++  }
++
++  bool isCurrent = _current && item->isChildOf(_current);
++  int dd = item->depth();
++  if (isTransparent(dd)) return;
++
++  RectDrawing d(item->itemRect());
++  item->setSelected(isSelected);
++  item->setCurrent(isCurrent);
++  item->setShaded(_shading);
++  item->drawFrame(drawFrame(dd));
++  d.drawBack(p, item);
++}
++
++
++bool TreeMapWidget::horizontal(TreeMapItem* i, const TQRect& r)
++{
++  switch(i->splitMode()) {
++  case TreeMapItem::HAlternate:
++    return (i->depth()%2)==1;
++  case TreeMapItem::VAlternate:
++    return (i->depth()%2)==0;
++  case TreeMapItem::Horizontal:
++    return true;
++  case TreeMapItem::Vertical:
++    return false;
++  default:
++    return r.width() > r.height();
++  }
++  return false;
++}
++
++
++/**
++ * Draw TreeMapItems recursive, starting from item
++ */
++void TreeMapWidget::drawItems(TQPainter* p,
++                              TreeMapItem* item)
++{
++    if (DEBUG_DRAWING)
++	kdDebug(90100) << "+drawItems(" << item->path(0).join("/") << ", "
++		  << item->itemRect().x() << "/" << item->itemRect().y()
++		  << "-" << item->itemRect().width() << "x"
++		  << item->itemRect().height() << "), Val " << item->value()
++		  << ", Sum " << item->sum() << endl;
++
++  drawItem(p, item);
++  item->clearFreeRects();
++
++  TQRect origRect = item->itemRect();
++  int bw = item->borderWidth();
++  TQRect r = TQRect(origRect.x()+bw, origRect.y()+bw,
++                  origRect.width()-2*bw, origRect.height()-2*bw);
++
++  TreeMapItemList* list = item->children();
++  TreeMapItem* i;
++
++  bool stopDrawing = false;
++
++  // only subdivide if there are children
++  if (!list || list->count()==0)
++    stopDrawing = true;
++
++  // only subdivide if there is enough space
++  if (!stopDrawing && (r.width()<=0 || r.height()<=0))
++    stopDrawing = true;
++
++  // stop drawing if maximum depth is reached
++  if (!stopDrawing &&
++      (_maxDrawingDepth>=0 && item->depth()>=_maxDrawingDepth))
++    stopDrawing = true;
++
++  // stop drawing if stopAtText is reached
++  if (!stopDrawing)
++    for (int no=0;no<(int)_attr.size();no++) {
++      TQString stopAt = fieldStop(no);
++      if (!stopAt.isEmpty() && (item->text(no) == stopAt)) {
++        stopDrawing = true;
++        break;
++      }
++    }
++
++  // area size is checked later...
++#if 0
++  // stop drawing if minimal area size is reached
++  if (!stopDrawing &&
++      (_minimalArea > 0) &&
++      (r.width() * r.height() < _minimalArea)) stopDrawing = true;
++#endif
++
++  if (stopDrawing) {
++    if (list) {
++      // invalidate rects
++      for (i=list->first();i;i=list->next())
++        i->clearItemRect();
++    }
++    // tooltip apears on whole item rect
++    item->addFreeRect(item->itemRect());
++
++    // if we have space for text...
++    if ((r.height() < _fontHeight) || (r.width() < _fontHeight)) return;
++
++    RectDrawing d(r);
++    item->setRotated(_allowRotation && (r.height() > r.width()));
++    for (int no=0;no<(int)_attr.size();no++) {
++      if (!fieldVisible(no)) continue;
++      d.drawField(p, no, item);
++    }
++    r = d.remainingRect(item);
++
++    if (DEBUG_DRAWING)
++	kdDebug(90100) << "-drawItems(" << item->path(0).join("/") << ")" << endl;
++    return;
++  }
++
++  double user_sum, child_sum, self;
++
++  // user supplied sum
++  user_sum = item->sum();
++
++  // own sum
++  child_sum = 0;
++  for (i=list->first();i;i=list->next()) {
++    child_sum += i->value();
++    if (DEBUG_DRAWING)
++      kdDebug(90100) << "  child: " << i->text(0) << ", value " 
++		<< i->value() << endl;
++  }
++
++  TQRect orig = r;
++
++  // if we have space for text...
++  if ((r.height() >= _fontHeight) && (r.width() >= _fontHeight)) {
++
++    RectDrawing d(r);
++    item->setRotated(_allowRotation && (r.height() > r.width()));
++    for (int no=0;no<(int)_attr.size();no++) {
++      if (!fieldVisible(no)) continue;
++      if (!fieldForced(no)) continue;
++      d.drawField(p, no, item);
++    }
++    r = d.remainingRect(item);
++  }
++
++  if (orig.x() == r.x()) {
++    // Strings on top
++    item->addFreeRect(TQRect(orig.x(), orig.y(),
++			    orig.width(), orig.height()-r.height()));
++  }
++  else {
++    // Strings on the left
++    item->addFreeRect(TQRect(orig.x(), orig.y(),
++			    orig.width()-r.width(), orig.height()));
++  }
++
++  if (user_sum == 0) {
++    // user didn't supply any sum
++    user_sum = child_sum;
++    self = 0;
++  }
++  else {
++    self = user_sum - child_sum;
++
++    if (user_sum < child_sum) {
++      //kdDebug(90100) << "TreeMWidget " <<
++      //       item->path() << ": User sum " << user_sum << " < Child Items sum " << child_sum << endl;
++
++      // invalid user supplied sum: ignore and use calculate sum
++      user_sum = child_sum;
++      self = 0.0;
++    }
++    else {
++      // Try to put the border waste in self
++      // percent of wasted space on border...
++      float borderArea = origRect.width() * origRect.height();
++      borderArea = (borderArea - r.width()*r.height())/borderArea;
++      unsigned borderValue = (unsigned)(borderArea * user_sum);
++
++      if (borderValue > self) {
++        if (_skipIncorrectBorder) {
++          r = origRect;
++          // should add my self to nested self and set my self =0
++        }
++        else
++          self = 0.0;
++      }
++      else
++        self -= borderValue;
++
++      user_sum = child_sum + self;
++    }
++  }
++
++  bool rotate = (_allowRotation && (r.height() > r.width()));
++  int self_length = (int)( ((rotate) ? r.width() : r.height()) *
++			   self / user_sum + .5);
++  if (self_length > 0) {
++    // take space for self cost
++    TQRect sr = r;
++    if (rotate) {
++      sr.setWidth( self_length );
++      r.setRect(r.x()+sr.width(), r.y(), r.width()-sr.width(), r.height());
++    }
++    else {
++      sr.setHeight( self_length );
++      r.setRect(r.x(), r.y()+sr.height(), r.width(), r.height()-sr.height());
++    }
++
++    // set selfRect (not occupied by children) for tooltip
++    item->addFreeRect(sr);
++
++    if (0) kdDebug(90100) << "Item " << item->path(0).join("/") << ": SelfR "
++		     << sr.x() << "/" << sr.y() << "-" << sr.width()
++		     << "/" << sr.height() << ", self " << self << "/"
++		     << user_sum << endl;
++
++    if ((sr.height() >= _fontHeight) && (sr.width() >= _fontHeight)) {
++
++      RectDrawing d(sr);
++      item->setRotated(_allowRotation && (r.height() > r.width()));
++      for (int no=0;no<(int)_attr.size();no++) {
++	if (!fieldVisible(no)) continue;
++	if (fieldForced(no)) continue;
++	d.drawField(p, no, item);
++      }
++    }
++
++    user_sum -= self;
++  }
++
++  bool goBack;
++  if (item->sorting(&goBack) == -1) {
++    // noSorting
++    goBack = false;
++  }
++
++  TreeMapItemListIterator it(*list);
++  if (goBack) it.toLast();
++
++  if (item->splitMode() == TreeMapItem::Columns) {
++    int len = list->count();
++    bool drawDetails = true;
++
++    while (len>0 && user_sum>0) {
++      TreeMapItemListIterator first = it;
++      double valSum = 0;
++      int lenLeft = len;
++      int columns = (int)(sqrt((double)len * r.width()/r.height())+.5);
++      if (columns==0) columns = 1; //should never be needed
++
++      while (lenLeft>0 && ((double)valSum*(len-lenLeft) <
++                           (double)len*user_sum/columns/columns)) {
++        valSum += it.current()->value();
++        if (goBack) --it; else ++it;
++        lenLeft--;
++      }
++
++      // we always split horizontally
++      int nextPos = (int)((double)r.width() * valSum / user_sum);
++      TQRect firstRect = TQRect(r.x(), r.y(), nextPos, r.height());
++
++      if (nextPos < _visibleWidth) {
++	  if (item->sorting(0) == -1) {
++	      // fill current rect with hash pattern
++	      drawFill(item, p, firstRect);
++	  }
++	  else {
++	      // fill rest with hash pattern
++	      drawFill(item, p, r, first, len, goBack);
++	      break;
++	  }
++      }
++      else {
++        drawDetails = drawItemArray(p, item, firstRect,
++                                    valSum, first, len-lenLeft, goBack);
++      }
++      r.setRect(r.x()+nextPos, r.y(), r.width()-nextPos, r.height());
++      user_sum -= valSum;
++      len = lenLeft;
++
++      if (!drawDetails) {
++        if (item->sorting(0) == -1)
++          drawDetails = true;
++        else {
++          drawFill(item, p, r, it, len, goBack);
++          break;
++        }
++      }
++    }
++  }
++  else if (item->splitMode() == TreeMapItem::Rows) {
++    int len = list->count();
++    bool drawDetails = true;
++
++    while (len>0 && user_sum>0) {
++      TreeMapItemListIterator first = it;
++      double valSum = 0;
++      int lenLeft = len;
++      int rows = (int)(sqrt((double)len * r.height()/r.width())+.5);
++      if (rows==0) rows = 1; //should never be needed
++
++      while (lenLeft>0 && ((double)valSum*(len-lenLeft) <
++                           (double)len*user_sum/rows/rows)) {
++        valSum += it.current()->value();
++        if (goBack) --it; else ++it;
++        lenLeft--;
++      }
++
++      // we always split horizontally
++      int nextPos = (int)((double)r.height() * valSum / user_sum);
++      TQRect firstRect = TQRect(r.x(), r.y(), r.width(), nextPos);
++
++      if (nextPos < _visibleWidth) {
++        if (item->sorting(0) == -1) {
++	    drawFill(item, p, firstRect);
++        }
++        else {
++	    drawFill(item, p, r, first, len, goBack);
++	    break;
++        }
++      }
++      else {
++        drawDetails = drawItemArray(p, item, firstRect,
++                                    valSum, first, len-lenLeft, goBack);
++      }
++      r.setRect(r.x(), r.y()+nextPos, r.width(), r.height()-nextPos);
++      user_sum -= valSum;
++      len = lenLeft;
++
++      if (!drawDetails) {
++        if (item->sorting(0) == -1)
++          drawDetails = true;
++        else {
++          drawFill(item, p, r, it, len, goBack);
++          break;
++        }
++      }
++    }
++  }
++  else
++    drawItemArray(p, item, r, user_sum, it, list->count(), goBack);
++
++  if (DEBUG_DRAWING)
++      kdDebug(90100) << "-drawItems(" << item->path(0).join("/") << ")" << endl;
++}
++
++// fills area with a pattern if to small to draw children
++void TreeMapWidget::drawFill(TreeMapItem* i, TQPainter* p, TQRect& r)
++{
++  p->setBrush(TQt::Dense4Pattern);
++  p->setPen(TQt::NoPen);
++  p->drawRect(r);
++  i->addFreeRect(r);
++}
++
++// fills area with a pattern if to small to draw children
++void TreeMapWidget::drawFill(TreeMapItem* i, TQPainter* p, TQRect& r,
++                             TreeMapItemListIterator it, int len, bool goBack)
++{
++  if (DEBUG_DRAWING)
++      kdDebug(90100) << "  +drawFill(" << r.x() << "/" << r.y()
++		<< "-" << r.width() << "x" << r.height()
++		<< ", len " << len << ")" << endl;
++
++  p->setBrush(TQt::Dense4Pattern);
++  p->setPen(TQt::NoPen);
++  p->drawRect(r);
++  i->addFreeRect(r);
++
++  // reset rects
++  while (len>0 && it.current()) {
++
++      if (DEBUG_DRAWING)
++	  kdDebug(90100) << "   Reset Rect " << (*it)->path(0).join("/") << endl;
++
++      (*it)->clearItemRect();
++      if (goBack) --it; else ++it;
++      len--;
++  }
++  if (DEBUG_DRAWING)
++      kdDebug(90100) << "  -drawFill(" << r.x() << "/" << r.y()
++		<< "-" << r.width() << "x" << r.height()
++		<< ", len " << len << ")" << endl;
++}
++
++// returns false if rect gets to small
++bool TreeMapWidget::drawItemArray(TQPainter* p, TreeMapItem* item,
++                                  TQRect& r, double user_sum,
++                                  TreeMapItemListIterator it, int len,
++				  bool goBack)
++{
++  if (user_sum == 0) return false;
++
++  static bool b2t = true;
++
++  // stop recursive bisection for small rectangles
++  if (((r.height() < _visibleWidth) &&
++       (r.width() < _visibleWidth)) ||
++      ((_minimalArea > 0) &&
++       (r.width() * r.height() < _minimalArea))) {
++
++    drawFill(item, p, r, it, len, goBack);
++    return false;
++  }
++
++  if (DEBUG_DRAWING)
++      kdDebug(90100) << " +drawItemArray(" << item->path(0).join("/") 
++		<< ", " << r.x() << "/" << r.y() << "-" << r.width()
++		<< "x" << r.height() << ")" << endl;
++
++  if (len>2 && (item->splitMode() == TreeMapItem::Bisection)) {
++
++    TreeMapItemListIterator first = it;
++    double valSum = 0;
++    int lenLeft = len;
++    //while (lenLeft>0 && valSum<user_sum/2) {
++    while (lenLeft>len/2) {
++      valSum += it.current()->value();
++      if (goBack) --it; else ++it;
++      lenLeft--;
++    }
++
++    // draw first half...
++    bool drawOn;
++
++    if (r.width() > r.height()) {
++      int halfPos = (int)((double)r.width() * valSum / user_sum);
++      TQRect firstRect = TQRect(r.x(), r.y(), halfPos, r.height());
++      drawOn = drawItemArray(p, item, firstRect,
++                             valSum, first, len-lenLeft, goBack);
++      r.setRect(r.x()+halfPos, r.y(), r.width()-halfPos, r.height());
++    }
++    else {
++      int halfPos = (int)((double)r.height() * valSum / user_sum);
++      TQRect firstRect = TQRect(r.x(), r.y(), r.width(), halfPos);
++      drawOn = drawItemArray(p, item, firstRect,
++                             valSum, first, len-lenLeft, goBack);
++      r.setRect(r.x(), r.y()+halfPos, r.width(), r.height()-halfPos);
++    }
++
++    // if no sorting, don't stop drawing
++    if (item->sorting(0) == -1) drawOn = true;
++
++    // second half
++    if (drawOn)
++      drawOn = drawItemArray(p, item, r, user_sum - valSum,
++                             it, lenLeft, goBack);
++    else {
++      drawFill(item, p, r, it, len, goBack);
++    }
++
++    if (DEBUG_DRAWING)
++	kdDebug(90100) << " -drawItemArray(" << item->path(0).join("/")
++		  << ")" << endl;
++
++    return drawOn;
++  }
++
++  bool hor = horizontal(item,r);
++
++  TreeMapItem* i;
++  while (len>0) {
++    i = it.current();
++    if (user_sum <= 0) {
++
++      if (DEBUG_DRAWING)
++	  kdDebug(90100) << "drawItemArray: Reset " << i->path(0).join("/") << endl;
++
++      i->clearItemRect();
++      if (goBack) --it; else ++it;
++      len--;
++      continue;
++    }
++
++    // stop drawing for small rectangles
++    if (((r.height() < _visibleWidth) &&
++         (r.width() < _visibleWidth)) ||
++        ((_minimalArea > 0) &&
++         (r.width() * r.height() < _minimalArea))) {
++
++      drawFill(item, p, r, it, len, goBack);
++      if (DEBUG_DRAWING)
++	  kdDebug(90100) << " -drawItemArray(" << item->path(0).join("/")
++		    << "): Stop" << endl;
++      return false;
++    }
++
++    if (i->splitMode() == TreeMapItem::AlwaysBest)
++      hor = r.width() > r.height();
++
++    int lastPos = hor ? r.width() : r.height();
++    double val = i->value();
++    int nextPos = (user_sum <= 0.0) ? 0: (int)(lastPos * val / user_sum +.5);
++    if (nextPos>lastPos) nextPos = lastPos;
++
++    if ((item->sorting(0) != -1) && (nextPos < _visibleWidth)) {
++      drawFill(item, p, r, it, len, goBack);
++      if (DEBUG_DRAWING)
++	  kdDebug(90100) << " -drawItemArray(" << item->path(0).join("/")
++		    << "): Stop" << endl;
++      return false;
++    }
++
++    TQRect currRect = r;
++
++    if (hor)
++      currRect.setWidth(nextPos);
++    else {
++      if (b2t)
++        currRect.setRect(r.x(), r.bottom()-nextPos+1, r.width(), nextPos);
++      else
++        currRect.setHeight(nextPos);
++    }
++
++    // don't draw very small rectangles:
++    if (nextPos >= _visibleWidth) {
++	i->setItemRect(currRect);
++	drawItems(p, i);
++    }
++    else {
++	i->clearItemRect();
++	drawFill(item, p, currRect);
++    }
++
++    // draw Separator
++    if (_drawSeparators && (nextPos<lastPos)) {
++      p->setPen(black);
++      if (hor) {
++        if (r.top()<=r.bottom())
++          p->drawLine(r.x() + nextPos, r.top(), r.x() + nextPos, r.bottom());
++      }
++      else {
++        if (r.left()<=r.right())
++        p->drawLine(r.left(), r.y() + nextPos, r.right(), r.y() + nextPos);
++      }
++      nextPos++;
++    }
++
++    if (hor)
++      r.setRect(r.x() + nextPos, r.y(), lastPos-nextPos, r.height());
++    else {
++      if (b2t)
++        r.setRect(r.x(), r.y(), r.width(), lastPos-nextPos);
++      else
++        r.setRect(r.x(), r.y() + nextPos, r.width(), lastPos-nextPos);
++    }
++
++    user_sum -= val;
++    if (goBack) --it; else ++it;
++    len--;
++  }
++
++  if (DEBUG_DRAWING)
++      kdDebug(90100) << " -drawItemArray(" << item->path(0).join("/")
++		<< "): Continue" << endl;
++
++  return true;
++}
++
++
++/*----------------------------------------------------------------
++ * Popup menus for option setting
++ */
++
++void TreeMapWidget::splitActivated(int id)
++{
++  if      (id == _splitID)   setSplitMode(TreeMapItem::Bisection);
++  else if (id == _splitID+1) setSplitMode(TreeMapItem::Columns);
++  else if (id == _splitID+2) setSplitMode(TreeMapItem::Rows);
++  else if (id == _splitID+3) setSplitMode(TreeMapItem::AlwaysBest);
++  else if (id == _splitID+4) setSplitMode(TreeMapItem::Best);
++  else if (id == _splitID+5) setSplitMode(TreeMapItem::VAlternate);
++  else if (id == _splitID+6) setSplitMode(TreeMapItem::HAlternate);
++  else if (id == _splitID+7) setSplitMode(TreeMapItem::Horizontal);
++  else if (id == _splitID+8) setSplitMode(TreeMapItem::Vertical);
++}
++
++
++void TreeMapWidget::addSplitDirectionItems(TQPopupMenu* popup, int id)
++{
++  _splitID = id;
++  popup->setCheckable(true);
++
++  connect(popup, TQT_SIGNAL(activated(int)),
++          this, TQT_SLOT(splitActivated(int)));
++
++  popup->insertItem(i18n("Recursive Bisection"), id);
++  popup->insertItem(i18n("Columns"),         id+1);
++  popup->insertItem(i18n("Rows"),            id+2);
++  popup->insertItem(i18n("Always Best"),     id+3);
++  popup->insertItem(i18n("Best"),            id+4);
++  popup->insertItem(i18n("Alternate (V)"),   id+5);
++  popup->insertItem(i18n("Alternate (H)"),   id+6);
++  popup->insertItem(i18n("Horizontal"),      id+7);
++  popup->insertItem(i18n("Vertical"),        id+8);
++
++  switch(splitMode()) {
++    case TreeMapItem::Bisection:  popup->setItemChecked(id,true); break;
++    case TreeMapItem::Columns:    popup->setItemChecked(id+1,true); break;
++    case TreeMapItem::Rows:       popup->setItemChecked(id+2,true); break;
++    case TreeMapItem::AlwaysBest: popup->setItemChecked(id+3,true); break;
++    case TreeMapItem::Best:       popup->setItemChecked(id+4,true); break;
++    case TreeMapItem::VAlternate: popup->setItemChecked(id+5,true); break;
++    case TreeMapItem::HAlternate: popup->setItemChecked(id+6,true); break;
++    case TreeMapItem::Horizontal: popup->setItemChecked(id+7,true); break;
++    case TreeMapItem::Vertical:   popup->setItemChecked(id+8,true); break;
++    default: break;
++  }
++}
++
++void TreeMapWidget::visualizationActivated(int id)
++{
++  if (id == _visID+2) setSkipIncorrectBorder(!skipIncorrectBorder());
++  else if (id == _visID+3) setBorderWidth(0);
++  else if (id == _visID+4) setBorderWidth(1);
++  else if (id == _visID+5) setBorderWidth(2);
++  else if (id == _visID+6) setBorderWidth(3);
++  else if (id == _visID+10) setAllowRotation(!allowRotation());
++  else if (id == _visID+11) setShadingEnabled(!isShadingEnabled());
++  else if (id<_visID+19 || id>_visID+100) return;
++
++  id -= 20+_visID;
++  int f = id/10;
++  if      ((id%10) == 1) setFieldVisible(f, !fieldVisible(f));
++  else if ((id%10) == 2) setFieldForced(f, !fieldForced(f));
++  else if ((id%10) == 3) setFieldPosition(f, DrawParams::TopLeft);
++  else if ((id%10) == 4) setFieldPosition(f, DrawParams::TopCenter);
++  else if ((id%10) == 5) setFieldPosition(f, DrawParams::TopRight);
++  else if ((id%10) == 6) setFieldPosition(f, DrawParams::BottomLeft);
++  else if ((id%10) == 7) setFieldPosition(f, DrawParams::BottomCenter);
++  else if ((id%10) == 8) setFieldPosition(f, DrawParams::BottomRight);
++}
++
++void TreeMapWidget::addVisualizationItems(TQPopupMenu* popup, int id)
++{
++  _visID = id;
++
++  popup->setCheckable(true);
++
++  TQPopupMenu* bpopup = new TQPopupMenu();
++  bpopup->setCheckable(true);
++
++  connect(popup, TQT_SIGNAL(activated(int)),
++          this, TQT_SLOT(visualizationActivated(int)));
++  connect(bpopup, TQT_SIGNAL(activated(int)),
++          this, TQT_SLOT(visualizationActivated(int)));
++
++  TQPopupMenu* spopup = new TQPopupMenu();
++  addSplitDirectionItems(spopup, id+100);
++  popup->insertItem(i18n("Nesting"), spopup, id);
++
++  popup->insertItem(i18n("Border"), bpopup, id+1);
++  bpopup->insertItem(i18n("Correct Borders Only"), id+2);
++  bpopup->insertSeparator();
++  bpopup->insertItem(i18n("Width %1").arg(0), id+3);
++  bpopup->insertItem(i18n("Width %1").arg(1), id+4);
++  bpopup->insertItem(i18n("Width %1").arg(2), id+5);
++  bpopup->insertItem(i18n("Width %1").arg(3), id+6);
++  bpopup->setItemChecked(id+2, skipIncorrectBorder());
++  bpopup->setItemChecked(id+3, borderWidth()==0);
++  bpopup->setItemChecked(id+4, borderWidth()==1);
++  bpopup->setItemChecked(id+5, borderWidth()==2);
++  bpopup->setItemChecked(id+6, borderWidth()==3);
++
++  popup->insertItem(i18n("Allow Rotation"), id+10);
++  popup->setItemChecked(id+10,allowRotation());
++  popup->insertItem(i18n("Shading"), id+11);
++  popup->setItemChecked(id+11,isShadingEnabled());
++
++  if (_attr.size() ==0) return;
++
++  popup->insertSeparator();
++  int f;
++  TQPopupMenu* tpopup;
++  id += 20;
++  for (f=0;f<(int)_attr.size();f++, id+=10) {
++    tpopup = new TQPopupMenu();
++    tpopup->setCheckable(true);
++    popup->insertItem(_attr[f].type, tpopup, id);
++    tpopup->insertItem(i18n("Visible"), id+1);
++    tpopup->insertItem(i18n("Take Space From Children"), id+2);
++    tpopup->insertSeparator();
++    tpopup->insertItem(i18n("Top Left"), id+3);
++    tpopup->insertItem(i18n("Top Center"), id+4);
++    tpopup->insertItem(i18n("Top Right"), id+5);
++    tpopup->insertItem(i18n("Bottom Left"), id+6);
++    tpopup->insertItem(i18n("Bottom Center"), id+7);
++    tpopup->insertItem(i18n("Bottom Right"), id+8);
++
++    tpopup->setItemChecked(id+1,_attr[f].visible);
++    tpopup->setItemEnabled(id+2,_attr[f].visible);
++    tpopup->setItemEnabled(id+3,_attr[f].visible);
++    tpopup->setItemEnabled(id+4,_attr[f].visible);
++    tpopup->setItemEnabled(id+5,_attr[f].visible);
++    tpopup->setItemEnabled(id+6,_attr[f].visible);
++    tpopup->setItemEnabled(id+7,_attr[f].visible);
++    tpopup->setItemEnabled(id+8,_attr[f].visible);
++    tpopup->setItemChecked(id+2,_attr[f].forced);
++    tpopup->setItemChecked(id+3,_attr[f].pos == DrawParams::TopLeft);
++    tpopup->setItemChecked(id+4,_attr[f].pos == DrawParams::TopCenter);
++    tpopup->setItemChecked(id+5,_attr[f].pos == DrawParams::TopRight);
++    tpopup->setItemChecked(id+6,_attr[f].pos == DrawParams::BottomLeft);
++    tpopup->setItemChecked(id+7,_attr[f].pos == DrawParams::BottomCenter);
++    tpopup->setItemChecked(id+8,_attr[f].pos == DrawParams::BottomRight);
++
++    connect(tpopup, TQT_SIGNAL(activated(int)),
++            this, TQT_SLOT(visualizationActivated(int)));
++  }
++}
++
++void TreeMapWidget::selectionActivated(int id)
++{
++  TreeMapItem* i = _menuItem;
++  id -= _selectionID;
++  while (id>0 && i) {
++    i=i->parent();
++    id--;
++  }
++  if (i)
++    setSelected(i, true);
++}
++
++void TreeMapWidget::addSelectionItems(TQPopupMenu* popup,
++				      int id, TreeMapItem* i)
++{
++  if (!i) return;
++
++  _selectionID = id;
++  _menuItem = i;
++
++  connect(popup, TQT_SIGNAL(activated(int)),
++          this, TQT_SLOT(selectionActivated(int)));
++
++  while (i) {
++    TQString name = i->text(0);
++    if (name.isEmpty()) break;
++    popup->insertItem(i->text(0), id++);
++    i = i->parent();
++  }
++}
++
++void TreeMapWidget::fieldStopActivated(int id)
++{
++  if (id == _fieldStopID) setFieldStop(0, TQString());
++  else {
++    TreeMapItem* i = _menuItem;
++    id -= _fieldStopID+1;
++    while (id>0 && i) {
++      i=i->parent();
++      id--;
++    }
++    if (i)
++      setFieldStop(0, i->text(0));
++  }
++}
++
++void TreeMapWidget::addFieldStopItems(TQPopupMenu* popup,
++				      int id, TreeMapItem* i)
++{
++  _fieldStopID = id;
++
++  connect(popup, TQT_SIGNAL(activated(int)),
++          this, TQT_SLOT(fieldStopActivated(int)));
++
++  popup->insertItem(i18n("No %1 Limit").arg(fieldType(0)), id);
++  popup->setItemChecked(id, fieldStop(0).isEmpty());
++  _menuItem = i;
++  bool foundFieldStop = false;
++  if (i) {
++    popup->insertSeparator();
++
++    while (i) {
++      id++;
++      TQString name = i->text(0);
++      if (name.isEmpty()) break;
++      popup->insertItem(i->text(0), id);
++      if (fieldStop(0) == i->text(0)) {
++        popup->setItemChecked(id, true);
++        foundFieldStop = true;
++      }
++      i = i->parent();
++    }
++  }
++
++  if (!foundFieldStop && !fieldStop(0).isEmpty()) {
++    popup->insertSeparator();
++    popup->insertItem(fieldStop(0), id+1);
++    popup->setItemChecked(id+1, true);
++  }
++}
++
++void TreeMapWidget::areaStopActivated(int id)
++{
++  if (id == _areaStopID) setMinimalArea(-1);
++  else if (id == _areaStopID+1) {
++    int area = _menuItem ? (_menuItem->width() * _menuItem->height()) : -1;
++    setMinimalArea(area);
++  }
++  else if (id == _areaStopID+2) setMinimalArea(100);
++  else if (id == _areaStopID+3) setMinimalArea(400);
++  else if (id == _areaStopID+4) setMinimalArea(1000);
++  else if (id == _areaStopID+5) setMinimalArea(minimalArea()*2);
++  else if (id == _areaStopID+6) setMinimalArea(minimalArea()/2);
++}
++
++void TreeMapWidget::addAreaStopItems(TQPopupMenu* popup,
++				     int id, TreeMapItem* i)
++{
++  _areaStopID = id;
++  _menuItem = i;
++
++  connect(popup, TQT_SIGNAL(activated(int)),
++          this, TQT_SLOT(areaStopActivated(int)));
++
++  bool foundArea = false;
++
++  popup->insertItem(i18n("No Area Limit"), id);
++  popup->setItemChecked(id, minimalArea() == -1);
++
++  if (i) {
++    int area = i->width() * i->height();
++    popup->insertSeparator();
++    popup->insertItem(i18n("Area of '%1' (%2)")
++                       .arg(i->text(0)).arg(area), id+1);
++    if (area == minimalArea()) {
++      popup->setItemChecked(id+1, true);
++      foundArea = true;
++    }
++  }
++
++  popup->insertSeparator();
++  int area = 100, count;
++  for (count=0;count<3;count++) {
++    popup->insertItem(i18n("1 Pixel", "%n Pixels", area), id+2+count);
++    if (area == minimalArea()) {
++      popup->setItemChecked(id+2+count, true);
++      foundArea = true;
++    }
++    area = (area==100) ? 400 : (area==400) ? 1000 : 4000;
++  }
++
++  if (minimalArea()>0) {
++    popup->insertSeparator();
++    if (!foundArea) {
++      popup->insertItem(i18n("1 Pixel", "%n Pixels", minimalArea()), id+10);
++      popup->setItemChecked(id+10, true);
++    }
++
++    popup->insertItem(i18n("Double Area Limit (to %1)")
++                       .arg(minimalArea()*2), id+5);
++    popup->insertItem(i18n("Halve Area Limit (to %1)")
++                       .arg(minimalArea()/2), id+6);
++  }
++}
++
++
++void TreeMapWidget::depthStopActivated(int id)
++{
++  if (id == _depthStopID) setMaxDrawingDepth(-1);
++  else if (id == _depthStopID+1) {
++    int d = _menuItem ? _menuItem->depth() : -1;
++    setMaxDrawingDepth(d);
++  }
++  else if (id == _depthStopID+2) setMaxDrawingDepth(maxDrawingDepth()-1);
++  else if (id == _depthStopID+3) setMaxDrawingDepth(maxDrawingDepth()+1);
++}
++
++void TreeMapWidget::addDepthStopItems(TQPopupMenu* popup,
++				      int id, TreeMapItem* i)
++{
++  _depthStopID = id;
++  _menuItem = i;
++
++  connect(popup, TQT_SIGNAL(activated(int)),
++          this, TQT_SLOT(depthStopActivated(int)));
++
++  bool foundDepth = false;
++
++  popup->insertItem(i18n("No Depth Limit"), id);
++  popup->setItemChecked(id, maxDrawingDepth() == -1);
++
++  if (i) {
++    int d = i->depth();
++    popup->insertSeparator();
++    popup->insertItem(i18n("Depth of '%1' (%2)")
++                       .arg(i->text(0)).arg(d), id+1);
++    if (d == maxDrawingDepth()) {
++      popup->setItemChecked(id+1, true);
++      foundDepth = true;
++    }
++  }
++
++  if (maxDrawingDepth()>1) {
++    popup->insertSeparator();
++    if (!foundDepth) {
++      popup->insertItem(i18n("Depth %1").arg(maxDrawingDepth()), id+10);
++      popup->setItemChecked(id+10, true);
++    }
++
++    popup->insertItem(i18n("Decrement (to %1)")
++                       .arg(maxDrawingDepth()-1), id+2);
++    popup->insertItem(i18n("Increment (to %1)")
++                       .arg(maxDrawingDepth()+1), id+3);
++  }
++}
++
++
++
++/*----------------------------------------------------------------
++ * Option saving/restoring
++ */
++
++void TreeMapWidget::saveOptions(KConfigGroup* config, TQString prefix)
++{
++  config->writeEntry(prefix+"Nesting", splitModeString());
++  config->writeEntry(prefix+"AllowRotation", allowRotation());
++  config->writeEntry(prefix+"ShadingEnabled", isShadingEnabled());
++  config->writeEntry(prefix+"OnlyCorrectBorder", skipIncorrectBorder());
++  config->writeEntry(prefix+"BorderWidth", borderWidth());
++  config->writeEntry(prefix+"MaxDepth", maxDrawingDepth());
++  config->writeEntry(prefix+"MinimalArea", minimalArea());
++
++  int f, fCount = _attr.size();
++  config->writeEntry(prefix+"FieldCount", fCount);
++  for (f=0;f<fCount;f++) {
++    config->writeEntry(TQString(prefix+"FieldVisible%1").arg(f),
++                       _attr[f].visible);
++    config->writeEntry(TQString(prefix+"FieldForced%1").arg(f),
++                       _attr[f].forced);
++    config->writeEntry(TQString(prefix+"FieldStop%1").arg(f),
++                       _attr[f].stop);
++    config->writeEntry(TQString(prefix+"FieldPosition%1").arg(f),
++                       fieldPositionString(f));
++  }
++}
++
++
++void TreeMapWidget::restoreOptions(KConfigGroup* config, TQString prefix)
++{
++  bool enabled;
++  int num;
++  TQString str;
++
++  str = config->readEntry(prefix+"Nesting");
++  if (!str.isEmpty()) setSplitMode(str);
++
++  if (config->hasKey(prefix+"AllowRotation")) {
++    enabled = config->readBoolEntry(prefix+"AllowRotation", true);
++    setAllowRotation(enabled);
++  }
++
++  if (config->hasKey(prefix+"ShadingEnabled")) {
++    enabled = config->readBoolEntry(prefix+"ShadingEnabled", true);
++    setShadingEnabled(enabled);
++  }
++
++  if (config->hasKey(prefix+"OnlyCorrectBorder")) {
++    enabled = config->readBoolEntry(prefix+"OnlyCorrectBorder", false);
++    setSkipIncorrectBorder(enabled);
++  }
++
++  num = config->readNumEntry(prefix+"BorderWidth", -2);
++  if (num!=-2) setBorderWidth(num);
++
++  num = config->readNumEntry(prefix+"MaxDepth", -2);
++  if (num!=-2) setMaxDrawingDepth(num);
++
++  num = config->readNumEntry(prefix+"MinimalArea", -2);
++  if (num!=-2) setMinimalArea(num);
++
++  num = config->readNumEntry(prefix+"FieldCount", -2);
++  if (num<=0 || num>MAX_FIELD) return;
++
++  int f;
++  for (f=0;f<num;f++) {
++    str = TQString(prefix+"FieldVisible%1").arg(f);
++    if (config->hasKey(str))
++      setFieldVisible(f, config->readBoolEntry(str));
++
++    str = TQString(prefix+"FieldForced%1").arg(f);
++    if (config->hasKey(str))
++      setFieldForced(f, config->readBoolEntry(str));
++
++    str = config->readEntry(TQString(prefix+"FieldStop%1").arg(f));
++    setFieldStop(f, str);
++
++    str = config->readEntry(TQString(prefix+"FieldPosition%1").arg(f));
++    if (!str.isEmpty()) setFieldPosition(f, str);
++  }
++}
++
++#include "treemap.moc"
+diff --git a/kdecachegrind/kdecachegrind/treemap.h b/kdecachegrind/kdecachegrind/treemap.h
+new file mode 100644
+index 0000000..422cd35
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/treemap.h
+@@ -0,0 +1,759 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/**
++ * A Widget for visualizing hierarchical metrics as areas.
++ * The API is similar to TQListView.
++ *
++ * This file defines the following classes:
++ *  DrawParams, RectDrawing, TreeMapItem, TreeMapWidget
++ *
++ * DrawParams/RectDrawing allows reusing of TreeMap drawing
++ * functions in other widgets.
++ */
++
++#ifndef TREEMAP_H
++#define TREEMAP_H
++
++#include <tqstring.h>
++#include <tqwidget.h>
++#include <tqpixmap.h>
++#include <tqptrlist.h>
++#include <tqvaluevector.h>
++#include <tqcolor.h>
++#include <tqapplication.h>
++#include <tqstringlist.h>
++
++class TQPopupMenu;
++class TreeMapTip;
++class TreeMapWidget;
++class TreeMapItem;
++class TreeMapItemList;
++class TQString;
++
++class KConfigGroup;
++
++
++/**
++ * Drawing parameters for an object.
++ * A Helper Interface for RectDrawing.
++ */
++class DrawParams
++{
++public:
++  /**
++   * Positions for drawing into a rectangle.
++   *
++   * The specified position assumes no rotation.
++   * If there is more than one text for one position, it is put
++   * nearer to the center of the item.
++   *
++   * Drawing at top positions cuts free space from top,
++   * drawing at bottom positions cuts from bottom.
++   * Default usually gives positions clockwise according to field number.
++   */
++  enum Position { TopLeft, TopCenter, TopRight,
++                  BottomLeft, BottomCenter, BottomRight,
++                  Default, Unknown};
++
++  // no constructor as this is an abstract class
++  virtual ~DrawParams() {}
++
++  virtual TQString  text(int) const = 0;
++  virtual TQPixmap  pixmap(int) const = 0;
++  virtual Position position(int) const = 0;
++  // 0: no limit, negative: leave at least -maxLines() free
++  virtual int      maxLines(int) const { return 0; }
++  virtual int      fieldCount() const { return 0; }
++
++  virtual TQColor   backColor() const { return TQt::white; }
++  virtual const TQFont& font() const = 0;
++
++  virtual bool selected() const { return false; }
++  virtual bool current() const { return false; }
++  virtual bool shaded() const { return true; }
++  virtual bool rotated() const { return false; }
++  virtual bool drawFrame() const { return true; }
++};
++
++
++/*
++ * DrawParam with attributes stored
++ */
++class StoredDrawParams: public DrawParams
++{
++public:
++  StoredDrawParams();
++  StoredDrawParams(TQColor c,
++                   bool selected = false, bool current = false);
++
++  // getters
++  TQString  text(int) const;
++  TQPixmap  pixmap(int) const;
++  Position position(int) const;
++  int      maxLines(int) const;
++  int      fieldCount() const { return _field.size(); }
++
++  TQColor   backColor() const { return _backColor; }
++  bool selected() const { return _selected; }
++  bool current() const { return _current; }
++  bool shaded() const { return _shaded; }
++  bool rotated() const { return _rotated; }
++  bool drawFrame() const { return _drawFrame; }
++
++  const TQFont& font() const;
++
++  // attribute setters
++  void setField(int f, const TQString& t, TQPixmap pm = TQPixmap(),
++                Position p = Default, int maxLines = 0);
++  void setText(int f, const TQString&);
++  void setPixmap(int f, const TQPixmap&);
++  void setPosition(int f, Position);
++  void setMaxLines(int f, int);
++  void setBackColor(const TQColor& c) { _backColor = c; }
++  void setSelected(bool b) { _selected = b; }
++  void setCurrent(bool b) { _current = b; }
++  void setShaded(bool b) { _shaded = b; }
++  void setRotated(bool b) { _rotated = b; }
++  void drawFrame(bool b) { _drawFrame = b; }
++
++protected:
++  TQColor _backColor;
++  bool _selected :1;
++  bool _current :1;
++  bool _shaded :1;
++  bool _rotated :1;
++  bool _drawFrame :1;
++
++private:
++  // resize field array if needed to allow to access field <f>
++  void ensureField(int f);
++
++  struct Field {
++    TQString text;
++    TQPixmap pix;
++    Position pos;
++    int maxLines;
++  };
++
++  TQValueVector<Field> _field;
++};
++
++
++/* State for drawing on a rectangle.
++ *
++ * Following drawing functions are provided:
++ * - background drawing with shading and 3D frame
++ * - successive pixmap/text drawing at various positions with wrap-around
++ *   optimized for minimal space usage (e.g. if a text is drawn at top right
++ *   after text on top left, the same line is used if space allows)
++ *
++ */
++class RectDrawing
++{
++public:
++  RectDrawing(TQRect);
++  ~RectDrawing();
++
++  // The default DrawParams object used.
++  DrawParams* drawParams();
++  // we take control over the given object (i.e. delete at destruction)
++  void setDrawParams(DrawParams*);
++
++  // draw on a given TQPainter, use this class as info provider per default
++  void drawBack(TQPainter*, DrawParams* dp = 0);
++  /* Draw field at position() from pixmap()/text() with maxLines().
++   * Returns true if something was drawn
++   */
++  bool drawField(TQPainter*, int f, DrawParams* dp = 0);
++
++  // resets rectangle for free space
++  void setRect(TQRect);
++
++  // Returns the rectangle area still free of text/pixmaps after
++  // a number of drawText() calls.
++  TQRect remainingRect(DrawParams* dp = 0);
++
++private:
++  int _usedTopLeft, _usedTopCenter, _usedTopRight;
++  int _usedBottomLeft, _usedBottomCenter, _usedBottomRight;
++  TQRect _rect;
++
++  // temporary
++  int _fontHeight;
++  TQFontMetrics* _fm;
++  DrawParams* _dp;
++};
++
++
++class TreeMapItemList: public TQPtrList<TreeMapItem>
++{
++public:
++  TreeMapItem* commonParent();
++protected:
++  int compareItems ( Item item1, Item item2 );
++};
++
++typedef TQPtrListIterator<TreeMapItem> TreeMapItemListIterator;
++
++
++/**
++ * Base class of items in TreeMap.
++ *
++ * This class supports an arbitrary number of text() strings
++ * positioned counterclock-wise starting at TopLeft. Each item
++ * has its own static value(), sum() and sorting(). The
++ * splitMode() and borderWidth() is taken from a TreeMapWidget.
++ *
++ * If you want more flexibility, reimplement TreeMapItem and
++ * override the corresponding methods. For dynamic creation of child
++ * items on demand, reimplement children().
++ */
++class TreeMapItem: public StoredDrawParams
++{
++public:
++
++  /**
++   * Split direction for nested areas:
++   *  AlwaysBest: Choose split direction for every subitem according to
++   *              longest side of rectangle left for drawing
++   *  Best:       Choose split direction for all subitems of an area
++   *              depending on longest side
++   *  HAlternate:Qt::Horizontal at top;  alternate direction on depth step
++   *  VAlternate:Qt::Vertical at top; alternate direction on depth step
++   * Qt::Horizontal: Always horizontal split direction
++   * Qt::Vertical:   Always vertical split direction
++   */
++  enum SplitMode { Bisection, Columns, Rows,
++                   AlwaysBest, Best,
++                   HAlternate, VAlternate,
++                   Horizontal, Vertical };
++
++  TreeMapItem(TreeMapItem* parent = 0, double value = 1.0 );
++  TreeMapItem(TreeMapItem* parent, double value,
++              TQString text1, TQString text2 = TQString(),
++              TQString text3 = TQString(), TQString text4 = TQString());
++  virtual ~TreeMapItem();
++
++  bool isChildOf(TreeMapItem*);
++
++  TreeMapItem* commonParent(TreeMapItem* item);
++
++  // force a redraw of this item
++  void redraw();
++
++  // delete all children
++  void clear();
++
++  // force new child generation & refresh
++  void refresh();
++
++  // call in a reimplemented items() method to check if already called
++  // after a clear(), this will return false
++  bool initialized();
++
++  /**
++   * Adds an item to a parent.
++   * When no sorting is used, the item is appended (drawn at bottom).
++   * This is only needed if the parent was not already specified in the
++   * construction of the item.
++   */
++  void addItem(TreeMapItem*);
++
++  /**
++   * Returns a list of text strings of specified text number,
++   * from root up to this item.
++   */
++  TQStringList path(int) const;
++
++  /**
++   * Depth of this item. This is the distance to root.
++   */
++  int depth() const;
++
++  /**
++   * Parent Item
++   */
++  TreeMapItem* parent() const { return _parent; }
++
++  /**
++   * Temporary rectangle used for drawing this item the last time.
++   * This is internally used to map from a point to an item.
++   */
++  void setItemRect(const TQRect& r) { _rect = r; }
++  void clearItemRect();
++  const TQRect& itemRect() const { return _rect; }
++  int width() const { return _rect.width(); }
++  int height() const { return _rect.height(); }
++
++  /**
++   * Temporary rectangle list of free space of this item.
++   * Used internally to enable tooltip.
++   */
++  void clearFreeRects();
++  TQPtrList<TQRect>* freeRects() const { return _freeRects; }
++  void addFreeRect(const TQRect& r);
++
++  /**
++   * Temporary child item index of the child that was current() recently.
++   */
++  int index() const { return _index; }
++  void setIndex(int i) { _index = i; }
++
++
++  /**
++   * TreeMap widget this item is put in.
++   */
++  TreeMapWidget* widget() const { return _widget; }
++
++  void setParent(TreeMapItem* p);
++  void setWidget(TreeMapWidget* w) { _widget = w; }
++  void setSum(double s) { _sum = s; }
++  void setValue(double s) { _value = s; }
++
++  virtual double sum() const;
++  virtual double value() const;
++  // replace "Default" position with setting from TreeMapWidget
++  virtual Position position(int) const;
++  virtual const TQFont& font() const;
++  virtual bool isMarked(int) const;
++
++  virtual int borderWidth() const;
++
++  /**
++   * Returns the text number after that sorting is done or
++   * -1 for no sorting, -2 for value() sorting (default).
++   * If ascending != 0, a bool value is written at that location
++   * to indicate if sorting should be ascending.
++   */
++  virtual int sorting(bool* ascending) const;
++
++  /**
++   * Set the sorting for child drawing.
++   *
++   * Default is no sorting: <textNo> = -1
++   * For value() sorting, use <textNo> = -2
++   *
++   * For fast sorting, set this to -1 before child insertions and call
++   * again after inserting all children.
++   */
++  void setSorting(int textNo, bool ascending = true);
++
++  /**
++   * Resort according to the already set sorting.
++   *
++   * This has to be done if the sorting base changes (e.g. text or values
++   * change). If this is only true for the children of this item, you can
++   * set the recursive parameter to false.
++   */
++  void resort(bool recursive = true);
++
++  virtual SplitMode splitMode() const;
++  virtual int rtti() const;
++  // not const as this can create children on demand
++  virtual TreeMapItemList* children();
++
++protected:
++  TreeMapItemList* _children;
++  double _sum, _value;
++
++private:
++  TreeMapWidget* _widget;
++  TreeMapItem* _parent;
++
++  int _sortTextNo;
++  bool _sortAscending;
++
++  // temporary layout
++  TQRect _rect;
++  TQPtrList<TQRect>* _freeRects;
++  int _depth;
++
++  // temporary self value (when using level skipping)
++  double _unused_self;
++
++  // index of last active subitem
++  int _index;
++};
++
++
++/**
++ * Class for visualization of a metric of hierarchically
++ * nested items as 2D areas.
++ */
++class TreeMapWidget: public TQWidget
++{
++  Q_OBJECT
++  TQ_OBJECT
++
++public:
++
++  /**
++   * Same as in TQListBox/TQListView
++   */
++  enum SelectionMode { Single, Multi, Extended, NoSelection };
++
++  /* The widget becomes owner of the base item */
++  TreeMapWidget(TreeMapItem* base, TQWidget* parent=0, const char* name=0);
++  ~TreeMapWidget();
++
++  /**
++   * Returns the TreeMapItem filling out the widget space
++   */
++  TreeMapItem* base() const { return _base; }
++
++  /**
++   * Returns a reference to the current widget font.
++   */
++  const TQFont& currentFont() const;
++
++  /**
++   * Returns the area item at position x/y, independent from any
++   * maxSelectDepth setting.
++   */
++  TreeMapItem* item(int x, int y) const;
++
++  /**
++   * Returns the nearest item with a visible area; this
++   * can be the given item itself.
++   */
++  TreeMapItem* visibleItem(TreeMapItem*) const;
++
++  /**
++   * Returns the item possible for selection. this returns the
++   * given item itself or a parent thereof,
++   * depending on setting of maxSelectDepth().
++   */
++  TreeMapItem* possibleSelection(TreeMapItem*) const;
++
++  /**
++   * Selects or unselects an item.
++   * In multiselection mode, the constrain that a selected item
++   * has no selected children or parents stays true.
++   */
++  void setSelected(TreeMapItem*, bool selected = true);
++
++  /**
++   * Switches on the marking <markNo>. Marking 0 switches off marking.
++   * This is mutually exclusive to selection, and is automatically
++   * switched off when selection is changed (also by the user).
++   * Marking is visually the same as selection, and is based on
++   * TreeMapItem::isMarked(<markNo>).
++   * This enables to programmatically show multiple selected items
++   * at once even in single selection mode.
++   */
++  void setMarked(int markNo = 1, bool redraw = true);
++
++  /**
++   * Clear selection of all selected items which are children of
++   * parent. When parent == 0, clears whole selection
++   * Returns true if selection changed.
++   */
++  bool clearSelection(TreeMapItem* parent = 0);
++
++  /**
++   * Selects or unselects items in a range.
++   * This is needed internally for Shift-Click in Extented mode.
++   * Range means for a hierarchical widget:
++   * - select/unselect i1 and i2 according selected
++   * - search common parent of i1 and i2, and select/unselect the
++   *   range of direct children between but excluding the child
++   *   leading to i1 and the child leading to i2.
++   */
++  void setRangeSelection(TreeMapItem* i1,
++                         TreeMapItem* i2, bool selected);
++
++  /**
++   * Sets the current item.
++   * The current item is mainly used for keyboard navigation.
++   */
++  void setCurrent(TreeMapItem*, bool kbd=false);
++
++  /**
++   * Set the maximal depth a selected item can have.
++   * If you try to select a item with higher depth, the ancestor holding
++   * this condition is used.
++   *
++   * See also possibleSelection().
++   */
++  void setMaxSelectDepth(int d) { _maxSelectDepth = d; }
++
++
++  void setSelectionMode(SelectionMode m) { _selectionMode = m; }
++
++  /**
++   * for setting/getting global split direction
++   */
++  void setSplitMode(TreeMapItem::SplitMode m);
++  TreeMapItem::SplitMode splitMode() const;
++  // returns true if string was recognized
++  bool setSplitMode(TQString);
++  TQString splitModeString() const;
++
++
++  /*
++   * Shading of rectangles enabled ?
++   */
++  void setShadingEnabled(bool s);
++  bool isShadingEnabled() const { return _shading; }
++
++  /* Setting for a whole depth level: draw 3D frame (default) or solid */
++  void drawFrame(int d, bool b);
++  bool drawFrame(int d) const { return (d<4)?_drawFrame[d]:true; }
++
++  /* Setting for a whole depth level: draw items (default) or transparent */
++  void setTransparent(int d, bool b);
++  bool isTransparent(int d) const { return (d<4)?_transparent[d]:false; }
++
++  /**
++   * Items usually have a size proportional to their value().
++   * With <width>, you can give the minimum width
++   * of the resulting rectangle to still be drawn.
++   * For space not used because of to small items, you can specify
++   * with <reuseSpace> if the background should shine through or
++   * the space will be used to enlarge the next item to be drawn
++   * at this level.
++   */
++  void setVisibleWidth(int width, bool reuseSpace = false);
++
++  /**
++   * If a children value() is almost the parents sum(),
++   * it can happen that the border to be drawn for visibilty of
++   * nesting relations takes to much space, and the
++   * parent/child size relation can not be mapped to a correct
++   * area size relation.
++   *
++   * Either
++   * (1) Ignore the incorrect drawing, or
++   * (2) Skip drawing of the parent level alltogether.
++   */
++  void setSkipIncorrectBorder(bool enable = true);
++  bool skipIncorrectBorder() const { return _skipIncorrectBorder; }
++
++  /**
++   * Maximal nesting depth
++   */
++  void setMaxDrawingDepth(int d);
++  int maxDrawingDepth() const { return _maxDrawingDepth; }
++
++  /**
++   * Minimal area for rectangles to draw
++   */
++  void setMinimalArea(int area);
++  int minimalArea() const { return _minimalArea; }
++
++  /* defaults for text attributes */
++  TQString defaultFieldType(int) const;
++  TQString defaultFieldStop(int) const;
++  bool    defaultFieldVisible(int) const;
++  bool    defaultFieldForced(int) const;
++  DrawParams::Position defaultFieldPosition(int) const;
++
++  /**
++   * Set the type name of a field.
++   * This is important for the visualization menu generated
++   * with visualizationMenu()
++   */
++  void setFieldType(int, TQString);
++  TQString fieldType(int) const;
++
++  /**
++   * Stop drawing at item with name
++   */
++  void setFieldStop(int, TQString);
++  TQString fieldStop(int) const;
++
++  /**
++   * Should the text with number textNo be visible?
++   * This is only done if remaining space is enough to allow for
++   * proportional size constrains.
++   */
++  void setFieldVisible(int, bool);
++  bool fieldVisible(int) const;
++
++  /**
++   * Should the drawing of the name into the rectangle be forced?
++   * This enables drawing of the name before drawing subitems, and
++   * thus destroys proportional constrains.
++   */
++  void setFieldForced(int, bool);
++  bool fieldForced(int) const;
++
++  /**
++   * Set the field position in the area. See TreeMapItem::Position
++   */
++  void setFieldPosition(int, DrawParams::Position);
++  DrawParams::Position fieldPosition(int) const;
++  void setFieldPosition(int, TQString);
++  TQString fieldPositionString(int) const;
++
++  /**
++   * Do we allow the texts to be rotated by 90 degrees for better fitting?
++   */
++  void setAllowRotation(bool);
++  bool allowRotation() const { return _allowRotation; }
++
++  void setBorderWidth(int w);
++  int borderWidth() const { return _borderWidth; }
++
++  /**
++   * Save/restore options.
++   */
++  void saveOptions(KConfigGroup*, TQString prefix = TQString());
++  void restoreOptions(KConfigGroup*, TQString prefix = TQString());
++
++  /**
++   * These functions populate given popup menus.
++   * The added items are already connected to handlers.
++   *
++   * The int is the menu id where to start for the items (100 IDs reserved).
++   */
++  void addSplitDirectionItems(TQPopupMenu*, int);
++  void addSelectionItems(TQPopupMenu*, int, TreeMapItem*);
++  void addFieldStopItems(TQPopupMenu*, int, TreeMapItem*);
++  void addAreaStopItems(TQPopupMenu*, int, TreeMapItem*);
++  void addDepthStopItems(TQPopupMenu*, int, TreeMapItem*);
++  void addVisualizationItems(TQPopupMenu*, int);
++
++  TreeMapWidget* widget() { return this; }
++  TreeMapItem* current() const { return _current; }
++  TreeMapItemList selection() const { return _selection; }
++  bool isSelected(TreeMapItem* i) const;
++  int maxSelectDepth() const { return _maxSelectDepth; }
++  SelectionMode selectionMode() const { return _selectionMode; }
++
++  /**
++   * Return tooltip string to show for a item (can be rich text)
++   * Default implementation gives lines with "text0 (text1)" going to root.
++   */
++  virtual TQString tipString(TreeMapItem* i) const;
++
++  /**
++   * Redraws an item with all children.
++   * This takes changed values(), sums(), colors() and text() into account.
++   */
++  void redraw(TreeMapItem*);
++  void redraw() { redraw(_base); }
++
++  /**
++   * Resort all TreeMapItems. See TreeMapItem::resort().
++   */
++  void resort() { _base->resort(true); }
++
++  // internal
++  void drawTreeMap();
++
++  // used internally when items are destroyed
++  void deletingItem(TreeMapItem*);
++
++protected slots:
++  void splitActivated(int);
++  void selectionActivated(int);
++  void fieldStopActivated(int);
++  void areaStopActivated(int);
++  void depthStopActivated(int);
++  void visualizationActivated(int);
++
++signals:
++  void selectionChanged();
++  void selectionChanged(TreeMapItem*);
++
++  /**
++   * This signal is emitted if the current item changes.
++   * If the change is done because of keyboard navigation,
++   * the <kbd> is set to true
++   */
++  void currentChanged(TreeMapItem*, bool keyboard);
++  void clicked(TreeMapItem*);
++  void returnPressed(TreeMapItem*);
++  void doubleClicked(TreeMapItem*);
++  void rightButtonPressed(TreeMapItem*, const TQPoint &);
++  void contextMenuRequested(TreeMapItem*, const TQPoint &);
++
++protected:
++  void mousePressEvent( TQMouseEvent * );
++  void contextMenuEvent( TQContextMenuEvent * );
++  void mouseReleaseEvent( TQMouseEvent * );
++  void mouseMoveEvent( TQMouseEvent * );
++  void mouseDoubleClickEvent( TQMouseEvent * );
++  void keyPressEvent( TQKeyEvent* );
++  void paintEvent( TQPaintEvent * );
++  void resizeEvent( TQResizeEvent * );
++  void showEvent( TQShowEvent * );
++  void fontChange( const TQFont& );
++
++private:
++  TreeMapItemList diff(TreeMapItemList&, TreeMapItemList&);
++  // returns true if selection changed
++  TreeMapItem* setTmpSelected(TreeMapItem*, bool selected = true);
++  TreeMapItem* setTmpRangeSelection(TreeMapItem* i1,
++				    TreeMapItem* i2, bool selected);
++  bool isTmpSelected(TreeMapItem* i);
++
++  void drawItem(TQPainter* p, TreeMapItem*);
++  void drawItems(TQPainter* p, TreeMapItem*);
++  bool horizontal(TreeMapItem* i, const TQRect& r);
++  void drawFill(TreeMapItem*,TQPainter* p, TQRect& r);
++  void drawFill(TreeMapItem*,TQPainter* p, TQRect& r,
++                TreeMapItemListIterator it, int len, bool goBack);
++  bool drawItemArray(TQPainter* p, TreeMapItem*, TQRect& r, double,
++                     TreeMapItemListIterator it, int len, bool);
++  bool resizeAttr(int);
++
++  TreeMapItem* _base;
++  TreeMapItem *_current, *_pressed, *_lastOver, *_oldCurrent;
++  TreeMapTip* _tip;
++  int _maxSelectDepth, _maxDrawingDepth;
++
++  // attributes for field, per textNo
++  struct FieldAttr {
++    TQString type, stop;
++    bool visible, forced;
++    DrawParams::Position pos;
++  };
++  TQValueVector<FieldAttr> _attr;
++
++  SelectionMode _selectionMode;
++  TreeMapItem::SplitMode _splitMode;
++  int _visibleWidth, _stopArea, _minimalArea, _borderWidth;
++  bool _reuseSpace, _skipIncorrectBorder, _drawSeparators, _shading;
++  bool _allowRotation;  
++  bool _transparent[4], _drawFrame[4];
++  TreeMapItem * _needsRefresh;
++  TreeMapItemList _selection;
++  int _markNo;
++
++  // for the context menus: start IDs
++  int _splitID, _selectionID, _visID;
++  int _fieldStopID, _areaStopID, _depthStopID;
++  TreeMapItem* _menuItem;
++
++  // temporary selection while dragging, used for drawing
++  // most of the time, _selection == _tmpSelection
++  TreeMapItemList _tmpSelection;
++  bool _inShiftDrag, _inControlDrag;
++
++  // temporary widget font metrics while drawing
++  TQFont _font;
++  int _fontHeight;
++
++  // back buffer pixmap
++  TQPixmap _pixmap;
++};
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/utils.cpp b/kdecachegrind/kdecachegrind/utils.cpp
+new file mode 100644
+index 0000000..65c7e34
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/utils.cpp
+@@ -0,0 +1,483 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Utility classes for KCachegrind
++ */
++
++#ifdef HAVE_CONFIG_H
++#include <config.h>
++#endif
++
++#ifdef HAVE_MMAP
++#include <unistd.h>
++#include <sys/mman.h>
++#endif
++
++#include <tqfile.h>
++#include <errno.h>
++
++#include "utils.h"
++
++
++// class FixString
++
++FixString::FixString(const char* str, int len)
++{
++    _str = str;
++    _len = len;
++}
++
++bool FixString::stripFirst(char& c)
++{
++    if (!_len) {
++	c = 0;
++	return false;
++    }
++
++    c = *_str;
++    _str++;
++    _len--;
++    return true;
++ }
++
++bool FixString::stripPrefix(const char* p)
++{
++    if (_len == 0) return false;
++    if (!p || (*p != *_str)) return false;
++
++    const char* s = _str+1;
++    int l = _len-1;
++    p++;
++    while(*p) {
++	if (l==0) return false;
++	if (*s != *p) return false;
++	p++;
++	s++;
++	l--;
++    }
++    _str = s;
++    _len = l;
++    return true;
++}
++
++
++// this parses hexadecimal (with prefix '0x' too)
++bool FixString::stripUInt(unsigned int& v, bool stripSpaces)
++{
++    if (_len==0) {
++	v = 0;
++	return false;
++    }
++
++    char c = *_str;
++    if (c<'0' || c>'9') {
++	v = 0;
++	return false;
++    }
++
++    v = c-'0';
++    const char* s = _str+1;
++    int l = _len-1;
++    c = *s;
++
++    if ((l>0) && (c == 'x') && (v==0)) {
++	// hexadecimal
++	s++;
++	c = *s;
++	l--;
++
++	while(l>0) {
++	    if (c>='0' && c<='9')
++		v = 16*v + (c-'0');
++	    else if (c>='a' && c<='f')
++		v = 16*v + 10 + (c-'a');
++	    else if (c>='A' && c<='F')
++		v = 16*v + 10 + (c-'A');
++	    else
++		break;
++	    s++;
++	    c = *s;
++	    l--;
++	}
++    }
++    else {
++	// decimal
++
++	while(l>0) {
++	    if (c<'0' || c>'9') break;
++	    v = 10*v + (c-'0');
++	    s++;
++	    c = *s;
++	    l--;
++	}
++    }
++
++    if (stripSpaces)
++      while(l>0) {
++        if (c != ' ') break;
++        s++;
++        c = *s;
++        l--;
++      }
++
++    _str = s;
++    _len = l;
++    return true;
++}
++
++
++void FixString::stripSurroundingSpaces()
++{
++    if (_len==0) return;
++
++    // leading spaces
++    while((_len>0) && (*_str==' ')) {
++	_len--;
++	_str++;
++    }
++
++    // trailing spaces
++    while((_len>0) && (_str[_len-1]==' ')) {
++	_len--;
++    }
++}
++
++void FixString::stripSpaces()
++{
++    while((_len>0) && (*_str==' ')) {
++	_len--;
++	_str++;
++    }
++}
++
++bool FixString::stripName(FixString& s)
++{
++    if (_len==0) return false;
++
++    // first char has to be a letter or "_"
++    if (!TQChar(*_str).isLetter() && (*_str != '_')) return false;
++
++    int newLen = 1;
++    const char* newStr = _str;
++
++    _str++;
++    _len--;
++
++    while(_len>0) {
++      if (!TQChar(*_str).isLetterOrNumber()
++	  && (*_str != '_')) break;
++
++      newLen++;
++      _str++;
++      _len--;
++    }
++    
++    s.set(newStr, newLen);
++    return true;
++}
++
++FixString FixString::stripUntil(char c)
++{
++  if (_len == 0) return FixString();
++
++  const char* newStr = _str;
++  int newLen = 0;
++
++  while(_len>0) {
++    if (*_str == c) {
++      _str++;
++      _len--;
++      break;
++    }
++    
++    _str++;
++    _len--;
++    newLen++;
++  }
++  return FixString(newStr, newLen);
++}
++
++bool FixString::stripUInt64(uint64& v, bool stripSpaces)
++{
++    if (_len==0) {
++	v = 0;
++	return false;
++    }
++
++    char c = *_str;
++    if (c<'0' || c>'9') {
++	v = 0;
++	return false;
++    }
++
++    v = c-'0';
++    const char* s = _str+1;
++    int l = _len-1;
++    c = *s;
++
++    if ((l>0) && (c == 'x') && (v==0)) {
++	// hexadecimal
++	s++;
++	c = *s;
++	l--;
++
++	while(l>0) {
++	    if (c>='0' && c<='9')
++		v = 16*v + (c-'0');
++	    else if (c>='a' && c<='f')
++		v = 16*v + 10 + (c-'a');
++	    else if (c>='A' && c<='F')
++		v = 16*v + 10 + (c-'A');
++	    else
++		break;
++	    s++;
++	    c = *s;
++	    l--;
++	}
++    }
++    else {
++      // decimal
++      while(l>0) {
++	if (c<'0' || c>'9') break;
++	v = 10*v + (c-'0');
++	s++;
++	c = *s;
++	l--;
++      }
++    }
++
++    if (stripSpaces)
++      while(l>0) {
++        if (c != ' ') break;
++        s++;
++        c = *s;
++        l--;
++      }
++
++    _str = s;
++    _len = l;
++    return true;
++}
++
++
++bool FixString::stripInt64(int64& v, bool stripSpaces)
++{
++    if (_len==0) {
++	v = 0;
++	return false;
++    }
++
++    char c = *_str;
++    if (c<'0' || c>'9') {
++	v = 0;
++	return false;
++    }
++
++    v = c-'0';
++    const char* s = _str+1;
++    int l = _len-1;
++    c = *s;
++
++    if ((l>0) && (c == 'x') && (v==0)) {
++	// hexadecimal
++	s++;
++	c = *s;
++	l--;
++
++	while(l>0) {
++	    if (c>='0' && c<='9')
++		v = 16*v + (c-'0');
++	    else if (c>='a' && c<='f')
++		v = 16*v + 10 + (c-'a');
++	    else if (c>='A' && c<='F')
++		v = 16*v + 10 + (c-'A');
++	    else
++		break;
++	    s++;
++	    c = *s;
++	    l--;
++	}
++    }
++    else {
++      // decimal
++
++      while(l>0) {
++	if (c<'0' || c>'9') break;
++	v = 10*v + (c-'0');
++	s++;
++	c = *s;
++	l--;
++      }
++    }
++
++    if (stripSpaces)
++      while(l>0) {
++        if (c != ' ') break;
++        s++;
++        c = *s;
++        l--;
++      }
++
++    _str = s;
++    _len = l;
++    return true;
++}
++
++
++
++// class FixFile
++
++FixFile::FixFile(TQFile* file)
++{
++  if (!file) {
++    _len = 0;
++    _currentLeft = 0;
++    _openError = true;
++    return;
++  }
++
++  _filename = file->name();
++  if (!file->isOpen() && !file->open( IO_ReadOnly ) ) {
++    qWarning( "%s: %s", (const char*) TQFile::encodeName(_filename),
++	      strerror( errno ) );
++    _len = 0;
++    _currentLeft = 0;
++    _openError = true;
++    return;
++  }
++
++  _openError = false;
++  _used_mmap = false;
++
++#ifdef HAVE_MMAP
++    char *addr = 0;
++    size_t len = file->size();
++    if (len>0) addr = (char *) mmap( addr, len,
++                                     PROT_READ, MAP_PRIVATE,
++                                     file->handle(), 0 );
++    if (addr && (addr != MAP_FAILED)) {
++      // mmap succeeded
++        _base = addr;
++        _len = len;
++	_used_mmap = true;
++
++	if (0) qDebug("Mapped '%s'", _filename.ascii());
++    } else {
++#endif // HAVE_MMAP
++        // try reading the data into memory instead
++        _data = file->readAll();
++        _base = _data.data();
++        _len  = _data.size();
++#ifdef HAVE_MMAP
++    }
++#endif // HAVE_MMAP
++
++    _current     = _base;
++    _currentLeft = _len;
++}
++
++FixFile::~FixFile()
++{
++    // if the file was read into _data, it will be deleted automatically
++
++#ifdef HAVE_MMAP
++    if (_used_mmap) {
++	if (0) qDebug("Unmapping '%s'", _filename.ascii());
++	if (munmap(_base, _len) != 0)
++	    qWarning( "munmap: %s", strerror( errno ) );
++    }
++#endif // HAVE_MMAP
++}
++
++bool FixFile::nextLine(FixString& str)
++{
++    if (_currentLeft == 0) return false;
++
++    unsigned left = _currentLeft;
++    char* current = _current;
++
++    while(left>0) {
++	if (*current == 0 || *current == '\n') break;
++	current++;
++	left--;
++    }
++
++    if (0) {
++	char tmp[200];
++	int l = _currentLeft-left;
++	if (l>199) l = 199;
++	strncpy(tmp, _current, l);
++	tmp[l] = 0;
++	qDebug("[FixFile::nextLine] At %d, len %d: '%s'",
++	       _current - _base, _currentLeft-left, tmp);
++    }
++
++    str.set(_current, _currentLeft-left);
++
++    if (*current == '\n') {
++	current++;
++	left--;
++    }
++    _current = current;
++    _currentLeft = left;
++
++    return true;
++}
++
++bool FixFile::setCurrent(unsigned pos)
++{
++    if (pos > _len) return false;
++
++    _current = _base + pos;
++    _currentLeft = _len - pos;
++    return true;
++}
++
++
++#if 0
++
++// class AppendList
++
++
++AppendList::AppendList()
++{
++  _next = 0;
++  _current = 0;
++  _last = 0;
++
++  _count = 0;
++  _currentIndex = 0;
++  _lastIndex = 0;
++  _autoDelete = false;
++}
++
++
++void AppendList::clear()
++{
++  int count = _count;
++  int i;
++
++  if (count <= firstLen) {
++    if (_autoDelete)
++      for (i=0;i<count;i++)
++        delete _first[i];
++  }
++}
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/utils.h b/kdecachegrind/kdecachegrind/utils.h
+new file mode 100644
+index 0000000..7256f05
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/utils.h
+@@ -0,0 +1,164 @@
++/* This file is part of KCachegrind.
++   Copyright (C) 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
++
++   KCachegrind 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, version 2.
++
++   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; see the file COPYING.  If not, write to
++   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++   Boston, MA 02110-1301, USA.
++*/
++
++/*
++ * Utility classes for KCachegrind
++ */
++
++#ifndef UTILS_H
++#define UTILS_H
++
++#include <tqstring.h>
++
++class TQFile;
++
++typedef unsigned long long uint64;
++typedef long long int64;
++
++/**
++ * A simple, constant string class
++ *
++ * For use with zero-copy strings from mapped files.
++ */
++class FixString {
++
++ public:
++    // constructor for an invalid string
++    FixString() { _len = 0; _str = 0; }
++
++    /**
++     * FixString never does a deep copy! You have to make sure that
++     * the string starting at the char pointer is valid trough the
++     * lifetime of FixString.
++     */
++    FixString(const char*, int len);
++
++    int len() { return _len; }
++    const char* ascii() { return _str; }
++    bool isEmpty() { return _len == 0; }
++    bool isValid() { return _str != 0; }
++
++    // sets <c> to first character and returns true if length >0
++    bool first(char& c)
++	{ if (_len==0) return false; c=_str[0]; return true; }
++
++    void set(const char* s, int l) { _str=s; _len=l; }
++    bool stripFirst(char&);
++    bool stripPrefix(const char*);
++
++    /**
++     * Strip leading and trailing spaces
++     */
++    void stripSurroundingSpaces();
++
++    /**
++     * Strip leading spaces
++     */
++    void stripSpaces();
++
++    /**
++     * Strip name: [A-Za-z_][0-9A_Za-z_]*
++     */
++    bool stripName(FixString&);
++
++    /**
++     * Strip string until char appears or end. Strips char, too.
++     */
++    FixString stripUntil(char);
++
++    bool stripUInt(uint&, bool stripSpaces = true);
++    bool stripUInt64(uint64&, bool stripSpaces = true);
++    bool stripInt64(int64&, bool stripSpaces = true);
++
++    operator TQString() const
++	{ return TQString::fromLatin1(_str,_len); }
++
++ private:
++    const char* _str;
++    int _len;
++};
++
++
++/**
++ * A class for fast line by line reading of a read-only ASCII file
++ */
++class FixFile {
++
++ public:
++    FixFile(TQFile*);
++    ~FixFile();
++
++    /**
++     * Read next line into <str>. Returns false on error or EOF.
++     */
++    bool nextLine(FixString& str);
++    bool exists() { return !_openError; }
++    unsigned len() { return _len; }
++    unsigned current() { return _current - _base; }
++    bool setCurrent(unsigned pos);
++    void rewind() { setCurrent(0); }
++
++ private:
++    char *_base, *_current;
++    TQByteArray _data;
++    unsigned _len, _currentLeft;
++    bool _used_mmap, _openError;
++    TQString _filename;
++};
++
++
++/**
++ * A list of pointers, only able to append items.
++ * Optimized for speed, not space.
++ */
++template<class type>
++class AppendList {
++
++ public:
++  AppendList();
++    ~AppendList() { clear(); }
++
++    void setAutoDelete(bool);
++    void clear();
++    void append(const type*);
++
++    unsigned count() const { return _count; }
++    unsigned containsRef(const type*) const;
++
++    type* current();
++    type* first();
++    type* next();
++
++ private:
++    static const int firstLen = 8;
++    static const int maxLen = 256;
++
++    struct AppendListChunk {
++	int size;
++	struct AppendListChunk* next;
++	type* data[1];
++    };
++
++    struct AppendListChunk *_next, *_current, *_last;
++    int _count, _currentIndex, _lastIndex;
++    bool _autoDelete;
++    type* _first[firstLen];
++};
++
++
++#endif
+diff --git a/kdecachegrind/kdecachegrind/x-kcachegrind.desktop b/kdecachegrind/kdecachegrind/x-kcachegrind.desktop
+new file mode 100644
+index 0000000..b9bf93a
+--- /dev/null
++++ b/kdecachegrind/kdecachegrind/x-kcachegrind.desktop
+@@ -0,0 +1,44 @@
++[Desktop Entry]
++Comment=Cachegrind/Callgrind Profile Dump
++Comment[ca]=Resultat del anàlisis de Cachegrind/Callgring
++Comment[cs]=Data profilace Cachegrind/Callgrind
++Comment[cy]=Tomen Proffil Cachegrind/Callgrind
++Comment[da]=Cachegrind/Callgrind profile-dump
++Comment[de]=Cachegrind/Callgrind Profil-Ausgabe
++Comment[el]=Αποτύπωση προφίλ Cachegrind/Callgrind
++Comment[es]=Resultado de análisis de Cachegrind/Callgring
++Comment[et]=Cachegrind/Callgrind profileerimistõmmis
++Comment[eu]=Cachegrind/Callgrind profil iraulketa
++Comment[fa]=تخلیۀ Profile Cachegrind/Callgrind
++Comment[fi]=Cachegrind/Callgrind-profiilivedos
++Comment[fr]=Dépôt de profil Cachegrind / Callgrind
++Comment[gl]=Resultado da análise de Cachegrind/Callgrind
++Comment[hi]=केश-ग्रिंड/काल-ग्रिंड प्रोफ़ाइल डम्प
++Comment[hu]=Cachegrind/Callgrind teljesítményprofil-fájl
++Comment[is]=Niðurstaða afkastakönnunar á Cachegrind/Callgrind
++Comment[it]=Dump del profilo di Cachegrind/Callgrind
++Comment[ja]=Callgrind/Callgrind プロファイルダンプ
++Comment[ka]=Cachegrind/Callgrind პროფილის დამპი
++Comment[kk]=Cachegrind/Callgrind профилінің дампы
++Comment[nds]=Cachegrind/Callgrind-Profilutgaav
++Comment[ne]=Cachegrind/Callgrind प्रोफाइल डम्प
++Comment[nl]=Cachegrind/Callgrind Profieldump
++Comment[nn]=Cachegrind/Callgrind-profildump
++Comment[pl]=Zrzut profilowania Cachegrind/Callgrind
++Comment[pt]=Resultado da Análise do Cachegrind/Callgrind
++Comment[pt_BR]=Depósito de Perfil Cachegrind/Callgrind
++Comment[ru]=Дамп профилирования Cachegrind/Callgrind
++Comment[sk]=Výpis volaní Cachegrind/Callgrind
++Comment[sr]=Cachegrind-ов/Callgrind-ов избачај профила
++Comment[sr@Latn]=Cachegrind-ov/Callgrind-ov izbačaj profila
++Comment[sv]=Profileringsdump från Cachegrind/Callgrind
++Comment[ta]=இடைமாற்றகட்டம்/ அழைப்பு கட்டம் விவரக்குறி திணிப்பு
++Comment[tg]=Дампи профилкунии Cachegrind/Callgrind
++Comment[uk]=Звалювання профілювання Cachegrind/Callgrind
++Comment[zh_CN]=Cachegrind/Callgrind 配置文件转存
++Comment[zh_TW]=Cachegrind/Callgrind 分析資料傾印
++DefaultApp=kdecachegrind
++Icon=kdecachegrind
++Type=MimeType
++MimeType=application/x-kcachegrind
++Patterns=cachegrind.out*;callgrind.out*
+diff --git a/kdecachegrind/tests/cg-badcompression1 b/kdecachegrind/tests/cg-badcompression1
+new file mode 100644
+index 0000000..6076bf9
+--- /dev/null
++++ b/kdecachegrind/tests/cg-badcompression1
+@@ -0,0 +1,17 @@
++# Test with bad callgrind format
++# Expected:
++#  :13 - Redefinition of compressed file index 2 (was 'file1.c') to ''
++#  :14 - Redefinition of compressed function index 1 (was 'main') to 'main2'
++#  :16 - Undefined compressed function index 2
++#  :16 - Invalid function, setting to unknown
++
++events: Ir
++
++fl=(2) file1.c
++fn=(1) main
++10 9
++fl=(2 ) 
++fn=(1) main2
++11 1
++fn=(2)
++12 1
+diff --git a/kdecachegrind/tests/cg-badcostline1 b/kdecachegrind/tests/cg-badcostline1
+new file mode 100644
+index 0000000..224ff67
+--- /dev/null
++++ b/kdecachegrind/tests/cg-badcostline1
+@@ -0,0 +1,11 @@
++# Test with bad callgrind format
++# Expected:
++#  :10 - ignored garbage at end of cost line ('30')
++#  :11 - ignored garbage at end of cost line ('hello')
++
++events: Ir
++
++fn=main
++10 20 30
++11 hello
++12 10                     
+diff --git a/kdecachegrind/tests/cg-badposition b/kdecachegrind/tests/cg-badposition
+new file mode 100644
+index 0000000..1be582c
+--- /dev/null
++++ b/kdecachegrind/tests/cg-badposition
+@@ -0,0 +1,15 @@
++# Test with bad callgrind format
++# Expected:
++#  :11 - Negative line number -20
++#  :12 - Garbage at end of cost line ('a 21')
++#  :13 - Negative line number -91
++#  :15 - Invalid line 'aa 40'
++
++events: Ir
++
++fn=main
++-20 1
++9a 21
++-100 20
++0x9a 30
++aa 40
+diff --git a/kdecachegrind/version.h.in b/kdecachegrind/version.h.in
+new file mode 100644
+index 0000000..d88081b
+--- /dev/null
++++ b/kdecachegrind/version.h.in
+@@ -0,0 +1 @@
++#define KCACHEGRIND_VERSION "@KCACHEGRIND_VERSION@"