From ceea23677c61f20759ae986bd77b0d5c4d673edb Mon Sep 17 00:00:00 2001 From: tpearson Date: Wed, 17 Feb 2010 00:43:50 +0000 Subject: [PATCH] Added old KDE3 version of kbfx git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kbfx@1091549 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- CMakeLists.txt | 274 ++ build.sh | 246 ++ cmakemodules/COPYING-CMAKE-SCRIPTS | 22 + cmakemodules/CheckCXXCompilerFlag.cmake | 21 + cmakemodules/FindGNUWIN32.cmake | 49 + cmakemodules/FindKBFX.cmake | 32 + cmakemodules/FindKDE4.cmake | 40 + cmakemodules/FindKDE4Internal.cmake | 839 ++++++ cmakemodules/FindKDEWIN32.cmake | 89 + cmakemodules/FindKdeLibs.cmake | 316 +++ cmakemodules/FindQt4.cmake | 1081 ++++++++ cmakemodules/FindStrigi.cmake | 47 + cmakemodules/FindX11.cmake | 352 +++ cmakemodules/KDE3Macros.cmake | 392 +++ cmakemodules/KDE4Macros.cmake | 854 ++++++ cmakemodules/MacroAddCompileFlags.cmake | 19 + cmakemodules/MacroAddFileDependencies.cmake | 20 + cmakemodules/MacroAddLinkFlags.cmake | 18 + cmakemodules/MacroAdditionalCleanFiles.cmake | 21 + cmakemodules/MacroBoolTo01.cmake | 20 + .../MacroEnsureOutOfSourceBuild.cmake | 16 + cmakemodules/MacroEnsureVersion.cmake | 35 + cmakemodules/MacroLibrary.cmake | 18 + cmakemodules/MacroLogFeature.cmake | 112 + .../MacroOptionalAddSubdirectory.cmake | 27 + cmakemodules/MacroOptionalFindPackage.cmake | 28 + cmakemodules/MacroPushRequiredVars.cmake | 47 + cmakemodules/generatelibtoolfile.cmake | 16 + cmakemodules/kde3uic.cmake | 20 + cmakemodules/kdesvnMacros.cmake | 50 + cmakemodules/makedist.sh.in | 36 + cmakemodules/package_messages.sh.in | 84 + config.h.in | 4 + configdialog/CMakeLists.txt | 57 + configdialog/kbfx_install_theme.desktop | 22 + configdialog/kbfx_prepare_theme.desktop | 23 + configdialog/kbfx_theme.desktop | 18 + configdialog/kbfxconfigapp.cpp | 416 +++ configdialog/kbfxconfigapp.desktop | 36 + configdialog/kbfxconfigapp.h | 159 ++ configdialog/kbfxconfigapp.lsm | 16 + configdialog/kbfxconfigappui.rc | 8 + configdialog/kbfxconfigdlgabout.ui | 727 +++++ configdialog/kbfxconfigdlgabout.ui.h | 159 ++ configdialog/kbfxconfigdlgbutton.ui | 1275 +++++++++ configdialog/kbfxconfigdlgbutton.ui.h | 183 ++ configdialog/kbfxconfigdlgfonts-old.ui | 1193 ++++++++ configdialog/kbfxconfigdlgfonts-old.ui.h | 204 ++ configdialog/kbfxconfigdlglayout.ui | 1084 ++++++++ configdialog/kbfxconfigdlglayout.ui.h | 641 +++++ configdialog/kbfxconfigdlgmain.ui | 670 +++++ configdialog/kbfxconfigdlgmain.ui.h | 24 + configdialog/kbfxconfigdlgplugins.ui | 390 +++ configdialog/kbfxconfigdlgplugins.ui.h | 157 ++ configdialog/kbfxconfigdlgstyle.ui | 505 ++++ configdialog/kbfxconfigdlgstyle.ui.h | 30 + configdialog/kbfxconfigdlgthemes.ui | 1032 +++++++ configdialog/kbfxconfigdlgthemes.ui.h | 367 +++ configdialog/kbfxconfigdlgtooltip.ui | 719 +++++ configdialog/kbfxconfigdlgtooltip.ui.h | 86 + configdialog/kbfxthemeinfo.ui | 603 ++++ configdialog/kbfxthemeinfo.ui.h | 19 + configdialog/main.cpp | 163 ++ configdialog/x-kbfxtheme.desktop | 20 + doc/AUTHORS | 26 + doc/CMakeLists.txt | 17 + doc/COPYING | 346 +++ doc/CREDITS | 11 + doc/ChangeLog | 123 + doc/HACKING | 21 + doc/HOWTO | 411 +++ doc/INSTALL | 203 ++ doc/KNOWN_BUGS | 1 + doc/LICENSE | 351 +++ doc/NEWS | 37 + doc/README | 44 + doc/TODO | 62 + doc/common/CMakeLists.txt | 5 + doc/common/kbfx-about.jpg | Bin 0 -> 25522 bytes doc/common/kbfx-fonts.jpg | Bin 0 -> 22863 bytes doc/common/kbfx-layout.jpg | Bin 0 -> 23403 bytes doc/common/kbfx-maindescription.jpg | Bin 0 -> 66520 bytes doc/common/kbfx-plugins.jpg | Bin 0 -> 18937 bytes doc/common/kbfx-startbutton.jpg | Bin 0 -> 30229 bytes doc/common/kbfx-style.jpg | Bin 0 -> 23407 bytes doc/common/kbfx-themes.jpg | Bin 0 -> 29524 bytes doc/common/kbfx-tooltip.jpg | Bin 0 -> 25521 bytes doc/en/CMakeLists.txt | 2 + doc/en/index.docbook.in | 2456 +++++++++++++++++ images/CMakeLists.txt | 5 + images/hi128-app-kbfx.png | Bin 0 -> 22402 bytes images/hi16-app-kbfxconfigapp.png | Bin 0 -> 871 bytes images/hi32-app-kbfxconfigapp.png | Bin 0 -> 2523 bytes kbfx-0.4.9.3.1.ebuild | 31 + kbfx-9999.ebuild | 27 + kbfx-svn.ebuild.in | 27 + kbfx.ebuild.in | 31 + kbfx.spec | 255 ++ kbfx.spec.in | 255 ++ kbfxlib/common/CMakeLists.txt | 48 + kbfxlib/common/kbfxconfig.cpp | 862 ++++++ kbfxlib/common/kbfxconfig.h | 295 ++ kbfxlib/common/kbfxfontchooser.cpp | 79 + kbfxlib/common/kbfxfontchooser.h | 70 + kbfxlib/common/kbfxkiodownload.cpp | 78 + kbfxlib/common/kbfxkiodownload.h | 75 + kbfxlib/common/kbfxpixmaplabel.cpp | 92 + kbfxlib/common/kbfxpixmaplabel.h | 53 + kbfxlib/common/kbfxplasmapixmapprovider.cpp | 146 + kbfxlib/common/kbfxplasmapixmapprovider.h | 53 + kbfxlib/common/kbfxpushbutton.cpp | 48 + kbfxlib/common/kbfxpushbutton.h | 41 + kbfxlib/common/kbfxthemesdata.cpp | 90 + kbfxlib/common/kbfxthemesdata.h | 52 + kbfxlib/data/CMakeLists.txt | 48 + kbfxlib/data/kbfxdatagroup.cpp | 92 + kbfxlib/data/kbfxdatagroup.h | 100 + kbfxlib/data/kbfxdatagrouplist.cpp | 54 + kbfxlib/data/kbfxdatagrouplist.h | 52 + kbfxlib/data/kbfxdatasource.cpp | 89 + kbfxlib/data/kbfxdatasource.h | 151 + kbfxlib/data/kbfxdatastack.cpp | 84 + kbfxlib/data/kbfxdatastack.h | 64 + kbfxlib/data/kbfxplasmadataplugin.cpp | 29 + kbfxlib/data/kbfxplasmadataplugin.h | 29 + kbfxlib/data/kbfxplasmapluginloader.cpp | 161 ++ kbfxlib/data/kbfxplasmapluginloader.h | 79 + kbfxlib/data/kbfxplugin.cpp | 115 + kbfxlib/data/kbfxplugin.h | 74 + patches/001.patch | 14 + plugins/applications/CMakeLists.txt | 44 + plugins/applications/kbfxplasmadataplugin.cpp | 224 ++ plugins/common/CMakeLists.txt | 3 + plugins/common/kbfxplasmadataplugin-common.h | 37 + plugins/plasmoids/CMakeLists.txt | 44 + .../kbfxplasmadatapluginplosmoid.cpp | 152 + plugins/recentstuff/CMakeLists.txt | 44 + plugins/recentstuff/kbfxplasmarecentstuff.cpp | 150 + plugins/settings/CMakeLists.txt | 44 + .../settings/kbfxplasmadatapluginsettings.cpp | 189 ++ plugins/strigi/CMakeLists.txt | 46 + plugins/strigi/kbfxstrigiplugin.cpp | 225 ++ plugins/strigi/kbfxstrigiplugin.h | 42 + po/CMakeLists.txt | 1 + po/bg.po | 1649 +++++++++++ po/hu.po | 1616 +++++++++++ po/it.po | 1591 +++++++++++ po/nl.po | 1551 +++++++++++ skin/raster/2panels/CMakeLists.txt | 4 + skin/raster/2panels/appfind.png | Bin 0 -> 5136 bytes skin/raster/2panels/bg.png | Bin 0 -> 726 bytes skin/raster/2panels/bg_sidebar.png | Bin 0 -> 2842 bytes skin/raster/2panels/botbg.png | Bin 0 -> 9119 bytes skin/raster/2panels/butterfly.png | Bin 0 -> 29563 bytes skin/raster/2panels/dudebox.png | Bin 0 -> 2032 bytes skin/raster/2panels/fancymenuitem.png | Bin 0 -> 1589 bytes skin/raster/2panels/find.png | Bin 0 -> 725 bytes skin/raster/2panels/hover.png | Bin 0 -> 11928 bytes skin/raster/2panels/indexseparator.png | Bin 0 -> 3210 bytes skin/raster/2panels/kbfxfontrc | 15 + skin/raster/2panels/kbfxlayoutrc | 66 + skin/raster/2panels/listboxbg.png | Bin 0 -> 177 bytes skin/raster/2panels/lock.png | Bin 0 -> 6644 bytes skin/raster/2panels/lockhover.png | Bin 0 -> 6981 bytes skin/raster/2panels/logo.png | Bin 0 -> 13043 bytes skin/raster/2panels/logout.png | Bin 0 -> 6908 bytes skin/raster/2panels/logouthover.png | Bin 0 -> 7238 bytes skin/raster/2panels/mask.png | Bin 0 -> 35310 bytes skin/raster/2panels/menu_main_white_bg.png | Bin 0 -> 242 bytes skin/raster/2panels/menu_top.png | Bin 0 -> 13306 bytes skin/raster/2panels/menu_top_image_person.png | Bin 0 -> 4828 bytes skin/raster/2panels/middleboxbg.png | Bin 0 -> 1894 bytes skin/raster/2panels/mystatus_bg.png | Bin 0 -> 1826 bytes skin/raster/2panels/normal.png | Bin 0 -> 12218 bytes skin/raster/2panels/off.png | Bin 0 -> 4788 bytes skin/raster/2panels/on.png | Bin 0 -> 5103 bytes skin/raster/2panels/pressed.png | Bin 0 -> 11997 bytes skin/raster/2panels/preview.png | Bin 0 -> 100871 bytes skin/raster/2panels/rhshovertile.png | Bin 0 -> 360 bytes skin/raster/2panels/rhstile.png | Bin 0 -> 362 bytes skin/raster/2panels/scrollnormal.png | Bin 0 -> 739 bytes skin/raster/2panels/scrollnormalbot.png | Bin 0 -> 739 bytes skin/raster/2panels/separator.png | Bin 0 -> 2500 bytes skin/raster/2panels/separator2.png | Bin 0 -> 645 bytes skin/raster/2panels/sidebar_top.png | Bin 0 -> 3240 bytes skin/raster/2panels/tabbg.png | Bin 0 -> 583 bytes skin/raster/2panels/tilehover.png | Bin 0 -> 9060 bytes skin/raster/2panels/tilenormal.png | Bin 0 -> 9060 bytes skin/raster/2panels/toolbuttonnormal.png | Bin 0 -> 1936 bytes skin/raster/2panels/top_bg.png | Bin 0 -> 8668 bytes skin/raster/2panels/topbg.png | Bin 0 -> 28154 bytes skin/raster/2panels/version-2 | 5 + skin/raster/default/CMakeLists.txt | 4 + skin/raster/default/appfind.png | Bin 0 -> 5136 bytes skin/raster/default/appviewbg.png | Bin 0 -> 177 bytes skin/raster/default/bg.png | Bin 0 -> 726 bytes skin/raster/default/botbg.png | Bin 0 -> 10739 bytes skin/raster/default/butterfly.png | Bin 0 -> 29563 bytes skin/raster/default/dudebox.png | Bin 0 -> 4024 bytes skin/raster/default/find.png | Bin 0 -> 1336 bytes skin/raster/default/hover.png | Bin 0 -> 7812 bytes skin/raster/default/indexseparator.png | Bin 0 -> 1310 bytes skin/raster/default/kbfxfontrc | 15 + skin/raster/default/kbfxlayoutrc | 26 + skin/raster/default/listboxbg.png | Bin 0 -> 177 bytes skin/raster/default/lock.png | Bin 0 -> 6644 bytes skin/raster/default/lockhover.png | Bin 0 -> 6981 bytes skin/raster/default/logo.png | Bin 0 -> 13043 bytes skin/raster/default/logout.png | Bin 0 -> 6908 bytes skin/raster/default/logouthover.png | Bin 0 -> 7238 bytes skin/raster/default/mask.png | Bin 0 -> 5685 bytes skin/raster/default/menu_top.png | Bin 0 -> 13306 bytes skin/raster/default/menu_top_image_person.png | Bin 0 -> 4828 bytes skin/raster/default/middleboxbg.png | Bin 0 -> 1894 bytes skin/raster/default/normal.png | Bin 0 -> 7692 bytes skin/raster/default/off.png | Bin 0 -> 4788 bytes skin/raster/default/on.png | Bin 0 -> 5103 bytes skin/raster/default/pressed.png | Bin 0 -> 7686 bytes skin/raster/default/preview.png | Bin 0 -> 36084 bytes skin/raster/default/rhshovertile.png | Bin 0 -> 2701 bytes skin/raster/default/rhstile.png | Bin 0 -> 1470 bytes skin/raster/default/scrollnormal.png | Bin 0 -> 1527 bytes skin/raster/default/scrollnormalbot.png | Bin 0 -> 1527 bytes skin/raster/default/separator.png | Bin 0 -> 5026 bytes skin/raster/default/tabbg.png | Bin 0 -> 583 bytes skin/raster/default/tilehover.png | Bin 0 -> 5892 bytes skin/raster/default/tilenormal.png | Bin 0 -> 5892 bytes skin/raster/default/tooltip_dudebox.png | Bin 0 -> 3056 bytes skin/raster/default/tooltip_logo.png | Bin 0 -> 291 bytes skin/raster/default/tooltip_mask.png | Bin 0 -> 446 bytes skin/raster/default/tooltip_window.png | Bin 0 -> 227 bytes skin/raster/default/topbg.png | Bin 0 -> 29294 bytes skin/raster/default/version-2 | 5 + skin/vector/CMakeLists.txt | 0 src/CMakeLists.txt | 62 + src/kbfxbutton.cpp | 417 +++ src/kbfxbutton.h | 113 + src/kbfxplasmacanvasabstractitem.cpp | 130 + src/kbfxplasmacanvasabstractitem.h | 103 + src/kbfxplasmacanvasgroup.cpp | 330 +++ src/kbfxplasmacanvasgroup.h | 95 + src/kbfxplasmacanvasgroupview.cpp | 213 ++ src/kbfxplasmacanvasgroupview.h | 86 + src/kbfxplasmacanvasitem.cpp | 401 +++ src/kbfxplasmacanvasitem.h | 141 + src/kbfxplasmacanvasitem_events.cpp | 81 + src/kbfxplasmacanvasitem_events.h | 23 + src/kbfxplasmacanvasitemwrapper.cpp | 125 + src/kbfxplasmacanvasitemwrapper.h | 49 + src/kbfxplasmacanvasrtti.h | 22 + src/kbfxplasmacanvasstack.cpp | 179 ++ src/kbfxplasmacanvasstack.h | 89 + src/kbfxplasmacanvasstackdata.h | 38 + src/kbfxplasmacanvasview.cpp | 665 +++++ src/kbfxplasmacanvasview.h | 124 + src/kbfxplasmaindexitem.cpp | 182 ++ src/kbfxplasmaindexitem.h | 68 + src/kbfxplasmaindexview.cpp | 436 +++ src/kbfxplasmaindexview.h | 94 + src/kbfxsignal.h | 38 + src/kbfxspinx.cpp | 327 +++ src/kbfxspinx.desktop | 17 + src/kbfxspinx.h | 108 + src/kbfxspinxmenu.cpp | 513 ++++ src/kbfxspinxmenu.h | 126 + src/kbfxspinxpopup.cpp | 70 + src/kbfxspinxpopup.h | 58 + src/kbfxspinxscrollbar.cpp | 142 + src/kbfxspinxscrollbar.h | 76 + src/kbfxspinxtoolbar.cpp | 67 + src/kbfxspinxtoolbar.h | 57 + src/kbfxspinxtoolbutton.cpp | 139 + src/kbfxspinxtoolbutton.h | 94 + src/kbfxspinxtop.cpp | 123 + src/kbfxspinxtop.h | 71 + src/kbfxspinxview.cpp | 35 + src/kbfxspinxview.h | 41 + src/kbfxtooltip.cpp | 306 ++ src/kbfxtooltip.h | 93 + strigi-0.3.11.ebuild | 91 + strigi.ebuild.in | 91 + 281 files changed, 39056 insertions(+) create mode 100644 CMakeLists.txt create mode 100755 build.sh create mode 100644 cmakemodules/COPYING-CMAKE-SCRIPTS create mode 100644 cmakemodules/CheckCXXCompilerFlag.cmake create mode 100644 cmakemodules/FindGNUWIN32.cmake create mode 100644 cmakemodules/FindKBFX.cmake create mode 100644 cmakemodules/FindKDE4.cmake create mode 100644 cmakemodules/FindKDE4Internal.cmake create mode 100644 cmakemodules/FindKDEWIN32.cmake create mode 100644 cmakemodules/FindKdeLibs.cmake create mode 100644 cmakemodules/FindQt4.cmake create mode 100644 cmakemodules/FindStrigi.cmake create mode 100644 cmakemodules/FindX11.cmake create mode 100644 cmakemodules/KDE3Macros.cmake create mode 100644 cmakemodules/KDE4Macros.cmake create mode 100644 cmakemodules/MacroAddCompileFlags.cmake create mode 100644 cmakemodules/MacroAddFileDependencies.cmake create mode 100644 cmakemodules/MacroAddLinkFlags.cmake create mode 100644 cmakemodules/MacroAdditionalCleanFiles.cmake create mode 100644 cmakemodules/MacroBoolTo01.cmake create mode 100644 cmakemodules/MacroEnsureOutOfSourceBuild.cmake create mode 100644 cmakemodules/MacroEnsureVersion.cmake create mode 100644 cmakemodules/MacroLibrary.cmake create mode 100644 cmakemodules/MacroLogFeature.cmake create mode 100644 cmakemodules/MacroOptionalAddSubdirectory.cmake create mode 100644 cmakemodules/MacroOptionalFindPackage.cmake create mode 100644 cmakemodules/MacroPushRequiredVars.cmake create mode 100644 cmakemodules/generatelibtoolfile.cmake create mode 100644 cmakemodules/kde3uic.cmake create mode 100644 cmakemodules/kdesvnMacros.cmake create mode 100755 cmakemodules/makedist.sh.in create mode 100755 cmakemodules/package_messages.sh.in create mode 100644 config.h.in create mode 100644 configdialog/CMakeLists.txt create mode 100644 configdialog/kbfx_install_theme.desktop create mode 100644 configdialog/kbfx_prepare_theme.desktop create mode 100644 configdialog/kbfx_theme.desktop create mode 100644 configdialog/kbfxconfigapp.cpp create mode 100644 configdialog/kbfxconfigapp.desktop create mode 100644 configdialog/kbfxconfigapp.h create mode 100644 configdialog/kbfxconfigapp.lsm create mode 100644 configdialog/kbfxconfigappui.rc create mode 100644 configdialog/kbfxconfigdlgabout.ui create mode 100644 configdialog/kbfxconfigdlgabout.ui.h create mode 100644 configdialog/kbfxconfigdlgbutton.ui create mode 100644 configdialog/kbfxconfigdlgbutton.ui.h create mode 100644 configdialog/kbfxconfigdlgfonts-old.ui create mode 100644 configdialog/kbfxconfigdlgfonts-old.ui.h create mode 100644 configdialog/kbfxconfigdlglayout.ui create mode 100644 configdialog/kbfxconfigdlglayout.ui.h create mode 100644 configdialog/kbfxconfigdlgmain.ui create mode 100644 configdialog/kbfxconfigdlgmain.ui.h create mode 100644 configdialog/kbfxconfigdlgplugins.ui create mode 100644 configdialog/kbfxconfigdlgplugins.ui.h create mode 100644 configdialog/kbfxconfigdlgstyle.ui create mode 100644 configdialog/kbfxconfigdlgstyle.ui.h create mode 100644 configdialog/kbfxconfigdlgthemes.ui create mode 100644 configdialog/kbfxconfigdlgthemes.ui.h create mode 100644 configdialog/kbfxconfigdlgtooltip.ui create mode 100644 configdialog/kbfxconfigdlgtooltip.ui.h create mode 100644 configdialog/kbfxthemeinfo.ui create mode 100644 configdialog/kbfxthemeinfo.ui.h create mode 100644 configdialog/main.cpp create mode 100644 configdialog/x-kbfxtheme.desktop create mode 100755 doc/AUTHORS create mode 100644 doc/CMakeLists.txt create mode 100755 doc/COPYING create mode 100644 doc/CREDITS create mode 100755 doc/ChangeLog create mode 100644 doc/HACKING create mode 100644 doc/HOWTO create mode 100755 doc/INSTALL create mode 100644 doc/KNOWN_BUGS create mode 100644 doc/LICENSE create mode 100755 doc/NEWS create mode 100755 doc/README create mode 100755 doc/TODO create mode 100644 doc/common/CMakeLists.txt create mode 100644 doc/common/kbfx-about.jpg create mode 100644 doc/common/kbfx-fonts.jpg create mode 100644 doc/common/kbfx-layout.jpg create mode 100644 doc/common/kbfx-maindescription.jpg create mode 100644 doc/common/kbfx-plugins.jpg create mode 100644 doc/common/kbfx-startbutton.jpg create mode 100644 doc/common/kbfx-style.jpg create mode 100644 doc/common/kbfx-themes.jpg create mode 100644 doc/common/kbfx-tooltip.jpg create mode 100644 doc/en/CMakeLists.txt create mode 100644 doc/en/index.docbook.in create mode 100644 images/CMakeLists.txt create mode 100644 images/hi128-app-kbfx.png create mode 100644 images/hi16-app-kbfxconfigapp.png create mode 100644 images/hi32-app-kbfxconfigapp.png create mode 100644 kbfx-0.4.9.3.1.ebuild create mode 100644 kbfx-9999.ebuild create mode 100644 kbfx-svn.ebuild.in create mode 100644 kbfx.ebuild.in create mode 100644 kbfx.spec create mode 100644 kbfx.spec.in create mode 100644 kbfxlib/common/CMakeLists.txt create mode 100644 kbfxlib/common/kbfxconfig.cpp create mode 100644 kbfxlib/common/kbfxconfig.h create mode 100644 kbfxlib/common/kbfxfontchooser.cpp create mode 100644 kbfxlib/common/kbfxfontchooser.h create mode 100644 kbfxlib/common/kbfxkiodownload.cpp create mode 100644 kbfxlib/common/kbfxkiodownload.h create mode 100644 kbfxlib/common/kbfxpixmaplabel.cpp create mode 100644 kbfxlib/common/kbfxpixmaplabel.h create mode 100644 kbfxlib/common/kbfxplasmapixmapprovider.cpp create mode 100644 kbfxlib/common/kbfxplasmapixmapprovider.h create mode 100644 kbfxlib/common/kbfxpushbutton.cpp create mode 100644 kbfxlib/common/kbfxpushbutton.h create mode 100644 kbfxlib/common/kbfxthemesdata.cpp create mode 100644 kbfxlib/common/kbfxthemesdata.h create mode 100644 kbfxlib/data/CMakeLists.txt create mode 100644 kbfxlib/data/kbfxdatagroup.cpp create mode 100644 kbfxlib/data/kbfxdatagroup.h create mode 100644 kbfxlib/data/kbfxdatagrouplist.cpp create mode 100644 kbfxlib/data/kbfxdatagrouplist.h create mode 100644 kbfxlib/data/kbfxdatasource.cpp create mode 100644 kbfxlib/data/kbfxdatasource.h create mode 100644 kbfxlib/data/kbfxdatastack.cpp create mode 100644 kbfxlib/data/kbfxdatastack.h create mode 100644 kbfxlib/data/kbfxplasmadataplugin.cpp create mode 100644 kbfxlib/data/kbfxplasmadataplugin.h create mode 100644 kbfxlib/data/kbfxplasmapluginloader.cpp create mode 100644 kbfxlib/data/kbfxplasmapluginloader.h create mode 100644 kbfxlib/data/kbfxplugin.cpp create mode 100644 kbfxlib/data/kbfxplugin.h create mode 100644 patches/001.patch create mode 100644 plugins/applications/CMakeLists.txt create mode 100644 plugins/applications/kbfxplasmadataplugin.cpp create mode 100644 plugins/common/CMakeLists.txt create mode 100644 plugins/common/kbfxplasmadataplugin-common.h create mode 100644 plugins/plasmoids/CMakeLists.txt create mode 100644 plugins/plasmoids/kbfxplasmadatapluginplosmoid.cpp create mode 100644 plugins/recentstuff/CMakeLists.txt create mode 100644 plugins/recentstuff/kbfxplasmarecentstuff.cpp create mode 100644 plugins/settings/CMakeLists.txt create mode 100644 plugins/settings/kbfxplasmadatapluginsettings.cpp create mode 100644 plugins/strigi/CMakeLists.txt create mode 100644 plugins/strigi/kbfxstrigiplugin.cpp create mode 100644 plugins/strigi/kbfxstrigiplugin.h create mode 100644 po/CMakeLists.txt create mode 100644 po/bg.po create mode 100644 po/hu.po create mode 100644 po/it.po create mode 100644 po/nl.po create mode 100644 skin/raster/2panels/CMakeLists.txt create mode 100644 skin/raster/2panels/appfind.png create mode 100644 skin/raster/2panels/bg.png create mode 100644 skin/raster/2panels/bg_sidebar.png create mode 100644 skin/raster/2panels/botbg.png create mode 100644 skin/raster/2panels/butterfly.png create mode 100644 skin/raster/2panels/dudebox.png create mode 100644 skin/raster/2panels/fancymenuitem.png create mode 100644 skin/raster/2panels/find.png create mode 100644 skin/raster/2panels/hover.png create mode 100644 skin/raster/2panels/indexseparator.png create mode 100644 skin/raster/2panels/kbfxfontrc create mode 100644 skin/raster/2panels/kbfxlayoutrc create mode 100644 skin/raster/2panels/listboxbg.png create mode 100644 skin/raster/2panels/lock.png create mode 100644 skin/raster/2panels/lockhover.png create mode 100644 skin/raster/2panels/logo.png create mode 100644 skin/raster/2panels/logout.png create mode 100644 skin/raster/2panels/logouthover.png create mode 100644 skin/raster/2panels/mask.png create mode 100644 skin/raster/2panels/menu_main_white_bg.png create mode 100644 skin/raster/2panels/menu_top.png create mode 100644 skin/raster/2panels/menu_top_image_person.png create mode 100644 skin/raster/2panels/middleboxbg.png create mode 100644 skin/raster/2panels/mystatus_bg.png create mode 100644 skin/raster/2panels/normal.png create mode 100644 skin/raster/2panels/off.png create mode 100644 skin/raster/2panels/on.png create mode 100644 skin/raster/2panels/pressed.png create mode 100644 skin/raster/2panels/preview.png create mode 100644 skin/raster/2panels/rhshovertile.png create mode 100644 skin/raster/2panels/rhstile.png create mode 100644 skin/raster/2panels/scrollnormal.png create mode 100644 skin/raster/2panels/scrollnormalbot.png create mode 100644 skin/raster/2panels/separator.png create mode 100644 skin/raster/2panels/separator2.png create mode 100644 skin/raster/2panels/sidebar_top.png create mode 100644 skin/raster/2panels/tabbg.png create mode 100644 skin/raster/2panels/tilehover.png create mode 100644 skin/raster/2panels/tilenormal.png create mode 100644 skin/raster/2panels/toolbuttonnormal.png create mode 100644 skin/raster/2panels/top_bg.png create mode 100644 skin/raster/2panels/topbg.png create mode 100644 skin/raster/2panels/version-2 create mode 100644 skin/raster/default/CMakeLists.txt create mode 100644 skin/raster/default/appfind.png create mode 100644 skin/raster/default/appviewbg.png create mode 100644 skin/raster/default/bg.png create mode 100644 skin/raster/default/botbg.png create mode 100644 skin/raster/default/butterfly.png create mode 100644 skin/raster/default/dudebox.png create mode 100644 skin/raster/default/find.png create mode 100644 skin/raster/default/hover.png create mode 100644 skin/raster/default/indexseparator.png create mode 100644 skin/raster/default/kbfxfontrc create mode 100644 skin/raster/default/kbfxlayoutrc create mode 100644 skin/raster/default/listboxbg.png create mode 100644 skin/raster/default/lock.png create mode 100644 skin/raster/default/lockhover.png create mode 100644 skin/raster/default/logo.png create mode 100644 skin/raster/default/logout.png create mode 100644 skin/raster/default/logouthover.png create mode 100644 skin/raster/default/mask.png create mode 100644 skin/raster/default/menu_top.png create mode 100644 skin/raster/default/menu_top_image_person.png create mode 100644 skin/raster/default/middleboxbg.png create mode 100644 skin/raster/default/normal.png create mode 100644 skin/raster/default/off.png create mode 100644 skin/raster/default/on.png create mode 100644 skin/raster/default/pressed.png create mode 100644 skin/raster/default/preview.png create mode 100644 skin/raster/default/rhshovertile.png create mode 100644 skin/raster/default/rhstile.png create mode 100644 skin/raster/default/scrollnormal.png create mode 100644 skin/raster/default/scrollnormalbot.png create mode 100644 skin/raster/default/separator.png create mode 100644 skin/raster/default/tabbg.png create mode 100644 skin/raster/default/tilehover.png create mode 100644 skin/raster/default/tilenormal.png create mode 100644 skin/raster/default/tooltip_dudebox.png create mode 100644 skin/raster/default/tooltip_logo.png create mode 100644 skin/raster/default/tooltip_mask.png create mode 100644 skin/raster/default/tooltip_window.png create mode 100644 skin/raster/default/topbg.png create mode 100644 skin/raster/default/version-2 create mode 100644 skin/vector/CMakeLists.txt create mode 100644 src/CMakeLists.txt create mode 100644 src/kbfxbutton.cpp create mode 100644 src/kbfxbutton.h create mode 100644 src/kbfxplasmacanvasabstractitem.cpp create mode 100644 src/kbfxplasmacanvasabstractitem.h create mode 100644 src/kbfxplasmacanvasgroup.cpp create mode 100644 src/kbfxplasmacanvasgroup.h create mode 100644 src/kbfxplasmacanvasgroupview.cpp create mode 100644 src/kbfxplasmacanvasgroupview.h create mode 100644 src/kbfxplasmacanvasitem.cpp create mode 100644 src/kbfxplasmacanvasitem.h create mode 100644 src/kbfxplasmacanvasitem_events.cpp create mode 100644 src/kbfxplasmacanvasitem_events.h create mode 100644 src/kbfxplasmacanvasitemwrapper.cpp create mode 100644 src/kbfxplasmacanvasitemwrapper.h create mode 100644 src/kbfxplasmacanvasrtti.h create mode 100644 src/kbfxplasmacanvasstack.cpp create mode 100644 src/kbfxplasmacanvasstack.h create mode 100644 src/kbfxplasmacanvasstackdata.h create mode 100644 src/kbfxplasmacanvasview.cpp create mode 100644 src/kbfxplasmacanvasview.h create mode 100644 src/kbfxplasmaindexitem.cpp create mode 100644 src/kbfxplasmaindexitem.h create mode 100644 src/kbfxplasmaindexview.cpp create mode 100644 src/kbfxplasmaindexview.h create mode 100644 src/kbfxsignal.h create mode 100644 src/kbfxspinx.cpp create mode 100644 src/kbfxspinx.desktop create mode 100644 src/kbfxspinx.h create mode 100644 src/kbfxspinxmenu.cpp create mode 100644 src/kbfxspinxmenu.h create mode 100644 src/kbfxspinxpopup.cpp create mode 100644 src/kbfxspinxpopup.h create mode 100644 src/kbfxspinxscrollbar.cpp create mode 100644 src/kbfxspinxscrollbar.h create mode 100644 src/kbfxspinxtoolbar.cpp create mode 100644 src/kbfxspinxtoolbar.h create mode 100644 src/kbfxspinxtoolbutton.cpp create mode 100644 src/kbfxspinxtoolbutton.h create mode 100644 src/kbfxspinxtop.cpp create mode 100644 src/kbfxspinxtop.h create mode 100644 src/kbfxspinxview.cpp create mode 100644 src/kbfxspinxview.h create mode 100644 src/kbfxtooltip.cpp create mode 100644 src/kbfxtooltip.h create mode 100644 strigi-0.3.11.ebuild create mode 100644 strigi.ebuild.in diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..52e2459 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,274 @@ +PROJECT(kbfx) + +CMAKE_MINIMUM_REQUIRED(VERSION 2.4.2 FATAL_ERROR) +SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmakemodules) +SET(CMAKE_COLOR_MAKEFILE ON CACHE STRING "Enable/Disable color output during build." FORCE) +#SET(CMAKE_VERBOSE_MAKEFILE OFF CACHE STRING "Enable/Disable cmake debug output during build." FORCE) + +# Optimization flags +# SET(CMAKE_CXX_FLAGS_DISTRIBUTION "-O3") +# SET(CMAKE_C_FLAGS_DISTRIBUTION "-O3") + +# Global variable CMAKE_BUILD_TYPE +# None (CMAKE_C_FLAGS or CMAKE_CXX_FLAGS used) +# Debug (CMAKE_C_FLAGS_DEBUG or CMAKE_CXX_FLAGS_DEBUG) +# Release (CMAKE_C_FLAGS_RELEASE or CMAKE_CXX_FLAGS_RELEASE) +# RelWithDebInfo (CMAKE_C_FLAGS_RELWITHDEBINFO or CMAKE_CXX_FLAGS_RELWITHDEBINFO +# MinSizeRel (CMAKE_C_FLAGS_MINSIZEREL or CMAKE_CXX_FLAGS_MINSIZEREL) +IF (NOT CMAKE_BUILD_TYPE) + SET(CMAKE_BUILD_TYPE RelWithDebInfo + CACHE + STRING "Specify build type: None Debug Release RelWithDebInfo MinSizeRel." + FORCE) +ENDIF (NOT CMAKE_BUILD_TYPE) + +OPTION(USE_STRIGI "Enable use of Strigi search support (disabled)" OFF) +OPTION(USE_MENUDRAKE "Use 'menudrake' instead of 'kmenuedit' in Mandriva (auto)" ON) +OPTION(USE_KDE4 "Compile for KDE4 (disabled)" OFF) + +SET(BIN_SEARCH_PATHES + $ENV{HOME}/bin + $ENV{HOME}/usr/bin + $ENV{KDEDIR}/bin + ${CMAKE_INSTALL_PREFIX}/bin + /opt/kde/bin + /opt/kde3/bin + /opt/kde4/bin + /usr/kde/3.5/bin + /usr/bin + /usr/local/bin + /opt/bin + ) +SET(INCLUDE_SEARCH_PATHES + $ENV{HOME}/include + $ENV{HOME}/usr/include + $ENV{KDEDIR}/include + /opt/kde/include + /opt/kde3/include + /opt/kde4/include + /usr/kde/3.5/include + /usr/include + /usr/local/include + /opt/include + ${CMAKE_SYSTEM_INCLUDE_PATH} + ) +SET(LIB_SEARCH_PATHES + $ENV{HOME}/lib + $ENV{HOME}/usr/lib + $ENV{KDEDIR}/lib + /opt/kde/lib + /opt/kde3/lib + /opt/kde4/lib + /usr/kde/3.5/lib + /usr/lib + /usr/local/lib + /opt/lib + ) + +# Setting versions + +# For versions that are stable set to 1, else to 0 +SET(APPLICATION_STABLE 1) + +SET(LIB_MAJOR 4) +SET(LIB_MINOR 9) +SET(LIB_RELEASE 3) +SET(LIB_SUB_RELEASE 1) +SET(APPLICATION_INTERNAL_VERSION "20070516") +SET(APPLICATION_DATE "2007-05-16") + +SET(APPLICATION_NAME "${PROJECT_NAME}") +SET(APPLICATION_MAIN_VERSION "0.${LIB_MAJOR}.${LIB_MINOR}.${LIB_RELEASE}") + +IF (APPLICATION_STABLE) + SET(APPLICATION_STABLE_RELEASE ".${LIB_SUB_RELEASE}") + SET(APPLICATION_VERSION "${APPLICATION_MAIN_VERSION}.${LIB_SUB_RELEASE}") + SET(GENTOO_VERSION "${APPLICATION_MAIN_VERSION}.${LIB_SUB_RELEASE}") +ELSE (APPLICATION_APPLICATION_STABLE "") + SET(STABLE_RELEASE) + SET(APPLICATION_VERSION "${APPLICATION_MAIN_VERSION}-${LIB_SUB_RELEASE}") + SET(GENTOO_VERSION "${APPLICATION_MAIN_VERSION}_pre${LIB_SUB_RELEASE}") +ENDIF (APPLICATION_STABLE) + +SET(VERSION ${APPLICATION_VERSION}) + +SET(STRIGI_VERSION "0.3.11") +SET(GENTOO_KEYWORDS "x86 ~ppc ~amd64") + +# Prepare docbook part +CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/doc/en/index.docbook.in ${CMAKE_BINARY_DIR}/doc/en/index.docbook @ONLY) + +IF (USE_STRIGI) + FIND_PACKAGE(Strigi REQUIRED) + INCLUDE_DIRECTORIES(${STRIGI_INCLUDE_DIR}) + MESSAGE(STATUS "Strigi support is: ON!") +ELSE (USE_STRIGI) + MESSAGE(STATUS "Strigi support is: OFF!") +ENDIF (USE_STRIGI) + + +FIND_PROGRAM(HAVE_MANDRAKE menudrake) +IF (HAVE_MANDRAKE AND USE_MENUDRAKE) + SET(MANDRAKE "1") + MESSAGE(STATUS "Will use 'menudrake' instead of 'kmenuedit'!") +ELSE (HAVE_MANDRAKE AND USE_MENUDRAKE) + SET(MANDRAKE "") + MESSAGE(STATUS "Will use 'kmenuedit'!") +ENDIF (HAVE_MANDRAKE AND USE_MENUDRAKE) + +IF (NOT USE_KDE4) + MESSAGE(STATUS "Building for KDE3") + INCLUDE(TestCXXAcceptsFlag) + + SET(CMAKE_CXX_FLAGS_DEBUG + "${CMAKE_CXX_FLAGS_DEBUG} -DTESTING_RC=\"\\\"\${CMAKE_SOURCE_DIR}/configdialog/kbfxconfigappui.rc\\\"\"") + + CHECK_CXX_ACCEPTS_FLAG("-fexceptions" CXX_EXCEPTION) + CHECK_CXX_ACCEPTS_FLAG("-fstack-protector" CXX_PROTECTOR) + + FIND_PACKAGE(KDE3 REQUIRED) + + INCLUDE(FindKdeLibs) + INCLUDE(MacroEnsureVersion) + + # Dummy macros for compatibility + MACRO(KDE4_AUTOMOC _dummy) + ENDMACRO(KDE4_AUTOMOC) + + MACRO(KDE4_ADD_LIBRARY _dummy _dummy1 _dummy2) + ENDMACRO(KDE4_ADD_LIBRARY) + + MACRO(KDE4_INSTALL_LIBTOOL_FILE _dummy _dummy1) + ENDMACRO(KDE4_INSTALL_LIBTOOL_FILE) + + MACRO(KDE4_ADD_UI3_FILES _dummy _dummy1) + ENDMACRO(KDE4_ADD_UI3_FILES) + + MACRO(KDE4_ADD_DCOP_SKELS _dummy _dummy1) + ENDMACRO(KDE4_ADD_DCOP_SKELS) + + MACRO(KDE4_ADD_EXECUTABLE _dummy _dummy1) + ENDMACRO(KDE4_ADD_EXECUTABLE) + + MACRO(KDE4_INSTALL_ICONS _dummy) + ENDMACRO(KDE4_INSTALL_ICONS) +ELSE (NOT USE_KDE4) + MESSAGE(STATUS "Building for KDE4") + FIND_PACKAGE(KDE4 REQUIRED) + ADD_DEFINITIONS(${KDE4_DEFINITIONS} ${QT_DEFINITIONS}) + SET(INCLUDE_SEARCH_PATHES + ${INCLUDE_SEARCH_PATHES} + ${KDE4_INCLUDES} + ) + SET(LIB_SEARCH_PATHES + ${LIB_SEARCH_PATHES} + ${KDE4_LIB_DIR} + ) +ENDIF (NOT USE_KDE4) + +INCLUDE_DIRECTORIES( + ${CMAKE_BINARY_DIR} + ${CMAKE_BINARY_DIR}/kbfxlib/data + ${CMAKE_BINARY_DIR}/kbfxlib/common + ${CMAKE_BINARY_DIR}/src + ${CMAKE_BINARY_DIR}/configdialog + ${CMAKE_BINARY_DIR}/plugins/common + ${CMAKE_SOURCE_DIR} + ${CMAKE_SOURCE_DIR}/kbfxlib/data + ${CMAKE_SOURCE_DIR}/kbfxlib/common + ${CMAKE_SOURCE_DIR}/src + ${CMAKE_SOURCE_DIR}/configdialog + ${CMAKE_SOURCE_DIR}/plugins/common + ${KDE3_INCLUDE_DIR}/kbfx + ${KDE3_INCLUDE_DIR}/kbfx/plugins + ${INCLUDE_SEARCH_PATHES} + ) + +IF (NOT USE_KDE4) + IF (CXX_EXCEPTION) + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions") + ENDIF (CXX_EXCEPTION) + IF (CXX_PROTECTOR) + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector") + ENDIF (CXX_PROTECTOR) + + ADD_DEFINITIONS(${KDE3_DEFINITIONS} ${QT_DEFINITIONS}) + SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin) + SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib) + + IF(KDE3_KDECONFIG_EXECUTABLE) + EXECUTE_PROCESS(COMMAND ${KDE3_KDECONFIG_EXECUTABLE} "--version" OUTPUT_VARIABLE output) + STRING(REGEX MATCH "KDE: [0-9]+\\.[0-9]+\\.[0-9]+" KDEVERSION "${output}") + STRING(REGEX REPLACE "^KDE: " "" KDEVERSION "${KDEVERSION}") + ENDIF(KDE3_KDECONFIG_EXECUTABLE) + SET(KDE_MIN_VERSION "3.5.0") + MACRO_ENSURE_VERSION(${KDE_MIN_VERSION} ${KDEVERSION} VERSION_OK) + IF(NOT VERSION_OK) + MESSAGE(FATAL_ERROR "You need at least KDE Version of 3.5.0 in order to compile KBFX.\n Please upgrade your KDE or install the development files of KDE.") + ENDIF(NOT VERSION_OK) +ENDIF (NOT USE_KDE4) + +SET(KBFX_LIB_INSTALL_DIR ${LIB_INSTALL_DIR}) + +ADD_SUBDIRECTORY(kbfxlib/data) +ADD_SUBDIRECTORY(kbfxlib/common) +ADD_SUBDIRECTORY(src) +ADD_SUBDIRECTORY(configdialog) +ADD_SUBDIRECTORY(skin/vector) +ADD_SUBDIRECTORY(skin/raster/default) +ADD_SUBDIRECTORY(skin/raster/2panels) +ADD_SUBDIRECTORY(images) +ADD_SUBDIRECTORY(doc) +ADD_SUBDIRECTORY(doc/en) +ADD_SUBDIRECTORY(doc/common) +ADD_SUBDIRECTORY(po) +ADD_SUBDIRECTORY(plugins/common) +ADD_SUBDIRECTORY(plugins/applications) +ADD_SUBDIRECTORY(plugins/settings) +ADD_SUBDIRECTORY(plugins/plasmoids) +ADD_SUBDIRECTORY(plugins/recentstuff) +IF (USE_STRIGI) + ADD_SUBDIRECTORY(plugins/strigi) +ENDIF (USE_STRIGI) + +CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/config.h.in ${CMAKE_BINARY_DIR}/config.h @ONLY) +CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/kbfx.spec.in ${CMAKE_BINARY_DIR}/kbfx.spec @ONLY) +CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/kbfx.ebuild.in ${CMAKE_BINARY_DIR}/kbfx-${GENTOO_VERSION}.ebuild @ONLY) +CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/strigi.ebuild.in ${CMAKE_BINARY_DIR}/strigi-${STRIGI_VERSION}.ebuild @ONLY) +CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/kbfx-svn.ebuild.in ${CMAKE_BINARY_DIR}/kbfx-9999.ebuild @ONLY) + +SET(DIST_INCLUDE "kbfx-9999.ebuild kbfx.spec kbfx-${GENTOO_VERSION}.ebuild strigi-${STRIGI_VERSION}.ebuild") +SET(DIST_EXCLUDE "Helperstuff") +CONFIGURE_FILE( + "${CMAKE_CURRENT_SOURCE_DIR}/cmakemodules/makedist.sh.in" + "${CMAKE_CURRENT_BINARY_DIR}/makedist.sh" + IMMEDIATE + @ONLY) +ADD_CUSTOM_TARGET(dist + "${CMAKE_BINARY_DIR}/makedist.sh" + WORKING_DIRECTORY ${CMAKE_BINARY_DIR}) + +IF (NOT USE_KDE4) + CONFIGURE_FILE( + "${CMAKE_CURRENT_SOURCE_DIR}/cmakemodules/cmake_uninstall.cmake.in" + "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" + IMMEDIATE @ONLY) + ADD_CUSTOM_TARGET(uninstall + "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake") +ENDIF (NOT USE_KDE4) + + +FILE(GLOB _POFILES po/*.po) +FOREACH(_p ${_POFILES}) + SET(POFILES "${_p} ${POFILES}") +ENDFOREACH(_p) + +SET(MESSAGES_DIR ${CMAKE_SOURCE_DIR}) +CONFIGURE_FILE( + "${CMAKE_CURRENT_SOURCE_DIR}/cmakemodules/package_messages.sh.in" + "${CMAKE_CURRENT_BINARY_DIR}/package_messages.sh" + IMMEDIATE + @ONLY) +ADD_CUSTOM_TARGET(package-messages + "${CMAKE_CURRENT_BINARY_DIR}/package_messages.sh") + diff --git a/build.sh b/build.sh new file mode 100755 index 0000000..d3f4983 --- /dev/null +++ b/build.sh @@ -0,0 +1,246 @@ +#! /bin/sh + +CMAKE_OPT_PREFIX_KDE3="-DCMAKE_INSTALL_PREFIX:PATH=`kde-config --prefix 2>/dev/null` " +CMAKE_OPT_PREFIX_KDE4="-DCMAKE_INSTALL_PREFIX:PATH=`kde4-config --prefix 2>/dev/null` " +CMAKE_OPT_PREFIX="" +MAKE_VERBOSE="" +USE_STRIGI_SEARCH="" +MENUDRAKE="" +KDE4="" +ACTION="install" +NOCHECK=0 +build_state="touch kbfx_build" +command_line_args=$@ +eval "which kbfxconfigapp > /dev/null 2>&1" && kbfx_installed="1" || kbfx_installed="0" + +color_ok="\\033[1;32m" +color_error="\\033[1;31m" +color_normal="\\033[0;39m" +color_warn="\\033[1;33m" + + +prog_action(){ + echo + echo -e "$color_ok $@ $color_normal" +} + +prog_err(){ + echo + echo -e "$color_error ERROR doing $@ $color_normal\n" +} + +confirm() { + printf "$color_warn %s (Y)es/(N)o? [%s]$color_normal " "$1" "$2" + unset user_input + answer="$2" + read user_input +if [ "$user_input" = "y" -o "$user_input" = "Y" -o "$user_input" = "YES" -o "$user_input" = "Yes" -o "$user_input" = "yes" ]; then + answer="Y" +fi +if [ "$user_input" = "n" -o "$user_input" = "N" -o "" = "NO" -o "$user_input" = "No" -o "$user_input" = "no" ]; then + answer="N" +fi +} + +parse_command_line() { + if [ "$#" -eq 0 ]; then + return 0 + fi + while [ "$1" != "${1##-}" ]; do + case $1 in + --verbose|-v) + MAKE_VERBOSE="VERBOSE=1" + shift 1 + ;; + --prefix|-p) + if [ -n "$2" -a "$2" = "${2##-}" ]; then + t=0 + stop=0 + s="" + for p in $@ + do + t=$[t+1] + if [ $t -gt 1 -a "$p" = "${p##-}" -a $stop -eq 0 ]; then + s="$s$p " + fi + if [ $t -gt 1 -a "$p" != "${p##-}" ]; then + stop=$[t-1] + fi + done + if [ $stop -eq 0 ]; then + stop=$[t-1] + fi + if [ -n "$s" ]; then + s=${s%%[ ]} + CMAKE_OPT_PREFIX="-DCMAKE_INSTALL_PREFIX:PATH='$s' " + fi + shift $stop + else + shift 1 + return 1 + fi + ;; + --strigi|-s) + USE_STRIGI_SEARCH="-DUSE_STRIGI:BOOL=TRUE" + shift 1 + ;; + --menudrake-off|-m) + MENUDRAKE="-DUSE_MENUDRAKE:BOOL=FALSE" + shift 1 + ;; + --kde4|-k) + KDE4="-DUSE_KDE4:BOOL=TRUE" + shift 1 + ;; + --uninstall|-u) + ACTION="uninstall" + shift 1 + ;; + --nocheck|-n) + NOCHECK=1 + shift 1 + ;; + *) + if [ "$#" -ge 1 ]; then + return 1 + fi + return 0 + ;; + esac + done +} + +show_usage(){ + echo + echo -e "$color_warn Usage: \n\t build.sh \t [(-v|--verbose) Be verbose when compiling (default: no)] \n\t\t\t [(-u|--uninstall) Uninstall KBFX (default: no)] \n\t\t\t [(-p|--prefix) Install prefix (default: KDE prefix)] \n\t\t\t [(-s|--strigi) Compile strigi search plugin (default: no)] \n\t\t\t [(-m|-menudrake-off) Don't use menudrake in Mandriva (default: auto)] \n\t\t\t [(-k|--kde4) Compile for KDE4 (default: no)] \n\t\t\t [(-n|--nocheck) Do not check for old KBFX versions (default: check)] $color_normal" + echo +} + +parse_command_line $command_line_args +if [ "$?" -eq 1 ]; then + prog_err "build.sh" + show_usage + exit 1 +fi + +show_usage + +if [ "$ACTION" = "install" ] +then { + if [ $kbfx_installed -eq 1 -a $NOCHECK -eq 0 ] ; then + echo + echo -e "$color_error \n\t You have KBFX installed in your \$PATH!\n\t In order to compile the new version you HAVE TO REMOVE the old KBFX first!\n $color_normal" + exit 1 + fi + + if [ -d build ] ; then + echo + echo -e "$color_warn Directory 'build' exists! Using it...$color_normal" + echo -e "$color_error If 'build.sh' fails, try removing the directory 'build' and run 'build.sh' again! $color_normal" + else + mkdir build + fi + cd build + + if [ "$CMAKE_OPT_PREFIX" = "" ] + then { + if [ "$KDE4" = "" ] + then { + CMAKE_OPT_PREFIX=$CMAKE_OPT_PREFIX_KDE3 + } + else { + CMAKE_OPT_PREFIX=$CMAKE_OPT_PREFIX_KDE4 + } + fi + } + fi + + CMAKE_OPT="$CMAKE_OPT_PREFIX $KDE4 $MENUDRAKE $USE_STRIGI_SEARCH" + + prog_action "Doing CMake configure..." + echo $CMAKE_OPT + eval "cmake ../ $CMAKE_OPT" + if [ $? -ne 0 ]; then + prog_err "CMake configure..." + exit 1 + fi + + prog_action "Doing make..." + make $MAKE_VERBOSE + if [ $? -ne 0 ]; then + prog_err "make..." + exit 1 + fi + + eval $build_state + prog_action "Success building KBFX...\n" + + confirm "Do you want to install KBFX?" "Y" + if [ "$answer" = "Y" ] + then + sucommand="make install" + after_su="touch kbfx_install_user" + if [ `whoami` != 'root' ] + then { + confirm "To install KBFX as 'root', answer 'Yes'. To install as '`whoami`', answer 'No'" "N" + if [ "$answer" = "Y" ] + then { + sucommand="su root -c 'make install'" + after_su="touch kbfx_install_root" + } + fi + } + fi + + prog_action "Doing 'make install'..." + eval $sucommand + if [ $? -ne 0 ]; then + prog_err "make install..." + exit 1 + fi + eval $after_su + echo + echo -e "$color_warn NOTE: If you have used a custom prefix for your install (-p or --prefix option for script), \n you should add '$s' to your \$KDEDIRS environment variable\n and '$s/lib' to your \$LD_LIBRARY_PATH environment variable!\n $color_normal" + fi +} +else { + if [ -d build ] + then + cd build + else + echo + echo -e "$color_error \n\t Directory 'build' DOES NOT exist!\n\t You HAVE NOT used 'build.sh' script for installing KBFX! \n\t Uninstall CAN NOT continue!\n $color_normal" + exit 1 + fi + + if [ -f kbfx_install_user ] + then + sucommand="make uninstall" + after_su="rm -f kbfx_install_user" + elif [ -f kbfx_install_root ] + then + sucommand="su root -c 'make uninstall'" + after_su="rm -f kbfx_install_root" + elif [ -f kbfx_build ] + then + echo + echo -e "$color_error \n\t KBFX IS NOT installed! \n\t Uninstall CAN NOT continue!\n $color_normal" + exit 1 + else + echo + echo -e "$color_error \n\t You HAVE NOT used 'build.sh' script for installing KBFX! \n\t Uninstall CAN NOT continue!\n $color_normal" + exit 1 + fi + + prog_action "Uninstalling..." + eval $sucommand + if [ $? -ne 0 ]; then + prog_err "uninstall..." + exit 1 + fi + eval $after_su + +} +fi + +prog_action "All actions ended successfully...\n" diff --git a/cmakemodules/COPYING-CMAKE-SCRIPTS b/cmakemodules/COPYING-CMAKE-SCRIPTS new file mode 100644 index 0000000..4b41776 --- /dev/null +++ b/cmakemodules/COPYING-CMAKE-SCRIPTS @@ -0,0 +1,22 @@ +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. The name of the author may not be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. diff --git a/cmakemodules/CheckCXXCompilerFlag.cmake b/cmakemodules/CheckCXXCompilerFlag.cmake new file mode 100644 index 0000000..43ea9a6 --- /dev/null +++ b/cmakemodules/CheckCXXCompilerFlag.cmake @@ -0,0 +1,21 @@ +# - Check whether the CXX compiler supports a given flag. +# CHECK_CXX_COMPILER_FLAG(FLAG VARIABLE) +# +# FLAG - the compiler flag +# VARIABLE - variable to store the result + +# Copyright (c) 2006, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +INCLUDE(CheckCXXSourceCompiles) + +MACRO (CHECK_CXX_COMPILER_FLAG _FLAG _RESULT) + SET(SAFE_CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}") + SET(CMAKE_REQUIRED_DEFINITIONS "${_FLAG}") + CHECK_CXX_SOURCE_COMPILES("int main() { return 0;}" ${_RESULT}) + SET (CMAKE_REQUIRED_DEFINITIONS "${SAFE_CMAKE_REQUIRED_DEFINITIONS}") +ENDMACRO (CHECK_CXX_COMPILER_FLAG) + diff --git a/cmakemodules/FindGNUWIN32.cmake b/cmakemodules/FindGNUWIN32.cmake new file mode 100644 index 0000000..8b999d9 --- /dev/null +++ b/cmakemodules/FindGNUWIN32.cmake @@ -0,0 +1,49 @@ + +# Copyright (c) 2006, Peter Kuemmel, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +if (WIN32) + +# check if GNUWIN32_DIR is already set +# (e.g. by command line argument or the calling script) +if(NOT GNUWIN32_DIR) + # check for enviroment variable + file(TO_CMAKE_PATH "$ENV{GNUWIN32_DIR}" GNUWIN32_DIR) + if(NOT GNUWIN32_DIR) + # search in the default program install folder + file(TO_CMAKE_PATH "$ENV{PROGRAMFILES}" _progFiles) + find_file(GNUWIN32_DIR_tmp gnuwin32 win32libs + PATHS + "${_progFiles}" + "C:/" "D:/" "E:/" "F:/" "G:/" + ) + set(GNUWIN32_DIR ${GNUWIN32_DIR_tmp}) + endif(NOT GNUWIN32_DIR) +endif(NOT GNUWIN32_DIR) + +if (GNUWIN32_DIR) + set(GNUWIN32_INCLUDE_DIR ${GNUWIN32_DIR}/include) + set(GNUWIN32_LIBRARY_DIR ${GNUWIN32_DIR}/lib) + set(GNUWIN32_BINARY_DIR ${GNUWIN32_DIR}/bin) + set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} ${GNUWIN32_INCLUDE_DIR}) + set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} ${GNUWIN32_LIBRARY_DIR}) + set(GNUWIN32_FOUND TRUE) +else (GNUWIN32_DIR) + set(GNUWIN32_FOUND) +endif (GNUWIN32_DIR) + +if (GNUWIN32_FOUND) + if (NOT GNUWIN32_FIND_QUIETLY) + message(STATUS "Found GNUWIN32: ${GNUWIN32_DIR}") + endif (NOT GNUWIN32_FIND_QUIETLY) +else (GNUWIN32_FOUND) + if (GNUWIN32_FIND_REQUIRED) + message(FATAL_ERROR "Could NOT find GNUWIN32") + endif (GNUWIN32_FIND_REQUIRED) +endif (GNUWIN32_FOUND) + +endif (WIN32) + diff --git a/cmakemodules/FindKBFX.cmake b/cmakemodules/FindKBFX.cmake new file mode 100644 index 0000000..b865018 --- /dev/null +++ b/cmakemodules/FindKBFX.cmake @@ -0,0 +1,32 @@ +# - Try to find the KBFX package - +# If found the following will be defined +# +# KBFX_FOUND - KBFX package found on the system +# KBFX_INCLUDE_DIR - Directory of the KBFX package include files +# KBFX_LIBRARY - Where libkbfxplasma.so resides +# + +FIND_PATH(KBFX_INCLUDE_DIR kbfx/kbfxconfig.h + PATHS + ${INCLUDE_SEARCH_PATHES} +) + +FIND_LIBRARY(KBFX_LIBRARY NAMES kbfxplasma + PATHS + ${LIB_SEARCH_PATHES} +) + +IF(KBFX_INCLUDE_DIR AND KBFX_LIBRARY) + SET(KBFX_FOUND TRUE) +ENDIF(KBFX_INCLUDE_DIR AND KBFX_LIBRARY) + +IF(KBFX_FOUND) + IF(NOT KBFX_FIND_QUIETLY) + MESSAGE(STATUS "Found KBFX package: ${KBFX_LIBRARY}") + ENDIF(NOT KBFX_FIND_QUIETLY) +ELSE(KBFX_FOUND) + IF(KBFX_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find KBFX package! Please download and install KBFX from http://www.kbfx.org") + ENDIF(KBFX_FIND_REQUIRED) +ENDIF(KBFX_FOUND) + diff --git a/cmakemodules/FindKDE4.cmake b/cmakemodules/FindKDE4.cmake new file mode 100644 index 0000000..bbcd8d5 --- /dev/null +++ b/cmakemodules/FindKDE4.cmake @@ -0,0 +1,40 @@ +# Find KDE4 and provide all necessary variables and macros to compile software for it. +# It looks for KDE 4 in the following directories in the given order: +# - CMAKE_INSTALL_PREFIX +# - KDEDIR +# - /opt/kde4 +# - /opt/kde +# +# Please look in FindKDE4Internal.cmake and KDE4Macros.cmake for more information. +# They are installed with the KDE 4 libraries in $KDEDIR/share/apps/cmake/modules/. +# +# Author: Alexander Neundorf +# Modified by PhobosK + +# For KDE4 kde-config has been renamed to kde4-config +FIND_PROGRAM(KDE4_KDECONFIG_EXECUTABLE NAMES kde4-config + PATHS + ${BIN_SEARCH_PATHES} + NO_DEFAULT_PATH) + +IF (NOT KDE4_KDECONFIG_EXECUTABLE) + FIND_PROGRAM(KDE4_KDECONFIG_EXECUTABLE NAMES kde4-config ) +ENDIF (NOT KDE4_KDECONFIG_EXECUTABLE) + +IF (KDE4_KDECONFIG_EXECUTABLE) + IF (KDE4_FIND_QUIETLY) + SET(_quiet QUIET) + ENDIF (KDE4_FIND_QUIETLY) + + IF (KDE4_FIND_REQUIRED) + SET(_req REQUIRED) + ENDIF (KDE4_FIND_REQUIRED) + + # use FindKDE4Internal.cmake to do the rest + FIND_PACKAGE(KDE4Internal ${_req} ${_quiet}) +ELSE (KDE4_KDECONFIG_EXECUTABLE) + IF (KDE4_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "ERROR: Could not find KDE4 kde4-config") + ENDIF (KDE4_FIND_REQUIRED) +ENDIF (KDE4_KDECONFIG_EXECUTABLE) + diff --git a/cmakemodules/FindKDE4Internal.cmake b/cmakemodules/FindKDE4Internal.cmake new file mode 100644 index 0000000..3747468 --- /dev/null +++ b/cmakemodules/FindKDE4Internal.cmake @@ -0,0 +1,839 @@ +# - Find the KDE4 include and library dirs, KDE preprocessors and define a some macros +# +# This module defines the following variables: +# +# KDE4_FOUND - set to TRUE if everything required for building KDE software has been found +# +# KDE4_DEFINITIONS - compiler definitions required for compiling KDE software +# KDE4_INCLUDE_DIR - the KDE 4 include directory +# KDE4_INCLUDES - all include directories required for KDE, i.e. +# KDE4_INCLUDE_DIR, but also the Qt4 include directories +# and other platform specific include directories +# KDE4_LIB_DIR - the directory where the KDE libraries are installed, +# intended to be used with LINK_DIRECTORIES() +# +# The following variables are defined for the various tools required to +# compile KDE software: +# +# KDE4_KCFGC_EXECUTABLE - the kconfig_compiler executable +# KDE4_MEINPROC_EXECUTABLE - the meinproc executable +# KDE4_MAKEKDEWIDGETS_EXECUTABLE - the makekdewidgets executable +# +# The following variables point to the location of the KDE libraries, +# but shouldn't be used directly: +# +# KDE4_KDECORE_LIBRARY - the kdecore library +# KDE4_KDEUI_LIBRARY - the kdeui library +# KDE4_KIO_LIBRARY - the kio library +# KDE4_KPARTS_LIBRARY - the kparts library +# KDE4_KUTILS_LIBRARY - the kutils library +# KDE4_KDE3SUPPORT_LIBRARY - the kde3support library +# KDE4_KXMLCORE_LIBRARY - the kxmlcore library +# KDE4_KHTML_LIBRARY - the khtml library +# KDE4_KJS_LIBRARY - the kjs library +# KDE4_KNEWSTUFF_LIBRARY - the knewstuff library +# KDE4_KDEPRINT_LIBRARY - the kdeprint library +# KDE4_KSPELL2_LIBRARY - the kspell2 library +# KDE4_KDNSSD_LIBRARY - the kdnssd library +# KDE4_PHONONCORE_LIBRARY - the phononcore library +# KDE4_PHONONUI_LIBRARY - the phononui library +# KDE4_KAUDIODEVICELIST_LIBRARY - the kaudiodevicelist library +# KDE4_KDEFX_LIBRARY - the kdefx library +# KDE4_THREADWEAVER_LIBRARY- the threadweaver library +# KDE4_SOLID_LIBRARY - the solid library +# KDE4_SOLIDIFACES_LIBRARY - the solidiface library +# KDE4_KNOTIFYCONFIG_LIBRARY- the knotifyconfig library +# KDE4_KROSSCORE_LIBRARY- the krosscore library +# KDE4_KTEXTEDITOR_LIBRARY - the ktexteditor library +# KDE4_KWALLETCLIENT_LIBRARY - the kwalletclient library +# +# Compared to the variables above, the following variables +# also contain all of the depending libraries, so the variables below +# should be used instead of the ones above: +# +# KDE4_KDECORE_LIBS - the kdecore library and all depending libraries +# KDE4_KDEUI_LIBS - the kdeui library and all depending libraries +# KDE4_KIO_LIBS - the kio library and all depending libraries +# KDE4_KPARTS_LIBS - the kparts library and all depending libraries +# KDE4_KUTILS_LIBS - the kutils library and all depending libraries +# KDE4_KDE3SUPPORT_LIBS - the kde3support library and all depending libraries +# KDE4_KXMLCORE_LIBS - the kxmlcore library and all depending libraries +# KDE4_KHTML_LIBS - the khtml library and all depending libraries +# KDE4_KJS_LIBS - the kjs library and all depending libraries +# KDE4_KNEWSTUFF_LIBS - the knewstuff library and all depending libraries +# KDE4_KDEPRINT_LIBS - the kdeprint library and all depending libraries +# KDE4_KSPELL2_LIBS - the kspell2 library and all depending libraries +# KDE4_KDNSSD_LIBS - the kdnssd library and all depending libraries +# KDE4_KDESU_LIBS - the kdesu library and all depending libraries +# KDE4_PHONONCORE_LIBS - the phononcore library and all depending librairies +# KDE4_PHONONUI_LIBRARIES - the phononui library and all depending librairies +# KDE4_KDEFX_LIBS - the kdefx library and all depending librairies +# KDE4_THREADWEAVER_LIBRARIES- the threadweaver library and all depending libraries +# KDE4_SOLID_LIBS - the solid library and all depending libraries +# KDE4_SOLIDIFACES_LIBS - the solid iface library and all depending libraries +# KDE4_KNOTIFYCONFIG_LIBS - the knotify config library and all depending libraries +# KDE4_KROSSCORE_LIBS - the kross core library and all depending libraries +# KDE4_KTEXTEDITOR_LIBS - the ktexteditor library and all depending libraries +# KDE4_KWALLETCLIENT_LIBS - the kwallet client library and all depending libraries +# +# This module defines a bunch of variables used as locations +# for install directories. They are all interpreted relative +# to CMAKE_INSTALL_PREFIX +# +# BIN_INSTALL_DIR - the directory where executables be installed (default is prefix/bin) +# SBIN_INSTALL_DIR - the directory where system executables will be installed (default is prefix/sbin) +# LIB_INSTALL_DIR - the directory where libraries will be installed (default is prefix/lib) +# CONFIG_INSTALL_DIR - the config file install dir +# DATA_INSTALL_DIR - the parent directory where applications can install their data +# HTML_INSTALL_DIR - the HTML install dir for documentation +# ICON_INSTALL_DIR - the icon install dir (default prefix/share/icons/) +# INFO_INSTALL_DIR - the kde info install dir (default prefix/info) +# KCFG_INSTALL_DIR - the install dir for kconfig files +# LOCALE_INSTALL_DIR - the install dir for translations +# MAN_INSTALL_DIR - the kde man page install dir (default prefix/man/) +# MIME_INSTALL_DIR - the install dir for the mimetype desktop files +# PLUGIN_INSTALL_DIR - the subdirectory relative to the install prefix where plugins will be installed (default is ${KDE4_LIB_INSTALL_DIR}/kde4) +# SERVICES_INSTALL_DIR - the install dir for service (desktop, protocol, ...) files +# SERVICETYPES_INSTALL_DIR - the install dir for servicestypes desktop files +# SOUND_INSTALL_DIR - the install dir for sound files +# TEMPLATES_INSTALL_DIR - the install dir for templates (Create new file...) +# WALLPAPER_INSTALL_DIR - the install dir for wallpapers +# KCONF_UPDATE_INSTALL_DIR - the kconf_update install dir +# XDG_APPS_DIR - the XDG apps dir +# XDG_DIRECTORY_DIR - the XDG directory +# DBUS_INTERFACES_DIR - the directory where dbus interfaces be installed (default is prefix/share/dbus-1/interfaces +# +# The following variables are provided, but are seem to be unused: +# LIBS_HTML_INSTALL_DIR /share/doc/HTML CACHE STRING "Is this still used ?") +# APPLNK_INSTALL_DIR /share/applnk CACHE STRING "Is this still used ?") +# +# The following user adjustable options are provided: +# +# KDE4_ENABLE_FINAL - enable KDE-style enable-final all-in-one-compilation +# KDE4_BUILD_TESTS - enable this to build the testcases +# KDE4_ENABLE_FPIE - enable it to use gcc Position Independent Executables feature +# +# It also adds the following macros (from KDE4Macros.cmake) +# KDE4_ADD_UI_FILES (SRCS_VAR file1.ui ... fileN.ui) +# Use this to add Qt designer ui files to your application/library. +# +# KDE4_ADD_UI3_FILES (SRCS_VAR file1.ui ... fileN.ui) +# Use this to add Qt designer ui files from Qt version 3 to your application/library. +# +# KDE4_ADD_KCFG_FILES (SRCS_VAR [GENERATE_MOC] file1.kcfgc ... fileN.kcfgc) +# Use this to add KDE config compiler files to your application/library. +# Use optional GENERATE_MOC to generate moc if you use signals in your kcfg files. +# +# KDE4_ADD_WIDGET_FILES (SRCS_VAR file1.widgets ... fileN.widgets) +# Use this to add widget description files for the makekdewidgets code generator +# for Qt Designer plugins. +# +# KDE4_AUTOMOC(file1 ... fileN) +# Call this if you want to have automatic moc file handling. +# This means if you include "foo.moc" in the source file foo.cpp +# a moc file for the header foo.h will be created automatically. +# You can set the property SKIP_AUTOMAKE using SET_SOURCE_FILES_PROPERTIES() +# to exclude some files in the list from being processed. +# If you don't want automoc, you can also use QT4_WRAP_CPP() or QT4_GENERATE_MOC() +# from FindQt4.cmake to have the moc files generated. This will be faster +# but require more manual work. +# +# KDE4_INSTALL_LIBTOOL_FILE ( subdir target ) +# This will create and install a simple libtool file for the +# given target. This might be required for other software. +# The libtool file will be install in subdir, relative to CMAKE_INSTALL_PREFIX . +# +# KDE4_CREATE_FINAL_FILES (filename_CXX filename_C file1 ... fileN) +# This macro is intended mainly for internal uses. +# It is used for enable-final. It will generate two source files, +# one for the C files and one for the C++ files. +# These files will have the names given in filename_CXX and filename_C. +# +# KDE4_ADD_PLUGIN ( name [WITH_PREFIX] file1 ... fileN ) +# Create a KDE plugin (KPart, kioslave, etc.) from the given source files. +# It supports KDE4_ENABLE_FINAL. +# If WITH_PREFIX is given, the resulting plugin will have the prefix "lib", otherwise it won't. +# It creates and installs an appropriate libtool la-file. +# +# KDE4_ADD_KDEINIT_EXECUTABLE (name [NOGUI] [RUN_UNINSTALLED] file1 ... fileN) +# Create a KDE application in the form of a module loadable via kdeinit. +# A library named kdeinit_ will be created and a small executable which links to it. +# It supports KDE4_ENABLE_FINAL +# If the executable has to be run from the buildtree (e.g. unit tests and code generators +# used later on when compiling), set the option RUN_UNINSTALLED. +# If the executable doesn't have a GUI, use the option NOGUI. By default on OS X +# application bundles are created, with the NOGUI option no bundles but simple executables +# are created. Currently it doesn't have any effect on other platforms. +# +# KDE4_ADD_EXECUTABLE (name [NOGUI] [RUN_UNINSTALLED] file1 ... fileN) +# Equivalent to ADD_EXECUTABLE(), but additionally adds support for KDE4_ENABLE_FINAL. +# If you don't need support for KDE4_ENABLE_FINAL, you can just use the +# normal ADD_EXECUTABLE(). +# If the executable has to be run from the buildtree (e.g. unit tests and code generators +# used later on when compiling), set the option RUN_UNINSTALLED. +# If the executable doesn't have a GUI, use the option NOGUI. By default on OS X +# application bundles are created, with the NOGUI option no bundles but simple executables +# are created. Currently it doesn't have any effect on other platforms. +# +# KDE4_ADD_LIBRARY (name [STATIC | SHARED | MODULE ] file1 ... fileN) +# Equivalent to ADD_LIBRARY(), but additionally it supports KDE4_ENABLE_FINAL +# and under Windows it adds a -DMAKE__LIB definition to the compilation. +# +# KDE4_INSTALL_ICONS( path theme) +# Installs all png and svgz files in the current directory to the icon +# directoy given in path, in the subdirectory for the given icon theme. +# +# KDE4_CREATE_HANDBOOK( docbookfile ) +# Create the handbook from the docbookfile (using meinproc) +# +# KDE4_INSTALL_HANDBOOK() +# Install the handbook documentation +# +# KDE4_CREATE_HTML_HANDBOOK( docbookfile ) +# Create HTML version of the handbook from the docbookfile (using meinproc) +# +# _KDE4_PLATFORM_INCLUDE_DIRS is used only internally +# _KDE4_PLATFORM_DEFINITIONS is used only internally +# +# +# Copyright (c) 2006, Alexander Neundorf +# Copyright (c) 2006, Laurent Montel, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. +# +# Modified by PhobosK + + +INCLUDE (MacroEnsureVersion) + +cmake_minimum_required(VERSION 2.4.3 FATAL_ERROR) + +set(QT_MIN_VERSION "4.2.0") +#this line includes FindQt4.cmake, which searches the Qt library and headers +find_package(Qt4 REQUIRED) + +if (NOT QT_DBUSXML2CPP_EXECUTABLE) + message(FATAL_ERROR "Qt4 qdbusxml2cpp was not found. Make sure it has been built and installed by Qt") +endif (NOT QT_DBUSXML2CPP_EXECUTABLE) + + +# Perl is required for building KDE software, +find_package(Perl REQUIRED) + +# remove once we require cmake >= 2.4.4, then the REQUIRED flag is honored by FindPerl.cmake, Alex +if(NOT PERL_FOUND) + message(FATAL_ERROR "Perl was not found. Make sure it has installed on your system") +endif(NOT PERL_FOUND) + +include (MacroLibrary) +include (CheckCXXCompilerFlag) + +#add some KDE specific stuff + +# the following are directories where stuff will be installed to +set(LIB_SUFFIX "" CACHE STRING "Define suffix of directory name (32/64)" ) + + +# this macro implements some very special logic how to deal with the cache +# by default the various install locations inherit their value from theit "parent" variable +# so if you set CMAKE_INSTALL_PREFIX, then EXEC_INSTALL_PREFIX, PLUGIN_INSTALL_DIR will +# calculate their value by appending subdirs to CMAKE_INSTALL_PREFIX +# this would work completely without using the cache. +# but if somebody wants e.g. a different EXEC_INSTALL_PREFIX this value has to go into +# the cache, otherwise it will be forgotten on the next cmake run. +# Once a variable is in the cache, it doesn't depend on its "parent" variables +# anymore and you can only change it by editing it directly. +# this macro helps in this regard, because as long as you don't set one of the +# variables explicitely to some location, it will always calculate its value from its +# parents. So modifying CMAKE_INSTALL_PREFIX later on will have the desired effect. +# But once you decide to set e.g. EXEC_INSTALL_PREFIX to some special location +# this will go into the cache and it will no longer depend on CMAKE_INSTALL_PREFIX. +macro(_SET_FANCY _var _value _comment) + if (NOT DEFINED ${_var}) + set(${_var} ${_value}) + else (NOT DEFINED ${_var}) + set(${_var} "${${_var}}" CACHE PATH "${_comment}") + endif (NOT DEFINED ${_var}) +endmacro(_SET_FANCY) + + +_set_fancy(SHARE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX}/share "Base directory for files which go to share/") +_set_fancy(EXEC_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX} "Base directory for executables and libraries") + +_set_fancy(BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin" "The install dir for executables (default ${EXEC_INSTALL_PREFIX}/bin)") +_set_fancy(SBIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/sbin" "The install dir for system executables (default ${EXEC_INSTALL_PREFIX}/sbin)") +_set_fancy(LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}" "The subdirectory relative to the install prefix where libraries will be installed (default is ${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX})") + +_set_fancy(LIBEXEC_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4/libexec" "The subdirectory relative to the install prefix where libraries will be installed (default is ${LIB_INSTALL_DIR}/kde4/libexec)") +_set_fancy(PLUGIN_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4" "The subdirectory relative to the install prefix where plugins will be installed (default is ${LIB_INSTALL_DIR}/kde4)") + +_set_fancy(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" "The subdirectory to the header prefix") +_set_fancy(CONFIG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config" "The config file install dir") +_set_fancy(DATA_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/apps" "The parent directory where applications can install their data") +_set_fancy(HTML_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/doc/HTML" "The HTML install dir for documentation") +_set_fancy(ICON_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/icons" "The icon install dir (default ${SHARE_INSTALL_PREFIX}/share/icons/)") +_set_fancy(KCFG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config.kcfg" "The install dir for kconfig files") +_set_fancy(LOCALE_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/locale" "The install dir for translations") +_set_fancy(MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mimelnk" "The install dir for the mimetype desktop files") +_set_fancy(SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/services" "The install dir for service (desktop, protocol, ...) files") +_set_fancy(SERVICETYPES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/servicetypes" "The install dir for servicestypes desktop files") +_set_fancy(SOUND_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/sounds" "The install dir for sound files") +_set_fancy(TEMPLATES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/templates" "The install dir for templates (Create new file...)") +_set_fancy(WALLPAPER_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/wallpapers" "The install dir for wallpapers") +_set_fancy(KCONF_UPDATE_INSTALL_DIR "${DATA_INSTALL_DIR}/kconf_update" "The kconf_update install dir") + # this one shouldn't be used anymore +_set_fancy(APPLNK_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/applnk" "Is this still used ?") +_set_fancy(AUTOSTART_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/autostart" "The install dir for autostart files") + +_set_fancy(XDG_APPS_DIR "${SHARE_INSTALL_PREFIX}/applications/kde" "The XDG apps dir") +_set_fancy(XDG_DIRECTORY_DIR "${SHARE_INSTALL_PREFIX}/desktop-directories" "The XDG directory") + +_set_fancy(SYSCONF_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/etc" "The kde sysconfig install dir (default /etc)") +_set_fancy(MAN_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/man" "The kde man install dir (default ${CMAKE_INSTALL_PREFIX}/man/)") +_set_fancy(INFO_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/info" "The kde info install dir (default ${CMAKE_INSTALL_PREFIX}/info)") +_set_fancy(DBUS_INTERFACES_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/interfaces" "The kde dbus interfaces install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/interfaces)") +# _set_fancy(LIBEXEC_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4/libexec" "The subdirectory relative to the install prefix where libraries will be installed (default is /lib)") +# _set_fancy(PLUGIN_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4/modules" "The subdirectory relative to the install prefix where plugins will be installed (default is ${KDE4_LIB_INSTALL_DIR}/kde4)") + + +################################# + + +# get the directory of the current file, used later on in the file +get_filename_component( kde_cmake_module_dir ${CMAKE_CURRENT_LIST_FILE} PATH) + +# the following are directories where stuff will be installed to + + +option(KDE4_ENABLE_FINAL "Enable final all-in-one compilation") +option(KDE4_BUILD_TESTS "Build the tests") + +if( KDE4_ENABLE_FINAL) + add_definitions(-DKDE_USE_FINAL) +endif(KDE4_ENABLE_FINAL) + +#Position-Independent-Executable is a feature of Binutils, Libc, and GCC that creates an executable +#which is something between a shared library and a normal executable. +#Programs compiled with these features appear as ?shared object? with the file command. +#info from "http://www.linuxfromscratch.org/hlfs/view/unstable/glibc/chapter02/pie.html" +option(KDE4_ENABLE_FPIE "Enable platform supports PIE linking") + +#now try to find some kde stuff + +#are we trying to compile kdelibs ? +#then enter bootstrap mode +if(EXISTS ${CMAKE_SOURCE_DIR}/kdecore/kernel/kglobal.h) + + message(STATUS "Building kdelibs...") + + set(KDE4_INCLUDE_DIR ${CMAKE_SOURCE_DIR}) + set(KDE4_KDECORE_LIBS ${QT_QTCORE_LIBRARY} kdecore) + set(KDE4_KDEUI_LIBS ${KDE4_KDECORE_LIBS} kdeui) + set(KDE4_KIO_LIBS ${KDE4_KDEUI_LIBS} kio) + set(KDE4_KPARTS_LIBS ${KDE4_KIO_LIBS} kparts) + set(KDE4_KUTILS_LIBS ${KDE4_KIO_LIBS} kutils) + set(KDE4_KDEFX_LIBS ${KDE4_KDEFX_LIBS} kdefx) + + + set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin ) + + if (WIN32) + set(LIBRARY_OUTPUT_PATH ${EXECUTABLE_OUTPUT_PATH} ) + # CMAKE_CFG_INTDIR is the output subdirectory created e.g. by XCode and MSVC + set(KDE4_KCFGC_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/kconfig_compiler ) + set(KDE4_MEINPROC_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/meinproc ) + set(KDE4_MAKEKDEWIDGETS_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/makekdewidgets ) + else (WIN32) + set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib ) + set(KDE4_KCFGC_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/kconfig_compiler.shell ) + set(KDE4_MEINPROC_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/meinproc.shell ) + set(KDE4_MAKEKDEWIDGETS_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/makekdewidgets.shell ) + endif (WIN32) + + set(KDE4_LIB_DIR ${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}) + + # when building kdelibs, make the kcfg rules depend on the binaries... + set( _KDE4_KCONFIG_COMPILER_DEP kconfig_compiler) + set( _KDE4_MAKEKDEWIDGETS_DEP makekdewidgets) + set( _KDE4_MEINPROC_EXECUTABLE_DEP meinproc) + + set(KDE4_INSTALLED_VERSION_OK TRUE) + +else(EXISTS ${CMAKE_SOURCE_DIR}/kdecore/kernel/kglobal.h) + + # ... but NOT otherwise + set( _KDE4_KCONFIG_COMPILER_DEP) + set( _KDE4_MAKEKDEWIDGETS_DEP) + set( _KDE4_MEINPROC_EXECUTABLE_DEP) + + # Check the version of kde. KDE4_KDECONFIG_EXECUTABLE was set by FindKDE4 + exec_program(${KDE4_KDECONFIG_EXECUTABLE} ARGS "--version" OUTPUT_VARIABLE kdeconfig_output ) + + string(REGEX MATCH "KDE: [0-9]+\\.[0-9]+\\.[0-9]+" KDEVERSION "${kdeconfig_output}") + if (KDEVERSION) + + string(REGEX REPLACE "^KDE: " "" KDEVERSION "${KDEVERSION}") + + # we need at least this version: + if (NOT KDE_MIN_VERSION) + set(KDE_MIN_VERSION "3.9.0") + endif (NOT KDE_MIN_VERSION) + + #message(STATUS "KDE_MIN_VERSION=${KDE_MIN_VERSION} found ${KDEVERSION}") + + macro_ensure_version( ${KDE_MIN_VERSION} ${KDEVERSION} KDE4_INSTALLED_VERSION_OK ) + + else (KDEVERSION) + message(FATAL_ERROR "Couldn't parse KDE version string from the kde4-config output:\n${kdeconfig_output}") + endif (KDEVERSION) + + + set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib ) + + # this file contains all dependencies of all libraries of kdelibs, Alex + include(${kde_cmake_module_dir}/KDELibsDependencies.cmake) + + find_library(KDE4_KDECORE_LIBRARY NAMES kdecore PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KDECORE_LIBS ${kdecore_LIB_DEPENDS} ${KDE4_KDECORE_LIBRARY} ) + + find_library(KDE4_KDEFX_LIBRARY NAMES kdefx PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KDEFX_LIBS ${kdefx_LIB_DEPENDS} ${KDE4_KDEFX_LIBRARY} ) + + find_library(KDE4_KDEUI_LIBRARY NAMES kdeui PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KDEUI_LIBS ${kdeui_LIB_DEPENDS} ${KDE4_KDEUI_LIBRARY} ) + + find_library(KDE4_KIO_LIBRARY NAMES kio PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KIO_LIBS ${kio_LIB_DEPENDS} ${KDE4_KIO_LIBRARY} ) + + find_library(KDE4_KPARTS_LIBRARY NAMES kparts PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KPARTS_LIBS ${kparts_LIB_DEPENDS} ${KDE4_KPARTS_LIBRARY} ) + + find_library(KDE4_KUTILS_LIBRARY NAMES kutils PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KUTILS_LIBS ${kutils_LIB_DEPENDS} ${KDE4_KUTILS_LIBRARY} ) + + find_library(KDE4_KDE3SUPPORT_LIBRARY NAMES kde3support PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KDE3SUPPORT_LIBS ${kde3support_LIB_DEPENDS} ${KDE4_KDE3SUPPORT_LIBRARY} ) + + find_library(KDE4_KHTML_LIBRARY NAMES khtml PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KHTML_LIBS ${khtml_LIB_DEPENDS} ${KDE4_KHTML_LIBRARY} ) + + find_library(KDE4_KJS_LIBRARY NAMES kjs PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KJS_LIBS ${kjs_LIB_DEPENDS} ${KDE4_KJS_LIBRARY} ) + + find_library(KDE4_KNEWSTUFF_LIBRARY NAMES knewstuff PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KNEWSTUFF_LIBS ${knewstuff_LIB_DEPENDS} ${KDE4_KNEWSTUFF_LIBRARY} ) + + find_library(KDE4_KDEPRINT_LIBRARY NAMES kdeprint PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KDEPRINT_LIBS ${kdeprint_LIB_DEPENDS} ${KDE4_KDEPRINT_LIBRARY} ) + + find_library(KDE4_KSPELL2_LIBRARY NAMES kspell2 PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KSPELL2_LIBS ${kspell2_LIB_DEPENDS} ${KDE4_KSPELL2_LIBRARY} ) + + if (UNIX) + find_library(KDE4_KDESU_LIBRARY NAMES kdesu PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KDESU_LIBS ${kdesu_LIB_DEPENDS} ${KDE4_KDESU_LIBRARY} ) + endif (UNIX) + + find_library(KDE4_KDNSSD_LIBRARY NAMES kdnssd PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KDNSSD_LIBS ${kdnssd_LIB_DEPENDS} ${KDE4_KDNSSD_LIBRARY} ) + + # now the KDE library directory, kxmlcore is new with KDE4 + find_library(KDE4_KXMLCORE_LIBRARY NAMES kxmlcore PATHS ${KDE4_LIB_INSTALL_DIR} ) + set(KDE4_KXMLCORE_LIBRARIES ${kxmlcore_LIB_DEPENDS} ${KDE4_KXMLCORE_LIBRARY} ) + + find_library(KDE4_PHONONCORE_LIBRARY NAMES phononcore PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_PHONONCORE_LIBS ${phononcore_LIB_DEPENDS} ${KDE4_PHONONCORE_LIBRARY} ) + + find_library(KDE4_PHONONUI_LIBRARY NAMES phononui PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_PHONONUI_LIBS ${phononui_LIB_DEPENDS} ${KDE4_PHONONUI_LIBRARY} ) + + find_library(KDE4_KAUDIODEVICELIST_LIBRARY NAMES kaudiodevicelist PATHS ${KDE4_LIB_INSTALL_DIR} NO_DEFAULT_PATH ) + set(KDE4_KAUDIODEVICELIST_LIBS ${kaudiodevicelist_LIB_DEPENDS} ${KDE4_KAUDIODEVICELIST_LIBRARY} ) + + find_library(KDE4_SOLID_LIBRARY NAMES solid PATHS ${KDE4_LIB_INSTALL_DIR} ) + set(KDE4_SOLID_LIBS ${solid_LIB_DEPENDS} ${KDE4_SOLID_LIBRARY} ) + + find_library(KDE4_SOLIDIFACES_LIBRARY NAMES solidifaces PATHS ${KDE4_LIB_INSTALL_DIR} ) + set(KDE4_SOLIDIFACES_LIBS ${solidifaces_LIB_DEPENDS} ${KDE4_SOLIDIFACES_LIBRARY} ) + + find_library(KDE4_THREADWEAVER_LIBRARY NAMES threadweaver PATHS ${KDE4_LIB_INSTALL_DIR} ) + set(KDE4_THREADWEAVER_LIBRARIES ${threadweaver_LIB_DEPENDS} ${KDE4_THREADWEAVER_LIBRARY} ) + + find_library(KDE4_KNOTIFYCONFIG_LIBRARY NAMES knotifyconfig PATHS ${KDE4_LIB_INSTALL_DIR} ) + set(KDE4_KNOTIFYCONFIG_LIBS ${knotifyconfig_LIB_DEPENDS} ${KDE4_KNOTIFYCONFIG_LIBRARY} ) + + find_library(KDE4_KROSSCORE_LIBRARY NAMES krosscore PATHS ${KDE4_LIB_INSTALL_DIR} ) + set(KDE4_KROSSCORE_LIBS ${krosscore_LIB_DEPENDS} ${KDE4_KROSSCORE_LIBRARY} ) + + find_library(KDE4_KTEXTEDITOR_LIBRARY NAMES ktexteditor PATHS ${KDE4_LIB_INSTALL_DIR} ) + set(KDE4_KTEXTEDITOR_LIBS ${ktexteditor_LIB_DEPENDS} ${KDE4_KTEXTEDITOR_LIBRARY} ) + + find_library(KDE4_KWALLETCLIENT_LIBRARY NAMES kwalletclient PATHS ${KDE4_LIB_INSTALL_DIR} ) + set(KDE4_KWALLETCLIENT_LIBS ${kwalletclient_LIB_DEPENDS} ${KDE4_KWALLETCLIENT_LIBRARY} ) + + get_filename_component(KDE4_LIB_DIR ${KDE4_KDECORE_LIBRARY} PATH ) + + + # at first the KDE include direcory + # kpassworddialog.h is new with KDE4 + find_path(KDE4_INCLUDE_DIR kpassworddialog.h + ${KDE4_INCLUDE_INSTALL_DIR} + $ENV{KDEDIR}/include + /opt/kde/include + /opt/kde4/include + /usr/local/include + /usr/include/ + /usr/include/kde + /usr/local/include/kde + ) + + find_program(KDE4_KCFGC_EXECUTABLE NAME kconfig_compiler PATHS + ${KDE4_BIN_INSTALL_DIR} + $ENV{KDEDIR}/bin + /opt/kde/bin + /opt/kde4/bin + NO_DEFAULT_PATH + ) + find_program(KDE4_KCFGC_EXECUTABLE NAME kconfig_compiler ) + + find_program(KDE4_MEINPROC_EXECUTABLE NAME meinproc PATHS + ${KDE4_BIN_INSTALL_DIR} + $ENV{KDEDIR}/bin + /opt/kde/bin + /opt/kde4/bin + NO_DEFAULT_PATH + ) + find_program(KDE4_MEINPROC_EXECUTABLE NAME meinproc ) + + find_program(KDE4_MAKEKDEWIDGETS_EXECUTABLE NAME makekdewidgets PATHS + ${KDE4_BIN_INSTALL_DIR} + $ENV{KDEDIR}/bin + /opt/kde/bin + /opt/kde4/bin + NO_DEFAULT_PATH + ) + find_program(KDE4_MAKEKDEWIDGETS_EXECUTABLE NAME makekdewidgets ) + +endif(EXISTS ${CMAKE_SOURCE_DIR}/kdecore/kernel/kglobal.h) + + +##################### and now the platform specific stuff ############################ + +# Set a default build type for single-configuration +# CMake generators if no build type is set. +if (NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE RelWithDebInfo) +endif (NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE) + + +if (WIN32) + + if(CYGWIN) + message(FATAL_ERROR "Support for Cygwin NOT yet implemented, please edit FindKDE4.cmake to enable it") + endif(CYGWIN) + + find_package(KDEWIN32 REQUIRED) + + # is GnuWin32 required or does e.g. Visual Studio provide an own implementation? + #find_package(GNUWIN32 REQUIRED) + find_package(GNUWIN32) + + set( _KDE4_PLATFORM_INCLUDE_DIRS ${KDEWIN32_INCLUDES} ${GNUWIN32_INCLUDE_DIR}) + + # if we are compiling kdelibs, add KDEWIN32_LIBRARIES explicitely, + # otherwise they come from KDELibsDependencies.cmake, Alex + if(EXISTS ${CMAKE_SOURCE_DIR}/kdecore/kernel/kglobal.h) + set( KDE4_KDECORE_LIBS ${KDE4_KDECORE_LIBS} ${KDEWIN32_LIBRARIES} ) + endif(EXISTS ${CMAKE_SOURCE_DIR}/kdecore/kernel/kglobal.h) + + # windows, mingw + if(MINGW) + #hmmm, something special to do here ? + endif(MINGW) + + # windows, microsoft compiler + if(MSVC) + set( _KDE4_PLATFORM_DEFINITIONS -DKDE_FULL_TEMPLATE_EXPORT_INSTANTIATION -DWIN32_LEAN_AND_MEAN -DUNICODE ) + # C4250: 'class1' : inherits 'class2::member' via dominance + set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4250" ) + # C4251: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2' + set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4251" ) + if(CMAKE_COMPILER_2005) + # to avoid a lot of deprecated warnings + add_definitions( -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE ) + # 'identifier' : no suitable definition provided for explicit template instantiation request + set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4661" ) + endif(CMAKE_COMPILER_2005) + endif(MSVC) + + + # for visual studio IDE set the path correctly for custom commands + # maybe under windows bat-files should be generated for running apps during the build + if(MSVC_IDE) + get_filename_component(PERL_LOCATION "${PERL_EXECUTABLE}" PATH) + file(TO_NATIVE_PATH "${PERL_LOCATION}" PERL_PATH_WINDOWS) + file(TO_NATIVE_PATH "${QT_BINARY_DIR}" QT_BIN_DIR_WINDOWS) + set(CMAKE_MSVCIDE_RUN_PATH "${PERL_PATH_WINDOWS}\;${QT_BIN_DIR_WINDOWS}" + CACHE STATIC "MSVC IDE Run path" FORCE) + endif(MSVC_IDE) + +endif (WIN32) + + +# also use /usr/local by default under UNIX, including Mac OS X +if (UNIX) + option(KDE4_USE_ALWAYS_FULL_RPATH "If set to TRUE, also libs and plugins will be linked with the full RPATH, which will usually make them work better, but make install will take longer." OFF) + + link_directories(/usr/local/lib) + set( _KDE4_PLATFORM_INCLUDE_DIRS /usr/local/include ) + + # the rest is RPATH handling + # here the defaults are set + # which are partly overwritten in kde4_handle_rpath_for_library() + # and kde4_handle_rpath_for_executable(), both located in KDE4Macros.cmake, Alex + if (APPLE) + set(CMAKE_INSTALL_NAME_DIR ${LIB_INSTALL_DIR}) + else (APPLE) + # add our LIB_INSTALL_DIR to the RPATH and use the RPATH figured out by cmake when compiling + set(CMAKE_INSTALL_RPATH ${LIB_INSTALL_DIR} ) + set(CMAKE_SKIP_BUILD_RPATH TRUE) + set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE) + set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) + endif (APPLE) +endif (UNIX) + + +# UNIX, except OS X +if (UNIX AND NOT APPLE) + # Done by FindQt4.cmake already + #find_package(X11 REQUIRED) + # UNIX has already set _KDE4_PLATFORM_INCLUDE_DIRS, so append + set(_KDE4_PLATFORM_INCLUDE_DIRS ${_KDE4_PLATFORM_INCLUDE_DIRS} ${X11_INCLUDE_DIR} ) +endif (UNIX AND NOT APPLE) + + +# This will need to be modified later to support either Qt/X11 or Qt/Mac builds +if (APPLE) + + set ( _KDE4_PLATFORM_DEFINITIONS -D__APPLE_KDE__ ) + + # we need to set MACOSX_DEPLOYMENT_TARGET to (I believe) at least 10.2 or maybe 10.3 to allow + # -undefined dynamic_lookup; in the future we should do this programmatically + # hmm... why doesn't this work? + set (ENV{MACOSX_DEPLOYMENT_TARGET} 10.3) + + # "-undefined dynamic_lookup" means we don't care about missing symbols at link-time by default + # this is bad, but unavoidable until there is the equivalent of libtool -no-undefined implemented + # or perhaps it already is, and I just don't know where to look ;) + + set (CMAKE_SHARED_LINKER_FLAGS "-single_module -multiply_defined suppress ${CMAKE_SHARED_LINKER_FLAGS}") + set (CMAKE_MODULE_LINKER_FLAGS "-multiply_defined suppress ${CMAKE_MODULE_LINKER_FLAGS}") + #set(CMAKE_SHARED_LINKER_FLAGS "-single_module -undefined dynamic_lookup -multiply_defined suppress") + #set(CMAKE_MODULE_LINKER_FLAGS "-undefined dynamic_lookup -multiply_defined suppress") + + # we profile... + if(CMAKE_BUILD_TYPE_TOLOWER MATCHES profile) + set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fprofile-arcs -ftest-coverage") + set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage") + endif(CMAKE_BUILD_TYPE_TOLOWER MATCHES profile) + + # removed -Os, was there a special reason for using -Os instead of -O2 ?, Alex + # optimization flags are set below for the various build types + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-common") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-common") +endif (APPLE) + + +if (CMAKE_SYSTEM_NAME MATCHES Linux) + if (CMAKE_COMPILER_IS_GNUCXX) + set ( _KDE4_PLATFORM_DEFINITIONS -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -D_GNU_SOURCE) + set ( CMAKE_SHARED_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_SHARED_LINKER_FLAGS}") + set ( CMAKE_MODULE_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_MODULE_LINKER_FLAGS}") + # we profile... + if(CMAKE_BUILD_TYPE_TOLOWER MATCHES profile) + set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fprofile-arcs -ftest-coverage") + set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage") + endif(CMAKE_BUILD_TYPE_TOLOWER MATCHES profile) + endif (CMAKE_COMPILER_IS_GNUCXX) + if (CMAKE_C_COMPILER MATCHES "icc") + set ( _KDE4_PLATFORM_DEFINITIONS -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -D_GNU_SOURCE) + set ( CMAKE_SHARED_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_SHARED_LINKER_FLAGS}") + set ( CMAKE_MODULE_LINKER_FLAGS "-Wl,--fatal-warnings -Wl,--no-undefined -lc ${CMAKE_MODULE_LINKER_FLAGS}") + endif (CMAKE_C_COMPILER MATCHES "icc") +endif (CMAKE_SYSTEM_NAME MATCHES Linux) + +if (CMAKE_SYSTEM_NAME MATCHES BSD) + set ( _KDE4_PLATFORM_DEFINITIONS -D_GNU_SOURCE ) + set ( CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -lc") + set ( CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -lc") +endif (CMAKE_SYSTEM_NAME MATCHES BSD) + +# compiler specific stuff, maybe this should be done differently, Alex + +if (MSVC) + set (KDE4_ENABLE_EXCEPTIONS -EHsc) +endif(MSVC) + +if (MINGW) + set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--export-all-symbols") + set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--export-all-symbols") +endif (MINGW) + +if (CMAKE_COMPILER_IS_GNUCXX) + set (KDE4_ENABLE_EXCEPTIONS -fexceptions) + # Select flags. + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g") + set(CMAKE_CXX_FLAGS_RELEASE "-O2") + set(CMAKE_CXX_FLAGS_DEBUG "-g -O2 -fno-reorder-blocks -fno-schedule-insns -fno-inline") + set(CMAKE_CXX_FLAGS_DEBUGFULL "-g3 -fno-inline") + set(CMAKE_CXX_FLAGS_PROFILE "-g3 -fno-inline -ftest-coverage -fprofile-arcs") + set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g") + set(CMAKE_C_FLAGS_RELEASE "-O2") + set(CMAKE_C_FLAGS_DEBUG "-g -O2 -fno-reorder-blocks -fno-schedule-insns -fno-inline") + set(CMAKE_C_FLAGS_DEBUGFULL "-g3 -fno-inline") + set(CMAKE_C_FLAGS_PROFILE "-g3 -fno-inline -ftest-coverage -fprofile-arcs") + + if (CMAKE_SYSTEM_NAME MATCHES Linux) + set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-long-long -ansi -Wundef -Wcast-align -Werror-implicit-function-declaration -Wchar-subscripts -Wall -W -Wpointer-arith -Wwrite-strings -Wformat-security -Wmissing-format-attribute -fno-common") + set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wnon-virtual-dtor -Wno-long-long -ansi -Wundef -Wcast-align -Wchar-subscripts -Wall -W -Wpointer-arith -Wformat-security -fno-exceptions -fno-check-new -fno-common") + endif (CMAKE_SYSTEM_NAME MATCHES Linux) + + + check_cxx_compiler_flag(-fPIE HAVE_FPIE_SUPPORT) + if(KDE4_ENABLE_FPIE) + if(HAVE_FPIE_SUPPORT) + set (KDE4_CXX_FPIE_FLAGS "-fPIE") + set (KDE4_PIE_LDFLAGS "-pie") + else(HAVE_FPIE_SUPPORT) + MESSAGE(STATUS "Your compiler doesn't support PIE flag") + endif(HAVE_FPIE_SUPPORT) + endif(KDE4_ENABLE_FPIE) + # visibility support + check_cxx_compiler_flag(-fvisibility=hidden __KDE_HAVE_GCC_VISIBILITY) + + # get the gcc version + exec_program(${CMAKE_C_COMPILER} ARGS --version OUTPUT_VARIABLE _gcc_version_info) + + string (REGEX MATCH "[345]\\.[0-9]\\.[0-9]" _gcc_version "${_gcc_version_info}") + # gcc on mac just reports: "gcc (GCC) 3.3 20030304 ..." without the patch level, handle this here: + if (NOT _gcc_version) + string (REGEX REPLACE ".*\\(GCC\\).* ([34]\\.[0-9]) .*" "\\1.0" _gcc_version "${_gcc_version_info}") + endif (NOT _gcc_version) + + macro_ensure_version("4.1.0" "${_gcc_version}" GCC_IS_NEWER_THAN_4_1) + + set(_GCC_COMPILED_WITH_BAD_ALLOCATOR FALSE) + if (GCC_IS_NEWER_THAN_4_1) + exec_program(${CMAKE_C_COMPILER} ARGS -v OUTPUT_VARIABLE _gcc_alloc_info) + string(REGEX MATCH "(--enable-libstdcxx-allocator=mt)" _GCC_COMPILED_WITH_BAD_ALLOCATOR "${_gcc_alloc_info}") + endif (GCC_IS_NEWER_THAN_4_1) + + if (__KDE_HAVE_GCC_VISIBILITY AND GCC_IS_NEWER_THAN_4_1 AND NOT _GCC_COMPILED_WITH_BAD_ALLOCATOR) + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -fvisibility-inlines-hidden") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden") + else (__KDE_HAVE_GCC_VISIBILITY AND GCC_IS_NEWER_THAN_4_1 AND NOT _GCC_COMPILED_WITH_BAD_ALLOCATOR) + set (__KDE_HAVE_GCC_VISIBILITY 0) + endif (__KDE_HAVE_GCC_VISIBILITY AND GCC_IS_NEWER_THAN_4_1 AND NOT _GCC_COMPILED_WITH_BAD_ALLOCATOR) + +endif (CMAKE_COMPILER_IS_GNUCXX) + +if (CMAKE_C_COMPILER MATCHES "icc") + set (KDE4_ENABLE_EXCEPTIONS -fexceptions) + # Select flags. + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g") + set(CMAKE_CXX_FLAGS_RELEASE "-O2") + set(CMAKE_CXX_FLAGS_DEBUG "-O2 -g -0b0 -noalign") + set(CMAKE_CXX_FLAGS_DEBUGFULL "-g -Ob0 -noalign") + set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g") + set(CMAKE_C_FLAGS_RELEASE "-O2") + set(CMAKE_C_FLAGS_DEBUG "-O2 -g -Ob0 -noalign") + set(CMAKE_C_FLAGS_DEBUGFULL "-g -Ob0 -noalign") + + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ansi -Wpointer-arith -fno-common") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ansi -Wpointer-arith -fno-exceptions -fno-common") + + # visibility support + set(__KDE_HAVE_ICC_VISIBILITY) +# check_cxx_compiler_flag(-fvisibility=hidden __KDE_HAVE_ICC_VISIBILITY) +# if (__KDE_HAVE_ICC_VISIBILITY) +# set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden") +# endif (__KDE_HAVE_ICC_VISIBILITY) + +endif (CMAKE_C_COMPILER MATCHES "icc") + +# we prefer to use a different postfix for debug libs only on Windows +# does not work atm +if (WIN32) + SET(CMAKE_DEBUG_POSTFIX "") +endif (WIN32) + +########### end of platform specific stuff ########################## + + +# KDE4Macros.cmake contains all the KDE specific macros +#include(${kde_cmake_module_dir}/KDE4Macros.cmake) +include(KDE4Macros) + + +# decide whether KDE4 has been found +set(KDE4_FOUND FALSE) +if (KDE4_INCLUDE_DIR AND KDE4_LIB_DIR AND KDE4_KCFGC_EXECUTABLE AND KDE4_INSTALLED_VERSION_OK) + set(KDE4_FOUND TRUE) +endif (KDE4_INCLUDE_DIR AND KDE4_LIB_DIR AND KDE4_KCFGC_EXECUTABLE AND KDE4_INSTALLED_VERSION_OK) + + +macro (KDE4_PRINT_RESULTS) + + # inside kdelibs the include dir and lib dir are internal, not "found" + if(NOT EXISTS ${CMAKE_SOURCE_DIR}/kdecore/kernel/kglobal.h) + if(KDE4_INCLUDE_DIR) + message(STATUS "Found KDE4 include dir: ${KDE4_INCLUDE_DIR}") + else(KDE4_INCLUDE_DIR) + message(STATUS "Didn't find KDE4 headers") + endif(KDE4_INCLUDE_DIR) + + if(KDE4_LIB_DIR) + message(STATUS "Found KDE4 library dir: ${KDE4_LIB_DIR}") + else(KDE4_LIB_DIR) + message(STATUS "Didn't find KDE4 core library") + endif(KDE4_LIB_DIR) + endif(NOT EXISTS ${CMAKE_SOURCE_DIR}/kdecore/kernel/kglobal.h) + + if(KDE4_KCFGC_EXECUTABLE) + message(STATUS "Found KDE4 kconfig_compiler preprocessor: ${KDE4_KCFGC_EXECUTABLE}") + else(KDE4_KCFGC_EXECUTABLE) + message(STATUS "Didn't find the KDE4 kconfig_compiler preprocessor") + endif(KDE4_KCFGC_EXECUTABLE) +endmacro (KDE4_PRINT_RESULTS) + + +if (KDE4Internal_FIND_REQUIRED AND NOT KDE4_FOUND) + #bail out if something wasn't found + kde4_print_results() + if (NOT KDE4_INSTALLED_VERSION_OK) + message(FATAL_ERROR "ERROR: the installed kdelibs version ${KDEVERSION} is too old, at least version ${KDE_MIN_VERSION} is required") + else (NOT KDE4_INSTALLED_VERSION_OK) + message(FATAL_ERROR "ERROR: could NOT find everything required for compiling KDE 4 programs") + endif (NOT KDE4_INSTALLED_VERSION_OK) +endif (KDE4Internal_FIND_REQUIRED AND NOT KDE4_FOUND) + + +if (NOT KDE4Internal_FIND_QUIETLY) + kde4_print_results() +endif (NOT KDE4Internal_FIND_QUIETLY) + +#add the found Qt and KDE include directories to the current include path +#the ${KDE4_INCLUDE_DIR}/KDE directory is for forwarding includes, eg. #include +set(KDE4_INCLUDES ${QT_INCLUDES} ${KDE4_INCLUDE_DIR} ${KDE4_INCLUDE_DIR}/KDE ${_KDE4_PLATFORM_INCLUDE_DIRS} ) + +set(KDE4_DEFINITIONS ${_KDE4_PLATFORM_DEFINITIONS} -DQT_NO_STL -DQT_NO_CAST_TO_ASCII -D_REENTRANT -DKDE_DEPRECATED_WARNINGS ) + +if (NOT _kde4_uninstall_rule_created) + set(_kde4_uninstall_rule_created TRUE) + + configure_file("${kde_cmake_module_dir}/kde4_cmake_uninstall.cmake.in" "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake" @ONLY) + + add_custom_target(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake") + +endif (NOT _kde4_uninstall_rule_created) diff --git a/cmakemodules/FindKDEWIN32.cmake b/cmakemodules/FindKDEWIN32.cmake new file mode 100644 index 0000000..afa8ee9 --- /dev/null +++ b/cmakemodules/FindKDEWIN32.cmake @@ -0,0 +1,89 @@ +# - Try to find the KDEWIN32 library +# Once done this will define +# +# KDEWIN32_FOUND - system has KDEWIN32 +# KDEWIN32_INCLUDES - the KDEWIN32 include directories +# KDEWIN32_LIBRARIES - The libraries needed to use KDEWIN32 +# +# Copyright (c) 2006, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +if (WIN32) + +file(TO_CMAKE_PATH "$ENV{PROGRAMFILES}" _program_FILES_DIR) + +if(NOT QT4_FOUND) + find_package(Qt4 REQUIRED) +endif(NOT QT4_FOUND) + +find_path(KDEWIN32_INCLUDE_DIR winposix_export.h + ${_program_FILES_DIR}/kdewin32/include ${CMAKE_INSTALL_PREFIX}/include +) + + +# at first find the kdewin32 library, this has to be compiled and installed before kdelibs/ +# search for kdewin32 in the default install directory for applications (default of (n)make install) + +set(KDEWIN32_LIBRARY_PATH ${_program_FILES_DIR}/kdewin32/lib) +find_library(KDEWIN32_LIBRARY_RELEASE NAMES kdewin32 + PATHS + ${KDEWIN32_LIBRARY_PATH} ${CMAKE_INSTALL_PREFIX}/lib +) + +# msvc makes a difference between debug and release +if(MSVC) + find_library(KDEWIN32_LIBRARY_DEBUG NAMES kdewin32d + PATHS + ${_program_FILES_DIR}/kdewin32/lib ${CMAKE_INSTALL_PREFIX}/lib + ) + if(MSVC_IDE) + # the ide needs the debug and release version + if( NOT KDEWIN32_LIBRARY_DEBUG OR NOT KDEWIN32_LIBRARY_RELEASE) + message(FATAL_ERROR "\nCould NOT find the debug AND release version of the KDEWIN32 library.\nYou need to have both to use MSVC projects.\nPlease build and install both kdelibs/win/ libraries first.\n") + endif( NOT KDEWIN32_LIBRARY_DEBUG OR NOT KDEWIN32_LIBRARY_RELEASE) + SET(KDEWIN32_LIBRARY optimized ${KDEWIN32_LIBRARY_RELEASE} debug ${KDEWIN32_LIBRARY_DEBUG}) + else(MSVC_IDE) + string(TOLOWER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_TOLOWER) + if(CMAKE_BUILD_TYPE_TOLOWER MATCHES debug) + set(KDEWIN32_LIBRARY ${KDEWIN32_LIBRARY_DEBUG}) + else(CMAKE_BUILD_TYPE_TOLOWER MATCHES debug) + set(KDEWIN32_LIBRARY ${KDEWIN32_LIBRARY_RELEASE}) + endif(CMAKE_BUILD_TYPE_TOLOWER MATCHES debug) + endif(MSVC_IDE) +else(MSVC) + set(KDEWIN32_LIBRARY ${KDEWIN32_LIBRARY_RELEASE}) +endif(MSVC) + +# kdelibs/win/ has to be built before the rest of kdelibs/ +# eventually it will be moved out from kdelibs/ +if (KDEWIN32_LIBRARY AND KDEWIN32_INCLUDE_DIR) + set(KDEWIN32_FOUND TRUE) + # add needed system libs + set(KDEWIN32_LIBRARIES ${KDEWIN32_LIBRARY} user32 shell32 ws2_32) + + if (MINGW) + #mingw compiler + set(KDEWIN32_INCLUDES ${KDEWIN32_INCLUDE_DIR} ${KDEWIN32_INCLUDE_DIR}/mingw ${QT_INCLUDES}) + else (MINGW) + # msvc compiler + # add the MS SDK include directory if available + file(TO_CMAKE_PATH "$ENV{MSSDK}" MSSDK_DIR) + set(KDEWIN32_INCLUDES ${KDEWIN32_INCLUDE_DIR} ${KDEWIN32_INCLUDE_DIR}/msvc ${QT_INCLUDES} ${MSSDK_DIR}) + endif (MINGW) + +endif (KDEWIN32_LIBRARY AND KDEWIN32_INCLUDE_DIR) + +if (KDEWIN32_FOUND) + if (NOT KDEWIN32_FIND_QUIETLY) + message(STATUS "Found KDEWIN32: ${KDEWIN32_LIBRARY}") + endif (NOT KDEWIN32_FIND_QUIETLY) +else (KDEWIN32_FOUND) + if (KDEWIN32_FIND_REQUIRED) + message(FATAL_ERROR "Could NOT find KDEWIN32 library\nPlease build and install kdelibs/win/ first") + endif (KDEWIN32_FIND_REQUIRED) +endif (KDEWIN32_FOUND) + +endif (WIN32) diff --git a/cmakemodules/FindKdeLibs.cmake b/cmakemodules/FindKdeLibs.cmake new file mode 100644 index 0000000..1259480 --- /dev/null +++ b/cmakemodules/FindKdeLibs.cmake @@ -0,0 +1,316 @@ +#INCLUDE(FindQt3) +#INCLUDE(FindQt) +#INCLUDE(FindKDE3) +INCLUDE(kdesvnMacros) +INCLUDE(KDE3Macros) + +FILE(GLOB GLOB_PATHS_INCLUDE /usr/lib*/qt-3*/include/) +FIND_PROGRAM(PKG_CONFIG NAMES pkg-config) +EXECUTE_PROCESS(COMMAND ${PKG_CONFIG} "--variable=prefix" "qt-mt" + OUTPUT_VARIABLE _qt_mt_path + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +SET(QT_MT_PATH ${_qt_mt_path} CACHE STRING "QT Path" FORCE) +FIND_PATH(QT_INCLUDE_DIR_PLUS qt.h + ${GLOB_PATHS_INCLUDE} + ${QT_MT_PATH}/include) +IF (NOT QT_INCLUDE_DIR) + SET(QT_INCLUDE_DIR ${QT_INCLUDE_DIR_PLUS}) +ENDIF (NOT QT_INCLUDE_DIR) + +FIND_PROGRAM(CMAKE_UNAME uname ${BIN_SEARCH_PATHES}) +IF(CMAKE_UNAME) + EXECUTE_PROCESS(COMMAND ${CMAKE_UNAME} "-m" + OUTPUT_VARIABLE CMAKE_SYSTEM_PROCESSOR + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + IF("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "64") + SET(LIB_SUFFIX "64" CACHE STRING "Define suffix of directory name (32/64)" FORCE) + ELSE("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "64") + SET(LIB_SUFFIX "" CACHE STRING "Define suffix of directory name (32/64)" FORCE) + ENDIF("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "64") +ENDIF(CMAKE_UNAME) + +SET(INCLUDE_SEARCH_PATHES + ${INCLUDE_SEARCH_PATHES} + ${KDE3_INCLUDE_DIRS}) + +SET(LIB_SEARCH_PATHES + ${LIB_SEARCH_PATHES} + ${KDE3_LIB_DIR}) + +IF (LIB_SUFFIX) + SET(LIB_SEARCH_PATHES + $ENV{KDEDIR}/lib${LIB_SUFFIX} + $ENV{HOME}/lib${LIB_SUFFIX} + $ENV{HOME}/usr/lib${LIB_SUFFIX} + /opt/lib${LIB_SUFFIX} + /opt/kde/lib${LIB_SUFFIX} + /opt/kde3/lib${LIB_SUFFIX} + /usr/lib${LIB_SUFFIX} + /usr/kde/3.5/lib${LIB_SUFFIX} + /usr/local/lib${LIB_SUFFIX} + ${LIB_SEARCH_PATHES} + ) +ENDIF (LIB_SUFFIX) + + + +FIND_LIBRARY(M_LIBRARY NAMES m + PATHS + ${LIB_SEARCH_PATHES} +) + +FIND_LIBRARY(KDE3_UI_LIBRARY NAMES kdeui + PATHS + ${LIB_SEARCH_PATHES} +) + +FIND_LIBRARY(KDE3_PART_LIBRARY NAMES kparts + PATHS + ${LIB_SEARCH_PATHES} +) + +FIND_LIBRARY(KDE3_KIO_LIBRARY NAMES kio + PATHS + ${LIB_SEARCH_PATHES} +) + +FIND_LIBRARY(KDE3_KHTML_LIBRARY NAMES khtml + PATHS + ${LIB_SEARCH_PATHES} +) + +FIND_LIBRARY(KDE3_DCOP_LIBRARY NAMES DCOP + PATHS + ${LIB_SEARCH_PATHES} +) + +FIND_PROGRAM(KDE3_KDECONFIG_EXECUTABLE NAME kde-config + PATHS ${BIN_SEARCH_PATHES}) + +FIND_PROGRAM(MSGFMT + NAMES gmsgfmt msgfmt + PATHS ${BIN_SEARCH_PATHES}) + + +FIND_PROGRAM(STRIP + NAMES strip + PATHS ${BIN_SEARCH_PATHES}) + +FIND_PROGRAM(KDE3_MEINPROC_EXECUTABLE NAME meinproc + PATHS ${BIN_SEARCH_PATHES}) + +IF(KDE3_MEINPROC_EXECUTABLE) + MESSAGE(STATUS "Found meinproc: ${KDE3_MEINPROC_EXECUTABLE}") +ELSE(KDE3_MEINPROC_EXECUTABLE) + MESSAGE(FATAL_ERROR "Could NOT find meinproc program!") +ENDIF(KDE3_MEINPROC_EXECUTABLE) + +IF(MSGFMT) + EXECUTE_PROCESS(COMMAND ${MSGFMT} "--version" + OUTPUT_VARIABLE _msgout + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + STRING(REGEX MATCH "GNU[\t ]gettext" _isgnu "${_msgout}") + IF (NOT _isgnu) + MESSAGE(STATUS "No gnu msgfmt found!") + SET(MSGFMT ":" CACHE STRING "Msgfmt program") + ELSE(NOT _isgnu) + MESSAGE(STATUS "Found gnu msgfmt: ${MSGFMT}") + ENDIF (NOT _isgnu) +ELSE(MSGFMT) + SET(MSGFMT ":" CACHE STRING "Msgfmt program") + MESSAGE( FATAL_ERROR "Could NOT find msgfmt program") +ENDIF(MSGFMT) + +EXECUTE_PROCESS(COMMAND ${KDE3_KDECONFIG_EXECUTABLE} "--prefix" + COMMAND xargs "echo" "-n" + OUTPUT_VARIABLE _kde_prefix_path + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +SET(KDE_HTML_COMMON_PATH ${_kde_prefix_path}/share/doc/HTML/en/common CACHE STRING "KDE HTML common Path" FORCE) + +# 'cause my own defines were not good I take them from kde4 trunk +#add some KDE specific stuff +SET(SHARE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX}/share CACHE PATH "Base directory for files which go to share/" FORCE) +SET(EXEC_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX} CACHE PATH "Base directory for executables and libraries" FORCE) +# +## the following are directories where stuff will be installed to +SET(BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin" CACHE PATH "The kde bin install dir (default prefix/bin)" FORCE) +SET(SBIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/sbin" CACHE PATH "The kde sbin install dir (default prefix/sbin)" FORCE) +SET(LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}" CACHE PATH "The subdirectory relative to the install prefix where libraries will be installed (default is /lib${LIB_SUFFIX})" FORCE) +SET(LIBEXEC_INSTALL_DIR "${LIB_INSTALL_DIR}/kde3/libexec" CACHE PATH "The subdirectory relative to the install prefix where libraries will be installed (default is /lib/kde3/libexec)" FORCE) +SET(PLUGIN_INSTALL_DIR "${LIB_INSTALL_DIR}/kde3" CACHE PATH "The subdirectory relative to the install prefix where plugins will be installed (default is ${LIB_INSTALL_DIR}/kde3)" FORCE) +SET(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "The subdirectory to the header prefix" FORCE) +SET(CONFIG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config" CACHE PATH "The config file install dir" FORCE) +SET(DATA_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/apps" CACHE PATH "The parent directory where applications can install their data" FORCE) +SET(HTML_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/doc/HTML" CACHE PATH "The HTML install dir for documentation" FORCE) +SET(ICON_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/icons" CACHE PATH "The icon install dir (default prefix/share/icons/)" FORCE) +SET(KCFG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config.kcfg" CACHE PATH "The install dir for kconfig files" FORCE) +SET(LOCALE_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/locale" CACHE PATH "The install dir for translations" FORCE) +SET(MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mimelnk" CACHE PATH "The install dir for the mimetype desktop files" FORCE) +SET(SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/services" CACHE PATH "The install dir for service (desktop, protocol, ...) files" FORCE) +SET(SERVICETYPES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/servicetypes" CACHE PATH "The install dir for servicestypes desktop files" FORCE) +SET(SOUND_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/sounds" CACHE PATH "The install dir for sound files" FORCE) +SET(TEMPLATES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/templates" CACHE PATH "The install dir for templates (Create new file...)" FORCE) +SET(WALLPAPER_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/wallpapers" CACHE PATH "The install dir for wallpapers" FORCE) +SET(KCONF_UPDATE_INSTALL_DIR "${DATA_INSTALL_DIR}/kconf_update" CACHE PATH "The kconf_update install dir" FORCE) +# this one shouldn't be used anymore +SET(APPLNK_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/applnk" CACHE PATH "Is this still used ?" FORCE) +SET(AUTOSTART_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/autostart" CACHE PATH "The install dir for autostart files" FORCE) +SET(XDG_APPS_DIR "${SHARE_INSTALL_PREFIX}/applications/kde" CACHE PATH "The XDG apps dir" FORCE) +SET(XDG_DIRECTORY_DIR "${SHARE_INSTALL_PREFIX}/desktop-directories" CACHE PATH "The XDG directory" FORCE) +SET(SYSCONF_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/etc" CACHE PATH "The kde sysconfig install dir (default/etc)" FORCE) +SET(MAN_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/man" CACHE PATH "The kde man install dir (default prefix/share/man/)" FORCE) +SET(INFO_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/info" CACHE PATH "The kde info install dir (default prefix/info)" FORCE) + +# linker flags - must get checked +SET(LINK_NO_UNDEFINED "") +SET(lundef "-Wl,--no-undefined") +KDESVN_CHECK_LINK_FLAG(${lundef} _NO_UNDEFINED) +IF (_NO_UNDEFINED) + SET(LINK_NO_UNDEFINED "${lundef}") +ENDIF (_NO_UNDEFINED) + +SET(lundef "-Wl,--allow-shlib-undefined") +KDESVN_CHECK_LINK_FLAG(${lundef} _ALLOW_SHLIB) +IF (_ALLOW_SHLIB) + SET(LINK_NO_UNDEFINED "${LINK_NO_UNDEFINED} ${lundef}") +ENDIF (_ALLOW_SHLIB) + + +# own macros +MACRO(KDESVN_INSTALL_ICONS _theme) + + FILE(GLOB _icons *.png) + FILE(GLOB _svg *svgz) + SET(_icons ${_icons} ${_svg}) + FOREACH(_current_ICON ${_icons} ) + GET_FILENAME_COMPONENT(_ctype ${_current_ICON} EXT) + + IF (${_ctype} STREQUAL ".png") + STRING(REGEX REPLACE "^.*/[a-zA-Z]+([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\1" _size "${_current_ICON}") + STRING(REGEX REPLACE "^.*/[a-zA-Z]+([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\2" _group "${_current_ICON}") + STRING(REGEX REPLACE "^.*/[a-zA-Z]+([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\3" _name "${_current_ICON}") + SET(_sizestring "${_size}x${_size}") + ENDIF (${_ctype} STREQUAL ".png") + + IF (${_ctype} STREQUAL ".svgz") + STRING(REGEX REPLACE "^.*/[a-zA-Z]+\\-([a-z]+)\\-(.+\\.svgz)$" "\\1" _group "${_current_ICON}") + STRING(REGEX REPLACE "^.*/[a-zA-Z]+\\-([a-z]+)\\-(.+\\.svgz)$" "\\2" _name "${_current_ICON}") + SET(_sizestring "scalable") + ENDIF (${_ctype} STREQUAL ".svgz") + + SET(_icon_GROUP "actions") + + IF(${_group} STREQUAL "mime") + SET(_icon_GROUP "mimetypes") + ENDIF(${_group} STREQUAL "mime") + + IF(${_group} STREQUAL "filesys") + SET(_icon_GROUP "filesystems") + ENDIF(${_group} STREQUAL "filesys") + + IF(${_group} STREQUAL "device") + SET(_icon_GROUP "devices") + ENDIF(${_group} STREQUAL "device") + + IF(${_group} STREQUAL "app") + SET(_icon_GROUP "apps") + ENDIF(${_group} STREQUAL "app") + + IF(${_group} STREQUAL "action") + SET(_icon_GROUP "actions") + ENDIF(${_group} STREQUAL "action") + + #message(STATUS "icon: ${_current_ICON} size: ${_sizestring} group: ${_group} name: ${_name}" ) + SET(_ICON_INSTALL_DIR ${ICON_INSTALL_DIR}/${_theme}/${_sizestring}/${_icon_GROUP}) + + INSTALL(FILES ${_current_ICON} DESTINATION ${_ICON_INSTALL_DIR} RENAME ${_name}) + + ENDFOREACH (_current_ICON) +ENDMACRO(KDESVN_INSTALL_ICONS) + +MACRO(ADD_POFILES packagename) + SET(_gmofiles) + FILE(GLOB _pofiles *.po) + + FOREACH(_current_po ${_pofiles}) + GET_FILENAME_COMPONENT(_name ${_current_po} NAME_WE) + STRING(REGEX REPLACE "^.*/([a-zA-Z]+)(\\.po)" "\\1" _lang "${_current_po}") + SET(_gmofile "${CMAKE_CURRENT_BINARY_DIR}/${_name}.gmo") + ADD_CUSTOM_COMMAND(OUTPUT ${_gmofile} + COMMAND ${MSGFMT} + ARGS "-o" "${_gmofile}" "${_current_po}" + DEPENDS ${_current_po} + ) + SET(_gmofiles ${_gmofiles} ${_gmofile}) + INSTALL(FILES ${_gmofile} + DESTINATION ${LOCALE_INSTALL_DIR}/${_lang}/LC_MESSAGES + RENAME ${packagename}.mo) + ENDFOREACH(_current_po ${_pofiles}) + + ADD_CUSTOM_TARGET(translations ALL + DEPENDS ${_gmofiles}) + +ENDMACRO(ADD_POFILES) + + +# KDE3_CREATE_HANDBOOK( docbookfile ) +# Create the handbook from the docbookfile (using meinproc) +MACRO (KDE3_CREATE_HANDBOOK _docbook ) + GET_FILENAME_COMPONENT(_tmp_src_FILE ${CMAKE_CURRENT_SOURCE_DIR} ABSOLUTE) + GET_FILENAME_COMPONENT(_tmp_bin_FILE ${CMAKE_CURRENT_BINARY_DIR} ABSOLUTE) + + IF(EXISTS ${_tmp_src_FILE}/${_docbook}) + get_filename_component(_input ${_tmp_src_FILE}/${_docbook} ABSOLUTE) + ENDIF(EXISTS ${_tmp_src_FILE}/${_docbook}) + IF(EXISTS ${_tmp_bin_FILE}/${_docbook}) + get_filename_component(_input ${_tmp_bin_FILE}/${_docbook} ABSOLUTE) + ENDIF(EXISTS ${_tmp_bin_FILE}/${_docbook}) + + SET(_doc ${CMAKE_CURRENT_BINARY_DIR}/index.cache.bz2) + ADD_CUSTOM_COMMAND(OUTPUT ${_doc} + COMMAND ${KDE3_MEINPROC_EXECUTABLE} --check --cache ${_doc} ${_input} + DEPENDS ${_input} ${KDE3_MEINPROC_EXECUTABLE} + ) + ADD_CUSTOM_TARGET(handbook ALL DEPENDS ${_doc}) +ENDMACRO (KDE3_CREATE_HANDBOOK) + + +# KDE3_INSTALL_HANDBOOK() +# Install the handbook documentation +MACRO (KDE3_INSTALL_HANDBOOK _appname ) + GET_FILENAME_COMPONENT(_tmp_src_FILE ${CMAKE_CURRENT_SOURCE_DIR} ABSOLUTE) + GET_FILENAME_COMPONENT(_tmp_bin_FILE ${CMAKE_CURRENT_BINARY_DIR} ABSOLUTE) + GET_FILENAME_COMPONENT(_basename ${_tmp_src_FILE} NAME_WE) + SET( dirname ${_basename}/${_appname}) + + FILE(GLOB _books_bin ${_tmp_bin_FILE}/*.docbook) + FILE(GLOB _images_bin ${_tmp_bin_FILE}/*.png) + FILE(GLOB _books_src ${_tmp_src_FILE}/*.docbook) + FILE(GLOB _images_src ${_tmp_src_FILE}/*.png) + + INSTALL( FILES ${CMAKE_CURRENT_BINARY_DIR}/index.cache.bz2 ${_books_src} ${_books_bin} ${_images_src} ${_images_bin} + DESTINATION ${HTML_INSTALL_DIR}/${dirname} ) + + INSTALL( CODE "EXECUTE_PROCESS ( COMMAND /bin/ln -s \"${KDE_HTML_COMMON_PATH}\" \"$ENV{DESTDIR}${HTML_INSTALL_DIR}/${dirname}/common\" ERROR_QUIET )" ) + INSTALL( CODE "MESSAGE(STATUS \"Installing $ENV{DESTDIR}${HTML_INSTALL_DIR}/${dirname}/common\")" ) + INSTALL( CODE "FILE(APPEND ${CMAKE_BINARY_DIR}/uninstall_plus.cmake \"IF(EXISTS \\\"$ENV{DESTDIR}${HTML_INSTALL_DIR}/${dirname}/common\\\")\\n\")" ) + INSTALL( CODE "FILE(APPEND ${CMAKE_BINARY_DIR}/uninstall_plus.cmake \"MESSAGE(STATUS \\\"Uninstalling \\\\\\\"$ENV{DESTDIR}${HTML_INSTALL_DIR}/${dirname}/common\\\\\\\"\\\")\\n\")" ) + INSTALL( CODE "FILE(APPEND ${CMAKE_BINARY_DIR}/uninstall_plus.cmake \"ENDIF(EXISTS \\\"$ENV{DESTDIR}${HTML_INSTALL_DIR}/${dirname}/common\\\")\\n\")" ) + INSTALL( CODE "FILE(APPEND ${CMAKE_BINARY_DIR}/uninstall_plus.cmake \"FILE(REMOVE \\\"$ENV{DESTDIR}${HTML_INSTALL_DIR}/${dirname}/common\\\")\\n\")" ) + + # Specific for KBFX code - remove for other installs + FILE(GLOB _docbook_PNGFILES ${CMAKE_SOURCE_DIR}/skin/raster/default/*.png) + FOREACH(_p ${_docbook_PNGFILES}) + GET_FILENAME_COMPONENT(_png_name ${_p} NAME) + INSTALL( CODE "EXECUTE_PROCESS ( COMMAND /bin/ln -s \"${DATA_INSTALL_DIR}/kbfx/skins/default/${_png_name}\" \"$ENV{DESTDIR}${HTML_INSTALL_DIR}/${dirname}\" ERROR_QUIET )" ) + INSTALL( CODE "MESSAGE(STATUS \"Installing $ENV{DESTDIR}${HTML_INSTALL_DIR}/${dirname}/${_png_name}\")" ) + INSTALL( CODE "FILE(APPEND ${CMAKE_BINARY_DIR}/uninstall_plus.cmake \"MESSAGE(STATUS \\\"Uninstalling \\\\\\\"$ENV{DESTDIR}${HTML_INSTALL_DIR}/${dirname}/${_png_name}\\\\\\\"\\\")\\n\")" ) + INSTALL( CODE "FILE(APPEND ${CMAKE_BINARY_DIR}/uninstall_plus.cmake \"FILE(REMOVE \\\"$ENV{DESTDIR}${HTML_INSTALL_DIR}/${dirname}/${_png_name}\\\")\\n\")" ) + ENDFOREACH(_p) + # End of specific for KBFX code +ENDMACRO (KDE3_INSTALL_HANDBOOK ) + diff --git a/cmakemodules/FindQt4.cmake b/cmakemodules/FindQt4.cmake new file mode 100644 index 0000000..8f3be9c --- /dev/null +++ b/cmakemodules/FindQt4.cmake @@ -0,0 +1,1081 @@ +# - Find QT 4 +# This module can be used to find Qt4. +# The most important issue is that the Qt4 qmake is available via the system path. +# This qmake is then used to detect basically everything else. +# This module defines a number of key variables and macros. First is +# QT_USE_FILE which is the path to a CMake file that can be included to compile +# Qt 4 applications and libraries. By default, the QtCore and QtGui +# libraries are loaded. This behavior can be changed by setting one or more +# of the following variables to true: +# QT_DONT_USE_QTCORE +# QT_DONT_USE_QTGUI +# QT_USE_QT3SUPPORT +# QT_USE_QTASSISTANT +# QT_USE_QTDESIGNER +# QT_USE_QTMOTIF +# QT_USE_QTMAIN +# QT_USE_QTNETWORK +# QT_USE_QTNSPLUGIN +# QT_USE_QTOPENGL +# QT_USE_QTSQL +# QT_USE_QTXML +# QT_USE_QTSVG +# QT_USE_QTTEST +# QT_USE_QTUITOOLS +# QT_USE_QTDBUS +# +# All the libraries required are stored in a variable called QT_LIBRARIES. +# Add this variable to your TARGET_LINK_LIBRARIES. +# +# macro QT4_WRAP_CPP(outfiles inputfile ... ) +# macro QT4_WRAP_UI(outfiles inputfile ... ) +# macro QT4_ADD_RESOURCE(outfiles inputfile ... ) +# macro QT4_AUTOMOC(inputfile ... ) +# macro QT4_GENERATE_MOC(inputfile outputfile ) +# +# macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename) +# create a the interface header and implementation files with the +# given basename from the given interface xml file and add it to +# the list of sources +# +# macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... ) +# create the interface header and implementation files +# for all listed interface xml files +# the name will be automatically determined from the name of the xml file +# +# macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname [basename] ) +# create a dbus adaptor (header and implementation file) from the xml file +# describing the interface, and add it to the list of sources. The adaptor +# forwards the calls to a parent class, defined in parentheader and named +# parentclassname. The name of the generated files will be +# adaptor.{cpp,h} where basename is the basename of the xml file. +# +# macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] ) +# generate the xml interface file from the given header. +# If the optional argument interfacename is omitted, the name of the +# interface file is constructed from the basename of the header with +# the suffix .xml appended. +# +# QT_FOUND If false, don't try to use Qt. +# QT4_FOUND If false, don't try to use Qt 4. +# +# QT_QTCORE_FOUND True if QtCore was found. +# QT_QTGUI_FOUND True if QtGui was found. +# QT_QT3SUPPORT_FOUND True if Qt3Support was found. +# QT_QTASSISTANT_FOUND True if QtAssistant was found. +# QT_QTDBUS_FOUND True if QtDBus was found. +# QT_QTDESIGNER_FOUND True if QtDesigner was found. +# QT_QTDESIGNERCOMPONENTS True if QtDesignerComponents was found. +# QT_QTMOTIF_FOUND True if QtMotif was found. +# QT_QTNETWORK_FOUND True if QtNetwork was found. +# QT_QTNSPLUGIN_FOUND True if QtNsPlugin was found. +# QT_QTOPENGL_FOUND True if QtOpenGL was found. +# QT_QTSQL_FOUND True if QtSql was found. +# QT_QTXML_FOUND True if QtXml was found. +# QT_QTSVG_FOUND True if QtSvg was found. +# QT_QTTEST_FOUND True if QtTest was found. +# QT_QTUITOOLS_FOUND True if QtUiTools was found. +# +# QT_DEFINITIONS Definitions to use when compiling code that uses Qt. +# +# QT_INCLUDES List of paths to all include directories of +# Qt4 QT_INCLUDE_DIR and QT_QTCORE_INCLUDE_DIR are +# always in this variable even if NOTFOUND, +# all other INCLUDE_DIRS are +# only added if they are found. +# +# QT_INCLUDE_DIR Path to "include" of Qt4 +# QT_QT_INCLUDE_DIR Path to "include/Qt" +# QT_QT3SUPPORT_INCLUDE_DIR Path to "include/Qt3Support" +# QT_QTASSISTANT_INCLUDE_DIR Path to "include/QtAssistant" +# QT_QTCORE_INCLUDE_DIR Path to "include/QtCore" +# QT_QTDESIGNER_INCLUDE_DIR Path to "include/QtDesigner" +# QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR Path to "include/QtDesigner" +# QT_QTDBUS_INCLUDE_DIR Path to "include/QtDBus" +# QT_QTGUI_INCLUDE_DIR Path to "include/QtGui" +# QT_QTMOTIF_INCLUDE_DIR Path to "include/QtMotif" +# QT_QTNETWORK_INCLUDE_DIR Path to "include/QtNetwork" +# QT_QTNSPLUGIN_INCLUDE_DIR Path to "include/QtNsPlugin" +# QT_QTOPENGL_INCLUDE_DIR Path to "include/QtOpenGL" +# QT_QTSQL_INCLUDE_DIR Path to "include/QtSql" +# QT_QTXML_INCLUDE_DIR Path to "include/QtXml" +# QT_QTSVG_INCLUDE_DIR Path to "include/QtSvg" +# QT_QTTEST_INCLUDE_DIR Path to "include/QtTest" +# +# QT_LIBRARY_DIR Path to "lib" of Qt4 +# +# QT_PLUGINS_DIR Path to "plugins" for Qt4 +# +# For every library of Qt, a QT_QTFOO_LIBRARY variable is defined, with the full path to the library. +# +# So there are the following variables: +# The Qt3Support library: QT_QT3SUPPORT_LIBRARY +# +# The QtAssistant library: QT_QTASSISTANT_LIBRARY +# +# The QtCore library: QT_QTCORE_LIBRARY +# +# The QtDBus library: QT_QTDBUS_LIBRARY +# +# The QtDesigner library: QT_QTDESIGNER_LIBRARY +# +# The QtDesignerComponents library: QT_QTDESIGNERCOMPONENTS_LIBRARY +# +# The QtGui library: QT_QTGUI_LIBRARY +# +# The QtMotif library: QT_QTMOTIF_LIBRARY +# +# The QtNetwork library: QT_QTNETWORK_LIBRARY +# +# The QtNsPLugin library: QT_QTNSPLUGIN_LIBRARY +# +# The QtOpenGL library: QT_QTOPENGL_LIBRARY +# +# The QtSql library: QT_QTSQL_LIBRARY +# +# The QtXml library: QT_QTXML_LIBRARY +# +# The QtSvg library: QT_QTSVG_LIBRARY +# +# The QtTest library: QT_QTTEST_LIBRARY +# +# The qtmain library for Windows QT_QTMAIN_LIBRARY +# +# The QtUiTools library: QT_QTUITOOLS_LIBRARY +# +# also defined, but NOT for general use are +# QT_MOC_EXECUTABLE Where to find the moc tool. +# QT_UIC_EXECUTABLE Where to find the uic tool. +# QT_UIC3_EXECUTABLE Where to find the uic3 tool. +# QT_RCC_EXECUTABLE Where to find the rcc tool +# QT_DBUSCPP2XML_EXECUTABLE Where to find the qdbuscpp2xml tool. +# QT_DBUSXML2CPP_EXECUTABLE Where to find the qdbusxml2cpp tool. +# +# QT_DOC_DIR Path to "doc" of Qt4 +# QT_MKSPECS_DIR Path to "mkspecs" of Qt4 +# +# +# These are around for backwards compatibility +# they will be set +# QT_WRAP_CPP Set true if QT_MOC_EXECUTABLE is found +# QT_WRAP_UI Set true if QT_UIC_EXECUTABLE is found +# +# These variables do _NOT_ have any effect anymore (compared to FindQt.cmake) +# QT_MT_REQUIRED Qt4 is now always multithreaded +# +# These variables are set to "" Because Qt structure changed +# (They make no sense in Qt4) +# QT_QT_LIBRARY Qt-Library is now split + +# Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. +# See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. + + +INCLUDE(CheckSymbolExists) +INCLUDE(MacroAddFileDependencies) + +SET(QT_USE_FILE ${CMAKE_ROOT}/Modules/UseQt4.cmake) + +SET( QT_DEFINITIONS "") + +IF (WIN32) + SET(QT_DEFINITIONS -DQT_DLL) +ENDIF(WIN32) + +SET(QT4_INSTALLED_VERSION_TOO_OLD FALSE) + +# macro for asking qmake to process pro files +MACRO(QT_QUERY_QMAKE outvar invar) + FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake/tmp.pro + "message(CMAKE_MESSAGE<$$${invar}>)") + + EXECUTE_PROCESS(COMMAND ${QT_QMAKE_EXECUTABLE} + WORKING_DIRECTORY + ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake + OUTPUT_VARIABLE _qmake_query_output + ERROR_VARIABLE _qmake_query_output ) + + FILE(REMOVE_RECURSE + "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmpQmake") + + STRING(REGEX REPLACE ".*CMAKE_MESSAGE<([^>]*).*" "\\1" ${outvar} "${_qmake_query_output}") +ENDMACRO(QT_QUERY_QMAKE) + +# check for qmake +FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake qmake4 qmake-qt4 PATHS + "[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin" + "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin" + $ENV{QTDIR}/bin +) + +IF (QT_QMAKE_EXECUTABLE) + + SET(QT4_QMAKE_FOUND FALSE) + + EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE} ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION) + + # check for qt3 qmake and then try and find qmake4 or qmake-qt4 in the path + IF("${QTVERSION}" MATCHES "Unknown") + SET(QT_QMAKE_EXECUTABLE NOTFOUND CACHE FILEPATH "" FORCE) + FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake4 qmake-qt4 PATHS + "[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin" + "[HKEY_CURRENT_USER\\Software\\Trolltech\\Versions\\4.0.0;InstallDir]/bin" + $ENV{QTDIR}/bin + ) + IF(QT_QMAKE_EXECUTABLE) + EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE} + ARGS "-query QT_VERSION" OUTPUT_VARIABLE QTVERSION) + ENDIF(QT_QMAKE_EXECUTABLE) + ENDIF("${QTVERSION}" MATCHES "Unknown") + + # check that we found the Qt4 qmake, Qt3 qmake output won't match here + STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" qt_version_tmp "${QTVERSION}") + IF (qt_version_tmp) + + # we need at least version 4.0.0 + IF (NOT QT_MIN_VERSION) + SET(QT_MIN_VERSION "4.0.0") + ENDIF (NOT QT_MIN_VERSION) + + #now parse the parts of the user given version string into variables + STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" req_qt_major_vers "${QT_MIN_VERSION}") + IF (NOT req_qt_major_vers) + MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", expected e.g. \"4.0.1\"") + ENDIF (NOT req_qt_major_vers) + + # now parse the parts of the user given version string into variables + STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+" "\\1" req_qt_major_vers "${QT_MIN_VERSION}") + STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+" "\\1" req_qt_minor_vers "${QT_MIN_VERSION}") + STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+)" "\\1" req_qt_patch_vers "${QT_MIN_VERSION}") + + IF (NOT req_qt_major_vers EQUAL 4) + MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", major version 4 is required, e.g. \"4.0.1\"") + ENDIF (NOT req_qt_major_vers EQUAL 4) + + # and now the version string given by qmake + STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" found_qt_major_vers "${QTVERSION}") + STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+.*" "\\1" found_qt_minor_vers "${QTVERSION}") + STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" found_qt_patch_vers "${QTVERSION}") + + # compute an overall version number which can be compared at once + MATH(EXPR req_vers "${req_qt_major_vers}*10000 + ${req_qt_minor_vers}*100 + ${req_qt_patch_vers}") + MATH(EXPR found_vers "${found_qt_major_vers}*10000 + ${found_qt_minor_vers}*100 + ${found_qt_patch_vers}") + + IF (found_vers LESS req_vers) + SET(QT4_QMAKE_FOUND FALSE) + SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE) + ELSE (found_vers LESS req_vers) + SET(QT4_QMAKE_FOUND TRUE) + ENDIF (found_vers LESS req_vers) + ENDIF (qt_version_tmp) + +ENDIF (QT_QMAKE_EXECUTABLE) + +IF (QT4_QMAKE_FOUND) + + # ask qmake for the library dir + # Set QT_LIBRARY_DIR + IF (NOT QT_LIBRARY_DIR) + EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE} + ARGS "-query QT_INSTALL_LIBS" + OUTPUT_VARIABLE QT_LIBRARY_DIR_TMP ) + IF(EXISTS "${QT_LIBRARY_DIR_TMP}") + SET(QT_LIBRARY_DIR ${QT_LIBRARY_DIR_TMP} CACHE PATH "Qt library dir") + ELSE(EXISTS "${QT_LIBRARY_DIR_TMP}") + MESSAGE("Warning: QT_QMAKE_EXECUTABLE reported QT_INSTALL_LIBS as ${QT_LIBRARY_DIR_TMP}") + MESSAGE("Warning: ${QT_LIBRARY_DIR_TMP} does NOT exist, Qt must NOT be installed correctly.") + ENDIF(EXISTS "${QT_LIBRARY_DIR_TMP}") + ENDIF(NOT QT_LIBRARY_DIR) + + IF (APPLE) + IF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework) + SET(QT_USE_FRAMEWORKS ON + CACHE BOOL "Set to ON if Qt build uses frameworks.") + ELSE (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework) + SET(QT_USE_FRAMEWORKS OFF + CACHE BOOL "Set to ON if Qt build uses frameworks.") + ENDIF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework) + + MARK_AS_ADVANCED(QT_USE_FRAMEWORKS) + ENDIF (APPLE) + + # ask qmake for the binary dir + IF (NOT QT_BINARY_DIR) + EXEC_PROGRAM(${QT_QMAKE_EXECUTABLE} + ARGS "-query QT_INSTALL_BINS" + OUTPUT_VARIABLE qt_bins ) + SET(QT_BINARY_DIR ${qt_bins} CACHE INTERNAL "") + ENDIF (NOT QT_BINARY_DIR) + + # ask qmake for the include dir + IF (NOT QT_HEADERS_DIR) + EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE} + ARGS "-query QT_INSTALL_HEADERS" + OUTPUT_VARIABLE qt_headers ) + SET(QT_HEADERS_DIR ${qt_headers} CACHE INTERNAL "") + ENDIF(NOT QT_HEADERS_DIR) + + + # ask qmake for the documentation directory + IF (NOT QT_DOC_DIR) + EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE} + ARGS "-query QT_INSTALL_DOCS" + OUTPUT_VARIABLE qt_doc_dir ) + SET(QT_DOC_DIR ${qt_doc_dir} CACHE PATH "The location of the Qt docs") + ENDIF (NOT QT_DOC_DIR) + + # ask qmake for the mkspecs directory + IF (NOT QT_MKSPECS_DIR) + EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE} + ARGS "-query QMAKE_MKSPECS" + OUTPUT_VARIABLE qt_mkspecs_dir ) + SET(QT_MKSPECS_DIR ${qt_mkspecs_dir} CACHE PATH "The location of the Qt mkspecs") + ENDIF (NOT QT_MKSPECS_DIR) + + # ask qmake for the plugins directory + IF (NOT QT_PLUGINS_DIR) + EXEC_PROGRAM( ${QT_QMAKE_EXECUTABLE} + ARGS "-query QT_INSTALL_PLUGINS" + OUTPUT_VARIABLE qt_plugins_dir ) + SET(QT_PLUGINS_DIR ${qt_plugins_dir} CACHE PATH "The location of the Qt plugins") + ENDIF (NOT QT_PLUGINS_DIR) + ######################################## + # + # Setting the INCLUDE-Variables + # + ######################################## + + FIND_PATH(QT_QTCORE_INCLUDE_DIR QtGlobal + ${QT_HEADERS_DIR}/QtCore + ${QT_LIBRARY_DIR}/QtCore.framework/Headers + NO_DEFAULT_PATH + ) + + # Set QT_INCLUDE_DIR by removine "/QtCore" in the string ${QT_QTCORE_INCLUDE_DIR} + IF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR) + IF (QT_USE_FRAMEWORKS) + SET(QT_INCLUDE_DIR ${QT_HEADERS_DIR}) + ELSE (QT_USE_FRAMEWORKS) + STRING( REGEX REPLACE "/QtCore$" "" qt4_include_dir ${QT_QTCORE_INCLUDE_DIR}) + SET( QT_INCLUDE_DIR ${qt4_include_dir} CACHE PATH "") + ENDIF (QT_USE_FRAMEWORKS) + ENDIF( QT_QTCORE_INCLUDE_DIR AND NOT QT_INCLUDE_DIR) + + IF( NOT QT_INCLUDE_DIR) + IF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED) + MESSAGE( FATAL_ERROR "Could NOT find QtGlobal header") + ENDIF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED) + ENDIF( NOT QT_INCLUDE_DIR) + + ############################################# + # + # Find out what window system we're using + # + ############################################# + # Save required includes variable + SET(CMAKE_REQUIRED_INCLUDES_SAVE ${CMAKE_REQUIRED_INCLUDES}) + # Add QT_INCLUDE_DIR to CMAKE_REQUIRED_INCLUDES + SET(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES};${QT_INCLUDE_DIR}") + # Check for Window system symbols (note: only one should end up being set) + CHECK_SYMBOL_EXISTS(Q_WS_X11 "QtCore/qglobal.h" Q_WS_X11) + CHECK_SYMBOL_EXISTS(Q_WS_MAC "QtCore/qglobal.h" Q_WS_MAC) + CHECK_SYMBOL_EXISTS(Q_WS_WIN "QtCore/qglobal.h" Q_WS_WIN) + + IF (QT_QTCOPY_REQUIRED) + CHECK_SYMBOL_EXISTS(QT_IS_QTCOPY "QtCore/qglobal.h" QT_KDE_QT_COPY) + IF (NOT QT_IS_QTCOPY) + MESSAGE(FATAL_ERROR "qt-copy is required, but hasn't been found") + ENDIF (NOT QT_IS_QTCOPY) + ENDIF (QT_QTCOPY_REQUIRED) + + # Restore CMAKE_REQUIRED_INCLUDES variable + SET(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES_SAVE}) + # + ############################################# + + IF (QT_USE_FRAMEWORKS) + SET(QT_DEFINITIONS ${QT_DEFINITIONS} -F${QT_LIBRARY_DIR} -L${QT_LIBRARY_DIR} ) + ENDIF (QT_USE_FRAMEWORKS) + + # Set QT_QT3SUPPORT_INCLUDE_DIR + FIND_PATH(QT_QT3SUPPORT_INCLUDE_DIR Qt3Support + PATHS + ${QT_INCLUDE_DIR}/Qt3Support + ${QT_LIBRARY_DIR}/Qt3Support.framework/Headers + NO_DEFAULT_PATH + ) + + # Set QT_QT_INCLUDE_DIR + FIND_PATH(QT_QT_INCLUDE_DIR qglobal.h + PATHS + ${QT_INCLUDE_DIR}/Qt + ${QT_LIBRARY_DIR}/QtCore.framework/Headers + NO_DEFAULT_PATH + ) + + # Set QT_QTGUI_INCLUDE_DIR + FIND_PATH(QT_QTGUI_INCLUDE_DIR QtGui + PATHS + ${QT_INCLUDE_DIR}/QtGui + ${QT_LIBRARY_DIR}/QtGui.framework/Headers + NO_DEFAULT_PATH + ) + + # Set QT_QTSVG_INCLUDE_DIR + FIND_PATH(QT_QTSVG_INCLUDE_DIR QtSvg + PATHS + ${QT_INCLUDE_DIR}/QtSvg + ${QT_LIBRARY_DIR}/QtSvg.framework/Headers + NO_DEFAULT_PATH + ) + + # Set QT_QTTEST_INCLUDE_DIR + FIND_PATH(QT_QTTEST_INCLUDE_DIR QtTest + PATHS + ${QT_INCLUDE_DIR}/QtTest + ${QT_LIBRARY_DIR}/QtTest.framework/Headers + NO_DEFAULT_PATH + ) + + # Set QT_QTUITOOLS_INCLUDE_DIR + FIND_PATH(QT_QTUITOOLS_INCLUDE_DIR QtUiTools + PATHS + ${QT_INCLUDE_DIR}/QtUiTools + ${QT_LIBRARY_DIR}/QtUiTools.framework/Headers + NO_DEFAULT_PATH + ) + + + + # Set QT_QTMOTIF_INCLUDE_DIR + IF(Q_WS_X11) + FIND_PATH(QT_QTMOTIF_INCLUDE_DIR QtMotif PATHS ${QT_INCLUDE_DIR}/QtMotif NO_DEFAULT_PATH ) + ENDIF(Q_WS_X11) + + # Set QT_QTNETWORK_INCLUDE_DIR + FIND_PATH(QT_QTNETWORK_INCLUDE_DIR QtNetwork + PATHS + ${QT_INCLUDE_DIR}/QtNetwork + ${QT_LIBRARY_DIR}/QtNetwork.framework/Headers + NO_DEFAULT_PATH + ) + + # Set QT_QTNSPLUGIN_INCLUDE_DIR + FIND_PATH(QT_QTNSPLUGIN_INCLUDE_DIR QtNsPlugin + PATHS + ${QT_INCLUDE_DIR}/QtNsPlugin + ${QT_LIBRARY_DIR}/QtNsPlugin.framework/Headers + NO_DEFAULT_PATH + ) + + # Set QT_QTOPENGL_INCLUDE_DIR + FIND_PATH(QT_QTOPENGL_INCLUDE_DIR QtOpenGL + PATHS + ${QT_INCLUDE_DIR}/QtOpenGL + ${QT_LIBRARY_DIR}/QtOpenGL.framework/Headers + NO_DEFAULT_PATH + ) + + # Set QT_QTSQL_INCLUDE_DIR + FIND_PATH(QT_QTSQL_INCLUDE_DIR QtSql + PATHS + ${QT_INCLUDE_DIR}/QtSql + ${QT_LIBRARY_DIR}/QtSql.framework/Headers + NO_DEFAULT_PATH + ) + + # Set QT_QTXML_INCLUDE_DIR + FIND_PATH(QT_QTXML_INCLUDE_DIR QtXml + PATHS + ${QT_INCLUDE_DIR}/QtXml + ${QT_LIBRARY_DIR}/QtXml.framework/Headers + NO_DEFAULT_PATH + ) + + # Set QT_QTASSISTANT_INCLUDE_DIR + FIND_PATH(QT_QTASSISTANT_INCLUDE_DIR QtAssistant + PATHS + ${QT_INCLUDE_DIR}/QtAssistant + ${QT_HEADERS_DIR}/QtAssistant + NO_DEFAULT_PATH + ) + + # Set QT_QTDESIGNER_INCLUDE_DIR + FIND_PATH(QT_QTDESIGNER_INCLUDE_DIR QDesignerComponents + PATHS + ${QT_INCLUDE_DIR}/QtDesigner + ${QT_HEADERS_DIR}/QtDesigner + NO_DEFAULT_PATH + ) + + # Set QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR + FIND_PATH(QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR QDesignerComponents + PATHS + ${QT_INCLUDE_DIR}/QtDesigner + ${QT_HEADERS_DIR}/QtDesigner + NO_DEFAULT_PATH + ) + + + # Set QT_QTDBUS_INCLUDE_DIR + FIND_PATH(QT_QTDBUS_INCLUDE_DIR QtDBus + PATHS + ${QT_INCLUDE_DIR}/QtDBus + ${QT_HEADERS_DIR}/QtDBus + NO_DEFAULT_PATH + ) + + # Make variables changeble to the advanced user + MARK_AS_ADVANCED( QT_LIBRARY_DIR QT_INCLUDE_DIR QT_QT_INCLUDE_DIR QT_DOC_DIR QT_MKSPECS_DIR QT_PLUGINS_DIR) + + # Set QT_INCLUDES + SET( QT_INCLUDES ${QT_INCLUDE_DIR} ${QT_QT_INCLUDE_DIR} ${QT_MKSPECS_DIR}/default ) + + + ######################################## + # + # Setting the LIBRARY-Variables + # + ######################################## + + IF (QT_USE_FRAMEWORKS) + # If FIND_LIBRARY found libraries in Apple frameworks, we would NOT have + # to jump through these hoops. + SET(QT_QTCORE_LIBRARY "-F${QT_LIBRARY_DIR} -framework QtCore" CACHE STRING "The QtCore library.") + SET(QT_QT3SUPPORT_LIBRARY "-framework Qt3Support" CACHE STRING "The Qt3Support library.") + SET(QT_QTGUI_LIBRARY "-framework QtGui" CACHE STRING "The QtGui library.") + SET(QT_QTNETWORK_LIBRARY "-framework QtNetwork" CACHE STRING "The QtNetwork library.") + SET(QT_QTOPENGL_LIBRARY "-framework QtOpenGL" CACHE STRING "The QtOpenGL library.") + SET(QT_QTSQL_LIBRARY "-framework QtSql" CACHE STRING "The QtSql library.") + SET(QT_QTXML_LIBRARY "-framework QtXml" CACHE STRING "The QtXml library.") + SET(QT_QTSVG_LIBRARY "-framework QtSvg" CACHE STRING "The QtSvg library.") + SET(QT_QTDBUS_LIBRARY "-framework QtDBus" CACHE STRING "The QtDBus library.") + SET(QT_QTTEST_LIBRARY "-framework QtTest" CACHE STRING "The QtTest library.") + + # WTF? why don't we have frameworks? :P + SET(QT_QTUITOOLS_LIBRARY "-L${QT_LIBRARY_DIR} -lQtUiTools" CACHE STRING "The QtUiTools library.") + + ELSE (QT_USE_FRAMEWORKS) + + # Set QT_QTCORE_LIBRARY by searching for a lib with "QtCore." as part of the filename + FIND_LIBRARY(QT_QTCORE_LIBRARY NAMES QtCore QtCore4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH ) + + # Set QT_QT3SUPPORT_LIBRARY + FIND_LIBRARY(QT_QT3SUPPORT_LIBRARY NAMES Qt3Support Qt3Support4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + # Set QT_QTGUI_LIBRARY + FIND_LIBRARY(QT_QTGUI_LIBRARY NAMES QtGui QtGui4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + # Set QT_QTMOTIF_LIBRARY + IF(Q_WS_X11) + FIND_LIBRARY(QT_QTMOTIF_LIBRARY NAMES QtMotif PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + ENDIF(Q_WS_X11) + + # Set QT_QTNETWORK_LIBRARY + FIND_LIBRARY(QT_QTNETWORK_LIBRARY NAMES QtNetwork QtNetwork4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + # Set QT_QTNSPLUGIN_LIBRARY + FIND_LIBRARY(QT_QTNSPLUGIN_LIBRARY NAMES QtNsPlugin PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + # Set QT_QTOPENGL_LIBRARY + FIND_LIBRARY(QT_QTOPENGL_LIBRARY NAMES QtOpenGL QtOpenGL4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + # Set QT_QTSQL_LIBRARY + FIND_LIBRARY(QT_QTSQL_LIBRARY NAMES QtSql QtSql4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + # Set QT_QTXML_LIBRARY + FIND_LIBRARY(QT_QTXML_LIBRARY NAMES QtXml QtXml4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + # Set QT_QTSVG_LIBRARY + FIND_LIBRARY(QT_QTSVG_LIBRARY NAMES QtSvg QtSvg4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + # Set QT_QTUITOOLS_LIBRARY + FIND_LIBRARY(QT_QTUITOOLS_LIBRARY NAMES QtUiTools QtUiTools4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + # Set QT_QTTEST_LIBRARY + FIND_LIBRARY(QT_QTTEST_LIBRARY NAMES QtTest QtTest4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + FIND_LIBRARY(QT_QTDBUS_LIBRARY NAMES QtDBus QtDBus4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + IF(MSVC) + FIND_LIBRARY(QT_QTCORE_LIBRARY_DEBUG NAMES QtCored4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + FIND_LIBRARY(QT_QT3SUPPORT_LIBRARY_DEBUG NAMES Qt3Supportd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + FIND_LIBRARY(QT_QTGUI_LIBRARY_DEBUG NAMES QtGuid4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + FIND_LIBRARY(QT_QTNETWORK_LIBRARY_DEBUG NAMES QtNetworkd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + FIND_LIBRARY(QT_QTOPENGL_LIBRARY_DEBUG NAMES QtOpenGLd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + FIND_LIBRARY(QT_QTSQL_LIBRARY_DEBUG NAMES QtSqld4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + FIND_LIBRARY(QT_QTXML_LIBRARY_DEBUG NAMES QtXmld4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + FIND_LIBRARY(QT_QTSVG_LIBRARY_DEBUG NAMES QtSvgd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + FIND_LIBRARY(QT_QTUITOOLS_LIBRARY_DEBUG NAMES QtUiToolsd QtUiToolsd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + FIND_LIBRARY(QT_QTTEST_LIBRARY_DEBUG NAMES QtTestd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + FIND_LIBRARY(QT_QTDBUS_LIBRARY_DEBUG NAMES QtDBusd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + FIND_LIBRARY(QT_QTASSISTANT_LIBRARY_DEBUG NAMES QtAssistantClientd4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + FIND_LIBRARY(QT_QTMAIN_LIBRARY_DEBUG NAMES qtmaind PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + ENDIF(MSVC) + + ENDIF (QT_USE_FRAMEWORKS) + + IF( NOT QT_QTCORE_LIBRARY ) + IF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED) + MESSAGE( FATAL_ERROR "Could NOT find QtCore. Check CMakeFiles/CMakeError.log for more details.") + ENDIF( NOT Qt4_FIND_QUIETLY AND Qt4_FIND_REQUIRED) + ENDIF( NOT QT_QTCORE_LIBRARY ) + + # Set QT_QTASSISTANT_LIBRARY + FIND_LIBRARY(QT_QTASSISTANT_LIBRARY NAMES QtAssistantClient QtAssistantClient4 QtAssistant QtAssistant4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + # Set QT_QTDESIGNER_LIBRARY + FIND_LIBRARY(QT_QTDESIGNER_LIBRARY NAMES QtDesigner QtDesigner4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + # Set QT_QTDESIGNERCOMPONENTS_LIBRARY + FIND_LIBRARY(QT_QTDESIGNERCOMPONENTS_LIBRARY NAMES QtDesignerComponents QtDesignerComponents4 PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + + # Set QT_QTMAIN_LIBRARY + IF(WIN32) + FIND_LIBRARY(QT_QTMAIN_LIBRARY NAMES qtmain PATHS ${QT_LIBRARY_DIR} NO_DEFAULT_PATH) + ENDIF(WIN32) + + ############################################ + # + # Check the existence of the libraries. + # + ############################################ + + MACRO (_QT4_ADJUST_LIB_VARS basename) + IF (QT_${basename}_LIBRARY OR QT_${basename}_LIBRARY_DEBUG) + + IF(MSVC) + + # Both set + IF (QT_${basename}_LIBRARY AND QT_${basename}_LIBRARY_DEBUG) + SET(QT_${basename}_LIBRARY optimized ${QT_${basename}_LIBRARY} debug ${QT_${basename}_LIBRARY_DEBUG}) + ENDIF (QT_${basename}_LIBRARY AND QT_${basename}_LIBRARY_DEBUG) + + # Only debug was found + IF (NOT QT_${basename}_LIBRARY AND QT_${basename}_LIBRARY_DEBUG) + SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY_DEBUG}) + ENDIF (NOT QT_${basename}_LIBRARY AND QT_${basename}_LIBRARY_DEBUG) + + # Hmm, is this used anywhere ? Yes, in UseQt4.cmake. We are currently incompatible :-( + SET(QT_${basename}_LIBRARIES optimized ${QT_${basename}_LIBRARY} debug ${QT_${basename}_LIBRARY_DEBUG}) + + ENDIF(MSVC) + + SET(QT_${basename}_LIBRARY ${QT_${basename}_LIBRARY} CACHE FILEPATH "The Qt ${basename} library") + + IF (QT_${basename}_LIBRARY) + SET(QT_${basename}_FOUND 1) + ENDIF (QT_${basename}_LIBRARY) + + ENDIF (QT_${basename}_LIBRARY OR QT_${basename}_LIBRARY_DEBUG) + + IF (QT_${basename}_INCLUDE_DIR) + #add the include directory to QT_INCLUDES + SET(QT_INCLUDES ${QT_INCLUDES} "${QT_${basename}_INCLUDE_DIR}") + ENDIF (QT_${basename}_INCLUDE_DIR) + + # Make variables changeble to the advanced user + MARK_AS_ADVANCED(QT_${basename}_LIBRARY QT_${basename}_INCLUDE_DIR) + ENDMACRO (_QT4_ADJUST_LIB_VARS) + + + # Set QT_xyz_LIBRARY variable and add + # library include path to QT_INCLUDES + _QT4_ADJUST_LIB_VARS(QTCORE) + _QT4_ADJUST_LIB_VARS(QTGUI) + _QT4_ADJUST_LIB_VARS(QT3SUPPORT) + _QT4_ADJUST_LIB_VARS(QTASSISTANT) + _QT4_ADJUST_LIB_VARS(QTDESIGNER) + _QT4_ADJUST_LIB_VARS(QTDESIGNERCOMPONENTS) + _QT4_ADJUST_LIB_VARS(QTNETWORK) + _QT4_ADJUST_LIB_VARS(QTNSPLUGIN) + _QT4_ADJUST_LIB_VARS(QTOPENGL) + _QT4_ADJUST_LIB_VARS(QTSQL) + _QT4_ADJUST_LIB_VARS(QTXML) + _QT4_ADJUST_LIB_VARS(QTSVG) + _QT4_ADJUST_LIB_VARS(QTUITOOLS) + _QT4_ADJUST_LIB_VARS(QTTEST) + _QT4_ADJUST_LIB_VARS(QTDBUS) + + + # platform dependent libraries + IF(Q_WS_X11) + _QT4_ADJUST_LIB_VARS(QTMOTIF) + ENDIF(Q_WS_X11) + IF(WIN32) + _QT4_ADJUST_LIB_VARS(QTMAIN) + ENDIF(WIN32) + + + ####################################### + # + # Check the executables of Qt + # ( moc, uic, rcc ) + # + ####################################### + + + # find moc and uic using qmake + QT_QUERY_QMAKE(QT_MOC_EXECUTABLE_INTERNAL "QMAKE_MOC") + QT_QUERY_QMAKE(QT_UIC_EXECUTABLE_INTERNAL "QMAKE_UIC") + + FILE(TO_CMAKE_PATH + "${QT_MOC_EXECUTABLE_INTERNAL}" QT_MOC_EXECUTABLE_INTERNAL) + FILE(TO_CMAKE_PATH + "${QT_UIC_EXECUTABLE_INTERNAL}" QT_UIC_EXECUTABLE_INTERNAL) + + SET(QT_MOC_EXECUTABLE + ${QT_MOC_EXECUTABLE_INTERNAL} CACHE FILEPATH "The moc executable") + SET(QT_UIC_EXECUTABLE + ${QT_UIC_EXECUTABLE_INTERNAL} CACHE FILEPATH "The uic executable") + + FIND_PROGRAM(QT_UIC3_EXECUTABLE + NAMES uic3 + PATHS ${QT_BINARY_DIR} + NO_DEFAULT_PATH + ) + + FIND_PROGRAM(QT_RCC_EXECUTABLE + NAMES rcc + PATHS ${QT_BINARY_DIR} + NO_DEFAULT_PATH + ) + + FIND_PROGRAM(QT_DBUSCPP2XML_EXECUTABLE + NAMES qdbuscpp2xml + PATHS ${QT_BINARY_DIR} + NO_DEFAULT_PATH + ) + + FIND_PROGRAM(QT_DBUSXML2CPP_EXECUTABLE + NAMES qdbusxml2cpp + PATHS ${QT_BINARY_DIR} + NO_DEFAULT_PATH + ) + + IF (QT_MOC_EXECUTABLE) + SET(QT_WRAP_CPP "YES") + ENDIF (QT_MOC_EXECUTABLE) + + IF (QT_UIC_EXECUTABLE) + SET(QT_WRAP_UI "YES") + ENDIF (QT_UIC_EXECUTABLE) + + + + MARK_AS_ADVANCED( QT_UIC_EXECUTABLE QT_UIC3_EXECUTABLE QT_MOC_EXECUTABLE QT_RCC_EXECUTABLE QT_DBUSXML2CPP_EXECUTABLE QT_DBUSCPP2XML_EXECUTABLE) + + ###################################### + # + # Macros for building Qt files + # + ###################################### + + MACRO (QT4_GET_MOC_INC_DIRS _moc_INC_DIRS) + SET(${_moc_INC_DIRS}) + GET_DIRECTORY_PROPERTY(_inc_DIRS INCLUDE_DIRECTORIES) + + FOREACH(_current ${_inc_DIRS}) + SET(${_moc_INC_DIRS} ${${_moc_INC_DIRS}} "-I" ${_current}) + ENDFOREACH(_current ${_inc_DIRS}) + ENDMACRO(QT4_GET_MOC_INC_DIRS) + + + MACRO (QT4_GENERATE_MOC infile outfile ) + # get include dirs + QT4_GET_MOC_INC_DIRS(moc_includes) + + GET_FILENAME_COMPONENT(abs_infile ${infile} ABSOLUTE) + + ADD_CUSTOM_COMMAND(OUTPUT ${outfile} + COMMAND ${QT_MOC_EXECUTABLE} + ARGS ${moc_includes} -o ${outfile} ${abs_infile} + DEPENDS ${abs_infile}) + + SET_SOURCE_FILES_PROPERTIES(${outfile} PROPERTIES SKIP_AUTOMOC TRUE) # dont run automoc on this file + + MACRO_ADD_FILE_DEPENDENCIES(${abs_infile} ${outfile}) + ENDMACRO (QT4_GENERATE_MOC) + + + # QT4_WRAP_CPP(outfiles inputfile ... ) + # TODO perhaps add support for -D, -U and other minor options + + MACRO (QT4_WRAP_CPP outfiles ) + # get include dirs + QT4_GET_MOC_INC_DIRS(moc_includes) + + FOREACH (it ${ARGN}) + GET_FILENAME_COMPONENT(it ${it} ABSOLUTE) + GET_FILENAME_COMPONENT(outfile ${it} NAME_WE) + + SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/moc_${outfile}.cxx) + ADD_CUSTOM_COMMAND(OUTPUT ${outfile} + COMMAND ${QT_MOC_EXECUTABLE} + ARGS ${moc_includes} -o ${outfile} ${it} + DEPENDS ${it}) + SET(${outfiles} ${${outfiles}} ${outfile}) + ENDFOREACH(it) + + ENDMACRO (QT4_WRAP_CPP) + + + # QT4_WRAP_UI(outfiles inputfile ... ) + + MACRO (QT4_WRAP_UI outfiles ) + + FOREACH (it ${ARGN}) + GET_FILENAME_COMPONENT(outfile ${it} NAME_WE) + GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE) + SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/ui_${outfile}.h) + ADD_CUSTOM_COMMAND(OUTPUT ${outfile} + COMMAND ${QT_UIC_EXECUTABLE} + ARGS -o ${outfile} ${infile} + MAIN_DEPENDENCY ${infile}) + SET(${outfiles} ${${outfiles}} ${outfile}) + ENDFOREACH (it) + + ENDMACRO (QT4_WRAP_UI) + + + # QT4_ADD_RESOURCE(outfiles inputfile ... ) + # TODO perhaps consider adding support for compression and root options to rcc + + MACRO (QT4_ADD_RESOURCES outfiles ) + + FOREACH (it ${ARGN}) + GET_FILENAME_COMPONENT(outfilename ${it} NAME_WE) + GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE) + GET_FILENAME_COMPONENT(rc_path ${infile} PATH) + SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${outfilename}.cxx) + # parse file for dependencies + FILE(READ "${infile}" _RC_FILE_CONTENTS) + STRING(REGEX MATCHALL "[^<]*" _RC_FILES "${_RC_FILE_CONTENTS}") + SET(_RC_DEPENDS) + FOREACH(_RC_FILE ${_RC_FILES}) + STRING(REGEX REPLACE "^" "" _RC_FILE "${_RC_FILE}") + SET(_RC_DEPENDS ${_RC_DEPENDS} "${rc_path}/${_RC_FILE}") + ENDFOREACH(_RC_FILE) + ADD_CUSTOM_COMMAND(OUTPUT ${outfile} + COMMAND ${QT_RCC_EXECUTABLE} + ARGS -name ${outfilename} -o ${outfile} ${infile} + MAIN_DEPENDENCY ${infile} + DEPENDS ${_RC_DEPENDS}) + SET(${outfiles} ${${outfiles}} ${outfile}) + ENDFOREACH (it) + + ENDMACRO (QT4_ADD_RESOURCES) + + MACRO(QT4_ADD_DBUS_INTERFACE _sources _interface _basename) + GET_FILENAME_COMPONENT(_infile ${_interface} ABSOLUTE) + SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h) + SET(_impl ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp) + SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc) + + ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header} + COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -p ${_basename} ${_infile} + DEPENDS ${_infile}) + + SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE) + + QT4_GENERATE_MOC(${_header} ${_moc}) + + SET(${_sources} ${${_sources}} ${_impl} ${_header} ${_moc}) + MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc}) + + ENDMACRO(QT4_ADD_DBUS_INTERFACE) + + + MACRO(QT4_ADD_DBUS_INTERFACES _sources) + FOREACH (_current_FILE ${ARGN}) + GET_FILENAME_COMPONENT(_infile ${_current_FILE} ABSOLUTE) + + # get the part before the ".xml" suffix + STRING(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2" _basename ${_current_FILE}) + STRING(TOLOWER ${_basename} _basename) + + QT4_ADD_DBUS_INTERFACE(${_sources} ${_infile} ${_basename}interface) + ENDFOREACH (_current_FILE) + ENDMACRO(QT4_ADD_DBUS_INTERFACES) + + + MACRO(QT4_GENERATE_DBUS_INTERFACE _header) # _customName ) + SET(_customName "${ARGV1}") + GET_FILENAME_COMPONENT(_in_file ${_header} ABSOLUTE) + GET_FILENAME_COMPONENT(_basename ${_header} NAME_WE) + + IF (_customName) + SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_customName}) + ELSE (_customName) + SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.xml) + ENDIF (_customName) + + ADD_CUSTOM_COMMAND(OUTPUT ${_target} + COMMAND ${QT_DBUSCPP2XML_EXECUTABLE} ${_in_file} > ${_target} + DEPENDS ${_in_file} + ) + ENDMACRO(QT4_GENERATE_DBUS_INTERFACE) + + + MACRO(QT4_ADD_DBUS_ADAPTOR _sources _xml_file _include _parentClass) # _optionalBasename ) + GET_FILENAME_COMPONENT(_infile ${_xml_file} ABSOLUTE) + + SET(_optionalBasename "${ARGV4}") + IF (_optionalBasename) + SET(_basename ${_optionalBasename} ) + ELSE (_optionalBasename) + STRING(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2adaptor" _basename ${_infile}) + STRING(TOLOWER ${_basename} _basename) + ENDIF (_optionalBasename) + + SET(_optionalClassName "${ARGV5}") + SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h) + SET(_impl ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp) + SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc) + + IF(_optionalClassName) + ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header} + COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -a ${_basename} -c ${_optionalClassName} -i ${_include} -l ${_parentClass} ${_infile} + DEPENDS ${_infile} + ) + ELSE(_optionalClassName) + ADD_CUSTOM_COMMAND(OUTPUT ${_impl} ${_header} + COMMAND ${QT_DBUSXML2CPP_EXECUTABLE} -m -a ${_basename} -i ${_include} -l ${_parentClass} ${_infile} + DEPENDS ${_infile} + ) + ENDIF(_optionalClassName) + + QT4_GENERATE_MOC(${_header} ${_moc}) + SET_SOURCE_FILES_PROPERTIES(${_impl} PROPERTIES SKIP_AUTOMOC TRUE) + MACRO_ADD_FILE_DEPENDENCIES(${_impl} ${_moc}) + + SET(${_sources} ${${_sources}} ${_impl} ${_header} ${_moc}) + ENDMACRO(QT4_ADD_DBUS_ADAPTOR) + + MACRO(QT4_AUTOMOC) + QT4_GET_MOC_INC_DIRS(_moc_INCS) + + SET(_matching_FILES ) + FOREACH (_current_FILE ${ARGN}) + + GET_FILENAME_COMPONENT(_abs_FILE ${_current_FILE} ABSOLUTE) + # if "SKIP_AUTOMOC" is set to true, we will not handle this file here. + # here. this is required to make bouic work correctly: + # we need to add generated .cpp files to the sources (to compile them), + # but we cannot let automoc handle them, as the .cpp files don't exist yet when + # cmake is run for the very first time on them -> however the .cpp files might + # exist at a later run. at that time we need to skip them, so that we don't add two + # different rules for the same moc file + GET_SOURCE_FILE_PROPERTY(_skip ${_abs_FILE} SKIP_AUTOMOC) + + IF ( NOT _skip AND EXISTS ${_abs_FILE} ) + + FILE(READ ${_abs_FILE} _contents) + + GET_FILENAME_COMPONENT(_abs_PATH ${_abs_FILE} PATH) + + STRING(REGEX MATCHALL "#include +[^ ]+\\.moc[\">]" _match "${_contents}") + IF(_match) + FOREACH (_current_MOC_INC ${_match}) + STRING(REGEX MATCH "[^ <\"]+\\.moc" _current_MOC "${_current_MOC_INC}") + + GET_filename_component(_basename ${_current_MOC} NAME_WE) + # SET(_header ${CMAKE_CURRENT_SOURCE_DIR}/${_basename}.h) + SET(_header ${_abs_PATH}/${_basename}.h) + SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_current_MOC}) + ADD_CUSTOM_COMMAND(OUTPUT ${_moc} + COMMAND ${QT_MOC_EXECUTABLE} + ARGS ${_moc_INCS} ${_header} -o ${_moc} + DEPENDS ${_header} + ) + + MACRO_ADD_FILE_DEPENDENCIES(${_abs_FILE} ${_moc}) + ENDFOREACH (_current_MOC_INC) + ENDIF(_match) + ENDIF ( NOT _skip AND EXISTS ${_abs_FILE} ) + ENDFOREACH (_current_FILE) + ENDMACRO(QT4_AUTOMOC) + + + + ###################################### + # + # decide if Qt got found + # + ###################################### + + # if the includes,libraries,moc,uic and rcc are found then we have it + IF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE) + SET( QT4_FOUND "YES" ) + IF( NOT Qt4_FIND_QUIETLY) + MESSAGE(STATUS "Found Qt-Version ${QTVERSION}") + ENDIF( NOT Qt4_FIND_QUIETLY) + ELSE( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE) + SET( QT4_FOUND "NO") + SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE) + IF( Qt4_FIND_REQUIRED) + IF ( NOT QT_LIBRARY_DIR ) + MESSAGE(STATUS "Qt libraries NOT found!") + ENDIF(NOT QT_LIBRARY_DIR ) + IF ( NOT QT_INCLUDE_DIR ) + MESSAGE(STATUS "Qt includes NOT found!") + ENDIF( NOT QT_INCLUDE_DIR ) + IF ( NOT QT_MOC_EXECUTABLE ) + MESSAGE(STATUS "Qt's moc NOT found!") + ENDIF( NOT QT_MOC_EXECUTABLE ) + IF ( NOT QT_UIC_EXECUTABLE ) + MESSAGE(STATUS "Qt's uic NOT found!") + ENDIF( NOT QT_UIC_EXECUTABLE ) + IF ( NOT QT_RCC_EXECUTABLE ) + MESSAGE(STATUS "Qt's rcc NOT found!") + ENDIF( NOT QT_RCC_EXECUTABLE ) + MESSAGE( FATAL_ERROR "Qt libraries, includes, moc, uic or/and rcc NOT found!") + ENDIF( Qt4_FIND_REQUIRED) + ENDIF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE) + SET(QT_FOUND ${QT4_FOUND}) + + + ####################################### + # + # System dependent settings + # + ####################################### + # for unix add X11 stuff + IF(UNIX) + # on OS X X11 may not be required + IF (Q_WS_X11) + FIND_PACKAGE(X11) + ENDIF (Q_WS_X11) + FIND_PACKAGE(Threads) + SET(QT_QTCORE_LIBRARY ${QT_QTCORE_LIBRARY} ${CMAKE_THREAD_LIBS_INIT}) + ENDIF(UNIX) + + + ####################################### + # + # compatibility settings + # + ####################################### + # Backwards compatibility for CMake1.4 and 1.2 + SET (QT_MOC_EXE ${QT_MOC_EXECUTABLE} ) + SET (QT_UIC_EXE ${QT_UIC_EXECUTABLE} ) + + SET( QT_QT_LIBRARY "") + +ELSE(QT4_QMAKE_FOUND) + + SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE) + IF(Qt4_FIND_REQUIRED) + IF(QT4_INSTALLED_VERSION_TOO_OLD) + MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required") + ELSE(QT4_INSTALLED_VERSION_TOO_OLD) + MESSAGE( FATAL_ERROR "Qt qmake not found!") + ENDIF(QT4_INSTALLED_VERSION_TOO_OLD) + ELSE(Qt4_FIND_REQUIRED) + IF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY) + MESSAGE(STATUS "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required") + ENDIF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY) + ENDIF(Qt4_FIND_REQUIRED) + +ENDIF (QT4_QMAKE_FOUND) + diff --git a/cmakemodules/FindStrigi.cmake b/cmakemodules/FindStrigi.cmake new file mode 100644 index 0000000..072ad84 --- /dev/null +++ b/cmakemodules/FindStrigi.cmake @@ -0,0 +1,47 @@ +# - Try to find Strigi +# Once done this will define +# +# STRIGI_FOUND - system has Strigi +# STRIGI_INCLUDE_DIR - the Strigi include directory +# STRIGIHTMLGUI_LIBRARY - Link these to use Strigi html gui +# STRIGICLIENT_LIBRARY - Link to use the Strigi C++ client +# + +FIND_PATH(STRIGI_INCLUDE_DIR strigihtmlgui.h + PATHS + $ENV{HOME}/include/strigi + $ENV{HOME}/usr/include/strigi + $ENV{KDEDIR}/include/strigi + /opt/kde/include/strigi + /opt/kde3/include/strigi + /opt/kde4/include/strigi + /usr/kde/3.5/include/strigi + /usr/include/strigi + /usr/local/include/strigi + /opt/include/strigi + ${INCLUDE_SEARCH_PATHES} +) + +FIND_LIBRARY(STRIGIHTMLGUI_LIBRARY NAMES strigihtmlgui + PATHS + ${LIB_SEARCH_PATHES} +) +FIND_LIBRARY(STRIGICLIENT_LIBRARY NAMES searchclient + PATHS + ${LIB_SEARCH_PATHES} +) + +IF(STRIGI_INCLUDE_DIR AND STRIGIHTMLGUI_LIBRARY AND STRIGICLIENT_LIBRARY) + SET(STRIGI_FOUND TRUE) +ENDIF(STRIGI_INCLUDE_DIR AND STRIGIHTMLGUI_LIBRARY AND STRIGICLIENT_LIBRARY) + +IF(STRIGI_FOUND) + IF(NOT Strigi_FIND_QUIETLY) + MESSAGE(STATUS "Found Strigi: ${STRIGIHTMLGUI_LIBRARY}") + ENDIF(NOT Strigi_FIND_QUIETLY) +ELSE(STRIGI_FOUND) + IF(Strigi_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find Strigi! Please download and install Strigi from http://strigi.sf.net") + ENDIF(Strigi_FIND_REQUIRED) +ENDIF(STRIGI_FOUND) + diff --git a/cmakemodules/FindX11.cmake b/cmakemodules/FindX11.cmake new file mode 100644 index 0000000..1fd45e1 --- /dev/null +++ b/cmakemodules/FindX11.cmake @@ -0,0 +1,352 @@ +# - Find X11 installation +# Try to find X11 on UNIX systems. The following values are defined +# X11_FOUND - True if X11 is available +# X11_INCLUDE_DIR - include directories to use X11 +# X11_LIBRARIES - link against these to use X11 + +# Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. +# See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. + +if (UNIX) + set(X11_FOUND 0) + + set(X11_INC_SEARCH_PATH + /usr/X11R6/include + /usr/local/include + /usr/include/X11 + /usr/openwin/include + /usr/openwin/share/include + /opt/graphics/OpenGL/include + /usr/include + ) + + set(X11_LIB_SEARCH_PATH + /usr/X11R6/lib + /usr/local/lib + /usr/openwin/lib + /usr/lib + ) + + FIND_PATH(X11_X11_INCLUDE_PATH X11/X.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xlib_INCLUDE_PATH X11/Xlib.h ${X11_INC_SEARCH_PATH}) + + # Look for includes; keep the list sorted by name of the cmake *_INCLUDE_PATH + # variable (which doesn't need to match the include file name). + + # Solaris lacks XKBrules.h, so we should skip kxkbd there. + FIND_PATH(X11_Xaccessrules_INCLUDE_PATH X11/extensions/XKBrules.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xaccessstr_INCLUDE_PATH X11/extensions/XKBstr.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xcomposite_INCLUDE_PATH X11/extensions/Xcomposite.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xcursor_INCLUDE_PATH X11/Xcursor/Xcursor.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xdamage_INCLUDE_PATH X11/extensions/Xdamage.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xdmcp_INCLUDE_PATH X11/Xdmcp.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_dpms_INCLUDE_PATH X11/extensions/dpms.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xf86misc_INCLUDE_PATH X11/extensions/xf86misc.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_xf86vmode_INCLUDE_PATH X11/extensions/xf86vmode.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xfixes_INCLUDE_PATH X11/extensions/Xfixes.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xft_INCLUDE_PATH X11/Xft/Xft.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xinerama_INCLUDE_PATH X11/extensions/Xinerama.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xinput_INCLUDE_PATH X11/extensions/XInput.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xkb_INCLUDE_PATH X11/extensions/XKB.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xkblib_INCLUDE_PATH X11/XKBlib.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xpm_INCLUDE_PATH X11/xpm.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_XTest_INCLUDE_PATH X11/extensions/XTest.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xrandr_INCLUDE_PATH X11/extensions/Xrandr.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xrender_INCLUDE_PATH X11/extensions/Xrender.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xscreensaver_INCLUDE_PATH X11/extensions/scrnsaver.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xshape_INCLUDE_PATH X11/extensions/shape.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xutil_INCLUDE_PATH X11/Xutil.h ${X11_INC_SEARCH_PATH}) + FIND_PATH(X11_Xv_INCLUDE_PATH X11/extensions/Xvlib.h ${X11_INC_SEARCH_PATH}) + + + FIND_LIBRARY(X11_X11_LIB X11 ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + + # Find additional X libraries. Keep list sorted by library name. + FIND_LIBRARY(X11_Xau_LIB Xau ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xcomposite_LIB Xcomposite ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xcursor_LIB Xcursor ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xdamage_LIB Xdamage ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xdmcp_LIB Xdmcp ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xext_LIB Xext ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xfixes_LIB Xfixes ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xft_LIB Xft ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xinerama_LIB Xinerama ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xinput_LIB Xi ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xpm_LIB Xpm ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xrandr_LIB Xrandr ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xrender_LIB Xrender ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xss_LIB Xss ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xt_LIB Xt ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_XTest_LIB Xtst ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xv_LIB Xv ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + FIND_LIBRARY(X11_Xxf86misc_LIB Xxf86misc ${X11_LIB_SEARCH_PATH} NO_SYSTEM_PATH) + + if (X11_X11_INCLUDE_PATH) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_X11_INCLUDE_PATH}) + endif (X11_X11_INCLUDE_PATH) + + if (X11_Xlib_INCLUDE_PATH) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xlib_INCLUDE_PATH}) + endif (X11_Xlib_INCLUDE_PATH) + + if (X11_Xutil_INCLUDE_PATH) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xutil_INCLUDE_PATH}) + endif (X11_Xutil_INCLUDE_PATH) + + if(X11_Xshape_INCLUDE_PATH) + set(X11_Xshape_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xshape_INCLUDE_PATH}) + endif(X11_Xshape_INCLUDE_PATH) + + if (X11_X11_LIB) + set(X11_LIBRARIES ${X11_LIBRARIES} ${X11_X11_LIB}) + endif (X11_X11_LIB) + + if (X11_Xext_LIB) + set(X11_LIBRARIES ${X11_LIBRARIES} ${X11_Xext_LIB}) + endif (X11_Xext_LIB) + + if(X11_Xft_LIB AND X11_Xft_INCLUDE_PATH) + set(X11_XFT_FOUND TRUE) + set(X11_LIBRARIES ${X11_LIBRARIES} ${X11_Xft_LIB}) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xft_INCLUDE_PATH}) + endif(X11_Xft_LIB AND X11_Xft_INCLUDE_PATH) + + if(X11_Xv_LIB AND X11_Xv_INCLUDE_PATH) + set(X11_XV_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xv_INCLUDE_PATH}) + endif(X11_Xv_LIB AND X11_Xv_INCLUDE_PATH) + + if (X11_Xau_LIB) + set(X11_Xau_FOUND TRUE) + set(X11_LIBRARIES ${X11_LIBRARIES} ${X11_Xau_LIB}) + endif (X11_Xau_LIB) + + if (X11_Xdmcp_INCLUDE_PATH AND X11_Xdmcp_LIB) + set(X11_Xdmcp_FOUND TRUE) + set(X11_LIBRARIES ${X11_LIBRARIES} ${X11_Xdmcp_LIB}) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xdmcp_INCLUDE_PATH}) + endif (X11_Xdmcp_INCLUDE_PATH AND X11_Xdmcp_LIB) + + if (X11_Xaccessrules_INCLUDE_PATH AND X11_Xaccessstr_INCLUDE_PATH) + set(X11_Xaccess_FOUND TRUE) + set(X11_Xaccess_INCLUDE_PATH ${X11_Xaccessstr_INCLUDE_PATH}) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xaccess_INCLUDE_PATH}) + endif (X11_Xaccessrules_INCLUDE_PATH AND X11_Xaccessstr_INCLUDE_PATH) + + if (X11_Xpm_INCLUDE_PATH AND X11_Xpm_LIB) + set(X11_Xpm_FOUND TRUE) + set(X11_LIBRARIES ${X11_LIBRARIES} ${X11_Xpm_LIB}) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xpm_INCLUDE_PATH}) + endif (X11_Xpm_INCLUDE_PATH AND X11_Xpm_LIB) + + + if (X11_Xcomposite_INCLUDE_PATH) + set(X11_Xcomposite_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xcomposite_INCLUDE_PATH}) + endif (X11_Xcomposite_INCLUDE_PATH) + + if (X11_Xdamage_INCLUDE_PATH) + set(X11_Xdamage_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xdamage_INCLUDE_PATH}) + endif (X11_Xdamage_INCLUDE_PATH) + + if (X11_XTest_INCLUDE_PATH AND X11_XTest_LIB) + set(X11_XTest_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_XTest_INCLUDE_PATH}) + endif (X11_XTest_INCLUDE_PATH AND X11_XTest_LIB) + + if (X11_Xinerama_INCLUDE_PATH) + set(X11_Xinerama_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xinerama_INCLUDE_PATH}) + endif (X11_Xinerama_INCLUDE_PATH) + + if (X11_Xfixes_INCLUDE_PATH) + set(X11_Xfixes_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xfixes_INCLUDE_PATH}) + endif (X11_Xfixes_INCLUDE_PATH) + + if (X11_Xrender_INCLUDE_PATH AND X11_Xrender_LIB) + set(X11_Xrender_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xrender_INCLUDE_PATH}) + endif (X11_Xrender_INCLUDE_PATH AND X11_Xrender_LIB) + + if (X11_Xrandr_INCLUDE_PATH) + set(X11_Xrandr_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xrandr_INCLUDE_PATH}) + endif (X11_Xrandr_INCLUDE_PATH) + + if (X11_Xxf86misc_INCLUDE_PATH) + set(X11_Xxf86misc_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xxf86misc_INCLUDE_PATH}) + endif (X11_Xxf86misc_INCLUDE_PATH) + + if (X11_xf86vmode_INCLUDE_PATH) + set(X11_xf86vmode_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_xf86vmode_INCLUDE_PATH}) + endif (X11_xf86vmode_INCLUDE_PATH) + + if (X11_Xcursor_INCLUDE_PATH AND X11_Xcursor_LIB) + set(X11_Xcursor_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xcursor_INCLUDE_PATH}) + endif (X11_Xcursor_INCLUDE_PATH AND X11_Xcursor_LIB) + + if (X11_Xscreensaver_INCLUDE_PATH) + set(X11_Xscreensaver_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xscreensaver_INCLUDE_PATH}) + endif (X11_Xscreensaver_INCLUDE_PATH) + + if (X11_dpms_INCLUDE_PATH) + set(X11_dpms_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_dpms_INCLUDE_PATH}) + endif (X11_dpms_INCLUDE_PATH) + + if (X11_Xkb_INCLUDE_PATH AND X11_Xkblib_INCLUDE_PATH AND X11_Xlib_INCLUDE_PATH) + set(X11_Xkb_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xkb_INCLUDE_PATH} ) + endif (X11_Xkb_INCLUDE_PATH AND X11_Xkblib_INCLUDE_PATH AND X11_Xlib_INCLUDE_PATH) + + if (X11_Xinput_INCLUDE_PATH AND X11_Xinput_LIB) + set(X11_Xinput_FOUND TRUE) + set(X11_INCLUDE_DIR ${X11_INCLUDE_DIR} ${X11_Xinput_INCLUDE_PATH}) + endif (X11_Xinput_INCLUDE_PATH AND X11_Xinput_LIB) + + # Deprecated variable for backwards compatibility with CMake 1.4 + if (X11_X11_INCLUDE_PATH) + if (X11_LIBRARIES) + set(X11_FOUND 1) + endif (X11_LIBRARIES) + endif (X11_X11_INCLUDE_PATH) + + set(X11_LIBRARY_DIR "") + if (X11_X11_LIB) + GET_FILENAME_COMPONENT(X11_LIBRARY_DIR ${X11_X11_LIB} PATH) + endif (X11_X11_LIB) + + if (X11_FOUND) + INCLUDE(CheckFunctionExists) + INCLUDE(CheckLibraryExists) + + # Translated from an autoconf-generated configure script. + # See libs.m4 in autoconf's m4 directory. + if ($ENV{ISC} MATCHES "^yes$") + set(X11_X_EXTRA_LIBS -lnsl_s -linet) + else ($ENV{ISC} MATCHES "^yes$") + set(X11_X_EXTRA_LIBS "") + + # See if XOpenDisplay in X11 works by itself. + CHECK_LIBRARY_EXISTS("${X11_LIBRARIES}" "XOpenDisplay" "${X11_LIBRARY_DIR}" X11_LIB_X11_SOLO) + if (NOT X11_LIB_X11_SOLO) + # Find library needed for dnet_ntoa. + CHECK_LIBRARY_EXISTS("dnet" "dnet_ntoa" "" X11_LIB_DNET_HAS_DNET_NTOA) + if (X11_LIB_DNET_HAS_DNET_NTOA) + set(X11_X_EXTRA_LIBS ${X11_X_EXTRA_LIBS} -ldnet) + else (X11_LIB_DNET_HAS_DNET_NTOA) + CHECK_LIBRARY_EXISTS("dnet_stub" "dnet_ntoa" "" X11_LIB_DNET_STUB_HAS_DNET_NTOA) + if (X11_LIB_DNET_STUB_HAS_DNET_NTOA) + set(X11_X_EXTRA_LIBS ${X11_X_EXTRA_LIBS} -ldnet_stub) + endif (X11_LIB_DNET_STUB_HAS_DNET_NTOA) + endif (X11_LIB_DNET_HAS_DNET_NTOA) + endif (NOT X11_LIB_X11_SOLO) + + # Find library needed for gethostbyname. + CHECK_FUNCTION_EXISTS("gethostbyname" CMAKE_HAVE_GETHOSTBYNAME) + if (NOT CMAKE_HAVE_GETHOSTBYNAME) + CHECK_LIBRARY_EXISTS("nsl" "gethostbyname" "" CMAKE_LIB_NSL_HAS_GETHOSTBYNAME) + if (CMAKE_LIB_NSL_HAS_GETHOSTBYNAME) + set(X11_X_EXTRA_LIBS ${X11_X_EXTRA_LIBS} -lnsl) + else (CMAKE_LIB_NSL_HAS_GETHOSTBYNAME) + CHECK_LIBRARY_EXISTS("bsd" "gethostbyname" "" CMAKE_LIB_BSD_HAS_GETHOSTBYNAME) + if (CMAKE_LIB_BSD_HAS_GETHOSTBYNAME) + set(X11_X_EXTRA_LIBS ${X11_X_EXTRA_LIBS} -lbsd) + endif (CMAKE_LIB_BSD_HAS_GETHOSTBYNAME) + endif (CMAKE_LIB_NSL_HAS_GETHOSTBYNAME) + endif (NOT CMAKE_HAVE_GETHOSTBYNAME) + + # Find library needed for connect. + CHECK_FUNCTION_EXISTS("connect" CMAKE_HAVE_CONNECT) + if (NOT CMAKE_HAVE_CONNECT) + CHECK_LIBRARY_EXISTS("socket" "connect" "" CMAKE_LIB_SOCKET_HAS_CONNECT) + if (CMAKE_LIB_SOCKET_HAS_CONNECT) + set(X11_X_EXTRA_LIBS -lsocket ${X11_X_EXTRA_LIBS}) + endif (CMAKE_LIB_SOCKET_HAS_CONNECT) + endif (NOT CMAKE_HAVE_CONNECT) + + # Find library needed for remove. + CHECK_FUNCTION_EXISTS("remove" CMAKE_HAVE_REMOVE) + if (NOT CMAKE_HAVE_REMOVE) + CHECK_LIBRARY_EXISTS("posix" "remove" "" CMAKE_LIB_POSIX_HAS_REMOVE) + if (CMAKE_LIB_POSIX_HAS_REMOVE) + set(X11_X_EXTRA_LIBS ${X11_X_EXTRA_LIBS} -lposix) + endif (CMAKE_LIB_POSIX_HAS_REMOVE) + endif (NOT CMAKE_HAVE_REMOVE) + + # Find library needed for shmat. + CHECK_FUNCTION_EXISTS("shmat" CMAKE_HAVE_SHMAT) + if (NOT CMAKE_HAVE_SHMAT) + CHECK_LIBRARY_EXISTS("ipc" "shmat" "" CMAKE_LIB_IPS_HAS_SHMAT) + if (CMAKE_LIB_IPS_HAS_SHMAT) + set(X11_X_EXTRA_LIBS ${X11_X_EXTRA_LIBS} -lipc) + endif (CMAKE_LIB_IPS_HAS_SHMAT) + endif (NOT CMAKE_HAVE_SHMAT) + endif ($ENV{ISC} MATCHES "^yes$") + + CHECK_LIBRARY_EXISTS("ICE" "IceConnectionNumber" "${X11_LIBRARY_DIR}" + CMAKE_LIB_ICE_HAS_ICECONNECTIONNUMBER) + if (CMAKE_LIB_ICE_HAS_ICECONNECTIONNUMBER) + set(X11_X_PRE_LIBS -lSM -lICE) + endif (CMAKE_LIB_ICE_HAS_ICECONNECTIONNUMBER) + # Build the final list of libraries. + set(X11_LIBRARIES ${X11_X_PRE_LIBS} ${X11_LIBRARIES} ${X11_X_EXTRA_LIBS}) + endif (X11_FOUND) + + MARK_AS_ADVANCED( + X11_X11_INCLUDE_PATH + X11_X11_LIB + X11_Xext_LIB + X11_Xau_LIB + X11_Xlib_INCLUDE_PATH + X11_Xutil_INCLUDE_PATH + X11_Xcomposite_INCLUDE_PATH + X11_Xcomposite_LIB + X11_Xaccess_INCLUDE_PATH + X11_Xfixes_LIB + X11_Xfixes_INCLUDE_PATH + X11_Xrandr_LIB + X11_Xrandr_INCLUDE_PATH + X11_Xdamage_LIB + X11_Xdamage_INCLUDE_PATH + X11_Xrender_LIB + X11_Xrender_INCLUDE_PATH + X11_Xxf86misc_LIB + X11_Xxf86misc_INCLUDE_PATH + X11_Xinerama_LIB + X11_Xinerama_INCLUDE_PATH + X11_XTest_LIB + X11_XTest_INCLUDE_PATH + X11_Xcursor_LIB + X11_Xcursor_INCLUDE_PATH + X11_dpms_INCLUDE_PATH + X11_Xt_LIB + X11_Xss_LIB + X11_Xdmcp_LIB + X11_LIBRARIES + X11_Xaccessrules_INCLUDE_PATH + X11_Xaccessstr_INCLUDE_PATH + X11_Xdmcp_INCLUDE_PATH + X11_Xf86misc_INCLUDE_PATH + X11_Xkb_INCLUDE_PATH + X11_Xkblib_INCLUDE_PATH + X11_Xscreensaver_INCLUDE_PATH + X11_Xpm_INCLUDE_PATH + X11_Xpm_LIB + X11_Xinput_LIB + X11_Xinput_INCLUDE_PATH + X11_Xft_LIB + X11_Xft_INCLUDE_PATH + X11_Xshape_INCLUDE_PATH + X11_Xv_LIB + X11_Xv_INCLUDE_PATH + ) + +endif (UNIX) diff --git a/cmakemodules/KDE3Macros.cmake b/cmakemodules/KDE3Macros.cmake new file mode 100644 index 0000000..f132854 --- /dev/null +++ b/cmakemodules/KDE3Macros.cmake @@ -0,0 +1,392 @@ +# + +# See FindKDE3.cmake for documentation. +# +# this file contains the following macros: +# KDE3_ADD_DCOP_SKELS +# KDE3_ADD_DCOP_STUBS +# KDE3_ADD_MOC_FILES +# KDE3_ADD_UI_FILES +# KDE3_ADD_KCFG_FILES +# KDE3_AUTOMOC +# KDE3_INSTALL_LIBTOOL_FILE +# KDE3_CREATE_FINAL_FILE +# KDE3_ADD_KPART +# KDE3_ADD_KDEINIT_EXECUTABLE +# KDE3_ADD_EXECUTABLE + +#neundorf@kde.org +# +# Modified by PhobosK + +INCLUDE(AddFileDependencies) + +#create the kidl and skeletion file for dcop stuff +#usage: KDE_ADD_COP_SKELS(foo_SRCS ${dcop_headers}) +MACRO(KDE3_ADD_DCOP_SKELS _sources) + FOREACH (_current_FILE ${ARGN}) + + GET_FILENAME_COMPONENT(_tmp_FILE ${_current_FILE} ABSOLUTE) + GET_FILENAME_COMPONENT(_basename ${_tmp_FILE} NAME_WE) + + SET(_skel ${CMAKE_CURRENT_BINARY_DIR}/${_basename}_skel.cpp) + SET(_kidl ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.kidl) + + IF (NOT HAVE_${_basename}_KIDL_RULE) + SET(HAVE_${_basename}_KIDL_RULE ON) + + ADD_CUSTOM_COMMAND(OUTPUT ${_kidl} + COMMAND ${KDE3_DCOPIDL_EXECUTABLE} + ARGS ${CMAKE_CURRENT_SOURCE_DIR}/${_current_FILE} > ${_kidl} + DEPENDS ${_tmp_FILE} + ) + ENDIF (NOT HAVE_${_basename}_KIDL_RULE) + + IF (NOT HAVE_${_basename}_SKEL_RULE) + SET(HAVE_${_basename}_SKEL_RULE ON) + + ADD_CUSTOM_COMMAND(OUTPUT ${_skel} + COMMAND ${KDE3_DCOPIDL2CPP_EXECUTABLE} + ARGS --c++-suffix cpp --no-signals --no-stub ${_kidl} + DEPENDS ${_kidl} + ) + + ENDIF (NOT HAVE_${_basename}_SKEL_RULE) + + SET(${_sources} ${${_sources}} ${_skel}) + + ENDFOREACH (_current_FILE) + +ENDMACRO(KDE3_ADD_DCOP_SKELS) + + +MACRO(KDE3_ADD_DCOP_STUBS _sources) + FOREACH (_current_FILE ${ARGN}) + + GET_FILENAME_COMPONENT(_tmp_FILE ${_current_FILE} ABSOLUTE) + + GET_FILENAME_COMPONENT(_basename ${_tmp_FILE} NAME_WE) + + SET(_stub_CPP ${CMAKE_CURRENT_BINARY_DIR}/${_basename}_stub.cpp) + SET(_kidl ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.kidl) + + IF (NOT HAVE_${_basename}_KIDL_RULE) + SET(HAVE_${_basename}_KIDL_RULE ON) + + + ADD_CUSTOM_COMMAND(OUTPUT ${_kidl} + COMMAND ${KDE3_DCOPIDL_EXECUTABLE} + ARGS ${tmp_FILE} > ${_kidl} + DEPENDS ${tmp_FILE} + ) + + ENDIF (NOT HAVE_${_basename}_KIDL_RULE) + + + IF (NOT HAVE_${_basename}_STUB_RULE) + SET(HAVE_${_basename}_STUB_RULE ON) + + ADD_CUSTOM_COMMAND(OUTPUT ${_stub_CPP} + COMMAND ${KDE3_DCOPIDL2CPP_EXECUTABLE} + ARGS --c++-suffix cpp --no-signals --no-skel ${_kidl} + DEPENDS ${_kidl} + ) + + ENDIF (NOT HAVE_${_basename}_STUB_RULE) + + SET(${_sources} ${${_sources}} ${_stub_CPP}) + + ENDFOREACH (_current_FILE) + +ENDMACRO(KDE3_ADD_DCOP_STUBS) + + +MACRO(KDE3_ADD_KCFG_FILES _sources) + FOREACH (_current_FILE ${ARGN}) + + GET_FILENAME_COMPONENT(_tmp_FILE ${_current_FILE} ABSOLUTE) + + GET_FILENAME_COMPONENT(_basename ${_tmp_FILE} NAME_WE) + + FILE(READ ${_tmp_FILE} _contents) + STRING(REGEX REPLACE "^(.*\n)?File=([^\n]+)\n.*$" "\\2" _kcfg_FILE "${_contents}") + + SET(_src_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp) + SET(_header_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h) + + ADD_CUSTOM_COMMAND(OUTPUT ${_src_FILE} + COMMAND ${KDE3_KCFGC_EXECUTABLE} + ARGS ${CMAKE_CURRENT_SOURCE_DIR}/${_kcfg_FILE} ${_tmp_FILE} + DEPENDS ${_tmp_FILE} ${CMAKE_CURRENT_SOURCE_DIR}/${_kcfg_FILE} ) + + SET(${_sources} ${${_sources}} ${_src_FILE}) + + ENDFOREACH (_current_FILE) + +ENDMACRO(KDE3_ADD_KCFG_FILES) + + +#create the moc files and add them to the list of sources +#usage: KDE_ADD_MOC_FILES(foo_SRCS ${moc_headers}) +MACRO(KDE3_ADD_MOC_FILES _sources) + FOREACH (_current_FILE ${ARGN}) + + GET_FILENAME_COMPONENT(_tmp_FILE ${_current_FILE} ABSOLUTE) + + GET_FILENAME_COMPONENT(_basename ${_tmp_FILE} NAME_WE) + SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc.cpp) + + ADD_CUSTOM_COMMAND(OUTPUT ${_moc} + COMMAND ${QT_MOC_EXECUTABLE} + ARGS ${_tmp_FILE} -o ${_moc} + DEPENDS ${_tmp_FILE} + ) + + SET(${_sources} ${${_sources}} ${_moc}) + + ENDFOREACH (_current_FILE) +ENDMACRO(KDE3_ADD_MOC_FILES) + + +GET_FILENAME_COMPONENT( KDE3_MODULE_DIR ${CMAKE_CURRENT_LIST_FILE} PATH) + +#create the implementation files from the ui files and add them to the list of sources +#usage: KDE_ADD_UI_FILES(foo_SRCS ${ui_files}) +MACRO(KDE3_ADD_UI_FILES _sources ) + FOREACH (_current_FILE ${ARGN}) + + GET_FILENAME_COMPONENT(_tmp_FILE ${_current_FILE} ABSOLUTE) + + GET_FILENAME_COMPONENT(_basename ${_tmp_FILE} NAME_WE) + SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h) + SET(_src ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp) + SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc.cpp) + + ADD_CUSTOM_COMMAND(OUTPUT ${_header} + COMMAND ${QT_UIC_EXECUTABLE} + ARGS -L ${KDE3_LIB_DIR}/kde3/plugins/designer -nounload -o ${_header} ${CMAKE_CURRENT_SOURCE_DIR}/${_current_FILE} + DEPENDS ${_tmp_FILE} + ) + + ADD_CUSTOM_COMMAND(OUTPUT ${_src} + COMMAND ${CMAKE_COMMAND} + ARGS + -DKDE_UIC_PLUGIN_DIR:FILEPATH=${KDE3_LIB_DIR}/kde3/plugins/designer + -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC_EXECUTABLE} + -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE} + -DKDE_UIC_CPP_FILE:FILEPATH=${_src} + -DKDE_UIC_H_FILE:FILEPATH=${_header} + -P ${KDE3_MODULE_DIR}/kde3uic.cmake + DEPENDS ${_header} + ) + + ADD_CUSTOM_COMMAND(OUTPUT ${_moc} + COMMAND ${QT_MOC_EXECUTABLE} + ARGS ${_header} -o ${_moc} + DEPENDS ${_header} + ) + + SET(${_sources} ${${_sources}} ${_src} ${_moc} ) + + ENDFOREACH (_current_FILE) +ENDMACRO(KDE3_ADD_UI_FILES) + + +MACRO(KDE3_AUTOMOC) + SET(_matching_FILES ) + FOREACH (_current_FILE ${ARGN}) + + GET_FILENAME_COMPONENT(_abs_FILE ${_current_FILE} ABSOLUTE) + + # if "SKIP_AUTOMOC" is set to true, we will not handle this file here. + # here. this is required to make bouic work correctly: + # we need to add generated .cpp files to the sources (to compile them), + # but we cannot let automoc handle them, as the .cpp files don't exist yet when + # cmake is run for the very first time on them -> however the .cpp files might + # exist at a later run. at that time we need to skip them, so that we don't add two + # different rules for the same moc file + GET_SOURCE_FILE_PROPERTY(_skip ${_abs_FILE} SKIP_AUTOMOC) + + IF (EXISTS ${_abs_FILE} AND NOT _skip) + + FILE(READ ${_abs_FILE} _contents) + + GET_FILENAME_COMPONENT(_abs_PATH ${_abs_FILE} PATH) + + STRING(REGEX MATCHALL "#include +[^ ]+\\.moc[\">]" _match "${_contents}") + IF(_match) + FOREACH (_current_MOC_INC ${_match}) + STRING(REGEX MATCH "[^ <\"]+\\.moc" _current_MOC "${_current_MOC_INC}") + + GET_FILENAME_COMPONENT(_basename ${_current_MOC} NAME_WE) +# SET(_header ${CMAKE_CURRENT_SOURCE_DIR}/${_basename}.h) + SET(_header ${_abs_PATH}/${_basename}.h) + SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_current_MOC}) + + ADD_CUSTOM_COMMAND(OUTPUT ${_moc} + COMMAND ${QT_MOC_EXECUTABLE} + ARGS ${_header} -o ${_moc} + DEPENDS ${_header} + ) + + ADD_FILE_DEPENDENCIES(${_abs_FILE} ${_moc}) + + ENDFOREACH (_current_MOC_INC) + ENDIF(_match) + + ENDIF (EXISTS ${_abs_FILE} AND NOT _skip) + ENDFOREACH (_current_FILE) +ENDMACRO(KDE3_AUTOMOC) + +# only used internally by KDE3_INSTALL_ICONS +MACRO (_KDE3_ADD_ICON_INSTALL_RULE _install_SCRIPT _install_PATH _group _orig_NAME _install_NAME) + + # if the string doesn't match the pattern, the result is the full string, so all three have the same content + IF (NOT ${_group} STREQUAL ${_install_NAME} ) + SET(_icon_GROUP "actions") + + IF (${_group} STREQUAL "mime") + SET(_icon_GROUP "mimetypes") + ENDIF (${_group} STREQUAL "mime") + + IF (${_group} STREQUAL "filesys") + SET(_icon_GROUP "filesystems") + ENDIF (${_group} STREQUAL "filesys") + + IF (${_group} STREQUAL "device") + SET(_icon_GROUP "devices") + ENDIF (${_group} STREQUAL "device") + + IF (${_group} STREQUAL "app") + SET(_icon_GROUP "apps") + ENDIF (${_group} STREQUAL "app") + + IF (${_group} STREQUAL "action") + SET(_icon_GROUP "actions") + ENDIF (${_group} STREQUAL "action") + +# message(STATUS "icon: ${_current_ICON} size: ${_size} group: ${_group} name: ${_name}" ) + INSTALL(FILES ${_orig_NAME} DESTINATION ${_install_PATH}/${_icon_GROUP}/ RENAME ${_install_NAME} ) + ENDIF (NOT ${_group} STREQUAL ${_install_NAME} ) + +ENDMACRO (_KDE3_ADD_ICON_INSTALL_RULE) + + +MACRO (KDE3_INSTALL_ICONS _theme ) + SET(_defaultpath "${CMAKE_INSTALL_PREFIX}/share/icons") + # first the png icons + FILE(GLOB _icons *.png) + FOREACH (_current_ICON ${_icons} ) + STRING(REGEX REPLACE "^.*/[a-zA-Z]+([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\1" _size "${_current_ICON}") + STRING(REGEX REPLACE "^.*/[a-zA-Z]+([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\2" _group "${_current_ICON}") + STRING(REGEX REPLACE "^.*/[a-zA-Z]+([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\3" _name "${_current_ICON}") + _KDE3_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake + ${_defaultpath}/${_theme}/${_size}x${_size} + ${_group} ${_current_ICON} ${_name}) + ENDFOREACH (_current_ICON) + + # and now the svg icons + FILE(GLOB _icons *.svgz) + FOREACH (_current_ICON ${_icons} ) + STRING(REGEX REPLACE "^.*/crsc\\-([a-z]+)\\-(.+\\.svgz)$" "\\1" _group "${_current_ICON}") + STRING(REGEX REPLACE "^.*/crsc\\-([a-z]+)\\-(.+\\.svgz)$" "\\2" _name "${_current_ICON}") + _KDE3_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake + ${_defaultpath}/${_theme}/scalable + ${_group} ${_current_ICON} ${_name}) + ENDFOREACH (_current_ICON) + +ENDMACRO (KDE3_INSTALL_ICONS) + +MACRO(KDE3_INSTALL_LIBTOOL_FILE _target _place) + GET_TARGET_PROPERTY(_target_location ${_target} LOCATION) + + GET_FILENAME_COMPONENT(_laname ${_target_location} NAME_WE) + GET_FILENAME_COMPONENT(_soname ${_target_location} NAME) + SET(_laname ${CMAKE_CURRENT_BINARY_DIR}/${_laname}.la) + + FILE(WRITE ${_laname} "# ${_laname} - a libtool library file, generated by cmake \n") + FILE(APPEND ${_laname} "# The name that we can dlopen(3).\n") + FILE(APPEND ${_laname} "dlname='${_soname}'\n") + FILE(APPEND ${_laname} "# Names of this library\n") + FILE(APPEND ${_laname} "library_names='${_soname} ${_soname} ${_soname}'\n") + FILE(APPEND ${_laname} "# The name of the static archive\n") + FILE(APPEND ${_laname} "old_library=''\n") + FILE(APPEND ${_laname} "# Libraries that this one depends upon.\n") + FILE(APPEND ${_laname} "dependency_libs=''\n") +# FILE(APPEND ${_laname} "dependency_libs='${${_target}_LIB_DEPENDS}'\n") + FILE(APPEND ${_laname} "# Version information.\ncurrent=0\nage=0\nrevision=0\n") + FILE(APPEND ${_laname} "# Is this an already installed library?\ninstalled=yes\n") + FILE(APPEND ${_laname} "# Should we warn about portability when linking against -modules?\nshouldnotlink=yes\n") + FILE(APPEND ${_laname} "# Files to dlopen/dlpreopen\ndlopen=''\ndlpreopen=''\n") + FILE(APPEND ${_laname} "# Directory that this library needs to be installed in:\n") + FILE(APPEND ${_laname} "libdir='${_place}'\n") + INSTALL(FILES ${_laname} DESTINATION ${_place}) +ENDMACRO(KDE3_INSTALL_LIBTOOL_FILE) + + +MACRO(KDE3_CREATE_FINAL_FILE _filename) + FILE(WRITE ${_filename} "//autogenerated file\n") + FOREACH (_current_FILE ${ARGN}) + FILE(APPEND ${_filename} "#include \"${_current_FILE}\"\n") + ENDFOREACH (_current_FILE) + +ENDMACRO(KDE3_CREATE_FINAL_FILE) + + +OPTION(KDE3_ENABLE_FINAL "Enable final all-in-one compilation") +OPTION(KDE3_BUILD_TESTS "Build the tests") + + +MACRO(KDE3_ADD_KPART _target_NAME _with_PREFIX) +#is the first argument is "WITH_PREFIX" then keep the standard "lib" prefix, otherwise SET the prefix empty + IF (${_with_PREFIX} STREQUAL "WITH_PREFIX") + SET(_first_SRC) + ELSE (${_with_PREFIX} STREQUAL "WITH_PREFIX") + SET(_first_SRC ${_with_PREFIX}) + ENDIF (${_with_PREFIX} STREQUAL "WITH_PREFIX") + + IF (KDE3_ENABLE_FINAL) + KDE3_CREATE_FINAL_FILE(${_target_NAME}_final.cpp ${_first_SRC} ${ARGN}) + ADD_LIBRARY(${_target_NAME} MODULE ${_target_NAME}_final.cpp) + ELSE (KDE3_ENABLE_FINAL) + ADD_LIBRARY(${_target_NAME} MODULE ${_first_SRC} ${ARGN}) + ENDIF (KDE3_ENABLE_FINAL) + + IF(_first_SRC) + SET_TARGET_PROPERTIES(${_target_NAME} PROPERTIES PREFIX "") + ENDIF(_first_SRC) + + KDE3_INSTALL_LIBTOOL_FILE(${_target_NAME}) + +ENDMACRO(KDE3_ADD_KPART) + + +MACRO(KDE3_ADD_KDEINIT_EXECUTABLE _target_NAME ) + + IF (KDE3_ENABLE_FINAL) + KDE3_CREATE_FINAL_FILE(${_target_NAME}_final.cpp ${ARGN}) + ADD_LIBRARY(kdeinit_${_target_NAME} SHARED ${_target_NAME}_final.cpp) + ELSE (KDE3_ENABLE_FINAL) + ADD_LIBRARY(kdeinit_${_target_NAME} SHARED ${ARGN} ) + ENDIF (KDE3_ENABLE_FINAL) + + CONFIGURE_FILE(${KDE3_MODULE_DIR}/kde3init_dummy.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp) + + ADD_EXECUTABLE( ${_target_NAME} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ) + TARGET_LINK_LIBRARIES( ${_target_NAME} kdeinit_${_target_NAME} ) + +ENDMACRO(KDE3_ADD_KDEINIT_EXECUTABLE) + + +MACRO(KDE3_ADD_EXECUTABLE _target_NAME ) + + IF (KDE3_ENABLE_FINAL) + KDE3_CREATE_FINAL_FILE(${_target_NAME}_final.cpp ${ARGN}) + ADD_EXECUTABLE(${_target_NAME} ${_target_NAME}_final.cpp) + ELSE (KDE3_ENABLE_FINAL) + ADD_EXECUTABLE(${_target_NAME} ${ARGN} ) + ENDIF (KDE3_ENABLE_FINAL) + +ENDMACRO(KDE3_ADD_EXECUTABLE) + + diff --git a/cmakemodules/KDE4Macros.cmake b/cmakemodules/KDE4Macros.cmake new file mode 100644 index 0000000..8be1538 --- /dev/null +++ b/cmakemodules/KDE4Macros.cmake @@ -0,0 +1,854 @@ +# for documentation look at FindKDE4Internal.cmake +# +# this file contains the following macros: +# KDE4_ADD_UI_FILES +# KDE4_ADD_UI3_FILES +# KDE4_ADD_KCFG_FILES +# KDE4_AUTOMOC +# KDE4_INSTALL_LIBTOOL_FILE +# KDE4_CREATE_FINAL_FILES +# KDE4_ADD_KDEINIT_EXECUTABLE +# KDE4_ADD_EXECUTABLE +# KDE4_ADD_WIDGET_FILES +# KDE4_INSTALL_ICONS +# KDE4_REMOVE_OBSOLETE_CMAKE_FILES +# KDE4_NO_ENABLE_FINAL +# KDE4_CREATE_HANDBOOK +# KDE4_CREATE_HTML_HANDBOOK +# KDE4_INSTALL_HANDBOOK + +# Copyright (c) 2006, 2007, Alexander Neundorf, +# Copyright (c) 2006, 2007, Laurent Montel, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. +# +# Modified by PhobosK + +macro (KDE4_ADD_KCFG_FILES _sources ) + if( ${ARGV1} STREQUAL "GENERATE_MOC" ) + set(_kcfg_generatemoc TRUE) + endif( ${ARGV1} STREQUAL "GENERATE_MOC" ) + + foreach (_current_FILE ${ARGN}) + + if(NOT ${_current_FILE} STREQUAL "GENERATE_MOC") + get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE) + get_filename_component(_abs_PATH ${_tmp_FILE} PATH) + get_filename_component(_basename ${_tmp_FILE} NAME_WE) + + file(READ ${_tmp_FILE} _contents) + string(REGEX REPLACE "^(.*\n)?File=([^\n]+kcfg).*\n.*$" "\\2" _kcfg_FILE "${_contents}") + set(_src_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp) + set(_header_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h) + set(_moc_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc) + + # the command for creating the source file from the kcfg file + add_custom_command(OUTPUT ${_header_FILE} ${_src_FILE} + COMMAND ${KDE4_KCFGC_EXECUTABLE} + ARGS ${_abs_PATH}/${_kcfg_FILE} ${_tmp_FILE} -d ${CMAKE_CURRENT_BINARY_DIR} + MAIN_DEPENDENCY ${_tmp_FILE} + DEPENDS ${_abs_PATH}/${_kcfg_FILE} ${_KDE4_KCONFIG_COMPILER_DEP} ) + + if(_kcfg_generatemoc) + qt4_generate_moc(${_header_FILE} ${_moc_FILE} ) + set_source_files_properties(${_src_FILE} PROPERTIES SKIP_AUTOMOC TRUE) # dont run automoc on this file + list(APPEND ${_sources} ${_moc_FILE}) + endif(_kcfg_generatemoc) + +# if (KDE4_ENABLE_FINAL) +# kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${ARGN}) +# macro_add_file_dependencies(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_src_FILE}) +# endif (KDE4_ENABLE_FINAL) + + list(APPEND ${_sources} ${_src_FILE} ${_header_FILE}) + endif(NOT ${_current_FILE} STREQUAL "GENERATE_MOC") + endforeach (_current_FILE) + +endmacro (KDE4_ADD_KCFG_FILES) + + +GET_FILENAME_COMPONENT(KDE4_MODULE_DIR ${CMAKE_CURRENT_LIST_FILE} PATH) + +#create the implementation files from the ui files and add them to the list of sources +#usage: KDE4_ADD_UI_FILES(foo_SRCS ${ui_files}) +macro (KDE4_ADD_UI_FILES _sources ) + foreach (_current_FILE ${ARGN}) + + get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE) + get_filename_component(_basename ${_tmp_FILE} NAME_WE) + set(_header ${CMAKE_CURRENT_BINARY_DIR}/ui_${_basename}.h) + + # we need to run uic and replace some things in the generated file + # this is done by executing the cmake script kde4uic.cmake + add_custom_command(OUTPUT ${_header} + COMMAND ${CMAKE_COMMAND} + ARGS + -DKDE4_HEADER:BOOL=ON + -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC_EXECUTABLE} + -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE} + -DKDE_UIC_H_FILE:FILEPATH=${_header} + -DKDE_UIC_BASENAME:STRING=${_basename} + -P ${KDE4_MODULE_DIR}/kde4uic.cmake + MAIN_DEPENDENCY ${_tmp_FILE} + ) + list(APPEND ${_sources} ${_header}) + endforeach (_current_FILE) +endmacro (KDE4_ADD_UI_FILES) + + +#create the implementation files from the ui files and add them to the list of sources +#usage: KDE4_ADD_UI3_FILES(foo_SRCS ${ui_files}) +macro (KDE4_ADD_UI3_FILES _sources ) + + qt4_get_moc_inc_dirs(_moc_INCS) + + foreach (_current_FILE ${ARGN}) + + get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE) + get_filename_component(_basename ${_tmp_FILE} NAME_WE) + set(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h) + set(_src ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp) + set(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc.cpp) + + add_custom_command(OUTPUT ${_header} + COMMAND ${CMAKE_COMMAND} + -DKDE3_HEADER:BOOL=ON + -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC3_EXECUTABLE} + -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE} + -DKDE_UIC_H_FILE:FILEPATH=${_header} + -DKDE_UIC_BASENAME:STRING=${_basename} + -DKDE_UIC_PLUGIN_DIR:FILEPATH="." + -P ${KDE4_MODULE_DIR}/kde4uic.cmake + MAIN_DEPENDENCY ${_tmp_FILE} + ) + +# we need to run uic3 and replace some things in the generated file + # this is done by executing the cmake script kde4uic.cmake + add_custom_command(OUTPUT ${_src} + COMMAND ${CMAKE_COMMAND} + ARGS + -DKDE3_IMPL:BOOL=ON + -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC3_EXECUTABLE} + -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE} + -DKDE_UIC_CPP_FILE:FILEPATH=${_src} + -DKDE_UIC_H_FILE:FILEPATH=${_header} + -DKDE_UIC_BASENAME:STRING=${_basename} + -DKDE_UIC_PLUGIN_DIR:FILEPATH="." + -P ${KDE4_MODULE_DIR}/kde4uic.cmake + MAIN_DEPENDENCY ${_header} + ) + + add_custom_command(OUTPUT ${_moc} + COMMAND ${QT_MOC_EXECUTABLE} + ARGS ${_moc_INCS} ${_header} -o ${_moc} + MAIN_DEPENDENCY ${_header} + ) + list(APPEND ${_sources} ${_src} ${_moc} ) + + endforeach (_current_FILE) +endmacro (KDE4_ADD_UI3_FILES) + + +macro (KDE4_AUTOMOC) + qt4_get_moc_inc_dirs(_moc_INCS) + + # iterate over all files + foreach (_current_FILE ${ARGN}) + + get_filename_component(_abs_FILE ${_current_FILE} ABSOLUTE) + # if "SKIP_AUTOMOC" is set to true, we will not handle this file here. + # here. this is required to make bouic work correctly: + # we need to add generated .cpp files to the sources (to compile them), + # but we cannot let automoc handle them, as the .cpp files don't exist yet when + # cmake is run for the very first time on them -> however the .cpp files might + # exist at a later run. at that time we need to skip them, so that we don't add two + # different rules for the same moc file + get_source_file_property(_skip ${_abs_FILE} SKIP_AUTOMOC) + + # if the file exists and should not be skipped read it completely into memory + # and grep for all include lines + # for each found moc file generate a custom_target and collect + # the generated moc files in a list which will be set as a source files property + # and later be queried in kde4_add_library/executable/plugin() + if (EXISTS ${_abs_FILE} AND NOT _skip) + set(_moc_FILES_PROPERTY) + + file(READ ${_abs_FILE} _contents) + get_filename_component(_abs_PATH ${_abs_FILE} PATH) + + string(REGEX MATCHALL "#include +[^ ]+\\.moc[\">]" _match "${_contents}") + if (_match) + foreach (_current_MOC_INC ${_match}) + string(REGEX MATCH "[^ <\"]+\\.moc" _current_MOC "${_current_MOC_INC}") + get_filename_component(_basename ${_current_MOC} NAME_WE) + set(_header ${_abs_PATH}/${_basename}.h) + set(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_current_MOC}) + + if (NOT EXISTS ${_abs_PATH}/${_basename}.h) + message(FATAL_ERROR "In the file \"${_abs_FILE}\" the moc file \"${_current_MOC}\" is included, but \"${_abs_PATH}/${_basename}.h\" doesn't exist.") + endif (NOT EXISTS ${_abs_PATH}/${_basename}.h) + + add_custom_command(OUTPUT ${_moc} + COMMAND ${QT_MOC_EXECUTABLE} + ARGS ${_moc_INCS} ${_header} -o ${_moc} + MAIN_DEPENDENCY ${_header} + ) + + list(APPEND _moc_FILES_PROPERTY ${_moc}) + +# if (KDE4_ENABLE_FINAL) +# kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${ARGN}) +# macro_add_file_dependencies(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_moc}) +# else (KDE4_ENABLE_FINAL) +# macro_add_file_dependencies(${_abs_FILE} ${_moc}) +# endif (KDE4_ENABLE_FINAL) + + endforeach (_current_MOC_INC) + endif (_match) + + set_source_files_properties(${_abs_FILE} PROPERTIES AUTOMOC_FILES "${_moc_FILES_PROPERTY}") + endif (EXISTS ${_abs_FILE} AND NOT _skip) + endforeach (_current_FILE) +endmacro (KDE4_AUTOMOC) + + +macro(KDE4_GET_AUTOMOC_FILES _list) + set(${_list}) + foreach (_current_FILE ${ARGN}) + set(_automoc_FILES_PROPERTY) + get_filename_component(_abs_FILE ${_current_FILE} ABSOLUTE) + get_source_file_property(_automoc_FILES_PROPERTY ${_abs_FILE} AUTOMOC_FILES) + if (_automoc_FILES_PROPERTY) + foreach (_current_MOC_FILE ${_automoc_FILES_PROPERTY}) + list(APPEND ${_list} ${_current_MOC_FILE}) + endforeach (_current_MOC_FILE) + endif (_automoc_FILES_PROPERTY) + endforeach (_current_FILE) +endmacro(KDE4_GET_AUTOMOC_FILES) + +macro (KDE4_INSTALL_HANDBOOK ) + get_filename_component(_tmp_FILE ${CMAKE_CURRENT_SOURCE_DIR} ABSOLUTE) + get_filename_component(_basename ${_tmp_FILE} NAME_WE) + file(GLOB _books *.docbook) + file(GLOB _images *.png) + set(relative ${ARGV0}) + set( dirname ${relative}/${_basename}) + FILE(MAKE_DIRECTORY ${HTML_INSTALL_DIR}/en/${dirname}) + install(FILES ${CMAKE_CURRENT_BINARY_DIR}/index.cache.bz2 ${_books} ${_images} DESTINATION ${HTML_INSTALL_DIR}/en/${dirname}) + # TODO symlinks on non-unix platforms + if (UNIX) + ADD_CUSTOM_COMMAND(OUTPUT "${HTML_INSTALL_DIR}/en/${dirname}/common" + DEPENDS "${HTML_INSTALL_DIR}/en/common" + COMMAND /bin/ln + ARGS -s "${HTML_INSTALL_DIR}/en/common" "${HTML_INSTALL_DIR}/en/${dirname}/common" + COMMENT "Symlink") + ADD_CUSTOM_TARGET(CreateSymlinks ALL DEPENDS ${HTML_INSTALL_DIR}/en/${dirname}/common) + endif (UNIX) +endmacro (KDE4_INSTALL_HANDBOOK ) + +macro (KDE4_CREATE_HANDBOOK _docbook) + get_filename_component(_input ${_docbook} ABSOLUTE) + set(_doc ${CMAKE_CURRENT_BINARY_DIR}/index.cache.bz2) + set(_ssheet ${DATA_INSTALL_DIR}/ksgmltools2/customization/kde-chunk.xsl) + add_custom_command(OUTPUT ${_doc} + COMMAND ${KDE4_MEINPROC_EXECUTABLE} --check --cache ${_doc} ${_input} + DEPENDS ${_input} ${_KDE4_MEINPROC_EXECUTABLE_DEP} ${_ssheet} + ) + add_custom_target(handbook ALL DEPENDS ${_doc}) +endmacro (KDE4_CREATE_HANDBOOK) + +macro (KDE4_CREATE_HTML_HANDBOOK _docbook) + get_filename_component(_input ${_docbook} ABSOLUTE) + set(_doc ${CMAKE_CURRENT_SOURCE_DIR}/index.html) + set(_ssheet ${DATA_INSTALL_DIR}/ksgmltools2/customization/kde-chunk.xsl) + add_custom_command(OUTPUT ${_doc} + COMMAND ${KDE4_MEINPROC_EXECUTABLE} --check -o ${_doc} ${_input} + DEPENDS ${_input} ${_KDE4_MEINPROC_EXECUTABLE_DEP} ${_ssheet} + ) + add_custom_target(htmlhandbook ALL DEPENDS ${_doc}) +endmacro (KDE4_CREATE_HTML_HANDBOOK) + +# only used internally by KDE4_INSTALL_ICONS +MACRO (_KDE4_ADD_ICON_INSTALL_RULE _install_SCRIPT _install_PATH _group _orig_NAME _install_NAME) + + # if the string doesn't match the pattern, the result is the full string, so all three have the same content + IF (NOT ${_group} STREQUAL ${_install_NAME} ) + SET(_icon_GROUP "actions") + + IF (${_group} STREQUAL "mime") + SET(_icon_GROUP "mimetypes") + ENDIF (${_group} STREQUAL "mime") + + IF (${_group} STREQUAL "filesys") + SET(_icon_GROUP "filesystems") + ENDIF (${_group} STREQUAL "filesys") + + IF (${_group} STREQUAL "device") + SET(_icon_GROUP "devices") + ENDIF (${_group} STREQUAL "device") + + IF (${_group} STREQUAL "app") + SET(_icon_GROUP "apps") + ENDIF (${_group} STREQUAL "app") + + IF (${_group} STREQUAL "action") + SET(_icon_GROUP "actions") + ENDIF (${_group} STREQUAL "action") + +# message(STATUS "icon: ${_current_ICON} size: ${_size} group: ${_group} name: ${_name}" ) + INSTALL(FILES ${_orig_NAME} DESTINATION ${_install_PATH}/${_icon_GROUP}/ RENAME ${_install_NAME} ) + ENDIF (NOT ${_group} STREQUAL ${_install_NAME} ) + +ENDMACRO (_KDE4_ADD_ICON_INSTALL_RULE) + + +macro (KDE4_INSTALL_ICONS _defaultpath ) + + # first the png icons + file(GLOB _icons *.png) + foreach (_current_ICON ${_icons} ) + string(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\1" _type "${_current_ICON}") + string(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\2" _size "${_current_ICON}") + string(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\3" _group "${_current_ICON}") + string(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\4" _name "${_current_ICON}") + set(_theme_GROUP "nogroup") + + if( ${_type} STREQUAL "ox" ) + set(_theme_GROUP "oxygen") + endif(${_type} STREQUAL "ox" ) + + if( ${_type} STREQUAL "cr" ) + set(_theme_GROUP "crystalsvg") + endif(${_type} STREQUAL "cr" ) + + if( ${_type} STREQUAL "lo" ) + set(_theme_GROUP "locolor") + endif(${_type} STREQUAL "lo" ) + + if( ${_type} STREQUAL "hi" ) + set(_theme_GROUP "hicolor") + endif(${_type} STREQUAL "hi" ) + + if( NOT ${_theme_GROUP} STREQUAL "nogroup") + _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake + ${_defaultpath}/${_theme_GROUP}/${_size}x${_size} + ${_group} ${_current_ICON} ${_name}) + endif( NOT ${_theme_GROUP} STREQUAL "nogroup") + + endforeach (_current_ICON) + + # mng icons + file(GLOB _icons *.mng) + foreach (_current_ICON ${_icons} ) + STRING(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" "\\1" _type "${_current_ICON}") + STRING(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" "\\2" _size "${_current_ICON}") + STRING(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" "\\3" _group "${_current_ICON}") + STRING(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" "\\4" _name "${_current_ICON}") + SET(_theme_GROUP "nogroup") + + if( ${_type} STREQUAL "ox" ) + SET(_theme_GROUP "oxygen") + endif(${_type} STREQUAL "ox" ) + + if( ${_type} STREQUAL "cr" ) + SET(_theme_GROUP "crystalsvg") + endif(${_type} STREQUAL "cr" ) + + if( ${_type} STREQUAL "lo" ) + set(_theme_GROUP "locolor") + endif(${_type} STREQUAL "lo" ) + + if( ${_type} STREQUAL "hi" ) + set(_theme_GROUP "hicolor") + endif(${_type} STREQUAL "hi" ) + + if( NOT ${_theme_GROUP} STREQUAL "nogroup") + _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake + ${_defaultpath}/${_theme_GROUP}/${_size}x${_size} + ${_group} ${_current_ICON} ${_name}) + endif( NOT ${_theme_GROUP} STREQUAL "nogroup") + + endforeach (_current_ICON) + + + # and now the svg icons + file(GLOB _icons *.svgz) + foreach (_current_ICON ${_icons} ) + STRING(REGEX REPLACE "^.*/([a-zA-Z]+)sc\\-([a-z]+)\\-(.+\\.svgz)$" "\\1" _type "${_current_ICON}") + STRING(REGEX REPLACE "^.*/([a-zA-Z]+)sc\\-([a-z]+)\\-(.+\\.svgz)$" "\\2" _group "${_current_ICON}") + STRING(REGEX REPLACE "^.*/([a-zA-Z]+)sc\\-([a-z]+)\\-(.+\\.svgz)$" "\\3" _name "${_current_ICON}") + SET(_theme_GROUP "nogroup") + + if(${_type} STREQUAL "ox" ) + SET(_theme_GROUP "oxygen") + endif(${_type} STREQUAL "ox" ) + + if(${_type} STREQUAL "cr" ) + SET(_theme_GROUP "crystalsvg") + endif(${_type} STREQUAL "cr" ) + + if(${_type} STREQUAL "hi" ) + SET(_theme_GROUP "hicolor") + endif(${_type} STREQUAL "hi" ) + + if(${_type} STREQUAL "lo" ) + SET(_theme_GROUP "locolor") + endif(${_type} STREQUAL "lo" ) + + if( NOT ${_theme_GROUP} STREQUAL "nogroup") + _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake + ${_defaultpath}/${_theme_GROUP}/scalable + ${_group} ${_current_ICON} ${_name}) + endif( NOT ${_theme_GROUP} STREQUAL "nogroup") + + endforeach (_current_ICON) + +endmacro (KDE4_INSTALL_ICONS) + + +MACRO (KDE4_INSTALL_LIBTOOL_FILE _target _dir) + GET_TARGET_PROPERTY(_target_location ${_target} LOCATION) + + GET_FILENAME_COMPONENT(_laname ${_target_location} NAME_WE) + GET_FILENAME_COMPONENT(_soname ${_target_location} NAME) + set(_laname ${LIBRARY_OUTPUT_PATH}/${_laname}.la) + + FILE(WRITE ${_laname} "# ${_laname} - a libtool library file, generated by cmake \n") + FILE(APPEND ${_laname} "# The name that we can dlopen(3).\n") + FILE(APPEND ${_laname} "dlname='${_soname}'\n") + FILE(APPEND ${_laname} "# Names of this library\n") + FILE(APPEND ${_laname} "library_names='${_soname} ${_soname} ${_soname}'\n") + FILE(APPEND ${_laname} "# The name of the static archive\n") + FILE(APPEND ${_laname} "old_library=''\n") + FILE(APPEND ${_laname} "# Libraries that this one depends upon.\n") + FILE(APPEND ${_laname} "dependency_libs=''\n") +# FILE(APPEND ${_laname} "dependency_libs='${${_target}_LIB_DEPENDS}'\n") + FILE(APPEND ${_laname} "# Version information.\ncurrent=0\nage=0\nrevision=0\n") + FILE(APPEND ${_laname} "# Is this an already installed library?\ninstalled=yes\n") + FILE(APPEND ${_laname} "# Should we warn about portability when linking against -modules?\nshouldnotlink=yes\n") + FILE(APPEND ${_laname} "# Files to dlopen/dlpreopen\ndlopen=''\ndlpreopen=''\n") + FILE(APPEND ${_laname} "# Directory that this library needs to be installed in:\n") + FILE(APPEND ${_laname} "libdir='${_dir}'\n") + + INSTALL(FILES ${_laname} DESTINATION ${_dir}) +ENDMACRO (KDE4_INSTALL_LIBTOOL_FILE) + + +# For all C++ sources a big source file which includes all the files +# is created. +# This is not done for the C sources, they are just gathered in a separate list +# because they are usually not written by KDE and as such not intended to be +# compiled all-in-one. +macro (KDE4_CREATE_FINAL_FILES _filenameCPP _filesExcludedFromFinalFile ) + set(${_filesExcludedFromFinalFile}) + file(WRITE ${_filenameCPP} "//autogenerated file\n") + foreach (_current_FILE ${ARGN}) + get_filename_component(_abs_FILE ${_current_FILE} ABSOLUTE) + # don't include any generated files in the final-file + # because then cmake will not know the dependencies + get_source_file_property(_isGenerated ${_abs_FILE} GENERATED) + if (_isGenerated) + list(APPEND ${_filesExcludedFromFinalFile} ${_abs_FILE}) + else (_isGenerated) + # don't include c-files in the final-file, because they usually come + # from a 3rd party and as such are not intended to be compiled all-in-one + string(REGEX MATCH ".+\\.c$" _isCFile ${_abs_FILE}) + if (_isCFile) + list(APPEND ${_filesExcludedFromFinalFile} ${_abs_FILE}) + else (_isCFile) + file(APPEND ${_filenameCPP} "#include \"${_abs_FILE}\"\n") + endif (_isCFile) + endif (_isGenerated) + endforeach (_current_FILE) + +endmacro (KDE4_CREATE_FINAL_FILES) + +# This macro sets the RPATH related options for libraries, plugins and kdeinit executables. +# It overrides the defaults set in FindKDE4Internal.cmake. +# If RPATH is not explicitely disabled, libraries and plugins are built without RPATH, in +# the hope that the RPATH which is compiled into the executable is good enough. +macro (KDE4_HANDLE_RPATH_FOR_LIBRARY _target_NAME) + if (NOT CMAKE_SKIP_RPATH AND NOT KDE4_USE_ALWAYS_FULL_RPATH) + set_target_properties(${_target_NAME} PROPERTIES INSTALL_RPATH_USE_LINK_PATH FALSE SKIP_BUILD_RPATH TRUE BUILD_WITH_INSTALL_RPATH TRUE INSTALL_RPATH "") + endif (NOT CMAKE_SKIP_RPATH AND NOT KDE4_USE_ALWAYS_FULL_RPATH) +endmacro (KDE4_HANDLE_RPATH_FOR_LIBRARY) + +# This macro sets the RPATH related options for executables +# and creates wrapper shell scripts for the executables. +# It overrides the defaults set in FindKDE4Internal.cmake. +# For every executable a wrapper script is created, which sets the appropriate +# environment variable for the platform (LD_LIBRARY_PATH on most UNIX systems, +# DYLD_LIBRARY_PATH on OS X and PATH in Windows) so that it points to the built +# but not yet installed versions of the libraries. So if RPATH is disabled, the executables +# can be run via these scripts from the build tree and will find the correct libraries. +# If RPATH is not disabled, these scripts are also used but only for consistency, because +# they don't really influence anything then, because the compiled-in RPATH overrides +# the LD_LIBRARY_PATH env. variable. +# Executables with the RUN_UNINSTALLED option will be built with the RPATH pointing to the +# build dir, so that they can be run safely without being installed, e.g. as code generators +# for other stuff during the build. These executables will be relinked during "make install". +# All other executables are built with the RPATH with which they will be installed. +macro (KDE4_HANDLE_RPATH_FOR_EXECUTABLE _target_NAME _type) + if (UNIX) + + # set the RPATH related properties + if (NOT CMAKE_SKIP_RPATH) + if (${_type} STREQUAL "GUI") + set_target_properties(${_target_NAME} PROPERTIES SKIP_BUILD_RPATH TRUE BUILD_WITH_INSTALL_RPATH TRUE) + endif (${_type} STREQUAL "GUI") + + if (${_type} STREQUAL "NOGUI") + set_target_properties(${_target_NAME} PROPERTIES SKIP_BUILD_RPATH TRUE BUILD_WITH_INSTALL_RPATH TRUE) + endif (${_type} STREQUAL "NOGUI") + + if (${_type} STREQUAL "RUN_UNINSTALLED") + set_target_properties(${_target_NAME} PROPERTIES SKIP_BUILD_RPATH FALSE BUILD_WITH_INSTALL_RPATH FALSE) + endif (${_type} STREQUAL "RUN_UNINSTALLED") + endif (NOT CMAKE_SKIP_RPATH) + + if (APPLE) + set(_library_path_variable "DYLD_LIBRARY_PATH") + else (APPLE) + set(_library_path_variable "LD_LIBRARY_PATH") + endif (APPLE) + + set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/:${LIB_INSTALL_DIR}:${KDE4_LIB_DIR}:${QT_LIBRARY_DIR}") + get_target_property(_executable ${_target_NAME} LOCATION ) + + # use add_custom_target() to have the sh-wrapper generated during build time instead of cmake time + add_custom_command(TARGET ${_target_NAME} POST_BUILD + COMMAND ${CMAKE_COMMAND} + -D_filename=${_executable}.shell -D_library_path_variable=${_library_path_variable} + -D_ld_library_path="${_ld_library_path}" -D_executable=${_executable} + -P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake + ) + + macro_additional_clean_files(${_executable}.shell) + + # under UNIX, set the property WRAPPER_SCRIPT to the name of the generated shell script + # so it can be queried and used later on easily + set_target_properties(${_target_NAME} PROPERTIES WRAPPER_SCRIPT ${_executable}.shell) + + else (UNIX) + # under windows, set the property WRAPPER_SCRIPT just to the name of the executable + # maybe later this will change to a generated batch file (for setting the PATH so that the Qt libs are found) + get_target_property(_executable ${_target_NAME} LOCATION ) + set_target_properties(${_target_NAME} PROPERTIES WRAPPER_SCRIPT ${_executable}) + + set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}\;${LIB_INSTALL_DIR}\;${KDE4_LIB_DIR}\;${QT_LIBRARY_DIR}") + get_target_property(_executable ${_target_NAME} LOCATION ) + + # use add_custom_target() to have the batch-file-wrapper generated during build time instead of cmake time + add_custom_command(TARGET ${_target_NAME} POST_BUILD + COMMAND ${CMAKE_COMMAND} + -D_filename="${_executable}.bat" + -D_ld_library_path="${_ld_library_path}" -D_executable="${_executable}" + -P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake + ) + + endif (UNIX) +endmacro (KDE4_HANDLE_RPATH_FOR_EXECUTABLE) + + +macro (KDE4_ADD_PLUGIN _target_NAME _with_PREFIX) +#is the first argument is "WITH_PREFIX" then keep the standard "lib" prefix, otherwise set the prefix empty + if (${_with_PREFIX} STREQUAL "WITH_PREFIX") + set(_first_SRC) + else (${_with_PREFIX} STREQUAL "WITH_PREFIX") + set(_first_SRC ${_with_PREFIX}) + endif (${_with_PREFIX} STREQUAL "WITH_PREFIX") + + kde4_get_automoc_files(_automoc_FILES ${_first_SRC} ${ARGN}) + + if (KDE4_ENABLE_FINAL) + kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_first_SRC} ${ARGN}) + add_library(${_target_NAME} MODULE ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files} ${_automoc_FILES}) + else (KDE4_ENABLE_FINAL) + add_library(${_target_NAME} MODULE ${_first_SRC} ${ARGN} ${_automoc_FILES}) + endif (KDE4_ENABLE_FINAL) + + if (_first_SRC) + set_target_properties(${_target_NAME} PROPERTIES PREFIX "") + endif (_first_SRC) + + kde4_handle_rpath_for_library(${_target_NAME}) + + if (WIN32) + # for shared libraries/plugins a -DMAKE_target_LIB is required + string(TOUPPER ${_target_NAME} _symbol) + set(_symbol "MAKE_${_symbol}_LIB") + set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol}) + endif (WIN32) + +endmacro (KDE4_ADD_PLUGIN _target_NAME _with_PREFIX) + + +# this macro checks is intended to check whether a list of source +# files has the "NOGUI" or "RUN_UNINSTALLED" keywords at the beginning +# in _output_LIST the list of source files is returned with the "NOGUI" +# and "RUN_UNINSTALLED" keywords removed +# if "NOGUI" is in the list of files, the _nogui argument is set to +# "NOGUI" (which evaluates to TRUE in cmake), otherwise it is set empty +# (which evaluates to FALSE in cmake) +# if "RUN_UNINSTALLED" is in the list of files, the _uninst argument is set to +# "RUN_UNINSTALLED" (which evaluates to TRUE in cmake), otherwise it is set empty +# (which evaluates to FALSE in cmake) +macro(KDE4_CHECK_EXECUTABLE_PARAMS _output_LIST _nogui _uninst) + set(${_nogui}) + set(${_uninst}) + set(${_output_LIST} ${ARGN}) + list(LENGTH ${_output_LIST} count) + + list(GET ${_output_LIST} 0 first_PARAM) + + set(second_PARAM "NOTFOUND") + if (${count} GREATER 1) + list(GET ${_output_LIST} 1 second_PARAM) + endif (${count} GREATER 1) + + set(remove "NOTFOUND") + + if (${first_PARAM} STREQUAL "NOGUI") + set(${_nogui} "NOGUI") + set(remove 0) + endif (${first_PARAM} STREQUAL "NOGUI") + + if (${second_PARAM} STREQUAL "NOGUI") + set(${_nogui} "NOGUI") + set(remove 0;1) + endif (${second_PARAM} STREQUAL "NOGUI") + + if (${first_PARAM} STREQUAL "RUN_UNINSTALLED") + set(${_uninst} "RUN_UNINSTALLED") + set(remove 0) + endif (${first_PARAM} STREQUAL "RUN_UNINSTALLED") + + if (${second_PARAM} STREQUAL "RUN_UNINSTALLED") + set(${_uninst} "RUN_UNINSTALLED") + set(remove 0;1) + endif (${second_PARAM} STREQUAL "RUN_UNINSTALLED") + + if (NOT "${remove}" STREQUAL "NOTFOUND") + list(REMOVE_AT ${_output_LIST} ${remove}) + endif (NOT "${remove}" STREQUAL "NOTFOUND") + +endmacro(KDE4_CHECK_EXECUTABLE_PARAMS) + + +macro (KDE4_ADD_KDEINIT_EXECUTABLE _target_NAME ) + + kde4_check_executable_params(_SRCS _nogui _uninst ${ARGN}) + +# if (WIN32) +# # under windows, just build a normal executable +# KDE4_ADD_EXECUTABLE(${_target_NAME} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${ARGN} ) +# else (WIN32) + # under UNIX, create a shared library and a small executable, which links to this library + kde4_get_automoc_files(_automoc_FILES ${_SRCS}) + + if (KDE4_ENABLE_FINAL) + kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS}) + add_library(kdeinit_${_target_NAME} SHARED ${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp ${_separate_files} ${_automoc_FILES}) + + else (KDE4_ENABLE_FINAL) + add_library(kdeinit_${_target_NAME} SHARED ${_SRCS} ${_automoc_FILES}) + endif (KDE4_ENABLE_FINAL) + + kde4_handle_rpath_for_library(kdeinit_${_target_NAME}) + + + configure_file(${KDE4_MODULE_DIR}/kde4init_dummy.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp) + kde4_add_executable(${_target_NAME} "${_nogui}" "${_uninst}" ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp) + target_link_libraries(${_target_NAME} kdeinit_${_target_NAME}) +# endif (WIN32) + + if (WIN32) + target_link_libraries(${_target_NAME} ${QT_QTMAIN_LIBRARY}) + endif (WIN32) + +endmacro (KDE4_ADD_KDEINIT_EXECUTABLE) + +macro (KDE4_ADD_EXECUTABLE _target_NAME) + + kde4_check_executable_params( _SRCS _nogui _uninst ${ARGN}) + + set(_add_executable_param) + set(_type "GUI") + + # determine additional parameters for add_executable() + # for GUI apps, create a bundle on OSX + if (APPLE) + set(_add_executable_param MACOSX_BUNDLE) + endif (APPLE) + + # for GUI apps, this disables the additional console under Windows + if (WIN32) + set(_add_executable_param WIN32) + endif (WIN32) + + if (_nogui) + set(_type "NOGUI") + set(_add_executable_param) + endif (_nogui) + + if (_uninst) + set(_type "RUN_UNINSTALLED") + endif (_uninst) + + kde4_get_automoc_files(_automoc_FILES ${_SRCS}) + + if (KDE4_ENABLE_FINAL) + kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS}) + add_executable(${_target_NAME} ${_add_executable_param} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files} ${_automoc_FILES}) + else (KDE4_ENABLE_FINAL) + add_executable(${_target_NAME} ${_add_executable_param} ${_SRCS} ${_automoc_FILES}) + endif (KDE4_ENABLE_FINAL) + + kde4_handle_rpath_for_executable(${_target_NAME} ${_type}) + + if (WIN32) + target_link_libraries(${_target_NAME} ${QT_QTMAIN_LIBRARY}) + endif (WIN32) + +endmacro (KDE4_ADD_EXECUTABLE) + + +MACRO (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE) +#is the first argument is "WITH_PREFIX" then keep the standard "lib" prefix, otherwise set the prefix empty + + set(_first_SRC ${_lib_TYPE}) + set(_add_lib_param) + + if (${_lib_TYPE} STREQUAL "STATIC") + set(_first_SRC) + set(_add_lib_param STATIC) + endif (${_lib_TYPE} STREQUAL "STATIC") + if (${_lib_TYPE} STREQUAL "SHARED") + set(_first_SRC) + set(_add_lib_param SHARED) + endif (${_lib_TYPE} STREQUAL "SHARED") + if (${_lib_TYPE} STREQUAL "MODULE") + set(_first_SRC) + set(_add_lib_param MODULE) + endif (${_lib_TYPE} STREQUAL "MODULE") + + kde4_get_automoc_files(_automoc_FILES ${_first_SRC} ${ARGN}) + + if (KDE4_ENABLE_FINAL) + kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_first_SRC} ${ARGN}) + add_library(${_target_NAME} ${_add_lib_param} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files} ${_automoc_FILES}) + else (KDE4_ENABLE_FINAL) + add_library(${_target_NAME} ${_add_lib_param} ${_first_SRC} ${ARGN} ${_automoc_FILES}) + endif (KDE4_ENABLE_FINAL) + + kde4_handle_rpath_for_library(${_target_NAME}) + + if (WIN32) + # for shared libraries a -DMAKE_target_LIB is required + string(TOUPPER ${_target_NAME} _symbol) + set(_symbol "MAKE_${_symbol}_LIB") + set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol}) + endif (WIN32) + +ENDMACRO (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE) + + +macro (KDE4_ADD_WIDGET_FILES _sources) + foreach (_current_FILE ${ARGN}) + + get_filename_component(_input ${_current_FILE} ABSOLUTE) + get_filename_component(_basename ${_input} NAME_WE) + set(_source ${CMAKE_CURRENT_BINARY_DIR}/${_basename}widgets.cpp) + set(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}widgets.moc) + + # create source file from the .widgets file + add_custom_command(OUTPUT ${_source} + COMMAND ${KDE4_MAKEKDEWIDGETS_EXECUTABLE} + ARGS -o ${_source} ${_input} + MAIN_DEPENDENCY ${_input} DEPENDS ${_KDE4_MAKEKDEWIDGETS_DEP}) + + # create moc file + qt4_generate_moc(${_source} ${_moc} ) + + list(APPEND ${_sources} ${_source} ${_moc}) + + endforeach (_current_FILE) + +endmacro (KDE4_ADD_WIDGET_FILES) + +MACRO(KDE4_ADD_DCOP_SKELS) + MESSAGE(FATAL_ERROR "There is a call to KDE4_ADD_DCOP_SKELS() in the CMakeLists.txt for '${ARGV0}', but DCOP is no longer supported by KDE4. + Please remove it and port to DBUS.") +ENDMACRO(KDE4_ADD_DCOP_SKELS) + +MACRO(KDE4_ADD_DCOP_STUBS) + MESSAGE(FATAL_ERROR "There is a call to KDE4_ADD_DCOP_STUBS() in the CMakeLists.txt for '${ARGV0}', but DCOP is no longer supported by KDE4. + Please remove it and port to DBUS.") +ENDMACRO(KDE4_ADD_DCOP_STUBS) + +MACRO(KDE4_REMOVE_OBSOLETE_CMAKE_FILES) +# the files listed here will be removed by remove_obsoleted_cmake_files.cmake, Alex + install(SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake ) + set(module_install_dir ${DATA_INSTALL_DIR}/cmake/modules ) + + file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "#generated by cmake, dont edit\n\n") + foreach ( _current_FILE ${ARGN}) + file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "message(STATUS \"Removing ${module_install_dir}/${_current_FILE}\" )\n" ) + file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "exec_program( ${CMAKE_COMMAND} ARGS -E remove ${module_install_dir}/${_current_FILE} OUTPUT_VARIABLE _dummy)\n" ) + endforeach ( _current_FILE) + +ENDMACRO(KDE4_REMOVE_OBSOLETE_CMAKE_FILES) + +MACRO(KDE4_NO_ENABLE_FINAL _project_name) + if(KDE4_ENABLE_FINAL) + set(KDE4_ENABLE_FINAL OFF) + REMOVE_DEFINITIONS(-DKDE_USE_FINAL) + MESSAGE(STATUS "You used enable-final argument but \"${_project_name}\" doesn't support it. Try to fix compile it and remove KDE4_NO_ENABLE_FINAL macro. Thanks") + + endif(KDE4_ENABLE_FINAL) +ENDMACRO(KDE4_NO_ENABLE_FINAL _project_name) + + +FIND_PROGRAM(MSGFMT + NAMES gmsgfmt msgfmt + PATHS ${BIN_SEARCH_PATHES}) + +IF(MSGFMT) + EXECUTE_PROCESS(COMMAND ${MSGFMT} "--version" "2>&1" + OUTPUT_VARIABLE _msgout) + STRING(REGEX MATCH "GNU[\t ]gettext" _isgnu "${_msgout}") + IF (NOT _isgnu) + MESSAGE(STATUS "No gnu msgfmt found!") + SET(MSGFMT ":" CACHE STRING "Msgfmt program") + ELSE(NOT _isgnu) + MESSAGE(STATUS "Found gnu msgfmt: ${MSGFMT}") + ENDIF (NOT _isgnu) +ELSE(MSGFMT) + SET(MSGFMT ":" CACHE STRING "Msgfmt program") + MESSAGE( FATAL_ERROR "Could NOT find Msgfmt program") +ENDIF(MSGFMT) + +MACRO(ADD_POFILES packagename) + SET(_gmofiles) + FILE(GLOB _pofiles *.po) + + FOREACH(_current_po ${_pofiles}) + GET_FILENAME_COMPONENT(_name ${_current_po} NAME_WE) + STRING(REGEX REPLACE "^.*/([a-zA-Z]+)(\\.po)" "\\1" _lang "${_current_po}") + SET(_gmofile "${CMAKE_CURRENT_BINARY_DIR}/${_name}.gmo") + ADD_CUSTOM_COMMAND(OUTPUT ${_gmofile} + COMMAND ${MSGFMT} + ARGS "-o" "${_gmofile}" "${_current_po}" + DEPENDS ${_current_po} + ) + SET(_gmofiles ${_gmofiles} ${_gmofile}) + INSTALL(FILES ${_gmofile} + DESTINATION ${LOCALE_INSTALL_DIR}/${_lang}/LC_MESSAGES + RENAME ${packagename}.mo) + ENDFOREACH(_current_po ${_pofiles}) + + ADD_CUSTOM_TARGET(translations ALL + DEPENDS ${_gmofiles}) + +ENDMACRO(ADD_POFILES) diff --git a/cmakemodules/MacroAddCompileFlags.cmake b/cmakemodules/MacroAddCompileFlags.cmake new file mode 100644 index 0000000..12038c0 --- /dev/null +++ b/cmakemodules/MacroAddCompileFlags.cmake @@ -0,0 +1,19 @@ +# - MACRO_ADD_COMPILE_FLAGS(<_target> "flags...") + +# Copyright (c) 2006, Oswald Buddenhagen, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +MACRO (MACRO_ADD_COMPILE_FLAGS _target _flg) + + GET_TARGET_PROPERTY(_flags ${_target} COMPILE_FLAGS) + if (_flags) + set(_flags "${_flags} ${_flg}") + else (_flags) + set(_flags "${_flg}") + endif (_flags) + SET_TARGET_PROPERTIES(${_target} PROPERTIES COMPILE_FLAGS "${_flags}") + +ENDMACRO (MACRO_ADD_COMPILE_FLAGS) diff --git a/cmakemodules/MacroAddFileDependencies.cmake b/cmakemodules/MacroAddFileDependencies.cmake new file mode 100644 index 0000000..9e55360 --- /dev/null +++ b/cmakemodules/MacroAddFileDependencies.cmake @@ -0,0 +1,20 @@ +# MACRO_ADD_FILE_DEPENDENCIES(<_file> depend_files...) + +# Copyright (c) 2006, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +MACRO (MACRO_ADD_FILE_DEPENDENCIES _file) + + GET_SOURCE_FILE_PROPERTY(_deps ${_file} OBJECT_DEPENDS) + if (_deps) + set(_deps ${_deps} ${ARGN}) + else (_deps) + set(_deps ${ARGN}) + endif (_deps) + + SET_SOURCE_FILES_PROPERTIES(${_file} PROPERTIES OBJECT_DEPENDS "${_deps}") + +ENDMACRO (MACRO_ADD_FILE_DEPENDENCIES) diff --git a/cmakemodules/MacroAddLinkFlags.cmake b/cmakemodules/MacroAddLinkFlags.cmake new file mode 100644 index 0000000..a10d39e --- /dev/null +++ b/cmakemodules/MacroAddLinkFlags.cmake @@ -0,0 +1,18 @@ +# - MACRO_ADD_LINK_FLAGS(<_target> "flags...") + +# Copyright (c) 2006, Oswald Buddenhagen, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + +MACRO (MACRO_ADD_LINK_FLAGS _target _flg) + + GET_TARGET_PROPERTY(_flags ${_target} LINK_FLAGS) + if (_flags) + set(_flags "${_flags} ${_flg}") + else (_flags) + set(_flags "${_flg}") + endif (_flags) + SET_TARGET_PROPERTIES(${_target} PROPERTIES LINK_FLAGS "${_flags}") + +ENDMACRO (MACRO_ADD_LINK_FLAGS) diff --git a/cmakemodules/MacroAdditionalCleanFiles.cmake b/cmakemodules/MacroAdditionalCleanFiles.cmake new file mode 100644 index 0000000..593182f --- /dev/null +++ b/cmakemodules/MacroAdditionalCleanFiles.cmake @@ -0,0 +1,21 @@ +# - MACRO_ADDITIONAL_CLEAN_FILES(files...) +# MACRO_OPTIONAL_FIND_PACKAGE( [QUIT] ) + +# Copyright (c) 2006, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +MACRO (MACRO_ADDITIONAL_CLEAN_FILES) + GET_DIRECTORY_PROPERTY(_tmp_DIR_PROPS ADDITIONAL_MAKE_CLEAN_FILES ) + + if (_tmp_DIR_PROPS) + set(_tmp_DIR_PROPS ${_tmp_DIR_PROPS} ${ARGN}) + else (_tmp_DIR_PROPS) + set(_tmp_DIR_PROPS ${ARGN}) + endif (_tmp_DIR_PROPS) + + SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${_tmp_DIR_PROPS}") +ENDMACRO (MACRO_ADDITIONAL_CLEAN_FILES) + diff --git a/cmakemodules/MacroBoolTo01.cmake b/cmakemodules/MacroBoolTo01.cmake new file mode 100644 index 0000000..63b9852 --- /dev/null +++ b/cmakemodules/MacroBoolTo01.cmake @@ -0,0 +1,20 @@ +# MACRO_BOOL_TO_01( VAR RESULT0 ... RESULTN ) +# This macro evaluates its first argument +# and sets all the given vaiables either to 0 or 1 +# depending on the value of the first one + +# Copyright (c) 2006, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +MACRO(MACRO_BOOL_TO_01 FOUND_VAR ) + FOREACH (_current_VAR ${ARGN}) + IF(${FOUND_VAR}) + SET(${_current_VAR} 1) + ELSE(${FOUND_VAR}) + SET(${_current_VAR} 0) + ENDIF(${FOUND_VAR}) + ENDFOREACH(_current_VAR) +ENDMACRO(MACRO_BOOL_TO_01) diff --git a/cmakemodules/MacroEnsureOutOfSourceBuild.cmake b/cmakemodules/MacroEnsureOutOfSourceBuild.cmake new file mode 100644 index 0000000..ef4d525 --- /dev/null +++ b/cmakemodules/MacroEnsureOutOfSourceBuild.cmake @@ -0,0 +1,16 @@ +# - MACRO_ENSURE_OUT_OF_SOURCE_BUILD() +# MACRO_ENSURE_OUT_OF_SOURCE_BUILD() + +# Copyright (c) 2006, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + +MACRO (MACRO_ENSURE_OUT_OF_SOURCE_BUILD _errorMessage) + + STRING(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" insource) + IF(insource) + MESSAGE(FATAL_ERROR "${_errorMessage}") + ENDIF(insource) + +ENDMACRO (MACRO_ENSURE_OUT_OF_SOURCE_BUILD) diff --git a/cmakemodules/MacroEnsureVersion.cmake b/cmakemodules/MacroEnsureVersion.cmake new file mode 100644 index 0000000..9d936ce --- /dev/null +++ b/cmakemodules/MacroEnsureVersion.cmake @@ -0,0 +1,35 @@ +# This macro compares version numbers of the form "x.y.z" +# MACRO_ENSURE_VERSION( FOO_MIN_VERSION FOO_VERSION_FOUND FOO_VERSION_OK) +# will set FOO_VERSIN_OK to true if FOO_VERSION_FOUND >= FOO_MIN_VERSION +# where both have to be in a 3-part-version format, leading and trailing +# text is ok, e.g. +# MACRO_ENSURE_VERSION( "2.5.31" "flex 2.5.4a" VERSION_OK) +# which means 2.5.31 is required and "flex 2.5.4a" is what was found on the system + +# Copyright (c) 2006, David Faure, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + +MACRO(MACRO_ENSURE_VERSION requested_version found_version var_too_old) + + # parse the parts of the version string + STRING(REGEX REPLACE "([0-9]+)\\.[0-9]+\\.[0-9]+" "\\1" req_major_vers "${requested_version}") + STRING(REGEX REPLACE "[0-9]+\\.([0-9]+)\\.[0-9]+" "\\1" req_minor_vers "${requested_version}") + STRING(REGEX REPLACE "[0-9]+\\.[0-9]+\\.([0-9]+)" "\\1" req_patch_vers "${requested_version}") + + STRING(REGEX REPLACE "[^0-9]*([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" found_major_vers "${found_version}") + STRING(REGEX REPLACE "[^0-9]*[0-9]+\\.([0-9]+)\\.[0-9]+.*" "\\1" found_minor_vers "${found_version}") + STRING(REGEX REPLACE "[^0-9]*[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" found_patch_vers "${found_version}") + + # compute an overall version number which can be compared at once + MATH(EXPR req_vers_num "${req_major_vers}*10000 + ${req_minor_vers}*100 + ${req_patch_vers}") + MATH(EXPR found_vers_num "${found_major_vers}*10000 + ${found_minor_vers}*100 + ${found_patch_vers}") + + if (found_vers_num LESS req_vers_num) + set( ${var_too_old} FALSE ) + else (found_vers_num LESS req_vers_num) + set( ${var_too_old} TRUE ) + endif (found_vers_num LESS req_vers_num) + +ENDMACRO(MACRO_ENSURE_VERSION) diff --git a/cmakemodules/MacroLibrary.cmake b/cmakemodules/MacroLibrary.cmake new file mode 100644 index 0000000..3b80212 --- /dev/null +++ b/cmakemodules/MacroLibrary.cmake @@ -0,0 +1,18 @@ +# - include MacroLibrary offers a collection of macros which extend the built-in cmake commands +# OPTIONAL_FIND_PACKAGE( [QUIT] ) + +# Copyright (c) 2006, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + +INCLUDE(MacroOptionalFindPackage) +INCLUDE(MacroOptionalAddSubdirectory) +INCLUDE(MacroAdditionalCleanFiles) +INCLUDE(MacroAddFileDependencies) +INCLUDE(MacroAddCompileFlags) +INCLUDE(MacroAddLinkFlags) +INCLUDE(MacroEnsureOutOfSourceBuild) +INCLUDE(MacroBoolTo01) +INCLUDE(MacroPushRequiredVars) +INCLUDE(MacroLogFeature) diff --git a/cmakemodules/MacroLogFeature.cmake b/cmakemodules/MacroLogFeature.cmake new file mode 100644 index 0000000..55f7b69 --- /dev/null +++ b/cmakemodules/MacroLogFeature.cmake @@ -0,0 +1,112 @@ +# This file defines the Feature Logging macros. +# +# MACRO_LOG_FEATURE(VAR FEATURE DESCRIPTION URL [REQUIRED [MIN_VERSION [COMMENTS]]]) +# Logs the information so that it can be displayed at the end +# of the configure run +# VAR : TRUE or FALSE, indicating whether the feature is supported +# FEATURE: name of the feature, e.g. "libjpeg" +# DESCRIPTION: description what this feature provides +# URL: home page +# REQUIRED: TRUE or FALSE, indicating whether the featue is required +# MIN_VERSION: minimum version number. empty string if unneeded +# COMMENTS: More info you may want to provide. empty string if unnecessary +# +# MACRO_DISPLAY_FEATURE_LOG() +# Call this to display the collected results. +# Exits CMake with a FATAL error message if a required feature is missing +# +# Example: +# +# INCLUDE(MacroLogFeature) +# +# FIND_PACKAGE(JPEG) +# MACRO_LOG_FEATURE(JPEG_FOUND "libjpeg" "Support JPEG images" "http://www.ijg.org" TRUE "3.2a" "") +# ... +# MACRO_DISPLAY_FEATURE_LOG() + +# Copyright (c) 2006, Alexander Neundorf, +# Copyright (c) 2006, Allen Winter, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + +IF (NOT _macroLogFeatureAlreadyIncluded) + SET(_file ${CMAKE_BINARY_DIR}/MissingRequirements.txt) + IF (EXISTS ${_file}) + FILE(REMOVE ${_file}) + ENDIF (EXISTS ${_file}) + + SET(_file ${CMAKE_BINARY_DIR}/EnabledFeatures.txt) + IF (EXISTS ${_file}) + FILE(REMOVE ${_file}) + ENDIF (EXISTS ${_file}) + + SET(_file ${CMAKE_BINARY_DIR}/DisabledFeatures.txt) + IF (EXISTS ${_file}) + FILE(REMOVE ${_file}) + ENDIF (EXISTS ${_file}) + + SET(_macroLogFeatureAlreadyIncluded TRUE) +ENDIF (NOT _macroLogFeatureAlreadyIncluded) + + +MACRO(MACRO_LOG_FEATURE _var _package _description _url ) # _required _minvers _comments) + + SET(_required "${ARGV4}") + SET(_minvers "${ARGV5}") + SET(_comments "${ARGV6}") + + IF (${_var}) + SET(_LOGFILENAME ${CMAKE_BINARY_DIR}/EnabledFeatures.txt) + ELSE (${_var}) + IF (${_required} MATCHES "[Tt][Rr][Uu][Ee]") + SET(_LOGFILENAME ${CMAKE_BINARY_DIR}/MissingRequirements.txt) + ELSE (${_required} MATCHES "[Tt][Rr][Uu][Ee]") + SET(_LOGFILENAME ${CMAKE_BINARY_DIR}/DisabledFeatures.txt) + ENDIF (${_required} MATCHES "[Tt][Rr][Uu][Ee]") + ENDIF (${_var}) + + SET(_logtext "> ${_package}") + + IF (${_minvers} MATCHES ".*") + SET(_logtext "${_logtext}, ${_minvers}") + ENDIF (${_minvers} MATCHES ".*") + SET(_logtext "${_logtext}: ${_description}; ${_url};") + IF (${_comments} MATCHES ".*") + SET(_logtext "${_logtext}\n${_comments}") + ENDIF (${_comments} MATCHES ".*") + FILE(APPEND "${_LOGFILENAME}" "${_logtext}\n\n") + +ENDMACRO(MACRO_LOG_FEATURE) + + +MACRO(MACRO_DISPLAY_FEATURE_LOG) + + SET(_file ${CMAKE_BINARY_DIR}/MissingRequirements.txt) + IF (EXISTS ${_file}) + FILE(READ ${_file} _requirements) + MESSAGE(STATUS "\n----------------------------------------------------------------------------------\n-- The following list of REQUIRED packages could not be located on your system. --\n-- Please install them before continuing with this software installation. --\n----------------------------------------------------------------------------------\n${_requirements}----------------------------------------------------------------------------------") +# MESSAGE(STATUS "MISSING REQUIREMENTS\n${_requirements}\n") + FILE(REMOVE ${_file}) + MESSAGE(FATAL_ERROR "Exiting: Missing Requirements") + ENDIF (EXISTS ${_file}) + + SET(_summary "\n") + SET(_file ${CMAKE_BINARY_DIR}/EnabledFeatures.txt) + IF (EXISTS ${_file}) + FILE(READ ${_file} _enabled) + FILE(REMOVE ${_file}) + SET(_summary "${_summary}----------------------------------------------------------------------------------\n-- The following list of OPTIONAL packages were located on your system. --\n-- You will have all the following features available from this software. --\n----------------------------------------------------------------------------------\n${_enabled}") +# SET(_summary "${_summary}Enabled Features:\n${_enabled}") + ENDIF (EXISTS ${_file}) + + SET(_file ${CMAKE_BINARY_DIR}/DisabledFeatures.txt) + IF (EXISTS ${_file}) + FILE(READ ${_file} _disabled) + FILE(REMOVE ${_file}) + SET(_summary "${_summary}----------------------------------------------------------------------------------\n-- The following list of OPTIONAL packages could not be located on your system. --\n-- Please consider installing them to enable more features of this software. --\n----------------------------------------------------------------------------------\n${_disabled}") +# SET(_summary "${_summary}Disabled Features:\n${_disabled}") + ENDIF (EXISTS ${_file}) + MESSAGE(STATUS "${_summary}") + +ENDMACRO(MACRO_DISPLAY_FEATURE_LOG) diff --git a/cmakemodules/MacroOptionalAddSubdirectory.cmake b/cmakemodules/MacroOptionalAddSubdirectory.cmake new file mode 100644 index 0000000..b0d565c --- /dev/null +++ b/cmakemodules/MacroOptionalAddSubdirectory.cmake @@ -0,0 +1,27 @@ +# - MACRO_OPTIONAL_ADD_SUBDIRECTORY() combines ADD_SUBDIRECTORY() with an OPTION() +# MACRO_OPTIONAL_ADD_SUBDIRECTORY( ) +# If you use MACRO_OPTIONAL_ADD_SUBDIRECTORY() instead of ADD_SUBDIRECTORY(), +# this will have two effects +# 1 - CMake will not complain if the directory doesn't exist +# This makes sense if you want to distribute just one of the subdirs +# in a source package, e.g. just one of the subdirs in kdeextragear. +# 2 - If the directory exists, it will offer an option to skip the +# subdirectory. +# This is useful if you want to compile only a subset of all +# directories. + +# Copyright (c) 2007, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +MACRO (MACRO_OPTIONAL_ADD_SUBDIRECTORY _dir ) + GET_FILENAME_COMPONENT(_fullPath ${_dir} ABSOLUTE) + IF(EXISTS ${_fullPath}) + OPTION(BUILD_${_dir} "Build directory ${_dir}" TRUE) + IF(BUILD_${_dir}) + ADD_SUBDIRECTORY(${_dir}) + ENDIF(BUILD_${_dir}) + ENDIF(EXISTS ${_fullPath}) +ENDMACRO (MACRO_OPTIONAL_ADD_SUBDIRECTORY) diff --git a/cmakemodules/MacroOptionalFindPackage.cmake b/cmakemodules/MacroOptionalFindPackage.cmake new file mode 100644 index 0000000..816cdb7 --- /dev/null +++ b/cmakemodules/MacroOptionalFindPackage.cmake @@ -0,0 +1,28 @@ +# - MACRO_OPTIONAL_FIND_PACKAGE() combines FIND_PACKAGE() with an OPTION() +# MACRO_OPTIONAL_FIND_PACKAGE( [QUIT] ) +# This macro is a combination of OPTION() and FIND_PACKAGE(), it +# works like FIND_PACKAGE(), but additionally it automatically creates +# an option name WITH_, which can be disabled via the cmake GUI. +# or via -DWITH_=OFF +# The standard _FOUND variables can be used in the same way +# as when using the normal FIND_PACKAGE() + +# Copyright (c) 2006, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +MACRO (MACRO_OPTIONAL_FIND_PACKAGE _name ) + OPTION(WITH_${_name} "Search for ${_name} package" ON) + if (WITH_${_name}) + FIND_PACKAGE(${_name} ${ARGN}) + else (WITH_${_name}) + set(${_name}_FOUND) + set(${_name}_INCLUDE_DIR) + set(${_name}_INCLUDES) + set(${_name}_LIBRARY) + set(${_name}_LIBRARIES) + endif (WITH_${_name}) +ENDMACRO (MACRO_OPTIONAL_FIND_PACKAGE) + diff --git a/cmakemodules/MacroPushRequiredVars.cmake b/cmakemodules/MacroPushRequiredVars.cmake new file mode 100644 index 0000000..650b566 --- /dev/null +++ b/cmakemodules/MacroPushRequiredVars.cmake @@ -0,0 +1,47 @@ +# this module defines two macros: +# MACRO_PUSH_REQUIRED_VARS() +# and +# MACRO_POP_REQUIRED_VARS() +# use these if you call cmake macros which use +# any of the CMAKE_REQUIRED_XXX variables +# +# Usage: +# MACRO_PUSH_REQUIRED_VARS() +# SET(CMAKE_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} -DSOME_MORE_DEF) +# CHECK_FUNCTION_EXISTS(...) +# MACRO_POP_REQUIRED_VARS() + +# Copyright (c) 2006, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + +MACRO(MACRO_PUSH_REQUIRED_VARS) + + IF(NOT DEFINED _PUSH_REQUIRED_VARS_COUNTER) + SET(_PUSH_REQUIRED_VARS_COUNTER 0) + ENDIF(NOT DEFINED _PUSH_REQUIRED_VARS_COUNTER) + + MATH(EXPR _PUSH_REQUIRED_VARS_COUNTER "${_PUSH_REQUIRED_VARS_COUNTER}+1") + + SET(_CMAKE_REQUIRED_INCLUDES_SAVE_${_PUSH_REQUIRED_VARS_COUNTER} ${CMAKE_REQUIRED_INCLUDES}) + SET(_CMAKE_REQUIRED_DEFINITIONS_SAVE_${_PUSH_REQUIRED_VARS_COUNTER} ${CMAKE_REQUIRED_DEFINITIONS}) + SET(_CMAKE_REQUIRED_LIBRARIES_SAVE_${_PUSH_REQUIRED_VARS_COUNTER} ${CMAKE_REQUIRED_LIBRARIES}) + SET(_CMAKE_REQUIRED_FLAGS_SAVE_${_PUSH_REQUIRED_VARS_COUNTER} ${CMAKE_REQUIRED_FLAGS}) +ENDMACRO(MACRO_PUSH_REQUIRED_VARS) + +MACRO(MACRO_POP_REQUIRED_VARS) + +# don't pop more than we pushed + IF("${_PUSH_REQUIRED_VARS_COUNTER}" GREATER "0") + + SET(CMAKE_REQUIRED_INCLUDES ${_CMAKE_REQUIRED_INCLUDES_SAVE_${_PUSH_REQUIRED_VARS_COUNTER}}) + SET(CMAKE_REQUIRED_DEFINITIONS ${_CMAKE_REQUIRED_DEFINITIONS_SAVE_${_PUSH_REQUIRED_VARS_COUNTER}}) + SET(CMAKE_REQUIRED_LIBRARIES ${_CMAKE_REQUIRED_LIBRARIES_SAVE_${_PUSH_REQUIRED_VARS_COUNTER}}) + SET(CMAKE_REQUIRED_FLAGS ${_CMAKE_REQUIRED_FLAGS_SAVE_${_PUSH_REQUIRED_VARS_COUNTER}}) + + MATH(EXPR _PUSH_REQUIRED_VARS_COUNTER "${_PUSH_REQUIRED_VARS_COUNTER}-1") + ENDIF("${_PUSH_REQUIRED_VARS_COUNTER}" GREATER "0") + +ENDMACRO(MACRO_POP_REQUIRED_VARS) + diff --git a/cmakemodules/generatelibtoolfile.cmake b/cmakemodules/generatelibtoolfile.cmake new file mode 100644 index 0000000..d74ed21 --- /dev/null +++ b/cmakemodules/generatelibtoolfile.cmake @@ -0,0 +1,16 @@ + FILE(WRITE ${OUTPUTFILE} "# ${OUTPUTFILE} - a libtool library file, generated by cmake \n") + FILE(APPEND ${OUTPUTFILE} "# The name that we can dlopen(3).\n") + FILE(APPEND ${OUTPUTFILE} "dlname='${SONAME}'\n") + FILE(APPEND ${OUTPUTFILE} "# Names of this library\n") + FILE(APPEND ${OUTPUTFILE} "library_names='${SONAME} ${SONAME} ${SONAME}'\n") + FILE(APPEND ${OUTPUTFILE} "# The name of the static archive\n") + FILE(APPEND ${OUTPUTFILE} "old_library=''\n") + FILE(APPEND ${OUTPUTFILE} "# Libraries that this one depends upon.\n") + FILE(APPEND ${OUTPUTFILE} "dependency_libs=''\n") +# FILE(APPEND ${OUTPUTFILE} "dependency_libs='${${_target}_LIB_DEPENDS}'\n") + FILE(APPEND ${OUTPUTFILE} "# Version information.\ncurrent=0\nage=0\nrevision=0\n") + FILE(APPEND ${OUTPUTFILE} "# Is this an already installed library?\ninstalled=yes\n") + FILE(APPEND ${OUTPUTFILE} "# Should we warn about portability when linking against -modules?\nshouldnotlink=yes\n") + FILE(APPEND ${OUTPUTFILE} "# Files to dlopen/dlpreopen\ndlopen=''\ndlpreopen=''\n") + FILE(APPEND ${OUTPUTFILE} "# Directory that this library needs to be installed in:\n") + FILE(APPEND ${OUTPUTFILE} "libdir='${LIBDIR}'\n") diff --git a/cmakemodules/kde3uic.cmake b/cmakemodules/kde3uic.cmake new file mode 100644 index 0000000..0dbbbcf --- /dev/null +++ b/cmakemodules/kde3uic.cmake @@ -0,0 +1,20 @@ + + +# used internally by KDE3Macros.cmake +# neundorf@kde.org + + +EXECUTE_PROCESS(COMMAND ${KDE_UIC_EXECUTABLE} + -L ${KDE_UIC_PLUGIN_DIR} -nounload -tr tr2i18n + -impl ${KDE_UIC_H_FILE} + ${KDE_UIC_FILE} + OUTPUT_VARIABLE _uic_CONTENTS + ERROR_QUIET + ) + +STRING(REGEX REPLACE "tr2i18n\\(\"\"\\)" "QString::null" _uic_CONTENTS "${_uic_CONTENTS}" ) +STRING(REGEX REPLACE "tr2i18n\\(\"\", \"\"\\)" "QString::null" _uic_CONTENTS "${_uic_CONTENTS}" ) + +FILE(WRITE ${KDE_UIC_CPP_FILE} "#include \n#include \n\n") +FILE(APPEND ${KDE_UIC_CPP_FILE} "${_uic_CONTENTS}") + diff --git a/cmakemodules/kdesvnMacros.cmake b/cmakemodules/kdesvnMacros.cmake new file mode 100644 index 0000000..29b99db --- /dev/null +++ b/cmakemodules/kdesvnMacros.cmake @@ -0,0 +1,50 @@ + +MACRO(KDESVN_CHECK_LINK_FLAG FLAGS VARIABLE) + IF(NOT DEFINED ${VARIABLE}) + TRY_COMPILE(${VARIABLE} + ${CMAKE_BINARY_DIR} + ${CMAKE_ROOT}/Modules/DummyCXXFile.cxx + CMAKE_FLAGS -DCMAKE_EXE_LINKER_FLAGS="${FLAGS}" + OUTPUT_VARIABLE OUTPUT) + IF (${VARIABLE}) + MESSAGE(STATUS "Checking to see if linker accepts flag ${FLAGS} - yes") + FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log + "Determining if the linker accepts the flag ${FLAGS} passed with " + "the following output:\n${OUTPUT}\n\n") + ELSE (${VARIABLE}) + MESSAGE(STATUS "Checking to see if linker accepts flag ${FLAGS} - no") + FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log + "Determining if the linker accepts the flag ${FLAGS} failed with " + "the following output:\n${OUTPUT}\n\n") + ENDIF (${VARIABLE}) + ENDIF(NOT DEFINED ${VARIABLE}) +ENDMACRO(KDESVN_CHECK_LINK_FLAG) + +# this macro is required to add libtools to normal build so +# we may debug our part from within build dir +# output name where +# _laname _soname ${LIBRARY_OUTPUT_PATH}/kde3 +MACRO(KDESVN_GENERATE_LIBTOOL_FILE _target) + GET_TARGET_PROPERTY(_target_location ${_target} LOCATION) + GET_FILENAME_COMPONENT(_laname ${_target_location} NAME_WE) + GET_FILENAME_COMPONENT(_soname ${_target_location} NAME) + IF(LIBRARY_OUTPUT_PATH) + SET(_laname ${LIBRARY_OUTPUT_PATH}/${_laname}.la) + ELSE(LIBRARY_OUTPUT_PATH) + SET(_laname ${CMAKE_CURRENT_BINARY_DIR}/${_laname}.la) + ENDIF(LIBRARY_OUTPUT_PATH) + IF(LIBRARY_OUTPUT_PATH) + SET(_libdir "'${LIBRARY_OUTPUT_PATH}/kde3'") + ELSE(LIBRARY_OUTPUT_PATH) + SET(_libdir "'${CMAKE_CURRENT_BUILD_DIR}/kde3'") + ENDIF(LIBRARY_OUTPUT_PATH) + ADD_CUSTOM_COMMAND(TARGET ${_target} + POST_BUILD + COMMAND ${CMAKE_COMMAND} + ARGS + -DOUTPUTFILE:FILEPATH=${_laname} + -DSONAME:STRING=${_soname} + -DLIBDIR:STRING=${_libdir} + -P ${CMAKE_SOURCE_DIR}/cmakemodules/generatelibtoolfile.cmake + ) +ENDMACRO(KDESVN_GENERATE_LIBTOOL_FILE) diff --git a/cmakemodules/makedist.sh.in b/cmakemodules/makedist.sh.in new file mode 100755 index 0000000..2a77085 --- /dev/null +++ b/cmakemodules/makedist.sh.in @@ -0,0 +1,36 @@ +#!/bin/sh +VERSION=@VERSION@ +SRCROOT=@CMAKE_SOURCE_DIR@ +BUILDDIR=@CMAKE_BINARY_DIR@ +PROJECT=@PROJECT_NAME@ +GENTOO_VERSION=@GENTOO_VERSION@ + +EXCLUDE="@DIST_EXCLUDE@" +INCLUDE="@DIST_INCLUDE@" +EXPORT_DIR="${PROJECT}-${VERSION}" + +if [ ! -d ${SRCROOT}/.svn ]; then + echo "This script must run for a svn dir!" + exit 1 +fi + +echo "Exporting source tree" +svn export "${SRCROOT}" ${EXPORT_DIR} + +echo "Copy required files to export" +for i in $INCLUDE ; do + echo " $i" + cp ${BUILDDIR}/$i ${EXPORT_DIR} +done + +echo "Removing not needed stuff" +for i in $EXCLUDE ; do + echo " $i" + rm -rf $EXPORT_DIR/$i +done + +echo "Generating archive" +tar cjf ${BUILDDIR}/${PROJECT}-${VERSION}.tar.bz2 ${EXPORT_DIR} + +echo "Cleaning up" +rm -rf ${EXPORT_DIR} diff --git a/cmakemodules/package_messages.sh.in b/cmakemodules/package_messages.sh.in new file mode 100755 index 0000000..f062fca --- /dev/null +++ b/cmakemodules/package_messages.sh.in @@ -0,0 +1,84 @@ +#!/bin/sh + +# little helper script for regenerating translation files. Mostly taken from cvs.sh from kde-autotool environment +# adapted to a cmake build environment and removed a lot not realy needed stuff +#EXTRACTRC=@EXTRACTRC@ +#PREPARETIPS=@PREPARETIPS@ +MESSAGES_DIR=@MESSAGES_DIR@ +SOURCE_DIR=@CMAKE_SOURCE_DIR@ +MAKE=make +POFILES="@POFILES@" +podir="${SOURCE_DIR}/po" + + +cd ${SOURCE_DIR} +rm -rf po.backup +mkdir po.backup + +for i in `ls -1 po/*.pot 2>/dev/null | sed -e "s#po/##"`; do + egrep -v '^#([^:]|$)' po/$i | egrep '^.*[^ ]+.*$' | grep -v "\"POT-Creation" > po.backup/$i + cp po/$i po.backup/backup_$i + touch -r po/$i po.backup/backup_$i + rm po/$i +done + +podir=${podir:-$PWD/po} +#files=`find . -name Makefile.am | xargs egrep -l '^messages:' ` +#dirs=`for i in $files; do echo \`dirname $i\`; done` +dirs=${MESSAGES_DIR} +tmpname="$PWD/messages.log" +if test -z "$EXTRACTRC"; then EXTRACTRC=extractrc ; fi +if test -z "$PREPARETIPS"; then PREPARETIPS=preparetips ; fi +export EXTRACTRC PREPARETIPS + +for subdir in $dirs; do + test -z "$VERBOSE" || echo "Making messages in $subdir" + (cd $subdir + echo -e 'i18n("_: NAME OF TRANSLATORS\\n"\n"Your names")\ni18n("_: EMAIL OF TRANSLATORS\\n"\n"Your emails")' > _translatorinfo.cpp + $EXTRACTRC `find . -name \*.ui -o -name \*.rc` > rc.cpp + XGETTEXT="${XGETTEXT:-xgettext} -C -ki18n -ktr2i18n -kI18N_NOOP -ktranslate -kaliasLocale -x @KDE3_INCLUDE_DIR@/kde.pot" + find . -name '*.cpp' | xargs ${XGETTEXT} _translatorinfo.cpp -o ${podir}/@PROJECT_NAME@.pot + find . -name '*.ui.h' | xargs ${XGETTEXT} _translatorinfo.cpp -j -o ${podir}/@PROJECT_NAME@.pot + ) 2>&1 | grep -v '^make\[1\]' > $tmpname + test -s $tmpname && { echo $subdir ; cat "$tmpname"; } + test -f $subdir/rc.cpp && rm -f $subdir/rc.cpp + rm -f $subdir/_translatorinfo.cpp +done +rm -f $tmpname +for i in `ls -1 po.backup/*.pot 2>/dev/null | sed -e "s#po.backup/##" | egrep -v '^backup_'`; do + test -f po/$i || echo "disappeared: $i" +done +for i in `ls -1 po/*.pot 2>/dev/null | sed -e "s#po/##"`; do + msgmerge -q -o po/$i po/$i po/$i + egrep -v '^#([^:]|$)' po/$i | egrep '^.*[^ ]+.*$' | grep -v "\"POT-Creation" > temp.pot + if test -f po.backup/$i && test -n "`diff temp.pot po.backup/$i`"; then + echo "will update $i" + msgmerge -q po.backup/backup_$i po/$i > temp.pot + mv temp.pot po/$i + else + if test -f po.backup/backup_$i; then + test -z "$VERBOSE" || echo "I'm restoring $i" + mv po.backup/backup_$i po/$i + rm po.backup/$i + else + echo "will add $i" + fi + fi +done +rm -f temp.pot +rm -rf po.backup + +echo Merging messages +for cat in $POFILES; do + msgmerge -o $cat.new $cat @CMAKE_SOURCE_DIR@/po/@PROJECT_NAME@.pot + if test -s $cat.new; then + grep -v "\"POT-Creation" $cat.new > $cat.new.2 + grep -v "\"POT-Creation" $cat >> $cat.new.1 + if diff $cat.new.1 $cat.new.2; then + rm $cat.new + else + mv $cat.new $cat + fi + rm -f $cat.new.1 $cat.new.2 + fi +done diff --git a/config.h.in b/config.h.in new file mode 100644 index 0000000..e040792 --- /dev/null +++ b/config.h.in @@ -0,0 +1,4 @@ +#cmakedefine APPLICATION_VERSION "@APPLICATION_VERSION@" +#cmakedefine HAVE_MANDRAKE @MANDRAKE@ +#cmakedefine APPLICATION_INTERNAL_VERSION @APPLICATION_INTERNAL_VERSION@ +#cmakedefine KBFX_LIB_INSTALL_DIR "@KBFX_LIB_INSTALL_DIR@" diff --git a/configdialog/CMakeLists.txt b/configdialog/CMakeLists.txt new file mode 100644 index 0000000..c65e04b --- /dev/null +++ b/configdialog/CMakeLists.txt @@ -0,0 +1,57 @@ +SET(kbfxconfigappsrc + main.cpp + kbfxconfigapp.cpp + ) + +SET(kbfxconfigappui + kbfxthemeinfo.ui + kbfxconfigdlgbutton.ui + kbfxconfigdlgmain.ui + kbfxconfigdlgthemes.ui + kbfxconfigdlgabout.ui + kbfxconfigdlgstyle.ui + kbfxconfigdlgtooltip.ui + kbfxconfigdlgfonts-old.ui + kbfxconfigdlgplugins.ui + kbfxconfigdlglayout.ui + ) + +IF (NOT USE_KDE4) + KDE3_AUTOMOC(${kbfxconfigappsrc}) + + KDE3_ADD_UI_FILES(kbfxconfigappsrc ${kbfxconfigappui}) + + KDE3_ADD_EXECUTABLE(kbfxconfigapp ${kbfxconfigappsrc}) + + TARGET_LINK_LIBRARIES(kbfxconfigapp + kbfxdata + kbfxcommon + ${QT_AND_KDECORE_LIBS} + ${KDE3_KIO_LIBRARY} + ${KDE3_UI_LIBRARY} + ) +ELSE (NOT USE_KDE4) + KDE4_AUTOMOC(${kbfxconfigappsrc}) + + KDE4_ADD_UI3_FILES(kbfxconfigappsrc ${kbfxconfigappui}) + + KDE4_ADD_EXECUTABLE(kbfxconfigapp ${kbfxconfigappsrc}) + + TARGET_LINK_LIBRARIES(kbfxconfigapp + kbfxdata + kbfxcommon + ${KDE4_KDECORE_LIBS} + ${KDE4_KIO_LIBS} + ${KDE4_KDEUI_LIBS} + ) +ENDIF (NOT USE_KDE4) + +INSTALL(TARGETS kbfxconfigapp + RUNTIME DESTINATION ${BIN_INSTALL_DIR}) + +INSTALL(FILES kbfxconfigappui.rc DESTINATION ${DATA_INSTALL_DIR}/kbfxconfigapp) +INSTALL(FILES kbfxconfigapp.desktop kbfx_theme.desktop DESTINATION ${XDG_APPS_DIR}) +INSTALL(FILES kbfx_install_theme.desktop kbfx_prepare_theme.desktop + DESTINATION ${DATA_INSTALL_DIR}/konqueror/servicemenus) +INSTALL(FILES x-kbfxtheme.desktop + DESTINATION ${MIME_INSTALL_DIR}/application) diff --git a/configdialog/kbfx_install_theme.desktop b/configdialog/kbfx_install_theme.desktop new file mode 100644 index 0000000..9406742 --- /dev/null +++ b/configdialog/kbfx_install_theme.desktop @@ -0,0 +1,22 @@ +[Desktop Entry] +Encoding=UTF-8 +ServiceTypes=application/x-kbfxtheme +Actions=kbfx_install_theme + +[Desktop Action kbfx_install_theme] +Icon=kbfxconfigapp +Exec=kbfxconfigapp --install %u +Name=Install KBFX Theme Package +Name[bg]=Инсталиране на пакета KBFX Theme +Name[da]=Installér KBFX-temapakke +Name[de]=KBFX Theme-Paket installieren +Name[el]=Εγκατάσταση του πακέτου θέματος KBFX +Name[es]=Instalar paquete con el tema KBFX +Name[et]=KBFX teemapaketi paigaldamine +Name[fr]=Installer le paquet des thèmes KBFX +Name[ja]=KBFX テーマパッケージをインストール +Name[nl]=KBFX-themapakket installeren +Name[pt]=Instalar o Pacote de Tema do KBFX +Name[pt_BR]=Instalar Pacote do Tema KBFX +Name[sv]=Installera KBFX-temapaket + diff --git a/configdialog/kbfx_prepare_theme.desktop b/configdialog/kbfx_prepare_theme.desktop new file mode 100644 index 0000000..f510fc5 --- /dev/null +++ b/configdialog/kbfx_prepare_theme.desktop @@ -0,0 +1,23 @@ +[Desktop Entry] +Encoding=UTF-8 +ServiceTypes=inode/directory +Actions=kbfx_prepare_theme + +[Desktop Action kbfx_prepare_theme] +Icon=kbfxconfigapp +Exec=kbfxconfigapp --prepare %u +Name=Prepare KBFX Theme Package +Name[bg]=Подготовка на пакета KBFX Theme +Name[da]=Opret KBFX-temapakke +Name[de]=KBFX Theme-Paket vorbereiten +Name[el]=Προετοιμασία του πακέτου θέματος KBFX +Name[es]=Preparar paquete con el tema KBFX +Name[et]=KBFX teemapaketi ettevalmistamine +Name[fr]=Preparer le paquet des thèmes KBFX +Name[ga]=Ullmhaigh Pacáiste Téama KBFX +Name[ja]=KBFX テーマパッケージを準備 +Name[nl]=KBFX-themapakket voorbereiden +Name[pt]=Preparar o Pacote de Tema do KBFX +Name[pt_BR]=Preparar Pacote do Tema KBFX +Name[sv]=Skapa KBFX-temapaket + diff --git a/configdialog/kbfx_theme.desktop b/configdialog/kbfx_theme.desktop new file mode 100644 index 0000000..50b3b37 --- /dev/null +++ b/configdialog/kbfx_theme.desktop @@ -0,0 +1,18 @@ +[Desktop Entry] +Encoding=UTF-8 +Name=KBFX Theme Installer +Name[de]=Installations von KBFX-Themes +Name[el]=Εγκατάσταση θέματος KBFX +Name[et]=KBFX teema paigaldaja +Name[fr]=Outil d'installation des thèmes KBFX +Name[ja]=KBFX テーマインストーラ +Name[nl]=KBFX-thema-installatie +Name[pt]=Instalador de Temas do KBFX +Name[pt_BR]=Instalador de Temas do KBFX +Name[sv]=KBFX-temainstallation +Exec=kbfxconfigapp --install %u +Icon=kbfxconfigapp +Type=Application +MimeType=application/x-kbfxtheme +NoDisplay=true + diff --git a/configdialog/kbfxconfigapp.cpp b/configdialog/kbfxconfigapp.cpp new file mode 100644 index 0000000..ac17881 --- /dev/null +++ b/configdialog/kbfxconfigapp.cpp @@ -0,0 +1,416 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxconfigapp.h" + +KbfxConfigApp::KbfxConfigApp ( QWidget* parent, const char* name, WFlags fl ) + : KbfxConfigDlgMain ( parent,name,fl ) +{ +// m_KbfxVersion = tr2i18n("

Running KBFX version: " APPLICATION_VERSION "

"); + m_KbfxVersion = tr2i18n ( "

%1

" ); + m_KbfxVersion2 = tr2i18n ( "You are running: KBFX " APPLICATION_VERSION "" ); + m_KbfxNewsBrowserError = tr2i18n ( "

" + "The connection to the KBFX News Section on www.kbfx.org is broken." + "

" + "If you want you can check the latest news for KBFX from here:" + "
KBFX News

" ); + m_KbfxLogoButton = tr2i18n ( "KBFX start button
" + "Tip! " + "You have 3 options to select for your KBFX start button." + "You have to select (Normal, Pressed, Hover) images.
" + "Down below you can also see a preview of the images you have selected." ); + m_KbfxLogoAbout = tr2i18n ( "About KBFX
" + "Tip! " + "Here you can find information about the KBFX Project and all the people involved in it." ); + m_KbfxLogoFonts = tr2i18n ( "KBFX font settings
" + "Tip! " + "Here you can set the fonts of the current theme.
" + "If you don't have any 'kbfxfontrc' file don't worry about that.
" + "When done just hit 'Apply' button and KBFX will save the 'kbfxfontrc' file." ); + m_KbfxLogoLayout = tr2i18n ( "KBFX Layout
" + "Tip! " + "Here you can configure the Look and Feel of your KBFX menu.
" + "The most important settings that are used with the 'Make it...' buttons are marked with '*'
" + "Have in mind that the Layout of the theme also depends on the sizes of the images!
" ); + m_KbfxLogoPlugins = tr2i18n ( "KBFX Plugins
" + "Tip! " + "Here you can select what plugins will be enabled and in which panel of the KBFX menu." ); + m_KbfxLogoStyle = tr2i18n ( "Menu Type
" + "Tip! " + "Please select which kind of menu you would like to use." ); + m_KbfxLogoThemes = tr2i18n ( "KBFX Themes
" + "Tip! " + "To keep it simple place all your themes inside one folder.
" + "Then create different folders inside that folder with different names.
" + "KBFX will then read those folders as themes." ); + m_KbfxLogoTooltip = tr2i18n ( "KBFX tooltip settings
" + "Tip! " + "Here you can configure the behaviour of KBFX's own tooltip." ); + m_KbfxNewsBrowserAddress = "http://www.kbfx.org/news/"; + InitForm(); +} + +KbfxConfigApp::~KbfxConfigApp() +{} + +void KbfxConfigApp::InitForm() +{ + lb_Main->clear(); + + /* initialize Themes page */ + lb_Main->insertItem ( img_themes, tr2i18n ( "Themes" ), THEMES ); + KbfxConfigDlgThemes *pageThemes = new KbfxConfigDlgThemes(); + ws_Main->addWidget ( pageThemes, THEMES ); + connect ( this, SIGNAL ( KbfxConfigDlgThemesChanged() ), + pageThemes, SLOT ( ChangeForm() ) ); + emit KbfxConfigDlgThemesChanged(); + connect ( pageThemes->KbfxGetMoreThemes, SIGNAL ( clicked() ), + this, SLOT ( KbfxGetMoreThemesClicked() ) ); + connect ( this, SIGNAL ( KbfxThemeDoInstall ( QString & ) ), + pageThemes, SLOT ( KbfxThemeInstall ( QString & ) ) ); + + /* initialize Button page */ + lb_Main->insertItem ( img_button, tr2i18n ( "Start Button" ), BUTTON ); + KbfxConfigDlgButton *pageButton = new KbfxConfigDlgButton(); + ws_Main->addWidget ( pageButton, BUTTON ); + connect ( this, SIGNAL ( KbfxConfigDlgButtonChanged() ), + pageButton, SLOT ( ChangeForm() ) ); + emit KbfxConfigDlgButtonChanged(); + + /* initialize Fonts page */ + lb_Main->insertItem ( img_fonts, tr2i18n ( "Fonts" ), FONTS ); + KbfxConfigDlgFonts *pageFonts = new KbfxConfigDlgFonts(); + ws_Main->addWidget ( pageFonts, FONTS ); + connect ( this, SIGNAL ( KbfxConfigDlgFontsChanged() ), + pageFonts, SLOT ( ChangeForm() ) ); + emit KbfxConfigDlgFontsChanged(); + + /* initialize Layout Page */ + lb_Main->insertItem ( img_search, tr2i18n ( "Layout" ), LAYOUT ); + KbfxConfigDlgLayout *pageLayout = new KbfxConfigDlgLayout(); + ws_Main->addWidget ( pageLayout, LAYOUT ); + connect ( this, SIGNAL ( KbfxConfigDlgLayoutChanged() ), + pageLayout, SLOT ( ChangeForm() ) ); + connect ( this, SIGNAL ( KbfxConfigDlgLayoutLeft() ), + pageLayout, SLOT ( LayoutFormLeft() ) ); + emit KbfxConfigDlgLayoutChanged(); + + /* initialize Plugins Page */ + lb_Main->insertItem ( img_plugins, tr2i18n ( "Plugins" ), PLUGINS ); + KbfxConfigDlgPlugins *pagePlugins = new KbfxConfigDlgPlugins(); + ws_Main->addWidget ( pagePlugins, PLUGINS ); + connect ( this, SIGNAL ( KbfxConfigDlgPluginsChanged() ), + pagePlugins, SLOT ( ChangeForm() ) ); + emit KbfxConfigDlgPluginsChanged(); + + /* initialize Tooltip page */ + lb_Main->insertItem ( img_tooltip, tr2i18n ( "Tooltip" ), TOOLTIP ); + KbfxConfigDlgTooltip *pageTooltip = new KbfxConfigDlgTooltip(); + ws_Main->addWidget ( pageTooltip, TOOLTIP ); + connect ( this, SIGNAL ( KbfxConfigDlgTooltipChanged() ), + pageTooltip, SLOT ( ChangeForm() ) ); + emit KbfxConfigDlgTooltipChanged(); + + /* initialize Menu Style page */ + lb_Main->insertItem ( img_style, tr2i18n ( "Menu Style" ), STYLE ); + KbfxConfigDlgStyle *pageStyle = new KbfxConfigDlgStyle(); + ws_Main->addWidget ( pageStyle, STYLE ); + connect ( this, SIGNAL ( KbfxConfigDlgStyleChanged() ), + pageStyle, SLOT ( ChangeForm() ) ); + emit KbfxConfigDlgStyleChanged(); + + /* initialize About page */ + lb_Main->insertItem ( img_about, tr2i18n ( "About" ), ABOUT ); + KbfxConfigDlgAbout *pageAbout = new KbfxConfigDlgAbout(); + ws_Main->addWidget ( pageAbout,ABOUT ); + pageAbout->KbfxLabelVersion->setText ( m_KbfxVersion2 ); + + connect ( btn_Default, SIGNAL ( clicked() ), + this, SLOT ( btn_DefaultClicked() ) ); + connect ( btn_Help, SIGNAL ( clicked() ), + this, SLOT ( btn_HelpClicked() ) ); + connect ( lb_Main, SIGNAL ( highlighted ( int ) ), + this, SLOT ( KbfxMenuItemChanged ( int ) ) ); + connect ( btn_SaveApply, SIGNAL ( clicked() ), + this, SLOT ( btn_SaveApplyClicked() ) ); + + m_KbfxPage = THEMES; + lb_Main->setCurrentItem ( THEMES ); + ws_Main->raiseWidget ( THEMES ); +} + +/* process help for each page */ +void KbfxConfigApp::btn_HelpClicked() +{ + if ( m_KbfxPage == THEMES ) + kapp->invokeHelp ( "kbfx_themes", "kbfxconfigapp" ); + if ( m_KbfxPage == BUTTON ) + kapp->invokeHelp ( "kbfx_button", "kbfxconfigapp" ); + if ( m_KbfxPage == FONTS ) + kapp->invokeHelp ( "kbfx_fonts", "kbfxconfigapp" ); + if ( m_KbfxPage == LAYOUT ) + kapp->invokeHelp ( "kbfx_layout", "kbfxconfigapp" ); + if ( m_KbfxPage == PLUGINS ) + kapp->invokeHelp ( "kbfx_plugins", "kbfxconfigapp" ); + if ( m_KbfxPage == TOOLTIP ) + kapp->invokeHelp ( "kbfx_tooltip", "kbfxconfigapp" ); + if ( m_KbfxPage == STYLE ) + kapp->invokeHelp ( "kbfx_style", "kbfxconfigapp" ); + if ( m_KbfxPage == ABOUT) + kapp->invokeHelp ( "kbfx_about", "kbfxconfigapp" ); +} + +/* process default options for each page */ +void KbfxConfigApp::btn_DefaultClicked() +{ + switch ( ws_Main->id ( ws_Main->visibleWidget() ) ) + { + case THEMES: /* Themes page */ + { + ConfigInit().m_SpinxThemeBasePath = ConfigInit().m_SpinxThemeBasePathDefault; + ConfigInit().m_UserSpinxThemeBasePath = ConfigInit().m_UserSpinxThemeBasePathDefault; + ConfigInit().m_SpinxThemeName = ConfigInit().m_SpinxThemeNameDefault; + ConfigInit().m_SpinxDudeBlink = ConfigInit().m_SpinxDudeBlinkDefault; + ConfigInit().m_SpinxDudeImage = ConfigInit().m_SpinxDudeImageDefault; + ConfigInit().m_KbfxWatcher = ConfigInit().m_KbfxWatcherDefault; + ConfigInit().m_KbfxShowOldThemes = ConfigInit().m_KbfxShowOldThemesDefault; + emit KbfxConfigDlgThemesChanged(); + break; + } + case BUTTON: /* Button page */ + { + ConfigInit().m_KbfxNormalButtonPath = ConfigInit().m_KbfxNormalButtonPathDefault; + ConfigInit().m_KbfxHoverButtonPath = ConfigInit().m_KbfxHoverButtonPathDefault; + ConfigInit().m_KbfxPressedButtonPath = ConfigInit().m_KbfxPressedButtonPathDefault; + ConfigInit().m_ToolBarResize = ConfigInit().m_ToolBarResizeDefault; + ConfigInit().m_fadeTime = ConfigInit().m_fadeTimeDefault; + emit KbfxConfigDlgButtonChanged(); + break; + } + case FONTS: /* Fonts page */ + { + ConfigInit().readFontrc ( ConfigInit().m_SpinxThemeBasePath, + ConfigInit().m_SpinxThemeName, + FALSE ); + emit KbfxConfigDlgFontsChanged(); + break; + } + case STYLE: /* Style page */ + { + ConfigInit().m_KbfxMenuType = ConfigInit().m_KbfxMenuTypeDefault; + emit KbfxConfigDlgStyleChanged(); + break; + } + case TOOLTIP: /* Tooltip page */ + { + ConfigInit().m_ToolTip = ConfigInit().m_ToolTipDefault; + ConfigInit().m_ToolTipAnimation = ConfigInit().m_ToolTipAnimationDefault; + ConfigInit().m_ToolTipText = ConfigInit().m_ToolTipTextDefault; + ConfigInit().m_ToolTipAvatar = ConfigInit().m_ToolTipAvatarDefault; + ConfigInit().m_SpinxTooltipDudebox = ConfigInit().m_SpinxTooltipDudeboxDefault; + ConfigInit().m_SpinxTooltipMask = ConfigInit().m_SpinxTooltipMaskDefault; + ConfigInit().m_SpinxTooltipWindow = ConfigInit().m_SpinxTooltipWindowDefault; + ConfigInit().m_SpinxTooltipLogo = ConfigInit().m_SpinxTooltipLogoDefault; + emit KbfxConfigDlgTooltipChanged(); + break; + } + case LAYOUT: /* Layout page */ + { + ConfigInit().readThemerc ( ConfigInit().m_SpinxThemeBasePath, + ConfigInit().m_SpinxThemeName, + FALSE ); + emit KbfxConfigDlgLayoutChanged(); + break; + } + case PLUGINS: /* Plugins page */ + { + ConfigInit().m_pluginsLeft = ConfigInit().m_pluginsLeftDefault; + ConfigInit().m_pluginsRight = ConfigInit().m_pluginsRightDefault; + emit KbfxConfigDlgPluginsChanged(); + break; + } + case ABOUT: /* About page */ + { + KMessageBox::information ( 0, tr2i18n ( "No default settings here ;)" ) ); + break; + } + default: /* Default Action Switch should never be reached */ + kdDebug() << "Default action switch for default clicked..." << endl; + } +} + +void KbfxConfigApp::KbfxMenuItemChanged ( int index ) +{ + /* + * switch is used in case we want to add special code + * for certain page before raiseWidget is called + */ + + + if( m_KbfxPage == LAYOUT ) + { + emit KbfxConfigDlgLayoutLeft(); + } + + m_KbfxPage = index; + + switch ( index ) + { + case THEMES: /* Themes page */ + { + KbfxLogoText->setText(m_KbfxLogoThemes); + ws_Main->raiseWidget ( THEMES ); + emit KbfxConfigDlgThemesChanged(); + break; + } + case BUTTON: /* Button page */ + { + KbfxLogoText->setText(m_KbfxLogoButton); + ws_Main->raiseWidget ( BUTTON ); + emit KbfxConfigDlgButtonChanged(); + break; + } + case FONTS: /* Fonts page */ + { + KbfxLogoText->setText(m_KbfxLogoFonts); + ws_Main->raiseWidget ( FONTS ); + emit KbfxConfigDlgFontsChanged(); + break; + } + case STYLE: /* Style page */ + { + KbfxLogoText->setText(m_KbfxLogoStyle); + ws_Main->raiseWidget ( STYLE ); + emit KbfxConfigDlgStyleChanged(); + break; + } + case TOOLTIP: /* Tooltip page */ + { + KbfxLogoText->setText(m_KbfxLogoTooltip); + ws_Main->raiseWidget ( TOOLTIP ); + emit KbfxConfigDlgTooltipChanged(); + break; + } + case LAYOUT: /* Layout page */ + { + KbfxLogoText->setText(m_KbfxLogoLayout); + ws_Main->raiseWidget ( LAYOUT ); + emit KbfxConfigDlgLayoutChanged(); + break; + } + case PLUGINS: /* Plugins page */ + { + KbfxLogoText->setText(m_KbfxLogoPlugins); + ws_Main->raiseWidget ( PLUGINS ); + break; + } + case ABOUT: /* About page */ + { + KbfxLogoText->setText(m_KbfxLogoAbout); + ws_Main->raiseWidget ( ABOUT ); + break; + } + default: /* default action switch should never be reached */ + kdDebug() << "Default action switch for menu changed..." << endl; + } +} + +void KbfxConfigApp::KbfxNewsBrowserOpenURLRequest ( const KURL &url, const KParts::URLArgs & ) +{ + kdDebug() << "Starting Konqueror ... "<< endl; + KRun::runCommand ( "konqueror " + url.url() ); + + return ; +} + +void KbfxConfigApp::KbfxNewsBrowserCompleted() +{ + kio->KbfxKioDownloadEnd(); +} + +void KbfxConfigApp::browserInit() +{ + /* initialize NewsBrowser widget */ + kio = new KbfxKioDownload(); + connect ( kio, SIGNAL ( KbfxKioDownloadReady() ), + this, SLOT ( KbfxNewsBrowserLoad() ) ); + kio->KbfxKioDownloadStart ( m_KbfxNewsBrowserAddress ); +} + +void KbfxConfigApp::KbfxNewsBrowserLoad() +{ + if ( kio->KbfxBrowserError() ) KBFXNewsBrowser->setText ( m_KbfxNewsBrowserError ); + else + { + browser = new KHTMLPart ( KBFXNewsBrowser ); + browser->openURL ( kio->KbfxBrowserTmpFile() ); + browser->view()->resize ( KBFXNewsBrowser->width(), KBFXNewsBrowser->height() ); + browser->view()->setVScrollBarMode ( QScrollView::AlwaysOff ); + browser->view()->setHScrollBarMode ( QScrollView::AlwaysOff ); + browser->view()->setFocusPolicy ( QWidget::NoFocus ); + browser->view()->show(); + + connect ( browser->browserExtension(), + SIGNAL ( openURLRequest ( const KURL &, const KParts::URLArgs & ) ), + this, + SLOT ( KbfxNewsBrowserOpenURLRequest ( const KURL &, const KParts::URLArgs & ) ) ); + connect ( browser, SIGNAL ( completed() ), + this, SLOT ( KbfxNewsBrowserCompleted() ) ); + } +} + +void KbfxConfigApp::KbfxGetMoreThemesClicked() +{ + KRun::runCommand ( "konqueror 'http://www.kbfx.org/news/new_themes.html'" ); + + return ; +} + +void KbfxConfigApp::KbfxThemeInstall ( QString & themeURL ) +{ + emit KbfxThemeDoInstall ( themeURL ); +} + + +void KbfxConfigApp::btn_SaveApplyClicked() +{ + if( m_KbfxPage == LAYOUT ) + { + emit KbfxConfigDlgLayoutLeft(); + } + + ConfigInit().write(); + ConfigInit().writeThemerc ( ConfigInit().m_SpinxThemeName ); + ConfigInit().writeFontrc ( ConfigInit().m_SpinxThemeName ); + + + DCOPRef m_kickerkbfxDevelnterface ( "kicker","KBFXInterface" ); + m_kickerkbfxDevelnterface.call ( "notifyConfigChange()" ); + +/* +// m_kickerkbfxDevelnterface.call ( "notifyConfigChange()" ); +// DCOPRef m_kickerPanel("kicker","Panel"); + DCOPRef m_kickerPanel("kicker","kicker"); + m_kickerPanel.call("restart()"); +*/ +} + +#include "kbfxconfigapp.moc" diff --git a/configdialog/kbfxconfigapp.desktop b/configdialog/kbfxconfigapp.desktop new file mode 100644 index 0000000..bac0e2c --- /dev/null +++ b/configdialog/kbfxconfigapp.desktop @@ -0,0 +1,36 @@ +[Desktop Entry] +Encoding=UTF-8 +Name=KBFX Configurator +Name[da]=KBFX-indstilling +Name[de]=KBFX einrichten +Name[el]=Ρύθμιση KBFX +Name[es]=Cofigurador de KBFX +Name[et]=KBFX seadistaja +Name[fr]=Configuration de KBFX +Name[ga]=Cumraitheoir KBFX +Name[ja]=KBFX 設定ツール +Name[pt]=Configuração do KBFX +Name[pt_BR]=Configurador do KBFX +Name[sv]=KBFX-inställning +Comment=KBFX Configuration Utility +Comment[bg]=Настройка на KBFX +Comment[br]=Ostilh kefluniadur KBFX +Comment[da]=KBFX-indstillingsværktøj +Comment[de]=KBFX Konfigurationswerkzeug +Comment[el]=Εργαλείο ρύθμισης του KBFX +Comment[es]=Utilidad de configuración de KBFX +Comment[et]=KBFX seadistamistööriist +Comment[fr]=Outil de configuration des services KBFX +Comment[ga]=Uirlis Chumraíochta KBFX +Comment[gl]=Ferramenta de Configurazón de KBFX +Comment[ja]=KBFX 設定ユーティリティ +Comment[nl]=KBFX-configuratieprogramma +Comment[pt]=Utilitário de Configuração do KBFX +Comment[pt_BR]=Utilitário para Configuração do KBFX +Comment[sv]=KBFX-inställningsverktyg +Icon=kbfxconfigapp +Exec=kbfxconfigapp +Type=Application +Categories=Qt;KDE;Settings; +DocPath=kbfxconfigapp/index.html +X-DCOP-ServiceType=Unique diff --git a/configdialog/kbfxconfigapp.h b/configdialog/kbfxconfigapp.h new file mode 100644 index 0000000..80f22ca --- /dev/null +++ b/configdialog/kbfxconfigapp.h @@ -0,0 +1,159 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + + +#ifndef _KBFXCONFIGAPP_H_ +#define _KBFXCONFIGAPP_H_ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "kbfxconfigdlgabout.h" +#include "kbfxconfigdlgbutton.h" +#include "kbfxconfigdlgfonts-old.h" +#include "kbfxconfigdlglayout.h" +#include "kbfxconfigdlgmain.h" +#include "kbfxconfigdlgplugins.h" +#include "kbfxconfigdlgstyle.h" +#include "kbfxconfigdlgthemes.h" +#include "kbfxconfigdlgtooltip.h" + +/** + * @short Application Main Window + * @author PhobosK + * @version 0.1 + */ + +enum {THEMES=0, BUTTON, FONTS, LAYOUT, PLUGINS, TOOLTIP, STYLE, ABOUT}; + +class KbfxConfigApp : public KbfxConfigDlgMain +{ + Q_OBJECT + public: + /** + * Default Constructor + */ + KbfxConfigApp ( QWidget* parent = 0, const char* name = 0, WFlags fl = 0 ); + + /** + * Default Destructor + */ + virtual ~KbfxConfigApp(); + void InitForm(); + + QString m_KbfxVersion; + QString m_KbfxVersion2; + QString m_KbfxNewsBrowserError; + QString m_KbfxNewsBrowserAddress; + + void browserInit(); + + + private: + QString m_KbfxLogoButton; + QString m_KbfxLogoThemes; + QString m_KbfxLogoAbout; + QString m_KbfxLogoLayout; + QString m_KbfxLogoTooltip; + QString m_KbfxLogoFonts; + QString m_KbfxLogoStyle; + QString m_KbfxLogoPlugins; + KbfxConfigDlgButton *pageButton; + KbfxConfigDlgThemes *pageThemes; + KbfxConfigDlgFonts *pageFonts; + KbfxConfigDlgStyle *pageStyle; + KbfxConfigDlgPlugins *pagePlugins; + KbfxConfigDlgLayout *pageLayout; + KbfxConfigDlgTooltip *pageTooltip; + KbfxConfigDlgAbout *pageAbout; + KHTMLPart * browser; + KbfxKioDownload * kio; + QString m_KbfxThemeUrl; + QString m_KbfxThemeFolderUrl; + int m_KbfxPage; + + public slots: + virtual void btn_DefaultClicked(); + virtual void btn_HelpClicked(); + virtual void btn_SaveApplyClicked(); + virtual void KbfxMenuItemChanged ( int index ); + virtual void KbfxNewsBrowserOpenURLRequest ( const KURL &, const KParts::URLArgs & ); + virtual void KbfxNewsBrowserCompleted(); + virtual void KbfxNewsBrowserLoad(); + virtual void KbfxGetMoreThemesClicked(); + virtual void KbfxThemeInstall ( QString & ); + + signals: + void KbfxConfigDlgButtonChanged(); + void KbfxConfigDlgThemesChanged(); + void KbfxConfigDlgStyleChanged(); + void KbfxConfigDlgTooltipChanged(); + void KbfxConfigDlgLayoutChanged(); + void KbfxConfigDlgLayoutLeft(); + void KbfxConfigDlgPluginsChanged(); + void KbfxConfigDlgFontsChanged(); + void KbfxThemeDoInstall( QString & ); + +}; + +#endif // _KBFXCONFIGAPP_H_ diff --git a/configdialog/kbfxconfigapp.lsm b/configdialog/kbfxconfigapp.lsm new file mode 100644 index 0000000..df0859a --- /dev/null +++ b/configdialog/kbfxconfigapp.lsm @@ -0,0 +1,16 @@ +Begin3 +Title: $APPNAME$ -- KBFX Configuration Utility +Version: $VERSION$ +Entered-date: +Description: +Keywords: KDE Qt +Author: PhobosK +Maintained-by: PhobosK +Home-page: http://www.kbfx.org +Alternate-site: +Primary-site: ftp://ftp.kde.org/pub/kde/unstable/apps/utils + xxxxxx kbfxconfigapp-0.1.tar.gz + xxx kbfxconfigapp-0.1.lsm +Platform: Linux. Needs KDE +Copying-policy: $LICENSE$ +End diff --git a/configdialog/kbfxconfigappui.rc b/configdialog/kbfxconfigappui.rc new file mode 100644 index 0000000..74cf442 --- /dev/null +++ b/configdialog/kbfxconfigappui.rc @@ -0,0 +1,8 @@ + + + + C&ustom + + + + diff --git a/configdialog/kbfxconfigdlgabout.ui b/configdialog/kbfxconfigdlgabout.ui new file mode 100644 index 0000000..034575f --- /dev/null +++ b/configdialog/kbfxconfigdlgabout.ui @@ -0,0 +1,727 @@ + +KbfxConfigDlgAbout + + + KbfxConfigDlgAbout + + + + 0 + 0 + 697 + 578 + + + + + 1 + 1 + 0 + 0 + + + + Form1 + + + + unnamed + + + 10 + + + Minimum + + + + kActiveLabel37 + + + + 7 + 0 + 0 + 0 + + + + + 0 + 29 + + + + + 32767 + 29 + + + + + 255 + 255 + 255 + + + + image0 + + + true + + + NoFocus + + + AutoText + + + <b><h3><p align="center">People behind KBFX</p></h3></b> + + + + + layout4 + + + + unnamed + + + + layout5 + + + + unnamed + + + 0 + + + 0 + + + + KbfxLabelVersion + + + + 0 + 0 + 0 + 0 + + + + + 629 + 20 + + + + + 629 + 20 + + + + + 255 + 255 + 255 + + + + image1 + + + + 11 + + + + NoFocus + + + You are running: <b>KBFX 0493</b> + + + + + kActiveLabel6 + + + + 3 + 0 + 0 + 0 + + + + + 0 + 20 + + + + + 32767 + 20 + + + + image2 + + + NoFocus + + + + + + + textLabel1 + + + + 1 + 1 + 0 + 0 + + + + Here are the people behind the KBFX application. +We would like to thank all people who have helped with KBFX or have donated money to our project! +THANKS A LOT ALL OF YOU OUT THERE!!! + + + AlignVCenter + + + + + line3 + + + HLine + + + Sunken + + + Horizontal + + + + + + + layout6 + + + + unnamed + + + + KbfxTeamInfo + + + + 1 + 3 + 0 + 0 + + + + NoFocus + + + StyledPanel + + + <strong>Name:</strong> Siraj Razick<br><br><strong>Country:</strong> Sri Lanka<br><br><strong>KBFX:</strong> Author, Maintainer, Developer, Project Admin<br><br><strong>Email:</strong> siraj(a)mail.kbfx.org + + + AtWordOrDocumentBoundary + + + true + + + + + layout5 + + + + unnamed + + + + layout8 + + + + unnamed + + + 20 + + + + KbfxPixmapLabelEphracis + + + + 0 + 0 + 0 + 0 + + + + + 90 + 90 + + + + + 90 + 90 + + + + true + + + WheelFocus + + + true + + + Raised + + + image3 + + + true + + + + + KbfxPixmapLabelJohnny + + + + 0 + 0 + 0 + 0 + + + + + 90 + 90 + + + + + 90 + 90 + + + + true + + + WheelFocus + + + true + + + Raised + + + image4 + + + true + + + + + KbfxPixmapLabelPhobosK + + + + 0 + 0 + 0 + 0 + + + + + 90 + 90 + + + + + 90 + 90 + + + + true + + + WheelFocus + + + true + + + Raised + + + image5 + + + true + + + + + KbfxPixmapLabelNookie + + + + 0 + 0 + 0 + 0 + + + + + 90 + 90 + + + + + 90 + 90 + + + + true + + + WheelFocus + + + true + + + Raised + + + image6 + + + true + + + + + KbfxPixmapLabelNathanael + + + + 0 + 0 + 0 + 0 + + + + + 90 + 90 + + + + + 90 + 90 + + + + true + + + WheelFocus + + + true + + + Raised + + + image7 + + + true + + + + + KbfxPixmapLabelSiraj + + + + 0 + 0 + 0 + 0 + + + + + 90 + 90 + + + + + 90 + 90 + + + + true + + + WheelFocus + + + true + + + WinPanel + + + Raised + + + image8 + + + true + + + + + + + textLabel3 + + + + 1 + 1 + 0 + 0 + + + + StyledPanel + + + Sunken + + + <b>Tip!</b> Hover over the contact images to see each personal contact information. + + + WordBreak|AlignVCenter + + + + + spacer4 + + + Vertical + + + MinimumExpanding + + + + 24 + 1 + + + + + + groupBox1 + + + + 1 + 1 + 0 + 0 + + + + + 9 + + + + StyledPanel + + + SPONSORS! + + + AlignVCenter + + + + unnamed + + + 4 + + + + textLabel5 + + + + 1 + 1 + 0 + 0 + + + + We would like to thank swedish computer company <b>PC Agenten</b> for sponsoring us with a server and bandwidth. + + + WordBreak|AlignVCenter + + + + + textLabel6 + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + <p align="right"><u><b><a href='http://www.pcagenten.se'>HTTP://WWW.PCAGENTEN.SE</a></u></b></p> + + + + + + + + + + + + + + + 789ced974b6fda401446f7fc0a8bec5095601eb64755174d7080a669d3b48b4a5517e33134a1101230e151f5bfd7f7bbc3f8510bb29a45d5b331e77e77c6c6067b7cd670bede5c3b8db3da3291c9bd72d49d5c388d78359b6dbf7d7ff3ab5677dda6d3124e2770dcfaab5afdd651ce4953785d11937e822acf63bd81c67bfd0c1d793eeb47ad8118917e20755d4f8a31e935d4f394c48ede4395df941dd277a4adaedf9501e995568f75001dfb9154a443ad8ab547da96412bc2cc97465ba4a1d636a77da348df9276ba818c3cd273a33ee985d688d30d69d7156e14916e8de230d65a5b9cee8c22fd028dfd91c05409ab08549374611407b9d42a387d328af459abe4746514e99cd40b645375491f8c62bf8f5a5d4e6746914e49fdb64c2f12e94fad3eeb049a9e7485eb7baf3566bd23a5b31ce3c4fe808aa813e3fa8ea02af263ec68ac35603d85c642ffea147494a6b80ab156c17a422a9afb34d22a631ca4d41ab19e5a058767157ce52a22a6322bb51debc95a69830b5445cc5466a5b6633d592b6df0fba962cc5466a5b6633d592b6df003b60afe4156c15ff810938c5ca9f4a16c93228509714b39c43423572a7d28dbb4486142dce2521e8acce78f9a3983da3c5f6152a7b17a8afdb042cb1c33cef6e0760d160ccbd290243a5824cb65be6cf449b35a9961cf29694752985383470fd86c36db941d581bb84a6cd6eb7cd9e82ea3d4b11fbacb83e7668173f07705a58b14aeec4378aeab3032ad16356dc753be17863d260cc34ba26f2a3daa6429d337a50c1a13f6fb61a99a178cc5aa63301c0e98a1fe3434952c435533a8e04094efc02ae8a55c8117b7578fc732cc2a58075a050b51ab60256c15acccad825703abfcdfe3bfb3c75babe045d52a78ddb34afdf7ebda1f4394dd1e + + + 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 + + + 789c9594cf4a04310cc6eff314657b5b64d61554447c04c1a3201ed2f4cf4cbb330bba1e447c77933483d7766e3fd28f245f9239eccdebcbb3d91f86cf0b5c663438c187d9fbaf65f97e7b7ffa1976b777e6e6da1cefcd717735ec4e068d8d0f1163641c0521ba8a5651a38ba0dba2a0a85154f4159d206e51afa8d1a8182a0641bf45b3a246cf8ab1e22a18b6c749511f17457d3c0bc62d3a296a74b460c1a1f7244ff44df3d4f48939d60229bdcf21e49c526993aa16009de3bc99f3f6684f54348267b34287b4e65d488b5c35d5ccda4675f58a8a762cf599fa2da5c7ab4d1c327bd52aad794700d1462e3995d68e252f8cb5e698453ba70eade5bc484ef17c4b9a7bf2da45bd0a2b659e4a8fcfc0e345e9978beef14a6a96b4816794a68e7e4732daf146071e52a7cf5c34af55f4d5e8be9aa95f3986b052da46e9ff1d61bda39072e9bbdf456e21d05292b4f4cc887f1b283b4936e773e76ef02938f971b0576d4ad2fe3e0e7f0aaa12e4 + + + 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 + + + 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 + + + 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 + + + 789c44ddc7722a5dd6ade17e5dc51745afe204854d92c66948026441202f9d388dc4c93bbcf4dffc9f30df31b4b55b4fa459b9cc5c260dfffdcf3f77fdee3ffff9efbfe68b6cf13cfa67f494cdfef9cf78f9fefef3fffefffffd9f7ffd3b4dfec9ffd7aaa5d23fd57fff9f7ffdbb3839fe67f44fa15429e5ff76f0740a544ae5d8e26807556ff1d8002a823a500526a7863846a5050ccbb1c5e87a07b5bf5d4e0cb1cbfb85a11209ab0035b6c84686d8e2ed12a8039b6c07f5edd5ec60d10474da2c33c4419f8e0db14b36047cda8921b678b905eada626a882daeaa802ebf7f6a885daa17c008981cee2071aebf5f024afad389217679ae18e2b48f09e0a48f0db1c5700628a5ef5786a81f1ff740020c8f0db51d7c960df51d4c75da06bb4c1b4013b82d18a69141756028d0b58c816e0b989477292d14df8069390efa14f5b4e1c21e0a94639bd410f9f1786a885d4657404df5a3606097ae816af96d8874bc5d00aa0e8f0b43e458f603284f473740832dbeea405a4a76705d02b2d22432a866880caa291d1975ac7a6388749ceab4438e71ba31c431aa6f027619dc03a3d238ce32177096dab52176a9770c7171374ac7985dcecf0cb14bd230449e565f0c54981e306197febd2176b9be03a66c91960d91a7f57743e46956dc41fa170c360682411550e98f2e0c71dae75343a4f4f5d710a77d6d03aa0e4f3303f5f4dbc0310a8638c650c7481493cf0c44a93d403568da0452416a8866faa8cb6f02df354323a2f6a1214abf710ea88ef50680aad4e0c11055eab2216097a46d20f4bd1ae25a9a4b43e447bf04a8165e248638ed656a88d3f6950ed5d38bba214e7b796988d3269f8638ed838a4131a8a7cb574dbeb934c4416fae0cd4e45b431cf4eec010e57273618862383b06269cf6fc46a006746da0cd1d19e2b4fd3b439cf6fade406b50d94e39e865dd10c7a82d0c34e481218e51bb3144d2eb354334b1e6b1218dfc201de512074d5b86386895922b97e3a085e299218e51a389952bc05be469d30d797469a0cd6d00b5caec1150ab1c760cc4f52f435ccbeb11a036f7b831d0357e19e22ca33b436450a507a86b1c7e1a6297a7a2217679bd0552f5a60503d1e1d410bb5cbe1b8671d00468b2cb630a6434f5d3b5212addac040c4b91c9974d43b4b95edf10bb9cfe0aa852571f86c8e4fb2f436461e5c81009eb1e036ad9e7b7065ac39580b39cb50cf4737b8638cbcdb521b2f052f9a1967da674a8659fcc0d71d0eedf1671d0d37d03cd2333c4b5245f8628978b0630e1e2ee9474b7ec4b03a73d30c469bb6d032dfbd610a7bddb37c469abef86a8c9b599214abfaf63a8ed9fb50d74c0a78638cbed9921ce92a486384bf5ce106779a06abbeddfff18e2a00fb706925e3270d08a210edae42c797420a0540c71d0d2a9210efa7069e0a01f8638686d6d88caff400dca434e1ca3bc31c4311eae0c749e2706425f15a8ea183543ec5288269679eab529001a7f0ce780a2d4e39981807208284a3d9f18628b55c940c8591a22e232b1da02a1efc71029fd38021a3a4bdd1067f9ac19e22c2f0f80e2d87762208e7d182283c63aa846289f554324ec7405e47f91a70f866862d32230649787be21da7ef94da0807260885c7f18008a41a72d8146171786d8e5fcc4406f7a6b88cb6ffc01f574df10573b6f00632eeefac1402cbc13286ccd0cc4c2b621d271db3530b8fa834847b96c887434fece12a57fa52d14a5cebb06e247c7c0b067cf1067e9f50c7196b46a204add1b1a3110780734c4af5c1be2b4bd530381be6620c2248638ed55c9c0691f0c71b537478668c8b7242c8f41d48f1743a4e3ae6788740cee0c918e7edf10e928750cd4d31b43a4a3746448233ffeced28c5ac8d53a16d6ab06cab66ee0b42786386de5d8402c5c19e2f22ba7064eabb35474967b439ca5b631c459caef06a265c71067691072f2e048c2ce0cb14bbd6e885d9299211236b8026a1c631d653bf4ca55a106683eb72a001a174e4f0dac90b40d91c9cf178022ee6bc7105b3cfe18187e2d0d9141cf0340f1745d32c4317e278638c6bc698863ac8780e2e9fbad21e27a616a88fc18be1b224fd765402b35ab91210efaf1b70541ba6a60a9e2d930dac14c5b640af46f86d8e5a36488748c6e0d51b6677b8618d2ce2ac050d3d9cc10071dd70c113f0a8f02a2e5c38581d1d609a08966a925608bde31a0107cb210b0c5ddaf81d167df10799a9c1b08063d0311f7ef18712d6fd7c0840c5a160dd1379c1d0a38ed43c310a73d3d30c469cf7b8638edcdb9214e5baf18e2b4e535a010dc3b3170b545439cb67b6888d35edf18e2b4f74d439cb6f16d20f27f199802fe18a2a9af28fd7289fce85d186220d0bc17a8e33b3390b02703097b3744c24a6d0331f9d8404cfe3634033e01c5e4d29581d35e1be2b4835b439c76706388d35e940d84be6f435c7e4907554cbebe327096bf2de22c975503ddfcbd815c2f1bb2b8b85343b4ca1aedc563dcd2a181303e3250a52a06aea56988b2ad370c7171d51950e318496660ac7d6588635c960d91d2f4cd1051aa4e4d2ed739463d31c4316ac4f572c2691b45436cb18ede63e4f1fa2205d49dbc770cd15e3e0e0c513fb225a0b5be978e81db1c6d43ecf2726888c29e7401f51ed5c4400f3437b0cc503444416dee008dc65f0f0cb1c56a0ca86ff86a1888c94d43ecf2a30c5257b01c1a9846fe6d11993c7c3544b9bcdf008afc4f1f86d86278028c38c663c1105b64bf8628b97b659002fd780f18738c936f8106bda7862897932f0353d17b432ddacb8721f2e358bb6801a079698883de370c9163e99e81867c66888326234324fd7e03284877f70dac5da40696f6ee0cc4c24f03e3e4a5818162c910797a4de9e7b190fe3635b0aaf060a0273c3730472e19e2b4f77fc788d3562f0db4fdb221d2d1bc0514829b178638edd5bb8115b41b0303d6aa214e7bfe778c386dff6f9738edb376a9300e4af705a4e3a262600a583470f99f06ba824b43a463d033908e6b43a4e3d6e9207c0e068688857d81a276fdd8c064a46988d35e560c71da8b5b03d1b268e0b47d439cb6fa6c20046b178dd7cbaf06baa43b03a7bd3430e63f37c46953c2671ec6e31869cd10c7480b863846656c8863dc9e1822e99509a0ae207d3570da4343ecf21a3076e4cfd60616762f0145fee99981c8df32b0ca726460eab532101c1786c8d3a73ea0a9c6d3998109cddf1671d0e7bf2d98ae1c035acba9ed1bb8ebd532c42ecb0c70df303390b0b921f2f4696d609dff0670675134c4316e6b8618c0ffe8b49a1524bf06e2faa7217619578031a77db93744fde829d715f99bd706725de998305d393b317083fb4da0b85e32b032f1608874dc340045edfb0f03f7929a863846af6b88cb4f87062a6e746b6307e9db92210e3ae81a58a9691be2a0773f06c6741f069ad8c81059382183ca6532e8e5ce1019745b16e8e20a06baa47d43a4e37c60605dfbca40dff064606c393744bb7da58ee5519b35b6738126341d0363dc0343a4a37766a06bbc3210b6ee0c849cb62186d63caa31fe1b5a2bc7aae447e3cb10e9e85f18e82c4e0cf495bf066eeadc1a221d49cb10f991cc0d918ea46f88a87d2df0e07b6e88833e9c1b38e89d210e7a716f888356540c0ad20faf863868e3cd1007bd2c1938e883215a765d755de3f5fab9218ed17c30c4311a05431ca34a3c2d3714e853c36e8b42515ba4e598797ec4d54ef240bf6b6285c291a11c859d1922a07c9f1ba2d22def0d2cff2440a2871756061e4b3a3210d7bb8022ffe38581877d5a06ee12f70c51c7b20590d247fd8e0c74055503c7681a18d42c0d2c3328619a4854eb86d8e27969889afcf300649c36f931c42e135ddc505dd2be814595cc4050ba04465a422a1bd8e20ad0ace0b96660a14a6751df502f19221d4d1d43e3f5135ddc34424e2153e92bd0df750d9185cd1b0371fdc1c04889fae1f58f6a4340a04f5f0c7196dea1817b7c45033730af0cdc7d5b1858b6ed191806b60dd15e26d40f47fee443a04713ca066638a70686a35d03339c370331e8da10a7edeba08aeb8d8d40bde9ab81a9c6af8141efb581307e63e06aeb86386d435b286aa7cf06d6faba06c6301503538dbe8121fea581d366067a8f1743c4d34be28747d297778638e8ddc61007ad2e0d712d777dc330ce3231c459ee75f91a6bdf9c1818c31c1b18af5f1858b92a18a27e5cdd1ae22c35028ac378e9d6c002516aa08efd6dc15cecc8c0a34daa850d0e9a6e0c742725431ca3b167a06f5819a2cd355471d3d8a5507832c416e93bd0e42cb368c8537516c545c34067313430803f07bc62746c88aabd57041a7a627760e01645cf4023fc3230a43d34b09297018afcc9dac02e2b0323fa4f435487a72ed0e45a2ae78648c74f19d098bffe69a06f5819e22c9f3ac65013ab9981bb4d434314f6ef13a0c87ff16c6019eac51075eca50da82b78aa1be2e2d6caa02991ae722fd03a4cd4a0a943f0ddb9210e3ae1a08e9693c410b5f0fb6f8ba8859f15a002ccca86a874c9be809073716d60a67505548996c981406bf49f069eeee819e218f72f06d6607d508dd81e0c712db7d43107a5fb9a814897180817370656153686b8fc2b5d9c6250f9c5c042d5c01007ad4c0d71d066c9100db93833c459d286814ca68ee51186d0d735c4596ece0c7196eb4b43e447b569606c796ee0aec6c6100595fe008a63c9bd214e5b4b0dcc2c1a86386d7360888b6b560c934847df104396e25c508908d350d25345cb2303d1726d886b299d19e2a005e2988263a1f828a870bb7617d8f2318e42df53cf105b4cbb866862f3be81dba403a0a16597be81875b7a06028a76493592ee1b788477cfc052c5c6100de8f10850e89bf40c2ceb9f1922a56f3f06d661168628ecf925a0f5f59f922176792b18e28e55d633c4319e7e0cf4955f806fb5fe1a58219919a28e3dbf1b98475581911e476e198874d78638c6545938261d635d8bee790e9f80a9b6d80ff05dc0496a882d4a97069ae98380f1d8a40138e2560ccc4dcb023ddb5330c469dfb91687e03413d02a37234001b67620d040b16e2016560d8c507e0d712d3fb486724d8b4c37028d939f0ddcf77832f08cd185212ebfa4a42b5ade1e198896b786d8e5e6d4408edd190828654324fd9ec2fe9b781f1ba8858981d9fcccc058aa69e075066ab2435fe3d51067b93d3690d24703e3c217034149a0b0754303caa31491ae616018583330f750b5cc941fc48ff2b0c27dc2681e653fd2fc5d057427f1e3d0c0232345402b028bc44060bb3030ea3b0714e9960f06d60cfeb6e0a1d69581b77dae00c5c2e90da038b62c1b58b97a3430a63b333079d76935bd9f0c0ccca25b066e4f3e1aa2aebf6d0ccc4d47805604922b038bc34b431ce34b3936221d5f0303d3b7a9218ef1fb6ce0e6f4b5211ad0cb2930d6312a060657878648fae3da10c7183e1ba2d24d4ac0842d1ef70d51d79fbf0decd204a644cb51db10bb1c6b17bd24704395da46e56862df86a8ebe303a04c3a3e1e0c51f9bf740c0d47cb770246c1e7f74095d39e760cbc97543244a54bfb0666af7b86b8b8790ad438e86668e035a43d43e4fa15f54391ae50fc03e247c740db7f37c4c55d53933d0c4cd78638c6c39b8149e21f101dea06467d7fc720a0d0801cd8ca3f067aa0998163d40c0ce12e0431842b144f0cbc527509783afb6c205a2606c67477069eb6fd15c4410b45da5c1e1c7984f7cbc0907625606cd9d4b564ba965760483aa611932b1e062eea40935858fd323084bb364474f86d1a18c25d1876cdb490750d849c2320d398ae6f6085f5c4c0db933d0367b934100b6f812107ddcb0c0c47eb06de6e79361061c6066eb6b50d512df786c048af421e19e2a07b8f060e3a3110b6fe8e11f9f1b230b052330014fadef60d2ceb3f19885237c044a72d1b88b863435ccb8a746cc79f112d1f0d0c145b800679dd534354ba3119940fd0629765c11095ee5707ad69907700d435473e31308621a579bb658bba8185aa1b0373b19521a68085ae21d2b1a19ee60db91a5bbc1a18f63c1b08285503f3392a5dde4cb9ab313030f3fc03dadcdc403335d04ceb1f809a693931c42e75e57ac62ea97619b24545573bd2164b435c6d910a539e54b83312795af538e8b36488b6ffdd033c9f3b073486793d0518c314b23fe02668cfc07cee1250db5f570c54dc0743ec321f006ac8d9938191d2818163940c718cbd11a011caf4dac013bbc70692fe07bca57760e0aec6ccc0d8e10a50bb4dbb066a72cb10c7f8d6c5a9ddbe4e0d4cf0be0d71963d6d31e5a0a34303cf05770c718cc7e8b3ab1e7f4cca40992d2a578668514fef86d86544d23d20395919080637408d63d0c4aa9e698d6f813ac1e0776a60765214d07966f780fadbc20940d7587cb80334b3482f0c849c2b4334e4c2a981e98aae96ceb3904d0dac273f1a184be9b46aa64d253dd3314a0646e309a0769b2c04b4dbeaa7212eae796ee0630d918535bffdb45700349118f701759ebfa921ead8de1850034a4f0cb1c5d7a9213a8bd205a0f6325c1862979faa819b6d9f061e04ed006e0d6d032d6a63887eeefdc7c092c91e30a106ed4d00b586e6be210eda8e865cf372c743ddc053154f86a8419fdaa5ac6597b581aef101a890d2e9ca1009eb75042c5564246cdbfae3185706660577408d848daf0dd464a554cf7e35bc0523faf13d50e76aa9da35b7b9b35381be32a284256aa687400318ed09ca54edbe213abe4c094ba39e160a6740535b28c73c3e7d03684085ac22a0aed7046a2ff554a0637c01238d935f0d747ccf066e0a532dcbd30acf39760db1c52ca0aed97c213b03fc88d500c86884afd7c090db4fc51f4394fee6c11067595c1ab84bdc30c4595e4f0035b14adf40133b35708c0c18ab659f196297af3fe0ad81a2815b9c0343d4f5b90e3ad1aac2c410079df500b5b9e737819ee727e9dba5dd682f5f066e60be1ae2b48f2bc00f3f3d1ba2265f3f0215b6a8bf0998464ed7809b5807a801c73301ade16d68e06a5f0cbb840d1614a53aadc1a26298069405facac8a361185b9480842dc63d038f569f036e739706d6a4a97479138bb728b23b039da772ccbdd80d90698baa21bac62c35d02a752d99dacb37a056992e04ea1a6f010f47af0d348f170399fc6ee0f5632a5d79a2c9fbbd405d63cfc0f38531694ebcb6f57c09684ef876686062f56888f0f97a0c68a0f87865e03de00b035f5eb837446bf83c34f068f50fa07161b360a0d31a1b48fa9181459515a036d74c0ddc59ed18a2791c0d00bac642f1da40b8681ab8fc5743b4a8f7918199567405c9f63e4fb4ca39a0aeb1341450b5e764a19b69e9dc10297d1b0bd865ba0f686d6bb8046a746b9bb1214e3b3a30448579f914e869fd2f43168d9092fb6bb73520115405a4a3f260600e343230fcea020db5ec13038b2abab8544f882883dc909b02b55b2a9dda6d31bd014654fefb6f60acd67062e0b50aaa76de5ea8411fc054107d43522955a2a0bea2a01a5ef99ed780a6668d6780e6734f03c06dae63e086dd0d30d283182706d6d75f0c4487a18106f4688840bfb802c69ca57261e0182303edb660889abc9802eae7defe202add4cbb4c75d0a981267663a0792c0ddc6cdb18a2289fe70686b45171f3faa3a7180b0692be36308d3c35c4590e2f0c3c58ff6ce0de3ce9f012f4f3dac0acf1db102d6af20bd4a8fca363a0ce59a6730343496fa1863c36708c7b20a1477ef912b0c5903ab62d8838e89181b3780bb5b953039fa4fa3570da1f032b02ca8f54af85f70d7171bd4ba0c9c7d5b25b205343a6f2e75d239f2e69036aa6b53d604ccb2ef4007ab1c250853d5543e65a2ae50a813e7ae45483cde2fb2130d23acc8981e9fd25a0d6b0b80626b497fd8521b658bd19a26a17ce0d918ed7170315f70b50f3584c0c54dc3b438c3eb34f4334e48f7d0373f5c8d35475bd907d1918e4b50dac39ce80327d65e7ccc0a0f7d6c023de6f866895af4f061e181a19e22c1997ef29e0fbaf81b727cf0d718ce114d014f0f140a071720f50b7f6a0a4eb764b46616fc73901478638ede2c6c0eb1d43400d689a1968400990028fda25d50b0fba160de1864560a23eaa61a0a06ac094115b15a8542abcc44ad956aa7438aba8da4d47feaf3ea08afb3b07547197cf86d8e27b6488ce62f364e0c1d8bf5d1849170cdc163c06a65aa67c3530171b18a235fc2e0c71711bce92574b569c3f0c4c348b069ad8a78197f1af0d91d2c2952152fa3504ca3ac6858162f836708c2f03cf6baf0c84e0bf5d581fbb04aaea2c7e0c5161a64aba2656cfbada1a8f8c1496803a8be1c410c778d7b5d419b1156640426b588f0c51b5b38e8156790234384b766ca021d70d71da858ac1bdc7ccc08704f70c3cb34985717b79bd13708c590dd04700476b40dfeb1bad0c512d6f6e8111539e79b4b9cc1389f905a0d6d03e02dc1a4a061e6d7a3144d27f878082f4b4666025efd9c0074138862beee60f628bfdb9818afb6d88a4ef7d008ac9df4303bbf40dd1800ef6810a4dacdc30304e9e1ba2b0974f4055c3af8d8178fa00d448d8feab8165863d4314c3fd8180922b2c00ad5a4f96024d134a065e0efc32f0519101a0303ebc34444a871786a8b80ff70666383a8b2aee686320a56b20e518ef778638c67322e018931f03370e55d84d0dbf068638c6dbad80631ccf0d8cb632406f1c3e2bd7337dd5eb0da0791486aa1f13d61d1a5487bcf7e0b60f07add4d47b44d90efd99d18f5b40b7af977706de79af0113bd6f3a37d0c40e0d348f3760ca597e5e0db1cbe1c0c04767fe7689d3cee3e2866e51f76b40613c9b19a27e2cc640855d3a5d03eb744540957ffd6ce0a3440503bd4706d4d8e2e7dd4085d918a2b0f775d07a89e5b01b43d48f0259b89d9ec51677061e6e490155bae135d0d4a0e6d4c08de58a218eb11c09f4f80b05b50d07119333031f681b1b22e40cb5c58401c90509abe851f3ebb2403775ea4045c39e04a8b272f51d716ce420fdd90554a53aa786d865d80234dc180d0c918ee39e218e71fcb705d5323268e42a755a05ca1a6e64063e4df16a88cbef9c008ab81f4d03f5e309501ddb175061068b818128f52ba05cca2950d74277622026bf18a2f40f5a8638e8f00ad0a07754337077e5d34090ee08484761056864505e18e22ceb77010381c206d037430bbf0696a1aa0606246780aaf6746a88637c0e0524ece9c5c092c91fb03ca85df4f4f1746288d33e3e1ae25a56aa1f1a7ffc28c7f4f1bdf1dcc08d65e5875ed81ecd0d3c75f300e8fdec59f45163cf4d8ffa802affb14035f9226ad0d8cb1d27b7802aeef215502dec26405513de85815755be0175f30f25038b7f3a8baad44b034838cb77d3c0ea68dd1045b9ff6820d73f05aa633f40430fea6486a874374301bb4cbd8b56267496544b48430323e91b03672918e22ce70d43a474d83730057c13104f5f9b8628ca93b58127fef70d3c07ab8b53d47ea91b221da38a214ebb51d9aaf20fef007dc3ec6568e0e254b69932e8c040b56c01fa64d9f8db40805d1ab81330327023f50b50f3287c1a58e95d1a681e3340efac8e740cbd80fafc62608d8d92ab94d425918e4a994559e673e34a93b37cc42e132f97ceabc0586deedc10bb9cdc01ee3dce0db1c5799c76fb222ccf7d360c71b527f78638c6fdcac0ac405b94f5a0ce17a0df1a98560db1c57bdd1081edec17d00ac9c31350e32c77670686f88f86a8dab31301a5bf7a07d4e18cea06de5ef830b0d4a9a46b99b2dd01140c16234314e5d3d410e958eba0ba7930f93444c2964a7a83831e1c18187e350c0c9d0a40ca2ea3c44030b835d0adcd0ddcced741d5038d5203f77054946a9585aa81098d2e5fdf949d8c81a1baa45781c2c5b38105c48d812e9a7a5af6f7a57e0d3c91f966a02b5075d09be48f5f063e37a6a4ab553eed016a84df1194a66e40dd3aa0f672167de5f6f541a609df86a8c96725439ce5ac0aa8aedfd40d51938fbb40955d06992192fea6d3eaaed7eac3c0b3c58706d650b48bc6529d63039dd60c503fb7f76ee0d1fb04d01a4a61cfc0935d8f06c6fc4f06d6833a02cae5e5c710a77d9e02ead6b2ae81d3ee1b88fc2303dd5a62a0136f09541d0e0d5194e322e0cadf34d0696506faca7bc03dd0c410e998140d3cd9a53cd50dbb9702a00fc33fff41ecf2a9d3aabd706b605ad6f7933f8a06e2986aa1be61b6a11656f48ed5d96efe5229fdd5e44a80c3784c342b25d7e4cb5743d4d3db3b4015f7b46288d3c62afe76d2a4837e009a89cf4e055a2129025aeef83a11d0f6dfaa80ead8e242a0b26d19221d877d4035e8f1c9c0b27ecd1025f7f4086878fe323130fe1819a8fc5303a3be67404396f834c50ef8b849c3c08de5ba80fc78fc3070f3b169e019349d566f0b0ecb06ee242a3f1460dfb4857e27e051c75095faea1ae8a26f0dfc50cfda405052c929c01e2f007f32f5c1c0d76fffb660c6373190eb5c7e3eab8e94d60e8184d59eeeae8faa943d473e89b3945d714f6b86d8e5f20550c59d5600d5d3f3a281cf49bd1858a73b00f4ede3f3a181aff16586d8e585947a41a4dc0414604f6e00f5fbab174314e57b62e07724947445cbf593217679fbdb8208330654b51f5f0c04d803431c235e73dd41348f8fd410076db70dbcaa321368f5bc00285a0e1f0c71d042db10077daf1ae2a04f1381864e3303f781be0055fefd918125f93781a6094b03a3f14740c38dbd6f03cfc13e1b18e528c7f4f5cab7d4c09d914f035de329a08f9af55550fa20d97064e06d3040ab4ec5176a50455f6e79fa35b0dc7169e065852e5061fdf42b9ac7f605107ee7ec3dc0c3f3f3828184ed030ae38f2786c8a06ecdc0070eca8046c19f4503a3cf33409fc8b85f1ae2e2ce9b063ebd583444619fa706e6955d402f8ebf8c0db1c56bd51009db1f1a58c67e12501da602358fc91fc441f70b0646b0730105d5d369354e2eb40c3c33f16ce09ed6c0c0f8a304a8aec7e3b73b60fcf16ca0d21d19b8381f8340ff7d66e065fc0a40df3088376377c0833a6b0337973e0c3c183b3110615461c66afbc706da7ec510298dc71ab7a080f26ae08ed52f30d5e08afa51d11300d981805d3ea7067af53703e9a028b7e789267609e89b6e05aeb6a25bf1a34f03cf6b934115bdf49dd11a6aba75b4899456dd69751b8067059f0262d0ec0cd02dace12fa0af9cb54f004d34fb05405f90b97c36b0c23a3550933303378626802a7faf6c885d8e2f0cb428efa292fb30f0a6df23a0ca3f1e1ae2187ba981fb0d6301b5f0756ee0d72a46809ac73833444a070503f5e3d2c0bca12620e94f63439c767f696045a005f84798ea06e6402f028db68a0622cc87210afbbd09a83b795006e9dbc7f1d0d10e1827370c1182c73a867ff37164e05b6a113faa15fd14c7d99981e9fd81216af2dbd2407ba13a6cc75b017b404ddfa3a78ee543b828978f68d935af5c5d4475a8fd8db6f6000dae1e6a06d6d8fa807e706cf803f8e7c4ce0dfc1ecea98135fa1ea0b7f3bffe20dacbf119a0c1d55e136872b59f0503cf2a7400d5e4d958a05f01d0b5e801ff878a8131ccb781aee0c24057f0b74bd4b1bd06e0496202289e3e17055ad82d1b1808dc1898abaf0c3c34f009a816be5401bdf3fef86a60b4c5e5fb56dad1a981e7a4b5853ede395e19780fe704d0f794def60cf4a625801751068b6895b5aa3e6c348bd9ebf6dd047e14335a43dd9380fe1050a59b960ddcd2eb1a22a51f53404385872aa06fccdcd40c7c1df9d640777208a8c28cc7069eba9908a863077b802accb06a205a1605fac5cf14d03324e3912132e8f0dcc08fda35050a395780faec56db10bbfc3c0a541dde0dbc81f90668147ca9abd537dc9f9e0cdcf33c34f001f24f4344baf7a221f2e3ee0850b52c7f1bf871bd8581458489818f77de1b58a68c3a56774deedd1bf89d8037433d6a61c340c4dd18f84d8ca68147cec853dd581e2ca8637f95ffd7c0b7c2a9a78ab883c5d8c0d39443018fe0bd68177d35a1f000f08183e2f335a037965791d24437db8ac30da06faa9c3d009acebe3f020a7d6fcf06ee782780ead8b066885d2e5e0c7c92aa67882cecd581312deae1d1c0a4e8c9c0b0f8ccc05d2fefa25e6c66882c3cb906f47384b4cac43579980a742d0d03f7c5da06964c4e01d5d37e6ae07713aa063abeb2811b4351d88907bd77c7023db37969a0077a30f070febd819f7b490c3c807968e05d8dbf2de2f22f8a8006029fa981634c0dd48fbf2de82b755045fe672a9d2aff603131f0f3155d03377429ca8ade8d9cb40ddc2af9db8215b473405f6d7aa6e42afad2c0d3ab81d92bd5b2a22fb6bdad04ccb35f94305e412c9ec770b4e13b01cb26a006f45b30d0df6a178d617e8b86a8fc7b57807aa09e0eaa9714e3134c39683031ac0ba81feb47406d6e3634444a0f7e01b597d5b38063ec550d712db391815b8bc7067e17b004a8bd7c8f0d848b07034fa7af0c51a5f6df0c7c4355bb4cf5552f1d544decf6cac0b7a1ea8648fa2031f00317e4875bd451cfc0ef238f0cfc524dcdc042d5d21055eaee04d06b15df9980ab7d2f1978aaa261e0f9d3a68195de9981cf26de017afdf8a502a83b79da37f01ae31340ef315850d8157d13723a3270df54c7a8d3bf8c740c7d77e3f51ed0b7c346af063eb37124e021ac21ada1a237855f5e0d3c2ca883eaddfbd107a0370e3fa33aa41ef5c5ab5d95ed23effc326d19d072fadda981a1e48540cb833a8616cb378f807f59f2cac02e898119f0bb81db82254095fff4dec07da011a0aa3d9e0af4a4dba7214abfcb41b7377ee2a0770252fad934c469afab8648d8556a600c7309e8c5bedbbe21ead85dc7c02f2b5c19989bbe1b78c84667d1ab7f8386818f120d0ddcc2ba3630916819b897d431f0e1bc8a8171323956d1a7b1961303bfe9f768e006c48d81db605706eed02c04d4c2d323405f163c3937c4e58f53031ddfaf40c3c037407dd45490f082d088eae02636ec19f87607ada1a2cfd2bc2a4f53da5c81d6903731ee6747706c7abab27f2f881c1bc42b4495a6bb938b2930627672f56c601da6282093db07807f89f5c110177735324431f412406f1d5d14047a83fbdbc017ca2600ef1415bb0f86a80e83a640bf6e7b6ba079648648d8f189813b010b03df521b19b87118b9de74abbc9f0b38cb77c1c0f4ad6260c1fd0e50ef51d02e1a7ef51b8638c6e5c4c0f8e3cdc07b5a998135c7634324bd4be957f4b197bd57817e32f7c2106739ec1af866e88b813990b65023ec1c1ae8092706ee13ee1b782e984a57d1d3a5c7c70606ce2543ecf2a383d6d9a2f26488faf1fd28a0217f53713d6d1a51b5ff9a980eaa8fbc8d94c9fad0d37461e067aa75507dc26dac92d3a7a00a2a7d7df969a4c2d627dc9eb48bde19c9d8a5aaf1fa4744a9cc2bced312a08f55fea480bec2fbd304f419a78731a0a5ce8709a071e15e454031f4750cf562ef5303bfa4f804b889150c54fea18135b6c8b1cc0de8e65ea0767b678883dede18e2a0073f06de91e81a98efcf0c71b51719a08eeff7c340946a1a78cae4d9c0b3e75f0656e0056a40b3d4c0b3e74503ddeba1817b054b033ff8313044e95f92eb157d1372f564607cfa6ee06505eda2f7e6377fc00ac99d215ae5d78b8127fe5f01755ac71d03b3359d565f7c7c1c1b784feb51c083f54f2da0a1aef1174835afbc37f015aba181833604749edf027d2ceaab69e065c9a1818f101b48d850a066faa40aa34f643ca96cdd4c75160d58879981d7f563ec90554b55eecf9d01e54a5ced77f4d943b7ec420a68a566af0ee81e5fb70aa88b3e6808a841b7d7801af2ef8381dff5d259f485d4f958a0476727807f822b5ad4d04b15ddb2409f4cad1a0806750313aba521aae5354977c777f568207e240686b453a0c22e3f7fc02e130359f862e0f5d2134314e5610fd0c42ade80d80281fea80ba801bd360ccda8c93a8b7e12e43535f0c2d4a1800af3b167603cf601a8457d6482a85283c527a0e7a546234334e48f8a81d33e197870e91b4839c6d3b3816964dfc0e46c08e8d73b1e755af573594b10a3cfc14249573f17eface6a0efc334fa06de8b568ee90318e31f60aa577722280dabd50af7e7a26a8f3c273cbb07349f7bff36c4696fca8056260a91d2916bf2c5c8404dfe03767906f4baedc550c02ead962112f6303530305a0bb8da8b09a0aaddde0314e8cf6e0c8cc7de0c51fae31740b7af59521b5512d5d32f400f71562a02e60db343034be13320d53302770662726288fcf8d269530abbdb05f454c5b069e04bbe7b061ef47b30701fa86ee096efbb80b3bc6b17ad2a1494523d9f9cb501d5c2c22da04a37d241f5d662bcb09d833ee7f0183936f6e2df4f03d0d76f7b024d57aec702aac3699c76ec4a775d33b0aac0593c64b9181b185d4c015598ab27436c713b3070ff253310c73e0c51613a4780ead8e61ca893a7271740a2e71ceb0622cc126868196a0ea806bd4c0d51b68b02a080b2d4d5aae43eaa0262724626abbf2dc6abf639387e6c007dbee02d9ac7dfc3e897514f27ee3dbe4686c88fcf8e212ebfbd0fa8b3f87e31f049cc7b036f81770524ece80cd042f7f2dac0bdb50c5077f23d31f0835229a06fec7e3e09d4592c007d2cfbfb18d042f7f111a027543fda06d6fac6808ae15d973fe26a571303b79f9430ad9ecf7496318b7fdfcfc094c70ae25df3caa45aaaf0ac0229add62bfce443e4e9dfcf01cdcb80bf30f40428ae77a3014d1dc6af8680aaf6f2dd10797af40528d7bfda02faec5e0950ae676f80e2e9ac2350f85c01aafc5f1301d561aa7434a9c9af6b03c3f32320e39da25111506be857013de778553444e9afc702aee5f00ce04b36c59f918177241203b7497767a9963cf37cb902f4edd2f73ec0c7a206f195c41c34493c043c0c7c7d0734b13abd0134da3aaf012a97931f0323a52740df932e9f0a34dad22efacafbd109e0f9be7669eac74b7a0272fdf41ac8b440a463647a75f8c8105b9c1e03433dcfdf35f0cde10ea04c2ee8f2e9810af1c5a57c4a9054a996510c65df8f9add025516cbe715405f797f2c03eaa3fa6360aac5f22b011d4eaf6d88cb3ffa0ed0f874b05803cab1f58580b67f3200320aeabc6488cb6fbd19a2e4565360487ebc2f8111f163ff0350c55d5d1a22a587a7c0a4c293903f0043c962bc05be03568baf0c54a949409eefec5203ca0ab05da05ae1eefdd0407eec626175fb20281f022b01fa7ee1eb15a00fa3bd9f037add762f2eaee21b323f7d0119b4fc0034e6efbc01a9467d1b403f3ed0bd05f460cae1978137c93f0d04c7a5218e715030f01af48180827a110c2997fd774031e8e8071893f4bd270165bb9e18b86ffa0ce843e81fa463db62e26acf801a45f97e04e453ef68d9bbc056adba5ce27b9fd5ede38404b66b404fbaad9b06dadc95811750fb80be60b74c0dcc3cef0d7c052f9a58d5ab4eef9f80ee481caf0085bea30b40bf0a79a85df44b689d17408b2aed4740cdf42033449b6b691795fed1dac043033a8b3a9cf5c01065db7a07d4e12c7a02b54a5dcb98d3febe0a38e8e2dc40957a06f485c3f88e51b55ae5eddac1e214a8d1e67e77e3c2eadfc7905729a0b25d6b0b15e5c7a58162e8012acaaf92810a5301d44ca78701153dc27bf86a88c23efc30c4c51d2d004ddedb4f807e9ea0f56a885d0ee706ee14ad014dac3aef86c88fd6b381c1d5978046387f3430f37c01dcf6678638c6c99e211276303244c23a3a8b3abec399816f531e0b68a6074340639883892176996b1775056de5a9aa54ebd31015b72d98728cced2c0e373fb061e8e5b18782573256038da89785af31a7dbf06e86d8ef82c6f0ef40dc5838d81178432a05ea53ba1d255532a7fd2317050aa83e3587c84b85a7777129f3badd6ffa2d435a09abca91b7874f601504dfebc31f03b783a8b5e416c45c2ea1ea0b55243e4d8c702d052d6d11c505d6f3d028a52ad2703ade1d9401d2b1a28b97740757dbf6988631cad0c91ebc76bc015770c0cd9e2f01b502d6c7d18f82cefc64084b91010a50ea6c058677934b06cfb62e086ae4eabd0d7ed017a34f2e0c910e9387836c4318e5a020df10f00d5f5b3be815d28caaa1e06fb9e0aa8744787801ef57ae2a0dbe144549889819b07e7003179b03801920a23c76320659cfc195d63e2b7f45e2e0155dcf868f70ea896027d3aeded1cd037773a91418957d0a69cc541ba3531c407c98a19a0f95c6b6aa07bfd30705f3d0554713b3303b1f01550906e4f0ddc5df9317013e34d404cde6f001ea07d1be2b4c71b03916e6e88749cfc020ac1ed774075fde4c010bb1cfd1a7867e40fa8417b80aaf6e1da400d3a307077f650405d6f7d01aaeb476d034dfdd710f5f44067d13add690fd0cdfaf69781f6f26de0182a28cd0ad6978688daade82c1207fa9313817ec1706e8872396c016a2f074b03cf5b36013d65f2f16ba09f3b1344df501c54013d063c3f051a6c7145fdc85b148d700464cc5f862b605aa501456b68b8b358350c4c571e00f50daf9780ba829f1849372a7a55b6fd0a6861b7fd06a8161e2e0ce4e93ea0107cd236c416a7a7800602a75d0385fd6da09eee19e8b3755ac5e4939681b1c3cc40857935c4310e7f0c5194dd3ea08adb591998d0cc0c54870f03b5f04b407558faa054ed8f8d21aa6547e950d53e393490d23d439ca5a584a9ae2f4e0d71d059dbc0b544136bb8f2b7fe805f103a36702d0b817a200eead670726a6097b9805d26af0646175c7edebfc416a52f03977f0668c9f553a74dd8a2451dabea19c50fd251abb0a8129f29ae36eafa7ed026c674a97ba0f72ee0d67061e006f71da01ee8832d2afa58c35e59c0a24a7b026845f1f00dd0e0fb70698872393d01b428db3d0754b54fcf0cb1cbd9df167c5246c71893c967034035f9a463a0357c1a7824b12fd06c7e1f50089e3f09a8c98b3fe0536131354ff31a44439e1b68fbe7061af22f502616b6fe8017fb5606e6736301b1f094abadeaf9c23699fc1793d706966d5f0d7cc84707ad72d00115260fd20cadb9da7c9cc3dc94b2dd469008d2874093b154fca241351f06b092d78ab334bd0030db0734ba687d030a7dadb9806b39eb01aa1f871b0365fb06a8b08f751695ed77db10997cf76988847507804affbc6ce03ee18b800c3a8ccb6fba374d7a0606df3f80a2437b61e0a3665d4045d9d913b04ba76d600de518a86a79b009d4b8b8f9a1811b547d201fe546c747b96c070b718c23a049273ebe00a65516ed4f0c51a596d1df660e17b34b03cb50718caca22f62ac13406ff8b767800afbedd5c023bc77808ab2770378061c4d3d73183f3a126889606260687d00b8cdad0d3c3d780c54d8e273cf10f5635001eaecb2d159f4be69fb0768e8c6d0dcc067bea2bd64b51a4decb30f24d5b8b8ef98bd6ebf6ecacbb4378032f9e443a0a78fe3a0dba75dd8e5d6c0dbb5da424fee7c74047a37e105f0342101741fe8e01dd060a2a7b368a8d0bb06d4ab1f1f186297e318c30cdd80ce2e002d449cd605dae2d210e5727804e816e7eb424060ab90415ecc585e013516446653a0c1cac4eb0a48ab343132c8916ea97434b5fed106320efac516b5bcc5c459a2e4b61fdee4ce59b4a8bceaeb57980780dacbfb99211a61f702d098eefd4ba0c83f07540ca7da450da813c17194e73a4fb83f1bb8c5d931b0e07e0528d7bf5f0d7c1bfbd91025b7e45ab6dd56246c0c0ca9ebf505306612f0fd64883a368f7a3af608e52bead8d8f9f17d0728a0bc0c003d83d6fd05f4cec8e118f0ddfb574031a81b25377640b92f02badab70f4031b9de161060e74740022c2f8011f1f427aaf6b8a65e7d13b3a4bc98e83cbfee0c2c11f400d58fef5b40af0ebf3f036a95ef4fc08478da3f01a6d4e40f76d9deb1dcc16d66e093876ba0aaf67200e816c5e73ed0d0b5f481945d1e3b804aff350a6aea6b99b700fd56c94d94dcd42b352b76d92eefeca0f40d8c39e8c10a9868a9b32320d7571194a6b552955f424b8132b570becbd35a69fb3bc491417d4075ecf51cd0eb728f77803e4a349b046c2b4494feaeb0b73fc6a85b9c7780bebbf12c50c5fdbc0628db42f117d0ac71f618a018542ca54046fff2ba04864c13a69c250f4adc19d98d3ff281833e81f07d03e8e26617803e70f0d103f4f982e707401fbf79ba06f46a792c986d5f9ba7c2ccdb4095087359041ab4a8782471077cbde15140e93fec014dad27732ddb5a165d741d98921f9d968072798cc2aed44635dadcae57af551da43fa2b0ab15bd8cbfaa03758a729918b8d3fc0ca8cd7dfe04b8897db5000d04ee2f055c5cac39e690f2f8ed2150d30dddd60150ad46067d5f00d31a63fe28ca5a5e72c48f3303d1b20fe889888f19a05fb8dc8f0a53dbdeb588e8d036103edf80ba4639020d7b2a55405de3fb22408db0f8be9bced6ea158d729ecb807e33f6e630c053e2ca2740175d6c3e031929edd781b1c2564b407b39af000a17a797c094b374af059ce5ec2a206fec8c61da0295cb9e81a63e35501d224f93b27ea36c360870957aed03fe86c825a0fce8640155fd96cdfaca40cb7e0734ecf9fc05866a40fbc084f0d9de005392fe1955aa51d14f6e7f5d034da5b46760707503e826d7f32da0dff33c1f0754f504c0e71b9091f4f93330a4f27fbe022372fd63058cc9d313d2b1edd8223ffa029ac7bc1390b77e9e2e3d031a352667bf405a639413812df56df48f8830a95bd4e71590ea37db4e01fd7cf8cb39a01f71fb8eab4d9d8e721148345064977a52e35b6a918ea697a1ae7b40938abb3c0746e4c7e60d50d5fe5d01aada9785801a77f08a4f57c0b816b08ac096b727c5f57b60a2df188a069455f5d244a727a06cd775408f8b1d3f034afa490950b5ac4460cbb6613a4a2e2a5d56cfea944ba4349f8c686deb23c0cb1d9d2150a7161e8e0c71dacb0b8015e7e2770b183103fe7e07b4e2bc8e9033ccfb53de577f02aac4b14dd710bf3a5c3c04c635965d22b08d3cf5fabe06f4f6d36734c2d1f61ecd0eae2e01e5d8f52130a4e46ed7c04883ef4f60424abfde81a916dca3f4477903e1699728b9513d8fd35b182ca2184689c2f87437a4ade5d194e9ca2c22dd787b4f33fadb6360a440ff62e0c9d0ae808455de012d33ac22e9db617164507500d4e8a29f23c28ceb25eae97b748d938a9e65398cfa31d9de3cdac1411bd04fa1c74f82d426b592fa8667a05ae537b9de8009bde97be4473e6cd61bbab580aa7ed0f22a2e6e3b94e4d72a3e810ab99e4e803115a611fded34bf1622ee2e5ad64b157d1de8e833c0afdd7cbc0263dacbb21650d36cad7a00e8fecbaa0f28c2dc6e800631687e0368b8717f0534098e85dd6a4fbd5cd16fc814ea01557db3fc730d3468403f170135bd42f475002414f6db49404ef1037df18b5bf5eda88f5f56380ef00a492c54ed20925ebb34f0a5c56e806a72317e6aa1beed4c79f133f2b49a5f2d3f67fa08e86a97b14b6dfb205f54ba1290e91b33510cdb2febf1026a1d48c8f5ca1ba0058078e7ac5edf4eaca36c9f8029d772f21cb01dd446b9bc000d52baac06e4630576892d12a7e3e32c20bf1a967f22e98daa86f8d36340dfc87c8f94363c153d4800f5511703a04e2cacd400256cd607c6ecf21535a8915708cec269f31ce105f6ddeca49ee603345ea53e0dd88e51769024c0309a7a219e2ead6f7b31de383c0fa825945cf90c18d778dcf40398d0abaf220b9b49a3ce3b01bb985ccf14720ad912a850fa971f802accfa1c18d5d8a5088cd59023c7b2bcecf87e5054fe61ded3711ff9129850712bcf065ad4aecfae8f9c41d751d8a33c1d743891f45192712d835dc757cfa32531e8e11d608e5c889fbdab8febc37a246c1d45394e4609e1223279e2d670f7016454cbf56e2050dfced519d345ab9ce625c76f2db68021575b6d03632eaeb7db229f89d4e91bdedf8126756c751e90d7647e847a0234eb91d2e35d034aca79fd609efd05a8b02b82692d92de6d06e401344efbf00bd408f4f1225b3e80192b18f402f246c6b27e1ca39af7a7d4b1fd80fca071b5576702eafa1dbbe4718af75f8e803a092b1f038d5ae4e97d01c82b5554fe2c20cf003e13b8ab0e492d4f070f72b5037496427c153087a4166dbf340234e8fdd8ada124792a14832ac08494eeaf03b6913db67812d0011f5e1b580f7a076ae458fd01a85394f1d980641bc7a841511d92ed5358d15e5e81bafa8631909263dfbb16953763cd80ef2f808c2d92d8a5910c89fcb328ecd4fdedcd0f50233fba71b5cdfcb4dc173b001a356e4fee7ac224cb5b0353c0cb80fcf2196ded0155aa434fd0608bef0f43a4b4a42d32068a716f2d8721d5a115a71d6ebbad1dfcde01aab85f9fc0905c6f1e02a39848141b6b413dde498c4f4224c33c57793c2a0a6a54d3f74fcf228346799f1cb5303edb9c078b841ea8b00bd2c9b8a69fbefaf8023262d06f29605b1f76d03907540bbb2b03993c0352aee5f81a182ae9c580a449d88ad74b93499e85b1cb7d0b18d2080782115b543bc0984c6e5c0153a61ab36862936d148aaa1d253775c2ee2e8029496fef7ab146c9857d740334a321177bbfc0885d6a23604a3a8ed965bb02b083ec21a091712d47bb114aa39c47297ef06315a070513cbc0154fa87bb6b696c031b6fa61c04788bda1898d6f8046424ac921737e16237546854f3ce20ea47e535601b63e218c7409d1c2b35802675ec38929eb70e862c9b41808ba1df0ac8739d30fe023468c84701c9b643890af31d90a7232a5d7d08a47416775f40932d4ab3803c9b79a07d571d1a8dba7a8fda24601bb7231ddf4093b0557a00f28e3efaa8386d9a5f0b4b26bf8026128771f9e9b6538acb3f03aaa4f4760cd4eb7c00230a2a6d94133e66ba6bfb8d3c156cb13707a634b1bdeb80bc77e0a9ac7d0167b9fe04ea754639674083a22c6b97519dfbeabbe6d1c8f20ac36a603320ef3eb9b17c0954b8b8b33550072ece80619d75edc8f52caf21513fea05a041b97c473a8609bd47f1e611c828864eec3272335d7e03d53aaf984d0c5183923720e5f2ab8740c616b7da6554e7f75e3f80498cb60af1dbd7394c197e9dc731c68982f4e997804ab712a4a4f4ba033429cada0930a418d26940de2e192a1480840c4a4a016929e1d719a2f42779c8e1a99b24c095bf7e098c09e367da62427e3cfc08a2ed178abb3eaa31cd2f8e5f6659012929fd7807861ca3143936cd2308af52ef0e9aa7b34abb3d48819482ba1901a33846a1d80cc8db031f7bd945dcb4ec90f3bb06d47b9c3504a4a35207b89662b91bb08d53b14ba4a3921f94afd07c010d12d63a045245ed293025b07deee60d69f5afd21d034d02eccd149824d15eeaab803c4c47d9d64e0db486355027e9b523206fa8113f76b99ecf9a325af6c70730a2b08f2e8129a7edf403f22e87ce6217b6f272546bd87f004664f2b20b8c49d8fa0b989263c7bba094e69532a254a1580234625bf580898e21987271c963c07675384a6e66e095ff04a82791b0fa08481808b4e3b4f9ec952960bb0ca404c7935a403269f07afa2b3025c05e9c046cbf7819a76d0035b6281f0179671065bb07a40903d6269045ab2c0ca7804e9b91d2263d72218bea90e699cc6d9f4940dee3f2e5b813202fdda80e674083ea70baeb0ad2663e5927042f0564d0ddbb812c7c05742df7d7c09494ae7633be34cba75e2c437d06e44d9d5f9a88969de54d3d925e1f032941a97c0b0c49fadd6e08970ef34900cf8dff00aac9d5c8e4615ed8849c1190501d9229a0cbafdf0179d2a2e4e6c090fea5dc03f2e017bb0c02b6f91e2517bb6c233f5f5c2a1b780e3662d028af96712d371b4059f8700aa424ec7e608884d5a7c088840de26ab7819e7baf3f804affee5ac0e577974042ae0ff60d918eab2fa0c12eb547a0195018be00438e71971a785443bb8cb8dafa041847d20bd921a00a53bf0ac8c32303b438e8b63be1c9ae42405e6158eabc06ea9cf67c1f509e1ede011915b711793ac92348e4696f37524af30e876e2d9edcc9a196f022fd2990502de3a3223928832a29a0665a8fb29de6dd059f5b6f01d506eb52bbaadd2ce5f13412d63f02ea54edd63da072399f00aa0eb52e30043e3f81892accbe817b383d60aaca7f6be087e09e02f2fe94f1fa42d0889456a740b91111b734072a0dc652bb10dc2c3bf41d3d0209c590bc029cb6103fb1d42ce767892cac1e1b220b6b9f80f2b4fe0354396d27929e4f4628cad65d40a23c3de804e4991c977fd10734373d790552527a9b0243e5d83d30a16a2727c09456f91d29adf85a9217a04c9ed67a025d0b49cf2b3f9df80da08bab67408d5c2f0bea0d3e2fbe0b8ecd6d37cf4f917e0053527a1b2557cdcb96b31c00151256df13a826ff02754abf7e0d244037ea474d9d56f176088c691ef71d0107bd6e1b9836c5e5d7f2d306dc6740adc17258e4c7760d9a57bb16806261ffc010d772fd258836574ca24ad57df947f702ce52ee0065723d79066a1ca3d234c42efbd180fe4617dd0c50bbed8d8106c570a62d52b6b8fe0032ba93e23ec00a6b21db8de9f2ee761c6729144780c61f490483c6f623aa712d87408d82fafa02f201475ccbd2c0a29ba0a98eef1cc81a3c25bf1b0834d33c26f31af44380fbdbab0530a2a08e1f0d745a87c084a45f9e025332f926225deae6317f03ea6c71bb34b04c99004983a5df1498a47cf97a17f99bcdbc21f324f523a0e0b89c1bf8ce555498a6abc3fd2140e9178a63a0ce16b56740cda32ed064a43c143478a02cda5c33d35936bba14233cbc32741a90e24348ff31720535ff90928280d46c0b4c18fdb9403b613a73846c7c0dae729d0d0d5f681a622ff892176a9160d91d2bd4303bd58a46398a4e4fafe26a0c194b8781f091be63946b4ac024a47a964e07dc207a09932073a07b20613ef0e3004e25383398c4869e9ddc04d9ddd78bdf937b8baba00a61a05472d1c6d87ce51b62d4019548aca3fdaf69691d2a81f7924a4aeaf225c8c3dbf3d8b4a3776c4fde919f850fec6c04ade15d02093931a90523f923340094b8e0cdc8a7f0586b4ec9b2703bd874eeb0c8a7219e7519957008a40fe17d7b21ba035278d1ad7d2ba012624fd3c7aa089236e770e68ec70dd05aaf4b7371d03abf87b063a9c1690a847ae000dc245ed051835f8767aa4749a68e8b4172537cd7bc208b005414ded650f50c8e9ef0309d561a02d144fef5640aa38b667e06ad706566a0e808c9496a3114eb7c3aba80ebbde232b7960d49f02658eb1fa06540cbf1ba04e06dd3f024d8e71df36f015cd1ea0c87fd700c634c2cdae6cb372a245b7fd3a30045ab7018d21bb9c35812967e9160c9185fd97000f362fce01cd5ef76e041ca3b7365072778086f8a70b01bb5cad0c3c55b104328e916d80211974d503265c4bfd0298d2150c234fcbdbf1561c740ed42897eeaebd64957c40c22fc2260179c9453a8e1f0055a9cb13a04931341640c616376b03ef686e80a1ae7669607cfa052816defe005305c771403e2f60cda00f9481ca0aa8502ddbbbe890553dda3a8dc2aea6daa57d0f5414c6cf80a646b0fbc09063b42e80514ab4dc0063b6386f1bf8ce6624ac9aa7945b36a74085987c16c5506b2883da7780c6c9179f01f9e09bd5d16f206397fea181b5f116a068d9a900e32631b90e4ca2b00bc3e7807ce6c0f2716288785a2d08521e1a680335aea5b71b4c64f53c4fa3bddc7c025572bd730fd4a9853fdf404a3fb7f91050d7970b406dff7a038c394b23caa59e677224bdf62a60b4d5190015a05d016acd7234d316504f196edc00f990358e11ad21f1b47a104d2cd92e88c51655a099d203cd808c92bbfc149063d7af803abefe1e3002ce7f8131c57071044c3946e332a0a9767b20a83020e98c802a5b54cf04b497eb1550e36af78e0cfcb8dea921964ce289aa1cc8a042b16d6041358ab2918c29cabb08c18d867ac283a8850d8f4f2f678648e9f90f3022934bec92972d7779da4025651cf40224ec521b08b8daf2c810bbdc452f960f8a695137918e74bb5217d5e1d8c052f81898502ebfe702ead8d5898175a92b60aaa28c769be6bd295f13ef0234b1e2550ba872da7e0750182f0f8024f2a3307c02527649ca40468edd46066d271254cb3ea0fee5f31b18695a3d33f069bd0f039df8113026e4f456001954281e00d388b8856234c2e676112932e815d0d5d6de80843c7d68034daee520b230cb9b18b7398e80b1c641d180b2ed12515c2d5b38932f8f812a15f7f01ea853b5b31f20a1e46aef4046c955330303b4880e430fbf3e17404adfd01b0143726cd001c8a0623f923ef468eb822df246485172d03ca571d0fb73c08df01e1837f9d4cf6efe926de70d7ca0fe1418d3e64ea680aaf6f20c98b2c5efad21b6b88a5a38ca6310370f96408dcb6f5d0a0828372ba0ceb57c7e012aecbb6f4001f64b90727195b521726c3f0a6aec1eb9750de85a2ede8029bbfc46e51fbbb3e8738cedaa52849c095053b43c03ea5cdcf501901250ae04cd94c177020c5561bac0982d6ea3f26f672791d2dbe89127eec4bf3680eac74d34c2499e749ea89a0255fa86874fa0468e5dff004afadd8b80cb1f788bb89642fc5c540e8906680780667ca537a01973b162356ae1643b648d661a839aa9c3e7e50a1893638388a7db990537c9db404df9d100528aa1b2018629f3ec5f60c4414b4b034f20fe016b9f1780d2511d1ae8f88e813c47223f12604a4a0b71b5d3618d2c3cd8e5d8b0a40580e26f051893f4cf59800757ed5b4031e8680ad488528715439cf67c035050c5872f40ddda606388fa717d0c8ce82ce2d3f1398c29a8da47403eb56286b3cbb161394f29f1231170b53d6da1f672d103122aeee52190b2c5a00d0ca9a7774b034bae4303cf90ac8151935be04fc04403810b4324bd4a3af25ac8ca04e9c86b6a9c656f170b87dbdf7aa2275c030dd2715407528aa1ff1890d75346b057801ae1d5dac087d1384b5e0c7c28ae0d34b8fc9b174314c36a06e8b4a5b28151f03ed0e4a057c7069e1f9b02cad3cbb921f2e3fe16504d2e8f035cfad53e5049797c6e0fa846032a141b403e0d88fcd80d9c87f96485b1c31ac8b390cfd224c0985878fe044cb9daee7780fab942b10a8c3430da07265487fb1230d5ece420603b6f8c3ab68b41c3edb23e6b4a7196ed8486fbea6f806af2aa0bd4085bf72740423a3a7706decfce0075c06b1d43616bb6019a348f9ba540177764889152610538c7767dc3309fbfa817fb0112cd2cde81065bdcce019de5a20d8c487aa90a8c29dbf875db1cd4c41ee2f2eb9906dfd51150a7f46f230bf39ace1687754049ef140334602d5e7d1bb82f760b3462aa513cd3162929bde62cf9b5302019007405c5db1930e2b4ad2b03cf39de089a0c25758c29508ee0986479548ed32e0c04a50e401d2b14b8dabc35f0dcc53e5067da94091272ac3a061a04a5ca1e900277110bf3de56d3d968d90de7e9411454c39d45ff15502dbc5818a80e4f8026ab250e9a8f6023d76f1f8121c1e0a80228045ff581b12add29e0294f1dd068eb225a434335a8506c1958427a06aa4d3af15f4075bd7c2950164e80a4c9ef46760c2c10fd000d76d9c431f2f11a5978177d769a476d3ae0c41015e66209682cd5ae01ea6f7fba80c6a79b4fa049dbfffe05b400b09e011a179638685ec7801540c42d762e809a062407806a50f91168029d2886a6e70d0747404a95daeb024d4aff6a0e684273f365880af33303861a386f8009c5305803532a4cbb6be0de5ab486a6fa97e2d1838063dc8f00cd1beeb585a2c3c3b1805d4a3f802ebff20b6454a9f235306452b489e890a555fa86d51dc048a9d88ff6924f0139cbfe2f9051d73fe7c084ea70fc0a4ca941a7ef06227f54fe2cef6f59887836700bab27200b6fde0dbc81f90d9435b1fa03865fe740454385b6815bf1fb80c6967797405db94e7e6c5795a2ddd6808606131303b76b0529292d5f1978ab35ae368f2fd4b1fe17a080d2895e7dd81c5294ad634061fc706ae0d6c003a091c13c0a6a98e76914e5f58981215cdbc074f61cd098ee6661600ea4835675da19a07a7ab73030f79803792f15f5740d34e94eca3740a61e888bdbcee7a301456bc82f9e0ad3ff0446ea1ba25c46798e5193e780067983270135f9204e3bcaca9c257ea52a872a25b77f616085e40148d8e5fadbc090a50434a885f76320a55c1e0e8121575bda00235a6527e2583e9bd7f43e52ba9d34338dfc1228ae9f00ea704e26069e715e0ba852fbd1ef8f1d716f0e800a75ec7229e06a0f4a00cbc7c59f0ea018747f0fa86c1f8e8011c7388a99561e2c28977674f379b5d598ee0618b1c5610dd02afef92b30213f0e1bc0b449fc88de63e2bade1903658dd8be010583e32a50557ecc014587db3d20214fefb48582e395b7a0031e44d89ae6436bd6c73e008d500613604c06f59f0126dec5aba830d3ed5dade8915b4095fcf8bd30f0ecd7d2c02b773503c1600fd088ed686288d35eea2c49935b7a6b6024d807c61cf47cd72a47a5edc32b91d27740d7725c37f041b25a405e0b230b8f2786b8969f334081be5506aaec723107ea6aa60580a85d6c5f03f9f822a008502d0b05a56342c9fd06e427a5f4fb1f01f9d88149f306c8a80e0fb3803ce9fc7ec31cd04cbcb7002a94cbde1950a5e22e4f01c5d3c3a6802dee4a8046d2bf3a464a80bdef014dca65f6066464d0deb9817b8dafc02863445f06c66a51c7c034a3f7d8758da34aca6cadd81a021a3b5c457e6c3f2aca73066ce1cb3f6a18f872ed0050d59ead018d825767065eea15d4095b9b6320618b7653c041ef4f810609fbbd3430a4d5169a8c5cff1a68845f06de9cd6d5aa17bb7903f23e39aeb626a016eeebb493264f306f80691465217ecb7754d92e55c531aa828c3b787b40b9c9d7c413a0d2e4a726771ddf68bb22c024f11da86a6dbc0ea8edf72686c88fdf5f80f95cf16b61e08ef7978096fd7b0da89e0e56066ae12dd0c878e5ee1548b5a872023455d7af0055dc9b5703af445481bc0b8e0c02f22c8c945efd0ad8a2c8e56f9788a24a45c2f27916c1b133019ac0e0035007fc1517b77d7992ef90fc0009e162f325a04a951e0d514f172d205526af0dcc811201a73db836f04c4d0d1892c99d4b20efe9224a29a579671019444ab74b8801bf4055b13032a89ef76291c97723a0415def451dab7bfe72f161e0ab5e534007fd5a02cae4fd3e506797836320a1cd1d570c512de73f4083a6fe3337448e95b44b83fa71d501341a3f1b1a78eda60834a963fdb5819f8b5a006aeab75f80c674976d431c74af6fe0a37757c084cabfb71b5b8eb637b8593d8fc2cec7165cdce577409ea73c22b102d47b0c5e01b5dbe3c4c0679bc7809ae9de1ad018e67b03688673f60534c9c2cb0e90718ce509a01592afb921f2e3ae6ce051af5341c614f009186bfc7120205a1ea6063e7ff20e4cd8e27a0650b58bad81819ff18ae691cfd59848f4a2116e1755186b970d3c89f00530c42f7eaf01d5b1deb3802d5a27404a61af4f812699bc5e18e26a4b4f063e6db30234ba58e91819f163736460a4d4324406ed5f1be25a368780ea69bb27203aac94f411075d0bc63acbb18161f1a78146a8b34c81fda8eb8d6199826aed568b4779d0e2f207d157a61e9e9f8d010d58cfdf01ad7edd698b86c2c509d0a41836df80863dfb7b066ed91c18a26aaf8f0165d07c03a86a2f8f0d3c62f566a07ff911500bef1e010df1efa6c094d3de451f95e67d545498bb8a81dfd5b815640c9ccb40de9423d7a3b0f346aaa81d57dbf4e5ff2c005ddcdec6c0db6073038f9b8e01c685c5c11250d89abd032aecbbe82b9b1aa1146f3f8032f991b0c576e01311378e916535ced29d006a40fd7743e4c7d50618aaa99f02236af26c0968eeb1e900caf583aa805de2e359f9cc5c03f8d5b18171e111a06bb93f032ac06109c8074f71712990f7c9510be3b4dbc51d0e7a0b280bf762683dccd45e4e0b404ac99d66c090467836051460bb9f028ae1771f186b0beda200db2a1ae80a56c044eb30e7022a5d2be2e9302f6c5615ce0dace33e1bb833c259b63728e32c33409380c33250555d6f0235f59527063e011907fd5b98399b004d607f1f5006cd16803a9c9fa5810c7a34f0fae0a9816f888c812957bb896b196def35477b7911b0c5c3dcc08d324ebbbdc71b95ee0fb8499e0ab8fcb34f03df2e251d792d24aef7811a7d65fbcac0e71c1a067e64b80e28a074a21846f95482f7b363d4377685e97f03ea6fbb2303f5239ac7d8577bb10f9481e511a0d9c9fa0ff804e41aa812a54e5201797afa6ae045d82e50e32c7bbb75a9d1c48f031d45d49eb85c0ece0cb1cb41d7c00f491e006afbfd9581e65100aae47ae70650ae1f698b3a55fb6266202855800607bd5c18f85ae3159002fb4afa70c80ba851c7a6db4720e2f27f0cbc8fdc127096bd3d40e572be32f0c4ff12a8522d97daa24adb9f0bb454b13a32f0b0e081802cdcb4015ded51d9c0a3b3d7400a1c3581d1308ed1dec5c27129af963ce2fd11905f1caf97ce001554f709a870b5973f061e365e01badacd5c4023bcd833f095229dd657db1170b5bd1703c39e8581b75af701cd81beb54542c9b5aa40835d1e1606966df70ddce2d469536a61a70134c9b187a58137862ac098831eef3ae07139efa2f97ad42330253f4e9a018e41676ce10c6a750d84e019a0b1f66a65e0a311bf028e71f1074c0296409d637ccf0dfc64cc50409b3b191918f51d0209d7d26e00caa0f6a56018a1ef380d1895098eeb5d9f3daee47b4406f5df02f2fca09b5f012afdfdb6811bfe1f401dd8ef010930fb04349d9d1b68843f1b03dfeb9b00f9002cae6560885d4ec740c616c74560a85d12c0d5212eae9a0f04e2e2ce015fed7a0da83bf96d1ba80e3d4314d46f0b50d23b4d036f714e0d911f2b9d25a5891d8d0c2cebff0137860e8126853dff0032eac746e91871dadf6873355fedfc2b60fb8c48b4db25a01a745c36b02ab9001a348fc1dc40517e0329c758cc0cd4a0b5814f951e1822a5836743246caed336c9a0c5dcc0b078dfc05d9e9e80001bef46e690d1ef2f0f0ddc6f581b28b9d4c087c00a06466c2f026ae1b2036844bf3930d03764065eb81c01238eb1df05a6c3c8e4e3a841b57c0cc30c78d79d8ceb5945139ac8e4ba8ba1fb0ea45cfeaa0da8c2ccbe0dd1d4675f0606353f06be757368605cf8778ca8fcfdb98008d3f31634c2c502c83457ef1828868d81b25d19f822a8123624c7da17061e183a37b094b5074cb445146592877156267e808c5a78be1428c24c0dfc467b11508459b7809186c56d43a463b33490855f02d520ed32a65c16bf066e3f95800999dcea0353c2f825bb8cf2ee330e1ad0f0c5eded0bb896f91c18d22a8f330117773e33f0adce16a08b5b770c44989981a0b4364451fefc1a18180d0d7c4cfd0718b3c57a63e06e42e4476394078c289728dbd45d417f69e0f39ebfc050853d17500cab0da075ba9f3d035f353f127096de9b810fc30f0d91418b1f60427eac7f0dacafff011f32de3730e5d1415593fb3303f72c4e8129701e8d30cde3076f8444d86a3a3fce042adb930c50d24f9f0d2c97b6005dcb6265a0a00e8029b0df11504f1791c9cd5189a2fcf911502dcf9e0c74389f06aa947629d31a2e360656475f818a20826396b7390679af0626deda623c8c72f93d0626dae5d9c01def8581cfaf3d1ae218bd2f600aac2283b2ff6de7cc965c65962c7ddf8fd171ff99e6c1fa4ab384241068d61d20a17946a359bd7bbb93f99fb62aabec1738b577980c2108c257b82f5fe140ea1ddc1f5b2affdaf1fbb7f5ff3922fd1b0deff73f3b7e27aae6fceec804bf6aeb47f406fa6acacf641f7e772c7fb3477ffbbb230a7e9cbfbbf9d78edfa7e57ec23490abfcdeafacfceec8fcc352d5df1dd9df89f2aebf3b72bfe3a80d7e7714c39ff0e8ff801cfeeb2a8f9f4e4399cadfdcf0fadd91feedf4f5cf11995f3f7d557f77e47e77546affdaf15be7ffb176299dfe3e3212ffeef807a0aff5bb23fb7bcab3fabbe39f4eed1f2db592537e6be33f4e1785b95f5b2a8ddf1dabf0b7e09ea4c6552a0cc3dfa568121eab742806ff1cd1fed9b194637487fbb34a8ad2abf0d77c93201645d1f267e6dcd8fcee907f3f3bf8376fff42c1fc1bb7ff41e1bf43c177e3c08d43375ebaf1ca8d23375ebbf1c68db76ebc73e3bd1b1fdcf8e8c627373ebbf1c58daf6e7c73e3bb1bc76efc70e3a71bbfdcf8edc61f37feba7145c2d38d6b6e5c77e3861b37ddb8e5c66d37eeb8b1e5c65d37eeb971df8d6d3776dc78e0c6ae1b7b6e3c74e3911b8fdd78e2c653379e256deec60b374eb971da8d336e9c4d36726e9c77e3821b17ddb8e4c6650c1883f1310126c42c312b4c84596336982d6687d9630e9823e6f4dfa38039632e982be686b96362cc03f3c4bc306fcc07f3c55430554c0d53c734304d4c0bd3c6743016a68be961fa181be30827615c8c8719624698316682996266983966814961d2980c268bc961f29802a6882961caf8e01b7c1f3fc00ff197f8ab7f5a84bfc6dfe06ff177f87bfc03fe11ff847fc6bfe05ff16ff877fc18ff81ffc47fe1bff13ff85ffc0a7ef50f14fc1a7e1dbf81df5414fc167e1bbf836fa9fd7e17bfa728f87d7c1bdfc11fe0bbf81efe107f843fc69fe04ff167f873fc057e0a3f8d9fc1cfe2e7f0f3f805fc227e09bf4c008121f0090282906049b0228808d6041b822dc18e604f702038129c08ce3afae0427025b811dc0962052278103c095e046f820fc197400eab12d408ea0a41d0206812b408da041d028ba04bd0fb0385a04f60133804039df9c025f0088604238231c184604a302398132c08520469820c419620479027281014094a046542080da14f181086844bc2156144b826dc106e0977847bc203e191f0447826bc105e096f8477c298f041f8247c11be093f845fc20a6195b04658276c1036095b846dc20ea145d825ec11f6096d428770a07084aeda1f7a8443c211e198704238259c11ceff40215c10a608d38419c22c612e890219449eb04058242c119659c2d2b0f459062c43964bb57cb96219b15cb3dcb0dcb2dcb1dcb33cb03cb23cb13cb3bcb0bcb2bcb1bcb38c593e583e59be58be597e587e5956585659d658d65936583659b658b65976585a2cbb2c7b2cfb2c6d968e7c157650149603962e4b8fe590e588e598e584e594e58ce59ce582658a659a65465d609955e75ae658e65916fe4061596429f69459c1cab0f275fe578186c32a64b564b5d2585845acd6ac36acb64a3f32ffab1dab3dab03ab23ab13ab33ab0bab2bab1bab3bab98d583d593d58bd59bd58795745861556555635567d560d564d562d566d56165b1eab2eaa9274bfcaffaace4a20eab012b9795c76ac86ac46acc4a86376535633567b560956295d6685a65586559e558e5591592afc5644f895599082243e4ff8142141085444b9db46845142904d15ae9405c4018512c8f361a08d1561d21da292f447ba283124a74243a119d892e44d2c38de84e14133d889e442fa237d187e84b5421aa12d588e4ac065193a845d426ea1059445de542315ee97049d423ea13d9440ed18048aee8110d89464463a209d194684634275a10a588647819a22c518e284f54202a129588caac616d58fb8ac23af8038575c87ac97ac53a62bd5608c417242ee473bd513a586f59ef1408c90eeb3deb03eb23eb13eb33eb8b7af8facafac6faae81b78e593f58cbce17eb37eb0feb2feb8abae8bacabac6bace5afa69b26eb16eb3eeb0b674c2d75dd6bd0405194f9fb5cdda613d487c41365c0565edb11eb21eb11eb396e14d59cb1565840bd6d27f9a75867596758e755e13cdba907c1659975897d9c0e60fbdc0c66713b009d92cd9ac34236e22f50889086184cd5a23423c424861b361b365b363b36773607354dede9cd89cd95cd8c8f64d3949f87c736713b379b079b279b179b3f9b0f9b2a9b091fe6b6cea6c1a6c9a6c5a6cda6c3a9a1a85cf37169baee6c84d4fe75fcd1eb0e9b3b1d9386c64db65e329349b219b119b319b099b299b199b399b059b149b349b8cdabfc9aa5b49a06d726cf26c0ac2267fa1506423d696d9c2d668146c7db68172c43664bb649ba0b08dd8aed96ed86ed9eed8eed91ed81ed99ed89ed95ed85e75e6b737b677b631db07db27db17db375bd9ff655b615b652b5dd5d936d836d9b6d8b6d976d85a6cbb6c7bea0eea113db67db6365b47e1d80ed417b6d23cb643b6238d88ed98ad7c4ed9ced8ce1585ed826d8a6d3a3926a3f3a1bac3280adb2cdb1cdb3cdbbfd8715b645b625b66073bc3ce6717b00b3529882fec96ec56babd8bd8ad35a4771b765b763b767b760776477627766776177657763776777671d21eec9e1ac0bb17bb37bb0fbb2fbb0abb2abb1a3be9aa91444d4f51102fd8353522c4ec5d8b5d9b5de7f753e0109a1088e573278775d9c9469f9dcdce613760e7b2f3d80dd98dd88dd94dd4b9445ceca61a14c2bbbb19bb39bb05bbd41f28ecd2aaed761976597639d59ebbbcb65f140aec8aec64a3ac24b787bd61efb30fd887ec97ec574afefb88fd9afd86fd96fd8efd9efd81fd91fd89fd99fd85fd95fd8dfd9d7dccfec1fec9fec5fecd5efa94d32becabec6beceb0ac1bec1bec9bea5b84853e39bea08fb36fb0e7b8b7d977d8f7d9fbdcdde613f60efb2970386ec47ecc7bfa25322629d10cd7ea291bb9fb29ffd81c27ece7ec13ec53ecd3ea359609f659f53b1b8cfb32fb02fb22fb12f738083e1e073083884ea0e87a572fe61c521e2b056c23b6c386c39c84f7b0e070e470e270e670e170e570e370e774d2b8798c383c393c38bc39bc34733dfe1cba1c2a1ca41faac6bfbb1ffd050a710d610140ef255ae221b1d0e16872e871e873e075b83e2e070187070350ac4fe83a7be70187218711873987098fea59a64d072fe9cc382438a435ad5c121c321cb21977ce639485f450e250e658e68601f0d479f63c031e4b8e4b8e218715c73dc70dc72dc71dc733c703c723c713c73bc70bc72bc71bc738c393e383e39be38be397e54ea1dbf1c2b1cab1c6b1ca5ff861a7f4c1c41184110512ddce2d852052d7ae1d8e6d8e16871ec72ec71ec73b4393a1c071c5d8e9eae3b0488e390e388e398e384a39cf5972f1ce71c171c531cd31c331cb3494680638e639e6381639163896399139c0c279f53c029e4b4e4b4e214715a73da70da72da71da733a703a723a713a73ba70ba72ba71ba738a393d383d39bd38bd397d387d3955385539d538d5554a9d1a9c9a9c5a09293455449cdaca1ab2a12b889646c4499ac5497eea71ea73b239399c069c5c4e1ea721a711a731a709a729a719a739a705a714a7f4df289c329cb29c729cf29c0a9c8a9c4aaa9a4e65552067381bce3ee78073c879c979c539e2bce6bce1bce5bce3bce77ce07ce47ce27ce67ce17ce57ce37ce71c737e707e727e717e73fe70fe72ae70ae72ae71ae736e706e726e716e73ee70b6387739f794057ecd6e6bfbf92adc7996667376380f38bb9c3dce43ce23ce63cd97a21ace13ce53ce33ce73ce0bceb227cd39c339cb59ccc9ff81c2b9c0b9c8b9c4b9cc05d58517c3c5e7126882b8845ce473c525e2b2e6b2e1b255efbdecb8ecb91cb81cb99cb89cb95cb85cb9dcb8dcb9c45c1e5c9e5c5e5cde5c3e5ce4940a972a971a973a9706972697169736970e178b4b974b8f4b9f8bcdc5d15838261c291944032159204afab80cb8c8083d2e432e232e632e132e532e332e732e0b2e292e692e192e592e3945e192e752e0524c5ae90f142e65ae70355c7d5d208a234852b8065c43ae4bae2ba546218e6bc475cd75c375cb75c775cff5c0f5c8f5c4f5ccf5c2f5caf5c6f5ce35e6fae0fae4fae2fae6fae1fae55ae15ae55ae35ae7dae0dae4da4a3a6c73ed70b5b87635b35e7b5cfb5ced4441b82a93242eae8eba834832d151d70485ab348feb90eb88eb98eb84eb94eb4cd3c475ce75c135c535cd35c335cb35c735cfb5a0aae94f5fb816751d2111712d694408355ecbdce066b8f9dc026e21b725b715b748795e16a0b735b70db72db71db73db703b723b713b733b70bb72bb71bb73bb798db83db93db8bdb9bdb87db975b855b955b8d5b9d5b835b935b8b5b9b5b879bc5adcbadc7adaff9526b244fe54821058908217c114b1211be5cdae6e6701b7073951a6e1eb721b711b771f239e136e536e336e7b6e026034e73cb70cb72cbfd81c22dcfadc0adc8adc4adac0afa0e77c3dde71ea8d9f790fb92fb8a7bc47dcd7dc37dcb7dc77dcffdc0fdc8fdc4fdccfdc25d0ebe71bf738fb93fb83fb9bfb8bfb97fb87fb957b84be735ee75ee0dee4dee2dee6dee1dee16f72ef71ef73e779bbbc37da0da799d6407890b710d51eb7797bbc77dc87dc47dcc7dc27dca7dc67dce7dc13dc53dcd3dc33dcb3dc73dcfbda039e25ee45ee25e5677f87f75c6ff82824a8612b14f1ca85e8843e225f18a38526a88d7c41be22df18e784f7c203e129f88cfc417e22bf18df84e1c133f889fc42fe237f187f84b5c21ae12d7d41de23a7183b849dc226e1377882de22e718fb84f6c133bc4036297d8231e266b275b13c78f70f841211e118f75a11d4f88a7c433e239f18238459c2696c1678973c4796231b8482c769579c0c3f0f079043cc23f50782415a187b4482b488f358f0d8f2d8f1d8f3d8f038f238f138f338f0b8f2b8f1b8f3b8f98c783c793c78bc79bc787c79747854795478d479d47834793478b479b478787c5a3cba3c7a3cfc3e6e128ac8f010f9787c763c863c463cc63c263ca63c663ce63a162e9f0a32393da992fd74df148f3c8f090a1e678e47914781495111e25a5c647592178a2283c8d169a9e3ecf8067c873f9372f3c573c239e6b9e1b9e5b9e3b9e7bf585e74123e279e479d2c2d1f3ccf3c2f3caf3c6f3ce33e6f9e0f9e4f9e2f9e6f9e1f9e559e159e559e359e7d9e0d9e4d9e2d9e6d9e169f1ecf2ecf1ecf3b4793a3c073c5d9e1ecf21cf114f19ee84e794e78ce79ce7425190b890eca8112107a7746e9e695d443c333cb33c733cf33c0b9a26443b3ec5ec12cf32af048297f92db7adb2bc7c5e81bac3eb2f5f782d79ad78458ac26bcd4b3eb7bc76bcf60afcebc0ebc8ebc4ebccebc2ebcaebc6ebce2be6f5e0f5e4f5e2f5e6f5e1f5e555e155e555e355e7d5e0d554b27cb578b579757859bcbabc7abcfabc6c5e0eaf012f9797c76bc86bc46bcc6bc26bca6bc66bce6ba122e29552145e69cdf61211af8c2eae5e62588e575e23e255e02536977895f5f38dbac0db68e9595078fbbc03dea1a220aae9bdfccb1722de2bde090aefb516542410de1b25c8f796f74e6b2a6fd973e02d1b27de67de17de57de37de77de31ef07ef27ef17ef37ef0fefaf02f1aef0aef2968d3aef06ef26ef16ef36ef0e6f8b7797778f779fb7cddbe13de0edf2f6780f79cbd0c7bc27bca73aff87444a0bb1bd67bce7bc178ac23bc55b4ccaf0ce2a3bbe73bcf3aa1adf7258917749cbf9925cc56c5950becb7ce063f8f87cfeaa357d423e4b3e2b3e119fb566cacf86cf96cf8ecf9ecf81cf91cf89cf99cf85cf95cf8dcf9d4fcce7c1e7c9e7a5107cdeea119f0f9f2f9f0a9f2a9f1a9f3a9f069f269f169f369f0e1f8b4f974f8f4f9f8f5cc8e133e0e3f2f1f80cf98cf88cf94cf84cf9ccf8ccf92cd4ff850e3f293e693e193e592d3d7d727cf27c0a7c8a7c4a7cca7ce16bf8fa7c03bea13abfaccabe4bbe2bbe11df35df0ddf2ddfdd1f287cf77c0f7c8f7c4f7ccf7c2f7caf7c6f8a82b0d1575accf7c1f7c9f7c5f7cdf7c3f7cbb7c2572e53e35be7dbe0dbe4dbe2dbe6dbe16bf1edf2edf1edf3b5f93a7c077c5dbe1edf21df11df31df09df29df19df39df05df14df34df0cdf2cdf1cdf3cdf02dfa2166065f297727a49ab6c5a56906ecb5a68a940c56801aee25309544448b044632a2195a596ea2b2b5d71c8fe4aa442abb2d6fdabbf78a122c76da9eca8eca91cb4d65e395239513953b9fc1252e54ae546e54e25a6f2a0f2a4f2a2f2a6f25177a87ca954a854a9d4a8d4a934a834a9b4a8c8503a542c2a5d2a3d2a7d2a361587ca808aabee50f1a8881962928c7e42654a6546654e6541254545ae9ba192a592a392a752a052a452a252a69a28fdaaa1ea530da886549754577abbac1a696540d6c4b202326baad23654b7547754f7540f7fa0503d523d513d53bd6889bd7aa57aa37a578294d554355677a83ea83ea9bea8bea97ea87e759950ad50ad52ad51ad536d506d526d51957174a85a54bb547b54fb546daa0ed5015519b74775487544754c7542754a7546754e75413545354d3543354b55ae9ba75aa05aa45aa25aa6063543cda716500ba92da9ada845d4d6d436d4b6d476d4f6d40ed48ed44e493b53bb50bb52bb51bb538ba93da83dff40a1f6a2f656bd50fb50fb52ab68c5b556d51c21bc20408847d46ad4ead41ad49ad45ad4dad43ad42c6a5d6a3d6a7d6a363587da809a4bcda336a436a236a636a136a536a336a7b6a096a296a696a196a596a396a756a056a456a256a60e7543dda71e500fa92fa9afa847d4d7d437d4b7d477d4f7d40f091072cc91fa89fa99fa85fa95fa8dfa5d8dafc7d41fd49f6a79fda5c6d7dfd43fd4bfd42b7fa050af52af6944d4ebd41b7ad3212ca94c90a0104750dd7e57b2dccbe59bd45bd4dbd43bd42dea5dea3dea7dea367587fa80ba4bdda33ea43ea23ea63ea13ea53ea33ea7bea09ea29ea69ea19ea59ea39ea75ea05ea45ea25ea6010d43c3a711d008692c69acd4fe46a4f6376463937c95ed1d8d3d8d038d238d93fa42e34ce342e34ae3a693afdb770d61710131be11d378d078d278d178ff8142438efbd2a8d0a8d2a8d1a8d368d068aa7c6eb4543234da0a44a343c3a2d1a5d1a3d1a761d370680c68b8343c1a431a231a631a131a531a331a731a0b1a727a9a46864696468e469e468146914689469926340d4d9f664033a4b9a4b9a219d15cd3dcd0dcd2dcd1dc2b10cd03cd23cd13cd33cd0bcd2bcd1bcd3bcd581da1f950209a4f9a2f9a6f9dffe647b77f50687e6956685669d668d6ff40a1d9a0d9a4d9a2d9d69b8ec240423ccd0e4d8b66f71708e1c8668f669fa64dd3a139a029c77834870a447344734c7342734a7346734e73413345334d3343334b3347334fb340b348b344b34c0b5a86964f2ba015d25ad25ad18a68ad696d686d69ed68ed691d94145a477584d689d699d685d695d68dd69d564ceb41eb49eb45eb4deb43eb4bab42ab4aab46ab4eab91b426ad16ad36ad0e2deb0f145a5d5a3d5a7d5ab6561f5b8e16605b03cd972d57f3a5a0a0025e46e6d11ad21ad11ad39ad09ad29ad1925316b4524a84ad34ad0cad2cad1cad3cad02ad22ad12ad326d681bda3eed8076487b497b453ba2bda6bda1bda5bda3bda77da07da47da27dd6f25cfb42fbaa06b76fca086dd98875bb2d3f3d69bf68bf697f687f6957d417da55da35da756507898876837693768b765b3da2fdff41a16dd1eed2eed1eed3b6f591044996c20ec79cae237e5443dba13da0edd2f6680f698f688f694f684f69cf68cf692f68a768a76967686769e768e76917681769976897e940c7d0f1e90474423a4b3a2b3a119d359d0d9d2d9d1d9d3d9d039d239d139d339d0b9d2b9d1b9d3b9d98ce83ce539d4248a1f3522c3a6f3a1f3a5f4541dc413684203b158540fc4250e854b50947766a74ea8a42a7f1070a9d269d169d361d39c8a2d3558e148fe8f4e8f4e9d84993af033a2e1d8fce90ce88ce98ce84ce94ce8cce9cce824e8a4e9a4e864e964e8e4e9e4e814e914e894e190b2c83e563055821d6126b851561adb136585bac1dd61eeb8075c43a619db12e5857ac1bd61d2bc67a603db15e586fac8f5283f5c5aa6055b16a58756547ab81d5c46aa9470835586dac0e9685d5c5ea61f5b1ec3f50b01cac01968be5a97cb4865a68b3465863ac09d654d38435c39a632d942cac14561a2b8395c5ca61e5b10a5845ac1256992e740d5d9f6e4037a4bba4bba21bd15dd3ddd0ddd2ddd1ddd33dd03dd23dd13dd3bdd0bdd2bdd1bdd38de93ef4e665f749f745f74df743f74bb742b74ab746b74eb741b749578e69d3edd0b5e876d517048b6e8f6e9fae4dd7a13b5077900dc91a8242d7a5ebd11dfe814277a4b7edbb63ba13ba53ba33ba73ba0bba29ba69ba99a4ec2b5d67e9e6b48cd3cdd32dd02dd22dd12dd3839ea1e7d30be885f496f456f4227a6b7a1b7a5b7a3b7a7b7a077a4785a377a277a677a177a577a377a717d37bd07bd27bd17bd3fbd0fbd2abd0abd2ab2510c8d7c4f89eb426bd16bd36bd0e3d8b5e975e8f5e9f9eadaaa9e7282ff606ea08229c04889eab895350e879f486f4467fa0d01b6b2008fdf6262a19aeb267aaf5e8de8cde9cde825e8a5e9a5e865e965e8e5e9e5e815e915e895e993ef40d7d9f7e403fa4bfa4bfa21fd15fd3dfd0dfd2dfd14f50e84b3bd23fd13fd3bfd0bfd2bfd1bfd38fe93fe83fe9bfe8bfe97fe87ff57676bf42bfaa1121f32f28f46bf4e5b3415f7e6ad16f2b16fd0e7d8b7e977e8f7e9fbead4aa1efd01fd077e97bbf2953bca03fa43fa23ffe0385fe448b8efda9ae23fa33fa73fa0bfa29fa69fa19fa59fa39fa79fa05f585be1c59a25fc606db60fbd8017688bdc45e6147d86bec0df6167b87bdc73e601fb14fd867ec0bf615fb867dc78eb11fd84fec17f61bfb83fdc5ae6057b16bd875ec067613bb85dd5614ec0eb6a55e6077b17bd87d6c5bf9c276140b7b80ed627bd843ec918a6b7bac2888a09688b027d853ec99f2c29f1161cfb117d829ec3476063b8b9dc3ce6317b08bd825ec320e3806c7c70970429c25ce0a27c259e36c70b6383b9c3dce01e78873c239e35c70ae38379c3b4eac0b4d2105e781f3d470705e386f9c0fce17a78253c5a9e1d4711a384d9c164e1ba78363e174717a387d1c5b23c27170064973713c650a678833c219e34c70a638339c39ce022785935605250a422050a69073337fa0e064f54e8493c3c9e314708afa389353c229ebb32c03181806bea23008921632583258318818ac19c8315b063b067b06070647062706670617065706370677b57f103378a8b30c9e0c5e0cde0c3e0cbe0c2a0caa0c6a0cea0c1a0c9a0c5a0cda0c3a0c2c065d063d067d06360387c18081cbc06330643062306630517406536d82d160c660ce60c120c520cd20c3209bacb2643c39cd1d83bfea8e838216a025f70c8aca8b8392b6539e411917bd91ed1a5c5f75e4dd53ed2059f39ac10d7043dc25ee0a37c25de36e70b7b83bdc3dee01f7887bc23de35e70afb837dc7bf21cf603f789fbc27de37e70bfb815dc2a6e0db78edbc06de2b670dbb81db5c7b570bbb83ddcbecebf6be33ab8035c37d9f07087b823dc31ee04778a3b4b28a3833bc795d353b862820c388b9bc3fd0b05b7805bc44deed0b9653cf00c9e8f17e085784bbc155e84b74e24838db7c1dbe2edf0f67807bc23de09ef8c77c1bbe2ddf0ee7831de03ef89f7c27be37df0be7815bc2a5e0daf8ed7c06be2b5f0da781d3c0baf8bd7c3ebe3c9251cbc019e8be7e10dd5ff05026f8437c69be04df1667873bc055e4ab1f0d27819bcacb2869753df112a1542f5f27805bc225e09afcc10867f3dd7744ce98272e8330c1886aa9a864b862b8691dead1205315c33dc30dc3294c3f60c0f7ac9e191a1fc7466786178657863786718337c307c327c317c33fc30fc32ac30ac32ac31ac336c306caaac1ab618b61976185a0ce58a3d867d86364347ef620d070c5d861ec321c311c331c309c369d2660ce70c170c530cd30c6524d25b4ec3619857b3954ae4f88212e7b0a87263586258d6a7474730fa0b85538e91cf286014325a325a291c62fc2862b4567790f439da30da32da31da333a303a329203ce8c2e8cae8c6e8cee8c62460f464f462f466f461f5d688fbe8ce4f255463546d24f835193518b519b51875102c1485a8f519f91cdc861346024277a8c866ad268a42c201e311a334ab0105f18499b319a335a304afdea88515a2d97c421596394619455fb7fa4d7486ccc332a302afe81c2a8c4a8cc18c64657d6cf2d639f71a0459771c878c978c5385205355eebf5c61bf54fa1a5b11cb963bc677c607c647c627c667cd1191e5f19df18df19c78c1f8c9f8c5f8cdf8ca5cf2fe30ae32ae31ae33a63e9b0c9b8c5b8cd584eb4187719f718f719dbaa0bc60ee301635751187b4a04e30494f188b1ec91614c5556cafc8f134618cf93acd1533f1250c60b4d1c4210e39462314eff81c238a3d33e4c5ce0b556d5a8286419cb3979c605c645c625bd973f2e33415198184dda139f49c02464b264b26212315933915fb74c764cf64c0e4c8e4c4e4cce4c2e4cae4c6e4cee4c62260f264f262f266f261f265f2615265526352675260d264d262d266d261d2616932e13b9629f89ad404c1ca580c9405583a020a9417c61e232919f864c46c9d892b8d07028291093896231f9eb899ec94c4b2ce20b933913392ec524ad5130c930c92a234c724cf24c0a4c8a9ab726252665a6e8144d0d539f69c03464ba64ba621a315d33dd30dd32dd31dd333d303d323d313d33bd30bd32bd31bd338d993e983e99be98be997e987e9956985699d698d6993634294c9b4c5b4cdb4c3bc9a7c5b4ab8973da53cb4559aa9aac69936439ed6b444c6d2508d5dd6d7513f91420445609534e9d3f50988a3172318fe990e988e9588110f92c11319d3095ae675a8c9dce93cb2c98a6148b699a69866996698e699ea95ca0c8b4c4b4cc0c668699cf2c6016325b325b318b98ad996d986d99ed98ed991d981d999d989d995d985d99dd98dd99c5cc1ecc9ecc5e9a23c57261c4d95b2362f6512f901430fb32ab68bc0810b36a222893f0919db39aba83a458a549eb577acfea091003667fadac67d2514b6fc9ccdaba821220661d6696d2c4accbaca7abc97545158b5c6cd6575f98d91a143387d9400962e632f3980d99c9b93256d9336526439f335b304b314b33cb30cb32cb31cb332b302b32937ecacc616e98fbcc03e621f325f315f388f95a9f7d1214e61be65be63be67be607e6479d6d59628afd321ed18ef313f3b3c6a9a0a001324fa263a81ca129a6a488cc2fea1dba71fdeb9ef54123429c7f7e637e671eeba7310ac7fcc1fcc9fca5ec3a7feb5545934882987f9499e65f4d63f30af32a73194d9d79837993794b2973de66de616e31174b7accfb49b3993bcc07cc5de61ef32173e941ba9a309f329f319f3397b1a698a799673441ce656039e6792508f108f10289f6b9b4a29a2d5e392fe9b24265a5745bd6ac294dc629835ca088c857a109c16e6158fcf54cbca050bdb00858842c962c569a1d17118b358b8dae26175b8560b1d39a873882a834d127727959db2df6ca558b830e77bf65716471d2a77b166716f27965716321978f593c583c59bc58485732be2f8b0a8b2a8b1a8b3a8b060be9adc5a2cda2c3c262d165d163d167612770cf5838cacd8b010b9785a70b6df1023711ceb2d05a0c598cd45344352dc6ca1d62bce0b298281cba91a8ecc55fcfb8090aa29aaa32c4398b058b140bb13cc322cb22a7cb87455e2fb628b028b228b128934a3285a020f393324a60295f47900a4885a496a456a422526b521b525b523b527b52075272cc89d499d485d495d48dd49d544cea41ea49ea45ea4dea43ea4baa42aaaa8e20c23155530e92b593c4b9909c107eaaae760a0b4c132f10c71411916a909291b448b5497574b65256a2a9a7c97e695d527fbd31244931d5d767dcb6557d752a65937248c9b55d529ede984a0d950852239d7f71b0d4384993460355501055939a90922bcd94ba5273520b5229526952195d35a5a4ff1ca93ca902a922a912a93269481bd23ee98074487aa928a457a423d26bd21bd25b4d78e99d46417a9f4803d9795015282b4861447101e17f99def451275f86276b8df4497584d82f82526455faac1bb2be10383464e480cb5ff7290fdad257d237d277d2b11bcff40587f4431fc64ccbc64bbb48bf93e5ca2c59deba2a57641923c952ec1f274a26fd21fd551e4a57485749cbb975d20dd24dd22dd26dd21dd216e92e69194d9fb44dda212d3dbba43dd2d283983d263d212db6cd34e0452088af89644acf75f2c511d20b6544499342fbc211e9948e4ae4633aadb39dcea8abcac0c46c11d7e96c02c79c748e745e9d25fdd733f195486f01a78baa8bd225d2653290317a8737e3930974492be1900993b8182bd388f34b93cb64e498950e543832139159eb46b74e6643664b6647664fe640e648e644e64ce642e64ae646e64e2626f320f324f322f326f321f32523fd54c9d4c8d4950e840b320d65874c535d23d322d3566b655b165a9211c47ef92a1e9ae928046e3237194b9bf8886091e992e9e9e902877044a6ff070ac1411fbacfd8fad44846ae3a20e3eae33c198f8cf43852fb756ddfd360938b65c6499af8aabc173d9799e8aa4efc363355619399291cc24c9939990519e9334d46f0ca92919d79320268914c894c992c640d599f6c403624bb24bb221b915d2733df535fcb6e7423bb25bb23bbd7f9d08d83aa00dd3eeaa7fa4246cb0d62aa582ebc903de97e090d45a1ab482d1207c99eff62c720793de3a30fce445d7d61e1d05044b61db217b257b2b7242f1613079b687c3a8e865cf64e364eb2d79bec83ec93ec8bec5b754ef693ecf992ad68b6cf56c9d6c8d6c936c836c9b6c8ca31d2bf0cab4b568cec93b5c93a64c56c97aca702293b243b5252cc8e559e652764a78aaf6c881cc8ced44ef1f3ec5c03568d97de169a0bb2a9e457393eadde91cde84f12d159e9e4afe71db3d251419ff9f8797c46dff7415f40dcdcf4a1986c5173b5d82fa9581cc1b5355c653525bdabf125f50551b8b2cecd9635658af192de65670e72869caf9a42482417900bc92dc9adc845e4d6e436e4b6e476e4f6e40ee48ee44ee4cee42e6a98067c3fa9a04c3528e46bee4aeea6e227772717abb3e41e3a2aa12a1995c47cee49ee45eead7326939ffb245e6069f0e6be0904d2c95ff7ac85050502997cf93ce7f425b0e09cbccb2a17ab92abe984e4ea9a11b49e3326d7d08810de163d2728e49a9acc64c123c241be0aab4ba40816e29f42a2c3b1964624c5e65ae4dae43ae42c7262402f01a24fce26e7901b9073c979e486ba0496b99d243128068834ca8d940e7372694173aa6b07593ee57eda5c3d426c962395b9268a850884dc825c2a61444b93682ead9518d9cefd5577fc414122e215e81354b9acbeb022deb1b5747f2ea74b7a013b974f56d3232561b14d12b8b87aaea0d32e66cbfce7c45401a5ace8b8961eec65b4469847137eaf45de90f7c907e443f24bf22bf211f935f90df92df91df93df98352dd229186828518635dd4077b0923e68f9a1a443588b3489c8b58101d25eea0bc9055a520b80b794910a94648584c80f8a9c4c8ac085fe6ff7adb3c7fd6474cf3176d62bfa0f0f09526c52f8293da20442d2609105ade982b0a425a626afeaa7a41e5ed5739227f535e949585c4b056c4d249ec4c7526f3775dd5e663f20ff24ff22ff26ff21ff25ff215f255f235f2328606f966a2822649c5d5d10582d355bf9065b29082ac11f282665bf70b5292327f2493125626a94a0eb5693a18aa830885c976be43de52761306cd77ff42a197787e56395236f27dc5226fab239cd27ab24caf5c435090ee44c94a2c684690697414a061828b84c0a4ab69729c148885d88547259885e18447657c62497e40de252fde31242fd08cc94fc84fc9cfc88b7902538a7c5ae73f9f5114c4480907d1ffa211bb3f8b455f95925898cf6a9acce7941dc454997399a745c2237239a5092bc99ab632743e4fbe40bea87393ffebcd80ad4c4e591d419f14f6158202bf28148cceb6f8bc88796f48c15741269f82852cf54653d50b02d3cf0d02519085400f164f91c9115714a22a84ca5be211024af745614941ba8d28ac296c286c29ec28ec291c281c75a9523825f50b27a90b3494080a67ad204838882f08298ea75a7a295c345968d56ba648493a1027151f2c5cd5312522c413654fe1a6fe2b2ea083bfeb5c16e23f50283c283c29bcf415aec25b5346e1a3b8887714be142abf3259729e3bd04ec511246b683a2c292916aa146a5a1a167710fb0bf5dff89ca694b17e062a8b4ea19242834293428b8298d1a120e77629f428f429d84a7bc226e23ea285c5db7fab263dad9d8917885812fba589238817141c85c6b1150b41411751331d9bda3fd3d42014a0ce7bd7542543924f99b3820cefafb74a15054f5fc3111484230a02db48c3447029c8d06536a6bf4ab630d3f89785937c2dcc35358ae562bfc02ffca75580bc52a940205321042eb32ad425095ce64abc43e0282c28a428a429c8b408ca390a027a41794e7c4a664f49fead0e2f460e92db708282b883a0205f0b450a255d44081cf293ec191d9444e689cd6e920ec4fe1f1d2ddb129885b286ad0cbb084543f1af957531d0874b4f16c590e292e28a62a4d014d7143714b7147714f72ae68b0775042d0176291e159de249a3a378a67849ee170d950b0514492582c2cf4415af6a9b30a5ec71e4e01b4519534c512ef1a4f8a2f8a6f8d15306a344264c95f0ecaec6bcdeaaaf6a38489a146ad0228a0ce9ab21238ee024f525bb9f2c10327a75f9541d6d69d84a529326ba7698d68810cf2d5628fef5b738c46c997f45a1a62f6c16eb141b149bfa573f8a2dd5c8c5a4e657eca8532916728ca0d0d3d4287428ae21aaa9d8571e12a92b1b6289ce4f5127ff27ab0b7b156d1d6ed1a138a0289d781487144714c73af9c589de7af3920281caf3b2cef9c4535e2c4e357174df9a20c50b8a8964941c2188084cb2314c5850a647048b182fea469adeb9c8e84e6faeea5bbc40e74c7afbebaf506492e76b8b8be4334531ad8bab628662569d6234a198d325a3f87f31af66170b148b14e5e032259275d48492a1e42b0a4201325d628616d1273aab227e4a81268b52a8889496945694224a6b4a1bf591d296d24e4f94c3c4425184ba8e9e2b5388dcea57552feafd95aa8222c68b23687db1aa28e882baaf932f7320364bd896f63aff85a42a533ae8a7e4b2d251674ef25ae92fbdb06924af275afa670b0485d2599f9a1607295d92764ddca140e996183ca574a714537a507a527a517a53fae83c94125f50522c2abdcf657f45e74a97610d3552c84259134a62704d795ebe4a280910220d24474a5a11fde326fa577e1581384b6ed2a6aa5a50d6e2baff1b14a57a82f24603a7d4d0145e6aeafc4bcc965a0a81ca96b6d2962ecc87dac4174aedbf575325e9c2d2a7a63f594ad2a94c5d5fb1900029d99404c8a48850722989a932a5234a634a32ffb2739610474791ca256b389dedb9c68252e389d242cd28a512359d552c0485144a01421fb2649a2e7ecb84a202273f2aebfd2b9c4a694a3f0ba1b4fa8278472959ce88bfc8294a37b3a4f472fe8dc7524e8d9738954f59bc94f21ac2a542d28a94c4e9ca94ff7a6faa2ccda71c500e292f29af284794d71a29024d59da96f24e557a794ff940f948f944f94cf942f94af946f9aeab492fa52e27b940ebc247f564f155f1859fd0d05a889c182b2242845aa719ebb6f88b78756aacb53cb14d6cfed5bfc9032b82cb4f0a283f54320a28728cc82a3bf111f11d81550015392f6a45ae2e66979feab3a324af955f89e7ca08dfdac4a3ff46e1a35e50feea4b9de208379b72857295728d729d72837293728b729b72475dab6c51ee52ee5196cb489ecf5076280f28bbcac3658ff250872e33561e511eab474c6412260a8a2ecc2794a71a3bf2b53ca33c579756fa18e89a4f8c97e5702929eda8d02827fb172a1f2447885814c9944bee4d6af96cae4256225f02a1bc482048514e6b93f917a728cbd8b23a304973e51ce53ce5bf6a4d62b9a250d4bc502e69c5b15cd6bf8725fffd6df2671c02a37f806869f40f53c8a25898702d7462f46f56ec0c7b452135d3a84b1f0d079c89e1982c876cc329d1f3138d14cd1d639d7699432d048d0ce764c9a43f192e49c92c5917fd1cf953599773059d89abb5bcacf47f55012228fc30882822097e1532c25322756f49f01675b624b5956e465ff98935d30ba3a58ce1f1972f9492a090239eb26df4adab77e21162f3c7e81b2815a3af22d48c3eb1de30fae872cbe893ac1d8325d9c1202be5a741e4cdccd0d73fb524cbf35e5dc96c9adcc5c9253c374d38c24dea343f825f1c418c940cfa5329902353ba9a32d849be3c26ec5051192e9ee50cb543891795e4331591fa50cf40b5404666c8d1e59cb8802780ca44e68c3e7de2e9fea98c736818a9ea2f797fd71dc51d840eda72dad86875591608b22d26cd8ddeca907ed3464b9159a3951359210bea92824b3fe019fde71b1318131ab3346625481a1319b34e9e4daca95f8819ca0e63cded8285d602863adbc3644524ea400e90fc27332c532dcc27a68af3ffe45a95d596a6831f6a10d6d025d358c5b2a020e120032cbbc6c8b26a6dccd6985d4201392585f44702c198bda060ccc198e3dfbef0949f4fc69cd511cc8574d198ab561f5f7b636ec6dc8d898d791823c4b332468e791bf331e66b4cc598aa3135b2b63175631ac6348d6919d3d6d742b305bd8ff47337519ade5c1e24e5908e52baaefc9a7a43c5cb256592737207a594d07e4ac5afd6cb7a6ab0080dd92f40c85a53efcd6fd4fe9f5abb90a2644475f899319d04024b4c155d604c57ddc1f48ce96bc94bb5b94cd81fcfbe1ae3e81b735fb176608c9ce619333446901bf3de193331666a8c5c636eccc21889adb4311963b2c6c8e8051141ba608c0027b151d63fad276ee1fb8282f103e387fa048175d302c10f16e21a32ab32c3b26af8b9cba0b7e1fb7a4b52eb3713d5578e6bfca5f157facc8ac6fc571d473092c019d87ad63079a827bdd3f4ac1420a61e925c90357e64fcb5f13746484d40f1e5988cf1f7c63f18ff68fc3f549386807f36fec5f857f505ff667c99fc8b62e1c7c67f18ff697cd9ff36fec7f85fe3578c5f251b1abf667c2127dff80de3378ddf327edbf81de35bc6ef1abf677cc90275e3dbc677347768dd6da6eaa8289793d0bd1a5facf58c2f171a197f6c7c19c9d4f833e3cf8dbf108563fc94f1d3c6cfe81e61be6152e912fe4bcb48c4e09cf1f3c62f18bf68fc92f1cbfab70d252e03df04810942132c4db032416482b5093626d89ae08f77e8fe5ddbffa0f09f51f8b76efffb3ffecffffabf5955f19b + + + 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 + + + 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 + + + + KbfxPixmapLabelSiraj + KbfxPixmapLabelPhobosK + KbfxPixmapLabelNookie + KbfxPixmapLabelNathanael + KbfxPixmapLabelJohnny + KbfxPixmapLabelEphracis + textLabel6 + + + kdebug.h + qevent.h + kbfxconfigdlgabout.ui.h + + + QString KbfxMemberTextJohnny; + QString KbfxMemberTextEphracis; + QString KbfxMemberTextNathanael; + QString KbfxMemberTextSiraj; + QString KbfxMemberTextNookie; + QString KbfxMemberTextPhobosK; + + + KbfxUnmarkAllPixmaps() + + + init() + eventFilter( QObject * obj, QEvent * ev ) + + + + kactivelabel.h + kactivelabel.h + kactivelabel.h + kactivelabel.h + + diff --git a/configdialog/kbfxconfigdlgabout.ui.h b/configdialog/kbfxconfigdlgabout.ui.h new file mode 100644 index 0000000..7f4b739 --- /dev/null +++ b/configdialog/kbfxconfigdlgabout.ui.h @@ -0,0 +1,159 @@ +/**************************************************************************** +** ui.h extension file, included from the uic-generated form implementation. +** +** If you want to add, delete, or rename functions or slots, use +** Qt Designer to update this file, preserving your code. +** +** You should not define a constructor or destructor in this file. +** Instead, write your code in functions called init() and destroy(). +** These will automatically be called by the form's constructor and +** destructor. +*****************************************************************************/ + +void KbfxConfigDlgAbout::init() +{ + KbfxPixmapLabelNookie->installEventFilter ( this ); + KbfxPixmapLabelSiraj->installEventFilter ( this ); + KbfxPixmapLabelNathanael->installEventFilter ( this ); + KbfxPixmapLabelPhobosK->installEventFilter ( this ); + KbfxPixmapLabelEphracis->installEventFilter ( this ); + KbfxPixmapLabelJohnny->installEventFilter ( this ); + + KbfxMemberTextNookie = tr2i18n ( + "Name: Mensur Zahirovic (Nookie)" + "

" + "Country: Sweden" + "

" + "KBFX: co-author, Q/A, system design, web designer, bug hunter, project administror" + "

" + "Email: nookie@mail.kbfx.org" ); + + KbfxMemberTextSiraj = tr2i18n ( + "Name: Siraj Razick" + "

" + "Country: Sri Lanka" + "

" + "KBFX: author, maintainer, developer, project administror" + "

" + "Email: siraj@mail.kbfx.org" ); + + KbfxMemberTextNathanael = tr2i18n ( + "Name: Nathanael Dracor Gogniat" + "

" + "Country: Switzerland" + "

" + "KBFX: project technical writer, documentation manager, co-author" + "

" + "Email: nathanael@mail.kbfx.org" ); + + KbfxMemberTextPhobosK = tr2i18n ( + "Name: PhobosK" + "

" + "Country: Bulgaria" + "

" + "KBFX: package & release manager, Q/A, bug hunter, mandriva packages, project administrator, developer Qt/C++" + "

" + "Email: phobosk@mail.kbfx.org" ); + + KbfxMemberTextJohnny = tr2i18n ( + "Name: Johnny Henry Saenz Acuna (scarebyte)" + "

" + "Country: Peru" + "

" + "KBFX: developer Qt4/C++" + "

" + "Email: saenzac@mail.kbfx.org" ); + + KbfxMemberTextEphracis = tr2i18n ( + "Name: Christoffer Brodd-Reijer (Ephracis)" + "

" + "Country: Sweden" + "

" + "KBFX: library developer for Raptor" + "

" + "Email: ephracis@mail.kbfx.org" ); +} + +bool KbfxConfigDlgAbout::eventFilter ( QObject *obj, QEvent *ev ) +{ + QCursor kbfxCursor; + kbfxCursor.setShape ( Qt::PointingHandCursor ); + this->setCursor ( ( const QCursor ) kbfxCursor ); + + if ( ev->type() == QEvent::FocusIn || ev->type() == QEvent::Enter ) + { + if ( obj == KbfxPixmapLabelNookie ) + { + KbfxTeamInfo->setText ( KbfxMemberTextNookie ); + KbfxUnmarkAllPixmaps(); + KbfxPixmapLabelNookie->setFrameShape ( QFrame::WinPanel ); + return TRUE; + } + else if ( obj == KbfxPixmapLabelSiraj ) + { + KbfxTeamInfo->setText ( KbfxMemberTextSiraj ); + KbfxUnmarkAllPixmaps(); + KbfxPixmapLabelSiraj->setFrameShape ( QFrame::WinPanel ); + return TRUE; + } + else if ( obj == KbfxPixmapLabelNathanael ) + { + KbfxTeamInfo->setText ( KbfxMemberTextNathanael ); + KbfxUnmarkAllPixmaps(); + KbfxPixmapLabelNathanael->setFrameShape ( QFrame::WinPanel ); + return TRUE; + } + else if ( obj == KbfxPixmapLabelPhobosK ) + { + KbfxTeamInfo->setText ( KbfxMemberTextPhobosK ); + KbfxUnmarkAllPixmaps(); + KbfxPixmapLabelPhobosK->setFrameShape ( QFrame::WinPanel ); + return TRUE; + } + else if ( obj == KbfxPixmapLabelJohnny ) + { + KbfxTeamInfo->setText ( KbfxMemberTextJohnny ); + KbfxUnmarkAllPixmaps(); + KbfxPixmapLabelJohnny->setFrameShape ( QFrame::WinPanel ); + return TRUE; + } + else if ( obj == KbfxPixmapLabelEphracis ) + { + KbfxTeamInfo->setText ( KbfxMemberTextEphracis ); + KbfxUnmarkAllPixmaps(); + KbfxPixmapLabelEphracis->setFrameShape ( QFrame::WinPanel ); + return TRUE; + } + } + +/* + if ( ev->type() == QEvent::Leave ) + { + if( + obj == KbfxPixmapLabelNookie || + obj == KbfxPixmapLabelSiraj || + obj == KbfxPixmapLabelNathanael || + obj == KbfxPixmapLabelPhobosK || + obj == KbfxPixmapLabelEphracis || + obj == KbfxPixmapLabelJohnny ) + { + KbfxTeamInfo->setText(""); + + return TRUE; + } + } +*/ + + return QWidget::eventFilter ( obj, ev ); +// return FALSE; +} + +void KbfxConfigDlgAbout::KbfxUnmarkAllPixmaps() +{ + KbfxPixmapLabelNookie->setFrameShape ( QFrame::NoFrame ); + KbfxPixmapLabelSiraj->setFrameShape ( QFrame::NoFrame ); + KbfxPixmapLabelNathanael->setFrameShape ( QFrame::NoFrame ); + KbfxPixmapLabelPhobosK->setFrameShape ( QFrame::NoFrame ); + KbfxPixmapLabelEphracis->setFrameShape ( QFrame::NoFrame ); + KbfxPixmapLabelJohnny->setFrameShape ( QFrame::NoFrame ); +} diff --git a/configdialog/kbfxconfigdlgbutton.ui b/configdialog/kbfxconfigdlgbutton.ui new file mode 100644 index 0000000..3d63e75 --- /dev/null +++ b/configdialog/kbfxconfigdlgbutton.ui @@ -0,0 +1,1275 @@ + +KbfxConfigDlgButton + + + KbfxConfigDlgButton + + + true + + + + 0 + 0 + 613 + 563 + + + + + 1 + 1 + 0 + 0 + + + + KBFX Button + + + false + + + TabFocus + + + false + + + To change KBFX button skin, simply browse to the image you want OR just Drag&Drop the images to their respective place. + + + + unnamed + + + 10 + + + Minimum + + + + layout6 + + + + unnamed + + + + groupBoxPressed + + + + 3 + 1 + 0 + 0 + + + + + 32767 + 150 + + + + StyledPanel + + + "PRESSED" IMAGE SELECTION + + + AlignVCenter + + + + unnamed + + + 5 + + + 0 + + + + textLabel8 + + + + 1 + 1 + 0 + 0 + + + + Please select "pressed" image. + + + + + KbfxURLRequesterPressed + + + true + + + + 3 + 1 + 0 + 0 + + + + true + + + WheelFocus + + + image/jpeg image/png image/x-xpm image/gif + + + The Pressed Button Skin Image + + + Here you can choose the Pressed Button Skin Image + + + + + + + groupBox10 + + + + 1 + 1 + 0 + 0 + + + + + 322 + 150 + + + + StyledPanel + + + Preview + + + AlignVCenter + + + + unnamed + + + 5 + + + 0 + + + + KbfxPixmapLabelPressed + + + + 0 + 0 + 0 + 0 + + + + + 150 + 50 + + + + + 150 + 50 + + + + true + + + true + + + Pressed Button Skin + + + Here you can Drag&Drop the Pressed Button Skin Image. + + + + + + + + + layout7 + + + + unnamed + + + + groupBoxNormal + + + + 3 + 1 + 0 + 0 + + + + + 32767 + 150 + + + + StyledPanel + + + "NORMAL" IMAGE SELECTION + + + AlignVCenter + + + + unnamed + + + 5 + + + 0 + + + + textLabel6 + + + + 1 + 1 + 0 + 0 + + + + Please select "normal" image. + + + + + KbfxURLRequesterNormal + + + + 3 + 1 + 0 + 0 + + + + WheelFocus + + + image/jpeg image/png image/x-xpm image/gif + + + The Normal Button Skin Image + + + Here you can choose the Normal Button Skin Image + + + + + + + groupBox7 + + + + 1 + 1 + 0 + 0 + + + + + 322 + 150 + + + + StyledPanel + + + Preview + + + AlignVCenter + + + + unnamed + + + 5 + + + 0 + + + + KbfxPixmapLabelNormal + + + true + + + + 0 + 0 + 0 + 0 + + + + + 150 + 50 + + + + + 150 + 50 + + + + true + + + true + + + Normal Button Skin + + + Here you can Drag&Drop the Normal Button Skin Image. + + + + + + + + + layout8 + + + + unnamed + + + + groupBoxHover + + + + 3 + 1 + 0 + 0 + + + + + 32767 + 150 + + + + StyledPanel + + + "HOVER" IMAGE SELECTION + + + AlignVCenter + + + + unnamed + + + 5 + + + 0 + + + + textLabel7 + + + + 1 + 1 + 0 + 0 + + + + Please select "hover" image. + + + + + KbfxURLRequesterHover + + + + 3 + 1 + 0 + 0 + + + + 0 + + + true + + + WheelFocus + + + false + + + image/jpeg image/png image/x-xpm image/gif + + + The Hover Button Skin Image + + + Here you can choose the Hover Button Skin Image + + + + + + + groupBox9 + + + + 1 + 1 + 0 + 0 + + + + + 322 + 150 + + + + StyledPanel + + + Preview + + + AlignVCenter + + + + unnamed + + + 5 + + + 0 + + + + KbfxPixmapLabelHover + + + + 0 + 0 + 0 + 0 + + + + + 150 + 50 + + + + + 150 + 50 + + + + true + + + true + + + Hover Button Skin + + + Here you can Drag&Drop the Hover Button Skin Image. + + + + + + + + + kActiveLabel6_2 + + + + 7 + 0 + 0 + 0 + + + + + 0 + 29 + + + + + 32767 + 29 + + + + + 255 + 255 + 255 + + + + image0 + + + NoFocus + + + AutoOneFit + + + false + + + AutoText + + + <h3><p align="center">Please select KBFX button's images</p></h3> + + + WidgetWidth + + + AutoAll + + + + + KbfxResizeKickerBox + + + + 1 + 1 + 0 + 0 + + + + StyledPanel + + + Resize Panel + + + AlignVCenter + + + + unnamed + + + 10 + + + 0 + + + + textLabel9_2 + + + + 1 + 1 + 0 + 0 + + + + <b>Tip!</b> This button resizes the panel on which the KBFX button is to button's height or width. + + + RichText + + + WordBreak|AlignTop|AlignLeft + + + + + layout8 + + + + unnamed + + + + spacer6_2 + + + Horizontal + + + Minimum + + + + 1 + 1 + + + + + + KbfxResizeKicker + + + + 1 + 1 + 0 + 0 + + + + + 270 + 58 + + + + WheelFocus + + + Panel Resize is 'ON' + + + true + + + true + + + + + + + + + + + spacer6_2_2 + + + Horizontal + + + Minimum + + + + 1 + 1 + + + + + + + + spacer4 + + + Vertical + + + Minimum + + + + 16 + 1 + + + + + + + + kActiveLabel6 + + + + 7 + 0 + 0 + 0 + + + + + 0 + 29 + + + + + 32767 + 29 + + + + + 255 + 255 + 255 + + + + image0 + + + NoFocus + + + AutoOneFit + + + false + + + AutoText + + + <h3><p align="center">Preview of selected images</p></h3> + + + WidgetWidth + + + AutoAll + + + + + groupBox11 + + + + 3 + 1 + 0 + 0 + + + + StyledPanel + + + Livepreview + + + AlignVCenter + + + + unnamed + + + 10 + + + 0 + + + + textLabel9 + + + + 3 + 1 + 0 + 0 + + + + <b>Tip!</b> To see live preview, hover or press the preview image with your mouse. + + + RichText + + + WordBreak|AlignTop|AlignLeft + + + + + spacer7 + + + Horizontal + + + Minimum + + + + 20 + 1 + + + + + + KbfxButton + + + true + + + + 0 + 0 + 0 + 0 + + + + + 150 + 50 + + + + + 150 + 50 + + + + 0 + + + true + + + false + + + KBFX Button live preview + + + Here you can see the live preview of the KBFX Button. + + + + + + + KbfxFadeButton + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + StyledPanel + + + Button Fade Transition Effect + + + true + + + true + + + true + + + Check this to turn the fade effect of the button ON + + + This allows you to turn ON or OFF the fade effect for the KBFX button.<br>This effect makes transitions between the three images (normal, hover, pressed) animated. + + + + unnamed + + + 10 + + + + textLabel5 + + + + 1 + 1 + 0 + 0 + + + + Fade Effect Time (in msec.): + + + The fade effect transition time in msec. Valid values are between 20 and 1000 msec. Default is 75 msec. + + + Here you can enter the value of the fade effect transition time in msec.<br>Valid values are between 20 and 1000 msec.<br>Default is 75 msec. + + + + + KbfxFadeTime + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + StyledPanel + + + AlignHCenter + + + The fade effect transition time in msec. Valid values are between 20 and 1000 msec. Default is 75 msec. + + + Here you can enter the value of the fade effect transition time in msec.<br>Valid values are between 20 and 1000 msec.<br>Default is 75 msec. + + + + + spacer6 + + + Horizontal + + + MinimumExpanding + + + + 16 + 16 + + + + + + + + spacer3 + + + Vertical + + + MinimumExpanding + + + + 16 + 1 + + + + + + + + KbfxPixmapLabel +
kbfxpixmaplabel.h
+ + -1 + -1 + + 0 + + 0 + 0 + 0 + 0 + + image1 + targetDrop(const QString &) + mouseClicked( const ButtonState & ) + mouseDoubleClicked( const ButtonState & ) + dragEnterEvent( QDragEnterEvent *mouseDragEnterEvent ) + dropEvent( QDropEvent *mouseDropEvent ) + mousePressEvent( QMouseEvent * e ) + mouseDoubleClickEvent( QMouseEvent * e ) + + + KbfxPushButton +
kbfxpushbutton.h
+ + -1 + -1 + + 0 + + 5 + 5 + 0 + 0 + + image2 + pressed() + released() + clicked() + toggled( bool ) + stateChanged( int ) + animateClick() + toggle() + + + + + 789ced974b6fda401446f7fc0a8bec5095601eb64755174d7080a669d3b48b4a5517e33134a1101230e151f5bfd7f7bbc3f8510bb29a45d5b331e77e77c6c6067b7cd670bede5c3b8db3da3291c9bd72d49d5c388d78359b6dbf7d7ff3ab5677dda6d3124e2770dcfaab5afdd651ce4953785d11937e822acf63bd81c67bfd0c1d793eeb47ad8118917e20755d4f8a31e935d4f394c48ede4395df941dd277a4adaedf9501e995568f75001dfb9154a443ad8ab547da96412bc2cc97465ba4a1d636a77da348df9276ba818c3cd273a33ee985d688d30d69d7156e14916e8de230d65a5b9cee8c22fd028dfd91c05409ab08549374611407b9d42a387d328af459abe4746514e99cd40b645375491f8c62bf8f5a5d4e6746914e49fdb64c2f12e94fad3eeb049a9e7485eb7baf3566bd23a5b31ce3c4fe808aa813e3fa8ea02af263ec68ac35603d85c642ffea147494a6b80ab156c17a422a9afb34d22a631ca4d41ab19e5a058767157ce52a22a6322bb51debc95a69830b5445cc5466a5b6633d592b6df0fba962cc5466a5b6633d592b6df003b60afe4156c15ff810938c5ca9f4a16c93228509714b39c43423572a7d28dbb4486142dce2521e8acce78f9a3983da3c5f6152a7b17a8afdb042cb1c33cef6e0760d160ccbd290243a5824cb65be6cf449b35a9961cf29694752985383470fd86c36db941d581bb84a6cd6eb7cd9e82ea3d4b11fbacb83e7668173f07705a58b14aeec4378aeab3032ad16356dc753be17863d260cc34ba26f2a3daa6429d337a50c1a13f6fb61a99a178cc5aa63301c0e98a1fe3434952c435533a8e04094efc02ae8a55c8117b7578fc732cc2a58075a050b51ab60256c15acccad825703abfcdfe3bfb3c75babe045d52a78ddb34afdf7ebda1f4394dd1e + + + 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 + + + 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 + + + + + KbfxURLRequesterHover + urlSelected(const QString&) + KbfxConfigDlgButton + KbfxURLRequesterHoverUrlSelected(const QString&) + + + KbfxURLRequesterPressed + urlSelected(const QString&) + KbfxConfigDlgButton + KbfxURLRequesterPressedUrlSelected(const QString&) + + + KbfxURLRequesterNormal + urlSelected(const QString&) + KbfxConfigDlgButton + KbfxURLRequesterNormalUrlSelected(const QString&) + + + KbfxURLRequesterHover + returnPressed(const QString&) + KbfxConfigDlgButton + KbfxURLRequesterHoverUrlSelected(const QString&) + + + KbfxURLRequesterPressed + returnPressed(const QString&) + KbfxConfigDlgButton + KbfxURLRequesterPressedUrlSelected(const QString&) + + + KbfxURLRequesterNormal + returnPressed(const QString&) + KbfxConfigDlgButton + KbfxURLRequesterNormalUrlSelected(const QString&) + + + KbfxButton + toggled(bool) + KbfxConfigDlgButton + KbfxButtonToggled(bool) + + + KbfxPixmapLabelHover + targetDrop(const QString&) + KbfxConfigDlgButton + KbfxURLRequesterHoverUrlSelected(const QString&) + + + KbfxPixmapLabelNormal + targetDrop(const QString&) + KbfxConfigDlgButton + KbfxURLRequesterNormalUrlSelected(const QString&) + + + KbfxPixmapLabelPressed + targetDrop(const QString&) + KbfxConfigDlgButton + KbfxURLRequesterPressedUrlSelected(const QString&) + + + KbfxResizeKicker + toggled(bool) + KbfxConfigDlgButton + KbfxResizeKickerToggled(bool) + + + KbfxFadeButton + toggled(bool) + KbfxConfigDlgButton + KbfxFadeButton_toggled(bool) + + + KbfxFadeTime + lostFocus() + KbfxConfigDlgButton + KbfxFadeTime_lostFocus() + + + KbfxFadeTime + returnPressed() + KbfxConfigDlgButton + KbfxFadeTime_lostFocus() + + + + KbfxURLRequesterNormal + KbfxURLRequesterPressed + KbfxURLRequesterHover + KbfxFadeButton + KbfxFadeTime + KbfxResizeKicker + + + kmessagebox.h + kbfxpushbutton.h + qstring.h + qpainter.h + qimage.h + kbfxpixmaplabel.h + kbfxconfigdlgbutton.ui.h + + + KbfxConfigDlgButtonChanged(const char * name, const QString & path) + + + KbfxURLRequesterNormalUrlSelected( const QString & selected_img_path ) + KbfxURLRequesterPressedUrlSelected( const QString & selected_img_path ) + KbfxURLRequesterHoverUrlSelected( const QString & selected_img_path ) + KbfxButtonToggled( bool ) + ChangeForm( const char * name, const QString & path ) + ChangeForm() + KbfxResizeKickerToggled( bool ) + KbfxFadeButton_toggled( bool _state ) + KbfxFadeTime_lostFocus() + + + init() + + + + kurlrequester.h + klineedit.h + kpushbutton.h + kbfxpixmaplabel.h + kurlrequester.h + klineedit.h + kpushbutton.h + kbfxpixmaplabel.h + kurlrequester.h + klineedit.h + kpushbutton.h + kbfxpixmaplabel.h + kactivelabel.h + kactivelabel.h + kbfxpushbutton.h + + diff --git a/configdialog/kbfxconfigdlgbutton.ui.h b/configdialog/kbfxconfigdlgbutton.ui.h new file mode 100644 index 0000000..015b860 --- /dev/null +++ b/configdialog/kbfxconfigdlgbutton.ui.h @@ -0,0 +1,183 @@ +/**************************************************************************** +** ui.h extension file, included from the uic-generated form implementation. +** +** If you want to add, delete, or rename functions or slots, use +** Qt Designer to update this file, preserving your code. +** +** You should not define a constructor or destructor in this file. +** Instead, write your code in functions called init() and destroy(). +** These will automatically be called by the form's constructor and +** destructor. +*****************************************************************************/ + +void KbfxConfigDlgButton::init() +{ + connect ( this, SIGNAL ( KbfxConfigDlgButtonChanged ( const char *, const QString & ) ), + this, SLOT ( ChangeForm ( const char *, const QString & ) ) ); +} + +/* actions performed when url is selected */ +void KbfxConfigDlgButton::KbfxURLRequesterNormalUrlSelected ( const QString &selected_img_path ) +{ + emit KbfxConfigDlgButtonChanged ( "normal", selected_img_path ); +} + +void KbfxConfigDlgButton::KbfxURLRequesterPressedUrlSelected ( const QString &selected_img_path ) +{ + emit KbfxConfigDlgButtonChanged ( "pressed", selected_img_path ); +} + +void KbfxConfigDlgButton::KbfxURLRequesterHoverUrlSelected ( const QString &selected_img_path ) +{ + emit KbfxConfigDlgButtonChanged ( "hover", selected_img_path ); +} + +void KbfxConfigDlgButton::KbfxButtonToggled ( bool ) +{ + if ( KbfxButton->state() == 2 ) + KbfxButton->setPixmap ( ConfigInit().m_KbfxPressedButtonPath ); + + if ( KbfxButton->state() == 0 ) + KbfxButton->setPixmap ( ConfigInit().m_KbfxNormalButtonPath ); +} + +/* url processing */ +void KbfxConfigDlgButton::ChangeForm ( const char *name, const QString &path ) +{ + kdDebug() << "Received: " << name << " + " << path << endl; + + QString tmppath = path; + if ( tmppath.startsWith ( "file://" ) ) tmppath.remove ( "file://" ); + + QImage tmp ( tmppath ); + + QString tmpname = name; + if ( tmpname == "pressed" ) + { + if ( tmp.isNull() ) + { + KMessageBox::error ( 0, + tr2i18n ( "

Image cannot be used as a pressed button skin!

" + "

Will use default pressed button skin.

" ), + tr2i18n ( "Error loading image" ) ); + tmppath = ConfigInit().m_KbfxPressedButtonPathDefault; + } + + kdDebug() << tmpname << " :: " << tmppath << endl; + + KbfxURLRequesterPressed->setURL ( tmppath ); + KbfxPixmapLabelPressed->setPixmap ( tmppath ); + ConfigInit().m_KbfxPressedButtonPath = tmppath; + + if ( KbfxButton->state() == 2 ) + KbfxButton->setPixmap ( ConfigInit().m_KbfxPressedButtonPath ); + } + + if ( tmpname == "normal" ) + { + if ( tmp.isNull() ) + { + KMessageBox::error ( 0, + tr2i18n ( "

Image cannot be used as a normal button skin!

" + "

Will use default normal button skin.

" ), + tr2i18n ( "Error loading image" ) ); + tmppath = ConfigInit().m_KbfxNormalButtonPathDefault; + } + + kdDebug() << tmpname << " :: " << tmppath << endl; + + KbfxURLRequesterNormal->setURL ( tmppath ); + KbfxPixmapLabelNormal->setPixmap ( tmppath ); + ConfigInit().m_KbfxNormalButtonPath = tmppath; + + if ( KbfxButton->state() == 0 ) + KbfxButton->setPixmap ( ConfigInit().m_KbfxNormalButtonPath ); + } + + if ( tmpname == "hover" ) + { + if ( tmp.isNull() ) + { + KMessageBox::error ( 0, + tr2i18n ( "

Image cannot be used as a hover button skin!

" + "

Will use default hover button skin.

" ), + tr2i18n ( "Error loading image" ) ); + tmppath = ConfigInit().m_KbfxHoverButtonPathDefault; + } + + kdDebug() << tmpname << " :: " << tmppath << endl; + + KbfxURLRequesterHover->setURL ( tmppath ); + KbfxPixmapLabelHover->setPixmap ( tmppath ); + ConfigInit().m_KbfxHoverButtonPath = tmppath; + } +} + +/* initialize Button page at the beginning or after "Default" pressed */ +void KbfxConfigDlgButton::ChangeForm() +{ + KbfxURLRequesterNormal->setURL ( ConfigInit().m_KbfxNormalButtonPath ); + KbfxURLRequesterPressed->setURL ( ConfigInit().m_KbfxPressedButtonPath ); + KbfxURLRequesterHover->setURL ( ConfigInit().m_KbfxHoverButtonPath ); + KbfxPixmapLabelNormal->setPixmap ( ConfigInit().m_KbfxNormalButtonPath ); + KbfxPixmapLabelPressed->setPixmap ( ConfigInit().m_KbfxPressedButtonPath ); + KbfxPixmapLabelHover->setPixmap ( ConfigInit().m_KbfxHoverButtonPath ); + KbfxButtonToggled ( 1 ); + + if ( ConfigInit().m_fadeTime == 0 ) + KbfxFadeButton->setChecked ( FALSE ); + else + KbfxFadeButton->setChecked ( TRUE ); + if ( ConfigInit().m_ToolBarResize == TRUE && KbfxResizeKicker->state() == 0 ) + KbfxResizeKicker->toggle(); + if ( ConfigInit().m_ToolBarResize == FALSE && KbfxResizeKicker->state() == 2 ) + KbfxResizeKicker->toggle(); + + KbfxFadeTime->setText ( QString::number ( ConfigInit().m_fadeTime ) ); +} + + +void KbfxConfigDlgButton::KbfxResizeKickerToggled ( bool ) +{ + if ( KbfxResizeKicker->state() == 2 ) + { + KbfxResizeKicker->setText ( tr2i18n ( "Panel Resize is 'ON'" ) ); + ConfigInit().m_ToolBarResize = TRUE; + } + + if ( KbfxResizeKicker->state() == 0 ) + { + KbfxResizeKicker->setText ( tr2i18n ( "Panel Resize is 'OFF'" ) ); + ConfigInit().m_ToolBarResize = FALSE; + } + + kdDebug() << "Panel Resize is: " + << ConfigInit().m_ToolBarResize + << endl; + +} + + + +void KbfxConfigDlgButton::KbfxFadeButton_toggled( bool _state ) +{ + if ( _state ) + { + KbfxFadeTime->setText ( QString::number ( ConfigInit().m_fadeTimeDefault ) ); + ConfigInit().m_fadeTime = ConfigInit().m_fadeTimeDefault; + } + else + { + ConfigInit().m_fadeTime = 0; + } +} + + +void KbfxConfigDlgButton::KbfxFadeTime_lostFocus() +{ + int _value = ( KbfxFadeTime->text () ).toInt(); + ConfigInit().m_fadeTime = _value; + ConfigInit().checkValues(); + + KbfxFadeTime->setText ( QString::number ( ConfigInit().m_fadeTime ) ); +} diff --git a/configdialog/kbfxconfigdlgfonts-old.ui b/configdialog/kbfxconfigdlgfonts-old.ui new file mode 100644 index 0000000..e76071f --- /dev/null +++ b/configdialog/kbfxconfigdlgfonts-old.ui @@ -0,0 +1,1193 @@ + +KbfxConfigDlgFonts + + + KbfxConfigDlgFonts + + + + 0 + 0 + 676 + 497 + + + + + 1 + 1 + 0 + 0 + + + + KBFX Control Center + + + TabFocus + + + + unnamed + + + 0 + + + 10 + + + Minimum + + + + kActiveLabel37 + + + + 3 + 0 + 0 + 0 + + + + + 0 + 29 + + + + + 32767 + 29 + + + + + 255 + 255 + 255 + + + + image0 + + + NoFocus + + + AutoText + + + <b><h3><p align="center">Font options</p></h3></b> + + + + + layout14 + + + + unnamed + + + + spacer3 + + + Horizontal + + + Expanding + + + + 436 + 1 + + + + + + KbfxExportFile + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + EXPORT KBFXFONTRC FILE + + + Export the kbfxfontrc file to a folder + + + + + + + groupBox43 + + + + 1 + 1 + 0 + 0 + + + + NoFocus + + + StyledPanel + + + Setup fonts for your KBFX + + + + unnamed + + + + spacer6_2 + + + Vertical + + + MinimumExpanding + + + + 16 + 1 + + + + + + layout17 + + + + unnamed + + + + layout15 + + + + unnamed + + + + spacer7 + + + Vertical + + + MinimumExpanding + + + + 1 + 1 + + + + + + layout22 + + + + unnamed + + + 0 + + + 0 + + + + kActiveLabel41 + + + + 7 + 1 + 0 + 0 + + + + NoFocus + + + Application "LINE": + + + + + KbfxLineColor + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + Horizontal line color in the application area. + + + + + + + layout21 + + + + unnamed + + + 0 + + + 0 + + + + kActiveLabel39 + + + + 7 + 1 + 0 + 0 + + + + NoFocus + + + Application text : + + + + + KbfxApplicationColor + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + Select the color of the "application" in the menu. + + + + + + + layout20 + + + + unnamed + + + 0 + + + 0 + + + + kActiveLabel40 + + + + 7 + 1 + 0 + 0 + + + + NoFocus + + + Comment text: + + + + + KbfxCommentColor + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + Color of the "comments" in the menu. + + + + + + + layout19 + + + + unnamed + + + 0 + + + 0 + + + + kActiveLabel43 + + + + 7 + 1 + 0 + 0 + + + + NoFocus + + + Name display: + + + + + KbfxNameColor + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + The color of your login name in the menu. + + + + + + + layout23 + + + + unnamed + + + + kActiveLabel42 + + + + 7 + 1 + 0 + 0 + + + + NoFocus + + + Category text: + + + + + KbfxCategoryColor + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + Font color of the categoris in the menu. + + + + + + + layout17 + + + + unnamed + + + 1 + + + 0 + + + + kActiveLabel43_2 + + + + 7 + 1 + 0 + 0 + + + + NoFocus + + + Separator: + + + + + KbfxSeparatorColor + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + The color of the separator in the menu. + + + + + + + layout18 + + + + unnamed + + + 0 + + + 0 + + + + kActiveLabel43_2_2 + + + + 7 + 1 + 0 + 0 + + + + NoFocus + + + Plugin: + + + + + KbfxPluginColor + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + The color of the plugin in the menu. + + + + + + + layout18_2 + + + + unnamed + + + 0 + + + 0 + + + + kActiveLabel43_2_2_2 + + + + 7 + 1 + 0 + 0 + + + + NoFocus + + + Tooltip: + + + + + KbfxTooltipColor + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + The color of the tooltip in the menu. + + + + + + + + + line2 + + + VLine + + + Sunken + + + Vertical + + + + + layout16 + + + + unnamed + + + + spacer6_3 + + + Vertical + + + MinimumExpanding + + + + 22 + 1 + + + + + + KbfxFont_app + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + Select font for the application's text + + + + + KbfxFont_comment + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + Select font for the comment's text + + + + + KbfxFont_username + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + Select font for the username's text + + + + + KbfxFont_category + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + Select font for the category's text + + + + + KbfxFont_separator + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + Select font for the separator's text + + + + + KbfxFont_plugin + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + Select font for the plugins' text + + + + + KbfxFont_tooltip + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + Select font for the tooltip's text + + + + + + + + + spacer2_2 + + + Vertical + + + Minimum + + + + 16 + 1 + + + + + + line1 + + + HLine + + + Sunken + + + Horizontal + + + + + layout15 + + + + unnamed + + + 0 + + + 0 + + + + kActiveLabel44 + + + + 1 + 1 + 0 + 0 + + + + + 32767 + 32767 + + + + NoFocus + + + Manual + + + Theme that is edited: + + + + + KbfxTheme + + + + 7 + 1 + 0 + 0 + + + + + 32767 + 32767 + + + + + 69 + 162 + 225 + + + + NoFocus + + + 1 + + + -1 + + + 0 + + + <p align="left"><b>default</b></p> + + + Please select the theme you want to edit + + + + + KbfxBoldHover + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + Bold fonts on hover + + + Make fonts bolder when you hover the mouse over an item + + + Make fonts bolder when you hover the mouse over an item + + + + + + + spacer2_2_2_2 + + + Vertical + + + Minimum + + + + 16 + 1 + + + + + + + + + + KBFXFontChooser +
kbfxfontchooser.h
+ + -1 + -1 + + 0 + + 1 + 0 + 0 + 0 + + image1 + FontChanged() + setFont(const QFont& font) + buttonClicked() + buttonClicked() + font + + + + + 789ced974b6fda401446f7fc0a8bec5095601eb64755174d7080a669d3b48b4a5517e33134a1101230e151f5bfd7f7bbc3f8510bb29a45d5b331e77e77c6c6067b7cd670bede5c3b8db3da3291c9bd72d49d5c388d78359b6dbf7d7ff3ab5677dda6d3124e2770dcfaab5afdd651ce4953785d11937e822acf63bd81c67bfd0c1d793eeb47ad8118917e20755d4f8a31e935d4f394c48ede4395df941dd277a4adaedf9501e995568f75001dfb9154a443ad8ab547da96412bc2cc97465ba4a1d636a77da348df9276ba818c3cd273a33ee985d688d30d69d7156e14916e8de230d65a5b9cee8c22fd028dfd91c05409ab08549374611407b9d42a387d328af459abe4746514e99cd40b645375491f8c62bf8f5a5d4e6746914e49fdb64c2f12e94fad3eeb049a9e7485eb7baf3566bd23a5b31ce3c4fe808aa813e3fa8ea02af263ec68ac35603d85c642ffea147494a6b80ab156c17a422a9afb34d22a631ca4d41ab19e5a058767157ce52a22a6322bb51debc95a69830b5445cc5466a5b6633d592b6df0fba962cc5466a5b6633d592b6df003b60afe4156c15ff810938c5ca9f4a16c93228509714b39c43423572a7d28dbb4486142dce2521e8acce78f9a3983da3c5f6152a7b17a8afdb042cb1c33cef6e0760d160ccbd290243a5824cb65be6cf449b35a9961cf29694752985383470fd86c36db941d581bb84a6cd6eb7cd9e82ea3d4b11fbacb83e7668173f07705a58b14aeec4378aeab3032ad16356dc753be17863d260cc34ba26f2a3daa6429d337a50c1a13f6fb61a99a178cc5aa63301c0e98a1fe3434952c435533a8e04094efc02ae8a55c8117b7578fc732cc2a58075a050b51ab60256c15acccad825703abfcdfe3bfb3c75babe045d52a78ddb34afdf7ebda1f4394dd1e + + + 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 + + + + + KbfxApplicationColor + activated(const QColor&) + KbfxConfigDlgFonts + KbfxApplicationColorSelected(const QColor&) + + + KbfxCommentColor + activated(const QColor&) + KbfxConfigDlgFonts + KbfxCommentColorSelected(const QColor&) + + + KbfxLineColor + activated(const QColor&) + KbfxConfigDlgFonts + KbfxLineColorSelected(const QColor&) + + + KbfxCategoryColor + activated(const QColor&) + KbfxConfigDlgFonts + KbfxCategoryColorSelected(const QColor&) + + + KbfxNameColor + activated(const QColor&) + KbfxConfigDlgFonts + KbfxNameColorSelected(const QColor&) + + + KbfxSeparatorColor + activated(const QColor&) + KbfxConfigDlgFonts + KbfxSeparatorColorSelected(const QColor&) + + + KbfxExportFile + clicked() + KbfxConfigDlgFonts + KbfxExportFileAction() + + + KbfxFont_username + FontChanged() + KbfxConfigDlgFonts + FontChanged() + + + KbfxFont_app + FontChanged() + KbfxConfigDlgFonts + FontChanged() + + + KbfxFont_category + FontChanged() + KbfxConfigDlgFonts + FontChanged() + + + KbfxFont_comment + FontChanged() + KbfxConfigDlgFonts + FontChanged() + + + KbfxBoldHover + toggled(bool) + KbfxConfigDlgFonts + KbfxBoldHover_toggled(bool) + + + KbfxPluginColor + activated(const QColor&) + KbfxConfigDlgFonts + KbfxPluginColorSelected(const QColor&) + + + KbfxFont_separator + FontChanged() + KbfxConfigDlgFonts + FontChanged() + + + KbfxFont_plugin + FontChanged() + KbfxConfigDlgFonts + FontChanged() + + + KbfxTooltipColor + activated(const QColor&) + KbfxConfigDlgFonts + KbfxTooltipColorSelected(const QColor&) + + + KbfxFont_tooltip + FontChanged() + KbfxConfigDlgFonts + FontChanged() + + + + KbfxBoldHover + KbfxLineColor + KbfxApplicationColor + KbfxFont_app + KbfxCommentColor + KbfxFont_comment + KbfxNameColor + KbfxFont_username + KbfxCategoryColor + KbfxFont_category + KbfxSeparatorColor + KbfxFont_separator + KbfxPluginColor + KbfxFont_plugin + KbfxExportFile + groupBox43 + + + kbfxconfig.h + kdebug.h + kbfxthemesdata.h + kstandarddirs.h + kfiledialog.h + kio/netaccess.h + kmessagebox.h + kconfig.h + kbfxfontchooser.h + kbfxconfigdlgfonts-old.ui.h + + + bool KbfxFormReady; + + + ChangeForm() + KbfxApplicationColorSelected( const QColor & color ) + KbfxTooltipColorSelected( const QColor & ) + KbfxCommentColorSelected( const QColor & color ) + KbfxLineColorSelected( const QColor & color ) + KbfxCategoryColorSelected( const QColor & color ) + KbfxNameColorSelected( const QColor & color ) + KbfxSeparatorColorSelected( const QColor & color ) + KbfxPluginColorSelected( const QColor & color ) + KbfxExportFileAction() + FontChanged() + KbfxBoldHover_toggled( bool state ) + + + init() + + + + kactivelabel.h + kactivelabel.h + kcolorcombo.h + kactivelabel.h + kcolorcombo.h + kactivelabel.h + kcolorcombo.h + kactivelabel.h + kcolorcombo.h + kactivelabel.h + kcolorcombo.h + kactivelabel.h + kcolorcombo.h + kactivelabel.h + kcolorcombo.h + kactivelabel.h + kcolorcombo.h + kbfxfontchooser.h + kbfxfontchooser.h + kbfxfontchooser.h + kbfxfontchooser.h + kbfxfontchooser.h + kbfxfontchooser.h + kbfxfontchooser.h + kactivelabel.h + kactivelabel.h + + diff --git a/configdialog/kbfxconfigdlgfonts-old.ui.h b/configdialog/kbfxconfigdlgfonts-old.ui.h new file mode 100644 index 0000000..11ad864 --- /dev/null +++ b/configdialog/kbfxconfigdlgfonts-old.ui.h @@ -0,0 +1,204 @@ +/**************************************************************************** +** ui.h extension file, included from the uic-generated form implementation. +** +** If you want to add, delete, or rename functions or slots, use +** Qt Designer to update this file, preserving your code. +** +** You should not define a constructor or destructor in this file. +** Instead, write your code in functions called init() and destroy(). +** These will automatically be called by the form's constructor and +** destructor. +*****************************************************************************/ + +void KbfxConfigDlgFonts::init() +{ + KbfxFormReady = FALSE; +} + +void KbfxConfigDlgFonts::ChangeForm() +{ + KbfxFormReady = FALSE; + KbfxTheme->setText ( "

" + ConfigInit().m_SpinxThemeName + "

" ); + KbfxBoldHover->setChecked ( ConfigInit().m_fontHoverBold ); + KbfxApplicationColor->setColor ( ConfigInit().m_fontAppNameColor ); + KbfxFont_app->setFont ( ConfigInit().m_fontAppNameFont ); + KbfxCommentColor->setColor ( ConfigInit().m_fontAppCommentColor ); + KbfxFont_comment->setFont ( ConfigInit().m_fontAppCommentFont ); + KbfxLineColor->setColor ( ConfigInit().m_lineColor ); + KbfxCategoryColor->setColor ( ConfigInit().m_fontIndexColor ); + KbfxFont_category->setFont ( ConfigInit().m_fontIndexFont ); + KbfxNameColor->setColor ( ConfigInit().m_userNameColor ); + KbfxFont_username->setFont ( ConfigInit().m_userNameFont ); + KbfxSeparatorColor->setColor ( ConfigInit().m_sepNameColor ); + KbfxFont_separator->setFont ( ConfigInit().m_sepNameFont ); + KbfxPluginColor->setColor ( ConfigInit().m_pluginNameColor ); + KbfxFont_plugin->setFont ( ConfigInit().m_pluginNameFont ); + KbfxTooltipColor->setColor ( ConfigInit().m_fontTooltipColor ); + KbfxFont_tooltip->setFont ( ConfigInit().m_fontTooltipFont ); + KbfxFormReady = TRUE; +} + +void KbfxConfigDlgFonts::KbfxApplicationColorSelected ( const QColor &color ) +{ + ConfigInit().m_fontAppNameColor = color; + + kdDebug() << "Application color: " + << ConfigInit().m_fontAppNameColor + << endl; +} + +void KbfxConfigDlgFonts::KbfxTooltipColorSelected ( const QColor &color ) +{ + ConfigInit().m_fontTooltipColor = color; + + kdDebug() << "Tooltip color: " + << ConfigInit().m_fontTooltipColor + << endl; +} + +void KbfxConfigDlgFonts::KbfxCommentColorSelected ( const QColor &color ) +{ + ConfigInit().m_fontAppCommentColor = color; + + kdDebug() << "Comment color: " + << ConfigInit().m_fontAppCommentColor + << endl; +} + +void KbfxConfigDlgFonts::KbfxLineColorSelected ( const QColor & color ) +{ + ConfigInit().m_lineColor = color; + + kdDebug() << "Line color: " + << ConfigInit().m_lineColor + << endl; +} + +void KbfxConfigDlgFonts::KbfxCategoryColorSelected ( const QColor &color ) +{ + ConfigInit().m_fontIndexColor = color; + + kdDebug() << "Category color: " + << ConfigInit().m_fontIndexColor + << endl; +} + +void KbfxConfigDlgFonts::KbfxNameColorSelected ( const QColor &color ) +{ + ConfigInit().m_userNameColor = color; + + kdDebug() << "User color: " + << ConfigInit().m_userNameColor + << endl; +} + +void KbfxConfigDlgFonts::KbfxSeparatorColorSelected ( const QColor &color ) +{ + ConfigInit().m_sepNameColor = color; + + kdDebug() << "Separator color: " + << ConfigInit().m_sepNameColor + << endl; +} + +void KbfxConfigDlgFonts::KbfxPluginColorSelected( const QColor &color ) +{ + ConfigInit().m_pluginNameColor = color; + + kdDebug() << "Plugin color: " + << ConfigInit().m_pluginNameColor + << endl; +} + +void KbfxConfigDlgFonts::KbfxExportFileAction() +{ + /* + KFileDialog KbfxExportFontRcDialog(QString::null, + "*.*|" + tr2i18n("All files"), + 0, + 0, + TRUE); + KbfxExportFontRcDialog.setOperationMode(KFileDialog::Saving); + KbfxExportFontRcDialog.setCaption(tr2i18n("Select Folder to export kbfxfontrc file")); + KbfxExportFontRcDialog.setMode(KFile::Directory); + + if(!KbfxExportFontRcDialog.exec()) return; + + QString KbfxExportFontRcDialogURL = KbfxExportFontRcDialog.selectedURL().path(); + */ + + QString KbfxExportFontRcDialogURL = KFileDialog::getExistingDirectory ( + QString::null, + 0, + tr2i18n ( "Select folder to export kbfxfontrc file" ) ).append ( "/kbfxfontrc" ); + + if ( KbfxExportFontRcDialogURL == "/kbfxfontrc") return; + + kdDebug() << "Selected export file is: " + << KbfxExportFontRcDialogURL + << endl; + + KConfig *fontconfig = new KConfig ( KbfxExportFontRcDialogURL ); + + fontconfig->setGroup ( "Fonts" ); + fontconfig->writeEntry ( "TooltipText", ConfigInit().m_fontTooltipColor ); + fontconfig->writeEntry ( "TooltipTextFont", ConfigInit().m_fontTooltipFont ); + fontconfig->writeEntry ( "ApplicationText", ConfigInit().m_fontAppNameColor ); + fontconfig->writeEntry ( "ApplicationTextFont", ConfigInit().m_fontAppNameFont ); + fontconfig->writeEntry ( "CommentText", ConfigInit().m_fontAppCommentColor ); + fontconfig->writeEntry ( "CommentTextFont", ConfigInit().m_fontAppCommentFont ); + fontconfig->writeEntry ( "GroupText", ConfigInit().m_fontIndexColor ); + fontconfig->writeEntry ( "GroupTextFont", ConfigInit().m_fontIndexFont ); + fontconfig->writeEntry ( "UserName", ConfigInit().m_userNameColor ); + fontconfig->writeEntry ( "UserNameFont", ConfigInit().m_userNameFont ); + fontconfig->writeEntry ( "SeparatorColor", ConfigInit().m_sepNameColor ); + fontconfig->writeEntry ( "SeparatorFont", ConfigInit().m_sepNameFont ); + fontconfig->writeEntry ( "PluginColor", ConfigInit().m_pluginNameColor ); + fontconfig->writeEntry ( "PluginFont", ConfigInit().m_pluginNameFont ); + fontconfig->writeEntry ( "LineColor", ConfigInit().m_lineColor ); + fontconfig->writeEntry ( "HoverBold", ConfigInit().m_fontHoverBold ); + fontconfig->sync(); + + delete fontconfig; + KMessageBox::information ( 0, + tr2i18n ( "

The Font configuration of the KBFX Theme %1 has been exported successfully!

" ).arg ( ConfigInit().m_SpinxThemeName ), + tr2i18n ( "KBFX Font Export Ready" ) ); +} + + +void KbfxConfigDlgFonts::FontChanged() +{ + if (KbfxFormReady) + { + ConfigInit().m_fontAppNameFont = KbfxFont_app->font(); + ConfigInit().m_fontAppCommentFont = KbfxFont_comment->font(); + ConfigInit().m_fontIndexFont = KbfxFont_category->font(); + ConfigInit().m_userNameFont = KbfxFont_username->font(); + ConfigInit().m_sepNameFont = KbfxFont_separator->font(); + ConfigInit().m_pluginNameFont = KbfxFont_plugin->font(); + ConfigInit().m_fontTooltipFont = KbfxFont_tooltip->font(); + + /* + kdDebug() << "Changed font... " + << endl << ConfigInit().m_fontAppNameFont + << endl << ConfigInit().m_fontAppCommentFont + << endl << ConfigInit().m_fontIndexFont + << endl << ConfigInit().m_userNameFont + << endl << ConfigInit().m_sepNameFont + << endl << ConfigInit().m_pluginNameFont + << endl << ConfigInit().m_fontTooltipFont + << endl; + */ + } +} + + +void KbfxConfigDlgFonts::KbfxBoldHover_toggled( bool state ) +{ + ConfigInit().m_fontHoverBold = state; + kdDebug() << "Bold on hover is: " + << endl << ConfigInit().m_fontHoverBold + << endl; +} + + diff --git a/configdialog/kbfxconfigdlglayout.ui b/configdialog/kbfxconfigdlglayout.ui new file mode 100644 index 0000000..f759df9 --- /dev/null +++ b/configdialog/kbfxconfigdlglayout.ui @@ -0,0 +1,1084 @@ + +KbfxConfigDlgLayout + + + KbfxConfigDlgLayout + + + + 0 + 0 + 667 + 369 + + + + + 1 + 1 + 0 + 0 + + + + KBFX Control Center + + + TabFocus + + + + unnamed + + + 0 + + + 10 + + + Minimum + + + + kActiveLabel37 + + + + 3 + 0 + 0 + 0 + + + + + 0 + 29 + + + + + 32767 + 29 + + + + + 255 + 255 + 255 + + + + image0 + + + NoFocus + + + AutoText + + + <b><h3><p align="center">Layout options</p></h3></b> + + + + + layout14_2 + + + + unnamed + + + + spacer3 + + + Horizontal + + + Expanding + + + + 408 + 1 + + + + + + KbfxExportFile + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + EXPORT KBFXLAYOUTRC FILE + + + Export the kbfxlayoutrc file to a folder + + + + + + + groupBox43 + + + + 1 + 1 + 0 + 0 + + + + NoFocus + + + StyledPanel + + + Setup fonts for your KBFX + + + + unnamed + + + + spacer12_2 + + + Vertical + + + Minimum + + + + 23 + 1 + + + + + + layout30 + + + + unnamed + + + 0 + + + 0 + + + + kActiveLabel44 + + + + 1 + 1 + 0 + 0 + + + + NoFocus + + + Manual + + + Theme that is edited: + + + + + KbfxTheme + + + + 7 + 1 + 0 + 0 + + + + + 69 + 162 + 225 + + + + NoFocus + + + 1 + + + -1 + + + 0 + + + <p align="left"><b>default</b></p> + + + Please select the theme you want to edit + + + + + KbfxLayoutProperty + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + Select the Layout property to change + + + + + + + spacer9_3_2 + + + Vertical + + + Minimum + + + + 16 + 1 + + + + + + layout17 + + + + unnamed + + + + spacer7_2 + + + Horizontal + + + Expanding + + + + 1 + 1 + + + + + + Kbfx2PanelsLeft + + + + 1 + 1 + 0 + 0 + + + + Make it 2 panels (Left "ON") + + + + + Kbfx2PanelsRight + + + + 1 + 1 + 0 + 0 + + + + Make it 2 panels (Right "ON") + + + + + Kbfx3Panels + + + + 1 + 1 + 0 + 0 + + + + Make it 3 panels + + + + + spacer7 + + + Horizontal + + + Expanding + + + + 1 + 1 + + + + + + + + spacer9_3 + + + Vertical + + + MinimumExpanding + + + + 16 + 1 + + + + + + layout33 + + + + unnamed + + + + layout28 + + + + unnamed + + + 0 + + + 0 + + + + layout21 + + + + unnamed + + + 0 + + + 0 + + + + layout16 + + + + unnamed + + + 0 + + + 0 + + + + textLabel1 + + + + 7 + 1 + 0 + 0 + + + + textLabel1 + + + + + lineEdit1 + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + StyledPanel + + + AlignHCenter + + + + + + + layout16_2 + + + + unnamed + + + 0 + + + 0 + + + + textLabel2 + + + + 7 + 1 + 0 + 0 + + + + textLabel2 + + + + + lineEdit2 + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + StyledPanel + + + AlignHCenter + + + + + + + layout16_3 + + + + unnamed + + + 0 + + + 0 + + + + textLabel3 + + + + 7 + 1 + 0 + 0 + + + + textLabel3 + + + + + lineEdit3 + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + StyledPanel + + + AlignHCenter + + + + + + + layout16_4 + + + + unnamed + + + 0 + + + 0 + + + + textLabel4 + + + + 7 + 1 + 0 + 0 + + + + textLabel4 + + + + + lineEdit4 + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + StyledPanel + + + AlignHCenter + + + + + + + + + checkBox1 + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + checkBox1 + + + + + + + line3 + + + + 9 + + + + VLine + + + Sunken + + + Vertical + + + + + layout29 + + + + unnamed + + + 0 + + + 0 + + + + layout21_2 + + + + unnamed + + + 0 + + + 0 + + + + layout16_5 + + + + unnamed + + + 0 + + + 0 + + + + textLabel5 + + + + 7 + 1 + 0 + 0 + + + + textLabel5 + + + + + lineEdit5 + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + StyledPanel + + + AlignHCenter + + + + + + + layout16_2_2 + + + + unnamed + + + 0 + + + 0 + + + + textLabel6 + + + + 7 + 1 + 0 + 0 + + + + textLabel6 + + + + + lineEdit6 + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + StyledPanel + + + AlignHCenter + + + + + + + layout16_3_2 + + + + unnamed + + + 0 + + + 0 + + + + textLabel7 + + + + 7 + 1 + 0 + 0 + + + + textLabel7 + + + + + lineEdit7 + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + StyledPanel + + + AlignHCenter + + + + + + + layout16_4_2 + + + + unnamed + + + 0 + + + 0 + + + + textLabel8 + + + + 7 + 1 + 0 + 0 + + + + textLabel8 + + + + + lineEdit8 + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + StyledPanel + + + AlignHCenter + + + + + + + + + checkBox2 + + + + 7 + 1 + 0 + 0 + + + + WheelFocus + + + checkBox2 + + + + + + + + + spacer12_3 + + + Vertical + + + Minimum + + + + 23 + 1 + + + + + + line1 + + + HLine + + + Sunken + + + Horizontal + + + + + + + + + + + 789ced974b6fda401446f7fc0a8bec5095601eb64755174d7080a669d3b48b4a5517e33134a1101230e151f5bfd7f7bbc3f8510bb29a45d5b331e77e77c6c6067b7cd670bede5c3b8db3da3291c9bd72d49d5c388d78359b6dbf7d7ff3ab5677dda6d3124e2770dcfaab5afdd651ce4953785d11937e822acf63bd81c67bfd0c1d793eeb47ad8118917e20755d4f8a31e935d4f394c48ede4395df941dd277a4adaedf9501e995568f75001dfb9154a443ad8ab547da96412bc2cc97465ba4a1d636a77da348df9276ba818c3cd273a33ee985d688d30d69d7156e14916e8de230d65a5b9cee8c22fd028dfd91c05409ab08549374611407b9d42a387d328af459abe4746514e99cd40b645375491f8c62bf8f5a5d4e6746914e49fdb64c2f12e94fad3eeb049a9e7485eb7baf3566bd23a5b31ce3c4fe808aa813e3fa8ea02af263ec68ac35603d85c642ffea147494a6b80ab156c17a422a9afb34d22a631ca4d41ab19e5a058767157ce52a22a6322bb51debc95a69830b5445cc5466a5b6633d592b6df0fba962cc5466a5b6633d592b6df003b60afe4156c15ff810938c5ca9f4a16c93228509714b39c43423572a7d28dbb4486142dce2521e8acce78f9a3983da3c5f6152a7b17a8afdb042cb1c33cef6e0760d160ccbd290243a5824cb65be6cf449b35a9961cf29694752985383470fd86c36db941d581bb84a6cd6eb7cd9e82ea3d4b11fbacb83e7668173f07705a58b14aeec4378aeab3032ad16356dc753be17863d260cc34ba26f2a3daa6429d337a50c1a13f6fb61a99a178cc5aa63301c0e98a1fe3434952c435533a8e04094efc02ae8a55c8117b7578fc732cc2a58075a050b51ab60256c15acccad825703abfcdfe3bfb3c75babe045d52a78ddb34afdf7ebda1f4394dd1e + + + + + KbfxLayoutProperty + activated(int) + KbfxConfigDlgLayout + KbfxLayoutProperty_activated(int) + + + KbfxExportFile + clicked() + KbfxConfigDlgLayout + KbfxExportFileAction() + + + Kbfx2PanelsLeft + clicked() + KbfxConfigDlgLayout + Kbfx2PanelsLeft_clicked() + + + Kbfx2PanelsRight + clicked() + KbfxConfigDlgLayout + Kbfx2PanelsRight_clicked() + + + Kbfx3Panels + clicked() + KbfxConfigDlgLayout + Kbfx3Panels_clicked() + + + + KbfxLayoutProperty + lineEdit1 + lineEdit5 + lineEdit2 + lineEdit6 + lineEdit3 + lineEdit7 + lineEdit4 + lineEdit8 + checkBox1 + checkBox2 + KbfxExportFile + + + kbfxthemesdata.h + kbfxconfig.h + kdebug.h + qstringlist.h + kstandarddirs.h + kmessagebox.h + kfiledialog.h + kbfxconfigdlglayout.ui.h + + + int previous_state; + + + ChangeForm() + KbfxLayoutProperty_activated( int index ) + KbfxExportFileAction() + LayoutFormLeft() + Kbfx2PanelsLeft_clicked() + Kbfx2PanelsRight_clicked() + Kbfx3Panels_clicked() + + + init() + KbfxShowAll() + KbfxMakePanel(int) + KbfxMessage() + + + + kactivelabel.h + kactivelabel.h + kactivelabel.h + kcombobox.h + + diff --git a/configdialog/kbfxconfigdlglayout.ui.h b/configdialog/kbfxconfigdlglayout.ui.h new file mode 100644 index 0000000..0ce4a70 --- /dev/null +++ b/configdialog/kbfxconfigdlglayout.ui.h @@ -0,0 +1,641 @@ +/**************************************************************************** +** ui.h extension file, included from the uic-generated form implementation. +** +** If you want to add, delete, or rename functions or slots, use +** Qt Designer to update this file, preserving your code. +** +** You should not define a constructor or destructor in this file. +** Instead, write your code in functions called init() and destroy(). +** These will automatically be called by the form's constructor and +** destructor. +*****************************************************************************/ + +void KbfxConfigDlgLayout::init() +{ + KbfxLayoutProperty->clear(); + KbfxLayoutProperty->insertItem ( tr2i18n ( "User Properties" ) ); // index = 0 + KbfxLayoutProperty->insertItem ( tr2i18n ( "* Top Bar Properties" ) ); // index = 1 + KbfxLayoutProperty->insertItem ( tr2i18n ( "* Bottom Bar Properties" ) ); // index = 2 +// KbfxLayoutProperty->insertItem ( tr2i18n ( "Scroll Bar Properties" ) ); // index = 3 + KbfxLayoutProperty->insertItem ( tr2i18n ( "* List Box Properties" ) ); // index = 4 + KbfxLayoutProperty->insertItem ( tr2i18n ( "Search Box Properties" ) ); // index = 5 + KbfxLayoutProperty->insertItem ( tr2i18n ( "* Item Properties" ) ); // index = 6 +// KbfxLayoutProperty->insertItem ( tr2i18n ( "Tool Bar Properties" ) ); // index = 7 + KbfxLayoutProperty->insertItem ( tr2i18n ( "* Main Menu Properties" ) ); // index = 8 +} + +void KbfxConfigDlgLayout::ChangeForm() +{ + KbfxTheme->setText ( "

" + ConfigInit().m_SpinxThemeName + "

" ); + KbfxLayoutProperty->setCurrentItem ( 0 ); + previous_state = -1; + KbfxLayoutProperty_activated ( 0 ); +} + +void KbfxConfigDlgLayout::KbfxLayoutProperty_activated( int index ) +{ + switch ( previous_state ) + { + case 0: /* User Properties */ + { + ConfigInit().m_facePos_x = ( lineEdit1->text () ).toInt(); + ConfigInit().m_facePos_y = ( lineEdit2->text () ).toInt(); + ConfigInit().m_userNamePos_x = ( lineEdit3->text () ).toInt(); + ConfigInit().m_userNamePos_y = ( lineEdit4->text () ).toInt(); + ConfigInit().m_faceIconX = ( lineEdit5->text () ).toInt(); + ConfigInit().m_faceIconY = ( lineEdit6->text () ).toInt(); + ConfigInit().m_faceIconH = ( lineEdit7->text () ).toInt(); + ConfigInit().m_faceIconW = ( lineEdit8->text () ).toInt(); + ConfigInit().m_faceBoxHideText = checkBox1->isChecked (); + kdDebug() << "User Properties VALUES: " + << endl << ConfigInit().m_facePos_x + << endl << ConfigInit().m_facePos_y + << endl << ConfigInit().m_userNamePos_x + << endl << ConfigInit().m_userNamePos_y + << endl << ConfigInit().m_faceIconX + << endl << ConfigInit().m_faceIconY + << endl << ConfigInit().m_faceIconH + << endl << ConfigInit().m_faceIconW + << endl << ConfigInit().m_faceBoxHideText + << endl; + break; + } + case 1: /* Top Bar Properties */ + { +/* + ConfigInit().m_topBar_x = ( lineEdit1->text () ).toInt(); + ConfigInit().m_topBar_y = ( lineEdit2->text () ).toInt(); + ConfigInit().m_topBar_h = ( lineEdit5->text () ).toInt(); + ConfigInit().m_topBar_w = ( lineEdit6->text () ).toInt(); +*/ + ConfigInit().m_topBar_h = ( lineEdit1->text () ).toInt(); + ConfigInit().m_topBar_w = ( lineEdit5->text () ).toInt(); + kdDebug() << "Top Bar Properties VALUES: " +// << endl << ConfigInit().m_topBar_x +// << endl << ConfigInit().m_topBar_y + << endl << ConfigInit().m_topBar_h + << endl << ConfigInit().m_topBar_w + << endl; + break; + } + case 2: /* Bottom Bar Properties */ + { +/* + ConfigInit().m_botBar_x = ( lineEdit1->text () ).toInt(); + ConfigInit().m_botBar_y = ( lineEdit2->text () ).toInt(); + ConfigInit().m_botBar_h = ( lineEdit5->text () ).toInt(); + ConfigInit().m_botBar_w = ( lineEdit6->text () ).toInt(); +*/ + ConfigInit().m_botBar_h = ( lineEdit1->text () ).toInt(); + ConfigInit().m_botBar_w = ( lineEdit5->text () ).toInt(); + kdDebug() << "Bottom Bar Properties VALUES: " +// << endl << ConfigInit().m_botBar_x +// << endl << ConfigInit().m_botBar_y + << endl << ConfigInit().m_botBar_h + << endl << ConfigInit().m_botBar_w + << endl; + break; + } + +/* + case 3: // Scroll Bar Properties + { + ConfigInit().m_scrollBarTopX = ( lineEdit1->text () ).toInt(); + ConfigInit().m_scrollBarTopY = ( lineEdit2->text () ).toInt(); + ConfigInit().m_scrollBarBotX = ( lineEdit5->text () ).toInt(); + ConfigInit().m_scrollBarBotY = ( lineEdit6->text () ).toInt(); + kdDebug() << "Scroll Bar Properties VALUES: " + << endl << ConfigInit().m_scrollBarTopX + << endl << ConfigInit().m_scrollBarTopY + << endl << ConfigInit().m_scrollBarBotX + << endl << ConfigInit().m_scrollBarBotY + << endl; + break; + } +*/ + + case 3: /* List Box Properties */ + { + ConfigInit().m_listBox_x = ( lineEdit1->text () ).toInt(); + ConfigInit().m_listBox_y = ( lineEdit2->text () ).toInt(); + ConfigInit().m_listBox_h = ( lineEdit5->text () ).toInt(); + ConfigInit().m_listBox_w = ( lineEdit6->text () ).toInt(); + kdDebug() << "List Box Properties VALUES: " + << endl << ConfigInit().m_listBox_x + << endl << ConfigInit().m_listBox_y + << endl << ConfigInit().m_listBox_h + << endl << ConfigInit().m_listBox_w + << endl; + break; + } + case 4: /* Search Box Properties */ + { + ConfigInit().m_searchBox_x = ( lineEdit1->text () ).toInt(); + ConfigInit().m_searchBox_y = ( lineEdit2->text () ).toInt(); + ConfigInit().m_searchBox_h = ( lineEdit5->text () ).toInt(); + ConfigInit().m_searchBox_w = ( lineEdit6->text () ).toInt(); + kdDebug() << "Search Box Properties VALUES: " + << endl << ConfigInit().m_searchBox_x + << endl << ConfigInit().m_searchBox_y + << endl << ConfigInit().m_searchBox_h + << endl << ConfigInit().m_searchBox_w + << endl; + break; + } + case 5: /* Item Properties */ + { + ConfigInit().m_itemView_x = ( lineEdit1->text () ).toInt(); + ConfigInit().m_itemView_y = ( lineEdit2->text () ).toInt(); + ConfigInit().m_iconSize = ( lineEdit3->text () ).toInt(); + ConfigInit().m_itemView_h = ( lineEdit5->text () ).toInt(); + ConfigInit().m_itemView_w = ( lineEdit6->text () ).toInt(); + ConfigInit().m_commentMargine = ( lineEdit7->text () ).toInt(); + ConfigInit().m_noComments = checkBox1->isChecked (); + kdDebug() << "Item Properties VALUES: " + << endl << ConfigInit().m_itemView_x + << endl << ConfigInit().m_itemView_y + << endl << ConfigInit().m_iconSize + << endl << ConfigInit().m_itemView_h + << endl << ConfigInit().m_itemView_w + << endl << ConfigInit().m_commentMargine + << endl << ConfigInit().m_noComments + << endl; + break; + } +/* + case 6: // Tool Bar Properties + { + ConfigInit().m_toolBarButtonNormalSize = ( lineEdit1->text () ).toInt(); + ConfigInit().m_toolBarButtonExpandSize = ( lineEdit5->text () ).toInt(); + kdDebug() << "Tool Bar Properties VALUES: " + << endl << ConfigInit().m_toolBarButtonNormalSize + << endl << ConfigInit().m_toolBarButtonExpandSize + << endl; + break; + } +*/ + case 6: /* Main Menu Properties */ + { + ConfigInit().m_userMenuHeight = ( lineEdit1->text () ).toInt(); + ConfigInit().m_userMenuWidth = ( lineEdit5->text () ).toInt(); + ConfigInit().m_startHidden = checkBox1->isChecked (); + kdDebug() << "Main Menu Properties VALUES: " + << endl << ConfigInit().m_userMenuHeight + << endl << ConfigInit().m_userMenuWidth + << endl << ConfigInit().m_startHidden + << endl; + break; + } + default: /* default action switch does nothing */ + kdDebug() << "Default action switch for saving layout changed..." << endl; + } + + KbfxShowAll (); + switch ( index ) + { + case 0: /* User Properties */ + { + textLabel1->setText ( tr2i18n ( "Face Position X" ) ); + textLabel2->setText ( tr2i18n ( "Face Position Y" ) ); + textLabel3->setText ( tr2i18n ( "User Name Position X" ) ); + textLabel4->setText ( tr2i18n ( "User Name Position Y" ) ); + textLabel5->setText ( tr2i18n ( "Face Box Position X" ) ); + textLabel6->setText ( tr2i18n ( "Face Box Position Y" ) ); + textLabel7->setText ( tr2i18n ( "Face Box Height" ) ); + textLabel8->setText ( tr2i18n ( "Face Box Width" ) ); + checkBox1->setText ( tr2i18n ( "Hide User Name" ) ); + checkBox2->hide(); + lineEdit1->setText ( QString::number ( ConfigInit().m_facePos_x ) ); + lineEdit2->setText ( QString::number ( ConfigInit().m_facePos_y ) ); + lineEdit3->setText ( QString::number ( ConfigInit().m_userNamePos_x ) ); + lineEdit4->setText ( QString::number ( ConfigInit().m_userNamePos_y ) ); + lineEdit5->setText ( QString::number ( ConfigInit().m_faceIconX ) ); + lineEdit6->setText ( QString::number ( ConfigInit().m_faceIconY ) ); + lineEdit7->setText ( QString::number ( ConfigInit().m_faceIconH ) ); + lineEdit8->setText ( QString::number ( ConfigInit().m_faceIconW ) ); + checkBox1->setChecked ( ConfigInit().m_faceBoxHideText ); + previous_state = 0; + break; + } + case 1: /* Top Bar Properties */ + { +// textLabel1->setText ( tr2i18n ( "Top Bar Position X" ) ); +// textLabel2->setText ( tr2i18n ( "Top Bar Position Y" ) ); + textLabel1->setText ( tr2i18n ( "* Top Bar Height" ) ); + textLabel2->hide(); + textLabel3->hide(); + textLabel4->hide(); +// textLabel5->setText ( tr2i18n ( "Top Bar Height" ) ); +// textLabel6->setText ( tr2i18n ( "Top Bar Width" ) ); + textLabel5->setText ( tr2i18n ( "Top Bar Width" ) ); + textLabel6->hide(); + textLabel7->hide(); + textLabel8->hide(); + checkBox1->hide(); + checkBox2->hide(); +// lineEdit1->setText ( QString::number ( ConfigInit().m_topBar_x ) ); +// lineEdit2->setText ( QString::number ( ConfigInit().m_topBar_y ) ); + lineEdit1->setText ( QString::number ( ConfigInit().m_topBar_h ) ); + lineEdit2->hide(); + lineEdit3->hide(); + lineEdit4->hide(); +// lineEdit5->setText ( QString::number ( ConfigInit().m_topBar_h ) ); +// lineEdit6->setText ( QString::number ( ConfigInit().m_topBar_w ) ); + lineEdit5->setText ( QString::number ( ConfigInit().m_topBar_w ) ); + lineEdit6->hide(); + lineEdit7->hide(); + lineEdit8->hide(); + previous_state = 1; + break; + } + case 2: /* Bottom Bar Properties */ + { +// textLabel1->setText ( tr2i18n ( "Bottom Bar Position X" ) ); +// textLabel2->setText ( tr2i18n ( "Bottom Bar Position Y" ) ); + textLabel1->setText ( tr2i18n ( "* Bottom Bar Height" ) ); + textLabel2->hide(); + textLabel3->hide(); + textLabel4->hide(); +// textLabel5->setText ( tr2i18n ( "Bottom Bar Height" ) ); +// textLabel6->setText ( tr2i18n ( "Bottom Bar Width" ) ); + textLabel5->setText ( tr2i18n ( "Bottom Bar Width" ) ); + textLabel6->hide(); + textLabel7->hide(); + textLabel8->hide(); + checkBox1->hide(); + checkBox2->hide(); +// lineEdit1->setText ( QString::number ( ConfigInit().m_botBar_x ) ); +// lineEdit2->setText ( QString::number ( ConfigInit().m_botBar_y ) ); + lineEdit1->setText ( QString::number ( ConfigInit().m_botBar_h ) ); + lineEdit2->hide(); + lineEdit3->hide(); + lineEdit4->hide(); +// lineEdit5->setText ( QString::number ( ConfigInit().m_botBar_h ) ); +// lineEdit6->setText ( QString::number ( ConfigInit().m_botBar_w ) ); + lineEdit5->setText ( QString::number ( ConfigInit().m_botBar_w ) ); + lineEdit6->hide(); + lineEdit7->hide(); + lineEdit8->hide(); + previous_state = 2; + break; + } + +/* + case 3: // Scroll Bar Properties + { + textLabel1->setText ( tr2i18n ( "Top Scroll Bar Position X" ) ); + textLabel2->setText ( tr2i18n ( "Top Scroll Bar Position Y" ) ); + textLabel3->hide(); + textLabel4->hide(); + textLabel5->setText ( tr2i18n ( "Bottom Scroll Bar Position X" ) ); + textLabel6->setText ( tr2i18n ( "Bottom Scroll Bar Position Y" ) ); + textLabel7->hide(); + textLabel8->hide(); + checkBox1->hide(); + checkBox2->hide(); + lineEdit1->setText ( QString::number ( ConfigInit().m_scrollBarTopX ) ); + lineEdit2->setText ( QString::number ( ConfigInit().m_scrollBarTopY ) ); + lineEdit3->hide(); + lineEdit4->hide(); + lineEdit5->setText ( QString::number ( ConfigInit().m_scrollBarBotX ) ); + lineEdit6->setText ( QString::number ( ConfigInit().m_scrollBarBotY ) ); + lineEdit7->hide(); + lineEdit8->hide(); + previous_state = 3; + break; + } +*/ + + case 3: /* List Box Properties */ + { + textLabel1->setText ( tr2i18n ( "* List Box Position X" ) ); + textLabel2->setText ( tr2i18n ( "* List Box Position Y" ) ); + textLabel3->hide(); + textLabel4->hide(); + textLabel5->setText ( tr2i18n ( "List Box Height" ) ); + textLabel6->setText ( tr2i18n ( "* List Box Width" ) ); + textLabel7->hide(); + textLabel8->hide(); + checkBox1->hide(); + checkBox2->hide(); + lineEdit1->setText ( QString::number ( ConfigInit().m_listBox_x ) ); + lineEdit2->setText ( QString::number ( ConfigInit().m_listBox_y ) ); + lineEdit3->hide(); + lineEdit4->hide(); + lineEdit5->setText ( QString::number ( ConfigInit().m_listBox_h ) ); + lineEdit6->setText ( QString::number ( ConfigInit().m_listBox_w ) ); + lineEdit7->hide(); + lineEdit8->hide(); + previous_state = 3; + break; + } + case 4: /* Search Box Properties */ + { + textLabel1->setText ( tr2i18n ( "Search Box Position X" ) ); + textLabel2->setText ( tr2i18n ( "Search Box Position Y" ) ); + textLabel3->hide(); + textLabel4->hide(); + textLabel5->setText ( tr2i18n ( "Search Box Height" ) ); + textLabel6->setText ( tr2i18n ( "Search Box Width" ) ); + textLabel7->hide(); + textLabel8->hide(); + checkBox1->hide(); + checkBox2->hide(); + lineEdit1->setText ( QString::number ( ConfigInit().m_searchBox_x ) ); + lineEdit2->setText ( QString::number ( ConfigInit().m_searchBox_y ) ); + lineEdit3->hide(); + lineEdit4->hide(); + lineEdit5->setText ( QString::number ( ConfigInit().m_searchBox_h ) ); + lineEdit6->setText ( QString::number ( ConfigInit().m_searchBox_w ) ); + lineEdit7->hide(); + lineEdit8->hide(); + previous_state = 4; + break; + } + case 5: /* Item Properties */ + { + textLabel1->setText ( tr2i18n ( "* Item Position X" ) ); + textLabel2->setText ( tr2i18n ( "* Item Position Y" ) ); + textLabel3->setText ( tr2i18n ( "Icon Size in Item" ) ); + textLabel4->hide(); + textLabel5->setText ( tr2i18n ( "Item Height" ) ); + textLabel6->setText ( tr2i18n ( "* Item Width" ) ); + textLabel7->setText ( tr2i18n ( "Comment Margin in Item" ) ); + textLabel8->hide(); + checkBox1->setText ( tr2i18n ( "No Comments in Item" ) ); + checkBox2->hide(); + lineEdit1->setText ( QString::number ( ConfigInit().m_itemView_x ) ); + lineEdit2->setText ( QString::number ( ConfigInit().m_itemView_y ) ); + lineEdit3->setText ( QString::number ( ConfigInit().m_iconSize ) ); + lineEdit4->hide(); + lineEdit5->setText ( QString::number ( ConfigInit().m_itemView_h ) ); + lineEdit6->setText ( QString::number ( ConfigInit().m_itemView_w ) ); + lineEdit7->setText ( QString::number ( ConfigInit().m_commentMargine ) ); + lineEdit8->hide(); + checkBox1->setChecked ( ConfigInit().m_noComments ); + previous_state = 5; + break; + } +/* + case 6: // Tool Bar Properties + { + textLabel1->setText ( tr2i18n ( "Tool Bar Button Normal Size" ) ); + textLabel2->hide(); + textLabel3->hide(); + textLabel4->hide(); + textLabel5->setText ( tr2i18n ( "Tool Bar Button Pressed Size" ) ); + textLabel6->hide(); + textLabel7->hide(); + textLabel8->hide(); + checkBox1->hide(); + checkBox2->hide(); + lineEdit1->setText ( QString::number ( ConfigInit().m_toolBarButtonNormalSize ) ); + lineEdit2->hide(); + lineEdit3->hide(); + lineEdit4->hide(); + lineEdit5->setText ( QString::number ( ConfigInit().m_toolBarButtonExpandSize ) ); + lineEdit6->hide(); + lineEdit7->hide(); + lineEdit8->hide(); + previous_state = 6; + break; + } +*/ + case 6: /* Main Menu Properties */ + { + textLabel1->setText ( tr2i18n ( "* Main Menu Height" ) ); + textLabel2->hide(); + textLabel3->hide(); + textLabel4->hide(); + textLabel5->setText ( tr2i18n ( "* Main Menu Width" ) ); + textLabel6->hide(); + textLabel7->hide(); + textLabel8->hide(); + checkBox1->setText ( tr2i18n ( "Contracted Menues" ) ); + checkBox2->hide(); + lineEdit1->setText ( QString::number ( ConfigInit().m_userMenuHeight ) ); + lineEdit2->hide(); + lineEdit3->hide(); + lineEdit4->hide(); + lineEdit5->setText ( QString::number ( ConfigInit().m_userMenuWidth ) ); + lineEdit6->hide(); + lineEdit7->hide(); + lineEdit8->hide(); + checkBox1->setChecked ( ConfigInit().m_startHidden ); + previous_state = 6; + break; + } + default: /* default action switch should never be reached */ + kdDebug() << "Default action switch for layout changed..." << endl; + } +} + +void KbfxConfigDlgLayout::KbfxShowAll() +{ + textLabel1->show(); + textLabel2->show(); + textLabel3->show(); + textLabel4->show(); + textLabel5->show(); + textLabel6->show(); + textLabel7->show(); + textLabel8->show(); + checkBox1->show(); + checkBox2->show(); + lineEdit1->show(); + lineEdit2->show(); + lineEdit3->show(); + lineEdit4->show(); + lineEdit5->show(); + lineEdit6->show(); + lineEdit7->show(); + lineEdit8->show(); +} + +void KbfxConfigDlgLayout::KbfxExportFileAction() +{ + QString KbfxExportLayoutRcDialogURL = KFileDialog::getExistingDirectory ( + QString::null, + 0, + tr2i18n ( "Select folder to export kbfxlayoutrc file" ) ).append ( "/kbfxlayoutrc" ); + + if ( KbfxExportLayoutRcDialogURL == "/kbfxlayoutrc") return; + + kdDebug() << "Selected export file is: " + << KbfxExportLayoutRcDialogURL + << endl; + + /* write layout theme configuration file */ + KConfig *layoutconfig = new KConfig ( KbfxExportLayoutRcDialogURL ); + + layoutconfig->setGroup ( "KbfxButton" ); + layoutconfig->writeEntry ( "FadeTime", ConfigInit().m_fadeTime ); + +/* + // No need for this to be exported because it is user/installation specific + layoutconfig->writeEntry ( "Normal", ConfigInit().m_KbfxNormalButtonPath ); + layoutconfig->writeEntry ( "Hover", ConfigInit().m_KbfxHoverButtonPath ); + layoutconfig->writeEntry ( "Press", ConfigInit().m_KbfxPressedButtonPath ); + + layoutconfig->setGroup ( "ToolTip" ); + layoutconfig->writeEntry ( "Avatar", m_ToolTipAvatar ); + layoutconfig->writeEntry ( "Dudebox", m_SpinxTooltipDudebox ); + layoutconfig->writeEntry ( "Mask", m_SpinxTooltipMask ); + layoutconfig->writeEntry ( "Window", m_SpinxTooltipWindow ); + layoutconfig->writeEntry ( "Logo", m_SpinxTooltipLogo ); +*/ + + layoutconfig->setGroup ( "TopBar" ); + layoutconfig->writeEntry ( "DudeX", ConfigInit().m_facePos_x ); + layoutconfig->writeEntry ( "DudeY", ConfigInit().m_facePos_y ); + layoutconfig->writeEntry ( "FaceX", ConfigInit().m_faceIconX ); + layoutconfig->writeEntry ( "FaceY", ConfigInit().m_faceIconY ); + layoutconfig->writeEntry ( "FaceH", ConfigInit().m_faceIconH ); + layoutconfig->writeEntry ( "FaceW", ConfigInit().m_faceIconW ); + layoutconfig->writeEntry ( "UserNameX", ConfigInit().m_userNamePos_x ); + layoutconfig->writeEntry ( "UserNameY", ConfigInit().m_userNamePos_y ); + layoutconfig->writeEntry ( "DisableUserName", ConfigInit().m_faceBoxHideText ); + layoutconfig->writeEntry ( "Height", ConfigInit().m_topBar_h ); + layoutconfig->writeEntry ( "Width", ConfigInit().m_topBar_w ); + layoutconfig->writeEntry ( "X", ConfigInit().m_topBar_x ); + layoutconfig->writeEntry ( "Y", ConfigInit().m_topBar_y ); + + layoutconfig->setGroup ( "BottomBar" ); + layoutconfig->writeEntry ( "Height", ConfigInit().m_botBar_h ); + layoutconfig->writeEntry ( "Width", ConfigInit().m_botBar_w ); + layoutconfig->writeEntry ( "X", ConfigInit().m_botBar_x ); + layoutconfig->writeEntry ( "Y", ConfigInit().m_botBar_y ); + + layoutconfig->setGroup ( "Scrollbars" ); + layoutconfig->writeEntry ( "ScrollBarBotX", ConfigInit().m_scrollBarBotX ); + layoutconfig->writeEntry ( "ScrollBarBotY", ConfigInit().m_scrollBarBotY ); + layoutconfig->writeEntry ( "ScrollBarTopX", ConfigInit().m_scrollBarTopX ); + layoutconfig->writeEntry ( "ScrollBarTopY", ConfigInit().m_scrollBarTopY ); + + layoutconfig->setGroup ( "ListBox" ); + layoutconfig->writeEntry ( "Height", ConfigInit().m_listBox_h ); + layoutconfig->writeEntry ( "Width", ConfigInit().m_listBox_w ); + layoutconfig->writeEntry ( "X", ConfigInit().m_listBox_x ); + layoutconfig->writeEntry ( "Y", ConfigInit().m_listBox_y ); + + layoutconfig->setGroup ( "SearchBox" ); + layoutconfig->writeEntry ( "Height", ConfigInit().m_searchBox_h ); + layoutconfig->writeEntry ( "Width", ConfigInit().m_searchBox_w ); + layoutconfig->writeEntry ( "X", ConfigInit().m_searchBox_x ); + layoutconfig->writeEntry ( "Y", ConfigInit().m_searchBox_y ); + layoutconfig->writeEntry ( "FixedPos", ConfigInit().m_searchBox_static ); + + layoutconfig->setGroup ( "ItemView" ); + layoutconfig->writeEntry ( "Height", ConfigInit().m_itemView_h ); + layoutconfig->writeEntry ( "Width", ConfigInit().m_itemView_w ); + layoutconfig->writeEntry ( "X", ConfigInit().m_itemView_x ); + layoutconfig->writeEntry ( "Y", ConfigInit().m_itemView_y ); + + layoutconfig->setGroup ( "ToolBar" ); + layoutconfig->writeEntry ( "ButtonNormalSize", ConfigInit().m_toolBarButtonNormalSize ); + layoutconfig->writeEntry ( "ButtonPressedSize", ConfigInit().m_toolBarButtonExpandSize ); + + layoutconfig->setGroup ( "MainMenu" ); + layoutconfig->writeEntry ( "UserMenuHeight", ConfigInit().m_userMenuHeight ); + layoutconfig->writeEntry ( "UserMenuWidth", ConfigInit().m_userMenuWidth ); + layoutconfig->writeEntry ( "ContractedMenu", ConfigInit().m_startHidden ); + + layoutconfig->setGroup ( "ItemProperties" ); + layoutconfig->writeEntry ( "NoComments", ConfigInit().m_noComments ); + layoutconfig->writeEntry ( "CommentMargin", ConfigInit().m_commentMargine ); + layoutconfig->writeEntry ( "IconSize", ConfigInit().m_iconSize ); + + layoutconfig->sync(); + + delete layoutconfig; + + KMessageBox::information ( 0, + tr2i18n ( "

The Layout configuration of the KBFX Theme %1 has been exported successfully!

" ).arg ( ConfigInit().m_SpinxThemeName ), + tr2i18n ( "KBFX Layout Export Ready" ) ); +} + +void KbfxConfigDlgLayout::LayoutFormLeft() +{ + KbfxLayoutProperty_activated ( previous_state ); + kdDebug() << "Called Leave form... Previous state is:" << previous_state << endl; +} + +void KbfxConfigDlgLayout::Kbfx2PanelsLeft_clicked() +{ + KbfxMakePanel( 0 ); +} + +void KbfxConfigDlgLayout::Kbfx2PanelsRight_clicked() +{ + KbfxMakePanel( 1 ); +} + +void KbfxConfigDlgLayout::Kbfx3Panels_clicked() +{ + KbfxMakePanel( 2 ); +} + +void KbfxConfigDlgLayout::KbfxMakePanel( int l_type ) +{ + if ( !KbfxMessage() ) + return; + + LayoutFormLeft(); + int mid_h = ConfigInit().m_userMenuHeight - ConfigInit().m_botBar_h - ConfigInit().m_topBar_h; + int mid_w = ConfigInit().m_userMenuWidth; + + ConfigInit().m_topBar_w = mid_w; + ConfigInit().m_botBar_w = mid_w; + ConfigInit().m_listBox_h = mid_h; + ConfigInit().m_listBox_w = mid_w/4; + ConfigInit().m_itemView_h = mid_h; + ConfigInit().m_listBox_y = ConfigInit().m_topBar_h; + ConfigInit().m_itemView_y = ConfigInit().m_topBar_h; + + if ( l_type == 0 ) + { + ConfigInit().m_listBox_x = 0; + ConfigInit().m_itemView_x = ConfigInit().m_listBox_w; + ConfigInit().m_itemView_w = mid_w - ConfigInit().m_listBox_w; + } + + if ( l_type == 1 ) + { + ConfigInit().m_itemView_x = 0; + ConfigInit().m_itemView_w = mid_w - ConfigInit().m_listBox_w; + ConfigInit().m_listBox_x = ConfigInit().m_itemView_w; + } + + if ( l_type == 2 ) + { + ConfigInit().m_listBox_x = 0; + ConfigInit().m_itemView_x = ConfigInit().m_listBox_w; + ConfigInit().m_itemView_w = mid_w/2; + } + + KbfxLayoutProperty->setCurrentItem ( 0 ); + previous_state = -1; + KbfxLayoutProperty_activated ( 0 ); + + KMessageBox::information ( 0, + tr2i18n ( "

The Layout configuration of the KBFX Theme %1 is ready!

Be sure to click the Apply button in order the changes to become active!

" ).arg ( ConfigInit().m_SpinxThemeName ), + tr2i18n ( "KBFX Layout Ready" ) ); +} + +bool KbfxConfigDlgLayout::KbfxMessage() +{ + int messageBoxReturn = KMessageBox::warningContinueCancel ( 0, + tr2i18n ( "

KBFX will calculate the necessary values using the present values for:

" + "

* Main Menu Height and * Main Menu Width
" + "* Bottom Bar Height and * Top Bar Height

" + "

So be sure that you have entered their values as you desire!

" + "

NOTE: Have in mind that the Layout of the theme also depends on the sizes of the images! " + "So if the theme does not look like as you desire either change the images' sizes to smaller width OR change * Main Menu Width to higher value!

" ), + tr2i18n ( "Prepare Layout for the KBFX theme" ), + tr2i18n ( "Prepare" ) ); + + if ( messageBoxReturn == KMessageBox::Cancel ) + return FALSE; + + return TRUE; +} diff --git a/configdialog/kbfxconfigdlgmain.ui b/configdialog/kbfxconfigdlgmain.ui new file mode 100644 index 0000000..c23db41 --- /dev/null +++ b/configdialog/kbfxconfigdlgmain.ui @@ -0,0 +1,670 @@ + +KbfxConfigDlgMain + + + tb_Main + + + true + + + + 0 + 0 + 807 + 618 + + + + + 1 + 1 + 0 + 0 + + + + KBFX Configurator Application + + + image0 + + + true + + + true + + + + unnamed + + + Minimum + + + + layout4 + + + + unnamed + + + + + Start Button + + + image1 + + + + + KBFX Themes + + + image2 + + + + + Fonts + + + image3 + + + + + Menu Style + + + image4 + + + + + Tooltip + + + image5 + + + + + Search Engine + + + image6 + + + + + Plugins + + + image7 + + + + + About KBFX + + + image8 + + + + lb_Main + + + + 1 + 3 + 0 + 0 + + + + + 150 + 265 + + + + + 32767 + 32767 + + + + WheelFocus + + + true + + + LineEditPanel + + + + + KBFXNewsBrowser + + + + 1 + 1 + 0 + 0 + + + + + 150 + 280 + + + + + 32767 + 32767 + + + + + 255 + 255 + 255 + + + + WheelFocus + + + StyledPanel + + + Sunken + + + <br><p align="center"><br><br><br>If you want you can check the latest news for KBFX from here:<br><a href="http://www.kbfx.org/">KBFX News</a></p> + + + + + + + layout12 + + + + unnamed + + + 2 + + + + btn_Help + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + &Help + + + Alt+H + + + false + + + image9 + + + Open Help Documentation + + + + + btn_Default + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + &Default + + + Alt+D + + + false + + + image10 + + + Apply the default configuration for this section only + + + + + spacer15 + + + Horizontal + + + Expanding + + + + 160 + 1 + + + + + + btn_SaveApply + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + &Apply + + + Alt+A + + + false + + + image11 + + + Save the configuration and Apply it + + + + + btn_Exit + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + E&xit + + + Alt+X + + + false + + + image12 + + + Exit the configuration without saving + + + + + + + layout5 + + + + unnamed + + + + layout3 + + + + 7 + 0 + 0 + 0 + + + + + unnamed + + + 0 + + + 0 + + + + frame4 + + + + 7 + 0 + 0 + 0 + + + + + 507 + 100 + + + + + 32767 + 100 + + + + image13 + + + + 9 + + + + NoFrame + + + Plain + + + + unnamed + + + 0 + + + 0 + + + + spacer3 + + + Vertical + + + Minimum + + + + 61 + 25 + + + + + + spacer6 + + + Horizontal + + + Minimum + + + + 16 + 16 + + + + + + spacer7 + + + Vertical + + + Expanding + + + + 56 + 7 + + + + + + KbfxLogoText + + + + 3 + 3 + 0 + 0 + + + + ParentOrigin + + + <font size="+2"><b>Kbfx start button</b><br></font> + + + RichText + + + + + + + frame3 + + + + 0 + 0 + 0 + 0 + + + + + 114 + 100 + + + + + 114 + 100 + + + + image14 + + + NoFrame + + + Plain + + + + + + + ws_Main + + + + 1 + 1 + 0 + 0 + + + + + 32767 + 32767 + + + + true + + + WheelFocus + + + true + + + NoFrame + + + + + + + + + + + 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 + + + 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 + + + 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 + + + 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 + + + 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 + + + 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 + + + 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 + + + 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 + + + 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 + + + 89504e470d0a1a0a0000000d49484452000000100000001008060000001ff3ff610000035949444154388d25d3d96b1c7500c0f1ef6f76f6989d3d32e96eb63647a54de2d1568d91d29a10a9a1476ab15044d4fae69b4602fe0de2832f0ae2f522d5070b82078ae08b8514c516dbc4580335246912499a3db2c7eccccecef19bf1a1ffc0e7ed2338f6110084021c4f23264ee50ac6ecc0c1d249c3c8ea5246d46b96737f7de74e7bb7f23141f8b3506266d4f5400854008400d71fd28cdc07a7cf3f7d69fab951d2199db61de274c10f95f86ec59ef8ebd6eac49df99bbfdadbbbb320ee02c4289e07c71b2a0c96be7d7b6e66faa50bc3742c497973878174179c162b6b15841ae7a183fd64070e1fdadba9bed0aded5d2316abc430cea6b45ce6c3d9b9997353cf9458dbece0d4ca5c9e32e87a1e8f0f6a9c7824c9f58532d5ba4342d3481c1831f636d68f050df30705a11c3f75e6a9d79f1d2b516fc0f67d8bf1611d239fe0cb6b2ddeffbe417f29cbe5e97dd49a1dea950a8aaa501c9b9c448d5f529319fdcd23632344019876402299627eb9ce9f2b165a264fa5e9b1bc61333e9a474b54a9b67c7c5921512890347ade528bfdc5a9c5721657ba3c560c1142507674aadb2e0dcb47531c4606faa85b014d53e274555aed066836a942efa89acde9b97233e2b7db4d5e399160a857201024559f17c75566c60fb0bf37c91757b7283741060eb5469d749841d5d209359211aa22e93a1e5f5d77181b50e8d1e068bfe08d7345cc8ee4ddabfff1e98f7bb43b2eb66312065d906922096aa7d5b67291afa38484a1c7edd5003a1e85a9346d4732f9ce32ab9b36222e89a40ba18450a20841605a81d2d8aefca17a6df494023200558274f97bd3e6ca7c8bd52d1b623e51e8411842e023141012bc6a7555b1eae627e6c63afdc504f81e782ea821174f1a9c7d32cdcbd32570fc07b8f4207049ea5964cdc46f363e5322297fbf7763f1bb7c68d1d7a783e3128f42268e6678e2618de38fe6a0eb41e083ef12d7d224441ae7eebf0b84de3731b2a77ddfb46ed9e5da99c1e1c1622ca363b74c1656da2cddeb72e5a735ac4e1b252e48e50c92f13cdd85a59da0b6fb1aa86b3192cf434c69b875f317736be7505e4f8de6f6f7b2db8ab8f14f932012683d3d24e33a62af83b3b874d3af6dbf0aea220804c5f71e844421725c5d845c4c193d73c9e2be23424b272219e199b6ef556aebb259fb3c0ae5d710d5410114fe074bcca25a888f01450000000049454e44ae426082 + + + 89504e470d0a1a0a0000000d49484452000000100000001008060000001ff3ff610000032749444154388d5dcc4d6b5c550080e1f7dc7bee3de77ecc4c669a4e19930689f8dd141304454a77426becc65d312e1405c9de3fe1aa3b455da85b51b476a136e8a692d44e2425b655842a6992369926339399b9df738f0bc185cf0f78048b532013d07df00b459fb3746bef349dd9b34dbf551596109dc3ee607fbfbb56167c8cb05770ec18ed803188ff02d59b468fdf9f3bf9ccc5d75f7c93f373e768d55b0860afd761a57d8dcfbfbeccaf6b7f7e8574df2374ef521a60710a2e3466c445b9fada678b66f5e135139b91f9bfd48ccc7af7ba59bab46ce473a76f716afe311616b079bcaa21bef4c24b73afbcb5f8360d6792244b29cb1283212b33fa599f075187a88c997abac25eba7dfcef8d87b358f28ac47046d6e452ee65748607b8a5a6f00a0c86d17804405aa674932e7bf11ef7d343b2d61ece74f66abeef9f938e6dbd5b69b9dceedd617d771d3da529c725511ea16d8db0044991d04b7b74b32e1b0f6eb271b041e5a913443db92c83aa7d464e0b12997165f732a94838553fcda47b0c253500599171901f70abb7c9d59def190529de6c8c7f47cc4bab4635af25b88e4529537eeeadb055fcc1949ea1226b000c8b01bbe916f7865be47682aada64798a0c8d9242e748cf21b434755dc5570ea9d3675bdcc6410230b60a52a7a01af828e9d24b071869535a9690100febce84173b05a15654b447a015da5548dbfa3718972479c648a60c444c6625b8c904ddc8cae4a097acb58ed405f7d110df5684be4745297cad51d2010cd9784c944a2c21181b43a153ec7b4d76f68b4d2bebc98f8e6e4a1aaa8ef26c7c47117a1e35dfa711f834c2909ae7112a8de72a94b638e63618fee21325e98716b6f9e9fe8df4cb7cf504f56a88eb1bb494044a530b02ea4148a83db4ebe06a417dc287f64976daf18fc8f25b9b99665e1eb9edc34df972b3d23cde7ad6219c1004be4b35f0705d8b5c6418b740942e9dab35da9ff6ff1a8de32594bd6d537902a4d3cda3e4bbed763a1bdd0d9e0c558d7a23403a16e55890765d76aedbac7f9271e38b831f46e9e80d02fb778c40f0fc3c082006f2718011e7b5d6cb938f040b61c3d158101d16696777f85b1c251f60cc37287b80166004ff00e8a46ea7529ddee00000000049454e44ae426082 + + + 89504e470d0a1a0a0000000d49484452000000100000001008060000001ff3ff61000002a649444154388da5934b4894511886df73ce7f1b674647d11927bae0586913d8902032ba28c82e625018495450948b70d526db745db5285a1974012130484828b0722ac245372630d394d06abaa8cce4a5747266fef3ffe7b4984d05ddf0ddbfdfcbf77ecf47a494588888f3941fd206948c01953ba0a61d30890d534d03d484a57298ba094933202a87d03820cc551ebfeb0a541aa4ff15270170beafac745164574d75d8a3e68a7f1e20a52c121497375557b41fdbb27e71ffd084888d26f62b12b2444acc0388ffc60961892aa7d7d17e604330b8adbc1467eef5e17134768838e92da5a0d0fdcae4e2f5dc47ab4103c67ef20aa9a66dab79e9cafcb3471b2a1db53e0f5a7bfa10e98d9da0ba72094480e632e75cc3ba9290335fbbce2d5190ad1610b62cb70d5cdbb83ed0d6b673b323ecf3e3d4fd21441e4c9cd7a4721a347b3d3a3e9aba580c2f5ab6876b480eba8400b1b8a873fb9448736368c7c9ba4df0b95c38d7fb12b7efc43b75ce5af143734c0bf9c7a793fce0e12df58aee16cb9e0c7f680e04ddfb8f34850beb0395488b39b43f7b81ae1bf1bb30edbdd0ad94a598b0b50ca46e817942255fa6a6534b8a161b954da15a62f853b98d55156a30af14d3561c37070770b373b29fcc925daa4a2799ad40b53568dc012d9303e65913907652e5b36466f79a321f097997834986193b81876f86d0d5f13526a7c8564d2731d5d2a059068c8c0bc67c1e1c490f5841f96aa896f1313927c2792bbe055cba82599940f4d35b7477a426f998b28d1a7c5032915d9a48482221a980a402d4307538849621e3b9ddd1e80c26c828fa13efd0d36126cd919c3d8c21fa27c028b375305b8721f4ab9f9f3bdf3f1d99c0a34e66a6063c2d8ca1e76f84b2e2956b412503252445e70defe488ab3a3dec3e0e665d909a05c138a4c20126b280fc22b2d077fe0e39d9212d1cfbea170000000049454e44ae426082 + + + 89504e470d0a1a0a0000000d49484452000000100000001008060000001ff3ff610000038449444154388d2dd2dd6b5b6500c7f1dff33ce73c49ce49fa92646d5abac469b1d9c6e8eccada491d45dceccb10d918689913c482e4629d7ae15fb281e88560a98309b2ab8137c349d196685bd3d1c16293b6491793a63939364d933c2f5ed83fe073f5fd92af7a7a506fb562f1cecef9a0d66fa40e0f3fd54a3de04ac1d41a542910a520a50403a6e3dddd3f3494fa7b6b7373c647e9061bf5fb6351bf7ffec39191b18ba74ff3c3747a3aaf5496689d320010ada1b58656eada6030b8303d3bdb161b1c8c94d2e9d1aae32cb25ba74efd7c6b78f852686e0eb87913afe672a65a5b9bcc53ba498175a23520e5d4058f67e1ed999936f3ce1d780606100b047a2b85c2b811f27acf054321c0b601d7859148e0f2c1814f3e7cf8cd8a6d3721a57b4e880763376e043cb76f03fbfb8094f0c762087675bdce06b4ce341c67e2b55c8e9348042004c6d0107a5fbee4cdb5b5ebc166f383f1ab57ad4022014809380ef4f23292f3f38dbf9e3efd9c8d793ca96dd7cdd052692a5a2c9a341201a48471fe3c42f93cedebee363a12099063ac9249ac3e7a247e5f5cfc420b719f5df6fba15badf5dcd15156140a53d1dd5d8385c3205ac31b8fc31a1c04d51aba5c865c5a42f2f163b1bcba7a574979cf2004ec2ddb06010021528546e359a354bade532e331e0e83500a220474b58afad212fe78f244aea4d39f28a5be6500082130da6b3528a5a02885e6dc5196a5fe4d26715028804622000059ab01ae0b69188a000e07c001985a835d314d4821a0bdde6b174e9efcf1cd6ad5ae95cba8964a286732a8663268390e28e788f6f531a3b3f3fd52b198c5f127ec1dc6a0389f1a8dc717c6f6f7db8ef279340148001621f0710e6ddb603e1f0880682c669a274e4cfe93cf6f52add7d915db7e6fe8ecd985f14aa5ad99c9e0e8187b4d13bb1e8faa3226bb3d1eaa4d13847350a5d0d7df6f22189cd8dfd9c919f13367e6dfadd7038d172fd0044001f82d0b699fafb156af7fa65badaa21e5f7fd5eaf2d098100d0daddc5f0f0b0ad28fd9a366ab5ed03ce414d130480d5d181ad6050fc7978f8a554ea3b0dfcf4ac5299ddaed5ea3edb06d51a94731c359ba8572a0576d1757f29fafd23af7475f5061843aabd5d248bc5bb52887b8cb1ff134bb95e72ddac6959937dd1a8a9c361fcb6b8f83cb7b2f2119be4bce4ecedfd7ae0f35ddab3ac506a67674e08719f520a4208a035985280d629b752c90a4a27b6b3d9ecd6c6c6c78c90a5ff007be7b8a6a32414700000000049454e44ae426082 + + + 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 + + + 789c44bdc792ec3a936e39afa7f8ad382b6b63455073d083d45aeb6ceb0165a8d43af3befc65c4b7dcf7c9d15e8741020e87c3e17000fffb3fffb93d3dfacffffcef7fbd7f541fb3e63fcdb47afbcfffb49f8f8fbfffdffffffffe9ffffaeff138f9cf7834fa4f52a6e57fe2fffe7ffeebbfc3e6f03fcd7f82d1eabf15985f3b18afc073e0205a81e98d03bd63bd7790acc0530318f38ee9ad03bd637bee40efd8dc77a077acb70ed215f87c0744bcf477cf81deb1953ad03b76771d64aa4b088829c747b70263affedbb603aa1f03ac2eb36b07faece41e6005ebbf1ce82bfd8e0324d63950e59e0a406c123b76a0777cbe39d04ff66e00093f797c02a47c65e70590d9673f5720f2a63c2a0063aafffee3402f9ddc39a0b601c02af75c39d0134fa50335c3cb35c0eaf2d83bd04fbe7f1de827930690f0c473ed404fac493f626fb9df7d80e9587701b092ceae1ce8a53f1f0ef4d2c3990309797a0db0a24ffe016a9b3bd04f5e124062026a1de827dda3037df6fdd781de31b3a25b533eb40ef4c4426a99b89e6e25006bcacf0f077a62e7d9815e7a380144fce423774057bf7080c43e1da8e8affb0013d02c7280c2a40e68db1b07aacbe41660029a540ef4932e75a09f1c5949532af77aeb8077d40ef48ec78903bde3a307643cf1f5e140e6e25d207599eeee004c1ed30380d5f6f3d1012f7d76a0cf3e1600d38f97d481ded1ae3bd03bfa7d077ac7f3bf9fa8a43f3f0e72bd3403983ca6570ef4d2f61fd04bdfd61de8a55f5f00b31f6f070ef48ee7c601052b1da81c5fdf809c9fcc2f1de82b376b0e4a0d05b2eb99abd4eb21c00434bf7740db760e548e873920e51d6f470ef48ed753077ac7db8903bda34b1ca8a4afe70093c7ecd201bde1ce01ef983bd03bfe6e1c4840df6b80dcac43ec40efe80f1ce8279f19a0e0b3b33307facaa7743d771dfbf80768b9dc81beb2bb0748d1f583da81def1bee10075d877a0977ebe3ad04b7fbe1ca860ddc281eaf276083011b66b0ef48edf0307e8fa2ec024f6b6e1000b73e980cf060ef4d9f51f8049ecfb1950f2d2dbb9834aa00054a35a32d5885cb85a36470e54f4ef3f802bdd910395747ae200897d3b40e92e0026a097dc01635404b0eacf62073c113ac00f4a1c481e931780a9d4eb9903acc3b103bd63f60fe81db373078514661d509a97533bd03b169903bd63f4ec4042beb37298d4df25d3d2a5bec80126b1b71d80496c9a3b5039d6bf1da052bf0e548ef77780e9d8cfbe03bd637ee140ef58ff0014fce463ea00995e3940eaad03496c7aee40b6b08b00a59e088231a0d21341b8e1407a7abfe94012fb563354ae851f338009e86d17e03d6a0b60459f640e10d02bc09af271ea8027360115127bff74a09f4ccf1ca8fa5f27807ad4acc0f515a019752b702c4daeddebfb780258db7ebc03aca17e6f01a6c9ef6f0ed0e4dc818afeb800585d9e260e54d2eec181a4fe3107586dd72b07fac9ebc881daf6c9ea5203268f80869f7c483f1a1f7036ef1c50b97b8077d33d80f5b987ce01e5380054a6850f0ef4c453eb40057bce00354f24ad033554f30968000feaa64d969502f399837605f6e449b7ae851f1f00abcbcf1ea0343ddd7480873277a0baecdd02ac72aff70e54978f12509b804207ea2f5faf80869f4c0f1de889f4c081eaf25c005a7ed27c39d013334aead59f1bc801db1250e775f97c00984acd2307facaef1da0461e1f8d03aa7fe90083523960142b00ad39246f0ef444bfed40259d5c013a7ae54cfda5f3ca2d9e0056b90fe947ef75f96c1dd009ef1ca8477d5680c686e81707f4975707faca340574143d5f38e857d6b29e017a81702a21f75951aa2e07abcf0e0ebf8dc8eb5f002bfaef9603f586ef5780758faf4f0774f51ee045cf1da8b6f33b078c73f6596b9749e7403d6a52003adeb1f807f48ee32b40cf67137b473f96f9ecb605967f7a6909185bdbce045c403fabe175f8ff6660bf2f0136f0fd8d1ca8e8bb770073ae368f00d64d372e00a6c9931e60f2588400eb622fff80aa3fdd772001cd0e1d483f1e4b40c713dd35a01f6b1a19ab29c74b0108bc3960b6c63b9685d7671f05b212011dad46c271e4b5fdf802985dffb427ac2e0f8d03bdf4b973a0eacf1240c74f5e6f003d3ff97a71a0da3e140e68ca7b81a596a9e8470ef444fc6260aca2f7df8031fa11bf3b58c923081207fce4131021b1d983806bd09ceaff939874ec5fc864ad0154368b9e3a605ef906686d583b0698801ee70e54dbaf7780f58697c001ea70e94005db781658f63a15fdca00f298f293a50ea98bf5800879243307cc8017025efd1995cbaa52eff8d067937f06a506987ebcaf01acb66b9d033dd16e1840935ff70066fa166301afdc4b0118238ff9d8814a3a3d3540f5fb4307748f5b40c44b5fed1d3120890c481e417ded8069c29f800be8e117500116cf0e549709f2c8ea4a053b5233a483c210620c018d454846809e2ef63276a0eaffa9bfa4de5f362e1d6050660e548e8e77b880b24f4042e5928903e6a6e78094271e5497d46b3b590778e5d4d8ff02112f32069997f4f504604df97207b07699dd38a0ef7f00520a964c1dac2416b42f0ef0824340c64f9e7f04b29a76993e011a8afe2590fb48b8b106305bb8f30ae850fe871e600df52ea3942f87607d3672a0da3e4d01b169f29901dae5a9022466a5f60129fda5df752021c7cf804cf208d34b072ae9447d2e1f6a4bc85556aa707fec700ae818e776f71da8a43f52fe62395cc8188c1c48a6f323039474913860b25a01acfadfef8084ea3f4c00a9641ab4af805c75099a530778c1325b45d652b94f19d8d2478fa70e6025fddd35c0673f5e00092dd7ff00321b3dd60139959b8f1cc87ce6f6d942050bba33077ae98dbda3a4e81faa5ce563f677ed402a35cf01d61bd67f013160f20648ccae378092cf16b903bdb4cb00150a339781ad5d409f2f00fbca5ae1404ff4bf8094ea2f4a4086801e9f1d10e96d00346598c4808a8225b983957e04d51ea0e689999c9ada1b7bb209e82b228aaa5ce332fdbb05988ecdc60e584da801a9799f570e98e19c02ac47cd0a404ee5b63a006d1b4c7f01357599fe3990a5bb5d001a2a775b3a50f7e8e57d36f9a89290b757b39371fb6fee21b3d57a43cd530354ee7704b0ea6fd84facb6b35b07fac9c981037c980850d0b60fa50395a3c8000d958b3f1da860bd8c52eb75f992a15fced6a4851f6a97ce5bee2b03a428dd6b0cc8ade8a7808a722c460e343668c56a00cd58ef480f012d20b1afb4112f950dea8692b24c7a051853f4577906bd4b7de314905a84e4d181daf6f3c900426e0e002542ce76009dca1134670e30392a58ef059b3e03c6158b4b7f0e54d2ef958f1b8d7cbcfd1b03128afe59023206e0a70c60866d76e28030d40ba0a42e8f8d037eb207a86c04ba00f426f5c480558e920e4547ead780a8623ea7a28f7de07bd907e4b4fefc065002b67a404dd167078046c631087281681469ded0260e88e33e0a78c1a673406452df72a0eaefaf8c41142d3d6569f2029021f5af1e50100090c98906a2728449ea60f59560feea405f39f80344fca457f5a33cae54fd437d25f650d69f641afb28d6ef015c6213408de97b6c1d68d08a9f0486afaa60c13f20c7b9f907f48e8335408c4cdf0c24d4e5e147c065faab922ee70d68b2ea3278a718838d2f0368e1c703a044d71791010cec430db0ca4d9e1d10dc5133248386745287021053d264ee209585b9749069d0ba0358e59e54db64a89ca47ea0fe329802ccc5efa50309f9f81a50a0ebef5b80da943f72c0fafe8103d5f6f103d0f093fc576028a98c63770a48a84bf0ec807047084869cac71d8141c724f5c58b035a6e15ba89b2a58f225def008db9b42340874f17e81dd9f01575d3fcc78104d424800c2107b103fde4615d204f28477f0b482b3d7124d51e549fc1f3a804585ac1ce27c00cdbdc9e30fbf1720568cdd21d39604213033af5a86016080c252506fb0dc829fa93da25f7a24fb601191d79f2eb403ff955572f7cc0d92a0039dd63bd0698c24c6300520f17b230c560846594b22f404e49d30b07b8c51f80827679565d8a7f526f0079a577f42da000eceaa54bf79c66680166a57ede013556ea4d7a5a0e259516966780828295278092a2f752baf25f397a8095e3574d39780e8870c340c148f891002c54f12911569105dd1e73076afdad16906a580bc25d40196942533f38d04f6e0d5426e47381bca4a43fabc959542f67632bb0dd004a1b4e268096924e3588d743579733d117003e1bf429a08a54dbfd1ed0c6f84132e3f5204235547f07282a49ace7b3434955f48d55b02b6a96d366bd2305f436bea860cdd2035149134064f3b93b408c5a3e058004df61662065cc0ee6809aca857b0e56e508a61b0ef4d2fcc1011101d9a066a81c4b36ab284b34f46beaf2796380bafc1e02e8eae19a6adb2e3d218d1e25c0cad12c008dca114cd71da81ccd07a0a55d3e25a0a5074b46d514d099c9516dbba5bfa5a21780120bf3fe02a800e939c01a7b7208e810d04486be1bda96c6e6b3795d697c395017eb072f87f0f10c60255deb01662d377e1db0dcd2002cd0fd2111f6cbb8adec7ae040b58d6240841d7b0c01e87ad8518ee5382679f015af5c7ae440ee57b86f00792405a007eca929877fc62a58b46a9778e9d252974e20b218fd57ee00f7eb1510a3eb3f6b0ee48ed68f809eaf14ef0ea4eb931307e4e53c092c91dae5d700452faf1ce8a547abfe122fd71bc80efb1418d7a6eb6381c802ee3f1307ac36d913639b7a5d0172a4ded500573a157d983551f4f4cc813cc7e90f606c526f1da8e84f1b02595a60947847dea2961f2bc7288e865932c671668059e3d7adc05017c2d80dc002551f0b07aa4b7c0db0961baf3b509f7b390464543f3d15188a2e3fb97f77405ad22520a2728a18ad00e9c8ab3e17c7dea3d627005b7f29ff04220b744f22404e7f59dc014a5cb8c535c0da25fe12183e4bbb1c3bc02fcc1c48eafb1f80989f44ab7e1b0f5e30329d67800c333e3f36c024607e00a06081bc8b3819dea99216ff803ebb57031244988c1de8271bd2b1746cab09dfaadc301e9b3bda0222d3e4c001f6f402505ad10f0de0162f2a40a5212940eaa9952368df1dc80dd49ac50a4840371b8094a26bb018fe9901b6a58583e36c73f55e6039815b81e31b4042d8e5f31a5050f4972340c93c7b3a0654662ded1db57cba400bbacb525017ad04ac00f3864b07c42eb61d10d9ac0159ccc49ba20fdd94617e06e8f01dba6f8162541162ac0dd494f40730061c49c78699b9255f4b84f972b221b5e489c8a2c5b310d0a085d3c201418473408b2bf97c02e8048240663c1f2a2789855b0ef49372e680186c03c891c76457c0abdfdf037aec5827339e7b6d7765b60a376c1b6aec62195790ae378018908f0116ba79df76a0af8c370085342858c86c154349d5b6e5b50355ae7873a0a2e71340613f091d9045a0d62f86daea1df347406fd597c48aa1f58917568088ea6fa85d4a1f70360f0116a67c7c0558ccf1e51e60b1bee99ec03056d25097803c967b1e6e028a98287ee840122b0a07d2b1fd774069ad1f3850e5d6f54435b645e14ff5ecca079c7e0d50327a4cc680868984922886497619134f5e7340e25205a8f8ec44fda51a64cabafa2b600ce8fe00712debb02b210f13091c81bd3b802d3daf4b1ef520753d11f50033399309c04c4ed7021aa43e7902b4d6a354b97a28ba0a56bc3a905a068f0ef4959b2d404dbbfcca6a373e347e4ba51aef0d9f35c0c2fa0b03bd0d8d529866d00f8970b6eb40faa1658e01d8678bce81e4917d3b90d295530309fed80da0e127b31781bc6479f253a3691bd90266943b20cfa00458f838be015434c383fda447ea5335c3e0f113fe09a68098ca85eb0e184e2e000c49016ad90e452766f0eb40452f2606a82d6e4fbbfc5349e7800e30d510dd66353edde24160505cac4300486b7939dff20c3a97c75a0e28b1fca5dc8d6ef0c8d45f8211a062146bce01adea122843640554976ccb80ea12288cbd0252edecc7810a167d033a04544c0d208f75d5a5f7861a6f026c896221433f4c010811dc6f0022c22e4502b096ebb7007c25a8170e346f589c38c01d7d01f466c7de1ca085abbe9f8c224b09f80c00391d68f3c0810af6d3024c2d7f1f0104dcc31f7b8705cc8a5a607004d5a3b2758017fd03d023c2eccf81a49e3f3a20d4f9ed8029209f5dfead5e5aed0222def137114873943f5dc9231947b65c3b19092ca734d2b15b81e55b54b04d07c4c623c01885292b0744adef017122996e7d022adcc04795743c740f123154b9f130ba9209790ac8182be72b233d38e3b105547b408a90e72706986a143c31149d11e81c40d183e6c481da45b9b42ba0dab6b903990b6586ae00b3b51860525fbc0a1449852d7c06a43802dd1a20afd93ea8cf0e9d8149d186015b9dcd1a408175f83900586c3c7b1718944e136f2de70f8d10515b6dcd5801cd4dc31d070421cf1da872d99a037df6e00710a3963f92479ce6369d95aec7de94999e489651257d452f4de211e36dba0348b1ebc54cc035a89c382058be7020d3171e3b6032b2094868fded3340877598ec091419ee79a127d2a1a4ac37a8bfa4ae74c91d20c36c951702568e70ff15c067836eea8085e5d2019afcec40ce7775e040cec42406a43602250e98d08c1ce8a5b74702a94dded7a84b5ad33d1eb70506b5943c7656035f92f9cce2b702742cc7dda957666eb59fe6005b06eb1a40ca2c3a0900950dd1d2d3cc2a17c68f80140195b503daf6c8810454df389080aad0015b88eca5192fddb4277abc9cf54381b464e2fdb02130a883d4b2e5b34555933ff6e54042ee3e01354fb4c70ed8fda48e9c2f43662bf01a3a20edf51690f244f405c86c6a7e09282ca8d23920cf711f405d026ded4af2a1be7806230712a112fd5640cd906d3820ad91cf2efff48e6f07fac9b7fa4b9e56cc92a6d2b1bc286c7efb01401e41a5ca159125406c1c010a5be559035468e1d73d802c82f077c701a387ccc5201ed432369023c2c71a50586c3c0054f4864c252d86ca4940da1aba022a47fee28085f67f3f913fa64cea011498ad76e28097de011a8cd2fb83815483784bd1dd4a3dc9e216ae968b052047c8ed09a041e9bef5c472d628798c65a5cae52c593ff903f4f8745b52cb72b0631a2c941a3980028bdbdc3b50f59b0707aafe3c76a019cefc0550d209f3a903a2c532d295b94e4198027a068b9114b7f2c1e2ef0e30a6032d2e00d691db6f40458c6d5a016ae296b5fa6d359443756953072a7a75ec409e745d002ad5363c390434d4e58e97a6b6b4f82c5daf8a9c96cb55f4619268134dbdb48e6db12d9a03228d40417004c878e9e321a0a2b6f993c0bf9296802a613e3777c042d9ab03a6a29f0ef40eed165c01728c7601b55e1a68dbcd0ae8a5ed2da0c37e6c508ed466c0bd74ac1ef4942dbbef80ae667b875aae892c096bf700601966bf47001ba247f7808e2736f5d9a183e1f3bfee02b085616f4f58d1954abc0292473d77a060a8ce335802ba693d0534a843d93850396ed4d84dda31e5e9a5c9cd600bf19355db76b90c2a4bf703b0b5a448f6a35d3a86eac80dc0b219c65b00160ec3e763408daf3dbf05b480a71d404780a8e1b356f440ab4d2bc034f2cb81e4d13c1a401ed5be03c6280ab6fc93c43207e869ee80e8a8a4de0efa41828c86a42eb265c1bf08d003b2d881ccc5f7d40189b152ba6eb9ceb3026b1980dc9ef0f316603ecc4b0530272fd1e8d1595dc2f2ce81e431ff35803c82d481da658f722cffa4da80146b19ae1f012ac6865d75f57e98ad9187f201e8d1f591cad1bb718c668008797c3e034c61464f004b2b78ac002dd6f24c451fe69d78b0ca641a00450faa890309397f3340ebe7af0e98ce7e3990095692cd007aaadf3f3a60aebefa49ba9c899378f02830d496be3f0690da14fe6e022cb7e7e708608ec02c0314ac9b4e4b408373f5752e30ccb489c11e00c604775a0a36ccb554d2f80a90319ad631c024a6c30906d09bfdf870a0ca55970e0811bc3b90c4aa13076a176dc75e01dc8d53817254ab6d472bd54ec7832380c7f603b08c997c24b05c6e53f74800e62a3c3e022cbbe3eb0ed01055986d014c831e3f01b6385daa60e374446dfbdc812a176e3b50e5aac001b670d5b3d3c83b72f408b055af68e1806cdb0090f393a719a0b2b0ad016bfd49026899bf3ced0a2cc3082bd0ec0352ba69d90a0c6555cb55170e68b9ca817ca9f6cd01f3ca7b4064e6f3d401c18c8503221373000e6b98ae869361de15e33b844f8014c3f61b01ac6db331c08cc1d3c2811afbd99e20a92478e0894100a4136e18b0daf60ed42ef9a70316db4e00315dfdfad600efe8160e9845db57127e7245e5d29e30d48efafe32cc400adeb1406c3924df2380253e8e22802de87e850690d8ed0c60896daf89035ceb6d40c94f9e7b408b081fa600cbbb98491d92c1c230c1db008c999b2e6e001126679f820dfe1851b835011350186d3860b93673c0a4f90a90d84fd61d10444084696a3a760fc0510caf00837c587f91954a0693c3b94e52cba1adc9fbcc0a81c148eb2b55094830e3e93bc04215ef3b00cbc9bbf903b0a01b7e3d386047d929a0c5e43c03bcdf9ef28ec143213343767d20d66f3b07e439560e1466e8330752a95deab244eaa6ad039a61d301d19e77076a172d0a2fff49df1fff00ccb75ce327d918d7ba53cba56584a1df56d1b3c852673f47800ecbbf278b9bc5b979d2b501643a4f00963ff67202b00ca207f5b96cd05329ee530a88883b549f00cb7788d591b3a136a412b70e88073d38609efde18089e6a50319361d7f3280ccc6cad40153c0b1030299bb0e48093806e4487df62a304c6f31c132d25999d4d2b1e6ce8144d85c3b90d235b780d49eb871a02722d5368f2d3770f3d681beb255023206ad2c05d828a679f600bca12e010d4df9dd025a8cd26c13d0b3907acd4f125b36deb801a43c51528ea58834462d1c48843af56d0554f4b607e4b46dfbe1009b5c3a5053a2c9b92bff0325cdab92e8c6a1808bb050eb2f6339ec379d002a0331a0c13a3c3d00488e0b1fd5c58ac4b27f169b80188bfbb407a82ddaf32b309455c660fee6404f4cce1d685ea9a3b106503012763b0e10e18303d22ba700269ae1a97c98221b316fb83c032448ec47ba5ee484f543456ad2a2cc90d88ffa6db9ccba126800a5cd1a67801601bd9d016cf6fa206fab4c225bc3090019ebd95ac3494baf5cf0e700015d3a6033dca90326016f801263b07301a8b0b83be70ed4b65349ac1c6ca1aa7f243d5d263d1375923caaa10391f41c016cbd72143b20dcf1610095ca5a074c24d494d5d05f9803dd022c87e4e914c0981d2ed61d100c2d00b6b03cab1d9047bfed80c9882634d5720fb36ce113a04440c58303f2e92207ccc4470e54fdc335406552bf7480d4af1cd06fb7002d2d7740c1b27186e2228f615097061d1e1aa06037c834ab10e18326565551b32231914a55656cf1f503405eeb275f32c1756c497adf8f0e54dbf01960f6348f0005bde1f816d0306beca5b8f5d0b69cef90014cd75b55bf1e0440ec337120b77872ea8010012f1dfe54d2fad4012bde0da049d9219303da8c15bc6d40af97865bd2d33acbb00e7bd436cbf593f06f0a289848cce42ad4834c99234b2d9b386504fa880119bde1e71090632ef66b406921f917077a22be0358077ad178bb0ccba9291f2a002967e13c70c0ced86d070488360039edb2d832c024e0f507d0e2297d5274738b43ed7e1a409d12b87b72a0b6d586dc1520faf56640aa1d74b50332995e1dc821092f000ddde37a01e8e81e5fa70e54b07b355493595d7e35acb571629a9c01cc11c83a40633bb9f6012d8e402b79b449c1e2f4949fb8eb145e021a6aab43779780cad5cf0ef48ed69eb0bebff30f10ee70406d77ce009d3d21f339fc7ff4f4791d50e56466a8ef2f837f84c3ae0096587f2cbbdec59688314a1c7016815eda2519327d3807948c950f67808a258a4789b0b3f96df89e01ccf4e98caa01b4b8b4f5ad03e2638d03fafe87016abbd7015c1e6b801e133c52bb7459862370b405c0bb087bb9e7dd30ccabb18ff5933eb25d47a9ec693f388aa8d413c0d2d6c63b00db909b4d1c108395d4fbc432ed17db8082610d27afb77965d0f384552e8c361d903f5618a04735af0e58a1193be0e8122a67a62f08cf0da06367f2d8faa103e9b3fb3b06328da6971d00231d6a5534edcbb2a157ae4c5f368a8a11eb512f023e6d7a7c10482c5f7bbe06c890c77c03505a42c88e03d62b2f00154063c30ab0d27c076879e26557c04326c523c0aa5fe60ed46fe7ef0ee84085c0f24ffa71e580b0ed9f03b60edf00c6486cc7013f99770283b7a1a21fac46f56c1cdb56849f05a0c675fafb1448c6ccd55fce0119325d18301d9b6f022c36fe7805a891d87c0f60ae9342f22bc001071b8016f07028e0b3c68337808dc8edb3800ba87c74200169345d01760abf39500060bae94025ddb9059808a335077a698f08074f493f7991162e8f9950cb3d6e0914151bd9da3381b2b459920414c5b693fcb70558ec73bd01741643e18965668e04f400a82c2eb56b00213f5e035a93fa0fa06355548929434dc680ed4d4063fe69263008488d5dfc01c618031d58b702e46c9e39209b611d60be65f36cc046e40307e45c9d026240fa024868974c058b074791c33c8e1cc8181417009b672fa485b10be8e112509b477f066850dc872b07c8d47ed29a087b406f2294262f1344586d9a3990c49a0b07449c3f1d1083ad1c10c8e4b3268f4081eee19fe64a5efc003ac0f443a02c0843b5fca46c1af2d8d42e496c09871b670e64c7d62680da7c1835543258070e498800968b3fdf02b49682f70f9097a32e96a42396c0b7d5c592657da5740f0ed8f33e76c0a93c570e54f49b6d40823dbd3b77c0024403b079d4c9025033f09dcf01ad4558470e38d6aa1428ab5ac3fcee6a98cfd2d8cedc894a809deef155396077beac549ad448ec2105343615dd77c0b178d70044182833344bbd72e5c201796c2f0ec852bb76a0926eaf0352bad8ed9303a4de3a20c2faed804015208ff1e8b395939765830f43b6cb27c0e411df03ec208e3f95344b2c077eb200b0f3205cb40012a7c34503e86c6e7a6380726c49ead960d8f4d942951b085d4c79062ba0f8874e185a01764ebf382033a30358486d373740335cdf395033dc050ed8e56b2f6d326c214f945d43802874a09736d4a5eced89da013bca642d97614a7214bf0196a1fa7b02b0a04a7109b0bccfefb9019bbfc8b00d131e14f7f7015010757a7a02d404551607808e417cbe0de82d37506e4f3e0880ccf26707e8d88f03497dd63bd04cab3790a3b8efcf0e24e4bb0b0738dfb285f930dcd209115051721edb9a9aa188ede8b4e809d090d3fb2dc52d12db89a1c5b6013456fd43800daf8b23808d0d5b7c25b5b4d7f72920235ef8bc092809ec96b20e85d7a5f8752089d59103e2daef80026ba935f115c0513c019498cf6b49bdc86df9e9790d5016aa5ca33e57542394ee5e0e6b39e818a9c439c08ed7dabc00b418839f5740cf0cf84fcef7e08be3e53cde004c83267380e5e23fdc3a40c7761d70dca97a76995a96fcf3b903fca01d07b84ec78031e05ad6b27411eaae9215200bfac70119dd9f0e0832258092d143e7d42c01ef78a7a45945bb6401a0a6b1f7d581ca4195395b5f035fe9cd309271ac62db72979c02482b08c2dc018b4b92699570a24eb8f10db07d387f9b80c41620de1de0196c034a36183eda1315bbd2e635c09af249ea50b9900be958e5f2c8771cb0fbe9cd0173f5d4402e75b8be01543403e67309d896853cf29e70e948667ce8c638df6369509d58f242b90eb0ccaecd33408ce95bfb07d8533402f890a4a1a01e748c41fc1e60eb84daf9b8022c2ed500f604844f970e3028270ed0754a9a16b6c4692f351f06d5ae07799069ffe780c5b6d6011df9c8814c30066500927a306b1c683aab3d7803a8cd81bf73c08164e780062bd5c918d4c3288647afded0c496513552630f6e1106e549bdb271113e9f0162a20acae71f4041f827943a34cb0f4bc7b61d7054c7be03d2096b03546efee58004883f40c3807373ec801d54eafbcd604f05ce297a6e9e41afd1a329bb9a6086e4d1c676f055a2e1a44d2c3b6c2b06d8a2f0f314609d70e31150d97e0f998b7650184478ee80a5a31120e689f617602aa5ade559bbf41d5725d54ac000a87e50ff03c874c740ae099e4e9f5b017da53e01b4a843bee580b803f228462567876912d096ad2df902aac81ca31610371c1dafd6ef12ceca0a77de0109a6efeb11509152f4a8f1a54bcda57d88008981b103468f33408a4cbb7b8065eb771303c40b1f650bbbe50c4642de04208f00bf700950cb1b0368e1ecde01d91deb800e996e7f39d090149e39d04bade8598f2617a9033543a2a6ecf211e027061438bde7578092c8d5b3ba47578c4b529b548ec10bb2b4465987de95ee4befe8b3114195b77780c5b6f219c0f4e32e045097b0ec0d60a5aa3307f4dbc68124b6730ce879c7f6a701c6975cedd22fafccd13b7601113fd99f18e0a5a3d557f2d1302764f2be07f03cd84d81617ce1788b0ad030277cba11486d1bd27417d0317bbde32756d220787380d9ca1cb03beedb01bb06ae1da823ebe089d57d412ad8c5c8816a7b31368080d25b070c058d030266e7002268e16e004850cbd65e9af3d99339c0acf6f3af4011974c8a2e05aa84aebeb6b2daf938e6ccd0203801d87ac37d6980517d7b02b074f59f67406f0bcb5381a1a1a8ed27c06cf2cf1c60fb81d6d601b5252ff095c1e272745a034870699fee00b63fea2176a0a26fabfa63ebd941752560520fb34307c43e23c098b9fac5bd015aae7f7240dee723803054f8b772d0f228b163f1fe3e000d4ededf3ba0650ef47206e879e2519f8d52db51f69302525b351f03328c017a1a0d7d1f2f67cd0186ed47c0d432d01c790972760c1d00c6f47d9d2cb8029cd43a7140aad71d20c21dddfe3680902f160ef8cab1036cf2362066689cde3be02ba70e88296d080ca31829236a8638b1e32c931380a5018ff70189a5de6f016c77cbf735a0c133f8c900d6500b75c2d89dcdc711806d7be16304c8d0c2c76f40ceecf52971c0a5436afd388b98f2c81118404adf7f3802e07e85137e62320dfa4d07c874e400113e032cf8a76d59abc34e0865bd3a201bbb065838acb7cf12ed09dfa85c5ee6e428aaabc7454fcad948c620893d3d5bdd74b00596a19a3820016204c899dffe3d001adb4026f399a4b9f5fdc40152cf008539682a58e2c91ce52fa061447e3e02982390aafa898f513a9e6f00482ca8bf1d10fc9b3b606595a29b0843250aaf76201272bd74c072be06be649847c816d66b80bcc10d5c071480581d394d2c1b2a1e39e0149a0f40435a631d027a929f9ed54dd3342252f3f805c8d0d3e70b077ae9660dc86d6940dd347583f268206609fcf60d60b52d3e1d309afe38208784cfe616735c540e78e2c181aa7fb96d00211f7c3bd067af8e1cb09a3001e4589819252d538ed6ab657252977a2173910d6325b7205e3ae02c35d5254bc6a8761c00ec28a8bf034066797d2f02a96db8fc529fcb06178ec5a54ec08a1e26a50392b08e1ca8efeb1295156015f0db01fb3c37010410c3ddcc0012d37af60a48628b4f408e43a2832697202758aed6cf0a1b3cff7a40cbb4baa6e855894cef55d23cb673f14735c02678a3d0016be20da0b73dde1a5f961685d3d5d700b619fff71950b32cf8f70630577222b335e836aabde01d362b084f24e4dc824c413575c028664fe416940d1d70f1883f91b39cbfe500ab7d0f28f06194a9b204fce4f813d0a00e1fd2c2bc18156c61e6892a21c3ec479a5c24be613b0470206a787c07a8ed446159ed62e8506aa8e74b4069de962c4c91d97e8f660f40582ea864b50bab5c98de38e018a77f80c4a59903d21b0a408180c2da0163d48603f68c2c0025123b90d757144981ef20a52b133bd9f8ef09c0eeda704dfda54c4738027f5f004bae9d57001b811275e4d20a16ded50ec81dbd77406d17060a4eb2d90294365bfb36405dea6307c4a42307ec03fe714034b00358fcf44a8345598cb13013794aa52b4cc34faaaa51f5eb4d40dda8b623f5ec2ab6e4fc1d157d986960fa9e651daad44ee47a7803d84e8ce72b001b72c3441ab48c4a32deaa2e9557ae797140d0edc60167fe3940a63ae76a054837dd01208f400b652bc0f42d3280906f371c70b8da8103c6fd11c0e2633ade6209181adfbe005dc10db952ed6ae8b7789f1ac5ea61a645905a73c27af09404c607003bf0f23b01b4e6c1d6808e43017ed594756a49be0b0326f5a767802de76f360e585aec01b6efb59290eba1361c7bb66ba0c03f7d02208ff0aa37406c2bad1cb085b9334086c8ce11c0c261a59aa1496cafe8b5dcaf65c2a14a7ab60034cc91677f0e38d44c2ad5f867a7db060a160fec898627c24307a489cf00c494827ec7013bc929c7d0b644aed494cde04ce0e41580a621b4a7a66c939491f07e1d9033f0bd4bc8ed72a7d60aac9f3920e37f0c286c35e11e60a7153cbc026cdfebc30bc036b17edf39c004f3598f6dbdfc006c988ffe002620ddf9b80426d314d0f284627d2bc0a20e9fcd3b1afb5e23505bd8dce3e21b5030f0dd6b0ad8c5be97582fed06f70ba3a496eb06479105886d034c56d36b404339eeae002d0645796c4b5030d3ba75c02eac3d076cbada027494f4ead001e7e4ed3ac0d08f0d60b674e2f40aa8474da96dde33050c6307ccf7a5635d1163b6ee678094963b0d01394ede4d03a871d094759377835ab24159ddb4b7f04f50fd003abce051e040e518abb6fde0f4b23ed7023273f266003b20e53b03b4b6965400ecdc9e0759a97e505cfc0f09b97783f26ca0c17ec40f80cec686da004da9fba35680a6dc72c07ec25b07ac48bc027a5aeef6dd009fdd95ae0fff64c0d199a10318e7ac9a8f00092d17ad2a578c124bd3fa7903d801e4afb5c07287945e7a2f30144c12bbd903508ea0ba7640a8f3486040447bb61d90943675a096bbea0c50b97cc3013bda4f1c60f9478031cabf9b18c018bc2f0071c1b9b45780b4908034595d9e39db122c575dc6a91d5ff09818604f8002220360af79f8ba26e0ed72fb22e045d7a166c5d84a1ae8d2b215201a181be01ded9303b229fd1d545fc7e12eebca4fceeda538bd6157080c732095b4fe13a8472dc93e7ae9e058db3e9c0860d557c0ac58a649b3db47ad1f5939c2e4d901bafee78015cd5b072cd61f03222a773d76a097deec3860adc07e129b3f36374063d75b02f5a8614a2c4d8e133ba3fb2f05d8f1c0a30c6067ccec48ea716ae749afed002cbde151958b97e9c61a1ad705724be48a558ed88baec35d5780d4841e10e36b5fb506a87efbe880a160174030238c2f0199553f10585e02219bacba246e2d7fbf05dc63fb947e0c931326abbfef00cbd7dedc0570f473f8bd05b0938d9f3e017654c7a3e491d81ebc808225991d02f8b86680d5b773093919c64a3cd817800d493a82a9586635120e9b3ad06031b973c07196bc63f9b7027b6aec61da8de98bc780ca66f3ea84e9e0b0b23dfd06d0e1c1dee7025ef43799cf74685b32329f0009a735de5d3b50df9f040ec863bb05a418e93637606343ef8015de0340c660f1f6076859e36bd491d3a13730e5598db74596d8b189c919c08e4cddbc316007f81d036c07c4a70a96a576b5c096013bb37ceb0fd0da7ab6cc45e65dfde9048080824905180aafded000a85cd06c0372e62ff5afc0f20461155dbd214f6cc7e197547b191f24a3bb0114242d6ebc002a967dfe3600963eb77f00e851dcdb0f816549a4419b0e64e9745fe3b29c34657760809fa48103fd64f10760f21e7ecb4a15cbb31724b111c03276b7ef01e6a16cad012cb16d5306a5f04df04f1f809818ca235fc9d8591fee4af987eab234f00e181a8ae05f0dc80b32dd6207cc4dc7002224e1edba016a5bcd1cf08e7b07c460297a51ea1d671f52dca21a7148b5ce422a8a61faaa96537ae5009256ce55b072cf8b72f0d7d9e45c0a24b653e75e63e532ec4230740c48ec2817a943e9c9c61fa702c3ec84b3f6d43dca6557969e1e02726ec88d7987d536bcdf76401a5f0e289147b0ee802b419e1ce01667808a277454faf2ffa363dfe7809ee1e4505a5896e6072991ab282bdb8852f38ee5fc5e324562cba9b8864615ac4aec1e895f296e958e2c09eb185022d3f57b809d8ebc7eee805e29c3566523b3b86f0e58699e034c93373b80a7d0d84f526cf2b386936a2900a9e513a06252a444f22530114e018d7e121e6d035a24d6c95c54f59840956627033001457aa21eec292771be012a5b3b890036f7f8e127c3f0aaa2ff1c032c6b6f472d57e711dd54c94f03e870f10f3466d7832bc9ea1b9f7567a2e6b36eb66e8e0055c1cdc51307325be77b809a27e275075c92f16b8074a0b55781d2e6d923a97693d8a4794d126bd2ce124135f035ee4b3d8f00d6b61355ae711f3779055839a203079ca3780cb079b6cefe5902c6dbe0c00191ef5f071cc1645f69f5c4d94768a024d6b707e891a9b6a72f4f956cb93345e6a24dec5cfcdf73806def8853801d38b5a7866a53bb04725f06a5cd2cf9696bc30171987740ca16f7e01e50e0afeb38dc0194a4e03dc8631baa8673a5739d5680b4f99103929fee1ca82ef75b0e98f0ee00882a9c69ada068ab92ad199584dc9a80429a6109640c026a3bb424c9829269e791de0da97697daf1f307f261bacc92c10ece1d30577f05a44cdf1a957498769b7b7e09686d14bb0374b4edd58103ecfa9a03152cda37807eb45780be20a74696ae2bc7286e03a8331bc5be00543fcc3446f5496a87fe4b847d6a89c21f3f8092c9fb766d0017ff59a6af37fd08d747005b6e798a0dd849699af0f6c31f7b9bb61c48b595abb002324a877f0ed86f7a658083494ee55bf6a5ad8cb49a59f4754a545287770e80ea9fe964f4010c1665f544befa6c394af211c1e15f00576e87d91c505a80e808d03205cc6602a9eda2f8e01d698c8fbb3d12f8a7412f00768187cfcf003b25e0f653c06b7b7127b04432c1670678e266df01219309c06217c586010cecd61720c1265f518e32a519b488518e0611261221121b44a8272a4a5a57e8d8fd4a93cb6170c5533a51c186f90d47528d0a038870f3de009ed2da06c0ae8cd997d4c799e549ff2d047276fb8433497d3cf89612e1452260020a9a4f0764438d0163665a177303c8f472c7812476fbec80b4d73d405ab2182b998eab5e1192b38f4ac02476a66bee0750490bcf74b5d10a904eb81a70cac8cdf8ce1ac0d2d6d654db65944505fbee000d9ed2c1026043e3c185c0725f9abad829c0366c3fbd022a3c83d18d404e9e74d8b602cb3f59a93d072ad8fd18c0a439d0994c4b507236760460e619be3c03b252ea70695fa9d1f51e790c9e922a576f032a3ca5e0d801326d1c20755e5ad708797365d707c7d2969ff6f58e38b33cb6e73b03b8818767004be37bfc05b448ece241c00554260e547d1d05b5bcc907c728bf36808e5ddf3be00cf74707a4e17c014ae6ead59fc05039aadf3950c1ee25e42449ec168023806dee59ab00764bf7c621c0ae38d8ee013678fea82327c3e8a1baec9e0162b2d4b6df0139c3c94600e0f4dbf08597661c631dbecc01a56d987a005418c754062571957ae089d20222ba2d7c0530f457066897fac8816a7b73e08020c21a20a3a1e20b40ce4f3e4f003557d5d6eac8c9bf66e81da819825d40dbe2d1eb2bc344c3d681e6000b31ee8d009675f3330314b8f83b5f8086e9fdee36a0c37c6e494f9727d8a9e85beb007303377b80b93d2f8f00cbd97c3650d30c0f6adbd4a609419d0a9808c3f81c90e2e59c5e19a019f69f1db0a873e880ad3b910362066f808c41abe12b838195c25439c09be1ce01c66002680c4c1da8ef47b2855962d7cc6eaa5d3297c7e139c00e003db87480262f0015a7ce86d2d3ac28587f69f98a696150bf01a87e30490119b3f945e880c9c8bd0124968c1c48624a075afe93515d87232d015f691b40a19f843b25a02b719da474990b28d807b426c2b9035678e5e5e4832340cbfd01ec6ef43f59dc657c8cd3a3a4b87936c23a6c7c3a90c4feec093bab736b1390307f794d01966ff932035418949729c00e7a4ad50cf930e3e3589a5d00be7678ab2e96bb4ca714bdb4c8950ec05801d23d6606ec24bdd8019b581b07ece2ac0085c5714f1c7094cb1850d15f5eff1c484067fb8046c3c99916a8ca7c183c89c37c00bce5160e4a01be5277061e1cb0bebf8a8f954512db4df029a0b2748f00e07bf05497221dd9dc949fa4b64722fd05f89d296b00cba5fdfb01f49632d23b204c29d52e068561274605885198ed3b030cf36fe700bb8ae368df816afbbe07b0b4e8572a9759c6eecb038013fcc3971a509b31e80ce04cecdb3b6cd1ef53235051c4447a5f11f2308d24094b5d6c19b9c3835d38903ded0e1de04a8e1d60a45f1d546a5b19d8e25f633f3a50f5c79269997012781827005be4fad912181c780e35cb01253d7bcd9eb030d4fa05a0b5b6d567cb6c44bafa214f6496b17ba23e570e7320a6d511c0229b933f070466f60dd00947670ef060ef1db019ae714092de0da0e2893e77804c7f1d10713640b0eb4c67ba2d4f876991fa13a0b71e25d5ae067f8c23b9df01662dbf558ec10b62afc6ef2fc0c6fd23e9699559b6fec115c06e00d95c00ec728a4632ad5c3fb4a97759139cefeb2703b8e7f19f03bde3eec681a4ae34ade5ffb7ea6b98afbcb6238d2f43e7b0d3a2cf0076b5c0a6dce23ab59b37766f00dc7b1fbeaa2e75c6cd1be158e6a21e8c3422ac00943498f093e10f77e3c601dba11e1d700d4fe880b8e5b70392b09e0116fc9b7e3b20d938308006fdb50eb03009a0ad9867034c62671f1a4deb66640aa36668dc5fff2e00966c5c6e02ecb2d25dc9b4490b2ceeab34b9f12e767400b09c2b25950ce58c5007ad9c0d20a52ef73b00e41116878086f9cbf9be03990bdd455136436f4855b95b406f3648634363b53dfb787580d249f99729676c822f01765bc5c61ea037778327d28431ea2f01782eed19c066d1bf3f8096e8d7970ad60ebd94eba17f1c7004e43b2002ecde03ec66eb6703968efcda03b8ef24fcfb06d812f848d56f4d844118382011f41960f1d32a3180a54b361da8e8278503b4f0c6810a36fef70ea25fad03ee043d30c01e9a7bea32788e1ca9aba1b15dde07a491701d60179fdddc02f0a5c24a4ad70e0e09a15fb9c56d33a6f5efd5fa9d59cb705c013ac6a84216b773776353fe5897597ee16b01b0c32a8f761d60613a038cd92f1307dc56a131aa1b269a6ab9f102d0e08f4594d425369e3b20c7f90440e837d096ff25c03d9fb70eb88ef0dc01fee9b703b6cb1d1940eae508d053b0439ea8c68080729890cf3ede011152cfd56ffba4c4e4dc9e012c2eb5a3c05d9fda81fd5b6aca3ecb6c6fe40ec01ca3c34b801d14f73a77c095420f800ef0a221bacfed50e6853cfa7eb05a6a9723ca31d497a2f395e14f5fb9ac1d60e83b0734e5cc404586bbf4a3af08fe85ef4f8084bb169f0e01a6dacc3cfbaae00eaa9aa20f42d667833d406496eec381de71b7b230d5bf78f25f0cb0fb3df6c60e38bb631360e78dff1d096476fceb7a01c8ed9aa60740cffeec9f1381bc62f5fe80270acb2c1f8f04fe098827064424efc4810474b6e3808df4fb067847f5ee403eeeb40720f5b38f4f81264640b1e4314eedc0dccd894066574e1d1d023ac06b03e04298f03810c8634e075afb12286c93627d2760050b4f8f01633ae1e1be031263ef0d7006515b3bd03bee6e1d48c8a76b80b82243f502c0cc337c7f04d41cb8bd7e0068b0eb3389705cdb96086dfdabc683d231e3cb0088f0ec23072406be1c48710f5786ad8a92928b02effe0c3009f8546da3d42e72fa93d4a3cc8e183e7902e424c86c8f01e66e6c6d032ac0eb046067ffbc9602b9ddcca25379aa6870f2d8fd44c18686d213a337800939bb05440c6b3b850376513c19b077bc38903acc29c7309f21a1ecd2006dfbb1e740ef08128141ea18d86f8009f94efd25f605dddb7380c5607fd50cb1f7dbdd39c046b1d719c0253675c0bcb2153011064ad5a8e282f31cc31775d3a12668e1987778f575d7d1724cc771bedd7780affde880bcf1ca01aea43fc14bfb086001c4f2d3810ab67d6ca0e2d2904307e41706808c3ea785f601d835801f568e920b1c8f3601353f99abf5e3ba6eb0c934c3e07daa60ca98a996f7ad93bbf10e48cc8c170e58f0ff01a4d6d8ab61be4a12db3eb8fe06e8006b5702991dfaff1d006c17c5da29c06e823f92a14f86a1513f39bc724017db75403a90d432b1b60d930a104ba6c1fc1e60ed32fe7480b57c3180aeef3f39e09a267b2245a5ce284765fdf63d35c0b5cc019533899d69657505a4529a350e2043a6bacd640558ced7e8b10ca773706f05b00bc67f559774b0529cef7008c871e0b76f0db09476afa2a756b9603e0510c60e742af10a10e78f1cb033e5c18075b1ce0103f01920b339e18dc0a074cc924a800be8cf01023a0764f6c49a03f22e64e807f78c2d11771b0e7058d581b261da845a6adccf96e76949c8d700db85b52363304810115ea819b2827cfe501900cbaaa130b73f00aa1fcc0f0019f6f4f8d501d721270eb8dce6dc01bb279f0039fba21ff61d702c8d7da5b6721c036c0e1450fd7f225c77c03c5b75c97da2b92e9b9ca71ce71054eb00bb21e6575d3d1f063eb27ef5957c98cce3d3f1846f747c7902b07b3298a8472d37fa711cddb3015ca7c9930392c0ef1c10826e1db0cdf511503034fedc1be027cfdb8092ebd42f4f011d5f79dd34808732d5209e0ff694d4269e1844889003070879039023e45bf94145d2d829016ab9653c99bd1a1af88acc2ef73dfe05b4a402bef50ef0a47701968ffb267914661cc3dd0560ccece44d9e52e122bcdf73c006f67d80c560af160610505a3a50c1b6de1c7041f0830396e27f1d9098720f28f9497ee800d7c97ed2d6ace148ea85cbf44ec660396b22fd053078d224d88500bb2335ef001d3194bd0f018f8def9f00ec8cfff52b07b230c73f004be25c3b774033f095ccb28fdfe4af97b9a5f11d5e0362da763b01708b7bb8b66bc0aef3d807e476879d5aae2c6b760ccd28983bf00b03368a7df3136fa8d18f03f2718f00252da77c8715e0894307845d660ef05064e807ff841ba5030d5acb0823565b7dbf4a527ac3ed25c06c50a1775483d526e0fe00b06379d7f9c9e04c30881f000a964a4e9e011d42de535356f98889e6be645ad9ca7b78cf3bbc72f7fb0e3874770f5061610eec890a89e90cf7156001a27740e03f06585076efc100ed72790e6879e9c735a0b7de20ab5db94c2b3edb9426640d38759221c29b18c075d9612e63500f36885cc910601d287b03d8b91b7f2a583d0859223cfe069480d331a0d2e43da83600367b7d4b00bd01cd2b6bef1eaf19206796f45a013836315c97d5ae4bdb6692f18e41d7592af90320f570f4ed804cd913408d6a9f1f3820197de140ef38ce1d303bd971201ba42dbbcbff5f314bd280530f0d259962a56a6fa8a0764028eb11d07552dc4d7db6496da7ceaffa5c93d9bd1a3f2520666971fd1a90e0c3acdd020a9e38bf03d841606787004b265d93809adcf22e361f01762cde016030396aec3071c045e7bcc3a74dfb53408e513a7805543443da024cc8479f808627e2430744bf160ed88d9e01daaa5733a8a11a6f86e0025099d45340d3616154b03665cb7f105c0212bb33f6cd010b54aadc3214aeca9dc6809ec1621bf06f44be006418fab76b805d6a77fc05b06bcd2ee58f2d83e5b85fb274ad1be96f5eea8a3be6b34b89aceaa2830506608ee2f9c4002667ffd301c1ae230712e1edaf036eff790174c4f91fa60ea452eb7b06b085cac95b01bdf40b21d771cd34413daa1dba072dd700aa4ed5b776696a9a72ac1ed5a5636bb97380dddaf527ebd02d4fc65f81dd0660f7479dbc005aa6097ffb80cec03aa0677cd9d794a71bda96c33bd71de82beb3120c255581f3b2065e4d5017770af3b60dc972dec2adb18bc3635c05474d39e88ac135e032c0a37fa02d03d82e90dc05a2e9c1930afaf73a097b65307ccb4ee1db07fff13d05b304336a8abd31ae32875e8bc6dab6d406501e62b006d1b0452dc61ec183144bf012cea349231e853db6692eaa57d36a69b6e6c022cf36fed0f10630b2f67003b607a6d1fd0a01ffba7065087d30860fab179ec80f383ec2b7656f83a3fc96d27e8c10d204283d6c60ef05078a90b79fa02b0c0ffdd9b01bbdd25738008bf0c10423a56df1ffe49f46bfe6ca062098bea0fed4243ad03accf05d706ac57b600b3a7e7ab66a847714590fa6e5320b103d9f35020b5b3c2d33f406997319c0a0cee0607d69d08e4963173bc0648ec26b45780ade19c5c095423ce105136e5002a82190f3b0006f1f0e406d056dce7f90d30112a676205f4d9b31f81e55b5660af77400ce5c500efb8eb1c70a31205abc76ab970ef099013647ade05140df9520702de50410cf086a22e43bba085abc6aec7a9dd8278b12e9059daebfa9d014e3b59bb0670885710d8130de3dc4605b0de70a266180f9acc824c0048882a6ced015274fdef1fe078cf2b80cd81766b40c16d04173c310c8ddc32231d1bbb77719c02386722bc903cc6de0c11051b9ee164b05d07ea1edd97030cecc80177fb6c3a2057d25f4adbdefe39502c787e0a886c850699d6090af38608adb1c3c901a06f58193914181a1bdff216608d1d7480965e99e889286d716ab6df04323f54f51750621c372602b9a535aee70073147f370091b9f815c0b2d3df6e1c10aa78005832c7b73a6154dad91d85d4327289f531c09639a2d601e707cd1d9001f06c8066d0310a2bc052c99a0375b1e30c10031ecf012957e76943ee001a12fce90dd12064a4ae7e1bb5e38ecc9d959f5cc7bebe7f7b05188f29fa0720a557fe150299dd5c7c79e9804d8af70243bb70504b00b0dd716ff6444217db5838e009fb899db2ba5e022c51786dcf01772fcc1d90fcf40428f8ca5ae48055f31b80dd72f746f5f39e43dd75855f1d2f473a0948ed125bbb04d313000b54c164cf012193c6006ddba70ed8dc73eb80ed1de78084aff433406a136fd9e4b869cc9e22d361b626959287b2020465652d972b231c4529954ad28e639b37a4b8c9f2f0e715f8fa73a0ea9f1d1b307bfa06307bfa160362a4fe1302129c89d35f408a63f43632602bcdf695cc02bb9700aeab0c9fdf0506df52addf1f015ac6ca7903e8cd38ca5c2cefc2c683bd3540bb6cdc39600ef4e440ea90ef3960cb1d32ad536bfd75071c04163bd0674fec2b2977d756b23049d35ad8f6d8016d4bd19b9e997840cb0d1d999df552dc348dc61c76bb0db01397e20650da311b53408dc5fd050cde279b035b80399b5a1919408b09de042ccf0297955a07d8a1dd5f6b8094b8e5760ab04366379f01390a93ef0b9890c33276a027ce2f00290da58b3557403fc9771d700097bd34e39ab7537b22af19b4d494e9d0a398159c02ba96c9fb8901b3a723404f170ba60e54b01b999ce50e0822bd9f02594507bad018950dd692d33d42c09876791b03ccffd8fc0264094bcf5298cc1d81949f78f51fcf1c90a13a0364389b69e18010e3be819a1c92b903ce1f6b1c10b5de74a097be8f1d30b37876c06464ea80acdf23405e71c84ae48073486e1c707cf496013e7b60f228ac6da9be75b130e0a54343612d29693bb2a69c3920f74b4ecdd00ae46e8c1e01b693eb529d301ffa0b991937005b3bb99c037a0ef2d95639962b569ccd9000ecd6d09f0e50e3a19cf0d982eb1ac22d9534f7f1657202486997681780d483ee196022bc7b37c04f8e170e384166ee8073d0fc1d34e55def80359c35406153c01703b82c5fc8b4aef8ecd903a0e532db2b6a5bdbf4fef318d0738e624049ffb5dcdc01db29d5e796bb28586d7a07d8d6d052022a06b7871d873b80884eb8990168ec408b6d03b03c8333296e31b42d6b6b6ab96279c5854c4e0288b196e723404286d9fba5019b78df3b6037873d61b741bf450e3017b7005b4bdada0794bc742374803de527cbc33aa4637ca5aab97a3354f7581e45a1a120aa0cd0729f5b0eb8bf72d781aa7f77e74052dfdf0094e8d8e99e03d9a0d901c056355a59fea2c91ad61b78c73012d2facf80acd34f6ed509cba129f5d92b0d27e530b3e0f89305c0ae05b8bc06582ae0b91c81d28df4d52b20a2e5ce4e0036dfdfdc00d8a5a97f170e64834e0055c2cc62a1d97ce9fd363b0320b1a099026c61e8e8d5814a7a7f698066789b396037fa8d0336c319e01ede00210f809fdc9f3b60f5eddf139c933701d41c2b7171ed8028ed21a047833e7869336ef4d28676696c3f722663500d730fe969f409c8489d4dd700768ce495dcd1657683c06e0bb060d7b934799957c072cbb303dcd13b801dc8fe7e002831c11b0dc00fccdd02d8b5cc87b2745569c7d0eaf6f4415e6e933b80d9d39353406119551f0ec8e9fd02d07261b4e580c1731d50d9327aec80da9e1b6066116c3860c9e61f20cd2275c04936370e887d9e38206d2d03d89ad6e9be01f4e353d6b26aec980da5add5cb85430e0499006c0755a0e97dd5a69df4546b27753d9860163055fd61483603fb08b0838cb70e00b66abe75e880e30ba40eb5d776f4ee8055f34d408dc44ea60e08ee940e54f4e3b903ee8e3b75c026818903aeef0c012c2e05fd9e037681670668a8eb0707dc8ab0e180ecc17b408fc5dd90d757379165997c03ec6eb08eda3605c737565287ba8d709deea4858d8fa62395a3c9ecf6f44b19d866309f92fa5504b00cd5ad238035c3c6cc81eaf22ee7aa29ece62fed13af976b7c04cc14ea6c4ca6c1829fb808abb9011aea2e7540cfce1d70f3c6a103362a2580d6d6e63b034c46d267079cdeb0e38008c9ae030e64af0de0f6ac1f033a8cb452bceba61953b08a77b43103dfbdcc459bd8e1e197eaa66dd6338aedeaa56d6e8b4be72f00ce940df7d60005a3d8da11a0b6b9075fc9edd0bba313404750f6efd2002b895af31c40cfc2e196dc9eb6e030b140994c03b04bcb0ed43d964b7a1c8b27e56fbd8b9d8700d3f57cdd01773fdd03ec1ebcd3030744e11e1c90fb456d6b5b05bc480df093d1a7039554973f0fed56e090dce8275d6a770ac719a064145b97b9e832db79b0a16eda0ddd031bb409884959ddfb0394b69ab0ee80d8d61da0b669f53bc012b90e6f012dc671731b603b4236f96c61376dee4680d8e230546e180a690679c19dcb343b71c096aa09c0965aa7af0e38fbf8ce00f3ca76db01d7988f1db036ffe4808d6c73075ceefb0f70a7dfa90336f7fc027afafecebd030cfd8f0102dd2fea1e5d93abb103ad36d57d1a8ff4939b39804b6483502db75cf42343f5dc01918977404ffcf4f3c700d6f2402dd7e796aebe9d011ada65f30560e673f313d099872285e98b081fe6b003d46c633c9661eb6bbb1354e77e2dc5c33877f80ab076d1151803203a1a284771097004ea3f076cddb9764022c6a3014cdfb92c7fdf58b4677bf5d96694b5ec59ddfb1218a6e22ce94580029fee3405d418a5f70b031686aa000d0bdc5bc7005b29dace019633b1752f50d80954176b02a51d117af42230cc1cd8233102d40cd1a30f80d536bb111890ace5f5a703a63c95017e325a77c006768aded82a8fae471a4083271dafac5433f60cc4df33817ccceacae52d2066b0b87c3060a712af016c5ff4f695030e26c900162f3cde00d83935bb8f064c71d71c9081580a0c368823647f1da00e05c06e645bbb00d8f2c2ec5bc02dff9d5a6eec127ba06083c448bfdd358090a73f0ef493e6d9010b6588b08978c7f13b2043b5cbd5a0d544c3fc8580d927c0ae463bed04dc61dd3f073466a4df0096ffb131055856e7d1a940614bcfefc70093d8e9a180d745d7bd0cc0969f6e370d349ca3f8e480ec9fc281da25fe75c07174f60ec250818e3a5e01b2907600098768bcb78094c33b0375a0683902cb9e4aa5628f5a7fab57c65983b5bc528f8af31133bead3b81c2b25d766a80252f6c8d1db0a16e2e50fa0d75d28fb8b20dec542ef6eadf9f3a601eb507b0da265f0e54b093dc01399bff7ec29ed50d0368e1cd890396f3df1c700453e2802d55d465b9835d6365ef80c1f3de80ad13f2d26162c51da932064966a725adcf00ad6d96d467970b432ac7e5232023155009874b40473e7907b476e88c743d19dc40625b31a0e020b0139ea83a3288f665949265df96c4ce00b664131f39608e7cea404d791d1b4084d7cf0e38a3fbd70161869103967d28589312722db61cb0052072c00eeece002fdddf75a0974eada41975b9ec01390df5f6e180f4176950d2961dc1d00250776ce89716a69e6a7e3303d82dbb1b2a479a4516d9ac009ef4fc04b040f7f6b5013b87e406600b431b92479a5784d4ce5f0d30d5d8690406ab8d4ca5748334586f686a078a5a079b0ed813f060c02e52787380b775e780d8d60ec042e1e1b5030e7bf936409f5b9b3950cb3d1f024a9ae156455f6eeee11d67807c841bf80da8c72cd8350e48f55249b33ca58b5d3e030a034f0e886ec4003bf9e9fd1cd0309aaea780de460fc9342b6cbde17a0d90a4c460295895b20bfc720a28d89d7f3711309986d99e03ee8c3d04a0c9413572406ecfa701f3832a07ac04bc3be0b8c20b079c8574eb409f9dfc026c11639c3a201ff7d5404376e916a065047aef001ca211d652986ce851fac98dccf872d94776ec5afed8d2f211844c002d07f9eceaa5791ee1f65c7d0212bac7c5162067c677760aa8b0967bbf06cc75fa0674b80aef6780de26011a3df262cc4c7c6701b0d4a6038db7b90bf9ecd30142be76c00e990b408e3d2dbf0c58cb7d38e010f377079ca516036cf1203e73a079c36203604b034ffb808a3054a1fe52a42d8757dca8724536a25d36f601b6a3fd7a139093efb02501158565109de680d816648e00961fb4f300b00330a62a69e1a3c7e20b6022bc1f010a8bc2050ed8289d196048da7a7580f2ff032ca6cc1cc8d057f684058747bb0e3017b5015c85f6cc814c706b0523f6192849af29d38a0341ca034087d48b7b406f9b37f49532b394a22bc9a3f404bbf337805de8b02bc3561676bad8d68d01747debd401023a73c022d735c016ca76e6004be4da9247bf5cf7e03e710a36f463b5cb4f0230cfe0fc1080d4838710805a06d3d4018d7d65c0266773077ae2e5db81e4a133cb5780059929a0e2a5e35f03fce4fad1814478750720541184aa6d358c2fdcdc53006cee51c87c56d918cfe02c01d42372e0e5c3548365d33b7678e9bf68a094ae2accb01dde01ac036df4004bf53aa51c45c652da4e6580416bf713603b856b75a0ca6dd09d8192eadf6580cadce22b079c95b5e180f8a9ac43d5b61d67315297b6ebb8ed57d5afd37644bf7d30c0926f5e013ab26e2ed51beac1d2130ccd01259731ec6a54af0bdb2fb6b903484939dbba0058f5f70e012d42be556fa8eb88bd2b0ff2b5eb411e34259ff5eadf4d1d30255e006a2476bbe500ef73cf0141c847077a69ffe2801b1d1b0704cb3b4083b7357d73c06eb053038c1e3aa6a7a9db31b18bd907c0b6a7df697edba423ce1b0fd53d9a4193f593eb0d404dbef6f516a061c9f72a05d83ebe738d514d6e67207e6c19c0a01ca9f59bc252acf6f88aebfaf126c06e65da7d0398d37b2ac56d7cfdf6577dee5f58ffb807547c76fe6ec09a320620e4b0380010f90eafeda596087a123a5027fcdc76c067670e485b7b34a0f3600386b5657614c1bf730792d8f58b011bb4f849dbd8eca404f41d8756a937b499ddd7b82ea3b45c8050f52f5f00b59dca7303b0348b73d5b62d2c7afe7e0ab0248a5dde31981cd6924e0cd813af005b0839e48961d628999e95000414c6db0eb8f23207b43846c98601261257c70eb8937ce240026a3207fa6c3977c012c501c082d40f9474e82fb42dd56fedf8821b15bdf34c95e81dc0353c81f6480cad44903a507af600ec64d20b03b96d315307eaf20c1ff7eadb01bee5d40187aa6accee868652631fcc01b12dc57f00ec648e441da8f3eacf5e0104fe832a76406daf0d20e4cbca0123d0a50316ebf71c508ea903ae233c77c051729b0e34697e7804b09a102cee1cb0c5ecc401cb827f0ef03e29693ba2f56bda6518a3381f462fed7d67cacd14d090945604808e41fce611d0db62ac6c509fb7cc3dd6a574bd7b5b3b21c0728cf60e002de1f44b8d51bd6776ed6b3819bc0f3957818ee81a408475c86f002d324da98b8930dc3e02f418a5db03072cea9c3860879dbd946b228389f463f827ea507e18a013be6e0052ce630bde012d49f1e5ca336847c3048f79d495406ebb7d2eb6010d8ed1fba14061a9e65bb7005b6fd899011ac0cd58a0b4dba03f37040611aa5dde2680d8563477000d7a3a3906984c4f8f0026a0e2db00029a6602838058191919e027f58b017eb2d80458d06d7aed80c8843f6187871f0874630cfd9d24b6bcad82eabf005ad4f2e64920b3ed3fd73b808e40d535eff031fb40021ae72931c7dd1e6047631d9d09147682ee0d3f29fa8cd47b9e682cebe6741dd0a174776aa8713bb291f00730b645e153030499ba6f0324b7d41f0e54d2f1950305cb1733408490bbd8812c4cbd6b004d3e5877c0da6b6880149a9b0e1063b64e25a068d064bc1c295d54440868670f60376d1ed7809625cedd77800dc0c72a6954db7c4e77c70da54083c22802208f609600ac72dd8701e241e98303ccf8b1038e29de70c0dea6670354bff872c05e8d1920a619eeecb3b600712b11c63e4bba96d4e3ac27aa70a50e14e731e76b5ffd001a46c2ef5b408b802ea5417131e63cc7cb5740c234e1e40360c7271d6f012a9c9a9d1660894bbbf652f34f9ff889e958f0c04fda9825f0e9990184bcbd6d8086facd1cd09163076c44b972c0b5111d20c118e81eab25e089590a4819e7167340c60d421552ef928e2b62f5d2242d99bde68540969a4322eb901476e5e5ee0850d94eae0f406d47c87e01ec32977d152c296d77cbc603204a596fc800e6e2671a1b12afbeae975fd69595b369e580b5b53d079c97d31840c8934f07c894a20f12a3e50203ccd6ceb61da8e83bb9019af23d7220217f9e016a1286ee54b0e58e1069d0ee54c0e3303b06d84e19e84cd965b158f73893a14fdd839da972a977f5f90520b545ae230326b17707c42ea60e88499f38e01ac075037c4549692b40dafc9d0355ae7a71a097269f0eb825a20010f80fbad2012b9a130704983f1c70978d95b4b29d8ff695d6f293ed273dee860edf6b9717f5b29aa0c6ce323b93a91801227ac3812a97b9b9d8fc01543629fa04d8a9e67b927a5646843a1f3566674b33bd025d0eb0ab26cf0a00120b16f7000bdabf7e1a40a64de980f3c716801c99ce0b07d8e4d001271ded1b6042136d3be0f0ac0d404166e8e331c0a4feae712eeb461d37d3768098e0ceadea92a7dc0a19de4e0176f64f72299055b82c3af56d989a9a31d84c0016ed39bb005448fd90af1476b8c9e79f01acf69d5c85dce21fc1ec4dc0954e374d2c01423eaf1ce8a5779103e2eb147d782ddec5960315ec6aee80f393f70df095f6d68104141d3a2018da00885a07d3dc81be32ba3280064dec1d449cc3732ba965fdea508001d8be46dd87d3e65d449cee46836731f40655ff5a76acc8c7364417809238ffd52fa027fc7329890dee3a63f6d939a0c00fd2315f03b038cc9e04540c1d880cf74b40cc36c6bd3d0398cfb99ab2f086bab805984c475b0e08aa04004418685fe30ab04f2b77c0b94e5f06f84a9b3a607efbe94001e6871e50d272b3cc019fdd77c085eb1f0628fae1b703f22ede017e9d983d61bbc0bf4f00bdd9642ad7658cfbb7aa5c99da699eb97c9832b3c31aae7822cf69cad329c06e33d994cb520e0a822d4c0125aec2c60ec03609ec19e878c79e4c4e3978066c55517f297dc5eaeac50181087ee241b73f7ee2fdf662f67fd97baf658751adedfa627c3eca391c3ae72067fbcc39e7ecabff414c58abbb7777effdd57bf857512e795846e2613209022440f2254050807d1210c601e3501a570b242b671b0764454856807d3430ba382075a58d63221dde98a93c27aaa7258308a678e87d13658a444780ddbaa467dcd6241994aed75de24826c41716ef02ec22a3624080ddc6297330201594e740e5928088ecde3035f6317196bc793a60feb28c0b4819cf1fd876054cec248abb033231f664813847b330d807f2f2c5b0033235d2c561140bec5702a6e2a4b72507a4bd7eb6c07aba9480997d38fd7640d6e19842a877f2917adff8f5a91ba9899bac9cc6a3d2f58a1f04a4a44aea1b91a72aa3642279ca0199c667727f9a9c8bea156341d3992cef08ec8c15ea99d352cd1f1d9089a025076432c7d20229c8d78303b2f353c301d9da77e880eced3212200211ef3b60f468652d90fd2d6b370764f7a88280b9c4119e5a20b67e327e6caa1a02b231ab49cb2c665fac9934656e168fcab07e32246022adadb2c9393dce2f6ded95003baba26f349da5c252804a190b6420a29210601ffbb4520292d254e89ad6c56c3209cbfc42a3d8cc0914fe01b280bd6f81b4d8ca3b07cc5fb2ee2f920db396036610722b776a250ccc714056b61d2d90e72fad82005917cddb58d06c11b6252a2020b5943924c627cf95c79597ec98fa769eb22b42da4f012171d2edb88088b8f19ec9b9f9c43edfef0504c4c429d58d1b9fdba28e27913a0b0a1d1c100b2a0b70c99f5a201664b61cf2818c05571d90b730371c9029ef5b010b8974dd764026a5d93b5dc85f1636d2a5dd29fe6a81acb299c8559ca62313c7221693ee5bc298d442f591cd19f1a300fbcaa9bec9db45626edd8531ba4532222da5b6b1d3452a2ecf2b8b0701f675a66b63300b97fc9d9c3197e1f4c07aee800cfdb61d90458aee0c31dcfcce01793a7b71c0dc69f4ee800cb84f052ceda4929003d296da3b60eacaf5c301590f74764086b2dc5fa47a354b32e78b45504a4373638164d4f52d202c63f4978c03c60a5bc65d2c937653c47c4fc0421c4aded462cb949d87520b0ab06fbba98c1d9001e6b005b2a8a662811bb89b088889636bc81993a98c5cd54d4db89ccea554b64df297aa396a7a6be6018402f68585db8b00eb0c760f010b019db503267189b403d2d590e4bb8cda341c30f932ff01f2b0ad658174139a4b078c5946f30ec890dade0179c563d401b120498bca5bc9ec8e03f20c67e7804c147e59203b4014fd7ee522e872ae7016e0b670bb09b05d8d4ed50179f65a1010930765e58680b83c6ec9da33ecfbc42b5101f6bd6f85ae01f3a094866dd60097966dce015987937440b65ef42cb0ef9e2c3920d34df716c844e1bda47611b212861d3097dd241c907abfef80a981cc3ba77d208f397ee2107f5a142043bff47d9fbc0825ec9eb2e59701ee096f612fc06db3511230b5cf0a8c40a154c856d12301091972ad4404d8e995978301cea4924d039440b20b5e4f804bedc101a96f8f0ec838ffcd01796453b1406cbd7f77c0dcc7bb6d8158e164e780bc5bf0ed80694cecaf02ece8f96eef802cb54f3a20f97273c0e4fe786c810ceeec4f0222523c3a1f0b64b0ab5a15105dc82075dd01e30b8f0d0131016193da706c261b2bf6270624ec4bed2a1d0392d6f8cbc6b4c329fb8687ea5880759fed9780983cf3ac242db0717802ac05959b0e8863ab0998484bdaec08aad4b02e2762521bfe515d6edda96edef6eb0399e75871401297b14022dde72db00d81ad03729580808835ba810392954d07c4e89216c8e05f34e38074debf16c80e433b49ed226a2d190764416ed1028934f0b1401adf81b70059c1cdf52120297da09964c3222560626f7db694d5b5468f4832289da25e4640c276798c738ca88ea64c5b2b0908dbb7976281346aca12a96b8d378202a65235f64206d8d18dc0de14e488537d57754004ca3b20cf4d9f0ec80b1dee1648f3bc1977405e7dd5b04072ff367540de465070405e3c72734072ae26c0e55cc101b9b19403f2aec59fbf18c7b6ba5a2003eeb3a5033284f41610b353355e0e987cb90704a416b2979a494bd43d681f98ab44e3324b9ea8b1e468c26676626681346a5a1b039233695cd58d7788a6dc2cf9a48099d4b7f59801136b1fef9601bae760eed4185dd4693af61c900180a2002be126e58024ffe1803cf7b85b601f0a972c904837721f4ec275c701a95fa616d8f90e770764d144c6017966117140f631ba39602ecbca01534cc7310b24f9ad9c03a6c5b6b2898bdbfb783a60ec74dfb040fcfa6d2b602afd97f3d70199b369ef632e6062f5582ce54d79a654c6e2761641cf54e2b1a45d1ed6343716539e5f7a9e77014969f4564202ec52959271d2fa3d70f270fa29206abb2b5b0b440ff316331f1809d7330136a3562f0b44a079c9017363031c9099b2630ba4644f460ec8d8565740dc5ee566815c65117340cc21e5803187c5d901f1a73b07644cbae980c96cf3604857d012e9e2ea80447a714016b15a0913929698c9a8b82ad9d2425909b0d57cd7dc7a5cf53c657a655b807d83502525c08ed17b5d011329ea35d320894f9311d99ad3f8e4b8537d96b540345d440558c5e6350764357ad5017921eed801696e942c10275d793a20834c7507e4a19f8b436ac248c501d9a22b2ec0aa3eaf3b2025fbe70c59819970c098e52cea80ccbae939207b22742c10e39f970524a52170b4c99f488d9c303e28114f890bee981b4b287f2adb4919af9dd0ef11f5c1a32c202ee5655e11e0d2927440d2927640164c151d9007217107e44d8a370764fb938003d2cf3e5b20cdd17bdd01c9978303261b663101497b630b0764dbe6ac03c6a4a679078c1ed1bd05e23e67330129fb978203a6692dbe30a15f3deac721d549c26543dca42519b7b3d323a67824554e4a6b7c6e40322173034b2d010bbb40c8f842e53ded5cfca58088347a4b6f0176626c2e2cc0eec25bb371d809ba95a08085f4a3ca72d94948220d9ad426b522460fb9d31f4d730e188126210744a0b403e6d6432907cc9d0e4b0e486d3ab440ca5c2deb80bc2126ef8078988303f292f28c009b73939303f2faac9d03b26a31ef80eca6b5b2c0faf5b503b296c75ed63ea2e83c2d905b3f5b81664be9029a5a2cb90c2d658d84296229b7bd67df94db5432267565cb546b29d52c9659d0750111e934378a026632065bef0a581a1030cfd5d58d27e4c6ccd415fd1a5ed134fd70c064f6e428c029b6774096640e1d90f725790e486551b7407ac0dec701d9d32de780b9b167c50119a40e3a208b9d0a02ec9322060ec803bba503f2fea89e03d259b5f731b1ab4ad20ec8ab49ac62f651c9256f81348b4726717a9733190030ee6292b47bb9b6f3029252f64b2b0176a181675a17135535ca1cb48780851deb33e5453f6e90c499e6c6c4195deaea80b9d364d901795056b240dce7abe280b4fa860ec872ca870312c7c701d38f622ec00a942c39200f855b0ec866840307642246de0271f4c98200d9dc95b3057329403d63307a2741739587b9b169ca3ef629bd044c45e46e5c806cf642d39e3193897eb5b080850ca7d78cad4f2776d795a42962d39fc4351d90877e1d07642eedd902a95e7b1b07647434e4802cdd5939209b68d41c30776a7616f481ac6afd3a201b2c350458096331076494b6e980d123161160478be736b57379e07fce0a5848f77e628abaea13881f1b9a368c5edc230b952202c2f6a98669a1cc12767bcf8eb1c259ca6e5fd07c0ab0abd1bd8000db272ca52d90b6653528c0eeca5331963c9bd89e45a72120263d8bb8718e3397516697557f69826cb95c7640e6c04be29c84b1ad03e6b2d1b403e2821d909c7b0f1d902276724022dd08b0d9107d3b60228dad1c902ecfcc0271b0bd9e03f202faa7032671d1af00f7c8e6e58089f49813b0942ee049f4580625f7a76b01e1a52c7830f7318fcb162a444c1b779e08caf3dbb2318779d26ed3933339374fd949e0a58f80897d8fb7a909e74eb1d85a8013e8e38034ae1a0ec81be93b168840ed85033209bcee808c3bdc1c902789650764272c7715a90ac27d0156c270cf02b9ec78e480d1b4187740d6d0941c90e7b7790bc4f5853d014b8974644ad4c2b51de2c6a41689999d7e6b6e5d352fecbac69c00fb6e8e82fc45a96ee2a89b5b5f4ceca4e7ee53404c7a7c1d04a46460a611126037a86f187358cced462d61d3495cb86cd89e1d90aae007c85fba02aca6a1a405124728ee80ccd6bf3a200e36e0804c9b0f3a20b5fadd0119c81c3820ef294a08b0aa872e0e98cb062b0ec84b211a0ec830e5c901d93125e580b4b58b0e98318389bbace47ed0d8a932067b959a03b24d4f5f4048c661a61b015171d293a980d852e6d19b9c5bba72db37b5fa326977c16b9976f252b960e937742d90e66855e298581b6b940458bfde7e0b48c8b3b59a31eda5cb86d05980d3b4ea806ce4337040c62e6e0ec8d4b7ad03e63e261b07642770531a964ec271c00119409c3860246cb71c3012168a0ec836b44907e44d8a710b647c6cdc17103257094c6da42139a37c1110969c3be71d900e6f5b80cdcaa1df645906e351a95e070f031211c9ca685f404c96987513064c42d20eaa450424ec90eb40404aca7ea729c0aed0f5260e18fba89f0c584c640ade7828c066d4786a80137974744026d79e1c90d93f7b07cc55ca5b07647fa9ba0346f5f5d201d9ff34648114a0ced7019396310242f6c60e0ec84077d701e99ca51c90696b47078c62ebb40592b7af9280b0549e23bfdc2e43b19438e958ce80644c0600ba2f0326f6f5bf239373a11fc5520ec8d856d601d9b8b7e2806c0793146013372c3a20a34e1d074ce2066d07a4c5767340fcd8c201d36d5ad42c10d5a715076444b1e48034140b02eccc8c7ecc0173d9fed501790be2de0289b4f67440fc98552c62b783590a982c65999ab9d37032290f317a790352b6fb5630791b9e84e47954bd2f20299eae1310b090e231f00c708af593025ce22e0ec822231c90859f3507649be28303d24e8e39209eae6f81243f527440bc655c40442edbeb38209b34b51c900d419a0ec8c3d89703f2ae7877865cb63976c05cf6bb10101573b87e04c49732bd72eb80cc1b37591949c4a57834aa064c66d6e50c05cc6d85e30958c823df8e494b641ab213a84c418e38917b6d0724b512c78f1e6b07e43d9a550764416ed10179ff4bc682a54ccfee3b20cbe42b02a2124727e180bc7af36881c4617636f6818923f5764096dd4c05c404f48d738c26edc8447563406a214deb8ec9fde8c46e775a2c0ab033219b6f01763e4c3729c0be55d6eb09b0d3b3bdbe00bb0168c3a4363a0dda057512e9d4d640ed8f00db39ab052c90f9851db9ecd2ae08c9ef2d1093fa241c903aeae48058e1c601d9b83725c065c3c50119746b3b2013415b0ec8638eb40326f7af5b0b6c1f79ed8034261a026212697bee8074bcf316485606fb0ec8a0bde4edd24e47be142c58caf46c4f40424ad4a9ea802cfcdc09480a88189163c9886d4cdc04a42cb80b984b1dd5281ba0325bde076cda0eb1a99d375e8d3a20b3e46b0264288bfad8013198ba80883d63e480494b6722202a25bb7610109338bca980949854c7d41e3197b79db30362854d01365fbc8c0372c6cc01e9de3f1d90e646d402c9b9d3dd0111e82bc0e69c9776c044da0c3b6022ad162d105b6ff51d90c7a4920d2a2be5cd70a66e88bb89d34363637a72a989a36f7c723c651d6cc514e4f8c4ee34509538264b71b05d534ce34a75a9f83c01f6dd60edb400fb58b01e1690b23e792a602a7ff14cb327ee34cdc62c90ea245c774024cc0ab012b63c0744c2a803f21aafa90522e138ec8034ad7b0ec83e684307e4c5011101091be9cc0289b4bc7640de8a907140deef11774066ed350524a5261c0405a856bec92893b844d26e9d5635f79150f92283b2a6ed9098dad9d8ddaf00fb2a0e6f28206e27934a1cd38494a8b6fd4bd276de5b025272463d24602ea0694c2ae1346d4e04583d1a470764cef7db01d919ece48049dce5e72fb2c9cad70179bd2b0e8877b067246d33b0e0804c298a3920fb16571d307abc3b0e187358db48539251d3bd0332e9d9fe65b294e6d7cc019961661a9b7aa99bb8cf97809914c2684fc0d23ef631154e3269fb733d9396e4242259d9fc0898d97d15c20216e2fa2a03017630b46beab9e4d48ec2d5a202226241adab80a8e47e3323c0d6c8cdb4006b418d868089adb32702ecfbb4ea41014b3198867139c9a5dd36b1feb24032aa2e89fbc9caa203d286293820af470a3a200579e580d440390129f94be5eb80ecda747240dab86f0193a53ce26c3b6044eedaab4c97329f6ee980cc973267a4122179ecd3378aa552b66b5e380858ca2e232d636329d7a4ad1a77919ada51386f24c0f6c4db1901b69358356d879413a81872c05ca5f21160f5286f1c90f79c951c307f79961d9079d233078cc866b7571f98cc2e741c90356711011389b45076c044babb3b20ef184a3b205552d301930d4f7b59e72d8ddb9aa4e652809a26b327aa7521e52525202a0fdb1a4d014bbbbcd4d8a9ea77cb1c456f6c81148fa22973132750a1e280ec5c7b74c0e45c312ac0263f7f744076e10d3b202fb3ad3a2073586b0ec8f3ca820346a0fc41c0d4461a71401619851c906d68470e9848d71f078cc866b713ede7c4d3b5c60ec8623863a753d5dc904def4c6998269232ea345c08984acb71608a987ee19aec83267f99846d83c4b472544b411c5b0f015139a375109090d645332bc0befabbf51060dfa2eacd2db09ece7818557e6c899238947f95f1b1a90576e2d24c405c3c5da32dc0f64db326b3a72e2b435f07648fee82009b2fdf8903f2eade8003265f3e29076495ded1011369b0ed80c9a8f45ec04c227d0f1c90ed2d70c0446ae628fa409e7b1c1c90b171917039174f577d38200b839b0296028ac6d1cf264159ffd26f0a7023ce6b0171eb2d57029292d93d9351b3a9dd57a1161360a778b72e0266d2b6acc505d8de49eb29602925bb657a38b359d0364723022292fb9db680a8b5a0a080983d6326206ee3580a48884fce189f3c73799bde3920799b74c06443fa20c0e55ccf01f39767d101f397f3c301d92b2beb806ce03775c0dcfabb2b606e232d3920cfd58b0ec883c38203621f4707648dd5da01b18fa703d2a1b90bb05efb9113e00cc65c65aebdb4a9a34c75329fda055355d3df9fcfec9ac46a524048fcba3713603d7f53229dd9564eeb282026e6d034c99fcf8332efc25b09b0b9ff364e69fe930d050744b1920332485d136035bd571d30675c530e4853f2e480f8a08603b267060216f297cbcd0129a65d0764f64fc70193dafc4b8055bd64ec74310dcbdb2ada265f16b3a99db1fb03a4f234ce40cf08909d6c4cddb07089bb051c90fd1c270e88c1ec04d8b49c6f0e485a960ec88b24170e985bbf9c042ce52f97ab03e62fbb9b03925ae3939793b9dd47c028b69cd9b74256111093a1dfd65d801dfdaa472db0a31b1d01f6a9a81712603bbcb58405e2b6bcb000bb4579eb24606e6ba0a30562fccdbc8085f563670176d94db36c8134cf5b26b397f3b0bd8fa405d2d8f43602ecbef8f58300bb56a3f51690b471a42c908e447d22c02e60af9bdc5f2e827660662d40de594f5d445ed8c19dda5c809d015097e42fa36263978b006b1fe7ab03f24a90ba03b2afc254807d4dd3e56c818de3ee806c06547440de28cdff1ffecf835136f0bf8789779f7af7d91fc3dc0f8b3f86a51f56de7ded878d77dfdab0f3c3de0f875fe1e88793773f7bf78b77bf7af79b77bf7bf787777f7af797777f7bf7cf1fc3d786b477cf78f7ac77cf79f7bc1f0adebde8dd4bdebdecdd2bdebdeadd6bdebdeedd1bdebde9dd5bdeddf3ee6defdef1ee5defdef3ee7def3ef0ee43ef3ef2d3f8ff208e0e46d9f1ff1882be8e4b5f292350c8bb877f4913f9a54ed4bbc77c759c40462315e2de3de12b95fc25965227a502010804084c084c09cc08cc092c082c09ac08ac096c086c6dd8fd0aeafc3d8103812381138133810b812b811b813b8107812781178137810f812f8134818c6a05a9ce2981bcea2ca9224da044a04ca0e2a7f47f154782710fd5ff3ad408d40934fcabaafb6efa021975d4bdb6fc54a9e011682b698ced58753a04ba047a04fa04067e18fa6144604c204820e4eba53ec3042204a2046204e20412049204524c601260326132653253ad775579fa42d83059eaa0649aac98ac996cb458932d931d93fdafcf8356539f7354ed13fbdf139333938b0faf4c6e4cee4c1e4c9eff8b3e3f4299cafdf55f8737930f13655631ade324cd24e3ab63a4d9586942da7c262a8539262a6d0526ead64b4cca4c2a4caa4c6a4cea4c1a4c9a4c543c1e9336938e6a43fd41a97f0d5aca9336b7498f499fc9c09752c937f4833a18311933093209f9a79dfe31b63093089328931893389304932493d4ffa2cf4f306d75feeb10603a613a653a633a67ba60ba64ba62ba66ba61ba65ba63ba579d43d5feffdf34fadbd49eb41169335cfa4535e79bdb80e9490b373d33bd30bdfa9f37a6771f9ef4095ae895ffaf7f883fc7f4e1e787b9d64047a23f9f4c5f4cdf4c3f4cbfff8b3e3fc1289bfe63c8d8f0279865aa6e25cfb4c0f47fb72c1d56da22b4347d3f8c989698967d392abe1c079f5499d698d69936983699b6987a4cdb4c3bdaa6a65dffd71ed33ed381e6ea5fbaecf7b4f4ff6c95d3215375d131d320d310d330531561d4de67541f2b1b9fc698c69926982699a67e09f2275932ff107c6567fc0a0166131b02bfc294d98cd99cd982d992d94a24d3791ef64bdc495b969669e0a7ffca6ced97c13cb30db3adf6624a8ed98ed99ed9c13f38323b313b33bbf89f5b5fac1a33f5df1bb33bb307b327b317b337b38f6f92175dcc759cdf7f2bda5d666966196659663966ea2f056645662566656615665566ea5a75660d5bc2d4094d662d661eb336b30e331549cf4f7be06fc2e48feab9609ae2b3be0d0366c35f61f42ba89fc6cc82cc42ccc2cc22fead647c09a2cc62bed16db434b338b304b324b394b63e2de89939cc03cc27cca7cc67cce7cc17cc97cc57ccd7cc37ccb7fe093be6beee73158efec9ea2f27df7bf6fea568eb9aa7ef67e790b9bae285f995f98df99df983f993f98bf99bf987f997795acb3acf30cf32cf31cf4b24735fdcb93a28312f33af30af32aff9c937128dfe18867f2146ab81afecbcfe5f84067375c916738f799b79c74f4c887997798f79dfb756f575a00b9412455999d25489ab74990fb585ce47ba206b59c7cc83ba80cf43beb2615f56bf54aa5c994725aac9eadffd8c72a9f398768e73f5c704f324f3140b5804584c584c59cc58cc592c582c59ac58ac596c586cb5ac8b1d8b3d8b038b230b6bfeaa086a3f536671667161716571637167f1f8831a8be73f69a57e5d3c7d6517af7f0b6f161f165f1669161916591639517691675160e1df93fe5af2cb75525bb1f212aafc2ecaba7a51055cd9e9a2c2a2aa355da884d5b55b5834fc021e956aea5fa55426a9d58ffbb13559b458a8d8da7eb9b661d161d165d163d1673160316431623166116411f24f08b388f89a4659c458c45924ace1f7c5712f922c522c61196039f115f0c372fa13fe49aeb7afec7266c3dc0fb33f8605cb25cb15cb35cb0dcb2dcb1dcbbd7f1f1b6d744ad9e5c177fc155da528db5c1efdcaa7a74d7879d29f4a7165b04a14a5b5b24af5c77f29dab6ba53522ecf3a0f9617965796379677968f3f4a19d0e566f964f962f9d664f961f9659966996199659963996759f07f2ab22cb12cb3acb0acb2ace96c58d6adabcdfa25acc5b2c1b2c9521d782cdb5699bf8af3b7c128dbf99ba02ea9eeb8cf52093464a9241bb30cb20cb10c4b615c4674c296515d4da92a7e19d30e54b90255e4958eba723bf8cda0beeddefc43c8e8ec59c675edb74cb04cb24cb142976e558fad027f50537d5d4d6c98fa9f335673560bffeb92d58ad59ad586d596d58ed5deffd7419baa127475647562756675617565756375b70e41fdfa60a5aef862f566f561f5fd7b89fe36988715e9ff1432acb2ac72acf2ac0aac8aac4aaccafef52aacaadaa6b41b550950775cd777a35c9eca70dd4e584b0fe7dfa51cb26ab06ab26ab1f258b5597558757d157aacfabfa4ecff92d2858136bdd550beaaa2bd1ab11ab30ab20ab10ab38ab08ab2523cce2ac12ac92ac51ad601d613d653d633d673d60bd6b60c29535075c37ac57acd7ac37acb7af73712fd53f0955defff5338b03eb256d738b3beb0beb2beb1beb37eb07eb27ef94d9f16ebb7364cdd903cfe6d334815fcf587f597759a75867596758e759e758175917589759975857595758d759d75837593754babb9f658b7b56aaabcff5956f56b877557d748eb9e9675adc880f590f588f5987590758875581bec3ac23aca5a9d13679d609d649d62039b009b099b299b99bddb9e56763367b360b364b362b366b3f91b95fe36f8ca6eb67f093b367b3607364736ea32673617365736373677360f7f14e31f4bb76e6ffaddf6cd93cd8bcd9bcd87cd974d9a4d864d964d8e8dfab5c0a6c8a6c4a6cca6c2a6caa6a68be7a6cea6c1a6c9a6c5c663d3f65b20bfc4dd74d874b5575519b0f165ddf4d90cd80cd98cd88cd904d9f8f5d526cc26c226ca26e69f10679360936493620bdb00db09db29dbd98f1da8f6f876ce76c176c976c576ed0bf25795fe29f8ca6e377f095bb63bb67bb607b647b6ffd82637617b667b617b657b637b67fb60fb64fb62fb66fb61fb659b669b619b659b639b675b60abfe55625b665b615b655b635b67db60db64db62ebb16db3edb0edb2ed696ffedb60b77db603b643b623b663b641b621b661b64a9428db98d65419affadcc6d926d826d9a6d8c12ec06ec26eca6ec66ece6ec16ec96ec56ecd6e63c50db3dbb2dbb1dbb33b68299458ff41a57f0a7fa3eceec8eec4eecceec2eefa1f74dcddd8ddd93dd83dd9bdd8bdd97dd87dd9a5d965d865d9e5d8e5d915d8a9934beccaec2aecaaec6aeceaec1aec9aec5aec3c766d761d765d763d767d7603764376237663764176217661ed1955d97736ab5af8bb08bb28bb18bb38bb04bb24bb147bd807d84fd84fd9cfd8cfd92fd82fd9afd8afd96fd86fd9efd8efd91fd81fd99fd89fd95fd85fd9dfd8db4a4c7523f70ff64ff62ff66ff61f2dc8ff81b2fbaf8e689f669f619f659f93eb295fb9cfb32fb02fb22fb12fb3afb0afb2afb1afb36fb06fb26fb1f7d8b7d977d877d9f7d8f7d9ab1b1db21fb11fb30fb20fb10ffb9f11f651f631f671f609f649f6290e70087098709872987198ebd2adabaffe1fbcc161a18bbf32c9c392c3ca0f6b0e1b0e5b0e3b0e7b0e070e470e270e670e170e570e370e770e0f0e4f0e2f0e6f0e1f0e5f0e690e190e590e36a5aafa55aef690e750d0e6a5a4f83f5356b915955187a28efa50fae9891fca1c2a1caa1c5492ea1c1a1c9a1c5a1c3c7dc2a1cda1c3419dd6e3d0d79aaa227f18684d0f430eea73cc21c821c421cc21c221ca21c621ce21a1ad726b944a724871846380e384e394e3ec3fb50a267faed694c447bfd5a5ccfcb8e0a8beae745fe0b8e6b8e1b8e5b8e3b8e778e078e478e278e678e178e578e378e7f8e0f8b48532ab1b91c717c737c7cfffadb2ea3ebe1cd31c331cb31c6d661ef31c0b1cd54189639963856395638d639d63836393638ba3c7b1cdb1c3b1cbb1c7b1cf71c071c871c471cc31c851a53ccc31c251253bc631ae053d267c69921c539ce014e034f1c3f46f6555e134fb11f734d7adab93df66507fd7b5d6586b7d5a705a725a715a73da70da72da71da733a703a723a713a73ba70ba72ba7172adda0727159e9c5e9cdeffafca9e3e7f13be9cd29c329cb2bfae97e394e754e054e454e254e654e154e554e354e7d4e0d4e4d4e2e4716a73ea70ea72ea7152a91d701a721a711a730a720a710a738a68a7798a7252a2c43925748daf9a50a7a42ed47ac4a4e77ffe0aaa01abaa7b75f0b772a7b47350a29fe11cd025e03ce13ce5acc89cf382f392f38af39af386f396f38ef39ef381f35127d0b5bdce27ce67ce97bfd7e79f82cc20e07c95471dfaf8e6873be707e727e7971efe71ddeaf39bf387f397739a73867396738e739e738173917389739973857395738d739d73837393738bb3c7b9cdb9c3b9cbb9a7edf4ac621b701e6a733b8f388f3907398738873947384739c77e043dc77f9455cd7e95017f6bcb2ada846ee7aa6aedac428a0b5c025c265ca65c665ce65c165c965c565cd65c365cb65c765cf65c0e3fae560f695eb81cb51a4a96cb4907a79226671f5e443df379b96a78bec9c493bfc8ea07d5f2bfdcb93cb83c7f72f2f2e2f2e6f2e1f2e592e692e192e592e392e752e052e452e252f61b923d5d715f2a5caa5c6a5cea5c1a5c9ad2a7bab4b878fa57d54f55aa5dda5c3a5cba5cd425fa5c065c8662bfea5727ab0a971197b11e06543d8bff68b9da3f0cb904b984b884b944b844b9c4b8a8ab24b824b9a4b8c235c075c275ca75c675ce75c175c975c5752d0317d33bd70dd7ad28fb5b99bf0beeb4896cb771e3bad3fa1a7ab9c9b182d73dd70357db4f551dadeb89eb99eb85eb95ab3a475dfec1f5c9f5c5f5cdf5c3f5cb35cd35a37bf1aaa6be66b50ad71cd73cd782d65129782deaa0baf0d712d732d78a36cf6b551773ddad6a682bbed67cb95b5ceb5a59f579f1f34375a8ae0ded52afcdbf5556f7c786daa55cd5df3dae6daeeaa25dae3dae7dae03ae43ae23ae63ae41ae21ae61ae11ae51ae2adab8757deade125c5524295f8a1d37449c5be0472bcd033fe2de26463d9970253f9b3fabdf14515f752c476e536e33e971a93cb9cdb92db8a98315b735b70db72d37f5c73db7033775fe89db99db4577ff6f575f9d113775c9bb1648f5356f0f7f2864a88dfaf6e4f6e2f6d6e55749a974514d4ead698ddb87db975b9a5b46dbaf33db5b965b4edbf2df292bde76a2db1bb73cb702b722b712b732b70ab72a3715799d5b835b935b8b9bc7adcdadc34dddb0baa5be352395ba01b721b7912f08a2ac96cbffaae54e69b9f44f013ff8e7f827fc5256ce367f1bfb42a7b437b805b985f408a1b9de4d4913e116e516e316e796e096e496e20ef700f709f7a9eec8df67dce7dc17da76ee4bee2b5db4ef6bee1b6d9ef7adf603f71df73df703f723f7936ed8dfcfdc2fda30ef57dd7fbddfb8dfb5d667df42550ead7be24c94eecac6ffa1d920ad85b19caf8ac8fdc1fdc9fdc5fdcdfdc3fdcb3dcd3dc33dcb3dc73dcfbdc05d9d665b992adccbdc2bbe795965c40ab121f08ba77e7f9559833f41d17b8d7b9d7b43d760fa81605e3f327195e6bdc95da5dce3dee6ae12aff4ea71ef731f7057228eb88ff530ca3dc83da4abfe7b987bc44f5594bbd234ce3dc13dc93dc5031e011e131e531e331e731e0b1e4b1e2b1e6bed341e1b1e5b1e3b1e7b5dc01f07dd917d1c799c789c759ee9daec2f823efcbc795cfd712f7f98e671d3b5a56ad26dfd06996a203fee3c1e3c9e3c5e3cde3c3e3cbe3cd23c323cb23c6c2bf391e751d0ae56cbf22795aa3c8aa2e3ef9fecaf327156077d6ac9ff2ceb86811b9e989efc67ce557bb10a0f754e8d479d47834793874a86c7a3cd4369d1e5d1e3a11233e031e431e2a1b408f208f108f388f088f2501af995d223c123c923c5139e019e139e539e339e739e0b9e4b9e2b9e6b9e1b9e5beda0958ecf1dcf3dcf03cf23cf93ef22ec488d19ee52e179d675e3f3c2f3caf3c6f3cef3e1578fbe4b793e79beb4f351fa9abec9f3cdf3c3f3cb33cd33c333cbd32a3b1ff2ccfb492e8a94eaf359f03f8ba298814a40a39e3d4d660ff32ce95375f0ed3f90fb51f6a9d2a322527750f7bd8192a0c1b3c9b3c55325a0cdb3c3b3cbb3c7b3cf73c053ddcd88e79867906788679867846794a74ab34a58826792678a17bc02bc26bca6bc66bce6bc16bc96bc56bcd6bc36bcb6bc76bcf6bc0ebc8e7a68e675e275e675d1455bb9d14d437ffe76b5ea5875ba5e575e375e775e0f5e4f5e2f5e6fdd147b7df41f9539bfbeda41bdd2faeb2ba3c57d6579e578e579157829681dc2b4cc4b850aafaa96480965ac50b42ad803f5979afd5af0e52ec944ed5f67d47935744bcb44fd6af252b7e2f16a8bb21aaa447679f578a9db1df01af21af11af30af20af10af38af052298cf18af34af04af24af1867780f784f794f78cf79cf782f792f78af79af786f796f78ef79ef781f791f789f799f785f795f74d0f0ba8e6c1fbae4760df0fde4fde2fde6fdd2970ca2ae7fb56e1cb3bcd3bc33bcb3bc73bcfdb7f4ea3fcc0bba85dcdbba48d5739fd7759fffd5de15de55de3ade26ff06ef26efdb8dab7c7bbcdbbf323d16fb9d4f1bbcbbbf78b2ba22ccc28fb1ee8df240c798f788f6dbc41de21de61de911f65df51de31de71de09de49de293ef009f099f099f299f199f359f059f259f159f3d9f0d9f2d9f1d9f339f039f239f139f3b9f0b9f2b9f1b9f379f079f279f179f3f9f0f9f249f3c9f0c9fa7fcce992abea34a59d2ad49f3c9f029f229f92f6b69fb26ec029653f153e553e353e753e0d3e4d3e2d3e1e9f369f0e9f2e9f1e9f3e9f8156f3a3fe38d226fc19eb36cc27c827c427cc27c227faa3ec27c627ce27f1a3d227c927256a1af2e597803df393afec37c077a2ffa93ebf53be33be737108df05df25df15df355f3b7cf9ddf2ddf1ddf33df03df23df13df3bdf0bdf2bdf1bdf37df07df27df17df3fdf0fdf24df3cdf0cdf2cdf1cdf32df055f194f896f956f856f9d6f8d6f936f836f9b6f87a7cdb7c3b7cbb7cd5adfb0e517946f5a944f9aa5b1df21df11df30df20d69715533ee98d2cef71be61be11be51be31be79be09be49b220de900e909e929e999365b1595f2bfcaa5a4e7ba879d5e905e925e915effcc309bb6496f486f49efb464e93de983564c1d28c5d4a73a36a26bf57c19f59966be814126a48fa44fa4cfdabd6a11d5dd5c485f49df48db6a2dfd20fd24fd22fd26fd21fd259d269d219d259d239d275d20ad4e2b912e93ae90ae92ae91ae6beb4b37483749b7487ba4d54d77487749ab3bee9356f734243d223d261d241d221d261d211dd586998e918e934e904e924e91814c80cc84cc94cc8ccc5c8b9e5990599259915993d990d992d991d9933990399239913993b990b992b991b99379e8a290799279917993f990f9924993c9fce1b158264b26a76ba01f950ebea6eaeaf93fa827415baa59ba53d0c1d04c914c894c998c6dc066aa64d44dd7c9342c69926991f1c8b4c974c874c9f4c8a85b1c901992199119930992099109938990899289918993499049924991856c80ec84ec94ec8cec9cec82ec92ec8aec9aec86ec96ec8eec9eec41273e7b247b227b267b217b257b237b27fb20fb24fb22fb26fb21fb259bd6ce549f9f219b259b239b275b205b245b225b265b215b255b235b27db20db24db22eb916d93ed90ed92ed91557f1f901dfe0c20644764c764835a255595a9cf6c481453075a345fc06cd8ff8cf8dc2c48505f14cd46fd83986ec966e364ede4866c926c8a1ce4023f0f147213725372337273720b724b722b726b721b725b723b727b72072d6bee48ee44ee4cee42ee4a4efdf74eee41ee49ee45ee4dee43ee4b2e4d2e432e4b2e472e4fae40ae48ae44ae4cae42ae4aae46ae4eae41ae49ae45ce23d726d721d725d723d727372037d48d59256e6e446e4c2e482e442e4c4edd46945c8c5c9c5c825c925c8a3ce403e427e4a7e467e4e7e417e497e457e4d7e4377ee7c8ef79e6b7e477e4f7be70be4af9832866a43402fe1ceb60940d933fda70227f267f216f1fd2e46fe4efe41fe4edb84cfe45fead3be3f90ff92ff934f90cf92cf91cf93cf90279754e897c997c857c957c8d7c9d7c837c937c8bbc475efdb743be4bbe47be4f7e407e487e447e4c3e483e445edd924a4054cf22c8c7c8c7c927c827c9a7284021406142614a6146614e614161496145614d614361abc52dec28ec291c281c299c289c295c285c29dc28dcf55c93c283c293c28bc29bc287c297429a42864296428e425e4f949afa22a8e67ca140a148a1f42394134d09aa0f0e3e8cb813cc8a29759932858a7625852a851a853a85864c072a3429b4287814da143aa26ca14ba147a14f614061486144614c21482144214c2142214a2146214e214121492145118a018a138a538a338a738a0b8a4b8a2b8a6b8a1b8a5b8a3b8a7b8a078a478a27ed348b678a178a578a378a778a0f8a4f8a2f8a6f8a1f5f41f5af2fc534c50cc52cc59cb41694db2de6291628162996289629562856292a5ed7b31f8b0d8a4d8a2d8a1ec536c50ec52ec51ec53ec501c521c5913f2be5ab5d6d714c314831245aa9cf6298a2d5b118fd39d65f238a98057f11f94d8718c538c504c5a49e2a6d8cb498a204a5809ef16a486942694a6946694e694169496945694d6943694b6947694fe940e948e944e94ce942e94ae946e94ee941e949e945e94de943e94b294d2943294b2947294fa940495da2a43b5da53225f559a554a354a7d4a0d4a4d4a2e4516aeba6be52b0d4a1d4a5d4a3d4a734a03494ce556944694c29482944294c2942294a294629aea7e5961294927a726e2945193df5af1ca03ca13ca53ca33ca7bcd0932175ffbe4079497945792d5a29e355411debcfa856590ea2f2b56857f7ff316c29ef28ef29db61e0f291f289f2593f881772a17ca57ca37ca7fca0fca4fca2fca6fca1fca59ca69ca19ca59ca39ca7acee4cfda544b94cb942b94ab946b94eb941b949b945d9a3dca6dca1ac92d7a3dca73cd04dd4f290f288f29872907288729872847294728c729c72827292728a0a5402542654a6546654e654165496545654d6543654b6547654f654fc11d18a0a272a673dbb5489bb3c50b950b952b951b9eb79bb2bf4ec3165c2ea4c3de1b948e541e549e5f517ad54e46f3930725bee2b5bf950f9daf3be54d2543254b2546c1fb792a752a0a20e6cb7af52a652a152a552a352a7d2a0d2a4d2a2e2516953e95051b7d5a3d2a732a032a432a232a612a412a212a612a112a512a312a792a092a492a20ad500d5892ee0f70dd529d519d539d505d525d515d53555c5b7547754f7540f548f544f7a2e78f5acfb2fd50bd5ab9e9f513533eb15b9fbe141f5a9676eb995217ae5c24ecf98d243225d3d0badfad2f379ab6faa1faa5faa693d0975b697c9a6cac8aa19aa59aa39d1ca29668eab79aa05f9551d57ccd31a83f467de0f45aa25aa65aab6e155ad52ad51ad53b50daf6a936a8baa47b54d5525ac4bb547b54f75407548754455dd6b906a886a986a84aa4a648c6a9c6a826a926a8a1ad402d426d4a6d466d4e6d416d496d456ba53bf3a535b53db50db52db51db533b503b523b51533f5da85da9ddfc051b636a776a0f6a4f2d65ed45ed4dede3aff788ea70f22556ee7296fe992525e1286b1ff43cfa8a1eea9ea9cb7df55ce55a9a5a467b033d295add55969a82796a4e2b73f0fbf8f74f05b3b8b240ada88372b2fa9feab844ad4cad227331d53dd5aad46ad4ea52add51ad49ad45ad43c6a6d6a1d6a5d6a3d6a7d6a036a436a236a2acd416a216a616a116a2ad92afe38b504b524b51475a807a84fa84fa9cfa8cfa92fa82fa9afa8afa96fa86fa9efa8efa91fa81fa99fa89fa95fa85fa9dff4c4db79cc9fe17df26782b67c638c8a58bae6e9f921aaed54cfce5bfb212a426b63ccf927fb726b7d07fe64de888e6dfda67ed72d59a5b58a599d537f68575b7ffa7259c574f0bf2ae9aabfb951b6fed25fea2aae8ffeadfea59ea69ea19efd19f0aee7a8e7a9177e11154ad4cbd42bd4abd46bd4ebd41bd49bd45bd43dea6dea1dea5dea3dea7dea03ea43ea23ea63ea41ea21ea61ea11ea51ea31eafeb3f17a827a927a8a063402342634a6346634e634163496345634d6fa89a7aa4bf5ccf78d3e6e6c7c65e3fe32a5903fe72c63edf42b229a205fa336ac6de8f9ab01c6fe8cf3aa9f49617fce7a53cf446f6c356fec68ec691c443ea552e368e5fae86343d4a7fed5ac5a52dfff1c4e34ce342e346cabb671a371a7f1f097a999cec998c693c68bc69b868a5ac59ba691a191a591a391a751a0a1fe58a251a651a151a551a351a7d1a0a1e468d1f068b4697468f8d33a1b3d1a7d1a031a431a231a2afe208d108d308d080d95b6188d388d849e41aee791a77c47e92f85581a15aaba44eb356007ed49676b7feaee46e43606fb63ad7ed08a1bd35ecbfa1e3d797da4bdb0d2773ed4fe5af9f14692468a263403a2a009eab839f903515ffd03b34a7caabf376734e77e50070b9a4b9a2b9a6bd1b1b9a1b9a5b9a3b9ff19bb6c1e68aab84e34cf342f34af346f34ef341f349f345f34df343f34d5e5d3343334b3347334f3340b34559c259a2a920acd2acd1acd3acd06cd26cd164d8f669b66876697668f669fe680e690e6484fc35755b62c8898f83370fdc505aa142b21949f5544cb7df14d78fb17adcbfe4a1575d1b12f77efc7ae45eba8ce09a3efdc9f716de2bf85680669aacfb02f97116ae61fff0e86cbbb0123beb8511f45fddf6234e33413349356d9142d6805684d84b4a6b466b4e6b416b496b456b4d6b436b4b6b476b4f6b40eb48eb44eb4ceb42eb4aeb46eb4eeb41eb49eb45eb4deb43eb4beb4d2b4327a098e4a462bababa3568e569e568196ba50895699564577b85598d6b4ac2db3664c1dd4b4c4caac54e2955bd013f6dbb4ea7edb20a2cd59f9623d1fdd975b4fe4df6b37226b1baddcdac36eac5dfb266cd6f399c5a57a1d534a47de6ad06ad26af98a9910f5a5fbfd5582d984c0d35fcca7092d75731d5a5d5a3d6976b4fab4543286b446b2dab535a615a415a215a615a1a5fe15a315a795a095a495c2032f8037c19be2cdf0e6780bbc25de0a6f8db7c1dbe2edf0f63a85de416be11db5ad2dca5a11ef84a73e2f5a41efaad7837937bdbc5daf55bc692915d10bbdfc5564bab426fdd5391fdd25f5fce6948a477909a548c377c77a89c4491ba092496b1dc67be2bd74c1d75a8f7d8937fec4ff8c547dbac17012e35539a42ee1bdf13eda6c7fe4f28f4dd0e66c7e92ad2abe7869bc8c465e162fa78fbd3c5e01afa82f6c26917925bc325ee5679abc57c553c9aee335f09a782d3c15431baf83d7c5ebe1f5f1067843bc11de182f8817c253498ae045f1627871bc843f7d7ced17bd946fb9bedd79be527a4d93ca9b94bfccccaaa37ddfdd5fd518d52b4c16256dc56db421b7035a6bbd8a6c2272eb0cf8f846ed6bad4c5bc9adff7b16a36e4f7c975af097543cc45de82596d11fe3d5eb5baafa7c558fb5a7be5c26e468cfe440ab97f605d43f3965337f08ed39ed05ed25ed156deb6adb1bda5bda3bed9584ec691f681f699f68ab5bbcd0bed2bed1bed37ed07ed27ed17ed3fed0fed24ed356316769abbbc9d32ed0563194f41224bdec73a88d482f7388f8c9bef92b72ea7af99dfaaab85e0411d316a7e5f05daa363d750365dda16a57f4fabc76559faf1ce2e5a92b741594bdff965bb5a5a6fe1250bd5457dd67cd57f92ccb9f8d9730d9acabb28aadf1fc253eba4ef3cd5f89ab5ce59f446bd7edb170b343cd5c177ffd73c3ff6cea83768bb647bb4dbb6375ecd2eed1eefbcd434394a50c698f688f6907698768876947684769c768c76927682769a7e84027406742674a6746674e6741674967e55747617dc7caa094582a01c6189528ba80dfb5b174d674367e7b60abd551679a42ddd9ea7193ce4ef7a0cc2234d567555a77f6740e748efe3ab4b8eed12ad3564ed9686d1c888a47c77fd185c0386253e9e91a6f2cc66bc49df86bef4cf35985cec9f7936d5fa5269db37f30f73fcd813e36ca36e43cf5d9b9d0b9eae3ce8dce9dce430fcd181d3b4f3a2f3a6f3a1f4bbe74d2743274b2747274f2740a74142fd151c9abd051a2d4e8d4e9a808d54db4e87874d4553a74ba747a74fa7ab15d67a013a92c4b2f211b4a51ed0cf572116d477b5d60db7e7da534d2ea74a482ea8c747f4929db19d309d209e9cf62c33fd8e901ad4e984e44af56ed44fde59353bdfa5469adecba6196f9f674547a61d0d06f1db77c7d77b2765f3bd990ef1982e2a9b4b22ac44547259791ce1d8886175fd94ec20f493a29ffc0ffec4237407742772a8eb53ba33ba7bba06b9f64745774d7743774b7747774f7740f748f744f74cf742f74af746f74ef741f749f745f74df743f74bf74d3743374b37e09bd699b554a69dbd9f92d9ebe5f7b3c74d5acd77fb67d5f39b00bc53b74737ebdbfd0a63a6dd0cd6b1d95e5aab068fa0b7937bee2211d8cd64b756305bdc04a99f6a24ab7a8553697d66b6d6de5a6975e56fddb70c6fbf01db169e70de996e896e9567c0513f633f5eb5807a36c4a876ed50f153fa8831add3a5d75d34d3d895ea46cd1f5e8b67f86c0bb2a915dba3dba7dba03baeac223ba63ba41ba21ba61ba11ba51ba31ba71ba2ac3927453f4a017a037a137d5926959cd7e1823ede0b46b5bea4f6d323bdf9ae27f565677c3c2daf454d99f07e9cde8cde92db46abda5d65a29beaa8bdc4a6523b711baf0d4a3884aeea9e7e7ab5fb3397d4d434d1ac57e8b58378adbda839b8e896aa8f456bf84fa936e027d657bebff1094cdf636f4b6f476f46cefa077a077a46797daec6ef4cef42ef4d4c5d4f19dde83de93de8bde9bde87de975e9a5e865e965e8e5e9e5e815ed10f257a657a155fb2b69f98bdae3db46bf37ba2cab5e97a63fb9f95358d5fe53db5e9294dabfeb2e8a03646b3cebc5713898dbe26f4eabe47f68fd54f0bbf7e93b6da45bac8ce39fce81b96fd2974c66f7d651bbfb46ad26bfd453d51d6a3d7f63f3b7ee8daaf3d7a7d7a037af6715b6f446f4c2fa847648484e885e945e845e9297b89d34bd04bd24bd1877e80fe84fe94fe8cfe9cfe82fe92fe8afe9afe86fe96fe4ed739aa5aefefe91f641040d7e366d43928ca6af8176555ca95cdea05fd736d7d4a5c65bfcaa52afb55e22e2f7a91aa92d558ab7e3cf3d441d9ac2233ffd7fe51bcad9eb8e677378cf1eac8ad73300d12a5acaa0974b3e442ff44ff6cb55aeb4f55bef581e78796f9c957b6afcebeda533bda5a0de9dfe8dfe93ff4308fd1b1ffa4ffa2afeec95662fd2ffd34fd0cfd2cfd1cfd3cfd027dc54bf4cbf42bf4abf46bf4ebf41bf49bf45bf43dfa6dfa1dfa5dfa3d7f857244af36eff7e90ff45e12fda15eb9dc1f4917e8ef6c567155a14d55cc6311b71fd4caeae5f82aab42da3928cbed87b594aaf8cf6e7a06eaeca88f95d00aaa3c5099aa9b0d35697518e3d5e2b6455fd30a3443337af706651011fa512b910a31ab589c7ec23fd0c1281bfb159236a8e314031804184c64387130653063306760371d1a2c19ac18ac196c186c19ec18ec191c181c199c189c195c185c19dc18dc193c183c19bc18bc197c187c19a41964f4ae1b83acd67790d363fb83bc1edb1f14fe2b655563761ed19fca6607ea7e4a0cca5a5c65bf830a03056b5afa415d3b07bd0b88ba13bf425386acfdc342fb043df8edf79895f1ea0bdda4f3a6f56dfb5b89a4fcba6eab0f064d062daba0d3cd7d55e955792c6fdf6933e848d06adae34197418f419f81bf238e483964306260a7270d820c420cc20c942e510631067106090649062986300c309c309c329c319c335c305c325c315c33dc30dc32dc31dceb2725c3835e1f5d7dfbe266191efd7ebdf506ba6def2bab3de3d5af6d86be22118627866786178657862a9e3bc307c327c317c337c30fc32fc3b4ae8294850e33dad51a9fa05ced30abfd86720bcb981f7fed475ced5bfdb1089591fa5a67bf47d764986398178986851fb9dcb17fe02b3b2cfa2276fc03a76f577f1d961896195618da599ec31ac33a43eb6787ea4a2d861ec336431583fa578f619fe180e190e188e198619061886198a15221ca30c630ce30e12b9b6498fa5b65f5d4ddc2bfd8ac526a04a300a309a3a936584594b2a399dea8623467b460b4d44fc0462b466b461bbf6bb7f57760686877a19455f59eea56a8c8554759797ced76afd24f331ed60c65a8db503e77b465b463b417b944342397254333af6b74f095ed323aca813e3ee9afa333a30ba32ba39b4839ba3352b1bb45698abc18bd197d187d19a519a9a46619e518e5191518a9134a8cca8c543aab8c6a8cea8c1a8c9a8c5a8cbc7f51f63f7b03f398ebac0bf2a8cda8c348dd708f515f977aed04141f301a6a6577eac6468cc68c828c428cc2da578e228ca2dacf6a830de95a547b95b55f08ced26070e33b2274559e5f8c628ce28c12a2980e27ada10e49ff53dba551f6c818c601c613c653ffab3b98319e335e30b6bd83f18af19ab13fe62664cb78c778cff8c058fde5c4f8ccf8c2f8caf8c6f8cef8c1f8c9f8c5f8cdf8c3f8cb38cd38c338cb38f7df29dbf48be440caac4aaa92495538e33ce30263750f25c665c615c655c635c675ddaf1d37f4f955753f4dc62ddb196931f6f4d09a6ae48ddbbad29bfb2e42ef6b33d25bb5a87230eee8c84d5006ab0777b6d230507732ee32ee597dfafee7f4976e135feb83afacd6d484817fd2c01e0f198f188f19071987a427360e338e308e328e5965e38c138c938c53042118203821382538233827b820b824b822b826b821b825b823b8277820782478fa776fa04c4c19697348f04cf042f02a3d54bd618d22378277820f5de4953f0d3e09be08be097e08aaaf6982195d968359823982793da2162c102cca435c9d6173dda2a87db54398ef749c7a5d465f5a63262868f66e52cea1a2e22969a182655f2ea3d5e09786fac057365821582558d32858f743c32765ffa726c116414faf32513a06db043b04bb047ba26cb04f704050a57c44704c30483044304c304250252346304e3041304930450842014213425342b37ff106ba777bf1c7096bba960fcd092d082df5031b65984a05655fa195362be54355e155a55e0fc18c08ad096d086d09ed74a90fed75b3347490d142551b878ef278510fc25e74bb42dbecc2cfb39dd4932e288975c3d9df4f48f987d0499b9ad24789a85532ea55ff785cf7950d9d05852e365cfdaf57fff846e84ee841c8fad6d08bd09b906dd286be84d2843284b2847284f2840a84142f112a13aa105251d508d50935083509b5087984da843aff64b3a12ea19e1651d5efaa3086fcd1135d054508f9abe45565a20a7868a8ed4e3907d3fc0c2959c78482da45844284c27e934b5d3da20d56afb928eb41899d9d7ba0875ffdbe9c3a2d14d5c3927a4438e07bf39a0c459aa03719f21b0f6d959c98af4cfcd7e7d54ae77f0d568cb2091f257d6a823b563c4518c201c2f6394d784a784678fed3c70d2f082ff522ccf08af09af086f096f08ef09ef081f091f089f099f085f095b03aff4ef841f8f99f6d36ec376f4b49ed01c26f3f7c087f09a70967086709e7fc319739e13ce102617fa9c6e42c033aea385cd223b6aa520a9709570857b53bd691d408d7ed232f1555c377e541df96f7fe46620b6de3aa2a336aea51983f853ee126e1964814f67c89123ae863a7b5d9713fdc26dc21dcd541fd21dcf3bff6f581fe3a20acee7544d8b661032a8541c2a19f0d4fc261c211c251c231c2ea7aea32ea8f292210091099109912991199135910591259115913d9fc0765557f21b225b2d335bbf292913d9103912391139133910b912b911b913b910791a75639f2d23e745a22f2f60bbbff7030f221f225a262c810c91251a7e5b54b8914881489a893cb442a44ccb348b36d655d07bdc3dd4e6b6a36c352e6acdd6ed70ffe9694911a91baaf4fc7d7aa274269adac6ee19eaf6ca4a1834272d091af26449a445a443c226d3d90a8a554f7aacee9fe340f3a4aa61e1175f280c890884ad89848904888489888122b4a2446244e24412449244514a281bf78037fda9aeae94627ba351a9d129d119d135d105d125d6941d5a73e38115d13dd68a1a35ba23b5d6545f7feb380b23c65513e317ad01d87e891e8493775a367a217a2576da7d11bd1bb1e6d893e648b41e50d5423418f4c5eb5a62a184daf7e3f42b988a5bf804b291b7dfed2a7f123971cf4889af906d137d18fff69c2579fa188f98ca68966886689e688fac389d1825e22125507769ad742a5b3aca7a247951c55a2eada75a2eaef4da22da21ed136d10ed12e5175d53ed101d121d1d19f6d5685a88a39a81589867c41175abe68d80fbeb8d108d128d1981fe24413bec42a2489a674933386ddb537a4ebae58406baa6c3f36d16308b1a96ef0ea06724b6baa5cb9eabfaabe6c6c466cae07c974c376ff63aaaad6d29db7b3b47695cdc616c496be321f91550be534fc10533769e675c5d65abed846823ede0a915377c4d49d1d88d9678bb113b1f3cfb8edec4bec42ec4a4c5df84eec41ec49ec45ec4d4cfd5dfdaa62cb10cbeaa199588e589e588158f1cf361b2b112b13ab683f1babeab2afd5dce84f751cab11537f6ff8a149ac45cc23d626d6f17fea6a9563bdffafbd2beb691e48b6eff333ee792fb1245e344f10028140084b08e1cdfb16b6845d9aff3e75ca7696ef6346bad27dbc50b2caed5e4faaababbadb6d4adff9a81da0fa7416ba7784b53b25f4ea0477efa928ba3362aa439f8e8ddd07e9ee48d75c8678870b482b586b4ce9b655165823bbd748e1267414c1aff6b63efba8bbcf2eaf68763bd2edd60f8cafaf4a8e74b5d29e74fd064a47c48138ed98c690509c489c589c449c549c4c9c5c9c429c529c4a9cb9388fe23c89f32cce8b38afe22cc4596ec96cdae12c8cc2eabc5154a9529786e9529c77713ec4f914e74b9c6f717ec43910e7509c9e3847e2f4c5396ef075b42603714ea90da81676c439e3d0a4b0aa9fe60cc5d13817e28c68bdd1980dc4b91467ccf1cab9a2553bd1fa5f5303505a1d3bbfb1222943fbef947b6915d91a1caacacb0db88a96a991756e08a85e9d5b63ecba49ce449c3b71a6e2b413b52a0bce4c9c870d64b50dbbe2ec89b32f4e471c4de588e38ae389e38b2be242dc40dc50dc48dc58dc44dc742db36e266e4e2fde2dc42dc5ad0c591baf145c774e40dd47719fc47d16f745dc577117e22ec57d13f75ddc0f713f29cbee97b81af3870a5161d501ca3d10f750dc9eb847e2f6c53d16f7843eb13ab5ee8026b07b4a23447174cfb856e60e39cb536b80c47c39f7dcce22cd1b64dd0b43b663b875fec2eaa6c6d3907547bc712fc9f05a334ae396b912f75a5c8d73cb7723ebeeef4ec4bd5b9f2be74ec5bd17572bfa20ee8eb85aef3d71f7c5ed88db15d711d715d713d7174fc483788178e15a66bd48bc98adf54cb772f46f49c152f1f452f132f172f10af14af12af134d5a3784fe23d8bf74270bd57f116e22dc57b13ef5dbc0f5b70bd17ef93ce5bfa444cbd2ff1bec5fb11ef8096997748f5aa56b38ab0dabc2aad91275eaf71f0e8922dccfba84c7e0744d63b12af2fde718b955103e09a0c594fcb1b3441cad4b74de0d878cd4e2b3114ef5c3c7b9351c78733adfa687db4a9a769c704d4bb12ef5abc1bf16ec59b887727de543c6dde4cbc07f176c4d3387be2ed8bd7d942565d03af2b9ed3e8019222e58aa74df529adbe880ff103f143f123f16322eb279c8d5503c04fc5cfc4cf29dd7e412d318b9a0370fd92e2391d70eec6afc49f8baf0935c367fa72fe0b7d36b546e8e07588acff6a07b19a2aa889f23b32f376c2151645b64166d08046f4c6048db784ae467620fea289d7d0e99af848af4bf1b5f6efe27f345b665443f99fb61dca90f5bfc4d726fd887fc0d793fd43f17be21f89df17ff587c8da0a5683e67e20fc5d7f65c883f6a6664fc4bead99399f8e346b7d6ea55c9bf12ff5a7c45e456fc090d06ff4efca9f8f7e2cfb818c3a504c5e841fc1df1774df3fe506fa880fb7be2ef37b339338dd011bf2bbe23be2bbec2e7f38b0dfabf47cb171298f7acae77680b13b9819bb7108f9a69b6f445d504b5813780c46bc46a9436a0b3cf13d939a7fa6cc5189f6edf66e0019805a4349955d3e41952addf7dc60978c0db2378d0963ed21abc8287b52cc12325dec117ed3fc1b79abf61af57826f21f61a6453220b396aed8166e002dfd93a06dfcad1da5f81e6ee19ad02ff0e32e49c77e39256d48cc908dc487ec1f1cdd53ae8ed25fbefec0132562f19dc68760d6e2ab9a52f77a2994c28daeaaad1cedb21a3bf166778bf5b553b6adc84c4768473ada10217f8d216a535d38246dc6a64a7e0d4ffb47d36b5a8f7769d59f8d4a67176c0d9143b7996c7f9e8a37dfe8c6b64d5f4efca670fb41b74c0526deaf3331efc0b8010888018488014c8807c2db3a71aa700ca16d93dd3b025500173e011785252a70078065e80571a52b1b02fd71a703ce4d4cc42a32d8025f006e8c8a6d70f4e7b87b7c027a0e02af30dfc809e64cf1623dea18644e79528abc376bfb035e08b767e6b8f769b2a9391ed5f1a69257bc0518b4c6a4cdaa2b462ee37916d097de0b8096c982914380c0005a0dd621f6819437ad92b64710e5c006a36ebf512180357c0357003687b26c01da05969b633e001d801766b64813d39d108fb40c76cac776334cfaea1a31e41b706d7c8053c2e04a89fa6d2aab0721fd184f6ff29371d013ebf3ba2bf66102008a91f1f46046bff10418420469020481164509b577ddfa97a3d4f50cda64c5cd8ab0a390d2fced83ed36851bbaddeeba8c806256556516a4124051582b9d123410b2a43b6097d327a36be6aa9e69fedfa82e015c1a279db37e82058721a69856cf086e01dc107824f045f08be11fc203840a0ede9213892b1b6aa8f400b3e91a19635907882e0b49659ceb6ec3f51600d5965289ec11902b59ce626b02b705d0e65c910c1b96db83b371b6bdf76d3bc699f4570816084e012c118c1156da65dc5f19ac6b2476945708340074c8da915b883fac43abef95adc3d57c9543328b2f40b349f19f7a3f3b30ef5dcc2358207043b06c8530bce530bd19a6a6477db18bbed757723b06a993d04fb20a0f59cf7917610f02b24931659178187c0e7476ab4eb8701c21061843046987012e43693fe27c21461262307618eb0e0da6d265caf4dfa86ec5e3b3fb04764c3126185706e8fbaad4ee8227cb4fd714fecb3aa079add76f679943b4df54469854653fe05dc1637977b2d7a817089f04d49074084ef083fe4b68f5045e11ee11737ce4cb47adf8d2fab63e369cc83cce347db217a4364c31f6a832da05a0a0f56181ab2e1a185f6dac74708fb0ce4b587f0d842f4f604e100e1299a9740d4e8bb045787ca06d9f01cfa238723841a3e467805d6e36625d42d1dd186e7c9eaae30b236405b35917857a1340dabb02ae877d4064476aa2eec862a68156ea8a96c73bd46e02659db60ab238cc60d1f10aa4dfd81509bb387701fda9175dc0fd592d71aea8fea22f410fa88446642fd1fa9de9870c19c1b4112f368cdb5e5d690a49931a8372e4e2f118586c931e18aa216b19e61f86c213d43368a19a4d04409f9fa56f9d5b566a21451862847b43a01f71e7ca9a73d3a4c8ddc6af9178edbc4a16fc2193f45443b20dfe5b86ba63ee3074415d56b27b7a9ac4c3a2ea2392235a1de106dc92c2765f63f388945a75395c039f839916f4e1eeefc207a41f44ab18d16889688de684274cf10bd1b881f469f88be54843902a9efa02eeff2990bc0b727b66c93f36d937ae650db4825bbac77f222fa46f4d3c042793286e0d6401dd8987452237b6094181d6c5f0f9aa8bc3d44a4298f10f5edb52b9eaa80e818d17f851227ed26ad9e5cebaf3240748a481b3944a4705c703a4a453be24208b41328b2dd5b9b5ed1c863736ab5cf569c37d8df125b445788ae39e6e828aaf2556ffe565e6d06ef0bd10da25b4413447788a68814111d36b5e729a6fa13aa2faea3829ac91ead0519aa65c2f5a149d29a71397fb065fded8dbb665b9f2a964885740fd17e834c0de5165c9d9ad944b68bc8d920b70df75ac6e7d7cfd46a8a03f0e53e4ed4228e10c7bfa019e56aea42bbd5e129e214718638475c202e115788e7881f113f1171edbf5cb9e3ee78c41455c42f885f955472d57a45bcd0e188935b9b7ab6b9ba88974c95be7264579f6aa699bc71988ad5a9d943fc81f813f117621d4eb57475224e106b5b76106be57b888f6884c57dbebfcccf405c99c0ced6c88eca661f6a38417c8c58930f0cab169ff8d478d740f356e819b2f1d916a6f110f1b93117e49bc073468b47882f118f11db51be6a5ec4d7747e76aea90ab4a7c437886fa1237e7c87780a86cca0dd3cd696ec22d6a6daab01d37043a227f6fe8a6df5d1b6755c02aad26a928bb883b88b582be09a19eb6e1a092db81e625fdd337ef34e8d747f4cd32a099084489489912448520efd893a66732479836c52202991544834f091665c2db09c2bb0e5f1da4cd6ce943c2179a6694464bc06a52d41dc849554237bde50f262cc05c533b15c92450bab85274b246f48de917cd49e18924f245f48b4ec1f240748b4ba3d244748fa488e919c2019203945720635929273fe067f0938545776b5ea23249748c6741092ab0dba4672439d90dc2299fc3194add42e473ffa66f71ca0923b330914eb29927b2433243aa67dd17a8d3df114d09d06df44e3548d1eb8b3d7c8b9467bd1a817b5e75460675d247b48f6d738ac990b42a428d7d0f1dac8a5219b742cb463806a2e8e5d5debfee7c6775af290f8fc1662da9e7ca25d2c0d90864823a431d20469aad61fd20c698ed43e0cf21fbf387588b4445a219d237d44fa84f419aa1c3c5701b5b91863d442d0ce9e2ec4d5eb92c6ec96d7d0920c90be217d47fa81f413e917d26fa43f480f906a413da44772fc4e63963ee0bb519f86577a8cf4844b099bd2aab02aa9239b6ab6a748cf0c4143a386a5c68ad78e41b468426ad0233b1711e990ba838f8d7ee56b263d477a817484f4b239764ac77a5743c648af905e23bd417aabea09e904e9dd6f68d2843040a748ef91ce903e20dd41aa49f690ee23eda879db20dbd9afc145aa453b344e5357c1ad976afe34c2524f659660a50b8a6aeaf35398ea426701b21059842c5633801a001e7f832c419622cb90e5c80a6425b20ad91cd923b22764cfc85ee8cd67afc8166b40fea64db81a9449866cb644f6c61864de8df9e0e3ecd3c89e36210b645fc8be91fdac5f135513da99213b407628c7c7ecf2bf02faa299f4c4b9b7961c21eb233b4676824c8b3b4576866c88ec1cd905b211b5adc9ac2d7399f06697c8c6c8ae905d23bbe1ec4ce3e6b622ac32abea22539a70d4caee904d9169715ab707f114ac1df11438056b0fd93eb20e326d91834c33f7283199cf8f92e6401ef0563d23b67dd9809087a4152635a67504656a7c1b183f348e219b474d823a31d3b719e9a35588465099cd63e409f21479d668c93c475ef025c75f015df8e25d202f9157ececf91cf923f227e4cabf207f45be40aec5bd217fb7fc3f906b4dbe6a4c917f23ffb161ed1df901e551fb7834694cb1ee15f243e43dd31215f223e47de4c78435d78a0d909f52cfe6675c3c3fd1c021722d42eb33427e897c8c5c73b86eb1bb31106e36a0b8d968fe728dec1638b76bdcd6e8bfd7c8de58a49b36a3d535da606e5a9a20d72a4ef9fec27f356391dfcbe50ef21925347f40aefc2ef23de4fbc83bc8bbc81de42e1b967bc8fd7533b4b585d802ad3efd21b29c9a713917a6e016017b7a11a28850c4281214298a8c8016398a82b0aa922d4a1415e5b798a378a469553ca17846f162dfccd5db57140b965e2c375a17aef91ae5e20dc5fbfae99a6f892135ca8652f151a7adf5ec398a4f5213f5cbae9f4c53d47274b3ceb1d03afda0d0161efe8ea98a73d1437184a28f425b7b826280e214c5198a218a73da6dc50585b418a1b8b452c6a6c1cf9b12490aaeb6f9a646d660bde5ec81bab96a5a158a570ddfd410bc3703606a70cfe81d140f2876a813d4e42a7639a19e8c51eca1d847d141d145e118a69aadc7466db6b1ae4f1db8c58f3740b0c0c26fe3fb04adc6900c63d632eb378f99deb70435ffd55c730b6432dfbe8a0c9401ca90072faec7a5679411cad8067ae5139429ca0c658eb2405912d0b2a22e2be7281fd9a4f2c944d56f0a6daad8f2a566f2c21d05dd7394afe26a65baf51a17f028fe35a7c1ca058dd6724903ab7ce310a7666ca9693f507ea234e8cb6f1a00e50fca039487287b288f28a76c48bf6ddd57d3eabc6d3e430ca3bcad4f0d4e73bbc264bc9d76dc322b6495ca6303ee18e549d33ce5578feaa70d3fa0e895a7766efb1b4a6de190037d794e355a5ea01ca1541cc728af505ea3bc41798b7282f2ce84b4ce47dbac49664de6f946714da177281f50eed443bf7455587aea89a1dc154fc76bcd730fe5be4d33069cc32d3b66c00694e5b28bd2a1e40629b8ef5e7f6017a5b706ee6ffa355ca1a86bb5426315ad81ebe4f74c4a3bedc4da261c3a98f863ddce5fa86fd77b0e62a56f5ff2d691234015a28a50c5a8125429aa0c558eaa60a7ab4a5415aab941b999c931aa47fe482cabbfae401d21b7ce513da17a46f5c2715f0654056a7239c74456872f3fe3c2816a861ad97007d52b0731d5b3d582925b2d6960556fa894ffd82abd2e94286c873735f1d795fca3ceeb1c3613cab6707cac90ed6fd0766c32d3365c9af0ea13d517556df58deac7e8806ab43a44d5437584aa8fea986ab43a4135a09c6e55ab6f217daab9ea14d599dd4e510ddbfccf9b084afab4ba4035e22242f7d296bb17e2e92f7729ce0167c288ec25dd5fb5b7d472e0e4d68457f589d568adc6a8ae505daf0bd5cc577cd3a8ba475e36f5d46b1d879187dba2306cdb325937a70ef92bdb165966616d5b517ddb14336d88b7035437a86e4d2a27a8544034e63daa19aa07542a38bba8f6b6e2b33c69206bf21f3495504b43152ea30d9b826a949b764ead384db58faa83aa6b3b0a5ec5f95c235b399c8725b2d766932d50e90fe6712db2f2a9f4d5ec5e57a62d85d90ead4ac3b6518316b8e956fcba26ab380d7f6b2d3299d3c09adfc4b09cd6c84eb768856c4d7334543f221f601e621e611eb3cbcf13cc53ebf5376daf9f6ee5b0c9ff4175b6bf96fe47aa7986798eb91657422e68bd8653221b964436b035cce8519c1f2e379c6add2acc15d6c7a6ceffab0afc1d327fdab89db3a5bf66b291d690ad1fac105cdf3eb333ae6eb7f27ac1fcd5c47397cc7cc1980c5f1a81d726045b69ff085c3d5266555693cf467dea540c7fa3853f7fc7fc03f34fccbf30ffe6dcca5c35d29b9c2d303fc0fc90bef2bcc71ffb3fc277f6671d5675feb56e9badf83bb7cd90b6b644f6ea4dfe9ffecfe97ffef5cf7ffc1b920e8074 + + + + + btn_Exit + clicked() + tb_Main + close() + + + + lb_Main + KBFXNewsBrowser + ws_Main + btn_Default + btn_SaveApply + btn_Exit + btn_Help + + + kdebug.h + qstring.h + qpainter.h + qimage.h + qpixmap.h + kmessagebox.h + kbfxconfigdlgmain.ui.h + + + QPixmap img_button; + QPixmap img_themes; + QPixmap img_fonts; + QPixmap img_style; + QPixmap img_tooltip; + QPixmap img_search; + QPixmap img_plugins; + QPixmap img_about; + + + KbfxConfigDlgButtonChanged(const char * name, const QString & path) + + + init() + + + + kactivelabel.h + + diff --git a/configdialog/kbfxconfigdlgmain.ui.h b/configdialog/kbfxconfigdlgmain.ui.h new file mode 100644 index 0000000..ee5fe64 --- /dev/null +++ b/configdialog/kbfxconfigdlgmain.ui.h @@ -0,0 +1,24 @@ +/**************************************************************************** +** ui.h extension file, included from the uic-generated form implementation. +** +** If you want to add, delete, or rename functions or slots, use +** Qt Designer to update this file, preserving your code. +** +** You should not define a constructor or destructor in this file. +** Instead, write your code in functions called init() and destroy(). +** These will automatically be called by the form's constructor and +** destructor. +*****************************************************************************/ + +void KbfxConfigDlgMain::init() +{ + img_button = image1; + img_themes = image2; + img_fonts = image3; + img_style = image4; + img_tooltip = image5; + img_search = image6; + img_plugins = image7; + img_about = image8; +} + diff --git a/configdialog/kbfxconfigdlgplugins.ui b/configdialog/kbfxconfigdlgplugins.ui new file mode 100644 index 0000000..81db2aa --- /dev/null +++ b/configdialog/kbfxconfigdlgplugins.ui @@ -0,0 +1,390 @@ + +KbfxConfigDlgPlugins + + + KbfxConfigDlgPlugins + + + + 0 + 0 + 660 + 217 + + + + + 1 + 1 + 0 + 0 + + + + KBFX Control Center + + + + unnamed + + + 0 + + + 10 + + + Minimum + + + + kActiveLabel37 + + + + 3 + 0 + 0 + 0 + + + + + 0 + 29 + + + + + 32767 + 29 + + + + + 255 + 255 + 255 + + + + image0 + + + NoFocus + + + AutoText + + + <b><h3><p align="center">Plugins options</p></h3></b> + + + + + KbfxSelectPanel + + + + 3 + 1 + 0 + 0 + + + + StyledPanel + + + Select KBFX Panel + + + + unnamed + + + + KbfxPanel + + + + 1 + 1 + 0 + 0 + + + + + 32767 + 44 + + + + WheelFocus + + + Plugin to configure + + + Plugin to configure + + + + + textLabel1 + + + + 7 + 1 + 0 + 0 + + + + + 32767 + 44 + + + + Please select the panel you want to configure: + + + + + + + KbfxPluginSelector + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + &Available Plugins: + + + &Enabled Plugins: + + + SmallIcon + + + + + layout3 + + + + unnamed + + + + spacer2 + + + Vertical + + + MinimumExpanding + + + + 1 + 1 + + + + + + KbfxConfigurePluginButton + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + &Configure Plugin + + + Alt+C + + + Configure the selected plugin + + + Configure the selected plugin + + + + + KbfxPluginInfoButton + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + &Plugin Information + + + Alt+P + + + Information about the selected plugin + + + Information about the selected plugin + + + + + spacer2_2 + + + Vertical + + + MinimumExpanding + + + + 1 + 1 + + + + + + + + spacer4 + + + Horizontal + + + Minimum + + + + 1 + 1 + + + + + + + + + + 789ced974b6fda401446f7fc0a8bec5095601eb64755174d7080a669d3b48b4a5517e33134a1101230e151f5bfd7f7bbc3f8510bb29a45d5b331e77e77c6c6067b7cd670bede5c3b8db3da3291c9bd72d49d5c388d78359b6dbf7d7ff3ab5677dda6d3124e2770dcfaab5afdd651ce4953785d11937e822acf63bd81c67bfd0c1d793eeb47ad8118917e20755d4f8a31e935d4f394c48ede4395df941dd277a4adaedf9501e995568f75001dfb9154a443ad8ab547da96412bc2cc97465ba4a1d636a77da348df9276ba818c3cd273a33ee985d688d30d69d7156e14916e8de230d65a5b9cee8c22fd028dfd91c05409ab08549374611407b9d42a387d328af459abe4746514e99cd40b645375491f8c62bf8f5a5d4e6746914e49fdb64c2f12e94fad3eeb049a9e7485eb7baf3566bd23a5b31ce3c4fe808aa813e3fa8ea02af263ec68ac35603d85c642ffea147494a6b80ab156c17a422a9afb34d22a631ca4d41ab19e5a058767157ce52a22a6322bb51debc95a69830b5445cc5466a5b6633d592b6df0fba962cc5466a5b6633d592b6df003b60afe4156c15ff810938c5ca9f4a16c93228509714b39c43423572a7d28dbb4486142dce2521e8acce78f9a3983da3c5f6152a7b17a8afdb042cb1c33cef6e0760d160ccbd290243a5824cb65be6cf449b35a9961cf29694752985383470fd86c36db941d581bb84a6cd6eb7cd9e82ea3d4b11fbacb83e7668173f07705a58b14aeec4378aeab3032ad16356dc753be17863d260cc34ba26f2a3daa6429d337a50c1a13f6fb61a99a178cc5aa63301c0e98a1fe3434952c435533a8e04094efc02ae8a55c8117b7578fc732cc2a58075a050b51ab60256c15acccad825703abfcdfe3bfb3c75babe045d52a78ddb34afdf7ebda1f4394dd1e + + + + + KbfxConfigurePluginButton + clicked() + KbfxConfigDlgPlugins + KbfxConfigurePluginButton_clicked() + + + KbfxPluginInfoButton + clicked() + KbfxConfigDlgPlugins + KbfxPluginInfoButton_clicked() + + + KbfxPanel + activated(int) + KbfxConfigDlgPlugins + KbfxPanelSelected(int) + + + KbfxPluginSelector + movedDown(QListBoxItem*) + KbfxConfigDlgPlugins + KbfxPluginSelector_movedDown(QListBoxItem*) + + + KbfxPluginSelector + movedUp(QListBoxItem*) + KbfxConfigDlgPlugins + KbfxPluginSelector_movedUp(QListBoxItem*) + + + KbfxPluginSelector + removed(QListBoxItem*) + KbfxConfigDlgPlugins + KbfxPluginSelector_removed(QListBoxItem*) + + + KbfxPluginSelector + added(QListBoxItem*) + KbfxConfigDlgPlugins + KbfxPluginSelector_added(QListBoxItem*) + + + + KbfxPanel + KbfxPluginSelector + KbfxConfigurePluginButton + KbfxPluginInfoButton + + + kbfxthemesdata.h + kbfxconfig.h + kdebug.h + qstringlist.h + kstandarddirs.h + kmessagebox.h + qlistbox.h + kbfxplasmapluginloader.h + kbfxconfigdlgplugins.ui.h + + + ChangeForm() + KbfxConfigurePluginButton_clicked() + KbfxPluginInfoButton_clicked() + KbfxPanelSelected( int _sel ) + KbfxPluginSelector_movedDown( QListBoxItem * ) + KbfxPluginSelector_movedUp( QListBoxItem * ) + KbfxPluginSelector_removed( QListBoxItem * ) + KbfxPluginSelector_added( QListBoxItem * ) + + + init() + KbfxListPlugins( int panel ) + KbfxSaveSelectedPlugins() + + + + kactivelabel.h + kcombobox.h + kactionselector.h + + diff --git a/configdialog/kbfxconfigdlgplugins.ui.h b/configdialog/kbfxconfigdlgplugins.ui.h new file mode 100644 index 0000000..40153d9 --- /dev/null +++ b/configdialog/kbfxconfigdlgplugins.ui.h @@ -0,0 +1,157 @@ +/**************************************************************************** +** ui.h extension file, included from the uic-generated form implementation. +** +** If you want to add, delete, or rename functions or slots, use +** Qt Designer to update this file, preserving your code. +** +** You should not define a constructor or destructor in this file. +** Instead, write your code in functions called init() and destroy(). +** These will automatically be called by the form's constructor and +** destructor. +*****************************************************************************/ +void KbfxConfigDlgPlugins::init() +{ + KbfxPanel->clear(); + KbfxPanel->insertItem ( tr2i18n ( "Left Panel" ) ); // index = 0 + KbfxPanel->insertItem ( tr2i18n ( "Right Panel" ) ); // index = 1 +} + +void KbfxConfigDlgPlugins::ChangeForm() +{ + KbfxPanel->setCurrentItem ( 0 ); + KbfxPluginSelector-> selectedListBox()-> clear(); + KbfxPluginSelector-> availableListBox()-> clear(); + KbfxPluginSelector-> selectedListBox()-> insertStringList ( ConfigInit().m_pluginsLeft ); + KbfxPluginSelector-> availableListBox()-> insertStringList ( KbfxListPlugins ( 0 ) ); // list Left Panel Plugins +} + +QStringList KbfxConfigDlgPlugins::KbfxListPlugins ( int panel ) +{ + QStringList _plugins; + _plugins.clear(); + bool _not_present; + QStringList::Iterator it_available; + QStringList::Iterator it_requested; + + KbfxPlasmaPluginLoader *_tmp = new KbfxPlasmaPluginLoader(); + QStringList allPlugins = _tmp -> scanPlugins(); + delete _tmp; + + for ( it_available = allPlugins.begin(); it_available != allPlugins.end(); ++it_available ) + { + _not_present = TRUE; + if ( panel == 0 ) + { + for ( it_requested = ConfigInit ().m_pluginsLeft.begin (); + it_requested != ConfigInit ().m_pluginsLeft.end (); ++it_requested ) + { + if ( ( *it_available ).contains ( *it_requested ) > 0 ) + { + _not_present = FALSE; + break; + } + } + } + if ( panel == 1 ) + { + for ( it_requested = ConfigInit ().m_pluginsRight.begin (); + it_requested != ConfigInit ().m_pluginsRight.end (); ++it_requested ) + { + if ( ( *it_available ).contains ( *it_requested ) > 0 ) + { + _not_present = FALSE; + break; + } + } + } + if ( _not_present ) + { + _plugins += ( *it_available ); + } + } + + kdDebug() << "Available PLUGINS: " << _plugins << endl; + return _plugins; +} + +void KbfxConfigDlgPlugins::KbfxConfigurePluginButton_clicked() +{ + KMessageBox::information ( 0, tr2i18n ( "

Not Implemented yet.

" ) ); +} + + +void KbfxConfigDlgPlugins::KbfxPluginInfoButton_clicked() +{ + KMessageBox::information ( 0, tr2i18n ( "

Not Implemented yet.

" ) ); +} + +void KbfxConfigDlgPlugins::KbfxSaveSelectedPlugins() +{ + int _selectedPanel = KbfxPanel->currentItem(); + QStringList _plugins; + _plugins.clear(); + int it; + int _num = KbfxPluginSelector-> selectedListBox()->count(); + for ( it = 0; it < _num; ++it ) + { + _plugins += KbfxPluginSelector -> selectedListBox() -> text ( it ); + } + kdDebug() << "Selected PLUGINS: " << _plugins << endl; + if ( _selectedPanel == 0 ) + { + ConfigInit().m_pluginsLeft = _plugins; + kdDebug() << "Saved to Left Panel... " << endl; + } + if ( _selectedPanel == 1 ) + { + ConfigInit().m_pluginsRight = _plugins; + kdDebug() << "Saved to Right Panel... " << endl; + } +} + +void KbfxConfigDlgPlugins::KbfxPanelSelected ( int _sel ) +{ + KbfxPluginSelector-> selectedListBox()-> clear(); + KbfxPluginSelector-> availableListBox()-> clear(); + if ( _sel ) + { + KbfxPluginSelector-> selectedListBox()-> insertStringList ( ConfigInit().m_pluginsRight ); + KbfxPluginSelector-> availableListBox()-> insertStringList ( KbfxListPlugins ( 1 ) ); // list Right Panel Plugins + } + else + { + KbfxPluginSelector-> selectedListBox()-> insertStringList ( ConfigInit().m_pluginsLeft ); + KbfxPluginSelector-> availableListBox()-> insertStringList ( KbfxListPlugins ( 0 ) ); // list Left Panel Plugins + } +} + + + + + +void KbfxConfigDlgPlugins::KbfxPluginSelector_movedDown ( QListBoxItem * ) +{ + /* save current selection */ + KbfxSaveSelectedPlugins(); +} + + +void KbfxConfigDlgPlugins::KbfxPluginSelector_movedUp ( QListBoxItem * ) +{ + /* save current selection */ + KbfxSaveSelectedPlugins(); +} + + +void KbfxConfigDlgPlugins::KbfxPluginSelector_removed ( QListBoxItem * ) +{ + /* save current selection */ + KbfxSaveSelectedPlugins(); +} + + +void KbfxConfigDlgPlugins::KbfxPluginSelector_added ( QListBoxItem * ) +{ + /* save current selection */ + KbfxSaveSelectedPlugins(); +} diff --git a/configdialog/kbfxconfigdlgstyle.ui b/configdialog/kbfxconfigdlgstyle.ui new file mode 100644 index 0000000..df866a9 --- /dev/null +++ b/configdialog/kbfxconfigdlgstyle.ui @@ -0,0 +1,505 @@ + +KbfxConfigDlgStyle + + + KbfxConfigDlgStyle + + + + 0 + 0 + 622 + 467 + + + + + 1 + 1 + 0 + 0 + + + + KBFX Control Center + + + + unnamed + + + 10 + + + Minimum + + + + kActiveLabel37 + + + + 3 + 0 + 0 + 0 + + + + + 0 + 29 + + + + + 32767 + 29 + + + + + 255 + 255 + 255 + + + + image0 + + + NoFocus + + + AutoText + + + <b><h3><p align="center">Menu type</p></h3></b> + + + + + KbfxStyleGroupBox + + + + 3 + 1 + 0 + 0 + + + + StyledPanel + + + Please select the menu style + + + + unnamed + + + 10 + + + + spacer4_2_2 + + + Horizontal + + + Minimum + + + + 53 + 1 + + + + + + spacer4_2 + + + Horizontal + + + Expanding + + + + 1 + 1 + + + + + + spacer4 + + + Horizontal + + + Minimum + + + + 38 + 1 + + + + + + KbfxRadioButtonKbfxStyle + + + + 3 + 1 + 0 + 0 + + + + WheelFocus + + + KBFX MENU + + + false + + + 0 + + + + + KbfxRadioButtonKdeStyle + + + + 3 + 1 + 0 + 0 + + + + WheelFocus + + + KDE MENU + + + 1 + + + + + + + groupBox4 + + + + 1 + 1 + 0 + 0 + + + + StyledPanel + + + KBFX MENU + + + + unnamed + + + 5 + + + 0 + + + + pixmapLabel1 + + + + 0 + 0 + 0 + 0 + + + + + 293 + 334 + + + + + 293 + 334 + + + + 15 + + + image1 + + + true + + + + + spacer7_2 + + + Horizontal + + + MinimumExpanding + + + + 1 + 1 + + + + + + spacer9 + + + Vertical + + + MinimumExpanding + + + + 1 + 1 + + + + + + spacer9_2 + + + Vertical + + + MinimumExpanding + + + + 1 + 1 + + + + + + spacer7 + + + Horizontal + + + MinimumExpanding + + + + 1 + 1 + + + + + + + + groupBox6 + + + + 1 + 1 + 0 + 0 + + + + StyledPanel + + + KDE MENU + + + + unnamed + + + 5 + + + 0 + + + + pixmapLabel1_2 + + + + 0 + 0 + 0 + 0 + + + + + 293 + 334 + + + + + 293 + 334 + + + + 15 + + + image2 + + + true + + + + + spacer7_3 + + + Horizontal + + + MinimumExpanding + + + + 1 + 1 + + + + + + spacer7_4 + + + Horizontal + + + MinimumExpanding + + + + 1 + 1 + + + + + + spacer13 + + + Vertical + + + MinimumExpanding + + + + 1 + 1 + + + + + + spacer13_2 + + + Vertical + + + MinimumExpanding + + + + 1 + 1 + + + + + + + + + + + + 789ced974b6fda401446f7fc0a8bec5095601eb64755174d7080a669d3b48b4a5517e33134a1101230e151f5bfd7f7bbc3f8510bb29a45d5b331e77e77c6c6067b7cd670bede5c3b8db3da3291c9bd72d49d5c388d78359b6dbf7d7ff3ab5677dda6d3124e2770dcfaab5afdd651ce4953785d11937e822acf63bd81c67bfd0c1d793eeb47ad8118917e20755d4f8a31e935d4f394c48ede4395df941dd277a4adaedf9501e995568f75001dfb9154a443ad8ab547da96412bc2cc97465ba4a1d636a77da348df9276ba818c3cd273a33ee985d688d30d69d7156e14916e8de230d65a5b9cee8c22fd028dfd91c05409ab08549374611407b9d42a387d328af459abe4746514e99cd40b645375491f8c62bf8f5a5d4e6746914e49fdb64c2f12e94fad3eeb049a9e7485eb7baf3566bd23a5b31ce3c4fe808aa813e3fa8ea02af263ec68ac35603d85c642ffea147494a6b80ab156c17a422a9afb34d22a631ca4d41ab19e5a058767157ce52a22a6322bb51debc95a69830b5445cc5466a5b6633d592b6df0fba962cc5466a5b6633d592b6df003b60afe4156c15ff810938c5ca9f4a16c93228509714b39c43423572a7d28dbb4486142dce2521e8acce78f9a3983da3c5f6152a7b17a8afdb042cb1c33cef6e0760d160ccbd290243a5824cb65be6cf449b35a9961cf29694752985383470fd86c36db941d581bb84a6cd6eb7cd9e82ea3d4b11fbacb83e7668173f07705a58b14aeec4378aeab3032ad16356dc753be17863d260cc34ba26f2a3daa6429d337a50c1a13f6fb61a99a178cc5aa63301c0e98a1fe3434952c435533a8e04094efc02ae8a55c8117b7578fc732cc2a58075a050b51ab60256c15acccad825703abfcdfe3bfb3c75babe045d52a78ddb34afdf7ebda1f4394dd1e + + + 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 + + + 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 + + + + + KbfxStyleGroupBox + clicked(int) + KbfxConfigDlgStyle + KbfxStyleSelected(int) + + + + kbfxconfig.h + kdebug.h + kbfxconfigdlgstyle.ui.h + + + KbfxStyleSelected( int ) + ChangeForm() + + + + kactivelabel.h + + diff --git a/configdialog/kbfxconfigdlgstyle.ui.h b/configdialog/kbfxconfigdlgstyle.ui.h new file mode 100644 index 0000000..eb8001c --- /dev/null +++ b/configdialog/kbfxconfigdlgstyle.ui.h @@ -0,0 +1,30 @@ +/**************************************************************************** +** ui.h extension file, included from the uic-generated form implementation. +** +** If you want to add, delete, or rename functions or slots, use +** Qt Designer to update this file, preserving your code. +** +** You should not define a constructor or destructor in this file. +** Instead, write your code in functions called init() and destroy(). +** These will automatically be called by the form's constructor and +** destructor. +*****************************************************************************/ + +void KbfxConfigDlgStyle::KbfxStyleSelected ( int id ) +{ + if ( id == 0 ) ConfigInit().m_KbfxMenuType="spinx"; + if ( id == 1 ) ConfigInit().m_KbfxMenuType="kmenu"; + + kdDebug() << "Selected style: " << ConfigInit().m_KbfxMenuType << endl; +} + +void KbfxConfigDlgStyle::ChangeForm() +{ + if ( ConfigInit().m_KbfxMenuType == "spinx" ) + KbfxStyleGroupBox->setButton ( 0 ); + + if ( ConfigInit().m_KbfxMenuType == "kmenu" ) + KbfxStyleGroupBox->setButton ( 1 ); + + kdDebug() << "Style: " << ConfigInit().m_KbfxMenuType << endl; +} diff --git a/configdialog/kbfxconfigdlgthemes.ui b/configdialog/kbfxconfigdlgthemes.ui new file mode 100644 index 0000000..9378b6a --- /dev/null +++ b/configdialog/kbfxconfigdlgthemes.ui @@ -0,0 +1,1032 @@ + +KbfxConfigDlgThemes + + + KbfxConfigDlgThemes + + + + 0 + 0 + 790 + 616 + + + + + 1 + 1 + 0 + 0 + + + + KBFX Control Center + + + + unnamed + + + 0 + + + 10 + + + Minimum + + + + groupBox8 + + + + 3 + 1 + 0 + 0 + + + + StyledPanel + + + Select default folder + + + + unnamed + + + + KbfxURLRequesterThemesPath + + + + 3 + 1 + 0 + 0 + + + + WheelFocus + + + 10 + + + + + textLabel1 + + + + 1 + 1 + 0 + 0 + + + + Please select the target folder where your themes are. + + + + + + + spacer11_3 + + + Vertical + + + MinimumExpanding + + + + 28 + 16 + + + + + + layout7 + + + + unnamed + + + + + SpixBar + + + + KbfxThemeList + + + + 3 + 1 + 0 + 0 + + + + + 200 + 0 + + + + WheelFocus + + + Installed Themes + + + Here are listed all the installed KBFX Themes + + + + + layout6 + + + + unnamed + + + + groupBox4 + + + + 1 + 1 + 0 + 0 + + + + StyledPanel + + + Selected Theme Preview + + + AlignVCenter + + + + unnamed + + + + spacer1_2 + + + Horizontal + + + Minimum + + + + 17 + 21 + + + + + + spacer1_2_2 + + + Vertical + + + MinimumExpanding + + + + 1 + 1 + + + + + + spacer1_2_2_2 + + + Vertical + + + MinimumExpanding + + + + 1 + 1 + + + + + + KbfxPixmapPreview + + + + 0 + 0 + 0 + 0 + + + + + 270 + 210 + + + + + 270 + 210 + + + + image0 + + + false + + + AlignCenter + + + + + spacer1 + + + Horizontal + + + Minimum + + + + 17 + 21 + + + + + + + + layout14 + + + + unnamed + + + + layout12 + + + + unnamed + + + + KbfxDeleteTheme + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + Delete Selected + + + Delete the Selected Theme + + + Pressing the button will delete the currently selected theme. <br><b>Warning!</b> You cannot delete the installed system wide themes! + + + + + KbfxGetMoreThemes + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + Get Themes + + + Get More Themes from the Internet + + + Pressing the button will launch konqueror and go to the KBFX Themes Section on www.kde-look.org + + + + + + + layout13 + + + + unnamed + + + + KbfxInstallTheme + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + Install Theme + + + Install New Theme from KBFX Theme Package + + + Pressing the button will offer a dialog where you can choose KBFX Theme Package to install in your home folder + + + + + KbfxThemeInfoBtn + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + Theme Info + + + Show specific theme info + + + Pressing the button will show you specific theme info + + + + + + + + + + + layout10 + + + + unnamed + + + + groupBox18 + + + + 1 + 1 + 0 + 0 + + + + StyledPanel + + + Personal Image + + + + unnamed + + + + spacer9_3_2 + + + Vertical + + + Minimum + + + + 16 + 7 + + + + + + KbfxDeleteDudeImage + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + Theme's Default + + + Set the Theme's Default Personal Image + + + Pressing the button will delete the personal image you have selected and install the theme's default personal image + + + + + textLabel3 + + + + 1 + 1 + 0 + 0 + + + + Maxsize 48 x 48 + + + AlignCenter + + + + + KbfxSelectDudeImage + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + Select New image + + + Select a Personal Image + + + Pressing the button will open a dialog to select your personal image + + + + + spacer9_2 + + + Horizontal + + + Minimum + + + + 18 + 54 + + + + + + spacer9 + + + Horizontal + + + Minimum + + + + 17 + 62 + + + + + + frame7 + + + + 0 + 0 + 0 + 0 + + + + + 255 + 255 + 255 + + + + StyledPanel + + + Sunken + + + + unnamed + + + + KbfxDudeImage + + + + 0 + 0 + 0 + 0 + + + + + 48 + 48 + + + + + 48 + 48 + + + + image1 + + + true + + + + + + + spacer11 + + + Horizontal + + + Minimum + + + + 16 + 16 + + + + + + spacer11_2 + + + Horizontal + + + Minimum + + + + 16 + 16 + + + + + + textLabel2 + + + + 1 + 1 + 0 + 0 + + + + This is your personal image displayed at the KBFX menu. + + + WordBreak|AlignCenter + + + + + spacer9_3 + + + Vertical + + + Minimum + + + + 16 + 10 + + + + + + + + groupBox4_2 + + + + 1 + 1 + 0 + 0 + + + + StyledPanel + + + Misc Options + + + AlignVCenter + + + + unnamed + + + + spacer13 + + + Vertical + + + MinimumExpanding + + + + 1 + 1 + + + + + + KbfxWatch + + + + 1 + 1 + 0 + 0 + + + + Watch System Installs + + + Watch for applications installs and reload KBFX if any occurs + + + Watch for applications installs and reload KBFX if any occurs + + + + + KbfxShowOldThemes + + + + 1 + 1 + 0 + 0 + + + + Show Old Themes + + + Show Old Themes + + + + + + + + + + + kActiveLabel6 + + + + 7 + 0 + 0 + 0 + + + + + 0 + 29 + + + + + 32767 + 29 + + + + + 255 + 255 + 255 + + + + image2 + + + NoFocus + + + AutoText + + + <b><h3><p align="center">Please select theme folder</p></h3></b> + + + WidgetWidth + + + + + kActiveLabel6_2 + + + + 7 + 0 + 0 + 0 + + + + + 0 + 29 + + + + + 32767 + 29 + + + + + 255 + 255 + 255 + + + + image2 + + + NoFocus + + + AutoText + + + <b><h3><p align="center">Installed themes</p></h3></b> + + + WidgetWidth + + + + + + + + + 789ced7d5973e33ad2e57bff8a1badb72f26f4695f62621ebceffbee8979e0029014256fb2645b13f3df279127012e925dd5ae2add6a77f984441e2091000e565232f5dffff5d7f5f1c15ffff5dfff183f7bcf49f057107b4f7ffd5738198ddefef7fff95ffff71fffac775b7f35eab5bffa4d3afef37ffce39f61ffafe0af4a8dfeda1de63dc7bbccbb8ef798771cef336f3bee316f39ee336f3a1e306f381e32af3bae98d71cd7cc6f99d76bf54ecdf0a02ddc837dd0729ced83a6e59d3af3ae705fec1b96775acceb8e73fd4603f0a6f2387e9438dee6f2dc306fd41a529e8e705b9ebee3287fd572294f4fb82d8ff5177458afe0da71d62bb8759cf50a2e1d477d2f2cef727b0657c243b1af592ef1e78e737d8223c7b9fd8303c7b9fd837dc7599f60cf716eef60d77194f750b8127fa78ec3dfa6e3a8ff86e3a8cfbae53de8bbe638f45b751cf579731cedf9e238ea37751ce5d912ae25ff15cb25bde738d2571c477aed38ea93380e7d52c7797c04778e43af27c7d1ded23fea35e4e7f71d477eb1e3c82f721cf98d1c477e0f8e23bf89e3188fe85fcd5a53fae3b170dbfe678ec3ff8970db9edb8e43bf99e5a2dfabe3d06f47b8e8edb72c87bddf731cfe7dc751dfd0719467e838eafbe838ea3b769cebeba37f36eb35c97fc771ee6ffea9e5e86ffe99e3ac8f7fed38f737ffd2f126f386e3a84fd371b467d771d42f701cf5538ea37e03c751bf7bc751bf67c751bf2de175a9dfbee3a8dfb9e552bf23c751bf2bc751bf0bc7b97e23f4b7668b2630ee3fb06fd55a1dd8633e68397db71d47fe27964bfe078e23ff9ae3f077e338f4ed380e7ddb8e43df3be175f457ffc171d6cf7f749cf5f3c78e43bf37c779fef2678ef3fce96f388efa6d3a8efa1d5a2ef53b761cf5ab3b8efadd3a8efa45c21b988f7ded38ebed0f1c47fd868ea37ecf8ea37e2f8ea37e6b8ea37eeb8e63fd457f6ed3f28ff2613e6b53fd509ed8719427751ce579721cf94f1d47feab8e23ff15c7397fef5a78a3c3fa7a378eb3bedeade55dd6d36b3acee5f5ba8eb39e5ecf71f417e538ea133a8efa8c1c477dee1d87be13c751bf57c7b97ede99f0a694ffd27194bf66b994bfe538cadf771cfd21701cfb0ff48776abe961ff85f1d9a9753a6c5f1908d74d2e5f65e43897af82f6ecd46b127fe738eb5f8984d785bf58dee2f255a68e23bf99f086c4bf390efdaf2c173d2e1c871e75cb458fb6e3e87f55c7a187e738ebe1ad0a6f7678fef4561c677dbc2dc7b9fdbc0dc7b9fedea1e3dc1fbd3dc7d11fcf1d47f94f1d47f91b964bf93b8ea3fcbee3287fc57194ff55784bca3f751ce5df751ce55f771ce5df771ce53f761ce319e5efd6bad23f52e1b67fc48e73fa0ae693aeeb1ff78e737d2bdaf216cf6f1525dcf68f89e3c8efd971ae6fe555b8f48fca8ae3881f3bcee3b3123acee3b3f2e438eb55d9731cfd7bdf71d4675578b3c5fa55761c87fd96e3b0df701cfdffcaf236ea77e238faf78be5d27e33c7d17e2e3f69bf35c7d17e478ea3fd0e1c47fed6bed586de978ea33ce78ea33c56af16f673ded071cc2f89e3b07f709cf5f61e1d67bdbd89e3a8df9be3a8dfb6e3a8dfa6e3a8df89e3a85f55781bd77b5ec5718c2fdf725c4f799ee3a8cf9de3a84fec38eaf3e438eaf3ec38d76784f9b4db6a7bb85ec57cdda3ed18fa1fc65bcff5a76dc7d13f1e85dbfef4e038ec371d87fd81e35cbfcabae5d29ea78ea33d2f1cc7f890f2b9f63e761cf1d78ea3fc378e63fc1c3a8ef153779cdbaf52731cf5e93a8ef68b2c97f6508ea33dee1d477b0c1c47f98e84b7a53c0dc791ffade3c8bfef38fa7fcf71f40f6db99427701ce519398ef2a48e737942e8ddaff5d13f2a586ffa4e8f96e3284f47b82d6fd3718e1fa17ff65b5d0ff73bd0df3dda1eb37f8df9c4ebd4022e6f88f6f36bbef4478c07bfe579b81f02bd02ba9ec7fd16b45f48d7efe0e84faaa630fe86682fd50a3cccf798ff744d4b3ceaa75bcac3fd149e2febb57a0de335e4fe5ea73f8cd76113bc4d45e4789ebfea0d5aaf513f1e0ff526cd4fdcdf8735f076d367fd439e4feb2d3bde431e0ff536e9cf7c7803de6efb680fd6a7dea97764bde2f151efd2f6129ce73fda3cf7b0fe0e2fc1db5d9ffb7bc8f37bbd5fef633d0e793da97b750f7c780edef67cdcafe1f9b9eed7fd2eeac7f3593da80758bf87a7e0edc087debc5ed5c37a88f890e7fbbaaa2bacefc363f0b6f2b11fe3f5bbaeeb5ae20fc03b351f7af37cdaa00b7eec07429e9f48de3af603c31978a7e9e3fa9cd7c306fd213ee4f9add16c34b17f0d793ea2cd570bfbd7e13d78a7ed437f9e9f1aed461bf121e23b8d0eeebf0c3578a7eba37ff0fc4a9baf2ee2431e4f8d5ea387fd702500eff43c8c6fdf712e5fda11eef9680f5e7f1afd461ffbe78a07dee9e3fe59a522dcc3f564a5ea38e75fed0bf765bfcbe3b9e1353cf8abf6c0291ebc2b3cc0784caf2cc7f8ab7684871eeb5b6d3b0ebd78fe6af80d1ffbfb6a0bbca330beaa4dc759af6a43b8f6b8bed53a78d78e1f5e6f1b4123c0f541ba03de5101f78f6a0d9cecb97f556f85d77dc4df086f60bc54af1d67bdab57c29b321e783d6c848d10f9552fc1299ef5ae5e086ff9ac77f5dc71e87d26bc8dfe5c3d751cfd97d783866a285cbfa52fe0dd7a80f29d08efc0be7aec38f43c12de45ffae1e3acefeaa07c27b3ec63ffaa76e68e457dd07b7f1d53de17df4dfeaaee3688f1de19eccbfdcdf9ab5660dd79bc355f04e88f87400de6d06d0775bb817a07db684fbd27e9bc203a9ff86f010e943eeef345dcafd82ea3a38c5a33dd684ab00edb1ea38da6345b8163e731ce381c71f4d070df81ff4c0bb6df1f706deab05688f57c7d11e2fc2eb01da63ea38f49e086f80873cfe9bf487fb1dd567708a477b8c853703d4f7c971d83f0a6f85188f0f8e637ee5fd6bb3d56ce1fec910edd1a2fec57a0fae8477458f7bf05e1be9ab778ea37d46c23b21e65bdebfd072d586ffea10dcc60fb8ffd066de13bd52f05e17f1d581e3e81f3cbe9bdd5e0f7c00fd7ad41fa06f0c6ee3ab3c7e9afd5e5fece1cfa3f686fe1adcc65795704f38f4f18973ff49d13f022a2feb91a0fd036a3fb44720dc877d15fd25b43ce1f9b0a95c7b79c203c40fd1bf69bcc978c0f8d1bd50f2e7f9ba55a3f2737d932678af8df63e79161e86589fb83fb5ea545e4eaf86e03d85f884e7c3162d37684f950a97783510aec51fb76fab49e391ebaf12701b9ff0fcd96a919edc1f542c5ce253d6abd5a6f2f378521178bf16b2bf94e777bad8a9213eb9141ea03d9406b7f64a09af830f50bf2e7508d65785e0363ee5f9b7d5a3f6827ea7c215f4550178bf21fe58ff96e93fdc7f950f6ee395279c9a98fdf3786f79bd16fa5772044ef943cf8a70b157684fbfdf92f43c5e5b41af83f19fac835bfbd1ae706b0f7d435bdfd10e78bf2df6db8ef3f84ae05f593eda12de011f70ff6ce95e5ffc6d82dbf811cfb7ed5abf2bfe02c759cf01af47ed3ab517eb355a07b7f6a335e13de13cffb61bc4397d7c2bbc1f72fd075cbe7693fa33f7cfd10a38c5233feeef6dd3bfb8bf8d66e0363ede171e843c3e473c3fd3c584c48f5e857be029af87ed4ecf47fd933e38b537ee07be0817fb78265c853cfe463c1fb569390cd1feac7fbb47f6cc4713e1121fdf837b7505bd509f3e9517e9513e8f38eb31ba171e8a3f9ecf69b3203c467bf85e53617f8df60a7a21e6a744835379a12f8f7fea0c0dd1ef51b8c48f9e846bf048ecbdb6e2f979087bd553d25fc6e0d63eee817bb590e323e8abbd9ec2fe9bfb6f872e10317f0dde847764be63fd3b752a1feb33b813de437cb402ee798ac757c4f353a7e1050ae39df7939d268d1fd663e009f7643ee0f1d969f565fd4af6c1bd3afa4b1409570ae38df5ec74fab23e25286fc76ba27e29b74fa7db97f52719827b6df48f08f977fd9a42ffe1f14fbb795fa1bedc3e9d7e5fd69bb80d4e0b16973f827ddf6f2a6eef01eae7517f42fd4fc0a9bccc63de5f9addbae2fae92eb8df565cbf01cf879d80fa0feb11ed8053f9307f40efb0239f670f9fc0a97ed81f6c0ad7986fe22d70aa0feba351fed0ef29f40fb48f3260fb29389517e30b7a6903f69f8253ffe1f94237c17d4f61bc71ffe99a1baed8bf54c0fbb25e0c3438b50fc63baf075d73c1cb7aa6b7e07d595f9315701290e3e344b846fb440138e9c7faeb9af040637e42fee6828ef54977c1fbb29e8eb83edd6657ee4f473d70bf8efeaa6f842b8deb59eeffdd9601db5f82fb2d691f5e8fba6d03ceef19dc6b487b748487d21ed7e0414d63fc22be63c0e9e1cff467d63b3e04a7fe80fcb784d310e7f4dcffbafcc7f1c8bfeb77d1bf35cadb0d9a1afb1bd4b7d795ebdb01ea4b57b3689f21afffdd7e57ae5f07c8bf4f178cac773400f7fba2ff3978d0d6d89fa03d3d03e6684fcf93f57760790ff3d3107af806ec1ffdc3f77d8c0f7d0a1e7435eeeff0f5266d86035c1fc54370d203d7f77cbdd70d0d98233ef464bd1e44c27dcc17c9049cda1ffda129bc0b7df53178e069e8cde3b9abbaf2f9ff10fd5179b23e0f79bfded506dc9ed0577b76bd46ffd3347f707bea23f020d0d08be78f9eb9418bebb35370cfaecf7570ea7f684f4edf33378c303f6d82937ed0f34178a8582f7d001e680dfd79beed991b1e182febe09eac9731fc9b1b00685f9e6f7b4d03b61f83939e688f35709a6f58ef2811aea43df7c0c39a46fb70ffeab50cd85f04eec97e61c8f35faf6dc0edd706f742c4c74fe0341f717e7a073c6c6ab40fef4f7b1d034e8ffa773c8df5406f81872d8df6827f1e20ec5f83d37684db2fe5fed5e33ff6f702eed7e02fd913de95f9aa2b3cc4784c793fd2eb1b70f960dff764bf31809e7dbf81fd483213de83fe29cfd73dcf80d3bf827bb2ff1804e0beec3f928170bb3e5f08d7e81f29dac737607f29b827fb8f08fdc10fea68bf147a05066c1f8253fdb15ea33d82a021eb1bea1f1a70fa6b705fd6f7d8f210ed3740f99401db431fe537305e07685f6dc09cc76fdfdce0c678d904f79b688f01d7af6f6e9862bd817d9dc60ff633dc1e7d73c30efd3f00a7f904fa71f9fb4d03b6af83d378c0fae481074d8caf84fb4fbf65c0f647e0d47ed8df6c0897fd4c740c1ec87e2081ffb601a75f05a7f916fb9d27e11ae9139e6ffb1d03b67f00a706847d084eedc7fd2dda15dec17e207a15dec37a9ef07ac2d33fe6d33570bf237ac6c203cc5f710d9cda1bd773dc9edcbdb1fe1d80072df4b784dbb7cf7fec7f0a4ee305fd9de783be67c0e957c0491fe8cbf32b2d3f046e2fb48f4ffaa03d507f5a2fc41ee50f0c98f3feb01f1a707ae417fab25f8aa157487aa03d783dee2b03b6877f45ed87f502eda568438ffd14cff77d6dc0f1f0af031ffac6dc9f3df38109fadf2d7850c37c916c096f43cf685578a0a10fcf879eb9e18ffd34fcd5a97d71fdbf2abc23f3bfd80721f64731cfdf9eb9a18cfde30c9cda0fe923e13d491f0b57921efe9a06ccbbe0547fccffac97d732607e0e1e78d03392789aff39ff08f56f1bb0fd0e38e985fd2acfdf5ec780fb0bf431fd19fe5f8487d29f793de3ed07fa2fe2bbd63e427d7902e5f403f040a17d22de2f70f7c3786980d37ac9fa47bc1e78fcc7fc143cac439f88f79f34ddfab8df9ea23c7e20fb93f44d78073cd9111e8a3edbe06143f4b917de04d7bc7ff30203f6f7044efd1dfe9e85cb7a1ba5e0b4be717b295e5fe8e239c4fdfdd4030f64bd4e46c215f4d4c85f7972ff3f41fd54a0452fb48f0adb1af787501eedc9e70303d45f53fb633fb926dc97ebaf0bf0b00e7f9afb976f3e30c4f8b80777f6abe0a40fc76b9eef7df30117c643084e7ab2fe8aaf8f7df30107eb178fc0490fb6d7acb7df34e0f80a38d5077af37ce9b70c98737dfcb601f72fc49bfe8af97c0f3cec426fcde3dfef1870fc0b78d813bd783ee1ed2ffa6b021ec87e43f37e9097675cffd6c1a97db09fe0fd3d4f87d89f409f7e5893fd39ef57b93bc21ef5f76c7cdc10de113db83d7cfe637be8e153fbe07ec5b5f0868cf763e15d991fd685f7443f9eaffdc080e3c7e074c18af514e50f0d98a37c61d892f93412ee49ff457f5006ac670b3cf4a1a7e6f9c4d7061c7f031e0612cff50dcc07ce18cf1be06188eb23cdfe02f30129d67fd89b0fb4501fbe5e0b9a061c7f004ef9239eaf17839601b7e7367828ebbbe2f536681b70fc183cec207e18398ef1160b0f50ffb82f3c143d78bc041d034eef81875da44f9bc2e5fa3fbe14aea047c2fd8f2fa7303f9d8087b21f4867c2fbb27e6d0bd7481f3f82ab1af453dcbf797b88fdf8c071f4e791f03ee253949fae6e24bfd0728cef3805b7fe35cfcf26b5f84f1d87ff58785f7822dcc3fde601f4a0051ffe07a7c2e5fe8186fe9e49c15c0b97cf47b4721cfed07f3c9b7ef0245cd6dbe80c5c35707d1cad096f6adc6f407d7df287f96a2adc07d7bef000f7a307c89f0684ac0f1370e78ff7af64ecc35eaf0b97f4bae238aec7d05f42175f152ef72b55cf71dccfef0b97fb8d8ad77fc3e47eed39b8aacbfc86f1a209b06f3b8efd26fa9b267dd01f371d477fe2f118d642b93fa99a96cbe7010de175dc5f4c127025f73b14f737138bf818fe683780f6884f85cbfd0bcdf36b683e50c67ab1096ee3e389f00ef456b06f1af0f85b07a7fe8afc62e1d69ef7cb61cb80edabe0a417dab3235cee7744e7c27be08ae7b7b06dc0e3e50c9cf4c2f5f89af02678f428bc8ffb178ae743be9d88ebc914dcda0ffa8ea3fd505fbea1c2f1c7e0a41fe2515fbec0e378e4d723bd70fde20bef487bf0fa419b6fb1576bc2fbb83fa278fde2ed098f2fc5eb072d0e965f0ab7f7f777c1a97ed097d72feebed8ef8fc19587f844398efd8e27dc177d79ff14f21fb71ffc87b4e141f9a0b732e0f857701b1f2be1a1d8a3fd7428f71b22e8ab6d7c742d5ce1fe8fe2eb1d65bef084f5e94db8c46bd64b992fe4e0f3851de19ef45fa4375f58c0fdcb07e1123ff485fb62cff3bb6a1a707fa809f7a1573a141e88beb06f1970bc121e227e70e638fac3ab7005aeb97d55db80e3abc26d3ceacb37a899233ddf70e3f682ffaeae41bfe4d8715c7f4e85d7454fe8c33714b87d9ae0363e3e11de10bee138e66394872f0039fe19dcc6476de14d70cdeb1f6f97717d70046ee3a3b1f016eebf295e4f793b83fcf8fa86a753ccc7a80f7738e63c1e15ffb13dcf4f4a2bd98f6b2e9f365f88c3fd78cbdb523ece5f9b2f6ce17ec8b170891f348477a4feac87365f48c1f5e2ba701bcff5a3dac9fc91bc08efa17e49d571ac27bc1fa6dacbfc115f0997f8c8f2bed8f3fe8a4a27f34934156ee3793fce1f57e0f35dde7ff3ed57f4571ebf7cbb08fd8bd767be3cc77acef3155faea0bff07ac0db47d48ffb072f57682fe8c5039ad3f3f862f9f17d4de8cb7f869f3c572b04cfc127048c90a1089a1111624222181052c2903122dc39dc131e088f8227c298f0ec30214c092f8257c61b61c658a9ae12d608eb848dea26638bb0cdd8a9ee12f608fb8403c2610e478c6387931c4e19670ee7255c082e05570b71ed7023b82dc3e8cb8a667ae6d5ccb47c5fc9452a7ea460a69f5130d330d37143b4dc725aeeb0967ba2a55512fa658a7d5ba9efd168814a825a01f53934e6c1fa860b14cdeb99a999d7b2ac64a663b917e635b40a6ee67a63d623ad92792d6d6fcc94cc74bcc8a976fd813af39a2cd0e21d3417a0f5bd607d8b9ae6152dea392ef44aab6559c9b5b911bd39a761a6e0fcd83e2a69992999f5b81ba75b51ab6f29d076e82c40f7e783f5cd467d51d3bca2793dcbb3e35a69769c9f1fad8a87b9de789c9b0df323fba2a0e562259b39bde675e939f43f46a5fa797ccb37814ac0fa5a55f39a667db4a8e87bab4d79865cd417f3bdb138b2af7323bb56d0d2f6c576a187f572fa983f6f0e7e01c10fc397f70cf37916c17f46df4a5851155d892a7125210ce47d20ef79a4126aedb25786a4706e90ba70eb372d59260b7c0ce7c292dc3129f85c54e2a4e477be3683051ef3b52c5b2654a6791f8b6c4795bbca3da98affb779a83c569e2ae3ca7365c298e6de279517b29bf06b22c72c66920bc5fbab0b9b14d24de94c39bf8adea7ce2eef4f398b49c9dbb7f09a2bd3a274591955a136281b8e26dd5b21d52c17af2ac59aaa9c06aa52cc6d85145dad3cb0be6b95f5ca4665b3b255d926ad0d761838dbadecf1d1bcefbaf83d8edf91901d09376c2f973a9f1e1e1e24dd432e058e26deb23df7bec3717be2e5c179d89534bbb9d2ee32f225c9ce77a5c4bb39ebcc6366bf932bdb434e85ac3e7be2235ff21df18fbaedd36bab726074657d0f2b4795e3ca09e1948e67743caf5cd0eb92cecff81c61978473b6bbac5cd1eb542ccdbbb1bca030a4bf229cd1f915c79c70dc19a735298f39fe8a535e718a63ceef8aedaed8f2ccf93d97dc8ef968ce4ec4f705c79b3c6ca92e39f494de4fb974975cca4b0abb70799f738ec6e2422c4cd96077cc0a9cbbfa1cb3af334e79ca61c75237e3ff9c5f275c4694e02a57f26b52f586f5bdadd408f54a83ceea9526bd6a74d6a2e32d85d52a6d8eadf33b6c6b148ed8bac43424d5adb3a873ba9a7835b6f0035f0d797528a649614df1749bb3699105fc76e4bdc1a175f17feb2c6daab694a541fe50f6ba94c196b029e5ad494ab0963bb77541896d996f5dfd8d2dfcdd4a0ea8a92dbd2d0d80ff67ee11fa95be57a5779cf7e42c63fc4e8b62df9edb542e9d89cda531b6b0a7f89e79b10d9f0beb71cabe0d97b00a7c67de5c5c5fcefbf9dcc58be499f97135e8570a7540399df77cfee2954beeeae44adfcf7b9552169492daf4f325e6fb111e7ff4177821bd9b3ff3c185e729bee1e17168e045f87c976d3d0ab7963e87798e1b3bdf5906e2cbfab4219a59c07906025f2ce02992184d67f0e0b16ff8f2a46c997fedfc78ec554b9942a999f1143a2b73ab58e5d207ae2c1e973ecaf9575c827ce97dc93f608db2d2c05249e9b9dcac6f4c48bc011f075ecaef084378c261b1bc23dcd825fc42ca844353e72171b626fd5078169ae6de13496d30925c6d1962970f7284c7bb428ec863c021b6f4e6fc8e5ef79cbb4931608b584a6c73495caac4953c250c726548a41403b1193aadaccfd895cdfa363e287fd6f7c1e191df9f4afcc11be758f68e97b57972678f398ff9148f85b0a752d8638e3dbe93cae2a994cba32bf3239f3f2fc8fda954c3476fbea4e51c8ddd73ae74f3a5c9f235e74fa552f1fecc9b7853efc57bf5def838e1e32b696af1c2af29851b1b6042789577633f757c22f1334af5c66153c61b5bccd86285d3c0ee4dc2a6fc9a396e626ca94c8a1987db74c6f39463671c87942f9cabb59a49be6f52ca55b67d91f4537744acc9712c79bf49a96d3caca7acc244eab22afe4dd9569c47940ae5a230d677cd5ba7d706c39c6f32d6898d39669d8e9b2e16f16b1262b1295ed69da579df721ed7e5cc586ed3fb3ac5ade7f25ca7d0358edd60dfc86543d2c2eb8e0b5b636cf0f986e4087feb5ce64df1694b6b4bb529361b2e877529d99a94d9a6b4fe37a556c8d1a65f9374b6d6bb4ebf4c0313cafb5f6fcfdbf70ebc43c611bf1f50d821bdc6126a7bb2b13cf48e8521e6d09d191cb0854db5e7c24daafd9ca7438e3b747e0ddb279bbd82ef7df1b027f9eccfe5572c5fdee3612ef7ccee50ca82d063f1bc978bdb77b1fbb93a1cbad80329f92133bcefb9f343b139f44e8c25eb7bea9dd1eb9c7041c7533ebfa4f74bf278c5e1630ebde6a36126ec948e175c8e53b232ef17e4c7845d703c528fd9e7b9bcdbb4e7623f26ab4be71f3e519a338ebd70616361385eba143822d753f63e963a9c4a0d6eb82ed6ce1c6f9ccd58d2c0f29c4b7c21b53ce7d28d5d094e999b325c53e9ce5d89812bc72eb9ecc258df5b41cdabd3eb965f381b7b0dfe9ee798431b7444a8458d5e750aafe5c26cfaa6c48ff14d4f0ab9658e33841aeb0633e4dfe23435afcd1eb25c1b9c4f8dc36a923ecbcf7aab31b339d425079b2f4a5ee7d87c0d5007c494eb67429af26ab85cdaacc9adb006951ae56c88f78e5312cf47e97a3dafef57f91ddfebece1dba1e4d19cf5f9d8238bb18476e9bccb7163634da9104321b481add20691e3c8aacfa9c71cd7138ff064721cfbbec9958e48d1cbfcf079cfe667cec96f20f1f0d3675fbef5ca29fa6cd13725345f10826797cec45b8f6465cbe96a3a26cb9e78ebe6f3c69162336dbaa282ad37eb67e32506cf8b0b054a5ef63d248f7cce47cb2d53e628e79a8efc01381f433ff2e3cc8ecf94af4d78d163ceaf4915fb318744c62387c6928fe2f3c44fe8a84b25826562fdd81878b439e7f2b3b994eb9788375b072955ce9652a296ec85eb2d4a69a79d726a1a8b98f51df8a93ff447f43ef0efe87dc4e774249f230a1bf091c2f8989aa381b1a6f794d28c8c0d87dd71ca81b1374c4247ec75c061a93b720ee26988342ec50056363dfbb8874fc22097f24eca8572a62809ca644bca76b6fc2393de95cb966a20f535feee726990f35da60552481da1d548620c1ef8fc8e41e1acef23e1c91fd3eb99ce267c1c131ee938e558b009b3295b3d71ac394ef90cf1f0f3cc318f1c66429e38fdd8593f4a3cd24fe4f8223e8de5442c900f30c9f978f25f25fd337b37b113f230258cb91cb07cf2c0e067cc65799694593d5096672ec11387bdba1453b1183bdb09a77dcaa93361f64ae95fa4cec617fb657ddf1c66eeb8e2c256257cc6285a66ef33b19de5e2b314f0372bd85a3b6b352b789b49aad95c8ab7429ec5b46b251bbadae0b315e7bbec09a957e7ea3f2b84ac1742ca2a14cbb7923be7eb0b7fc3dff4b7fc6dc20661878e5b14b2edef32df66188b0d7f8f6336fd7db23296266c8bd3eff3d19e199b0dc62e87196f7b7cb6c7e73bec69432c7739d53e1d7739a70d872db6dfe2b03df1bfcdef48bbc7b96d4b982da3f1665edbe20d69f6d916fe325f9be21f25dee6941b52864db6db93106bb32f675b9cb351017e4c8d7639cf3da939c5b3be07fea17f44efc7743cf14ffd333a3b239c50a8c139c71cc9fb29591a1c9185893de15426355ee76461383c1df1d909879c71cc19871cb3dd21bdcee9dde67ccee10782632e89b135f9185b93e28c2c8c9743b63ee1d791f83b91721eb0ed01db1fcbfba1e47ec6e538e21a1c70e8017b3067c75cab53cee3987340fd6c094f2417137bcc79a096671c7ec6b53fe6ba421ddefffa17fea57fe55f17de6ffc6b9ee3af05b72684e200136f8e35bf4ed6b40be7b09a581abb1b97b2c6bc4e2157260dfbbc106fe675ebfc5c8bcf2b4963525f71c825a5a8b1458dcf50ca1afbb9143f97cee385cbf78253c3da94e19acb51130b84da5a5d116e50737e5db10dca99e57825beeb128bb2dbdcaf5c9d6bd080f56df0ffb6b4e8d5c8403a14385b3524accdef1db229db369935ca9030ca67815febb5e962da2eac51383368bd93da9eb7e7732fd8b55c6e36bcb320171bd2992b23de3b1f9423e789f535ffb9d3f47bf80f1ebf8f336f1c5425c4a047e1d6ae2776e6baa00b5b09efb125ff27129f75c5b6c996bda0e2f770e677838a78b4b9e6f3ea717a7b4e39b9b2345d698a365d97174a9a856476c68bd483cf7a2eb5396b06955c1e08ebd3795fea63f5b16565df815728b92d4f53f2c0f3e17dfc2f03ffc701ff1781e1d8039aff5990b328880da757182414ac5d4c627799e485d29b902074e98de7d8b1d8d99a9cb25c94f5207189f123e78a7c445c3a4a8fffd320ee73b829b596501c637ef7510bfc17061f23ae1d42e01171e05af209259de1a1a9b3f8342111a74ed85fcc1e7c4e017f9a4b82b4b1f5cdfa0ee82ca5f73418f2bb79913ef44e603d077c1c727d876c9792cf94951c22cef8e05608614921c61bde53e1a380f6e9ec3f45bb50486a7d1bbf8895b8289787c971c4eff9b20e383481c79c5d88b2b3c590c253173fa29084a0d816f6297b1b527ef61c5e8d9748e2524e9b728cb54825047128d7884b3912bf43d6f72eb827fe40b8a7f3077a11a85ed99162e8f8c0e78f0c1b66ce1e73b68f1cca5740d69358208db1b93779c19febcd776c7f0f4fd6838d335e2936650fe2874afce8fca772fe28ec8eeb646c1f3874c8210f391b29175bc0eed1797fccf1bb021e4b1e6c1a840c5d4e7792f31debfb54c2985ecfde182c7f94f389b55c64e3d8336b53b25ce86f2e6d392e18bb777b362ec4ccc3864fe6629eddd97cdc5842cb794f8279bff3394fe6cf59dff1829c1669372ed5799c8f2ba8f38c9238fb054a8b86253de7f5f5c6a88bf79e9279f5cb7a2f4a93b77b5e106b5b713ca7f2386753b6ca149ce4523ccdf5dfbc0e92524669a65ca1154a3a4dac3a92665cb49cefebc570782ac571ae5e59917ced27eef87e2be4551a2ff432afff7b21df82533ba76fb91dbe5dd2f76d30c6b2b1bc607ce4c65dd94bbef6b68f7c9cd3a2924c824cf18fea52ac09ac27c1a2d923f3972f5d5ebbb99ac8fc305fe78c3f3bcff91294cbf8be02c5148bdbefbd715c6e99c579408dc56d359f72524895852cea05939282e53a2c9ec173be64ff907e03c3021bbdc38605cb51c9c3c8ed74ca3e47b9b362aacc6e98db0b2d2ed547a52f5b663bb391db6b0d0b79974b5faec922cfc3a05c26ec1fcc5eba124c8397e035780b6684157abdc93bb0e2ceb2b0b79cd52c6733cbdefd56ce5ae0c2564ade8a3916739b954a302be4582cd7ca7b392fa84d2935a55a99b39bcd5966359cf3441e5e085382fc7f37d9ad066bc17ab0116ce6b0156c1336bf135b1f842df202dfeffbdf9e4bb91decbce36f3b97fb7629cdbce7b297ad92af8fcf1797d886eec8d906a9b946aaf2fd5f62bbc15eb01f1c0487c1510ec7eeec30c78e0b3659fc7caac538ce9d0147f23a96d0c305a94e3ec8e1d8a5fda83487efa49dcfad9ce65bb53a9cf3711a9c91a2bbc106ebbb1f9c0717c16570155c07377ff0c3b80e6e49cd0b52759ff5ad51483d6804cda0c54f45e9e0d92872d675cc867472569d528aa27519bd859eb274e5bc3a259ebdf79c874e29be7cde9d3b2ba7c87c641e7b731e8b5ee6f3caf2e9875552b34eaa5e187dc30ac32bc17ed01ce4f0bd7f6a0edffb6773f2f13c07069e8d1031e230210c086938248c0877e17df8c078243c11c68c67c2843065bc105ec337c68cb012ae32d608ebe1066333dc0ab7193be16eb8c7d80f0fc243c651781c9e104e0967e139e122bc0caf08d7e14d78cbe0a78ee05922f6f92054e66801740e9512ca6df1fd287bcae7522e41a6a551331535a1e7bde899696975b44a16b5ccd45ccfa959d47357f42c2a6a3585a299a699aab582aaac2b9ea622bf5f3058886401e2efc6a2d4494eaf79a40e43d7338d96e5de59d6d3f6cab28e7925d133ad967935d13f17e9995734eba7ef695a5095d0ca9e3f233599c7f0bb30725a7c1b7705dc3b3ccca138ce270535ad9ef93e99ef91791d8b4a16b5b4e3ddf6cf7c0fcdf7d1a2a2654d17a84a6867cfe75950bb1fc163094f0ee30578164c1ca6b9719e1fe5b66f2e9a2f7772f3657184177b65b967e6fb6651cdc57ace2bba40533cb9287b7ed1c27a7f1bcf054c162a342da8f5e266c64cb73c666e8c2f1ae5e5d9b2b8fa1c2d54b1ac63d62baf736bd27b5a2e5233af67a66841533ce9297bded387aa94d5296ab45827ab94d5caaa95614db02ed8c861b330ca773e5879ca6b79b12fdad972918a651dad921f69f9be9e0545093d817dde5555505908cf41be3c882703e5603761f64f971031624152c080913286194e9ef9a935d9136bf2cf57c99e54537c6ac5f73ca1a6f88c9ac9a79fb0b2f8f9203be5675bb0bedfa7dbf7aa36784f33a75aa5f4bc9feca93f56c7a296da6999149eaa925731ff849f45cff8c9149cd7705ec5f2936a163d6965819af3cf0a617d17f5bbbc7a8bfb5b4937a7dcb774cb9ef2933de927ffeca4fcd393cafd32d372f1d33fe69f9164d5837ec57e585630d3b0ac6251c7ec992b070b9fa7947b8e12eb1b2d54b1a0614ec145fa15b50b1728577ceed4fc1393ac8aa305fdb2ace534d70b8b4ffe785fb9c5dae5d5cbeb9757705ec3b28af67954a7f34fa3627d0b5abed313f32a8685b1bbe8b95defa9579c1bbf3d3b4e73cf50795bf08c9ff9274d95c7ee22dd1629577e9ed7fbeabdf78caa85cff2faf3fcb33fcf3ffbf3fcb33fcf3ffbf3fcb33fcf3ffbf3fcb33fcf3ffbccf3cfd448dda97bf5a01ed5931affc10fe389947c2045ef14ffff9b7a5613d278aa5e28e4f50f7e1877a4e494149da8673c3f5acdd40aa9bcaad6d4fa1ffc30d648c9675274a6def07c6ab5a9b6d436e9bcf3073f056fa4e616a9ba81e767ab3db5af0ed421e1e80f7e1846c70352744fede279e2ea8470fa073f1546d3633c8ffd0f7e15fee8fb6bf147df5f8b3ffafe5afcd1f7d7e28fbebf167ff4fdb5f89cbeea4c9dff8b382be1997121b8645cd175a5b94637b8e62bcd09e346dd12f8f7b8f0ab5b746ddfa097f9c5ac16ff8e554775558f5e7dfe98c0fc9690af0335a577f3c54c452fad231deb845e03f542efa97a31d0437a9910e27a84b045d077ea6c79faeafb9fd5befaa10cbadab13811c88e5d3f329e00baea34d79de6ca739faf3e0ff80a1457501b6a438f09cf066a534f1853ba6635d8d62f06f67e807ed56f166a66a133987b33affaee33f5fb64fffd49ea7e87c699cab92bccbcd2ac3394b66a5bad736a17f536b09a3bd5cd1d1851dee9cfd0ab6a45ad2c575f1af13353b6ff10aca9f325eb7b46adbaf59f029a21ce96acef33cd51dbfa553575f56b8356df6deabfcf4bd6f782e6fd175af39fbe3af43ad57385eafbb7e8abeff4c697c61df5e1175a6d96adef25cd496ff4be4965d8fab2d8a0fa55a99ee7a6272d55df559a937628d76d2ac3ce97c506d5af4af53ca3fa2e57df35da11be52aebb5486bd2f8b0daa5f95eaf9acd6fe267df7a90c075f161b7a5f75a99e174bd7779d76dc6fa4ef2195e1e8cb62431f92beb4cea8f5bf415f7337e681ca70fc65b1a11e48dfd5bf41df09cdf9331a3527a4efe997c5863e515daae7aa9a2c59df1bbaa231fa9e5119cebf2c36f419f55fa3efcdd2f5bd607d2fa80c975f161bfa42b54d3d97aeef2de9bb42fa5e5119aebf2c36f415e9bb42abcded92f5add1b585f936e03d95e1e6cb6243dd93be6bb4dad496aeafb9825bd7b7a46fedcb6243dfaae6dfa1afaed39c744eab6a83cad0fcb2d8d00dd5a47adee8fad2f55d677d5b5486f697c5866eb1beb7cbd6578d48df33d2b74365e87e596ce80ee97b46b3e16899faea1ee53a31ff57a0fb7a23aa7e5590be7daae9b3aad3fbd3f2f48d2a94df0dffdfc62be9eb2d843cbb3e0a224fce16dbfd4cc853f523f573fcd1fee195462af4fd84ba9fd657abb6d90193c677a4efe23ff9a5802889e4d7aadeb1fb997f36a7f4e7b8237def48df0b5a6dda4bd5774857e5b7ea92f47d217d470b21f355741fc973ec255cbe9b123d464f057b1b7a2fa946d1b3f330614e69a3692eed93b3e41ca29752095ea3370e1f4777cc1f993d472367fdc2674f73651790be2fa4ef25bdbabab7447d67ba6a76c0b46f8949df95855815dbb5685dce4ce846c1cf7acebe9cc766b42567e6b53d977633dae1a3c97f97cf565d8aed2cff5cc89ee4b925e55a89d6f86ceb9d1aacd0fc1b93b6abb4ba5523bd447df749df3aebab48df838590df6e8d8e22f93d560a3b91b3d3e88c8f6739fb230e3977d617d1652ec75397f63097f68a531c44a7c514647d10f1ef2745371277e5ac0e914374edf25c5c7e02e9abb4a96793f41d2e51df5bbdce5718b76a4afad616c2fd8a68d490632d6aca593d6af1b19db36f734827ea8a4d37921119f5e3ea3b69fb38c6150ee9b9140d8abbe2b3962d47d48b3d896b88e2b5b9329440f3c394ebd9d6ebd16c79fac63eff7fa2b9ebb1ae37e2602142672dbf7d436132c6e2308e50b7cc1efac6b1b3d1b1fcee4e3c608bd2f8e4b4a9f8b5c75c8ab9322731f7c0388ae5b72585c7ef949f40fd779dafa4ba6a1aed2f51df3badf8ff3f6f35ed11e3fb8590552d7e74a9ee63d943c60f318ecf397b5ecde289b3798aa7cefa3e4bebbc99b4bc3ec5d3f855b84df112cf7dc393acee258747d37b8d15f3f13be52790be55d27742ef2aba2d7bfc85fabed1bc6f76c0351a391bf16c2156c4d6ad3314b626672b31af79713e2daf5ef1a6b3598bb79cf5ac90b69447bcc66a6d13b729766219cdf17aa14c1b9ce7aeb1c60bb6ef81e68736e97b43bd388efd25eabb47fab659df26e9bbbf100762eb7ea39cc28ee4ec20e635263ec9d9f3fa159f3a9ba3f8cc59ef17d29ebbb41c26fc82b84d711ecb688e8f5dba338ae7f52f36ad71603c30bb7ea7fc04d2b7a9acbe4bbc3e8e69dfcb3b60735dbe11df2e84fca677ecc61585c95a13d7625e63e266cebec9212d67538fdbcedac4771cebbab4bc9ec5fc0bd67197b84d41e74995cf1ace5f9bc22a384f3ceb8dc23bef949f40fa8e48df5bf36c81f86d79fa263eebcbdfd7d71b49b0102154a03359dfe84cd6a8244af8ea2e89337be89b24895c832569223ba224648b2c2daf4f89e25052114a260362436723b9520ed69fa6b048cee3c4ad961cfe0e485ff3df0835a36fb2c4fe9bdc270fbc03a6bc49dfc785e0f52819d3995c87716852f033c9d9f3da94bcb8b8d7447a4cf22416cf85b4330ecbf80a319b6295ce0bfba9e499ad67b978c9ef9dd233485ffe8f0fad9287f86689faaea93bdeb9d0d8217dd71782d7ab6493ce64d5e1d0ed6447d86eb257b09f8a3d5b275b1422736892e5b005fd73690f5c99d67329b698ed25bba2e19658e73d1e88a7c5a56790be3407ea3aad3677c912d7b7e4d0e97b43fa1efd14f08a979cfc246f3f05a4ef8dd3f753ffd3f3697d5fcd1586d97b93bea73f0567ecf9fc2779fb29207dd7cd1a4eabcd6bb2b6447d2f749fae309ae6da91f4bdfcaa207dd7cc1e94569b7e72b5447daf75c7ec80cdbd0fd2f7e6ab82f45da519b84db3612739fcd775fab4beb74e5f6ae3a4f65541fa5e3a7daf97a86f3d69981d30e9bb42fa36bf2a48df67d2b74bb36f23692d51dfb66ef10e78a4cdfcdbf9aa207dcff81e569feabbc4fb3b495737cc0e8d5656d37f7bdf81be4d3ba81a3ea80aab0ce4d3cf814fa1eeaee22044ba81b2690672c53508accff7acadbf41c461f23960d26796bbcb89927c04d2f79cef3e747423a91735f895fa0e127dcb3bb4a6e9bf83eff94b73a987c4e51eece0cec60cee29d4fde2f4e051d23d4189ccc360ec7cbe639dcb29cdac06cf73e5a87eabd0a4ef0aed80a74943df26dd25ea3b29e83bfd0ef075d7e095dfdf88cb95ea60652057c483550a5db356837549b781103adb14bb17e7f3236bbeff3998d199dc1f1d6cb1c5bc970fa037f49ad577b0bd447d77d4bdec8067a4efee77803f5b1cf0f5e9e080b8ec76e85cee1f0e0e29f4386775c2e9f833b3c1199d9dbb14d6e747d66788a333eb1f16f35e3e00e93be3cf185bea7e907ca4c84fd6f76270c93bb4a632fa5e7d07787733e07b24835be272f772501fc8ba31a8516883d5a9c396d33545b1ab81acdf83b6f3f99175c3d9cabc39e8b0c5bc970f40f3c38c3f236f0c2e079325eadbd557bc436b6bbabe18f4be03b4be0d1a29af6a69c584c053eaa5767debd9d894efa4a481b14af92e67aae84c56a63482c7f7ad2d244c56c1346656f2f231a8ffaeaa897ad1b7fa6ab0b33c7dd3c4e9fba637d2c1b7c1a9523a1bd271c861bcd2a4a394efab7218df41491f52fec42e7d62ab522c9d8fc5e7bbd6b9723e5398f4bbf4314b252177df2a35e9fbe6f45de2fa964ef585d901d395cd0ee9fbf24df0ba96bed119af6be90a9df1ba93ce525ea5d2550ae135295d4f79c54bd738e54cf47d49e5db25269ef1a135e607f62a2b5afaca16b9efa850dedf2837cd0f3b6a42f5bcd717e9d612f5ddd66766074cfa9afebbf34df07dd8748fce78354a0fe86c4fb4e0cf1cd2430ae1352f3da233d3cb8f39e58958eda4b24ea5a7e2f3636b783db3f9d0f9395b94bd7c08d2d7f4df3b5a6dced225ae6fe9457ac93bb4aea6364eafbe89d2b57b7a4361bcaea5b5947701e935859476f06983c29a627595b67269afbe695d7367d7b9f8792f1f82e68717b5ae5ef5557a994e97a86f5b9f981d1a5d996f93be9d6fa23477a55d0a2b7c5f2eeda79d61b56835ac5018af7e439fece50a7018c0e7c7d643df9dc99a97f6385dc9cbc7a0febbadd669277aa14fd225ee7f87caeaab690f3ed4df047fae388ce98caf568789094d8f731e074359d9d99ed73e9a3a6c4adfa6a4f3217c7e683d80ef616463e97cc4b6252f1f83faefd4e97bb1447def58df0ee93b217defbf09be461d3ed2195fc10e1f3834f3f74c4cd6798ee1b1387cb1366cff98cb7ffc9175ce6e4a61af39fe9af7427cf271b949df8932771f8cbeed25eafba61e069774d558559ba4efec5b90542b742edfea19aed2b9fbc465b84e4c56f6e1269d6fb9501e95c39d2c9ef9f647d6ce6a9773d9cb85ec0d0bdf71e5d41f409b27d3af513dcfd4c370899fcf0ff7f5a1bed22d5dd5cfa4efc15705f55ff3648d16ade687c3257e7e313c227d2f8cbe6a83f43dfeaad0e6c97f56df257e7f6778a2f7cd0e58afab23d2f7f4ab82f43d227d1bea41ef0f97f8fdd4e199de257d6f49df43d2f7fcab82f43d54abb4d37fd0bbc39325ea7ba1b77907b1ae688e1a5e7e5590be076a95eab9afb7874bfc7c7e78ad37cd0e82f4dd277d6fbe2a48df7db54af5dcd59bc3b325ea7babeff4e1e0524dd52ee95bfbaa207d7759df6d7d375ce2e76fc3863663e64a4df513e9dbfcaaa0fdd913cdbf57ea51df0f97f8fd87614bf768cc5c90be8fa46ffbab82f47d5497b413bdd3bd616389fa7648df6da3afa23dccb0fb5541f3c3a9d1573d91be4bfcffcd613fd23466ceb452b4071f55bf2a48df63d2f74cdf477ab8c4efef8c2ad14c6fd2558dd20fa4aff75541f3c383baa47af6a2d96889dfaf267df7694e3ad1ca1b93bec15785def0cc93784f22aaef52f50d474adfd3554dccfaeaaf0ae8ab1e223d52c3febfaed3e7f58d7d3576fabef7effdfff670face627fa9fac631ed58f4a17a617d93af0ad677551f92be77cbd537b98b2a7a5ff41d7c5588befb23952c59df782fd27a3779f88fd07737ba8df746e9bfaed30fe87b130df5aebafb0fd0774defc67e7cb3547d87c97d34538feaf53f415ff518bf25f74bd6772ddab7fa7e6578e649dd8fc95db2b6547d47c921ed8037d5ebbf9ef6df0d6a5d6fc67b54dfca67527f5adf8bc8dc03ded7fd2f8f337d17df24174bd5f74e3dc43ee9fb1f82c44fae97acefa17dfe03ffff3e418de4171b9bfc8b8d5dd5955fa05ad7eb6aaaa65a31621d9bdf5b4c1e0cd41de1d5807b4ac72069240ddd223418b7fa56ddabfbc1a581be225c10ce0c5273e7e5449fa807037d48d827ec32b6f536ad0f8f7a93411afdc86f3c256bc9ed72f5d563fc8220ff72e0befb6d46f32b81f6f718a7f82546f32b8cfa957f8371957f757145afe935b5c2bfc9f92cbfbd697e7573ddfdd6269eb950e7f66a733b711b99d6312d835631edc12d216dc0ea5f58d559ef7dabb351583de9fbcf22b91aec8cc27f5da7cfff7fc020a136bda77103dce7b0e670e57098c385c3750ead1c6e1dea39b41dba1683ed1c1287490e3b0e179f46379da6dbcbfcff805f87746b78363cfa342e92aefed4f7487f157e377d93ab616f78f8695cc47b3f5e869f89df4ddfe17eba559837fe2550da4f7d0befd7e1b7d39766dd78efb3482e3ef72dd25f87df4b5ffd46fafaf1dd6791aca5176af7efae451ebf97beea6c7831523f8234d12b7f772df2f8bdf44d1ed27634fb110cbaea53ff27f1abf07be9ab1be95654f911d0eef9e1c7cbf1f3f07be96bf4f9b15f2ba6eb974f7d8fe957e137d3975637b97ff049449ffc9dab5f85df4bdf74aac6b893f359443afad47d985f85df4cdf2d7d66eeb07d1eeafe73cf81fb55f89df4d5b3c18e5a57173f8411cd309ffa259b5f83df4cdf6db5f1a388f7f46ff4a9d56fa56f9cdcf1dde01fc248a9e71f2fcbcfc2efa4af7a8defcc671b3f067daf3ff59f12bf06bf8bbefa49dd25177af3277c1e79a8efd5f9df5d1f8b9fadaf7ec0ebfd7803754c38c96116ed27f76a8c4fe57e147a5bf774434f0b399c983c91fbe74bff77ea5bd0edf43de43eb3b3d8a63dd53d5d17ecea93c125a9f363fb33f32ca213eac39b743537d5e35c3efb94ebae7ed28fef972edf0ebf8fbea22b69c7ca1da823c682b5dd7cfaa9276a0b9f7a9acf3dd559ec47157e5692fd24799d7f11e133a8535af3d9e71d797b5177fa423de835f3d9aac94bbd51ae5b7a4225182fdc79a0d407dc0aa60d58e7bf5f5f56f7844a649435cfa3d8a69ae0f3e279acea9936bf3b7ba156f933e3b5c1a5ee51cb3c50af3e349f3cff28c8c791da276fa6c58fc87b6c722198fc2ed439e93da3522c2a9b698737b54d3530ff15bb47353af971857f92bea7d4730f595da3e18a5ae1cfdf570a309fc79b4fe42fcdaf8d9bdec69fc2b7a221c51c53ea37bda27e18e463874a71c8a3e94cef6b857c784cdc50ce975402538ef9d2716abd4ae5300a1f528d4e7f1b7d3fdd7fcdb73fa37dbe773b24684685668c1ef56bf33bc0fcfd0373678cbf49c3df16e1ef8d6c13704f67ff0374a4f7fe1bf7df1f9b7f97837fe7f93753f993fb87e5e1df74ff5054f953fbdf65e0df7cfffb078bf047df5f8b3ffafe5afcd1f7d7c2e8fbad35ff0f3e055e53595ffb1de943fe8ef41ffc288c8e07d80fb2bee6298b5be6ba8bf7e17ff0e3a0eb405274536db0be6f6a4657dfcff22dfd3ff85198abf1675274a6de58df67355123f31b9ef61ee11ffc10cca75c53fefded67d6774421f7ea413daa27734fe50f7e104fa4e403297aa74646dfd13de3a1884403a3c71c9ebe13e3397c6f4ac98973b665b91f3d3b4c4653c20be175f44698115646aba335c63a6183b0c9d8226c137618bba35d5555158647f055c008090aff3ca62215ab843150a91a1a9c3c572b554fe05703424850fccf675135ae26844135ad0e19778cfbea43f5b1fa54e5fd1995f9f91bb82fe1e1d3287bfa28d74c4ba3e6aba8093d5745cf4c4baba355b2a865a6a6caa959d433859e2545ada65034d33453d53c6a2a539575ad3e1326d529ebfbb210d305987c3716a59ee6f49ac7abc39beb9946cb72ef2ceb697b6559c7bc92e89956cb9c9ad23f17e9995734eba7f39a9655655dab2f84d7ea2beb3b7b076fdf8599d3e2db582960d5616d0ec571be5d50d3ea99ef93f91e99d7b1a064494b3bde6dffccf7d07c1f2d2a8a7e6a35cdfaaa55d5e8fa569d1156aa2bacef7ced7e04eb256c386c2ec09660db61271be785516efbe6a2f97290cd9773233cdf2bcb3d33df378b6a2ed613bd34df4fcb9a1a5557096b8c75d67751bdbf8dad02b6172a94c72ec09a65bae5e1b931be68949767cb45ab4f59c5b28e59af1ce4d6a4a2964535b3515fd63353149aae594dab1b844dc256758bf5fd4895923a258d16eb6495b25a59b5328402fba773880aa37cf0c1ca535ecb8b7dd1ce96451517eb68955caca55533eba1853eca8a6e0ab618db8c9dea0eef7f3f522ad3ea736a1515cbcf8dd90c0905ddf87e57cbb29ae53527df0fdfd3b0ace2e44325cb5a5a35cb7ae614adee12f604fbaceff7e9f6bdaa0dded32cb7c2544af3a31dddd9f82eafe08bd69bbbb9151cea65fa3d3bfd3205e7359c5731d3f13d2517aac938201c0a8e58df8f4769fc4e7f2be9e694fb966ed9dc989f1fb319b2b8da0cdfd90d2dda0f59ed16a907fd8afdb0ac60a66159c5a28e7b4ec74c49d292714c387138657da3852a1634cc29b848bfa276e102e5a282728b66c7a17b2c6cb95f96b59ccead302bdf546eb17679f5f2fae5159cd7b0ac22e92838639c67607d0b5abed313cb6b73b8b0ef7d4bbde2dcf8edd931d3f22ddb53e65696dc4abd40b7dd77745ba45cbeff7dac5e413fc605e352709587d177c1aedb7fa73796751cbcb363fc9e15fa79e1da525ca7ed88ceafd1f9d5c4aa579ef7e6f55aa4d8d937147b4733876b871bc16d19fffc7ffff31fff1f031c5b9b + + + 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 + + + 789ced974b6fda401446f7fc0a8bec5095601eb64755174d7080a669d3b48b4a5517e33134a1101230e151f5bfd7f7bbc3f8510bb29a45d5b331e77e77c6c6067b7cd670bede5c3b8db3da3291c9bd72d49d5c388d78359b6dbf7d7ff3ab5677dda6d3124e2770dcfaab5afdd651ce4953785d11937e822acf63bd81c67bfd0c1d793eeb47ad8118917e20755d4f8a31e935d4f394c48ede4395df941dd277a4adaedf9501e995568f75001dfb9154a443ad8ab547da96412bc2cc97465ba4a1d636a77da348df9276ba818c3cd273a33ee985d688d30d69d7156e14916e8de230d65a5b9cee8c22fd028dfd91c05409ab08549374611407b9d42a387d328af459abe4746514e99cd40b645375491f8c62bf8f5a5d4e6746914e49fdb64c2f12e94fad3eeb049a9e7485eb7baf3566bd23a5b31ce3c4fe808aa813e3fa8ea02af263ec68ac35603d85c642ffea147494a6b80ab156c17a422a9afb34d22a631ca4d41ab19e5a058767157ce52a22a6322bb51debc95a69830b5445cc5466a5b6633d592b6df0fba962cc5466a5b6633d592b6df003b60afe4156c15ff810938c5ca9f4a16c93228509714b39c43423572a7d28dbb4486142dce2521e8acce78f9a3983da3c5f6152a7b17a8afdb042cb1c33cef6e0760d160ccbd290243a5824cb65be6cf449b35a9961cf29694752985383470fd86c36db941d581bb84a6cd6eb7cd9e82ea3d4b11fbacb83e7668173f07705a58b14aeec4378aeab3032ad16356dc753be17863d260cc34ba26f2a3daa6429d337a50c1a13f6fb61a99a178cc5aa63301c0e98a1fe3434952c435533a8e04094efc02ae8a55c8117b7578fc732cc2a58075a050b51ab60256c15acccad825703abfcdfe3bfb3c75babe045d52a78ddb34afdf7ebda1f4394dd1e + + + + + KbfxURLRequesterThemesPath + urlSelected(const QString&) + KbfxConfigDlgThemes + KbfxURLRequesterThemesPathUrlSelected(const QString&) + + + KbfxURLRequesterThemesPath + returnPressed(const QString&) + KbfxConfigDlgThemes + KbfxURLRequesterThemesPathUrlSelected(const QString&) + + + KbfxThemeList + highlighted(const QString&) + KbfxConfigDlgThemes + KbfxThemeSelected(const QString&) + + + KbfxDeleteTheme + clicked() + KbfxConfigDlgThemes + KbfxDeleteThemeClicked() + + + KbfxInstallTheme + clicked() + KbfxConfigDlgThemes + KbfxInstallThemeClicked() + + + KbfxSelectDudeImage + clicked() + KbfxConfigDlgThemes + KbfxSelectDudeImageClicked() + + + KbfxDeleteDudeImage + clicked() + KbfxConfigDlgThemes + KbfxDeleteDudeImageClicked() + + + KbfxThemeInfoBtn + clicked() + KbfxConfigDlgThemes + KbfxThemeInfoClicked() + + + KbfxShowOldThemes + toggled(bool) + KbfxConfigDlgThemes + KbfxShowOldThemes_toggled(bool) + + + KbfxWatch + toggled(bool) + KbfxConfigDlgThemes + KbfxWatch_toggled(bool) + + + + KbfxURLRequesterThemesPath + KbfxThemeList + KbfxDeleteTheme + KbfxInstallTheme + KbfxGetMoreThemes + KbfxThemeInfoBtn + KbfxSelectDudeImage + KbfxDeleteDudeImage + KbfxShowOldThemes + KbfxWatch + + + kbfxconfig.h + kdebug.h + qstringlist.h + kmessagebox.h + kio/netaccess.h + kfiledialog.h + ktar.h + kstandarddirs.h + kbfxthemesdata.h + kbfxthemeinfo.h + kbfxconfigdlgthemes.ui.h + + + class KbfxThemeInfo; + + + bool KbfxFormReady; + QString KbfxInstallDialogURL; + QStringList KbfxThemes; + QPixmap img_nopreview; + static KbfxThemeInfo * _info_box; + + + KbfxThemeDoInstall( QString & installUrl ) + + + KbfxURLRequesterThemesPathUrlSelected( const QString & path ) + KbfxThemeSelected( const QString & name ) + setKbfxThemePreview() + ChangeForm() + KbfxDeleteThemeClicked() + KbfxInstallThemeClicked() + KbfxThemeInstall( QString & installUrl ) + KbfxSelectDudeImageClicked() + KbfxDeleteDudeImageClicked() + KbfxThemeInfoClicked() + KbfxShowOldThemes_toggled( bool ) + KbfxWatch_toggled( bool ) + + + init() + + + + kurlrequester.h + klineedit.h + kpushbutton.h + kactivelabel.h + kactivelabel.h + + diff --git a/configdialog/kbfxconfigdlgthemes.ui.h b/configdialog/kbfxconfigdlgthemes.ui.h new file mode 100644 index 0000000..fe28790 --- /dev/null +++ b/configdialog/kbfxconfigdlgthemes.ui.h @@ -0,0 +1,367 @@ +/**************************************************************************** +** ui.h extension file, included from the uic-generated form implementation. +** +** If you want to add, delete, or rename functions or slots, use +** Qt Designer to update this file, preserving your code. +** +** You should not define a constructor or destructor in this file. +** Instead, write your code in functions called init() and destroy(). +** These will automatically be called by the form's constructor and +** destructor. +*****************************************************************************/ + +KbfxThemeInfo * KbfxConfigDlgThemes::_info_box = 0; + +void KbfxConfigDlgThemes::init() +{ + KbfxFormReady = FALSE; + img_nopreview = image0; + + connect ( this, SIGNAL ( KbfxThemeDoInstall ( QString & ) ), + this, SLOT ( KbfxThemeInstall ( QString & ) ) ); +} + +/* +void KbfxConfigDlgThemes::KbfxDudeAnimationButtonToggled(bool) +{ + if(KbfxAnimationButton->state() == 2) + { + KbfxAnimationButton->setText(tr2i18n("Animation is ON")); + KbfxAnimationButton->setPaletteBackgroundColor(QColor(0,255,0)); + ConfigInit().m_SpinxDudeBlink = TRUE; + } + + if(KbfxAnimationButton->state() == 0) + { + KbfxAnimationButton->setText(tr2i18n("Animation is OFF")); + KbfxAnimationButton->setPaletteBackgroundColor(QColor(221,223,228)); + ConfigInit().m_SpinxDudeBlink = FALSE; + } + + kdDebug() << "SpinxDudeBlink State is:" + << ConfigInit().m_SpinxDudeBlink + << endl; +} +*/ + +void KbfxConfigDlgThemes::KbfxURLRequesterThemesPathUrlSelected ( const QString &path ) +{ + QString tmppath = path; + + if ( tmppath.startsWith ( "file://" ) ) tmppath.remove ( "file://" ); + if ( !tmppath.endsWith ( "/" ) ) tmppath.append ( "/" ); + + QDir d ( tmppath ); + d.setFilter ( QDir::Dirs ); + if ( !d.exists() ) + { + kdDebug() << "Themes folder does not exist: " << tmppath << endl; + + KMessageBox::error ( 0, + tr2i18n ( "

Invalid user themes folder!

" + "

Will use default user themes folder.

" ), + tr2i18n ( "Error loading themes" ) ); + + tmppath = ConfigInit().m_UserSpinxThemeBasePathDefault; + } + + KbfxURLRequesterThemesPath->setURL ( tmppath ); + + KbfxThemeList->clear(); + KbfxThemeList->insertStringList ( KbfxThemesData().setThemeList ( tmppath ).keys() ); + KbfxThemeList->setCurrentItem ( 0 ); + + ConfigInit().m_SpinxThemeName = KbfxThemeList->currentText(); + ConfigInit().m_SpinxThemeBasePath = KbfxThemesData().setThemeList ( ConfigInit().m_UserSpinxThemeBasePath ) [ConfigInit().m_SpinxThemeName]; + ConfigInit().m_UserSpinxThemeBasePath = tmppath; + + setKbfxThemePreview(); +} + +void KbfxConfigDlgThemes::KbfxThemeSelected ( const QString &name ) +{ + if (KbfxFormReady) + { + ConfigInit().m_SpinxThemeName = name; + ConfigInit().m_SpinxThemeBasePath = KbfxThemesData().setThemeList ( ConfigInit().m_UserSpinxThemeBasePath ) [ConfigInit().m_SpinxThemeName]; + ConfigInit().readFontrc ( ConfigInit().m_SpinxThemeBasePath, + ConfigInit().m_SpinxThemeName ); + ConfigInit().readThemerc ( ConfigInit().m_SpinxThemeBasePath, + ConfigInit().m_SpinxThemeName ); + + kdDebug() << "Selected theme: " + << name + << endl + << "Base path: " + << ConfigInit().m_SpinxThemeBasePath + << endl; + + setKbfxThemePreview(); + } +} + +void KbfxConfigDlgThemes::setKbfxThemePreview() +{ + QString path = ConfigInit().m_SpinxThemeBasePath + ConfigInit().m_SpinxThemeName + "/preview.png"; + + QImage tmp ( path ); + if ( tmp.isNull() ) + { + kdDebug() << "No preview available for theme: " + << ConfigInit().m_SpinxThemeBasePath + ConfigInit().m_SpinxThemeName + << endl; + + // QString default_path = locate("data", "kbfx/images/nopreview.png"); + KbfxPixmapPreview->setPixmap ( img_nopreview ); + } + else + { + KbfxPixmapPreview->setPixmap ( path ); + } +} + +void KbfxConfigDlgThemes::ChangeForm() +{ + KbfxFormReady = FALSE; + KbfxURLRequesterThemesPath->setURL ( ConfigInit().m_UserSpinxThemeBasePath ); + KbfxThemeList->clear(); + + KbfxThemeList->insertStringList ( KbfxThemesData().setThemeList ( ConfigInit().m_UserSpinxThemeBasePath ).keys() ); + + kdDebug() << "Theme path: " + << KbfxThemesData().setThemeList ( ConfigInit().m_UserSpinxThemeBasePath ) [ConfigInit().m_SpinxThemeName] + << endl; + + KbfxThemeList->setSelected ( KbfxThemeList->findItem ( ConfigInit().m_SpinxThemeName ), TRUE ); + + setKbfxThemePreview(); + + KbfxDudeImage->setPixmap ( ConfigInit().m_SpinxDudeImage ); + + kdDebug() << "Dude image: " + << ConfigInit().m_SpinxDudeImage + << endl + << "Default dude image: " + << ConfigInit().m_SpinxDudeImageDefault + << endl; + + KbfxFormReady = TRUE; + + KbfxShowOldThemes->setChecked ( ConfigInit().m_KbfxShowOldThemes ); + KbfxWatch->setChecked ( ConfigInit().m_KbfxWatcher ); + + /* + if(ConfigInit().m_SpinxDudeBlink == TRUE && KbfxAnimationButton->state() == 0) + KbfxAnimationButton->toggle(); + + if(ConfigInit().m_SpinxDudeBlink == FALSE && KbfxAnimationButton->state() == 2) + KbfxAnimationButton->toggle(); + */ +} + +void KbfxConfigDlgThemes::KbfxDeleteThemeClicked() +{ + int messageBoxReturn; + int messageBoxUserResReturn; + QString KbfxThemeRcDestination = KGlobal::dirs()->saveLocation ( "data", QString ( "kbfx/themerc/" ), TRUE ); + KbfxThemeRcDestination.append( ConfigInit().m_SpinxThemeName ); + + messageBoxReturn = KMessageBox::warningContinueCancel ( 0, + tr2i18n ( "

Are you sure you want to uninstall the KBFX theme %1?

" ).arg ( ConfigInit().m_SpinxThemeName ), + tr2i18n ( "Uninstall KBFX theme" ), + tr2i18n ( "Uninstall" ) ); + + if ( messageBoxReturn == KMessageBox::Cancel ) return; + + messageBoxUserResReturn = KMessageBox::questionYesNo ( 0, + tr2i18n ( "

Do you want to keep your personal settings for theme %1?

" ).arg ( ConfigInit().m_SpinxThemeName ), + tr2i18n ( "Personal settings" ), + tr2i18n ( "Keep settings" ), + tr2i18n ( "Delete settings" ) ); + + if ( messageBoxUserResReturn == KMessageBox::No ) + { + if ( QFile::exists ( KbfxThemeRcDestination + "_fontrc" ) ) + { + QFile::remove ( KbfxThemeRcDestination + "_fontrc" ); + + kdDebug() << "Deleting user's fontrc file: " + << KbfxThemeRcDestination + "_fontrc" + << endl; + } + if ( QFile::exists ( KbfxThemeRcDestination + "_layoutrc" ) ) + { + QFile::remove ( KbfxThemeRcDestination + "_layoutrc" ); + kdDebug() << "Deleting user's layoutrc file: " + << KbfxThemeRcDestination + "_layoutrc" + << endl; + } + } + + kdDebug() << "Deleting theme: " + << ConfigInit().m_SpinxThemeName + << " - " + << ConfigInit().m_SpinxThemeBasePath + ConfigInit().m_SpinxThemeName + << endl; + + if ( !KIO::NetAccess::del ( ConfigInit().m_SpinxThemeBasePath+ConfigInit().m_SpinxThemeName, 0 ) ) + { + KMessageBox::sorry ( 0, + tr2i18n ( "

Could not uninstall this KBFX theme.

" + "

You may not have sufficient permissions to delete " + "the folder %1.

" ).arg ( ConfigInit().m_SpinxThemeBasePath + ConfigInit().m_SpinxThemeName ) ); + + return; + } + + ChangeForm(); +} + +void KbfxConfigDlgThemes::KbfxInstallThemeClicked() +{ + KFileDialog KbfxInstallDialog ( QString::null, + "*.tar *.tar.bz2 *.tar.gz *.kbfxtheme|" + tr2i18n ( "KBFX theme packages (*.tar, *.tar.bz2, *.tar.gz, *.kbfxtheme)" ), + 0, + 0, + TRUE ); + KbfxInstallDialog.setCaption ( tr2i18n ( "Select KBFX theme package to install" ) ); + KbfxInstallDialog.setMode ( KFile::File | KFile::ExistingOnly ); + + if ( !KbfxInstallDialog.exec() ) return; + + KbfxInstallDialogURL = KbfxInstallDialog.selectedURL().path(); + + emit KbfxThemeDoInstall ( KbfxInstallDialogURL ); +} + +void KbfxConfigDlgThemes::KbfxThemeInstall ( QString &installUrl ) +{ + KTar KbfxThemeArchive ( installUrl ); + + if ( !KbfxThemeArchive.open ( IO_ReadOnly ) ) + { + KMessageBox::sorry ( 0, tr2i18n ( "

Could not read this KBFX theme package.

" ) ); + + kdDebug() << "Error reading archive: " << installUrl << endl; + + return; + } + + const QString KbfxThemeDestination = KGlobal::dirs()->saveLocation ( "data", + QString ( "kbfx/skins/" ), + TRUE ); + + kdDebug() << "Copying theme: " << KbfxThemeDestination << endl; + + const KArchiveDirectory *KbfxThemeArchiveDir = KbfxThemeArchive.directory(); + KbfxThemeArchiveDir->copyTo ( KbfxThemeDestination, TRUE ); + + ChangeForm(); +} + +void KbfxConfigDlgThemes::KbfxSelectDudeImageClicked() +{ + KFileDialog KbfxDudeImageDialog ( QString::null, + "image/jpeg image/png image/x-xpm image/gif ", + 0, + 0, + TRUE ); + + KbfxDudeImageDialog.setCaption ( tr2i18n ( "Select personal image" ) ); + KbfxDudeImageDialog.setMode ( KFile::File | KFile::ExistingOnly ); + + if ( !KbfxDudeImageDialog.exec() ) return; + + ConfigInit().m_SpinxDudeImage = KbfxDudeImageDialog.selectedURL().path(); + + QImage tmp ( ConfigInit().m_SpinxDudeImage ); + if ( tmp.isNull() ) + { + KMessageBox::error ( 0, + tr2i18n ( "

Image cannot be used as a personal image!

" + "

Will use default personal image.

" ), + tr2i18n ( "Error loading image" ) ); + + ConfigInit().m_SpinxDudeImage=ConfigInit().m_SpinxDudeImageDefault; + } + + KbfxDudeImage->setPixmap ( ConfigInit().m_SpinxDudeImage ); + + kdDebug() << "Dude image changed: " + << ConfigInit().m_SpinxDudeImage + << endl; +} + + +void KbfxConfigDlgThemes::KbfxDeleteDudeImageClicked() +{ + QString tmp_dude = ConfigInit().m_SpinxThemeBasePath + ConfigInit().m_SpinxThemeName + "/menu_top_image_person.png"; + QFile tmp ( tmp_dude ); + if ( tmp.exists() ) + { + ConfigInit().m_SpinxDudeImage = tmp_dude; + } + else + { + ConfigInit().m_SpinxDudeImage = locate ( "data","kbfx/skins/default/menu_top_image_person.png" ); + } + + KbfxDudeImage->setPixmap ( ConfigInit().m_SpinxDudeImage ); +} + + +void KbfxConfigDlgThemes::KbfxThemeInfoClicked() +{ + QPixmap _logo = QPixmap (ConfigInit ().m_SpinxThemeBasePath + ConfigInit ().m_SpinxThemeName + "/logo.png"); + + ConfigInit().readThemeInfo ( ConfigInit().m_SpinxThemeBasePath, ConfigInit().m_SpinxThemeName ); + _info_box = new KbfxThemeInfo (this,"infodlg",Qt::WType_Modal); + + if ( !_logo.isNull() ) + { + _info_box->KbfxThemeLogo->setPixmap( _logo ); + } + else + { + _info_box->KbfxThemeLogo->hide(); + _info_box->hideSpacer(); + } + _info_box->KbfxThemeName->setText( ConfigInit().m_SpinxThemeName ); + _info_box->KbfxThemeVersion->setText( ConfigInit().m_InfoVersion ); + _info_box->KbfxAuthorName->setText( ConfigInit().m_InfoAuthor ); + if ( ConfigInit().m_InfoEmail == ConfigInit().m_InfoEmailDefault ) + { + _info_box->KbfxAuthorEmail->setText( ConfigInit().m_InfoEmail ); + } + else + { + _info_box->KbfxAuthorEmail->setText( "" + ConfigInit().m_InfoEmail + "" ); + } + if ( ConfigInit().m_InfoUrl == ConfigInit().m_InfoUrlDefault ) + { + _info_box->KbfxThemeHomepage->setText( ConfigInit().m_InfoUrl ); + } + else + { + _info_box->KbfxThemeHomepage->setText( "" + ConfigInit().m_InfoUrl + "" ); + } + + _info_box->show(); + _info_box->update(); +} + + +void KbfxConfigDlgThemes::KbfxShowOldThemes_toggled( bool state ) +{ + ConfigInit().m_KbfxShowOldThemes = state; + kdDebug() << "Show Old Themes is: " << ConfigInit().m_KbfxShowOldThemes << endl; + + ChangeForm(); +} + + +void KbfxConfigDlgThemes::KbfxWatch_toggled( bool state ) +{ + ConfigInit().m_KbfxWatcher = state; + kdDebug() << "Watch for Installs is: " << ConfigInit().m_KbfxWatcher << endl; +} diff --git a/configdialog/kbfxconfigdlgtooltip.ui b/configdialog/kbfxconfigdlgtooltip.ui new file mode 100644 index 0000000..97d5218 --- /dev/null +++ b/configdialog/kbfxconfigdlgtooltip.ui @@ -0,0 +1,719 @@ + +KbfxConfigDlgTooltip + + + KbfxConfigDlgTooltip + + + true + + + + 0 + 0 + 648 + 526 + + + + + 1 + 1 + 0 + 0 + + + + KBFX Control Center + + + + unnamed + + + 10 + + + Minimum + + + + kActiveLabel37 + + + + 3 + 0 + 0 + 0 + + + + + 0 + 29 + + + + + 32767 + 29 + + + + + 255 + 255 + 255 + + + + image0 + + + NoFocus + + + AutoText + + + <b><h3><p align="center">Tooltip ON or OFF</p></h3></b> + + + + + groupBox24 + + + + 3 + 1 + 0 + 0 + + + + StyledPanel + + + Turn off or on the tooltip + + + AlignVCenter + + + + unnamed + + + 10 + + + + layout21 + + + + unnamed + + + + layout6 + + + + unnamed + + + + kActiveLabel4 + + + + 3 + 1 + 0 + 0 + + + + Turn your tooltip off or on. <br>You can see the current status of the tooltip to the right. + + + + + layout4 + + + + unnamed + + + + spacer4_2 + + + Horizontal + + + Minimum + + + + 24 + 1 + + + + + + KbfxTooltipOnButton + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + Turn the tooltip "OFF" + + + true + + + true + + + + + spacer5_2 + + + Horizontal + + + Expanding + + + + 1 + 1 + + + + + + + + + + KbfxTooltipOnPixmapLabel + + + + 0 + 0 + 0 + 0 + + + + + 120 + 80 + + + + + 120 + 80 + + + + GroupBoxPanel + + + image1 + + + true + + + + + + + + + groupBox3 + + + + 3 + 1 + 0 + 0 + + + + StyledPanel + + + Tooltip Text + + + AlignVCenter + + + + unnamed + + + 10 + + + + layout19 + + + + unnamed + + + + kActiveLabel6 + + + + 3 + 1 + 0 + 0 + + + + Type the text which you want to be displayed in the tooltip. + + + + + spacer9 + + + Vertical + + + Minimum + + + + 1 + 19 + + + + + + + + KbfxTooltipTextEdit + + + + 1 + 0 + 0 + 0 + + + + + 0 + 100 + + + + + 32767 + 100 + + + + WheelFocus + + + StyledPanel + + + AlwaysOff + + + AlwaysOff + + + PlainText + + + + + + + kActiveLabel37_2_2 + + + + 3 + 0 + 0 + 0 + + + + + 0 + 29 + + + + + 32767 + 29 + + + + + 255 + 255 + 255 + + + + image0 + + + NoFocus + + + AutoText + + + <b><h3><p align="center">Tooltip personal text</p></h3></b> + + + + + groupBox26 + + + + 3 + 1 + 0 + 0 + + + + StyledPanel + + + Tooltip animation + + + AlignVCenter + + + + unnamed + + + 10 + + + 0 + + + + layout20 + + + + unnamed + + + + layout9 + + + + unnamed + + + + kActiveLabel5 + + + + 3 + 1 + 0 + 0 + + + + Turn your tooltip animation off or on. <br>You can see the current status of the tooltip to the right. + + + + + layout8 + + + + unnamed + + + + spacer4 + + + Horizontal + + + Minimum + + + + 26 + 1 + + + + + + KbfxTooltipAnimationButton + + + + 1 + 1 + 0 + 0 + + + + WheelFocus + + + Turn the animation "ON" + + + true + + + + + spacer5 + + + Horizontal + + + Expanding + + + + 1 + 1 + + + + + + + + + + KbfxTooltipAnimationPixmapLabel + + + + 0 + 0 + 0 + 0 + + + + + 120 + 80 + + + + + 120 + 80 + + + + GroupBoxPanel + + + image2 + + + true + + + + + + + + + spacer6 + + + Vertical + + + MinimumExpanding + + + + 1 + 1 + + + + + + kActiveLabel37_2 + + + + 3 + 0 + 0 + 0 + + + + + 0 + 29 + + + + + 32767 + 29 + + + + + 255 + 255 + 255 + + + + image0 + + + NoFocus + + + AutoText + + + <b><h3><p align="center">Tooltip animation ON or OFF</p></h3></b> + + + + + spacer6_2 + + + Vertical + + + MinimumExpanding + + + + 1 + 1 + + + + + + + + + + 789ced974b6fda401446f7fc0a8bec5095601eb64755174d7080a669d3b48b4a5517e33134a1101230e151f5bfd7f7bbc3f8510bb29a45d5b331e77e77c6c6067b7cd670bede5c3b8db3da3291c9bd72d49d5c388d78359b6dbf7d7ff3ab5677dda6d3124e2770dcfaab5afdd651ce4953785d11937e822acf63bd81c67bfd0c1d793eeb47ad8118917e20755d4f8a31e935d4f394c48ede4395df941dd277a4adaedf9501e995568f75001dfb9154a443ad8ab547da96412bc2cc97465ba4a1d636a77da348df9276ba818c3cd273a33ee985d688d30d69d7156e14916e8de230d65a5b9cee8c22fd028dfd91c05409ab08549374611407b9d42a387d328af459abe4746514e99cd40b645375491f8c62bf8f5a5d4e6746914e49fdb64c2f12e94fad3eeb049a9e7485eb7baf3566bd23a5b31ce3c4fe808aa813e3fa8ea02af263ec68ac35603d85c642ffea147494a6b80ab156c17a422a9afb34d22a631ca4d41ab19e5a058767157ce52a22a6322bb51debc95a69830b5445cc5466a5b6633d592b6df0fba962cc5466a5b6633d592b6df003b60afe4156c15ff810938c5ca9f4a16c93228509714b39c43423572a7d28dbb4486142dce2521e8acce78f9a3983da3c5f6152a7b17a8afdb042cb1c33cef6e0760d160ccbd290243a5824cb65be6cf449b35a9961cf29694752985383470fd86c36db941d581bb84a6cd6eb7cd9e82ea3d4b11fbacb83e7668173f07705a58b14aeec4378aeab3032ad16356dc753be17863d260cc34ba26f2a3daa6429d337a50c1a13f6fb61a99a178cc5aa63301c0e98a1fe3434952c435533a8e04094efc02ae8a55c8117b7578fc732cc2a58075a050b51ab60256c15acccad825703abfcdfe3bfb3c75babe045d52a78ddb34afdf7ebda1f4394dd1e + + + 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 + + + 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 + + + + + KbfxTooltipAnimationButton + toggled(bool) + KbfxConfigDlgTooltip + KbfxTooltipAnimationButtonToggled(bool) + + + KbfxTooltipOnButton + toggled(bool) + KbfxConfigDlgTooltip + KbfxTooltipOnButtonToggled(bool) + + + KbfxTooltipTextEdit + textChanged() + KbfxConfigDlgTooltip + KbfxTooltipTextEditTextChanged() + + + + kbfxconfig.h + kdebug.h + kbfxconfigdlgtooltip.ui.h + + + QPixmap img_on; + QPixmap img_off; + + + KbfxTooltipAnimationButtonToggled( bool ) + KbfxTooltipTextEditTextChanged() + KbfxTooltipOnButtonToggled( bool ) + ChangeForm() + + + init() + + + + kactivelabel.h + kactivelabel.h + kactivelabel.h + ktextedit.h + kactivelabel.h + kactivelabel.h + kactivelabel.h + + diff --git a/configdialog/kbfxconfigdlgtooltip.ui.h b/configdialog/kbfxconfigdlgtooltip.ui.h new file mode 100644 index 0000000..196c2d9 --- /dev/null +++ b/configdialog/kbfxconfigdlgtooltip.ui.h @@ -0,0 +1,86 @@ +/**************************************************************************** +** ui.h extension file, included from the uic-generated form implementation. +** +** If you want to add, delete, or rename functions or slots, use +** Qt Designer to update this file, preserving your code. +** +** You should not define a constructor or destructor in this file. +** Instead, write your code in functions called init() and destroy(). +** These will automatically be called by the form's constructor and +** destructor. +*****************************************************************************/ + +void KbfxConfigDlgTooltip::init() +{ + img_on = ConfigInit().KbfxOnImg; + img_off = ConfigInit().KbfxOffImg; +} + +void KbfxConfigDlgTooltip::KbfxTooltipAnimationButtonToggled ( bool ) +{ + if ( KbfxTooltipAnimationButton->state() == 2 ) + { + KbfxTooltipAnimationButton->setText ( tr2i18n ( "Turn the animation 'OFF'" ) ); + KbfxTooltipAnimationPixmapLabel->setPixmap ( img_on ); + ConfigInit().m_ToolTipAnimation = TRUE; + } + + if ( KbfxTooltipAnimationButton->state() == 0 ) + { + KbfxTooltipAnimationButton->setText ( tr2i18n ( "Turn the animation 'ON'" ) ); + KbfxTooltipAnimationPixmapLabel->setPixmap ( img_off ); + ConfigInit().m_ToolTipAnimation = FALSE; + } + + kdDebug() << "Tooltip animation state: " + << ConfigInit().m_ToolTipAnimation + << endl; +} + +void KbfxConfigDlgTooltip::KbfxTooltipTextEditTextChanged() +{ + ConfigInit().m_ToolTipText = KbfxTooltipTextEdit->text(); + + kdDebug() << "Tooltip text: " + << ConfigInit().m_ToolTipText + << endl; +} + +void KbfxConfigDlgTooltip::KbfxTooltipOnButtonToggled ( bool ) +{ + if ( KbfxTooltipOnButton->state() == 2 ) + { + KbfxTooltipOnButton->setText ( tr2i18n ( "Turn the tooltip 'OFF'" ) ); + KbfxTooltipOnPixmapLabel->setPixmap ( img_on ); + ConfigInit().m_ToolTip = TRUE; + } + + if ( KbfxTooltipOnButton->state() == 0 ) + { + KbfxTooltipOnButton->setText ( tr2i18n ( "Turn the tooltip 'ON'" ) ); + KbfxTooltipOnPixmapLabel->setPixmap ( img_off ); + ConfigInit().m_ToolTip = FALSE; + + } + + kdDebug() << "Tooltip state: " + << ConfigInit().m_ToolTip + << endl; +} + +void KbfxConfigDlgTooltip::ChangeForm() +{ + if ( ConfigInit().m_ToolTip == TRUE && KbfxTooltipOnButton->state() == 0 ) + KbfxTooltipOnButton->toggle(); + + if ( ConfigInit().m_ToolTip == FALSE && KbfxTooltipOnButton->state() == 2 ) + KbfxTooltipOnButton->toggle(); + + if ( ConfigInit().m_ToolTipAnimation == TRUE && KbfxTooltipAnimationButton->state() == 0 ) + KbfxTooltipAnimationButton->toggle(); + + if ( ConfigInit().m_ToolTipAnimation == FALSE && KbfxTooltipAnimationButton->state() == 2 ) + KbfxTooltipAnimationButton->toggle(); + + KbfxTooltipTextEdit->setText ( ConfigInit().m_ToolTipText ); +} diff --git a/configdialog/kbfxthemeinfo.ui b/configdialog/kbfxthemeinfo.ui new file mode 100644 index 0000000..69cd3e8 --- /dev/null +++ b/configdialog/kbfxthemeinfo.ui @@ -0,0 +1,603 @@ + +KbfxThemeInfo + + + KbfxThemeInfo + + + + 0 + 0 + 332 + 299 + + + + + 1 + 1 + 0 + 0 + + + + Theme Info + + + image0 + + + WheelFocus + + + + unnamed + + + 0 + + + 0 + + + Minimum + + + + layout10 + + + + unnamed + + + 10 + + + + spacer1_2 + + + Horizontal + + + MinimumExpanding + + + + 54 + 6 + + + + + + KbfxOk + + + + 1 + 1 + 0 + 0 + + + + OK + + + true + + + + + spacer1 + + + Horizontal + + + MinimumExpanding + + + + 54 + 6 + + + + + + + + spacer7 + + + Vertical + + + MinimumExpanding + + + + 16 + 16 + + + + + + spacer7_2 + + + Vertical + + + MinimumExpanding + + + + 16 + 16 + + + + + + layout7 + + + + unnamed + + + 0 + + + 0 + + + + layout11 + + + + unnamed + + + + spacer3_2 + + + Vertical + + + MinimumExpanding + + + + 10 + 49 + + + + + + KbfxThemeLogo + + + + 0 + 0 + 0 + 0 + + + + + 100 + 100 + + + + + 100 + 100 + + + + image1 + + + true + + + AlignCenter + + + + + spacer3 + + + Vertical + + + MinimumExpanding + + + + 10 + 49 + + + + + + + + KbfxSpacer + + + Horizontal + + + MinimumExpanding + + + + 16 + 16 + + + + + + layout21 + + + + unnamed + + + 15 + + + + layout19 + + + + unnamed + + + + _KbfxThemeName + + + + 1 + 1 + 0 + 0 + + + + <p align="right"><b>Name:</b></p> + + + + + _KbfxThemeVersion + + + + 1 + 1 + 0 + 0 + + + + <p align="right"><b>Version:</b></p> + + + + + _KbfxAuthorName + + + + 1 + 1 + 0 + 0 + + + + <p align="right"><b>Author:</b></p> + + + + + _KbfxAuthorEmail + + + + 1 + 1 + 0 + 0 + + + + <p align="right"><b>Email:</b></p> + + + + + _KbfxThemeHomepage + + + + 1 + 1 + 0 + 0 + + + + <p align="right"><b>Homepage:</b></p> + + + + + + + layout20 + + + + unnamed + + + + KbfxThemeName + + + + 1 + 1 + 0 + 0 + + + + + 69 + 163 + 225 + + + + + 1 + + + + Test + + + + + KbfxThemeVersion + + + + 1 + 1 + 0 + 0 + + + + + 69 + 163 + 225 + + + + + 1 + + + + Test + + + + + KbfxAuthorName + + + + 1 + 1 + 0 + 0 + + + + + 131 + 187 + 225 + + + + + 1 + + + + Test + + + + + KbfxAuthorEmail + + + + 1 + 1 + 0 + 0 + + + + + 131 + 187 + 225 + + + + + 1 + + + + WheelFocus + + + Test + + + false + + + NoWrap + + + + + KbfxThemeHomepage + + + + 1 + 1 + 0 + 0 + + + + + 78 + 184 + 255 + + + + + 1 + + + + WheelFocus + + + Test + + + false + + + NoWrap + + + + + + + + + + + spacer8 + + + Horizontal + + + MinimumExpanding + + + + 16 + 16 + + + + + + spacer8_2 + + + Horizontal + + + MinimumExpanding + + + + 16 + 16 + + + + + + + + + + 89504e470d0a1a0a0000000d49484452000000100000001008060000001ff3ff610000032f49444154388d6dd34d681c6500c6f1ffbc33b3d9dd24a6f9c2fab159d93692948a07535350682b01c1431585f420e41a042f856cf1a437bd945eac395941507368aa2018fca0899542032a2526a1b14dd7da6c3bc9ee6637bbb333fbeebc33f37a2bd5fabf3fbfdb6368ad7938c77144b3d93c1a45d184522adb6eb7e356abb5e9fbfef7b95cee8fe1e1e17f0d8c878162b1380e9c17c218532a64af56278a22ec8485ebbaba56ab2d7a9ef7eee4e4e4c62380e338a74cd3fcdcad373ab60a7791322095ee4463e0b5db581d16c98441ad56ad371a8d37a6a6a67e7e006c6f6f8f5b9675c5d92a76dcbb7397eeae4e2c5313449a2836086383d030915144cad6ec564a35d775c7a6a7a70ba252a90821c4f97ab5da7173758d8419225b5574586574bf448755dc6685c8df45fa92d25e9b542addabb53eeb791e220882a3a629c67ebb7a8d4836910d8767075b944a0e9da6c7813e49a9748f234312ed97a9d45ccaf500d31427676767872cadf5840a143f5efa163b2e934cfb4c9c7993e71eb758bcb6ca4e5db1536ed3f7520799748bab374c84297871a4cf84fa092b8aa26cd9d9e1cfeb6b0cf47a88649d2fe62e92eecff0d3bac49360ea340b57e0f28d905bf56e3c197268a81bc330b296522a8ea2182935510ccfecefe1bbe502774aeb64334ff1d1f4311e4b2739f7cd16eb8ec94ab98e8a34b11e0588ad2008367b077a098d2e4a55c907ef8c7238b78f7397d648d936b97d6d30423e3c95e4d78264e293909eae14dd691bdfd59ba2d56afd1028a5c75f3d46a3ddc3fb170a5cbe5e62e5b6c49716a04187681db37453934e2578f9f90ccda61b008ba2bfbf7fa5d1682cbe3dfd1676e669fe720739736197b5bfbb387c601080fb7b11a72f2a3efbbd8727fb52bc726488564b7e99cfe74b86d69aa5a5a5914422b15c742a3d1f7f3a4f1484885863d970f0098b8ddd2486dd49c216bc7efc10847e310882171e00000b0b0bc76ddbfe3a5051ef2fcbab6c14ee1321300c13cb14e432038c64fbf03db71804c16bf97c7ef59133cdcfcfe780b3428893a629ccbaeb132a856d19341a6e5b4af9551cc7efe5f3f9d2ffbe11c0f77de6e6e6869452279452d92008e2388e6f1b86b1383333b3c37ffa075ed9c8000f73ed450000000049454e44ae426082 + + + 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 + + + + + KbfxOk + clicked() + KbfxThemeInfo + close() + + + + kbfxthemeinfo.ui.h + + + hideSpacer() + + + init() + + + + kactivelabel.h + kactivelabel.h + kactivelabel.h + kactivelabel.h + kactivelabel.h + kactivelabel.h + kactivelabel.h + kactivelabel.h + kactivelabel.h + kactivelabel.h + + diff --git a/configdialog/kbfxthemeinfo.ui.h b/configdialog/kbfxthemeinfo.ui.h new file mode 100644 index 0000000..e67a134 --- /dev/null +++ b/configdialog/kbfxthemeinfo.ui.h @@ -0,0 +1,19 @@ +/**************************************************************************** +** ui.h extension file, included from the uic-generated form implementation. +** +** If you want to add, delete, or rename functions or slots, use +** Qt Designer to update this file, preserving your code. +** +** You should not define a constructor or destructor in this file. +** Instead, write your code in functions called init() and destroy(). +** These will automatically be called by the form's constructor and +** destructor. +*****************************************************************************/ +void KbfxThemeInfo::init() +{ +} + +void KbfxThemeInfo::hideSpacer() +{ + KbfxSpacer->changeSize(0,0); +} diff --git a/configdialog/main.cpp b/configdialog/main.cpp new file mode 100644 index 0000000..fe5e508 --- /dev/null +++ b/configdialog/main.cpp @@ -0,0 +1,163 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "kbfxconfigapp.h" + +static const char description[] = I18N_NOOP ( "KBFX Configuration Utility" ); +static const char version[] = APPLICATION_VERSION; +static const KCmdLineOptions options[] = + { + {"install ", I18N_NOOP ( "Install KBFX theme from " ), 0}, + { "prepare ", I18N_NOOP ( "Prepare KBFX theme from folder " ), 0 }, + { "about", I18N_NOOP ( "Show the About page" ), 0 }, + KCmdLineLastOption + }; + +static KbfxConfigApp *mainWin = 0; + +class KbfxConfigApplication : public KUniqueApplication +{ + public: + KbfxConfigApplication() { } + virtual ~KbfxConfigApplication() { } + + virtual int newInstance() + { + KCmdLineArgs* KbfxArgs = KCmdLineArgs::parsedArgs(); + + /* prepare kbfx theme cmdline option given */ + if ( KbfxArgs->isSet ( "prepare" ) ) + { + QString m_KbfxThemeFolderUrl = KbfxArgs->getOption ( "prepare" ); + if ( m_KbfxThemeFolderUrl.endsWith ( "/" ) ) m_KbfxThemeFolderUrl.truncate ( m_KbfxThemeFolderUrl.length()-1 ); + QString theme_name = m_KbfxThemeFolderUrl.section ( '/', -1 ); + QString archive_dir = m_KbfxThemeFolderUrl.section ( '/', 0, -2 ); + QString archive_name = archive_dir+"/"+ theme_name+".kbfxtheme"; + kdDebug() << "Prepare option arguments: " + << theme_name + << endl + << archive_dir + << endl + << archive_name + << endl; + + KTar ThemeArchive ( archive_name,"application/x-bzip" ); + + if ( !ThemeArchive.open ( IO_WriteOnly ) ) + { + KMessageBox::sorry ( 0, + tr2i18n ( "

Could not create this KBFX theme package.

" ) ); + + kdDebug() << "Error creating theme file: " + << archive_name + << endl; + } + else + { + ThemeArchive.addLocalDirectory ( m_KbfxThemeFolderUrl,theme_name ); + ThemeArchive.close (); + KMessageBox::information ( 0, + tr2i18n ( "

KBFX Theme %1 prepared.

" ).arg ( theme_name ), + tr2i18n ( "KBFX Theme Ready" ) ); + kdDebug() << "KBFX theme file ready: " + << archive_name + << endl; + } + + kdDebug() << "KBFX theme prepared. Quitting..." << endl; + QTimer::singleShot ( 100, mainWin, SLOT ( deleteLater() ) ); + } + else + { + /* install kbfx theme cmdline option given */ + if ( KbfxArgs->isSet ( "install" ) ) + { + QString m_KbfxThemeUrl = KbfxArgs->getOption ( "install" ); + kdDebug() << "Install option argument: " + << m_KbfxThemeUrl + << endl; + + mainWin->lb_Main->setCurrentItem ( THEMES ); + mainWin->KbfxMenuItemChanged ( THEMES ); + mainWin->KbfxThemeInstall ( m_KbfxThemeUrl ); + } + + /* show the "About" page */ + if ( KbfxArgs->isSet ( "about" ) ) + { + kdDebug() << "About option argument given on command line." + << endl; + + mainWin->lb_Main->setCurrentItem ( ABOUT ); + mainWin->KbfxMenuItemChanged ( ABOUT ); + } + + mainWin->show(); + mainWin->browserInit(); + } + return KUniqueApplication::newInstance(); + } +}; + +int main ( int argc, char **argv ) +{ + KAboutData about ( "kbfxconfigapp", + I18N_NOOP ( "kbfxconfigapp" ), + version, + description, + KAboutData::License_GPL, + "(C) 2006 PhobosK", + 0, + 0, + "phobosk@mail.kbfx.org" ); + about.addAuthor ( "PhobosK", 0, "phobosk@mail.kbfx.org" ); + + KCmdLineArgs::init( argc, argv, &about ); + KUniqueApplication::addCmdLineOptions(); + KCmdLineArgs::addCmdLineOptions( options ); + + if (!KUniqueApplication::start()) + return 1; + + KbfxConfigApplication app; + + mainWin = new KbfxConfigApp(); +/* + Don't show initially untill found out if prepare option is given on the command line + mainWin->show(); +*/ + app.setMainWidget ( mainWin ); + + /* mainWin has WDestructiveClose flag by default, so it will delete itself */ + return app.exec(); +} diff --git a/configdialog/x-kbfxtheme.desktop b/configdialog/x-kbfxtheme.desktop new file mode 100644 index 0000000..1551b13 --- /dev/null +++ b/configdialog/x-kbfxtheme.desktop @@ -0,0 +1,20 @@ +[Desktop Entry] +Encoding=UTF-8 +Type=MimeType +MimeType=application/x-kbfxtheme +Icon=kbfxconfigapp +Patterns=*.kbfxtheme + +Comment=KBFX Theme Package +Comment[bg]=Пакет KBFX Theme +Comment[da]=KBFX-temapakke +Comment[de]=KBFX Theme-Paket +Comment[el]=Πακέτο θέματος KBFX +Comment[es]=Paquete con el tema KBFX +Comment[et]=KBFX teemapakett +Comment[fr]=Paquet des thèmes KBFX +Comment[ja]=KBFX テーマパッケージ +Comment[nl]=KBFX-themapakket +Comment[pt]=Pacote de Tema do KBFX +Comment[pt_BR]=Pacote do Tema KBFX +Comment[sv]=KBFX-temapaket diff --git a/doc/AUTHORS b/doc/AUTHORS new file mode 100755 index 0000000..af2e935 --- /dev/null +++ b/doc/AUTHORS @@ -0,0 +1,26 @@ +KBFX Team Managers +------------------ +Siraj Razick: +Mensur Zahirovic: +PhobosK: +Nathanael Gogniat: + + +Translations +------------ +Hungary (HU) Ferenc Stelcz +Italia (IT) Divilinux +Bulgaria (BG) Lexus + PhobosK +Netherlands (NL) Monkey 9 + + +Ideas and Guidence +------------------ +Aaron Seigo: +Vandenoever: + + +Patches +------- +Darwin M. Bautista 001.patch diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt new file mode 100644 index 0000000..19a5cbc --- /dev/null +++ b/doc/CMakeLists.txt @@ -0,0 +1,17 @@ +SET(DOCFILES + AUTHORS +# ChangeLog +# COPYING + CREDITS + HACKING +# HOWTO +# INSTALL +# KNOWN_BUGS +# LICENSE +# NEWS +# README +# TODO + ) + +INSTALL(FILES ${DOCFILES} + DESTINATION ${SHARE_INSTALL_PREFIX}/doc/kbfx) diff --git a/doc/COPYING b/doc/COPYING new file mode 100755 index 0000000..bfefe24 --- /dev/null +++ b/doc/COPYING @@ -0,0 +1,346 @@ +This is A Recursive NOTE! + +All and All None Mentioned Files contained within the Source Package , Binary +or None Binary Follow the below Lincense . + + + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 51 Franklin St, 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. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 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 St, 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. + + , 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/doc/CREDITS b/doc/CREDITS new file mode 100644 index 0000000..32ac405 --- /dev/null +++ b/doc/CREDITS @@ -0,0 +1,11 @@ +Credits and Thanks go to: +========================= + +Revaline C. Regendra: For the Launch button in the default "KBFX Silk TTP" theme (version 0.4.9.3-20070117). +--------------------- Copyright (c) 2006. Revaline^Studio; Revaline's Launch Menu v4.0 + http://www.kde-look.org/content/show.php?content=36399 + regendra_mail7@yahoo.com + +Petri Damstn: For the KMFFontChooser class. +-------------- http://www.iki.fi/damu/software/kmediafactory/ + damu@iki.fi \ No newline at end of file diff --git a/doc/ChangeLog b/doc/ChangeLog new file mode 100755 index 0000000..6fef33f --- /dev/null +++ b/doc/ChangeLog @@ -0,0 +1,123 @@ +0.4.9.3.1 +========= + - CHANGED layout and font configfile specs + - UPDATED help documentation + - ADDED fade transition effect on the KBFX Button + - ADDED install guides for using checkinstall + - ADDED Hungarian translation (thanks to Ferenc Stelcz for it) + - ADDED option to watch for KDE global changes like new installed applications + - ADDED option for Theme Info + - ADDED resizable configuration dialogs + - ADDED drag&drop hover, pressed and normal images over the KBFX button + - ADDED tooltip support for the KBFX button + - ADDED switch between KBFX and K Menu + - ADDED new two panel skin - "2panels" + - ADDED configurable middle background - middleboxbg.png + - ADDED fonts support in every part of the menu + - ADDED layout support in the KBFX Configurator + - ADDED support for the new versions of strigi + - ADDED support for use of strigi in Gentoo + - ADDED support for SVN version in Gentoo + - ADDED support for PCLinuxOS rpm build (thanks to @PaGal and @tom777 for the testing) + - ADDED support for future KDE4 (part 1) + - ADDED uninstall option for "build.sh" script + - FIXED cmake uninstall + - FIXED RPM .la issues + - FIXED some major bugs + - REMOVED Water effect (too much CPU time consuming and not a favorite one for our users) + +0.4.9.3-20070117 +================ + - Initial Release of the 0.4.9.3 Series - KBFX Silk (0.4.9.3) + - New Build system (cmake) + - Re-write of the data backend + - Re-write of the GUI + - Totally new theme + - Improved configuration dialog + +0.4.9.2rc4 +========== + - CHANGED some aspects of autoconf/automake behavior + - CHANGED "Toolbar Resize" behavior - turned off by default so kicker doesn't change its size anymore + - ADDED support for Mandriva 2007 compilation (no menudrake there by default) + - FIXED Search bar behavior (thanks @gropiuskalle) + - FIXED some minor bugs + +0.4.9.2rc3 +========== + - ADDED support for preparing .kbfxtheme files in Konqueror (look the explanation in HOWTO file) + - ADDED "--prepare" command line option to pack existing KBFX Skin Folders to .kbfxtheme files + - ADDED "Default Theme's Personal Image" to the "KBFX Configurator Application" + - ADDED "Toolbar Resize" option to the "KBFX Configurator Application" for the toolbar where the KBFX Button resides + - ADDED it, bg and nl translations + - FIXED some minor bugs + +0.4.9.2rc2 +========== + - CHANGED "KBFX Configurator Application" - rewritten from scratch and is no more part of "kcontrol" + - CHANGED "Tooltip Animation" behavior - turned off by default + - ADDED new Default Theme + - ADDED fonts configuration option to the "KBFX Configurator Application" + - ADDED Install/Delete Themes to the "KBFX Configurator Application" + - ADDED support for .kbfxtheme files in Konqueror (look the explanation in HOWTO file) + - ADDED possibility to change "dude" image to the "KBFX Configurator Application" + - ADDED Free-BSD Support + - FIXED font alignment problems + - FIXED long applications name problem + - FIXED some memory leaks + - FIXED some minor bugs + +0.4.9.2-20060708cvs +=================== + - UPDATED make system + +0.4.9.2-20060611cvs +=================== + - ADDED PC-BSD Support + - ADDED Drag and Drop Support + - FIXED a bug with showing icons in "Recently Used" items + - FIXED a bug with the placement of ".face.icon" (thanks @Nucc) + - Flicker Free KBFX Button + - Flicker Free KBFX SPINX Menu TOP + - Better scrolling + +0.4.9.2-20060528cvs +=================== + - ADDED support for Fedora rpm + - ADDED an option to disable tooltips (see HOWTO file) + - FIXED a problem with building SUSE rpm + +0.4.9.2rc1 +========== + - ADDED support for Buttons with Drop shadows + - ADDED Font settings as part of the Theme itself + - ADDED Kiosk mode support + - ADDED Handling of submenus + - FIXED make system for all distributions + - Better support for Mandriva distribution + - More applications for the menu + - Grouping header for each application group and sub groups + +0.4.9.1 +======= + - New HTML based Config + - Spinx Bar improved and redone for MAX icandy with better theme support + - Double buffered rendering for kbfx button + - image support + - Animated scrollbars like thing + - icons zoom + - Improved skin support + - themeable tooltip ( two types animated and none animated) + - KDE user icon support (KDM icons) + - user Name support (login name) + - Application Items are sorted + - Better user support and Help + - login and lock buttons are working now + - Mouse Cursor has more sense + - KControl Module uses HTML ..old config removed + - Automatic icons and theme installation with source code + - The applet is renamed , from kbfxvista to kbfxspinx + - Animated User Image + - Add more to Menu Action for Application List Better Customizations. + - 32x32 icons support + diff --git a/doc/HACKING b/doc/HACKING new file mode 100644 index 0000000..b2eb11e --- /dev/null +++ b/doc/HACKING @@ -0,0 +1,21 @@ +======================== +| Some syntax rules: | +======================== + +Variables: +---------- + + {prefix}_{variablename} + + Prefixes Use + "m_" for member variables + "p_" for pointer variables + "a_" for variables of argument functions + + +Comments: +--------- + + Please make small comments on important issues. + And TODOs also. + \ No newline at end of file diff --git a/doc/HOWTO b/doc/HOWTO new file mode 100644 index 0000000..c254a02 --- /dev/null +++ b/doc/HOWTO @@ -0,0 +1,411 @@ +How to apply the Menu button +============================ + +The menu button is starting point for the menu. +It first has to be added to the panel. +To add the KBFX Menu to the panel, proceed as following: + Right-click on the panel, on which you want to place the KBFX button + Select "Add Applet to panel" in the context menu + Select "KBFX Spinx" +A tooltip appears "KBFX Spinx Added" +If you move your mouse over the button, a tooltip appears (turned off +in the default configuration). +If you want to, you can now remove the K-Menu button and move the KBFX +to the desired place on the panel. +To open the menu, just click on the button. + + + +How to create themes for KBFX 0.4.9.3 +===================================== + +So you want to create your own themes for KBFX 0.4.9.3? +The guide is done in a simple manner and we hope that you will easily and +simply create themes for KBFX 0.4.9.3. If you don't like something in this +guide, please feel free to contact us at IRC on irc.freenode.org +on channel #kbfx + +NOTE: - The values for Width and Height are only our suggested values. + You can use whatever values you feel are appropriate for your theme. + - If ANY of these images are missing KBFX will use the image with the + same name from the "default" theme. + - In order to be used by the Configurator and by KBFX, every theme for + 0.4.9.3 MUST HAVE a file in it's folder named "version-2" ! + + topbg.png + --------- + This is an image that is at the top of the menu. + Width = 504px + Height = 95px + + dudebox.png + ----------- + This is the background image where your personal image is displayed. + Width = 95px + Height = 88px + + menu_top_image_person.png + ------------------------- + This image is used for theme's default personal image. + Width = 48 px + Height = 48 px + + find.png + -------- + This is a small image displayed in the search field. + Width = 22px + Height = 21px + + rhstile.png + ----------- + This is normal image displayed in categories. + Width = 132px + Height = 23px + + rhshovertile.png + ---------------- + This is a hover image for categories.Used as hover image for rhstile.png + Width = 132px + Height = 23px + + scrollnormal.png / scrollnormalbot.png + -------------------------------------- + These images are used as top and bottom scrollbars. + Width = 240px + Height = 10px + + separator.png / indexseparator.png + ---------------------------------- + These are the separator images which separate your different subcategories. + Width = 240px + Height = 27px + + tilenormal.png + -------------- + This is the normal image where your applications are showed. + Width = 240px + Height = 46px + + tilehover.png + ------------- + This is the hover image where your applications are showed. + Width = 240px + Height = 46px + + listboxbg.png + ------------- + This is the background under the categories. It can be viewed on description + on both sides of the menu. + Width = 108px + Height = 23px + + middleboxbg.png + --------------- + This is the background of the middle part of the menu. + Width = 200px + Height = 270px + + botbg.png + --------- + This is the background image at the bottom of the menu. + Width = 504px + Height = 38px + + lock.png + -------- + This is the lock image. + Width = 84px + Height = 38px + + lockhover.png + ------------- + This is the lock hover image. + Width = 84px + Height = 38px + + logout.png + ---------- + This is the logout image. + Width = 84px + Height = 38px + + + logouthover.png + --------------- + This is the logout hover image. + Width = 84px + Height = 38px + + mask.png + -------- + This is deciding what size your menu will have when users install it + and which will be the transparent parts of the menu (through the alpha + mask of the png image). Of course the size can be controlled later by + the configuration of KBFX. + Width = 504px + Height = 513px + + logo.png + --------- + logo.png is used as a theme's or author's logo shown in the Information box of + the KBFX Configurator. You can put whatever image you want and it will be scaled + to 100px width by 100px height. + Width = up to 100 px + Height = up to 100 px + + preview.png + ----------- + preview.png should be a snapshot of the working KBFX theme. It is used in the + configuration application in order the user to see what the theme will look like. + Width = 170 px + Height = 205 px + + normal.png / hover.png / pressed.png + ------------------------------------ + These are the KBFX Buttons for the kicker panel that are used in the theme. + Width and Height - as you like, but preferably Height not to be too much. + + +More information can be found on: + http://www.kbfx.org/staticpages/index.php?page=howto0493 + + + +How to write theme's kbfxfontrc and kbfxlayoutrc files +====================================================== + + Every theme MAY have two configuration files named: + +kbfxfontrc - configures the fonts properties that the theme uses +kbfxlayoutrc - configures the layout of the theme, the KBFX button + and some other properties of the theme + + If one or both of these files don't exist, KBFX internal configuration +options will be used for fonts and layout. + All the properties and values are separated between different Sections +in the way showed below: + +[Section] +property = value + + When you want to prepare a theme, have in mind that every change that you +make in the "KBFX Configurator" is kept in files in your home KDE directory. +Usually these files are here: + ~/.kde/share/apps/kbfx/themerc +and are named: + THEMENAME_layoutrc + THEMENAME_fontrc +So if you want to ship your theme settings from the "KBFX Configurator", the best +thing to do is to use the buttons: "EXPORT KBFXFONTRC FILE" ("Fonts" section of the +Configurator) and "EXPORT KBFXLAYOUTRC FILE" ("Layout section" of the Configurator) +and put the exported files in your theme folder. + +NOTE: - Pay close attention to the case of the properties and Sections names + because the configuration is CASE SENSITIVE! + - The order of the sections in the file is not important! + - Have in mind that the Layout of the theme also depends on the sizes of + the images! + + + File kbfxfontrc + --------------- + It's best the colors to be represented in RGB format. + Font Properties should constrain to QFont class representation. + The values bellow are the default ones: + + [Fonts] + TooltipText=0,0,0 + TooltipTextFont=Arial,8,-1,5,50,0,0,0,0,0 + ApplicationText=0,0,0 + ApplicationTextFont=Arial,8,-1,5,50,0,0,0,0,0 + CommentText=128,125,0 + CommentTextFont=Arial,8,-1,5,50,0,0,0,0,0 + GroupText=0,0,0 + GroupTextFont=Arial,8,-1,5,50,0,0,0,0,0 + UserName=255,255,255 + UserNameFont=Arial,10,-1,5,75,0,0,0,0,0 + SeparatorColor=0,0,0 + SeparatorFont=Arial,8,-1,5,50,0,0,0,0,0 + PluginColor=0,0,0 + PluginFont=Arial,8,-1,5,50,0,0,0,0,0 + LineColor=255,220,125 + # This is if the font when you hover on an item will be bold + HoverBold = false + + File kbfxlayoutrc + ----------------- + The values bellow are the default ones: + + [KbfxButton] + # Time in msec for which the button + # to fade in/out + FadeTime=75 + # The three properties below describe the + # paths to the theme's buttons. + # KBFX uses the normal.png/hover.png/pressed.png + # that are in the theme's folder by default. + # So we recommend NOT to use the below three + # properties! + Normal = KBFX Normal Button Full Path + Hover = KBFX Hover Button Full Path + Press = KBFX Pressed Button Full Path + + [TopBar] + # Face Position X + DudeX=-1 + # Face Position Y + DudeY=-1 + # Face Box Height + FaceH=64 + # Face Box Width + FaceW=65 + # Face Box Position X + FaceX=27 + # Face Box Position Y + FaceY=8 + # User Name Position X + UserNameX=130 + # User Name Position Y + UserNameY=32 + # Hide User Name + DisableUserName=false + # Top Bar Height + Height=95 + # THE PROPERTIES BELOW ARE NOT USED FOR NOW + # Top Bar Width + Width=504 + # Top Bar Position X + X=0 + # Top Bar Position Y + Y=0 + + [BottomBar] + # Bottom Bar Height + Height=38 + # THE PROPERTIES BELOW ARE NOT USED FOR NOW + # Bottom Bar Width + Width=504 + # Bottom Bar Position X + X=0 + # Bottom Bar Position Y + Y=428 + + [Scrollbars] + # THIS SECTION IS NOT USED FOR NOW + # Bottom Scroll Bar Position X + ScrollBarBotX=108 + # Bottom Scroll Bar Position Y + ScrollBarBotY=95 + # Top Scroll Bar Position X + ScrollBarTopX=108 + # Top Scroll Bar Position Y + ScrollBarTopY=95 + + [ListBox] + # List Box Position X + X=0 + # List Box Position Y + Y=95 + # List Box Width + Width=132 + # THE PROPERTIES BELOW ARE NOT USED FOR NOW + # List Box Height + Height=275 + + [SearchBox] + # Search Box Height + Height=22 + # Search Box Width + Width=240 + # Search Box Position X + X=130 + # Search Box Position Y + Y=48 + + [ItemView] + # Item Position X + X=132 + # Item Position Y + Y=95 + # Item Width + Width=240 + # THE PROPERTIES BELOW ARE NOT USED FOR NOW + # Item Height + Height=275 + + [ItemProperties] + # Comment Margin in Item + CommentMargin=66 + # Icon Size in Item + IconSize=32 + # No Comments in Item + NoComments=false + + [ToolBar] + # THIS SECTION IS NOT USED FOR NOW + # Tool Bar Button Normal Size + ButtonNormalSize=48 + # Tool Bar Button Pressed Size + ButtonPressedSize=48 + + [MainMenu] + # Main Menu Height + UserMenuHeight=513 + # Main Menu Width + UserMenuWidth=504 + # Contracted Menues + ContractedMenu=false + + File version-2 + -------------- + + This file is obligatory to exist, though it can be empty. + It is used to designate that the theme is in the new format and the + properties that are in the file are used in the KBFX Configurator for + showing the user some info about the theme. + The values in this file cannot be overwritten by the KBFX Configurator. + If existing, the file should contain information about the theme's version, + author's name, author's email and a homepage for the theme. + The unspecified fields are replaced with the string - "Not Specified". + The values bellow are self explanatory and are just an example: + + [ThemeGeneral] + ThemeVersion=0.51 + AuthorName=Nookie + AuthorEmail=nookie@no_spam.org + Homepage=http://www.kbfx.org + + + + How to create a ".kbfxtheme" file for 0.4.9.3 + ============================================= + +The ".kbfxtheme" file is a simple archive file (.tar.gz or .tar.bz2) that should +contain at least these elements: +- one or more theme folders with all the necessary images/files inside. Have in mind + that the name of the theme is the name of the folder. +- in the theme(s) folder(s) there should be an image named preview.png that serves + as a live preview of the look of the theme. +- in the theme(s) folder(s) there should be a file named version-2 +- the extension of the archive should be ".kbfxtheme" + +You can create ".kbfxtheme" file following these instructions (there is +an option in Konqueror's rightclick "Actions" menu for preparing KBFX Theme Package +OR you can create the ".kbfxtheme" file manually as described bellow): +- Create a folder with a name that is identical to the name you want for your theme. +- Put the necessary images/files inside it (see the above instructions for the images part). +- Create an archive of the folder (with ark/tar etc). +- Rename the archive file to ".kbfxtheme" and you are ready. + + + How to help us out + ================== + +You can help us for the KBFX releases with the translation of the interface. +For this purpose please download the kbfxconfigapp.pot file from SourceForge: +http://sourceforge.net/project/showfiles.php?group_id=141258&package_id=210120 . +Another way to get a .pot file is to use the command "make package-messages" +just after the configuration of the compilation process is done. +Then use KBabel (http://kbabel.kde.org/) or poEdit (http://www.poedit.org/) to make the translation. +Next send the .po file to my mail - phobosk@mail.kbfx.org +Thanks in advance for this help. diff --git a/doc/INSTALL b/doc/INSTALL new file mode 100755 index 0000000..6166e13 --- /dev/null +++ b/doc/INSTALL @@ -0,0 +1,203 @@ +############################################ +# # +# INSTALL file for KBFX > 0.4.9.2 # +# # +############################################ +Last update: 03/03/2007 + +Installation Notes by PhobosK + + + + +1. Requirements : +================= + +- Cmake ( http://www.cmake.org ) - min. version 2.4.2 +- KDE3 and Qt3 sources - header files/devel packages +- Strigi ( http://strigi.sf.net ) - header files/devel packages needed too + (optional package) + + + +2. Compilation Instructions : +============================= + + 2.1. Unpack the sources of KBFX with (x.y.z-XXXXXXXX represents the version of + the KBFX package, for example : 0.4.9.3-20070117): + + > tar xjvf kbfx-x.y.z-XXXXXXXX.tar.bz2 + + 2.2. Change into the new directory: + + > cd kbfx-x.y.z-XXXXXXXX/ + + 2.3. Start the configuration and the compilation using the command: + + > ./build.sh + + Note for Mandriva < 2007 users: + =============================== + The build script (by default) enables the use of "menudrake" + instead of "kmenuedit". If you want to prevent this behavior then + pass ONE of these options to the build script: + "--menudrake-off" OR "-m" + + Notes for other building options: + ================================= + "--prefix" OR "-p" to install KBFX in a different than the default folder + (default is KDE install folder) for example: + > ./build.sh -p /home/user + "--strigi" OR "-s" to enable Strigi support in KBFX + (default is no Strigi support) + "--kde4" OR "-k" to build KBFX for KDE4 + (default is for KDE3) + "--verbose" OR "-v" to make the build script give more verbose information + "--nocheck" OR "-n" to make the build script not to check if an old KBFX + version is installed (default is to check) + + + +3. Using the "checkinstall" application for building KBFX packages : +==================================================================== + +"checkinstall" DOES NOT work with cmake correctly up to this moment. :( +It can be used with additional commands in order to "work properly". +Here is the procedure to follow as user (NOT as ROOT) in order to obtain +the necessary distribution package. +NOTE: - x.y.z-XXXXXXXX represents the version of the KBFX package, + in this example it is: 0.4.9.3-20070117 + - in the example here the version string is replaced only in the + checkinstall comand but you have to do that everywhere the + "x.y.z-XXXXXXXX" string is met + + > cd /tmp + > tar xjvf kbfx-x.y.z-XXXXXXXX.tar.bz2 + > cd kbfx-x.y.z-XXXXXXXX/ + > mkdir -p build/package + > cd build + > export DESTDIR=/tmp/kbfx-x.y.z-XXXXXXXX/build/package + > cmake ../ -DCMAKE_INSTALL_PREFIX=`kde-config --prefix` + > make install DESTDIR=/tmp/kbfx-x.y.z-XXXXXXXX/build/package + > find package/|sed s#^package/#./# > installed_files.txt + > cd package/ + > su + > checkinstall -nodoc --pkgname="kbfx" --pkgversion="0.4.9.3" --pkgrelease="20070117" \ + --exclude="/" --include=../installed_files.txt --pakdir=/tmp/kbfx-0.4.9.3-20070117 sleep 1 + +When ready, "checkinstall" will show you the folder where the prepared package +is, like in this Mandriva Example: + +********************************************************************** + + Done. The new package has been saved to + + /tmp/kbfx-0.4.9.3-20070117/kbfx-0.4.9.3-20070117.i386.rpm + You can install it in your system anytime using: + + rpm -i kbfx-0.4.9.3-20070117.i386.rpm + +********************************************************************** + +Of course the best way to make RPM packages is to use the "kbfx.spec" file provided +in the KBFX sources like described bellow. + + + +4. RPM Building Instructions (Mandriva, Fedora, Suse) : +======================================================= + +If you prefer manipulate a RPM, you can build it with the following commands: + + 4.1. Build the RPM + + > rpmbuild -tb kbfx-x.y.z-XXXXXXXX.tar.bz2 + + or (for Mandriva) + + > rpmbuild --rebuild kbfx-x.y.z-XXXXXXXX-mdv20070.src.rpm + + or (for Fedora) + + > rpmbuild --rebuild kbfx-x.y.z-XXXXXXXX-FCx.src.rpm + + or (for SuSe) + + > rpmbuild --rebuild kbfx-x.y.z-XXXXXXXX-suseXXX.src.rpm + + 4.2. If succeed, you will found the rpm in /usr/src/rpm/RPMS (for Mandriva) + or /usr/src/redhat/RPMS (for Fedora) or /usr/src/packages/RPMS (for Suse) + according to the platform you have. + + 4.3. Install the rpm as usually by: + > rpm -Uvh kbfx-x.y.z-XXXXXXXX.rpm + + Notes for building RPM from KBFX SVN versions : + =============================================== + - Follow these commands in the sources directory: + > ./build.sh + > Answer "N" to the question if you want to install KBFX + > cd build + > make dist + - A file "kbfx-x.y.z-XXXXXXXX.tar.bz2" will be created in the build + directory. + - Proceed with the steps described in 4.1., 4.2., 4.3. + + + +5. Gentoo users: +================ + +In order to use the strigi engine in KBFX you have to do these steps: + - Copy the "strigi-X.X.X.ebuild" and the "kbfx-0.4.9.X.ebuild" (from the sources + directory) to your local portage tree as needed + OR use the "kbfx-0.4.9.X-portage-overlay.tar.bz2" + - Set the flag "strigi" for the kbfx ebuild + - Emerge "clucene" + - Emerge "kbfx" + +There is a Layman overlay resource on the SourceForge SVN. +You can add it by this command: + > layman -f -o https://kbfx.svn.sourceforge.net/svnroot/kbfx/layman/kbfx-overlay.xml \ + -a kbfx +After you add the "kbfx" overlay you can use it as usual. + + + +6. Getting SVN version: +======================= + +To download the latest development source, you need to go to KDE SVN +and download it from there. The current SVN address of the repository is: +svn://anonsvn.kde.org/home/kde/trunk/playground/base/kbfx_plasma + +Here are the instructions on how to get a copy of the SVN Repository: + + 6.1. Install your distribution's package named "subversion" + OR download and install it from: http://subversion.tigris.org + + 6.2. Create a folder where you will compile/install KBFX and enter in it. + For example do this: + + > mkdir -p ~/usr/src/svn + > cd ~/usr/src/svn + + 6.3. Checkout the SVN version of KBFX in this way and proceed as follows: + + > svn co svn://anonsvn.kde.org/home/kde/trunk/playground/base/kbfx_plasma + > cd kbfx_plasma + + 6.4. Proceed with the compilation/installation of KBFX as described in 2.3. + + > ./build.sh + + 6.5. If you want always to have the latest version of KBFX you may leave + the folder ~/usr/src/svn/kbfx_plasma intact for future use. + When you want to update the source files of KBFX you just need to do + "svn up" in this folder, delete the folder ~/usr/src/svn/kbfx_plasma/build + and do the step described in 2.3. i.e: + + > cd ~/usr/src/svn/kbfx_plasma + > svn up + > rm -fR build + > ./build.sh diff --git a/doc/KNOWN_BUGS b/doc/KNOWN_BUGS new file mode 100644 index 0000000..9491fb9 --- /dev/null +++ b/doc/KNOWN_BUGS @@ -0,0 +1 @@ +1. Global keybindings DOES NOT work diff --git a/doc/LICENSE b/doc/LICENSE new file mode 100644 index 0000000..628a8da --- /dev/null +++ b/doc/LICENSE @@ -0,0 +1,351 @@ +########### +# GPL-2 # +########### + +This is A Recursive NOTE! + +All and All None Mentioned Files contained within the Source Package , Binary +or None Binary Follow the below Lincense . + + + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 51 Franklin St, 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. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 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 St, 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. + + , 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/doc/NEWS b/doc/NEWS new file mode 100755 index 0000000..a78e19c --- /dev/null +++ b/doc/NEWS @@ -0,0 +1,37 @@ +"KBFX Silk" (0.4.9.3.1) +======================= + +Hello everyone, + +After a long silence from us now we are happy to announce that finally the +stable release of KBFX is ready. +We made a lot of changes to the KBFX Configurator and to KBFX Menu itself. +However we were not able to implement everything you proposed and everything we +wanted. So some of the features (see the TODO list in the source files) +in "KBFX Silk" (0.4.9.3.1) are still not ready. We are sure that they will +present in the next stable release which will be due just after KDE4 is +released. The menu itself, however, is fully functional. + +Thanks to all of you who gave us ideas and who tested the prerelease versions of +KBFX. + +All the best from your KBFX Team. :) + + +Note: Things to be considered before installing "KBFX Silk" +=========================================================== + +1.) To configure and compile "KBFX Silk" you need Cmake >= 2.4.2 from http://www.cmake.org + +2.) To configure, compile and install "KBFX Silk" simply run ./build.sh + +3.) Before the install of "KBFX Silk", please unload and uninstall any previous version of KBFX. + +4.) After the install of "KBFX Silk" please relogin KDE. + +5.) If you need file searching capabilities in KBFX, please download and install Strigi + from http://strigi.sf.net + +6.) To enable Strigi support in KBFX, please pass "--strigi" OR "-s" option to build.sh + i.e: ./build.sh --strigi + diff --git a/doc/README b/doc/README new file mode 100755 index 0000000..406bb02 --- /dev/null +++ b/doc/README @@ -0,0 +1,44 @@ + KBFX Preface: + ============ + KBFX is an alternative to the classical K-Menu button and it's menu. +It improves the user experience by enabling the user to set a bigger (and +thus more visible) start button and by finally replacing the Win95-like +K-Menu with the Spinx bar. +If you still want the old menu, because you're used to it, it is still +available as an option in KBFX. + + + Team/Credits + ============ +The KBFX team is small, but very active. The members are: + Siraj Razick: Maintainer, initiator of KBFX, Developer, Project Admin + Mensur Zahirovic (nookie): Web-development, Q&A, Graphics, Bug Hunter, + Project Admin + Nathanael Gogniat (dracor): Documentation + PhobosK: Package & Release Manager, Quality Assurance, Bug Hunter, + Mandriva Packages, Project Admin, Developer QT/C++ + Johnny Henry Sáenz Acuña (scarebyte): Developer QT4/C++, Debian Packages + Fathi Boudra (fabo): Developper QT/C++, Debian Packages + Pascal Jungblut (Jongking): Development support + +Special thanks goes to: + Akhmad Fathonih, Asif Ali Rizwaan, Dominik, Victor, Ron (bfman), Steady + +We would also like to thank everyone who has contributed to KBFX by using +it and sending feedback and bugs and everyone who has contributed button +designs or ideas. + + + Other Useful Info + ================= +For Installation Instructions: + see INSTALL +For useful howtoes: + see HOWTO +For known bugs: + see KNOWN_BUGS +Project Homepage: + http://www.kbfx.org +Project Releases: + http://sourceforge.net/project/showfiles.php?group_id=141258 + diff --git a/doc/TODO b/doc/TODO new file mode 100755 index 0000000..11bb1fa --- /dev/null +++ b/doc/TODO @@ -0,0 +1,62 @@ +############### +# # +# TODO List # +# # +############### + + + KEYS + ---- + * Completed + + Work In Progress + - Still Dreaming About It + ? What On The Earth Is This + ! Top Important - To Be Done As Soon As Possible + + + KBFX Cmake + ---------- +!+ # KDE4 Compatibility +!- # Auto Strigi Sensitive + + + KBFX Docs + --------- + - # Document Plugin Interface + + + KBFX App + -------- +!- # Implement A Recently Used Menu +!- # Rightclick On An App - Menu (Run, Edit, Properties etc.) +!- # Implement A "Switch User" Button (Like Logout And Lock Buttons) +!- # Customization Of The Logout And Lock Buttons Places +!- # To Implement Another Way Of Reloading KBFX Not Through Kicker DCOP Reload +!- # Rewrite the DCOP interface (in src/) to DBUS for KDE4 support. Should be done in a way to preserve KDE3 compatibility! +!- # Side Slider For The Programs In The Middle Part Except The Arrow Up/Down (@janet Proposal) + + # Make The Canvas Autoadjust On Group Fold + - # Add Config Interface For Each Plugin + - # Clean Plugin Interface + - # Write More Plugins + - # Some Tool-Tips Would Be Really Nice To Have, Especially The Cancel And Logout Buttons (@athleston Proposal) + - # Configurable Timeout When Clicking And Hovering Over A Group In The Menu (@ruffy Proposal) + - # Beryl Compatibility (@ruffy Proposal And Testing - http://img406.imageshack.us/img406/1554/snapshot207ed.png ) + - # Submenu Handling - See http://img211.imageshack.us/img211/2026/kbfxsubmenusweirdod7.jpg (@janet Proposal) + + + KBFX Config + ----------- + + + KBFX Design + ----------- + + + Remover + ------- + + + Public Relations + ---------------- + + # Talk To Heliocastro About Shifting To Extragears : emailTO helio@kde.org + + # Talk To SuSe People diff --git a/doc/common/CMakeLists.txt b/doc/common/CMakeLists.txt new file mode 100644 index 0000000..7871a0c --- /dev/null +++ b/doc/common/CMakeLists.txt @@ -0,0 +1,5 @@ +FILE(GLOB JPGFILES *.jpg ) +FILE(GLOB PNGFILES *.png ) + +INSTALL(FILES ${JPGFILES} ${PNGFILES} + DESTINATION ${HTML_INSTALL_DIR}/en/common) diff --git a/doc/common/kbfx-about.jpg b/doc/common/kbfx-about.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a349e7fbff9958e366e831283d237f7e0306067c GIT binary patch literal 25522 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 UA9s|cCDw7Vdx_i#58oO7Co4qkumAu6 literal 0 HcmV?d00001 diff --git a/doc/common/kbfx-layout.jpg b/doc/common/kbfx-layout.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f8f65d4a7d04af842e3b76168ba3015d7da8402 GIT binary patch literal 23403 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 V+H3!3XYBuz+t&Zf_IJM){y%Bhz^?!R literal 0 HcmV?d00001 diff --git a/doc/common/kbfx-plugins.jpg b/doc/common/kbfx-plugins.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e9e3466154f879e2454b809995cce32f81d88f51 GIT binary patch literal 18937 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 Wyzd2|OjZ_~#=C4O__BO8`Tqc1vH#ov literal 0 HcmV?d00001 diff --git a/doc/common/kbfx-startbutton.jpg b/doc/common/kbfx-startbutton.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e800577f8a45d1d31d6ff2b8bf98943ed6a7b6b6 GIT binary patch literal 30229 zcmdSAWmH^Sw=G&Y1WAD4?jg9l1rHX21a}B-g}Vf&(BPH;!5s>BcXxLQ9tbYCLbCVy z_IJ-Yuif{~`*DlbRuwge^wCGJRddZX>v8sR74YJ%gtPCP3P4AM3W8dNfg%S$qeH=5HW01jNzGP8^7kRG~ z9W#c7O|GnO=Nrq)X`flXM#28(^Vf>XaW(^B8>OM2{|SfaI>M){Qz~jPNJKmcF~1)F zkqrO^4Fd}Y8Dc<(0zkn+Lqn24!@)fnK!(s2Fsqp=P4+wSg2NtrDycz$Ok9jXy8LSUzlfuUKe zajBh4bItR0-$9h_^`1Fs&vT>q5Zn$y$#WrD)aBV|z!*YqOsWYNetZW};dRMv14T@gOiWKi=d=#+1_2~8H z55t(v7`^b=VRNGOCN$|ECNnRsMjn87%1I&QNkNR?L-DlfHbTSofuAUJwvh<&MbOOb zDkV;AlCXE)jY&$XWWDMr$TDrcRBoJH%g{h-?_TFb<@sp9UD7ZlDCd^q1-w)G`vr4t z0s|Ijh@ZLh;n^gxsY1Et`5`j;L7C9QBxvk2D>x3QswyhS;g4b;&cF$XaRv|y3y#<8 zvR`w2x4IrV)w!G9d?-}Ob1J!PtC9|U*q`IUwL8ch3)FD=Hm<@_uNrfCXa!W0Ags8I zJ%W=_l*~+R3zF&`(y}sn^}Ved*hPlm3sAGEC37S;`(ZJ;aF(&2{@07tuiOKmtREh3 zPPs%%Ls;|*js-M5#kSa1{#IeEs6lYXXaQqW7!x>V_|>6x#Q1uN*Z=@|>&}RcF=$47 zJBUUGx$8wc&(D#X^~Rdm#$;<0dec^EtAcdq*yiPU=>aj(l=uwM>(_w!e8;cDoK~8S z6@&*p1hejkHlbY%*kPfhdvq5eMo>9is_?61LsYG)5o$HZ<=QwYgmK@=@7I=Tw|l7E zf?HgiLybC;*m=p1oZ||#U|@W#WHiHL7~vj3B@!Ntb#+_mJewdeYhAIcsZ-fD)Jl^l z-B85apXgpE$1l%5#w>~HHu80;6_8OUB@8-+Ml|ats{VfR_%Puyw^^fzbBuPX{Vs^icKRna+_!T8Z?D7#ntaGjV_RJ=h=xLaLVY5Z)SJ4n~;muZ0Nok*sbbEqU zKYk<1P4P(lZt$xM!|ZkmL)9U_l5svAJ!yWWWO?HEub4dD5vDKm!`M)^Jovke4~%nBWOrdK@#yW|=05B85k z!?KP~sdwhx&F=LvyzjYkvFCY%uNof8sez&mM^F+C5U$acwN!M*hqf)Aw z%OfCVTO!kzEnPR!;{zx&%cDq)mC;4>5x~WihH`Z(w76`i$ovd6 z>RPEiq;8}|iG85DvzMj)hbPS!GYIq*Ba41rQ5To-Q@0D*tOBN3)Ar+p7rV0j zG!Uxc`bk)>%?=|a-yfPp!G$YoGfni+WNazQioE~yCN#-iuJ`fB6a+=uabXbhe zfzMURMTwGxtLTW^lFFc60?yXVi2`FwX1$?kA7DG2*-Z|uUozSNs*Zn-rztD+a&!2t zUbjI=QA0||h>ICRGaY6$I8tBROpmeqV+5w09>!%?Oe#LHFqlRy` z=fZV-SM(7IKP;=bmD)Ab!-?!}_??d~a?_V1nwDxG0g#mG+TP-hlH&I7l$0kCzd9(_ z%<#n2&9XK-@jpxa;T>xrpr0EAR~n{eWz9D+Vk4<@wCJ6nJN5*&mR*v{oGH(kuN730 zB5!Y4!{@bO%;(D2HzQqW#V#SEi;$#FVSnu3&{hBa{@;dA88H7R zGKllnKZG7O{srxCtQY5wM~9u)j`uJBCm{I!|C*r%^#Ll|9hG@t{DFx z`t<+41PaM)^L>*kCE;t`<{_Luhqe*lV=VS_+s-+B{A(jrMiYRR^KqAL_7ByNu``aU zvhP%>iHw9B9&*$xZMMlyd6T2#Tr#2=NZGBqOB**Cj_5|54irjrbB2;4y{&U{ z6-;lq@TkYxO*kJqUv|IudY!EBkZF3OB^#JtUGiq%??MuhxJ^&Ne8ZfU9jqinNr5a^ zR;5OCC(vI~5}KK=#eqt;RqL~2TiazPRB~oR60!FPxR)%7j&R`RO(ys9*V4M=JHh_o zMj-cLPf$j6at|<}2wSITjqc+kp?T` zM8A3q5?(jcVy)*$qTP@{nsnh^IP=$$^M;d~CSKX<**U)8QUqCI= zm!uz3YX~|4XZc`o4oui@acqS1R~OGnxV}Y2`uSR+Qt|Fsx#}fqNsI|%#}c6|kRZ59 zE7o&)wd5SPg?#10Tqx~(L_~9zgtDNT*$Q<9XXPEMm7(VfR`5^8b8qJxE{Br9oUAc6 zWl22Ca&R`GJkO#X-Fsd+Lyc7m+_Xj*vG;_oL#r~7zeJZ(atx71v4P`sX+-ex3H;D#HpN>^3u&Zq z$1e%s!^KWuIMz$Nmg_x56LZJ#(bV)qQOTHd10q^c{o$>ilMP#o)n#RP9@K1&X;5oO z(~`VfBVPI&bysv53}HHs0k z_Kl*!_-_mg!routu*3Tea)B#qxz@b8D5H0it$49Ym6GUHe)V=JD*T#{g;*9#n7T=RC&4|j-AZ==sbz)PKW>)jYbb_w8 zDE_2T(AL&RDyo+$UKE}0^LCK9D5c}`Xb_7usKmo>h!cM9%vy-xEdN_z$Y6m-tPfTD z9#Oa(w{(p@g6E|=EBjq^7VWyFdelF{#I=Hadw4ZhEEj6OBdm}o2X{SP;HI|c9HJE-7&MTXZ zgKAsOS3!*YJV;!S8|J&3CWmp3@De$|dt>U;(VZh_2LuIr3*;40bVN&L~ruN(E_!xm#5-fX~smLFjujxCNa0s2SqU!>R@p>1~ z@oEqH_o6MTMBOb6o4u=fYA)#av$}%R2DJ&_e9yskFlJ_oFm2*qhDkqJ3!=MYg>v=t zm&7Dce{Yn?tUmPFfYOBM_yH-}f=Zj;iqYc~Tuh3g#oD}|Cm;6}7WB0SzEhv8rM|!B z5wMmbLq!%{8c>Xd!H3nAEGk0ju6c)TwmQb>)nIBF;qa|G?vTrKSWJ`6J@qIF`=HSG zfXQ-@0UK_%h|w9=*qCn)6x+GIlg=_|>He%JnE_khlQ51fF}qvC7;5&|K>WI|rOU+; zJJeBz@Ww}HrVgb4S&a{ye8GMAxQ~?qPgjO45>Cu|IsyL0s%V(Ak4sizzB-$}rz}JC zMSJ@x(0#sRRmCYwLY^Eo-y*sFI+=jN>QhR?n%x~&DY?G{rwCp?wQPk$F=e>V_NvwC zRgQRrIk_uTOnF!PDo5+0osPP?0?lYL7toWe{Sn|- zf8ZyB9TMmFaZx9}&cLBT%sAW$ zft&Y&pH+i#bdu543jslozLtX2#W*HzUJ#+%5SXs9hZ4k+#8AGyQzr|`nO17Vm|G`B zzGta#U0E{V`|wo-swp>k!8->F=)i%jZQG;Y6$a(F;J#AHr|B4PH1<*f{?L}jJ=xOr zK4V)TKU(j#fo)Wf9|exxHlD6`oohrzx++42OE15+Ve>+S`wxw>-R~~1R-}npU=}{r z;BXYTECO_>$Jp64Uot?IJ_kTq1{51`X`a$X>qFFzmsLxtiMz~IWc4md^F`dZBWu!8 zn*F@{nUDdRx0@azwZp%9O3NBk%bE3{!JF%4wbm zM!4=v_*u}8+Wy7q#UyOhLf@GVIz%%-l>La4#e})OZG%a8n6K>#kk4=2DhBa>`&sVR_fhW&_i z5la#6Q?^lZA9A+4&ic48t_VPL6)@tqobCJh^PwLNe|csHdQ;1fz39Skt+*yaw+a#Z zj{uniZ~xHk*QWDB97^b>s2H{3hb=;v+EyNJyI@a4Z4%e)=Nra7Km3}iZshTFqw{kk zbU{Vla68v5Y&JKZO+o~OrwpM5k`)M?p-_s-Yfchc0FrIHwX1@AqP~xzt`TwhQIo^c z@lr*ilFSH?0QxU^TlAB0?87;MTtPty78DD zG4|66GaIS9l~?JS zt)7hfT@D5jTyHL9_Uhj)>EqxA1GH=xD`f|7HB9o8wh&2jUd_%B^vh_5w2JM6)_dqd z^Wve&>CMlQkjbYFQPFIHh#hwB1ZT7136QTnF>8H&ThFj^?wEBXE+LE$c@7>g2Io>h z;~a@l?gJH9w|)~=*j?(tAi*1grGD`2vB3pFbI*5VdQWvX26s- zc}`=xE>lKlghwrg`J|k3YdE)VHGvRZO)hl<63T6X4w7i?ZCMsWgN!vRbPy5 zwjD9{Bfzm7*v9BWE%svceY-R$0>`A3D>lw&XQ%h$!80MsQGEvHSSLL$JIb&X?<0= zOu+z8ia~mTWu8(y(;Myr&frzk1T?}Ad_`~#0Hxn?VI5wMiBrlN`Wso}Xm7?qPPx~E zWe$#H(J{CsS4$x!jFiip50u4WPgIaOqSB>a^719bXzvmBH9Z0nFY?fWvbty31+vt1 zE`l&9n<}`rdz}~-p3F&uBqxM-moSlKE$MBtr2wY{5f6@pZm&Vn<+VC8nnBpCNW+%{ z8EhG>3s1z6!-%}yO~DI~2mAVubCtCS-HVHFdXo6VXVF2WM6%G-2;EgI{|1M$4ZtN33d5t-7s1Ek*ko5 zcVuH6KRRnV8KFy=pF;NfhP^dVa9q_IA`RHyONaW?r{+jD6s;@%=7^dqtQ3bIW5>@( zI)vrbFA4pNomgTlM#PSv)`@Hg3%$0>Zv|kXRZ(@g)1RJjX(iA(82w~5y;N+Y90rZI z+p=M$gkgI7YFh+S$45tFtHiMPpWxq%~Sh^XJSHHfx<91P&K}(oC`CU zU+19z`kU9M{4o{ltRjo~?%G5e)4q;J03XH@i#Wf&^#_irer-h#OYGD#$$HMOFFIWg-N26Z>ZDV`cmXjDiqiP(&&zCxk65~O~N)01tY^z zEn}o_w}2Hk;N$P#ZG;#yR5Zfzd{ ziUo>1F*=ZyGo7cEvr@V(OU1J0SvwQ%0zp~N50QsM_mT{UbV>|VhE!8^W7ulk>`|yg z#~n!yYr`h-u6ERH)Sv;=00`( zKAo21BJdsSs-$C8lV_Z2{%xjYUmD}X=C3`V^8z5J_qGTim4&W5AEGTlV{2Brqa}S> zCnLu+D_%m5)C6I*Zif@+3VD8?)ih6@hGhgJ<;KR&o1@4YNZb{_n=FCYp>eX?YHI7+ zR#>+?R*zr6bhNT~gQwe|T&zheRzZRRN`ZI$UV>Je6#t1*8?n&E%?uF;_= zc%Iz`{_>d>@2{*t4L0dEDgh%fS~y~IJMz4C(=-oC|B973s(Q$1uVHxSCD?Cv<>n2; zF_eLom^{@ulL;HLRqiiPIZxH9P&hK?6eO4pQ&2yb(pm$|M$jy0lc$)41b!W|*Z_9O zq<}g#>3}*93v&uYbX)m0Rl6%c{?4wcMIn3O)`#+88PHXKQG?akJ;C!6#Zj>fv%|Jq zG)&@!wX?BDT@4*){->}BI?sR2D{J#DkF?&BQUs|DD}*~GCB9MR1(#v;5vw@;*9sv5 zQT07dB!Xkhi7w>rxQi#Kf0$4At0rNpk2k>B-NcvTy2D=L5PP0(fZInl#d3mu zBfjwhb~bv?rnbM2GZTYJwz&GKHz`jYQI5kpSFZYr2F#)YD})3TPrH$QiLje*l+na= z;7()}C{&#hNUXF#;`FRdE#Zk_5Q}y7tlEY2<>kD?FWxhaWm$INS&fc9i_ z&|E1;$i^x3Ds~~17?O~4Q$ln#(9y+rU?C>fn#`k;?zaeXp5&uKN9CtRYdzDsgGWHd z%DFZ~Jt#O~8L<_Quf(Qyy^Ne45>T7sGB7U&D2Ds%57!`S~yr+C-N3z+b)+ByyCp z4#4=jA>W6T1wBei^keMzZ)xXPENFnkdHfQ@qx&1}Kz^>=h}Z!-(7(2dzdij`LB!~f zE2HRmY;N15u44^1`GVKnW}6{LPE~}d;+H4~Je5*l*yl_0)4JJ-@8Mnr%pCDYvWMZ_7U0;5}{LE z1#~}sU?5JF5ptL>$X{jZ@pX_>oFGp>$>v`&JyA)g5GS4+%Np;Aabbu3_V%bg(bRz5 zw&xXaKyNbUek&V!Wg$xA8r|l*X}r~xitZ9Ff4=nY(h+QmT6t>?pPRZHPjpMD9|MmZ zh1w3Q34#$6s53ze836Bo8Nd~j?}@QS5zIx|yRJL3_c48~Ns>A+$Eg%1Clba#5D!h~ z;73!yOww2rN>MWP0H%N9nyncWf(MzPcvAtwp}xb3>6%<3=YQ{oe348n-?1{=A17 z-a{qbOCE2Q?@exK8?l3Kr8@q#TVq78ck1<#$?>Ch_%wbz&m?fVFO1>i&TA~^>G4Y{ z;X20`P4ONN)Yu^hHfu)wZ0;JW`&qmvzAf;fRAkZKHBx1N)S0k!DW^4hI^6sxs9l~e z@c_xQIQ}D5gPbCVaE?29cn>v$q5qk22=twfwV3cAqwWh;dCtC8@~RXIo)u|?VPBGF*&eV zqu!5zfP=iXso3cwBL5EkP_gmLWcjZZ=AT&hwW+ZyI#UJX-CKnu6So|GqY(Hfih6bS zPwm*>*Udgp;>uXcZ?89%9;|;0&CGEno_^+p{i2=3Lwp+k0>Q~U*@@9|UvnbvjJR;- z%MlNMPr=V!z6fm;UWptzF>7N!qdY^M8SS>>TD$TcnlUN%hHudz4|)ru=;-pcnL1K~ zJ8SMwe?w6C#bZz6Pr)XIMf(HJ+Iq~pge&SfoHyQ4j{w-;W+dAj3MCVFH8hD+f(;5k z`VTmJA!b4UYBmq)O3!tql7-c%<^d0XcmB_L@Awb;)#9TWn?h}W>}d?PhrvzUj{uee zPp6EnI{u#gC**;DrCT81Rro=&niiJAJAJ-!*OL#f-etHTOgB_Mo1VC4cTcgQ8QDWY zLvFqq)%^BK=aL|SCxS9=XV5LWz8-BO;Xmb*=lMTBQZt9q4m8)#Pvri@e|EuW1)+2E zk4_YRTPNteUT1_J4~t^lO@(*0sqib5f`3CKKf}{4QE?QqX<})mpV9W4-+_M`s3*RPsjg)U$TGu6y5)W zRiQs6KqT^XrYNoxh057<$p!j{YXo9&5eR(MI<$LYOU0wm-Dq>LRKG#%N=oPwzfxts zu!njVEQhz=LoHY&d9nSF6@OajI-xSwbi~~DQcVrDi6S^-%{Z$sqY(XRDM7#_Xq<68 zPDRzz#$96c8wzgwvj-OfiGU5Kuh_k0q4LC( z4Q@d!P4VCl2Y0+V!K($?Z7vzYwej}xaC z5jCpHD_pDAM2ZCYRH;Sm&DBqv2-bnvAj|`%MwB1KLj%x$>C)dU9I4-lri*3-W4eEI z2kkJK!%lrJ8!=-At}_8owtQe3PkJ}O2IKX-FLYlTaB^$KcjIgAAC;}dJJ&CJ5<0T3 zy97##+0L$$64*AC8r~@rK$f(tZhBF&s6iHCUA2TC5ScCV!Fr+!^yR%5WvjvZR2>Tz z3v}O9l+k;4%}qCf0H|DL;u#+n0yOA>=^?3088g~GeRvtEW3iglo#+9tyZFH}g#PZg z`b?E&eyE30&O%ksAvbY8WX-YZ5(#WlvT{{GId2n~WEi*d;{;Bd_KB9iCuD+tqbmz= z&XnRgi$aaxXE(BpRqI_tgGE2DpzvwdTK>6p!;7kE;7)r|3-4o-mMlzg?fZ&@b}O?e z4<$&lLV~w#{CkSYrdNV-biG7C$#eFR=Xwm!jkr(&T0W2)R;n-037E;DFzpCp_b}x8 z>L_m&%um=Y^}l6u)9){;&n>E*orn}tc||%^W1@fV*{x?mbZo8bwZ#^?QvN(ur2u4-Ba>}lk7!YK@}+IHWDim#CX8Jb&$TuA z`bD$o%CNr~P7n@9ZFt#QSK#$=Q*ld#%!DRI>UL14j9i2yg~gYCiX;lFP$}`DfVRPt z<;EIKII6Z1wob>GWqo(LRRm_#)+YDviwe*!ijuy$wT5K$nLlSgZG z8?r=OOG<*3ro8m(_IW4@d8hBG#7-Y2gN1k>=`7mRz6#e{!H#u*#L9w{Z#ep=aE-x|`r99vn7w0m$S2WKaZBd|&cU&PuILcvCOXI2=+UStMMtgn2F ztLNE@8O=>ZG&lcF#+YMj`y8$2TWBks6>{P(t&s`NWT=*%n7sT_+ATtteMo`!_nc&J z{PhoP$YKtMZRf(KxUN6W?R75tZWJ#dXAR|{JddKhWNC?4fwagqiz%9O$%?l-&(UZ)x_2?3PzVan-fHE3E zvPiGax;%S%Ri9_m+I4E@y~|-y^&eNMf_<9Q9%S5;4l|O_A^o*;pkP~_;-L-IY5Q6U zBRU)3+!43Pm5CQ}L5?4h^P0Q@7s_Wh>ech$%i*%s;dEML3d*m1o;H4LE;Xhl9F?jqFCi4e8Y zCtjqU<|?P2#wlOUN)dgt&8J8iEoF%hnYzKdvTJGXVX@;gCL?~bvWOg|OdyDvuyy~y zx$trdUF8kcrfhrTMCIPF5ZoPkj$d!T(Xk2u}Ug}C%2nx zT@dJCSf1K_$8pTsoX09z6$CD(gqCR{JH+)tm^)O(KbxF%7Gj@C&&jI0{!(Zi9xgTK zI2tA$se(z|jgpdBzOoD1sJIk3;if$7C<^r{iO8gOJ!<)(ozX>$VaWBnIbTMy#fZ|c z)MmV&Ef&SfIcbSe!Y#B|+(bH~teNa=fT5sdRum=-If5oUSno_hUni2cw|(c%#}|b} z|L|9>5%2zpsEVpXFFsHnt)Q5Ds6pJo534{S6ka@@(! zJMuCs6_Aqzo{6a4W1*%}*OzGr7hN%pycrNoZO-0-TzOYg92W>n~OrjF4T04R+1OCiq z!NIMbBvQ75k*EL0c!?E^Lbb%dR_X7K$o*CZDyV=srdiT&yDB0QYYKIGcy|F8SD3T12&%TGjM4u$rpn*gRjCapIFzs? zsIuf4aB+VoI_i&fSTv|Tn;lyb_V7*{Sghcc0B7Qrf^v?me4tv>y$u30G?4*Q{e+Cq zcTb;ZOYL0bqX)NdJWn?*_|A-xqtiw9AT!N+K-1pxMly z7ILdUoEcmnABB(uMb$&6Zh4)X1&(krwq>MDZQ)?|NdFdgCs5@*ijxx1`!lHCdcFY2 z#;9iY`bMC$qd&UKjKcnPi zshLMnj~f?F!04DlW=X*}*7fyYBN~!069uDS!@MW$-z$8}U(>g<{A7+Y149Sp?%oT# zFsrP=Cc*p4Mn{vsra`8Oo+8kd_B*=@kxaJ3Xpq3|G7=h|M(Z*3B6nO;d*v3dOcfp? zBWJmxueH;8#W|3|8!LlWDLGhQ-+hVAt_u9ghbM%8U?gVGdi>WiksT{$B;SpeGhDEP zHa}~%)ZlEA1tu9M4C#t$>Epufo|Cd0e&lZUiVLdU&WTPIIA#?%F+j6mF@Ql%mIl~zQAy^1eOcl=6**ZJ z+{=N-MW=t)6wJmL@5i7IBr)AYkI`z|!-On8A9J>_o-a`mG%?85muZZj1`O2!e4{UX zJ!j}J#uf1cL#Tl!%H%X4VVl}*H;a}d)H$T0iz`q@ z4~_{GA=7In5=U*Xc-s#+r15>5s*>`S)$aoGC z?y2raA{!k_m)e?SIY6~aKj3D??(pm$BB&*em!m_mL(+cf$A!IW2iY)(sRwitowxkv z=^<;(S5})G`2{BBYPrXoWk}e}!7fU}U7)nJm1dYri;!V0t>V30xw7zVc424h0m;Ta zTkENC&bX~|KZT(dQdGA9b!s=mDnVqXb193Nnn@=G=*ZR!FuIMgVb7(@lqv6|qe}$) zu5P%BfZC6>T7+lSrrKFK`qTwHFovx=7QWmz9z$2Y$*n<> zta==S-D5=-L>wo`>$Nz&zy~SLBt_&|ZBQ|8>WY-FJt`=n*g?QS`y?|bC)=0}4+i(j zT5I9PkPT?ySs<5=mdUs(lJ;bfyz92xux9wtKQF8n^Xd5FqxN%c91rSx;(Ep_wYk;r zaqd&)-+bzECXC4QDp2Gj%nnbLedsYUI zCXxSDK_OXABp%t$3v2AUnmW!M(&wRaC~}5cvsthLNr3>bD2?;c9tJ*qJy0iiV{F_o zmu8AUFDrW&TCT>P3_;u}`=(S=En($AlDk)ImI<_pH4evcS1StSiocM>@4elGw1>+n z$293$M?$N*i-$v`Lxd;cr(Qe0alS*#TD!~b9E}Zz?LA%`juI@C${L%xl~s4_fo~z% z;PGz6UcZw9A|i^-K!S9Li1J>B(Qa%bDtS{T50gp~EVPcYlXMLa1%g}<2e zhrK-_X&;*5y+k1y0hGQYJpc#lT)gYyS;l8wWz^b^dx>JnYAPn`hoYW~Zx2}sQgzL8 z_v(>{GWU{<(KK_!pTrc!e(jTh6%$d{yovib7ki?ZMuIYuE`pqTO~^#m)#Wc9FmkQ@ z*CGfWmV6$D@J#%hgLy>!feb0+ttgnPFVjvw`ne9Mm@L`H*2wdnYCCBqmLKXI=#0@i z=PY$}rlZ=Y7hgyaEbtXo5Yb;k(QTT#tApAl!il3g;c8NJ`JRWeqEeN5iW!y34$KV? zl{B0z-?d^d0yBa|8010oMi!}k8e@2%A$`-%1#|pc##53TpMU`6gOh;vlO&=8HRIg-2*HM@{h4m?UYOOMw#49E%G8GA^QS!a_ z2zS_{owe2|m;s$^7wWE7)UobiEA+)4Rs5#eKnZujV(?#hY0dRpGIV4I9TP$T5+uEysmiz9u_r%C3 zVQ+Co3HMSjpjWko2WK@_qbym{?l$aExZZGb50GJW1KU?|rC`wwJ+HZsPn##td2gu4 z>uF&C(5uzk?Tado=M!c-K#&AD9Ndv&xQmj^c3zI2Zs@j99UC$jg_Lc`lBVu1UG3CV zleYYdjWcw5ovflPfoD!{r{i$Y4a(g0nXK%mjXB%_fQ%iEK5EMn@rc32cT@@j6#a3j zAq!#-`@jbBMX}gnOUT7UfO|xWbo-g2E8%5bjv^?#4rGd}`Czd!*Agt!AR~KY`pFX1 zm3a;54vUfIAu&%M|H%mXwOpYm<7eCU84RuI#w0@K@+<#{4|T(LtOPST6K4E2v1%8D z+&?NiC&OI*P86vOuGOY&hwz2w{8MHbnaKul^XrNj2J%aQ zQJxX`2WXv(#VVfZj$t@|8;_AwskI4cY&@#y9~MwR>*=bkbY~h=$i8;c%6}j*irVw* z;fR%juS)%3W{2J1egXZkc*Ud;DJ7|>$oHv)AyA?$sH%FawF=zu1BUNQSykFE{FP>I z2~IU#s$FQGJw%3+o#4B*x|=0%aOSEzh0Afe7LKas8Qr|1VtgfWT7HP*?^@7na!fjjC zw45w3DSA9{z&OvadN63T{6c3Z5^R^Ff7Bq`c?;R3Bwo$?QJT^YySzEt0*FF9wPAS? zC%P3c%Hd(BC~*E$4A7&z#^Ph6C(NUJMZ2*jb}9-h_r)5qX8CJp!zjbDgyvE0HSK*u zX(^CoLPGV{2JB|6v`nZ*xH=XxO%Q}7$wc@1RGU={GA-o!Fp>lR4X zQ6cSf&;$dw_IoXSm~!kIdfzha)gl$yhjNv|@<)Kd$xM9r4!fZ(fFq3t(+|%hh>`tLK9lof0^vx zu03R_9AuO~WO-wW_cImHtUUjT-_X&S5bLdKc>Dg>Qc||o%71)$#2!Sxf!ui}Cw-b3 z7Z>4V6;Fwt7c7T8F0`4K==TE)C$Sz--b(of%L@I%>uRqt?LEN6@(p8+mh_^ziP zF8FSOW(@xN5wJB)R+yXW`|@koLIwHVwXWN9-hRf4jK)8J{FR#s4=a7Ef3-5&d=lhyFLM@Ao=WZ6}@iP2q1S{{#Q~R=#Ins%U-wVl_)p0T>pN zL%A(aT0I7zk|8w>FT5+_5Z)JoBN(OgYA51V*9y@YEFO&1`J(InzNbsF>1w1pTL*zH zqf1&F0<0_U1luOB{O5H$TlhJxmCz+`8eKYaEBUDGw6aQA{hi$!pCQM?beuAQSP2bb z(shD}t=-=4x?)B^{l%4y*7g+U)wyJU14)T=YPxS0*Y3ut&|<}rLc7F!)6*lnhpp+L zs<0q-&}Du9h|Y4#vF?LBwY*IC{gi{;CCP(~%3U}bkJ($rx%FnB(5^7MD}~_}!S9cN ziP+6cn*1sO)hPxorG6&A5etoFi{rtPSj)&@$tk^!xv{W+A725@#O^}!+NZ5 zMhTI4r_;KWe}sJxxr9u(3V+J=9~V|W0`hTw;)977w<6^3H9pQmc2Q`P@9^+4^i@AU z`!)Rn{d4-Isl49*wuU`wl~{zZyZ?2lhM8FgYz%S~qt2bYY3;f-)Y9pD)rW8D7e;s3 zsW$>KL;NL)hQN+Q=FJuHFN?mw+AVi$5!x}4$ixZhd`tw6L;9}WC@ApoUCpgCy-X&| z;(8w<+z=3dJBGmOHkc>%vY2M~rYUXE*mx6oY6x6PDz9vgkl4gvTWVyoA5|8p-~e-4 zd}Ate_fJLSTl#cVOTlP$8)e;-IXkDxmcH}iK)i0X8US}!hx>6709W^ z;seb!8-Y#3WFK0Ru3lgmgCCA-K+nh>0^h^T(7gH4%W6QOukyR7xHSAUL-$6o&P7)c z*+_#MYTMUDLYa?oSy;1UQFx2~-TN4(Grb0e`}p@NpX}-arvc%uw!=Lx)mxamTDKO2 zePKF1L4uNtfeT|i?nBqdb#m$=a*FS$t&-2e2%1Q>Y}c%h5NXmwe&7=JIm!n^fk0f~ zZs8RtP0%F!JgbI2T7hX>@TQ|YcR+E*x0a<@@WtEex^YS6Hs(S8gs8KGaqKdH7P3t} zo1{Qxs^fb>@{82v{kkvy1`G$)ccTh&SwsA`)vtp;MQ4oFGN$@-bd~KYQ;E!X<6TxSA1el_@Fw8fk=sjL~D|2;naEKAfudbG*+Thrp%I< z=Q~mr6v8#vgAyHR6TUk#b z^fZH0jGNVieUfmLo{Xo<RNZM{&hB6f)I@ZU+@bywVRkj6Sjb(ZPzlqt%f9P*^6c&vE`AEX93ue zj{p?+$g?^)hjV2Njv>PZk{lunW4%F6PFtGPk@Ys&kpe&lB5r zTgEAuk7(>D+*UlQB3#I5es})9nk<`?U=2a0ktfm0_@4Ux6LUlr`8#E{ni4TMGdS2MI2bY5ucGGX>yb*D)kfY5DH>E0JC>Q0G3vJN4rgTI(WdENXGh4C zYyl64!2#54(gp9&p5{p~8BlkD1>(MrWlDPRs3mgKiLty~MRuF}*v11sf@v#}U_vv(Zp- zfx~&JWdwav*Kj1lSoorULqOdFoQQ^O)v1L@RU42p$mn@{9ePO|RbmuqmgKU$?T2Cw zjScUodx*nVv(1h5(f8h{sU_w&8GhwAl2V$;28_VuIs9oZJ{*`&u~EGX&Ry=tUQw)4 z+uh^cHF#*C>w6OMMy>|Wvu7PJH+}Bjl)o#15Bgk4I8$Ek&qjC_P{he#x`?!rWV*<8 z^sXnn$~P8SqYwX@DDX`WGkR2|!~>1M_nE)FA$^3?7K|+pI2B>HjxGj8#J}%>W(wRn zCf?K0{6^<^9NmM$WbsMXK^`|F$`tl!#pAwU0pi{8S8h0WI)?y$QhANr1h3DX$HEBF z&QL9M))gJ+-&_LM!#NI7nHbU9NB7lkt~3zvLXOw!832jit5EnOjS1lOAgLc6vVx7?64`wW_dL`I|mO z2XV_dKTm!Ask&k~5YV}bK<%WyTtl&y+#0vMyrwBdk7>5)H^=@~*f|J4V=f+~f4ibq zY5dk8_0zjjoMYzyQ09Vo{=c^9-`$a33w4G;ex0r>Gi?T67xk`QQEx_I$g^kxC8$Nn zd=CbVbbXId;y_%aoSnO_G%k168I2$=q=Q4LpC!JS$Nj5*RKIkqM9m&l5jLDcRR?L8ao6BUSJ$9HF>k?SNL23Y+)#p_==EfOLq2K!8+ z(#nd;+H~*>CE!=Fb9Kqiv#<>~Z0^0Mc@%`uFXZKJ(wdg)pts(8bvr&)Z!OzJz8Li2 zZsQMt?LJadojzwLKZPU1@r8}ICv(w@2St0`mTjwY1FM1d(jn0;3NzvggJjl@o|cc14j-!tYL)Y+fDKtN&)J-@D=d z3r_x9ucr#Yz}iNqTk5!KL9ms{ht5{j)HhQsIUM( z6#!~{1K{Exo4=ucP+=U0aToqvffV{E3QK--%CI$Fb6!sr?fd~Kc>Q~6pQ*?wBTN3% z_WN_A9Q^#5Us+k{Tn^h5=lvVM$J<|n?*Hs3ug373d%(AQ7{fwW?uy6A#1Fu5hVp5!Li7mWE*=7Iag0?dawJdT`gyrvrOs_ z#8s=?I6P8WP=kFFca^;V1K|9(i-^QuDattwH$`8{mJfd$xX8Nf{6jnbMdq9C2}jJB zy$(O0prJ3WYDnBAIi324h7i=WDKL?}0+c)!GB^=fe8SS}WjD!1_!ct(`JdIr&ne6A z9RGc-)UT`N{{T=2q!q`z=uvJqp^Vo!a}NrFBQrSt2u&)S7AO&T{NW64XJ@r{vR1r_rLR~%`|ZUL!mBXTy@=u{BejmM zA&?lUsHJ<)=s4V(yRy@LX?^z!cpfEI%pW+T@SLD6K>h{oYaOp`=;YbdWG$`@jXa_s z_NCVnF@~*MuZr-BRzxd`-i0-$y+%z1b4y4D6H?Tv@Qt*!1K)#TACT{b=ESu6XSU{2 z!bhAF(ATo8cSc`h_rR7S+B3L{H4DISrls~0Gui&3BO$_BGz!lx^NNY!rw#lKb!XKD0;`bEa(JlKnqo?v-1!m(@bfvydEc}9 z3m8&tv=7Oi9j2Cjt-JxLEiP`$@AC%wfrSAZ{=-GU?EkFxOn-|BBohJ zo7b-!|IxWnU0QP0*wtPWZm0R{Yp!e~0k50-w3SR`!#mj~rDbci-lkaAkuj(J6f^dVKJC(Cn|NQ*%!gJjpT zI9>Mf1|3u02OcM!J}ydTdr9o^4L3{icR(U+ig^kMMA&EG*)Scc@MvwYmm!Q1k)4QV zc&0O#mg+#cia%vKfEK*pD&UX@mGNM%CQ%L(4~Luo{07%eaKx~ zwXN@6G7KEyW$ny|$k8!nSzEtQ>su=$;9JH|vxfwUm5Uqj3xZP$u$tK{;nxU-MqKKZIQ*cSU{9*+$?6Lx`} zzIs}s+P?H^g@>&pWzp<4*F_%jwefcvVS!tkjrKN8Pvh$6$PZnV&tLpR%7M1mdS|%m z{|P1+wDrFU0lJIk?F2h5^HoDU$SiEs2r!XLmSzM(-EA+(US<;*!B2NM6CKzpmVm%X zcIgx;Y~dRE5w=)i=_sqM^2Ib#_O_|U)z!0o-TV|w|NPLr{Oagh3x88kC_4j46gx?Q z$lcQbMp(`Bh%!{X#LR7!O4oX}HAdhM-{8x#aQc15k;Jt>@T(ZV~v z0^F`aMP3i^tHIMQhj-rbU3@6k44^iWp#1#);aCfE6f_)4=d9!r?H$_i9ZS!WFXn_~ zT5Mil(%rUb5)x0GBAk9lF@fJ*lGc7`@sTs0zW~IwMe=3TeqhaS zVo#I?YQGU|*vD^V?Z7>TN<>3MUY1Kq#3ZDo?^p1qQl=kwbCpXVpSc>dci(#+Q9!^f z!dFQDiZ;AI*)vSqIpSu|z>rF(p-;7N6$G+`6dJmCzoNY#|250UCPQ=vUs`EvOawWu z3=dM*P@nf*iF$=V9gKbjUULGFofi9AH>!uv(dU1}evufwXRmVDl*K|*<8nTxsq8A4?bfWk!2b>Eer#L%I-grqfxylH?_AyRRqw{fb=#(23 z9>l|<;HNboIb3iltxB1QSEYxqJkc7F*O?>FtAbr(1)O2 zglUISD>&%~Ku9OwjZ^-M*(VrxN-8PxyHEHm2x+Zs4CI$!3wjj=64vLfB#K^9j4h+u zjGVkd#N!ZM3bGNF{AeDFR+Q(TUGfm_!;YJ*e4_rH7pbXz_N37FpS0j2)7gptO-=a! zwL2=Q$h&=@TfFM>T+*u`>aRYn_)8rijEfO>Aw&D zGwM99DZ2She~ITCuvT+5!$HGalq6{nYe$Y9H zvSB-nA68Y=bxsqJn#7rtEA)^Gf=`>)P?wMj7I0N=p-)Oign>ghQ4bxk#F2Or-r^AQ zSfSD8)rtx++S=`g-m4?ZW$nELv+EIG3DRS~VuH|MK3Y|~C zG*1)TFAAe}6~k%_rya{KdR#ZK>(_j@xIFYvXLO%#<3=!P0Wtt6oT`fl80U{1 z-Jx-jbL%FP+1~7$*2aU%!YO0P@TVI7S%$lbdq#6o1W8KLndM3fp}j;zl`Y-lBwp@u zndVPozY#!jL?Wt{5%$5*$ zI|RdiQTiLq?F`E4^GQn^<@Mw~AV@*$LHmD9n;5e4ynn3cpdGdnjXh!0V8oChMxywu z6nyQNG#*+^K50xoRJRhQET2yq<7h=-yV$=ZXJInvVKPv->p5us6hOaUjw#0z80LYL z@PyQn4`*gAg8w;$rJrx}t3L4M zjk6k_UabdI3Y?3M5buP2*XZG)cKG$W{|!K$*C`!>_**$BqMGErKU@xAEFjP$k9>w1 z;^SPCC6Rv+aqF|~44F!g%a`#9A5%B>>lYAE(v&Q-U2H{9^LC#rfOzpXD|3pa#7YHl z%#RZM9X{+PKsxmB%*dXKTiVWTUY1-FHqwSNg3RGRY_wB*kZ=o*G0}{fB{!$y$0lfN z(x+zU;p-SPzHV3vDw%VHc^Eh_iB5qJ;OtZ>2dld6BxX^Mrblb2cd5DPXcZ=O_ImYG z7FR=KaLsRnzAT;v)E>Ah^Fg;PahBgmZ`X&|jb6s?u1SFfD$1YSjj*hJG%ZyV0>wHd zv1<|_(9?_EPX?~Z4A9u`_k114_{2nq2i0V8l=5j`EBpZDIEyox@YMNB$+AXfCB(iR z$2YT_Z#8xP?CZQX8#4BG-LYm$8a8CMo_5H@Ro+7yKU}KODhfQEoxV0MUCgx=RDEpu zAx;k6fdW^~hCUH0)=xjXTzT9j;?7&8F?M~+D2b@A+2wnT(%%*6pD7n6%~(5Rr4pke zzx40+-@ofEag6#boZ0Ou|Dt9s*uT{HPQZQ1BO5z(^x2mg@`~}W3$W-pV!i-cy9du)?t0cbtN6UWXypVCwgJ3q&MCU)>j}4tNkCo zc}Q7>(5aIj6i4pnyzFzTVF`SLSng$j!W{K4d8^3ew{F^eBty}?s93;`q_yOU{cLMN zK)$CA4!>t^vP($uESP8|`r=k?^f0vH;Odq*pUmbZT^_v9HCSPqk5&h-qE52x#x!&Tuz3ggqv>Cu>UzuO^_*3xC@=oho!syob zt|#NfoP<;u*Sz1!h$=G-wSqrtz4Je6R)_xdLN*F|_67*7WadT8Yvq}HjQ zeHi-|8Qjts2b5Njh%4mrJ+Y_*)5Z?<-|-yrCNB~OOY{=99yvN8(@#OVHm+HzOuAx$ zP(|#=d=%r86XO88FBd}HghsJ$zK)8Iv1P7rgeZq)IrDFwl(5>d6~@TXjNSy&M%`PK zeJ9m$31?t%zIpd!@t7ub&1HfKIEw#Tc&9rlD&RzKD-#{t{5-<3#dKb}9O?6%{tJH- zxqEE!ZKa|}b&}R|`A173eg~JucJ1j(S)82txt4=u)MS~^Vyb!N$stEOyX6(1<&Zn1 z+7Y%2OTN2rc1KC?+e|yov<6i*P4$PNZSJi{jj=>dn_~`&JH*#J(@*xmm9VhJ`^}Y<7g9M& zJ{a(d(qi-KAI~wT(TsoX@^MsM;C)R_D{U0;tmx=vLt6=`xWp6Q`?A`=aa_(2-W({~ z(!rn*(#(FhpfDx(Mw^`A0vsnxBT9^mhEK1#Lo6CASvr>;SaRV)3=nYW~y-e-f-%;3s*STSkX$un% zU(H&^B0B*n63XJ$3YIMt8CtK7w6JTPiaq%xOXzbi_UNFKyiDlLSZ`D-0BgbrzPUgm zCDUn^V`k+u$Jo%_!8+Dq;6uLt(~Tx<7^>5cnA^%XPg2S;R55RPHHtgd*M&li8!{eYWrue?~W@uT?=DMKPlpX^Nai08MN6>aM@Rwwi9RKe&-Yz ziq3m%r_A$3n2i zk?BeH&9(7ZfEO7=R@60h9VEY1Ut!Krq9`H%P%LnFo+5erhS*|@Prz5F%djhuUVr@X zk++;Bz>qfE$DW&;=7wfGi%KLK>@A2TGtDozf!H+MNOOS@!b^_0iLdQwRgk;AE-?T0 zhVproCBPhMSu2--)fO6QD9_>_V;!xHl|$r*umw&_bK7lK_FW$9x@pBnYYmaxv)y#* zQ2`jfUns4ab8^MXbnG(5l99}gZEoAbMSiyKPPypP6XIMfe03|M^tJj` zNObsG>snF7o9m;(Xi<7DwZu14M|yU(7hZ)qxd{!YZAB*B@II^c4njvK0PwI2iCf7c z7@Nx&Xn?AZqfR5)Q>t>64ey?qBG8jmKuoqvC_6zf#j_K_gp2xSzn~#5!42)2Ikt|H zPi-6%f!wd_NWLgE2AKQoG>Bv=G``acZDhv>n$dg|iVHtH)aR-hP`m^3=Wn?YS3g1B%50_B$Pj{O5YB{<#xwoJV7(NME;s`gU3k}wi6dETT*^b{Iq}6M$p}UH zY<(tL9F5w9>VO@?snq)P#f1qU566jYKc)O^GRnme$?09Y3TlFltg=kgqXG-i*Zzm3i5 z-8ou*+1~1O#0FyujOYVYdlQL$@u~Pd1?unG)nE&lrLtv0^1`49FYo1T6&32;TN7HN z)}Byi*XVa2UepwqGc#TnBDU8)!MTHVWamG+IK#sWU+IG?)YyN$)&mo|5-w35RDZCW zp`ggJ=xdKsApznP^1zDveP-x7&rKI)z7bMD9mDX=L9LR&u^OyKRzwS^AJHLbH!w@Al(8)3IE)gaE{hwz40h)o)KmY{*AMkfCz@ICDg6D6v zc#$t^vX_-h+)y?WiZ+iM*u|A}ubCIOT}zmrU75Yt>niK?%C*Y5z$M9vV0kuSf+;)U z{+udpkB=$sRl{G6^YX2Xf`V*jvMWma|6#n zUS529yIG1PKL9(DER&i2DpLWAlo=9kd-EbpSjwI@D^%(a$sH&>4((2w{wvBS09FcY?6uQ2ZNJlIGf#< zEJIQz{-mgVS>=njj|oI|9V~k2eOVW%FQJu5>6jcVHTv>Y8a~NIEQ!8#A6&mKv|^)4cUoH3suZuvT=?+=P7? zb+YGrSu9&~x}24TUetadJdR3i=tWIn{t0Ly18aTfxPTQ&c7qEJXVjsnz$e0|NrElp zMfE`(o5h*77lU&_5T?$Up*F@ZC&8>og;)w*qnE`T?i<>|eNdaA7L${kQh>zg6y1CQ z&U3>^pUtc$Al7u*_!3lF4<(Sri1qLW*f;ay4%}7Qe0Wg!n7i5uYpZ70UbUIjen($te~a8&q0@)J%VBi zD)!mB_TZY!dffV6ImQwqGQnZH_Hv+%?@rJqOCM*9^XILqyyM4ypEQzM-a>A$InuY( zC^k!>2Kyl?#gTY4MJ~JZ1l>wfu*Kdw=OyGpd7Qd=EJGWKU`h z8;9u!KtFm*a^Ln)=_o&7%wwL!l*5zVI6_dYV*#2-S^c_dZkil4ILzfTJ;{c3x9*bc zo%t0vhxaQ1XOw5<+*XBaj%(~w@x9KV(9n`uxI ze2a#C8V+A_kxm=p#v}0mYJ@^v+^VL;L`1A$PA!YRGHCeniMbGcPfwe-!wklo?BT#& zz5{Z$YmRgr6k!7g<&(E|wdHHq+h)1@z*qN}f5N+%m(Q%*W%H z@5PzF{65rOe7`yxT_L-ng9&eWXJRlV{#6@>cJM8ZuzAAQwnXhn=$g8v(3(7xU@-mE zRp)oX3n>AW+cl+aQwI5y)cMI&0_saFS)8-&@GbGtss|~G``uU$n7&E!dWi2Y6;b-5 zBKlRHC;4!eZ>|ATS0?YHA6@F4c3-TxMrJI3)n^TaM^i%68JVJUS1iiqTQEl_U2$~D z=N^CvQzVGbqV|=46E*$y3PI~r$yHJ0AA)-hB7FCc5UIvUdCTaKE3*sr-{h&3+Bw{# z(YVDf5cXiz2%9uKoy6+>*G1gbliB($gsbr(-C{75{-#-rbQy9mpapliQ^Tf znTgqzu}e;4Cf7A+ISdewov`X0^6sC$7@h5=l*MQXCTQaKHzQPKQ~oOHa`=bn`*0aj zUbJIkEPli83y7sd3NQP6{}8)BA3ha~*FT zAOOK`v%g9>VY=RgQA+G)pftCeT6SY`^!I?CJ5jyApU$bO%vU(jZ-$eCZpI^4V2q9n zI43v$8J7`Spok>j{%HB3Y_m1Z+-}#&XP4TE!(Q3y{fF<)0iyBlu>*C`mV}#AOgd&f zQL}M&P%F35IU?gxqygfR6GWWNUhyv4P9az@O*Z>ld^^r&m4cd@kf60k+u1ef%|=>_ znB$_y9FPHYSxU+qEmZIH@;hfO4t84(AkZxT^*omlZ)C+Tbx4b4&BwRBmRk}6+4>c17)6u9^L1Yx5vU#^xv5$>@qD1KY7zwgqu6>Bs zEt}CP{kW{LC68QHQF}=il;o#HW1fKxai~nvFUNyz`q(O ze~p_D3XW@aCb0|a_V8}&`x-L@&uNsYKQWqiJ*aL^kZ1GUf97%;mw~zzonZD{{s>Q$ z2>IK&z&&HWTsh}H2eS(;Nn@$NyXYZo0|wLuS3&ZJ@s4Dw zth9N5(L_rX-xJJPN~7xSGN<{pVAnU`%4~rTnY|6g{)|LO*}|QdrI_f@fqAqP7B4Kv zr%8(1-6Uc0c+R`f$M#)2uX?u!zGWc?)u94Si$~SXD%yK_b2+UXhL6|TUz`@=5nUha zJF|+J^Xpo+h4INW+a;B)`Gyd&(_4RhAb#5OVy1PR7{?q(0dUI(M!~*vzU^&iDi*LQ z`WRi7pUKWHZ5kMJ#xD%GDfoH8Uu-HdUztToQ=6F}%aMSp@@3}e@nLW!>w8z!Bb$60 zbH?h*sXpEDR2L$P6mLp(idqiEkmk?aF1xGxPI?*=f{zSoX~u%N9`;z0dwcutI$87I{;J=0~jBGuwz9X4V z-k7I7-oGQG*T$D@)fZu`QLtro!j^W_n5X%Z{X{BRY&G}W<6=~RbAQ_Kf61+wE%=Rn zw5lr1-k?>0$e1o)ql4rRAM<~YC2ymS>*H|H%EQRzIzuXNj)=prmSx(wRfRB)j*o~Y z43-d5FzgONlJa3mII4R$$ea19cOPAqsEyB&%d`=kd1rk3wB-=dpU8gx>O1XXcv9fO zilmyPnXi^_mFjRm1|`eOzw${WxsGASr=-F3vL~4965K~-?LsgsYCnin&rsz)&8Q0lk`WNXTNUJX1Bja&WG7^i7`_h8} zrnlCk`M;CiX`@bXAFmcgSivGMX2M^EKk57|du5MIFXK6MzsJhhlWJhRx}`grd3^lq zPQz#x2`~PWhWH6>n=+l>X_LXo5&S7fa2@kQ%7<$KZ{&{rPC*nCmU-12o_p7Y%S-N8 zImB{^AE~rp-Z_NJOXU~GtSjc5vpX@SW;p3JLkbd0Jqx|`i1Ljvpj_OaFU@1JFP&?$ znY%@QKfKV(mMGUAbz10UpOKe=XuSU_D4JXS8`&`gDORUCtopNt=~Xgv8GZoXWg!|l gZbj_pvSa??l3$)V$}a6f5FkWWy>}x#`p3k-0d}hu#sB~S literal 0 HcmV?d00001 diff --git a/doc/common/kbfx-style.jpg b/doc/common/kbfx-style.jpg new file mode 100644 index 0000000000000000000000000000000000000000..85e580e27630cd7037927793cfb0c6a8c611bcf6 GIT binary patch literal 23407 zcmeFY1yr2PvM4$@f#AV4Kp+qXcMTy}u;A{_;2JDJf;+)AxI2Tp+u-gH+$DH`JCS|& zzxUZk?p^1;_1;_eo3(o8>#nYd9`%aLJQ;drN_*zw1Oj=e!QGr!Z zLto>)-aB~(xt~a2(9zLxuyAN_acSf@fE;rF%g{qh7tga1p|i#^VkI- z2EYJd;h^09{eeS(g-3)zf;LKH0$|`^Vd0Tckzf(vVPOz{0mEYTiWDIAn(EI2HH z5TLHO)RC1_($KL%e3KEP2kE-QjuYYMRpmGh!2#_PUA!vfr8hSxW+<-bsvi=kQ@6Eb z#%5zC)7>Mxn3Qu7dKZr;p3K&VkQ7qm`zeW2t%_OVdNAdffcd(FFg#3SlUt=lwf})wa$>+kxFIf3lfNncc$}zFmxec^)R1YpR_0VC4lJpeLCD*xDl9BG7Gt}i z4@x*F@l+_RT@G#53DIOkesyFm+=0tWH8^&^NFJB0iVT zAWJB*Q*H99N+t7K-(uDs{b*j-F1?W`4CXNipF2rU26 z>r!&4l^ePjkap2flrX{gDnb_`EAWZK+3Jqt(sKh*L2P|%3-IonU8{9>x=$T>K6+#0 zbhEn$%fixT*XjOEL2ub&BTozDKFvF0LZO?0rmaO`B~hL0pap&_fYUFVR4<6c=6<5g z#@EIr9=Eq_E03%-snG_(R!H7PdueyI6lo8*-`LE1dChs{YRB*PU}3j^Q&e-J3U`5b zv9z3qvidP|xv}vN0-XN_1dAz9B8N@5ZTF(hE-raL$5dN-^nHI}_3uO4DqU#T!kE;Y zadG?b%KJ9N?dVvxxdp9xSxXMe{{I^g+z}+$dXz1ggzRZEJFI&6y z^CBgIk>r~Pgl1*VHsMgdAR{L`BZB%=NFGSRZpl+ty@$8+YQ*_KE__5LnT^c7At}Wj zBg-z@QY^G*%qLLD+X3o>c@Kp|<{9)7XQXkn`B zpNxwv>;Mz;@C}vh>_!w=Me8l5eykr-Eb6EVDUIhf(BeHWxo|SNvWqgFx|6a~^WvXv z&h+1As|J5fcFolI@pCdiP13Cz?fcaG%=&uHO>j_8){N4xhVntPadK*m^(o6}*J4Ev z(R5fFmho=AebQ+znI`9crm0d>*16h_%TNh}GhN}SsxZ#RLn@n2&l9b7`zu(PzzqO! zUWg++z++&tCpB<9#T-XmwPK|zDdP30c^Xq^O`YkM4EOX=M(a!u5a#Fce!sq+zOCzd{+cT9X`2IW z85ww7IS99Vci>>kCQ)E>?QE)r=cSX1V~>0zUY4al>n^*`$^=#;OAAD$A=uJ7jb6ho zK%BzpkkQOD;Wg~-Ic9DMN_My>H)zOLd+9mvjqI}WZl@k|H>M*53zk6hl{er_=Z*uz zhfVK?Mr>p+?S*!>El6Xw-{}Z(#JJ;(!5~^9@%eZU8Jqekw;Bk1VbL5`TPBMoriBbz zu%YG@2P`GEwPdaP9X}gads>MXrY;>021f!teYO@N<)l>6G*L4cDKyp~K;G`2tOLdT zjJ$As?w$pFjoT|!jDsBE{1MjGT^A762KD8AK53OBl}hSdRYR07ICx1 z*7*r)MnN3sh67Q1MJ?W(=fV|QFq@AK4q<6p52u)HV@jUqaX$!^=I!-IEZ_^*LQjti z{7}{r+Nctu8}yo$oNf({wV46o0ZXes7y5=Kw$FW6Ck2KO_94Idy}=j+ltMT390< ziEP`9abaSqEl&z(-6nXzNHZ~kXdAy8k(m2SKDk97FVq<(rqA*dQ-43kHrGKIyXiAM zXTY%s20IqZVvcKlQ)aYBMkgv}5PJleUDJr>$L9F0wN>jJwPaWoP4f$QA8?uD!&^RA zlJu>7r)CZj>7+88eQo9ITh{NX>DdrdwH77yGE(9a4_snqKDmIV)mpZbh!-z7S+7*m zo&eLVw6WC1UAJh$d*foEAcPTn7!+RQ>F+?bupV#11wfY~CT)t_lnw#K)L#}BTJnqv zvRb5FvSX^pwIy>~%;bMq5bzcyL(6)K*pPFhLnZ|o9+p{b#m1prnqWz+63BWvWNoG2 zn!$b=zcIWx11@E9*BMBX#+M?rjE&}Qd`VrU><>|W1Wc63a1zW}KwjrZg^!!FdI8-v zbxsoTa;7Or^9(Nc66-_|sNWL>k?f>hJt1}B>oG?%pLAM&1k6cwAB`!ND@(w?87@Eb z*W0(6s$6UU(}?B_Xe%k`d*GQF!7^e0LOS;xzp zNdN7X^+kiWXd)ZU+ghpoDjK7{xLqeaqoG9XCC1F5#4nVZIg{#NSdF9{8$wu3q=SEG z!NeIp0=llZ$ibIFbKMTO>{ccmidbf7*mYsf3uO=DALZ|`2!72+#y3y`xnNQ=>Vs~=X zbG$e%wM~4Y?kNv$%N}{W$ca9Ws6@@NmQue(qT)~TK5H{|AC{Xdq{RbWa|_a6-I}w# zK?nrC$R-ml3I2$p6LtPXn8Kafma7q5#v;@vIWDNLb{6{b$22eL`73_YXVxT?aCGkd zJTe#F#omYD2NYfrOZtsj0MrduOC#>wC*`YnXHwH8hTNhZ_Xxn3>nhN(o9ou7I6SK= z>d7~!3Fk55iZp>o_2OK~91vfR6jufEwVMZJ4BOdm;!iR;oM>%|0e07eB6`e2vh+i- zm%_kaXEiX*jui5|_?7DG?m1}VSQLbT04>l|#XASVcP7Qd8Q0y!MBiK`K@Qx=sdm+B zdz04V3`&z1CrW+lcphsR!|3{i)=Y+WHC+}O>ra`*wg{+Rr^Q{DS@I?2eN zLK4Afj$tORw;{=@d!F8ohX%pu_%gd|`=8ewm($4Vgn3_bYjfoVl;ZeJxP53?gBKb2 zvhs?!Ol_;Vk|!M9+`U-1j-D@dFu2D>XG?zZNGf$OrHHT0;pLIbi{XvF;r+z{zSMq) zdRDfEE7tIBd#xksAT}n(^7_SizAsdN0o--+8{Vj2Oe9?Tw~b#|&-PJ&VWA#sYUucd zCG;p>O$$n{KPq+nPa|7{w!T9>qYI7L-+1YdqA}i_#^;OPwl|VYWcwRaf1`zMBK?QE zzvGRdCpDAupH~0&ol7fzev#EJk@-r#oq9NIyu+T2BRQGvQ-wCj-y|+7KZL%Y$oK== zM~ZJTNS!#<(nAPAj0>fm1}z5q=BaG)ND*Ty@=|a2lElGLJy&Ys!YvE9z^5L(H84tN zHx{Iu_?nE(udQ`eKa%Y3X6Hp!Omx1I(wR+8>>@pOu52;a^-)?=w$3UB&G*zL(3(xI zJpx+cYo+C76EtHXP8RV>GRh3t`pQ*=)polDG&IL%o96TyTIv_Ye&f;G6{SN~_OHob z7n~%y?$cPYv-a~3<2jbq_bqMLJ0*F4Nb*~PiXhOyAwD#M{Om&=+W-TpY!%inpOUmxrF*Hme zEjctR$D5UtiS=+a5hgSXAEDMd({zhb-8m5-t1n^Y85!uCm+9w1yqs!&GiPiDlhcMS zo#**rF;~lZ*d=`>bs?%sD;MbAmQzlHSB>S~(CP9)z5#Y{EA(kiOGe>7m&_}_Kt4c= zjH#)uPK&vbImoY_iP>;%k2h6$wdC2Fd0MT&Q{q60Uf1kJ6rbtJ z0Xu^E=`-u{!olSGNolDvdlE^CD%FR5>3;tfm2=G#olP5#R)oU{jwOXS{u!rt^`E;M zTB~j}y?V4QzxI1-B?c#d)^ALne5HzF7je*-CQPXQ3LF6n-b7?8Fcd9u09tGBuFapM za5=d7af=bxH@~SX<&ovlK1@8ym_G^qr)rr>>wi^S(GURYU|xdkJzFENxpnii)3Q&o zPc~i>0k08QZ(X3+{=)OS*3b!k<`+kFzk1+y+YQ(aSbh0fy9VWxuEQ3J=TB|eB%cnB z|B=o6JmgLnu6$M8Ub<#ot2<{uc8sW`SmpwCop{;^(#2-M^uT|2sL` zmG2iQg=uBzR@z3E4s5Kn{^g`HK&$hQ4JC&Sr;u#yH)ASS99NCqm32mpbpn)wf+_5K z0}FrH`Z+vY89-j@=thcv>)UPEOP`+R>~wFy$09lOF3SAiY5{*qs!(1|aC`Rk{NX2q z=9jY74S(2w@{@gKK2g3F-A5knFX`EL zLeElmvV>lw4r;Ift#tNGu*ZHSf0U;ZhH_gzq-GmFw=+ZgD6c>8uHtvdlYbgfb$%q7>Cj^LBkD%xtbo2+ygD>;wfi-wK&P4f(;de3{Y)J5-m z>j7qJ%@j|SnS!;b?GQH-Nu+K(tlTcq3VE0$ckpZ?(sOX7|Kv=dv8-oy7%Pzg1k>^_nN=eeRdOXr_vzUCQdb~j?_S+JC!~1 zTVCI0xSYOrXn~t@`%WrO>vf^ij3hsp|B)*Cvr{XgN6~B^l(wvjVf%?1rB8hhk{rR+kYrUiwUJ2UN$oND5*I!XCv*sc|2Tw9YnE*M@Nh$W z`*?14Zh$23EvNgNxjg97XTb7x0UyDxUz)?2)~x;RZU2Yr-vp3h!j`z&kWMXJpF<-@ zB%lYv+dzkhnyyO{UCH;)*`bDVp_@#~8bJH)M5cRK2HZk&{9APWs{*QJ!jty_KUf)!?tSmR_=^sumw&RiX0*2|IoaSx zD!ka?4VU{Z*?8Sf$}PEBq5A(lR0Tg#>3l#_+^@b*)DCzWk|?D2u(1~9Kzl&G2-RUJ zlr5n)i*)V0gMq6yw=Xpf=vn^`Nxl2HZc@gW^@{DWowCRqyc(Slpbbo+l{K-P&E;Yv zIw3ym$M*aFU+lKlOSEd?>>dtA{+XG72BrP!A2}#p-=?dn?fg%m{>(Luf1GPGCw=u_ zE-{W|{}8UL@BhE3e(Ln+y8I)nco_!7WVrCuVRRO;9&AoxHDDV4FEtI&U)4x+jOaIN z$N1WqX(>Awo)#?O6=XFt{RvI8Vb3K7r$_KU$EY-^7-w`>r!~ z(--FN>xJ`%*3VJ%1eVv_heXs&t{do=gsjK16MTsEAHinE*GkszSoO_c)OvNL($UW1 zYKw_UV&(Z23*=Y|de&AUxs(2Es-(zTlcOYp4pfgkQ|8t5sh-NORU0xtE?8RmF$;6RRBxT zs}LsDFl!ZWdrP2w^Xs>7absJ3im!}rfL@4sYFcRG_A@0va7`O&`z^zKGvH0qU=Ml- zf(GL@eJ+_eDQ(Uwp|L%kZfIC8suV3E5VOHI5h+SHcZn8);Q8M?5{ zpZegLI+d=rJ6I)6DajOYT%K0?3^I4ei`%^1dIaEJz1+_%jLR*g;WVw0kq68mmTy`? zetdDqD&D()hw4AxHaa^0VV=N&9l345B}^mO_Je&z67pI3brwaHT$O!MR;Q_zTAYF= z&JzcMgX}OvW$*G?XB$OvNrjht-&`3T%j3H5~~AdN)f8(VP%xv?OxctN{*QdH=Bw6 z0@R5~9jj7e?|C?^;0s2DU*NJwnGG?3oNmz27HUoI1Kc7zaZ+Y@Uk)ZYu*Ze?Hd(7@ z!csy{QvSI(9Y({q1K7N91MmG%B=HOPu%ugPPGQJWw)cc&mV@TYWTpsDxdpqzc`r_Iq_)}-onc*J(mVCFHS5?i zR)I?OOPerz32?a8e4qwDUZD>9;AG!y!ZhXXn@A)jxf~zyYH@jj{H8}1a%3?Ss z_83(Xs@9zmj2B$~EU1pc9i<`%htMR>Y)Jn`L`{oC)W51oWs>-1pjTiZ^6$cTY!f|J zTPRWUsCElC@GRh6Y5GvfmF780Z&WIIQh-Q{v1_ieaPlo*8oT*TT?xI-R@#dX>qh(pO9DO8NbocG+oN)mx4Fq@w0oW^*>&9v(heze)^oa8 zW@gRvPiUCMZq$prSPE+ z?aoDrk!TO}GW>!`jCI1{zwj!`+~8aY76I9R*2(-T|Nqd!*-spnOhw{?1X~ejwhl_U z;yg5W)(lBT-9zU8t1>{L@3=OZ+u0%RsPkKhv(*|KTKfzAV0Wn?VO75M5FO2wZpchk z^ws8~kLNFO{?SHA#encrR^#~Fp?pzjzCu!)F zP~rburjqBBun6CqR?1qXMP)wVdSpY0<0!Lo~qholFnd zfYP)vF){F9$;nBC)PCgGpMoD95jr1SGqoggoseea2M= zOw(M-S>}{))X5PL!xdN9C1rm;@^QvT#J@<5^sA=xS@xRFY3hslr=RhO{~CztoW}Cx z`{Us^PjK-`sY$>^e(9@NZ_uo+lUPSvl>WRu^NILlTT=jPp1(>zVKN)gz=)>J0&VB= zWy!|dzZh{QU2z#2g&i*-QHX~o2yuO}7Ea@=_Cz`DApJ!pC;Dfi3jN7bfe0dT0?1s_ z8xf8bg?L}l+zDe|>A5Pc72}dIYf*ZNsW0f+QQ@Fq~UT0`yQIGS(RNnSjv}~f83Dbzc_;+l?Rlnr7s&bV(p`U zH|qcP7v(?7xH$K2?~?~K^Ut9F!&vp;;U(?cx9~qF?Y}C>B3?Qc?*159acX5Q7LVao zc6>0lX;?{suH&6wCl2&WO3*ttj(l6n4ewqD2EY8{T)cYq2|@j+|4frgZ%1S5k4GC- z?)cN0dRa(sn8#u+Nu&;MRldn}q%cwc1>BuIS6WGk1!`zW%&rsYVSd7dN7-qG7zkQ>};&ZI^U^Em}k?#Ka-r-gH3%cKEf1~@2=C9~5Y6*BK zG>UXL!!O2t?Hu9X3O`%%lsise-wYKBExb?fHs)GUyxYF6H^lfx-)ed)%nMZ;J)PZ? zHH2~5lZ6FEVGVg}(8*R|b(#Eoso>@S#w5^P5UHo-&Q#zkB z4pIQ(_LLt1=9^dw3fPw9Dt#j&zR8aO`UMPUH~VcY7d2@9|INCIL!j2%9xW>}Tsd@P zI$idN&)w1LHs4Gun!`sK#d2tbWPs%Ne7Qbu@k#>Wfu@x6wTw}-GKi`y!?0T$rsdc4 z5w~8~y>oAR1o9XvykNA(xM+#49|1<)EGdFE@culBG_QYzBhk%z26ym_wpAw)*$da7 zS~+F;4)s+8^B6y`s5FVkDMu~K*Pk6mBT=X6qSMu5xWaOnIMm4UG6tRNh7>FvP$`VD zPc$FdnoPKBds-T*Va;iZpQ4V1>IE1Z({@qZ5M&kztv>8`iYstd-IbM{)}ZyPN}Zw( zbG3Wge_6-$@S2c?HWW*H78oc|lwJ6j_j8W38IOx)FLXqLzlM zeECUKL|KNq!GxqD${o~jGiLv!ipCh-XvoKzuh&LG*V-nU7xr3{^jmEe>xPFY)Z1=lK|MNDrjL4RCAXDdv# zHq@!4S$ww>m7K@=#NT1z^hpQdh)oyGGhM1|oR(wwWiI9qt%U<+*ul~2?30J1JzM4V z4U1Z9cIykKdrep>I&-0vN$wq|&q6UMAukqCCcLA?m3mvu7H8YdPLCvJY?79ox!z2N zbOJ}N9Sy$O*j+O{?#>ag7?-B*RwW@f1w^$ed1iqm2k3r{O2%VGB;NGymhEEg&qc?gGWlxV~ph)ri|`y?e_ngKUAvB(_OlzR z(o`D@OF)8lHuJ8pFXMsn|Z<1QqY^t3b8N z&pv{Frev(6BPl6^{{+Y=11s$+?v);KeY3oHV4KwRovSza2my~ikk@TUUR;eoUw7c)$80e zM`vY)aLw0L``TVJ$pn|G;!K7zH)jTgvBeMc&XrY*7(Z)<5@|vA%(~!#b}uW~CJtz4 z3+r619q-i=)L5zdWFAyywk`AspmLu{L%+|yko*ajJ0j1ZXGSrOa|k=2B9$2CkQftX zKVc>5t0kzux-!pJ6RtDXyx)0gdiZ2Pgvo6A;zH}2?KO>Eod=F&Dfvqwx!8h*@lhcc8Y<5Q!Kx}njA6kze8}m>@#Z=WfH;Okmc$+fL7WZ~taf$EWC#aQ&jSsWuex>h zbSxv5UC!wJi;jcqI!P||hQ>DQ9l95-tc*c>RP1kAD$Zjgkg%tE6`yryu32ySct4NNj+?L8+$&H`EU(N1@=^u}AFEavSn6biIGOhss zR{rg8287i$ujxme<)Y_^k={)I#f^j>41w0MYf$J+ochA*14#;#f~!zVvy8^sS+eIc zh27O=KRLN7$NM&N4=q?OS4)?_p04#75XOHBhvTDn%zzRERKS7 z0;`tOMC-hMj4ac3nfGRK=|5TEmj!)9b)XguOGns}@FW&|Qiz5ePy)BUybR8W!*5)OaRhGsm)uW! zOV^V1t2!7D$i`(+tZGDD3f(Pu+XiA~x-op*qofQq%Pr(=<|mwk)UMw^ODR_6kebCB zWn5_eFz%CNBty8$l%r|Un|I&cioZAVKO~dN9_~rY#^svyqNX^Yf~QZlM^z?cBSmQ> z$z!}-u+de%r+TZ5>dW}oDK&?ghvN0Xw5&v4x~pue5XvdD8O5|J&Yz8nhWK|lF{N5t zBtYbx?4;$u)U$phK)dKnW{oGnA*LehY~1grkAVJwQjQWXJ@(-=S5k(}ss)LTwQrc# z9P_s^dB}O=lM*un6Y`$Gz~?KNjrJ?>+^}fv_y}%Ih9U&hJ`%7qG@EX}gQ2Vm(Y#S} z;+()*hviE}g>vlT3 z!#dN5Z2I!Lx`jKpo*6wkT*s+=n96x~p!~i4i2cBodSgHbuw+}xXG-(&i-7Ae`N^5UrC zRN@|2heKNs*SGom_U(kMh<3yJZP{RfhWQlt=fo~!a}pMoVMm$gBV2YhQ@;60+t|9C zRi3i+$p_AKs)6J0_G;^Iq$C)*C|8$iH)o4q6y}2lHMOM?`c4zS!Fi^lsA5U4YcC|_ zH3P%pM;DNW(T1CPpo``a5I9dUZuLT3%pm3h0;GiABx@HGTg_gZT+8S&0XS=w3Y4(f z5x?{$Pmtu9%WqW4sfaleLcr{z3#>~_$K5X~m|yHM(Nt;7H6WRiaS&KL=%to*ezT7{ zzo4uQl#%=lrMA_y!rTX}Rmww?TNM*a`oUEtxul ziF#rZu{ud&Fc2SBO6_d_n&E@8Ow;00QUIbjsI zV(e!;2Q-<8Z&#g>wh*jeR;B4*)4j*Sf>-ps5Ni1p636_&T6FmdH|8IMM);jTuOgOH zOL{rabPkh(imOJi`r1>eT+3zriin)Un@O9kT?*{Z;{-x0%wC|wS zL6}FTXIPZ-1XFUR*y@rADhH^g!7C_8Fz|^{sB6<7Ckoj^hgi0vfy^<5@p>Ntb;n8H z!(7zFJX)_v&(%xwIy{@+iVigYH9PXxY=kSeJnR88fKk>aQHA71Q$Met$~b@T=Urk@ zHFwCtyvi|B!S~TisP94@^SS9)JGYc;v=d5*@8qqSJJll~+SV;y2E*vnnY_YD+&MM$ zb`o$)a+01ALvc6bAmTx?eb19!APTw*!T-nIg_)k%u*zo0VlNw|zR6s@5KJQLdjxEx zkmXH?%#r_y1Wjv=Dn}zX>bw>}g}TG23K=8LBjOe%oYUTvlVOlzWud&rphtwV_UjG zI4qK{m5B`uN_i*e7mgz;EQgcspD?75Y8)~2gq*6x8tQw^5xR(hhwp=fGf8+&CVQ!< zv1@MTMSp0wEEGL47s>u~|E1qfkUM%lXoEi_sk-a(F|;U1j$eNjmGSb~Kj<9FqeJIg>#h-v!=3OzhD=q`)#nGBZ2_3PCC^e9*xd$zyy|ph_;#~8>*o(B^ul-RvSKI%AlLBLs zE>=s;iYjf6Dzd4j3yUoknxq(mE(Otl%oVB2TunaQJTR(tUJsPb{dg}M7>JtQz2t_^ zzJHp0t_{1*q6od2e)^Dct`i|gI=g%_R(Q8wLI?N3&+pV+#E80<(dLxYS=s5AL02Wk zL+;;fd4GkbGXuQ;9aCGZp3Jlo8_VZdIz|kkh3C#zk5!NInHAyrP&Ne3zDY$ZYO7`K)^+wuL5AgZnIG*0*>IDf35DD$3Y5Hw>JI z%^J_MNVKq;{aUcFHc6}5hOv2E8ggoTYJ1WGRt~~+J>#s0cI!gCeD9%M3gV6kvWek6 z|JOy6!9kGD%#4l24q@Q9K)AaJ9*8}>juNu$8A5Q%D@khvjPH#~T(A}G-9Hn~oG}b_ zvSaCeiAM5_yBdjjA7bT625FcSD>?*b!=Yt0YOvz4RE2}cv^7eVi&%)nd(&lmLeiPK zc*DZ;G~*RSgXG_h?(FFUDOb0Ndg+ik%6BWwX@Fhk&;62U>Ug=fPKT!tHT^hXJ-v|t#z@)+(O@< zRTnjtDs8K$C-tkQdJCkm%Od6N3q=;fM9W?D^V9co8aq0O{^l_F5Q66BApc24RgO+E zbq14h=7!6bLEJBeJ49C%Loqx_eSL=pmvsvH6Wj?@Y=l9te<;2vlTos%96LLD1T5{a zypbTmF4L=rzA7}dqL?+Ni66SfsqZ{Tb4*N{;bP`=hG_4nbgbt^DVbA&4lbb=EKtE% z<5lCSdyM!2X5Z5|rJ_7aH|E2OJCk6Z-)JqiZ8!x=x965B@X9^gvID@%wi=9Ee#f3* zIg4wd#fjM*#ygkcug-LHUgZ8zTi4oct~e#ugC{OdB|;+Ni{K@InzB_ak{=X!#463) zw?tZ&0C=l1?Sw8Gfzrt@5y;6^B~1*xrAt)X_H`qQi)1pzI+;&lnHIXl36Syu<6bp3qdFp{x$Gnh437 zD+vhOO$6bg=O44ft*9aG}l#X*9*QM$g7qHB5Q4!_D<*huFA07>quD5s*SFI1UYF{KMI#rRKlh~BT;3G$3!y9QU*6Ab78k}nerDN(DLKsm zB@>_cznh4Aj+Cf<)VNi$8CCK2hRkvrcAK<~KJfR(<)9}T-W5$G(`_!93#wwdVCCgx z=~T0AK0bL^Q%R#4C9Gq}s6I;=bPCOxt_R;Zk?!qQm$NeWh~TJA*p9XVbZmJo>!q=< zk~u2T8YgipmG!GD8yOf+vuZwot1EkBNWEY`a<+iW2s_jnIIu<`*(UkRoW6yf1Div< z^HUS~1=>{EPV6s^DC)a?Ho^kF%OXi-v7CIc=f>2GR9jr!+ZC32ZyPimJBc%}Z;TK| zUB`PoW%yCSs#-UaVF3?~${>_Y>^81i++NBXe%5~0_tTVyofDqrB6d2*U|AM^{ro58 zgsfa5K4JXtKO!(cG!sXfbq20gv%h({?J$R^b^*IhoQy8x!k?jWh^jvM%$m!I0e&&n zE-cR?wdAQ8=rzC+2Eq96+ZFI#MB9wx;F+eO-VXE-j9>u9q{7pJq-4vFJxy*eOE_HR z{Ee{Yu78=bL3zJxSVy#*XXM$-MYWLSEAq@* zPh(97qwvIANExHHFbCx0UQ?__vO`YwYtGGk%#ac@5WN)H?t=8PigDc4?qr3Pm3lox z4nC*Ng>3VWR1^~&>_wfI=7oi%RDM!=hL)@wUsztqbr>=Nu{pn)wR9aAXk6q#a_y`a z{4}$Z9b&txxI~jyYxWh)CGFTNYnb${+I2wFnGIECXeEmi1QW5AZCS z5*99zZiQA{@p?DRW2*!ttBPqj?T4rd3|fIHSTc?g+CUT_U%BK%wVR-qSR5euu4h#Z~OdNT^2* zh4HX{YjZ~Z_V#nW-SECvcN$D(x)r99zQXUWmwThPh!?B1_W4`OE>UCEGyhyDJNw3B z)qUvBq*Czp^SU7>&-cU69sE}6lJ!$9JM6~zX;y~Eq=Sc=&#ZtLtrcSHOAHy1IV$kN zd~U9pHHcJfa7^irP`sZPx>KnBXFEk{ECZRbOT%$egCteQSB3SV?5MC}!@OaV-c~iU zK?6>k6(?#)x9{>!wpY0#<}@@Ghx9pxsHY}& zREXVrI7srX7kh0@VG2r#9=jV)TNPO>mSyA@)cZ7O7{oZGBBi>&kp~bUFzr<$1AJRd0=*3&;*Q zV-;6^yfORrYf(-z|8;2WQwFrY%LA$ykjhIsb(t_xtVcjoxHv~O?oXxS5 zu}BBnGqGYALE#ist9uUMXJKXeYoepXk5ZOD!>_-)EtptXh^($cg<+DkUvBfEChk44 zN~$%fWMB)|5Zn->Ej*dd`&wK<0e_Y0(QYzwg<09e;mC#uW-8O3!K8xVEbI!U2_C;N zbW%Anq)0!^~JO*tzl^K7_ zU)-ujX^4vi)P00{AMwgs*#)^^x^O&jJk@(nl%~;PVM70kVUp^qRR8(%;f;FeEV_W`k&yIT0;o+6d=`FAgY}$k3NBULE_XTlr z#quCt^~FZzk;uRh6SM!yF~D_&3*f`XFw|ARC1W3FzDmES-D<{zUTaxXRKD8Ol;=5U zr($qOa%j|aKBUhrIv!~3FtkjN);}5;y~1}Fg>-z^O_9ewp9`H~p6giFeeSSVwTRhc z+T3$T_o{+Tf(Ff3Vy6$L{y+;=vh`9;esnzajYi$#O#Sr0V$ImzhKd*`zKH{owq-4q zb}bY96o;(NO)lLbituIN6IzU1p63p}DP$Zl*0PGV2Fsbf5OFw&}nqV5V{-+LH6^XvTQ|VO&1=3$Z3uQZJrBdm~!gRG%2wMZfNOB}%b;^>~XQ z2H)UoYOw!2qz3wzgh}pG%pe)!L1_)CfIawVKy!0&_pB$*qRy?F);4jp+LKqq44sG8 zNC>S9sC7w#t5P!DY0L*Xc`vEe7Svj@tSpS5K08rl52Q5GJ4C}%@ImkHy~cGS_b%Oy z->B(n9|hA3!D&x0^;<#jJO4bJP@PtkSKKY!vXtLK8#;_vUdGZ}*<$v1H}(j~4yLDwkKZXu9SUDu-siSUo))db ztf?v#XZHF1Zi(^L2>={x!+5j1qL0353t zh#Kyr@^p~HWWYze18S?Xfc2&mUu5$8&*Zr0Zu}w`!HPNAmfm*`SnKYP7fu3ps=w4bVq7~C+v(DaLn3y)-v+9ZZWo0-LDQgUEKR~#qC#~jX^m2~)K<$VjeTi?P;05B zV+lnXMJ-RqIciwZ(bKdX!&U?=LJEw0_^{(Mr zVR0#@;}SRGjRPFV;RhjJi1M`T;rVe13xr*Sp?R1fg@zt}nd#N^ICfS`XU4Bk!Zy$6N zpQCx@@Uy(+vzE1Ia<9EOC@RCav$Nm9cWj)ykgb+fJV32V9tk0S~~Tuia5V!yF1XQ||bPx+QV1P+YojP9gbf#FatD_Z%DqFHG62 z_s)$T*Ln}Olp8CnG++Y}VLx*u z_6OklL~P%%W$eTl@5gUUhKddK&#}dPQlQLR^CRx1qWhfK;t#-y&}sF|v`WK+A#CwC zmDvSq?NyAOSmx7kvB^xUFg(~OJkhd479cMU*6Wi(llnJtZ6bDA6>oO3ra#RG!)Hkk z4~^Wg4#3fO`l1!K#7eWEqd$=i`ToWnZlI%dP&9QW_V|9l;89mQDCV)5Ti&AbjhW?Z zpcUzjlj={KMWUbpiey-Dp%t{SNL9^96~YolnhRRbqq=mN4Lxnw*VSoX%)3XP(8ude zX`*mc$T1f&RZ(e(S@&DqaUeP7B|T=4=ivn;#Pvm{2UZr3bn&-JG`$54gn;)a)AxeO-dX=o3F+{AX(KCe(Lbrv_5CV zK9+2kc6A=n8WgIU#FJoU{5F!9 z|9hnbtY--_mazxnct{7P#-KUp#d6>1{2qL^{+})g`kW68+06&0V_Eo?77G_j3ds8= z@|)JJl;n)|!9%T16PBi!8YQAapt^nL?kMj94^ungiQo4mqngoAzSxDQ=KsBd;cfKL zOUvsZ)Uqk0Q(8a_{>kNkUr92e6aSex2Lb3%#3r1<8iBhFGBimN-SBSb3j0LPI+WeX zSf3R{#n#o%vZ7X2RKP%m-jKgbkDA8T!-mZm`%Y?0C`a$;>!Y!v&4KvlxZpG1kz3}q{?5NVW7*EuMfP>H|&cavo)lB_lbxI;FF@Xh0peL{0 z<%z+1l^8XPZI;$nTMt-w=#q5xuVynFDH%8~+UQ`(8_AbdnKlEB z`xQKZfmB%FzBBO2(P_E_b@^4Y8B#d!j?sDU>{M+MnEXO%HorE)|kFX->^4jGO6}dVAXWiqXxfks8;Zc(t19_QIQC81 zXf^P%jD!!k|IDOc|7NDS+*V^lT2*NpmB+taSHq29)Lg?TKAe+)fG<8K3*#$zvG8#x z*v8UPbi^Q?n{~jN>m@z~Xu?+)*7o%D&f?>#$pV+?_}kD&>oTxn#zw!(N(Cb z^K&$CbVQzdo~dN^@qSA{m`ms7rK)MM4}-;~tLSGo1e=<&t8gF;>m4Oo0=bXUP70Si z>1E*4XL>wiHd!?X;!Tx}f8aJ8TE3Zn;9fy|x96#Mdd$E^l-$JomD z*j~RS*M;fE2MUYjKb$zyW;t}99G_cys1ykHS|Yr=rpq6FepJ9Yo*t9kOb!Q7JadB| zWs3(;ObNl>G&>#ISxlQNrkvbbh%1^3OZ=9Tq!Cw%9vic?BQu0je>8_1m|YhG z*I}QPwT{I3sbJ?E&Cqj&P+_j2nzLu+mZJKz*UG<`d(NyEy$GO|sQ7-})Uk8B5f*G~ z;(ke9%!e5O#1ld91v3xNfEMx1s7_6L9%{$k>Jz1%-VGk@lq*^x+zp}*&N@4dffrrAaJuWHqjZ+%s@ckSK%F#WI$KzlDLAqs$kf&z#`{s0ei0ATOQ87ueFflMNsR@a3NP)CWZ-BH6^eo)(`B~USIp`S#m4!s5WaJg(nfcYU z)jnvwmy?%$R04&9f`W;TNri<)CCkRZCj0;R_3#6LjsWEgwG0FG3IL4`1%nRt&<-E~ z0HB^hoc*U4Gz{!BI4F2Xqaqpr3I-Ym8veyI#Ak4DFi-#}0HhWD83q}X9319LETQlb z>{rb43X0lRVG*gL*6!)0W#kkrtn5nQw3fFz9_1_WIBdeYNAL7JBU@J~sg6Y;T5%!Z zJmT|DFDQssNDB=*!~)DS05mi-%pU)u`*7n!?nTFt+7_c+ouT4h^Mw7u6~au$)_G>*|f8kCvcEGsg!LdgOb({(d& ztGK%~=8eCgKjuvttCFB9HC5tUQzNlJAP83znv#Sm$!GDf)QS&-;u(;;isp*;n9FUx z5ZjO_ij5D$e2yt6K^Au0B~Gu|fx_00YH9Y(63A{ei+uKKfwu0WysXfBWGOQ|!X00{ zlYTv%-WISHO5ALpNPh$N1EA0CAf!K7Z@K#Z^8>)fRi8tosqeiHr)9UE_idSKod(H= z`Q}+{@)0eU__3grbSHHM25Ci0Nv$qsq3>BgFl2tf6!7V5f*GGRpDf*^|DpuT!qqe} z@^UdcHx$gx#Bw|UCd#>p*opN#Xz8-G!>XOGBsC^Y7k2qu6OxjV8AdDjSEnZpf-?xa zG=|700oBq6Scl9<>JI>h2SA+wGbGdpz?IwG$kq2Hl3CTb3|6Vm*GM~r#tv{CcXzV zJdz??ZO^Oa&n=bR*F`y*Q6Jx*vpW(_)_esgirj%*`Uwe6=2Q1ZB61KH8Q{yz-n}8KO|42#vmOA?_74cV!@=?lq%u{cD^VWG$O{P{8 zqN~idcj*@@+-<^BWW>luI14&zjr5TC-kvGCVJ=@!R~bgvgNebvD*s{5_^-K7?)|(3 zCst3$|4}KUW@#D)^P~d;XZ5z;?)T=6KcUO@YY;w3XESiJ%c!96|C2qpe%{}0=`l52 zPtHAQ0t|6{k0_Gs8d!f)1VnLs#PDAgaYGPNfjHhLF-7P0*T{b;GO;vGc!c1iOsN>r zqrN8yep`Vs0sO>-M+msIAVeuh)T!^164-!%;PUTunI)9)K7lPp#JiLeAp{F*k0MDdHT*ue5;d=UDAdzM4eqZE%gre|}$?~@|!4Q>C z41{1_W!+-+%MpUPfHV!55~E4})~oy^L*qc*{2zAz>Q1OwvFk&8S!DI+|&E-p5Xgm+zDcrtyEvwjf<=f1= zdl%s1u=h1g;#R4QE^b~ow7;XMOY`T#om5uBlbprnxxtJvGS6SlGOhD1!6efUkQtS3 zS_fu_k2YZI37v3x zBrh{kq1Vn|dk7?x2?PoD9{?`2`N(b4NzA=!=RTn%RU>oPR44WAZi@Ms;ac&KmHGJ^^jynuWMSPOqj^UC&2J)`-~;cN^CaWugU>#4IGlKy89Pe zOeMAB(#S@&Tni~AYHOmItWpO)XRNzLbNT_BQwL)F%^hmG!YzP}z!Liblu@xT9jID9 ze6FUEM#gwf+6XRxsTK#Q?N|HAm2&9)^E=n6Fz3Fj;6W^lQ_H^!70bd}KuyqYdOm)%0_~uy4)I=ZVQ1P)GqDfwpeMerL8yY-bsz00mTi}m$?qLlqV z6ytU3?Ot9u>POq>EA@a zga3ak(d1&^CME|u6a=q6R}J8d7<(qeEWS40TJbAmWjpD{*XaLRvp*NN!Zn~GL&Bmi ziHc7Dv&C|gV8fXGlAel3(ZtBum`1mUS9Ulm6rY`NYSsq(3~O^@!tdA0_Q*)g#d>aT zSIIR89#y+hzuA5J%T9UMN@?nwcWv8XX8bR+wMa!sGlZmHp1Jc+1m$FOA}^*ro8i!{ z&tuV_LJD8iE5U9r`iVVKP03%P^GK8n^?VMdvB)Hflfj)U#UFb*;L?0w`pAb$sO6#! z)4Gcw4J5iuJjbZ?C31?XiddR~d#h=i+;gcs@LC?Sps)8^)9#ci3%v|?m5D9Zg)P#m zb#kX_w*lZd@ZGQvWinm`Yj!4n8(nS9^9ht*hopH0!PEBfDhASq5 za)Q0lDQW2-g$_yC4_iN9BxVkvmLmW@YqV3RwdRs1hafwKg6zd*8mTSbZ?|c^=|Hm? zK!?Uvr*j9Ke!5{LZU>WHR??9Lf9|ahv;?V5V(iW%Ck1$Sm-z% z#vSC#TCoFU<@dTa!FN~z2bz`I78k8(AIYSA8$x~nw9|suZ7|q=`qXA%z*UtAJJa&V zYBKgB6-ZZ>;Jg;^S6IO%ENR2yCwr6a9o&uV30H_pHfZiuo1Sg9mo=^(Ba|AKq~?39 z_zTaV*A~@wada0YaEe6fAYHabMXxx&!~zXGmjW5UiPQ21=~7pv9f$@ zyn9SdRK7mFh%a6s!`+m*=gO~Do>tfnAAiSUR*gJ)yE+FG^#O`PT{xx6U*OG(b87i< zU6~M-#y~G(kG6S`t}%(4)$xh~cRJrY^L3#@Cx>Ci_z&>K4}evj_Zp}{k&-+}Js7-o zqT8YC<6+yCAuT|>1B+)Kabnz=13?8$jaRb_S|hnI77nPDGFh!#G&|cnWXa@fA;6Ed zDdMBjelSM$L5;?_q;0g?whZrn9%uCKhB+baX0_x=QnZ5RUn2{_llmVzsm9Zw%#2xR zO#p%3im)28=r}N9!HM63vuN>R!&w79n^n}}Tw+O5QlXM+VKIr~FUzRn0})733xIm9 z1c}Fk_#m=y7P40@>0$(lQ8mOvY8sl%c{nwdWhIH+HXJj$W96v~<)SAr6uLz~`elpZ zoJ46a1HX{ODbs44&=-S7K;YRIk*e(6)z;LUV56OMn=~>^LOo;3?3S6Wh5KA9!#?B7 zjgHQW#mp1RL$z*WcKoM-wq<%CbIAqOk(rh=)}&AWQ*qhSgwyAiZb1rhO)tUb(j%Y#N&yOkAi;Eo4ieF-ql@J(gY6@TgL_IZ99RZj(YTBxPO#luFl z@8_s*;DgQoJO>rwsq%VsWqR#aPcAZ8X?%l#3XNj(EeU-N*ha&l%39ve-zSiJC+ zxwP$q?*3?$1srJuQN0?wCuz#IYLPM3uvj47u_c^p$ZdAln+E{Wo+}C+lY;1^t`ZaW z*AcpJlXJHB`RboZh;VS$@wcuANS#efZ%K>I_^DqM508&^F;0OMohD^1}Aq2hzSODsgItMFZe366{@eno*X^J9xXWazn=lC8ER&gvA8m@AqPIR_MpS zvkqqYaQOPdTNUyVFzl;|=R2B{$kMwf=$&3Lm8fV0eFeJtX7b9heQ6HU=m5i&3?gf@ zcBanfrM9Nc#EApcvkk_pEM=0OU(%KIc9kAAGa2jJ61`fJv;B-hz!WLciSLN&!9w?i zV`8{ILMf#8jRyAxD#270?Y9$R<2=KOJJ#4#=yvSzQPj8jD+0F|ZrLPjCecEqP860L z^_6m*k`Dlw`0cLC*-Ej!{!7q*tW^Sd9R$7zUwc2D$SAl7j=OJH-uc7BHyg~HW9rLqcBEed3Ms=s`E zIk~*_YZ`+(=g`x{+i2gJYinD&1e9}zuOe~?sM3B|ITB_uFt-<<)O&Ua9NRs6mNgpc zMT+J{>cb0JCB$t!*ts@!g{-bCCAXuuBm2IBB{hJA^rAlNN+W`#C zc2!@%moW=FL{diQ(j*}BiDXb4A)t1CTJb5WKp5- zX>6+Ol<=02#dO-Js4c^eMpLoYz;ThDT$+&b_m9GKNI~X8Vr^=3;p365v>YA{m&i7z z0N5Q=&qt$sU5W@NT!@cQH2#W{7|3OSTTJMhMQ>kTjSgWXd}m1O7&giCEcnh{!rv!~ z8eR+l@-8s{g4}X;txV)Q$`Ai`$1Z06_Q050*|ce4ma^^LN|-_?{wD7B`fBIfHA4*K zpsJmbJ*gkJSRwvdTwc~(sRIqcuy8?(h4tf$VzN;}?T@E(x#K~;CM&6#z=57QC&&Qx zSc0tyiHCEVUSmN7zA$36tS^#j8?$!Fpd1_4j%cTJZ_q_xKpkAOw5e)_y-Lqw1oe~i zNViNb@6O7nc)T{iZX*^Amv*QATnOZn6OvH+K%InkCD=;@wq)BEILFaR&-PpC*RG)m zsEIct9=uu{-yi&`aUl7vzl~-Z!PI;ly ZE~*uU8?WMqC$H}pWz_T6zuS6{O-5h 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

1paA1VGS^&hC>a~Zir)=Z9W{yEr9ny}7wS@&P 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 +KBFX Configurator @APPLICATION_VERSION@"> + + + + + + + +]> + + + + + + + + + The &kbfxconfigapp; Handbook + + + + Siraj + + Razick + +

siraj@kdemail.net
+ + + + + + + PhobosK + +
phobosk@mail.kbfx.org
+ + + + + Mensur + Nookie + Zahirovic + +
nookie@mail.kbfx.org
+ + + + + Nathanael + + Gogniat + +
nathanael@mail.kbfx.org
+ + + + + + + + 2007 + KBFX Team + + + + + &FDLNotice; + + + + @APPLICATION_DATE@ + @APPLICATION_VERSION@ + + + + + + KBFX is an alternative to the classical K-Menu button and it's menu. + + + + It improves the user experience by enabling the user to set a bigger (and + thus more visible) start button and by finally replacing the Win95-like K-Menu. + But if you still want the old menu, because you're used to it, it is still + available as an option in KBFX. We recommend, however, that you give the Spinx + bar a try. + + + + + + + KDE + kbfxconfigapp + KBFX + Menu + Configurator + + + + + + + Introduction + + + KBFX is an alternative to the classical K-Menu button and it's menu. + It improves the user experience by enabling the user to set a bigger (and + thus more visible) start button and by finally replacing the Win95-like K-Menu. + But if you still want the old menu, because you're used to it, it is still + available as an option in KBFX. We recommend, however, that you give the Spinx + bar a try. + + +   + + + KBFX features + + + Main KBFX features: + + + + + + Using Plugins. + + + + + + Selecting an Application Group. + + + + + + Scroll up and down the application list. + + + + + + Type and locate an Application. + + + + + + Logout of the Desktop. + + + + + + Lock the Desktop. + + + + + + Launch the KBFX Configurator (the KBFX settings manager). + + + + + + Extra KBFX features: + + + + + + Double buffered Widgets to minimize flicker. + + + + + + Animated scroll bars. + + + + + + New Tooltip. + + + + + + New Control Manager. + + + + + + Drag & Drop Applications' Items support. + + + + + + + + KBFX History + + + KBFX was started on June 5th 2005 as a hobbyist project by Siraj Razick, born out of a spontaneous idea. + + + + The reason was that Siraj didn't like the old K-Menu, which was quite a clone of the old Win95 Start menu. So he started coding. + The first step provided merely the possibility to call the K-Menu via a button, that could have a different shape and size than the original K-Menu button, which has always been an icon of a square size. To change the default KBFX button, one still had to copy an image file to a certain location. + After the first post in mid-June 05, KBFX has spread rapidly and it was nice to see that until end of June, there were already a dozen posts on kde-look with buttons and builds. + + + + Mensur Zahirovic (called Nookie) joined Siraj on 5th of august, after Siraj met him on yahoo. Nookie is responsible for the Web-development and the Q&A. He also arranged the site www.kbfx.org, that replaces the previous site www.linuxlots.com/~siraj/plugin/kde. + + + + After that, things began to speed up. + Now KBFX is no longer just another button design for the K-Menu, but provides an alternative to it, that is in fact more sophisticated than the XP-Start menu. + + + + + KBFX Development + + + KBFX version 0.4.9.3 is a complete rewrite of the old KBFX code eliminating all the negative points of the previous versions. + + + + At the start we had a list of end requirements for version 0.4.9.3 and we developed each of the feature units, testing each and every class as it was developed. + Apart from unit testing, the quality assurance managers periodically checked the quality of the product and the new releases that were made to the KBFX source repository. + The Q&A always checked the product against the requirements that we had set to maximize quality. + This way of development helped us to discover tons of bugs and fix them instantly, and so we debut with a rather clean and bug free KBFX. + + + + It was really helpful to see many users around the world checking out the development release of KBFX from SVN, reporting and posting problems encountered and helping to add more stability and compatibility between distributions. + Because of this, we know the supported platforms even before KBFX is 0.4.9.3 is released. + + + + KBFX has been tested to work with all GCC3.x and GCC4.x compilers. + It has been tested on systems running the distributions of Gentoo, Debian, Ubuntu, Suse, Slackware, Mango, Mandrake, PCLinuxOS and Fedora core. + Unfortunately, compiling on FreeBSD systems is yet to be tested, but we plan to port KBFX to FreeBSD and PcBSD. + + + + + KBFX Concepts + + + The KBFX Spinx Menu does not try to copy the WinXP Start menu. + It is based on a different approach and concept. + Following, the concepts of the traditional hierarchical structure and the new, flat indexed menu are described and compared, although the new menu structure is quite intuitive. + + +   + + + Hierarchical (Traditional) menu structure + + + The KDE K-Menu is a good example of a flat hierarchical menu. + It organizes application shortcuts in a tree link structure, where it can expand and open a submenu, with entries displayed based on some logical order. + This order may be task oriented, type oriented or just ordered alphabetically. + To find and launch an application, the user needs to navigate through the submenus, until he reaches the leaf (leaf node). + This approach is a direct adoption of the Microsoft Windows Start Menu. They introduced it with Windows 95/98/ME/NT/2000. This was certainly a huge usability advantage compared to the Windows 3.1 System with the program manager, but a lot has changed since these days. The Windows XP Start Menu is still based on this concept, although it is enhanced by the functionalities to pin applications to the left column and the automatically pinned most used applications. + But still, a user must move the mouse over the half screen, if his menu has many submenus with other submenus, and the application is not one of his most used or pinned applications. + + +   + + + + + Flat indexed menu structure + + + The KBFX Spinx Menu uses a different approach – the flat indexed menu. + With this type of menu it's very easy to navigate. + On the left hand side, you are given the application categories. + They can be task oriented or type oriented. On the right (middle) side of the menu, there are all the available applications listed that belong to the activated category. + The advantage is evident - the menu reduces the mouse paths, so you can locate your applications very fast. The user sees all the categories at a glance and he can pick it without having to travel along a long list until he finds the end leaf. + The speed of use is further enhanced by moving the most used and recently used applications on the top index, so that the most used applications are just one click away. + + + + + + + + Using KBFX + +   + + + Starting KBFX + + + The KBFX menu button is a starting point for the menu. It first has to be added to a kicker's panel. + To add the KBFX Menu to a panel, proceed as following: + + + + + + Right-click on the kicker's panel, on which you want to place the KBFX button. + + + + + + Select "Add Applet to Panel..." in the context menu. + + + + + + Select "KBFX Spinx". + + + + + + A tooltip appears "KBFX Spinx Added". + + + + + + If you move your mouse over the button, a tooltip appears (turned off + in the default configuration). + + + + + + If you want to skin the KBFX Start Button see this section. + + + + + + If you want to, you can now remove the K-Menu button and move the KBFX to the desired place on the panel. To open the menu, just click on the button. + + + + + + + Using the Spinx Menu + + + Here's a screenshot of the Spinx Menu + + + + + + + + Screenshot of the the Spinx Menu + + + + + + The Spinx Menu looks (depending on the skin) like the picture above. + It consists of following elements. + + + + The picture in the upper left corner is your "dude" icon. + + + + + + In the left and right columns of the menu, the plugins are displayed. + Click on a plugin section, to display it's content in the middle column. + If you click on the plugin's name you can contract its sections. + + + + + + In the middle column of the menu, the menu items of the selected plugin section are displayed. + Usually the menu items are grouped. + If you click on a group it will contract. + There is an option in the KBFX Configurator to start all these groups contracted. + + + You CAN drag and drop items FROM this part of the menu to your desktop, konqueror etc. + + + You CAN NOT drag and drop items TO this part of the menu. + + + + + + The arrows above and below the middle column are used to scroll up and down in the middle column. + + + + + + In the upper right corner, you find a search field, which can help you finding a menu item. + It is "search as you tipe" field. + If you want to clear the search (or the search term) double click on the search icon in the field. + If you type a command in the search field and press "Enter", the command will be started as if it has been typed in the "Run command..." dialog of K-menu. + + + + + + In the lower right corner, you find two buttons, one to log out and one to lock the desktop. + + + + + + + + How to configure KBFX + + + Here you can find how to use the KBFX Configurator. + + +   + + + <anchor id="kbfx_themes" />Choose the KBFX Theme + + + Here's a screenshot of the Themes Section of the KBFX Configurator + + + + + + + + Screenshot of the Themes Section of the KBFX Configurator + + + + + + + + Select default folder + + + Here you can select the folder in which you keep all your themes. + + + + + + + + The other options are self explanatory and have tooltips that can help you use them. + + +   + + + + <anchor id="kbfx_button" />Skin the KBFX Button + + + Here's a screenshot of the Start Button Section of the KBFX Configurator + + + + + + + + Screenshot of the Start Button Section of the KBFX Configurator + + + + + + Here you can skin the button. There are three fields to fill. + The first field is the field for the path to the picture for the default button state (Normal). + The second field is for the picture of the button in pressed state (Pressed). + The third field is for the picture of the button in hovered state (Hover). + You can drag and drop images on the "Preview" place or on the file selector field of each button. + The selected design can be seen in the preview area. Press the "Apply" button to apply the selected look. + + + + + You can skin the KBFX Start Button by selecting three images (Normal, Pressed and Hover) in any file manager, drag and drop them on the KBFX Start Button. In order this to work the images have to have in their name the respective state of the button, i.e. "pressed", "hover" or "normal". Here is an example of valid file names for the button: my_hover_dButton.png, my_pressed_dButton.png, my_normal_dButton.png . + + + + + + Button Fade Transition Effect + + + This allows you to turn ON or OFF the fade effect for the KBFX button. This effect makes transitions between the three images (normal, hover, pressed) animated. Here you can set the time for the fade effect in msec. This time should be greater than 20 msec and less than 1000 msec. If set to 0 the effect will be disabled. + + + + + +   + + + The other options are self explanatory and have tooltips that can help you use them. + + +   + + + + <anchor id="kbfx_fonts" />Set the Fonts of the KBFX Theme + + + Here's a screenshot of the Fonts Section of the KBFX Configurator + + + + + + + + Screenshot of the Fonts Section of the KBFX Configurator + + + + + + Here you can configure all the fonts (colors, points, style etc.) for the current theme. + + + + + + EXPORT KBFXFONTRC FILE + + + Use this button to export your font settings in order to share it with other KBFX users or if you want to create a theme by yourself (how to create your own themes you can find out in this chapter). + + + + + + + + + In the font settings for the tooltip only "Font Name" and "Font Color" are used. + The other settings like "Font Style" and "Font size" are not used. + This may change in future versions. + + + + + The other options are self explanatory and have tooltips that can help you use them. + + +   + + + + <anchor id="kbfx_layout" />Set the Layout of the KBFX Theme + + + Here's a screenshot of the Layout Section of the KBFX Configurator + + + + + + + + Screenshot of the Layout Section of the KBFX Configurator + + + + + + Here you can configure all the layout options for the current theme. + + + + + + Make it 2/3 Panels buttons + + + Use these buttons to force KBFX to auto-configure the current theme to the listed layouts. + + + + + + EXPORT KBFXLAYOUTRC FILE + + + Use this button to export your layout settings in order to share it with other KBFX users or if you want to create a theme by yourself (how to create your own themes you can find out in this chapter). + + + + + + + + The other options are self explanatory and have tooltips that can help you use them. + + +   + + + + <anchor id="kbfx_plugins" />Set the KBFX Plugins + + + Here's a screenshot of the Plugins Section of the KBFX Configurator + + + + + + + + Screenshot of the Plugins Section of the KBFX Configurator + + + + + + Here you can configure the plugins KBFX will use and where to place them - on the left or on the right column of the KBFX Menu. + + + + The other options are self explanatory and have tooltips that can help you use them. + + +   + + + + <anchor id="kbfx_tooltip" />Set the Tooltip of the KBFX Button + + + Here's a screenshot of the Tooltip Section of the KBFX Configurator + + + + + + + + Screenshot of the Tooltip Section of the KBFX Configurator + + + + + + Here you can select if the tooltip is on or off and if the tooltip animation is on or off. + In the field for the Tooltip text, you can change the tooltip text that will appear in the Tooltip balloon. + + + + The other options are self explanatory and have tooltips that can help you use them. + + +   + + + + <anchor id="kbfx_style" />Set the Style of the KBFX Menu + + + Here's a screenshot of the Menu Style Section of the KBFX Configurator + + + + + + + + Screenshot of the Menu Style Section of the KBFX Configurator + + + + + + Here you can select, whether you want to work with the KBFX SPINX or the KDE MENU. + You just have to select the according option and press the "Apply" button. + + + + + + + Questions and Answers + + + + + + I have a question that is not covered by this documentation. Where I can get an answer? + + + + + + You can search the KBFX Forum for an answer OR you can ask your question in the forum. + + + + + + + + How can I contact you live? + + + + + + Come to the #kbfx channel on irc.freenode.org + + + + + + + + + Authors, Credits and License + + + &kbfxconfigapp; + + +   + + + Program Copyright (c) 2007 KBFX Team. + + +   + + + KBFX Team Managers: + + + + Siraj Razick siraj@kdemail.net + + + + + + PhobosK phobosk@kdemail.net + + + + + + Mensur Zahirovic nookie@mail.kbfx.org + + + + + + + Nathanael Gogniat nathanael@mail.kbfx.org + + + + + +   + + + Translations: + + + + Ferenc Stelcz ferenc@stelcz.hu - Hungary (HU) + + + + + + Divilinux divilinux@mail.kbfx.org - Italy (IT) + + + + + + Lexus lexus@mail.kbfx.org - Bulgaria (BG) + + + + + + PhobosK phobosk@kdemail.net - Bulgaria (BG) + + + + + + Monkey 9 monkey9@iae.nl - Netherlands (NL) + + + + + +   + + + Contributors and Credits: + + + + Darwin M. Bautista djclue917@gmail.com - 001.patch + + + + + + Revaline C. Regendra regendra_mail7@yahoo.com - + Author of the Launch button in the default "KBFX Silk TTP" theme. + + + + Copyright (c) 2006 Revaline^Studio + + + Revaline's Launch Menu v4.0 + + + + + + + Petri Damstén damu@iki.fi - Author of the KMFFontChooser class. + KMediaFactory + + + + + +   + + + Documentation Copyright (c) 2007 PhobosK phobosk@mail.kbfx.org + + +   + + + + &underFDL; + +   + + &underGPL; + + + + Installation + + + How to obtain KBFX + + + KBFX can be downloaded from SourceForge project pages. + + + + Sometimes development versions are uploaded in a separate space on SourceForge. + + + + The SVN address of the KBFX project is on the KDE SVN servers. + + + + + Requirements + + + In order to successfully compile and use KBFX, you need at least &kde; 3.4.X and also you need: + + + + + + Cmake - min. version 2.4.2 + + + + + + KDE3 and Qt3 sources - header files/devel packages + + + + + + Strigi -this package is OPTIONAL and is used for files inline search + + + + +   + + + You can find the most recent KBFX's list of changes at KDE SVN. + + + + + Compilation and Installation + + + + + Unpack the sources of KBFX with (x.y.z-XXXXXXXX represents the version of + the KBFX package, for example 0.4.9.3-20070117): + + +> tar xjvf kbfx-x.y.z-XXXXXXXX.tar.bz2 + + + + + + Change into the new directory: + + + +> cd kbfx-x.y.z-XXXXXXXX/ + + + + + + Start the configuration and the compilation using the command: + + + +> ./build.sh + + + + +   + + + Note for Mandriva < 2007 users: + + + The build script (by default) enables the use of menudrake + instead of kmenuedit. + If you want to prevent this behavior then pass ONE of these options to the build script: --menudrake-off OR -m + + + +   + + + Other building options: + + + + + --prefix OR -p to install KBFX in a different than the default folder (default is KDE install folder) for example: + +> ./build.sh -p /home/user + + + + + + + --strigi OR -s to enable Strigi support in KBFX (default is no Strigi support) + + + + + + --kde4 OR -k to build KBFX for KDE4 (default is for KDE3) + + + + + + --verbose OR -v to make the build script give more verbose information + + + + + + --nocheck OR -n to make the build script not to check if an old KBFX version is installed (default is to check) + + + + + + + + Using <command>checkinstall</command> + + + checkinstall is an application used to build distribution specific packages from sources. + + + + checkinstall DOES NOT work with cmake correctly up to this moment. :( + + + + It can be used with additional commands in order to "work properly". + Here is the procedure to follow as user (NOT as ROOT) in order to obtain + the necessary distribution package. + + + + + + + x.y.z-XXXXXXXX represents the version of the KBFX package, in this example it is: 0.4.9.3-20070117 + + + + + + In the example here the version string is replaced only in the checkinstall command but you have to do that everywhere the "x.y.z-XXXXXXXX" string is met. + + + + + + + + +> cd /tmp +> tar xjvf kbfx-x.y.z-XXXXXXXX.tar.bz2 +> cd kbfx-x.y.z-XXXXXXXX/ +> mkdir -p build/package +> cd build +> export DESTDIR=/tmp/kbfx-x.y.z-XXXXXXXX/build/package +> cmake ../ -DCMAKE_INSTALL_PREFIX=`kde-config --prefix` +> make install DESTDIR=/tmp/kbfx-x.y.z-XXXXXXXX/build/package +> find package/|sed s#^package/#./# > installed_files.txt +> cd package/ +> su +> checkinstall -nodoc --pkgname="kbfx" --pkgversion="0.4.9.3" \ +--pkgrelease="20070117" --exclude="/" --include=../installed_files.txt \ +--pakdir=/tmp/kbfx-0.4.9.3-20070117 sleep 1 + + + + When ready, "checkinstall" will show you the folder where the prepared package is, like in this Mandriva Example: + + + +********************************************************************** + +Done. The new package has been saved to + +/tmp/kbfx-0.4.9.3-20070117/kbfx-0.4.9.3-20070117.i386.rpm +You can install it in your system anytime using: + +rpm -i kbfx-0.4.9.3-20070117.i386.rpm + +********************************************************************** + + + + Of course the best way to make RPM packages is to use the "kbfx.spec" file provided in the KBFX sources like described bellow. + + + + + RPM Building Instructions (Mandriva, Fedora, Suse) + + + If you prefer manipulate a RPM, you can build it with the following commands: + + + + + + Build the RPM: + + + +> rpmbuild -tb kbfx-x.y.z-XXXXXXXX.tar.bz2 + + + or (for Mandriva) + + +> rpmbuild --rebuild kbfx-x.y.z-XXXXXXXX-mdv20070.src.rpm + + + or (for Fedora) + + +> rpmbuild --rebuild kbfx-x.y.z-XXXXXXXX-FCx.src.rpm + + + or (for SuSe) + + +> rpmbuild --rebuild kbfx-x.y.z-XXXXXXXX-suseXXX.src.rpm + + + + + + If succeed, you will found the rpm in /usr/src/rpm/RPMS (for Mandriva) or /usr/src/redhat/RPMS (for Fedora) or /usr/src/packages/RPMS (for Suse) according to the platform you have. + + + + + + Install the rpm as usually by: + + + +> rpm -Uvh kbfx-x.y.z-XXXXXXXX.rpm + + + + +   + + + Building RPM from KBFX SVN versions: + + + + + Follow these commands in the sources directory: + + +> ./build.sh + + + + Answer "N" to the question if you want to install KBFX. + + + +> cd build +> make dist + + + + + + A file "kbfx-x.y.z-XXXXXXXX.tar.bz2" will be created in the build directory. + + + + + + Proceed with the steps described in 1., 2., 3. + + + + + + + + Gentoo users + + + In order to use the strigi engine in KBFX you have to do these steps: + + + + + + Copy the "strigi-X.X.X.ebuild" and the "kbfx-0.4.9.X.ebuild" (from the sources directory) to your local portage tree as needed OR use the "kbfx-0.4.9.X-portage-overlay.tar.bz2" + + + + + + Set the flag "strigi" for the kbfx ebuild + + + + + + Emerge "clucene" + + + + + + Emerge "kbfx" + + + + +   + + + There is a Layman overlay resource on the SourceForge SVN. + You can add it by this command: + + + +> layman -f -o https://kbfx.svn.sourceforge.net/svnroot/kbfx/layman/kbfx-overlay.xml \ + -a kbfx + + + + After you add the "kbfx" overlay you can use it as usual. + + + + + + SVN version + + + To download the latest development source, you need to go to KDE SVN and download it from there. The current SVN address of the repository is: svn://anonsvn.kde.org/home/kde/trunk/playground/base/kbfx_plasma + + + + Here are the instructions on how to get a copy of the SVN Repository: + + + + + + Install your distribution's package named "subversion" OR download and install it from subversion's homepage + + + + + + Create a folder where you will compile/install KBFX and enter in it. For example do this: + + + +> mkdir -p ~/usr/src/svn +> cd ~/usr/src/svn + + + + + + Checkout the SVN version of KBFX in this way and proceed as follows: + + + +> svn co svn://anonsvn.kde.org/home/kde/trunk/playground/base/kbfx_plasma +> cd kbfx_plasma + + + + + + Proceed with the compilation/installation of KBFX: + + + +> ./build.sh + + + + + + If you want always to have the latest version of KBFX you may leave the folder "~/usr/src/svn/kbfx_plasma" intact for future use. + When you want to update the source files of KBFX you just need to do svn up in this folder, delete the folder "~/usr/src/svn/kbfx_plasma/build" and start the ./build.sh script i.e: + + + +> cd ~/usr/src/svn/kbfx_plasma +> svn up +> rm -fR build +> ./build.sh + + + + + + + + How To + + + + <anchor id="howto-themes" />How to create themes for KBFX + + + So you want to create your own themes for KBFX 0.4.9.3? + + + + The guide is done in a simple manner and we hope that you will easily and + simply create themes for KBFX 0.4.9.3. If you don't like something in this + guide, please feel free to contact us at IRC on irc.freenode.org + on channel #kbfx + + + + + + + The values for Width and Height are only our suggested values. + You can use whatever values you feel are appropriate for your theme. + + + + + + If ANY of these images are missing KBFX will use the image with the + same name from the "default" theme. + + + + + + In order to be used by the Configurator and by KBFX, every theme for + 0.4.9.3 MUST HAVE a file in it's folder named "version-2" ! + + + + + +   + + + Images in KBFX + + + Here's a screenshot of all the images used in KBFX Menu + + + + + + + + Screenshot of all the images used in KBFX Menu + + + + + + This image is showing you all the images which are used in KBFX 0.4.9.3. + The most simple way to create a theme at this point is to take some of the images from the "default" theme and just change colors on some and see how that effects your menu. + + + + + DO NOT EVER CHANGE ANY IMAGE IN THE DEFAULT FOLDER! + + + + The images there are used as fallback when there is a missing image in your own theme. + We suggest rather to work with a copy folder of the default theme (the name of the folder containing your theme of course should be not "default" ;) ). + + + +   + + + + topbg.png + + + + + + + + + topbg.png + + + + + + This is an image that is at the top of the menu. + + + + Width = 504px and Height = 95px + + +   + + + + + dudebox.png + + + + + + + + + dudebox.png + + + + + + This is the background image where your personal image is displayed. + + + + Width = 95px and Height = 88px + + +   + + + + + menu_top_image_person.png + + + + + + + + + menu_top_image_person.png + + + + + + This image is used for theme's default personal image. + + + + Width = 48px and Height = 48px + + +   + + + + + find.png + + + + + + + + + find.png + + + + + + This is a small image displayed in the search field. + + + + Width = 22px and Height = 21px + + +   + + + + + rhstile.png + + + + + + + + + rhstile.png + + + + + + This is normal image displayed in categories. + + + + Width = 132px and Height = 23px + + +   + + + + + rhshovertile.png + + + + + + + + + rhshovertile.png + + + + + + This is a hover image for categories. Used as hover image for rhstile.png + + + + Width = 132px and Height = 23px + + +   + + + + + scrollnormal.png / scrollnormalbot.png + + + + + + + + + scrollnormal.png + + + + + + These images are used as top and bottom scrollbars. + + + + Width = 240px and Height = 10px + + +   + + + + + separator.png / indexseparator.png + + + + + + + + + separator.png + + + + + + These are the separator images which separate your different subcategories. + + + + Width = 240px and Height = 27px + + +   + + + + + tilenormal.png + + + + + + + + + tilenormal.png + + + + + + This is the normal image where your applications are showed. + + + + Width = 240px and Height = 46px + + +   + + + + + tilehover.png + + + + + + + + + tilehover.png + + + + + + This is the hover image where your applications are showed. + + + + Width = 240px and Height = 46px + + +   + + + + + listboxbg.png + + + + + + + + + listboxbg.png + + + + + + This is the background under the categories. + It can be viewed on description on both sides of the menu. + + + + Width = 108px and Height = 23px + + +   + + + + + middleboxbg.png + + + + + + + + + middleboxbg.png + + + + + + This is the background of the middle part of the menu. + + + + Width = 200px and Height = 270px + + +   + + + + + botbg.png + + + + + + + + + botbg.png + + + + + + This is the background image at the bottom of the menu. + + + + Width = 504px and Height = 38px + + +   + + + + + lock.png + + + + + + + + + lock.png + + + + + + This is the lock image. + + + + Width = 84px and Height = 38px + + +   + + + + + lockhover.png + + + + + + + + + lockhover.png + + + + + + This is the lock hover image. + + + + Width = 84px and Height = 38px + + +   + + + + + logout.png + + + + + + + + + logout.png + + + + + + This is the logout image. + + + + Width = 84px and Height = 38px + + +   + + + + + logouthover.png + + + + + + + + + logouthover.png + + + + + + This is the logout hover image. + + + + Width = 84px and Height = 38px + + +   + + + + + mask.png + + + + + + + + + mask.png + + + + + + This is deciding what size your menu will have when users install it and which will be the transparent parts of the menu (through the alpha mask of the png image). + Of course the size can be controlled later by the configuration of KBFX. + + + + Width = 504px and Height = 513px + + +   + + + + + logo.png + + + + + + + + + logo.png + + + + + + This is used as a theme's or author's logo shown in the Information box of the KBFX Configurator. + You can put whatever image you want and it will be scaled to 100px width by 100px height. + + + + Width = 100px and Height = 100px + + +   + + + + + preview.png + + + + + + + + + preview.png + + + + + + This should be a snapshot of the working KBFX theme. + It is used in the configuration application in order the user to see what the theme will look like. + + + + Width = 170px and Height = 205px + + +   + + + + + normal.png / hover.png / pressed.png + + + + + + + + + normal.png + + + + + + + + hover.png + + + + + + + + pressed.png + + + + + + These are the KBFX Buttons for the kicker panel that are used in the theme. + Width and Height - as you like, but preferably Height not to be too much. + + +   + + + + + + More information can be found on our homepage here + + +   + + + + "kbfxfontrc" and "kbfxlayoutrc" files + + + Every theme MAY have two configuration files named: + + + + + + kbfxfontrc - configures the fonts properties that the theme uses. + + + + + + kbfxlayoutrc - configures the layout of the theme, the KBFX button and some other properties of the theme. + + + + + + + If one or both of these files don't exist, KBFX internal configuration + options will be used for fonts and layout. + All the properties and values are separated between different Sections + in the way showed below: + + + + [Section] + property = value + + + + When you want to prepare a theme, have in mind that every change that you make in the "KBFX Configurator" is kept in files in your home KDE directory. + + + + Usually these files are in the folder ~/.kde/share/apps/kbfx/themerc + and are named: + + + + + + THEMENAME_layoutrc + + + + + + THEMENAME_fontrc + + + + + + + So if you want to ship your theme settings from the "KBFX Configurator", the best + thing to do is to use the buttons: + "EXPORT KBFXFONTRC FILE" ("Fonts" section of the Configurator) + and + "EXPORT KBFXLAYOUTRC FILE" ("Layout section" of the Configurator) + and put the exported files in your theme folder. + + + + + + + Pay close attention to the case of the properties and Sections names + because the configuration is CASE SENSITIVE! + + + + + + The order of the sections in the file is not important! + + + + + + Have in mind that the Layout of the theme also depends on the sizes of the images! + + + + + +   + + + File kbfxfontrc + + + + + + It's best the colors to be represented in RGB format. + + + + + + Font Properties should constrain to QFont class representation. + + + + + + The values bellow are the default ones. + + + + + + + [Fonts] + TooltipText=0,0,0 + TooltipTextFont=Arial,8,-1,5,50,0,0,0,0,0 + ApplicationText=0,0,0 + ApplicationTextFont=Arial,8,-1,5,50,0,0,0,0,0 + CommentText=128,125,0 + CommentTextFont=Arial,8,-1,5,50,0,0,0,0,0 + GroupText=0,0,0 + GroupTextFont=Arial,8,-1,5,50,0,0,0,0,0 + UserName=255,255,255 + UserNameFont=Arial,10,-1,5,75,0,0,0,0,0 + SeparatorColor=0,0,0 + SeparatorFont=Arial,8,-1,5,50,0,0,0,0,0 + PluginColor=0,0,0 + PluginFont=Arial,8,-1,5,50,0,0,0,0,0 + LineColor=255,220,125 + # This is if the font when you hover on an item will be bold + HoverBold = false + + +   + + + + File kbfxlayoutrc + + + + + + The values bellow are the default ones. + + + + + + + [KbfxButton] + # Time in msec for which the button + # to fade in/out + FadeTime=75 + # The three properties below describe the + # paths to the theme's buttons. + # KBFX uses the normal.png/hover.png/pressed.png + # that are in the theme's folder by default. + # So we recommend NOT to use the below three + # properties! + Normal = KBFX Normal Button Full Path + Hover = KBFX Hover Button Full Path + Press = KBFX Pressed Button Full Path + + [TopBar] + # Face Position X + DudeX=-1 + # Face Position Y + DudeY=-1 + # Face Box Height + FaceH=64 + # Face Box Width + FaceW=65 + # Face Box Position X + FaceX=27 + # Face Box Position Y + FaceY=8 + # User Name Position X + UserNameX=130 + # User Name Position Y + UserNameY=32 + # Hide User Name + DisableUserName=false + # Top Bar Height + Height=95 + # THE PROPERTIES BELOW ARE NOT USED FOR NOW + # Top Bar Width + Width=504 + # Top Bar Position X + X=0 + # Top Bar Position Y + Y=0 + + [BottomBar] + # Bottom Bar Height + Height=38 + # THE PROPERTIES BELOW ARE NOT USED FOR NOW + # Bottom Bar Width + Width=504 + # Bottom Bar Position X + X=0 + # Bottom Bar Position Y + Y=428 + + [Scrollbars] + # THIS SECTION IS NOT USED FOR NOW + # Bottom Scroll Bar Position X + ScrollBarBotX=108 + # Bottom Scroll Bar Position Y + ScrollBarBotY=95 + # Top Scroll Bar Position X + ScrollBarTopX=108 + # Top Scroll Bar Position Y + ScrollBarTopY=95 + + [ListBox] + # List Box Position X + X=0 + # List Box Position Y + Y=95 + # List Box Width + Width=132 + # THE PROPERTIES BELOW ARE NOT USED FOR NOW + # List Box Height + Height=275 + + [SearchBox] + # Search Box Height + Height=22 + # Search Box Width + Width=240 + # Search Box Position X + X=130 + # Search Box Position Y + Y=48 + + [ItemView] + # Item Position X + X=132 + # Item Position Y + Y=95 + # Item Width + Width=240 + # THE PROPERTIES BELOW ARE NOT USED FOR NOW + # Item Height + Height=275 + + [ItemProperties] + # Comment Margin in Item + CommentMargin=66 + # Icon Size in Item + IconSize=32 + # No Comments in Item + NoComments=false + + [ToolBar] + # THIS SECTION IS NOT USED FOR NOW + # Tool Bar Button Normal Size + ButtonNormalSize=48 + # Tool Bar Button Pressed Size + ButtonPressedSize=48 + + [MainMenu] + # Main Menu Height + UserMenuHeight=513 + # Main Menu Width + UserMenuWidth=504 + # Contracted Menues + ContractedMenu=false + + + +   + + + + + + "version-2" file + + + + + + This file is OBLIGATORY to exist, though it can be empty. + It is used to designate that the theme is in the new format and the properties that are in the file are used in the KBFX Configurator for showing the user some info about the theme. + + + + + + The values in this file cannot be overwritten by the KBFX Configurator. + + + + + + If existing, the file should contain information about the theme's version, author's name, author's email and a homepage for the theme. + + + + + + The unspecified fields are replaced with the string - "Not Specified". + + + + + + The values bellow are self explanatory and are just an example. + + + + + + + [ThemeGeneral] + ThemeVersion=0.51 + AuthorName=Nookie + AuthorEmail=nookie@no_spam.org + Homepage=http://www.kbfx.org + + +   + + + Now we wish you all good luck when creating themes. + We are looking forward to all your good looking themes out there for the KBFX! + + +   + + + + + How to create a ".kbfxtheme" file + + + The ".kbfxtheme" file is a simple archive file (.tar.gz or .tar.bz2) that should contain at least these elements: + + + + + + One or more theme folders with all the necessary images/files inside. + Have in mind that the name of the theme is the name of the folder. + + + + + + In the theme(s) folder(s) there should be an image named "preview.png" that serves as a live preview of the look of the theme. + + + + + + In the theme(s) folder(s) there should be a file named "version-2" + + + + + + The extension of the archive should be ".kbfxtheme" + + + + + + You can create ".kbfxtheme" file following these instructions (there is an option in Konqueror's rightclick "Actions" menu for preparing KBFX Theme Package OR you can create the ".kbfxtheme" file manually as described bellow): + + + + + + Create a folder with a name that is identical to the name you want for your theme. + + + + + + Put the necessary images/files inside it (see the above instructions for the images part). + + + + + + Create an archive of the folder (with ark/tar etc). + + + + + + Rename the archive file to ".kbfxtheme" and you are ready. + + + + + + + How to help us out for KBFX + + + You can help us for the KBFX releases with the translation of the interface. + For this purpose please download the kbfxconfigapp.pot file from SourceForge and use KBabel or poEdit to make the translation. + + + + Next send the .po file to my mail phobosk@mail.kbfx.org. + + + + + Another way to get a .pot file is to use the command: make package-messages just after the configuration of the compilation process is done. + + + +   + + + Thanks in advance for this help. + + + + + + Useful links + + + KBFX Homepage + + + + KBFX SourceForge project page + + + + KBFX Releases + + + + KBFX Forum + + + + KBFX Bugs + + +&documentation.index; + + + + diff --git a/images/CMakeLists.txt b/images/CMakeLists.txt new file mode 100644 index 0000000..6482f38 --- /dev/null +++ b/images/CMakeLists.txt @@ -0,0 +1,5 @@ +IF (NOT USE_KDE4) + KDE3_INSTALL_ICONS(hicolor) +ELSE (NOT USE_KDE4) + KDE4_INSTALL_ICONS(hicolor) +ENDIF (NOT USE_KDE4) diff --git a/images/hi128-app-kbfx.png b/images/hi128-app-kbfx.png new file mode 100644 index 0000000000000000000000000000000000000000..3986198d80ac43b6fe41fa52d06655b42278a8fa GIT binary patch literal 22402 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 FV1k3vtyTa4 literal 0 HcmV?d00001 diff --git a/images/hi16-app-kbfxconfigapp.png b/images/hi16-app-kbfxconfigapp.png new file mode 100644 index 0000000000000000000000000000000000000000..864d09c645b61ad7e4995dc4d3b0a670eaa98964 GIT binary patch literal 871 zcmV-t1DO1YP)cL_t(IjcwCS zXdGn##_|8WGqc&l<#dYWqoygw ze!F^&NH&oThi3;{lu8brrpJLkNvU*?BSRAHm#NfT%Jl%#6enkAXNN4U^@Iu(KVJG4 zJ1&z<`%Ij9ljk0{SiH8%PF=B6ZqxTt2bpw>t2a!9DR^uU`3 zdWdA5FXk?i?$7Yky2O)U>NE>i;PQ=-TlH={8FFZ-8^bWNmQpH?q8KSPQ4G)Q@8P@U z0(VO5WHV3k(eyDMOD8$^%@*s9$x6A7iZrnv1&FO62sV2MdI^m#N>#}R?~HOdw~up| z)=1elxqWRgLOwi|n-NXAA3S7QkV&%5P zmlmKwhiDzMbW@W~C3yMy49%t+0E?o(zkj9CXe_=x{T6oSY5sBtIdfr`wZFSKd|(iO z`+E_mFDgF!y@x0JQoM3xh*nE}na}4-hSr*;rKOQXBC%X_Dm@>6I!_dYh*)FUaPSF> zjol=M-ATe0yng%;gnlsyf)^eD01FEX$8FpGI#5yXFUzZJ6z&rtFbosR6y!1kjAZ-p zJ+~MH!E5<^e)W+v&Ck#0fU`n~lcp)my6Y1vg>4x$8g5%k`Bfap@8$FP(*M2@!1sOT x=H`Z!QYVyB*&qnwIF4@{hOsy^Gqb~g`UhUw$N&#>?L`0p002ovPDHLkV1nS6p!NU& literal 0 HcmV?d00001 diff --git a/images/hi32-app-kbfxconfigapp.png b/images/hi32-app-kbfxconfigapp.png new file mode 100644 index 0000000000000000000000000000000000000000..7f71e8e10446d2b38726db9dcc79b80a68674401 GIT binary patch literal 2523 zcmV<12_*K3P)L_t(og`JmM zj9t}z#((Rw_c>?InTr|QV~@u(#>SyIQDQEJMwJ~A$D~MvR!QxUwiwBMsQS>VSY?o! zmlUa$TJ-@DL|dgrm4bspE7b(1v48@yaMD07jvJVoV%Ih^<2f^DX3lM&eOb3Y4C4@D z0(41BTH0Id|NZpeTWfuv2qExM#`*K-RgxqdthHm#xj}2Kcg`(&?=SWD_qTWN-t9k1 zJ@H`xE?l?}TWj}+5Dt3pZ};AhhY+N54(A-k7>qGRQ50v3qIj+-iYEsL2Y<46@7@oD z`IP{3b934l^JU=Afn7of0M_<+?{Usyt;LvvJTJ(yj5JMMmSry&Me()q@$pl8_Uw6I zk@p3dnVH!J{Jjw34k@LOQX-`wguwFBGL3~Lyn_G;85mqQNUc^OO*6XPE=kfONfMJ~ z+248Zzk1I-_jErr!0hbor-cwtNh!yaQfRGNT3lrMzozN55-NRFYPEi%I0hjooT1xG z$?}|Pwak{$4G0lvHk))hU3$IVDQoSa!-o&geIUTx+}x*y5YK3>hm}$|YdH1NNo?WS zw0Sd9Nnq_$tWFPj1YQW72((%qL@-Qj9iiE5(rUFylH|0t_Rb?mj?BL=z}(#2gp~3X zt@W5viuTG1FMjuVwr$@|9LKEw0)Y@#8Lj{X@O}+I5TwM1z|!I(+b2e7w_7xuEs`Yp z4hXqF%3SDdj&XrB=n8D?ITWWAK_`&RuL!tyU?Q%V@3l=XpN)?haf5@ZKMiQr@Ap##zhMzaD3NVjS-Z zoXKz|#n~R#^jK6);phAy4?^5Jl^1RE=5y@aF@axx= zxM8y(%{pXRLY5^|b&r84B~5x{X-Y56DOIXmnpvV&tD=;uh7cyFr>B1o;Jx23gxDpe zWO4p7moLtOw-i~IBJ0wpQ)+R>aG#;q>+sg>GS21%Uodu!WTfWkCLOxnHiPAYn)dlAp}xNUU}gq`fD|Moi@F0i?rKh=JF!9 z?kMxg@tB&<`Jan*mYXfGDZ-|d$Y?d2^g1nejYvsl$80 z#D;#9>w#N6DSXjoX~nDpD2*v{j0L3>LWtduKmNGX-utZ~1PO5Ie=pHqYSCZuMAG6^ zK_I7R3SNBmET7+#<7->ETo0_QEU~x*g$3&Z&PJ4+rN}lAX~D&Xf*+o3lBy~qDxq~m zmZj9|EtHZ7Ax1l$j?y87LGL{wc-qSytPMEpan@p$MPLcS^4Pzf=GEy1wAP%S3seU; zQdlT#z!-_5#KPqsfAlvgBO5FH^pdA1D!5pnB2O=GGc#A`v$ySJFqQ}*2E6xDJLjB~ z67N?}IA_4>fYAY@2k&sg;e_YpnYS?xatl#qg}#9e+;Q_5hY##vcpzr#`%C=wQ+3W< z%JI5{jRi(SJ89F)3Zx7K1Z$TmfOgI;ODS>AQ5&dYte~(GWd!46{R~|*z=2ywd3CzZ zOQ+{ZQ-g7^k~I0N-@cwNer5t>0GD&utu?j`!|QM76b>GGxG&D>PXVQxp*ofBVg~mQgKhzO;86J4Od+bv#LCS6>7RJ_nbBH-H0R&-NIl zBuYu7fUO$`h$FDp5<+j3T5JE`=5+MWu56*GZ4P)H&@vYPs8YD@AG3HxZ z>pwVp^l0{Oy{p>tr=Na$6YxY7Mf>A8rmwF;ksE&S<7v+P_XS#=6rnXzz5^3hL&{LC z%&%?V%&wiIq-jF4*(S>}XN-9)j^oMu@4r8Luh#npljFyaSBx78y-7$?D`PG zBydOwQCoW+LcsggSZ1xoIsdM;n{&?nqm=UN4?OTd<5$)HP~r64xpSO6d2+;Bd#CsQ zfOBrQ_kPqlH{hJ}-usmh!o?86YaxUaQ53y+^yty6MzQ}FzCONE002ovPDHLkV1jjf+m`?U literal 0 HcmV?d00001 diff --git a/kbfx-0.4.9.3.1.ebuild b/kbfx-0.4.9.3.1.ebuild new file mode 100644 index 0000000..f8dbb73 --- /dev/null +++ b/kbfx-0.4.9.3.1.ebuild @@ -0,0 +1,31 @@ +# Copyright 1999-2004 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header + +inherit kde eutils +need-kde 3.3 + +MY_PN="${PN}-0.4.9.3.1" +S="${WORKDIR}/${MY_PN}" + +DESCRIPTION="KDE alternative K-Menu" +HOMEPAGE="http://www.kbfx.org/" +SRC_URI="mirror://sourceforge/${PN}/${MY_PN}.tar.bz2" + +SLOT="0" +LICENSE="GPL-2" +KEYWORDS="x86 ~ppc ~amd64" +IUSE="strigi" + +DEPEND=">=dev-util/cmake-2.4.2 + strigi? ( kde-misc/strigi )" + +export DESTDIR=${D} + +src_compile() { + cd ${S} + cmake \ + -DCMAKE_INSTALL_PREFIX:PATH=${KDEDIR} \ + -DUSE_STRIGI:BOOL=$( use strigi && echo ON || echo OFF ) \ + . || die +} diff --git a/kbfx-9999.ebuild b/kbfx-9999.ebuild new file mode 100644 index 0000000..6a8e498 --- /dev/null +++ b/kbfx-9999.ebuild @@ -0,0 +1,27 @@ +# Copyright 1999-2004 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header + +inherit kde eutils subversion +need-kde 3.3 + +DESCRIPTION="The SVN Version of the KDE alternative K-Menu KBFX" +HOMEPAGE="http://www.kbfx.org/" +ESVN_REPO_URI="svn://anonsvn.kde.org/home/kde/trunk/playground/base/kbfx_plasma" + +SLOT="0" +LICENSE="GPL-2" +KEYWORDS="~x86 ~ppc ~amd64" +IUSE="strigi" + +DEPEND=">=dev-util/cmake-2.4.2 + strigi? ( kde-misc/strigi )" + +export DESTDIR=${D} + +src_compile() { + cmake \ + -DCMAKE_INSTALL_PREFIX:PATH=${KDEDIR} \ + -DUSE_STRIGI:BOOL=$( use strigi && echo ON || echo OFF ) \ + . || die +} diff --git a/kbfx-svn.ebuild.in b/kbfx-svn.ebuild.in new file mode 100644 index 0000000..6a8e498 --- /dev/null +++ b/kbfx-svn.ebuild.in @@ -0,0 +1,27 @@ +# Copyright 1999-2004 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header + +inherit kde eutils subversion +need-kde 3.3 + +DESCRIPTION="The SVN Version of the KDE alternative K-Menu KBFX" +HOMEPAGE="http://www.kbfx.org/" +ESVN_REPO_URI="svn://anonsvn.kde.org/home/kde/trunk/playground/base/kbfx_plasma" + +SLOT="0" +LICENSE="GPL-2" +KEYWORDS="~x86 ~ppc ~amd64" +IUSE="strigi" + +DEPEND=">=dev-util/cmake-2.4.2 + strigi? ( kde-misc/strigi )" + +export DESTDIR=${D} + +src_compile() { + cmake \ + -DCMAKE_INSTALL_PREFIX:PATH=${KDEDIR} \ + -DUSE_STRIGI:BOOL=$( use strigi && echo ON || echo OFF ) \ + . || die +} diff --git a/kbfx.ebuild.in b/kbfx.ebuild.in new file mode 100644 index 0000000..2eb54c3 --- /dev/null +++ b/kbfx.ebuild.in @@ -0,0 +1,31 @@ +# Copyright 1999-2004 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header + +inherit kde eutils +need-kde 3.3 + +MY_PN="${PN}-@VERSION@" +S="${WORKDIR}/${MY_PN}" + +DESCRIPTION="KDE alternative K-Menu" +HOMEPAGE="http://www.kbfx.org/" +SRC_URI="mirror://sourceforge/${PN}/${MY_PN}.tar.bz2" + +SLOT="0" +LICENSE="GPL-2" +KEYWORDS="@GENTOO_KEYWORDS@" +IUSE="strigi" + +DEPEND=">=dev-util/cmake-2.4.2 + strigi? ( kde-misc/strigi )" + +export DESTDIR=${D} + +src_compile() { + cd ${S} + cmake \ + -DCMAKE_INSTALL_PREFIX:PATH=${KDEDIR} \ + -DUSE_STRIGI:BOOL=$( use strigi && echo ON || echo OFF ) \ + . || die +} diff --git a/kbfx.spec b/kbfx.spec new file mode 100644 index 0000000..4916ec5 --- /dev/null +++ b/kbfx.spec @@ -0,0 +1,255 @@ +%define name kbfx +%define version 0.4.9.3.1 +%define kbfx_release 1 +%define is_stable 1 +%define debug_package %{nil} + +%define is_unknown %(test -e /etc/mandrake-release -o -e /etc/SuSE-release -o -e /etc/fedora-release -o -e /etc/pclinuxos-release && echo 0 || echo 1) +%define is_suse %(test -e /etc/SuSE-release && echo 1 || echo 0) +%define is_fedora %(test -e /etc/fedora-release && echo 1 || echo 0) +%define is_mandrake %(test -e /etc/mandrake-release && echo 1 || echo 0) +%define is_pclinuxos %(test -e /etc/pclinuxos-release && echo 1 || echo 0) + +%if %{is_suse} +%define prefix /opt/kde3 +Group: System/GUI/KDE +Release: %{kbfx_release}.suse%(echo "%{suse_version}" | %__sed -e 's/.$//') +Requires: kdelibs3 +BuildRequires: kdelibs3-devel kdebase3-devel +BuildRequires: cmake, automake, libtool +BuildRequires: glibc-devel, libstdc++-devel +%endif + +%if %{is_fedora} +%define fedora_version %(rpm -q --queryformat '%{VERSION}' fedora-release) +%define fedora_vernum %(echo "%{fedora_version}" | tr -d '.') +%define prefix /usr +Group: System/GUI/KDE +Release: %{kbfx_release}.FC%{fedora_vernum} +Requires: kdebase +BuildRequires: kdebase-devel qt-devel +BuildRequires: cmake, automake, libtool +BuildRequires: glibc-devel, libstdc++-devel +%endif + +%if %{is_mandrake} +%if %{is_pclinuxos} < 1 +%define prefix /usr +Group: Graphical desktop/KDE +Release: %{kbfx_release}.mdv%(echo "%{mdkversion}" | %__sed -e 's/.$//') +Requires: kdebase +BuildRequires: kdebase-devel +BuildRequires: cmake, automake, libtool +BuildRequires: glibc-devel, libstdc++-devel +%endif +%endif + +%if %{is_pclinuxos} +%define prefix /usr +Group: Graphical desktop/KDE +Release: %{kbfx_release}.pclos%{product_version} +Requires: kdelibs +BuildRequires: cmake, automake, libtool +BuildRequires: kdelibs-devel +%endif + +%if %{is_unknown} +%define prefix %(kde-config --prefix) +Group: Graphical desktop/KDE +Release: %{kbfx_release} +BuildRequires: cmake, automake, libtool +%endif + + +Name: %{name} +Version: %{version} +License: GPL +URL: http://www.kbfx.org +Summary: An alternative to the classical K-Menu button and it's menu. +BuildRoot: %{_tmppath}/build-%{name}-%{version}-root +Packager: PhobosK +Vendor: KBFX TEAM +Provides: kbfx + +%if %{is_stable} < 1 +Source: %{name}-%{version}-%{kbfx_release}.tar.bz2 +%else +Source: %{name}-%{version}.tar.bz2 +%endif + +%description +KBFX is an alternative to the classical K-Menu button and it's menu. +It improves the user experience by enabling the user to set a bigger (and thus more visible) start button and by finally replacing the Win95-like K-Menu with the Spinx bar. +If you still want the old menu, because you're used to it, it is still available as an option in kbfx. + +Main features: + Spinx Bar has 6 Basic Functionalities. + 1.Selecting an Application Group + 2.Selecting an Application + 3.Type and locate an Application + 4.Logout of the Desktop + 5.Lock the Desktop + 6.Launch KBFX settings manager + 7.Scroll up and down the application list + +Extra features: + 1.Double buffered Widgets to minimize flicker. + 2.Animated scroll bars + 3.New Tooltip + 4.Gif/Mng File Support + 5.New Control Manager + +%prep + +%if %{is_stable} < 1 +%setup -n %{name}-%{version}-%{kbfx_release} +%else +%setup -n %{name}-%{version} +%endif + +rm -Rf build +mkdir build +cd build +export DESTDIR=${RPM_BUILD_ROOT} +cmake ../ -DCMAKE_INSTALL_PREFIX=%{prefix} + +%build +cd build + +%install +cd build +[ "${RPM_BUILD_ROOT}" != "/" ] && [ -d ${RPM_BUILD_ROOT} ] && rm -Rf ${RPM_BUILD_ROOT}; +export DESTDIR=${RPM_BUILD_ROOT} +make install + +%if %{is_mandrake} +mkdir -p ${RPM_BUILD_ROOT}%{_menudir} +cat << EOF > ${RPM_BUILD_ROOT}%{_menudir}/%{name} +?package(%{name}): needs="kde" kde_filename="kbfxconfig" \ +section="System/Configuration/Other" title="KBFX Configurator" icon="kbfxconfigapp" \ +command="kbfxconfigapp" longtitle="KBFX Configuration Utility" \ +kde_opt="\\\\nEncoding=UTF-8\\\\nType=Application" +EOF +%endif + +%post +if [ -x /usr/bin/update-menus ]; then /usr/bin/update-menus || true ; fi +/sbin/ldconfig + +%postun +if [ "$1" = "0" -a -x /usr/bin/update-menus ]; then /usr/bin/update-menus || true ; fi +/sbin/ldconfig + + +%clean +[ "${RPM_BUILD_ROOT}" != "/" ] && [ -d ${RPM_BUILD_ROOT} ] && rm -Rf ${RPM_BUILD_ROOT}; + +%files +%defattr(-, root, root) +%{prefix}/* + +%changelog + +* Wed May 16 2007 0.4.9.3.1 + - CHANGED layout and font configfile specs + - UPDATED help documentation + - ADDED fade transition effect on the KBFX Button + - ADDED install guides for using checkinstall + - ADDED Hungarian translation (thanks to Ferenc Stelcz for it) + - ADDED option to watch for KDE global changes like new installed applications + - ADDED option for Theme Info + - ADDED resizable configuration dialogs + - ADDED drag&drop hover, pressed and normal images over the KBFX button + - ADDED tooltip support for the KBFX button + - ADDED switch between KBFX and K Menu + - ADDED new two panel skin - "2panels" + - ADDED configurable middle background - middleboxbg.png + - ADDED fonts support in every part of the menu + - ADDED layout support in the KBFX Configurator + - ADDED support for the new versions of strigi + - ADDED support for use of strigi in Gentoo + - ADDED support for SVN version in Gentoo + - ADDED support for PCLinuxOS rpm build (thanks to @PaGal and @tom777 for the testing) + - ADDED support for future KDE4 (part 1) + - ADDED uninstall option for "build.sh" script + - FIXED cmake uninstall + - FIXED RPM .la issues + - FIXED some major bugs + - REMOVED Water effect (too much CPU time consuming and not a favorite one for our users) + +* Wed Jan 17 2007 0.4.9.3-20070117 + - Initial Release of the 0.4.9.3 Series - KBFX Silk (0.4.9.3) + - New Build system (cmake) + - Re-write of the data backend + - Re-write of the GUI + - Totally new theme + - Improved configuration dialog + +* Fri Nov 17 2006 0.4.9.2rc4 + - CHANGED some aspects of autoconf/automake behaviour + - CHANGED "Toolbar Resize" behaviour - turned off by default so kicker doesn't change its size anymore + - ADDED support for Mandriva 2007 compilation (no menudrake there by default) + - FIXED Searchbar behaviour (thanks @gropiuskalle) + - FIXED some minor bugs + +* Sun Nov 05 2006 0.4.9.2rc3 + - ADDED support for preparing .kbfxtheme files in konqueror (look the explanation in HOWTO file) + - ADDED "--prepare" commandline option to pack existing KBFX Skin Folders to .kbfxtheme files + - ADDED "Default Theme's Personal Image" to the "KBFX Configurator Application" + - ADDED "Toolbar Resize" option to the "KBFX Configurator Application" for the toolbar where the KBFX Button resides + - ADDED it, bg and nl translations + - FIXED some minor bugs + +* Mon Sep 19 2006 0.4.9.2rc2 + - CHANGED "KBFX Configurator Application" - rewritten from scratch and is no more part of "kcontrol" + - CHANGED "Tooltip Animation" behaviour - turned off by default + - ADDED new Default Theme + - ADDED fonts configuration option to the "KBFX Configurator Application" + - ADDED Install/Delete Themes to the "KBFX Configurator Application" + - ADDED support for .kbfxtheme files in konqueror (look the explanation in HOWTO file) + - ADDED possibility to change "dude" image to the "KBFX Configurator Application" + - ADDED Free-BSD Support + - FIXED font alignment problems + - FIXED long applications name problem + - FIXED some memory leaks + - FIXED some minor bugs + +* Sun Jun 18 2006 0.4.9.2-20060708cvs + - UPDATED make system + +* Sun Jun 11 2006 0.4.9.2-20060611cvs + - ADDED KNOWN_BUGS file in the project documents + - ADDED PC-BSD Support + - ADDED Drag and Drop Support + - FIXED a bug with showing icons in "Recently Used" items + - FIXED a bug with the placement of ".face.icon" (thanks @Nucc) + - Flicker Free KBFX Button + - Flicker Free KBFX SPINX Menu TOP + - Better scrolling + + +* Sun May 28 2006 0.4.9.2-20060528cvs + - ADDED suport for Fedora rpm + - ADDED an option to disable tooltip (see HOWTO file) + - FIXED a problem with building SUSE rpm + + +* Wed May 10 2006 0.4.9.2rc1 + - ADDED suport for SUSE rpm + - ADDED support for Buttons with Drop shadows + - ADDED Font settings as part of the Theme itself + - ADDED Grouping header for each application group and sub groups + - ADDED Kiosk mode support + - ADDED Handling of submenus + - FIXED a problem with make + - FIXED make system for all distributions + - Better support for Mandriva distribution + - More applications for the menu + + +* Sun Apr 16 2006 0.4.9.1-1 + Initial rpm release + - FIXED Kbfx configuration + - FIXED Slack 1.9 automake and compilation + - FIXED /tmp/.kbfx.html + diff --git a/kbfx.spec.in b/kbfx.spec.in new file mode 100644 index 0000000..030dab1 --- /dev/null +++ b/kbfx.spec.in @@ -0,0 +1,255 @@ +%define name @APPLICATION_NAME@ +%define version @APPLICATION_MAIN_VERSION@@APPLICATION_STABLE_RELEASE@ +%define kbfx_release @LIB_SUB_RELEASE@ +%define is_stable @APPLICATION_STABLE@ +%define debug_package %{nil} + +%define is_unknown %(test -e /etc/mandrake-release -o -e /etc/SuSE-release -o -e /etc/fedora-release -o -e /etc/pclinuxos-release && echo 0 || echo 1) +%define is_suse %(test -e /etc/SuSE-release && echo 1 || echo 0) +%define is_fedora %(test -e /etc/fedora-release && echo 1 || echo 0) +%define is_mandrake %(test -e /etc/mandrake-release && echo 1 || echo 0) +%define is_pclinuxos %(test -e /etc/pclinuxos-release && echo 1 || echo 0) + +%if %{is_suse} +%define prefix /opt/kde3 +Group: System/GUI/KDE +Release: %{kbfx_release}.suse%(echo "%{suse_version}" | %__sed -e 's/.$//') +Requires: kdelibs3 +BuildRequires: kdelibs3-devel kdebase3-devel +BuildRequires: cmake, automake, libtool +BuildRequires: glibc-devel, libstdc++-devel +%endif + +%if %{is_fedora} +%define fedora_version %(rpm -q --queryformat '%{VERSION}' fedora-release) +%define fedora_vernum %(echo "%{fedora_version}" | tr -d '.') +%define prefix /usr +Group: System/GUI/KDE +Release: %{kbfx_release}.FC%{fedora_vernum} +Requires: kdebase +BuildRequires: kdebase-devel qt-devel +BuildRequires: cmake, automake, libtool +BuildRequires: glibc-devel, libstdc++-devel +%endif + +%if %{is_mandrake} +%if %{is_pclinuxos} < 1 +%define prefix /usr +Group: Graphical desktop/KDE +Release: %{kbfx_release}.mdv%(echo "%{mdkversion}" | %__sed -e 's/.$//') +Requires: kdebase +BuildRequires: kdebase-devel +BuildRequires: cmake, automake, libtool +BuildRequires: glibc-devel, libstdc++-devel +%endif +%endif + +%if %{is_pclinuxos} +%define prefix /usr +Group: Graphical desktop/KDE +Release: %{kbfx_release}.pclos%{product_version} +Requires: kdelibs +BuildRequires: cmake, automake, libtool +BuildRequires: kdelibs-devel +%endif + +%if %{is_unknown} +%define prefix %(kde-config --prefix) +Group: Graphical desktop/KDE +Release: %{kbfx_release} +BuildRequires: cmake, automake, libtool +%endif + + +Name: %{name} +Version: %{version} +License: GPL +URL: http://www.kbfx.org +Summary: An alternative to the classical K-Menu button and it's menu. +BuildRoot: %{_tmppath}/build-%{name}-%{version}-root +Packager: PhobosK +Vendor: KBFX TEAM +Provides: kbfx + +%if %{is_stable} < 1 +Source: %{name}-%{version}-%{kbfx_release}.tar.bz2 +%else +Source: %{name}-%{version}.tar.bz2 +%endif + +%description +KBFX is an alternative to the classical K-Menu button and it's menu. +It improves the user experience by enabling the user to set a bigger (and thus more visible) start button and by finally replacing the Win95-like K-Menu with the Spinx bar. +If you still want the old menu, because you're used to it, it is still available as an option in kbfx. + +Main features: + Spinx Bar has 6 Basic Functionalities. + 1.Selecting an Application Group + 2.Selecting an Application + 3.Type and locate an Application + 4.Logout of the Desktop + 5.Lock the Desktop + 6.Launch KBFX settings manager + 7.Scroll up and down the application list + +Extra features: + 1.Double buffered Widgets to minimize flicker. + 2.Animated scroll bars + 3.New Tooltip + 4.Gif/Mng File Support + 5.New Control Manager + +%prep + +%if %{is_stable} < 1 +%setup -n %{name}-%{version}-%{kbfx_release} +%else +%setup -n %{name}-%{version} +%endif + +rm -Rf build +mkdir build +cd build +export DESTDIR=${RPM_BUILD_ROOT} +cmake ../ -DCMAKE_INSTALL_PREFIX=%{prefix} + +%build +cd build + +%install +cd build +[ "${RPM_BUILD_ROOT}" != "/" ] && [ -d ${RPM_BUILD_ROOT} ] && rm -Rf ${RPM_BUILD_ROOT}; +export DESTDIR=${RPM_BUILD_ROOT} +make install + +%if %{is_mandrake} +mkdir -p ${RPM_BUILD_ROOT}%{_menudir} +cat << EOF > ${RPM_BUILD_ROOT}%{_menudir}/%{name} +?package(%{name}): needs="kde" kde_filename="kbfxconfig" \ +section="System/Configuration/Other" title="KBFX Configurator" icon="kbfxconfigapp" \ +command="kbfxconfigapp" longtitle="KBFX Configuration Utility" \ +kde_opt="\\\\nEncoding=UTF-8\\\\nType=Application" +EOF +%endif + +%post +if [ -x /usr/bin/update-menus ]; then /usr/bin/update-menus || true ; fi +/sbin/ldconfig + +%postun +if [ "$1" = "0" -a -x /usr/bin/update-menus ]; then /usr/bin/update-menus || true ; fi +/sbin/ldconfig + + +%clean +[ "${RPM_BUILD_ROOT}" != "/" ] && [ -d ${RPM_BUILD_ROOT} ] && rm -Rf ${RPM_BUILD_ROOT}; + +%files +%defattr(-, root, root) +%{prefix}/* + +%changelog + +* Wed May 16 2007 0.4.9.3.1 + - CHANGED layout and font configfile specs + - UPDATED help documentation + - ADDED fade transition effect on the KBFX Button + - ADDED install guides for using checkinstall + - ADDED Hungarian translation (thanks to Ferenc Stelcz for it) + - ADDED option to watch for KDE global changes like new installed applications + - ADDED option for Theme Info + - ADDED resizable configuration dialogs + - ADDED drag&drop hover, pressed and normal images over the KBFX button + - ADDED tooltip support for the KBFX button + - ADDED switch between KBFX and K Menu + - ADDED new two panel skin - "2panels" + - ADDED configurable middle background - middleboxbg.png + - ADDED fonts support in every part of the menu + - ADDED layout support in the KBFX Configurator + - ADDED support for the new versions of strigi + - ADDED support for use of strigi in Gentoo + - ADDED support for SVN version in Gentoo + - ADDED support for PCLinuxOS rpm build (thanks to @PaGal and @tom777 for the testing) + - ADDED support for future KDE4 (part 1) + - ADDED uninstall option for "build.sh" script + - FIXED cmake uninstall + - FIXED RPM .la issues + - FIXED some major bugs + - REMOVED Water effect (too much CPU time consuming and not a favorite one for our users) + +* Wed Jan 17 2007 0.4.9.3-20070117 + - Initial Release of the 0.4.9.3 Series - KBFX Silk (0.4.9.3) + - New Build system (cmake) + - Re-write of the data backend + - Re-write of the GUI + - Totally new theme + - Improved configuration dialog + +* Fri Nov 17 2006 0.4.9.2rc4 + - CHANGED some aspects of autoconf/automake behaviour + - CHANGED "Toolbar Resize" behaviour - turned off by default so kicker doesn't change its size anymore + - ADDED support for Mandriva 2007 compilation (no menudrake there by default) + - FIXED Searchbar behaviour (thanks @gropiuskalle) + - FIXED some minor bugs + +* Sun Nov 05 2006 0.4.9.2rc3 + - ADDED support for preparing .kbfxtheme files in konqueror (look the explanation in HOWTO file) + - ADDED "--prepare" commandline option to pack existing KBFX Skin Folders to .kbfxtheme files + - ADDED "Default Theme's Personal Image" to the "KBFX Configurator Application" + - ADDED "Toolbar Resize" option to the "KBFX Configurator Application" for the toolbar where the KBFX Button resides + - ADDED it, bg and nl translations + - FIXED some minor bugs + +* Mon Sep 19 2006 0.4.9.2rc2 + - CHANGED "KBFX Configurator Application" - rewritten from scratch and is no more part of "kcontrol" + - CHANGED "Tooltip Animation" behaviour - turned off by default + - ADDED new Default Theme + - ADDED fonts configuration option to the "KBFX Configurator Application" + - ADDED Install/Delete Themes to the "KBFX Configurator Application" + - ADDED support for .kbfxtheme files in konqueror (look the explanation in HOWTO file) + - ADDED possibility to change "dude" image to the "KBFX Configurator Application" + - ADDED Free-BSD Support + - FIXED font alignment problems + - FIXED long applications name problem + - FIXED some memory leaks + - FIXED some minor bugs + +* Sun Jun 18 2006 0.4.9.2-20060708cvs + - UPDATED make system + +* Sun Jun 11 2006 0.4.9.2-20060611cvs + - ADDED KNOWN_BUGS file in the project documents + - ADDED PC-BSD Support + - ADDED Drag and Drop Support + - FIXED a bug with showing icons in "Recently Used" items + - FIXED a bug with the placement of ".face.icon" (thanks @Nucc) + - Flicker Free KBFX Button + - Flicker Free KBFX SPINX Menu TOP + - Better scrolling + + +* Sun May 28 2006 0.4.9.2-20060528cvs + - ADDED suport for Fedora rpm + - ADDED an option to disable tooltip (see HOWTO file) + - FIXED a problem with building SUSE rpm + + +* Wed May 10 2006 0.4.9.2rc1 + - ADDED suport for SUSE rpm + - ADDED support for Buttons with Drop shadows + - ADDED Font settings as part of the Theme itself + - ADDED Grouping header for each application group and sub groups + - ADDED Kiosk mode support + - ADDED Handling of submenus + - FIXED a problem with make + - FIXED make system for all distributions + - Better support for Mandriva distribution + - More applications for the menu + + +* Sun Apr 16 2006 0.4.9.1-1 + Initial rpm release + - FIXED Kbfx configuration + - FIXED Slack 1.9 automake and compilation + - FIXED /tmp/.kbfx.html + diff --git a/kbfxlib/common/CMakeLists.txt b/kbfxlib/common/CMakeLists.txt new file mode 100644 index 0000000..f318f74 --- /dev/null +++ b/kbfxlib/common/CMakeLists.txt @@ -0,0 +1,48 @@ +SET(libkbfxcommonsrc + kbfxkiodownload.cpp + kbfxpixmaplabel.cpp + kbfxconfig.cpp + kbfxpushbutton.cpp + kbfxthemesdata.cpp + kbfxfontchooser.cpp + kbfxplasmapixmapprovider.cpp + ) + +FILE(GLOB HEADERS *.h) + +IF (NOT USE_KDE4) + KDE3_AUTOMOC(${libkbfxcommonsrc}) + + ADD_LIBRARY(kbfxcommon SHARED ${libkbfxcommonsrc}) + SET_TARGET_PROPERTIES(kbfxcommon + PROPERTIES + COMPILE_FLAGS ${CMAKE_SHARED_LIBRARY_CXX_FLAGS}) + # SET_TARGET_PROPERTIES(kbfxcommon PROPERTIES + # SOVERSION ${LIB_MAJOR} + # VERSION ${APPLICATION_VERSION}) + TARGET_LINK_LIBRARIES(kbfxcommon + ${QT_AND_KDECORE_LIBS} + ${KDE3_KIO_LIBRARY} + ${KDE3_UI_LIBRARY} + ${KDE3_KHTML_LIBRARY} + ${M_LIBRARY} + ) + + KDE3_INSTALL_LIBTOOL_FILE(kbfxcommon ${LIB_INSTALL_DIR}) +ELSE (NOT USE_KDE4) + KDE4_AUTOMOC(${libkbfxcommonsrc}) + + KDE4_ADD_LIBRARY(kbfxcommon SHARED ${libkbfxcommonsrc}) + TARGET_LINK_LIBRARIES(kbfxcommon + ${KDE4_KDECORE_LIBS} + ${KDE4_KIO_LIBS} + ${KDE4_KDEUI_LIBS} + ${KDE4_KHTML_LIBS} + ${M_LIBRARY} + ) + + KDE4_INSTALL_LIBTOOL_FILE(kbfxcommon ${LIB_INSTALL_DIR}) +ENDIF (NOT USE_KDE4) + +INSTALL(TARGETS kbfxcommon DESTINATION ${LIB_INSTALL_DIR}) +INSTALL(FILES ${HEADERS} DESTINATION ${INCLUDE_INSTALL_DIR}/kbfx/common) diff --git a/kbfxlib/common/kbfxconfig.cpp b/kbfxlib/common/kbfxconfig.cpp new file mode 100644 index 0000000..15c2590 --- /dev/null +++ b/kbfxlib/common/kbfxconfig.cpp @@ -0,0 +1,862 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxconfig.h" + +KbfxConfig::KbfxConfig() +{ + /* set default configuration values */ + + /* KBFX internal settings */ + KbfxThemeRcDestination = KGlobal::dirs()->saveLocation ( "data", QString ( "kbfx/themerc/" ), TRUE ); + KbfxRcPath = KGlobal::dirs()->findResource ( "config", "kbfxrc" ); + m_KbfxDeleteOldConf = FALSE; + QString _unspecified = tr2i18n ( "Not Specified" ); + QString path = locate ( "data", "kbfx/skins/default/bg.png" ); + path.remove ( "default/bg.png" ); + + kdDebug() << "Configuration path skins: " + path << endl; + + /* KBFX general settings */ + m_KbfxGeneralVersionDefault = APPLICATION_INTERNAL_VERSION; + m_KbfxThemesVersion = "version-2"; + + m_KbfxHistoryDefault = ""; + + /* theme properties */ + m_SpinxThemeNameDefault = "default"; + m_SpinxThemeBasePathDefault = path; + m_UserSpinxThemeBasePathDefault = path; + + m_KbfxMenuTypeDefault = "spinx"; + m_ToolBarResizeDefault = FALSE; + m_KbfxWatcherDefault = TRUE; + m_KbfxShowOldThemesDefault = FALSE; + + /* user(dude) image properties */ + m_SpinxDudeBlinkDefault = FALSE; + KUser *user = new KUser(); + m_SpinxDudeImageDefault = locate ( "data", user->homeDir () + "/.face.icon" ); + delete user; + + /* tooltip properties */ + m_ToolTipDefault = FALSE; + m_ToolTipAnimationDefault = TRUE; + m_ToolTipTextDefault = "Application menu"; + m_ToolTipAvatarDefault = path + "default/butterfly.png"; + m_SpinxTooltipDudeboxDefault = path + "default/tooltip_dudebox.png"; + m_SpinxTooltipMaskDefault = path + "default/tooltip_mask.png"; + m_SpinxTooltipWindowDefault = path + "default/tooltip_window.png"; + m_SpinxTooltipLogoDefault = path + "default/tooltip_logo.png"; + + /* KBFX plugins */ + m_pluginsLeftDefault="Applications"; + m_pluginsRightDefault="Settings"; + + /* specific theme KBFX settings */ + + /* KBFX panel button */ + m_KbfxNormalButtonPathDefault = path + "default/normal.png"; + m_KbfxHoverButtonPathDefault = path + "default/hover.png"; + m_KbfxPressedButtonPathDefault = path + "default/pressed.png"; + + /* face properties */ + m_facePos_xDefault = -1; + m_facePos_yDefault = -1; + m_faceIconXDefault = 27; + m_faceIconYDefault = 8; + m_faceIconHDefault = 64; + m_faceIconWDefault = 65; + m_userNamePos_xDefault = 130; + m_userNamePos_yDefault = 32; + m_faceBoxHideTextDefault = FALSE; + + /* top bar properties */ + m_topBar_xDefault = 0; + m_topBar_yDefault = 0; + m_topBar_hDefault = 95; + m_topBar_wDefault = 504; //108+190+74; + + /* bottom bar properties */ + m_botBar_xDefault = 0; + m_botBar_yDefault = 428; + m_botBar_hDefault = 38; + m_botBar_wDefault = 504; //108+190+74; + + /* scroll bar properties */ + m_scrollBarBotYDefault = 95; + m_scrollBarBotXDefault = 108; + m_scrollBarTopXDefault = 108; + m_scrollBarTopYDefault = 95; + + /* listbox properties */ + m_listBox_xDefault = 0; + m_listBox_yDefault = m_topBar_hDefault; + m_listBox_wDefault = 132; + m_listBox_hDefault = 275; + + /* search box properties */ + m_searchBox_hDefault = 22; + m_searchBox_wDefault = 240; + m_searchBox_xDefault = 130; + m_searchBox_yDefault = 48; + m_searchBox_staticDefault = TRUE; + + /* item view properties */ + m_itemView_hDefault = 380; + m_itemView_wDefault = 240; + m_itemView_xDefault = 132; + m_itemView_yDefault = m_topBar_hDefault; + + /* toolbar properties */ + m_toolBarButtonNormalSizeDefault = 48; + m_toolBarButtonExpandSizeDefault = 48; + + /* KBFX misc properties */ + m_userMenuHeightDefault = 513; + m_userMenuWidthDefault = 504; + m_startHiddenDefault = FALSE; + m_fadeTimeDefault = 75; + m_noCommentsDefault = FALSE; + m_commentMargineDefault = 66; + m_iconSizeDefault = 32; + + /* set default fonts values */ + m_fontTooltipColorDefault = QColor ( 0,0,0 ); + m_fontTooltipFontDefault = QFont ( "Arial", 8, QFont::Normal ); + m_fontAppNameColorDefault = QColor ( 0,0,0 ); + m_fontAppNameFontDefault = QFont ( "Arial", 8, QFont::Normal ); + m_fontAppCommentColorDefault = QColor ( 128,125,0 ); + m_fontAppCommentFontDefault = QFont ( "Arial", 8, QFont::Normal ); + m_fontIndexColorDefault = QColor ( 0,0,0 ); + m_fontIndexFontDefault = QFont ( "Arial", 8, QFont::Normal ); + m_userNameColorDefault = QColor ( 255,255,255 ); + m_userNameFontDefault = QFont ( "Arial", 10, QFont::Bold ); + m_sepNameColorDefault = QColor ( 0,0,0 ); + m_sepNameFontDefault = QFont ( "Arial", 8, QFont::Bold ); + m_pluginNameColorDefault = QColor ( 0,0,0 ); + m_pluginNameFontDefault = QFont ( "Arial", 8, QFont::Normal ); + m_lineColorDefault = QColor ( 255,220,125 ); + m_fontHoverBoldDefault = FALSE; + + /* set default theme info values */ + m_InfoVersionDefault = _unspecified; + m_InfoAuthorDefault = _unspecified; + m_InfoEmailDefault = _unspecified; + m_InfoUrlDefault = _unspecified; + + read(); +} + +KbfxConfig& ConfigInit() +{ + static KbfxConfig _config; + return _config; +} + +void KbfxConfig::setDefault() +{ + /* set default configuration */ + m_KbfxHistory = m_KbfxHistoryDefault; + + m_SpinxThemeName = m_SpinxThemeNameDefault; + m_SpinxThemeBasePath = m_SpinxThemeBasePathDefault; + m_UserSpinxThemeBasePath = m_UserSpinxThemeBasePathDefault; + + m_KbfxMenuType = m_KbfxMenuTypeDefault; + m_ToolBarResize = m_ToolBarResizeDefault; + m_KbfxWatcher = m_KbfxWatcherDefault; + m_KbfxShowOldThemes = m_KbfxShowOldThemesDefault; + + m_SpinxDudeBlink = m_SpinxDudeBlinkDefault; + m_SpinxDudeImage = m_SpinxDudeImageDefault; + + m_ToolTip = m_ToolTipDefault; + m_ToolTipAnimation = m_ToolTipAnimationDefault; + m_ToolTipText = m_ToolTipTextDefault; + + m_pluginsLeft = m_pluginsLeftDefault; + m_pluginsRight = m_pluginsRightDefault; +} + +void KbfxConfig::setThemeInfoDefault() +{ + /* set default configuration */ + m_InfoVersion = m_InfoVersionDefault; + m_InfoAuthor = m_InfoAuthorDefault; + m_InfoEmail = m_InfoEmailDefault; + m_InfoUrl = m_InfoUrlDefault; +} + +void KbfxConfig::setThemeDefault() +{ + /* set default theme layout configuration */ + m_KbfxNormalButtonPath = m_KbfxNormalButtonPathDefault; + m_KbfxHoverButtonPath = m_KbfxHoverButtonPathDefault; + m_KbfxPressedButtonPath = m_KbfxPressedButtonPathDefault; + + m_ToolTipAvatar = m_ToolTipAvatarDefault; + m_SpinxTooltipDudebox = m_SpinxTooltipDudeboxDefault; + m_SpinxTooltipMask = m_SpinxTooltipMaskDefault; + m_SpinxTooltipWindow = m_SpinxTooltipWindowDefault; + m_SpinxTooltipLogo = m_SpinxTooltipLogoDefault; + + m_facePos_x = m_facePos_xDefault; + m_facePos_y = m_facePos_yDefault; + m_faceIconX = m_faceIconXDefault; + m_faceIconY = m_faceIconYDefault; + m_faceIconH = m_faceIconHDefault; + m_faceIconW = m_faceIconWDefault; + m_userNamePos_x = m_userNamePos_xDefault; + m_userNamePos_y = m_userNamePos_yDefault; + m_faceBoxHideText = m_faceBoxHideTextDefault; + + m_topBar_x = m_topBar_xDefault; + m_topBar_y = m_topBar_yDefault; + m_topBar_h = m_topBar_hDefault; + m_topBar_w = m_topBar_wDefault; + + m_botBar_x = m_botBar_xDefault; + m_botBar_y = m_botBar_yDefault; + m_botBar_h = m_botBar_hDefault; + m_botBar_w = m_botBar_wDefault; + + m_scrollBarBotY = m_scrollBarBotYDefault; + m_scrollBarBotX = m_scrollBarBotXDefault; + m_scrollBarTopX = m_scrollBarTopXDefault; + m_scrollBarTopY = m_scrollBarTopYDefault; + + m_listBox_x = m_listBox_xDefault; + m_listBox_y = m_listBox_yDefault; + m_listBox_w = m_listBox_wDefault; + m_listBox_h = m_listBox_hDefault; + + m_searchBox_h = m_searchBox_hDefault; + m_searchBox_w = m_searchBox_wDefault; + m_searchBox_x = m_searchBox_xDefault; + m_searchBox_y = m_searchBox_yDefault; + m_searchBox_static = m_searchBox_staticDefault; + + m_itemView_h = m_itemView_hDefault; + m_itemView_w = m_itemView_wDefault; + m_itemView_x = m_itemView_xDefault; + m_itemView_y = m_itemView_yDefault; + + m_toolBarButtonNormalSize = m_toolBarButtonNormalSizeDefault; + m_toolBarButtonExpandSize = m_toolBarButtonExpandSizeDefault; + + m_userMenuHeight = m_userMenuHeightDefault; + m_userMenuWidth = m_userMenuWidthDefault; + m_startHidden = m_startHiddenDefault; + m_fadeTime = m_fadeTimeDefault; + m_noComments = m_noCommentsDefault; + m_commentMargine = m_commentMargineDefault; + m_iconSize = m_iconSizeDefault; +} + +void KbfxConfig::setFontsDefault() +{ + /* set default fonts values */ + m_fontTooltipColor = m_fontTooltipColorDefault; + m_fontTooltipFont = m_fontTooltipFontDefault; + m_fontAppNameColor = m_fontAppNameColorDefault; + m_fontAppNameFont = m_fontAppNameFontDefault; + m_fontAppCommentColor = m_fontAppCommentColorDefault; + m_fontAppCommentFont = m_fontAppCommentFontDefault; + m_fontIndexColor = m_fontIndexColorDefault; + m_fontIndexFont = m_fontIndexFontDefault; + m_userNameColor = m_userNameColorDefault; + m_userNameFont = m_userNameFontDefault; + m_sepNameColor = m_sepNameColorDefault; + m_sepNameFont = m_sepNameFontDefault; + m_pluginNameColor = m_pluginNameColorDefault; + m_pluginNameFont = m_pluginNameFontDefault; + m_lineColor = m_lineColorDefault; + m_fontHoverBold = m_fontHoverBoldDefault; +} + +void KbfxConfig::readThemeInfo ( QString &themePath, QString &themeName ) +{ + setThemeInfoDefault(); + + QFileInfo * info_theme = new QFileInfo ( themePath + themeName + "/" + m_KbfxThemesVersion ); + KConfig * infoconfig = 0; + + if ( info_theme->exists() == TRUE ) + { + infoconfig = new KConfig ( info_theme->absFilePath() ); + infoconfig->setGroup ( "ThemeGeneral" ); + m_InfoVersion = infoconfig->readEntry ( "ThemeVersion", m_InfoVersionDefault ); + m_InfoAuthor = infoconfig->readEntry ( "AuthorName", m_InfoAuthorDefault ); + m_InfoEmail = infoconfig->readEntry ( "AuthorEmail", m_InfoEmailDefault ); + m_InfoUrl = infoconfig->readEntry ( "Homepage", m_InfoUrlDefault ); + } + +/* + kdDebug() << " m_InfoVersion: " << m_InfoVersion + << endl << " m_InfoAuthor: " << m_InfoAuthor + << endl << " m_InfoEmail: " << m_InfoEmail + << endl << " m_InfoUrl: " << m_InfoUrl + << endl; +*/ + + delete info_theme; + delete infoconfig; +} + +void KbfxConfig::read() +{ + /* read general configuration */ + KConfigSkeleton *confskel = new KConfigSkeleton ( QString::fromLatin1 ( "kbfxrc" ) ); + + KConfig *conf = confskel->config(); + + QString __default = KGlobal::iconLoader()->iconPath ( "kbfx", ( int ) KIcon::Desktop, FALSE ); + + conf->setGroup ( "KbfxGeneral" ); + m_KbfxGeneralVersion = conf->readNumEntry ( "Version", 0 ); + m_ToolBarResize = conf->readBoolEntry ( "ToolBarResize", m_ToolBarResizeDefault ); + m_KbfxMenuType = conf->readEntry ( "MenuType", m_KbfxMenuTypeDefault ); + m_KbfxWatcher = conf->readBoolEntry ( "KbfxWatcher", m_KbfxWatcherDefault ); + m_KbfxShowOldThemes = conf->readBoolEntry ( "KbfxShowOld", m_KbfxShowOldThemesDefault ); + + conf->setGroup ( "SpinxTheme" ); + m_UserSpinxThemeBasePath = conf->readEntry ( "UserThemePath", m_UserSpinxThemeBasePathDefault ); + /* if a new version use default theme */ + if ( m_KbfxGeneralVersion < m_KbfxGeneralVersionDefault ) + { + m_SpinxThemeName = m_SpinxThemeNameDefault; + m_SpinxThemeBasePath = m_SpinxThemeBasePathDefault; + } + else + { + m_SpinxThemeName = conf->readEntry ( "ThemeName", m_SpinxThemeNameDefault ); + m_SpinxThemeBasePath = conf->readEntry ( "ThemePath", m_SpinxThemeBasePathDefault ); + } + + conf->setGroup ( "UserImage" ); + m_SpinxDudeBlink = conf->readBoolEntry ( "DudeBlink", m_SpinxDudeBlinkDefault ); + + conf->setGroup ( "ToolTip" ); + m_ToolTip = conf->readBoolEntry ( "EnableToolTip", m_ToolTipDefault ); + m_ToolTipAnimation = conf->readBoolEntry ( "AnimatedTooltip", m_ToolTipAnimationDefault ); + m_ToolTipText = conf->readEntry ( "ToolTipText", m_ToolTipTextDefault ); + + conf->setGroup ( "Plugins" ); + m_pluginsLeft = conf->readListEntry ( "LoadedPluginsLeft", m_pluginsLeftDefault ); + m_pluginsRight = conf->readListEntry ( "LoadedPluginsRight", m_pluginsRightDefault ); + + conf->setGroup ( "Runtime" ); + m_KbfxHistory = conf->readEntry ( "History", m_KbfxHistoryDefault ); + + /* + kdDebug() << " m_KbfxGeneralVersion: " << m_KbfxGeneralVersion + << endl << " m_KbfxMenuType: " << m_KbfxMenuType + << endl << " m_KbfxWatcher: " << m_KbfxWatcher + << endl << " m_KbfxShowOldThemes: " << m_KbfxShowOldThemes + << endl << " m_ToolBarResize: " << m_ToolBarResize + << endl << " m_UserSpinxThemeBasePath : " << m_UserSpinxThemeBasePath + << endl << " m_SpinxThemeName: " << m_SpinxThemeName + << endl << " m_SpinxThemeBasePath: " << m_SpinxThemeBasePath + << endl << " m_SpinxDudeBlink: " << m_SpinxDudeBlink + << endl << " m_ToolTip: " << m_ToolTip + << endl << " m_ToolTipAnimation: " << m_ToolTipAnimation + << endl << " m_ToolTipText: " << m_ToolTipText + << endl << " m_KbfxHoverButtonPath: " << m_KbfxHoverButtonPath + << endl << " m_KbfxPressedButtonPath: " << m_KbfxPressedButtonPath + << endl << " m_pluginsLeft: " << m_pluginsLeft + << endl << " m_pluginsRight: " << m_pluginsRight + << endl << " m_KbfxHistory: " << m_KbfxHistory + << endl; + */ + + delete confskel; + + readFontrc ( m_SpinxThemeBasePath, m_SpinxThemeName ); + readThemerc ( m_SpinxThemeBasePath, m_SpinxThemeName ); + + if ( m_KbfxGeneralVersion < m_KbfxGeneralVersionDefault ) + { + m_KbfxGeneralVersion = m_KbfxGeneralVersionDefault; + m_KbfxDeleteOldConf = TRUE; + } +} + +void KbfxConfig::readFontrc ( QString & themePath, QString & themeName, bool user_rc ) +{ + setFontsDefault(); + + /* if a new version use default theme fonts */ + if ( m_KbfxGeneralVersion < m_KbfxGeneralVersionDefault ) + { + themePath = m_SpinxThemeBasePathDefault; + themeName = m_SpinxThemeNameDefault; + } + /* get some font settings from theme file or from theme section */ + QString _abs_path = ""; + QFileInfo * info = new QFileInfo ( themePath + themeName + "/kbfxfontrc" ); + QFileInfo * info_theme = new QFileInfo ( KbfxThemeRcDestination + "/" + themeName + "_fontrc" ); + KConfig * fontconfig = 0; + + /* if theme kbfxfontrc exists, make its configuration as default values - prefer users' configuration */ + if ( info_theme->exists() == TRUE || info->exists() == TRUE ) + { + if ( info_theme->exists() == TRUE && m_KbfxGeneralVersion >= m_KbfxGeneralVersionDefault && user_rc ) + { + _abs_path = info_theme->absFilePath(); + } + else if ( info->exists() == TRUE || m_KbfxGeneralVersion < m_KbfxGeneralVersionDefault ) + { + _abs_path = info->absFilePath(); + } + fontconfig = new KConfig ( _abs_path ); + + fontconfig->setGroup ( "Fonts" ); + m_fontTooltipColor = fontconfig->readColorEntry ( "TooltipText", &m_fontTooltipColorDefault ); + m_fontTooltipFont = fontconfig->readFontEntry ( "TooltipTextFont", &m_fontTooltipFontDefault ); + m_fontAppNameColor = fontconfig->readColorEntry ( "ApplicationText", &m_fontAppNameColorDefault ); + m_fontAppNameFont = fontconfig->readFontEntry ( "ApplicationTextFont", &m_fontAppNameFontDefault ); + m_fontAppCommentColor = fontconfig->readColorEntry ( "CommentText", &m_fontAppCommentColorDefault ); + m_fontAppCommentFont = fontconfig->readFontEntry ( "CommentTextFont", &m_fontAppCommentFontDefault ); + m_fontIndexColor = fontconfig->readColorEntry ( "GroupText", &m_fontIndexColorDefault ); + m_fontIndexFont = fontconfig->readFontEntry ( "GroupTextFont", &m_fontIndexFontDefault ); + m_userNameColor = fontconfig->readColorEntry ( "UserName", &m_userNameColorDefault ); + m_userNameFont = fontconfig->readFontEntry ( "UserNameFont", &m_userNameFontDefault ); + m_sepNameColor = fontconfig->readColorEntry ( "SeparatorColor", &m_sepNameColorDefault ); + m_sepNameFont = fontconfig->readFontEntry ( "SeparatorFont", &m_sepNameFontDefault ); + m_pluginNameColor = fontconfig->readColorEntry ( "PluginColor", &m_pluginNameColorDefault ); + m_pluginNameFont = fontconfig->readFontEntry ( "PluginFont", &m_pluginNameFontDefault ); + m_lineColor = fontconfig->readColorEntry ( "LineColor", &m_lineColorDefault ); + m_fontHoverBold = fontconfig->readBoolEntry ( "HoverBold",m_fontHoverBoldDefault ); + kdDebug() << "Read default font settings for theme: " + << themeName + << " from file: " + << _abs_path + << endl; + } + else + { + kdDebug() << "Left Default Font Values for theme: " + << themeName + << endl; + } + + /* + kdDebug() << "Font Values:" << endl + << m_fontTooltipColor << endl + << m_fontTooltipFont << endl + << m_fontAppNameColor << endl + << m_fontAppNameFont << endl + << m_fontAppCommentColor << endl + << m_fontAppCommentFont << endl + << m_fontIndexColor << endl + << m_fontIndexFont << endl + << m_userNameColor << endl + << m_userNameFont << endl + << m_sepNameColor << endl + << m_sepNameFont << endl + << m_pluginNameColor << endl + << m_pluginNameFont << endl + << m_fontHoverBold << endl + << m_lineColor << endl + ; + */ + + delete info; + delete info_theme; + delete fontconfig; +} + +void KbfxConfig::readThemerc ( QString &themePath, QString &themeName, bool user_rc ) +{ + /* if a new version use default theme layout */ + if ( m_KbfxGeneralVersion < m_KbfxGeneralVersionDefault ) + { + themePath = m_SpinxThemeBasePathDefault; + themeName = m_SpinxThemeNameDefault; + } + + /* load theme's on and off buttons if any */ + KbfxOnImg = QPixmap::QPixmap ( KbfxPlasmaPixmapProvider::PixmapPath ( "on", themePath, themeName ) ); + KbfxOffImg = QPixmap::QPixmap ( KbfxPlasmaPixmapProvider::PixmapPath ( "off", themePath, themeName ) ); + + /* use theme's default dude image if any */ + KConfigSkeleton *confskel = new KConfigSkeleton ( QString::fromLatin1 ( "kbfxrc" ) ); + KConfig *conf = confskel->config(); + QString __default = KGlobal::iconLoader()->iconPath ( "kbfx", ( int ) KIcon::Desktop, FALSE ); + + if ( m_SpinxDudeImageDefault == QString::null || !KStandardDirs::exists ( m_SpinxDudeImageDefault ) ) + { + m_SpinxDudeImageDefault = KbfxPlasmaPixmapProvider::PixmapPath ( "menu_top_image_person", themePath, themeName ); + } + conf->setGroup ( "UserImage" ); + m_SpinxDudeImage = conf->readEntry ( "DudeImage", m_SpinxDudeImageDefault ); + delete confskel; + + /* load theme's default buttons if any */ + m_KbfxNormalButtonPathDefault = KbfxPlasmaPixmapProvider::PixmapPath ( "normal", themePath, themeName ); + m_KbfxHoverButtonPathDefault = KbfxPlasmaPixmapProvider::PixmapPath ( "hover", themePath, themeName ); + m_KbfxPressedButtonPathDefault = KbfxPlasmaPixmapProvider::PixmapPath ( "pressed", themePath, themeName ); + + /* load theme's default tooltip images if any */ + m_ToolTipAvatarDefault = KbfxPlasmaPixmapProvider::PixmapPath ( "butterfly", themePath, themeName ); + m_SpinxTooltipDudeboxDefault = KbfxPlasmaPixmapProvider::PixmapPath ( "tooltip_dudebox", themePath, themeName ); + m_SpinxTooltipMaskDefault = KbfxPlasmaPixmapProvider::PixmapPath ( "tooltip_mask", themePath, themeName ); + m_SpinxTooltipWindowDefault = KbfxPlasmaPixmapProvider::PixmapPath ( "tooltip_window", themePath, themeName ); + m_SpinxTooltipLogoDefault = KbfxPlasmaPixmapProvider::PixmapPath ( "tooltip_logo", themePath, themeName ); + + setThemeDefault(); + + /* get some theme layout settings from theme file or from theme section */ + QString _abs_path = ""; + QFileInfo * info = new QFileInfo ( themePath + themeName + "/kbfxlayoutrc" ); + QFileInfo * info_theme = new QFileInfo ( KbfxThemeRcDestination + "/" + themeName + "_layoutrc" ); + KConfig *layoutconfig = 0; + + /* if theme kbfxlayoutrc exists, make its configuration as default values - prefer users' configuration */ + if ( info_theme->exists() == TRUE || info->exists() == TRUE ) + { + if ( info_theme->exists() == TRUE && m_KbfxGeneralVersion >= m_KbfxGeneralVersionDefault && user_rc ) + { + _abs_path = info_theme->absFilePath(); + } + else if ( info->exists() == TRUE || m_KbfxGeneralVersion < m_KbfxGeneralVersionDefault ) + { + _abs_path = info->absFilePath(); + } + + layoutconfig = new KConfig ( _abs_path ); + + layoutconfig->setGroup ( "KbfxButton" ); + m_KbfxNormalButtonPath = layoutconfig->readEntry ( "Normal", m_KbfxNormalButtonPathDefault ); + m_KbfxHoverButtonPath = layoutconfig->readEntry ( "Hover", m_KbfxHoverButtonPathDefault ); + m_KbfxPressedButtonPath = layoutconfig->readEntry ( "Press", m_KbfxPressedButtonPathDefault ); + m_fadeTime = layoutconfig->readNumEntry ( "FadeTime", m_fadeTimeDefault ); + + layoutconfig->setGroup ( "ToolTip" ); + m_ToolTipAvatar = layoutconfig->readEntry ( "Avatar", m_ToolTipAvatarDefault ); + m_SpinxTooltipDudebox = layoutconfig->readEntry ( "Dudebox", m_SpinxTooltipDudeboxDefault ); + m_SpinxTooltipMask = layoutconfig->readEntry ( "Mask", m_SpinxTooltipMaskDefault ); + m_SpinxTooltipWindow = layoutconfig->readEntry ( "Window", m_SpinxTooltipWindowDefault ); + m_SpinxTooltipLogo = layoutconfig->readEntry ( "Logo", m_SpinxTooltipLogoDefault ); + + layoutconfig->setGroup ( "TopBar" ); + m_facePos_x = layoutconfig->readNumEntry ( "DudeX", m_facePos_xDefault ); + m_facePos_y = layoutconfig->readNumEntry ( "DudeY", m_facePos_yDefault ); + m_faceIconX = layoutconfig->readNumEntry ( "FaceX",m_faceIconXDefault ); + m_faceIconY = layoutconfig->readNumEntry ( "FaceY",m_faceIconYDefault ); + m_faceIconH = layoutconfig->readNumEntry ( "FaceH",m_faceIconHDefault ); + m_faceIconW = layoutconfig->readNumEntry ( "FaceW",m_faceIconWDefault ); + m_userNamePos_x = layoutconfig->readNumEntry ( "UserNameX", m_userNamePos_xDefault ); + m_userNamePos_y = layoutconfig->readNumEntry ( "UserNameY", m_userNamePos_yDefault ); + m_faceBoxHideText= layoutconfig->readBoolEntry ( "DisableUserName", m_faceBoxHideTextDefault ); + m_topBar_h = layoutconfig->readNumEntry ( "Height", m_topBar_hDefault ); + m_topBar_w = layoutconfig->readNumEntry ( "Width", m_topBar_wDefault ); + m_topBar_x = layoutconfig->readNumEntry ( "X", m_topBar_xDefault ); + m_topBar_y = layoutconfig->readNumEntry ( "Y", m_topBar_yDefault ); + + layoutconfig->setGroup ( "BottomBar" ); + m_botBar_h = layoutconfig->readNumEntry ( "Height", m_botBar_hDefault ); + m_botBar_w = layoutconfig->readNumEntry ( "Width", m_botBar_wDefault ); + m_botBar_x = layoutconfig->readNumEntry ( "X", m_botBar_xDefault ); + m_botBar_y = layoutconfig->readNumEntry ( "Y", m_botBar_yDefault ); + + layoutconfig->setGroup ( "Scrollbars" ); + m_scrollBarBotX = layoutconfig->readNumEntry ( "ScrollBarBotX", m_scrollBarBotXDefault ); + m_scrollBarBotY = layoutconfig->readNumEntry ( "ScrollBarBotY", m_scrollBarBotYDefault ); + m_scrollBarTopX = layoutconfig->readNumEntry ( "ScrollBarTopX", m_scrollBarTopXDefault ); + m_scrollBarTopY = layoutconfig->readNumEntry ( "ScrollBarTopY", m_scrollBarTopYDefault ); + + layoutconfig->setGroup ( "ListBox" ); + m_listBox_h = layoutconfig->readNumEntry ( "Height", m_listBox_hDefault ); + m_listBox_w = layoutconfig->readNumEntry ( "Width", m_listBox_wDefault ); + m_listBox_x = layoutconfig->readNumEntry ( "X", m_listBox_xDefault ); + m_listBox_y = layoutconfig->readNumEntry ( "Y", m_listBox_yDefault ); + + layoutconfig->setGroup ( "SearchBox" ); + m_searchBox_h = layoutconfig->readNumEntry ( "Height", m_searchBox_hDefault ); + m_searchBox_w = layoutconfig->readNumEntry ( "Width", m_searchBox_wDefault ); + m_searchBox_x = layoutconfig->readNumEntry ( "X", m_searchBox_xDefault ); + m_searchBox_y = layoutconfig->readNumEntry ( "Y", m_searchBox_yDefault ); + m_searchBox_static = layoutconfig->readBoolEntry ( "FixedPos", m_searchBox_staticDefault ); + + layoutconfig->setGroup ( "ItemView" ); + m_itemView_h = layoutconfig->readNumEntry ( "Height", m_itemView_hDefault ); + m_itemView_w = layoutconfig->readNumEntry ( "Width", m_itemView_wDefault ); + m_itemView_x = layoutconfig->readNumEntry ( "X", m_itemView_xDefault ); + m_itemView_y = layoutconfig->readNumEntry ( "Y", m_itemView_yDefault ); + + layoutconfig->setGroup ( "ToolBar" ); + m_toolBarButtonNormalSize = layoutconfig->readNumEntry ( "ButtonNormalSize", m_toolBarButtonNormalSizeDefault ); + m_toolBarButtonExpandSize = layoutconfig->readNumEntry ( "ButtonPressedSize", m_toolBarButtonExpandSizeDefault ); + + layoutconfig->setGroup ( "MainMenu" ); + m_userMenuHeight = layoutconfig->readNumEntry ( "UserMenuHeight",m_userMenuHeightDefault ); + m_userMenuWidth = layoutconfig->readNumEntry ( "UserMenuWidth",m_userMenuWidthDefault ); + m_startHidden = layoutconfig->readBoolEntry ( "ContractedMenu", m_startHiddenDefault ); + + layoutconfig->setGroup ( "ItemProperties" ); + m_noComments = layoutconfig->readBoolEntry ( "NoComments",m_noCommentsDefault ); + m_commentMargine = layoutconfig->readNumEntry ( "CommentMargin",m_commentMargineDefault ); + m_iconSize = layoutconfig->readNumEntry ( "IconSize",m_iconSizeDefault ); + + kdDebug() << "Read default layout settings for theme: " + << themeName + << " from file: " + << _abs_path + << endl; + } + else + { + kdDebug() << "Left Default Layout Values for theme: " + << themeName + << endl; + } + + /* + kdDebug() << " m_KbfxNormalButtonPath: " << m_KbfxNormalButtonPath + << endl << " m_KbfxHoverButtonPath: " << m_KbfxHoverButtonPath + << endl << " m_KbfxPressedButtonPath: " << m_KbfxPressedButtonPath + << endl << " m_fadeTime: " << m_fadeTime + << endl << " m_SpinxDudeImage: " << m_SpinxDudeImage + << endl << " m_ToolTipAvatar: " << m_ToolTipAvatar + << endl << " m_SpinxTooltipDudebox: " << m_SpinxTooltipDudebox + << endl << " m_SpinxTooltipMask: " << m_SpinxTooltipMask + << endl << " m_SpinxTooltipWindow: " << m_SpinxTooltipWindow + << endl << " m_SpinxTooltipLogo: " << m_SpinxTooltipLogo + << endl << " m_facePos_x: " << m_facePos_x + << endl << " m_facePos_y: " << m_facePos_y + << endl << " m_faceIconX: " << m_faceIconX + << endl << " m_faceIconY: " << m_faceIconY + << endl << " m_faceIconH: " << m_faceIconH + << endl << " m_faceIconW: " << m_faceIconW + << endl << " m_userNamePos_x: " << m_userNamePos_x + << endl << " m_userNamePos_y: " << m_userNamePos_y + << endl << " m_faceBoxHideText: " << m_faceBoxHideText + << endl << " m_topBar_x: " << m_topBar_x + << endl << " m_topBar_y: " << m_topBar_y + << endl << " m_topBar_h: " << m_topBar_h + << endl << " m_topBar_w: " << m_topBar_w + << endl << " m_botBar_x: " << m_botBar_x + << endl << " m_botBar_y: " << m_botBar_y + << endl << " m_botBar_h: " << m_botBar_h + << endl << " m_botBar_w: " << m_botBar_w + << endl << " m_scrollBarBotY: " << m_scrollBarBotY + << endl << " m_scrollBarBotX: " << m_scrollBarBotX + << endl << " m_scrollBarTopX: " << m_scrollBarTopX + << endl << " m_scrollBarTopY: " << m_scrollBarTopY + << endl << " m_listBox_x: " << m_listBox_x + << endl << " m_listBox_y: " << m_listBox_y + << endl << " m_listBox_w: " << m_listBox_w + << endl << " m_listBox_h: " << m_listBox_h + << endl << " m_searchBox_h: " << m_searchBox_h + << endl << " m_searchBox_w: " << m_searchBox_w + << endl << " m_searchBox_x: " << m_searchBox_x + << endl << " m_searchBox_y: " << m_searchBox_y + << endl << " m_searchBox_static: " << m_searchBox_static + << endl << " m_itemView_h: " << m_itemView_h + << endl << " m_itemView_w: " << m_itemView_w + << endl << " m_itemView_x: " << m_itemView_x + << endl << " m_itemView_y: " << m_itemView_y + << endl << " m_toolBarButtonNormalSize: " << m_toolBarButtonNormalSize + << endl << " m_toolBarButtonExpandSize: " << m_toolBarButtonExpandSize + << endl << " m_userMenuHeight: " << m_userMenuHeight + << endl << " m_userMenuWidth: " << m_userMenuHeight + << endl << " m_startHidden: " << m_startHidden + << endl << " m_noComments: " << m_noComments + << endl << " m_commentMargine: " << m_commentMargine + << endl << " m_iconSize: " << m_iconSize + << endl; + */ + + checkValues(); + + delete info; + delete info_theme; + delete layoutconfig; +} + +void KbfxConfig::write() +{ + if ( m_KbfxDeleteOldConf && KbfxRcPath != QString::null ) + { + QFile::remove ( KbfxRcPath ); + kdDebug() << "Deleting general RC file: " << KbfxRcPath << endl; + } + + KConfigSkeleton *confskel = new KConfigSkeleton ( QString::fromLatin1 ( "kbfxrc" ) ); + + /* write general KBFX configuration options */ + KConfig *conf = confskel->config(); + + conf->setGroup ( "KDE Action Restrictions" ); + conf->writeEntry ( "warn_unwritable_config", FALSE ); + + conf->setGroup ( "KbfxGeneral" ); + conf->writeEntry ( "Version", m_KbfxGeneralVersion ); + conf->writeEntry ( "MenuType", m_KbfxMenuType ); + conf->writeEntry ( "ToolBarResize", m_ToolBarResize ); + conf->writeEntry ( "KbfxWatcher", m_KbfxWatcher ); + conf->writeEntry ( "KbfxShowOld", m_KbfxShowOldThemes ); + + conf->setGroup ( "SpinxTheme" ); + conf->writeEntry ( "UserThemePath", m_UserSpinxThemeBasePath ); + conf->writeEntry ( "ThemeName", m_SpinxThemeName ); + conf->writeEntry ( "ThemePath", m_SpinxThemeBasePath ); + + conf->setGroup ( "UserImage" ); + conf->writeEntry ( "DudeBlink", m_SpinxDudeBlink ); + conf->writeEntry ( "DudeImage", m_SpinxDudeImage ); + + conf->setGroup ( "ToolTip" ); + conf->writeEntry ( "EnableToolTip", m_ToolTip ); + conf->writeEntry ( "AnimatedTooltip", m_ToolTipAnimation ); + conf->writeEntry ( "ToolTipText", m_ToolTipText ); + + conf->setGroup ( "Plugins" ); + conf->writeEntry ( "LoadedPluginsLeft", m_pluginsLeft ); + conf->writeEntry ( "LoadedPluginsRight", m_pluginsRight ); + + conf->setGroup ( "Runtime" ); + conf->writeEntry ( "History", m_KbfxHistory ); + + conf->sync(); + + delete confskel; +} + +void KbfxConfig::writeFontrc ( QString & themeName ) +{ + /* write fonts KBFX configuration from theme name */ + KConfig *fontconfig = new KConfig ( KbfxThemeRcDestination + "/" + themeName + "_fontrc" ); + + fontconfig->setGroup ( "Fonts" ); + fontconfig->writeEntry ( "TooltipText", m_fontTooltipColor ); + fontconfig->writeEntry ( "TooltipTextFont", m_fontTooltipFont ); + fontconfig->writeEntry ( "ApplicationText", m_fontAppNameColor ); + fontconfig->writeEntry ( "ApplicationTextFont", m_fontAppNameFont ); + fontconfig->writeEntry ( "CommentText", m_fontAppCommentColor ); + fontconfig->writeEntry ( "CommentTextFont", m_fontAppCommentFont ); + fontconfig->writeEntry ( "GroupText", m_fontIndexColor ); + fontconfig->writeEntry ( "GroupTextFont", m_fontIndexFont ); + fontconfig->writeEntry ( "UserName", m_userNameColor ); + fontconfig->writeEntry ( "UserNameFont", m_userNameFont ); + fontconfig->writeEntry ( "SeparatorColor", m_sepNameColor ); + fontconfig->writeEntry ( "SeparatorFont", m_sepNameFont ); + fontconfig->writeEntry ( "PluginColor", m_pluginNameColor ); + fontconfig->writeEntry ( "PluginFont", m_pluginNameFont ); + fontconfig->writeEntry ( "LineColor", m_lineColor ); + fontconfig->writeEntry ( "HoverBold",m_fontHoverBold ); + fontconfig->sync(); + + delete fontconfig; +} + +void KbfxConfig::writeThemerc ( QString & themeName ) +{ + checkValues(); + + /* write layout theme configuration from theme name */ + KConfig *layoutconfig = new KConfig ( KbfxThemeRcDestination + "/" + themeName + "_layoutrc" ); + + layoutconfig->setGroup ( "KbfxButton" ); + layoutconfig->writeEntry ( "Normal", m_KbfxNormalButtonPath ); + layoutconfig->writeEntry ( "Hover", m_KbfxHoverButtonPath ); + layoutconfig->writeEntry ( "Press", m_KbfxPressedButtonPath ); + layoutconfig->writeEntry ( "FadeTime", m_fadeTime ); + + layoutconfig->setGroup ( "ToolTip" ); + layoutconfig->writeEntry ( "Avatar", m_ToolTipAvatar ); + layoutconfig->writeEntry ( "Dudebox", m_SpinxTooltipDudebox ); + layoutconfig->writeEntry ( "Mask", m_SpinxTooltipMask ); + layoutconfig->writeEntry ( "Window", m_SpinxTooltipWindow ); + layoutconfig->writeEntry ( "Logo", m_SpinxTooltipLogo ); + + layoutconfig->setGroup ( "TopBar" ); + layoutconfig->writeEntry ( "DudeX", m_facePos_x ); + layoutconfig->writeEntry ( "DudeY", m_facePos_y ); + layoutconfig->writeEntry ( "FaceX",m_faceIconX ); + layoutconfig->writeEntry ( "FaceY",m_faceIconY ); + layoutconfig->writeEntry ( "FaceH",m_faceIconH ); + layoutconfig->writeEntry ( "FaceW",m_faceIconW ); + layoutconfig->writeEntry ( "UserNameX", m_userNamePos_x ); + layoutconfig->writeEntry ( "UserNameY", m_userNamePos_y ); + layoutconfig->writeEntry ( "DisableUserName", m_faceBoxHideText ); + layoutconfig->writeEntry ( "Height", m_topBar_h ); + layoutconfig->writeEntry ( "Width", m_topBar_w ); + layoutconfig->writeEntry ( "X", m_topBar_x ); + layoutconfig->writeEntry ( "Y", m_topBar_y ); + + layoutconfig->setGroup ( "BottomBar" ); + layoutconfig->writeEntry ( "Height", m_botBar_h ); + layoutconfig->writeEntry ( "Width", m_botBar_w ); + layoutconfig->writeEntry ( "X", m_botBar_x ); + layoutconfig->writeEntry ( "Y", m_botBar_y ); + + layoutconfig->setGroup ( "Scrollbars" ); + layoutconfig->writeEntry ( "ScrollBarBotX", m_scrollBarBotX ); + layoutconfig->writeEntry ( "ScrollBarBotY", m_scrollBarBotY ); + layoutconfig->writeEntry ( "ScrollBarTopX", m_scrollBarTopX ); + layoutconfig->writeEntry ( "ScrollBarTopY", m_scrollBarTopY ); + + layoutconfig->setGroup ( "ListBox" ); + layoutconfig->writeEntry ( "Height", m_listBox_h ); + layoutconfig->writeEntry ( "Width", m_listBox_w ); + layoutconfig->writeEntry ( "X", m_listBox_x ); + layoutconfig->writeEntry ( "Y", m_listBox_y ); + + layoutconfig->setGroup ( "SearchBox" ); + layoutconfig->writeEntry ( "Height", m_searchBox_h ); + layoutconfig->writeEntry ( "Width", m_searchBox_w ); + layoutconfig->writeEntry ( "X", m_searchBox_x ); + layoutconfig->writeEntry ( "Y", m_searchBox_y ); + layoutconfig->writeEntry ( "FixedPos", m_searchBox_static ); + + layoutconfig->setGroup ( "ItemView" ); + layoutconfig->writeEntry ( "Height", m_itemView_h ); + layoutconfig->writeEntry ( "Width", m_itemView_w ); + layoutconfig->writeEntry ( "X", m_itemView_x ); + layoutconfig->writeEntry ( "Y", m_itemView_y ); + + layoutconfig->setGroup ( "ToolBar" ); + layoutconfig->writeEntry ( "ButtonNormalSize", m_toolBarButtonNormalSize ); + layoutconfig->writeEntry ( "ButtonPressedSize", m_toolBarButtonExpandSize ); + + layoutconfig->setGroup ( "MainMenu" ); + layoutconfig->writeEntry ( "UserMenuHeight",m_userMenuHeight ); + layoutconfig->writeEntry ( "UserMenuWidth",m_userMenuWidth ); + layoutconfig->writeEntry ( "ContractedMenu", m_startHidden ); + + layoutconfig->setGroup ( "ItemProperties" ); + layoutconfig->writeEntry ( "NoComments",m_noComments ); + layoutconfig->writeEntry ( "CommentMargin",m_commentMargine ); + layoutconfig->writeEntry ( "IconSize",m_iconSize ); + + layoutconfig->sync(); + + delete layoutconfig; +} + +void KbfxConfig::checkValues() +{ + /* Protect some of the values */ + m_fadeTime = ( m_fadeTime == 0 ) ? m_fadeTime: ( m_fadeTime < 20 ) ? 20: ( m_fadeTime > 1000 ) ? 1000: m_fadeTime; +} diff --git a/kbfxlib/common/kbfxconfig.h b/kbfxlib/common/kbfxconfig.h new file mode 100644 index 0000000..739524b --- /dev/null +++ b/kbfxlib/common/kbfxconfig.h @@ -0,0 +1,295 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_CONFIG_H +#define KBFX_CONFIG_H + +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +class KbfxConfig +{ + public: + void read(); + void readFontrc ( QString &themePath, QString &themeName, bool user_rc=TRUE ); + void readThemerc ( QString &themePath, QString &themeName, bool user_rc=TRUE ); + void readThemeInfo ( QString &themePath, QString &themeName ); + void setDefault(); + void setThemeDefault(); + void setFontsDefault(); + void setThemeInfoDefault(); + void write(); + void writeFontrc ( QString &themeName ); + void writeThemerc ( QString &themeName ); + void checkValues(); + + /* Theme info resources */ + QString m_InfoVersion; + QString m_InfoVersionDefault; + QString m_InfoAuthor; + QString m_InfoAuthorDefault; + QString m_InfoEmail; + QString m_InfoEmailDefault; + QString m_InfoUrl; + QString m_InfoUrlDefault; + + /* kbfx_menu_button config items list */ + QString m_KbfxThemesVersion; + QString KbfxThemeRcDestination; + QString KbfxRcPath; + QPixmap KbfxOnImg; + QPixmap KbfxOffImg; + int m_KbfxGeneralVersion; + int m_KbfxGeneralVersionDefault; + QString m_KbfxNormalButtonPath; + QString m_KbfxNormalButtonPathDefault; + QString m_KbfxHoverButtonPath; + QString m_KbfxHoverButtonPathDefault; + QString m_KbfxPressedButtonPath; + QString m_KbfxPressedButtonPathDefault; + QString m_KbfxMouseOverAnimationPath; + QString m_KbfxMouseOverAnimationPathDefault; + QColor m_KbfxButtonColor; + QColor m_KbfxButtonColorDefault; + int m_KbfxButtonSize; + int m_KbfxButtonSizeDefault; + bool m_KbfxButtonGlow; + bool m_KbfxButtonGlowDefault; + bool m_KbfxButtonKikerResize; + bool m_KbfxButtonKikerResizeDefault; + QString m_KbfxMenuType; + QString m_KbfxMenuTypeDefault; + + /* spinx config items list */ + QString m_SpinxThemeBasePath; + QString m_SpinxThemeBasePathDefault; + QString m_UserSpinxThemeBasePath; + QString m_UserSpinxThemeBasePathDefault; + bool m_SpinxDudeBlink; + bool m_SpinxDudeBlinkDefault; + QString m_SpinxDudeImage; + QString m_SpinxDudeImageDefault; + QString m_SpinxThemeName; + QString m_SpinxThemeNameDefault; + bool m_ToolBarResize; + bool m_ToolBarResizeDefault; + bool m_KbfxWatcher; + bool m_KbfxWatcherDefault; + bool m_KbfxShowOldThemes; + bool m_KbfxShowOldThemesDefault; + + + /* tooltip options list */ + bool m_ToolTipAnimation; + bool m_ToolTipAnimationDefault; + bool m_ToolTip; + bool m_ToolTipDefault; + QString m_ToolTipText; + QString m_ToolTipTextDefault; + QString m_ToolTipAvatar; + QString m_ToolTipAvatarDefault; + QString m_SpinxTooltipDudebox; + QString m_SpinxTooltipDudeboxDefault; + QString m_SpinxTooltipMask; + QString m_SpinxTooltipMaskDefault; + QString m_SpinxTooltipWindow; + QString m_SpinxTooltipWindowDefault; + QString m_SpinxTooltipLogo; + QString m_SpinxTooltipLogoDefault; + + QString m_KbfxHistory; + QString m_KbfxHistoryDefault; + + /* font settings */ + QColor m_fontTooltipColor; + QColor m_fontTooltipColorDefault; + QFont m_fontTooltipFont; + QFont m_fontTooltipFontDefault; + QColor m_fontAppNameColor; + QColor m_fontAppNameColorDefault; + QFont m_fontAppNameFont; + QFont m_fontAppNameFontDefault; + QColor m_fontAppCommentColor; + QColor m_fontAppCommentColorDefault; + QFont m_fontAppCommentFont; + QFont m_fontAppCommentFontDefault; + QColor m_lineColor; + QColor m_lineColorDefault; + QColor m_fontIndexColor; + QColor m_fontIndexColorDefault; + QFont m_fontIndexFont; + QFont m_fontIndexFontDefault; + QColor m_userImageColor; + QColor m_userImageColorDefault; + QColor m_userNameColor; + QColor m_userNameColorDefault; + QFont m_userNameFont; + QFont m_userNameFontDefault; + QColor m_sepNameColor; + QColor m_sepNameColorDefault; + QFont m_sepNameFont; + QFont m_sepNameFontDefault; + QColor m_pluginNameColor; + QColor m_pluginNameColorDefault; + QFont m_pluginNameFont; + QFont m_pluginNameFontDefault; + bool m_fontHoverBold; + bool m_fontHoverBoldDefault; + + /* history */ + QStringList m_pluginsLeft; + QStringList m_pluginsLeftDefault; + QStringList m_pluginsRight; + QStringList m_pluginsRightDefault; + + /* layout */ + int m_facePos_x; + int m_facePos_xDefault; + int m_facePos_y; + int m_facePos_yDefault; + int m_userNamePos_x; + int m_userNamePos_xDefault; + int m_userNamePos_y; + int m_userNamePos_yDefault; + bool m_faceBoxHideText; + bool m_faceBoxHideTextDefault; + int m_userMenuHeight; + int m_userMenuHeightDefault; + int m_userMenuWidth; + int m_userMenuWidthDefault; + + int m_topBar_x; + int m_topBar_xDefault; + int m_topBar_y; + int m_topBar_yDefault; + int m_topBar_h; + int m_topBar_hDefault; + int m_topBar_w; + int m_topBar_wDefault; + + int m_botBar_x; + int m_botBar_xDefault; + int m_botBar_y; + int m_botBar_yDefault; + int m_botBar_h; + int m_botBar_hDefault; + int m_botBar_w; + int m_botBar_wDefault; + + int m_scrollBarTopX; + int m_scrollBarTopXDefault; + int m_scrollBarTopY; + int m_scrollBarTopYDefault; + int m_scrollBarBotX; + int m_scrollBarBotXDefault; + int m_scrollBarBotY; + int m_scrollBarBotYDefault; + + int m_listBox_x; + int m_listBox_xDefault; + int m_listBox_y; + int m_listBox_yDefault; + int m_listBox_w; + int m_listBox_wDefault; + int m_listBox_h; + int m_listBox_hDefault; + + int m_searchBox_x; + int m_searchBox_xDefault; + int m_searchBox_y; + int m_searchBox_yDefault; + int m_searchBox_w; + int m_searchBox_wDefault; + int m_searchBox_h; + int m_searchBox_hDefault; + bool m_searchBox_static; + bool m_searchBox_staticDefault; + + int m_itemView_x; + int m_itemView_xDefault; + int m_itemView_y; + int m_itemView_yDefault; + int m_itemView_h; + int m_itemView_hDefault; + int m_itemView_w; + int m_itemView_wDefault; + + int m_fadeTime; + int m_fadeTimeDefault; + + /* toolbar */ + int m_toolBarButtonNormalSizeDefault; + int m_toolBarButtonNormalSize; + int m_toolBarButtonExpandSizeDefault; + int m_toolBarButtonExpandSize; + + /* Face Icon */ + int m_faceIconX; + int m_faceIconXDefault; + int m_faceIconY; + int m_faceIconYDefault; + int m_faceIconH; + int m_faceIconHDefault; + int m_faceIconW; + int m_faceIconWDefault; + + /* element controll */ + int m_iconSize; + int m_iconSizeDefault; + bool m_noComments; + bool m_noCommentsDefault; + int m_commentMargine; + int m_commentMargineDefault; + /* states */ + bool m_startHidden; + bool m_startHiddenDefault; + + bool m_KbfxDeleteOldConf; + + private: + KbfxConfig(); + KbfxConfig ( const KbfxConfig& ); + + friend KbfxConfig& ConfigInit(); +}; + +KbfxConfig & ConfigInit(); + +#endif + diff --git a/kbfxlib/common/kbfxfontchooser.cpp b/kbfxlib/common/kbfxfontchooser.cpp new file mode 100644 index 0000000..c05a81e --- /dev/null +++ b/kbfxlib/common/kbfxfontchooser.cpp @@ -0,0 +1,79 @@ +//************************************************************************** +// Copyright (C) 2004, 2005 by Petri Damstn +// petri.damsten@iki.fi +// +// 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. +//************************************************************************** + +#include "kbfxfontchooser.h" + +KBFXFontChooser::KBFXFontChooser ( QWidget *parent, const char *name ) + : QWidget ( parent, name ) +{ + QHBoxLayout* layout = new QHBoxLayout ( this, 0, KDialog::spacingHint() ); + + m_label = new QLabel ( this, "fontLabel" ); + m_label->setSizePolicy ( QSizePolicy::Expanding, QSizePolicy::Fixed, TRUE); +// m_label->setFrameShape ( QFrame::StyledPanel ); +// m_label->setFrameShadow ( QFrame::Sunken ); + + layout->addWidget ( m_label ); + + m_button = new QPushButton ( this, "fontButton" ); + m_label->setMaximumHeight ( m_button -> height() ); + m_label->setMinimumHeight ( m_button -> height() ); + QString fontText = i18n ( "Font..." ); +// m_button->setSizePolicy ( QSizePolicy::Minimum, QSizePolicy::Minimum, TRUE); + m_button->setText ( fontText ); + QIconSet iconSet = SmallIconSet ( QString::fromLatin1 ( "fonts" ) ); + QPixmap pixmap = iconSet.pixmap ( QIconSet::Small, QIconSet::Normal ); + m_button->setIconSet ( iconSet ); + m_button->setFixedWidth ( m_button->fontMetrics().width ( fontText ) + + 3 * KDialog::spacingHint() + pixmap.width() ); + layout->addWidget ( m_button ); + + connect ( m_button, SIGNAL ( clicked() ), this, SLOT ( buttonClicked() ) ); + + updateFontLabel(); + + setFocusProxy ( m_button ); +} + +KBFXFontChooser::~KBFXFontChooser() +{} + +void KBFXFontChooser::setFont ( const QFont& font ) +{ + m_font = font; + updateFontLabel(); +} + +void KBFXFontChooser::updateFontLabel() +{ + QString s = QString ( "%1 (%2pt) " ).arg ( m_font.family() ).arg ( m_font.pointSize() ); + m_label->setFont ( m_font ); + m_label->setText ( s ); + m_label->setAlignment ( Qt::AlignLeft | Qt::AlignVCenter ); + emit FontChanged(); +} + +void KBFXFontChooser::buttonClicked() +{ + KFontDialog::getFont ( m_font ); + updateFontLabel(); +} + +#include "kbfxfontchooser.moc" diff --git a/kbfxlib/common/kbfxfontchooser.h b/kbfxlib/common/kbfxfontchooser.h new file mode 100644 index 0000000..639a674 --- /dev/null +++ b/kbfxlib/common/kbfxfontchooser.h @@ -0,0 +1,70 @@ +//************************************************************************** +// Copyright (C) 2004, 2005 by Petri Damstn +// petri.damsten@iki.fi +// +// 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. +//************************************************************************** +#ifndef KBFX_FONT_CHOOSER_H +#define KBFX_FONT_CHOOSER_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class QLabel; +class QPushButton; +class QFont; + +/** + @author Petri Damsten +*/ + +class KBFXFontChooser : public QWidget +{ + Q_OBJECT + Q_PROPERTY ( QFont font READ font WRITE setFont ) + public: + KBFXFontChooser ( QWidget *parent = 0, const char *name = 0 ); + ~KBFXFontChooser(); + + QFont font() const { return m_font; }; + + public slots: + void setFont ( const QFont& font ); + + protected: + void updateFontLabel(); + + protected slots: + void buttonClicked(); + + private: + QFont m_font; + QLabel* m_label; + QPushButton* m_button; + + signals: + void FontChanged(); +}; + +#endif diff --git a/kbfxlib/common/kbfxkiodownload.cpp b/kbfxlib/common/kbfxkiodownload.cpp new file mode 100644 index 0000000..ff6dccc --- /dev/null +++ b/kbfxlib/common/kbfxkiodownload.cpp @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxkiodownload.h" + +KbfxKioDownload::KbfxKioDownload ( QObject *parent, const char *name ) + : QObject ( parent, name ) +{ + m_KbfxBrowserError = 0; + m_KbfxBrowserErrorText = "No error"; + m_KbfxBrowserTmpFile = tmpF.name(); + + kdDebug() << "Created temp file for download transfer: " + << m_KbfxBrowserTmpFile + << endl; +} + +KbfxKioDownload::~KbfxKioDownload() +{} + +void KbfxKioDownload::KbfxKioDownloadStart ( QString &url ) +{ + KIO::Job *download_job = KIO::file_copy ( KURL ( url ), + KURL ( m_KbfxBrowserTmpFile ), + -1, + TRUE ); + connect ( download_job, SIGNAL ( result ( KIO::Job* ) ), + this, SLOT ( KbfxBrowserResult ( KIO::Job * ) ) ); +} + +void KbfxKioDownload::KbfxBrowserResult ( KIO::Job *download_job ) +{ + m_KbfxBrowserError = download_job->error(); + + if ( m_KbfxBrowserError ) + { + KbfxKioDownloadEnd(); + m_KbfxBrowserErrorText = download_job->errorString(); + } + else m_KbfxBrowserErrorText = "No error"; + + kdDebug() << "Download transfer error: " + << m_KbfxBrowserError + << " - " + << m_KbfxBrowserErrorText + << endl; + + emit KbfxKioDownloadReady(); +} + +void KbfxKioDownload::KbfxKioDownloadEnd() +{ + kdDebug() << "Deleting temp file for download transfer: " + << tmpF.name() + < + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_KIO_DOWNLOAD_H +#define KBFX_KIO_DOWNLOAD_H + +#include +#include +#include + +/** + * @author PhobosK + */ +class KbfxKioDownload : public QObject +{ + Q_OBJECT + + public: + KbfxKioDownload ( QObject * parent = 0, const char * name = 0 ); + ~KbfxKioDownload(); + + /* KbfxKioDownload invocation - pass an url as QString */ + void KbfxKioDownloadStart ( QString &url ); + + /* return temp file name for the download */ + QString KbfxBrowserTmpFile() {return m_KbfxBrowserTmpFile;} + + /* return error number occured during download + * see definition in global.h + */ + int KbfxBrowserError() {return m_KbfxBrowserError;} + + /* return error text occured during download */ + QString KbfxBrowserErrorText() {return m_KbfxBrowserErrorText;} + + protected: + QString m_KbfxBrowserTmpFile; + int m_KbfxBrowserError; + QString m_KbfxBrowserErrorText; + + private: + KTempFile tmpF; + + public slots: + /* call when you are ready to delete the temp file for the download */ + virtual void KbfxKioDownloadEnd(); + + private slots: + /* current job is done here */ + virtual void KbfxBrowserResult ( KIO::Job * ); + + signals: + /* emitted when the download is ready */ + void KbfxKioDownloadReady(); +}; + +#endif diff --git a/kbfxlib/common/kbfxpixmaplabel.cpp b/kbfxlib/common/kbfxpixmaplabel.cpp new file mode 100644 index 0000000..a85627e --- /dev/null +++ b/kbfxlib/common/kbfxpixmaplabel.cpp @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxpixmaplabel.h" + +KbfxPixmapLabel::KbfxPixmapLabel ( QWidget *parent, const char *name, WFlags fl ) + : QLabel ( parent, name, fl ) +{ + // setFrameShape(QLabel::WinPanel); + // setFrameShadow(QLabel::Sunken); + setFrameShape ( QLabel::LineEditPanel ); + setFrameShadow ( QLabel::Plain ); + setScaledContents ( FALSE ); + setAlignment ( int ( QLabel::WordBreak | QLabel::AlignCenter ) ); + setMouseTracking ( TRUE ); +} + +KbfxPixmapLabel::~KbfxPixmapLabel() +{ +} + +/* normalize label */ +void KbfxPixmapLabel::normalize () +{ + setFrameShape ( QLabel::NoFrame ); + setFrameShadow ( QLabel::Plain ); + setScaledContents ( FALSE ); + setAlignment ( int ( QLabel::WordBreak | QLabel::AlignCenter ) ); +} + +/* processing drag events over label */ +void KbfxPixmapLabel::dragEnterEvent ( QDragEnterEvent *mouseDragEnterEvent ) +{ + kdDebug() << "Accepting drag..." << endl; + mouseDragEnterEvent->accept ( QTextDrag::canDecode ( mouseDragEnterEvent ) ); +} + +/* processing drop events over label */ +void KbfxPixmapLabel::dropEvent ( QDropEvent *mouseDropEvent ) +{ + QString text; + + if ( QTextDrag::decode ( mouseDropEvent,text ) ) + { + if ( text.startsWith ( "file://" ) ) text.remove ( "file://" ); + + kdDebug() << "Dropping drag..." << text << endl; + + emit targetDrop ( text ); + } +} + +/* processing mouse click events over label */ +void KbfxPixmapLabel::mousePressEvent ( QMouseEvent * e ) +{ + e->accept(); + ButtonState _btn = e->button(); + kdDebug() << "Mouse Clicked: " << _btn << endl; + emit clicked(); + emit mouseClicked (); + emit mouseClicked ( _btn ); +} + +/* processing mouse double click events over label */ +void KbfxPixmapLabel::mouseDoubleClickEvent ( QMouseEvent * e ) +{ + e->accept(); + ButtonState _btn = e->button(); + kdDebug() << "Mouse Double Clicked: " << _btn << endl; + emit mouseDoubleClicked (); + emit mouseDoubleClicked ( _btn ); +} + +#include "kbfxpixmaplabel.moc" diff --git a/kbfxlib/common/kbfxpixmaplabel.h b/kbfxlib/common/kbfxpixmaplabel.h new file mode 100644 index 0000000..1e20b99 --- /dev/null +++ b/kbfxlib/common/kbfxpixmaplabel.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_PIXMAP_LABEL_H +#define KBFX_PIXMAP_LABEL_H + +#include +#include +#include +#include + +class KbfxPixmapLabel : public QLabel +{ + Q_OBJECT + + public: + KbfxPixmapLabel ( QWidget *parent = 0, const char *name = 0, WFlags f = 0 ); + ~KbfxPixmapLabel (); + + void dragEnterEvent ( QDragEnterEvent *mouseDragEnterEvent ); + void dropEvent ( QDropEvent *mouseDropEvent ); + void mousePressEvent ( QMouseEvent * e ); + void mouseDoubleClickEvent ( QMouseEvent * e ); + void normalize (); + + signals: + void targetDrop ( const QString & ); + void clicked(); + void mouseClicked (); + void mouseClicked ( const ButtonState & ); + void mouseDoubleClicked (); + void mouseDoubleClicked ( const ButtonState & ); +}; + +#endif // KBFX_PIXMAP_LABEL_H diff --git a/kbfxlib/common/kbfxplasmapixmapprovider.cpp b/kbfxlib/common/kbfxplasmapixmapprovider.cpp new file mode 100644 index 0000000..e505c62 --- /dev/null +++ b/kbfxlib/common/kbfxplasmapixmapprovider.cpp @@ -0,0 +1,146 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxplasmapixmapprovider.h" + +int +KbfxPlasmaPixmapProvider::addPixmap ( QString pixmapname ) +{ + QString lFileName = PixmapPath( pixmapname ); + QPixmap * lPixmapPtr = 0; + + if ( ( lPixmapPtr = QPixmapCache::find ( pixmapname ) ) == NULL ) + { + lPixmapPtr = new QPixmap ( lFileName ); + QPixmapCache::insert ( pixmapname,lPixmapPtr ); + return ( lPixmapPtr->height() *lPixmapPtr->width() *lPixmapPtr->depth() ) /8; + } + return 0; +} + +QString +KbfxPlasmaPixmapProvider::PixmapPath ( QString pixmapName ) +{ + QString lFileName = ConfigInit ().m_SpinxThemeBasePath + ConfigInit ().m_SpinxThemeName + "/" + pixmapName + ".png"; + + if ( QPixmap::QPixmap ( lFileName ).isNull() ) + lFileName = locate ( "data", "kbfx/skins/default/" + pixmapName + ".png" ); + + return lFileName; +} + +QString +KbfxPlasmaPixmapProvider::PixmapPath ( QString pixmapName, QString themePath, QString themeName ) +{ + QString lFileName = themePath + themeName + "/" + pixmapName + ".png"; + + if ( QPixmap::QPixmap ( lFileName ).isNull() ) + lFileName = locate ( "data", "kbfx/skins/default/" + pixmapName + ".png" ); + + return lFileName; +} + +bool +KbfxPlasmaPixmapProvider::PixmapPathCheck ( QString pixmapPath ) +{ + if ( QPixmap::QPixmap ( pixmapPath ).isNull() ) + return FALSE; + + return TRUE; +} + +void +KbfxPlasmaPixmapProvider::deletePixmap ( const QString & key ) +{ + QPixmapCache::remove ( key ); +} + +void +KbfxPlasmaPixmapProvider::rebuildCache() +{ + QPixmapCache::clear (); + buildCache(); +} + +void KbfxPlasmaPixmapProvider::buildCache() +{ +//m_skinElements.append("topbg"); + QPixmapCache::setCacheLimit ( 1024*5 ); + static QStringList m_skinElements; + m_skinElements + <<"appfind" + <<"bg" + <<"botbg" + <<"butterfly" + <<"dudebox" + <<"find" + <<"hover" + <<"indexseparator" + <<"listboxbg" + <<"lock" + <<"lockhover" + <<"logout" + <<"logouthover" + <<"mask" + <<"menu_top" + <<"menu_top_image_person" + <<"middleboxbg" + <<"normal" + <<"off" + <<"on" + <<"pressed" + <<"preview" + <<"rhshovertile" + <<"rhstile" + <<"scrollnormal" + <<"separator" + <<"tabbg" + <<"tilehover" + <<"tilenormal" + <<"topbg" + <<"appviewbg" + ; + + for ( QStringList::Iterator it = m_skinElements.begin(); it != m_skinElements.end(); ++it ) + { + QPixmapCache::setCacheLimit ( KbfxPlasmaPixmapProvider::addPixmap ( *it ) +QPixmapCache::cacheLimit() ); + } + + +} + +QPixmap * +KbfxPlasmaPixmapProvider::pixmap ( const QString & key ) +{ + QPixmap* pp; + QPixmap p; + if ( ( pp=QPixmapCache::find ( key ) ) ) + { + return pp; + } + else + { + addPixmap ( key ); + return pixmap ( key ); + } + +} + diff --git a/kbfxlib/common/kbfxplasmapixmapprovider.h b/kbfxlib/common/kbfxplasmapixmapprovider.h new file mode 100644 index 0000000..00fd5b4 --- /dev/null +++ b/kbfxlib/common/kbfxplasmapixmapprovider.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_PLASMA_PIXMAP_PROVIDER_H +#define KBFX_PLASMA_PIXMAP_PROVIDER_H + + +#include +#include +#include +#include +#include + +#include + +class KbfxPlasmaPixmapProvider +{ + + public: + + KbfxPlasmaPixmapProvider() + {} + ~KbfxPlasmaPixmapProvider() {} + + static int addPixmap ( QString ); + static void deletePixmap ( const QString & ); + static void rebuildCache(); + static void buildCache(); + static QPixmap* pixmap ( const QString & ); + static QString PixmapPath ( QString, QString, QString ); + static QString PixmapPath ( QString ); + static bool PixmapPathCheck ( QString ); +}; + +#endif diff --git a/kbfxlib/common/kbfxpushbutton.cpp b/kbfxlib/common/kbfxpushbutton.cpp new file mode 100644 index 0000000..e971993 --- /dev/null +++ b/kbfxlib/common/kbfxpushbutton.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxpushbutton.h" + +KbfxPushButton::KbfxPushButton ( QWidget *parent, const char *name ) + : KPushButton ( parent, name ) +{ + setText ( "P R E V I E W" ); + setToggleButton ( TRUE ); + setFocusPolicy ( QWidget::NoFocus ); +} + +KbfxPushButton::~KbfxPushButton() +{ +} + +/* process hover events */ +void KbfxPushButton::enterEvent ( QEvent * ) +{ + if ( this->state() == 0 ) this->setPixmap ( ConfigInit().m_KbfxHoverButtonPath ); +} + +void KbfxPushButton::leaveEvent ( QEvent * ) +{ + if ( this->state() == 2 ) this->setPixmap ( ConfigInit().m_KbfxPressedButtonPath ); + if ( this->state() == 0 ) this->setPixmap ( ConfigInit().m_KbfxNormalButtonPath ); +} + +#include "kbfxpushbutton.moc" diff --git a/kbfxlib/common/kbfxpushbutton.h b/kbfxlib/common/kbfxpushbutton.h new file mode 100644 index 0000000..3d90bf7 --- /dev/null +++ b/kbfxlib/common/kbfxpushbutton.h @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_PUSH_BUTTON_H +#define KBFX_PUSH_BUTTON_H + +#include + +#include "kbfxconfig.h" + +class KbfxPushButton: public KPushButton +{ + Q_OBJECT + + public: + KbfxPushButton ( QWidget *parent = 0, const char *name = 0 ); + ~KbfxPushButton(); + + void enterEvent ( QEvent * ); + void leaveEvent ( QEvent * ); +}; + +#endif // KBFX_PUSH_BUTTON_H diff --git a/kbfxlib/common/kbfxthemesdata.cpp b/kbfxlib/common/kbfxthemesdata.cpp new file mode 100644 index 0000000..2ebaa10 --- /dev/null +++ b/kbfxlib/common/kbfxthemesdata.cpp @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxthemesdata.h" + +KbfxThemesData::KbfxThemesData() +{} + +KbfxThemesData::~KbfxThemesData() +{ + m_themesMap.clear(); +} + +ThemesMap KbfxThemesData::setThemeList ( QString path ) +{ + QString m_KbfxThemesVersion = ConfigInit().m_KbfxThemesVersion; + bool m_KbfxShowOldThemes = ConfigInit().m_KbfxShowOldThemes; + QFileInfo *fi=0, *f=0; + + m_themesMap.clear(); + + KStandardDirs *tmp = new KStandardDirs(); + + /* search themes in KDE Resource Folders and append user selected folder */ + QStringList skinsFolders = tmp->findDirs ( "data", "kbfx/skins" ); + if ( tmp->exists ( path ) ) + { + skinsFolders.append ( path ); + } + else + { + kdDebug() << "KbfxThemesData: Path doesn't exist! :" << path << endl; + } + + for ( QStringList::Iterator skinsIt = skinsFolders.begin(); skinsIt != skinsFolders.end(); ++skinsIt ) + { + QDir d ( *skinsIt ); + d.setFilter ( QDir::Dirs ); + + const QFileInfoList *list = d.entryInfoList(); + QFileInfoListIterator it ( *list ); + + while ( ( fi = it.current() ) != 0 ) + { + if ( !fi->fileName().startsWith ( "." ) ) + { + f = new QFileInfo ( d, fi->fileName() + "/" + m_KbfxThemesVersion ); + if ( m_KbfxShowOldThemes ) + { + m_themesMap[fi->fileName() ] = ( fi->dirPath ( TRUE ) ).append ( "/" ); + } + else + { + if ( f->exists () ) + m_themesMap[fi->fileName() ] = ( fi->dirPath ( TRUE ) ).append ( "/" ); + } + } + ++it; + } + } + + /* kdDebug() << "Available Themes - " + * << m_themesMap.keys() + * << m_themesMap.values() + * << endl; + */ + + delete fi; + delete f; + delete tmp; + return m_themesMap; +} diff --git a/kbfxlib/common/kbfxthemesdata.h b/kbfxlib/common/kbfxthemesdata.h new file mode 100644 index 0000000..5dd0bf1 --- /dev/null +++ b/kbfxlib/common/kbfxthemesdata.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_THEMES_DATA_H +#define KBFX_THEMES_DATA_H + +#include +#include +#include +#include +#include +#include +#include + +#include "kbfxconfig.h" + +typedef QMap ThemesMap; + +/** + * @author PhobosK + */ +class KbfxThemesData +{ + public: + KbfxThemesData(); + ~KbfxThemesData(); + + ThemesMap setThemeList ( QString path ); + + private: + ThemesMap m_themesMap; +}; + +#endif diff --git a/kbfxlib/data/CMakeLists.txt b/kbfxlib/data/CMakeLists.txt new file mode 100644 index 0000000..676ef78 --- /dev/null +++ b/kbfxlib/data/CMakeLists.txt @@ -0,0 +1,48 @@ +SET(libkbfxdatasrc + kbfxdatagroup.cpp + kbfxdatagrouplist.cpp + kbfxdatasource.cpp + kbfxdatastack.cpp + kbfxplasmadataplugin.cpp + kbfxplasmapluginloader.cpp + kbfxplugin.cpp + ) + +FILE(GLOB HEADERS *.h) + +IF (NOT USE_KDE4) + KDE3_AUTOMOC(${libkbfxdatasrc}) + + ADD_LIBRARY(kbfxdata SHARED ${libkbfxdatasrc}) + SET_TARGET_PROPERTIES(kbfxdata + PROPERTIES + COMPILE_FLAGS ${CMAKE_SHARED_LIBRARY_CXX_FLAGS}) + # SET_TARGET_PROPERTIES(kbfxdata PROPERTIES + # SOVERSION ${LIB_MAJOR} + # VERSION ${APPLICATION_VERSION}) + TARGET_LINK_LIBRARIES(kbfxdata + ${QT_AND_KDECORE_LIBS} + ${KDE3_KIO_LIBRARY} + ${KDE3_UI_LIBRARY} + ${KDE3_KHTML_LIBRARY} + ${M_LIBRARY} + ) + + KDE3_INSTALL_LIBTOOL_FILE(kbfxdata ${LIB_INSTALL_DIR}) +ELSE (NOT USE_KDE4) + KDE4_AUTOMOC(${libkbfxdatasrc}) + + KDE4_ADD_LIBRARY(kbfxdata SHARED ${libkbfxdatasrc}) + TARGET_LINK_LIBRARIES(kbfxdata + ${KDE4_KDECORE_LIBS} + ${KDE4_KIO_LIBS} + ${KDE4_KDEUI_LIBS} + ${KDE4_KHTML_LIBS} + ${M_LIBRARY} + ) + + KDE4_INSTALL_LIBTOOL_FILE(kbfxdata ${LIB_INSTALL_DIR}) +ENDIF (NOT USE_KDE4) + +INSTALL(TARGETS kbfxdata DESTINATION ${LIB_INSTALL_DIR}) +INSTALL(FILES ${HEADERS} DESTINATION ${INCLUDE_INSTALL_DIR}/kbfx/data) diff --git a/kbfxlib/data/kbfxdatagroup.cpp b/kbfxlib/data/kbfxdatagroup.cpp new file mode 100644 index 0000000..5c097a6 --- /dev/null +++ b/kbfxlib/data/kbfxdatagroup.cpp @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxdatagroup.h" + +KbfxDataGroup::KbfxDataGroup() +{ + m_name = "Uknown Group"; + m_count = 0; +} + +KbfxDataGroup::~KbfxDataGroup() +{ + Data::Iterator it; + for ( it = m_data.begin();it!=m_data.end();++it ) + { + delete it.data(); + m_data.remove ( it ); + //delete *it; + } + m_data.clear(); +} + +KbfxDataSource::DataSourceList +KbfxDataGroup::lookup ( QString str ) +{ +//static KbfxDataGroup * _matching = new KbfxDataGroup(); + KbfxDataSource::DataSourceList _matching; + Data::Iterator it; + for ( it = m_data.begin();it!=m_data.end();++it ) + { + if ( ( *it )->lookup ( str ) == true ) + { + _matching.prepend ( * ( *it ) ); + } + } + + return _matching; +} + +void +KbfxDataGroup::addItem ( KbfxDataSource * item ) +{ + if ( item == 0 ) + return ; + m_data[item->name() ] = item; + m_index[m_count] = item; + m_count++; + +// qDebug("KbfxDataGroup.cpp::addItem("+item->name()+")"); +} + +KbfxDataSource* +KbfxDataGroup::itemAt(int index) +{ + if ( index < 0 || index > m_count) + return new KbfxDataSource(); + else + return m_index[index]; +} + + +KbfxDataSource * +KbfxDataGroup::getItem ( QString name ) +{ + return m_data[name]; +} + +KbfxDataGroup::Data +KbfxDataGroup::getData() +{ + return m_data; +} + diff --git a/kbfxlib/data/kbfxdatagroup.h b/kbfxlib/data/kbfxdatagroup.h new file mode 100644 index 0000000..7587502 --- /dev/null +++ b/kbfxlib/data/kbfxdatagroup.h @@ -0,0 +1,100 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_DATA_GROUP_H +#define KBFX_DATA_GROUP_H + +#include +#include +#include "kbfxdatasource.h" + +class KbfxDataGroup +{ + + public: + typedef QMap Data; + typedef QMap Index; + + /** + * Construts a new data group and initialzes the group + * @return Constructs a new Datagroup + */ + KbfxDataGroup(); + /** + * De-allocates and frees the meomery when destroyed + * @return + */ + ~KbfxDataGroup(); + /** + * Adds a new DataSource to the Group + * null pointers and invalid datasources are handled + * internally no manal checking is needed + * @param item A pointer to a datasource valid or invalid + */ + void addItem ( KbfxDataSource * item ); + /** + * Sets a proper Name to the group. The default will be set to + * "Unknown Group" . it is recomended that a name is always set + * @param name The name that should be give to the group + */ + void setName ( QString name ) {m_name = name;} + /** + * To access a datasource give the name of the datasource + * @param The name othe datasource + * @return pointer to a valid datasource + */ + KbfxDataSource * getItem ( QString ); + /** + * use this to get all the items inside the datagroup + * @return a copy of the data Map (QMap) + */ + Data getData(); + /** + * searches and returns the list of matching datasources + * @param keyword to search for + * @return list of matching datasources + */ + KbfxDataSource::DataSourceList lookup ( QString ); + /** + * The name of the group + * @return Name of the group + */ + QString name() {return m_name;} + /** + * The number of datasources inside the datagroup + * @return number of datasources + */ + int count() {return m_count;} + /** + * + * + * + */ + KbfxDataSource * itemAt(int index); + + private: + Data m_data; + QString m_name; + int m_count; + Index m_index; +}; + +#endif diff --git a/kbfxlib/data/kbfxdatagrouplist.cpp b/kbfxlib/data/kbfxdatagrouplist.cpp new file mode 100644 index 0000000..5f89b5f --- /dev/null +++ b/kbfxlib/data/kbfxdatagrouplist.cpp @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxdatagrouplist.h" + +KbfxDataGroupList::KbfxDataGroupList() +{ + m_name="Unset"; + m_iconPath= ""; + m_count = 0; +//m_groupList.setAutoDelete(true); +} + +KbfxDataGroupList::~KbfxDataGroupList() +{ +} + +void +KbfxDataGroupList::addGroup ( KbfxDataGroup * group ) +{ + + + for ( int i =0; i < ( int ) m_groupList.count();i++ ) + { +// qDebug("Curent loop + "+m_groupList.at(i)->name()+"adding "+group->name()); + if ( m_groupList.at ( i ) == group ) + { + return ; + } + } +//above is to save from bad plugins + + m_groupList.append ( group ); + m_count++; +} + diff --git a/kbfxlib/data/kbfxdatagrouplist.h b/kbfxlib/data/kbfxdatagrouplist.h new file mode 100644 index 0000000..711b7af --- /dev/null +++ b/kbfxlib/data/kbfxdatagrouplist.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_DATA_GROUP_LIST_H +#define KBFX_DATA_GROUP_LIST_H + +#include +#include "kbfxdatagroup.h" + +class KbfxDataGroupList +{ + public: + typedef QPtrList GroupList; + KbfxDataGroupList(); + ~KbfxDataGroupList(); + //in + void addGroup ( KbfxDataGroup * group ); + void setName ( QString name ) { m_name = name;} + void setIcon ( QString path ) { m_iconPath = path;} + //out + QString name() {return m_name;} + GroupList getGroup() { return m_groupList;} + QString iconPath() { return m_iconPath;} + + int count() {return m_count;} + + private: + QString m_name; + QString m_iconPath; + GroupList m_groupList; + int m_count; +}; + +#endif diff --git a/kbfxlib/data/kbfxdatasource.cpp b/kbfxlib/data/kbfxdatasource.cpp new file mode 100644 index 0000000..8a44478 --- /dev/null +++ b/kbfxlib/data/kbfxdatasource.cpp @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxdatasource.h" +#include +#include +#include + +KbfxDataSource::KbfxDataSource() +{ + m_type = NONDESKTOP; + m_keyWords=""; + m_command=""; + m_desktopPath="none"; + m_contentPath = "none"; +} + +KbfxDataSource::~KbfxDataSource() +{ +} + +bool +KbfxDataSource::lookup ( QString str ) +{ + if ( str.isNull() ) + return false; + + QString _searchStr = m_text+m_comment+m_description+m_keyWords; + + + if ( _searchStr.contains ( str,false ) > 0 ) + return true; + + return false; +} + +void +KbfxDataSource::loadDesktopFile() +{ + KDesktopFile * file = new KDesktopFile ( m_desktopPath ); + m_text = file->readName(); + m_comment= file->readComment(); + m_iconPath = file->readIcon(); + m_command = file->readEntry ( "Exec","none" ); + m_description = file->readGenericName () +file->readEntry ( "Categories","Application" ); + + setContentPath ( m_desktopPath ); + delete file; + +} + + +void +KbfxDataSource::exec() +{ + + if ( type() == KbfxDataSource::DESKTOP ) + { + QCString dcop; + int pid; + QString m_error; + KApplication::startServiceByDesktopPath ( desktopFile(), + QString::null, &m_error,&dcop,&pid,"",true ); + } + + else + { + KRun::runCommand ( m_command ); + } +} + diff --git a/kbfxlib/data/kbfxdatasource.h b/kbfxlib/data/kbfxdatasource.h new file mode 100644 index 0000000..aba89ad --- /dev/null +++ b/kbfxlib/data/kbfxdatasource.h @@ -0,0 +1,151 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_DATA_SOURCE_H +#define KBFX_DATA_SOURCE_H + +#include +#include + +class KbfxDataSource +{ + + + public: + typedef enum + { DESKTOP = 0, NONDESKTOP } Type; + typedef QValueList < KbfxDataSource > DataSourceList; + /** + * Constructs a new DataSource. Data source is a simple class that holds + * a .desktop file and also you can include a custom commmand that can be + * exectuted + * @return a pointer to a new data source + */ + KbfxDataSource (); + virtual ~ KbfxDataSource (); + + /** + * Sets the name of a data source and should not be used if your dara is + * a desktop file use KbfxDataSource::setDesktopPath() functions instead + * @param name should be the name of the data source + */ + void setName ( QString name ) + { + m_text = name; + } + /** + * Sets the desktop file of for the data source. Note that u do not have to check + * parameters such as if the the desktop is kiosk allowed. the this function internally + * abstracts such functions. + * @param path should be the absolute path of a valid desktop file + */ + void setDesktopPath ( QString path ) + { + m_desktopPath = path; + m_type = DESKTOP; + loadDesktopFile (); + } + + virtual void setCommand ( QString cmd ) + { + m_command = cmd; + } + + + void setContentPath ( QString path ) + { + m_contentPath = path; + } + QString contentPath () + { + return m_contentPath; + } + + virtual void setType ( Type t ) + { + m_type = t; + } + + virtual void exec (); + + void setComment ( QString comment ) + { + m_comment = comment; + }; + + void setDescription ( QString desc ) + { + m_description = desc; + } + + void setIconPath ( QString path ) + { + m_iconPath = path; + } + + QString desktopFile () + { + return m_desktopPath; + } + //out + QString name () + { + return m_text; + } + QString icon () + { + return m_iconPath; + }; + QString command () + { + return m_command; + } + Type type () + { + return m_type; + } + /** + * Use this function to get the comment of the a data soruce. this + * functio will NOT return NULL so no checking needed + * @return the comment of the data source or empty string + */ + QString comment () + { + return m_comment; + } + bool lookup ( QString str ); + private: +//TODO +//MOve to private D + void loadDesktopFile (); + QString m_text; + QString m_desktopPath; + QString m_command; + QString m_iconPath; + QString m_comment; + QString m_description; + QString m_keyWords; + Type m_type; + QString m_contentPath; + + +}; +#endif diff --git a/kbfxlib/data/kbfxdatastack.cpp b/kbfxlib/data/kbfxdatastack.cpp new file mode 100644 index 0000000..2d84e02 --- /dev/null +++ b/kbfxlib/data/kbfxdatastack.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxdatastack.h" + +KbfxDataStack::KbfxDataStack() +{ + m_nameList.append ( "" ); + m_name = "Unset"; + m_count = 0; +} + +KbfxDataStack::~KbfxDataStack() +{ +//TODO: empty the list +} + +void +KbfxDataStack::addGroupList ( KbfxDataGroupList * list ) +{ + m_stack[list->name() ]=list; + m_nameList.append ( list->name() ); + m_dict[list->name() ]=m_count; + + KbfxPlasmaCanvasStackData stackinfo; + stackinfo.name = list->name(); + stackinfo.icon = list->iconPath(); + m_dataDict[m_count] = stackinfo; + + m_count++; + +} +QStringList +KbfxDataStack::getStackIndex() +{ + return m_nameList; +} + +KbfxDataGroupList * +KbfxDataStack::getStack ( QString name ) +{ + + + if ( m_nameList.contains ( name ) >0 ) + return m_stack[name]; + else + { + return NULL; + } +} + + +QString +KbfxDataStack::getSubGroupName ( uint id ) +{ + + Dict::Iterator it; + for ( it=m_dict.begin();it!=m_dict.end();++it ) + { + if ( it.data() == id ) + return it.key(); + + } + return QString ( "Empty" ); +} + diff --git a/kbfxlib/data/kbfxdatastack.h b/kbfxlib/data/kbfxdatastack.h new file mode 100644 index 0000000..6d65810 --- /dev/null +++ b/kbfxlib/data/kbfxdatastack.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_DATA_STACK_H +#define KBFX_DATA_STACK_H + +#include +#include +#include +#include "kbfxdatagrouplist.h" +#include "kbfxplasmacanvasstackdata.h" //TODO:change the name here + +class KbfxDataStack +{ + + public: + typedef QMap StackMap; + typedef QMap Dict; + typedef QMap DataDict; + + KbfxDataStack(); + ~KbfxDataStack(); + void setName ( QString name ) { m_name=name;} + void addGroupList ( KbfxDataGroupList * list ); + //out + KbfxDataGroupList * getGroupList ( QString name ); + QStringList getStackIndex(); + KbfxDataGroupList * getStack ( QString name ); + + Dict getDict() {return m_dict;} + DataDict getDataDict() { return m_dataDict;} + QString name() {return m_name;} + uint getIndex ( QString name ) { return m_dict[name];} + QString getSubGroupName ( uint id ); + int count() {return m_count;} + private: + StackMap m_stack; + QStringList m_nameList; + QString m_name; + Dict m_dict; + DataDict m_dataDict; + uint m_count; + +}; + +#endif diff --git a/kbfxlib/data/kbfxplasmadataplugin.cpp b/kbfxlib/data/kbfxplasmadataplugin.cpp new file mode 100644 index 0000000..d237d3a --- /dev/null +++ b/kbfxlib/data/kbfxplasmadataplugin.cpp @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxplasmadataplugin.h" + +KbfxPlasmaCanvasStack * view() +{ + + return NULL; + +} diff --git a/kbfxlib/data/kbfxplasmadataplugin.h b/kbfxlib/data/kbfxplasmadataplugin.h new file mode 100644 index 0000000..82a812b --- /dev/null +++ b/kbfxlib/data/kbfxplasmadataplugin.h @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxplasmacanvasstack.h" + + +extern "C" +{ + KbfxPlasmaCanvasStack * view(); +} + diff --git a/kbfxlib/data/kbfxplasmapluginloader.cpp b/kbfxlib/data/kbfxplasmapluginloader.cpp new file mode 100644 index 0000000..ebc992a --- /dev/null +++ b/kbfxlib/data/kbfxplasmapluginloader.cpp @@ -0,0 +1,161 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include + +#include "kbfxplasmapluginloader.h" +#include +#include +#include +#include + +KbfxPlasmaPluginLoader::KbfxPlasmaPluginLoader() +{ + m_plugin = 0; + init(); + +} + + +void +KbfxPlasmaPluginLoader::init() +{ + + QString libprefix = locate ( "lib","libkbfxdata.so" ); + libprefix.remove ( "libkbfxdata.so" ); +// QString libprefix = KBFX_LIB_INSTALL_DIR ; + kdDebug() << "KBFX plugins lib is: " << libprefix << endl; + QDir * _dir = new QDir ( libprefix+"/kbfx/plugins/" ); + QStringList plugins; + _dir->setFilter ( QDir::Files ); + _dir->setNameFilter ( "*.so" ); + if ( !_dir->exists() ) + { + kdDebug() << "Invalid Plugin Prefix: " << libprefix << "/kbfx/plugins/" << endl; + delete _dir; + return ;//QStringList("No Plugins found: Error in default Paths.Contact Package Manager"); + } + + const QFileInfoList *list = _dir->entryInfoList(); + QFileInfoListIterator it ( *list ); + QFileInfo *fi=0; + int _index =0; + while ( ( fi = it.current() ) != 0 ) + { + QString * path = new QString ( libprefix+"/kbfx/plugins/"+fi->fileName() ); + QLibrary * _l = new QLibrary ( *path ); + + typedef QString ( *getName ) (); + getName nameFunc; + nameFunc = ( getName ) _l->resolve ( "name" ); + if ( nameFunc ) + { + pluginMap() [nameFunc() ] = new KbfxPlugin ( nameFunc(),*path,_index++ ); + } + ++it; + _l->unload(); + delete _l; + delete path; + } + + delete _dir; +} + + +KbfxPlasmaPluginLoader::~KbfxPlasmaPluginLoader() +{ + // if(m_plugin!=0) +// delete m_plugin; + + // PluginMap::Iterator it; + // for ( it = pluginMap().begin(); it != pluginMap().end(); ++it ) { + // delete it.data(); + // pluginMap().remove(it); + // } + + +} + +KbfxDataStack * +KbfxPlasmaPluginLoader::getView ( QString name ) +{ + PluginMap::Iterator it; + for ( it = pluginMap().begin(); it != pluginMap().end(); ++it ) + { + pluginMap().remove ( it ); + } + init(); + KbfxDataStack * stack = pluginMap() [name]->data(); + + if (stack == 0 ) { + return new KbfxDataStack(); + } + + return stack; +} + +KbfxDataGroup * +KbfxPlasmaPluginLoader::search ( QString pname,QString keyword ) +{ + if ( pname == NULL ) + return NULL; + + KbfxDataGroup * group = pluginMap() [pname]->search ( keyword ); + if ( group == NULL ) + { + kdDebug() << "KbfxPlasmaaPluginLoader:109:Null pointer" << endl; + return NULL; + } + + return group; + +} + + +KbfxPlasmaPluginLoader::PluginMap& +KbfxPlasmaPluginLoader::pluginMap() +{ + static PluginMap * map = 0; + if ( !map ) + map = new PluginMap(); + return *map; +} + + + + +QStringList +KbfxPlasmaPluginLoader::scanPlugins() +{ + + init(); + QStringList plugins; + PluginMap::Iterator it; + + for ( it = pluginMap().begin(); it != pluginMap().end();++it ) + { + if ( it.data()->status() == false ) + plugins.append ( it.data()->name() ); + } + return plugins; +} + +#include "kbfxplasmapluginloader.moc" diff --git a/kbfxlib/data/kbfxplasmapluginloader.h b/kbfxlib/data/kbfxplasmapluginloader.h new file mode 100644 index 0000000..2ae2f54 --- /dev/null +++ b/kbfxlib/data/kbfxplasmapluginloader.h @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_PLASMA_PLUGIN_LOADER_H +#define KBFX_PLASMA_PLUGIN_LOADER_H + +#include +#include "kbfxplasmacanvasstack.h" +#include "kbfxdatastack.h" +#include "kbfxplugin.h" +#include + +class KbfxPlasmaPluginLoader:public QObject +{ + Q_OBJECT + + public: + typedef QMap PluginMap; + + /** + * + * @return + */ + KbfxPlasmaPluginLoader(); + /** + * + * @return + */ + ~KbfxPlasmaPluginLoader(); + /** + * + * @param name + * @return + */ + KbfxDataStack * getView ( QString name ); + /* + look for all installed Plugins. returns a list of installed plugins + */ + static QStringList scanPlugins(); + + /** + * Calls the search function of a given plugin and returns the result + * @param pluginName The name of the plugin to call + * @param keyword the keyword to pass to the plugin + * @return a valid KbfxDataGroup or -1 + */ + static KbfxDataGroup * search ( QString pluginName,QString keyword ); + + protected: + static void init(); + + private: + + QLibrary * m_plugin; + static PluginMap& pluginMap(); + QString m_prefix; + + +}; + +#endif diff --git a/kbfxlib/data/kbfxplugin.cpp b/kbfxlib/data/kbfxplugin.cpp new file mode 100644 index 0000000..ae53d67 --- /dev/null +++ b/kbfxlib/data/kbfxplugin.cpp @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include "kbfxplugin.h" + +KbfxPlugin::KbfxPlugin ( QString name,QString lib,uint id ) +{ + m_name = name; + m_libName = lib; + m_id = id; + m_loaded = false; +} + +KbfxPlugin::KbfxPlugin() +{ +} + +KbfxPlugin::~KbfxPlugin() +{ +// delete [] m_name; +// delete [] m_libName; +} + +QString +KbfxPlugin::name() +{ + return m_name; +} + +QString +KbfxPlugin::libName() +{ + return m_libName; +} + +uint +KbfxPlugin::id() +{ + return m_id; +} + +bool +KbfxPlugin::status() +{ + return m_loaded; +} + +KbfxDataStack * +KbfxPlugin::data() +{ + typedef KbfxDataStack * ( *KbfxPluginView ) (); + KbfxDataStack * m_stack =0; + KbfxPluginView m_hook; + QLibrary * m_plugin = new QLibrary ( m_libName ); + + if ( m_plugin == NULL ) + return new KbfxDataStack(); + + m_hook = ( KbfxPluginView ) m_plugin->resolve ( "view" ); + m_stack = m_hook(); + m_plugin->unload(); + delete m_plugin; + + if ( m_stack != NULL ) + return m_stack; + else + return new KbfxDataStack(); +} + +KbfxDataGroup * +KbfxPlugin::search ( QString keyword ) +{ + if ( keyword == 0 ) + return NULL;//new KbfxDataGroup(); + + if ( keyword.isNull() ) + return NULL;//KbfxDataGroup(); + + + typedef KbfxDataGroup * ( *KbfxPluginSearch ) ( QString key ); + KbfxDataGroup * m_group =0; + KbfxPluginSearch m_hook; + QLibrary * m_plugin = new QLibrary ( m_libName ); + m_hook = ( KbfxPluginSearch ) m_plugin->resolve ( "search" ); + m_group = m_hook ( keyword ); + m_plugin->unload(); + delete m_plugin; + if ( m_group != NULL ) + { + // qDebug("KbfxPlugin():search():103:return Valid Group "+m_group->name()); + return m_group; + } + else return NULL; +} + + +#include "kbfxplugin.moc" diff --git a/kbfxlib/data/kbfxplugin.h b/kbfxlib/data/kbfxplugin.h new file mode 100644 index 0000000..5868d14 --- /dev/null +++ b/kbfxlib/data/kbfxplugin.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_PLUGIN_H +#define KBFX_PLUGIN_H +//#include "kbfxplasmacanvasstack.h" +#include "kbfxdatastack.h" +#include +#include +#include +/** +This class reprecentes a plugin +written for kbfx menu this +will be passed between the life time +of the menu +**/ + + +class KbfxPlugin:public QObject +{ + + Q_OBJECT + public: + + KbfxPlugin(); + KbfxPlugin ( QString Name,QString lib,uint id ); + ~KbfxPlugin(); + + void setStatus ( bool ); + + QString name(); + QString libName(); + uint id(); + bool status(); +// KbfxPlasmaCanvasStack * data(); + KbfxDataStack * data(); + KbfxDataGroup * search ( QString keyword ); + +// KbfxDataStack * data(); + + public slots: + void reload() {} + signals: + void loadComplete(); + + private: + QString m_name; + QString m_libName; + uint m_id; +// KbfxPlasmaCanvasStack * m_data; + KbfxDataStack m_data_R; +// QCanvas * m_canvas; + bool m_loaded; +}; + +#endif diff --git a/patches/001.patch b/patches/001.patch new file mode 100644 index 0000000..d07d523 --- /dev/null +++ b/patches/001.patch @@ -0,0 +1,14 @@ +--- kbfx-0.4.9.3-20070117.orig/CMakeLists.txt 2007-01-17 23:31:10.000000000 +0800 ++++ kbfx-0.4.9.3-20070117/CMakeLists.txt 2007-01-18 23:30:43.000000000 +0800 +@@ -8,7 +8,10 @@ + # Release (CMAKE_C_FLAGS_RELEASE or CMAKE_CXX_FLAGS_RELEASE) + # RelWithDebInfo (CMAKE_C_FLAGS_RELWITHDEBINFO or CMAKE_CXX_FLAGS_RELWITHDEBINFO + # MinSizeRel (CMAKE_C_FLAGS_MINSIZEREL or CMAKE_CXX_FLAGS_MINSIZEREL) +-SET(CMAKE_BUILD_TYPE RelWithDebInfo) ++if (NOT CMAKE_BUILD_TYPE) ++ SET(CMAKE_BUILD_TYPE RelWithDebInfo ++ CACHE STRING "Specify build type: None Debug Release RelWithDebInfo MinSizeRel." FORCE) ++endif (NOT CMAKE_BUILD_TYPE) + SET(CMAKE_COLOR_MAKEFILE ON CACHE STRING "Enable/Disable color output during build." FORCE) + #SET(CMAKE_VERBOSE_MAKEFILE OFF CACHE STRING "Enable/Disable cmake debug output during build." FORCE) + diff --git a/plugins/applications/CMakeLists.txt b/plugins/applications/CMakeLists.txt new file mode 100644 index 0000000..6a717fd --- /dev/null +++ b/plugins/applications/CMakeLists.txt @@ -0,0 +1,44 @@ +SET(libkbfxplasmadatastubsrc + kbfxplasmadataplugin.cpp + ) + +FILE(GLOB HEADERS *.h) + +IF (NOT USE_KDE4) + KDE3_AUTOMOC(${libkbfxplasmadatastubsrc}) + + ADD_LIBRARY(kbfxplasmadatastub SHARED ${libkbfxplasmadatastubsrc}) + SET_TARGET_PROPERTIES(kbfxplasmadatastub + PROPERTIES + COMPILE_FLAGS ${CMAKE_SHARED_LIBRARY_CXX_FLAGS}) + # SET_TARGET_PROPERTIES(kbfxplasmadatastub PROPERTIES + # SOVERSION ${LIB_MAJOR} + # VERSION ${APPLICATION_VERSION}) + TARGET_LINK_LIBRARIES(kbfxplasmadatastub + kbfxdata + ${QT_AND_KDECORE_LIBS} + ${KDE3_KIO_LIBRARY} + ${KDE3_UI_LIBRARY} + ${KDE3_KHTML_LIBRARY} + ${M_LIBRARY} + ) + + KDE3_INSTALL_LIBTOOL_FILE(kbfxplasmadatastub ${LIB_INSTALL_DIR}/kbfx/plugins) +ELSE (NOT USE_KDE4) + KDE4_AUTOMOC(${libkbfxplasmadatastubsrc}) + + KDE4_ADD_LIBRARY(kbfxplasmadatastub SHARED ${libkbfxplasmadatastubsrc}) + TARGET_LINK_LIBRARIES(kbfxplasmadatastub + kbfxdata + ${KDE4_KDECORE_LIBS} + ${KDE4_KIO_LIBS} + ${KDE4_KDEUI_LIBS} + ${KDE4_KHTML_LIBS} + ${M_LIBRARY} + ) + + KDE4_INSTALL_LIBTOOL_FILE(kbfxplasmadatastub ${LIB_INSTALL_DIR}/kbfx/plugins) +ENDIF (NOT USE_KDE4) + +INSTALL(TARGETS kbfxplasmadatastub DESTINATION ${LIB_INSTALL_DIR}/kbfx/plugins) +INSTALL(FILES ${HEADERS} DESTINATION ${INCLUDE_INSTALL_DIR}/kbfx/plugins) diff --git a/plugins/applications/kbfxplasmadataplugin.cpp b/plugins/applications/kbfxplasmadataplugin.cpp new file mode 100644 index 0000000..cffb72f --- /dev/null +++ b/plugins/applications/kbfxplasmadataplugin.cpp @@ -0,0 +1,224 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + + +void +browseApp ( KServiceGroup::Ptr service, KbfxDataGroupList * glist, + KbfxDataGroup * appGroup ) +{ + if ( !service || !service->isValid () ) + return; + + + KServiceGroup::List list = service->entries ( true, true, false, true ); + + + if ( service->noDisplay () == true ) + return; + + /* + if (list.count () <= 0) + return; + */ + + appGroup = new KbfxDataGroup (); + appGroup->setName ( service->caption () ); + + for ( KServiceGroup::List::ConstIterator it = list.begin (); + it != list.end (); it++ ) + { + KSycocaEntry *p = ( *it ); + if ( p->isType ( KST_KService ) ) + { + KService *s = static_cast < KService * > ( p ); + KbfxDataSource *data = new KbfxDataSource (); + data->setDesktopPath ( s->desktopEntryPath () ); + appGroup->addItem ( data ); + } + else if ( p->isType ( KST_KServiceGroup ) ) + { + KServiceGroup *g = static_cast < KServiceGroup * > ( p ); + if ( g->childCount () > 0 ) + { + glist->addGroup ( appGroup ); + appGroup = new KbfxDataGroup (); + appGroup->setName ( g->caption () ); + browseApp ( g, glist, appGroup ); + } + + } + } + glist->addGroup ( appGroup ); + +} + + + + + + +KbfxDataStack * +view () +{ + KbfxDataGroup *appGroup = new KbfxDataGroup (); + KbfxDataGroupList *glist = new KbfxDataGroupList (); + KbfxDataStack *gstack = new KbfxDataStack (); + + KServiceGroup::Ptr service = KServiceGroup::group ( "/" ); + if ( service == NULL) + { + int messageBoxUserResReturn = KMessageBox::questionYesNo ( 0, + tr2i18n ( "

There is a problem in KDE Menu services!
KBFX can try to autorepair this problem.
Should KBFX autorepair this problem?

" ), + tr2i18n ( "Problem in KDE Menu Services" ), + tr2i18n ( "Do Autorepair" ), + tr2i18n ( "Do NOT Autorepair" ) ); + if ( messageBoxUserResReturn == KMessageBox::Yes ) + { + KRun::runCommand ( "kbuildsycoca" ); +// if ( ! ConfigInit().m_KbfxWatcher ) +// { + DCOPRef m_kickerPanel("kicker", "kicker"); + m_kickerPanel.call("restart()"); +// } + } + return new KbfxDataStack(); + } + + service->setShowEmptyMenu ( false ); + + glist->setName ( "Applications" ); + appGroup->setName ( service->caption () ); + + KServiceGroup::List list = service->entries ( true, true, false, false ); + + if ( list.count() <= 0) + { + return new KbfxDataStack(); + } + + + for ( KServiceGroup::List::ConstIterator it = list.begin (); + it != list.end (); it++ ) + { + KSycocaEntry *p = ( *it ); + if ( p->isType ( KST_KService ) ) + {} + else if ( p->isType ( KST_KServiceGroup ) ) + { + KServiceGroup *g = static_cast < KServiceGroup * > ( p ); + g->setShowEmptyMenu ( false ); + + if ( g->childCount () > 0 ) + { + glist = new KbfxDataGroupList (); + glist->setName ( g->caption () ); + glist->setIcon ( g->icon () ); + browseApp ( g, glist, appGroup ); + gstack->addGroupList ( glist ); + } + + } + } + + gstack->setName ( "Applications" ); + + + return gstack; + +} + +QString +name () +{ + return QString ( "Applications" ); +} + +QString +type () +{ + return QString ( "Stub Type" ); +} + + +uint +id () +{ + return 1; //TODO see what can be done... manybe rand()? +} + +#include + +KbfxDataGroup * +search ( QString _keyword ) +{ + + + KbfxDataGroup *g = new KbfxDataGroup (); + g->setName ( "Applications" ); + + + KTrader::OfferList offers = KTrader::self ()->query ( "Application" ); + + int *count = new int; + *count = 0; + QValueListIterator < KService::Ptr > s = offers.begin (); + + for ( ; s != offers.end (); ++s ) + { + if ( s == NULL ) + continue; + if ( (*s)->noDisplay () == true ) + continue; + + QString *sPtr = new QString (); + + ( *sPtr ) = ( *s )->name () + ( *s )->genericName () + ( *s )->comment (); + if ( ( !sPtr->isNull () ) && sPtr->contains ( _keyword, false ) > 0 ) + { + KbfxDataSource *data = new KbfxDataSource (); + data->setName ( ( *s )->name () ); + data->setDesktopPath ( ( *s )->desktopEntryPath () ); + + g->addItem ( data ); + ( *count ) ++; + if ( ( *count ) == 10 ) + break; + + } + if ( sPtr != 0 ) + delete sPtr; + } + delete count; + return g; +} diff --git a/plugins/common/CMakeLists.txt b/plugins/common/CMakeLists.txt new file mode 100644 index 0000000..96b4a77 --- /dev/null +++ b/plugins/common/CMakeLists.txt @@ -0,0 +1,3 @@ +FILE(GLOB HEADERS *.h) + +INSTALL(FILES ${HEADERS} DESTINATION ${INCLUDE_INSTALL_DIR}/kbfx/plugins) diff --git a/plugins/common/kbfxplasmadataplugin-common.h b/plugins/common/kbfxplasmadataplugin-common.h new file mode 100644 index 0000000..d446ef8 --- /dev/null +++ b/plugins/common/kbfxplasmadataplugin-common.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_PLASMA_DATA_PLUGIN_COMMON_H +#define KBFX_PLASMA_DATA_PLUGIN_COMMON_H + +#include "kbfxdatastack.h" + +extern "C" +{ +// static QString check = "Static Check for Plugin"; + KbfxDataStack * view(); + QString name(); //Name of the Plugin My Music .if TOM Create..Configure .. + QString type(); //Type of the plugin ex: Application : Amork : kio ..etc + uint id(); //A id for menus + KbfxDataGroup * search ( QString str ); +} + +#endif diff --git a/plugins/plasmoids/CMakeLists.txt b/plugins/plasmoids/CMakeLists.txt new file mode 100644 index 0000000..abb1167 --- /dev/null +++ b/plugins/plasmoids/CMakeLists.txt @@ -0,0 +1,44 @@ +SET(libkbfxplasmadataplasmoidsrc + kbfxplasmadatapluginplosmoid.cpp + ) + +FILE(GLOB HEADERS *.h) + +IF (NOT USE_KDE4) + KDE3_AUTOMOC(${libkbfxplasmadataplasmoidsrc}) + + ADD_LIBRARY(kbfxplasmadataplasmoid SHARED ${libkbfxplasmadataplasmoidsrc} ) + SET_TARGET_PROPERTIES(kbfxplasmadataplasmoid + PROPERTIES + COMPILE_FLAGS ${CMAKE_SHARED_LIBRARY_CXX_FLAGS}) + # SET_TARGET_PROPERTIES(kbfxplasmadataplasmoid PROPERTIES + # SOVERSION ${LIB_MAJOR} + # VERSION ${APPLICATION_VERSION}) + TARGET_LINK_LIBRARIES(kbfxplasmadataplasmoid + kbfxdata + ${QT_AND_KDECORE_LIBS} + ${KDE3_KIO_LIBRARY} + ${KDE3_UI_LIBRARY} + ${KDE3_KHTML_LIBRARY} + ${M_LIBRARY} + ) + + KDE3_INSTALL_LIBTOOL_FILE(kbfxplasmadataplasmoid ${LIB_INSTALL_DIR}/kbfx/plugins) +ELSE (NOT USE_KDE4) + KDE4_AUTOMOC(${libkbfxplasmadataplasmoidsrc}) + + KDE4_ADD_LIBRARY(kbfxplasmadataplasmoid SHARED ${libkbfxplasmadataplasmoidsrc} ) + TARGET_LINK_LIBRARIES(kbfxplasmadataplasmoid + kbfxdata + ${KDE4_KDECORE_LIBS} + ${KDE4_KIO_LIBS} + ${KDE4_KDEUI_LIBS} + ${KDE4_KHTML_LIBS} + ${M_LIBRARY} + ) + + KDE4_INSTALL_LIBTOOL_FILE(kbfxplasmadataplasmoid ${LIB_INSTALL_DIR}/kbfx/plugins) +ENDIF (NOT USE_KDE4) + +INSTALL(TARGETS kbfxplasmadataplasmoid DESTINATION ${LIB_INSTALL_DIR}/kbfx/plugins) +INSTALL(FILES ${HEADERS} DESTINATION ${INCLUDE_INSTALL_DIR}/kbfx/plugins) diff --git a/plugins/plasmoids/kbfxplasmadatapluginplosmoid.cpp b/plugins/plasmoids/kbfxplasmadatapluginplosmoid.cpp new file mode 100644 index 0000000..998fafb --- /dev/null +++ b/plugins/plasmoids/kbfxplasmadatapluginplosmoid.cpp @@ -0,0 +1,152 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + + + + + + + +KbfxDataStack * +view () +{ + + KbfxDataGroup *appGroup = new KbfxDataGroup (); + KbfxDataGroupList *glist = new KbfxDataGroupList (); + KbfxDataStack *gstack = new KbfxDataStack (); + + + glist->setName ( "Browse" ); + glist->setIcon ( "plasmagik" ); + appGroup->setName ( "Plasmoids" ); + + QString path = locate ( "data", "kicker/applets/lockout.desktop" ); + path.remove ( "lockout.desktop" ); + + + + QDir d ( path ); + d.setFilter ( QDir::Files | QDir::Hidden | QDir::NoSymLinks ); + d.setSorting ( QDir::Size | QDir::Reversed ); + d.setNameFilter ( "*.desktop" ); + + const QFileInfoList *list = d.entryInfoList (); + QFileInfoListIterator it ( *list ); + QFileInfo *fi; + while ( ( fi = it.current () ) != 0 ) + { + + KDesktopFile *desktop = new KDesktopFile ( fi->filePath () ); + + KbfxDataSource *src = new KbfxDataSource (); + + src->setName ( desktop->readName () ); + src->setContentPath ( fi->filePath () ); + src->setIconPath ( desktop->readIcon () ); + src->setCommand ( "dcop kicker Panel addApplet " + fi->filePath () ); + appGroup->addItem ( src ); + + + ++it; + } + + + gstack->setName ( "Plasmoids" ); + + glist->addGroup ( appGroup ); + gstack->addGroupList ( glist ); + return gstack; + + +} + +QString +name () +{ + return QString ( "Plasmoids" ); +} + +QString +type () +{ + return QString ( "Stub Type" ); +} + + +uint +id () +{ + return 1; //TODO see what can be done... manybe rand()? +} + + +#include + +KbfxDataGroup * +search ( QString _keyword ) +{ + KbfxDataGroup *appGroup = new KbfxDataGroup (); + + + QString path = locate ( "data", "kicker/applets/lockout.desktop" ); + path.remove ( "lockout.desktop" ); + + + + QDir d ( path ); + d.setFilter ( QDir::Files | QDir::Hidden | QDir::NoSymLinks ); + d.setSorting ( QDir::Size | QDir::Reversed ); + d.setNameFilter ( "*.desktop" ); + + const QFileInfoList *list = d.entryInfoList (); + QFileInfoListIterator it ( *list ); + QFileInfo *fi; + + while ( ( fi = it.current () ) != 0 ) + { + if ( fi->fileName ().contains ( _keyword ) > 0 ) + { + KDesktopFile *desktop = new KDesktopFile ( fi->filePath () ); + + KbfxDataSource *src = new KbfxDataSource (); + + src->setName ( desktop->readName () ); + src->setContentPath ( fi->filePath () ); + src->setIconPath ( desktop->readIcon () ); + src->setCommand ( "dcop kicker Panel addApplet " + fi->filePath () ); + appGroup->addItem ( src ); + } + + ++it; + } + + + return appGroup; +} diff --git a/plugins/recentstuff/CMakeLists.txt b/plugins/recentstuff/CMakeLists.txt new file mode 100644 index 0000000..787fbd8 --- /dev/null +++ b/plugins/recentstuff/CMakeLists.txt @@ -0,0 +1,44 @@ +SET(libkbfxplasmarecentstuffsrc + kbfxplasmarecentstuff.cpp + ) + +FILE(GLOB HEADERS *.h) + +IF (NOT USE_KDE4) + KDE3_AUTOMOC(${libkbfxplasmarecentstuffsrc}) + + ADD_LIBRARY(kbfxplasmarecentstuff SHARED ${libkbfxplasmarecentstuffsrc} ) + SET_TARGET_PROPERTIES(kbfxplasmarecentstuff + PROPERTIES + COMPILE_FLAGS ${CMAKE_SHARED_LIBRARY_CXX_FLAGS}) + # SET_TARGET_PROPERTIES(kbfxplasmarecentstuff PROPERTIES + # SOVERSION ${LIB_MAJOR} + # VERSION ${APPLICATION_VERSION}) + TARGET_LINK_LIBRARIES(kbfxplasmarecentstuff + kbfxdata + ${QT_AND_KDECORE_LIBS} + ${KDE3_KIO_LIBRARY} + ${KDE3_UI_LIBRARY} + ${KDE3_KHTML_LIBRARY} + ${M_LIBRARY} + ) + + KDE3_INSTALL_LIBTOOL_FILE(kbfxplasmarecentstuff ${LIB_INSTALL_DIR}/kbfx/plugins) +ELSE (NOT USE_KDE4) + KDE4_AUTOMOC(${libkbfxplasmarecentstuffsrc}) + + KDE4_ADD_LIBRARY(kbfxplasmarecentstuff SHARED ${libkbfxplasmarecentstuffsrc} ) + TARGET_LINK_LIBRARIES(kbfxplasmarecentstuff + kbfxdata + ${KDE4_KDECORE_LIBS} + ${KDE4_KIO_LIBS} + ${KDE4_KDEUI_LIBS} + ${KDE4_KHTML_LIBS} + ${M_LIBRARY} + ) + + KDE4_INSTALL_LIBTOOL_FILE(kbfxplasmarecentstuff ${LIB_INSTALL_DIR}/kbfx/plugins) +ENDIF (NOT USE_KDE4) + +INSTALL(TARGETS kbfxplasmarecentstuff DESTINATION ${LIB_INSTALL_DIR}/kbfx/plugins) +INSTALL(FILES ${HEADERS} DESTINATION ${INCLUDE_INSTALL_DIR}/kbfx/plugins) diff --git a/plugins/recentstuff/kbfxplasmarecentstuff.cpp b/plugins/recentstuff/kbfxplasmarecentstuff.cpp new file mode 100644 index 0000000..b0c4f8c --- /dev/null +++ b/plugins/recentstuff/kbfxplasmarecentstuff.cpp @@ -0,0 +1,150 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +KbfxDataStack * +view () +{ + + KbfxDataGroup *appGroup = new KbfxDataGroup (); + KbfxDataGroupList *glist = new KbfxDataGroupList (); + KbfxDataStack *gstack = new KbfxDataStack (); + + + glist->setName ( "List" ); + glist->setIcon ( "newstuff" ); + appGroup->setName ( "RecentStuff" ); + + QString path = + KStandardDirs ().localkdedir () + "/share/apps/RecentDocuments/"; + + + + QDir d ( path ); + d.setFilter ( QDir::Files | QDir::Hidden | QDir::NoSymLinks ); + d.setSorting ( QDir::Size | QDir::Reversed ); + d.setNameFilter ( "*.desktop" ); + + const QFileInfoList *list = d.entryInfoList (); + QFileInfoListIterator it ( *list ); + QFileInfo *fi; + + while ( ( fi = it.current () ) != 0 ) + { + + KDesktopFile *desktop = new KDesktopFile ( fi->filePath () ); + + KbfxDataSource *src = new KbfxDataSource (); + + src->setName ( desktop->readName () ); + src->setContentPath ( fi->filePath () ); + src->setIconPath ( desktop->readIcon () ); + src->setCommand ( "kfmclient exec " + desktop->readEntry ( "URL" ) ); + + appGroup->addItem ( src ); + + delete desktop; + ++it; + } + + + gstack->setName ( "RecentStuff" ); + + glist->addGroup ( appGroup ); + gstack->addGroupList ( glist ); + return gstack; + + +} + +QString +name () +{ + return QString ( "RecentStuff" ); +} + +QString +type () +{ + return QString ( "Stub Type" ); +} + + +uint +id () +{ + return 1; //TODO see what can be done... manybe rand()? +} + + +#include + +KbfxDataGroup * +search ( QString _keyword ) +{ + KbfxDataGroup *appGroup = new KbfxDataGroup (); +// KbfxDataGroupList *glist = new KbfxDataGroupList (); +// KbfxDataStack *gstack = new KbfxDataStack (); + + + + QString path = + KStandardDirs ().localkdedir () + "/share/apps/RecentDocuments/"; + + QDir d ( path ); + d.setFilter ( QDir::Files | QDir::Hidden | QDir::NoSymLinks ); + d.setSorting ( QDir::Size | QDir::Reversed ); + d.setNameFilter ( "*.desktop" ); + + const QFileInfoList *list = d.entryInfoList (); + QFileInfoListIterator it ( *list ); + QFileInfo *fi; + + while ( ( fi = it.current () ) != 0 ) + { + if ( fi->fileName ().contains ( _keyword ) > 0 ) + { + KDesktopFile *desktop = new KDesktopFile ( fi->filePath () ); + + KbfxDataSource *src = new KbfxDataSource (); + + src->setName ( desktop->readName () ); + src->setContentPath ( fi->filePath () ); + src->setIconPath ( desktop->readIcon () ); + src->setCommand ( "kfmclient exec " + desktop->readEntry ( "URL" ) ); + appGroup->addItem ( src ); + delete desktop; + } + + ++it; + } + + return appGroup; +} diff --git a/plugins/settings/CMakeLists.txt b/plugins/settings/CMakeLists.txt new file mode 100644 index 0000000..2ef6f02 --- /dev/null +++ b/plugins/settings/CMakeLists.txt @@ -0,0 +1,44 @@ +SET(libkbfxplasmadatasettingssrc + kbfxplasmadatapluginsettings.cpp + ) + +FILE(GLOB HEADERS *.h) + +IF (NOT USE_KDE4) + KDE3_AUTOMOC(${libkbfxplasmadatasettingssrc}) + + ADD_LIBRARY(kbfxplasmadatasettings SHARED ${libkbfxplasmadatasettingssrc}) + SET_TARGET_PROPERTIES(kbfxplasmadatasettings + PROPERTIES + COMPILE_FLAGS ${CMAKE_SHARED_LIBRARY_CXX_FLAGS}) + # SET_TARGET_PROPERTIES(kbfxplasmadatasettings PROPERTIES + # SOVERSION ${LIB_MAJOR} + # VERSION ${APPLICATION_VERSION}) + TARGET_LINK_LIBRARIES(kbfxplasmadatasettings + kbfxdata + ${QT_AND_KDECORE_LIBS} + ${KDE3_KIO_LIBRARY} + ${KDE3_UI_LIBRARY} + ${KDE3_KHTML_LIBRARY} + ${M_LIBRARY} + ) + + KDE3_INSTALL_LIBTOOL_FILE(kbfxplasmadatasettings ${LIB_INSTALL_DIR}/kbfx/plugins) +ELSE (NOT USE_KDE4) + KDE4_AUTOMOC(${libkbfxplasmadatasettingssrc}) + + KDE4_ADD_LIBRARY(kbfxplasmadatasettings SHARED ${libkbfxplasmadatasettingssrc}) + TARGET_LINK_LIBRARIES(kbfxplasmadatasettings + kbfxdata + ${KDE4_KDECORE_LIBS} + ${KDE4_KIO_LIBS} + ${KDE4_KDEUI_LIBS} + ${KDE4_KHTML_LIBS} + ${M_LIBRARY} + ) + + KDE4_INSTALL_LIBTOOL_FILE(kbfxplasmadatasettings ${LIB_INSTALL_DIR}/kbfx/plugins) +ENDIF (NOT USE_KDE4) + +INSTALL(TARGETS kbfxplasmadatasettings DESTINATION ${LIB_INSTALL_DIR}/kbfx/plugins) +INSTALL(FILES ${HEADERS} DESTINATION ${INCLUDE_INSTALL_DIR}/kbfx/plugins) diff --git a/plugins/settings/kbfxplasmadatapluginsettings.cpp b/plugins/settings/kbfxplasmadatapluginsettings.cpp new file mode 100644 index 0000000..bc02003 --- /dev/null +++ b/plugins/settings/kbfxplasmadatapluginsettings.cpp @@ -0,0 +1,189 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + + +void +browseApp ( KServiceGroup::Ptr service, KbfxDataGroupList * glist, + KbfxDataGroup * appGroup ) +{ + if ( !service || !service->isValid () ) + return; + + + KServiceGroup::List list = service->entries ( true, true, false, true ); + + /* + if (service->noDisplay () == true) + return; + + + if (list.count () <= 0) + return; + */ + + appGroup = new KbfxDataGroup (); + appGroup->setName ( service->caption () ); + + for ( KServiceGroup::List::ConstIterator it = list.begin (); + it != list.end (); it++ ) + { + KSycocaEntry *p = ( *it ); + if ( p->isType ( KST_KService ) ) + { + KService *s = static_cast < KService * > ( p ); + KbfxDataSource *data = new KbfxDataSource (); + data->setDesktopPath ( s->desktopEntryPath () ); + appGroup->addItem ( data ); + } + else if ( p->isType ( KST_KServiceGroup ) ) + { + KServiceGroup *g = static_cast < KServiceGroup * > ( p ); + if ( g->childCount () > 0 ) + { + glist->addGroup ( appGroup ); + appGroup = new KbfxDataGroup (); + appGroup->setName ( g->caption () ); + browseApp ( g, glist, appGroup ); + } + + } + } +//if(appGroup->count() >0) + glist->addGroup ( appGroup ); + +} + + + + + + +KbfxDataStack * +view () +{ + KbfxDataGroup *appGroup = new KbfxDataGroup (); + KbfxDataGroupList *glist = new KbfxDataGroupList (); + KbfxDataStack *gstack = new KbfxDataStack (); + + KServiceGroup::Ptr service = KServiceGroup::baseGroup ( "settings" );//KServiceGroup::group ("/"); + if ( service == NULL) + { + int messageBoxUserResReturn = KMessageBox::questionYesNo ( 0, + tr2i18n ( "

There is a problem in KDE Menu services!
KBFX can try to autorepair this problem.
Should KBFX autorepair this problem?

" ), + tr2i18n ( "Problem in KDE Menu Services" ), + tr2i18n ( "Do Autorepair" ), + tr2i18n ( "Do NOT Autorepair" ) ); + if ( messageBoxUserResReturn == KMessageBox::Yes ) + { + KRun::runCommand ( "kbuildsycoca" ); +// if ( ! ConfigInit().m_KbfxWatcher ) +// { + DCOPRef m_kickerPanel("kicker", "kicker"); + m_kickerPanel.call("restart()"); +// } + } + return new KbfxDataStack(); + } + + service->setShowEmptyMenu ( false ); + + glist->setName ( "Settings" ); + appGroup->setName ( service->caption () ); + + + KServiceGroup::List list = service->entries ( true, true, false, false ); + + if ( list.count() <= 0) + { + return new KbfxDataStack(); + } + + for ( KServiceGroup::List::ConstIterator it = list.begin (); + it != list.end (); it++ ) + { + KSycocaEntry *p = ( *it ); + if ( p->isType ( KST_KService ) ) + {} + else if ( p->isType ( KST_KServiceGroup ) ) + { + KServiceGroup *g = static_cast < KServiceGroup * > ( p ); + g->setShowEmptyMenu ( false ); + + if ( g->childCount () > 0 ) + { + glist = new KbfxDataGroupList (); + glist->setName ( g->caption () ); + glist->setIcon ( g->icon () ); + browseApp ( g, glist, appGroup ); + gstack->addGroupList ( glist ); + } + + } + } + + gstack->setName ( "Settings" ); + + + return gstack; + +} + +QString +name () +{ + return QString ( "Settings" ); +} + +QString +type () +{ + return QString ( "Stub Type" ); +} + +uint +id () +{ + return 1; //TODO see what can be done... manybe rand()? +} + + + +KbfxDataGroup * +search ( QString _keyword ) +{ + _keyword = _keyword; + return new KbfxDataGroup(); + +} + diff --git a/plugins/strigi/CMakeLists.txt b/plugins/strigi/CMakeLists.txt new file mode 100644 index 0000000..29289b0 --- /dev/null +++ b/plugins/strigi/CMakeLists.txt @@ -0,0 +1,46 @@ +SET(libkbfxstrigiclientsrc + kbfxstrigiplugin.cpp + ) + +FILE(GLOB HEADERS *.h) + +IF (NOT USE_KDE4) + KDE3_AUTOMOC(${libkbfxstrigiclientsrc}) + + ADD_LIBRARY(kbfxstrigiclient SHARED ${libkbfxstrigiclientsrc}) + SET_TARGET_PROPERTIES(kbfxstrigiclient + PROPERTIES + COMPILE_FLAGS ${CMAKE_SHARED_LIBRARY_CXX_FLAGS}) + # SET_TARGET_PROPERTIES(kbfxstrigiclient PROPERTIES + # SOVERSION ${LIB_MAJOR} + # VERSION ${APPLICATION_VERSION}) + TARGET_LINK_LIBRARIES(kbfxstrigiclient + kbfxdata + ${QT_AND_KDECORE_LIBS} + ${KDE3_KIO_LIBRARY} + ${KDE3_UI_LIBRARY} + ${KDE3_KHTML_LIBRARY} + ${M_LIBRARY} + ${STRIGICLIENT_LIBRARY} + ) + + KDE3_INSTALL_LIBTOOL_FILE(kbfxstrigiclient ${LIB_INSTALL_DIR}/kbfx/plugins) +ELSE (NOT USE_KDE4) + KDE4_AUTOMOC(${libkbfxstrigiclientsrc}) + + KDE4_ADD_LIBRARY(kbfxstrigiclient SHARED ${libkbfxstrigiclientsrc}) + TARGET_LINK_LIBRARIES(kbfxstrigiclient + kbfxdata + ${KDE4_KDECORE_LIBS} + ${KDE4_KIO_LIBS} + ${KDE4_KDEUI_LIBS} + ${KDE4_KHTML_LIBS} + ${M_LIBRARY} + ${STRIGICLIENT_LIBRARY} + ) + + KDE4_INSTALL_LIBTOOL_FILE(kbfxstrigiclient ${LIB_INSTALL_DIR}/kbfx/plugins) +ENDIF (NOT USE_KDE4) + +INSTALL(TARGETS kbfxstrigiclient DESTINATION ${LIB_INSTALL_DIR}/kbfx/plugins) +INSTALL(FILES ${HEADERS} DESTINATION ${INCLUDE_INSTALL_DIR}/kbfx/plugins) diff --git a/plugins/strigi/kbfxstrigiplugin.cpp b/plugins/strigi/kbfxstrigiplugin.cpp new file mode 100644 index 0000000..dd9471b --- /dev/null +++ b/plugins/strigi/kbfxstrigiplugin.cpp @@ -0,0 +1,225 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "kbfxstrigiplugin.h" + + + +bool +stopDaemon () +{ + return true; +} + +bool +startDaemon () +{ + stopDaemon (); + +// TODO: add the actual code to start the daemon process + return true; +} + +void +init () +{} + +void +poll () +{ +} + + +KbfxDataStack * +view () +{ + KbfxDataGroup *appGroup = new KbfxDataGroup (); + KbfxDataGroupList *glist = new KbfxDataGroupList (); + KbfxDataStack *gstack = new KbfxDataStack (); + + init (); + glist->setName ( "Configure" ); + appGroup->setName ( "Strigi Options" ); + KbfxDataSource *m_source = new KbfxDataSource (); + m_source->setName ( "Start Indexing" ); + m_source->setCommand ( "kfmclient exec strigi:/status/startindexing" ); + m_source->setComment ( "Starts Building an Index" ); + m_source->setIconPath ( "enhanced_browsing.png" ); + appGroup->addItem ( m_source ); + + m_source = new KbfxDataSource (); + m_source->setName ( "Stop Indexing" ); + m_source->setCommand ( "kfmclient exec strigi:/status/stopindexing" ); + m_source->setComment ( "Stop Index Building Process" ); + m_source->setIconPath ( "enhanced_browsing.png" ); + appGroup->addItem ( m_source ); + m_source = new KbfxDataSource (); + m_source->setName ( "Stop Daemon" ); + m_source->setCommand ( "kfmclient exec strigi:/status/stop" ); + m_source->setComment ( "Stop Search Engine" ); + m_source->setIconPath ( "enhanced_browsing.png" ); + appGroup->addItem ( m_source ); + + m_source = new KbfxDataSource (); + m_source->setName ( "Advanced Searching" ); + m_source->setCommand ( "kfmclient exec strigi:/" ); + m_source->setComment ( "Detailed Search Results" ); + m_source->setIconPath ( "enhanced_browsing.png" ); + appGroup->addItem ( m_source ); + m_source = new KbfxDataSource (); + m_source->setName ( "Start Daemon" ); + m_source->setCommand ( "kfmclient exec strigi:/status/start" ); + m_source->setComment ( "Start Search Engine" ); + m_source->setIconPath ( "enhanced_browsing.png" ); + appGroup->addItem ( m_source ); + + glist->addGroup ( appGroup ); + gstack->addGroupList ( glist ); + gstack->setName ( "Strigi" ); + + return gstack; +} + + +QString +name () +{ + return QString ( "Strigi" ); +} + +QString +type () +{ + return QString ( "Stub Type" ); +} + + +uint +id () +{ + return 1; //TODO see what can be done... maybe rand()? +} + + + +KbfxDataGroup * +search ( QString _keyword ) +{ + + KbfxDataGroup *datagroup = new KbfxDataGroup (); + datagroup->setName ( "Strigi" ); + + QString socketpath = QDir::homeDirPath () + "/.strigi/socket"; + startDaemon (); + kdDebug() << socketpath << endl; + AsyncSocketClient socket; + ClientInterface::Hits hits; + + + socket.setSocketPath ( ( const char * ) socketpath.utf8 () ); + bool ok = socket.query ( _keyword.ascii (), 5, 0 ); + + if ( ok == true ) + { + while ( !socket.statusChanged () ) + { + struct timespec sleeptime; + sleeptime.tv_sec = 0; + sleeptime.tv_nsec = 1; + nanosleep ( &sleeptime, 0 ); + } + hits = socket.getHits (); + + jstreams::IndexedDocument hit; +// int last = ( hits.hits.size () > 5 ) ? 5 : hits.hits.size (); + + + for ( uint i = 0; i < socket.getHits ().hits.size (); ++i ) + { + jstreams::IndexedDocument hit = hits.hits[i]; + KbfxDataSource *data = new KbfxDataSource (); + + QString name; + std::map < std::string, std::string >::const_iterator it = + hits.hits[i].properties.find ( "title" ); + + QString filename ( hits.hits[i].uri.c_str () ); + + if ( filename.contains ( ".tar." ) > 0 ) + { + filename = "tar:" + filename; + kdDebug() << filename << endl; + } + + if ( it != hits.hits[i].properties.end () ) + { + name = it->second; + } + else + { + uint pos = hits.hits[i].uri.rfind ( '/' ); + if ( pos == std::string::npos ) + { + name = hits.hits[i].uri; + } + else + { + name = hits.hits[i].uri.substr ( pos + 1 ); + } + } + + + data->setName ( name ); + + + + data->setCommand ( "kfmclient exec " + filename ); + + + + QString iconname = + KMimeType::mimeType ( hits.hits[i].mimetype.c_str () )-> + icon ( QString::null, 0 ); + data->setIconPath ( iconname ); + datagroup->addItem ( data ); + + } + } + else + { + KbfxDataSource *data = new KbfxDataSource (); + data->setName ( "Start Strigi" ); + data->setComment ( "Strigi Daemon down" ); + data->setCommand ( "strigidaemon &" ); + } + + return datagroup; + + +} diff --git a/plugins/strigi/kbfxstrigiplugin.h b/plugins/strigi/kbfxstrigiplugin.h new file mode 100644 index 0000000..a2e3137 --- /dev/null +++ b/plugins/strigi/kbfxstrigiplugin.h @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2006 + * Siraj Razick + * PhobosK + * see Also AUTHORS + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License version 2 as + * published by the Free Software Foundation + * + * 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 Library 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. + */ + +#ifndef KBFX_STRIGI_PLUGIN_H +#define KBFX_STRIGI_PLUGIN_H + +//#include "kbfxplasmacanvasstack.h" +//#include "kbfxplasmacanvasitemwrapper.h" +#include "kbfxdatastack.h" +#include +#include +#include + +extern "C" +{ + KbfxDataStack * view(); + QString name(); //Name of the Plugin My Music .if TOM Create..Configure .. + QString type(); //Type of the plugin ex: Application : Amork : kio ..etc + uint id(); //A id for menus + KbfxDataGroup * search ( QString str ); +// KbfxPlasmaCanvasGroup * search(QString _keyword,QCanvas * canvas); //search and return a group +} + +#endif diff --git a/po/CMakeLists.txt b/po/CMakeLists.txt new file mode 100644 index 0000000..7f31392 --- /dev/null +++ b/po/CMakeLists.txt @@ -0,0 +1 @@ +ADD_POFILES("kbfxconfigapp") diff --git a/po/bg.po b/po/bg.po new file mode 100644 index 0000000..f77d285 --- /dev/null +++ b/po/bg.po @@ -0,0 +1,1649 @@ +# translation of bg.po to Bulgarian +# Bulgarian translation for KBFX +# Copyright (c) 2007 KBFX Team +# This file is distributed under the same license as the KBFX package. +# +# Lexus , 2006. +# PhobosK , 2007. +msgid "" +msgstr "" +"Project-Id-Version: bg\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2007-03-04 15:53+0200\n" +"PO-Revision-Date: 2007-03-04 16:04+0200\n" +"Last-Translator: PhobosK \n" +"Language-Team: Bulgarian \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Poedit-Language: Bulgarian\n" +"X-Poedit-Country: BULGARIA\n" +"X-Generator: KBabel 1.11.4\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: _translatorinfo.cpp:1 +msgid "" +"_: NAME OF TRANSLATORS\n" +"Your names" +msgstr "Lexus" + +#: _translatorinfo.cpp:3 +msgid "" +"_: EMAIL OF TRANSLATORS\n" +"Your emails" +msgstr "lexus_t@abv.bg" + +#: kbfxlib/common/kbfxconfig.cpp:32 +msgid "Not Specified" +msgstr "Няма Информация" + +#: kbfxlib/common/kbfxfontchooser.cpp:38 +msgid "Font..." +msgstr "Шрифт..." + +#: configdialog/kbfxconfigapp.cpp:28 +msgid "

%1

" +msgstr "

%1

" + +#: configdialog/kbfxconfigapp.cpp:29 +msgid "You are running: KBFX " +msgstr "Вие използвате: KBFX" + +#: configdialog/kbfxconfigapp.cpp:30 +msgid "" +"

The connection to the KBFX News " +"Section on www.kbfx.org is broken.

If you want you can check " +"the latest news for KBFX from here:
KBFX " +"News

" +msgstr "" +"

Връзката към \"KBFX Новини\" не " +"може да се осъществи.

Ако желаете можете да проверите " +"последните новости за KBFX тук:
KBFX " +"Новини

" + +#: configdialog/kbfxconfigapp.cpp:35 +msgid "" +"KBFX start button
Tip! You have 3 " +"options to select for your KBFX start button.You have to select (Normal, " +"Pressed, Hover) images.
Down below you can also see a preview of the " +"images you have selected." +msgstr "" +"KBFX старт бутон
Съвет!Имате 3 " +"възможности за избор на KBFX старт бутон. Трябва да изберете изображения " +"за(Нормален, Натиснат, Посочен) бутон.
По-надолу можете да " +"разгледате изображенията които сте избрали." + +#: configdialog/kbfxconfigapp.cpp:40 +msgid "" +"About KBFX
Tip! Here you can find " +"information about the KBFX Project and all the people involved in it." +msgstr "" +"Относно програмата KBFX
Съвет!Тук " +"можете да намерите информация относно KBFX проекта и за всички участници в " +"него." + +#: configdialog/kbfxconfigapp.cpp:43 +msgid "" +"KBFX font settings
Tip! Here you can " +"set the fonts of the current theme.
If you don't have any 'kbfxfontrc' " +"file don't worry about that.
When done just hit 'Apply' button and KBFX " +"will save the 'kbfxfontrc' file." +msgstr "" +"KBFX настройки на шрифта
Съвет!Тук " +"можете да настроите шрифта на настоящата тема.
Ако нямате \"kbfxfontrc\" " +"файл, когато приключите, натиснете бутона \"Прилагане\" и \"kbfxfontrc\" ще " +"се създаде автоматично." + +#: configdialog/kbfxconfigapp.cpp:48 +msgid "" +"KBFX Layout
Tip! Here you can " +"configure the Look and Feel of your KBFX menu.
The most important " +"settings that are used with the 'Make it...' buttons are " +"marked with '*'
Have in mind that the Layout of the " +"theme also depends on the sizes of the images!
" +msgstr "" +"KBFX Изглед
Съвет! Тук можете да " +"определите външния вид на вашето KBFX меню.
Най-важните настройки, които " +"могат да бъдат направени с бутоните'Направи...' са " +"отбелязани със'*'
Трябва да имате в предвид,че Изгледа " +"на темата също е свързан с размерите на изображенията!
" + +#: configdialog/kbfxconfigapp.cpp:53 +msgid "" +"KBFX Plugins
Tip! Here you can " +"select what plugins will be enabled and in which panel of the KBFX menu." +msgstr "" +"KBFX Приставки
Съвет! Тук можете да " +"изберете каква приставка ще използвате и в кой панел на KBFX менюто." + +#: configdialog/kbfxconfigapp.cpp:56 +msgid "" +"Menu Type
Tip! Please select which " +"kind of menu you would like to use." +msgstr "" +"Тип на Менюто
Съвет!Моля изберете " +"вида на менюто, което искате да използвате." + +#: configdialog/kbfxconfigapp.cpp:59 +msgid "" +"KBFX Themes
Tip! To keep it simple " +"place all your themes inside one folder.
Then create different folders " +"inside that folder with different names.
KBFX will then read those " +"folders as themes." +msgstr "" +"KBFX Теми
Съвет!За да запазите " +"темите просто поставете всички ваши теми в една папка.
След това създайте " +"в нея други папки с различни имена.
KBFX ще разчита тези папки като теми." + +#: configdialog/kbfxconfigapp.cpp:64 +msgid "" +"KBFX tooltip settings
Tip! Here you " +"can configure the behaviour of KBFX's own tooltip." +msgstr "" +"KBFX настройки на подсказките
Съвет! Тук можете да определите поведението на избрани от вас KBFX подсказки." + +#: configdialog/kbfxconfigapp.cpp:93 +msgid "Themes" +msgstr "Теми" + +#: configdialog/kbfxconfigapp.cpp:105 rc.cpp:230 +#, no-c-format +msgid "Start Button" +msgstr "Старт бутон" + +#: configdialog/kbfxconfigapp.cpp:121 rc.cpp:239 +#, no-c-format +msgid "Menu Style" +msgstr "Стил на менюто" + +#: configdialog/kbfxconfigapp.cpp:130 rc.cpp:242 +#, no-c-format +msgid "Tooltip" +msgstr "Подсказка" + +#: configdialog/kbfxconfigapp.cpp:141 +msgid "Layout" +msgstr "Изглед" + +#: configdialog/kbfxconfigapp.cpp:151 rc.cpp:248 +#, no-c-format +msgid "Plugins" +msgstr "Приставки" + +#: configdialog/kbfxconfigapp.cpp:240 +msgid "No default settings here ;)" +msgstr "Тук няма настройки по подразбиране ;)" + +#: configdialog/kbfxconfigapp.cpp:423 +msgid "

Could not create this KBFX theme package.

" +msgstr "

Пакета с KBFX темата не може да бъде създаден.

" + +#: configdialog/kbfxconfigapp.cpp:435 +msgid "

KBFX Theme %1 prepared.

" +msgstr "

KBFX темата %1 подготвена.

" + +#: configdialog/kbfxconfigapp.cpp:436 +msgid "KBFX Theme Ready" +msgstr "KBFX Темата е готова" + +#: configdialog/main.cpp:33 +msgid "KBFX Configuration Utility" +msgstr "KBFX Конфигуриратор" + +#: configdialog/main.cpp:39 +msgid "kbfxconfigapp" +msgstr "kbfxconfigapp" + +#: configdialog/main.cpp:52 +msgid "Install KBFX theme from " +msgstr "Инсталиране на KBFX тема от папка " + +#: configdialog/main.cpp:53 +msgid "Prepare KBFX theme from folder " +msgstr "Подготвяне на KBFX тема от папка " + +#: configdialog/main.cpp:54 +msgid "Show the About page" +msgstr "Покажи страницата \"Относно програмата KBFX\"" + +#: src/kbfxspinx.cpp:234 +msgid "This is a help box" +msgstr "Това е прозорец \"Помощ\"" + +#: src/kbfxspinx.cpp:358 +msgid "Remove KBFX from Pannel" +msgstr "Премахване на KBFX от панела" + +#: src/kbfxspinx.cpp:360 +msgid "Reload KBFX" +msgstr "Презареди KBFX" + +#: src/kbfxspinx.cpp:363 +msgid "Configure KBFX" +msgstr "Конфигурация на KBFX" + +#: src/kbfxspinx.cpp:365 +msgid "Edit Applications Menu" +msgstr "Редактиране на Менюто" + +#: src/kbfxspinxmenu.cpp:54 +msgid "Double click to clear..." +msgstr "Натисни два пъти за да изтриеш..." + +#: src/kbfxspinxmenu.cpp:66 +msgid "Type here to search..." +msgstr "Пишете тук за да търсите програми..." + +#: src/kbfxbutton.cpp:270 +msgid "" +"Invalid images were dropped!\n" +"Cannot set the KBFX button to use these images!" +msgstr "" +"Използвахте невалидни изображения!\n" +"Невъзможно е KBFX бутона да използва тези изображения!" + +#: src/kbfxbutton.cpp:272 +msgid "Error setting KBFX button images" +msgstr "Грешка при настройването на изображенията за KBFX бутона" + +#: rc.cpp:3 +#, no-c-format +msgid "KBFX Button" +msgstr "KBFX Бутон" + +#: rc.cpp:6 +#, no-c-format +msgid "" +"To change KBFX button skin, simply browse to the image you want OR just " +"Drag&Drop the images to their respective place." +msgstr "" +"За да промените изгледа на KBFX бутона просто изберете изображението, което " +"желаете ИЛИ Придърпайте и Пуснете изображението на съответветстващото му " +"място." + +#: rc.cpp:9 +#, no-c-format +msgid "Livepreview" +msgstr "Реален преглед" + +#: rc.cpp:12 +#, no-c-format +msgid "" +"Tip! To see live preview, hover or press the preview image with your " +"mouse." +msgstr "Съвет! За реалния изглед посочете/натиснете изображението за преглед." + +#: rc.cpp:15 +#, no-c-format +msgid "KBFX Button live preview" +msgstr "Реален бутон" + +#: rc.cpp:18 +#, no-c-format +msgid "Here you can see the live preview of the KBFX Button." +msgstr "Тук можете да проверите реалния изглед на KBFX бутона." + +#: rc.cpp:21 +#, no-c-format +msgid "Resize Panel" +msgstr "Големина на панела" + +#: rc.cpp:24 +#, no-c-format +msgid "" +"Tip! This button resizes the panel on which the KBFX button is to " +"button's height or width." +msgstr "" +"Съвет! Бутона променя размера на панела върху който се намира KBFX " +"бутона." + +#: rc.cpp:27 configdialog/kbfxconfigdlgbutton.ui.h:141 +#, no-c-format +msgid "Panel Resize is 'ON'" +msgstr "Оразмеряване на панела 'ВКЛ'" + +#: rc.cpp:32 +#, no-c-format +msgid "

Preview of selected images

" +msgstr "

Преглед на избраните изображения

" + +#: rc.cpp:35 +#, no-c-format +msgid "\"PRESSED\" IMAGE SELECTION" +msgstr "ИЗБОР НА ИЗОБРАЖЕНИЕ за \"НАТИСНАТ\" БУТОН" + +#: rc.cpp:38 +#, no-c-format +msgid "Please select \"pressed\" image." +msgstr "Моля изберете изображение за \"натиснат\" бутон." + +#: rc.cpp:41 rc.cpp:65 rc.cpp:89 +#, no-c-format +msgid "image/jpeg image/png image/x-xpm image/gif" +msgstr "image/jpeg image/png image/x-xpm image/gif" + +#: rc.cpp:44 +#, no-c-format +msgid "The Pressed Button Skin Image" +msgstr "Изображение за Натиснат бутон" + +#: rc.cpp:47 +#, no-c-format +msgid "Here you can choose the Pressed Button Skin Image" +msgstr "Тук можете да изберете изображение за изгледа на Натиснат бутон" + +#: rc.cpp:50 rc.cpp:74 rc.cpp:98 +#, no-c-format +msgid "Preview" +msgstr "Предварителен изглед" + +#: rc.cpp:53 +#, no-c-format +msgid "Pressed Button Skin" +msgstr "Изглед на Натиснат бутон" + +#: rc.cpp:56 +#, no-c-format +msgid "Here you can Drag&Drop the Pressed Button Skin Image." +msgstr "Тук можете да Придърпате и Пуснете изображението за Изглед на Натиснат Бутон." + +#: rc.cpp:59 +#, no-c-format +msgid "\"NORMAL\" IMAGE SELECTION" +msgstr "ИЗБОР НА ИЗОБРАЖЕНИЕ за \"НОРМАЛЕН\" БУТОН" + +#: rc.cpp:62 +#, no-c-format +msgid "Please select \"normal\" image." +msgstr "Моля изберете изображение за \"нормален\" бутон." + +#: rc.cpp:68 +#, no-c-format +msgid "The Normal Button Skin Image" +msgstr "Изображение за Нормален бутон" + +#: rc.cpp:71 +#, no-c-format +msgid "Here you can choose the Normal Button Skin Image" +msgstr "Тук можете да изберете изображение за изгледа на Нормалния бутон" + +#: rc.cpp:77 +#, no-c-format +msgid "Normal Button Skin" +msgstr "Изглед на Нормален бутон" + +#: rc.cpp:80 +#, no-c-format +msgid "Here you can Drag&Drop the Normal Button Skin Image." +msgstr "Тук можете да Придърпате и Пуснете изображението за Изглед на Нормален Бутон." + +#: rc.cpp:83 +#, no-c-format +msgid "\"HOVER\" IMAGE SELECTION" +msgstr "ИЗБОР НА ИЗОБРАЖЕНИЕ за \"ПОСОЧЕН\" БУТОН" + +#: rc.cpp:86 +#, no-c-format +msgid "Please select \"hover\" image." +msgstr "Моля изберете изображение за \"посочен\" бутон." + +#: rc.cpp:92 +#, no-c-format +msgid "The Hover Button Skin Image" +msgstr "Изображение за Посочен бутон" + +#: rc.cpp:95 +#, no-c-format +msgid "Here you can choose the Hover Button Skin Image" +msgstr "Тук можете да изберете изображение за изгледа на Посочения бутон" + +#: rc.cpp:101 +#, no-c-format +msgid "Hover Button Skin" +msgstr "Изглед на Посочен бутон" + +#: rc.cpp:104 +#, no-c-format +msgid "Here you can Drag&Drop the Hover Button Skin Image." +msgstr "Тук можете да Придърпате и Пуснете изображението за Изглед на Посочен Бутон." + +#: rc.cpp:107 +#, no-c-format +msgid "

Please select KBFX button's images

" +msgstr "

Моля изберете изображенията за KBFX бутона

" + +#: rc.cpp:110 rc.cpp:179 rc.cpp:296 rc.cpp:404 rc.cpp:440 rc.cpp:461 +#, no-c-format +msgid "KBFX Control Center" +msgstr "Контролен Панел на KBFX" + +#: rc.cpp:113 +#, no-c-format +msgid "

Layout options

" +msgstr "

Свойства на Изгледа

" + +#: rc.cpp:116 +#, no-c-format +msgid "EXPORT KBFXLAYOUTRC FILE" +msgstr "Експорт в KBFXLAYOUTRC файл" + +#: rc.cpp:119 +#, no-c-format +msgid "Export the kbfxlayoutrc file to a folder" +msgstr "Експорт на KBFXLAYOUTRC файла в папка" + +#: rc.cpp:122 rc.cpp:473 +#, no-c-format +msgid "Setup fonts for your KBFX" +msgstr "Настройка на шрифтовете на KBFX менюто" + +#: rc.cpp:125 rc.cpp:476 +#, no-c-format +msgid "Theme that is edited:" +msgstr "Тема която се конфигурира:" + +#: rc.cpp:128 rc.cpp:479 +#, no-c-format +msgid "

default

" +msgstr "

default

" + +#: rc.cpp:131 rc.cpp:482 +#, no-c-format +msgid "Please select the theme you want to edit" +msgstr "Моля изберете темата, която желаете да редактирате" + +#: rc.cpp:134 +#, no-c-format +msgid "Select the Layout property to change" +msgstr "Изберете свойството на Изгледа промяна" + +#: rc.cpp:137 +#, no-c-format +msgid "Make it 2 panels (Left \"ON\")" +msgstr "Направи 2 панелно меню (дясно)" + +#: rc.cpp:140 +#, no-c-format +msgid "Make it 2 panels (Right \"ON\")" +msgstr "Направи 2 панелно меню (ляво)" + +#: rc.cpp:143 +#, no-c-format +msgid "Make it 3 panels" +msgstr "Направи 3 панелно меню" + +#: rc.cpp:146 +#, no-c-format +msgid "textLabel1" +msgstr "textLabel1" + +#: rc.cpp:149 +#, no-c-format +msgid "textLabel2" +msgstr "textLabel2" + +#: rc.cpp:152 +#, no-c-format +msgid "textLabel3" +msgstr "textLabel3" + +#: rc.cpp:155 +#, no-c-format +msgid "textLabel4" +msgstr "textLabel4" + +#: rc.cpp:158 +#, no-c-format +msgid "checkBox1" +msgstr "checkBox1" + +#: rc.cpp:161 +#, no-c-format +msgid "textLabel5" +msgstr "textLabel5" + +#: rc.cpp:164 +#, no-c-format +msgid "textLabel6" +msgstr "textLabel6" + +#: rc.cpp:167 +#, no-c-format +msgid "textLabel7" +msgstr "textLabel7" + +#: rc.cpp:170 +#, no-c-format +msgid "textLabel8" +msgstr "textLabel8" + +#: rc.cpp:173 +#, no-c-format +msgid "checkBox2" +msgstr "checkBox2" + +#: rc.cpp:176 +#, no-c-format +msgid "C&ustom" +msgstr "Потребителски &настройки" + +#: rc.cpp:182 +#, no-c-format +msgid "

Plugins options

" +msgstr "

Свойства на приставката

" + +#: rc.cpp:185 +#, no-c-format +msgid "Select KBFX Panel" +msgstr "Избор на KBFX панел" + +#: rc.cpp:188 rc.cpp:191 +#, no-c-format +msgid "Plugin to configure" +msgstr "Приставка за конфигуриране" + +#: rc.cpp:194 +#, no-c-format +msgid "Please select the panel you want to configure: " +msgstr "Моля изберете панела който желаете да конфигурирате: " + +#: rc.cpp:197 +#, no-c-format +msgid "&Available Plugins:" +msgstr "&Налични приставки:" + +#: rc.cpp:200 +#, no-c-format +msgid "&Enabled Plugins:" +msgstr "&Активирани приставки:" + +#: rc.cpp:203 +#, no-c-format +msgid "&Configure Plugin" +msgstr "&Конфигуриране на приставките" + +#: rc.cpp:206 +#, no-c-format +msgid "Alt+C" +msgstr "Alt+C" + +#: rc.cpp:209 rc.cpp:212 +#, no-c-format +msgid "Configure the selected plugin" +msgstr "Конфигуриране на избраната приставка" + +#: rc.cpp:215 +#, no-c-format +msgid "&Plugin Information" +msgstr "&Информация за приставката" + +#: rc.cpp:218 +#, no-c-format +msgid "Alt+P" +msgstr "Alt+P" + +#: rc.cpp:221 rc.cpp:224 +#, no-c-format +msgid "Information about the selected plugin" +msgstr "Информация за избраната приставка" + +#: rc.cpp:227 +#, no-c-format +msgid "KBFX Configurator Application" +msgstr "KBFX Конфигуратор" + +#: rc.cpp:233 +#, no-c-format +msgid "KBFX Themes" +msgstr "KBFX Теми" + +#: rc.cpp:245 +#, no-c-format +msgid "Search Engine" +msgstr "Търсене" + +#: rc.cpp:251 +#, no-c-format +msgid "About KBFX" +msgstr "Относно KBFX" + +#: rc.cpp:254 +#, no-c-format +msgid "" +"




If you want you can check the latest " +"news for KBFX from here:
KBFX News" +msgstr "" +"




Ако желаете можете да проверите " +"последните новости за KBFX на адрес:
KBFX Новини

" + +#: rc.cpp:260 +#, no-c-format +msgid "Alt+H" +msgstr "Alt+H" + +#: rc.cpp:263 +#, no-c-format +msgid "Open Help Documentation" +msgstr "Отваряне на документацията за Помощ" + +#: rc.cpp:266 +#, no-c-format +msgid "&Default" +msgstr "&Подразбиране" + +#: rc.cpp:269 +#, no-c-format +msgid "Alt+D" +msgstr "Alt+D" + +#: rc.cpp:272 +#, no-c-format +msgid "Apply the default configuration for this section only" +msgstr "Прилагане на настройките по подразбиране само за тази секция" + +#: rc.cpp:278 +#, no-c-format +msgid "Alt+A" +msgstr "Alt+A" + +#: rc.cpp:281 +#, no-c-format +msgid "Save the configuration and Apply it" +msgstr "Запазване и Прилагане на настройките" + +#: rc.cpp:287 +#, no-c-format +msgid "Alt+X" +msgstr "Alt+X" + +#: rc.cpp:290 +#, no-c-format +msgid "Exit the configuration without saving" +msgstr "Излизане от настройките без запазване" + +#: rc.cpp:293 +#, no-c-format +msgid "Kbfx start button
" +msgstr "KBFX старт бутон
" + +#: rc.cpp:299 +#, no-c-format +msgid "Select default folder" +msgstr "Избор на папка по подразбиране" + +#: rc.cpp:302 +#, no-c-format +msgid "Please select the target folder where your themes are." +msgstr "Моля изберете папка, в която се намират вашите KBFX теми." + +#: rc.cpp:305 +#, no-c-format +msgid "SpixBar" +msgstr "SpixBar" + +#: rc.cpp:308 +#, no-c-format +msgid "Installed Themes" +msgstr "Инсталирани Теми" + +#: rc.cpp:311 +#, no-c-format +msgid "Here are listed all the installed KBFX Themes" +msgstr "Тук можете да видите списъка на всички инсталирани KBFX Теми" + +#: rc.cpp:314 +#, no-c-format +msgid "Selected Theme Preview" +msgstr "Преглед на Избраната Тема" + +#: rc.cpp:317 +#, no-c-format +msgid "Delete Selected" +msgstr "Изтриване" + +#: rc.cpp:320 +#, no-c-format +msgid "Delete the Selected Theme" +msgstr "Изтрива Избраната Тема" + +#: rc.cpp:323 +#, no-c-format +msgid "" +"Pressing the button will delete the currently selected theme.
Warning!" +" You cannot delete the installed system wide themes!" +msgstr "" +"Натискането на бутона ще изтрие избраната в момента тема.
Внимание!Не можете да изтриете теми, които са инсталирани за цялата система!" + +#: rc.cpp:326 +#, no-c-format +msgid "Get Themes" +msgstr "Изтегляне" + +#: rc.cpp:329 +#, no-c-format +msgid "Get More Themes from the Internet" +msgstr "Изтегляне на още теми от Интернет" + +#: rc.cpp:332 +#, no-c-format +msgid "" +"Pressing the button will launch konqueror and go to the KBFX Themes Section " +"on www.kde-look.org" +msgstr "" +"Натискането на бутона ще стартира Konqueror и ще ви отведе до KBFX Секцията " +"за Теми на адрес www.kde-look.org" + +#: rc.cpp:335 +#, no-c-format +msgid "Install Theme" +msgstr "Инсталиране" + +#: rc.cpp:338 +#, no-c-format +msgid "Install New Theme from KBFX Theme Package" +msgstr "Инсталиране на Нова Тема от KBFX Пакет за Теми" + +#: rc.cpp:341 +#, no-c-format +msgid "" +"Pressing the button will offer a dialog where you can choose KBFX Theme " +"Package to install in your home folder" +msgstr "" +"Натискането на бутона ще отвори диалог от където можете да изберете KBFX " +"Пакет за Тема, която да инсталирате във вашата домашна папка" + +#: rc.cpp:344 rc.cpp:583 +#, no-c-format +msgid "Theme Info" +msgstr "Информация" + +#: rc.cpp:347 +#, no-c-format +msgid "Show specific theme info" +msgstr "Показване на специфична за темата информация" + +#: rc.cpp:350 +#, no-c-format +msgid "Pressing the button will show you specific theme info" +msgstr "Този бутон ще Ви покаже специфична за темата информация" + +#: rc.cpp:353 +#, no-c-format +msgid "Personal Image" +msgstr "Персонална снимка" + +#: rc.cpp:356 +#, no-c-format +msgid "Theme's Default" +msgstr "Снимка на Темата" + +#: rc.cpp:359 +#, no-c-format +msgid "Set the Theme's Default Personal Image" +msgstr "Използване на Персонална Снимка на Темата по подразбиране" + +#: rc.cpp:362 +#, no-c-format +msgid "" +"Pressing the button will delete the personal image you have selected and " +"install the theme's default personal image" +msgstr "" +"Натискането на бутона ще изтрие персоналната снимка, която сте избрали и ще " +"я замени с персоналната снимка на темата по подразбиране" + +#: rc.cpp:365 +#, no-c-format +msgid "Maxsize 48 x 48" +msgstr "Макс. 48 x 48" + +#: rc.cpp:368 +#, no-c-format +msgid "Select New image" +msgstr "Нова снимка" + +#: rc.cpp:371 +#, no-c-format +msgid "Select a Personal Image" +msgstr "Избери Персонална Снимка" + +#: rc.cpp:374 +#, no-c-format +msgid "Pressing the button will open a dialog to select your personal image" +msgstr "" +"Натискането на бутона ще отвори диалог, чрез който можете да изберете вашата " +"персонална снимка" + +#: rc.cpp:377 +#, no-c-format +msgid "This is your personal image displayed at the KBFX menu." +msgstr "Това е Вашата персонална снимка, в KBFX менюто." + +#: rc.cpp:380 +#, no-c-format +msgid "Misc Options" +msgstr "Разни" + +#: rc.cpp:383 +#, no-c-format +msgid "Watch System Installs" +msgstr "Наблюдавай системните инсталации" + +#: rc.cpp:386 rc.cpp:389 +#, no-c-format +msgid "Watch for applications installs and reload KBFX if any occurs" +msgstr "Наблюдавай за инсталиране на софтуер и презареди KBFX менюто" + +#: rc.cpp:392 rc.cpp:395 +#, no-c-format +msgid "Show Old Themes" +msgstr "Покажи и старите теми" + +#: rc.cpp:398 +#, no-c-format +msgid "

Please select theme folder

" +msgstr "

Моля изберете папка за Темите

" + +#: rc.cpp:401 +#, no-c-format +msgid "

Installed themes

" +msgstr "

Инсталирани теми

" + +#: rc.cpp:407 +#, no-c-format +msgid "

Tooltip ON or OFF

" +msgstr "

Включване/Изключване на подсказката

" + +#: rc.cpp:410 +#, no-c-format +msgid "Turn off or on the tooltip" +msgstr "Изключване или включване на подсказката" + +#: rc.cpp:413 +#, no-c-format +msgid "" +"Turn your tooltip off or on.
You can see the current status of the " +"tooltip to the right." +msgstr "" +"Включване/изключване подсказката.
Състоянието на подсказката в момента " +"е показано в дясно." + +#: rc.cpp:416 +#, no-c-format +msgid "Turn the tooltip \"OFF\"" +msgstr "Изключи подсказката" + +#: rc.cpp:419 +#, no-c-format +msgid "Tooltip Text" +msgstr "Текст на подсказката" + +#: rc.cpp:422 +#, no-c-format +msgid "Type the text which you want to be displayed in the tooltip." +msgstr "Въведете текста, за подсказката." + +#: rc.cpp:425 +#, no-c-format +msgid "

Tooltip personal text

" +msgstr "

Текст на подсказката

" + +#: rc.cpp:428 +#, no-c-format +msgid "Tooltip animation" +msgstr "Анимация на подсказката" + +#: rc.cpp:431 +#, no-c-format +msgid "" +"Turn your tooltip animation off or on.
You can see the current status of " +"the tooltip to the right." +msgstr "" +"Включване/изключване анимацията за подсказката.
Състоянието на анимацията " +"в момента е показано в дясно." + +#: rc.cpp:434 +#, no-c-format +msgid "Turn the animation \"ON\"" +msgstr "Включи анимацията" + +#: rc.cpp:437 +#, no-c-format +msgid "

Tooltip animation ON or OFF

" +msgstr "

Анимиране на подсказката

" + +#: rc.cpp:443 +#, no-c-format +msgid "

Menu type

" +msgstr "

Тип на менюто

" + +#: rc.cpp:446 +#, no-c-format +msgid "Please select the menu style" +msgstr "Моля изберете стил за менюто" + +#: rc.cpp:449 rc.cpp:455 +#, no-c-format +msgid "KBFX MENU" +msgstr "KBFX МЕНЮ" + +#: rc.cpp:452 rc.cpp:458 +#, no-c-format +msgid "KDE MENU" +msgstr "KDE МЕНЮ" + +#: rc.cpp:464 +#, no-c-format +msgid "

Font options

" +msgstr "

Настройка на шрифта

" + +#: rc.cpp:467 +#, no-c-format +msgid "EXPORT KBFXFONTRC FILE" +msgstr "ЕКСПОРТ ВЪВ ФАЙЛ" + +#: rc.cpp:470 +#, no-c-format +msgid "Export the kbfxfontrc file to a folder" +msgstr "Експорт на kbfxfontrc файла в папка" + +#: rc.cpp:485 +#, no-c-format +msgid "Bold fonts on hover" +msgstr "Открояване под мишката" + +#: rc.cpp:488 rc.cpp:491 +#, no-c-format +msgid "Make fonts bolder when you hover the mouse over an item" +msgstr "Удебели шрифтовете при посочване с мишката на програмите" + +#: rc.cpp:494 +#, no-c-format +msgid "Application \"LINE\":" +msgstr "Линия на програмите:" + +#: rc.cpp:497 +#, no-c-format +msgid "Horizontal line color in the application area." +msgstr "Цвят на хоризонталната линия в зоната за програми." + +#: rc.cpp:500 +#, no-c-format +msgid "Application text :" +msgstr "Текст на Програмите:" + +#: rc.cpp:503 +#, no-c-format +msgid "Select the color of the \"application\" in the menu." +msgstr "Изберете цвят за \"програма\" в менюто." + +#: rc.cpp:506 +#, no-c-format +msgid "Comment text:" +msgstr "Текст на Коментара:" + +#: rc.cpp:509 +#, no-c-format +msgid "Color of the \"comments\" in the menu." +msgstr "Цвят за \"коментар\" в менюто." + +#: rc.cpp:512 +#, no-c-format +msgid "Name display:" +msgstr "Текст на Името:" + +#: rc.cpp:515 rc.cpp:527 rc.cpp:533 +#, no-c-format +msgid "The color of your login name in the menu." +msgstr "Цвета на вашето име в менюто." + +#: rc.cpp:518 +#, no-c-format +msgid "Category text:" +msgstr "Текст на Категориите:" + +#: rc.cpp:521 +#, no-c-format +msgid "Font color of the categoris in the menu." +msgstr "Цвят на шрифта за категориите в менюто." + +#: rc.cpp:524 +#, no-c-format +msgid "Separator:" +msgstr "Разделител:" + +#: rc.cpp:530 +#, no-c-format +msgid "Plugin:" +msgstr "Приставки:" + +#: rc.cpp:536 +#, no-c-format +msgid "Select font for the application's text" +msgstr "Избери шрифт за текста на приложенията" + +#: rc.cpp:539 +#, no-c-format +msgid "Select font for the comment's text" +msgstr "Избор на шрифт за текста на коментарите" + +#: rc.cpp:542 +#, no-c-format +msgid "Select font for the username's text" +msgstr "Избор на шрифт за текста на потребителското име" + +#: rc.cpp:545 +#, no-c-format +msgid "Select font for the category's text" +msgstr "Избор на шрифт за текста на категориите" + +#: rc.cpp:548 +#, no-c-format +msgid "Select font for the separator's text" +msgstr "Избор на шрифт за текста на разделителите" + +#: rc.cpp:551 +#, no-c-format +msgid "Select font for the plugins' text" +msgstr "Избор на шрифт за текста на плъгините" + +#: rc.cpp:554 +#, no-c-format +msgid "Form1" +msgstr "Form1" + +#: rc.cpp:557 +#, no-c-format +msgid "

People behind KBFX

" +msgstr "

Хората зад KBFX

" + +#: rc.cpp:560 +#, no-c-format +msgid "You are running: KBFX 0493" +msgstr "Използвате: KBFX 0493" + +#: rc.cpp:563 +#, no-c-format +msgid "" +"Here are the people behind the KBFX application.\n" +"We would like to thank all people who have helped with KBFX or have donated " +"money to our project!\n" +"THANKS A LOT ALL OF YOU OUT THERE!!!" +msgstr "" +"Това са хората, които стоят зад проекта KBFX.\n" +"Искаме да благодарим на всички, които помогнаха с KBFX и на всички, които " +"дариха средства за нашия проект! МНОГО БЛАГОДАРИМ НА ВСИЧКИ!!!" + +#: rc.cpp:568 +#, no-c-format +msgid "" +"Name: Siraj Razick

Country: Sri " +"Lanka

KBFX: Author, Maintainer, Developer, Project " +"Admin

Email: siraj(a)mail.kbfx.org" +msgstr "" +"Име: Siraj Razick

Страна: Шри " +"Ланка

KBFX: Автор, поддръжка, разработка, " +"администратор на проекта

Email: siraj@mail.kbfx.org" + +#: rc.cpp:571 +#, no-c-format +msgid "" +"Tip! Hover over the contact images to see each personal contact " +"information." +msgstr "" +"Посочете изображение за да видите персонална информация за участниците в " +"проекта." + +#: rc.cpp:574 +#, no-c-format +msgid "SPONSORS!" +msgstr "СПОНСОРИ!" + +#: rc.cpp:577 +#, no-c-format +msgid "" +"We would like to thank swedish computer company PC Agenten for " +"sponsoring us with a server and bandwidth." +msgstr "" +"Благодарим на шведската компания PC Agenten за предоставеният сървър " +"и интернет връзка." + +#: rc.cpp:580 +#, no-c-format +msgid "" +"

HTTP://WWW." +"PCAGENTEN.SE

" +msgstr "" +"

HTTP://WWW." +"PCAGENTEN.SE

" + +#: rc.cpp:589 +#, no-c-format +msgid "

Name:

" +msgstr "

Име:

" + +#: rc.cpp:592 +#, no-c-format +msgid "

Version:

" +msgstr "

Версия:

" + +#: rc.cpp:595 +#, no-c-format +msgid "

Author:

" +msgstr "

Автор:

" + +#: rc.cpp:598 +#, no-c-format +msgid "

Email:

" +msgstr "

Email:

" + +#: rc.cpp:601 +#, no-c-format +msgid "

Homepage:

" +msgstr "

Интернет Адрес:

" + +#: rc.cpp:604 rc.cpp:607 rc.cpp:610 rc.cpp:613 rc.cpp:616 +#, no-c-format +msgid "Test" +msgstr "Тест" + +#: configdialog/kbfxconfigdlgthemes.ui.h:61 +msgid "" +"

Invalid user themes folder!

Will use " +"default user themes folder.

" +msgstr "" +"

Невалидна папка с теми на потребителя!

Ще бъде използвана папката с теми на потребителя по " +"подразбиране.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:63 +msgid "Error loading themes" +msgstr "Грешка при зареждането на темите" + +#: configdialog/kbfxconfigdlgthemes.ui.h:170 +msgid "" +"

Are you sure you want to uninstall the KBFX theme %" +"1?

" +msgstr "" +"

Сигурен ли сте, че искате да деинсталирате тази KBFX тема " +"%1?

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:171 +msgid "Uninstall KBFX theme" +msgstr "Деинсталиране на KBFX тема" + +#: configdialog/kbfxconfigdlgthemes.ui.h:172 +msgid "Uninstall" +msgstr "Деинсталиране" + +#: configdialog/kbfxconfigdlgthemes.ui.h:177 +msgid "" +"

Do you want to keep your personal settings for theme " +"%1?

" +msgstr "" +"

Искате ли да запазите личните си настройки на темата " +"%1?

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:178 +msgid "Personal settings" +msgstr "Персонални настройки" + +#: configdialog/kbfxconfigdlgthemes.ui.h:179 +msgid "Keep settings" +msgstr "Запази настройките" + +#: configdialog/kbfxconfigdlgthemes.ui.h:180 +msgid "Delete settings" +msgstr "Изтрий настройките" + +#: configdialog/kbfxconfigdlgthemes.ui.h:210 +msgid "" +"

Could not uninstall this KBFX theme.

You may not have sufficient permissions to delete the folder " +"%1.

" +msgstr "" +"

KBFX темата не може да бъде деинсталирана.

Вероятно нямате необходимите права, за да изтриете папката " +"%1.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:223 +msgid "KBFX theme packages (*.tar, *.tar.bz2, *.tar.gz, *.kbfxtheme)" +msgstr " KBFX теми (*.tar, *.tar.bz2, *.tar.gz, *.kbfxtheme)" + +#: configdialog/kbfxconfigdlgthemes.ui.h:227 +msgid "Select KBFX theme package to install" +msgstr "Избор на KBFX тема за инсталиране" + +#: configdialog/kbfxconfigdlgthemes.ui.h:243 +msgid "

Could not read this KBFX theme package.

" +msgstr "

Пакета с KBFX темата не може да бъде прочетен.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:270 +msgid "Select personal image" +msgstr "Избиране на Персонална Снимка" + +#: configdialog/kbfxconfigdlgthemes.ui.h:281 +msgid "" +"

Image cannot be used as a personal image!

Will use default personal image.

" +msgstr "" +"

Изображението не може да бъде използвано като персонална " +"снимка!

Ще бъде използвана персоналната снимка по " +"подразбиране.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:283 +#: configdialog/kbfxconfigdlgbutton.ui.h:65 +#: configdialog/kbfxconfigdlgbutton.ui.h:86 +#: configdialog/kbfxconfigdlgbutton.ui.h:107 +msgid "Error loading image" +msgstr "Грешка при зареждането на изображението" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:23 +msgid "Turn the animation 'OFF'" +msgstr "Изключи анимацията" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:30 +msgid "Turn the animation 'ON'" +msgstr "Включи анимацията" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:53 +msgid "Turn the tooltip 'OFF'" +msgstr "Изключи подсказката" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:60 +msgid "Turn the tooltip 'ON'" +msgstr "Включи подсказката" + +#: configdialog/kbfxconfigdlgfonts-old.ui.h:122 +msgid "Select folder to export kbfxfontrc file" +msgstr "Изберете директория където да бъде запазен KBFXLAYOUTRC файла" + +#: configdialog/kbfxconfigdlgfonts-old.ui.h:151 +msgid "" +"

The Font configuration of the KBFX Theme %1 has been exported successfully!

" +msgstr "" +"

Настройките за Шрифт на KBFX темата %1са " +"успешно експортирани!

" + +#: configdialog/kbfxconfigdlgfonts-old.ui.h:152 +msgid "KBFX Font Export Ready" +msgstr "Експортирането на шрифта на KBFX е готово" + +#: configdialog/kbfxconfigdlgabout.ui.h:23 +msgid "" +"Name: Mensur Zahirovic (Nookie)

Country: Sweden

KBFX: co-author, Q/A, system design, " +"web designer, bug hunter, project administror

Email: " +"nookie@mail.kbfx.org" +msgstr "" +"Име: Mensur Zahirovic (Nookie)

Страна: Швеция

KBFX: Съавтор, Q/A, системен и уеб " +"дизайн, тестер, администратор на проекта

Email: " +"nookie@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:32 +msgid "" +"Name: Siraj Razick

Country: Sri " +"Lanka

KBFX: author, maintainer, developer, project " +"administror

Email: siraj@mail.kbfx.org" +msgstr "" +"Име: Siraj Razick

Страна: Шри " +"Ланка

KBFX: Автор, поддръжка, разработка, " +"администратор на проекта

Email: siraj@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:41 +msgid "" +"Name: Nathanael Dracor Gogniat

Country: Switzerland

KBFX: project technical writer, " +"documentation manager, co-author

Email: " +"nathanael@mail.kbfx.org" +msgstr "" +"Име: Nathanael Dracor Gogniat

Страна: Швейцария

KBFX: Теьническа доцументация, " +"съавтор

Email: nathanael@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:50 +msgid "" +"Name: PhobosK

Country: " +"Bulgaria

KBFX: package & release manager, Q/A, bug " +"hunter, mandriva packages, project administrator, developer Qt/C+" +"+

Email: phobosk@mail.kbfx.org" +msgstr "" +"Име: PhobosK

Страна: " +"България

KBFX: Поддръжка пакети и версии, Q/A, " +"програмни грешки, пакети за mandriva, разработка с Qt/C++, администратор на " +"проекта

Email: phobosk@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:59 +msgid "" +"Name: Johnny Henry Saenz Acuna (scarebyte)" +"

Country: Peru

KBFX: " +"developer Qt4/C++

Email: saenzac@mail.kbfx.org" +msgstr "" +"Име: Johnny Henry Saenz Acuna (scarebyte)" +"

Страна: Перу

KBFX: " +"Разработчик с Qt4/C++

Email: saenzac@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:68 +msgid "" +"Name: Christoffer Brodd-Reijer (Ephracis)" +"

Country: Sweden

KBFX: " +"library developer for Raptor

Email: ephracis@mail." +"kbfx.org" +msgstr "" +"Име: Christoffer Brodd-Reijer (Ephracis)" +"

Страна: Швеция

KBFX: " +"Разработчик на библиотеките за Raptor

Email: " +"ephracis@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgbutton.ui.h:63 +msgid "" +"

Image cannot be used as a pressed button skin!

Will use default pressed button skin.

" +msgstr "" +"

Изображението не може да бъде използвано като изглед за " +"натиснат бутон!

Ще бъде използван изгледа за натиснат " +"бутон по подразбиране.

" + +#: configdialog/kbfxconfigdlgbutton.ui.h:84 +msgid "" +"

Image cannot be used as a normal button skin!

Will use default normal button skin.

" +msgstr "" +"

Изображението не може да бъде използвано като изглед за " +"нормален бутон!

Ще бъде използван изгледа за нормален " +"бутон по подразбиране.

" + +#: configdialog/kbfxconfigdlgbutton.ui.h:105 +msgid "" +"

Image cannot be used as a hover button skin!

Will use default hover button skin.

" +msgstr "" +"

Изображението не може да бъде използвано като изглед за " +"посочен бутон!

Ще бъде използван изгледа за посочен " +"бутон по подразбиране.

" + +#: configdialog/kbfxconfigdlgbutton.ui.h:147 +msgid "Panel Resize is 'OFF'" +msgstr "Оразмеряване на панела 'ИЗКЛ'" + +#: configdialog/kbfxconfigdlglayout.ui.h:16 +msgid "User Properties" +msgstr "Потребителски настройки" + +#: configdialog/kbfxconfigdlglayout.ui.h:17 +msgid "* Top Bar Properties" +msgstr "* Свойства на Горната Лента" + +#: configdialog/kbfxconfigdlglayout.ui.h:18 +msgid "* Bottom Bar Properties" +msgstr "* Свойства на Долната Лента" + +#: configdialog/kbfxconfigdlglayout.ui.h:20 +msgid "* List Box Properties" +msgstr "* Свойства на Списъчното Поле" + +#: configdialog/kbfxconfigdlglayout.ui.h:21 +msgid "Search Box Properties" +msgstr "Свойства на Полето за Търсене" + +#: configdialog/kbfxconfigdlglayout.ui.h:22 +msgid "* Item Properties" +msgstr "* Свойства на Приложенията" + +#: configdialog/kbfxconfigdlglayout.ui.h:24 +msgid "* Main Menu Properties" +msgstr "* Свойства на Главното Меню" + +#: configdialog/kbfxconfigdlglayout.ui.h:25 +msgid "Water Effect Properties" +msgstr "Ефект тип вода" + +#: configdialog/kbfxconfigdlglayout.ui.h:209 +msgid "Face Position X" +msgstr "Позиция на Снимката X" + +#: configdialog/kbfxconfigdlglayout.ui.h:210 +msgid "Face Position Y" +msgstr "Позиция на Снимката Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:211 +msgid "User Name Position X" +msgstr "Позиция на Потребителското Име X" + +#: configdialog/kbfxconfigdlglayout.ui.h:212 +msgid "User Name Position Y" +msgstr "Позиция на Потребителското Име Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:213 +msgid "Face Box Position X" +msgstr "Позиция на Полето за Снимка X" + +#: configdialog/kbfxconfigdlglayout.ui.h:214 +msgid "Face Box Position Y" +msgstr "Позиция на Полето за Снимка Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:215 +msgid "Face Box Height" +msgstr "Височина на Полето за Снимка" + +#: configdialog/kbfxconfigdlglayout.ui.h:216 +msgid "Face Box Width" +msgstr "Ширина на Полето за Снимка" + +#: configdialog/kbfxconfigdlglayout.ui.h:217 +msgid "Hide User Name" +msgstr "Скриване на Потребителското Име" + +#: configdialog/kbfxconfigdlglayout.ui.h:235 +msgid "* Top Bar Height" +msgstr "* Височина на Горната Лента" + +#: configdialog/kbfxconfigdlglayout.ui.h:241 +msgid "Top Bar Width" +msgstr "Ширина на Горната Лента" + +#: configdialog/kbfxconfigdlglayout.ui.h:266 +msgid "* Bottom Bar Height" +msgstr "* Височина на Долната Лента" + +#: configdialog/kbfxconfigdlglayout.ui.h:272 +msgid "Bottom Bar Width" +msgstr "Ширина на Долната Лента" + +#: configdialog/kbfxconfigdlglayout.ui.h:322 +msgid "* List Box Position X" +msgstr "* Позиция на Списъчното Поле X" + +#: configdialog/kbfxconfigdlglayout.ui.h:323 +msgid "* List Box Position Y" +msgstr "* Позиция на Списъчното Поле Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:326 +msgid "List Box Height" +msgstr "Височина на Списъчното Поле" + +#: configdialog/kbfxconfigdlglayout.ui.h:327 +msgid "* List Box Width" +msgstr "* Ширина на Списъчното Поле" + +#: configdialog/kbfxconfigdlglayout.ui.h:345 +msgid "Search Box Position X" +msgstr "Позиция на Полето за Търсене X" + +#: configdialog/kbfxconfigdlglayout.ui.h:346 +msgid "Search Box Position Y" +msgstr "Позиция на Полето за Търсене Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:349 +msgid "Search Box Height" +msgstr "Височина на Полето за Търсене" + +#: configdialog/kbfxconfigdlglayout.ui.h:350 +msgid "Search Box Width" +msgstr "Ширина на Полето за Търсене" + +#: configdialog/kbfxconfigdlglayout.ui.h:368 +msgid "* Item Position X" +msgstr "* Позиция на Приложенията X" + +#: configdialog/kbfxconfigdlglayout.ui.h:369 +msgid "* Item Position Y" +msgstr "* Позиция на Приложенията Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:370 +msgid "Icon Size in Item" +msgstr "Големина на иконата в Приложенията" + +#: configdialog/kbfxconfigdlglayout.ui.h:372 +msgid "Item Height" +msgstr "Височина на Приложенията" + +#: configdialog/kbfxconfigdlglayout.ui.h:373 +msgid "* Item Width" +msgstr "* Ширина на Приложенията" + +#: configdialog/kbfxconfigdlglayout.ui.h:374 +msgid "Comment Margin in Item" +msgstr "Граница на Коментара в Приложенията" + +#: configdialog/kbfxconfigdlglayout.ui.h:376 +msgid "No Comments in Item" +msgstr "Без коментари в Приложенията" + +#: configdialog/kbfxconfigdlglayout.ui.h:417 +msgid "* Main Menu Height" +msgstr "* Височина на Главното Меню" + +#: configdialog/kbfxconfigdlglayout.ui.h:421 +msgid "* Main Menu Width" +msgstr "* Ширина на Главното Меню" + +#: configdialog/kbfxconfigdlglayout.ui.h:425 +msgid "Contracted Menues" +msgstr "Намалени Менюта" + +#: configdialog/kbfxconfigdlglayout.ui.h:441 +msgid "Water Effect Frame Rate" +msgstr "Честота на ефекта тип вода" + +#: configdialog/kbfxconfigdlglayout.ui.h:450 +msgid "Enabled Water Effect" +msgstr "Активиран ефект тип вода" + +#: configdialog/kbfxconfigdlglayout.ui.h:495 +msgid "Select folder to export kbfxlayoutrc file" +msgstr "Изберете папка където да бъде експортиран KBFXLAYOUTRC файла" + +#: configdialog/kbfxconfigdlglayout.ui.h:583 +msgid "" +"

The Layout configuration of the KBFX Theme %1 has been exported successfully!

" +msgstr "" +"

Настройките на Изгледа на KBFX темата%1 " +"бяха експортирани успешно!

" + +#: configdialog/kbfxconfigdlglayout.ui.h:584 +msgid "KBFX Layout Export Ready" +msgstr "Експорта на KBFX Изгледа е готов" + +#: configdialog/kbfxconfigdlglayout.ui.h:651 +msgid "" +"

The Layout configuration of the KBFX Theme %1 is ready!

Be sure to click the Apply button in order the changes to become active!

" +msgstr "" +"

Конфигурирането на Изгледа на KBFX Темата %1 е завършено!

Натиснете бутона " +"Прлилаганеза да се активират извършените промени!

" + +#: configdialog/kbfxconfigdlglayout.ui.h:652 +msgid "KBFX Layout Ready" +msgstr "KBFX Изгледа е готов" + +#: configdialog/kbfxconfigdlglayout.ui.h:658 +msgid "" +"

KBFX will calculate the necessary values using the present " +"values for:

* Main Menu Height and " +"* Main Menu Width
* Bottom Bar Height " +"and * Top Bar Height

So be sure " +"that you have entered their values as you desire!

NOTE: Have in mind that the Layout of the " +"theme also depends on the sizes of the images! So if the theme does not look " +"like as you desire either change the images' sizes to smaller width OR " +"change * Main Menu Width to higher value!

" +msgstr "" +"

KBFX ще пресметне необходимите стойности използвайки:

* Височина на Главното Меню и * " +"Ширина на Главното Меню
* Височина на Долната Лента и * Височина на Горната Лента

Така че, моля уверете се, че сте въвели стойностите, които " +"желаете!

ЗАБЕЛЕЖКА: Трябва да се има " +"предвид, че Изгледа на темата е също свързан с размерите на изображенията! " +"Ето защо, ако темата не изглежда както желаете или променете ширината на " +"изображенията ИЛИ заменете стойностите за *Ширина на Главното Меню с по-големи!

" + +#: configdialog/kbfxconfigdlglayout.ui.h:664 +msgid "Prepare Layout for the KBFX theme" +msgstr "Подготвяне на Изглед за KBFX тема" + +#: configdialog/kbfxconfigdlglayout.ui.h:665 +msgid "Prepare" +msgstr "Подготви" + +#: configdialog/kbfxconfigdlgplugins.ui.h:15 +msgid "Left Panel" +msgstr "Ляв Панел" + +#: configdialog/kbfxconfigdlgplugins.ui.h:16 +msgid "Right Panel" +msgstr "Десен Панел" + +#: configdialog/kbfxconfigdlgplugins.ui.h:79 +#: configdialog/kbfxconfigdlgplugins.ui.h:85 +msgid "

Not Implemented yet.

" +msgstr "

В процес на разработка.

" + +#: configdialog/kbfxconfigdlgmain.ui.h:34 +msgid "

Not implemented yet.

" +msgstr "

В процес на разработка.

" + +#~ msgid "Convert Theme" +#~ msgstr "Конвертиране на Темата" + +#~ msgid "Convert a theme to the new format" +#~ msgstr "Конвертира темата в новият формат" + +#~ msgid "" +#~ "Pressing the button will open dialog for converting old themes to the new " +#~ "specifications" +#~ msgstr "" +#~ "Натискането на бутона ще отвори диалог, чрез който можете да конвертирате " +#~ "темата в новият формат" + +#~ msgid "This is an about box" +#~ msgstr "Това е прозорец „Относно програмата“" + +#~ msgid "Resize Toolbar" +#~ msgstr "Размер на лентата" + +#~ msgid "Toolbar Resize is 'ON'" +#~ msgstr "Промяна размера на лентата 'ВКЛ'" + +#~ msgid "Installed Themes" +#~ msgstr "Инсталирани Теми" + +#~ msgid "Nookie" +#~ msgstr "Nookie" + +#~ msgid "Enkelhet" +#~ msgstr "Enkelhet" + +#~ msgid "Plugin color:" +#~ msgstr "Цвят на приставката" + diff --git a/po/hu.po b/po/hu.po new file mode 100644 index 0000000..817e378 --- /dev/null +++ b/po/hu.po @@ -0,0 +1,1616 @@ +# translation of hu.po to Hungarian +# Hungarian translation for KBFX +# Copyright (c) 2007 Rosetta Contributors and Canonical Ltd 2007 +# This file is distributed under the same license as the KBFX package. +# +# Ferenc Stelcz , 2007. +# PhobosK , 2007. +msgid "" +msgstr "" +"Project-Id-Version: hu\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2007-03-04 15:53+0200\n" +"PO-Revision-Date: 2007-03-04 17:39+0100\n" +"Last-Translator: Ferenc Stelcz \n" +"Language-Team: Hungarian \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Rosetta-Export-Date: 2007-02-07 06:34+0000\n" +"X-Generator: KBabel 1.11.4\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: _translatorinfo.cpp:1 +msgid "" +"_: NAME OF TRANSLATORS\n" +"Your names" +msgstr "Stelcz Ferenc" + +#: _translatorinfo.cpp:3 +msgid "" +"_: EMAIL OF TRANSLATORS\n" +"Your emails" +msgstr "ferenc@stelcz.hu" + +#: kbfxlib/common/kbfxconfig.cpp:32 +msgid "Not Specified" +msgstr "Nincs megadva" + +#: kbfxlib/common/kbfxfontchooser.cpp:38 +msgid "Font..." +msgstr "Betűtípus..." + +#: configdialog/kbfxconfigapp.cpp:28 +msgid "

%1

" +msgstr "

%1

" + +#: configdialog/kbfxconfigapp.cpp:29 +msgid "You are running: KBFX " +msgstr "KBFX verziója: KBFX " + +#: configdialog/kbfxconfigapp.cpp:30 +msgid "" +"

The connection to the KBFX News " +"Section on www.kbfx.org is broken.

If you want you can check " +"the latest news for KBFX from here:
KBFX " +"News

" +msgstr "" +"

A KBFX híroldal a www.kbfx.org " +"szerverrel való kapcsolat hibájából eredően nem elérhető.

Ha " +"szeretnél a legújabb KBFX-szel kapcsolatos hírekről olvasni, akkor a " +"következő hivatkozáson próbáld:
KBFX " +"Hírek

" + +#: configdialog/kbfxconfigapp.cpp:35 +msgid "" +"KBFX start button
Tip! You have 3 " +"options to select for your KBFX start button.You have to select (Normal, " +"Pressed, Hover) images.
Down below you can also see a preview of the " +"images you have selected." +msgstr "" +"
Kbfx start gomb
Tipp! \n" +"Saját KBFX gombodat 3 opcióval szabhatod testre. Válassz egy (Normál, " +"Lenyomott, Fókuszált)
állapothoz tartozó képet. Lejjebb láthatod a " +"választott képekkel készült előnézetet." + +#: configdialog/kbfxconfigapp.cpp:40 +msgid "" +"About KBFX
Tip! Here you can find " +"information about the KBFX Project and all the people involved in it." +msgstr "" +"
A KBFX névjegye
Tipp! \n" +"Itt találhatsz bővebb információt a KBFX Projektről
és a benne résztvevő " +"emberekről." + +#: configdialog/kbfxconfigapp.cpp:43 +msgid "" +"KBFX font settings
Tip! Here you can " +"set the fonts of the current theme.
If you don't have any 'kbfxfontrc' " +"file don't worry about that.
When done just hit 'Apply' button and KBFX " +"will save the 'kbfxfontrc' file." +msgstr "" +"
Kbfx betűtípus " +"beállítások
Tipp! \n" +"Itt állíthatod be az aktuális témához tartozó betűtípusokat.
Amennyiben " +"még nincs \"kbfxfontrc\" fájlod, ne aggódj.
Amennyiben kész vagy, csak " +"kattints az \"Alkalmazás\" gombra
és a KBFX automatikusan elkészíti " +"neked a kbfxfontrc fájlt." + +#: configdialog/kbfxconfigapp.cpp:48 +msgid "" +"KBFX Layout
Tip! Here you can " +"configure the Look and Feel of your KBFX menu.
The most important " +"settings that are used with the 'Make it...' buttons are " +"marked with '*'
Have in mind that the Layout of the " +"theme also depends on the sizes of the images!
" +msgstr "" +"KBFX elrendezés
Tipp! Itt szabhatod " +"testre a KBFX menü megjelenését.
A Tedd...' gombbal " +"jelölt beállítások között a legfontosabbakat '*'-gal " +"jelöltük.
Vedd figyelembe, hogy a téma elrendezése függ a képek méretétől " +"is!
" + +#: configdialog/kbfxconfigapp.cpp:53 +msgid "" +"KBFX Plugins
Tip! Here you can " +"select what plugins will be enabled and in which panel of the KBFX menu." +msgstr "" +"KBFX modulok
Tipp! Itt választhatod " +"ki, hogy melyik modulok legyenek engedélyzve és, hogy a KBFX menü mely " +"paneljén." + +#: configdialog/kbfxconfigapp.cpp:56 +msgid "" +"Menu Type
Tip! Please select which " +"kind of menu you would like to use." +msgstr "" +"
Menü típusa
Tipp!\n" +"Válaszd ki milyen típusú menüt szeretnél használni.
KBFX menü vagy KDE " +"Menü." + +#: configdialog/kbfxconfigapp.cpp:59 +msgid "" +"KBFX Themes
Tip! To keep it simple " +"place all your themes inside one folder.
Then create different folders " +"inside that folder with different names.
KBFX will then read those " +"folders as themes." +msgstr "" +"
Kbfx Témák
Tipp! \n" +"Hogy egyszerűvé tedd a témakezelést, helyezz minden témát egy könyvtáron " +"belül alkönyvtárakba.
A KBFX ezekután minden könyvtárat külön témaként " +"kezel." + +#: configdialog/kbfxconfigapp.cpp:64 +msgid "" +"KBFX tooltip settings
Tip! Here you " +"can configure the behaviour of KBFX's own tooltip." +msgstr "" +"KBFX eszköztipp beállítások
Tipp!Itt " +"állíthatod be a KBFX saját eszköztippjeinek viselkedését." + +#: configdialog/kbfxconfigapp.cpp:93 +msgid "Themes" +msgstr "Témák" + +#: configdialog/kbfxconfigapp.cpp:105 rc.cpp:230 +#, no-c-format +msgid "Start Button" +msgstr "Start gomb" + +#: configdialog/kbfxconfigapp.cpp:121 rc.cpp:239 +#, no-c-format +msgid "Menu Style" +msgstr "Menü stílus" + +#: configdialog/kbfxconfigapp.cpp:130 rc.cpp:242 +#, no-c-format +msgid "Tooltip" +msgstr "Eszköztipp" + +#: configdialog/kbfxconfigapp.cpp:141 +msgid "Layout" +msgstr "Elrendezés" + +#: configdialog/kbfxconfigapp.cpp:151 rc.cpp:248 +#, no-c-format +msgid "Plugins" +msgstr "Modulok" + +#: configdialog/kbfxconfigapp.cpp:240 +msgid "No default settings here ;)" +msgstr "Itt nincsenek alapértelmezett beállítások ;)" + +#: configdialog/kbfxconfigapp.cpp:423 +msgid "

Could not create this KBFX theme package.

" +msgstr "

Nem sikerült létrehozni ezt a KBFX témacsomagot.

" + +#: configdialog/kbfxconfigapp.cpp:435 +msgid "

KBFX Theme %1 prepared.

" +msgstr "

A(z) %1 KBFX téma elkészítve.

" + +#: configdialog/kbfxconfigapp.cpp:436 +msgid "KBFX Theme Ready" +msgstr "KBFX téma kész" + +#: configdialog/main.cpp:33 +msgid "KBFX Configuration Utility" +msgstr "KBFX Beállító Segédprogram" + +#: configdialog/main.cpp:39 +msgid "kbfxconfigapp" +msgstr "kbfxconfigapp" + +#: configdialog/main.cpp:52 +msgid "Install KBFX theme from " +msgstr "KBFX téma telepítése saját címről" + +#: configdialog/main.cpp:53 +msgid "Prepare KBFX theme from folder " +msgstr "KBFX téma előkészítése a következő -en található könyvtárból" + +#: configdialog/main.cpp:54 +msgid "Show the About page" +msgstr "Névjegy mutatása" + +#: src/kbfxspinx.cpp:234 +msgid "This is a help box" +msgstr "Ez egy súgó doboz" + +#: src/kbfxspinx.cpp:358 +msgid "Remove KBFX from Pannel" +msgstr "KBFX eltávolítása a Panelről" + +#: src/kbfxspinx.cpp:360 +msgid "Reload KBFX" +msgstr "KBFX újratöltése" + +#: src/kbfxspinx.cpp:363 +msgid "Configure KBFX" +msgstr "KBFX beállítása" + +#: src/kbfxspinx.cpp:365 +msgid "Edit Applications Menu" +msgstr "Alkalmazások menü szerkesztése" + +#: src/kbfxspinxmenu.cpp:54 +msgid "Double click to clear..." +msgstr "Törléshez kattints kétszer..." + +#: src/kbfxspinxmenu.cpp:66 +msgid "Type here to search..." +msgstr "Keresendő kifejezés..." + +#: src/kbfxbutton.cpp:270 +msgid "" +"Invalid images were dropped!\n" +"Cannot set the KBFX button to use these images!" +msgstr "" +"Érvénytelen képeket helyeztél el!\n" +"Nem lehet beállítani a KBFX gombot ezen képek használatára!" + +#: src/kbfxbutton.cpp:272 +msgid "Error setting KBFX button images" +msgstr "Hiba a KBFX gomb képeinek beállításakor" + +#: rc.cpp:3 +#, no-c-format +msgid "KBFX Button" +msgstr "KBFX gomb" + +#: rc.cpp:6 +#, no-c-format +msgid "" +"To change KBFX button skin, simply browse to the image you want OR just " +"Drag&Drop the images to their respective place." +msgstr "" +"A KBFX gomb kinézetének megváltoztatásához egyszerűen csak nyisd meg a " +"használni kívánt képet VAGY \"húzd és ejtsd\" a képeket a megfelelő helyre." + +#: rc.cpp:9 +#, no-c-format +msgid "Livepreview" +msgstr "Élőkép" + +#: rc.cpp:12 +#, no-c-format +msgid "" +"Tip! To see live preview, hover or press the preview image with your " +"mouse." +msgstr "" +"Tipp! Az élő előnézeti kép megtekintéséhez vidd az egérkurzort az " +"előnézeti kép fölé vagy kattints rajta." + +#: rc.cpp:15 +#, no-c-format +msgid "KBFX Button live preview" +msgstr "KBFX gomb élő előnézet" + +#: rc.cpp:18 +#, no-c-format +msgid "Here you can see the live preview of the KBFX Button." +msgstr "Itt láthatod a KBFX gomb valósidejű előnézeti képét." + +#: rc.cpp:21 +#, no-c-format +msgid "Resize Panel" +msgstr "Panel átméretezése" + +#: rc.cpp:24 +#, no-c-format +msgid "" +"Tip! This button resizes the panel on which the KBFX button is to " +"button's height or width." +msgstr "" +"Tipp! Ez a gomb átméretezi a KBFX gombot tartalmazó eszköztárt saját " +"magasságára, illetve szélességére." + +#: rc.cpp:27 configdialog/kbfxconfigdlgbutton.ui.h:141 +#, no-c-format +msgid "Panel Resize is 'ON'" +msgstr "Eszköztár átméretezés \"BE\"" + +#: rc.cpp:32 +#, no-c-format +msgid "

Preview of selected images

" +msgstr "

Választott képek előnézete

" + +#: rc.cpp:35 +#, no-c-format +msgid "\"PRESSED\" IMAGE SELECTION" +msgstr "\"LENYOMOTT\" KÉP VÁLASZTÁS" + +#: rc.cpp:38 +#, no-c-format +msgid "Please select \"pressed\" image." +msgstr "Válaszd ki a \"Lenyomott\" állapothoz tartozó képet." + +#: rc.cpp:41 rc.cpp:65 rc.cpp:89 +#, no-c-format +msgid "image/jpeg image/png image/x-xpm image/gif" +msgstr "Képek/jpeg Képek/png Képek/x-xpm Képek/gif" + +#: rc.cpp:44 +#, no-c-format +msgid "The Pressed Button Skin Image" +msgstr "A \"Lenyomott\" állapothoz tartozó kép" + +#: rc.cpp:47 +#, no-c-format +msgid "Here you can choose the Pressed Button Skin Image" +msgstr "Itt választhatod ki a \"Lenyomott\" állapotú gombhoz tartozó képet" + +#: rc.cpp:50 rc.cpp:74 rc.cpp:98 +#, no-c-format +msgid "Preview" +msgstr "Előnézet" + +#: rc.cpp:53 +#, no-c-format +msgid "Pressed Button Skin" +msgstr "Lenyomott állapotú gomb képe" + +#: rc.cpp:56 +#, no-c-format +msgid "Here you can Drag&Drop the Pressed Button Skin Image." +msgstr "Ide ejtheted a \"Lenyomott\" állapotú gomb képét." + +#: rc.cpp:59 +#, no-c-format +msgid "\"NORMAL\" IMAGE SELECTION" +msgstr "\"NORMÁL\" KÉP VÁLASZTÁS" + +#: rc.cpp:62 +#, no-c-format +msgid "Please select \"normal\" image." +msgstr "Válaszd ki a \"normál\" állapothoz tartozó képet." + +#: rc.cpp:68 +#, no-c-format +msgid "The Normal Button Skin Image" +msgstr "A \"Normál\" állapotú gomb képe" + +#: rc.cpp:71 +#, no-c-format +msgid "Here you can choose the Normal Button Skin Image" +msgstr "Itt választhatod ki a \"Normál\" állapothoz tartozó képet" + +#: rc.cpp:77 +#, no-c-format +msgid "Normal Button Skin" +msgstr "\"Normál\" állapotú gomb képe" + +#: rc.cpp:80 +#, no-c-format +msgid "Here you can Drag&Drop the Normal Button Skin Image." +msgstr "Ide ejtheted a \"Normál\" állapotú gomb képét." + +#: rc.cpp:83 +#, no-c-format +msgid "\"HOVER\" IMAGE SELECTION" +msgstr "\"FÓKUSZÁLT\" KÉP VÁLASZTÁS" + +#: rc.cpp:86 +#, no-c-format +msgid "Please select \"hover\" image." +msgstr "Válaszd ki a \"Fókuszált\" állapothoz tartozó képet." + +#: rc.cpp:92 +#, no-c-format +msgid "The Hover Button Skin Image" +msgstr "A \"Fókuszált\" állapotú gombhoz tartozó kép" + +#: rc.cpp:95 +#, no-c-format +msgid "Here you can choose the Hover Button Skin Image" +msgstr "Itt választhatod ki a \"Fókuszált\" állapotú gombhoz tartozó képet" + +#: rc.cpp:101 +#, no-c-format +msgid "Hover Button Skin" +msgstr "\"Fókuszált\" állapotú gomb képe" + +#: rc.cpp:104 +#, no-c-format +msgid "Here you can Drag&Drop the Hover Button Skin Image." +msgstr "Ide ejtheted a \"Fókuszált\" állapotú gomb képét." + +#: rc.cpp:107 +#, no-c-format +msgid "

Please select KBFX button's images

" +msgstr "

Válaszd ki a KBFX gomb képeit

" + +#: rc.cpp:110 rc.cpp:179 rc.cpp:296 rc.cpp:404 rc.cpp:440 rc.cpp:461 +#, no-c-format +msgid "KBFX Control Center" +msgstr "KBFX vezérlőpult" + +#: rc.cpp:113 +#, no-c-format +msgid "

Layout options

" +msgstr "

Elrendezés beállítások

" + +#: rc.cpp:116 +#, no-c-format +msgid "EXPORT KBFXLAYOUTRC FILE" +msgstr "KBFXLAYOUTRC FÁJL EXPORTÁLÁSA" + +#: rc.cpp:119 +#, no-c-format +msgid "Export the kbfxlayoutrc file to a folder" +msgstr "kbfxlayoutrc fájl exportálása könyvtárba" + +#: rc.cpp:122 rc.cpp:473 +#, no-c-format +msgid "Setup fonts for your KBFX" +msgstr "KBFX betűtípusainak testreszabása" + +#: rc.cpp:125 rc.cpp:476 +#, no-c-format +msgid "Theme that is edited:" +msgstr "Szerkesztett téma:" + +#: rc.cpp:128 rc.cpp:479 +#, no-c-format +msgid "

default

" +msgstr "

alapértelmezés

" + +#: rc.cpp:131 rc.cpp:482 +#, no-c-format +msgid "Please select the theme you want to edit" +msgstr "Válaszd ki a szerkeszteni kívánt témát" + +#: rc.cpp:134 +#, no-c-format +msgid "Select the Layout property to change" +msgstr "Válaszd ki a szerkeszteni kívánt elrendezési tulajdonságot" + +#: rc.cpp:137 +#, no-c-format +msgid "Make it 2 panels (Left \"ON\")" +msgstr "Váltás 2 paneles módba (Baloldali \"BE\")" + +#: rc.cpp:140 +#, no-c-format +msgid "Make it 2 panels (Right \"ON\")" +msgstr "Váltás 2 paneles módba (Jobboldali \"BE\")" + +#: rc.cpp:143 +#, no-c-format +msgid "Make it 3 panels" +msgstr "Váltás 3 paneles módba" + +#: rc.cpp:146 +#, no-c-format +msgid "textLabel1" +msgstr "textLabel1" + +#: rc.cpp:149 +#, no-c-format +msgid "textLabel2" +msgstr "textLabel2" + +#: rc.cpp:152 +#, no-c-format +msgid "textLabel3" +msgstr "textLabel3" + +#: rc.cpp:155 +#, no-c-format +msgid "textLabel4" +msgstr "textLabel4" + +#: rc.cpp:158 +#, no-c-format +msgid "checkBox1" +msgstr "checkBox1" + +#: rc.cpp:161 +#, no-c-format +msgid "textLabel5" +msgstr "textLabel5" + +#: rc.cpp:164 +#, no-c-format +msgid "textLabel6" +msgstr "textLabel6" + +#: rc.cpp:167 +#, no-c-format +msgid "textLabel7" +msgstr "textLabel7" + +#: rc.cpp:170 +#, no-c-format +msgid "textLabel8" +msgstr "textLabel8" + +#: rc.cpp:173 +#, no-c-format +msgid "checkBox2" +msgstr "checkBox2" + +#: rc.cpp:176 +#, no-c-format +msgid "C&ustom" +msgstr "Egyéni" + +#: rc.cpp:182 +#, no-c-format +msgid "

Plugins options

" +msgstr "

Modul beállítások

" + +#: rc.cpp:185 +#, no-c-format +msgid "Select KBFX Panel" +msgstr "KBFX panel kiválasztása" + +#: rc.cpp:188 rc.cpp:191 +#, no-c-format +msgid "Plugin to configure" +msgstr "Beállítandó modul" + +#: rc.cpp:194 +#, no-c-format +msgid "Please select the panel you want to configure: " +msgstr "Válaszd ki, melyik panelt szeretnéd beállítani: " + +#: rc.cpp:197 +#, no-c-format +msgid "&Available Plugins:" +msgstr "Elérhető modulok:" + +#: rc.cpp:200 +#, no-c-format +msgid "&Enabled Plugins:" +msgstr "Engedélyezett modulok:" + +#: rc.cpp:203 +#, no-c-format +msgid "&Configure Plugin" +msgstr "Modul beállítása" + +#: rc.cpp:206 +#, no-c-format +msgid "Alt+C" +msgstr "Alt+C" + +#: rc.cpp:209 rc.cpp:212 +#, no-c-format +msgid "Configure the selected plugin" +msgstr "Választott modul beállítása" + +#: rc.cpp:215 +#, no-c-format +msgid "&Plugin Information" +msgstr "Modul Információ" + +#: rc.cpp:218 +#, no-c-format +msgid "Alt+P" +msgstr "Alt+P" + +#: rc.cpp:221 rc.cpp:224 +#, no-c-format +msgid "Information about the selected plugin" +msgstr "Választott modul részletei" + +#: rc.cpp:227 +#, no-c-format +msgid "KBFX Configurator Application" +msgstr "KBFX Beállító Alkalmazás" + +#: rc.cpp:233 +#, no-c-format +msgid "KBFX Themes" +msgstr "KBFX témák" + +#: rc.cpp:245 +#, no-c-format +msgid "Search Engine" +msgstr "Keresőmotor" + +#: rc.cpp:251 +#, no-c-format +msgid "About KBFX" +msgstr "A KBFX névjegye" + +#: rc.cpp:254 +#, no-c-format +msgid "" +"




If you want you can check the latest " +"news for KBFX from here:
KBFX News" +msgstr "" +"




A KBFX-szel kapcsolatos legfrissebb " +"hírekért látogass el ide:
KBFX Hírek

" + +#: rc.cpp:260 +#, no-c-format +msgid "Alt+H" +msgstr "Alt+H" + +#: rc.cpp:263 +#, no-c-format +msgid "Open Help Documentation" +msgstr "Súgó megnyitása" + +#: rc.cpp:266 +#, no-c-format +msgid "&Default" +msgstr "Alapértelmezett" + +#: rc.cpp:269 +#, no-c-format +msgid "Alt+D" +msgstr "Alt+D" + +#: rc.cpp:272 +#, no-c-format +msgid "Apply the default configuration for this section only" +msgstr "Alapértelmezett beállítások alkalmazása csak erre a szakaszra" + +#: rc.cpp:278 +#, no-c-format +msgid "Alt+A" +msgstr "Alt+A" + +#: rc.cpp:281 +#, no-c-format +msgid "Save the configuration and Apply it" +msgstr "Beállítások mentése és alkalmazása" + +#: rc.cpp:287 +#, no-c-format +msgid "Alt+X" +msgstr "Alt+X" + +#: rc.cpp:290 +#, no-c-format +msgid "Exit the configuration without saving" +msgstr "Kilépés a beállításokból mentés nélkül" + +#: rc.cpp:293 +#, no-c-format +msgid "Kbfx start button
" +msgstr "KBFX start gomb
" + +#: rc.cpp:299 +#, no-c-format +msgid "Select default folder" +msgstr "Alapértelmezett könyvtár kiválasztása" + +#: rc.cpp:302 +#, no-c-format +msgid "Please select the target folder where your themes are." +msgstr "Válaszd ki a témákat tartalmazó könyvtárat." + +#: rc.cpp:305 +#, no-c-format +msgid "SpixBar" +msgstr "SpixBar" + +#: rc.cpp:308 +#, no-c-format +msgid "Installed Themes" +msgstr "Telepített témák" + +#: rc.cpp:311 +#, no-c-format +msgid "Here are listed all the installed KBFX Themes" +msgstr "Itt vannak felsorolva a telepített KBFX témák" + +#: rc.cpp:314 +#, no-c-format +msgid "Selected Theme Preview" +msgstr "Választott téma előnézete" + +#: rc.cpp:317 +#, no-c-format +msgid "Delete Selected" +msgstr "Kijelöltek törlése" + +#: rc.cpp:320 +#, no-c-format +msgid "Delete the Selected Theme" +msgstr "Kiválasztott téma törlése" + +#: rc.cpp:323 +#, no-c-format +msgid "" +"Pressing the button will delete the currently selected theme.
Warning!" +" You cannot delete the installed system wide themes!" +msgstr "" +"A gomb lenyomásával az éppen kijelölt téma törlésre kerül.
Figyelem! Az egész rendszerre érvényes témákat nem lehet törölni!" + +#: rc.cpp:326 +#, no-c-format +msgid "Get Themes" +msgstr "Témák beszerzése" + +#: rc.cpp:329 +#, no-c-format +msgid "Get More Themes from the Internet" +msgstr "További témák beszerzése az Internetről" + +#: rc.cpp:332 +#, no-c-format +msgid "" +"Pressing the button will launch konqueror and go to the KBFX Themes Section " +"on www.kde-look.org" +msgstr "" +"A gomb megnyomásával egy Konqueror ablak nyílik a www.kde-look.org KBFX téma " +"szekciójával" + +#: rc.cpp:335 +#, no-c-format +msgid "Install Theme" +msgstr "Téma telepítése" + +#: rc.cpp:338 +#, no-c-format +msgid "Install New Theme from KBFX Theme Package" +msgstr "Új téma telepítése KBFX Témacsomagból" + +#: rc.cpp:341 +#, no-c-format +msgid "" +"Pressing the button will offer a dialog where you can choose KBFX Theme " +"Package to install in your home folder" +msgstr "" +"A gomb megnyomásával kiválaszthatod hogy megy KBFX témacsomag kerüljön " +"telepítésre a saját könyvtáradba" + +#: rc.cpp:344 rc.cpp:583 +#, no-c-format +msgid "Theme Info" +msgstr "Téma Info" + +#: rc.cpp:347 +#, no-c-format +msgid "Show specific theme info" +msgstr "Témaspecifikus információ megjelenítése" + +#: rc.cpp:350 +#, no-c-format +msgid "Pressing the button will show you specific theme info" +msgstr "A gomb megnyomásával megtekintheted a témaspecifikus információkat" + +#: rc.cpp:353 +#, no-c-format +msgid "Personal Image" +msgstr "Saját kép" + +#: rc.cpp:356 +#, no-c-format +msgid "Theme's Default" +msgstr "Téma alapértelmezése" + +#: rc.cpp:359 +#, no-c-format +msgid "Set the Theme's Default Personal Image" +msgstr "Téma alapértelmezett saját képének beállítása" + +#: rc.cpp:362 +#, no-c-format +msgid "" +"Pressing the button will delete the personal image you have selected and " +"install the theme's default personal image" +msgstr "" +"A gomb megnyomásával a beállított saját kép törlődik és helyette a témában " +"beállítottalapértelmezett kép kerül telepítésre" + +#: rc.cpp:365 +#, no-c-format +msgid "Maxsize 48 x 48" +msgstr "Maximális méret 48 x 48" + +#: rc.cpp:368 +#, no-c-format +msgid "Select New image" +msgstr "Új kép kiválasztása" + +#: rc.cpp:371 +#, no-c-format +msgid "Select a Personal Image" +msgstr "Saját kép kiválasztása" + +#: rc.cpp:374 +#, no-c-format +msgid "Pressing the button will open a dialog to select your personal image" +msgstr "A gomb megnyomásával kiválaszthatod a saját személyes képed" + +#: rc.cpp:377 +#, no-c-format +msgid "This is your personal image displayed at the KBFX menu." +msgstr "Ez a saját kép mely a KBFX menü bal felső sarkában kerül megjelenítésre." + +#: rc.cpp:380 +#, no-c-format +msgid "Misc Options" +msgstr "Egyéb beállítások" + +#: rc.cpp:383 +#, no-c-format +msgid "Watch System Installs" +msgstr "Rendszertelepítések figyelése" + +#: rc.cpp:386 rc.cpp:389 +#, no-c-format +msgid "Watch for applications installs and reload KBFX if any occurs" +msgstr "Alkalmazás telepítések figyelése és KBFX újratöltése szükség esetén" + +#: rc.cpp:392 rc.cpp:395 +#, no-c-format +msgid "Show Old Themes" +msgstr "Régi témák megjelenítése" + +#: rc.cpp:398 +#, no-c-format +msgid "

Please select theme folder

" +msgstr "

Válassz téma könyvtárat

" + +#: rc.cpp:401 +#, no-c-format +msgid "

Installed themes

" +msgstr "

Telepített témák

" + +#: rc.cpp:407 +#, no-c-format +msgid "

Tooltip ON or OFF

" +msgstr "

Eszköztipp KI/BEkapcsolása

" + +#: rc.cpp:410 +#, no-c-format +msgid "Turn off or on the tooltip" +msgstr "Eszköztipp ki/bekapcsolása" + +#: rc.cpp:413 +#, no-c-format +msgid "" +"Turn your tooltip off or on.
You can see the current status of the " +"tooltip to the right." +msgstr "" +"Eszköztipp ki/bekapcsolása.
Az eszköztipp aktuális állapota jobboldalt " +"látható." + +#: rc.cpp:416 +#, no-c-format +msgid "Turn the tooltip \"OFF\"" +msgstr "Eszköztipp \"KI\"" + +#: rc.cpp:419 +#, no-c-format +msgid "Tooltip Text" +msgstr "Eszköztipp szövege" + +#: rc.cpp:422 +#, no-c-format +msgid "Type the text which you want to be displayed in the tooltip." +msgstr "Írd be az eszköztippben megjeleníteni kívánt szöveget." + +#: rc.cpp:425 +#, no-c-format +msgid "

Tooltip personal text

" +msgstr "

Személyes eszköztipp szövege

" + +#: rc.cpp:428 +#, no-c-format +msgid "Tooltip animation" +msgstr "Eszköztipp animáció" + +#: rc.cpp:431 +#, no-c-format +msgid "" +"Turn your tooltip animation off or on.
You can see the current status of " +"the tooltip to the right." +msgstr "" +"Eszköztipp animációjának ki/bekapcsolása.
Az animáció aktuális állapota " +"jobboldalt látható." + +#: rc.cpp:434 +#, no-c-format +msgid "Turn the animation \"ON\"" +msgstr "Animáció \"BE\"" + +#: rc.cpp:437 +#, no-c-format +msgid "

Tooltip animation ON or OFF

" +msgstr "

Eszköztipp animáció KI/BEkapcsolása

" + +#: rc.cpp:443 +#, no-c-format +msgid "

Menu type

" +msgstr "

Menü típusa

" + +#: rc.cpp:446 +#, no-c-format +msgid "Please select the menu style" +msgstr "Válaszd ki a menü stílusát" + +#: rc.cpp:449 rc.cpp:455 +#, no-c-format +msgid "KBFX MENU" +msgstr "KBFX MENÜ" + +#: rc.cpp:452 rc.cpp:458 +#, no-c-format +msgid "KDE MENU" +msgstr "KDE MENÜ" + +#: rc.cpp:464 +#, no-c-format +msgid "

Font options

" +msgstr "

Betűtípus beállítások

" + +#: rc.cpp:467 +#, no-c-format +msgid "EXPORT KBFXFONTRC FILE" +msgstr "KBFXFONTRC FÁJL EXPORTÁLÁSA" + +#: rc.cpp:470 +#, no-c-format +msgid "Export the kbfxfontrc file to a folder" +msgstr "kbfxfontrc fájl exportálása könyvtárba" + +#: rc.cpp:485 +#, no-c-format +msgid "Bold fonts on hover" +msgstr "Félkövér betűk fókusznál" + +#: rc.cpp:488 rc.cpp:491 +#, no-c-format +msgid "Make fonts bolder when you hover the mouse over an item" +msgstr "A betűk legyenek félkövérek, ha az egér egy elem fölött van" + +#: rc.cpp:494 +#, no-c-format +msgid "Application \"LINE\":" +msgstr "Alkalmazás \"SOR\":" + +#: rc.cpp:497 +#, no-c-format +msgid "Horizontal line color in the application area." +msgstr "Vízszintes vonal színe az alkalmazásterületen." + +#: rc.cpp:500 +#, no-c-format +msgid "Application text :" +msgstr "Alkalmazás szövege:" + +#: rc.cpp:503 +#, no-c-format +msgid "Select the color of the \"application\" in the menu." +msgstr "Válaszd ki a menüben lévő \"alkalmazás\" színét." + +#: rc.cpp:506 +#, no-c-format +msgid "Comment text:" +msgstr "Megjegyzés szövegének színe:" + +#: rc.cpp:509 +#, no-c-format +msgid "Color of the \"comments\" in the menu." +msgstr "A menüben lévő \"megjegyzések\" színe." + +#: rc.cpp:512 +#, no-c-format +msgid "Name display:" +msgstr "Név megjelenítés:" + +#: rc.cpp:515 rc.cpp:527 rc.cpp:533 +#, no-c-format +msgid "The color of your login name in the menu." +msgstr "Menüben megjelenő bejelentkezési név színe." + +#: rc.cpp:518 +#, no-c-format +msgid "Category text:" +msgstr "Kategória szövege:" + +#: rc.cpp:521 +#, no-c-format +msgid "Font color of the categoris in the menu." +msgstr "Kategóriák betűszíne." + +#: rc.cpp:524 +#, no-c-format +msgid "Separator:" +msgstr "Elválasztó:" + +#: rc.cpp:530 +#, no-c-format +msgid "Plugin:" +msgstr "Modul:" + +#: rc.cpp:536 +#, no-c-format +msgid "Select font for the application's text" +msgstr "Add meg az alkalmazások betűtípusát" + +#: rc.cpp:539 +#, no-c-format +msgid "Select font for the comment's text" +msgstr "Add meg a megjegyzések betűtípusát" + +#: rc.cpp:542 +#, no-c-format +msgid "Select font for the username's text" +msgstr "Add meg a felhasználónév betűtípusát" + +#: rc.cpp:545 +#, no-c-format +msgid "Select font for the category's text" +msgstr "Add meg a kategória szövegének betűtípusát" + +#: rc.cpp:548 +#, no-c-format +msgid "Select font for the separator's text" +msgstr "Add meg az elválasztók szövegének betűtípusát" + +#: rc.cpp:551 +#, no-c-format +msgid "Select font for the plugins' text" +msgstr "Válaszd ki a modulok szöveg betűtípusát" + +#: rc.cpp:554 +#, no-c-format +msgid "Form1" +msgstr "Form1" + +#: rc.cpp:557 +#, no-c-format +msgid "

People behind KBFX

" +msgstr "

A KBFX mögött álló emberek

" + +#: rc.cpp:560 +#, no-c-format +msgid "You are running: KBFX 0493" +msgstr "A KBFX 0493 verzióját futtatod" + +#: rc.cpp:563 +#, no-c-format +msgid "" +"Here are the people behind the KBFX application.\n" +"We would like to thank all people who have helped with KBFX or have donated " +"money to our project!\n" +"THANKS A LOT ALL OF YOU OUT THERE!!!" +msgstr "" +"Itt olvashatsz a kbfx mögött álló emberekről.\n" +"Szeretnénk köszönetet mondani mindazoknak, akik segítettek a KBFX\n" +"fejlesztésében és akik adományukkal segítették a projektet! KÖSZÖNET\n" +"MINDANNYIÓTOKNAK ODAKINN!!!" + +#: rc.cpp:568 +#, no-c-format +msgid "" +"Name: Siraj Razick

Country: Sri " +"Lanka

KBFX: Author, Maintainer, Developer, Project " +"Admin

Email: siraj(a)mail.kbfx.org" +msgstr "" +"Név: Siraj Razick

Ország: Sri " +"Lanka

KBFX: Szerző, Karbantartó, Fejlesztő, " +"Projektvezető

Email: siraj(a)mail.kbfx.org" + +#: rc.cpp:571 +#, no-c-format +msgid "" +"Tip! Hover over the contact images to see each personal contact " +"information." +msgstr "" +"Tipp!Húzd az egeret a képek fölé, hogy megtekinthesd minden személy " +"kapcsolati adatait." + +#: rc.cpp:574 +#, no-c-format +msgid "SPONSORS!" +msgstr "TÁMOGATÓK!" + +#: rc.cpp:577 +#, no-c-format +msgid "" +"We would like to thank swedish computer company PC Agenten for " +"sponsoring us with a server and bandwidth." +msgstr "" +"Szeretnénk köszönetet mondani a svéd PC Agenten számítástechnikai " +"cégnek hogy egy szerverrel és sávszélességgel támogatott bennünket." + +#: rc.cpp:580 +#, no-c-format +msgid "" +"

HTTP://WWW." +"PCAGENTEN.SE

" +msgstr "" +"

HTTP://WWW." +"PCAGENTEN.SE

" + +#: rc.cpp:589 +#, no-c-format +msgid "

Name:

" +msgstr "

Név:

" + +#: rc.cpp:592 +#, no-c-format +msgid "

Version:

" +msgstr "

Verzió:

" + +#: rc.cpp:595 +#, no-c-format +msgid "

Author:

" +msgstr "

Szerző:

" + +#: rc.cpp:598 +#, no-c-format +msgid "

Email:

" +msgstr "

Email:

" + +#: rc.cpp:601 +#, no-c-format +msgid "

Homepage:

" +msgstr "

Weboldal:

" + +#: rc.cpp:604 rc.cpp:607 rc.cpp:610 rc.cpp:613 rc.cpp:616 +#, no-c-format +msgid "Test" +msgstr "Test" + +#: configdialog/kbfxconfigdlgthemes.ui.h:61 +msgid "" +"

Invalid user themes folder!

Will use " +"default user themes folder.

" +msgstr "" +"

Érvénytelen felhasználói témakönyvtár!

Az alapértelmezettet fogom használni.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:63 +msgid "Error loading themes" +msgstr "Hiba a témák betöltésekor" + +#: configdialog/kbfxconfigdlgthemes.ui.h:170 +msgid "" +"

Are you sure you want to uninstall the KBFX theme %" +"1?

" +msgstr "

Biztosan törölni szeretnéd a(z) %1 témát?

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:171 +msgid "Uninstall KBFX theme" +msgstr "KBFX téma eltávolítása" + +#: configdialog/kbfxconfigdlgthemes.ui.h:172 +msgid "Uninstall" +msgstr "Eltávolítás" + +#: configdialog/kbfxconfigdlgthemes.ui.h:177 +msgid "" +"

Do you want to keep your personal settings for theme " +"%1?

" +msgstr "

Szeretnéd megtartani a(z) %1 témához tartozó személyes beállításaid?

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:178 +msgid "Personal settings" +msgstr "Személyes beállítások" + +#: configdialog/kbfxconfigdlgthemes.ui.h:179 +msgid "Keep settings" +msgstr "Beállítások megtartása" + +#: configdialog/kbfxconfigdlgthemes.ui.h:180 +msgid "Delete settings" +msgstr "Beállítások törlése" + +#: configdialog/kbfxconfigdlgthemes.ui.h:210 +msgid "" +"

Could not uninstall this KBFX theme.

You may not have sufficient permissions to delete the folder " +"%1.

" +msgstr "" +"

Nem sikerült eltávolítani ezt a KBFX témát.

Valószínűleg nincs elegendő jogosultságod a(z) %1 könyvtár törléséhez.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:223 +msgid "KBFX theme packages (*.tar, *.tar.bz2, *.tar.gz, *.kbfxtheme)" +msgstr "KBFX témacsomagok (*.tar, *.tar.bz2, *.tar.gz, *.kbfxtheme)" + +#: configdialog/kbfxconfigdlgthemes.ui.h:227 +msgid "Select KBFX theme package to install" +msgstr "Válaszd ki a telepíteni kívánt témacsomagot" + +#: configdialog/kbfxconfigdlgthemes.ui.h:243 +msgid "

Could not read this KBFX theme package.

" +msgstr "

Nem sikerült olvasni ezt a KBFX témacsomagot.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:270 +msgid "Select personal image" +msgstr "Személyes kép kiválasztása" + +#: configdialog/kbfxconfigdlgthemes.ui.h:281 +msgid "" +"

Image cannot be used as a personal image!

Will use default personal image.

" +msgstr "" +"

A választott kép nem használható mint személyes kép!

Az alapértelmezett képet fogom használni.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:283 +#: configdialog/kbfxconfigdlgbutton.ui.h:65 +#: configdialog/kbfxconfigdlgbutton.ui.h:86 +#: configdialog/kbfxconfigdlgbutton.ui.h:107 +msgid "Error loading image" +msgstr "Hiba a kép betöltésekor" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:23 +msgid "Turn the animation 'OFF'" +msgstr "Animáció \"KI\"" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:30 +msgid "Turn the animation 'ON'" +msgstr "Animáció \"BE\"" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:53 +msgid "Turn the tooltip 'OFF'" +msgstr "Eszköztippek \"KI\"" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:60 +msgid "Turn the tooltip 'ON'" +msgstr "Eszköztipp \"BE\"" + +#: configdialog/kbfxconfigdlgfonts-old.ui.h:122 +msgid "Select folder to export kbfxfontrc file" +msgstr "Válaszd ki a kbfxfontrc fájl exportjának célkönyvtárát" + +#: configdialog/kbfxconfigdlgfonts-old.ui.h:151 +msgid "" +"

The Font configuration of the KBFX Theme %1 has been exported successfully!

" +msgstr "" +"

A(z) %1 KBFX témához tartozó betűtípus " +"beállítások exportja sikeresen megtörtént!

" + +#: configdialog/kbfxconfigdlgfonts-old.ui.h:152 +msgid "KBFX Font Export Ready" +msgstr "KBFX betűtípus export kész" + +#: configdialog/kbfxconfigdlgabout.ui.h:23 +msgid "" +"Name: Mensur Zahirovic (Nookie)

Country: Sweden

KBFX: co-author, Q/A, system design, " +"web designer, bug hunter, project administror

Email: " +"nookie@mail.kbfx.org" +msgstr "" +"Név: Mensur Zahirovic (Nookie)

Ország: Svédország

KBFX: Társszerző, " +"minőségbiztosítás (Q/A), rendszerterv, weblaptervező, hibavadász, projekt " +"adminisztrátor

Email: nookie@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:32 +msgid "" +"Name: Siraj Razick

Country: Sri " +"Lanka

KBFX: author, maintainer, developer, project " +"administror

Email: siraj@mail.kbfx.org" +msgstr "" +"Név: Siraj Razick

Ország: Sri " +"Lanka

KBFX: Szerző, karbantartó, fejlesztő, projekt " +"adminisztrátor

Email: siraj@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:41 +msgid "" +"Name: Nathanael Dracor Gogniat

Country: Switzerland

KBFX: project technical writer, " +"documentation manager, co-author

Email: " +"nathanael@mail.kbfx.org" +msgstr "" +"Név: Nathanael Dracor Gogniat

Ország: Svájc

KBFX: technikai szakíró, " +"dokumentációkezelő, társszerző

Email: nathanael@mail." +"kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:50 +msgid "" +"Name: PhobosK

Country: " +"Bulgaria

KBFX: package & release manager, Q/A, bug " +"hunter, mandriva packages, project administrator, developer Qt/C+" +"+

Email: phobosk@mail.kbfx.org" +msgstr "" +"Név: PhobosK

Ország: " +"Bulgária

KBFX: csomag és kiadás felelős, " +"minőségbiztosítás (Q/A), hibavadász, Mandriva csomagok, projekt " +"adminisztrátor, Qt/C++ fejlesztő

Email: phobosk@mail." +"kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:59 +msgid "" +"Name: Johnny Henry Saenz Acuna (scarebyte)" +"

Country: Peru

KBFX: " +"developer Qt4/C++

Email: saenzac@mail.kbfx.org" +msgstr "" +"Név: Johnny Henry Saenz Acuna (scarebyte)" +"

Ország: Peru

KBFX: Qt4/C++ " +"fejlesztő

Email: saenzac@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:68 +msgid "" +"Name: Christoffer Brodd-Reijer (Ephracis)" +"

Country: Sweden

KBFX: " +"library developer for Raptor

Email: ephracis@mail." +"kbfx.org" +msgstr "" +"Név: Christofer Brodd-Reijer (Ephracis)" +"

Ország: Svédország

KBFX: " +"Raptor könyvtár fejlesztője

Email: ephracis@mail." +"kbfx.org" + +#: configdialog/kbfxconfigdlgbutton.ui.h:63 +msgid "" +"

Image cannot be used as a pressed button skin!

Will use default pressed button skin.

" +msgstr "" +"

A választott kép nem használható mint lenyomott állapotú " +"gomb képe!

Az alapértelmezettet fogom használni.

" + +#: configdialog/kbfxconfigdlgbutton.ui.h:84 +msgid "" +"

Image cannot be used as a normal button skin!

Will use default normal button skin.

" +msgstr "" +"

A választott kép nem használható mint normál állapotú gomb " +"képe!

Az alapértelmezettet fogom használni.

" + +#: configdialog/kbfxconfigdlgbutton.ui.h:105 +msgid "" +"

Image cannot be used as a hover button skin!

Will use default hover button skin.

" +msgstr "" +"

A választott kép nem használható mint fókuszált állapotú " +"gomb képe!

Az alapértelmezettet fogom használni.

" + +#: configdialog/kbfxconfigdlgbutton.ui.h:147 +msgid "Panel Resize is 'OFF'" +msgstr "Eszköztár átméretezés \"KI\"" + +#: configdialog/kbfxconfigdlglayout.ui.h:16 +msgid "User Properties" +msgstr "Felhasználó tulajdonságai" + +#: configdialog/kbfxconfigdlglayout.ui.h:17 +msgid "* Top Bar Properties" +msgstr "* Felső sáv tulajdonságai" + +#: configdialog/kbfxconfigdlglayout.ui.h:18 +msgid "* Bottom Bar Properties" +msgstr "* Alsó sáv tulajdonságai" + +#: configdialog/kbfxconfigdlglayout.ui.h:20 +msgid "* List Box Properties" +msgstr "* Lista doboz tulajdonságai" + +#: configdialog/kbfxconfigdlglayout.ui.h:21 +msgid "Search Box Properties" +msgstr "Keresődoboz tulajdonságai" + +#: configdialog/kbfxconfigdlglayout.ui.h:22 +msgid "* Item Properties" +msgstr "* Elemek tulajdonságai" + +#: configdialog/kbfxconfigdlglayout.ui.h:24 +msgid "* Main Menu Properties" +msgstr "* Főmenü tulajdonságai" + +#: configdialog/kbfxconfigdlglayout.ui.h:25 +msgid "Water Effect Properties" +msgstr "Víz effektus tulajdonságai" + +#: configdialog/kbfxconfigdlglayout.ui.h:209 +msgid "Face Position X" +msgstr "Arckép X pozíciója" + +#: configdialog/kbfxconfigdlglayout.ui.h:210 +msgid "Face Position Y" +msgstr "Arckép Y pozíciója" + +#: configdialog/kbfxconfigdlglayout.ui.h:211 +msgid "User Name Position X" +msgstr "Felhasználónév X pozíciója" + +#: configdialog/kbfxconfigdlglayout.ui.h:212 +msgid "User Name Position Y" +msgstr "Felhasználónév Y pozíciója" + +#: configdialog/kbfxconfigdlglayout.ui.h:213 +msgid "Face Box Position X" +msgstr "Arckép doboz X pozíciója" + +#: configdialog/kbfxconfigdlglayout.ui.h:214 +msgid "Face Box Position Y" +msgstr "Arckép doboz Y pozíciója" + +#: configdialog/kbfxconfigdlglayout.ui.h:215 +msgid "Face Box Height" +msgstr "Arckép doboz magassága" + +#: configdialog/kbfxconfigdlglayout.ui.h:216 +msgid "Face Box Width" +msgstr "Arckép doboz szélessége" + +#: configdialog/kbfxconfigdlglayout.ui.h:217 +msgid "Hide User Name" +msgstr "Felhasználónév elrejtése" + +#: configdialog/kbfxconfigdlglayout.ui.h:235 +msgid "* Top Bar Height" +msgstr "* Felső sáv magassága" + +#: configdialog/kbfxconfigdlglayout.ui.h:241 +msgid "Top Bar Width" +msgstr "Felső sáv szélessége" + +#: configdialog/kbfxconfigdlglayout.ui.h:266 +msgid "* Bottom Bar Height" +msgstr "* Alsó sáv magassága" + +#: configdialog/kbfxconfigdlglayout.ui.h:272 +msgid "Bottom Bar Width" +msgstr "Alsó sáv szélessége" + +#: configdialog/kbfxconfigdlglayout.ui.h:322 +msgid "* List Box Position X" +msgstr "* Lista doboz X pozíciója" + +#: configdialog/kbfxconfigdlglayout.ui.h:323 +msgid "* List Box Position Y" +msgstr "* Lista doboz Y pozíciója" + +#: configdialog/kbfxconfigdlglayout.ui.h:326 +msgid "List Box Height" +msgstr "Lista doboz magassága" + +#: configdialog/kbfxconfigdlglayout.ui.h:327 +msgid "* List Box Width" +msgstr "* Lista doboz szélessége" + +#: configdialog/kbfxconfigdlglayout.ui.h:345 +msgid "Search Box Position X" +msgstr "Keresődoboz X pozíciója" + +#: configdialog/kbfxconfigdlglayout.ui.h:346 +msgid "Search Box Position Y" +msgstr "Keresődoboz Y pozíciója" + +#: configdialog/kbfxconfigdlglayout.ui.h:349 +msgid "Search Box Height" +msgstr "Keresődoboz magassága" + +#: configdialog/kbfxconfigdlglayout.ui.h:350 +msgid "Search Box Width" +msgstr "Keresődoboz szélessége" + +#: configdialog/kbfxconfigdlglayout.ui.h:368 +msgid "* Item Position X" +msgstr "* Elem X pozíciója" + +#: configdialog/kbfxconfigdlglayout.ui.h:369 +msgid "* Item Position Y" +msgstr "* Elem Y pozíciója" + +#: configdialog/kbfxconfigdlglayout.ui.h:370 +msgid "Icon Size in Item" +msgstr "Elem ikonjának mérete" + +#: configdialog/kbfxconfigdlglayout.ui.h:372 +msgid "Item Height" +msgstr "Elem magassága" + +#: configdialog/kbfxconfigdlglayout.ui.h:373 +msgid "* Item Width" +msgstr "* Elem szélessége" + +#: configdialog/kbfxconfigdlglayout.ui.h:374 +msgid "Comment Margin in Item" +msgstr "Megjegyzés margó az elemben" + +#: configdialog/kbfxconfigdlglayout.ui.h:376 +msgid "No Comments in Item" +msgstr "Nincs megjegyzés az elemben" + +#: configdialog/kbfxconfigdlglayout.ui.h:417 +msgid "* Main Menu Height" +msgstr "* Főmenü magassága" + +#: configdialog/kbfxconfigdlglayout.ui.h:421 +msgid "* Main Menu Width" +msgstr "* Főmenü szélessége" + +#: configdialog/kbfxconfigdlglayout.ui.h:425 +msgid "Contracted Menues" +msgstr "Összevont menük" + +#: configdialog/kbfxconfigdlglayout.ui.h:441 +msgid "Water Effect Frame Rate" +msgstr "Víz effektus képkockasebessége" + +#: configdialog/kbfxconfigdlglayout.ui.h:450 +msgid "Enabled Water Effect" +msgstr "Víz effektus engedélyezve" + +#: configdialog/kbfxconfigdlglayout.ui.h:495 +msgid "Select folder to export kbfxlayoutrc file" +msgstr "Add meg a kbfxlayoutrc fájl exportjának célkönyvtárát" + +#: configdialog/kbfxconfigdlglayout.ui.h:583 +msgid "" +"

The Layout configuration of the KBFX Theme %1 has been exported successfully!

" +msgstr "" +"

A(z) %1 téma elrendezésének beállítása " +"sikeresen exportálva!

" + +#: configdialog/kbfxconfigdlglayout.ui.h:584 +msgid "KBFX Layout Export Ready" +msgstr "KBFX elrendezés exportja kész" + +#: configdialog/kbfxconfigdlglayout.ui.h:651 +msgid "" +"

The Layout configuration of the KBFX Theme %1 is ready!

Be sure to click the Apply button in order the changes to become active!

" +msgstr "" +"

A(z) %1 téma elrendezése kész!

Feltétlenül nyomd meg az Alkalmazás gombot, " +"hogy érvényesítsd a változtatásokat!

" + +#: configdialog/kbfxconfigdlglayout.ui.h:652 +msgid "KBFX Layout Ready" +msgstr "KBFX elrendezés kész" + +#: configdialog/kbfxconfigdlglayout.ui.h:658 +msgid "" +"

KBFX will calculate the necessary values using the present " +"values for:

* Main Menu Height and " +"* Main Menu Width
* Bottom Bar Height " +"and * Top Bar Height

So be sure " +"that you have entered their values as you desire!

NOTE: Have in mind that the Layout of the " +"theme also depends on the sizes of the images! So if the theme does not look " +"like as you desire either change the images' sizes to smaller width OR " +"change * Main Menu Width to higher value!

" +msgstr "" +"

A KBFX a jelenlegi értékek alapján beállítja a " +"következőket:

* Főmenü magassága és " +"* Főmenü szélessége
* Alsó sor magassága és * Felső sor magassága

Győződj meg róla, hogy mindennek a kívánt értéket adtad meg!

Figyelem:Vedd figyelembe, hogy a téma " +"elrendezése a használt képek méretétől is függ! Tehát, ha a téma nem úgy néz " +"ki, ahogy szeretted volna, akkor állítsd a képeket kisebb méretűre VAGY " +"állítsd a * Főmenü magasságát nagyobbra!

" + +#: configdialog/kbfxconfigdlglayout.ui.h:664 +msgid "Prepare Layout for the KBFX theme" +msgstr "Elrendezés előkészítése a KBFX témához" + +#: configdialog/kbfxconfigdlglayout.ui.h:665 +msgid "Prepare" +msgstr "Elkészítés" + +#: configdialog/kbfxconfigdlgplugins.ui.h:15 +msgid "Left Panel" +msgstr "Bal panel" + +#: configdialog/kbfxconfigdlgplugins.ui.h:16 +msgid "Right Panel" +msgstr "Jobb panel" + +#: configdialog/kbfxconfigdlgplugins.ui.h:79 +#: configdialog/kbfxconfigdlgplugins.ui.h:85 +msgid "

Not Implemented yet.

" +msgstr "

Még nincs implementálva.

" + +#: configdialog/kbfxconfigdlgmain.ui.h:34 +msgid "

Not implemented yet.

" +msgstr "

Még nincs implementálva.

" + diff --git a/po/it.po b/po/it.po new file mode 100644 index 0000000..32c6508 --- /dev/null +++ b/po/it.po @@ -0,0 +1,1591 @@ +# translation of it.po to Italian +# Italian translation for KBFX +# Copyright (c) 2007 KBFX Team +# This file is distributed under the same license as the KBFX package. +# +# Divilinux , 2006. +# dyve , 2007. +# PhobosK , 2007. +msgid "" +msgstr "" +"Project-Id-Version: it\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2007-03-04 15:53+0200\n" +"PO-Revision-Date: 2007-03-04 21:41+0200\n" +"Last-Translator: dyve \n" +"Language-Team: \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: KBabel 1.11.4\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: _translatorinfo.cpp:1 +msgid "" +"_: NAME OF TRANSLATORS\n" +"Your names" +msgstr "Divilinux" + +#: _translatorinfo.cpp:3 +msgid "" +"_: EMAIL OF TRANSLATORS\n" +"Your emails" +msgstr "divilinux@mail.kbfx.org" + +#: kbfxlib/common/kbfxconfig.cpp:32 +msgid "Not Specified" +msgstr "Non specificato" + +#: kbfxlib/common/kbfxfontchooser.cpp:38 +msgid "Font..." +msgstr "Font..." + +#: configdialog/kbfxconfigapp.cpp:28 +msgid "

%1

" +msgstr "

%1

" + +#: configdialog/kbfxconfigapp.cpp:29 +msgid "You are running: KBFX " +msgstr "Stai usando KBFX: " + +#: configdialog/kbfxconfigapp.cpp:30 +msgid "" +"

The connection to the KBFX News " +"Section on www.kbfx.org is broken.

If you want you can check " +"the latest news for KBFX from here:
KBFX " +"News

" +msgstr "" +"

La connessione alle news KBFX " +"non e' attiva.

Controlla lo stesso a questo url:
News KBFX

" + +#: configdialog/kbfxconfigapp.cpp:35 +msgid "" +"KBFX start button
Tip! You have 3 " +"options to select for your KBFX start button.You have to select (Normal, " +"Pressed, Hover) images.
Down below you can also see a preview of the " +"images you have selected." +msgstr "Bottone start KBFX NotaBene!Si puo' scegliere fra 3 tipi diversi di bottone(Normale, Pressed, Hover).
In basso verra' visualizzata l'anteprima dell'immagine selezionata." + +#: configdialog/kbfxconfigapp.cpp:40 +msgid "" +"About KBFX
Tip! Here you can find " +"information about the KBFX Project and all the people involved in it." +msgstr "About KBFX
NotaBene!Qui puoi trovare informazioni riguardo al progetto KBFX, e tutte le persone che lo hanno reso possibile." + +#: configdialog/kbfxconfigapp.cpp:43 +msgid "" +"KBFX font settings
Tip! Here you can " +"set the fonts of the current theme.
If you don't have any 'kbfxfontrc' " +"file don't worry about that.
When done just hit 'Apply' button and KBFX " +"will save the 'kbfxfontrc' file." +msgstr "Impostazioni font kbfx
NotaBene!E' possibile selezionare vari fonts e colori per personalizzare il menu KBFX. Se non hai il file kbfxfontrc,
all'interno dei tuoi temi,e' sufficiente selezionare e poi premere \"Apply\" per salvare il file." + +#: configdialog/kbfxconfigapp.cpp:48 +msgid "" +"KBFX Layout
Tip! Here you can " +"configure the Look and Feel of your KBFX menu.
The most important " +"settings that are used with the 'Make it...' buttons are " +"marked with '*'
Have in mind that the Layout of the " +"theme also depends on the sizes of the images!
" +msgstr "" +"KBFX Layout
Tip! Configura l'aspetto " +"del tuo kbfx menu.
Le impostazioni importanti usate col bottone " +"'Crea...'sono marcate con '*'
Ricorda " +"che il layout dipende dalla grandezza dell'immagine
" + +#: configdialog/kbfxconfigapp.cpp:53 +msgid "" +"KBFX Plugins
Tip! Here you can " +"select what plugins will be enabled and in which panel of the KBFX menu." +msgstr "" +"KBFX Plugins
Tip! Seleziona i " +"plugins da abilitare per i vari pannelli." + +#: configdialog/kbfxconfigapp.cpp:56 +msgid "" +"Menu Type
Tip! Please select which " +"kind of menu you would like to use." +msgstr "Stile Menu
NotaBene!Seleziona lo stile preferito per il menu: KBFX menu o KDE menu(classico)." + +#: configdialog/kbfxconfigapp.cpp:59 +msgid "" +"KBFX Themes
Tip! To keep it simple " +"place all your themes inside one folder.
Then create different folders " +"inside that folder with different names.
KBFX will then read those " +"folders as themes." +msgstr "Temi KBFX
NotaBene!Inserisci i tuoi temi in un unica directory, scompattali e crea
per ognuno una subdirectory. I temi verranno cosi' caricati senza problemi da KBFX." + +#: configdialog/kbfxconfigapp.cpp:64 +msgid "" +"KBFX tooltip settings
Tip! Here you " +"can configure the behaviour of KBFX's own tooltip." +msgstr "" +"KBFX tooltip Impostazioni
Tip! Configura il comportamento dei \"tooltips\"." + +#: configdialog/kbfxconfigapp.cpp:93 +msgid "Themes" +msgstr "Temi" + +#: configdialog/kbfxconfigapp.cpp:105 rc.cpp:230 +#, no-c-format +msgid "Start Button" +msgstr "Pulsante Start" + +#: configdialog/kbfxconfigapp.cpp:121 rc.cpp:239 +#, no-c-format +msgid "Menu Style" +msgstr "Stile Menu" + +#: configdialog/kbfxconfigapp.cpp:130 rc.cpp:242 +#, no-c-format +msgid "Tooltip" +msgstr "Suggerimento" + +#: configdialog/kbfxconfigapp.cpp:141 +msgid "Layout" +msgstr "Layout" + +#: configdialog/kbfxconfigapp.cpp:151 rc.cpp:248 +#, no-c-format +msgid "Plugins" +msgstr "Plugins" + +#: configdialog/kbfxconfigapp.cpp:240 +msgid "No default settings here ;)" +msgstr "Nessuna impostazione di default qui " + +#: configdialog/kbfxconfigapp.cpp:423 +msgid "

Could not create this KBFX theme package.

" +msgstr "

Impossibile installare il tema da pacchetto.

" + +#: configdialog/kbfxconfigapp.cpp:435 +msgid "

KBFX Theme %1 prepared.

" +msgstr "

Tema KBFX %1 si è preparata.

" + +#: configdialog/kbfxconfigapp.cpp:436 +msgid "KBFX Theme Ready" +msgstr "Tema KBFX pronto" + +#: configdialog/main.cpp:33 +msgid "KBFX Configuration Utility" +msgstr "Utility di configurazione KBFX" + +#: configdialog/main.cpp:39 +msgid "kbfxconfigapp" +msgstr "kbfxconfigapp" + +#: configdialog/main.cpp:52 +msgid "Install KBFX theme from " +msgstr "Installa il tema KBFX da " + +#: configdialog/main.cpp:53 +msgid "Prepare KBFX theme from folder " +msgstr "Prepari il tema KBFX dalla directory " + +#: configdialog/main.cpp:54 +msgid "Show the About page" +msgstr "Mostra la pagina informativa" + +#: src/kbfxspinx.cpp:234 +msgid "This is a help box" +msgstr "Help" + +#: src/kbfxspinx.cpp:358 +msgid "Remove KBFX from Pannel" +msgstr "Rimuovi KBFX dal pannello" + +#: src/kbfxspinx.cpp:360 +msgid "Reload KBFX" +msgstr "Ricarica KBFX" + +#: src/kbfxspinx.cpp:363 +msgid "Configure KBFX" +msgstr "Configura KBFX" + +#: src/kbfxspinx.cpp:365 +msgid "Edit Applications Menu" +msgstr "Modifica il menu' applicazioni" + +#: src/kbfxspinxmenu.cpp:54 +msgid "Double click to clear..." +msgstr "Doppio click per ripulire..." + +#: src/kbfxspinxmenu.cpp:66 +msgid "Type here to search..." +msgstr "Digita qui per la ricerca..." + +#: src/kbfxbutton.cpp:270 +msgid "" +"Invalid images were dropped!\n" +"Cannot set the KBFX button to use these images!" +msgstr "" +"Le immagini non valide verranno scartate!\n" +"Impossibile usare l'immagine per il bottone KBFX!" + +#: src/kbfxbutton.cpp:272 +msgid "Error setting KBFX button images" +msgstr "Errore impostazione immagine KBFX" + +#: rc.cpp:3 +#, no-c-format +msgid "KBFX Button" +msgstr "Bottone KBFX" + +#: rc.cpp:6 +#, no-c-format +msgid "" +"To change KBFX button skin, simply browse to the image you want OR just " +"Drag&Drop the images to their respective place." +msgstr "" +"Per cambiare il tema del bottone KBFX seleziona l'immagine oppure,piu' " +"semplicemente,\"trascina\" l'immagine sopra il campo desiderato." + +#: rc.cpp:9 +#, no-c-format +msgid "Livepreview" +msgstr "Anteprima Live" + +#: rc.cpp:12 +#, no-c-format +msgid "" +"Tip! To see live preview, hover or press the preview image with your " +"mouse." +msgstr "" +"NotaBene! Per vedere l'anteprima,clicca sull'immagine direttamente " +"oppure passa sopra col mouse." + +#: rc.cpp:15 +#, no-c-format +msgid "KBFX Button live preview" +msgstr "KBFX Anteprima Live" + +#: rc.cpp:18 +#, no-c-format +msgid "Here you can see the live preview of the KBFX Button." +msgstr "Qui puoi vedere l'anteprima del bottone KBFX." + +#: rc.cpp:21 +#, no-c-format +msgid "Resize Panel" +msgstr "Ridimensiona pannello" + +#: rc.cpp:24 +#, no-c-format +msgid "" +"Tip! This button resizes the panel on which the KBFX button is to " +"button's height or width." +msgstr "" +"NotaBene! Questo bottone ridimensiona la toolbar dove si trova la " +"applet KBFX(normalmente la kickbar) per adattarla al pulsante KBFX scelto." + +#: rc.cpp:27 configdialog/kbfxconfigdlgbutton.ui.h:141 +#, no-c-format +msgid "Panel Resize is 'ON'" +msgstr "Ridimensiona barra \"ON\"" + +#: rc.cpp:32 +#, no-c-format +msgid "

Preview of selected images

" +msgstr "

Anteprima immagine selezionata

" + +#: rc.cpp:35 +#, no-c-format +msgid "\"PRESSED\" IMAGE SELECTION" +msgstr "\"PRESSED\" SELEZIONA IMMAGINE" + +#: rc.cpp:38 +#, no-c-format +msgid "Please select \"pressed\" image." +msgstr "Seleziona immagine \"pressed\"." + +#: rc.cpp:41 rc.cpp:65 rc.cpp:89 +#, no-c-format +msgid "image/jpeg image/png image/x-xpm image/gif" +msgstr "Immagine/jpeg immagine/png immagine/x-xpm immagine/gif" + +#: rc.cpp:44 +#, no-c-format +msgid "The Pressed Button Skin Image" +msgstr "Immagine bottone \"pressed\"" + +#: rc.cpp:47 +#, no-c-format +msgid "Here you can choose the Pressed Button Skin Image" +msgstr "Qui puoi scegliere l'immagine per il bottone\"pressed\"" + +#: rc.cpp:50 rc.cpp:74 rc.cpp:98 +#, no-c-format +msgid "Preview" +msgstr "Anteprima Live" + +#: rc.cpp:53 +#, no-c-format +msgid "Pressed Button Skin" +msgstr "Immagine bottone \"pressed\"" + +#: rc.cpp:56 +#, no-c-format +msgid "Here you can Drag&Drop the Pressed Button Skin Image." +msgstr "Drag&Drop immagine bottone \"pressed\"." + +#: rc.cpp:59 +#, no-c-format +msgid "\"NORMAL\" IMAGE SELECTION" +msgstr "\"NORMALE\" SELEZIONA IMMAGINE" + +#: rc.cpp:62 +#, no-c-format +msgid "Please select \"normal\" image." +msgstr "Seleziona immagine \"normale\"." + +#: rc.cpp:68 +#, no-c-format +msgid "The Normal Button Skin Image" +msgstr "Immagine bottone \"normale\"" + +#: rc.cpp:71 +#, no-c-format +msgid "Here you can choose the Normal Button Skin Image" +msgstr "Qui puoi scegliere l'immagine per il bottone \"normale\"" + +#: rc.cpp:77 +#, no-c-format +msgid "Normal Button Skin" +msgstr "Tema bottone \"normale\"" + +#: rc.cpp:80 +#, no-c-format +msgid "Here you can Drag&Drop the Normal Button Skin Image." +msgstr "Drag&Drop Immagine bottone \"normale\"." + +#: rc.cpp:83 +#, no-c-format +msgid "\"HOVER\" IMAGE SELECTION" +msgstr "\"HOVER\" SELEZIONA IMMAGINE" + +#: rc.cpp:86 +#, no-c-format +msgid "Please select \"hover\" image." +msgstr "Seleziona immagine \"hover\"." + +#: rc.cpp:92 +#, no-c-format +msgid "The Hover Button Skin Image" +msgstr "Tema bottone \"HOVER\"" + +#: rc.cpp:95 +#, no-c-format +msgid "Here you can choose the Hover Button Skin Image" +msgstr "Qui puoi scegliere l'immagine per il bottone \"hover\"" + +#: rc.cpp:101 +#, no-c-format +msgid "Hover Button Skin" +msgstr "Tema bottone \"hover\"" + +#: rc.cpp:104 +#, no-c-format +msgid "Here you can Drag&Drop the Hover Button Skin Image." +msgstr "Drag&Drop immagine bottone \"hover\"." + +#: rc.cpp:107 +#, no-c-format +msgid "

Please select KBFX button's images

" +msgstr "

Anteprima immagine selezionata

" + +#: rc.cpp:110 rc.cpp:179 rc.cpp:296 rc.cpp:404 rc.cpp:440 rc.cpp:461 +#, no-c-format +msgid "KBFX Control Center" +msgstr "Centro controllo KBFX" + +#: rc.cpp:113 +#, no-c-format +msgid "

Layout options

" +msgstr "

Anteprima immagine selezionata

" + +#: rc.cpp:116 +#, no-c-format +msgid "EXPORT KBFXLAYOUTRC FILE" +msgstr "ESPORTA FILE KBFXFONTRC" + +#: rc.cpp:119 +#, no-c-format +msgid "Export the kbfxlayoutrc file to a folder" +msgstr "Esporta il file kbfxfontrc in una directory" + +#: rc.cpp:122 rc.cpp:473 +#, no-c-format +msgid "Setup fonts for your KBFX" +msgstr "Seleziona i font per il tuo tema KBFX" + +#: rc.cpp:125 rc.cpp:476 +#, no-c-format +msgid "Theme that is edited:" +msgstr "Tema modificato:" + +#: rc.cpp:128 rc.cpp:479 +#, no-c-format +msgid "

default

" +msgstr "

default

" + +#: rc.cpp:131 rc.cpp:482 +#, no-c-format +msgid "Please select the theme you want to edit" +msgstr "Seleziona il tema da modificare" + +#: rc.cpp:134 +#, no-c-format +msgid "Select the Layout property to change" +msgstr "Seleziona propieta' layout" + +#: rc.cpp:137 +#, no-c-format +msgid "Make it 2 panels (Left \"ON\")" +msgstr "Crea 2 pannelli (sx \"ON\")" + +#: rc.cpp:140 +#, no-c-format +msgid "Make it 2 panels (Right \"ON\")" +msgstr "Crea 2 pannelli (dx \"ON\")" + +#: rc.cpp:143 +#, no-c-format +msgid "Make it 3 panels" +msgstr "Crea 3 pannelli" + +#: rc.cpp:146 +#, no-c-format +msgid "textLabel1" +msgstr "textLabel1" + +#: rc.cpp:149 +#, no-c-format +msgid "textLabel2" +msgstr "textLabel2" + +#: rc.cpp:152 +#, no-c-format +msgid "textLabel3" +msgstr "textLabel3" + +#: rc.cpp:155 +#, no-c-format +msgid "textLabel4" +msgstr "textLabel4" + +#: rc.cpp:158 +#, no-c-format +msgid "checkBox1" +msgstr "checkBox1" + +#: rc.cpp:161 +#, no-c-format +msgid "textLabel5" +msgstr "textLabel5" + +#: rc.cpp:164 +#, no-c-format +msgid "textLabel6" +msgstr "textLabel6" + +#: rc.cpp:167 +#, no-c-format +msgid "textLabel7" +msgstr "textLabel7" + +#: rc.cpp:170 +#, no-c-format +msgid "textLabel8" +msgstr "textLabel8" + +#: rc.cpp:173 +#, no-c-format +msgid "checkBox2" +msgstr "checkBox2" + +#: rc.cpp:176 +#, no-c-format +msgid "C&ustom" +msgstr "&Modificato" + +#: rc.cpp:182 +#, no-c-format +msgid "

Plugins options

" +msgstr "

Opzioni plugins:

" + +#: rc.cpp:185 +#, no-c-format +msgid "Select KBFX Panel" +msgstr "Seleziona pannello kbfx" + +#: rc.cpp:188 rc.cpp:191 +#, no-c-format +msgid "Plugin to configure" +msgstr "Configura plugins" + +#: rc.cpp:194 +#, no-c-format +msgid "Please select the panel you want to configure: " +msgstr "Seleziona il pannello da configurare" + +#: rc.cpp:197 +#, no-c-format +msgid "&Available Plugins:" +msgstr "Plugins &disponibili:" + +#: rc.cpp:200 +#, no-c-format +msgid "&Enabled Plugins:" +msgstr "Plugins &abilitati:" + +#: rc.cpp:203 +#, no-c-format +msgid "&Configure Plugin" +msgstr "&Configura plugins" + +#: rc.cpp:206 +#, no-c-format +msgid "Alt+C" +msgstr "Alt+C" + +#: rc.cpp:209 rc.cpp:212 +#, no-c-format +msgid "Configure the selected plugin" +msgstr "Configura il plugin selezionato" + +#: rc.cpp:215 +#, no-c-format +msgid "&Plugin Information" +msgstr "&Info plugin" + +#: rc.cpp:218 +#, no-c-format +msgid "Alt+P" +msgstr "Alt+P" + +#: rc.cpp:221 rc.cpp:224 +#, no-c-format +msgid "Information about the selected plugin" +msgstr "Info sul plugin selezionato" + +#: rc.cpp:227 +#, no-c-format +msgid "KBFX Configurator Application" +msgstr "KBFX applicazione di configurazione" + +#: rc.cpp:233 +#, no-c-format +msgid "KBFX Themes" +msgstr "Temi KBFX" + +#: rc.cpp:245 +#, no-c-format +msgid "Search Engine" +msgstr "Motore di ricerca" + +#: rc.cpp:251 +#, no-c-format +msgid "About KBFX" +msgstr "Info KBFX" + +#: rc.cpp:254 +#, no-c-format +msgid "" +"




If you want you can check the latest " +"news for KBFX from here:
KBFX News" +msgstr "" +"




Puoi trovare le ultime informazioni e " +"lenews KBFX da qui:
KBFX News

" + +#: rc.cpp:260 +#, no-c-format +msgid "Alt+H" +msgstr "Alt+H" + +#: rc.cpp:263 +#, no-c-format +msgid "Open Help Documentation" +msgstr "Apri documentazione" + +#: rc.cpp:266 +#, no-c-format +msgid "&Default" +msgstr "&Default" + +#: rc.cpp:269 +#, no-c-format +msgid "Alt+D" +msgstr "Alt+D" + +#: rc.cpp:272 +#, no-c-format +msgid "Apply the default configuration for this section only" +msgstr "Applica la configurazione di default solo per questa sezione" + +#: rc.cpp:278 +#, no-c-format +msgid "Alt+A" +msgstr "Alt+A" + +#: rc.cpp:281 +#, no-c-format +msgid "Save the configuration and Apply it" +msgstr "Salva e applica configurazione" + +#: rc.cpp:287 +#, no-c-format +msgid "Alt+X" +msgstr "Alt+X" + +#: rc.cpp:290 +#, no-c-format +msgid "Exit the configuration without saving" +msgstr "Esci senza salvare le impostazioni" + +#: rc.cpp:293 +#, no-c-format +msgid "Kbfx start button
" +msgstr "Kbfx bottone start
" + +#: rc.cpp:299 +#, no-c-format +msgid "Select default folder" +msgstr "Seleziona directory di default" + +#: rc.cpp:302 +#, no-c-format +msgid "Please select the target folder where your themes are." +msgstr "Seleziona la directory dei tuoi temi KBFX." + +#: rc.cpp:305 +#, no-c-format +msgid "SpixBar" +msgstr "SpixBar" + +#: rc.cpp:308 +#, no-c-format +msgid "Installed Themes" +msgstr "Temi installati" + +#: rc.cpp:311 +#, no-c-format +msgid "Here are listed all the installed KBFX Themes" +msgstr "Lista temi KBFX installati" + +#: rc.cpp:314 +#, no-c-format +msgid "Selected Theme Preview" +msgstr "Seleziona anteprima tema" + +#: rc.cpp:317 +#, no-c-format +msgid "Delete Selected" +msgstr "Rimuovi selezionato" + +#: rc.cpp:320 +#, no-c-format +msgid "Delete the Selected Theme" +msgstr "Rimuovi il tema selezionato" + +#: rc.cpp:323 +#, no-c-format +msgid "" +"Pressing the button will delete the currently selected theme.
Warning!" +" You cannot delete the installed system wide themes!" +msgstr "" +"Premendo il bottone verra' rimosso il tema corrente
ATTENZIONE! Questa azione non rimuovera' il tema dal vostro sistema!" + +#: rc.cpp:326 +#, no-c-format +msgid "Get Themes" +msgstr "Scarica temi" + +#: rc.cpp:329 +#, no-c-format +msgid "Get More Themes from the Internet" +msgstr "Scarica altri temi da internet" + +#: rc.cpp:332 +#, no-c-format +msgid "" +"Pressing the button will launch konqueror and go to the KBFX Themes Section " +"on www.kde-look.org" +msgstr "" +"Premi il bottone per lanciare konqueror all'indirizzo:www.kde-look.org," +"sezione temi KBFX" + +#: rc.cpp:335 +#, no-c-format +msgid "Install Theme" +msgstr "Installa Tema" + +#: rc.cpp:338 +#, no-c-format +msgid "Install New Theme from KBFX Theme Package" +msgstr "Installa tema KBFX da pacchetto" + +#: rc.cpp:341 +#, no-c-format +msgid "" +"Pressing the button will offer a dialog where you can choose KBFX Theme " +"Package to install in your home folder" +msgstr "" +"Premendo il bottone verra' mostrata una finestra di dialogo dove sara' " +"possibile selezionare il tema KBFX(in formato compresso)e installarlo nella " +"home directory" + +#: rc.cpp:344 rc.cpp:583 +#, no-c-format +msgid "Theme Info" +msgstr "Info temi" + +#: rc.cpp:347 +#, no-c-format +msgid "Show specific theme info" +msgstr "Mostra le info specifiche del tema" + +#: rc.cpp:350 +#, no-c-format +msgid "Pressing the button will show you specific theme info" +msgstr "Premi il bottone per le info sul tema" + +#: rc.cpp:353 +#, no-c-format +msgid "Personal Image" +msgstr "Immagine personale" + +#: rc.cpp:356 +#, no-c-format +msgid "Theme's Default" +msgstr "Tema di default" + +#: rc.cpp:359 +#, no-c-format +msgid "Set the Theme's Default Personal Image" +msgstr "Seleziona immagine personale da tema di default" + +#: rc.cpp:362 +#, no-c-format +msgid "" +"Pressing the button will delete the personal image you have selected and " +"install the theme's default personal image" +msgstr "" +"Premi il bottone per rimuovere l'immagine personale selezionata e installare " +"quella del tema di default" + +#: rc.cpp:365 +#, no-c-format +msgid "Maxsize 48 x 48" +msgstr "Dimensione massima 48x48" + +#: rc.cpp:368 +#, no-c-format +msgid "Select New image" +msgstr "Seleziona nuova immagine" + +#: rc.cpp:371 +#, no-c-format +msgid "Select a Personal Image" +msgstr "Seleziona immagine personale" + +#: rc.cpp:374 +#, no-c-format +msgid "Pressing the button will open a dialog to select your personal image" +msgstr "" +"Premendo il bottone verra' mostrata una finestra di dialogo dove sara' " +"possibile selezionare la propia immagine personale" + +#: rc.cpp:377 +#, no-c-format +msgid "This is your personal image displayed at the KBFX menu." +msgstr "Questa e' la tua immagine personale che potra' essere visualizzata nella barra superiore del menu KBFX." + +#: rc.cpp:380 +#, no-c-format +msgid "Misc Options" +msgstr "Opzioni varie" + +#: rc.cpp:383 +#, no-c-format +msgid "Watch System Installs" +msgstr "Guarda installazione di sistema" + +#: rc.cpp:386 rc.cpp:389 +#, no-c-format +msgid "Watch for applications installs and reload KBFX if any occurs" +msgstr "Guarda le applicazioni installate e ricarica il kbfx" + +#: rc.cpp:392 rc.cpp:395 +#, no-c-format +msgid "Show Old Themes" +msgstr "Mostra i temi vecchi" + +#: rc.cpp:398 +#, no-c-format +msgid "

Please select theme folder

" +msgstr "

Seleziona una directory per i temi

" + +#: rc.cpp:401 +#, no-c-format +msgid "

Installed themes

" +msgstr "

Temi installati

" + +#: rc.cpp:407 +#, no-c-format +msgid "

Tooltip ON or OFF

" +msgstr "

Tooltip ON - OFF

" + +#: rc.cpp:410 +#, no-c-format +msgid "Turn off or on the tooltip" +msgstr "Disattiva suggerimento" + +#: rc.cpp:413 +#, no-c-format +msgid "" +"Turn your tooltip off or on.
You can see the current status of the " +"tooltip to the right." +msgstr "" +"Attiva/Disattiva il
suggerimento Controlla lo stato attuale sulla " +"destra." + +#: rc.cpp:416 +#, no-c-format +msgid "Turn the tooltip \"OFF\"" +msgstr "Suggerimento \"OFF\"" + +#: rc.cpp:419 +#, no-c-format +msgid "Tooltip Text" +msgstr "Testo suggerimento" + +#: rc.cpp:422 +#, no-c-format +msgid "Type the text which you want to be displayed in the tooltip." +msgstr "Scrivi il messaggio che verra' visualizzato nel suggerimento." + +#: rc.cpp:425 +#, no-c-format +msgid "

Tooltip personal text

" +msgstr "

Tooltip testo personale

" + +#: rc.cpp:428 +#, no-c-format +msgid "Tooltip animation" +msgstr "Animazione suggerimento" + +#: rc.cpp:431 +#, no-c-format +msgid "" +"Turn your tooltip animation off or on.
You can see the current status of " +"the tooltip to the right." +msgstr "" +"Attiva/Disattiva animazione
suggerimento Controlla lo stato attuale " +"sulla destra ." + +#: rc.cpp:434 +#, no-c-format +msgid "Turn the animation \"ON\"" +msgstr "Animazione \"ON\"" + +#: rc.cpp:437 +#, no-c-format +msgid "

Tooltip animation ON or OFF

" +msgstr "

Tooltip animazione ON - OFF

" + +#: rc.cpp:443 +#, no-c-format +msgid "

Menu type

" +msgstr "

Tipo di Menu'

" + +#: rc.cpp:446 +#, no-c-format +msgid "Please select the menu style" +msgstr "Seleziona lo stile del Menu" + +#: rc.cpp:449 rc.cpp:455 +#, no-c-format +msgid "KBFX MENU" +msgstr "KBFX MENU" + +#: rc.cpp:452 rc.cpp:458 +#, no-c-format +msgid "KDE MENU" +msgstr "MENU KDE" + +#: rc.cpp:464 +#, no-c-format +msgid "

Font options

" +msgstr "

Font opzioni

" + +#: rc.cpp:467 +#, no-c-format +msgid "EXPORT KBFXFONTRC FILE" +msgstr "ESPORTA FILE KBFXFONTRC" + +#: rc.cpp:470 +#, no-c-format +msgid "Export the kbfxfontrc file to a folder" +msgstr "Esporta il file kbfxfontrc in una directory" + +#: rc.cpp:485 +#, no-c-format +msgid "Bold fonts on hover" +msgstr "Ingrandisci font al passaggio" + +#: rc.cpp:488 rc.cpp:491 +#, no-c-format +msgid "Make fonts bolder when you hover the mouse over an item" +msgstr "Ingrandisci i fonts quando passi col mouse su un oggetto" + +#: rc.cpp:494 +#, no-c-format +msgid "Application \"LINE\":" +msgstr "\"LINEA\" applicazioni:" + +#: rc.cpp:497 +#, no-c-format +msgid "Horizontal line color in the application area." +msgstr "Colore linea orizzontale dell'area-applicazioni." + +#: rc.cpp:500 +#, no-c-format +msgid "Application text :" +msgstr "Testo applicazioni:" + +#: rc.cpp:503 +#, no-c-format +msgid "Select the color of the \"application\" in the menu." +msgstr "Seleziona il colore \"applicazioni\" del menu." + +#: rc.cpp:506 +#, no-c-format +msgid "Comment text:" +msgstr "Testo \"commenti\":" + +#: rc.cpp:509 +#, no-c-format +msgid "Color of the \"comments\" in the menu." +msgstr "Colore dei \"commenti\" del menu." + +#: rc.cpp:512 +#, no-c-format +msgid "Name display:" +msgstr "Nome del display:" + +#: rc.cpp:515 rc.cpp:527 rc.cpp:533 +#, no-c-format +msgid "The color of your login name in the menu." +msgstr "Colore del nome_utente nel menu." + +#: rc.cpp:518 +#, no-c-format +msgid "Category text:" +msgstr "Testo \"categorie\":" + +#: rc.cpp:521 +#, no-c-format +msgid "Font color of the categoris in the menu." +msgstr "Colore font del menu." + +#: rc.cpp:524 +#, no-c-format +msgid "Separator:" +msgstr "Separatore:" + +#: rc.cpp:530 +#, no-c-format +msgid "Plugin:" +msgstr "Plugin:" + +#: rc.cpp:536 +#, no-c-format +msgid "Select font for the application's text" +msgstr "Seleziona font per testo applicazione" + +#: rc.cpp:539 +#, no-c-format +msgid "Select font for the comment's text" +msgstr "Seleziona font per i commenti" + +#: rc.cpp:542 +#, no-c-format +msgid "Select font for the username's text" +msgstr "Seleziona font per il nome utente" + +#: rc.cpp:545 +#, no-c-format +msgid "Select font for the category's text" +msgstr "Seleziona font per le categorie" + +#: rc.cpp:548 +#, no-c-format +msgid "Select font for the separator's text" +msgstr "Seleziona font per il separatore" + +#: rc.cpp:551 +#, no-c-format +msgid "Select font for the plugins' text" +msgstr "Seleziona font per i plugins" + +#: rc.cpp:554 +#, no-c-format +msgid "Form1" +msgstr "Form1" + +#: rc.cpp:557 +#, no-c-format +msgid "

People behind KBFX

" +msgstr "

Persone che lavorano al progetto KBFX

" + +#: rc.cpp:560 +#, no-c-format +msgid "You are running: KBFX 0493" +msgstr "Stai usando KBFX 0493" + +#: rc.cpp:563 +#, no-c-format +msgid "" +"Here are the people behind the KBFX application.\n" +"We would like to thank all people who have helped with KBFX or have donated " +"money to our project!\n" +"THANKS A LOT ALL OF YOU OUT THERE!!!" +msgstr "" +"Queste persone rappresentano il team di KBFX Vorremmo ringraziare tutti " +"coloro che ci hanno aiutati economicamente o semplicemente col propio " +"supporto, con la realizzazione dei temi e della documentazione.\n" +"GRAZIE DI CUORE A TUTTI QUANTI!!!" + +#: rc.cpp:568 +#, no-c-format +msgid "" +"Name: Siraj Razick

Country: Sri " +"Lanka

KBFX: Author, Maintainer, Developer, Project " +"Admin

Email: siraj(a)mail.kbfx.org" +msgstr "" +"Name: Siraj Razick

Country: Sri " +"Lanka

KBFX: Author, Maintainer, Developer, Project " +"Admin

Email: siraj(a)mail.kbfx.org" + +#: rc.cpp:571 +#, no-c-format +msgid "" +"Tip! Hover over the contact images to see each personal contact " +"information." +msgstr "" +"Passa il mouse sopra l'immagine personale per scoprire ulteriori " +"informazioni su ogni team member." + +#: rc.cpp:574 +#, no-c-format +msgid "SPONSORS!" +msgstr "SPONSORS!" + +#: rc.cpp:577 +#, no-c-format +msgid "" +"We would like to thank swedish computer company PC Agenten for " +"sponsoring us with a server and bandwidth." +msgstr "" +"Un grazie particolare alla compagnia di computer Svedesi PC Agenten " +"per il supporto e lo spazio web." + +#: rc.cpp:580 +#, no-c-format +msgid "" +"

HTTP://WWW." +"PCAGENTEN.SE

" +msgstr "" +"

HTTP://WWW." +"PCAGENTEN.SE

" + +#: rc.cpp:589 +#, no-c-format +msgid "

Name:

" +msgstr "

Nome:

" + +#: rc.cpp:592 +#, no-c-format +msgid "

Version:

" +msgstr "

Versione:

" + +#: rc.cpp:595 +#, no-c-format +msgid "

Author:

" +msgstr "

Autore:

" + +#: rc.cpp:598 +#, no-c-format +msgid "

Email:

" +msgstr "

Email:

" + +#: rc.cpp:601 +#, no-c-format +msgid "

Homepage:

" +msgstr "

Homepage:

" + +#: rc.cpp:604 rc.cpp:607 rc.cpp:610 rc.cpp:613 rc.cpp:616 +#, no-c-format +msgid "Test" +msgstr "Test" + +#: configdialog/kbfxconfigdlgthemes.ui.h:61 +msgid "" +"

Invalid user themes folder!

Will use " +"default user themes folder.

" +msgstr "" +"

Directory dei temi errata!

Verra'usata la directory di default.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:63 +msgid "Error loading themes" +msgstr "Errore nel caricamento temi" + +#: configdialog/kbfxconfigdlgthemes.ui.h:170 +msgid "" +"

Are you sure you want to uninstall the KBFX theme %" +"1?

" +msgstr "" +"

Vuoi disinstallare il tema di KBFX? %" +"1?

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:171 +msgid "Uninstall KBFX theme" +msgstr "Disinstalla tema KBFX" + +#: configdialog/kbfxconfigdlgthemes.ui.h:172 +msgid "Uninstall" +msgstr "Disinstalla" + +#: configdialog/kbfxconfigdlgthemes.ui.h:177 +msgid "" +"

Do you want to keep your personal settings for theme " +"%1?

" +msgstr "" +"

Vuoi mantenere le impostazioni personali del tema?" +"%1?

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:178 +msgid "Personal settings" +msgstr "IMpostazioni personali" + +#: configdialog/kbfxconfigdlgthemes.ui.h:179 +msgid "Keep settings" +msgstr "Mantieni impostazioni" + +#: configdialog/kbfxconfigdlgthemes.ui.h:180 +msgid "Delete settings" +msgstr "Rimuovi impostazioni" + +#: configdialog/kbfxconfigdlgthemes.ui.h:210 +msgid "" +"

Could not uninstall this KBFX theme.

You may not have sufficient permissions to delete the folder " +"%1.

" +msgstr "" +"

Impossibile disinstallare il tema.

Permessi insufficienti per rimuovere il tema%" +"1.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:223 +msgid "KBFX theme packages (*.tar, *.tar.bz2, *.tar.gz, *.kbfxtheme)" +msgstr "KBFX temi (*.tar, *.tar.bz2, *.tar.gz, *.kbfxtheme)" + +#: configdialog/kbfxconfigdlgthemes.ui.h:227 +msgid "Select KBFX theme package to install" +msgstr "Seleziona il tema da installare" + +#: configdialog/kbfxconfigdlgthemes.ui.h:243 +msgid "

Could not read this KBFX theme package.

" +msgstr "

Impossibile leggere il tema KBFX.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:270 +msgid "Select personal image" +msgstr "Seleziona immagine personale" + +#: configdialog/kbfxconfigdlgthemes.ui.h:281 +msgid "" +"

Image cannot be used as a personal image!

Will use default personal image.

" +msgstr "" +"

Impossibile usare immagine per l'avatar personale!

Verra' usato l'avatar di default.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:283 +#: configdialog/kbfxconfigdlgbutton.ui.h:65 +#: configdialog/kbfxconfigdlgbutton.ui.h:86 +#: configdialog/kbfxconfigdlgbutton.ui.h:107 +msgid "Error loading image" +msgstr "Errore caricamento immagine" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:23 +msgid "Turn the animation 'OFF'" +msgstr "Animazione \"OFF\"" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:30 +msgid "Turn the animation 'ON'" +msgstr "Animazione \"ON\"" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:53 +msgid "Turn the tooltip 'OFF'" +msgstr "Suggerimento \"OFF\"" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:60 +msgid "Turn the tooltip 'ON'" +msgstr "Suggerimento \"ON\"" + +#: configdialog/kbfxconfigdlgfonts-old.ui.h:122 +msgid "Select folder to export kbfxfontrc file" +msgstr "Seleziona directory per esportare il file kbfxfontrc" + +#: configdialog/kbfxconfigdlgfonts-old.ui.h:151 +msgid "" +"

The Font configuration of the KBFX Theme %1 has been exported successfully!

" +msgstr "" +"

La configurazione font del tema KBFX %1 e' stata esportata con successo

" + +#: configdialog/kbfxconfigdlgfonts-old.ui.h:152 +msgid "KBFX Font Export Ready" +msgstr "KBFX font pronto" + +#: configdialog/kbfxconfigdlgabout.ui.h:23 +msgid "" +"Name: Mensur Zahirovic (Nookie)

Country: Sweden

KBFX: co-author, Q/A, system design, " +"web designer, bug hunter, project administror

Email: " +"nookie@mail.kbfx.org" +msgstr "" +"Name: Mensur Zahirovic (Nookie)

Country: Sweden

KBFX: co-author, Q/A, system design, " +"web designer, bug hunter, project administror

Email: " +"nookie@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:32 +msgid "" +"Name: Siraj Razick

Country: Sri " +"Lanka

KBFX: author, maintainer, developer, project " +"administror

Email: siraj@mail.kbfx.org" +msgstr "" +"Name: Siraj Razick

Country: Sri " +"Lanka

KBFX: author, maintainer, developer, project " +"administror

Email: siraj@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:41 +msgid "" +"Name: Nathanael Dracor Gogniat

Country: Switzerland

KBFX: project technical writer, " +"documentation manager, co-author

Email: " +"nathanael@mail.kbfx.org" +msgstr "" +"Name: Nathanael Dracor Gogniat

Country: Switzerland

KBFX: project technical writer, " +"documentation manager, co-author

Email: " +"nathanael@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:50 +msgid "" +"Name: PhobosK

Country: " +"Bulgaria

KBFX: package & release manager, Q/A, bug " +"hunter, mandriva packages, project administrator, developer Qt/C+" +"+

Email: phobosk@mail.kbfx.org" +msgstr "" +"Name: PhobosK

Country: " +"Bulgaria

KBFX: package & release manager, Q/A, bug " +"hunter, mandriva packages, project administrator, developer Qt/C+" +"+

Email: phobosk@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:59 +msgid "" +"Name: Johnny Henry Saenz Acuna (scarebyte)" +"

Country: Peru

KBFX: " +"developer Qt4/C++

Email: saenzac@mail.kbfx.org" +msgstr "" +"Name: Johnny Henry Saenz Acuna (scarebyte)" +"

Country: Peru

KBFX: " +"developer Qt4/C++

Email: saenzac@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:68 +msgid "" +"Name: Christoffer Brodd-Reijer (Ephracis)" +"

Country: Sweden

KBFX: " +"library developer for Raptor

Email: ephracis@mail." +"kbfx.org" +msgstr "" +"Name: Christoffer Brodd-Reijer (Ephracis)" +"

Country: Sweden

KBFX: " +"library developer for Raptor

Email: ephracis@mail." +"kbfx.org" + +#: configdialog/kbfxconfigdlgbutton.ui.h:63 +msgid "" +"

Image cannot be used as a pressed button skin!

Will use default pressed button skin.

" +msgstr "

Impossibile caricare immagine per il bottone \"pressed\"

Verra' usata l'immagine di default.

" + +#: configdialog/kbfxconfigdlgbutton.ui.h:84 +msgid "" +"

Image cannot be used as a normal button skin!

Will use default normal button skin.

" +msgstr "" +"

Impossibile caricare immagine per il bottone \"normal\"

Verra' usata l'immagine di default

" + +#: configdialog/kbfxconfigdlgbutton.ui.h:105 +msgid "" +"

Image cannot be used as a hover button skin!

Will use default hover button skin.

" +msgstr "" +"

Impossibile caricare immagine per il bottone \"hover\"

Verra' usata l'immagine di default

" + +#: configdialog/kbfxconfigdlgbutton.ui.h:147 +msgid "Panel Resize is 'OFF'" +msgstr "Ridimensiona pannello \"OFF\"" + +#: configdialog/kbfxconfigdlglayout.ui.h:16 +msgid "User Properties" +msgstr "Propieta' utente" + +#: configdialog/kbfxconfigdlglayout.ui.h:17 +msgid "* Top Bar Properties" +msgstr "Propieta' barra superiore" + +#: configdialog/kbfxconfigdlglayout.ui.h:18 +msgid "* Bottom Bar Properties" +msgstr "Propieta' barra inferiore" + +#: configdialog/kbfxconfigdlglayout.ui.h:20 +msgid "* List Box Properties" +msgstr "Propieta' lista" + +#: configdialog/kbfxconfigdlglayout.ui.h:21 +msgid "Search Box Properties" +msgstr "Propieta' ricerca" + +#: configdialog/kbfxconfigdlglayout.ui.h:22 +msgid "* Item Properties" +msgstr "Propieta' oggetto" + +#: configdialog/kbfxconfigdlglayout.ui.h:24 +msgid "* Main Menu Properties" +msgstr "Propieta' menu' principale" + +#: configdialog/kbfxconfigdlglayout.ui.h:25 +msgid "Water Effect Properties" +msgstr "Propieta' effetto acqua" + +#: configdialog/kbfxconfigdlglayout.ui.h:209 +msgid "Face Position X" +msgstr "Posizione X" + +#: configdialog/kbfxconfigdlglayout.ui.h:210 +msgid "Face Position Y" +msgstr "Posizione Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:211 +msgid "User Name Position X" +msgstr "Posizione utente X" + +#: configdialog/kbfxconfigdlglayout.ui.h:212 +msgid "User Name Position Y" +msgstr "Posizione utente Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:213 +msgid "Face Box Position X" +msgstr "Lato posizione X" + +#: configdialog/kbfxconfigdlglayout.ui.h:214 +msgid "Face Box Position Y" +msgstr "Lato posizione Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:215 +msgid "Face Box Height" +msgstr "Lato altezza" + +#: configdialog/kbfxconfigdlglayout.ui.h:216 +msgid "Face Box Width" +msgstr "Lato larghezza" + +#: configdialog/kbfxconfigdlglayout.ui.h:217 +msgid "Hide User Name" +msgstr "Nascondi nome utente" + +#: configdialog/kbfxconfigdlglayout.ui.h:235 +msgid "* Top Bar Height" +msgstr "Altezza barra superiore" + +#: configdialog/kbfxconfigdlglayout.ui.h:241 +msgid "Top Bar Width" +msgstr "Larghezza barra inferiore" + +#: configdialog/kbfxconfigdlglayout.ui.h:266 +msgid "* Bottom Bar Height" +msgstr "Altezza barra inferiore" + +#: configdialog/kbfxconfigdlglayout.ui.h:272 +msgid "Bottom Bar Width" +msgstr "Larghezza barra inferiore" + +#: configdialog/kbfxconfigdlglayout.ui.h:322 +msgid "* List Box Position X" +msgstr "List box posizione X" + +#: configdialog/kbfxconfigdlglayout.ui.h:323 +msgid "* List Box Position Y" +msgstr "List box posizione Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:326 +msgid "List Box Height" +msgstr "Altezza list box" + +#: configdialog/kbfxconfigdlglayout.ui.h:327 +msgid "* List Box Width" +msgstr "Larghezza list box" + +#: configdialog/kbfxconfigdlglayout.ui.h:345 +msgid "Search Box Position X" +msgstr "Posizione campo di ricerca X" + +#: configdialog/kbfxconfigdlglayout.ui.h:346 +msgid "Search Box Position Y" +msgstr "Posizione campo di ricerca Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:349 +msgid "Search Box Height" +msgstr "Altezza campo di ricerca" + +#: configdialog/kbfxconfigdlglayout.ui.h:350 +msgid "Search Box Width" +msgstr "Larghezza campo di ricerca" + +#: configdialog/kbfxconfigdlglayout.ui.h:368 +msgid "* Item Position X" +msgstr "Posizione oggetto X" + +#: configdialog/kbfxconfigdlglayout.ui.h:369 +msgid "* Item Position Y" +msgstr "Posizione oggetto Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:370 +msgid "Icon Size in Item" +msgstr "Dimensione icona oggetto" + +#: configdialog/kbfxconfigdlglayout.ui.h:372 +msgid "Item Height" +msgstr "Altezza oggetto" + +#: configdialog/kbfxconfigdlglayout.ui.h:373 +msgid "* Item Width" +msgstr "Larghezza oggetto" + +#: configdialog/kbfxconfigdlglayout.ui.h:374 +msgid "Comment Margin in Item" +msgstr "Margine commento" + +#: configdialog/kbfxconfigdlglayout.ui.h:376 +msgid "No Comments in Item" +msgstr "Nessun commento" + +#: configdialog/kbfxconfigdlglayout.ui.h:417 +msgid "* Main Menu Height" +msgstr "ALtezza menu' principale" + +#: configdialog/kbfxconfigdlglayout.ui.h:421 +msgid "* Main Menu Width" +msgstr "Larghezza menu' principale" + +#: configdialog/kbfxconfigdlglayout.ui.h:425 +msgid "Contracted Menues" +msgstr "Menu' contratti" + +#: configdialog/kbfxconfigdlglayout.ui.h:441 +msgid "Water Effect Frame Rate" +msgstr "Frame rate effetto acqua" + +#: configdialog/kbfxconfigdlglayout.ui.h:450 +msgid "Enabled Water Effect" +msgstr "Abilita effetto acqua" + +#: configdialog/kbfxconfigdlglayout.ui.h:495 +msgid "Select folder to export kbfxlayoutrc file" +msgstr "Seleziona directory per esportare il file kbfxlayoutrc" + +#: configdialog/kbfxconfigdlglayout.ui.h:583 +msgid "" +"

The Layout configuration of the KBFX Theme %1 has been exported successfully!

" +msgstr "" +"

La configurazione layout del tema KBFX %1 e' stata esportata con successo

" + +#: configdialog/kbfxconfigdlglayout.ui.h:584 +msgid "KBFX Layout Export Ready" +msgstr "KBFX layout pronto" + +#: configdialog/kbfxconfigdlglayout.ui.h:651 +msgid "" +"

The Layout configuration of the KBFX Theme %1 is ready!

Be sure to click the Apply button in order the changes to become active!

" +msgstr "" +"

Configurazione layout del tema KBFX%1 " +"pronta!

Clicca sul bottone Applicaper " +"attivare i cambiamenti

" + +#: configdialog/kbfxconfigdlglayout.ui.h:652 +msgid "KBFX Layout Ready" +msgstr "Layout KBFX pronto" + +#: configdialog/kbfxconfigdlglayout.ui.h:658 +msgid "" +"

KBFX will calculate the necessary values using the present " +"values for:

* Main Menu Height and " +"* Main Menu Width
* Bottom Bar Height " +"and * Top Bar Height

So be sure " +"that you have entered their values as you desire!

NOTE: Have in mind that the Layout of the " +"theme also depends on the sizes of the images! So if the theme does not look " +"like as you desire either change the images' sizes to smaller width OR " +"change * Main Menu Width to higher value!

" +msgstr "" +"

KBFX calcolera' i valori necessari per:

*Altezza menu' principalee * Menu' " +"principale Larghezza
*Barra inferiore Altezza e " +"*Altezza barra superiore

assicurati di avere questi valori attivi

NOTA: Ricarda che il layout del tema dipende " +"dalla grandezza dell'immagine..quindi se i temi non sono esattamente come li " +"volevi,cambia la grandezza dell'immagine * Larghezza menu' " +"principalead un valore piu' alto

" + +#: configdialog/kbfxconfigdlglayout.ui.h:664 +msgid "Prepare Layout for the KBFX theme" +msgstr "Prepara il layout per il tema KBFX" + +#: configdialog/kbfxconfigdlglayout.ui.h:665 +msgid "Prepare" +msgstr "Prepara" + +#: configdialog/kbfxconfigdlgplugins.ui.h:15 +msgid "Left Panel" +msgstr "Pannello sx" + +#: configdialog/kbfxconfigdlgplugins.ui.h:16 +msgid "Right Panel" +msgstr "Pannello dx" + +#: configdialog/kbfxconfigdlgplugins.ui.h:79 +#: configdialog/kbfxconfigdlgplugins.ui.h:85 +msgid "

Not Implemented yet.

" +msgstr "

Non implementatot.

" + +#: configdialog/kbfxconfigdlgmain.ui.h:34 +msgid "

Not implemented yet.

" +msgstr "

Non implementato

" + diff --git a/po/nl.po b/po/nl.po new file mode 100644 index 0000000..edfcb19 --- /dev/null +++ b/po/nl.po @@ -0,0 +1,1551 @@ +# translation of nl.po to +# translation of kbfxconfigapp.po to +# translation of kbfx.po to +# This file is put in the public domain. +# +# Monkey 9 , 2006, 2007. +msgid "" +msgstr "" +"Project-Id-Version: nl\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2007-03-01 11:46+0200\n" +"PO-Revision-Date: 2007-03-06 21:47+0100\n" +"Last-Translator: Monkey 9 \n" +"Language-Team: \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: KBabel 1.11.4\n" + +#: _translatorinfo.cpp:1 +#, fuzzy +msgid "" +"_: NAME OF TRANSLATORS\n" +"Your names" +msgstr "Monkey 9" + +#: _translatorinfo.cpp:3 +msgid "" +"_: EMAIL OF TRANSLATORS\n" +"Your emails" +msgstr "monkey9@iae.nl" + +#: kbfxlib/common/kbfxfontchooser.cpp:38 +msgid "Font..." +msgstr "Lettertype..." + +#: configdialog/kbfxconfigapp.cpp:28 +msgid "

%1

" +msgstr "

%1

" + +#: configdialog/kbfxconfigapp.cpp:29 +msgid "You are running: KBFX " +msgstr "U gebruikt: KBFX " + +#: configdialog/kbfxconfigapp.cpp:30 +msgid "" +"

The connection to the KBFX News " +"Section on www.kbfx.org is broken.

If you want you can check " +"the latest news for KBFX from here:
KBFX " +"News

" +msgstr "" +"

De verbinding naar de KBFX Niews " +"Sectie op www.kbfx.org is kapot.

Als je wilt kun je vanaf hier " +"het laatste nieuws voor KBFX controleren:
KBFX News

" + +#: configdialog/kbfxconfigapp.cpp:35 +msgid "" +"KBFX start button
Tip! You have 3 " +"options to select for your KBFX start button.You have to select (Normal, " +"Pressed, Hover) images.
Down below you can also see a preview of the " +"images you have selected." +msgstr "" +"KBFX start knop
Tip! Er zijn 3 " +"opties om je KBFX startknop te selecteren. Je dient (Normaal, " +"Ingedrukt, Muis-over) afbeeldingen te kiezen.
Hier beneden kun je ook een voorbeeld zien van de afbeeldingen, die je hebt gekozen." + +#: configdialog/kbfxconfigapp.cpp:40 +msgid "" +"About KBFX
Tip! Here you can find " +"information about the KBFX Project and all the people involved in it." +msgstr "" +"Over KBFX
Tip!Hier kun je informatie " +"vinden over het KBFX Project en alle betrokkenen." + +#: configdialog/kbfxconfigapp.cpp:43 +msgid "" +"KBFX font settings
Tip! Here you can " +"set the fonts of the current theme.
If you don't have any 'kbfxfontrc' " +"file don't worry about that.
When done just hit 'Apply' button and KBFX " +"will save the 'kbfxfontrc' file." +msgstr "" +"Kbfx lettertype instellingen
Tip!Hier kan men " +"de lettertypen. voor het huidige thema instellen.
Als je geen 'kbfxfontrc' hebt " +"maak je daarover dan niet bezorgd.
Wanneer gereed enkel op 'Toepassen'klikken en KBFX " +"zal de kbfxfontrc opslaan." + +#: configdialog/kbfxconfigapp.cpp:48 +msgid "" +"KBFX Layout
Tip! Here you can " +"configure the Look and Feel of your KBFX menu.
The most important " +"settings that are used with the 'Make it...' buttons are " +"marked with '*'
Have in mind that the Layout of the " +"theme also depends on the sizes of the images!
" +msgstr "" +"KBFX Opmaak
Tip! Hier kun je " +"het uiterlijk en thema van je KBFX menu instellen
De belangrijkste instellingen " +"die gebruikt worden met de 'Maken...' knoppen zijn " +"gemarkeerd met '*'
Houd in gedachten dat de opmaak van het " +"thema ook afhangt van de afmetingen van de plaatjes!
" + +#: configdialog/kbfxconfigapp.cpp:53 +msgid "" +"KBFX Plugins
Tip! Here you can " +"select what plugins will be enabled and in which panel of the KBFX menu." +msgstr "" +"KBFX Plugins
Tip!Hier kun je " +"kiezen welke plugins gebruikt zullen worden en in welk paneel van het KBFX menu" + +#: configdialog/kbfxconfigapp.cpp:56 +msgid "" +"Menu Type
Tip! Please select which " +"kind of menu you would like to use." +msgstr "" +"Menu Type
 Tip!Kies " +"welk soort menu je wilt gebruiken." + +#: configdialog/kbfxconfigapp.cpp:59 +msgid "" +"KBFX Themes
Tip! To keep it simple " +"place all your themes inside one folder.
Then create different folders " +"inside that folder with different names.
KBFX will then read those " +"folders as themes." +msgstr "" +"Kbfx Thema's

Tip!Voor alle eenvoud " +"plaats je alle thema's in een map in aparte mappen
met " +"eigen naam. KBFX zal die dan lezen als thema's." + +#: configdialog/kbfxconfigapp.cpp:64 +msgid "" +"KBFX tooltip settings
Tip! Here you " +"can configure the behaviour of KBFX's own tooltip." +msgstr "" +"KBFX hulpballon instellingen
Tip! Hier " +"kun je het gedrag van KBFX's eigen hulpballon instellen." + +#: configdialog/kbfxconfigapp.cpp:93 +msgid "Themes" +msgstr "Thema's" + +#: configdialog/kbfxconfigapp.cpp:105 rc.cpp:230 +#, no-c-format +msgid "Start Button" +msgstr "Start Knop" + +#: configdialog/kbfxconfigapp.cpp:121 rc.cpp:239 +#, no-c-format +msgid "Menu Style" +msgstr "Menu Stijl" + +#: configdialog/kbfxconfigapp.cpp:130 rc.cpp:242 +#, no-c-format +msgid "Tooltip" +msgstr "Tooltip" + +#: configdialog/kbfxconfigapp.cpp:141 +msgid "Layout" +msgstr "Opmaak" + +#: configdialog/kbfxconfigapp.cpp:151 rc.cpp:248 +#, no-c-format +msgid "Plugins" +msgstr "Plugins" + +#: configdialog/kbfxconfigapp.cpp:240 +msgid "No default settings here ;)" +msgstr "geen standaard instellingen hier;)" + +#: configdialog/kbfxconfigapp.cpp:412 +msgid "

Could not create this KBFX theme package.

" +msgstr "

Kon dit KBFX thema pakket niet aanmaken.

" + +#: configdialog/kbfxconfigapp.cpp:424 +msgid "

KBFX Theme %1 prepared

." +msgstr "

KBFX Thema %1 voorbereid

." + +#: configdialog/kbfxconfigapp.cpp:425 +msgid "KBFX Theme Ready" +msgstr "KBFX Thema klaar" + +#: configdialog/main.cpp:33 +msgid "KBFX Configuration Utility" +msgstr "KBFX Configuratie Programma" + +#: configdialog/main.cpp:39 +msgid "kbfxconfigapp" +msgstr "kbfxconfiguratieprogramma" + +#: configdialog/main.cpp:52 +msgid "Install KBFX theme from " +msgstr "Installeer KBFX thema van " + +#: configdialog/main.cpp:53 +msgid "Prepare KBFX theme from folder " +msgstr "Bereid KBFX thema uit map voor " + +#: src/kbfxspinx.cpp:228 +msgid "This is an about box" +msgstr "Dit is een informatievenster" + +#: src/kbfxspinx.cpp:233 +msgid "This is a help box" +msgstr "Dit is een helpvenster" + +#: src/kbfxspinx.cpp:357 +msgid "Remove KBFX from Pannel" +msgstr "Verwijder KBFX uit het paneel" + +#: src/kbfxspinx.cpp:359 +msgid "Reload KBFX" +msgstr "Herlaad KBFX" + +#: src/kbfxspinx.cpp:362 +msgid "Configure KBFX" +msgstr "Stel KBFX in" + +#: src/kbfxspinx.cpp:364 +msgid "Edit Applications Menu" +msgstr "Bewerk toepassingen menu" + +#: src/kbfxbutton.cpp:270 +msgid "" +"Invalid images were dropped!\n" +"Cannot set the KBFX button to use these images!" +msgstr "" +"Ongeldige plaatjes niet gebruikt!\n" +"Kan de KBFX knop niet instellen om deze plaatjes te gebruiken!" + +#: src/kbfxbutton.cpp:272 +msgid "Error setting KBFX button images" +msgstr "Foute instelling KBFX knop plaatjes" + +#: rc.cpp:3 +#, no-c-format +msgid "KBFX Button" +msgstr "KBFX Knop" + +#: rc.cpp:6 +#, no-c-format +msgid "" +"To change KBFX button skin, simply browse to the image you want OR just " +"Drag&Drop the images to their respective place." +msgstr "" +"Om de 'Skin' van de KBFX knop te veranderen: blader naar de afbeelding die " +"je wilt gebruiken OF Drag&Drop de afbeeldingen naar hun respectievelijke " +"plaatsen." + +#: rc.cpp:9 +#, no-c-format +msgid "Livepreview" +msgstr "'Live'voorbeeld" + +#: rc.cpp:12 +#, no-c-format +msgid "" +"Tip! To see live preview, hover or press the preview image with your " +"mouse." +msgstr "" +" Tip! Om het 'live' voorbeeld te zien, mouse-over of druk de " +"voorbeeld afbeelding in met je muis." + +#: rc.cpp:15 +#, no-c-format +msgid "KBFX Button live preview" +msgstr "KBFX Knop 'live' voorbeeld" + +#: rc.cpp:18 +#, no-c-format +msgid "Here you can see the live preview of the KBFX Button." +msgstr "'Live' voorbeeld van de KBFX Knop." + +#: rc.cpp:21 +#, no-c-format +msgid "Resize Panel" +msgstr "Grootte Werkbalk Wijzigen" + +#: rc.cpp:24 +#, no-c-format +msgid "" +"Tip! This button resizes the panel on which the KBFX button is to " +"button's height or width." +msgstr "" +"Tip! Deze knop wijzigt de hoogte van de werkbalk tot de hoogte " +"van de KBFX knop." + +#: rc.cpp:27 configdialog/kbfxconfigdlgbutton.ui.h:141 +#, no-c-format +msgid "Panel Resize is 'ON'" +msgstr "Werkbalk formaat wijzigen 'AAN'" + +#: rc.cpp:32 +#, no-c-format +msgid "

Preview of selected images

" +msgstr "

Voorbeeld van de geselecteerde afbeeldingen

" + +#: rc.cpp:35 +#, no-c-format +msgid "\"PRESSED\" IMAGE SELECTION" +msgstr "\"INGEDRUKT\"AFBEELDING SELECTIE" + +#: rc.cpp:38 +#, no-c-format +msgid "Please select \"pressed\" image." +msgstr "Selecteer \"ingedrukt\"afbeelding." + +#: rc.cpp:41 rc.cpp:65 rc.cpp:89 +#, no-c-format +msgid "image/jpeg image/png image/x-xpm image/gif" +msgstr "afbeelding/jpeg afbeelding/png afbeelding/x-xpm afbeelding/gif" + +#: rc.cpp:44 +#, no-c-format +msgid "The Pressed Button Skin Image" +msgstr "Ingedrukte Knop Skin Afbeelding" + +#: rc.cpp:47 +#, no-c-format +msgid "Here you can choose the Pressed Button Skin Image" +msgstr "Ingedrukte Knop Skin Afbeelding kiezen" + +#: rc.cpp:50 rc.cpp:74 rc.cpp:98 +#, no-c-format +msgid "Preview" +msgstr "Voorbeeld" + +#: rc.cpp:53 +#, no-c-format +msgid "Pressed Button Skin" +msgstr "Ingedrukte Knop Skin" + +#: rc.cpp:56 +#, no-c-format +msgid "Here you can Drag&Drop the Pressed Button Skin Image." +msgstr "Hier kun je Drag&Drop de Ingedrukte Knop Skin Afbeelding." + +#: rc.cpp:59 +#, no-c-format +msgid "\"NORMAL\" IMAGE SELECTION" +msgstr "\"NORMAAL\" AFBEELDINGS KEUZE" + +#: rc.cpp:62 +#, no-c-format +msgid "Please select \"normal\" image." +msgstr "selecteer \"normaal\" afbeelding." + +#: rc.cpp:68 +#, no-c-format +msgid "The Normal Button Skin Image" +msgstr "Normaal Knop Skin Afbeelding" + +#: rc.cpp:71 +#, no-c-format +msgid "Here you can choose the Normal Button Skin Image" +msgstr "Normaal Knop Skin Afbeelding kiezen" + +#: rc.cpp:77 +#, no-c-format +msgid "Normal Button Skin" +msgstr "Normaal knop skin" + +#: rc.cpp:80 +#, no-c-format +msgid "Here you can Drag&Drop the Normal Button Skin Image." +msgstr "Drag&Drop de Normaal Knop Skin Afbeelding." + +#: rc.cpp:83 +#, no-c-format +msgid "\"HOVER\" IMAGE SELECTION" +msgstr "\"MOUSE-OVER\" AFBEELDINGS KEUZE" + +#: rc.cpp:86 +#, no-c-format +msgid "Please select \"hover\" image." +msgstr "selecteer \"mouse-over\" afbeelding." + +#: rc.cpp:92 +#, no-c-format +msgid "The Hover Button Skin Image" +msgstr "De Mouse-Over Knop Skin Afbeelding" + +#: rc.cpp:95 +#, no-c-format +msgid "Here you can choose the Hover Button Skin Image" +msgstr "Mouse-Over Knop Skin Afbeelding kiezen" + +#: rc.cpp:101 +#, no-c-format +msgid "Hover Button Skin" +msgstr "Mouse-over Knop Skin" + +#: rc.cpp:104 +#, no-c-format +msgid "Here you can Drag&Drop the Hover Button Skin Image." +msgstr "Drag&Drop de Mouse-over Knop Skin Afbeelding." + +#: rc.cpp:107 +#, no-c-format +msgid "

Please select KBFX button's images

" +msgstr "

Selecteer afbeelding voor de KBFX knop

" + +#: rc.cpp:110 rc.cpp:179 rc.cpp:296 rc.cpp:404 rc.cpp:440 rc.cpp:461 +#, no-c-format +msgid "KBFX Control Center" +msgstr "KBFX Configuratie Centrum" + +#: rc.cpp:113 +#, no-c-format +msgid "

Layout options

" +msgstr "

Opmaak opties

" + +#: rc.cpp:116 +#, no-c-format +msgid "EXPORT KBFXLAYOUTRC FILE" +msgstr "EXPORT KBFXOPMAAKRC BESTAND" + +#: rc.cpp:119 +#, no-c-format +msgid "Export the kbfxlayoutrc file to a folder" +msgstr "Exporeer het kbfxopmaakrc bestand naar een map" + +#: rc.cpp:122 rc.cpp:473 +#, no-c-format +msgid "Setup fonts for your KBFX" +msgstr "Stel de lettertypen voor je KBFX in" + +#: rc.cpp:125 rc.cpp:476 +#, no-c-format +msgid "Theme that is edited:" +msgstr "Thema wat bewerkt is" + +#: rc.cpp:128 rc.cpp:479 +#, no-c-format +msgid "

default

" +msgstr "

standaard

" + +#: rc.cpp:131 rc.cpp:482 +#, no-c-format +msgid "Please select the theme you want to edit" +msgstr "Selecteer het thema om te bewerken" + +#: rc.cpp:134 +#, no-c-format +msgid "Select the Layout property to change" +msgstr "Selekteer de opmaakeigenschappen om te veranderen" + +#: rc.cpp:137 +#, no-c-format +msgid "Make it 2 panels (Left \"ON\")" +msgstr "Maak 2 panelen (Links \"AAN\")" + +#: rc.cpp:140 +#, no-c-format +msgid "Make it 2 panels (Right \"ON\")" +msgstr "Maak 2 panelen (Rechts \"AAN\")" + +#: rc.cpp:143 +#, no-c-format +msgid "Make it 3 panels" +msgstr "Maak 3 panelen" + +#: rc.cpp:146 +#, no-c-format +msgid "textLabel1" +msgstr "tekstLabel1" + +#: rc.cpp:149 +#, no-c-format +msgid "textLabel2" +msgstr "tekstLabel2" + +#: rc.cpp:152 +#, no-c-format +msgid "textLabel3" +msgstr "tekstLabel3" + +#: rc.cpp:155 +#, no-c-format +msgid "textLabel4" +msgstr "tekstLabel4" + +#: rc.cpp:158 +#, no-c-format +msgid "checkBox1" +msgstr "Keuzevakje1" + +#: rc.cpp:161 +#, no-c-format +msgid "textLabel5" +msgstr "tekstLabel5" + +#: rc.cpp:164 +#, no-c-format +msgid "textLabel6" +msgstr "tekstLabel6" + +#: rc.cpp:167 +#, no-c-format +msgid "textLabel7" +msgstr "tekstLabel7" + +#: rc.cpp:170 +#, no-c-format +msgid "textLabel8" +msgstr "tekstLabel8" + +#: rc.cpp:173 +#, no-c-format +msgid "checkBox2" +msgstr "Keuzevakje2" + +#: rc.cpp:176 +#, no-c-format +msgid "C&ustom" +msgstr "&Aanpassen" + +#: rc.cpp:182 +#, no-c-format +msgid "

Plugins options

" +msgstr "

Voorbeeld van de geselecteerde afbeeldingen

" + +#: rc.cpp:185 +#, no-c-format +msgid "Select KBFX Panel" +msgstr "Kies KBFX paneel" + +#: rc.cpp:188 rc.cpp:191 +#, no-c-format +msgid "Plugin to configure" +msgstr "Plugin om in te stellen" + +#: rc.cpp:194 +#, no-c-format +msgid "Please select the panel you want to configure: " +msgstr "Selecteer het paneel om te bewerken: " + +#: rc.cpp:197 +#, no-c-format +msgid "&Available Plugins:" +msgstr "Beschikb&are plugins:" + +#: rc.cpp:200 +#, no-c-format +msgid "&Enabled Plugins:" +msgstr "Plugins di&e aanstaan:" + +#: rc.cpp:203 +#, no-c-format +msgid "&Configure Plugin" +msgstr "&Bewerk plugin" + +#: rc.cpp:206 +#, no-c-format +msgid "Alt+C" +msgstr "Alt+C" + +#: rc.cpp:209 rc.cpp:212 +#, no-c-format +msgid "Configure the selected plugin" +msgstr "Bewerk de geselecteerde plugin" + +#: rc.cpp:215 +#, no-c-format +msgid "&Plugin Information" +msgstr "&Plugin informatie" + +#: rc.cpp:218 +#, no-c-format +msgid "Alt+P" +msgstr "Alt+P" + +#: rc.cpp:221 rc.cpp:224 +#, no-c-format +msgid "Information about the selected plugin" +msgstr "Informatie over de geselecteerde plugin" + +#: rc.cpp:227 +#, no-c-format +msgid "KBFX Configurator Application" +msgstr "KBFX Configuratie Programma" + +#: rc.cpp:233 +#, no-c-format +msgid "KBFX Themes" +msgstr "KBFX Thema's" + +#: rc.cpp:245 +#, no-c-format +msgid "Search Engine" +msgstr "Zoekmachine" + +#: rc.cpp:251 +#, no-c-format +msgid "About KBFX" +msgstr "Info over KBFX" + +#: rc.cpp:254 +#, no-c-format +msgid "" +"




If you want you can check the latest " +"news for KBFX from here:
KBFX News" +msgstr "" +"




Als je het laatste nieuws van KBFX wilt " +"zien van hier:
KBFX Nieuws

" + +#: rc.cpp:260 +#, no-c-format +msgid "Alt+H" +msgstr "Alt+H" + +#: rc.cpp:263 +#, no-c-format +msgid "Open Help Documentation" +msgstr "Help Documentatie Openen" + +#: rc.cpp:266 +#, no-c-format +msgid "&Default" +msgstr "Stan&daard" + +#: rc.cpp:269 +#, no-c-format +msgid "Alt+D" +msgstr "Alt+D" + +#: rc.cpp:272 +#, no-c-format +msgid "Apply the default configuration for this section only" +msgstr "Standaard configuratie alleen voor deze sectie toepassen" + +#: rc.cpp:278 +#, no-c-format +msgid "Alt+A" +msgstr "Alt+A" + +#: rc.cpp:281 +#, no-c-format +msgid "Save the configuration and Apply it" +msgstr "Sla de configuratie op en pas deze toe" + +#: rc.cpp:287 +#, no-c-format +msgid "Alt+X" +msgstr "Alt+X" + +#: rc.cpp:290 +#, no-c-format +msgid "Exit the configuration without saving" +msgstr "Configuratie afsluiten zonder op te slaan" + +#: rc.cpp:293 +#, no-c-format +msgid "Kbfx start button
" +msgstr "KBFX start knop
" + +#: rc.cpp:299 +#, no-c-format +msgid "Select default folder" +msgstr "Selecteer de standaard map" + +#: rc.cpp:302 +#, no-c-format +msgid "Please select the target folder where your themes are." +msgstr "selecteer de map waarin je thema's zijn." + +#: rc.cpp:305 +#, no-c-format +msgid "SpixBar" +msgstr "SpixBalk" + +#: rc.cpp:308 +#, no-c-format +msgid "Installed Themes" +msgstr "Geïnstalleerde Thema's" + +#: rc.cpp:311 +#, no-c-format +msgid "Here are listed all the installed KBFX Themes" +msgstr "Alle geïnstalleerde KBFX Thema's" + +#: rc.cpp:314 +#, no-c-format +msgid "Selected Theme Preview" +msgstr "Geselecteerd Thema Voorbeeld" + +#: rc.cpp:317 +#, no-c-format +msgid "Delete Selected" +msgstr "Selectie verwijderen" + +#: rc.cpp:320 +#, no-c-format +msgid "Delete the Selected Theme" +msgstr "Geselecteerd Thema Verwijderen" + +#: rc.cpp:323 +#, no-c-format +msgid "" +"Pressing the button will delete the currently selected theme.
Warning!" +" You cannot delete the installed system wide themes!" +msgstr "" +"Als je de knop indrukt wordt het huidig geselecteerde thema verwijdert. " +"
Waarschuwing! U kunt de systeem breed geïnstalleerde thema's " +"niet verwijderen!" + +#: rc.cpp:326 +#, no-c-format +msgid "Get Themes" +msgstr "Thema's Ophalen" + +#: rc.cpp:329 +#, no-c-format +msgid "Get More Themes from the Internet" +msgstr "Meer Thema's van het Internet Ophalen" + +#: rc.cpp:332 +#, no-c-format +msgid "" +"Pressing the button will launch konqueror and go to the KBFX Themes Section " +"on www.kde-look.org" +msgstr "" +"Het indrukken van de knop start konqueror op, die vervolgens naar de KBFX " +"Thema Sectie van www.kde-look.org gaat" + +#: rc.cpp:335 +#, no-c-format +msgid "Install Theme" +msgstr "Installeer Thema" + +#: rc.cpp:338 +#, no-c-format +msgid "Install New Theme from KBFX Theme Package" +msgstr "Installeer Nieuw Thema van KBFX Thema Pakket" + +#: rc.cpp:341 +#, no-c-format +msgid "" +"Pressing the button will offer a dialog where you can choose KBFX Theme " +"Package to install in your home folder" +msgstr "" +"Wanneer de knop wordt ingedrukt zal er een dialoogvenster verschijnen waarin " +"je het KBFX Thema Pakket kunt kiezen om te installeren in je home map" + +#: rc.cpp:344 +#, no-c-format +msgid "Convert Theme" +msgstr "Converteer thema " + +#: rc.cpp:347 +#, no-c-format +msgid "Convert a theme to the new format" +msgstr "Converteer een thema naar het nieuwe formaat" + +#: rc.cpp:350 +#, no-c-format +msgid "" +"Pressing the button will open dialog for converting old themes to the new " +"specifications" +msgstr "" +"Wanneer de knop wordt ingedrukt zal er een dialoogvenster verschijnen waarin " +"je oude thema's naar de nieuwe specificaties kunt converteren" + +#: rc.cpp:353 +#, no-c-format +msgid "Personal Image" +msgstr "Persoonlijke Afbeelding" + +#: rc.cpp:356 +#, no-c-format +msgid "Theme's Default" +msgstr "Thema s Standaard" + +#: rc.cpp:359 +#, no-c-format +msgid "Set the Theme's Default Personal Image" +msgstr "Instellen van Thema s Standaard Persoonlijke Afbeelding" + +#: rc.cpp:362 +#, no-c-format +msgid "" +"Pressing the button will delete the personal image you have selected and " +"install the theme's default personal image" +msgstr "" +"Wanneer de knop wordt ingedrukt zal de persoonlijke afbeelding die je hebt " +"gekozen worden verwijderd, en zal de afbeelding van het standaard thema " +"worden geinstalleerd." + +#: rc.cpp:365 +#, no-c-format +msgid "Maxsize 48 x 48" +msgstr "Maximum grootte 48 x 48" + +#: rc.cpp:368 +#, no-c-format +msgid "Select New image" +msgstr "Kies Nieuwe afbeelding" + +#: rc.cpp:371 +#, no-c-format +msgid "Select a Personal Image" +msgstr "Kies een Persoonlijke Afbeelding" + +#: rc.cpp:374 +#, no-c-format +msgid "Pressing the button will open a dialog to select your personal image" +msgstr "" +"Wanneer de knop wordt ingedrukt zal er een dialoogvenster verschijnen waarin " +"je een persoonlijke afbeelding kunt kiezen" + +#: rc.cpp:377 +#, no-c-format +msgid "This is your personal image displayed at the KBFX menu." +msgstr "Dit is je persoonlijke afbeelding getoond in het KBFX menu." + +#: rc.cpp:380 +#, no-c-format +msgid "Misc Options" +msgstr "Diverse opties" + +#: rc.cpp:383 +#, no-c-format +msgid "Watch System Installs" +msgstr "Systeem installaties bekijken" + +#: rc.cpp:386 rc.cpp:389 +#, no-c-format +msgid "Watch for applications installs and reload KBFX if any occurs" +msgstr "Kijk naar programma installaties en herlaad KBFX als die zich voordoen" + +#: rc.cpp:392 rc.cpp:395 +#, no-c-format +msgid "Show Old Themes" +msgstr "Laat oude thema's zien" + +#: rc.cpp:398 +#, no-c-format +msgid "

Please select theme folder

" +msgstr "

Selecteer de thema map

" + +#: rc.cpp:401 +#, no-c-format +msgid "

Installed themes

" +msgstr "

Geinstalleerde thema's

" + +#: rc.cpp:407 +#, no-c-format +msgid "

Tooltip ON or OFF

" +msgstr "

Hulpballon AAN of UIT

" + +#: rc.cpp:410 +#, no-c-format +msgid "Turn off or on the tooltip" +msgstr "Zet de hulpballon uit of aan" + +#: rc.cpp:413 +#, no-c-format +msgid "" +"Turn your tooltip off or on.
You can see the current status of the " +"tooltip to the right." +msgstr "" +"Zet de hulpballon uit of aan
U kunt de huidige status van de hulpballon " +"aan de rechterkant zien." + +#: rc.cpp:416 +#, no-c-format +msgid "Turn the tooltip \"OFF\"" +msgstr "Zet hulpballon animatie \"UIT\"" + +#: rc.cpp:419 +#, no-c-format +msgid "Tooltip Text" +msgstr "Hulpballon Tekst" + +#: rc.cpp:422 +#, no-c-format +msgid "Type the text which you want to be displayed in the tooltip." +msgstr "Type de tekst in die moet worden getoond in de hulpballon" + +#: rc.cpp:425 +#, no-c-format +msgid "

Tooltip personal text

" +msgstr "

Hulpballon met persoonlijke tekst

" + +#: rc.cpp:428 +#, no-c-format +msgid "Tooltip animation" +msgstr "Hulpballon animatie" + +#: rc.cpp:431 +#, no-c-format +msgid "" +"Turn your tooltip animation off or on.
You can see the current status of " +"the tooltip to the right." +msgstr "" +"Zet hulpballon animatie uit of aan.
U kunt de huidige status van de " +"hulpballon aan de rechterkant zien." + +#: rc.cpp:434 +#, no-c-format +msgid "Turn the animation \"ON\"" +msgstr "Animatie \"AAN\"" + +#: rc.cpp:437 +#, no-c-format +msgid "

Tooltip animation ON or OFF

" +msgstr "

Hulpballon animatie AAN of UIT

" + +#: rc.cpp:443 +#, no-c-format +msgid "

Menu type

" +msgstr "

Menu type

" + +#: rc.cpp:446 +#, no-c-format +msgid "Please select the menu style" +msgstr "Kies de menu stijl" + +#: rc.cpp:449 rc.cpp:455 +#, no-c-format +msgid "KBFX MENU" +msgstr "KBFX MENU" + +#: rc.cpp:452 rc.cpp:458 +#, no-c-format +msgid "KDE MENU" +msgstr "KDE MENU" + +#: rc.cpp:464 +#, no-c-format +msgid "

Font options

" +msgstr "

Lettertype opties

" + +#: rc.cpp:467 +#, no-c-format +msgid "EXPORT KBFXFONTRC FILE" +msgstr "EXPORT KBFXFONTRC BESTAND" + +#: rc.cpp:470 +#, no-c-format +msgid "Export the kbfxfontrc file to a folder" +msgstr "Exporeer het kbfxfontrc bestand naar een map" + +#: rc.cpp:485 +#, no-c-format +msgid "Bold fonts on hover" +msgstr "Vette letters bij muisover" + +#: rc.cpp:488 rc.cpp:491 +#, no-c-format +msgid "Make fonts bolder when you hover the mouse over an item" +msgstr "Maak de letters vetter als je met de muis over een item gaat" + +#: rc.cpp:494 +#, no-c-format +msgid "Application \"LINE\":" +msgstr "Toepassing \"REGEL\":" + +#: rc.cpp:497 +#, no-c-format +msgid "Horizontal line color in the application area." +msgstr "Horizontale regel kleur in de toepassing." + +#: rc.cpp:500 +#, no-c-format +msgid "Application text :" +msgstr "Programma tekst :" + +#: rc.cpp:503 +#, no-c-format +msgid "Select the color of the \"application\" in the menu." +msgstr "Selecteer de kleur van het \"programma\" in het menu." + +#: rc.cpp:506 +#, no-c-format +msgid "Comment text:" +msgstr "Toelichtings tekst :" + +#: rc.cpp:509 +#, no-c-format +msgid "Color of the \"comments\" in the menu." +msgstr "Kleur van de commentaren in het menu." + +#: rc.cpp:512 +#, no-c-format +msgid "Name display:" +msgstr "Naam venster :" + +#: rc.cpp:515 rc.cpp:527 rc.cpp:533 +#, no-c-format +msgid "The color of your login name in the menu." +msgstr "De kleur van je login naam in het menu." + +#: rc.cpp:518 +#, no-c-format +msgid "Category text:" +msgstr "Categorie tekst :" + +#: rc.cpp:521 +#, no-c-format +msgid "Font color of the categoris in the menu." +msgstr "Lettertype kleur van de categorien in het menu." + +#: rc.cpp:524 +#, no-c-format +msgid "Separator:" +msgstr "Scheidingslijn :" + +#: rc.cpp:530 +#, no-c-format +msgid "Plugin:" +msgstr "Plugin:" + +#: rc.cpp:536 +#, no-c-format +msgid "Select font for the application's text" +msgstr "Selecteer het lettertype van de programma tekst" + +#: rc.cpp:539 +#, no-c-format +msgid "Select font for the comment's text" +msgstr "Kies het lettertype voor de tekst van het commentaar" + +#: rc.cpp:542 +#, no-c-format +msgid "Select font for the username's text" +msgstr "Kies het lettertype voor de gebruikersnaam" + +#: rc.cpp:545 +#, no-c-format +msgid "Select font for the category's text" +msgstr "Kies het lettertype voor categorie tekst" + +#: rc.cpp:548 +#, no-c-format +msgid "Select font for the separator's text" +msgstr "Kies het lettertype voor scheidingslijn tekst" + +#: rc.cpp:551 +#, no-c-format +msgid "Select font for the plugins' text" +msgstr "Kies het lettertype voor de plugins tekst" + +#: rc.cpp:554 +#, no-c-format +msgid "Form1" +msgstr "Formulier1" + +#: rc.cpp:557 +#, no-c-format +msgid "

People behind KBFX

" +msgstr "

Mensen achter KBFX

" + +#: rc.cpp:560 +#, no-c-format +msgid "You are running: KBFX 0493" +msgstr "U draait: KBFX 0493" + +#: rc.cpp:563 +#, no-c-format +msgid "" +"Here are the people behind the KBFX application.\n" +"We would like to thank all people who have helped with KBFX or have donated " +"money to our project!\n" +"THANKS A LOT ALL OF YOU OUT THERE!!!" +msgstr "" +"Hier zijn de mensen achter het KBFX programma.\n" +"We willen alle mensen bedanken die hebben geholpen met KBFX en degenen die " +"geld hebben gedoneerd voor ons project!\n" +"BEDANKT ALLEMAAL!!!" + +#: rc.cpp:568 +#, no-c-format +msgid "" +"Name: Siraj Razick

Country: Sri " +"Lanka

KBFX: Author, Maintainer, Developer, Project " +"Admin

Email: siraj(a)mail.kbfx.org" +msgstr "" +" Naam Siraj Razick

Land: Sri " +"Lanka

KBFX Auteur Onderhouder Ontwikkelaar Project " +"Admin

E-mail siraj(a)mail.kbfx.org" + +#: rc.cpp:571 +#, no-c-format +msgid "" +"Tip! Hover over the contact images to see each personal contact " +"information." +msgstr "" +"Tip!Beweeg de muis-pijl over de contact afbeeldingen om de persoonlijke contact " +"informatie zichtbaar te maken." + +#: rc.cpp:574 +#, no-c-format +msgid "SPONSORS!" +msgstr "DONATEURS!" + +#: rc.cpp:577 +#, no-c-format +msgid "" +"We would like to thank swedish computer company PC Agenten for " +"sponsoring us with a server and bandwidth." +msgstr "" +"We willen de Zweedse computer firma PC Agenten bedanken voor het " +"verstrekken van een server en bandbreedte." + +#: rc.cpp:580 +#, no-c-format +msgid "" +"

HTTP://WWW." +"PCAGENTEN.SE

" +msgstr "" +"

HTTP://WWW. " +"PCAGENTEN.SE

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:59 +msgid "" +"

Invalid user themes folder!

Will use " +"default user themes folder.

" +msgstr "" +"

Onbruikbare gebruikers thema map!

Standaard " +"gebruikers thema map wordt gebruikt

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:61 +msgid "Error loading themes" +msgstr "Fout! Thema niet geladen" + +#: configdialog/kbfxconfigdlgthemes.ui.h:164 +msgid "" +"

Are you sure you want to uninstall the KBFX theme %" +"1?

" +msgstr "" +"

Weet U zeker dat U het KBFX thema wilt verwijderen % " +"1?

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:165 +msgid "Uninstall KBFX theme" +msgstr "Verwijder KBFX thema " + +#: configdialog/kbfxconfigdlgthemes.ui.h:166 +msgid "Uninstall" +msgstr "Verwijder" + +#: configdialog/kbfxconfigdlgthemes.ui.h:179 +msgid "" +"

Could not uninstall this KBFX theme.

You may not have sufficient permissions to delete the folder " +"%1.

" +msgstr "" +"

Kon de installatie van dit KBFX thema niet ongedaan maken.

Misschien heeft U niet voldoende rechten om de map te verwijderen " +"%1.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:192 +msgid "KBFX theme packages (*.tar, *.tar.bz2, *.tar.gz, *.kbfxtheme)" +msgstr "KBFX thema pakketten (*.tar, *.tar.bz2, *tar.gz, *.kbfxtheme)" + +#: configdialog/kbfxconfigdlgthemes.ui.h:196 +msgid "Select KBFX theme package to install" +msgstr "Kies het KBFX thema pakket om te installeren" + +#: configdialog/kbfxconfigdlgthemes.ui.h:212 +msgid "

Could not read this KBFX theme package.

" +msgstr "

Kon dit KBFX thema pakket niet lezen.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:239 +msgid "Select personal image" +msgstr "Kies een persoonlijke afbeelding" + +#: configdialog/kbfxconfigdlgthemes.ui.h:250 +msgid "" +"

Image cannot be used as a personal image!

Will use default personal image.

" +msgstr "" +"

Afbeelding kan niet als persoonlijke afbeelding gebruikt worden!

De standaard persoonlijke afbeelding wordt gebruikt.

" + +#: configdialog/kbfxconfigdlgthemes.ui.h:252 +#: configdialog/kbfxconfigdlgbutton.ui.h:65 +#: configdialog/kbfxconfigdlgbutton.ui.h:86 +#: configdialog/kbfxconfigdlgbutton.ui.h:107 +msgid "Error loading image" +msgstr "Fout! Afbeelding niet geladen" + +#: configdialog/kbfxconfigdlgthemes.ui.h:284 +#: configdialog/kbfxconfigdlgmain.ui.h:34 +msgid "

Not implemented yet.

" +msgstr "

Nog niet geimplementeerd

" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:23 +msgid "Turn the animation 'OFF'" +msgstr "Animatie 'UIT'" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:30 +msgid "Turn the animation 'ON'" +msgstr "Animatie 'AAN'" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:53 +msgid "Turn the tooltip 'OFF'" +msgstr "Zet hulpballon 'UIT'" + +#: configdialog/kbfxconfigdlgtooltip.ui.h:60 +msgid "Turn the tooltip 'ON'" +msgstr "Zet hulpballon 'AAN'" + +#: configdialog/kbfxconfigdlgfonts-old.ui.h:122 +msgid "Select folder to export kbfxfontrc file" +msgstr "Kies de map waar het kbfxfontrc bestand naartoe geexporteerd moet worden" + +#: configdialog/kbfxconfigdlgfonts-old.ui.h:151 +msgid "" +"

The Font configuration of the KBFX Theme %1 has been exported successfully!

" +msgstr "" +"

Lettertype instelling voor het KBFX thema %1is met succes geexporteerd!

" + +#: configdialog/kbfxconfigdlgfonts-old.ui.h:152 +msgid "KBFX Font Export Ready" +msgstr "KBFX lettertype export gereed" + +#: configdialog/kbfxconfigdlgabout.ui.h:23 +msgid "" +"Name: Mensur Zahirovic (Nookie)

Country: Sweden

KBFX: co-author, Q/A, system design, " +"web designer, bug hunter, project administror

Email: " +"nookie@mail.kbfx.org" +msgstr "" +" Naam Mensur Zahirovic (Nookie)

Land: Sweden

KBFX co auteur, Q/A, systeem ontwerp, " +"web designer, bug hunter, project administrator

E-mail " +"nookie@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:32 +msgid "" +"Name: Siraj Razick

Country: Sri " +"Lanka

KBFX: author, maintainer, developer, project " +"administror

Email: siraj@mail.kbfx.org" +msgstr "" +" Naam Siraj Razick

Land: Sri " +"Lanka

KBFX auteur onderhouder ontwikkelaar project " +"administrator

E-mail siraj@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:41 +msgid "" +"Name: Nathanael Dracor Gogniat

Country: Switzerland

KBFX: project technical writer, " +"documentation manager, co-author

Email: " +"nathanael@mail.kbfx.org" +msgstr "" +" Naam Nathanael Dracor Gogniat

Land: Switzerland

KBFX technisch project schrijver, " +"documentatie manager, co auteur

E-mail " +"nathanael@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:50 +msgid "" +"Name: PhobosK

Country: " +"Bulgaria

KBFX: package & release manager, Q/A, bug " +"hunter, mandriva packages, project administrator, developer Qt/C+" +"+

Email: phobosk@mail.kbfx.org" +msgstr "" +" Naam PhobosK

Land: " +"Bulgarije

KBFX pakket en release manager, Q/A, bug " +"hunter, mandriva pakketten, project administrator, ontwikkelaar Qt/C+" +"+

E-mail phobosk@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:59 +msgid "" +"Name: Johnny Henry Saenz Acuna (scarebyte)" +"

Country: Peru

KBFX: " +"developer Qt4/C++

Email: saenzac@mail.kbfx.org" +msgstr "" +" Naam Johnny Henry Saenz Acuna (scarebyte)" +"

Country: Peru

KBFX: " +"ontwikkelaar Qt4/C++

Email: saenzac@mail.kbfx.org" + +#: configdialog/kbfxconfigdlgabout.ui.h:68 +msgid "" +"Name: Christoffer Brodd-Reijer (Ephracis)" +"

Country: Sweden

KBFX: " +"library developer for Raptor

Email: ephracis@mail." +"kbfx.org" +msgstr "" +" NaamChristoffer Brodd-Reijer (Ephracis)" +"

Country: Sweden

KBFX: " +"bibliotheek ontwikkelaar voor Raptor

Email: ephracis@mail." +"kbfx.org" + +#: configdialog/kbfxconfigdlgbutton.ui.h:63 +msgid "" +"

Image cannot be used as a pressed button skin!

Will use default pressed button skin.

" +msgstr "" +"

Afbeelding kan niet gebruikt worden als ingedrukte knop skin!

De standaard ingedrukte knop skin wordt gebruikt.

" + +#: configdialog/kbfxconfigdlgbutton.ui.h:84 +msgid "" +"

Image cannot be used as a normal button skin!

Will use default normal button skin.

" +msgstr "" +"

Afbeelding kan niet gebruikt worden als normale knop skin!

De standaard normale knop skin wordt gebruikt.

" + +#: configdialog/kbfxconfigdlgbutton.ui.h:105 +msgid "" +"

Image cannot be used as a hover button skin!

Will use default hover button skin.

" +msgstr "" +"

Afbeelding kan niet gebruikt worden als muisover knop skin!

De standaard muisoverknop skin word gebruikt.

" + +#: configdialog/kbfxconfigdlgbutton.ui.h:147 +msgid "Panel Resize is 'OFF'" +msgstr "Werkbalk Grootte wijzigen 'UIT'" + +#: configdialog/kbfxconfigdlglayout.ui.h:16 +msgid "User Properties" +msgstr "Gebruikers eigenschappen" + +#: configdialog/kbfxconfigdlglayout.ui.h:17 +msgid "* Top Bar Properties" +msgstr "* Bovenbalk eigenschappen" + +#: configdialog/kbfxconfigdlglayout.ui.h:18 +msgid "* Bottom Bar Properties" +msgstr "* Bodembalk eigenschappen" + +#: configdialog/kbfxconfigdlglayout.ui.h:20 +msgid "* List Box Properties" +msgstr "* Eigenschappen van lijstveld" + +#: configdialog/kbfxconfigdlglayout.ui.h:21 +msgid "Search Box Properties" +msgstr "Eigenschappen van zoekveld" + +#: configdialog/kbfxconfigdlglayout.ui.h:22 +msgid "* Item Properties" +msgstr "* Item eigenschappen" + +#: configdialog/kbfxconfigdlglayout.ui.h:24 +msgid "* Main Menu Properties" +msgstr "* Hoofdmenu eigenschappen" + +#: configdialog/kbfxconfigdlglayout.ui.h:25 +msgid "Water Effect Properties" +msgstr "Water effect eigenschappen" + +#: configdialog/kbfxconfigdlglayout.ui.h:209 +msgid "Face Position X" +msgstr "Gezichts positie X" + +#: configdialog/kbfxconfigdlglayout.ui.h:210 +msgid "Face Position Y" +msgstr "Gezichts positie Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:211 +msgid "User Name Position X" +msgstr "Gebruikersnaam positie X" + +#: configdialog/kbfxconfigdlglayout.ui.h:212 +msgid "User Name Position Y" +msgstr "Gebruikersnaam positie Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:213 +msgid "Face Box Position X" +msgstr "Positie X van vensterweergave" + +#: configdialog/kbfxconfigdlglayout.ui.h:214 +msgid "Face Box Position Y" +msgstr "Positie Y van vensterweergave" + +#: configdialog/kbfxconfigdlglayout.ui.h:215 +msgid "Face Box Height" +msgstr "Hoogte van vensterweergave" + +#: configdialog/kbfxconfigdlglayout.ui.h:216 +msgid "Face Box Width" +msgstr "Breedte van vensterweergave" + +#: configdialog/kbfxconfigdlglayout.ui.h:217 +msgid "Hide User Name" +msgstr "Verberg gebruikersnaam" + +#: configdialog/kbfxconfigdlglayout.ui.h:235 +msgid "* Top Bar Height" +msgstr "* Hoogte van de bovenbalk" + +#: configdialog/kbfxconfigdlglayout.ui.h:241 +msgid "Top Bar Width" +msgstr "Breedte van de bovenbalk" + +#: configdialog/kbfxconfigdlglayout.ui.h:266 +msgid "* Bottom Bar Height" +msgstr "*Hoogte van de onderbalk" + +#: configdialog/kbfxconfigdlglayout.ui.h:272 +msgid "Bottom Bar Width" +msgstr "Breedte van de onderbalk" + +#: configdialog/kbfxconfigdlglayout.ui.h:322 +msgid "* List Box Position X" +msgstr "Positie X van lijstweergave" + +#: configdialog/kbfxconfigdlglayout.ui.h:323 +msgid "* List Box Position Y" +msgstr "Positie Y van lijstweergave" + +#: configdialog/kbfxconfigdlglayout.ui.h:326 +msgid "List Box Height" +msgstr "Hoogte van lijstweergave" + +#: configdialog/kbfxconfigdlglayout.ui.h:327 +msgid "* List Box Width" +msgstr "Breedte van lijstweergave" + +#: configdialog/kbfxconfigdlglayout.ui.h:345 +msgid "Search Box Position X" +msgstr "Positie X van zoekveld" + +#: configdialog/kbfxconfigdlglayout.ui.h:346 +msgid "Search Box Position Y" +msgstr "Positie Y van zoekveld" + +#: configdialog/kbfxconfigdlglayout.ui.h:349 +msgid "Search Box Height" +msgstr "Hoogte van zoekveld" + +#: configdialog/kbfxconfigdlglayout.ui.h:350 +msgid "Search Box Width" +msgstr "Breedte van zoekveld" + +#: configdialog/kbfxconfigdlglayout.ui.h:368 +msgid "* Item Position X" +msgstr "* Item positie X" + +#: configdialog/kbfxconfigdlglayout.ui.h:369 +msgid "* Item Position Y" +msgstr "* Item positie Y" + +#: configdialog/kbfxconfigdlglayout.ui.h:370 +msgid "Icon Size in Item" +msgstr "Icoon formaat in item" + +#: configdialog/kbfxconfigdlglayout.ui.h:372 +msgid "Item Height" +msgstr "Item hoogte" + +#: configdialog/kbfxconfigdlglayout.ui.h:373 +msgid "* Item Width" +msgstr "* Item breedte" + +#: configdialog/kbfxconfigdlglayout.ui.h:374 +msgid "Comment Margin in Item" +msgstr "Ruimte voor commentaar in item" + +#: configdialog/kbfxconfigdlglayout.ui.h:376 +msgid "No Comments in Item" +msgstr "Geen commentaar in item" + +#: configdialog/kbfxconfigdlglayout.ui.h:417 +msgid "* Main Menu Height" +msgstr "* Hoogte hoofdmenu" + +#: configdialog/kbfxconfigdlglayout.ui.h:421 +msgid "* Main Menu Width" +msgstr "* Breedte hoofdmenu" + +#: configdialog/kbfxconfigdlglayout.ui.h:425 +msgid "Contracted Menues" +msgstr "Gecontracteerde menu's" + +#: configdialog/kbfxconfigdlglayout.ui.h:441 +msgid "Water Effect Frame Rate" +msgstr "Framesnelheid van watereffect" + +#: configdialog/kbfxconfigdlglayout.ui.h:450 +msgid "Enabled Water Effect" +msgstr "Water effect aan" + +#: configdialog/kbfxconfigdlglayout.ui.h:495 +msgid "Select folder to export kbfxlayoutrc file" +msgstr "Kies een map om het kbfxopmaak bestand naartoe te exporteren" + +#: configdialog/kbfxconfigdlglayout.ui.h:580 +msgid "" +"

The Layout configuration of the KBFX Theme %1 has been exported successfully!

" +msgstr "" +"

De opmaak instelling voor het KBFX thema opslaan %1?is met succes geexporteerd!

" + +#: configdialog/kbfxconfigdlglayout.ui.h:581 +msgid "KBFX Layout Export Ready" +msgstr "KBFX opmaak exporteren gereed" + +#: configdialog/kbfxconfigdlglayout.ui.h:648 +msgid "" +"

The Layout configuration of the KBFX Theme %1 is ready!

Be sure to click the Apply button in order the changes to become active!

" +msgstr "" +"

De opmaak instelling van het KBFX thema%1 " +"is gereed!

Vergeet niet om de toepassen knop te gebruiken om de wijzigingen te aktiveren!

" + +#: configdialog/kbfxconfigdlglayout.ui.h:649 +msgid "KBFX Layout Ready" +msgstr "KBFX opmaak gereed" + +#: configdialog/kbfxconfigdlglayout.ui.h:655 +msgid "" +"

KBFX will calculate the necessary values using the present " +"values for:

* Main Menu Height and " +"* Main Menu Width
* Bottom Bar Height " +"and * Top Bar Height

So be sure " +"that you have entered their values as you desire!

NOTE: Have in mind that the Layout of the " +"theme also depends on the sizes of the images! So if the theme does not look " +"like as you desire either change the images' sizes to smaller width OR " +"change * Main Menu Width to higher value!

" +msgstr "" +"

KBFX zal door gebruik te maken van de huidige waarden, de noodzakelijke " +"waarden voor de:

* hoogte van het Hoofdmenu en de " +"*breedte van het Hoofdmenu
hoogte van de Onderbalk " +"en van de hoogte van de Bovenbalk

Wees er dus " +"zeker van de waarden die je wenst te hebben ingevuld!

LET OP:Houd in gedachten dat de opmaakvan het thema " +"ook afhangt van de afmetingen van de afbeeldingen! Dus als het thema er niet uitziet " +"zoals je wilt, verklein dan de afmetingen van de afbeeldingen, OF " +"vergroot de breedte van het Hoofdmenu

" + +#: configdialog/kbfxconfigdlglayout.ui.h:661 +msgid "Prepare Layout for the KBFX theme" +msgstr "Opmaak voor het KBFX thema voorbereiden" + +#: configdialog/kbfxconfigdlglayout.ui.h:662 +msgid "Prepare" +msgstr "Voorbereiden" + +#: configdialog/kbfxconfigdlgplugins.ui.h:15 +msgid "Left Panel" +msgstr "Linker paneel" + +#: configdialog/kbfxconfigdlgplugins.ui.h:16 +msgid "Right Panel" +msgstr "Rechter paneel" + +#: configdialog/kbfxconfigdlgplugins.ui.h:79 +#: configdialog/kbfxconfigdlgplugins.ui.h:85 +msgid "

Not Implemented yet.

" +msgstr "

Nog niet geimplementeerd.

" + diff --git a/skin/raster/2panels/CMakeLists.txt b/skin/raster/2panels/CMakeLists.txt new file mode 100644 index 0000000..107e44d --- /dev/null +++ b/skin/raster/2panels/CMakeLists.txt @@ -0,0 +1,4 @@ +FILE(GLOB PNGFILES *.png kbfxlayoutrc kbfxfontrc version-2 ) + +INSTALL(FILES ${PNGFILES} + DESTINATION ${DATA_INSTALL_DIR}/kbfx/skins/2panels) diff --git a/skin/raster/2panels/appfind.png b/skin/raster/2panels/appfind.png new file mode 100644 index 0000000000000000000000000000000000000000..2919054f2d6674ca552788f3e27b0fc0521e1bfe GIT binary patch literal 5136 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 K=d#Wzp$P!@Q14d& literal 0 HcmV?d00001 diff --git a/skin/raster/2panels/bg_sidebar.png b/skin/raster/2panels/bg_sidebar.png new file mode 100644 index 0000000000000000000000000000000000000000..d10c7f4b11097205ca334b99f4dddb48bcc5c980 GIT binary patch literal 2842 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 literal 0 HcmV?d00001 diff --git a/skin/raster/2panels/botbg.png b/skin/raster/2panels/botbg.png new file mode 100644 index 0000000000000000000000000000000000000000..7951a91d2fa9dcb4eddd03576bd820298a7742e2 GIT binary patch literal 9119 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 literal 0 HcmV?d00001 diff --git a/skin/raster/2panels/butterfly.png b/skin/raster/2panels/butterfly.png new file mode 100644 index 0000000000000000000000000000000000000000..70fb383f092b68e9eb3ca80581baf3e84ef79137 GIT binary patch literal 29563 zcmce-iC+`f7xzDt$uil0BpqUVYc}o8{x76E*o}7V0Sj) zZfZQi(u`9!m^xm>n8g1EEI#&+i- z3#^bJXC%ZOiSR-qeUZozb8mAO7k93C=iiv*p}f=i{;ub|9^w5r!hSc#{mg#yuYW;fE`oh}v z>uc8+HmqOYpxXTHccqH0>ua}`*6-R{TDw(KqpE4DRjyy(vej%`&DNpX+M+UhRf|g1 zQLAdHHT&9*hFWb)LrY6TM@NIUqorf()^3%`Y<;z=?pjr!rnbAb*6hzU)Lv|8=xb`| z(>9%LXt>(aJlfH6wWVe9;?}~xty}w4svd3Ai|(y|_HCZ*Zg_FArMsh}yQ90iqp$CW z?!Jz`bM1W>`?_!S^mMdLc65w&bWC=4TFyZo?jGsx9_wo`e{Z&tzV5M$eHTai zMn*1PymfK7qvK)s|2jYH?w;)Ke%RMNd9h=%ujgK0pZUm(KC|_`=1_cXuFgJi9FgvfI`xiVI?KymT7bmL5KK@kul|B6QW7$_ubzIvg$i3PUfBMLc1HtQGKDcuF=*=I5 z%N`XNetLF%`RJyUBjHjFW)Nb;ySAPVDNfymP%~?#i0m@= zxFfVvxz#0`F44TVY&cuK_W4kDO@QXYK2hB=kKdb}diJ4D30|Eo3k|~RTn|eBgv)i; zMdT~l5wkAXJG?O0ORL|lL|b8N!q#u*BsQ)0p19x(*Tec(xS}fZ)X8G7VQe4EmyHALa7YBb3 zA5*GV(k%r-1AXz|ja3njebD}Iu@ldQU&pXo6;+fA8VvQas^J=p2iUGq;Y{mg+f;!G zW4~HwbY|XOsY;=h-<^3xq)S@Wj@xQQ2O!>6={)g=Y(I>Rk#73cdIc&QvR>b>x!Z~7 z_0+{q&lsO9k1>VdZ02%n4HZ9ZlL^$+L$yPsHAdVXWYF0+>^RftxF3YO7A54z_ihW!B;6N$D7^)YL= zrAmLdaH2&@&`SN&! zVE!Bwna>%rc7FE^v{^r8Q=zu4n-$Vx%O_ND#`Pnu^s?(9!G4YS21^4#JNV{LjvO(@w{;C|ctISC!J!Geu+Z?_U|GVR}AXV81P=_|JQpXl|9VW0 z_qLbiNYflQ_@N33%yXETiivn2qeTjOzD{6`(=X|C&PA8O47td%tDdnjvlY%0Kgb%{ zfOVHE$eHNCm)-C|JS@YVN5p9iq%^tAub|s~c-oQs0AG`=)Dts<*_t+0jH08|#;+;aoqdxIQ zEaHuq%F3G?25oft&NCDPyk|zVvQeXQ#%TA+(nE^+3-$(bzYxPSQe8fl z4#EBM{-RJ5E{Jl39UXIG`Q3boZgjvNK^2r&uMgjkH`t7=i3*YXABfQ^C>i6sOZXzZ zx5fY`2=@of{zjH?QZ0O&+#m5!QrV8k7Z#trDFvfhD}<1ZReZW_y9u9M#Y-G2slKIo zj%|+z|2hTW{k9q48fIIJouCIS-2lYIWLJxS!C3c8ahWUgNGTE}%kNu71mmPzz$Yn)BJP=vBG_+)3GE{mcGJYFS1x~vR)(Be{I8Z$`$m)dF|Jg zJMt97WI?oLu~BKw0;}TKbCHh%G|ChUEh$KBpgW%5htCs2qF@ZG4Z%6H6u1SQO3r?b ziuYbiP?(03=fmi-_b6cd8Dpad@WDAEQW_eG#|uyZmI84CA*M$15YU{3B>h%a0|?&N z^A(vMtY?(H*^|!`m14C6&n7f#f0SDn#l~O}0s78Si^s813M^m#Hc|^k33%+PDSV*G z0Am3K*d&*<=#^McfzX02R7Z48lQU-;*m}t$PQM)BOjTG-6yjZB4uBO45uNZU#B3%P z>Ic~wp8IXY3*0Ukjr~nQ6}~O4@^w|^?1!`XfFfy>7O7l<*W=>8aDYE<0CVgij#|*J z*d*sb)+#B=uB`_BXZ9zz=o@i3n6}LX-4!e)gve!>-CR-Fh7ude{KrhHqj1PLtHvB} zmDd(TVYfxu(HJ&Q0hR+2gg@K20{L1@cR%v;lUL!{(+O#xnjN8H=;7* zQ!8zyI6zUC$K1+R`fz7K3yKgQq?wM}6nZDrOWE9MS$)v+|6@QrLT-&lZBq@l*O`lxxc z0^I#PCUMih&lsKDBF8{UqLg&aU$&#h67?R@Hi{7xmHMJcz+=0(5}-*X`BQpYMm2tn zvPn>>+#95XoTJq?1mVx_It8^@A7wKo!FQiskWJt**1?)MCi5|ds&!T%&>H zydd4rq_Ci`?9XMp3#vYS0;)~S*PQJMQe2o$>}USZ(Z%rs`fCBSO|*9hYp-|~h@ai< zUjkbgiE@972tD?)iMUvhKFFpw>WUAUNH=i8m$Su3^vrP~CXBQAwt*a>+sBg8>NVJJ zqP}@9fdYjML7;7$o>4Bq?9eh(mtg9)%&X21T>#o985tk7Nqe_2w_gG3?=mU{n4Mdg z4XEODDdW6OyeX5}o*9`xiluRCg2pYFpWkW2uMcEokqC53`17RuX`EFNzS*exbAO~a8z4;?U2&ryK6_;&eN2mGrtCF1paO(QEU_~V@=ab4Uu zHXU=8f9AX2T_0az(QrAN<*l*;yW@ndSy?F=xN8PtA2TuF58kvsH&Q;1;!_sdE9jfR zAR9~f?6*4;DuT`P6Q!Y*;IJm3Wzt3}O!X+I1Yq?3PEU*X}GOs~{R%W!?r1B6S>8^sWUTw3p6P-ASRk?FS-b>B=3IuL&cT5NOM zM}p1r5{a_yoIU%qT!f$7*I$ts-m37o*XHWhp@cRR=PehJ9Huhz19V^_tg=1}?_h>& z6mP&WaOv)Wt|jIurwJFBr!%8`P6Di5E#%N9sPHKo zS8!CTmRWQP*)yGAMfAQX@)KMm#cHdpyN9ftOMx!205j3mTK7-lU~lFGn<|tcp}_{Y zQ3w49rffX9TWR~MO6@7odK|R>pUke=*B?csa0X9_O;M6bu7w1BcE%RK+1Wq#Pnyyr z%dcpk2>?p1s=O^$f5jR|CJq-8Jz_bbga+-N6@bfs4NqdO=1DQ>h>;$u6*3p%OTFgA z5dZfmOv<`3d`G_Zs{K;PdS>^YR1|_w8!@CHc}VO}Ov?m4>U?1&xb#%(qZBFDQ^Td= zBUY30<&eb{p5s2Tf>L@k(Y99~xdI-vuGPd}4V1@PO7(zM0FZEZ(QdC&5xH@1xM-&k zzhDaMliyb7+M>m}X+Tnf-1S1Yg1kVim|sZhe_5-=usA^MPL-{w4<#2?mD@iT;=Z}c zIp&ui8N4!QS5`nPAwEBnNh%@oicY|B@GGQ21@5wu0*iGbQk~Wd&jTPEWB_RcD){Va zoX3>HvP-Ap@nnP~O@(mHiRzJ+OhS;0hIe zKUxmj4(TfZ6+r(DA$b;<0H|L}mFGvKTcWnBlb8T>oewwCzjnrSjqh-S)KEAAJ_h@i=Z-30At9s79!cKTb&6wc#Ig(6nKHUC5*GNw_}k1Mjv zrUu!t1bFMB*clQZH@9R-hAMnkbj5gMg~O00&S7HEl008e=YTsP3JM^cH(9>`l@YV8 zw9@`-Ya4VK2Qv@j(KX(de;X@j+Nv%7KAoS{Ra#4TLLp6m1v5Vk@ElTDOe*E`-Xamm zh9qLIF+QRTXtMdjDP7AMw4KsEb@>4Z;zhWdF}dj;dXsUnl81qJ`a=j7!NlEt&- zwllYo{4>?=oXZ%_=8KwMP+GewRdQTl=ST8lD1?cPTIsUDLh`!e6PVW{Gf0Yy2|9NdjkaOp%6LtStUwApkS$QO

J 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 literal 0 HcmV?d00001 diff --git a/skin/raster/2panels/find.png b/skin/raster/2panels/find.png new file mode 100644 index 0000000000000000000000000000000000000000..47bdd185fb8d7b7f25d0fc48f25895a690a57690 GIT binary patch literal 725 zcmV;`0xJE9P)6o~BEewo!L6b7P;2ZVTq}obsc3fZJ*Oun z%WGp)5PhD0=f{uF;e5{zpdOy6_7VaBP$(1|R4UaR$YZnFIE-;8ED3MiNKcKfqwsq; zF~#@RG~5x*hw9<@<2BNuxQ-4@gb)A#0s!DRu7x166(lC(^?Ik_&$D+x^Qls!YV(%% zAP^=M_2ysgA6Tgo)ww*CK)AoJ$jO>6jJVQ6bA5FCMNK>WqZ~^b&Qxlq(O}OQ@64s8 zjlVP=7&bWe^s8%@s%m!M*1V}^KB&Dc3Sv^B!ZlW0Das4X+1}Arv>+~k0;wQ7{q^2M zUw%^dYS)#Pop;jb==rC+Kg$jU0s*Ag>rG0faxKPq6UKNe#@NAeoXu*rs^LE;H0xqc zzBO*H`+v*j$OOM@>_x0d1?K(teY9NR;TYdmm>1$w8Th8v%Jnz5EzUF)cSm$P7=)+p zdKT05gxwKc7XdOzMKB^3UYhjg&Kq6t%0JHiBzE^V@km>qVU=JIigZN!0^00000NkvXX Hu0mjf>}E-` literal 0 HcmV?d00001 diff --git a/skin/raster/2panels/hover.png b/skin/raster/2panels/hover.png new file mode 100644 index 0000000000000000000000000000000000000000..ff00ee1986d231f5297eaaa24d6d9fb406d7f780 GIT binary patch literal 11928 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 literal 0 HcmV?d00001 diff --git a/skin/raster/2panels/kbfxfontrc b/skin/raster/2panels/kbfxfontrc new file mode 100644 index 0000000..06c6b79 --- /dev/null +++ b/skin/raster/2panels/kbfxfontrc @@ -0,0 +1,15 @@ +[Fonts] +ApplicationText=0,0,0 +ApplicationTextFont=Arial,8,-1,5,50,0,0,0,0,0 +CommentText=47,63,85 +CommentTextFont=Arial,8,-1,5,50,0,0,0,0,0 +GroupText=0,0,0 +GroupTextFont=Arial,8,-1,5,50,0,0,0,0,0 +HoverBold=false +LineColor=47,63,85 +PluginColor=47,63,85 +PluginFont=Arial,8,-1,5,50,0,0,0,0,0 +SeparatorColor=47,63,85 +SeparatorFont=Arial,8,-1,5,75,0,0,0,0,0 +UserName=255,255,255 +UserNameFont=Arial,10,-1,5,75,0,0,0,0,0 diff --git a/skin/raster/2panels/kbfxlayoutrc b/skin/raster/2panels/kbfxlayoutrc new file mode 100644 index 0000000..96d4589 --- /dev/null +++ b/skin/raster/2panels/kbfxlayoutrc @@ -0,0 +1,66 @@ +[BottomBar] +Height=38 +Width=410 +X=0 +Y=428 + +[ItemProperties] +CommentMargin=66 +IconSize=32 +NoComments=false + +[ItemView] +Height=467 +Width=256 +X=0 +Y=95 + +[KbfxButton] +FadeTime=75 + +[ListBox] +Height=100 +Width=154 +X=256 +Y=95 + +[MainMenu] +ContractedMenu=false +UserMenuHeight=600 +UserMenuWidth=410 + +[Scrollbars] +ScrollBarBotX=0 +ScrollBarBotY=51 +ScrollBarTopX=0 +ScrollBarTopY=62 + +[SearchBox] +FixedPos=true +Height=22 +Width=193 +X=20 +Y=570 + +[ToolBar] +ButtonNormalSize=48 +ButtonPressedSize=48 + +[TopBar] +DisableUserName=false +DudeX=311 +DudeY=0 +FaceH=52 +FaceW=52 +FaceX=8 +FaceY=7 +Height=95 +UserNameX=292 +UserNameY=84 +Width=410 +X=0 +Y=0 + +[WaterEffect] +EnableWater=false +FrameRate=20 diff --git a/skin/raster/2panels/listboxbg.png b/skin/raster/2panels/listboxbg.png new file mode 100644 index 0000000000000000000000000000000000000000..ef36f770b74094bee989b086c9c9946ba1312320 GIT binary patch literal 177 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 XV)2FVMgHnp00000NkvXXu0mjfVYG~^ literal 0 HcmV?d00001 diff --git a/skin/raster/2panels/logo.png b/skin/raster/2panels/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..febf2308014c483bed08b562fd120342d8726733 GIT binary patch literal 13043 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 BU=08O literal 0 HcmV?d00001 diff --git a/skin/raster/2panels/logout.png b/skin/raster/2panels/logout.png new file mode 100644 index 0000000000000000000000000000000000000000..e69b6a3ef3ba89d5ca3722a601bf09370b784a29 GIT binary patch literal 6908 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 UAH!P|CjbBd07*qoM6N<$f`2U|6aWAK literal 0 HcmV?d00001 diff --git a/skin/raster/2panels/mask.png b/skin/raster/2panels/mask.png new file mode 100644 index 0000000000000000000000000000000000000000..824741769df2c70f6c754865296f7b3c8ec89e1a GIT binary patch literal 35310 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%0DEXR}#nG#VwF%{C6m3pl>O3xE>~4>2jl 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