diff options
Diffstat (limited to '.pc')
46 files changed, 5714 insertions, 0 deletions
diff --git a/.pc/.quilt_patches b/.pc/.quilt_patches new file mode 100644 index 0000000..6857a8d --- /dev/null +++ b/.pc/.quilt_patches @@ -0,0 +1 @@ +debian/patches diff --git a/.pc/.quilt_series b/.pc/.quilt_series new file mode 100644 index 0000000..c206706 --- /dev/null +++ b/.pc/.quilt_series @@ -0,0 +1 @@ +series diff --git a/.pc/.version b/.pc/.version new file mode 100644 index 0000000..0cfbf08 --- /dev/null +++ b/.pc/.version @@ -0,0 +1 @@ +2 diff --git a/.pc/0001-ZLQtFSManager.cpp.patch/zlibrary/ui/src/qt4/filesystem/ZLQtFSManager.cpp b/.pc/0001-ZLQtFSManager.cpp.patch/zlibrary/ui/src/qt4/filesystem/ZLQtFSManager.cpp new file mode 100644 index 0000000..50a9f09 --- /dev/null +++ b/.pc/0001-ZLQtFSManager.cpp.patch/zlibrary/ui/src/qt4/filesystem/ZLQtFSManager.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <QtCore/QCoreApplication> +#include <QtCore/QDir> +#include <QtCore/QString> + +#include <ZLStringUtil.h> + +#include "ZLQtFSManager.h" + +std::string ZLQtFSManager::convertFilenameToUtf8(const std::string &name) const { + if (name.empty()) { + return name; + } + + QString qString = QString::fromLocal8Bit(name.c_str()); + return (qString == QString::null) ? "" : (const char*)qString.toUtf8(); +} + +shared_ptr<ZLMimeType> ZLQtFSManager::mimeType(const std::string &path) const { + // TODO: implement + return ZLMimeType::EMPTY; +} + +void ZLQtFSManager::normalizeRealPath(std::string &path) const { + if (ZLStringUtil::stringStartsWith(path, "~~/") || path == "~~") { + static const std::string replacement = + std::string((const char*)QCoreApplication::applicationDirPath().toUtf8()) + "/.."; + path = replacement + path.substr(2); + } else if (ZLStringUtil::stringStartsWith(path, "~/") || path == "~") { + static const std::string replacement = (const char*)QDir::homePath().toUtf8(); + path = replacement + path.substr(1); + } +} diff --git a/.pc/0002-Qt5.patch/makefiles/arch/desktop.mk b/.pc/0002-Qt5.patch/makefiles/arch/desktop.mk new file mode 100644 index 0000000..3e81598 --- /dev/null +++ b/.pc/0002-Qt5.patch/makefiles/arch/desktop.mk @@ -0,0 +1,42 @@ +include $(ROOTDIR)/makefiles/arch/unix.mk + +ifeq "$(INSTALLDIR)" "" + INSTALLDIR=/usr +endif +IMAGEDIR = $(INSTALLDIR)/share/pixmaps +APPIMAGEDIR = $(INSTALLDIR)/share/pixmaps/%APPLICATION_NAME% + + +CCACHE = $(shell if which ccache > /dev/null; then echo "ccache"; fi) #if ccache is not installed, do not use it +CC = $(CCACHE) gcc +AR = ar rsu +LD = g++ + +CFLAGS = -pipe -fno-exceptions -Wall -Wno-ctor-dtor-privacy -W -DLIBICONV_PLUG +LDFLAGS = +EXTERNAL_INCLUDE = $(shell pkg-config --cflags fribidi) + +ifeq "$(UI_TYPE)" "qt" + MOC = moc-qt3 + QTINCLUDE = -I /usr/include/qt3 +else + MOC = $(shell pkg-config QtCore --variable=moc_location) + QTINCLUDE = -I $(shell pkg-config --cflags QtCore) +endif + +GTKINCLUDE = $(shell pkg-config --cflags gtk+-2.0 libpng xft) + +ifeq "$(UI_TYPE)" "qt" + UILIBS = -lqt-mt +endif + +ifeq "$(UI_TYPE)" "qt4" + UILIBS = $(shell pkg-config --libs QtCore QtGui QtNetwork) +endif + +ifeq "$(UI_TYPE)" "gtk" + UILIBS = $(shell pkg-config --libs gtk+-2.0 gio-2.0) -lpng -ljpeg +endif + +RM = rm -rvf +RM_QUIET = rm -rf diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/application/LineEditParameter.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/application/LineEditParameter.cpp new file mode 100644 index 0000000..dfcbc0b --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/application/LineEditParameter.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2008-2012 Geometer Plus <[email protected]> + * + * 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 <QtGui/QBoxLayout> +#include <QtGui/QLineEdit> +#include <QtGui/QToolBar> +#include <QtGui/QKeyEvent> + +#include "ZLQtApplicationWindow.h" +#include "../util/ZLQtKeyUtil.h" + +class ZLQtLineEdit : public QLineEdit { + +public: + ZLQtLineEdit(QToolBar *toolbar, ZLQtApplicationWindow &window, ZLQtApplicationWindow::LineEditParameter ¶meter, const std::string &actionId); + +private: + void keyReleaseEvent(QKeyEvent *event); + +private: + ZLQtApplicationWindow &myWindow; + ZLQtApplicationWindow::LineEditParameter &myParameter; + const std::string myActionId; +}; + +ZLQtLineEdit::ZLQtLineEdit(QToolBar *toolbar, ZLQtApplicationWindow &window, ZLQtApplicationWindow::LineEditParameter ¶meter, const std::string &actionId) : QLineEdit(toolbar), myWindow(window), myParameter(parameter), myActionId(actionId) { +} + +void ZLQtLineEdit::keyReleaseEvent(QKeyEvent *event) { + event->accept(); + const std::string key = ZLQtKeyUtil::keyName(event); + if (key == "<Return>") { + myWindow.application().doAction(myActionId); + myWindow.setFocusToMainWidget(); + } else if (key == "<Esc>") { + myParameter.restoreOldValue(); + myWindow.setFocusToMainWidget(); + } +} + +ZLQtApplicationWindow::LineEditParameter::LineEditParameter(QToolBar *toolbar, ZLQtApplicationWindow &window, const ZLToolbar::ParameterItem &textFieldItem) { + myEdit = new ZLQtLineEdit(toolbar, window, *this, textFieldItem.actionId()); + myEdit->setAlignment(Qt::AlignHCenter); + myEdit->setMaxLength(textFieldItem.maxWidth()); + myEdit->setFixedWidth(textFieldItem.maxWidth() * 10 + 10); + myEdit->setFocusPolicy(Qt::ClickFocus); + myEdit->setToolTip(QString::fromUtf8(textFieldItem.tooltip().c_str())); + myAction = toolbar->addWidget(myEdit); + // I don't understand why this code does work but it does. + //QBoxLayout *layout = (QBoxLayout*)toolbar->layout(); + //layout->addStretch(); +} + +QAction *ZLQtApplicationWindow::LineEditParameter::action() const { + return myAction; +} + +std::string ZLQtApplicationWindow::LineEditParameter::internalValue() const { + return (const char*)myEdit->text().toUtf8(); +} + +void ZLQtApplicationWindow::LineEditParameter::internalSetValue(const std::string &value) { + myEdit->setText(QString::fromUtf8(value.c_str())); +} + +void ZLQtApplicationWindow::LineEditParameter::restoreOldValue() { + VisualParameter::restoreOldValue(); +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/application/ZLQtApplicationWindow.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/application/ZLQtApplicationWindow.cpp new file mode 100644 index 0000000..6241514 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/application/ZLQtApplicationWindow.cpp @@ -0,0 +1,331 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <QtGui/QApplication> +#include <QtGui/QPixmap> +#include <QtGui/QImage> +#include <QtGui/QIcon> +#include <QtGui/QToolBar> +#include <QtGui/QMenuBar> +#include <QtGui/QMenu> +#include <QtGui/QToolButton> +#include <QtGui/QLayout> +#include <QtGui/QWheelEvent> +#include <QtGui/QDockWidget> +#include <QtCore/QObjectList> + +#include <ZLibrary.h> +#include <ZLFile.h> +#include <ZLPopupData.h> + +#include "ZLQtApplicationWindow.h" +#include "../dialogs/ZLQtDialogManager.h" +#include "../view/ZLQtViewWidget.h" +#include "../util/ZLQtKeyUtil.h" + +void ZLQtDialogManager::createApplicationWindow(ZLApplication *application) const { + myApplicationWindow = new ZLQtApplicationWindow(application); +} + +ZLQtToolBarAction::ZLQtToolBarAction(ZLQtApplicationWindow *parent, ZLToolbar::AbstractButtonItem &item) : QAction(parent), myItem(item) { + static std::string imagePrefix = ZLibrary::ApplicationImageDirectory() + ZLibrary::FileNameDelimiter; + const QString path = QString::fromUtf8(ZLFile(imagePrefix + myItem.iconName() + ".png").path().c_str()); + QPixmap icon(path); + setIcon(QIcon(icon)); + QSize size = icon.size(); + if (item.type() == ZLToolbar::Item::TOGGLE_BUTTON) { + setCheckable(true); + } + QString text = QString::fromUtf8(myItem.tooltip().c_str()); + setText(text); + setToolTip(text); + connect(this, SIGNAL(triggered()), this, SLOT(onActivated())); +} + +void ZLQtToolBarAction::onActivated() { + ((ZLQtApplicationWindow*)parent())->onButtonPress(myItem); +} + +void ZLQtApplicationWindow::setToggleButtonState(const ZLToolbar::ToggleButtonItem &button) { + myActions[&button]->setChecked(button.isPressed()); +} + +ZLQtApplicationWindow::ZLQtApplicationWindow(ZLApplication *application) : + ZLDesktopApplicationWindow(application), + myFullscreenToolBar(0), + myDocWidget(0), + myFullScreen(false), + myWasMaximized(false), + myCursorIsHyperlink(false) { + + const std::string iconFileName = ZLibrary::ImageDirectory() + ZLibrary::FileNameDelimiter + ZLibrary::ApplicationName() + ".png"; + QPixmap icon(iconFileName.c_str()); + setWindowIcon(icon); + + myWindowToolBar = new QToolBar(this); + myWindowToolBar->setFocusPolicy(Qt::NoFocus); + myWindowToolBar->setMovable(false); + addToolBar(myWindowToolBar); + myWindowToolBar->setIconSize(QSize(32, 32)); + + if (hasFullscreenToolbar()) { + myFullscreenToolBar = new QToolBar(); + myFullscreenToolBar->setMovable(false); + myFullscreenToolBar->setIconSize(QSize(32, 32)); + myFullscreenToolBar->hide(); + } + + resize(myWidthOption.value(), myHeightOption.value()); + move(myXOption.value(), myYOption.value()); + + menuBar()->hide(); + show(); +} + +void ZLQtApplicationWindow::init() { + ZLDesktopApplicationWindow::init(); + switch (myWindowStateOption.value()) { + case NORMAL: + break; + case FULLSCREEN: + setFullscreen(true); + break; + case MAXIMIZED: + showMaximized(); + break; + } +} + +ZLQtApplicationWindow::~ZLQtApplicationWindow() { + if (isFullscreen()) { + myWindowStateOption.setValue(FULLSCREEN); + } else if (isMaximized()) { + myWindowStateOption.setValue(MAXIMIZED); + } else { + myWindowStateOption.setValue(NORMAL); + QPoint position = pos(); + if (position.x() != -1) { + myXOption.setValue(position.x()); + } + if (position.y() != -1) { + myYOption.setValue(position.y()); + } + myWidthOption.setValue(width()); + myHeightOption.setValue(height()); + } + for (std::map<const ZLToolbar::Item*,QAction*>::iterator it = myActions.begin(); it != myActions.end(); ++it) { + if (it->second != 0) { + delete it->second; + } + } +} + +void ZLQtApplicationWindow::setFullscreen(bool fullscreen) { + if (fullscreen == myFullScreen) { + return; + } + myFullScreen = fullscreen; + if (myFullScreen) { + myWasMaximized = isMaximized(); + myWindowToolBar->hide(); + showFullScreen(); + if (myFullscreenToolBar != 0) { + if (myDocWidget == 0) { + myDocWidget = new QDockWidget(this); + myDocWidget->setWidget(myFullscreenToolBar); + myDocWidget->setFloating(true); + myDocWidget->setAllowedAreas(Qt::NoDockWidgetArea); + } + myDocWidget->show(); + myFullscreenToolBar->show(); + myDocWidget->setMinimumSize(myDocWidget->size()); + myDocWidget->setMaximumSize(myDocWidget->size()); + } + } else { + myWindowToolBar->show(); + showNormal(); + if (myWasMaximized) { + showMaximized(); + } + if (myDocWidget != 0) { + //myFullscreenToolBar->hide(); + myDocWidget->hide(); + } + } +} + +bool ZLQtApplicationWindow::isFullscreen() const { + return myFullScreen; +} + +void ZLQtApplicationWindow::keyPressEvent(QKeyEvent *event) { + application().doActionByKey(ZLQtKeyUtil::keyName(event)); +} + +void ZLQtApplicationWindow::wheelEvent(QWheelEvent *event) { + if (event->orientation() == Qt::Vertical) { + if (event->delta() > 0) { + application().doActionByKey(ZLApplication::MouseScrollUpKey); + } else { + application().doActionByKey(ZLApplication::MouseScrollDownKey); + } + } +} + +void ZLQtApplicationWindow::closeEvent(QCloseEvent *event) { + if (application().closeView()) { + event->accept(); + } else { + event->ignore(); + } +} + +void ZLQtApplicationWindow::addToolbarItem(ZLToolbar::ItemPtr item) { + QToolBar *tb = toolbar(type(*item)); + QAction *action = 0; + + switch (item->type()) { + case ZLToolbar::Item::PLAIN_BUTTON: + case ZLToolbar::Item::TOGGLE_BUTTON: + action = new ZLQtToolBarAction(this, (ZLToolbar::AbstractButtonItem&)*item); + tb->addAction(action); + break; + case ZLToolbar::Item::MENU_BUTTON: + { + ZLToolbar::MenuButtonItem &buttonItem = (ZLToolbar::MenuButtonItem&)*item; + QToolButton *button = new QToolButton(tb); + button->setFocusPolicy(Qt::NoFocus); + button->setDefaultAction(new ZLQtToolBarAction(this, buttonItem)); + button->setMenu(new QMenu(button)); + button->setPopupMode(QToolButton::MenuButtonPopup); + action = tb->addWidget(button); + myMenuButtons[&buttonItem] = button; + shared_ptr<ZLPopupData> popupData = buttonItem.popupData(); + myPopupIdMap[&buttonItem] = + popupData.isNull() ? (size_t)-1 : (popupData->id() - 1); + break; + } + case ZLToolbar::Item::TEXT_FIELD: + case ZLToolbar::Item::SEARCH_FIELD: + { + ZLToolbar::ParameterItem &textFieldItem = + (ZLToolbar::ParameterItem&)*item; + LineEditParameter *para = new LineEditParameter(tb, *this, textFieldItem); + addVisualParameter(textFieldItem.parameterId(), para); + action = para->action(); + break; + } + case ZLToolbar::Item::SEPARATOR: + action = tb->addSeparator(); + break; + } + + if (action != 0) { + myActions[&*item] = action; + } +} + +ZLQtRunPopupAction::ZLQtRunPopupAction(QObject *parent, shared_ptr<ZLPopupData> data, size_t index) : QAction(parent), myData(data), myIndex(index) { + setText(QString::fromUtf8(myData->text(myIndex).c_str())); + connect(this, SIGNAL(triggered()), this, SLOT(onActivated())); +} + +ZLQtRunPopupAction::~ZLQtRunPopupAction() { +} + +void ZLQtRunPopupAction::onActivated() { + myData->run(myIndex); +} + +void ZLQtApplicationWindow::setToolbarItemState(ZLToolbar::ItemPtr item, bool visible, bool enabled) { + QAction *action = myActions[&*item]; + if (action != 0) { + action->setEnabled(enabled); + action->setVisible(visible); + } + switch (item->type()) { + default: + break; + case ZLToolbar::Item::MENU_BUTTON: + { + ZLToolbar::MenuButtonItem &buttonItem = (ZLToolbar::MenuButtonItem&)*item; + shared_ptr<ZLPopupData> data = buttonItem.popupData(); + if (!data.isNull() && (data->id() != myPopupIdMap[&buttonItem])) { + myPopupIdMap[&buttonItem] = data->id(); + QToolButton *button = myMenuButtons[&buttonItem]; + QMenu *menu = button->menu(); + menu->clear(); + const size_t count = data->count(); + for (size_t i = 0; i < count; ++i) { + menu->addAction(new ZLQtRunPopupAction(menu, data, i)); + } + } + break; + } + } +} + +void ZLQtApplicationWindow::processAllEvents() { + qApp->processEvents(); +} + +ZLViewWidget *ZLQtApplicationWindow::createViewWidget() { + ZLQtViewWidget *viewWidget = new ZLQtViewWidget(this, &application()); + setCentralWidget(viewWidget->widget()); + viewWidget->widget()->show(); + return viewWidget; +} + +void ZLQtApplicationWindow::close() { + QMainWindow::close(); +} + + + +void ZLQtApplicationWindow::refresh() { + QMetaObject::invokeMethod(this, "onRefresh", Qt::AutoConnection); +} + +void ZLQtApplicationWindow::onRefresh() { + ZLApplicationWindow::refresh(); +} + +void ZLQtApplicationWindow::grabAllKeys(bool) { +} + +void ZLQtApplicationWindow::setCaption(const std::string &caption) { + QMainWindow::setWindowTitle(QString::fromUtf8(caption.c_str())); +} + +void ZLQtApplicationWindow::setHyperlinkCursor(bool hyperlink) { + if (hyperlink == myCursorIsHyperlink) { + return; + } + myCursorIsHyperlink = hyperlink; + if (hyperlink) { + myStoredCursor = cursor(); + setCursor(Qt::PointingHandCursor); + } else { + setCursor(myStoredCursor); + } +} + +void ZLQtApplicationWindow::setFocusToMainWidget() { + centralWidget()->setFocus(); +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/application/ZLQtApplicationWindow.h b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/application/ZLQtApplicationWindow.h new file mode 100644 index 0000000..3b4fd3a --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/application/ZLQtApplicationWindow.h @@ -0,0 +1,141 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 __ZLQTAPPLICATIONWINDOW_H__ +#define __ZLQTAPPLICATIONWINDOW_H__ + +#include <map> + +#include <QtGui/QMainWindow> +#include <QtGui/QAction> +#include <QtGui/QCursor> + +class QDockWidget; +class QToolBar; +class QToolButton; +class QLineEdit; + +class ZLPopupData; + +#include "../../../../core/src/desktop/application/ZLDesktopApplicationWindow.h" + +class ZLQtApplicationWindow : public QMainWindow, public ZLDesktopApplicationWindow { + Q_OBJECT + +public: + ZLQtApplicationWindow(ZLApplication *application); + ~ZLQtApplicationWindow(); + + void setFocusToMainWidget(); + +private: + ZLViewWidget *createViewWidget(); + void addToolbarItem(ZLToolbar::ItemPtr item); + void init(); + void processAllEvents(); + void close(); + + void refresh(); + + void grabAllKeys(bool grab); + + void setCaption(const std::string &caption); + + void setHyperlinkCursor(bool hyperlink); + + bool isFullscreen() const; + void setFullscreen(bool fullscreen); + + void setToggleButtonState(const ZLToolbar::ToggleButtonItem &button); + void setToolbarItemState(ZLToolbar::ItemPtr item, bool visible, bool enabled); + + void closeEvent(QCloseEvent *event); + void keyPressEvent(QKeyEvent *event); + void wheelEvent(QWheelEvent *event); + +private Q_SLOTS: + void onRefresh(); + +private: + QToolBar *myWindowToolBar; + QToolBar *myFullscreenToolBar; + QDockWidget *myDocWidget; + QToolBar *toolbar(ToolbarType type) { return (type == WINDOW_TOOLBAR) ? myWindowToolBar : myFullscreenToolBar; } + +friend class ZLQtToolBarAction; + std::map<const ZLToolbar::Item*,QAction*> myActions; + std::map<const ZLToolbar::MenuButtonItem*,QToolButton*> myMenuButtons; + std::map<const ZLToolbar::MenuButtonItem*,size_t> myPopupIdMap; + + bool myFullScreen; + bool myWasMaximized; + + bool myCursorIsHyperlink; + QCursor myStoredCursor; + +private: + class LineEditParameter : public VisualParameter { + + public: + LineEditParameter(QToolBar *toolbar, ZLQtApplicationWindow &window, const ZLToolbar::ParameterItem &textFieldItem); + QAction *action() const; + void restoreOldValue(); + + private: + std::string internalValue() const; + void internalSetValue(const std::string &value); + void setValueList(const std::vector<std::string> &values) {} + + private: + QLineEdit *myEdit; + QAction *myAction; + }; + +friend class ZLQtLineEdit; +}; + +class ZLQtToolBarAction : public QAction { + Q_OBJECT + +public: + ZLQtToolBarAction(ZLQtApplicationWindow *parent, ZLToolbar::AbstractButtonItem &item); + +private Q_SLOTS: + void onActivated(); + +private: + ZLToolbar::AbstractButtonItem &myItem; +}; + +class ZLQtRunPopupAction : public QAction { + Q_OBJECT + +public: + ZLQtRunPopupAction(QObject *parent, shared_ptr<ZLPopupData> data, size_t index); + ~ZLQtRunPopupAction(); + +private Q_SLOTS: + void onActivated(); + +private: + shared_ptr<ZLPopupData> myData; + const size_t myIndex; +}; + +#endif /* __ZLQTAPPLICATIONWINDOW_H__ */ diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtDialog.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtDialog.cpp new file mode 100644 index 0000000..24eb897 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtDialog.cpp @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <QtGui/QApplication> +#include <QtGui/QPushButton> + +#include <ZLDialogManager.h> + +#include "ZLQtDialog.h" +#include "ZLQtDialogContent.h" +#include "ZLQtUtil.h" + +ZLQtDialog::ZLQtDialog(const ZLResource &resource) : QDialog(qApp->activeWindow()), myButtonNumber(0) { + setModal(true); + setWindowTitle(::qtString(resource[ZLDialogManager::DIALOG_TITLE].value())); + + QVBoxLayout *layout = new QVBoxLayout(this); + QWidget *widget = new QWidget(this); + layout->addWidget(widget); + myTab = new ZLQtDialogContent(widget, resource); + + myButtonGroup = new QWidget(this); + layout->addWidget(myButtonGroup); + myButtonLayout = new QGridLayout(myButtonGroup); +} + +ZLQtDialog::~ZLQtDialog() { +} + +void ZLQtDialog::addButton(const ZLResourceKey &key, bool accept) { + QPushButton *button = new QPushButton(myButtonGroup); + button->setText(::qtButtonName(key)); + myButtonLayout->addWidget(button, 0, myButtonNumber++); + connect(button, SIGNAL(clicked()), this, accept ? SLOT(accept()) : SLOT(reject())); +} + +bool ZLQtDialog::run() { + ((ZLQtDialogContent*)myTab)->close(); + return exec(); +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtDialog.h b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtDialog.h new file mode 100644 index 0000000..068039d --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtDialog.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 __ZLQTDIALOG_H__ +#define __ZLQTDIALOG_H__ + +#include <QtGui/QDialog> +#include <QtGui/QLayout> + +#include <ZLDialog.h> + +class ZLQtDialog : public QDialog, public ZLDialog { + +public: + ZLQtDialog(const ZLResource &resource); + ~ZLQtDialog(); + + void addButton(const ZLResourceKey &key, bool accept); + bool run(); + +private: + QGridLayout *myButtonLayout; + QWidget *myButtonGroup; + int myButtonNumber; +}; + +#endif /* __ZLQTDIALOG_H__ */ diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtDialogContent.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtDialogContent.cpp new file mode 100644 index 0000000..e8ff422 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtDialogContent.cpp @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <QtGui/QApplication> +#include <QtGui/QDesktopWidget> +#include <QtGui/QWidget> +#include <QtGui/QLayout> + +#include "ZLQtDialogContent.h" +#include "ZLQtOptionView.h" + +void ZLQtDialogContent::close() { + myLayout->setRowStretch(myRowCounter, 10); +} + +ZLQtDialogContent::ZLQtDialogContent(QWidget *widget, const ZLResource &resource) : ZLDialogContent(resource), myWidget(widget) { + myLayout = new QGridLayout(myWidget); + myRowCounter = 0; +} + +ZLQtDialogContent::~ZLQtDialogContent() { +} + +void ZLQtDialogContent::addOption(const std::string &name, const std::string &tooltip, ZLOptionEntry *option) { + createViewByEntry(name, tooltip, option, 0, 12); + ++myRowCounter; +} + +void ZLQtDialogContent::addOptions(const std::string &name0, const std::string &tooltip0, ZLOptionEntry *option0, const std::string &name1, const std::string &tooltip1, ZLOptionEntry *option1) { + createViewByEntry(name0, tooltip0, option0, 0, 5); + createViewByEntry(name1, tooltip1, option1, 7, 12); + ++myRowCounter; +} + +void ZLQtDialogContent::addItem(QWidget *widget, int row, int fromColumn, int toColumn) { + myLayout->addWidget(widget, row, fromColumn, 1, toColumn - fromColumn + 1); +} + +void ZLQtDialogContent::createViewByEntry(const std::string &name, const std::string &tooltip, ZLOptionEntry *option, int fromColumn, int toColumn) { + if (option == 0) { + return; + } + ZLQtOptionView *view = 0; + switch (option->kind()) { + case ZLOptionEntry::BOOLEAN: + view = new BooleanOptionView(name, tooltip, (ZLBooleanOptionEntry*)option, this, myRowCounter, fromColumn, toColumn); + break; + case ZLOptionEntry::BOOLEAN3: + view = new Boolean3OptionView(name, tooltip, (ZLBoolean3OptionEntry*)option, this, myRowCounter, fromColumn, toColumn); + break; + case ZLOptionEntry::STRING: + view = new StringOptionView(name, tooltip, (ZLStringOptionEntry*)option, this, false, myRowCounter, fromColumn, toColumn); + break; + case ZLOptionEntry::PASSWORD: + view = new StringOptionView(name, tooltip, (ZLStringOptionEntry*)option, this, true, myRowCounter, fromColumn, toColumn); + break; + case ZLOptionEntry::CHOICE: + view = new ChoiceOptionView(name, tooltip, (ZLChoiceOptionEntry*)option, this, myRowCounter, fromColumn, toColumn); + break; + case ZLOptionEntry::SPIN: + view = new SpinOptionView(name, tooltip, (ZLSpinOptionEntry*)option, this, myRowCounter, fromColumn, toColumn); + break; + case ZLOptionEntry::COMBO: + view = new ComboOptionView(name, tooltip, (ZLComboOptionEntry*)option, this, myRowCounter, fromColumn, toColumn); + break; + case ZLOptionEntry::COLOR: + view = new ColorOptionView(name, tooltip, (ZLColorOptionEntry*)option, this, myRowCounter, fromColumn, toColumn); + break; + case ZLOptionEntry::KEY: + view = new KeyOptionView(name, tooltip, (ZLKeyOptionEntry*)option, this, myRowCounter, fromColumn, toColumn); + break; + case ZLOptionEntry::ORDER: + //view = new OrderOptionView(name, tooltip, (ZLOrderOptionEntry*)option, this, myRowCounter, fromColumn, toColumn); + break; + case ZLOptionEntry::STATIC: + view = new StaticTextOptionView(name, tooltip, (ZLStaticTextOptionEntry*)option, this, myRowCounter, fromColumn, toColumn); + break; + } + + if (view != 0) { + view->setVisible(option->isVisible()); + addView(view); + } +} + +QWidget *ZLQtDialogContent::widget() { + return myWidget; +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtDialogManager.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtDialogManager.cpp new file mode 100644 index 0000000..d5eb4d4 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtDialogManager.cpp @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <QtGui/QApplication> +#include <QtGui/QMessageBox> +#include <QtGui/QFileDialog> +#include <QtGui/QClipboard> +#include <QtGui/QDesktopWidget> + +#include "ZLQtDialogManager.h" +#include "ZLQtDialog.h" +#include "ZLQtOptionsDialog.h" +#include "ZLQtOpenFileDialog.h" +#include "ZLQtDialogContent.h" +#include "ZLQtProgressDialog.h" +#include "ZLQtTreeDialog.h" +#include "ZLQtUtil.h" + +#include "../image/ZLQtImageManager.h" + +shared_ptr<ZLDialog> ZLQtDialogManager::createDialog(const ZLResourceKey &key) const { + myStoredWindow = qApp->activeWindow(); + return new ZLQtDialog(resource()[key]); +} + +shared_ptr<ZLOptionsDialog> ZLQtDialogManager::createOptionsDialog(const ZLResourceKey &key, shared_ptr<ZLRunnable> applyAction, bool showApplyButton) const { + myStoredWindow = qApp->activeWindow(); + return new ZLQtOptionsDialog(resource()[key], applyAction, showApplyButton); +} + +shared_ptr<ZLOpenFileDialog> ZLQtDialogManager::createOpenFileDialog(const ZLResourceKey &key, const std::string &directoryPath, const std::string &filePath, const ZLOpenFileDialog::Filter &filter) const { + return new ZLQtOpenFileDialog(dialogTitle(key), directoryPath, filePath, filter); +} + +shared_ptr<ZLTreeDialog> ZLQtDialogManager::createTreeDialog(const ZLResource &resource) const { + return new ZLQtTreeDialog(resource, myApplicationWindow); +} + +void ZLQtDialogManager::informationBox(const std::string &title, const std::string &message) const { + QWidget *parent = qApp->activeWindow(); + if (parent == 0) { + parent = myStoredWindow; + } + QMessageBox::information(parent, ::qtString(title), ::qtString(message), ::qtButtonName(OK_BUTTON)); +} + +void ZLQtDialogManager::errorBox(const ZLResourceKey &key, const std::string &message) const { + QWidget *parent = qApp->activeWindow(); + if (parent == 0) { + parent = myStoredWindow; + } + QMessageBox::critical(parent, ::qtString(dialogTitle(key)), ::qtString(message), ::qtButtonName(OK_BUTTON)); +} + +int ZLQtDialogManager::questionBox(const ZLResourceKey &key, const std::string &message, const ZLResourceKey &button0, const ZLResourceKey &button1, const ZLResourceKey &button2) const { + QWidget *parent = qApp->activeWindow(); + if (parent == 0) { + parent = myStoredWindow; + } + return QMessageBox::question(parent, ::qtString(dialogTitle(key)), ::qtString(message), ::qtButtonName(button0), ::qtButtonName(button1), ::qtButtonName(button2)); +} + +shared_ptr<ZLProgressDialog> ZLQtDialogManager::createProgressDialog(const ZLResourceKey &key, bool network) const { + return new ZLQtProgressDialog(key, network); +} + +bool ZLQtDialogManager::isClipboardSupported(ClipboardType type) const { + return true; +} + +void ZLQtDialogManager::setClipboardText(const std::string &text, ClipboardType type) const { + if (!text.empty()) { + qApp->clipboard()->setText( + ::qtString(text), + (type == CLIPBOARD_MAIN) ? QClipboard::Clipboard : QClipboard::Selection + ); + } +} + +void ZLQtDialogManager::setClipboardImage(const ZLImageData &imageData, ClipboardType type) const { + qApp->clipboard()->setImage( + *((ZLQtImageData&)imageData).image(), + (type == CLIPBOARD_MAIN) ? QClipboard::Clipboard : QClipboard::Selection + ); +} + +QWidget *ZLQtDialogManager::getApplicationWindow() const { + return myApplicationWindow; +} + +void ZLQtDialogManager::notifyApplicationWindowDeleted() { + myApplicationWindow = 0; +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtOpenFileDialog.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtOpenFileDialog.cpp new file mode 100644 index 0000000..ec9e73c --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtOpenFileDialog.cpp @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2010-2012 Geometer Plus <[email protected]> + * + * 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 <QtGui/QFileDialog> + +#include "ZLQtOpenFileDialog.h" + +ZLQtOpenFileDialog::ZLQtOpenFileDialog(const std::string &title, const std::string &directoryPath, const std::string &filePath, const Filter &filter) { + myDialog = new QFileDialog(); + myDialog->setWindowTitle(QString::fromUtf8(title.c_str())); + myDialog->setDirectory(QString::fromUtf8(directoryPath.c_str())); + myDialog->selectFile(QString::fromUtf8(filePath.c_str())); +} + +ZLQtOpenFileDialog::~ZLQtOpenFileDialog() { + delete myDialog; +} + +bool ZLQtOpenFileDialog::runInternal() { + return myDialog->exec(); +} + +std::string ZLQtOpenFileDialog::filePath() const { + QStringList paths = myDialog->selectedFiles(); + return paths.size() > 0 ? (const char*)paths[0].toUtf8() : std::string(); +} + +std::string ZLQtOpenFileDialog::directoryPath() const { + return (const char*)myDialog->directory().absolutePath().toUtf8(); +} + +void ZLQtOpenFileDialog::setPosition(int x, int y) { + myDialog->move(x, y); +} + +void ZLQtOpenFileDialog::setSize(int width, int height) { + myDialog->resize(width, height); +} + +int ZLQtOpenFileDialog::x() const { + return myDialog->x(); +} + +int ZLQtOpenFileDialog::y() const { + return myDialog->y(); +} + +int ZLQtOpenFileDialog::width() const { + return myDialog->width(); +} + +int ZLQtOpenFileDialog::height() const { + return myDialog->height(); +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtOptionView.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtOptionView.cpp new file mode 100644 index 0000000..48a1b8f --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtOptionView.cpp @@ -0,0 +1,462 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <cctype> + +#include <QtGui/QCheckBox> +#include <QtGui/QComboBox> +#include <QtGui/QLabel> +#include <QtGui/QGroupBox> +#include <QtGui/QRadioButton> +#include <QtGui/QPushButton> +#include <QtGui/QSpinBox> +#include <QtGui/QLineEdit> +#include <QtGui/QSlider> +#include <QtGui/QLayout> + +#include <ZLStringUtil.h> +#include <ZLDialogManager.h> +#include "../util/ZLQtKeyUtil.h" + +#include "ZLQtOptionView.h" +#include "ZLQtDialogContent.h" +#include "ZLQtUtil.h" + +void ZLQtOptionView::_show() { + for (std::vector<QWidget*>::iterator it = myWidgets.begin(); it != myWidgets.end(); ++it) { + (*it)->show(); + } +} + +void ZLQtOptionView::_hide() { + for (std::vector<QWidget*>::iterator it = myWidgets.begin(); it != myWidgets.end(); ++it) { + (*it)->hide(); + } +} + +void BooleanOptionView::_createItem() { + myCheckBox = new QCheckBox(::qtString(ZLOptionView::name()), myTab->widget()); + myCheckBox->setChecked(((ZLBooleanOptionEntry&)*myOption).initialState()); + myWidgets.push_back(myCheckBox); + myTab->addItem(myCheckBox, myRow, myFromColumn, myToColumn); + connect(myCheckBox, SIGNAL(toggled(bool)), this, SLOT(onStateChanged(bool))); +} + +void BooleanOptionView::_setActive(bool active) { + myCheckBox->setEnabled(active); +} + +void BooleanOptionView::_onAccept() const { + ((ZLBooleanOptionEntry&)*myOption).onAccept(myCheckBox->isChecked()); +} + +void BooleanOptionView::onStateChanged(bool state) const { + ((ZLBooleanOptionEntry&)*myOption).onStateChanged(state); +} + +void Boolean3OptionView::_createItem() { + myCheckBox = new QCheckBox(::qtString(ZLOptionView::name()), myTab->widget()); + myCheckBox->setTristate(true); + Qt::CheckState state = Qt::PartiallyChecked; + switch (((ZLBoolean3OptionEntry&)*myOption).initialState()) { + case B3_FALSE: + state = Qt::Unchecked; + break; + case B3_TRUE: + state = Qt::Checked; + break; + case B3_UNDEFINED: + state = Qt::PartiallyChecked; + break; + } + myCheckBox->setCheckState(state); + myWidgets.push_back(myCheckBox); + myTab->addItem(myCheckBox, myRow, myFromColumn, myToColumn); + connect(myCheckBox, SIGNAL(stateChanged(int)), this, SLOT(onStateChanged(int))); +} + +void Boolean3OptionView::_setActive(bool active) { + myCheckBox->setEnabled(active); +} + +void Boolean3OptionView::_onAccept() const { + ZLBoolean3 value = B3_UNDEFINED; + switch (myCheckBox->checkState()) { + case Qt::Checked: + value = B3_TRUE; + break; + case Qt::Unchecked: + value = B3_FALSE; + break; + case Qt::PartiallyChecked: + value = B3_UNDEFINED; + break; + } + ((ZLBoolean3OptionEntry&)*myOption).onAccept(value); +} + +void Boolean3OptionView::onStateChanged(int state) const { + ZLBoolean3 value = B3_UNDEFINED; + switch (state) { + case Qt::Checked: + value = B3_TRUE; + break; + case Qt::Unchecked: + value = B3_FALSE; + break; + case Qt::PartiallyChecked: + value = B3_UNDEFINED; + break; + } + ((ZLBoolean3OptionEntry&)*myOption).onStateChanged(value); +} + +void ChoiceOptionView::_createItem() { + myGroupBox = new QGroupBox(::qtString(ZLOptionView::name())); + myWidgets.push_back(myGroupBox); + QVBoxLayout *layout = new QVBoxLayout(myGroupBox); + myButtons = new QRadioButton*[((ZLChoiceOptionEntry&)*myOption).choiceNumber()]; + for (int i = 0; i < ((ZLChoiceOptionEntry&)*myOption).choiceNumber(); ++i) { + myButtons[i] = new QRadioButton(myGroupBox); + myButtons[i]->setText(::qtString(((ZLChoiceOptionEntry&)*myOption).text(i))); + layout->addWidget(myButtons[i]); + } + myButtons[((ZLChoiceOptionEntry&)*myOption).initialCheckedIndex()]->setChecked(true); + myTab->addItem(myGroupBox, myRow, myFromColumn, myToColumn); +} + +void ChoiceOptionView::_setActive(bool active) { + myGroupBox->setEnabled(active); +} + +void ChoiceOptionView::_onAccept() const { + for (int i = 0; i < ((ZLChoiceOptionEntry&)*myOption).choiceNumber(); ++i) { + if (myButtons[i]->isChecked()) { + ((ZLChoiceOptionEntry&)*myOption).onAccept(i); + return; + } + } +} + +void ComboOptionView::_createItem() { + const ZLComboOptionEntry &comboOption = (ZLComboOptionEntry&)*myOption; + QLabel *label = 0; + const std::string &name = ZLOptionView::name(); + if (!name.empty()) { + label = new QLabel(::qtString(name), myTab->widget()); + } + myComboBox = new QComboBox(myTab->widget()); + myComboBox->setEditable(comboOption.isEditable()); + + if (label != 0) { + myWidgets.push_back(label); + } + myWidgets.push_back(myComboBox); + + connect(myComboBox, SIGNAL(activated(int)), this, SLOT(onValueSelected(int))); + connect(myComboBox, SIGNAL(editTextChanged(const QString&)), this, SLOT(onValueEdited(const QString&))); + + if (label != 0) { + int width = myToColumn - myFromColumn + 1; + myTab->addItem(label, myRow, myFromColumn, myFromColumn + width / 2 - 1); + myTab->addItem(myComboBox, myRow, myFromColumn + width / 2, myToColumn); + } else { + myTab->addItem(myComboBox, myRow, myFromColumn, myToColumn); + } + + reset(); +} + +void ComboOptionView::reset() { + if (myComboBox == 0) { + return; + } + + const int count = myComboBox->count(); + for (int i = 0; i < count; ++i) { + myComboBox->removeItem(0); + } + + const ZLComboOptionEntry &comboOption = (ZLComboOptionEntry&)*myOption; + const std::vector<std::string> &values = comboOption.values(); + const std::string &initial = comboOption.initialValue(); + int selectedIndex = -1; + int index = 0; + for (std::vector<std::string>::const_iterator it = values.begin(); it != values.end(); ++it, ++index) { + myComboBox->insertItem(it - values.begin(), ::qtString(*it)); + if (*it == initial) { + selectedIndex = index; + } + } + if (selectedIndex >= 0) { + myComboBox->setCurrentIndex(selectedIndex); + } +} + +void ComboOptionView::_setActive(bool active) { + myComboBox->setEnabled(active); +} + +void ComboOptionView::_onAccept() const { + ((ZLComboOptionEntry&)*myOption).onAccept((const char*)myComboBox->currentText().toUtf8()); +} + +void ComboOptionView::onValueSelected(int index) { + ZLComboOptionEntry &o = (ZLComboOptionEntry&)*myOption; + if ((index >= 0) && (index < (int)o.values().size())) { + o.onValueSelected(index); + } +} + +void ComboOptionView::onValueEdited(const QString &value) { + ZLComboOptionEntry &o = (ZLComboOptionEntry&)*myOption; + if (o.useOnValueEdited()) { + o.onValueEdited((const char*)value.toUtf8()); + } +} + +void SpinOptionView::_createItem() { + ZLSpinOptionEntry &entry = (ZLSpinOptionEntry&)*myOption; + QLabel *label = new QLabel(::qtString(ZLOptionView::name()), myTab->widget()); + mySpinBox = new QSpinBox(myTab->widget()); + + myWidgets.push_back(label); + myWidgets.push_back(mySpinBox); + + mySpinBox->setMinimum(entry.minValue()); + mySpinBox->setMaximum(entry.maxValue()); + mySpinBox->setSingleStep(entry.step()); + mySpinBox->setValue(entry.initialValue()); + int width = myToColumn - myFromColumn + 1; + myTab->addItem(label, myRow, myFromColumn, myFromColumn + width / 2 - 1); + myTab->addItem(mySpinBox, myRow, myFromColumn + width / 2, myToColumn); +} + +void SpinOptionView::_onAccept() const { + ((ZLSpinOptionEntry&)*myOption).onAccept(mySpinBox->value()); +} + +void StringOptionView::_createItem() { + myLineEdit = new QLineEdit(myTab->widget()); + myLineEdit->setEchoMode(myPasswordMode ? QLineEdit::Password : QLineEdit::Normal); + myWidgets.push_back(myLineEdit); + connect(myLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(onValueEdited(const QString&))); + if (!ZLOptionView::name().empty()) { + QLabel *label = new QLabel(::qtString(ZLOptionView::name()), myTab->widget()); + myWidgets.push_back(label); + int width = myToColumn - myFromColumn + 1; + myTab->addItem(label, myRow, myFromColumn, myFromColumn + width / 2 - 1); + myTab->addItem(myLineEdit, myRow, myFromColumn + width / 2, myToColumn); + } else { + myTab->addItem(myLineEdit, myRow, myFromColumn, myToColumn); + } + reset(); +} + +void StringOptionView::_setActive(bool active) { + myLineEdit->setReadOnly(!active); +} + +void StringOptionView::_onAccept() const { + ((ZLStringOptionEntry&)*myOption).onAccept((const char*)myLineEdit->text().toUtf8()); +} + +void StringOptionView::reset() { + if (myLineEdit == 0) { + return; + } + myLineEdit->setText(::qtString(((ZLStringOptionEntry&)*myOption).initialValue())); + myLineEdit->cursorForward(false, -myLineEdit->text().length()); +} + +void StringOptionView::onValueEdited(const QString &value) { + ZLStringOptionEntry &o = (ZLStringOptionEntry&)*myOption; + if (o.useOnValueEdited()) { + o.onValueEdited((const char*)value.toUtf8()); + } +} + +class KeyLineEdit : public QLineEdit { + +public: + KeyLineEdit(KeyOptionView &keyView, QWidget *parent); + +protected: + void focusInEvent(QFocusEvent*); + void focusOutEvent(QFocusEvent*); + void keyPressEvent(QKeyEvent *keyEvent); + +private: + KeyOptionView &myKeyView; +}; + +KeyLineEdit::KeyLineEdit(KeyOptionView &keyView, QWidget *parent) : QLineEdit(parent), myKeyView(keyView) { + focusOutEvent(0); +} + +void KeyLineEdit::keyPressEvent(QKeyEvent *keyEvent) { + std::string keyText = ZLQtKeyUtil::keyName(keyEvent); + setText(keyText.c_str()); + if (!keyText.empty()) { + myKeyView.myCurrentKey = keyText; + myKeyView.myComboBox->setCurrentIndex(((ZLKeyOptionEntry&)*myKeyView.myOption).actionIndex(keyText)); + myKeyView.myComboBox->show(); + } + ((ZLKeyOptionEntry&)*myKeyView.myOption).onKeySelected(keyText); +} + +void KeyLineEdit::focusInEvent(QFocusEvent*) { + grabKeyboard(); +} + +void KeyLineEdit::focusOutEvent(QFocusEvent*) { + releaseKeyboard(); +} + +void KeyOptionView::_createItem() { + QWidget *widget = new QWidget(myTab->widget()); + QGridLayout *layout = new QGridLayout(widget); + + QLabel *label = new QLabel(widget); + label->setText(::qtString(ZLResource::resource("keyOptionView")["actionFor"].value())); + layout->addWidget(label, 0, 0); + + myKeyEditor = new KeyLineEdit(*this, widget); + layout->addWidget(myKeyEditor, 0, 1); + + myWidgets.push_back(widget); + myWidgets.push_back(label); + myWidgets.push_back(myKeyEditor); + + myComboBox = new QComboBox(widget); + const std::vector<std::string> &actions = ((ZLKeyOptionEntry&)*myOption).actionNames(); + for (std::vector<std::string>::const_iterator it = actions.begin(); it != actions.end(); ++it) { + myComboBox->insertItem(it - actions.begin(), ::qtString(*it)); + } + connect(myComboBox, SIGNAL(activated(int)), this, SLOT(onValueChanged(int))); + layout->addWidget(myComboBox, 1, 0, 1, 2); + myTab->addItem(widget, myRow, myFromColumn, myToColumn); +} + +void KeyOptionView::reset() { + if (myKeyEditor == 0) { + return; + } + myCurrentKey.erase(); + myKeyEditor->setText(""); + ((ZLKeyOptionEntry&)*myOption).onKeySelected(myCurrentKey); + myComboBox->hide(); +} + +void KeyOptionView::_show() { + ZLQtOptionView::_show(); + if (!myCurrentKey.empty()) { + myComboBox->show(); + } else { + myComboBox->hide(); + } +} + +void KeyOptionView::_hide() { + ZLQtOptionView::_hide(); + myComboBox->hide(); + myCurrentKey.erase(); + myKeyEditor->setText(""); + ((ZLKeyOptionEntry&)*myOption).onKeySelected(myCurrentKey); +} + +void KeyOptionView::_onAccept() const { + ((ZLKeyOptionEntry&)*myOption).onAccept(); +} + +void KeyOptionView::onValueChanged(int index) { + if (!myCurrentKey.empty()) { + ((ZLKeyOptionEntry&)*myOption).onValueChanged(myCurrentKey, index); + } +} + +QSlider *ColorOptionView::createColorSlider(QGridLayout *layout, int index, const ZLResource &resource, int value) { + layout->addWidget(new QLabel(::qtString(resource.value()), layout->parentWidget()), index, 0); + QSlider *slider = new QSlider(Qt::Horizontal, layout->parentWidget()); + layout->addWidget(slider, index, 1); + slider->setMinimum(0); + slider->setMaximum(255); + slider->setSingleStep(5); + slider->setTracking(true); + slider->setValue(value); + connect(slider, SIGNAL(sliderMoved(int)), this, SLOT(onSliderMove(int))); + return slider; +} + +void ColorOptionView::_createItem() { + QWidget *widget = new QWidget(myTab->widget()); + myWidgets.push_back(widget); + QGridLayout *layout = new QGridLayout(widget); + const ZLColor &color = ((ZLColorOptionEntry&)*myOption).color(); + const ZLResource &resource = ZLResource::resource(ZLDialogManager::COLOR_KEY); + myRSlider = createColorSlider(layout, 0, resource["red"], color.Red); + myGSlider = createColorSlider(layout, 1, resource["green"], color.Green); + myBSlider = createColorSlider(layout, 2, resource["blue"], color.Blue); + + myColorBar = new QLabel(" ", widget); + QPalette palette = myColorBar->palette(); + palette.setColor(myColorBar->backgroundRole(), QColor(color.Red, color.Green, color.Blue)); + myColorBar->setPalette(palette); + myColorBar->setFrameStyle(QFrame::Panel | QFrame::Plain); + layout->addWidget(myColorBar, 0, 2, 3, 1); + myColorBar->setAutoFillBackground(true); + + myTab->addItem(widget, myRow, myFromColumn, myToColumn); +} + +void ColorOptionView::reset() { + if (myColorBar == 0) { + return; + } + ZLColorOptionEntry &colorEntry = (ZLColorOptionEntry&)*myOption; + colorEntry.onReset(ZLColor(myRSlider->value(), myGSlider->value(), myBSlider->value())); + const ZLColor &color = colorEntry.color(); + myRSlider->setValue(color.Red); + myGSlider->setValue(color.Green); + myBSlider->setValue(color.Blue); + QPalette palette = myColorBar->palette(); + palette.setColor(myColorBar->backgroundRole(), QColor(color.Red, color.Green, color.Blue)); + myColorBar->setPalette(palette); +} + +void ColorOptionView::onSliderMove(int) { + QPalette palette = myColorBar->palette(); + palette.setColor(myColorBar->backgroundRole(), QColor(myRSlider->value(), myGSlider->value(), myBSlider->value())); + myColorBar->setPalette(palette); +} + +void ColorOptionView::_onAccept() const { + ((ZLColorOptionEntry&)*myOption).onAccept(ZLColor(myRSlider->value(), myGSlider->value(), myBSlider->value())); +} + +void StaticTextOptionView::_createItem() { + const std::string &text = ((ZLStaticTextOptionEntry&)*myOption).initialValue(); + QLabel *label = new QLabel(::qtString(text), myTab->widget()); + myWidgets.push_back(label); + myTab->addItem(label, myRow, myFromColumn, myToColumn); +} + +void StaticTextOptionView::_onAccept() const { +} + diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtOptionsDialog.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtOptionsDialog.cpp new file mode 100644 index 0000000..f6c36fb --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtOptionsDialog.cpp @@ -0,0 +1,100 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <QtGui/QApplication> +#include <QtGui/QDesktopWidget> +#include <QtGui/QLayout> +#include <QtGui/QPushButton> +#include <QtGui/QButtonGroup> +#include <QtGui/QResizeEvent> + +#include <ZLDialogManager.h> + +#include "ZLQtOptionsDialog.h" +#include "ZLQtDialogContent.h" +#include "ZLQtUtil.h" + +ZLQtOptionsDialog::ZLQtOptionsDialog(const ZLResource &resource, shared_ptr<ZLRunnable> applyAction, bool showApplyButton) : QDialog(qApp->activeWindow()), ZLDesktopOptionsDialog(resource, applyAction) { + setModal(true); + setWindowTitle(::qtString(caption())); + QVBoxLayout *layout = new QVBoxLayout(this); + + myTabWidget = new QTabWidget(this); + layout->addWidget(myTabWidget); + + QWidget *group = new QWidget(this); + layout->addWidget(group); + QGridLayout *buttonLayout = new QGridLayout(group); + buttonLayout->setColumnStretch(0, 3); + + QPushButton *okButton = new QPushButton(group); + okButton->setText(::qtButtonName(ZLDialogManager::OK_BUTTON)); + buttonLayout->addWidget(okButton, 0, 1); + connect(okButton, SIGNAL(clicked()), this, SLOT(accept())); + + QPushButton *cancelButton = new QPushButton(group); + cancelButton->setText(::qtButtonName(ZLDialogManager::CANCEL_BUTTON)); + buttonLayout->addWidget(cancelButton, 0, 2); + connect(cancelButton, SIGNAL(clicked()), this, SLOT(reject())); + + if (showApplyButton) { + QPushButton *applyButton = new QPushButton(group); + applyButton->setText(::qtButtonName(ZLDialogManager::APPLY_BUTTON)); + buttonLayout->addWidget(applyButton, 0, 3); + connect(applyButton, SIGNAL(clicked()), this, SLOT(apply())); + } + + if (parent() == 0) { + QDesktopWidget *desktop = qApp->desktop(); + if (desktop != 0) { + move((desktop->width() - width()) / 2, (desktop->height() - height()) / 2); + } + } +} + +void ZLQtOptionsDialog::apply() { + ZLOptionsDialog::accept(); +} + +ZLDialogContent &ZLQtOptionsDialog::createTab(const ZLResourceKey &key) { + ZLQtDialogContent *tab = new ZLQtDialogContent(new QWidget(myTabWidget), tabResource(key)); + myTabWidget->addTab(tab->widget(), ::qtString(tab->displayName())); + myTabs.push_back(tab); + return *tab; +} + +const std::string &ZLQtOptionsDialog::selectedTabKey() const { + return myTabs[myTabWidget->currentIndex()]->key(); +} + +void ZLQtOptionsDialog::selectTab(const ZLResourceKey &key) { + for (std::vector<shared_ptr<ZLDialogContent> >::const_iterator it = myTabs.begin(); it != myTabs.end(); ++it) { + if ((*it)->key() == key.Name) { + myTabWidget->setCurrentWidget(((ZLQtDialogContent&)**it).widget()); + break; + } + } +} + +bool ZLQtOptionsDialog::runInternal() { + for (std::vector<shared_ptr<ZLDialogContent> >::iterator it = myTabs.begin(); it != myTabs.end(); ++it) { + ((ZLQtDialogContent&)**it).close(); + } + return exec() == QDialog::Accepted; +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtOptionsDialog.h b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtOptionsDialog.h new file mode 100644 index 0000000..e38b62a --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtOptionsDialog.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 __ZLQTOPTIONSDIALOG_H__ +#define __ZLQTOPTIONSDIALOG_H__ + +#include <QtGui/QWidget> +#include <QtGui/QTabWidget> +#include <QtGui/QDialog> + +#include "../../../../core/src/desktop/dialogs/ZLDesktopOptionsDialog.h" + +class ZLQtOptionsDialog : public QDialog, public ZLDesktopOptionsDialog { + Q_OBJECT + +public: + ZLQtOptionsDialog(const ZLResource &resource, shared_ptr<ZLRunnable> applyAction, bool showApplyButton); + ZLDialogContent &createTab(const ZLResourceKey &key); + +protected: + const std::string &selectedTabKey() const; + void selectTab(const ZLResourceKey &key); + bool runInternal(); + + void setSize(int width, int height) { QDialog::resize(width, height); } + int width() const { return QDialog::width(); } + int height() const { return QDialog::height(); } + +private Q_SLOTS: + void apply(); + +private: + QTabWidget *myTabWidget; +}; + +#endif /* __ZLQTOPTIONSDIALOG_H__ */ diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtProgressDialog.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtProgressDialog.cpp new file mode 100644 index 0000000..98e469e --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtProgressDialog.cpp @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <unistd.h> + +#include <QtGui/QApplication> +#include <QtGui/QDesktopWidget> +#include <QtGui/QWidget> +#include <QtGui/QLabel> +#include <QtGui/QLayout> +#include <QtCore/QThreadPool> + +#include "../dialogs/ZLQtDialogManager.h" +#include "ZLQtProgressDialog.h" +#include "ZLQtUtil.h" + +ZLQtProgressDialog::ZLQtProgressDialog(const ZLResourceKey &key, bool network) : ZLProgressDialog(key), myIsNetworkRunnable(network), myActiveWindow(0) { +} + +void ZLQtProgressDialog::run(ZLRunnable &runnable) { + myActiveWindow = static_cast<ZLQtDialogManager&>(ZLDialogManager::Instance()).getApplicationWindow(); + if (myActiveWindow != 0) { + myActiveWindow->setCursor(Qt::WaitCursor); + } + + ZLQtWaitDialog* dialog = new ZLQtWaitDialog(messageText(), myActiveWindow); + dialog->setCursor(Qt::WaitCursor); + + if (myIsNetworkRunnable) { + dialog->show(); + runnable.run(); + dialog->hide(); + } else { + ZLQtRunnableWrapper* wrapper = new ZLQtRunnableWrapper(runnable); + wrapper->setAutoDelete(true); + QObject::connect(wrapper, SIGNAL(finished()), dialog, SLOT(close()), Qt::QueuedConnection); + QThreadPool::globalInstance()->start(wrapper); + dialog->exec(); + } + dialog->deleteLater(); + restoreCursor(); +} + +void ZLQtProgressDialog::restoreCursor() { + if (myActiveWindow != 0) { + myActiveWindow->setCursor(Qt::ArrowCursor); + } +} + + +void ZLQtProgressDialog::setMessage(const std::string &message) { + //qDebug() << QString::fromStdString(message); + //TODO implement +} + +ZLQtWaitDialog::ZLQtWaitDialog(const std::string &message, QWidget* parent) : QDialog(parent) { + setWindowFlags((windowFlags() | Qt::CustomizeWindowHint) ^ Qt::WindowCloseButtonHint); //hide close button + myLayout = new QVBoxLayout; + + myLabel = new QLabel(::qtString(message)); + myLabel->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter); + myLabel->setWordWrap(true); + + myProgressBar = new QProgressBar; + myProgressBar->setRange(0,0); + //myProgressBar->setFixedWidth( qApp->desktop()->availableGeometry().width()*COEF_PROGRESS_BAR_WIDTH ); + + myLayout->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter); + + myLayout->addWidget(myLabel); + myLayout->addWidget(myProgressBar); + + this->setLayout(myLayout); +} + +ZLQtRunnableWrapper::ZLQtRunnableWrapper(ZLRunnable &runnable) : myRunnable(runnable) { +} + +void ZLQtRunnableWrapper::run() { + myRunnable.run(); + emit finished(); +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtProgressDialog.h b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtProgressDialog.h new file mode 100644 index 0000000..df6c73b --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtProgressDialog.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 __ZLQTWAITMESSAGE_H__ +#define __ZLQTWAITMESSAGE_H__ + +#include <string> + +#include <QtGui/QWidget> +#include <QtGui/QCursor> +#include <QtGui/QDialog> +#include <QtGui/QProgressBar> +#include <QtGui/QLabel> +#include <QtCore/QRunnable> + +#include <ZLProgressDialog.h> + +class QLabel; +class QLayout; + +class ZLQtWaitDialog : public QDialog { + +public: + ZLQtWaitDialog(const std::string &message, QWidget* parent = 0); + +private: + QLayout* myLayout; + QLabel* myLabel; + QProgressBar* myProgressBar; + +friend class ZLQtProgressDialog; +}; + + +class ZLQtProgressDialog : public ZLProgressDialog { + +public: + ZLQtProgressDialog(const ZLResourceKey &key, bool network); + +private: + void run(ZLRunnable &runnable); + void setMessage(const std::string &message); + void restoreCursor(); + +private: + bool myIsNetworkRunnable; + QWidget* myActiveWindow; +}; + +class ZLQtRunnableWrapper : public QObject, public QRunnable { + Q_OBJECT; +public: + ZLQtRunnableWrapper(ZLRunnable& runnable); + void run(); +Q_SIGNALS: + void finished(); +private: + ZLRunnable& myRunnable; +}; + +#endif /* __ZLQTWAITMESSAGE_H__ */ diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtTreeDialog.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtTreeDialog.cpp new file mode 100644 index 0000000..65530be --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtTreeDialog.cpp @@ -0,0 +1,347 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <algorithm> + +#include <QtGui/QSplitter> +#include <QtGui/QVBoxLayout> +#include <QtGui/QHBoxLayout> +#include <QtGui/QScrollBar> +#include <QtGui/QResizeEvent> +#include <QtCore/QDebug> + +#include <ZLFile.h> +#include <ZLibrary.h> +#include <ZLTreePageNode.h> +#include <ZLFile.h> + +#include "../tree/ZLQtItemsListWidget.h" +#include "../tree/ZLQtPreviewWidget.h" + +#include "ZLQtTreeDialog.h" + +static const int DIALOG_WIDTH_HINT = 840; + +ZLQtTreeDialog::ZLQtTreeDialog(const ZLResource &res, QWidget *parent) : + QDialog(parent), ZLTreeDialog(res), myLastClickedNode(0), myLastClickedSearchNode(0) { + setWindowTitle(QString::fromStdString(resource().value())); //TODO maybe user resources by other way + setMinimumSize(400, 260); //minimum sensible size + + myListWidget = new ZLQtItemsListWidget; + myPreviewWidget = new ZLQtPreviewWidget; + myBackButton = new ZLQtIconButton("back_button.png", "back_button_disabled.png"); + myForwardButton = new ZLQtIconButton("forward_button.png", "forward_button_disabled.png"); + mySearchField = new ZLQtSearchField; + + myBackButton->setAutoDefault(false); + myForwardButton->setAutoDefault(false); + + QVBoxLayout *mainLayout = new QVBoxLayout; + QHBoxLayout *panelLayout = new QHBoxLayout; + + QSplitter *splitter = new QSplitter; + splitter->setChildrenCollapsible(false); + splitter->addWidget(myListWidget); + splitter->addWidget(myPreviewWidget); + + const int scrollbarWidth = 30; //myListWidget->verticalScrollBar()->width() * 2; //commented because with Qt::ScrollBarAsNeeded policy the size is too big + splitter->setSizes(QList<int>() << DIALOG_WIDTH_HINT / 2 + scrollbarWidth << DIALOG_WIDTH_HINT / 2 - scrollbarWidth); //50/50 default size + + mainLayout->setSizeConstraint(QLayout::SetMinAndMaxSize); + + panelLayout->setSpacing(0); + panelLayout->addWidget(myBackButton); + panelLayout->addWidget(myForwardButton); + panelLayout->addStretch(); + panelLayout->addWidget(mySearchField); + + mainLayout->addLayout(panelLayout); + mainLayout->addWidget(splitter); + this->setLayout(mainLayout); + + connect(myListWidget, SIGNAL(nodeClicked(ZLQtTreeItem*)), this, SLOT(onNodeClicked(ZLQtTreeItem*))); + connect(myListWidget, SIGNAL(nodeDoubleClicked(ZLQtTreeItem*)), this, SLOT(onNodeDoubleClicked(ZLQtTreeItem*))); + connect(myBackButton, SIGNAL(clicked()), this, SLOT(onBackButton())); + connect(myForwardButton, SIGNAL(clicked()), this, SLOT(onForwardButton())); + connect(mySearchField, SIGNAL(returnPressed()), this, SLOT(onSearchField())); + connect(myListWidget, SIGNAL(wantMoreChildren()), this, SLOT(onMoreChildren())); +} + +void ZLQtTreeDialog::run(ZLTreeNode *rootNode) { + myRootNode = rootNode; + myBackHistory.clear(); + myForwardHistory.clear(); + onExpandRequest(myRootNode); //TODO make generic async loading + show(); + myListWidget->setFocus(); +} + +void ZLQtTreeDialog::onCloseRequest() { + hide(); +} + +QSize ZLQtTreeDialog::sizeHint() const { + return QSize(DIALOG_WIDTH_HINT + myListWidget->verticalScrollBar()->width(), 0); +} + +void ZLQtTreeDialog::resizeEvent(QResizeEvent *event){ + int width = event->size().width(); + int listWidth = width / 3; + int previewWidth = width / 3; + myListWidget->setMinimumWidth(listWidth); + myPreviewWidget->setMinimumWidth(previewWidth); +} + +void ZLQtTreeDialog::onExpandRequest(ZLTreeNode *node) { + myLastClickedNode = node; + node->requestChildren(new ChildrenRequestListener(this, node, false)); +} + +void ZLQtTreeDialog::onMoreChildrenRequest(ZLTreeNode *node) { + //TODO implement the way to not sending new request for more children + //qDebug() << Q_FUNC_INFO << node << node->children().size(); + //TODO don't ask many times + node->requestMoreChildren(new ChildrenRequestListener(this, node, true)); +} + +void ZLQtTreeDialog::onChildrenLoaded(ZLTreeNode *node, bool checkLast, bool successLoaded) { + if (!successLoaded) { + return; + } + if (node->children().empty()) { + return; + } + if (checkLast) { + if (node != myLastClickedNode) { //load just last clicked item + return; + } + } + saveShowParameters(); + myLastClickedNode = 0; //for case if item has been requested for several times + myBackHistory.push(node); + myForwardHistory.clear(); + if (!myBackHistory.empty()) { + myListWidget->fillNodes(myBackHistory.top()); + } + //myListWidget->verticalScrollBar()->setValue(myListWidget->verticalScrollBar()->minimum()); //to the top + setupShowParameters(); + updateAll(); + +} + +void ZLQtTreeDialog::onMoreChildrenLoaded(bool successLoaded) { + if (!successLoaded) { + return; + } + if (!myBackHistory.empty()) { + myListWidget->fillNewNodes(myBackHistory.top()); + } + updateAll(); +} + +void ZLQtTreeDialog::updateAll() { + updateNavigationButtons(); + updateWaitingIcons(); +} + +void ZLQtTreeDialog::updateWaitingIcons() { + foreach(ZLQtTreeItem *item, myListWidget->getItems()) { + ZLTreeNode *node = item->getNode(); + if (myDownloadingNodes.contains(node)) { + item->getWaitingIcon()->start(); + } else { + item->getWaitingIcon()->finish(); + } + } +} + +void ZLQtTreeDialog::onNodeUpdated(ZLTreeNode *node) { + if (!myBackHistory.empty() && myBackHistory.top() == node) { + onMoreChildrenLoaded(true); + return; + } + + foreach(ZLQtTreeItem *item, myListWidget->getItems()) { + if (node == item->getNode()) { + if (ZLTreeTitledNode *titledNode = zlobject_cast<ZLTreeTitledNode*>(node)) { + item->fill(titledNode); + updateAll(); + break; + } + } + } +} + +void ZLQtTreeDialog::onDownloadingStarted(ZLTreeNode *node) { + myDownloadingNodes.insert(node); + updateWaitingIcons(); +} + +void ZLQtTreeDialog::onDownloadingStopped(ZLTreeNode *node) { + myDownloadingNodes.remove(node); + updateWaitingIcons(); +} + +void ZLQtTreeDialog::onSearchStarted(ZLTreeNode *node) { + //TODO what in case if different searches started or stopped? + myLastClickedSearchNode = node; + mySearchField->getWaitingIcon()->start(); +} + +void ZLQtTreeDialog::onSearchStopped(ZLTreeNode *node) { + if (node == myLastClickedSearchNode) { + myLastClickedSearchNode = 0; + mySearchField->getWaitingIcon()->finish(); + } +} + +void ZLQtTreeDialog::onRefresh() { + myPreviewWidget->refresh(); + //TODO maybe add other refreshes? (list widget, for i.e.) +} + +void ZLQtTreeDialog::updateNavigationButtons() { + myBackButton->setEnabled(myBackHistory.size() > 1); + myForwardButton->setEnabled(!myForwardHistory.empty()); +} + +void ZLQtTreeDialog::saveShowParameters() { + if (myBackHistory.empty()) { + return; + } + ShowParameter parameter; + parameter.sliderPosition = myListWidget->verticalScrollBar()->value(); + parameter.activeItemNumber = -1; + for (int i = 0; i < myListWidget->getItems().size(); ++i) { + if (myListWidget->getItems().at(i)->isActive()) { + parameter.activeItemNumber = i; + break; + } + } + myShowParameters.insert(myBackHistory.top(), parameter); +} + +void ZLQtTreeDialog::setupShowParameters() { + if (myBackHistory.empty()) { + return; + } + if (!myShowParameters.contains(myBackHistory.top())) { + myPreviewWidget->clear(); + return; + } + //TODO implement setting a slider position + ShowParameter parameter = myShowParameters.value(myBackHistory.top()); + if (parameter.activeItemNumber != -1 && myListWidget->getItems().size() > parameter.activeItemNumber) { + myListWidget->onNodeClicked(myListWidget->getItems().at(parameter.activeItemNumber)); + } else { + myPreviewWidget->clear(); + } +} + +void ZLQtTreeDialog::onNodeClicked(ZLQtTreeItem* item) { + ZLTreeNode* node = item->getNode(); + myPreviewWidget->show(node); +} + +void ZLQtTreeDialog::onNodeDoubleClicked(ZLQtTreeItem* item) { + const ZLTreeNode* node = item->getNode(); + if (const ZLTreePageNode *pageNode = zlobject_cast<const ZLTreePageNode*>(node)) { + (void)pageNode; + //TODO maybe use different kind of check + //isExpandable method for i.e. + return; + } + onExpandRequest(item->getNode()); +} + +void ZLQtTreeDialog::onBackButton() { + if (myBackHistory.size() <= 1) { + return; + } + saveShowParameters(); + myLastClickedNode = 0; + myForwardHistory.push(myBackHistory.pop()); + myListWidget->fillNodes(myBackHistory.top()); + updateAll(); + setupShowParameters(); +} + +void ZLQtTreeDialog::onForwardButton() { + if (myForwardHistory.empty()) { + return; + } + saveShowParameters(); + myLastClickedNode = 0; + myBackHistory.push(myForwardHistory.pop()); + if (!myBackHistory.empty()) { + myListWidget->fillNodes(myBackHistory.top()); + } + updateAll(); + setupShowParameters(); +} + +void ZLQtTreeDialog::onSearchField() { + if (mySearcher.isNull()) { + return; + } + if (mySearchField->text().isEmpty()) { + return; + } + mySearcher->simpleSearch(mySearchField->text().toStdString()); +} + +void ZLQtTreeDialog::onMoreChildren() { + if (!myBackHistory.empty()) { + onMoreChildrenRequest(myBackHistory.top()); + } +} + +ZLQtTreeDialog::ChildrenRequestListener::ChildrenRequestListener(ZLQtTreeDialog *dialog, ZLTreeNode *node, bool moreMode) : + myTreeDialog(dialog), myNode(node), myMoreMode(moreMode) { +} + +void ZLQtTreeDialog::ChildrenRequestListener::finished(const std::string &error) { + if (!error.empty()) { + //TODO show error message? + } + if (!myMoreMode) { + myTreeDialog->onChildrenLoaded(myNode, true, error.empty()); + } else { + myTreeDialog->onMoreChildrenLoaded(error.empty()); + } + +} + +ZLQtIconButton::ZLQtIconButton(const std::string &iconEnabled, const std::string &iconDisabled, QWidget *parent) : QPushButton(parent) { + static std::string imagePrefix = ZLibrary::ApplicationImageDirectory() + ZLibrary::FileNameDelimiter; + myEnabled = QPixmap(ZLFile(imagePrefix + iconEnabled).path().c_str()); + myDisabled = QPixmap(ZLFile(imagePrefix + iconDisabled).path().c_str()); + setIconSize(myEnabled.size()); + setFixedSize(28, 22); + + //setAttribute is needed to workaround a bug on MacOS with size for QPushButton-derived subclasses + //see https://bugreports.qt-project.org/browse/QTBUG-14591 + setAttribute(Qt::WA_LayoutUsesWidgetRect); +} + +void ZLQtIconButton::setEnabled(bool enabled) { + setIcon(enabled ? myEnabled : myDisabled); + QPushButton::setEnabled(enabled); +} + diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtTreeDialog.h b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtTreeDialog.h new file mode 100644 index 0000000..9cf7c47 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/dialogs/ZLQtTreeDialog.h @@ -0,0 +1,143 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 __ZLQTTREEDIALOG_H__ +#define __ZLQTTREEDIALOG_H__ + +#include <QtCore/QStack> +#include <QtCore/QSet> +#include <QtCore/QMap> + +#include <QtGui/QDialog> +#include <QtGui/QScrollArea> +#include <QtGui/QPushButton> +#include <QtGui/QLabel> +#include <QtGui/QLineEdit> +#include <QtGui/QWidget> + +#include <ZLTreeDialog.h> + +#include "../tree/ZLQtItemsListWidget.h" +#include "../tree/ZLQtPreviewWidget.h" +#include "../tree/ZLQtSearchField.h" + +class ZLQtIconButton; + +class ZLQtTreeDialog : public QDialog, public ZLTreeDialog { + Q_OBJECT +public: + ZLQtTreeDialog(const ZLResource &resource, QWidget *parent = 0); + +public: + void run(ZLTreeNode *rootNode); + +protected: + QSize sizeHint() const; + void resizeEvent(QResizeEvent *event); + +public: //listener methods + void onExpandRequest(ZLTreeNode *node); + void onCloseRequest(); + void onNodeUpdated(ZLTreeNode *node); + + void onDownloadingStarted(ZLTreeNode *node); + void onDownloadingStopped(ZLTreeNode *node); + + void onSearchStarted(ZLTreeNode *node); + void onSearchStopped(ZLTreeNode *node); + + void onRefresh(); + + void onMoreChildrenRequest(ZLTreeNode *node); + +public: + void onChildrenLoaded(ZLTreeNode *node, bool checkLast, bool success); + void onMoreChildrenLoaded(bool success); + +private: + void updateAll(); + void updateWaitingIcons(); + void updateNavigationButtons(); + +private: //TODO maybe these functions can be used as a typical updateAll() + void saveShowParameters(); + void setupShowParameters(); + +private Q_SLOTS: + void onNodeClicked(ZLQtTreeItem* item); + void onNodeDoubleClicked(ZLQtTreeItem* item); + void onBackButton(); + void onForwardButton(); + void onSearchField(); + void onMoreChildren(); + +private: + ZLTreeNode *myRootNode; + +private: + ZLQtIconButton *myBackButton; + ZLQtIconButton *myForwardButton; + ZLQtSearchField *mySearchField; +// QScrollArea *myScrollArea; + ZLQtItemsListWidget *myListWidget; + ZLQtPreviewWidget *myPreviewWidget; + + QStack<ZLTreeNode*> myBackHistory; + QStack<ZLTreeNode*> myForwardHistory; + + struct ShowParameter { + int sliderPosition; + int activeItemNumber; + }; + + QMap<ZLTreeNode*, ShowParameter> myShowParameters; + +private: + class ChildrenRequestListener : public ZLNetworkRequest::Listener { + public: + ChildrenRequestListener(ZLQtTreeDialog *dialog, ZLTreeNode *node, bool moreMode); + void finished(const std::string &error); +// const ZLTreeNode *getNode() const; + + private: + ZLQtTreeDialog *myTreeDialog; + ZLTreeNode *myNode; + bool myMoreMode; + }; + +// QList<shared_ptr<ZLNetworkRequest::Listener> > myListeners; + QSet<ZLTreeNode *> myDownloadingNodes; + const ZLTreeNode *myLastClickedNode; //used to 'last clicked item shows first after downloading' + const ZLTreeNode *myLastClickedSearchNode; //used to 'last clicked item shows first after downloading' + +friend class ChildrenRequestListener; + +}; + +class ZLQtIconButton : public QPushButton { + +public: + ZLQtIconButton(const std::string &iconEnabled, const std::string &iconDisabled, QWidget *parent = 0); + void setEnabled(bool enabled); +private: + QPixmap myEnabled; + QPixmap myDisabled; +}; + +#endif /* __ZLQTTREEDIALOG_H__ */ diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/library/ZLQApplication.h b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/library/ZLQApplication.h new file mode 100644 index 0000000..c08c536 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/library/ZLQApplication.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 __ZLQAPPLICATION_H__ +#define __ZLQAPPLICATION_H__ + +#include <QtGui/QApplication> + +class ZLQApplication : public QApplication { + +Q_OBJECT + +public: + ZLQApplication(int &argc, char **argv); + +protected: + bool event(QEvent *event); +}; + +#endif /* __ZLQAPPLICATION_H__ */ diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/library/ZLibrary.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/library/ZLibrary.cpp new file mode 100644 index 0000000..9648e95 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/library/ZLibrary.cpp @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <QtCore/QTextCodec> +#include <QtCore/QFile> +#include <QtGui/QApplication> +#include <QtGui/QFileOpenEvent> + +#include <ZLApplication.h> +#include <ZLibrary.h> +#include <ZLLanguageUtil.h> + +#include "ZLQApplication.h" +#include "../../../../core/src/unix/library/ZLibraryImplementation.h" + +#include "../filesystem/ZLQtFSManager.h" +#include "../time/ZLQtTime.h" +#include "../dialogs/ZLQtDialogManager.h" +#include "../image/ZLQtImageManager.h" +#include "../view/ZLQtPaintContext.h" +#include "../network/ZLQtNetworkManager.h" +#include "../../unix/message/ZLUnixMessage.h" +#include "../../../../core/src/util/ZLKeyUtil.h" +#include "../../../../core/src/unix/xmlconfig/XMLConfig.h" +#include "../../../../core/src/unix/iconv/IConvEncodingConverter.h" + +class ZLQtLibraryImplementation : public ZLibraryImplementation { + +private: + void init(int &argc, char **&argv); + void setStylesheet(const std::string &filename); + ZLPaintContext *createContext(); + void run(ZLApplication *application); +}; + +void initLibrary() { + new ZLQtLibraryImplementation(); +} + +ZLQApplication::ZLQApplication(int &argc, char **argv) : QApplication(argc, argv) { +} + +bool ZLQApplication::event(QEvent *e) { + switch (e->type()) { + case QEvent::FileOpen: + { + ZLFile file((const char*)static_cast<QFileOpenEvent*>(e)->file().toUtf8(), 0); + ZLApplication::Instance().openFile(file); + return true; + } + default: + return QApplication::event(e); + } +} + +void ZLQtLibraryImplementation::init(int &argc, char **&argv) { + new ZLQApplication(argc, argv); + + QTextCodec::setCodecForCStrings(QTextCodec::codecForName("utf-8")); + + ZLibrary::parseArguments(argc, argv); + + XMLConfigManager::createInstance(); + ZLQtTimeManager::createInstance(); + ZLQtFSManager::createInstance(); + ZLQtDialogManager::createInstance(); + ZLUnixCommunicationManager::createInstance(); + ZLQtImageManager::createInstance(); + ZLEncodingCollection::Instance().registerProvider(new IConvEncodingConverterProvider()); + ZLQtNetworkManager::createInstance(); + + setStylesheet("style.qss"); + ZLKeyUtil::setKeyNamesFileName("keynames-qt4.xml"); +} + +void ZLQtLibraryImplementation::setStylesheet(const std::string &filename) { + const std::string stylesheetPath = ZLibrary::ZLibraryDirectory() + ZLibrary::FileNameDelimiter + filename; + QFile file(QString::fromStdString(ZLFile(stylesheetPath).path())); + file.open(QFile::ReadOnly); + QString styleSheet = QLatin1String(file.readAll()); + qApp->setStyleSheet(styleSheet); +} + +ZLPaintContext *ZLQtLibraryImplementation::createContext() { + return new ZLQtPaintContext(); +} + +void ZLQtLibraryImplementation::run(ZLApplication *application) { + if (ZLLanguageUtil::isRTLLanguage(ZLibrary::Language())) { + qApp->setLayoutDirection(Qt::RightToLeft); + } + static_cast<ZLQtNetworkManager&>(ZLNetworkManager::Instance()).initPaths(); + ZLDialogManager::Instance().createApplicationWindow(application); + application->initWindow(); + qApp->exec(); + static_cast<ZLQtDialogManager&>(ZLDialogManager::Instance()).notifyApplicationWindowDeleted(); + delete application; +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/network/ZLQtNetworkManager.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/network/ZLQtNetworkManager.cpp new file mode 100644 index 0000000..47067d3 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/network/ZLQtNetworkManager.cpp @@ -0,0 +1,453 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <QtCore/QVector> +#include <QtCore/QStringList> +#include <QtCore/QFile> +#include <QtCore/QEventLoop> +#include <QtCore/QDir> +#include <QtCore/QList> +#include <QtCore/QTimer> + +#include <QtNetwork/QNetworkRequest> +#include <QtNetwork/QNetworkReply> +#include <QtNetwork/QNetworkProxy> +#include <QtNetwork/QSslConfiguration> +#include <QtNetwork/QSslCertificate> +#include <QtNetwork/QAuthenticator> + +#include <QtCore/QDebug> + +#include <ZLApplication.h> +#include <ZLStringUtil.h> +#include <ZLLogger.h> +#include <ZLResource.h> +#include <ZLNetworkUtil.h> + +#include "ZLQtNetworkManager.h" + +static QString fixPath(const QString &path) { + if (path.startsWith('~')) { + return QDir::homePath() + path.mid(1); + } + return path; +} + +ZLQtNetworkManager::ZLQtNetworkManager() { + myCache = new QNetworkDiskCache(&myManager); + myManager.setCache(myCache); + myCookieJar = new ZLQtNetworkCookieJar(&myManager); + myManager.setCookieJar(myCookieJar); + QObject::connect(&myManager, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)), + this, SLOT(onAuthenticationRequired(QNetworkReply*,QAuthenticator*))); + QObject::connect(&myManager, SIGNAL(finished(QNetworkReply*)), + this, SLOT(onFinished(QNetworkReply*))); +} + +ZLQtNetworkManager::~ZLQtNetworkManager() { +} + +void ZLQtNetworkManager::createInstance() { + ourInstance = new ZLQtNetworkManager(); +} + +void ZLQtNetworkManager::initPaths() { + myCookieJar->setFilePath(fixPath(QString::fromStdString(CookiesPath()))); + QDir cacheDirectory = fixPath(QString::fromStdString(CacheDirectory())); + if (!cacheDirectory.exists()) { + cacheDirectory.mkpath(cacheDirectory.absolutePath()); + } + myCache->setCacheDirectory(cacheDirectory.absolutePath()); +} + + +std::string ZLQtNetworkManager::perform(const ZLNetworkRequest::Vector &requestsList) const { + if (useProxy()) { + QString host = QString::fromStdString(proxyHost()); + QNetworkProxy proxy(QNetworkProxy::HttpProxy, host, atoi(proxyPort().c_str())); + const_cast<QNetworkAccessManager&>(myManager).setProxy(proxy); + } + QList<QNetworkReply*> replies; + QStringList errors; + QEventLoop eventLoop; + + foreach (const shared_ptr<ZLNetworkRequest> &request, requestsList) { + if (request.isNull()) { + continue; + } + //ZLNetworkRequest &request = static_cast<ZLNetworkRequest&>(*requestPtr); + QNetworkRequest networkRequest; + ZLLogger::Instance().println("network", "requesting " + request->url()); + networkRequest.setUrl(QUrl::fromUserInput(QString::fromStdString(request->url()))); + + if (!request->doBefore()) { + std::string error = request->errorMessage(); + if (error.empty()) { + const ZLResource &errorResource = ZLResource::resource("dialog")["networkError"]; + error = ZLStringUtil::printf(errorResource["somethingWrongMessage"].value(), networkRequest.url().host().toStdString()); + } + errors << QString::fromStdString(error); + continue; + } + + setHeadersAndSsl(networkRequest); + QTimer* timeoutTimer = new QTimer; + ZLQtNetworkReplyScope scope = { request, timeoutTimer, false, &replies, &errors, &eventLoop}; + prepareReply(scope, networkRequest); + } + if (!replies.isEmpty()) { + eventLoop.exec(QEventLoop::ExcludeUserInputEvents); + } + + return errors.join(QLatin1String("\n")).toStdString(); +} + +std::string ZLQtNetworkManager::performAsync(const ZLNetworkRequest::Vector &requestsList) const { + if (useProxy()) { + QString host = QString::fromStdString(proxyHost()); + QNetworkProxy proxy(QNetworkProxy::HttpProxy, host, atoi(proxyPort().c_str())); + const_cast<QNetworkAccessManager&>(myManager).setProxy(proxy); + } + + foreach (const shared_ptr<ZLNetworkRequest> &request, requestsList) { + if (request.isNull()) { + continue; + } + QNetworkRequest networkRequest; + ZLLogger::Instance().println("network", "async requesting " + request->url()); + networkRequest.setUrl(QUrl::fromUserInput(QString::fromStdString(request->url()))); + + if (!request->doBefore()) { + continue; + } + + setHeadersAndSsl(networkRequest); + QTimer* timeoutTimer = new QTimer; + ZLQtNetworkReplyScope scope = { request, timeoutTimer, false, 0, 0, 0}; + prepareReply(scope, networkRequest); + } + return std::string(); +} + +void ZLQtNetworkManager::prepareReply(ZLQtNetworkReplyScope &scope, QNetworkRequest networkRequest) const { + QNetworkReply *reply = NULL; + if (!scope.request->postParameters().empty()) { + QByteArray data; + QUrl tmp; + typedef std::pair<std::string, std::string> string_pair; + foreach (const string_pair &pair, scope.request->postParameters()) { + tmp.addQueryItem(QString::fromStdString(pair.first), QString::fromStdString(pair.second)); + } + data = tmp.encodedQuery(); + reply = const_cast<QNetworkAccessManager&>(myManager).post(networkRequest, data); + } else { + reply = const_cast<QNetworkAccessManager&>(myManager).get(networkRequest); + } + + if (scope.replies) { + scope.replies->push_back(reply); + } + + QObject::connect(reply, SIGNAL(sslErrors(QList<QSslError>)),this, SLOT(onSslErrors(QList<QSslError>))); + QObject::connect(reply, SIGNAL(readyRead()), this, SLOT(onReplyReadyRead())); + QObject::disconnect(scope.timeoutTimer, 0, this, 0); + QObject::connect(scope.timeoutTimer, SIGNAL(timeout()), this, SLOT(onTimeOut())); + reply->setProperty("scope", qVariantFromValue(scope)); + scope.timeoutTimer->setProperty("reply", qVariantFromValue(reply)); + scope.timeoutTimer->start(timeoutValue()); +} + +void ZLQtNetworkManager::onFinished(QNetworkReply *reply) { + ZLQtNetworkReplyScope scope = reply->property("scope").value<ZLQtNetworkReplyScope>(); + + if (!scope.eventLoop) { + onFinishedAsync(reply); + return; + } + + reply->deleteLater(); + scope.replies->removeOne(reply); + scope.timeoutTimer->stop(); + + if (!scope.timeoutTimer->property("expired").isValid()) { + if (handleRedirect(reply)) { + return; + } + handleHeaders(reply); + handleContent(reply); + } + + QString error = handleErrors(reply); + if (!error.isEmpty()) { + scope.errors->push_back(error); + } + if (error.isEmpty()) { + saveUserName(reply); + } + + scope.timeoutTimer->deleteLater(); + + if (!scope.request->doAfter(error.toStdString())) { + scope.errors->append(QString::fromStdString(scope.request->errorMessage())); + } + if (scope.replies->isEmpty()) { + scope.eventLoop->quit(); + } +} + +void ZLQtNetworkManager::onFinishedAsync(QNetworkReply *reply) { + ZLQtNetworkReplyScope scope = reply->property("scope").value<ZLQtNetworkReplyScope>(); + ZLLogger::Instance().println("network", "[FINISHED] async request " + scope.request->url()); + reply->deleteLater(); + scope.timeoutTimer->stop(); + + //TODO maybe timeout is working incorrect? + if (!scope.timeoutTimer->property("expired").isValid()) { + if (handleRedirect(reply)) { + return; + } + handleHeaders(reply); + handleContent(reply); + } + scope.timeoutTimer->deleteLater(); + QString error = handleErrors(reply); + if (error.isEmpty()) { + saveUserName(reply); + } + scope.request->doAfter(error.toStdString()); + return; +} + +bool ZLQtNetworkManager::handleRedirect(QNetworkReply *reply) { + ZLQtNetworkReplyScope scope = reply->property("scope").value<ZLQtNetworkReplyScope>(); + if (!scope.request->isRedirectionSupported()) { + return false; + } + QUrl redirect = reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl(); + if (!redirect.isValid()) { + return false; + } + QObject::disconnect(reply, 0, this, 0); + + QNetworkRequest request = reply->request(); + request.setUrl(reply->url().resolved(redirect)); + scope.authAskedAlready = false; + prepareReply(scope, request); + return true; +} + +void ZLQtNetworkManager::onReplyReadyRead() { + QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender()); + ZLQtNetworkReplyScope scope = reply->property("scope").value<ZLQtNetworkReplyScope>(); + scope.timeoutTimer->start(timeoutValue()); +} + +void ZLQtNetworkManager::onTimeOut() { + QTimer *timer = qobject_cast<QTimer*>(sender()); + QNetworkReply* reply = timer->property("reply").value<QNetworkReply*>(); + timer->stop(); + timer->setProperty("expired", true); + reply->abort(); +} + +void ZLQtNetworkManager::onAuthenticationRequired(QNetworkReply *reply, QAuthenticator *authenticator) { + ZLQtNetworkReplyScope scope = reply->property("scope").value<ZLQtNetworkReplyScope>(); + scope.timeoutTimer->stop(); + std::string userName; + std::string password; + scope.request->setUIStatus(false); + bool result = ZLApplication::Instance().showAuthDialog( + ZLNetworkUtil::hostFromUrl(reply->url().toString().toStdString()), + userName, + password, + scope.authAskedAlready ? ZLResourceKey("authenticationFailed") : ZLResourceKey()); + scope.request->setUIStatus(true); + if (result) { + scope.request->setupAuthentication(userName, password); + } else { + return; + } + + scope.timeoutTimer->start(timeoutValue()); + authenticator->setUser(QString::fromStdString(scope.request->userName())); + authenticator->setPassword(QString::fromStdString(scope.request->password())); + scope.authAskedAlready = true; + reply->setProperty("scope", qVariantFromValue(scope)); +} + +void ZLQtNetworkManager::onSslErrors(const QList<QSslError> &errors) { + QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender()); + reply->ignoreSslErrors(errors); +} + +void ZLQtNetworkManager::handleHeaders(QNetworkReply *reply) const { + ZLQtNetworkReplyScope scope = reply->property("scope").value<ZLQtNetworkReplyScope>(); + //TODO set HTTP header not with predefined information (like line below) + QByteArray data = "HTTP/1.1 "; + data += reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toByteArray(); + data += " "; + data += reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toByteArray(); + scope.request->handleHeader(data.data(), data.size()); + foreach (const QByteArray &headerName, reply->rawHeaderList()) { + data = headerName; + QByteArray value = reply->rawHeader(headerName); + data += ": "; + data += value; + if (headerName.toLower() == QString("content-encoding") && value.toLower().contains("gzip")) { + continue; + } + scope.request->handleHeader(data.data(), data.size()); + } +} + +void ZLQtNetworkManager::handleContent(QNetworkReply *reply) const { + ZLQtNetworkReplyScope scope = reply->property("scope").value<ZLQtNetworkReplyScope>(); + if (reply->error() != QNetworkReply::NoError) { + return; + } + QByteArray data = reply->readAll(); + if (!data.isEmpty()) { + scope.request->handleContent(data.data(), data.size()); + } +} + +QString ZLQtNetworkManager::handleErrors(QNetworkReply *reply) { + if (reply->error() == QNetworkReply::NoError) { + return QString(); + } + ZLLogger::Instance().println("network", QString("handleErrors: %1. Qt code: %2, url: %3").arg(reply->errorString()).arg(reply->error()).arg(reply->url().toString()).toStdString()); + std::string error; + const ZLResource &errorResource = ZLResource::resource("dialog")["networkError"]; + switch (reply->error()) { + case QNetworkReply::AuthenticationRequiredError: + error = errorResource["authenticationFailed"].value(); + break; + case QNetworkReply::OperationCanceledError: + case QNetworkReply::TimeoutError: + case QNetworkReply::ProxyTimeoutError: + error = errorResource["operationTimedOutMessage"].value(); + break; + case QNetworkReply::SslHandshakeFailedError: + error = ZLStringUtil::printf(errorResource["sslConnectErrorMessage"].value(), reply->url().toString().toStdString()); + break; + case QNetworkReply::HostNotFoundError: + error = ZLStringUtil::printf(errorResource["couldntConnectMessage"].value(), reply->url().toString().toStdString()); + break; + case QNetworkReply::ContentNotFoundError: //404 error, may be it should be other error message? + error = ZLStringUtil::printf(errorResource["somethingWrongMessage"].value(), reply->url().toString().toStdString()); + break; + case QNetworkReply::UnknownNetworkError: + error = QString("%1: %2").arg(reply->url().host()).arg(reply->errorString()).toStdString(); //TODO maybe host information is excess + break; + case QNetworkReply::UnknownProxyError: + case QNetworkReply::UnknownContentError: + case QNetworkReply::ProtocolUnknownError: + error = errorResource["unknownErrorMessage"].value(); + break; + case QNetworkReply::ProxyNotFoundError: + error = ZLStringUtil::printf(errorResource["couldntResolveProxyMessage"].value(), reply->url().toString().toStdString()); + break; + + //TODO add support of other errors code in our resources + case QNetworkReply::ConnectionRefusedError: + case QNetworkReply::RemoteHostClosedError: + // proxy errors (101-199): + case QNetworkReply::ProxyConnectionRefusedError: + case QNetworkReply::ProxyConnectionClosedError: + case QNetworkReply::ProxyAuthenticationRequiredError: + // content errors (201-299): + case QNetworkReply::ContentAccessDenied: + case QNetworkReply::ContentOperationNotPermittedError: + case QNetworkReply::ContentReSendError: + // protocol errors + case QNetworkReply::ProtocolInvalidOperationError: + case QNetworkReply::ProtocolFailure: + default: + error = reply->errorString().toStdString(); + break; + } + return QString::fromStdString(error); +} + +void ZLQtNetworkManager::setHeadersAndSsl(QNetworkRequest &networkRequest) const { + networkRequest.setRawHeader("User-Agent", userAgent().c_str()); + QSslConfiguration configuration = QSslConfiguration::defaultConfiguration(); + networkRequest.setSslConfiguration(configuration); +} + +void ZLQtNetworkManager::saveUserName(QNetworkReply *reply) const { + ZLQtNetworkReplyScope scope = reply->property("scope").value<ZLQtNetworkReplyScope>(); + std::string userName = scope.request->userName(); + if (userName.empty()) { + return; + } + std::string siteName = ZLNetworkUtil::hostFromUrl(reply->url().toString().toStdString()); + ZLApplication::Instance().saveUserName(siteName, userName); +} + +int ZLQtNetworkManager::timeoutValue() const { + return TimeoutOption().value() * 1000; +} + +ZLQtNetworkCookieJar::ZLQtNetworkCookieJar(QObject *parent) : + QNetworkCookieJar(parent) { +} + +ZLQtNetworkCookieJar::~ZLQtNetworkCookieJar() { + save(); +} + +void ZLQtNetworkCookieJar::setFilePath(const QString &filePath) { + myFilePath = filePath; + QFile file(myFilePath); + QList<QNetworkCookie> cookies; + if (file.open(QFile::ReadOnly)) { + cookies = QNetworkCookie::parseCookies(file.readAll()); + } + setAllCookies(cookies); +} + +bool ZLQtNetworkCookieJar::setCookiesFromUrl(const QList<QNetworkCookie> &cookieList, const QUrl &url) { + bool result = QNetworkCookieJar::setCookiesFromUrl(cookieList, url); + save(); + return result; +} + +void ZLQtNetworkCookieJar::save() { + if (myFilePath.isEmpty()) + return; + QFile file(myFilePath); + QDir dir = QFileInfo(myFilePath).absoluteDir(); + if (!dir.exists()) { + dir.mkpath(dir.absolutePath()); + } + if (!file.open(QFile::WriteOnly)) { + ZLLogger::Instance().println("ZLQtNetworkCookieJar", myFilePath.toStdString() + " can't be open for writing"); + return; + } + bool first = true; + foreach (const QNetworkCookie &cookie, allCookies()) { + if (first) { + first = false; + } else { + file.write("\n", 1); + } + file.write(cookie.toRawForm(QNetworkCookie::Full)); + } +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/QtWaitingSpinner.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/QtWaitingSpinner.cpp new file mode 100644 index 0000000..1be8569 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/QtWaitingSpinner.cpp @@ -0,0 +1,155 @@ +#include <cmath> +#include <algorithm> + +#include <QtGui/QPainter> + +#include "QtWaitingSpinner.h" + +QtWaitingSpinner::QtWaitingSpinner(int linesNumber, int length, int width, int radius, QWidget *parent) : QWidget(parent), + myLinesNumber(linesNumber), + myLength(length + width), + myWidth(width), + myRadius(radius), + myRoundness(70.0), + myColor(Qt::black), + mySpeed(1), + myTrail(70), + myOpacity(15) +{ + myCurrentCounter = 0; + myTimer = new QTimer(this); + connect(myTimer,SIGNAL(timeout()), this, SLOT(rotate())); + updateSize(); + updateTimer(); + this->hide(); +} + +void QtWaitingSpinner::paintEvent(QPaintEvent */*ev*/) { + QPainter painter(this); + painter.fillRect(this->rect(), Qt::transparent); + painter.setRenderHint(QPainter::Antialiasing, true); + + if (myCurrentCounter >= myLinesNumber) { + myCurrentCounter = 0; + } + painter.setPen(Qt::NoPen); + for (int i = 0; i < myLinesNumber; ++i) { + painter.save(); + painter.translate(myRadius + myLength, myRadius + myLength); + qreal rotateAngle = (qreal)360 * qreal(i) / qreal(myLinesNumber); + painter.rotate(rotateAngle); + painter.translate(myRadius, 0); + int distance = lineDistance(i, myCurrentCounter, myLinesNumber); + QColor color = countTrailColor(distance, myLinesNumber, myTrail, myOpacity, myColor); + painter.setBrush(color); + //TODO improve the way rounded rect is painted + painter.drawRoundedRect(QRect(0, -myWidth/2, myLength, myWidth), myRoundness, myRoundness, Qt::RelativeSize); + painter.restore(); + } +} + +void QtWaitingSpinner::start() { + this->show(); + if (!myTimer->isActive()) { + myTimer->start(); + myCurrentCounter = 0; + } +} + +void QtWaitingSpinner::finish() { + this->hide(); + if (myTimer->isActive()) { + myTimer->stop(); + myCurrentCounter = 0; + } +} + +void QtWaitingSpinner::setLinesNumber(int linesNumber) { + myLinesNumber = linesNumber; + myCurrentCounter = 0; + updateTimer(); +} + +void QtWaitingSpinner::setLength(int length){ + myLength = length; + updateSize(); +} + +void QtWaitingSpinner::setWidth(int width) { + myWidth = width; + updateSize(); +} + +void QtWaitingSpinner::setRadius(int radius) { + myRadius = radius; + updateSize(); +} + +void QtWaitingSpinner::setRoundness(qreal roundness) { + myRoundness = std::max(0.0, std::min(100.0, roundness)); +} + +void QtWaitingSpinner::setColor(QColor color) { + myColor = color; +} + +void QtWaitingSpinner::setSpeed(qreal speed) { + mySpeed = speed; + updateTimer(); +} + +void QtWaitingSpinner::setTrail(int trail) { + myTrail = trail; +} + +void QtWaitingSpinner::setOpacity(int minOpacity) { + myOpacity = minOpacity; +} + +void QtWaitingSpinner::rotate() { + ++myCurrentCounter; + if (myCurrentCounter >= myLinesNumber) { + myCurrentCounter = 0; + } + update(); +} + +void QtWaitingSpinner::updateSize() { + int size = (myRadius + myLength) * 2; + setFixedSize(size, size); +} + +void QtWaitingSpinner::updateTimer() { + myTimer->setInterval(countTimeout(myLinesNumber, mySpeed)); +} + +int QtWaitingSpinner::countTimeout(int lines, qreal speed) { + return 1000 / (lines * speed); +} + +int QtWaitingSpinner::lineDistance(int from, int to, int lines) { + int result = to - from; + if (result < 0) { + result += lines; + } + return result; +} + +QColor QtWaitingSpinner::countTrailColor(int distance, int lines, int trail, int minOpacity, QColor color) { + if (distance == 0) { + return color; + } + const qreal minAlphaF = (qreal)minOpacity / 100; + int distanceThreshold = ceil( (lines - 1) * (qreal)trail / 100); + if (distance > distanceThreshold) { + color.setAlphaF(minAlphaF); + return color; + } + qreal alphaDiff = color.alphaF() - (qreal)minAlphaF; + qreal gradation = alphaDiff / (qreal)(distanceThreshold + 1); + qreal resultAlpha = color.alphaF() - gradation * distance; + resultAlpha = std::min(1.0, std::max(0.0, resultAlpha)); //if alpha is out of bound, force it to bounds + color.setAlphaF(resultAlpha); + return color; +} + diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/QtWaitingSpinner.h b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/QtWaitingSpinner.h new file mode 100644 index 0000000..cdaef01 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/QtWaitingSpinner.h @@ -0,0 +1,59 @@ +#ifndef QTWAITINGSPINNER_H +#define QTWAITINGSPINNER_H + +#include <QtCore/QTimer> + +#include <QtGui/QWidget> +#include <QtGui/QColor> + +class QtWaitingSpinner : public QWidget { + Q_OBJECT + +public: + explicit QtWaitingSpinner(int linesNumber = 12, int length = 7, int width = 5, int radius = 10, QWidget *parent = 0); + +public Q_SLOTS: + void start(); + void finish(); + +public: + void setLinesNumber(int linesNumber); + void setLength(int length); + void setWidth(int width); + void setRadius(int radius); + void setRoundness(qreal roundness); + void setColor(QColor color); + void setSpeed(qreal speed); + void setTrail(int trail); + void setOpacity(int minOpacity); + +private Q_SLOTS: + void rotate(); + void updateSize(); + void updateTimer(); + +protected: + void paintEvent(QPaintEvent *ev); + +private: + static int countTimeout(int lines, qreal speed); + static int lineDistance(int from, int to, int lines); + static QColor countTrailColor(int distance, int lines, int trail, int minOpacity, QColor color); + +private: + int myLinesNumber; + int myLength; + int myWidth; + int myRadius; + qreal myRoundness; //0..100 + QColor myColor; + qreal mySpeed; // in rounds per second + int myTrail; + int myOpacity; + +private: + QTimer *myTimer; + int myCurrentCounter; +}; + +#endif // QTWAITINGSPINNER_H diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtItemsListWidget.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtItemsListWidget.cpp new file mode 100644 index 0000000..a3e5b35 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtItemsListWidget.cpp @@ -0,0 +1,255 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <QtGui/QVBoxLayout> +#include <QtGui/QHBoxLayout> +#include <QtGui/QPixmap> +#include <QtGui/QPalette> +#include <QtGui/QPainter> +#include <QtGui/QPaintEvent> +#include <QtGui/QScrollBar> +#include <QtCore/QTimer> + +#include <QtCore/QDebug> + +#include <ZLibrary.h> +#include <ZLNetworkManager.h> +#include <ZLTreeTitledNode.h> +#include <ZLFile.h> + +#include "../dialogs/ZLQtDialogManager.h" + +#include "../image/ZLQtImageUtils.h" + +#include "ZLQtPreviewWidget.h" + +#include "ZLQtItemsListWidget.h" + +static const int ITEM_HEIGHT = 98; +static const int ITEM_COUNT = 5; +static const int ITEM_SIZE = 77; +static const int WAITING_SIZE = 40; + +ZLQtItemsListWidget::ZLQtItemsListWidget(QWidget *parent) : QScrollArea(parent), myLayout(0) { + myContainerWidget = new QWidget; + myContainerWidget->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Minimum); + + verticalScrollBar()->setTracking(false); + connect(verticalScrollBar(), SIGNAL(valueChanged(int)), SLOT(onSliderMoved(int))); + + setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded); + setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + setWidget(myContainerWidget); + setFrameShape(QFrame::NoFrame); + setWidgetResizable(true); + setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Minimum); +} + +void ZLQtItemsListWidget::clear() { + if (myLayout != 0) { + delete myLayout; + qDeleteAll(myContainerWidget->children()); + } + myLayout = new QVBoxLayout; + myLayout->setContentsMargins(0,0,0,0); + myLayout->setSpacing(0); + myLayout->setSizeConstraint(QLayout::SetMinAndMaxSize); + myContainerWidget->setLayout(myLayout); + + + myItems.clear(); + +} + +void ZLQtItemsListWidget::addNode(ZLTreeTitledNode *titledNode) { + //qDebug() << QString::fromStdString(titledNode->title()); + ZLQtTreeItem *item = new ZLQtTreeItem; + item->fill(titledNode); + connect(item, SIGNAL(clicked(ZLQtTreeItem*)), this, SLOT(onNodeClicked(ZLQtTreeItem*))); //action ExpandAction used instead + connect(item, SIGNAL(doubleClicked(ZLQtTreeItem*)), this, SIGNAL(nodeDoubleClicked(ZLQtTreeItem*))); + myLayout->addWidget(item); + myItems.push_back(item); +} + +void ZLQtItemsListWidget::fillNodes(const ZLTreeNode *expandNode) { + clear(); + + foreach(ZLTreeNode* node, expandNode->children()) { + if (ZLTreeTitledNode *titledNode = zlobject_cast<ZLTreeTitledNode*>(node)) { + addNode(titledNode); + } + } +} + +void ZLQtItemsListWidget::fillNewNodes(const ZLTreeNode *rootNode) { + if (myLayout == 0) { + return; + } + + size_t oldSize = (size_t)myItems.size(); + + //qDebug() << Q_FUNC_INFO << oldSize << rootNode->children().size(); + + for (size_t i = oldSize; i < rootNode->children().size(); ++i) { + if (ZLTreeTitledNode *titledNode = zlobject_cast<ZLTreeTitledNode*>(rootNode->children().at(i))) { + addNode(titledNode); + } + } +} + +QSize ZLQtItemsListWidget::sizeHint() const { + return QSize(0, ITEM_HEIGHT * ITEM_COUNT); +} + +void ZLQtItemsListWidget::setMinimumWidth(int w) { + myContainerWidget->setMinimumWidth(w - verticalScrollBar()->width()); + QScrollArea::setMinimumWidth(w); +} + +QList<ZLQtTreeItem *> ZLQtItemsListWidget::getItems() const { + return myItems; +} + +void ZLQtItemsListWidget::onNodeClicked(ZLQtTreeItem* itemClicked) { + foreach(ZLQtTreeItem *item, myItems) { + item->setActive(item == itemClicked); + } + emit nodeClicked(itemClicked); +} + +void ZLQtItemsListWidget::onSliderMoved(int value) { + int maximum = verticalScrollBar()->maximum(); + if ((double)value > (double)maximum * 0.8) { + emit wantMoreChildren(); + } +} + +ZLQtTreeItem::ZLQtTreeItem(QWidget *parent) : QFrame(parent), myNode(0), myImageRequested(false) { + setAutoFillBackground(true); + setActive(false); + + QHBoxLayout *mainLayout = new QHBoxLayout; + QHBoxLayout *infoLayout = new QHBoxLayout; + infoLayout->setAlignment(Qt::AlignLeft); + QVBoxLayout *titlesLayout = new QVBoxLayout; + + myIcon = new QLabel; + myTitle = new QLabel; + mySubtitle = new QLabel; + + myWaitingIcon = new QtWaitingSpinner(12, 6, 4, 10); + myWaitingIcon->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed); + + myTitle->setWordWrap(true); + mySubtitle->setWordWrap(true); + + titlesLayout->addWidget(myTitle); + titlesLayout->addWidget(mySubtitle); + + infoLayout->addWidget(myIcon, 0); + infoLayout->addLayout(titlesLayout, 1); + mainLayout->addLayout(infoLayout, 1); + mainLayout->addWidget(myWaitingIcon, 0, Qt::AlignRight); + setLayout(mainLayout); + + setFixedHeight(ITEM_HEIGHT); + + clear(); +} + +void ZLQtTreeItem::fill(ZLTreeTitledNode *node) { + clear(); + myNode = node; + myTitle->setText(QString("<b>%1</b>").arg(QString::fromStdString(node->title()))); + mySubtitle->setText(QString::fromStdString(node->subtitle())); + fillImage(); +} + +void ZLQtTreeItem::fillImage() { + //separated method for deferred loding of cover (good for slow connections) + //TODO as it starts loading on paintEvent, it works bad while scrolling + if (!myImageRequested) { + return; + } + shared_ptr<const ZLImage> image = myNode->image(); + if (!image.isNull()) { + QPixmap pixmap = ZLQtImageUtils::ZLImageToQPixmapWithSize(image, QSize(ITEM_SIZE,ITEM_SIZE), false, Qt::SmoothTransformation); + if (!pixmap.isNull()) { + myIcon->setPixmap(pixmap); + } + } +} + +void ZLQtTreeItem::clear() { + myNode = 0; + myImageRequested = false; + myTitle->clear(); + mySubtitle->clear(); + + QPixmap pixmap(ITEM_SIZE, ITEM_SIZE); + pixmap.fill(Qt::transparent); + myIcon->setPixmap(pixmap); + + myWaitingIcon->finish(); +} + +void ZLQtTreeItem::setActive(bool active) { + myIsActive = active; + + //TODO due to different themes on OS, take a color from existed palette + QColor mainColor = myIsActive ? QColor::fromHsv(0, 0, 0.75 * 255) : QColor::fromHsv(0, 0, 0.95 * 255); + + setFrameStyle(QFrame::Panel | QFrame::Raised); + setLineWidth(2); + + QPalette p = palette(); + p.setColor(QPalette::Window, mainColor); + setPalette(p); + + update(); +} + +bool ZLQtTreeItem::isActive() const { + return myIsActive; +} + +ZLTreeTitledNode *ZLQtTreeItem::getNode() const { + return myNode; +} + +QtWaitingSpinner *ZLQtTreeItem::getWaitingIcon() const { + return myWaitingIcon; +} + +void ZLQtTreeItem::mousePressEvent(QMouseEvent *) { + emit clicked(this); +} + +void ZLQtTreeItem::mouseDoubleClickEvent(QMouseEvent *) { + emit doubleClicked(this); +} + +void ZLQtTreeItem::paintEvent(QPaintEvent *event) { + if (myNode && !myImageRequested) { + myNode->image(); + myImageRequested = true; + fillImage(); + } + QFrame::paintEvent(event); +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtItemsListWidget.h b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtItemsListWidget.h new file mode 100644 index 0000000..4f09cfc --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtItemsListWidget.h @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 __ZLQTITEMSLISTWIDGET_H__ +#define __ZLQTITEMSLISTWIDGET_H__ + +#include <QtGui/QWidget> +#include <QtGui/QFrame> +#include <QtGui/QPushButton> +#include <QtGui/QLabel> +#include <QtGui/QVBoxLayout> +#include <QtGui/QScrollArea> + +#include <ZLTreeTitledNode.h> + +#include "QtWaitingSpinner.h" + +class ZLQtTreeItem; + +class ZLQtItemsListWidget : public QScrollArea { + Q_OBJECT +public: + ZLQtItemsListWidget(QWidget *parent = 0); + void fillNodes(const ZLTreeNode *rootNode); + void fillNewNodes(const ZLTreeNode *rootNode); + QSize sizeHint() const; + void setMinimumWidth(int w); + QList<ZLQtTreeItem*> getItems() const; + + +Q_SIGNALS: + void nodeClicked(ZLQtTreeItem* item); + void nodeDoubleClicked(ZLQtTreeItem* item); + void wantMoreChildren(); + +public Q_SLOTS: + void onNodeClicked(ZLQtTreeItem* item); + void onSliderMoved(int value); + +private: + void clear(); + void addNode(ZLTreeTitledNode *node); + +private: + QWidget *myContainerWidget; + QVBoxLayout *myLayout; + QList<ZLQtTreeItem*> myItems; +}; + +class QtWaitingSpinner; + +class ZLQtTreeItem : public QFrame { + Q_OBJECT + +public: + ZLQtTreeItem(QWidget *parent = 0); + void fill(ZLTreeTitledNode *node); + void setActive(bool active); + bool isActive() const; + +public: + ZLTreeTitledNode *getNode() const; + QtWaitingSpinner *getWaitingIcon() const; + +Q_SIGNALS: + void clicked(ZLQtTreeItem* item); + void doubleClicked(ZLQtTreeItem* item); + +protected: + void mousePressEvent(QMouseEvent *event); + void mouseDoubleClickEvent(QMouseEvent *event); + void paintEvent(QPaintEvent *event); + +protected: + void fillImage(); + void clear(); + +private: + ZLTreeTitledNode *myNode; + + QLabel *myIcon; + QLabel *myTitle; + QLabel *mySubtitle; + QtWaitingSpinner *myWaitingIcon; + bool myImageRequested; + + bool myIsActive; +}; + +#endif /* __ZLQTITEMSLISTWIDGET_H__ */ diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtPreviewWidget.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtPreviewWidget.cpp new file mode 100644 index 0000000..472f05f --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtPreviewWidget.cpp @@ -0,0 +1,411 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <QtGui/QVBoxLayout> +#include <QtGui/QHBoxLayout> +#include <QtGui/QScrollBar> +#include <QtGui/QGraphicsDropShadowEffect> + +#include <QtCore/QDebug> + +#include <ZLNetworkManager.h> +#include <ZLStringUtil.h> + +#include "QtWaitingSpinner.h" +#include "../image/ZLQtImageUtils.h" + +#include "ZLQtPreviewWidget.h" + +class ZLQtLabelAction : public QLabel { + +public: + ZLQtLabelAction(shared_ptr<ZLTreeAction> action, QWidget *parent=0, Qt::WindowFlags f=0); + +protected: + void mousePressEvent(QMouseEvent *ev); + +private: + shared_ptr<ZLTreeAction> myAction; +}; + +ZLQtLabelAction::ZLQtLabelAction(shared_ptr<ZLTreeAction> action,QWidget *parent, Qt::WindowFlags f) : + QLabel(parent, f), myAction(action) { + setCursor(Qt::PointingHandCursor); + QPalette p = palette(); + p.setColor(QPalette::WindowText, QColor(33, 96, 180)); //blue color + setPalette(p); +} + +void ZLQtLabelAction::mousePressEvent(QMouseEvent *) { + if (myAction.isNull() || !myAction->makesSense()) { + return; + } + myAction->run(); +} + + +ZLQtButtonAction::ZLQtButtonAction(shared_ptr<ZLTreeAction> action,QWidget *parent) : + QPushButton(parent), myAction(action) { + connect(this, SIGNAL(clicked()), this, SLOT(onClicked()), Qt::QueuedConnection); //QueuedConnection used for sending clicked() signal for UI at first + setAttribute(Qt::WA_LayoutUsesWidgetRect); +} + +void ZLQtButtonAction::onClicked() { + if (myAction.isNull() || !myAction->makesSense()) { + return; + } + myAction->run(); +} + +ZLQtPreviewWidget::ZLQtPreviewWidget(QWidget *parent) : QWidget(parent), myCurrentNode(0) { + QSizePolicy policy = QSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding); + //policy.setHorizontalStretch(2); + setSizePolicy(policy); +} + +void ZLQtPreviewWidget::show(ZLTreeNode *node) { + clear(); + myCurrentNode = node; + if (ZLTreePageNode *pageNode = zlobject_cast<ZLTreePageNode*>(node)) { + if (myDownloadingNodes.contains(pageNode)) { + fillWaitingIcon(); + return; + } + fillPageInfo(pageNode); + } else if (const ZLTreeTitledNode *titledNode = zlobject_cast<const ZLTreeTitledNode*>(node)) { + fillCatalog(titledNode); + } +} + +void ZLQtPreviewWidget::refresh() { + if (myCurrentNode) { + show(myCurrentNode); + } +} + +class PageInfoLoaderListener : public ZLNetworkRequest::Listener { + public: + PageInfoLoaderListener(ZLQtPreviewWidget &previewWidget, ZLTreePageNode *node) : + myPreviewWidget(previewWidget), myNode(node) { + myPreviewWidget.myDownloadingNodes.insert(node); + } + void finished(const std::string &error) { + myPreviewWidget.myDownloadingNodes.remove(myNode); + if (myPreviewWidget.myCurrentNode == myNode) { + myPreviewWidget.refresh(); + } + } + private: + ZLQtPreviewWidget &myPreviewWidget; + ZLTreePageNode *myNode; +}; + +void ZLQtPreviewWidget::fillPageInfo(ZLTreePageNode *node) { + if (myDownloadingNodes.contains(node)) { + fillWaitingIcon(); + return; + } + shared_ptr<ZLTreePageInfo> info = node->getPageInfo(); + if (info.isNull()) { + return; + } + if (!info->isPageInfoLoaded()) { + fillWaitingIcon(); + info->loadAll(new PageInfoLoaderListener(*this, node)); + return; + } + setBasicLayout(); + QWidget *widget = new ZLQtPageWidget(*info); + widget->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::MinimumExpanding); + layout()->addWidget(widget); +} + + +void ZLQtPreviewWidget::setBasicLayout() { + QHBoxLayout *layout = new QHBoxLayout; + layout->setSizeConstraint(QLayout::SetMinimumSize); + layout->setContentsMargins(0,0,0,0); + setLayout(layout); +} + + +void ZLQtPreviewWidget::fillCatalog(const ZLTreeTitledNode *node) { + setBasicLayout(); + QWidget *widget = new ZLQtCatalogPageWidget(node); + widget->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::MinimumExpanding); + layout()->addWidget(widget); +} + +void ZLQtPreviewWidget::fillWaitingIcon() { + setBasicLayout(); + QtWaitingSpinner *icon = new QtWaitingSpinner(12, 26, 8, 36); + icon->start(); + layout()->addWidget(icon); +} + + +void ZLQtPreviewWidget::clear() { + myCurrentNode = 0; + qDeleteAll(children()); + +} + +ZLTreeNode *ZLQtPreviewWidget::getCurrentNode() const { + return myCurrentNode; +} + +QSize ZLQtPreviewWidget::sizeHint() const { + QSize hint = QWidget::sizeHint(); +// qDebug() << Q_FUNC_INFO << hint << minimumSize(); + return hint; +} + +ZLQtAbstractPageWidget::ZLQtAbstractPageWidget(QWidget *parent) : QWidget(parent) { } + +void ZLQtAbstractPageWidget::onActionActivated() { + foreach(QPushButton* button, myButtonActions) { + button->setEnabled(false); + } +} + +ZLQtPageWidget::ZLQtPageWidget(const ZLTreePageInfo &info, QWidget *parent) : ZLQtAbstractPageWidget(parent) { + //TODO fix it: if element is absent, there's a empty space instead it. Looks bad. + createElements(); + setInfo(info); +} + +void ZLQtPageWidget::createElements() { + myPicLabel = new QLabel; + + // the code inside #ifndef does crash on MacOS, + // see https://bugreports.qt-project.org/browse/QTBUG-24792 +#ifndef Q_OS_MAC + QGraphicsDropShadowEffect* effect = new QGraphicsDropShadowEffect; + effect->setBlurRadius(12); + effect->setOffset(3); + myPicLabel->setGraphicsEffect(effect); +#endif +// myPicLabel->setMaximumSize(300,300); +// myPicLabel->setMinimumSize(77,77); + + myTitleLabel = new QLabel; + myAuthorLabel = new QLabel; + myCategoriesLabel = new QLabel; + mySummaryTitleLabel = new QLabel; + mySummaryLabel = new QLabel; + + myScrollArea = new QScrollArea; + myScrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + myScrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded); + myScrollArea->setWidgetResizable(true); + myScrollArea->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding); + + mySummaryLabel->setAlignment(Qt::AlignLeft | Qt::AlignTop); + mySummaryLabel->setMargin(3); + //mySummaryLabel->setMaximumHeight(200); + mySummaryLabel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding); + //mySummaryLabel->setIndent(3); + + myRelatedWidget = new QWidget; + + myActionsWidget = new QWidget; + + QVBoxLayout *layout = new QVBoxLayout; + QWidget *containerWidget = new QWidget; + + QVBoxLayout *previewLayout = new QVBoxLayout; + QHBoxLayout *actionsLayout = new QHBoxLayout; + QVBoxLayout *relatedLayout = new QVBoxLayout; + myActionsWidget->setLayout(actionsLayout); + previewLayout->setSizeConstraint(QLayout::SetMinimumSize); + + layout->setSizeConstraint(QLayout::SetMinimumSize); + + QHBoxLayout *picLayout = new QHBoxLayout; + picLayout->addStretch(); + picLayout->addWidget(myPicLabel); + picLayout->addStretch(); + + previewLayout->addLayout(picLayout); + previewLayout->addWidget(myTitleLabel); + previewLayout->addWidget(myAuthorLabel); + previewLayout->addWidget(myCategoriesLabel); + previewLayout->addWidget(mySummaryTitleLabel); + previewLayout->addWidget(mySummaryLabel); + previewLayout->addWidget(myRelatedWidget); + //previewLayout->addStretch(); + + myRelatedWidget->setLayout(relatedLayout); + containerWidget->setLayout(previewLayout); + myScrollArea->setWidget(containerWidget); + + layout->setContentsMargins(0,0,0,0); + + layout->addWidget(myScrollArea); + layout->addWidget(myActionsWidget); + setLayout(layout); +} + +void ZLQtPageWidget::setInfo(const ZLTreePageInfo &info) { + shared_ptr<const ZLImage> image = info.image(); + if (!image.isNull()) { + QPixmap pixmap = ZLQtImageUtils::ZLImageToQPixmap(image); + //TODO implement resizable pixmap widget + const int maxPreviewWidth = 300; + if (pixmap.height() > maxPreviewWidth || pixmap.width() > maxPreviewWidth) { + pixmap = pixmap.scaled(maxPreviewWidth, maxPreviewWidth, Qt::KeepAspectRatio, Qt::SmoothTransformation); + } + myPicLabel->setPixmap(pixmap); + } + + //TODO implement 'condition'-like attributes support for ZLResource + static const ZLResource &resource = ZLResource::resource("bookInfo"); + static QString colon = "<b>%1</b> %2"; + + if (!info.title().empty()) { + static QString title = QString::fromStdString(resource["title"].value()); + myTitleLabel->setText(colon.arg(title, QString::fromStdString(info.title()))); + } + + if (info.authors().size() > 0) { + static QString label = QString::fromStdString(resource["authors"].value(info.authors().size())); + myAuthorLabel->setText(colon.arg(label, QString::fromStdString(ZLStringUtil::join(info.authors(), ", ")))); + } + + if (info.tags().size() > 0) { + static QString label = QString::fromStdString(resource["tags"].value(info.tags().size())); + myCategoriesLabel->setText(colon.arg(label, QString::fromStdString(ZLStringUtil::join(info.tags(), ", ")))); + } + + if (!info.summary().empty()) { + static QString annotation = QString::fromStdString(resource["annotation"].value()); + mySummaryLabel->setText(QString::fromStdString(info.summary())); + mySummaryTitleLabel->setText(QString("<b>%1</b>").arg(annotation)); +// mySummaryScrollArea->show(); + } + + myTitleLabel->setWordWrap(true); + myAuthorLabel->setWordWrap(true); + myCategoriesLabel->setWordWrap(true); + mySummaryLabel->setWordWrap(true); + + foreach(shared_ptr<ZLTreeAction> action, info.actions()) { + if (!action->makesSense()) { + continue; + } + QPushButton *actionButton = new ZLQtButtonAction(action); + QString text = QString::fromStdString(info.actionText(action)); + actionButton->setText(text); + myActionsWidget->layout()->addWidget(actionButton); + connect(actionButton, SIGNAL(clicked()), this, SLOT(onActionActivated())); + myButtonActions.push_back(actionButton); + } + + //TODO check case if I will load all links at the same time + foreach(shared_ptr<ZLTreeAction> action, info.relatedActions()) { + if (!action->makesSense()) { + continue; + } + QLabel *actionLabel = new ZLQtLabelAction(action); + QString text = QString::fromStdString(info.actionText(action)); + actionLabel->setText(QString("<big><u>%1</u></big>").arg(text)); + actionLabel->setWordWrap(true); + myRelatedWidget->layout()->addWidget(actionLabel); + } +} + +ZLQtCatalogPageWidget::ZLQtCatalogPageWidget(const ZLTreeTitledNode *node, QWidget *parent) : ZLQtAbstractPageWidget(parent) { + createElements(); + setInfo(node); +} + +void ZLQtCatalogPageWidget::createElements() { + myPicLabel = new QLabel; + myTitleLabel = new QLabel; + mySubtitleLabel = new QLabel; + + mySubtitleLabel->setWordWrap(true); + myTitleLabel->setAlignment(Qt::AlignCenter); + mySubtitleLabel->setAlignment(Qt::AlignCenter); + + myActionsWidget = new QWidget; + + QVBoxLayout *previewLayout = new QVBoxLayout; + previewLayout->setSizeConstraint(QLayout::SetMinimumSize); + + QHBoxLayout *strechActionsLayout = new QHBoxLayout; + strechActionsLayout->addStretch(); + strechActionsLayout->addWidget(myActionsWidget); + strechActionsLayout->addStretch(); + QVBoxLayout *actionsLayout = new QVBoxLayout; myActionsWidget->setLayout(actionsLayout); + + QHBoxLayout *picLayout = new QHBoxLayout; + picLayout->addStretch(); + picLayout->addWidget(myPicLabel); + picLayout->addStretch(); + + previewLayout->addStretch(); + previewLayout->addLayout(picLayout); + previewLayout->addWidget(myTitleLabel); + previewLayout->addWidget(mySubtitleLabel); + previewLayout->addLayout(strechActionsLayout); + previewLayout->addStretch(); + + setLayout(previewLayout); +} + +void ZLQtCatalogPageWidget::setInfo(const ZLTreeTitledNode *node) { + shared_ptr<const ZLImage> image = node->image(); + if (!image.isNull()) { + + //TODO make async image downloading + + ZLNetworkManager::Instance().perform(image->synchronizationData()); + QPixmap pixmap = ZLQtImageUtils::ZLImageToQPixmap(image); + //TODO implement resizable pixmap widget + const int maxPreviewWidth = 300; + if (pixmap.height() > maxPreviewWidth || pixmap.width() > maxPreviewWidth) { + pixmap = pixmap.scaled(maxPreviewWidth, maxPreviewWidth, Qt::KeepAspectRatio, Qt::SmoothTransformation); + } + myPicLabel->setPixmap(pixmap); + } + + if (!node->title().empty()) { + myTitleLabel->setText(QString("<b>%1</b>").arg(QString::fromStdString(node->title()))); + } + if (!node->subtitle().empty()) { + mySubtitleLabel->setText(QString::fromStdString(node->subtitle())); + } + + foreach(shared_ptr<ZLTreeAction> action, node->actions()) { + if (!action->makesSense()) { + continue; + } + QPushButton *actionButton = new ZLQtButtonAction(action); + QString text = QString::fromStdString(node->actionText(action)); + actionButton->setText(text); + myActionsWidget->layout()->addWidget(actionButton); + connect(actionButton, SIGNAL(clicked()), this, SLOT(onActionActivated())); + myButtonActions.push_back(actionButton); + //TODO maybe buttons should not be too big + //actionButton->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Preferred); + + } + +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtPreviewWidget.h b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtPreviewWidget.h new file mode 100644 index 0000000..1b8ebcc --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtPreviewWidget.h @@ -0,0 +1,121 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 __ZLQTPREVIEWWIDGET_H__ +#define __ZLQTPREVIEWWIDGET_H__ + +#include <QtGui/QWidget> +#include <QtGui/QPushButton> +#include <QtGui/QLabel> +#include <QtGui/QScrollArea> +#include <QtGui/QVBoxLayout> +#include <QtCore/QSet> + +#include <ZLTreePageNode.h> + +class ZLQtPreviewWidget : public QWidget { + +public: + ZLQtPreviewWidget(QWidget *parent = 0); + void show(ZLTreeNode *node); + void refresh(); + void clear(); + + ZLTreeNode* getCurrentNode() const; + + QSize sizeHint() const; + +protected: + void setBasicLayout(); + void fillWaitingIcon(); + void fillPageInfo(ZLTreePageNode *node); + void fillCatalog(const ZLTreeTitledNode *node); + +private: + ZLTreeNode *myCurrentNode; + + QSet<ZLTreePageNode *> myDownloadingNodes; + +friend class PageInfoLoaderListener; +}; + +class ZLQtAbstractPageWidget : public QWidget { + Q_OBJECT +public: + ZLQtAbstractPageWidget(QWidget *parent = 0); + +public Q_SLOTS: + void onActionActivated(); + +protected: + QList<QPushButton*> myButtonActions; +}; + +class ZLQtPageWidget : public ZLQtAbstractPageWidget { + +public: + ZLQtPageWidget(const ZLTreePageInfo &info, QWidget *parent = 0); + +private: + void createElements(); + void setInfo(const ZLTreePageInfo &info); + +private: + QScrollArea *myScrollArea; + + QLabel *myPicLabel; + QLabel *myTitleLabel; + QLabel *myAuthorLabel; + QLabel *myCategoriesLabel; + QLabel *mySummaryTitleLabel; + QLabel *mySummaryLabel; + QWidget *myRelatedWidget; + QWidget *myActionsWidget; +}; + + +class ZLQtCatalogPageWidget : public ZLQtAbstractPageWidget { + +public: + ZLQtCatalogPageWidget(const ZLTreeTitledNode *node, QWidget *parent = 0); + +private: + void createElements(); + void setInfo(const ZLTreeTitledNode *); + +private: + QLabel *myPicLabel; + QLabel *myTitleLabel; + QLabel *mySubtitleLabel; + QWidget *myActionsWidget; +}; + +class ZLQtButtonAction : public QPushButton { + Q_OBJECT +public: + ZLQtButtonAction(shared_ptr<ZLTreeAction> action, QWidget *parent=0); + +private Q_SLOTS: + void onClicked(); + +private: + shared_ptr<ZLTreeAction> myAction; +}; + +#endif /* __ZLQTPREVIEWWIDGET_H__ */ diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtSearchField.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtSearchField.cpp new file mode 100644 index 0000000..1cddaf9 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtSearchField.cpp @@ -0,0 +1,125 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <QtCore/QDebug> +#include <QtGui/QStyle> +#include <QtGui/QCompleter> +#include <QtGui/QStringListModel> + +#include <ZLibrary.h> +#include <ZLFile.h> +#include <ZLResource.h> +#include <ZLOptions.h> +#include <ZLStringUtil.h> + +#include "ZLQtSearchField.h" + +ZLQtSearchField::ZLQtSearchField(QWidget *parent) : QLineEdit(parent) { + //TODO somehow make it feathered + //TODO set active and non-active color by default of system + + setObjectName("search-field"); + + myWaitingIcon = new QtWaitingSpinner(12, 3, 2, 3, this); + myWaitingIcon->setSpeed(2); + + mySearchIcon = new QLabel(this); + static std::string iconPath = ZLibrary::ApplicationImageDirectory() + ZLibrary::FileNameDelimiter + "search_icon.png"; + QPixmap searchIcon = QPixmap(ZLFile(iconPath).path().c_str()); + mySearchIcon->setPixmap(searchIcon); + mySearchIcon->setFixedSize(searchIcon.size()); + + setFixedSize(155,25); + + setPlaceholderText(QString::fromStdString(ZLResource::resource("networkView")["searchResultNode"]["searchfield"].value())); + + int frameWidth = style()->pixelMetric(QStyle::PM_DefaultFrameWidth); + + setStyleSheet(QString("QLineEdit { padding-left: %1px; } ").arg(mySearchIcon->sizeHint().width() + frameWidth)); + + QCompleter *completer = new QCompleter(this); + completer->setCaseSensitivity(Qt::CaseInsensitive); + completer->setCompletionMode(QCompleter::PopupCompletion); + this->setCompleter(completer); + + loadSuggestions(); + connect(this, SIGNAL(returnPressed()), this, SLOT(onReturnPressed())); +} + +QtWaitingSpinner *ZLQtSearchField::getWaitingIcon() { + return myWaitingIcon; +} + +void ZLQtSearchField::onReturnPressed() { + if (text().isEmpty()) { + return; + } + if (mySuggestions.contains(text())) { + return; + } + mySuggestions.insert(text()); + saveSuggestions(); +} + +void ZLQtSearchField::updateSuggestions() { + QStringListModel *model = new QStringListModel(mySuggestions.toList(), this); + this->completer()->setModel(model); +} + +static const std::string SUGGESTION = "suggestion"; +static const std::string SUGGESTIONS = "suggestions"; + +void ZLQtSearchField::loadSuggestions() { + mySuggestions.clear(); + bool finished = false; + for (unsigned int i = 0; !finished; ++i) { + std::string suggestOptionName(SUGGESTION); + ZLStringUtil::appendNumber(suggestOptionName, i); + std::string suggestion = ZLStringOption(ZLCategoryKey::NETWORK, SUGGESTIONS, suggestOptionName, "").value(); + if (suggestion.empty()) { + finished = true; + } else { + mySuggestions.insert(QString::fromStdString(suggestion)); + } + } + updateSuggestions(); +} + +void ZLQtSearchField::saveSuggestions() { + QList<QString> suggestions = mySuggestions.values(); + for (int i = 0; i < suggestions.size(); ++i) { + if (suggestions.at(i).isEmpty()) { + continue; + } + std::string suggestOptionName(SUGGESTION); + ZLStringUtil::appendNumber(suggestOptionName, (unsigned int)i); + ZLStringOption suggestion(ZLCategoryKey::NETWORK, SUGGESTIONS, suggestOptionName, ""); + suggestion.setValue(suggestions.at(i).toStdString()); + } + updateSuggestions(); +} + +void ZLQtSearchField::resizeEvent(QResizeEvent *ev) { + int frameWidth = style()->pixelMetric(QStyle::PM_DefaultFrameWidth); + mySearchIcon->move(rect().left() + frameWidth + 4, (rect().bottom() - mySearchIcon->sizeHint().height())/2 + 2); + + QSize waitingIconSize = myWaitingIcon->size(); + myWaitingIcon->move(rect().right() - frameWidth - waitingIconSize.width() - 2, (rect().bottom() + 1 - waitingIconSize.height())/2); + QLineEdit::resizeEvent(ev); +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtSearchField.h b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtSearchField.h new file mode 100644 index 0000000..f6e174c --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/tree/ZLQtSearchField.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 __ZLQTSEARCHFIELD_H__ +#define __ZLQTSEARCHFIELD_H__ + +#include <QtCore/QSet> +#include <QtGui/QLabel> +#include <QtGui/QLineEdit> + +#include "QtWaitingSpinner.h" +#include "ZLQtItemsListWidget.h" + +class ZLQtSearchField : public QLineEdit { + Q_OBJECT; +public: + ZLQtSearchField(QWidget *parent = 0); + QtWaitingSpinner *getWaitingIcon(); + +protected Q_SLOTS: + void onReturnPressed(); + +protected: + void updateSuggestions(); + void loadSuggestions(); + void saveSuggestions(); + +protected: + void resizeEvent(QResizeEvent *ev); + +private: + QLabel *mySearchIcon; + QtWaitingSpinner *myWaitingIcon; + QSet<QString> mySuggestions; + +}; + +#endif /* __ZLQTSEARCHFIELD_H__ */ diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/view/ZLQtViewWidget.cpp b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/view/ZLQtViewWidget.cpp new file mode 100644 index 0000000..4f5d196 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/view/ZLQtViewWidget.cpp @@ -0,0 +1,300 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <algorithm> + +#include <QtGui/QLayout> +#include <QtGui/QScrollBar> +#include <QtGui/QPainter> +#include <QtGui/QPixmap> +#include <QtGui/QMouseEvent> + +#include <ZLibrary.h> +#include <ZLLanguageUtil.h> + +#include "ZLQtViewWidget.h" +#include "ZLQtPaintContext.h" + +class MyQScrollBar : public QScrollBar { + +public: + MyQScrollBar(Qt::Orientation orientation, QWidget *parent) : QScrollBar(orientation, parent) { + } + +private: + void mouseMoveEvent(QMouseEvent *event) { + if (orientation() == Qt::Vertical) { + const int y = event->y(); + if ((y <= 0) || (y >= height())) { + return; + } + } else { + const int x = event->x(); + if ((x <= 0) || (x >= width())) { + return; + } + } + QScrollBar::mouseMoveEvent(event); + } +}; + +ZLQtViewWidget::Widget::Widget(QWidget *parent, ZLQtViewWidget &holder) : QWidget(parent), myHolder(holder) { + //setBackgroundMode(NoBackground); +} + +QScrollBar *ZLQtViewWidget::addScrollBar(QGridLayout *layout, Qt::Orientation orientation, int x, int y) { + QScrollBar *scrollBar = new MyQScrollBar(orientation, myFrame); + layout->addWidget(scrollBar, x, y); + scrollBar->hide(); + if (orientation == Qt::Vertical) { + connect(scrollBar, SIGNAL(sliderMoved(int)), this, SLOT(onVerticalSliderMoved(int))); + connect(scrollBar, SIGNAL(actionTriggered(int)), this, SLOT(onVerticalSliderClicked(int))); + } else { + connect(scrollBar, SIGNAL(sliderMoved(int)), this, SLOT(onHorizontalSliderMoved(int))); + connect(scrollBar, SIGNAL(actionTriggered(int)), this, SLOT(onHorizontalSliderClicked(int))); + } + return scrollBar; +} + +ZLQtViewWidget::ZLQtViewWidget(QWidget *parent, ZLApplication *application) : ZLViewWidget((ZLView::Angle)application->AngleStateOption.value()), myApplication(application) { + myFrame = new QWidget(parent); + QGridLayout *layout = new QGridLayout(); + layout->setMargin(0); + layout->setSpacing(0); + myFrame->setLayout(layout); + myQWidget = new Widget(myFrame, *this); + layout->addWidget(myQWidget, 1, 1); + + myRightScrollBar = addScrollBar(layout, Qt::Vertical, 1, 2); + myLeftScrollBar = addScrollBar(layout, Qt::Vertical, 1, 0); + myShowScrollBarAtRight = true; + + myBottomScrollBar = addScrollBar(layout, Qt::Horizontal, 2, 1); + myTopScrollBar = addScrollBar(layout, Qt::Horizontal, 0, 1); + myShowScrollBarAtBottom = true; +} + +void ZLQtViewWidget::trackStylus(bool track) { + myQWidget->setMouseTracking(track); +} + +void ZLQtViewWidget::Widget::paintEvent(QPaintEvent*) { + ZLQtPaintContext &context = (ZLQtPaintContext&)myHolder.view()->context(); + switch (myHolder.rotation()) { + default: + context.setSize(width(), height()); + break; + case ZLView::DEGREES90: + case ZLView::DEGREES270: + context.setSize(height(), width()); + break; + } + myHolder.view()->paint(); + QPainter realPainter(this); + switch (myHolder.rotation()) { + default: + realPainter.drawPixmap(0, 0, context.pixmap()); + break; + case ZLView::DEGREES90: + realPainter.rotate(270); + realPainter.drawPixmap(1 - height(), -1, context.pixmap()); + break; + case ZLView::DEGREES180: + realPainter.rotate(180); + realPainter.drawPixmap(1 - width(), 1 - height(), context.pixmap()); + break; + case ZLView::DEGREES270: + realPainter.rotate(90); + realPainter.drawPixmap(-1, 1 - width(), context.pixmap()); + break; + } +} + +void ZLQtViewWidget::Widget::mousePressEvent(QMouseEvent *event) { + myHolder.view()->onStylusMove(x(event), y(event)); + myHolder.view()->onStylusPress(x(event), y(event)); +} + +void ZLQtViewWidget::Widget::mouseReleaseEvent(QMouseEvent *event) { + myHolder.view()->onStylusRelease(x(event), y(event)); +} + +void ZLQtViewWidget::Widget::mouseMoveEvent(QMouseEvent *event) { + switch (event->buttons()) { + case Qt::LeftButton: + myHolder.view()->onStylusMovePressed(x(event), y(event)); + break; + case Qt::NoButton: + myHolder.view()->onStylusMove(x(event), y(event)); + break; + default: + break; + } +} + +int ZLQtViewWidget::Widget::x(const QMouseEvent *event) const { + const int maxX = width() - 1; + const int maxY = height() - 1; + switch (myHolder.rotation()) { + default: + return std::min(std::max(event->x(), 0), maxX); + case ZLView::DEGREES90: + return maxY - std::min(std::max(event->y(), 0), maxY); + case ZLView::DEGREES180: + return maxX - std::min(std::max(event->x(), 0), maxX); + case ZLView::DEGREES270: + return std::min(std::max(event->y(), 0), maxY); + } +} + +int ZLQtViewWidget::Widget::y(const QMouseEvent *event) const { + const int maxX = width() - 1; + const int maxY = height() - 1; + switch (myHolder.rotation()) { + default: + return std::min(std::max(event->y(), 0), maxY); + case ZLView::DEGREES90: + return std::min(std::max(event->x(), 0), maxX); + case ZLView::DEGREES180: + return maxY - std::min(std::max(event->y(), 0), maxY); + case ZLView::DEGREES270: + return maxX - std::min(std::max(event->x(), 0), maxX); + } +} + +void ZLQtViewWidget::repaint() { + //myQWidget->repaint(); + myQWidget->update(); //not repaint for thread safety +} + +void ZLQtViewWidget::setScrollbarEnabled(ZLView::Direction direction, bool enabled) { + if (direction == ZLView::VERTICAL) { + myRightScrollBar->setShown(enabled && myShowScrollBarAtRight); + myLeftScrollBar->setShown(enabled && !myShowScrollBarAtRight); + } else { + myBottomScrollBar->setShown(enabled && myShowScrollBarAtBottom); + myTopScrollBar->setShown(enabled && !myShowScrollBarAtBottom); + } +} + +void ZLQtViewWidget::setScrollbarPlacement(ZLView::Direction direction, bool standard) { + if ((rotation() == ZLView::DEGREES90) || (rotation() == ZLView::DEGREES270)) { + if (ZLLanguageUtil::isRTLLanguage(ZLibrary::Language())) { + standard = !standard; + } + } + if (direction == ZLView::VERTICAL) { + if (standard != myShowScrollBarAtRight) { + myShowScrollBarAtRight = standard; + QScrollBar *old = standard ? myLeftScrollBar : myRightScrollBar; + QScrollBar *current = standard ? myRightScrollBar : myLeftScrollBar; + if (old->isVisible()) { + old->hide(); + current->show(); + } + } + } else { + if (standard != myShowScrollBarAtBottom) { + myShowScrollBarAtBottom = standard; + QScrollBar *old = standard ? myTopScrollBar : myBottomScrollBar; + QScrollBar *current = standard ? myBottomScrollBar : myTopScrollBar; + if (old->isVisible()) { + old->hide(); + current->show(); + } + } + } +} + +void ZLQtViewWidget::setScrollbarParameters(ZLView::Direction direction, size_t full, size_t from, size_t to) { + QScrollBar *bar = + (direction == ZLView::VERTICAL) ? + (myShowScrollBarAtRight ? myRightScrollBar : myLeftScrollBar) : + (myShowScrollBarAtBottom ? myBottomScrollBar : myTopScrollBar); + bar->setMinimum(0); + bar->setMaximum(full + from - to); + bar->setValue(from); + bar->setPageStep(to - from); +} + +void ZLQtViewWidget::onVerticalSliderMoved(int value) { + QScrollBar *bar = + myShowScrollBarAtRight ? myRightScrollBar : myLeftScrollBar; + int maxValue = bar->maximum(); + int pageStep = bar->pageStep(); + value = std::max(std::min(value, maxValue), 0); + onScrollbarMoved( + ZLView::VERTICAL, + maxValue + pageStep, + value, + value + pageStep + ); +} + +void ZLQtViewWidget::onHorizontalSliderMoved(int value) { + QScrollBar *bar = + myShowScrollBarAtBottom ? myBottomScrollBar : myTopScrollBar; + int maxValue = bar->maximum(); + int pageStep = bar->pageStep(); + value = std::max(std::min(value, maxValue), 0); + onScrollbarMoved( + ZLView::HORIZONTAL, + maxValue + pageStep, + value, + value + pageStep + ); +} + +void ZLQtViewWidget::onVerticalSliderClicked(int value) { + switch (value) { + case QScrollBar::SliderSingleStepAdd: + onScrollbarStep(ZLView::VERTICAL, 1); + break; + case QScrollBar::SliderSingleStepSub: + onScrollbarStep(ZLView::VERTICAL, -1); + break; + case QScrollBar::SliderPageStepAdd: + onScrollbarPageStep(ZLView::VERTICAL, 1); + break; + case QScrollBar::SliderPageStepSub: + onScrollbarPageStep(ZLView::VERTICAL, -1); + break; + } +} + +void ZLQtViewWidget::onHorizontalSliderClicked(int value) { + switch (value) { + case QScrollBar::SliderSingleStepAdd: + onScrollbarStep(ZLView::HORIZONTAL, 1); + break; + case QScrollBar::SliderSingleStepSub: + onScrollbarStep(ZLView::HORIZONTAL, -1); + break; + case QScrollBar::SliderPageStepAdd: + onScrollbarPageStep(ZLView::HORIZONTAL, 1); + break; + case QScrollBar::SliderPageStepSub: + onScrollbarPageStep(ZLView::HORIZONTAL, -1); + break; + } +} + +QWidget *ZLQtViewWidget::widget() { + return myFrame; +} diff --git a/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/view/ZLQtViewWidget.h b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/view/ZLQtViewWidget.h new file mode 100644 index 0000000..6fabf00 --- /dev/null +++ b/.pc/0002-Qt5.patch/zlibrary/ui/src/qt4/view/ZLQtViewWidget.h @@ -0,0 +1,88 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 __ZLQTVIEWWIDGET_H__ +#define __ZLQTVIEWWIDGET_H__ + +#include <QtGui/QWidget> + +#include "../../../../core/src/view/ZLViewWidget.h" +#include <ZLApplication.h> + +class QGridLayout; +class QScrollBar; + +class ZLQtViewWidget : public QObject, public ZLViewWidget { + Q_OBJECT + +private: + class Widget : public QWidget { + + public: + Widget(QWidget *parent, ZLQtViewWidget &holder); + + private: + void paintEvent(QPaintEvent *event); + void mousePressEvent(QMouseEvent *event); + void mouseReleaseEvent(QMouseEvent *event); + void mouseMoveEvent(QMouseEvent *event); + + int x(const QMouseEvent *event) const; + int y(const QMouseEvent *event) const; + + private: + ZLQtViewWidget &myHolder; + }; + +public: + ZLQtViewWidget(QWidget *parent, ZLApplication *application); + QWidget *widget(); + +private Q_SLOTS: + void onVerticalSliderMoved(int value); + void onHorizontalSliderMoved(int value); + void onVerticalSliderClicked(int value); + void onHorizontalSliderClicked(int value); + +private: + void repaint(); + void trackStylus(bool track); + + void setScrollbarEnabled(ZLView::Direction direction, bool enabled); + void setScrollbarPlacement(ZLView::Direction direction, bool standard); + void setScrollbarParameters(ZLView::Direction direction, size_t full, size_t from, size_t to); + + QScrollBar *addScrollBar(QGridLayout *layout, Qt::Orientation orientation, int x, int y); + +private: + QWidget *myFrame; + Widget *myQWidget; + + QScrollBar *myRightScrollBar; + QScrollBar *myLeftScrollBar; + bool myShowScrollBarAtRight; + + QScrollBar *myBottomScrollBar; + QScrollBar *myTopScrollBar; + bool myShowScrollBarAtBottom; + + ZLApplication *myApplication; +}; + +#endif /* __ZLQTVIEWWIDGET_H__ */ diff --git a/.pc/0003-gcc-6.patch/fbreader/src/formats/doc/OleStorage.cpp b/.pc/0003-gcc-6.patch/fbreader/src/formats/doc/OleStorage.cpp new file mode 100644 index 0000000..016f9fd --- /dev/null +++ b/.pc/0003-gcc-6.patch/fbreader/src/formats/doc/OleStorage.cpp @@ -0,0 +1,304 @@ +/* + * Copyright (C) 2004-2012 Geometer Plus <[email protected]> + * + * 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 <ZLLogger.h> + +#include "OleStorage.h" +#include "OleUtil.h" + +#include <cstring> + +const std::size_t OleStorage::BBD_BLOCK_SIZE = 512; + +OleStorage::OleStorage() { + clear(); +} + +void OleStorage::clear() { + myInputStream = 0; + mySectorSize = 0; + myShortSectorSize = 0; + myStreamSize = 0; + myRootEntryIndex = -1; + + myDIFAT.clear(); + myBBD.clear(); + mySBD.clear(); + myProperties.clear(); + myEntries.clear(); +} + + + +bool OleStorage::init(shared_ptr<ZLInputStream> stream, std::size_t streamSize) { + clear(); + + myInputStream = stream; + myStreamSize = streamSize; + myInputStream->seek(0, true); + + char oleBuf[BBD_BLOCK_SIZE]; + std::size_t ret = myInputStream->read(oleBuf, BBD_BLOCK_SIZE); + if (ret != BBD_BLOCK_SIZE) { + clear(); + return false; + } + static const char OLE_SIGN[] = {0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1, 0}; + if (std::strncmp(oleBuf, OLE_SIGN, 8) != 0) { + clear(); + return false; + } + mySectorSize = 1 << OleUtil::getU2Bytes(oleBuf, 0x1e); //offset for value of big sector size + myShortSectorSize = 1 << OleUtil::getU2Bytes(oleBuf, 0x20); //offset for value of small sector size + + if (readDIFAT(oleBuf) && readBBD(oleBuf) && readSBD(oleBuf) && readProperties(oleBuf) && readAllEntries()) { + return true; + } + clear(); + return false; +} + +bool OleStorage::readDIFAT(char *oleBuf) { + int difatBlock = OleUtil::get4Bytes(oleBuf, 0x44); //address for first difat sector + int difatSectorNumbers = OleUtil::get4Bytes(oleBuf, 0x48); //numbers of additional difat records + + //436 of difat records are stored in header, by offset 0x4c + for (unsigned int i = 0; i < 436; i += 4) { + myDIFAT.push_back(OleUtil::get4Bytes(oleBuf + 0x4c, i)); + } + + //for files > 6.78 mb we need read additional DIFAT fields + for (int i = 0; difatBlock > 0 && i < difatSectorNumbers; ++i) { + ZLLogger::Instance().println("DocPlugin", "Read additional data for DIFAT"); + char buffer[mySectorSize]; + myInputStream->seek(BBD_BLOCK_SIZE + difatBlock * mySectorSize, true); + if (myInputStream->read(buffer, mySectorSize) != mySectorSize) { + ZLLogger::Instance().println("DocPlugin", "Error read DIFAT!"); + return false; + } + for (unsigned int j = 0; j < (mySectorSize - 4); j += 4) { + myDIFAT.push_back(OleUtil::get4Bytes(buffer, j)); + } + difatBlock = OleUtil::get4Bytes(buffer, mySectorSize - 4); //next DIFAT block is pointed at the end of the sector + } + + //removing unusable DIFAT links + //0xFFFFFFFF means "free section" + while (!myDIFAT.empty() && myDIFAT.back() == (int)0xFFFFFFFF) { + myDIFAT.pop_back(); + } + return true; +} + +bool OleStorage::readBBD(char *oleBuf) { + char buffer[mySectorSize]; + unsigned int bbdNumberBlocks = OleUtil::getU4Bytes(oleBuf, 0x2c); //number of big blocks + + if (myDIFAT.size() < bbdNumberBlocks) { + //TODO maybe add check on myDIFAT == bbdNumberBlocks + ZLLogger::Instance().println("DocPlugin", "Wrong number of FAT blocks value"); + return false; + } + + for (unsigned int i = 0; i < bbdNumberBlocks; ++i) { + int bbdSector = myDIFAT.at(i); + if (bbdSector >= (int)(myStreamSize / mySectorSize) || bbdSector < 0) { + ZLLogger::Instance().println("DocPlugin", "Bad BBD entry!"); + return false; + } + myInputStream->seek(BBD_BLOCK_SIZE + bbdSector * mySectorSize, true); + if (myInputStream->read(buffer, mySectorSize) != mySectorSize) { + ZLLogger::Instance().println("DocPlugin", "Error during reading BBD!"); + return false; + } + for (unsigned int j = 0; j < mySectorSize; j += 4) { + myBBD.push_back(OleUtil::get4Bytes(buffer, j)); + } + } + return true; +} + +bool OleStorage::readSBD(char *oleBuf) { + int sbdCur = OleUtil::get4Bytes(oleBuf, 0x3c); //address of first small sector + int sbdCount = OleUtil::get4Bytes(oleBuf, 0x40); //count of small sectors + + if (sbdCur <= 0) { + ZLLogger::Instance().println("DocPlugin", "There's no SBD, don't read it"); + return true; + } + + char buffer[mySectorSize]; + for (int i = 0; i < sbdCount; ++i) { + if (i != 0) { + if (sbdCur < 0 || (unsigned int)sbdCur >= myBBD.size()) { + ZLLogger::Instance().println("DocPlugin", "error during parsing SBD"); + return false; + } + sbdCur = myBBD.at(sbdCur); + } + if (sbdCur <= 0) { + break; + } + myInputStream->seek(BBD_BLOCK_SIZE + sbdCur * mySectorSize, true); + if (myInputStream->read(buffer, mySectorSize) != mySectorSize) { + ZLLogger::Instance().println("DocPlugin", "reading error during parsing SBD"); + return false; + } + for (unsigned int j = 0; j < mySectorSize; j += 4) { + mySBD.push_back(OleUtil::get4Bytes(buffer, j)); + } + + } + return true; +} + +bool OleStorage::readProperties(char *oleBuf) { + int propCur = OleUtil::get4Bytes(oleBuf, 0x30); //offset for address of sector with first property + if (propCur < 0) { + ZLLogger::Instance().println("DocPlugin", "Wrong first directory sector location"); + return false; + } + + char buffer[mySectorSize]; + do { + myInputStream->seek(BBD_BLOCK_SIZE + propCur * mySectorSize, true); + if (myInputStream->read(buffer, mySectorSize) != mySectorSize) { + ZLLogger::Instance().println("DocPlugin", "Error during reading properties"); + return false; + } + for (unsigned int j = 0; j < mySectorSize; j += 128) { + myProperties.push_back(std::string(buffer + j, 128)); + } + if (propCur < 0 || (std::size_t)propCur >= myBBD.size()) { + break; + } + propCur = myBBD.at(propCur); + } while (propCur >= 0 && propCur < (int)(myStreamSize / mySectorSize)); + return true; +} + +bool OleStorage::readAllEntries() { + int propCount = myProperties.size(); + for (int i = 0; i < propCount; ++i) { + OleEntry entry; + bool result = readOleEntry(i, entry); + if (!result) { + break; + } + if (entry.type == OleEntry::ROOT_DIR) { + myRootEntryIndex = i; + } + myEntries.push_back(entry); + } + if (myRootEntryIndex < 0) { + return false; + } + return true; +} + +bool OleStorage::readOleEntry(int propNumber, OleEntry &e) { + static const std::string ROOT_ENTRY = "Root Entry"; + + std::string property = myProperties.at(propNumber); + + char oleType = property.at(0x42); //offset for Ole Type + if (oleType != 1 && oleType != 2 && oleType != 3 && oleType != 5) { + ZLLogger::Instance().println("DocPlugin", "entry -- not right ole type"); + return false; + } + + e.type = (OleEntry::Type)oleType; + + int nameLength = OleUtil::getU2Bytes(property.c_str(), 0x40); //offset for value entry's name length + e.name.clear(); + e.name.reserve(33); //max size of entry name + + if ((unsigned int)nameLength >= property.size()) { + return false; + } + for (int i = 0; i < nameLength; i+=2) { + char c = property.at(i); + if (c != 0) { + e.name += c; + } + } + + e.length = OleUtil::getU4Bytes(property.c_str(), 0x78); //offset for entry's length value + e.isBigBlock = e.length >= 0x1000 || e.name == ROOT_ENTRY; + + // Read sector chain + if (property.size() < 0x74 + 4) { + ZLLogger::Instance().println("DocPlugin", "problems with reading ole entry"); + return false; + } + int chainCur = OleUtil::get4Bytes(property.c_str(), 0x74); //offset for start block of entry + if (chainCur >= 0 && (chainCur <= (int)(myStreamSize / (e.isBigBlock ? mySectorSize : myShortSectorSize)))) { + //filling blocks with chains + do { + e.blocks.push_back((unsigned int)chainCur); + if (e.isBigBlock && (std::size_t)chainCur < myBBD.size()) { + chainCur = myBBD.at(chainCur); + } else if (!mySBD.empty() && (std::size_t)chainCur < mySBD.size()) { + chainCur = mySBD.at(chainCur); + } else { + chainCur = -1; + } + } while (chainCur > 0 && + chainCur < (int)(e.isBigBlock ? myBBD.size() : mySBD.size()) && + e.blocks.size() <= e.length / (e.isBigBlock ? mySectorSize : myShortSectorSize)); + } + e.length = std::min(e.length, (unsigned int)((e.isBigBlock ? mySectorSize : myShortSectorSize) * e.blocks.size())); + return true; +} + +bool OleStorage::countFileOffsetOfBlock(const OleEntry &e, unsigned int blockNumber, unsigned int &result) const { + //TODO maybe better syntax can be used? + if (e.blocks.size() <= (std::size_t)blockNumber) { + ZLLogger::Instance().println("DocPlugin", "countFileOffsetOfBlock can't be done, blockNumber is invalid"); + return false; + } + if (e.isBigBlock) { + result = BBD_BLOCK_SIZE + e.blocks.at(blockNumber) * mySectorSize; + } else { + unsigned int sbdPerSector = mySectorSize / myShortSectorSize; + unsigned int sbdSectorNumber = e.blocks.at(blockNumber) / sbdPerSector; + unsigned int sbdSectorMod = e.blocks.at(blockNumber) % sbdPerSector; + if (myEntries.at(myRootEntryIndex).blocks.size() <= (std::size_t)sbdSectorNumber) { + ZLLogger::Instance().println("DocPlugin", "countFileOffsetOfBlock can't be done, invalid sbd data"); + return false; + } + result = BBD_BLOCK_SIZE + myEntries.at(myRootEntryIndex).blocks.at(sbdSectorNumber) * mySectorSize + sbdSectorMod * myShortSectorSize; + } + return true; +} + +bool OleStorage::getEntryByName(std::string name, OleEntry &returnEntry) const { + //TODO fix the workaround for duplicates streams: now it takes a stream with max length + unsigned int maxLength = 0; + for (std::size_t i = 0; i < myEntries.size(); ++i) { + const OleEntry &entry = myEntries.at(i); + if (entry.name == name && entry.length >= maxLength) { + returnEntry = entry; + maxLength = entry.length; + } + } + return maxLength > 0; +} + + diff --git a/.pc/0004-prevent-so-install.patch/zlibrary/core/Makefile b/.pc/0004-prevent-so-install.patch/zlibrary/core/Makefile new file mode 100644 index 0000000..55c9401 --- /dev/null +++ b/.pc/0004-prevent-so-install.patch/zlibrary/core/Makefile @@ -0,0 +1,109 @@ +ROOTDIR = $(CURDIR)/../.. +MAKEFILESDIR = $(ROOTDIR)/makefiles +include $(MAKEFILESDIR)/config.mk + +VERSION = $(shell cat ../VERSION) +SOVERSION = $(shell cat SOVERSION) + +ifeq "$(ZLSHARED)" "yes" + ifeq "$(TARGET_ARCH)" "macosx" + TARGET = libzlcore.$(VERSION).dylib + TARGET_SONAME = libzlcore.$(SOVERSION).dylib + TARGET_SHORTNAME = libzlcore.dylib + else + TARGET = libzlcore.so.$(VERSION) + TARGET_SONAME = libzlcore.so.$(SOVERSION) + TARGET_SHORTNAME = libzlcore.so + endif +else + TARGET = libzlcore.a +endif + +SUBDIRS_ALL = src/library src/typeId src/util src/constants src/logger src/filesystem src/filesystem/zip src/filesystem/bzip2 src/filesystem/tar src/dialogs src/optionEntries src/application src/view src/encoding src/options src/message src/resources src/time src/xml src/xml/expat src/image src/language src/runnable src/network src/network/requests src/blockTreeView src/tree src/desktop/application src/desktop/dialogs src/unix/time src/unix/xmlconfig src/unix/filesystem src/unix/iconv src/unix/library src/unix/curl src/win32/encoding src/win32/filesystem src/win32/config + +SUBDIRS = src/library src/typeId src/util src/constants src/logger src/filesystem src/filesystem/zip src/filesystem/bzip2 src/filesystem/tar src/dialogs src/optionEntries src/application src/view src/encoding src/options src/message src/resources src/time src/xml src/xml/expat src/image src/language src/unix/time src/runnable src/network src/network/requests src/blockTreeView src/tree + +ifeq "<$(TARGET_ARCH)>" "$(findstring <$(TARGET_ARCH)>, <desktop> <pepperpad3> <macosx> <bb10>)" + SUBDIRS += src/desktop/application src/desktop/dialogs +endif + +ifeq "$(TARGET_ARCH)" "pdaxrom" + SUBDIRS += src/desktop/dialogs +endif + +ifeq "$(TARGET_ARCH)" "win32" + SUBDIRS += src/desktop/application src/desktop/dialogs src/win32/encoding src/win32/filesystem src/win32/config +else + SUBDIRS += src/unix/xmlconfig src/unix/filesystem src/unix/iconv src/unix/library +endif + +.objects: + +@for subdir in $(SUBDIRS); do \ + if [ -d $$subdir ]; then \ + if ! $(LIBMAKE) -C $$subdir -f $(MAKEFILESDIR)/subdir.mk; then \ + exit 1; \ + fi; \ + fi; \ + done; + +$(TARGET): .objects + @echo -n 'Creating $@ ...' + @$(RM_QUIET) $(TARGET) +ifeq "$(ZLSHARED)" "yes" + @$(LD) $(LDFLAGS) -shared -Wl,-soname,$(TARGET_SONAME) -o $(TARGET) -lc $(patsubst %, %/*.o, $(SUBDIRS)) $(XML_LIBS) $(ARCHIVER_LIBS) +#@$(LD) $(LDFLAGS) -dynamiclib -dylinker_install_name $(TARGET_SONAME) -o $(TARGET) -lc $(patsubst %, %/*.o, $(SUBDIRS)) $(XML_LIBS) $(ARCHIVER_LIBS) $(ZLUI_LIB) -ldl -liconv + @ln -sf $(TARGET) $(TARGET_SONAME) + @ln -sf $(TARGET) $(TARGET_SHORTNAME) +else + @$(AR) $(TARGET) $(patsubst %, %/*.o, $(SUBDIRS)) +endif + echo ' OK' + +SHARE_ZLIBRARY = $(DESTDIR)$(SHAREDIR)/zlibrary + +ENCODING_FILES = $(wildcard data/encodings/*) +ifeq "$(TARGET_ARCH)" "maemo" + ENCODING_FILES = $(filter-out %/Big5,$(wildcard data/encodings/*)) +endif + +do_install: + @install -d $(SHARE_ZLIBRARY) + @install -d $(SHARE_ZLIBRARY)/encodings + @install -m 0644 $(ENCODING_FILES) $(SHARE_ZLIBRARY)/encodings + @install -d $(SHARE_ZLIBRARY)/resources + @install -m 0644 $(wildcard data/resources/*.xml) $(SHARE_ZLIBRARY)/resources + @install -m 0644 data/languagePatterns.zip $(SHARE_ZLIBRARY) + @install -m 0644 data/unicode.xml.gz $(SHARE_ZLIBRARY) + @install -d $(SHARE_ZLIBRARY)/default + @if [ -e data/default/config.$(TARGET_ARCH).xml ]; then \ + install -m 0644 data/default/config.$(TARGET_ARCH).xml $(SHARE_ZLIBRARY)/default/config.xml; \ + fi + @if [ -e data/default/config.$(TARGET_ARCH)-$(UI_TYPE).xml ]; then \ + install -m 0644 data/default/config.$(TARGET_ARCH)-$(UI_TYPE).xml $(SHARE_ZLIBRARY)/default/config.xml; \ + fi +ifeq "$(ZLSHARED)" "yes" + @install -d $(DESTDIR)$(LIBDIR) + @install $(TARGET) $(DESTDIR)$(LIBDIR) + @ln -sf $(TARGET) $(DESTDIR)$(LIBDIR)/$(TARGET_SONAME) + @ln -sf $(TARGET) $(DESTDIR)$(LIBDIR)/$(TARGET_SHORTNAME) +endif + +do_install_dev: + @install -d $(DESTDIR)$(LIBDIR) +ifeq "$(ZLSHARED)" "yes" + @ln -sf $(TARGET) $(DESTDIR)$(LIBDIR)/$(TARGET_SHORTNAME) +else + @install $(TARGET) $(DESTDIR)$(LIBDIR) +endif + @install -d $(DESTDIR)$(INCDIR)/zlibrary/core + @install -m 0644 $(wildcard include/*.h) $(DESTDIR)$(INCDIR)/zlibrary/core + @install -d $(DESTDIR)$(INCDIR)/zlibrary/core/optionEntries + @install -m 0644 $(wildcard include/optionEntries/*.h) $(DESTDIR)$(INCDIR)/zlibrary/core/optionEntries + +clean: + @for subdir in $(SUBDIRS_ALL); do \ + if [ -d $$subdir ]; then \ + $(MAKE) -C $$subdir -f $(MAKEFILESDIR)/subdir.mk clean; \ + fi; \ + done; + @$(RM) *.so *.so.* *.dylib *.a diff --git a/.pc/0004-prevent-so-install.patch/zlibrary/text/Makefile b/.pc/0004-prevent-so-install.patch/zlibrary/text/Makefile new file mode 100644 index 0000000..7fa8fbd --- /dev/null +++ b/.pc/0004-prevent-so-install.patch/zlibrary/text/Makefile @@ -0,0 +1,74 @@ +ROOTDIR = $(CURDIR)/../.. +MAKEFILESDIR = $(ROOTDIR)/makefiles +include $(MAKEFILESDIR)/config.mk + +VERSION = $(shell cat ../VERSION) +SOVERSION = $(shell cat SOVERSION) + +ifeq "$(ZLSHARED)" "yes" + ifeq "$(TARGET_ARCH)" "macosx" + TARGET = libzltext.$(VERSION).dylib + TARGET_SONAME = libzltext.$(SOVERSION).dylib + TARGET_SHORTNAME = libzltext.dylib + else + TARGET = libzltext.so.$(VERSION) + TARGET_SONAME = libzltext.so.$(SOVERSION) + TARGET_SHORTNAME = libzltext.so + endif +else + TARGET = libzltext.a +endif + +SUBDIRS = src/model src/area src/view src/style src/styleOptions src/hyphenation + +.objects: + +@for subdir in $(SUBDIRS); do \ + if [ -d $$subdir ]; then \ + if ! $(LIBMAKE) -C $$subdir -f $(MAKEFILESDIR)/subdir.mk; then \ + exit 1; \ + fi; \ + fi; \ + done; + +$(TARGET): .objects + @echo -n 'Creating $@ ...' + @$(RM_QUIET) $(TARGET) +ifeq "$(ZLSHARED)" "yes" + @$(LD) $(LDFLAGS) -shared -Wl,-soname,$(TARGET_SONAME) -o $(TARGET) $(patsubst %, %/*.o, $(SUBDIRS)) $(CORE_LIBS) -lunibreak -lfribidi +#@$(LD) $(LDFLAGS) -dynamiclib -dylinker_install_name $(TARGET_SONAME) -o $(TARGET) $(patsubst %, %/*.o, $(SUBDIRS)) $(CORE_LIBS) $(EXTERNAL_LIBS) -llinebreak -lfribidi + @ln -sf $(TARGET) $(TARGET_SONAME) + @ln -sf $(TARGET) $(TARGET_SHORTNAME) +else + @$(AR) $(TARGET) $(patsubst %, %/*.o, $(SUBDIRS)) +endif + @echo ' OK' + +SHARE_ZLIBRARY = $(DESTDIR)$(SHAREDIR)/zlibrary + +do_install: + @install -d $(SHARE_ZLIBRARY) + @install -m 0644 $(wildcard data/hyphenationPatterns.zip) $(SHARE_ZLIBRARY) +ifeq "$(ZLSHARED)" "yes" + @install -d $(DESTDIR)$(LIBDIR) + @install $(TARGET) $(DESTDIR)$(LIBDIR) + @ln -sf $(TARGET) $(DESTDIR)$(LIBDIR)/$(TARGET_SONAME) + @ln -sf $(TARGET) $(DESTDIR)$(LIBDIR)/$(TARGET_SHORTNAME) +endif + +do_install_dev: + @install -d $(DESTDIR)$(LIBDIR) +ifeq "$(ZLSHARED)" "yes" + @ln -sf $(TARGET) $(DESTDIR)$(LIBDIR)/$(TARGET_SHORTNAME) +else + @install $(TARGET) $(DESTDIR)$(LIBDIR) +endif + @install -d $(DESTDIR)$(INCDIR)/zlibrary/text + @install -m 0644 $(wildcard include/*.h) $(DESTDIR)$(INCDIR)/zlibrary/text + +clean: + @for subdir in $(SUBDIRS); do \ + if [ -d $$subdir ]; then \ + $(MAKE) -C $$subdir -f $(MAKEFILESDIR)/subdir.mk clean; \ + fi; \ + done; + @$(RM) *.so *.so.* *.dylib *.a diff --git a/.pc/0008-951-fix-calling-compiler.patch/makefiles/arch/desktop.mk b/.pc/0008-951-fix-calling-compiler.patch/makefiles/arch/desktop.mk new file mode 100644 index 0000000..90abdf2 --- /dev/null +++ b/.pc/0008-951-fix-calling-compiler.patch/makefiles/arch/desktop.mk @@ -0,0 +1,24 @@ +include $(ROOTDIR)/makefiles/arch/unix.mk + +ifeq "$(INSTALLDIR)" "" + INSTALLDIR=/usr +endif +IMAGEDIR = $(INSTALLDIR)/share/pixmaps +APPIMAGEDIR = $(INSTALLDIR)/share/pixmaps/%APPLICATION_NAME% + + +CCACHE = $(shell if which ccache > /dev/null; then echo "ccache"; fi) #if ccache is not installed, do not use it +CC = $(CCACHE) gcc +AR = ar rsu +LD = g++ + +CFLAGS = -pipe -fno-exceptions -Wall -Wno-ctor-dtor-privacy -W -DLIBICONV_PLUG +LDFLAGS = +EXTERNAL_INCLUDE = $(shell $(PKG_CONFIG) --cflags fribidi) + +MOC = "$(shell $(PKG_CONFIG) --variable=host_bins Qt5Core)/moc" +QTINCLUDE = $(shell $(PKG_CONFIG) --cflags Qt5Gui Qt5Widgets Qt5Network) +UILIBS = $(shell $(PKG_CONFIG) --libs Qt5Gui Qt5Widgets Qt5Network) + +RM = rm -rvf +RM_QUIET = rm -rf diff --git a/.pc/0008-951-fix-calling-compiler.patch/makefiles/gtksubdir.mk b/.pc/0008-951-fix-calling-compiler.patch/makefiles/gtksubdir.mk new file mode 100644 index 0000000..aed94f3 --- /dev/null +++ b/.pc/0008-951-fix-calling-compiler.patch/makefiles/gtksubdir.mk @@ -0,0 +1,28 @@ +include $(ROOTDIR)/makefiles/config.mk + +INCLUDE = $(ZINCLUDE) $(EXTERNAL_INCLUDE) $(GTKINCLUDE) + +HEADERS = $(wildcard *.h) +CSOURCES = $(wildcard *.c) +SOURCES = $(wildcard *.cpp) +OBJECTS = $(patsubst %.c, %.o, $(CSOURCES)) +OBJECTS += $(patsubst %.cpp, %.o, $(SOURCES)) + +.SUFFIXES: .c .cpp .o .h + +.c.o: + @echo -n 'Compiling $@ ...' + @$(CC) -MMD -c $(CFLAGS) $(INCLUDE) $< + @echo ' OK' + +.cpp.o: + @echo -n 'Compiling $@ ...' + @$(CC) -MMD -c $(CFLAGS) $(INCLUDE) $< + @echo ' OK' + +all: $(OBJECTS) + +clean: + @$(RM) *.o *.d + +-include *.d diff --git a/.pc/0008-951-fix-calling-compiler.patch/makefiles/platforms.mk b/.pc/0008-951-fix-calling-compiler.patch/makefiles/platforms.mk new file mode 100644 index 0000000..df83885 --- /dev/null +++ b/.pc/0008-951-fix-calling-compiler.patch/makefiles/platforms.mk @@ -0,0 +1,15 @@ +ifeq "$(TARGET_ARCH)$(UI_TYPE)" "" + include $(ROOTDIR)/makefiles/target.mk +endif + +ifeq "$(TARGET_ARCH)" "" +$(error TARGET_ARCH is not defined. Please edit $(ROOTDIR)/makefiles/target.mk) +endif + +ifeq "$(UI_TYPE)" "" +$(error UI_TYPE is not defined. Please edit $(ROOTDIR)/makefiles/target.mk) +endif + +ifeq "$(TARGET_STATUS)" "" + TARGET_STATUS = release +endif diff --git a/.pc/0008-951-fix-calling-compiler.patch/makefiles/qsubdir.mk b/.pc/0008-951-fix-calling-compiler.patch/makefiles/qsubdir.mk new file mode 100644 index 0000000..14b4efc --- /dev/null +++ b/.pc/0008-951-fix-calling-compiler.patch/makefiles/qsubdir.mk @@ -0,0 +1,28 @@ +include $(ROOTDIR)/makefiles/config.mk +-include moc.mk + +INCLUDE = $(QTINCLUDE) $(ZINCLUDE) $(EXTERNAL_INCLUDE) + +HEADERS = $(wildcard *.h) +SOURCES = $(wildcard *.cpp) +OBJMOC = $(patsubst %.cpp, %.o, $(SRCMOC)) +OBJECTS = $(patsubst %.cpp, %.o, $(SOURCES)) + +.SUFFIXES: .cpp .moc.cpp .moc.o .o .h + +.cpp.o: + @echo -n 'Compiling $@ ...' + @$(CC) -MMD -c $(CFLAGS) $(INCLUDE) $< + @echo ' OK' + +.h.moc.cpp: + @echo -n 'Generating $@ ...' + @$(MOC) $< -o $@ + @echo ' OK' + +all: $(OBJECTS) $(OBJMOC) + +clean: + @$(RM) *.o *.moc.cpp *.d + +-include *.d diff --git a/.pc/0008-951-fix-calling-compiler.patch/makefiles/subdir.mk b/.pc/0008-951-fix-calling-compiler.patch/makefiles/subdir.mk new file mode 100644 index 0000000..b364211 --- /dev/null +++ b/.pc/0008-951-fix-calling-compiler.patch/makefiles/subdir.mk @@ -0,0 +1,48 @@ +include $(ROOTDIR)/makefiles/config.mk + +INCLUDE = $(ZINCLUDE) $(EXTERNAL_INCLUDE) + +HEADERS = $(wildcard *.h) +SOURCES_CPP = $(wildcard *.cpp) +SOURCES_OBJCPP = $(wildcard *.M) +SOURCES_OBJC = $(wildcard *.m) +OBJECTS = $(patsubst %.cpp, %.o, $(SOURCES_CPP)) $(patsubst %.M, %.o, $(SOURCES_OBJCPP)) $(patsubst %.m, %.o, $(SOURCES_OBJC)) + +.SUFFIXES: .cpp .M .m .o .h + +.cpp.o: + @echo -n 'Compiling $@ ...' +ifdef CFLAGS_NOARCH + @$(CC) -MM $(CFLAGS_PRE) $(INCLUDE) $< -o `basename $< .cpp`.d + @$(CC) -c $(CFLAGS) $(INCLUDE) $< +else + @$(CC) -MMD -c $(CFLAGS) $(INCLUDE) $< +endif + @echo ' OK' + +.M.o: + @echo -n 'Compiling $@ ...' +ifdef CFLAGS_NOARCH + @$(CC) -MM $(CFLAGS_PRE) $(INCLUDE) $< -o `basename $< .M`.d + @$(CC) -c $(CFLAGS) $(INCLUDE) $< +else + @$(CC) -MMD -c $(CFLAGS) $(INCLUDE) $< +endif + @echo ' OK' + +.m.o: + @echo -n 'Compiling $@ ...' +ifdef CFLAGS_NOARCH + @$(CC) -MM $(CFLAGS_PRE) $(INCLUDE) $< -o `basename $< .m`.d + @$(CC) -c $(CFLAGS) $(INCLUDE) $< +else + @$(CC) -MMD -c $(CFLAGS) $(INCLUDE) $< +endif + @echo ' OK' + +all: $(OBJECTS) + +clean: + @$(RM) *.o *.s *.ld *.d + +-include *.d diff --git a/.pc/0009-fbreader-Makefile-do-not-try-to-install-empty-format.patch/fbreader/Makefile b/.pc/0009-fbreader-Makefile-do-not-try-to-install-empty-format.patch/fbreader/Makefile new file mode 100644 index 0000000..0d5ac7b --- /dev/null +++ b/.pc/0009-fbreader-Makefile-do-not-try-to-install-empty-format.patch/fbreader/Makefile @@ -0,0 +1,72 @@ +ROOTDIR = $(CURDIR)/.. + +MAKEFILESDIR = $(ROOTDIR)/makefiles + +include $(MAKEFILESDIR)/config.mk + +TARGET = FBReader +target = fbreader + +ALL_SUBDIRS = src src/database src/database/sqldb src/database/sqldb/implsqlite src/database/booksdb src/database/booksdb/runnables src/database/networkdb src/database/networkdb/runnables src/migration src/options src/library src/bookmodel src/formats src/formats/fb2 src/formats/docbook src/formats/css src/formats/html src/formats/pdb src/formats/txt src/formats/tcr src/formats/chm src/formats/xhtml src/formats/oeb src/formats/rtf src/formats/openreader src/formats/pdf src/formats/doc src/formats/dummy src/formats/util src/external src/fbreader src/encodingOption src/network src/network/authentication src/network/atom src/network/opds src/network/litres src/network/tree src/network/authentication/litres src/blockTree src/libraryActions src/libraryTree src/networkActions src/tree src/optionsDialog src/optionsDialog/bookInfo src/optionsDialog/library src/optionsDialog/network src/optionsDialog/system src/optionsDialog/reading src/optionsDialog/lookAndFeel +ALL_ARCHSUBDIRS = desktop pdaxrom opie zaurus maemo openzaurus pma400 win32 + +SUBDIRS = src/database src/database/sqldb src/database/sqldb/implsqlite src/database/booksdb src/database/booksdb/runnables src/database/networkdb src/database/networkdb/runnables src/migration src/options src/library src/bookmodel \ + src/formats src/formats/fb2 src/formats/css src/formats/html src/formats/pdb src/formats/txt src/formats/tcr src/formats/chm src/formats/xhtml src/formats/oeb src/formats/rtf src/formats/openreader src/formats/doc src/formats/util \ + src/external src/fbreader src/encodingOption src/network src/network/authentication src/network/atom src/network/opds src/network/litres src/network/tree src/network/authentication/litres \ + src/blockTree src/libraryActions src/libraryTree src/networkActions src/tree src/optionsDialog src/optionsDialog/bookInfo src/optionsDialog/library src/optionsDialog/network src/optionsDialog/system src/optionsDialog/reading src/optionsDialog/lookAndFeel + +all: .resources + @for subdir in $(SUBDIRS); do \ + if ! $(MAKE) -C $$subdir -f $(MAKEFILESDIR)/subdir.mk; then \ + exit 1; \ + fi; \ + done; + @echo -n 'Linking $(TARGET) ...' + @$(LD) $(LDFLAGS) -o $(TARGET) `find src -name *.o` $(TEXT_LIBS) $(CORE_LIBS) $(ZLUI_LIB) -lsqlite3 + @echo ' OK' + +FBSHAREDIR = $(DESTDIR)$(SHAREDIR)/FBReader +VARIANT = $(TARGET_ARCH) +ifneq "$(RESOLUTION)" "" + VARIANT = $(TARGET_ARCH)_$(RESOLUTION) +endif + +APPIMAGEDIR_REAL = $(subst %application_name%,$(target),$(subst %APPLICATION_NAME%,$(TARGET),$(APPIMAGEDIR))) + +do_install: + @install -d $(DESTDIR)$(BINDIR) + @install $(TARGET) $(DESTDIR)$(BINDIR)/FBReader + @install -d $(FBSHAREDIR) + @install -d $(FBSHAREDIR)/help + @./scripts/install_help.sh $(VARIANT) $(FBSHAREDIR)/help + @install -d $(FBSHAREDIR)/formats/html + @install -m 0644 data/formats/html/html.ent $(FBSHAREDIR)/formats/html + @install -d $(FBSHAREDIR)/formats/xhtml + @install -m 0644 $(wildcard data/formats/xhtml/*.ent) $(FBSHAREDIR)/formats/xhtml + @install -d $(FBSHAREDIR)/formats/fb2 + @sed "s/VERSION/$(VERSION)/" data/formats/fb2/FBReaderVersion.ent > $(FBSHAREDIR)/formats/fb2/FBReaderVersion.ent + @install -m 0644 data/formats/fb2/fb2genres.xml $(FBSHAREDIR)/formats/fb2 + @install -d $(FBSHAREDIR)/default + @./scripts/install_toolbar_and_menu.sh $(VARIANT) $(UI_TYPE) $(FBSHAREDIR)/default + @./scripts/install_config.sh $(VARIANT) $(UI_TYPE) $(FBSHAREDIR)/default + @install -m 0644 data/default/external.$(TARGET_ARCH).xml $(FBSHAREDIR)/default/external.xml + @if [ -f data/default/messages.$(TARGET_ARCH).xml ]; then \ + install -m 0644 data/default/messages.$(TARGET_ARCH).xml $(FBSHAREDIR)/default/messages.xml; \ + fi + @install -d $(FBSHAREDIR)/resources + @install -m 0644 $(wildcard data/resources/*.xml) $(FBSHAREDIR)/resources + @install -d $(DESTDIR)$(APPIMAGEDIR_REAL) + @install -m 0644 $(wildcard data/icons/toolbar/$(VARIANT)/*.*) $(DESTDIR)$(APPIMAGEDIR_REAL) + @install -m 0644 $(wildcard data/icons/filetree/$(VARIANT)/*.*) $(DESTDIR)$(APPIMAGEDIR_REAL) + @install -m 0644 $(wildcard data/icons/booktree/new/*.*) $(DESTDIR)$(APPIMAGEDIR_REAL) + @install -m 0644 $(wildcard data/icons/*.*) $(DESTDIR)$(APPIMAGEDIR_REAL) + @$(MAKE) -C $(TARGET_ARCH) RESOLUTION=$(RESOLUTION) install + +clean: + @for subdir in $(ALL_SUBDIRS); do \ + $(MAKE) -C $$subdir -f $(MAKEFILESDIR)/subdir.mk clean; \ + done; + @for subdir in $(ALL_ARCHSUBDIRS); do \ + cd $$subdir; $(MAKE) clean; cd ..; \ + done; + @$(RM) $(TARGET) err diff --git a/.pc/0011-zlibrary-unix-curl-avoid-duplicate-case-in-a-switch.patch/zlibrary/core/src/unix/curl/ZLCurlNetworkManager.cpp b/.pc/0011-zlibrary-unix-curl-avoid-duplicate-case-in-a-switch.patch/zlibrary/core/src/unix/curl/ZLCurlNetworkManager.cpp new file mode 100644 index 0000000..542ec80 --- /dev/null +++ b/.pc/0011-zlibrary-unix-curl-avoid-duplicate-case-in-a-switch.patch/zlibrary/core/src/unix/curl/ZLCurlNetworkManager.cpp @@ -0,0 +1,320 @@ +/* + * Copyright (C) 2008-2012 Geometer Plus <[email protected]> + * + * 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 <map> +#include <set> + +#include <curl/curl.h> + +#include <ZLStringUtil.h> +#include <ZLNetworkUtil.h> +#include <ZLResource.h> +#include <ZLOutputStream.h> +#include <ZLXMLReader.h> +#include <ZLNetworkRequest.h> + +#include "ZLCurlNetworkManager.h" + + + +class PostData : public ZLUserData { + +public: + PostData(); + ~PostData(); + + bool addItem(const std::string &name, const std::string &content); + + const curl_httppost *postItem() const; + +private: + curl_httppost *myPostItem; + curl_httppost *myLastItem; + +private: // disable copying + PostData(const PostData &); + const PostData &operator = (const PostData &); +}; + +PostData::PostData() : myPostItem(0), myLastItem(0) { +} + +PostData::~PostData() { + if (myPostItem != 0) { + curl_formfree(myPostItem); + } +} + +bool PostData::addItem(const std::string &name, const std::string &content) { + // TODO: url-encode content??? + return curl_formadd(&myPostItem, &myLastItem, + CURLFORM_COPYNAME, name.c_str(), + CURLFORM_COPYCONTENTS, content.c_str(), + CURLFORM_END) == 0; +} + +inline const curl_httppost *PostData::postItem() const { + return myPostItem; +} + + + +static std::size_t handleHeader(void *ptr, std::size_t size, std::size_t nmemb, ZLNetworkRequest *request) { + const std::size_t dataSize = size * nmemb; + return (request->handleHeader(ptr, dataSize)) ? dataSize : 0; +} + +static std::size_t handleContent(void *ptr, std::size_t size, std::size_t nmemb, ZLNetworkRequest *request) { + const std::size_t dataSize = size * nmemb; + return (request->handleContent(ptr, dataSize)) ? dataSize : 0; +} + + + +void ZLCurlNetworkManager::createInstance() { + ourInstance = new ZLCurlNetworkManager(); +} + + +void ZLCurlNetworkManager::setStandardOptions(CURL *handle, const std::string &proxy) const { + const std::string &agent = userAgent(); + if (!agent.empty()) { + curl_easy_setopt(handle, CURLOPT_USERAGENT, agent.c_str()); + } + if (useProxy()) { + curl_easy_setopt(handle, CURLOPT_PROXY, proxy.c_str()); + } + curl_easy_setopt(handle, CURLOPT_LOW_SPEED_LIMIT, 1L); + curl_easy_setopt(handle, CURLOPT_LOW_SPEED_TIME, TimeoutOption().value()); + curl_easy_setopt(handle, CURLOPT_CONNECTTIMEOUT, ConnectTimeoutOption().value()); + curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 1L); + curl_easy_setopt(handle, CURLOPT_SSL_VERIFYHOST, 2L); + + const std::string cookies = CookiesPath(); + curl_easy_setopt(handle, CURLOPT_COOKIEFILE, cookies.c_str()); + curl_easy_setopt(handle, CURLOPT_COOKIEJAR, cookies.c_str()); +} + + +std::string ZLCurlNetworkManager::doBeforeRequest(ZLNetworkRequest &request) const { + const ZLResource &errorResource = ZLResource::resource("dialog")["networkError"]; + + if (!request.doBefore()) { + const std::string &err = request.errorMessage(); + if (!err.empty()) { + return err; + } + return ZLStringUtil::printf(errorResource["somethingWrongMessage"].value(), ZLNetworkUtil::hostFromUrl(request.url())); + } + + if (request.isInstanceOf(ZLNetworkPostRequest::TYPE_ID)) { + return doBeforePostRequest((ZLNetworkPostRequest &) request); + } + return ""; +} + +std::string ZLCurlNetworkManager::doBeforePostRequest(ZLNetworkPostRequest &request) const { + shared_ptr<ZLUserData> postDataPtr = new PostData; + PostData &postData = (PostData&)*postDataPtr; + + const std::vector<std::pair<std::string, std::string> > &data = request.postParameters(); + for (std::size_t i = 0; i < data.size(); ++i) { + if (!postData.addItem(data[i].first, data[i].second)) { + return "Invalid form data for " + ZLNetworkUtil::hostFromUrl(request.url()); // TODO: localize + } + } + + request.addUserData("postData", postDataPtr); + return ""; +} + + +void ZLCurlNetworkManager::setRequestOptions(CURL *handle, const ZLNetworkRequest &request) const { + curl_easy_setopt(handle, CURLOPT_URL, request.url().c_str()); + if (!request.sslCertificate().Path.empty()) { + curl_easy_setopt(handle, CURLOPT_CAINFO, request.sslCertificate().Path.c_str()); + } else if (!request.sslCertificate().DoVerify) { + curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 0L); + } + + curl_easy_setopt(handle, CURLOPT_HEADERFUNCTION, handleHeader); + curl_easy_setopt(handle, CURLOPT_WRITEHEADER, &request); + curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, handleContent); + curl_easy_setopt(handle, CURLOPT_WRITEDATA, &request); + + switch (request.authenticationMethod()) { + case ZLNetworkRequest::NO_AUTH: + break; + + case ZLNetworkRequest::BASIC: +#if LIBCURL_VERSION_NUM >= 0x071301 + curl_easy_setopt(handle, CURLOPT_USERNAME, request.userName().c_str()); + curl_easy_setopt(handle, CURLOPT_PASSWORD, request.password().c_str()); +#else + curl_easy_setopt( + handle, CURLOPT_USERPWD, + (request.userName() + ':' + request.password()).c_str() + ); +#endif + curl_easy_setopt(handle, CURLOPT_HTTPAUTH, (long) CURLAUTH_BASIC); + break; + } + + curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, request.isRedirectionSupported()); + + if (request.isInstanceOf(ZLNetworkPostRequest::TYPE_ID)) { + shared_ptr<ZLUserData> postDataPtr = request.getUserData("postData"); + PostData &postData = (PostData&)*postDataPtr; + + if (postData.postItem() != 0) { + curl_easy_setopt(handle, CURLOPT_HTTPPOST, postData.postItem()); + } + } +} + + +void ZLCurlNetworkManager::clearRequestOptions(ZLNetworkRequest &request) const { + if (request.isInstanceOf(ZLNetworkPostRequest::TYPE_ID)) { + request.removeUserData("postData"); + } +} + + + +std::string ZLCurlNetworkManager::perform(const ZLExecutionData::Vector &dataList) const { + const ZLResource &errorResource = ZLResource::resource("dialog")["networkError"]; + + if (dataList.empty()) { + return errorResource["emptyLibrariesList"].value(); + } + + std::set<std::string> errors; + + const std::string proxy = proxyHost() + ':' + proxyPort(); + CURLM *handle = curl_multi_init(); + + std::map<CURL*,shared_ptr<ZLExecutionData> > handleToRequest; + + for (ZLExecutionData::Vector::const_iterator it = dataList.begin(); it != dataList.end(); ++it) { + if (it->isNull() || !(*it)->isInstanceOf(ZLNetworkRequest::TYPE_ID)) { + continue; + } + ZLNetworkRequest &request = (ZLNetworkRequest&)**it; + const std::string err = doBeforeRequest(request); + if (!err.empty()) { + errors.insert(err); + continue; + } + CURL *easyHandle = curl_easy_init(); + if (easyHandle != 0) { + handleToRequest[easyHandle] = *it; + setStandardOptions(easyHandle, proxy); + setRequestOptions(easyHandle, request); + curl_multi_add_handle(handle, easyHandle); + } + } + + int counter; + CURLMcode res; + do { + res = curl_multi_perform(handle, &counter); + } while ((res == CURLM_CALL_MULTI_PERFORM) || (counter > 0)); + + CURLMsg *message; + do { + int queueSize; + message = curl_multi_info_read(handle, &queueSize); + if ((message != 0) && (message->msg == CURLMSG_DONE)) { + ZLNetworkRequest &request = (ZLNetworkRequest&)*handleToRequest[message->easy_handle]; + const std::string &url = request.url(); + + CURLcode result = message->data.result; + bool doAfterResult = request.doAfter(result == CURLE_OK); + if (result == CURLE_OK && !doAfterResult) { + result = CURLE_WRITE_ERROR; + } + + switch (result) { + case CURLE_OK: + break; + case CURLE_WRITE_ERROR: + if (!request.errorMessage().empty()) { + errors.insert(request.errorMessage()); + } else { + errors.insert(ZLStringUtil::printf(errorResource["somethingWrongMessage"].value(), ZLNetworkUtil::hostFromUrl(url))); + } + break; + default: + errors.insert(ZLStringUtil::printf(errorResource["somethingWrongMessage"].value(), ZLNetworkUtil::hostFromUrl(url))); + break; + case CURLE_COULDNT_RESOLVE_PROXY: + errors.insert(ZLStringUtil::printf(errorResource["couldntResolveProxyMessage"].value(), proxyHost())); + break; + case CURLE_COULDNT_RESOLVE_HOST: + errors.insert(ZLStringUtil::printf(errorResource["couldntResolveHostMessage"].value(), ZLNetworkUtil::hostFromUrl(url))); + break; + case CURLE_COULDNT_CONNECT: + errors.insert(ZLStringUtil::printf(errorResource["couldntConnectMessage"].value(), ZLNetworkUtil::hostFromUrl(url))); + break; + case CURLE_OPERATION_TIMEDOUT: + errors.insert(errorResource["operationTimedOutMessage"].value()); + break; + case CURLE_SSL_CONNECT_ERROR: + errors.insert(ZLStringUtil::printf(errorResource["sslConnectErrorMessage"].value(), curl_easy_strerror(CURLE_SSL_CONNECT_ERROR))); + break; +#if LIBCURL_VERSION_NUM > 0x071100 + case CURLE_PEER_FAILED_VERIFICATION: +#else + case CURLE_SSL_PEER_CERTIFICATE: +#endif + errors.insert(ZLStringUtil::printf(errorResource["peerFailedVerificationMessage"].value(), ZLNetworkUtil::hostFromUrl(url))); + break; + case CURLE_SSL_CACERT: + errors.insert(ZLStringUtil::printf(errorResource["sslCertificateAuthorityMessage"].value(), ZLNetworkUtil::hostFromUrl(url))); + break; + case CURLE_SSL_CACERT_BADFILE: + errors.insert(ZLStringUtil::printf(errorResource["sslBadCertificateFileMessage"].value(), request.sslCertificate().Path)); + break; + case CURLE_SSL_SHUTDOWN_FAILED: + errors.insert(ZLStringUtil::printf(errorResource["sslShutdownFailedMessage"].value(), ZLNetworkUtil::hostFromUrl(url))); + break; + } + } + } while ((message != 0) && (errors.size() < 3)); + + for (std::map<CURL*,shared_ptr<ZLExecutionData> >::const_iterator jt = handleToRequest.begin(); jt != handleToRequest.end(); ++jt) { + CURL *easyHandle = jt->first; + curl_multi_remove_handle(handle, easyHandle); + curl_easy_cleanup(easyHandle); + + ZLNetworkRequest &request = (ZLNetworkRequest&)*jt->second; + clearRequestOptions(request); + } + handleToRequest.clear(); + curl_multi_cleanup(handle); + + std::string result; + for (std::set<std::string>::const_iterator et = errors.begin(); et != errors.end(); ++et) { + if (!result.empty()) { + result += '\n'; + } + result += *et; + } + return result; +} diff --git a/.pc/0013-fbreader-Makefile-make-linking-order-reproducible.patch/fbreader/Makefile b/.pc/0013-fbreader-Makefile-make-linking-order-reproducible.patch/fbreader/Makefile new file mode 100644 index 0000000..be5ee54 --- /dev/null +++ b/.pc/0013-fbreader-Makefile-make-linking-order-reproducible.patch/fbreader/Makefile @@ -0,0 +1,70 @@ +ROOTDIR = $(CURDIR)/.. + +MAKEFILESDIR = $(ROOTDIR)/makefiles + +include $(MAKEFILESDIR)/config.mk + +TARGET = FBReader +target = fbreader + +ALL_SUBDIRS = src src/database src/database/sqldb src/database/sqldb/implsqlite src/database/booksdb src/database/booksdb/runnables src/database/networkdb src/database/networkdb/runnables src/migration src/options src/library src/bookmodel src/formats src/formats/fb2 src/formats/docbook src/formats/css src/formats/html src/formats/pdb src/formats/txt src/formats/tcr src/formats/chm src/formats/xhtml src/formats/oeb src/formats/rtf src/formats/openreader src/formats/pdf src/formats/doc src/formats/dummy src/formats/util src/external src/fbreader src/encodingOption src/network src/network/authentication src/network/atom src/network/opds src/network/litres src/network/tree src/network/authentication/litres src/blockTree src/libraryActions src/libraryTree src/networkActions src/tree src/optionsDialog src/optionsDialog/bookInfo src/optionsDialog/library src/optionsDialog/network src/optionsDialog/system src/optionsDialog/reading src/optionsDialog/lookAndFeel +ALL_ARCHSUBDIRS = desktop pdaxrom opie zaurus maemo openzaurus pma400 win32 + +SUBDIRS = src/database src/database/sqldb src/database/sqldb/implsqlite src/database/booksdb src/database/booksdb/runnables src/database/networkdb src/database/networkdb/runnables src/migration src/options src/library src/bookmodel \ + src/formats src/formats/fb2 src/formats/css src/formats/html src/formats/pdb src/formats/txt src/formats/tcr src/formats/chm src/formats/xhtml src/formats/oeb src/formats/rtf src/formats/openreader src/formats/doc src/formats/util \ + src/external src/fbreader src/encodingOption src/network src/network/authentication src/network/atom src/network/opds src/network/litres src/network/tree src/network/authentication/litres \ + src/blockTree src/libraryActions src/libraryTree src/networkActions src/tree src/optionsDialog src/optionsDialog/bookInfo src/optionsDialog/library src/optionsDialog/network src/optionsDialog/system src/optionsDialog/reading src/optionsDialog/lookAndFeel + +all: .resources + @for subdir in $(SUBDIRS); do \ + if ! $(MAKE) -C $$subdir -f $(MAKEFILESDIR)/subdir.mk; then \ + exit 1; \ + fi; \ + done; + @echo -n 'Linking $(TARGET) ...' + @$(LD) $(LDFLAGS) -o $(TARGET) `find src -name *.o` $(TEXT_LIBS) $(CORE_LIBS) $(ZLUI_LIB) -lsqlite3 + @echo ' OK' + +FBSHAREDIR = $(DESTDIR)$(SHAREDIR)/FBReader +VARIANT = $(TARGET_ARCH) +ifneq "$(RESOLUTION)" "" + VARIANT = $(TARGET_ARCH)_$(RESOLUTION) +endif + +APPIMAGEDIR_REAL = $(subst %application_name%,$(target),$(subst %APPLICATION_NAME%,$(TARGET),$(APPIMAGEDIR))) + +do_install: + @install -d $(DESTDIR)$(BINDIR) + @install $(TARGET) $(DESTDIR)$(BINDIR)/FBReader + @install -d $(FBSHAREDIR) + @install -d $(FBSHAREDIR)/help + @./scripts/install_help.sh $(VARIANT) $(FBSHAREDIR)/help + @install -d $(FBSHAREDIR)/formats/html + @install -m 0644 data/formats/html/html.ent $(FBSHAREDIR)/formats/html + @install -d $(FBSHAREDIR)/formats/fb2 + @sed "s/VERSION/$(VERSION)/" data/formats/fb2/FBReaderVersion.ent > $(FBSHAREDIR)/formats/fb2/FBReaderVersion.ent + @install -m 0644 data/formats/fb2/fb2genres.xml $(FBSHAREDIR)/formats/fb2 + @install -d $(FBSHAREDIR)/default + @./scripts/install_toolbar_and_menu.sh $(VARIANT) $(UI_TYPE) $(FBSHAREDIR)/default + @./scripts/install_config.sh $(VARIANT) $(UI_TYPE) $(FBSHAREDIR)/default + @install -m 0644 data/default/external.$(TARGET_ARCH).xml $(FBSHAREDIR)/default/external.xml + @if [ -f data/default/messages.$(TARGET_ARCH).xml ]; then \ + install -m 0644 data/default/messages.$(TARGET_ARCH).xml $(FBSHAREDIR)/default/messages.xml; \ + fi + @install -d $(FBSHAREDIR)/resources + @install -m 0644 $(wildcard data/resources/*.xml) $(FBSHAREDIR)/resources + @install -d $(DESTDIR)$(APPIMAGEDIR_REAL) + @install -m 0644 $(wildcard data/icons/toolbar/$(VARIANT)/*.*) $(DESTDIR)$(APPIMAGEDIR_REAL) + @install -m 0644 $(wildcard data/icons/filetree/$(VARIANT)/*.*) $(DESTDIR)$(APPIMAGEDIR_REAL) + @install -m 0644 $(wildcard data/icons/booktree/new/*.*) $(DESTDIR)$(APPIMAGEDIR_REAL) + @install -m 0644 $(wildcard data/icons/*.*) $(DESTDIR)$(APPIMAGEDIR_REAL) + @$(MAKE) -C $(TARGET_ARCH) RESOLUTION=$(RESOLUTION) install + +clean: + @for subdir in $(ALL_SUBDIRS); do \ + $(MAKE) -C $$subdir -f $(MAKEFILESDIR)/subdir.mk clean; \ + done; + @for subdir in $(ALL_ARCHSUBDIRS); do \ + cd $$subdir; $(MAKE) clean; cd ..; \ + done; + @$(RM) $(TARGET) err diff --git a/.pc/1014-desktop-mime-type.patch/fbreader/desktop/desktop b/.pc/1014-desktop-mime-type.patch/fbreader/desktop/desktop new file mode 100644 index 0000000..bb35fe3 --- /dev/null +++ b/.pc/1014-desktop-mime-type.patch/fbreader/desktop/desktop @@ -0,0 +1,23 @@ +[Desktop Entry] +Name=FBReader +GenericName=E-book reader +GenericName[ar]=قارئ الكتب الإلكترونية +GenericName[es]=Lector de Libros +GenericName[hu]=E-könyv olvasó +GenericName[pl]=Czytnik e-książek +GenericName[ru]=Чтение электронных книг +GenericName[zh_CN]=电子书阅读 +Comment=FBReader E-book reader +Comment[ar]=قارئ الكتب الإلكترونية +Comment[es]=FBReader Lector de Libros Elecrónicos +Comment[hu]=FBReader, E-könyv olvasó program +Comment[pl]=FBReader, czytnik książek elektronicznych +Comment[ru]=FBReader, программа для чтения электронных книг +Comment[zh_CN]=FBReader 电子书阅读器 +TryExec=FBReader +Exec=FBReader %F +StartupNotify=true +Terminal=false +Type=Application +Icon=FBReader +Categories=Office;Viewer;Literature; diff --git a/.pc/applied-patches b/.pc/applied-patches new file mode 100644 index 0000000..79b3b93 --- /dev/null +++ b/.pc/applied-patches @@ -0,0 +1,9 @@ +0001-ZLQtFSManager.cpp.patch +0002-Qt5.patch +0003-gcc-6.patch +0004-prevent-so-install.patch +0008-951-fix-calling-compiler.patch +0009-fbreader-Makefile-do-not-try-to-install-empty-format.patch +0011-zlibrary-unix-curl-avoid-duplicate-case-in-a-switch.patch +0013-fbreader-Makefile-make-linking-order-reproducible.patch +1014-desktop-mime-type.patch |