first new teacher guide implementation

preferencesAboutTextFull
Claudio Valerio 13 years ago
parent e82d5d880d
commit 93f69f80aa
  1. 40
      plugins/cffadaptor/src/UBCFFAdaptor.cpp
  2. 7
      src/board/UBBoardPaletteManager.cpp
  3. 4
      src/board/UBBoardPaletteManager.h
  4. 146
      src/board/UBBoardView.cpp
  5. 1
      src/board/UBBoardView.h
  6. 15
      src/customWidgets/UBActionableWidget.cpp
  7. 15
      src/customWidgets/UBActionableWidget.h
  8. 39
      src/customWidgets/UBDraggableLabel.cpp
  9. 23
      src/customWidgets/UBDraggableLabel.h
  10. 42
      src/customWidgets/UBDraggableMedia.cpp
  11. 19
      src/customWidgets/UBDraggableMedia.h
  12. 5
      src/customWidgets/customWidgets.pri
  13. 38
      src/desktop/UBDesktopAnnotationController.cpp
  14. 10
      src/domain/UBGraphicsItemDelegate.cpp
  15. 1
      src/gui/UBActionPalette.cpp
  16. 2
      src/gui/UBActionPalette.h
  17. 45
      src/gui/UBDockTeacherGuideWidget.cpp
  18. 39
      src/gui/UBDockTeacherGuideWidget.h
  19. 166
      src/gui/UBMediaPlayer.cpp
  20. 31
      src/gui/UBMediaPlayer.h
  21. 5
      src/gui/UBTeacherGuideDelegate.cpp
  22. 10
      src/gui/UBTeacherGuideDelegate.h
  23. 404
      src/gui/UBTeacherGuideWidget.cpp
  24. 114
      src/gui/UBTeacherGuideWidget.h
  25. 361
      src/gui/UBTeacherGuideWidgetsTools.cpp
  26. 144
      src/gui/UBTeacherGuideWidgetsTools.h
  27. 24
      src/gui/gui.pri

@ -639,28 +639,29 @@ QDomElement UBCFFAdaptor::UBToCFFConverter::parseSvgPageSection(const QDomElemen
void UBCFFAdaptor::UBToCFFConverter::writeQDomElementToXML(const QDomNode &node)
{
if (!node.isNull())
if (node.isText())
{
mIWBContentWriter->writeCharacters(node.nodeValue());
}
else
{
mIWBContentWriter->writeStartElement(node.namespaceURI(), node.toElement().tagName());
for (int i = 0; i < node.toElement().attributes().count(); i++)
if (!node.isNull()){
if (node.isText())
{
QDomAttr attr = node.toElement().attributes().item(i).toAttr();
mIWBContentWriter->writeAttribute(attr.name(), attr.value());
mIWBContentWriter->writeCharacters(node.nodeValue());
}
QDomNode child = node.firstChild();
while(!child.isNull())
else
{
writeQDomElementToXML(child);
child = child.nextSibling();
}
mIWBContentWriter->writeStartElement(node.namespaceURI(), node.toElement().tagName());
mIWBContentWriter->writeEndElement();
for (int i = 0; i < node.toElement().attributes().count(); i++)
{
QDomAttr attr = node.toElement().attributes().item(i).toAttr();
mIWBContentWriter->writeAttribute(attr.name(), attr.value());
}
QDomNode child = node.firstChild();
while(!child.isNull())
{
writeQDomElementToXML(child);
child = child.nextSibling();
}
mIWBContentWriter->writeEndElement();
}
}
}
@ -1322,7 +1323,7 @@ QDomNode UBCFFAdaptor::UBToCFFConverter::findNodeByTagName(const QDomNode &node,
if (!iterNode.firstChildElement().isNull())
{
QDomNode foundNode = findNodeByTagName(iterNode.firstChildElement(), tagName);
if (!foundNode.isNull())
if (!foundNode.isNull()){
if (foundNode.isElement())
{
if (tagName == foundNode.toElement().tagName())
@ -1330,6 +1331,7 @@ QDomNode UBCFFAdaptor::UBToCFFConverter::findNodeByTagName(const QDomNode &node,
}
else
break;
}
}
}

@ -31,6 +31,7 @@
#include "gui/UBZoomPalette.h"
#include "gui/UBActionPalette.h"
#include "gui/UBFavoriteToolPalette.h"
#include "gui/UBDockTeacherGuideWidget.h"
#include "web/UBWebPage.h"
@ -84,6 +85,7 @@ UBBoardPaletteManager::UBBoardPaletteManager(QWidget* container, UBBoardControll
, mpCachePropWidget(NULL)
, mpDownloadWidget(NULL)
, mpDesktopLibWidget(NULL)
, mpTeacherGuideWidget(NULL)
, mDownloadInProgress(false)
{
setupPalettes();
@ -135,6 +137,7 @@ void UBBoardPaletteManager::setupDockPaletteWidgets()
mpCachePropWidget = new UBCachePropertiesWidget();
mpDownloadWidget = new UBDockDownloadWidget();
mpTeacherGuideWidget = new UBDockTeacherGuideWidget();
// Add the dock palettes
mLeftPalette = new UBLeftPalette(mContainer);
@ -143,6 +146,9 @@ void UBBoardPaletteManager::setupDockPaletteWidgets()
mLeftPalette->registerWidget(mpPageNavigWidget);
mLeftPalette->addTab(mpPageNavigWidget);
mLeftPalette->registerWidget(mpTeacherGuideWidget);
mLeftPalette->addTab(mpTeacherGuideWidget);
mLeftPalette->connectSignals();
mRightPalette = new UBRightPalette(mContainer);
@ -232,6 +238,7 @@ void UBBoardPaletteManager::setupPalettes()
#endif
}
setupDockPaletteWidgets();

@ -40,6 +40,7 @@ class UBServerXMLHttpRequest;
class UBKeyboardPalette;
class UBMainWindow;
class UBApplicationController;
class UBDockTeacherGuideWidget;
class UBBoardPaletteManager : public QObject
{
@ -52,6 +53,7 @@ class UBBoardPaletteManager : public QObject
void setupLayout();
UBLeftPalette* leftPalette(){return mLeftPalette;}
UBRightPalette* rightPalette(){return mRightPalette;}
UBStylusPalette* stylusPalette(){return mStylusPalette;}
void showVirtualKeyboard(bool show = true);
void initPalettesPosAtStartup();
void connectToDocumentController();
@ -134,6 +136,8 @@ class UBBoardPaletteManager : public QObject
// lib widget!
UBLibWidget* mpDesktopLibWidget;
UBDockTeacherGuideWidget* mpTeacherGuideWidget;
bool mDownloadInProgress;
private slots:

@ -49,9 +49,6 @@
#include "document/UBDocumentProxy.h"
#include "customWidgets/UBDraggableLabel.h"
#include "customWidgets/UBDraggableMedia.h"
#include "tools/UBGraphicsCompass.h"
#include "tools/UBGraphicsCache.h"
@ -378,59 +375,61 @@ void UBBoardView::tabletEvent (QTabletEvent * event)
}
void
UBBoardView::mousePressEvent (QMouseEvent *event)
void UBBoardView::mousePressEvent (QMouseEvent *event)
{
if (isAbsurdPoint (event->pos ()))
if (isAbsurdPoint (event->pos ()))
{
event->accept ();
return;
event->accept ();
return;
}
mMouseDownPos = event->pos ();
mMouseDownPos = event->pos ();
if (event->button () == Qt::LeftButton && isInteractive ())
emit clickOnBoard();
if (event->button () == Qt::LeftButton && isInteractive ())
{
UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController ()->stylusTool ();
if (!mTabletStylusIsPressed)
mMouseButtonIsPressed = true;
UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController ()->stylusTool ();
if (!mTabletStylusIsPressed)
mMouseButtonIsPressed = true;
if (currentTool == UBStylusTool::ZoomIn)
if (currentTool == UBStylusTool::ZoomIn)
{
mController->zoomIn (mapToScene (event->pos ()));
event->accept ();
mController->zoomIn (mapToScene (event->pos ()));
event->accept ();
}
else if (currentTool == UBStylusTool::ZoomOut)
else if (currentTool == UBStylusTool::ZoomOut)
{
mController->zoomOut (mapToScene (event->pos ()));
event->accept ();
mController->zoomOut (mapToScene (event->pos ()));
event->accept ();
}
else if (currentTool == UBStylusTool::Hand)
else if (currentTool == UBStylusTool::Hand)
{
viewport ()->setCursor (QCursor (Qt::ClosedHandCursor));
mPreviousPoint = event->posF ();
event->accept ();
viewport ()->setCursor (QCursor (Qt::ClosedHandCursor));
mPreviousPoint = event->posF ();
event->accept ();
}
else if (currentTool == UBStylusTool::Selector)
else if (currentTool == UBStylusTool::Selector)
{
QSet<QGraphicsItem*> existingTools = scene()->tools();
movingItem = scene()->itemAt(this->mapToScene(event->posF().toPoint()));
if (!movingItem
|| movingItem->isSelected()
|| movingItem->type() == UBGraphicsDelegateFrame::Type
|| movingItem->type() == DelegateButton::Type
|| movingItem->type() == UBGraphicsCompass::Type
|| movingItem->type() == UBGraphicsPDFItem::Type
|| movingItem->type() == UBGraphicsPolygonItem::Type
|| movingItem->type() == UBGraphicsCache::Type)
{
movingItem = NULL;
QGraphicsView::mousePressEvent (event);
|| movingItem->isSelected()
|| movingItem->type() == UBGraphicsDelegateFrame::Type
|| movingItem->type() == DelegateButton::Type
|| movingItem->type() == UBGraphicsCompass::Type
|| movingItem->type() == UBGraphicsPDFItem::Type
|| movingItem->type() == UBGraphicsPolygonItem::Type
|| movingItem->type() == UBGraphicsCache::Type)
{
movingItem = NULL;
QGraphicsView::mousePressEvent (event);
}
}
else
{
mLastPressedMousePos = mapToScene(event->pos());
@ -443,64 +442,64 @@ UBBoardView::mousePressEvent (QMouseEvent *event)
event->accept();
}
else if (currentTool == UBStylusTool::Text)
else if (currentTool == UBStylusTool::Text)
{
int frameWidth = UBSettings::settings ()->objectFrameWidth;
QRectF fuzzyRect (0, 0, frameWidth * 4, frameWidth * 4);
fuzzyRect.moveCenter (mapToScene (mMouseDownPos));
int frameWidth = UBSettings::settings ()->objectFrameWidth;
QRectF fuzzyRect (0, 0, frameWidth * 4, frameWidth * 4);
fuzzyRect.moveCenter (mapToScene (mMouseDownPos));
UBGraphicsTextItem* foundTextItem = 0;
QListIterator<QGraphicsItem *> it (scene ()->items (fuzzyRect));
UBGraphicsTextItem* foundTextItem = 0;
QListIterator<QGraphicsItem *> it (scene ()->items (fuzzyRect));
while (it.hasNext () && !foundTextItem)
while (it.hasNext () && !foundTextItem)
{
foundTextItem = qgraphicsitem_cast<UBGraphicsTextItem*>(it.next ());
foundTextItem = qgraphicsitem_cast<UBGraphicsTextItem*>(it.next ());
}
if (foundTextItem)
if (foundTextItem)
{
mIsCreatingTextZone = false;
QGraphicsView::mousePressEvent (event);
mIsCreatingTextZone = false;
QGraphicsView::mousePressEvent (event);
}
else
else
{
scene ()->deselectAllItems ();
scene ()->deselectAllItems ();
if (!mRubberBand)
mRubberBand = new UBRubberBand (QRubberBand::Rectangle, this);
if (!mRubberBand)
mRubberBand = new UBRubberBand (QRubberBand::Rectangle, this);
mRubberBand->setGeometry (QRect (mMouseDownPos, QSize ()));
mRubberBand->show ();
mIsCreatingTextZone = true;
mRubberBand->setGeometry (QRect (mMouseDownPos, QSize ()));
mRubberBand->show ();
mIsCreatingTextZone = true;
event->accept ();
event->accept ();
}
}
else if (currentTool == UBStylusTool::Capture)
else if (currentTool == UBStylusTool::Capture)
{
scene ()->deselectAllItems ();
scene ()->deselectAllItems ();
if (!mRubberBand)
mRubberBand = new UBRubberBand (QRubberBand::Rectangle, this);
if (!mRubberBand)
mRubberBand = new UBRubberBand (QRubberBand::Rectangle, this);
mRubberBand->setGeometry (QRect (mMouseDownPos, QSize ()));
mRubberBand->show ();
mIsCreatingSceneGrabZone = true;
mRubberBand->setGeometry (QRect (mMouseDownPos, QSize ()));
mRubberBand->show ();
mIsCreatingSceneGrabZone = true;
event->accept ();
event->accept ();
}
else
else
{
if(UBDrawingController::drawingController()->mActiveRuler==NULL)
{
if(UBDrawingController::drawingController()->mActiveRuler==NULL)
{
viewport()->setCursor (QCursor (Qt::BlankCursor));
}
viewport()->setCursor (QCursor (Qt::BlankCursor));
}
if (scene () && !mTabletStylusIsPressed)
{
scene ()->inputDevicePress (mapToScene (UBGeometryUtils::pointConstrainedInRect (event->pos (), rect ())));
}
event->accept ();
if (scene () && !mTabletStylusIsPressed)
{
scene ()->inputDevicePress (mapToScene (UBGeometryUtils::pointConstrainedInRect (event->pos (), rect ())));
}
event->accept ();
}
}
}
@ -809,8 +808,7 @@ void UBBoardView::dropEvent (QDropEvent *event)
event->acceptProposedAction();
} else if (!event->source() || dynamic_cast<UBThumbnailWidget *>(event->source())
|| dynamic_cast<QWebView*>(event->source()) || dynamic_cast<UBDraggableMediaPlayer *>(event->source())
|| dynamic_cast<UBDraggableLabel *>(event->source()) || dynamic_cast<UBDraggableMedia *>(event->source())) {
|| dynamic_cast<QWebView*>(event->source())) {
mController->processMimeData (event->mimeData (), mapToScene (event->pos ()));
event->acceptProposedAction();

@ -46,6 +46,7 @@ class UBBoardView : public QGraphicsView
void resized(QResizeEvent* event);
void hidden();
void shown();
void clickOnBoard();
protected:

@ -1,3 +1,18 @@
/*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
#include <QPainter>
#include <QDebug>

@ -1,3 +1,18 @@
/*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef UBACTIONABLEWIDGET_H
#define UBACTIONABLEWIDGET_H

@ -1,39 +0,0 @@
#include <QMimeData>
#include <QDrag>
#include <QUrl>
#include "UBDraggableLabel.h"
UBDraggableLabel::UBDraggableLabel(QWidget *parent) :
QLabel(parent)
{
}
UBDraggableLabel::~UBDraggableLabel()
{
//NOOP
}
void UBDraggableLabel::loadImage(QString imagePath)
{
mSourcePath = imagePath;
QPixmap pix = QPixmap(mSourcePath);
setPixmap(pix);
setScaledContents(true);
}
void UBDraggableLabel::mousePressEvent(QMouseEvent *event)
{
Q_UNUSED(event);
QMimeData *mimeData = new QMimeData;
QList<QUrl> urls;
urls << QUrl::fromLocalFile(mSourcePath);
mimeData->setUrls(urls);
mimeData->setText(mSourcePath);
QDrag *drag = new QDrag(this);
drag->setMimeData(mimeData);
drag->start();
}

@ -1,23 +0,0 @@
#ifndef UBDRAGGABLELABEL_H
#define UBDRAGGABLELABEL_H
#include <QLabel>
class UBDraggableLabel : public QLabel
{
Q_OBJECT
public:
UBDraggableLabel(QWidget *parent = 0);
~UBDraggableLabel();
void loadImage(QString imagePath);
signals:
public slots:
protected:
QString mSourcePath;
void mousePressEvent(QMouseEvent *event);
};
#endif // UBDRAGGABLELABEL_H

@ -1,42 +0,0 @@
#include <QApplication>
#include <QUrl>
#include "UBDraggableMedia.h"
UBDraggableMedia::UBDraggableMedia(eMediaType type, QWidget *parent, const char *name):UBMediaWidget(type, parent, name)
{
removeAllActions();
}
UBDraggableMedia::~UBDraggableMedia()
{
}
void UBDraggableMedia::mousePressEvent(QMouseEvent* ev)
{
if(Qt::LeftButton == ev->button()){
mDragStartPos = ev->pos();
}
}
void UBDraggableMedia::mouseMoveEvent(QMouseEvent* ev)
{
if(!(ev->buttons() & Qt::LeftButton)){
return;
}
if((ev->pos() - mDragStartPos).manhattanLength() < QApplication::startDragDistance()){
return;
}
QDrag *drag = new QDrag(this);
QMimeData *mimeData = new QMimeData;
QList<QUrl> urls;
urls << QUrl(mFilePath);
mimeData->setText(mFilePath);
mimeData->setUrls(urls);
drag->setMimeData(mimeData);
drag->exec(Qt::CopyAction | Qt::MoveAction);
}

@ -1,19 +0,0 @@
#ifndef UBDRAGGABLEMEDIA_H
#define UBDRAGGABLEMEDIA_H
#include "UBMediaWidget.h"
class UBDraggableMedia : public UBMediaWidget
{
public:
UBDraggableMedia(eMediaType type = eMediaType_Video, QWidget* parent=0, const char* name="UBDraggableMedia");
~UBDraggableMedia();
protected:
void mousePressEvent(QMouseEvent* ev);
void mouseMoveEvent(QMouseEvent* ev);
private:
QPoint mDragStartPos;
};
#endif // UBDRAGGABLEMEDIA_H

@ -1,13 +1,8 @@
HEADERS += src/customWidgets/UBWidgetList.h \
src/customWidgets/UBDraggableLabel.h \
src/customWidgets/UBMediaWidget.h \
src/globals/UBGlobals.h \
src/customWidgets/UBDraggableMedia.h \
src/customWidgets/UBActionableWidget.h
SOURCES += src/customWidgets/UBWidgetList.cpp \
src/customWidgets/UBDraggableLabel.cpp \
src/customWidgets/UBMediaWidget.cpp \
src/customWidgets/UBDraggableMedia.cpp \
src/customWidgets/UBActionableWidget.cpp

@ -761,21 +761,6 @@ void UBDesktopAnnotationController::togglePropertyPalette(UBActionPalette *palet
void UBDesktopAnnotationController::switchCursor(const int tool)
{
// enum Enum
// {
// Pen = 0,
// Eraser,
// Marker,
// Selector,
// Hand,
// ZoomIn,
// ZoomOut,
// Pointer,
// Line,
// Text,
// Capture
// };
mTransparentDrawingScene->setToolCursor(tool);
mTransparentDrawingView->setToolCursor(tool);
}
@ -825,17 +810,6 @@ void UBDesktopAnnotationController::onDesktopPaletteMaximized()
connect(pPointerButton, SIGNAL(pressed()), this, SLOT(pointerActionPressed()));
connect(pPointerButton, SIGNAL(released()), this, SLOT(pointerActionReleased()));
}
// enum Enum
// {
// Hand,
// ZoomIn,
// ZoomOut,
// Line,
// Text,
// Capture
// };
}
/**
@ -871,16 +845,6 @@ void UBDesktopAnnotationController::onDesktopPaletteMinimize()
void UBDesktopAnnotationController::TransparentWidgetResized()
{
/*
int rW = UBApplication::boardController->paletteManager()->rightPalette()->width();
int rH_ = UBApplication::boardController->paletteManager()->rightPalette()->height();
int rH = mTransparentDrawingView->height();
UBApplication::boardController->paletteManager()->rightPalette()->resize(rW+1, rH);
// UBApplication::boardController->paletteManager()->rightPalette()->resize(500, 500);
*/
onTransparentWidgetResized();
}
@ -899,8 +863,6 @@ void UBDesktopAnnotationController::onTransparentWidgetResized()
UBApplication::boardController->paletteManager()->leftPalette()->resize(lW+1, rH);
UBApplication::boardController->paletteManager()->leftPalette()->resize(lW, rH);
// mRightPalette->resize(mRightPalette->width(), mTransparentDrawingView->height());
}
void UBDesktopAnnotationController::updateMask(bool bTransparent)

@ -322,16 +322,8 @@ void UBGraphicsItemDelegate::duplicate()
}
void UBGraphicsItemDelegate::increaseZLevel(int delta)
{
Q_UNUSED(delta)
qDebug() << delegated()->scene()->items().count();
// UBGraphicsItem::assignZValue(delegated(), )
// int valueCandidate = delegated()->data(UBGraphicsItemData::ItemOwnZValue).toInt();
// if (delta < 0) {
// } else if (delta > 0) {
// }
}
void UBGraphicsItemDelegate::lock(bool locked)

@ -231,6 +231,7 @@ void UBActionPalette::mouseReleaseEvent(QMouseEvent * event)
void UBActionPalette::actionChanged()
{
emit itemOnActionPaletteChanged();
for(int i = 0; i < mActions.length() && i < mButtons.length(); i++)
{
mButtons.at(i)->setVisible(mActions.at(i)->isVisible());

@ -56,10 +56,12 @@ class UBActionPalette : public UBFloatingPalette
public slots:
void close();
signals:
void closed();
void buttonGroupClicked(int id);
void customMouseReleased();
void itemOnActionPaletteChanged();
protected:
virtual void paintEvent(QPaintEvent *event);

@ -0,0 +1,45 @@
/*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
#include "core/UBApplication.h"
#include "globals/UBGlobals.h"
#include "UBDockTeacherGuideWidget.h"
#include "UBTeacherGuideWidget.h"
UBDockTeacherGuideWidget::UBDockTeacherGuideWidget(QWidget* parent, const char* name):
UBDockPaletteWidget(parent,name)
, mpTeacherGuideWidget(NULL)
{
mName = "TeacherGuide";
setAttribute(Qt::WA_StyledBackground, true);
setStyleSheet(UBApplication::globalStyleSheet());
mIconToLeft = QPixmap(":images/teacher_open.png");
mIconToRight = QPixmap(":images/teacher_close.png");
mpLayout = new QVBoxLayout(this);
setLayout(mpLayout);
mpTeacherGuideWidget = new UBTeacherGuideWidget(this);
mpLayout->addWidget(mpTeacherGuideWidget);
}
UBDockTeacherGuideWidget::~UBDockTeacherGuideWidget()
{
DELETEPTR(mpTeacherGuideWidget);
DELETEPTR(mpLayout);
}

@ -0,0 +1,39 @@
/*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef UBDOCKTEACHERGUIDEWIDGET_H
#define UBDOCKTEACHERGUIDEWIDGET_H
class QVBoxLayout;
class UBTeacherGuideWidget;
#include "UBDockPaletteWidget.h"
class UBDockTeacherGuideWidget : public UBDockPaletteWidget
{
Q_OBJECT
public:
UBDockTeacherGuideWidget(QWidget* parent=0, const char* name="UBDockTeacherGuideWidget");
~UBDockTeacherGuideWidget();
bool visibleInMode(eUBDockPaletteWidgetMode mode){ return mode == eUBDockPaletteWidget_BOARD; }
private:
QVBoxLayout* mpLayout;
UBTeacherGuideWidget* mpTeacherGuideWidget;
};
#endif // UBDOCKTEACHERGUIDEWIDGET_H

@ -1,22 +1,29 @@
#include "UBMediaPlayer.h"
/*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
#include <QtGui>
#include "UBMediaPlayer.h"
#define SLIDER_RANGE 8
MediaVideoWidget::MediaVideoWidget(UBMediaPlayer *player, QWidget *parent) :
Phonon::VideoWidget(parent), m_player(player)/*, m_action(this)*/
{
// m_action.setCheckable(true);
// m_action.setChecked(false);
// m_action.setShortcut(QKeySequence( Qt::AltModifier + Qt::Key_Return));
// m_action.setShortcutContext(Qt::WindowShortcut);
// connect(&m_action, SIGNAL(toggled(bool)), SLOT(setFullScreen(bool)));
// addAction(&m_action);
// setAcceptDrops(true);
//NOOP
}
void MediaVideoWidget::timerEvent(QTimerEvent *e)
@ -41,23 +48,6 @@ UBMediaPlayer::UBMediaPlayer() :
QSize buttonSize(26, 20);
// QPushButton *openButton = new QPushButton(this);
//// openButton->setIcon(style()->standardIcon(QStyle::SP_DialogOpenButton));
//// QPalette bpal;
//// QColor arrowcolor = bpal.buttonText().color();
//// if (arrowcolor == Qt::black)
//// arrowcolor = QColor(80, 80, 80);
//// bpal.setBrush(QPalette::ButtonText, arrowcolor);
//// openButton->setPalette(bpal);
// rewindButton = new QPushButton(this);
// rewindButton->setIcon(style()->standardIcon(QStyle::SP_MediaSkipBackward));
// forwardButton = new QPushButton(this);
// forwardButton->setIcon(style()->standardIcon(QStyle::SP_MediaSkipForward));
// forwardButton->setEnabled(false);
playButton = new QPushButton(this);
playIcon = style()->standardIcon(QStyle::SP_MediaPlay);
pauseIcon = style()->standardIcon(QStyle::SP_MediaPause);
@ -69,53 +59,18 @@ UBMediaPlayer::UBMediaPlayer() :
QVBoxLayout *vLayout = new QVBoxLayout(this);
vLayout->setContentsMargins(1, 1, 1, 1);
// QHBoxLayout *layout = new QHBoxLayout();
// info = new QLabel(this);
// info->setMinimumHeight(70);
// info->setAcceptDrops(false);
// info->setMargin(2);
// info->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
// info->setLineWidth(2);
// info->setAutoFillBackground(true);
// QPalette palette;
// palette.setBrush(QPalette::WindowText, Qt::white);
#ifndef Q_WS_MAC
// rewindButton->setMinimumSize(buttonSize);
// forwardButton->setMinimumSize(buttonSize);
playButton->setMinimumSize(buttonSize);
#endif
// info->setStyleSheet("border-image:url(:/images/screen.png) ; border-width:3px");
// info->setPalette(palette);
// info->setText(tr("<center>No media</center>"));
// layout->addWidget(rewindButton);
// layout->addWidget(playButton);
// layout->addWidget(forwardButton);
// layout->addStretch();
// vLayout->addWidget(info);
initVideoWindow();
vLayout->addWidget(&m_videoWindow);
// m_videoWidget->setStyleSheet(QString("background:red;"));
QVBoxLayout *buttonPanelLayout = new QVBoxLayout();
#ifndef Q_WS_WIN
m_videoWindow.hide();
#endif
// buttonPanelLayout->addLayout(layout);
// timeLabel = new QLabel(this);
progressLabel = new QLabel(this);
QWidget *sliderPanel = new QWidget(this);
// sliderPanel->setStyleSheet(QString("background:green;"));
QHBoxLayout *sliderLayout = new QHBoxLayout();
// playButton->setStyleSheet(QString("background:yellow;"));
sliderLayout->addWidget(playButton);
sliderLayout->addWidget(slider);
// sliderLayout->addWidget(timeLabel);
sliderLayout->addWidget(progressLabel);
sliderLayout->setContentsMargins(0, 0, 0, 0);
sliderPanel->setLayout(sliderLayout);
@ -123,11 +78,7 @@ UBMediaPlayer::UBMediaPlayer() :
buttonPanelLayout->addWidget(sliderPanel);
buttonPanelLayout->setContentsMargins(0, 0, 0, 0);
#ifdef Q_OS_MAC
// layout->setSpacing(4);
buttonPanelLayout->setSpacing(0);
// info->setMinimumHeight(100);
// info->setFont(QFont("verdana", 15));
// openButton->setFocusPolicy(Qt::NoFocus);
#endif
QWidget *buttonPanelWidget = new QWidget(this);
buttonPanelWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
@ -138,23 +89,13 @@ UBMediaPlayer::UBMediaPlayer() :
vLayout->addLayout(labelLayout);
setLayout(vLayout);
// Setup signal connections:
// connect(rewindButton, SIGNAL(clicked()), this, SLOT(rewind()));
connect(playButton, SIGNAL(clicked()), this, SLOT(playPause()));
// connect(forwardButton, SIGNAL(clicked()), this, SLOT(forward()));
// connect(&m_MediaObject, SIGNAL(totalTimeChanged(qint64)), this, SLOT(updateTime()));
// connect(&m_MediaObject, SIGNAL(tick(qint64)), this, SLOT(updateTime()));
connect(&m_MediaObject, SIGNAL(finished()), this, SLOT(finished()));
connect(&m_MediaObject, SIGNAL(stateChanged(Phonon::State,Phonon::State)), this, SLOT(stateChanged(Phonon::State,Phonon::State)));
connect(&m_MediaObject, SIGNAL(bufferStatus(int)), this, SLOT(bufferStatus(int)));
connect(&m_MediaObject, SIGNAL(hasVideoChanged(bool)), this, SLOT(hasVideoChanged(bool)));
// rewindButton->setEnabled(false);
playButton->setEnabled(false);
// setAcceptDrops(true);
m_audioOutputPath = Phonon::createPath(&m_MediaObject, &m_AudioOutput);
Phonon::createPath(&m_MediaObject, m_videoWidget);
@ -180,7 +121,6 @@ void UBMediaPlayer::stateChanged(Phonon::State newstate, Phonon::State oldstate)
case Phonon::ErrorState:
if (m_MediaObject.errorType() == Phonon::FatalError) {
playButton->setEnabled(false);
// rewindButton->setEnabled(false);
} else {
m_MediaObject.pause();
}
@ -188,16 +128,13 @@ void UBMediaPlayer::stateChanged(Phonon::State newstate, Phonon::State oldstate)
break;
case Phonon::StoppedState:
// m_videoWidget-> (false);
// Fall through
case Phonon::PausedState:
playButton->setIcon(playIcon);
if (m_MediaObject.currentSource().type() != Phonon::MediaSource::Invalid){
playButton->setEnabled(true);
// rewindButton->setEnabled(true);
} else {
playButton->setEnabled(false);
// rewindButton->setEnabled(false);
}
break;
case Phonon::PlayingState:
@ -207,10 +144,8 @@ void UBMediaPlayer::stateChanged(Phonon::State newstate, Phonon::State oldstate)
m_videoWindow.show();
// Fall through
case Phonon::BufferingState:
// rewindButton->setEnabled(true);
break;
case Phonon::LoadingState:
// rewindButton->setEnabled(false);
break;
}
@ -280,35 +215,6 @@ void UBMediaPlayer::bufferStatus(int percent)
}
}
//void UBMediaPlayer::updateTime()
//{
// long len = m_MediaObject.totalTime();
// long pos = m_MediaObject.currentTime();
// QString timeString;
// if (pos || len)
// {
// int sec = pos/1000;
// int min = sec/60;
// int hour = min/60;
// int msec = pos;
// QTime playTime(hour%60, min%60, sec%60, msec%1000);
// sec = len / 1000;
// min = sec / 60;
// hour = min / 60;
// msec = len;
// QTime stopTime(hour%60, min%60, sec%60, msec%1000);
// QString timeFormat = "m:ss";
// if (hour > 0)
// timeFormat = "h:mm:ss";
// timeString = playTime.toString(timeFormat);
// if (len)
// timeString += " / " + stopTime.toString(timeFormat);
// }
// timeLabel->setText(timeString);
//}
void UBMediaPlayer::rewind()
{
m_MediaObject.seek(0);
@ -319,7 +225,6 @@ void UBMediaPlayer::forward()
QList<Phonon::MediaSource> queue = m_MediaObject.queue();
if (queue.size() > 0) {
m_MediaObject.setCurrentSource(queue[0]);
// forwardButton->setEnabled(queue.size() > 1);
m_MediaObject.play();
}
}
@ -343,47 +248,10 @@ void UBMediaPlayer::finished()
void UBMediaPlayer::hasVideoChanged(bool bHasVideo)
{
// info->setVisible(!bHasVideo);
m_videoWindow.setVisible(bHasVideo);
}
void UBMediaPlayer::resizeEvent(QResizeEvent* pEvent)
{
Q_UNUSED(pEvent);
// int origWidth = m_videoWindow.width();
// int origHeight = m_videoWindow.height();
// float scaleFactor = (float)origWidth / (float)width();
// int newWidth = width();
// int newHeigth = origHeight/scaleFactor;
// m_videoWindow.resize(newWidth, newHeigth);
}
//*************************************************************************
UBDraggableMediaPlayer::UBDraggableMediaPlayer():UBMediaPlayer()
{
// setAcceptDrops(true);
}
void UBDraggableMediaPlayer::setFile(const QString &text)
{
mSourcePath = text;
UBMediaPlayer::setFile(text);
}
void UBDraggableMediaPlayer::mousePressEvent(QMouseEvent *event)
{
Q_UNUSED(event);
QMimeData *mimeData = new QMimeData;
QList<QUrl> urls;
urls << QUrl::fromLocalFile(mSourcePath);
mimeData->setUrls(urls);
mimeData->setText(mSourcePath);
QDrag *drag = new QDrag(this);
drag->setMimeData(mimeData);
drag->start();
}

@ -1,3 +1,18 @@
/*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef UBUBMediaPlayer_H
#define UBUBMediaPlayer_H
@ -41,7 +56,6 @@ protected:
private:
UBMediaPlayer* m_player;
QBasicTimer m_timer;
// QAction m_action;
};
class UBMediaPlayer : public QWidget
@ -58,7 +72,6 @@ public slots:
void openFile();
void rewind();
void forward();
// void updateTime();
void finished();
void playPause();
@ -78,12 +91,8 @@ private:
QIcon playIcon;
QIcon pauseIcon;
QPushButton *playButton;
// QPushButton *rewindButton;
// QPushButton *forwardButton;
Phonon::SeekSlider *slider;
// QLabel *timeLabel;
QLabel *progressLabel;
// QLabel *info;
QWidget m_videoWindow;
Phonon::MediaObject m_MediaObject;
@ -92,16 +101,6 @@ private:
Phonon::Path m_audioOutputPath;
};
class UBDraggableMediaPlayer : public UBMediaPlayer
{
Q_OBJECT
public:
UBDraggableMediaPlayer();
void setFile(const QString &text);
protected:
QString mSourcePath;
void mousePressEvent(QMouseEvent *event);
};
#endif // UBUBMediaPlayer_H

@ -0,0 +1,5 @@
#include "UBTeacherGuideDelegate.h"
UBTeacherGuideDelegate::UBTeacherGuideDelegate()
{
}

@ -0,0 +1,10 @@
#ifndef UBTEACHERGUIDEDELEGATE_H
#define UBTEACHERGUIDEDELEGATE_H
class UBTeacherGuideDelegate
{
public:
UBTeacherGuideDelegate();
};
#endif // UBTEACHERGUIDEDELEGATE_H

@ -0,0 +1,404 @@
/*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
#include <QDebug>
#include <QLabel>
#include <QVBoxLayout>
#include <QHeaderView>
#include <QTreeWidget>
#include <QPushButton>
#include "UBTeacherGuideWidget.h"
#include "core/UBApplication.h"
#include "globals/UBGlobals.h"
#include "board/UBBoardController.h"
#include "board/UBBoardView.h"
#include "board/UBBoardPaletteManager.h"
#include "gui/UBStylusPalette.h"
#include "gui/UBActionPalette.h"
#include "web/UBWebController.h"
typedef enum
{
eUBTGAddSubItemWidgetType_None,
eUBTGAddSubItemWidgetType_Action ,
eUBTGAddSubItemWidgetType_Media,
eUBTGAddSubItemWidgetType_Url
}eUBTGAddSubItemWidgetType;
/***************************************************************************
* class UBTeacherGuideEditionWidget *
***************************************************************************/
UBTeacherGuideEditionWidget::UBTeacherGuideEditionWidget(QWidget *parent, const char* name) :
QWidget(parent)
, mpLayout(NULL)
, mpDocumentTitle(NULL)
, mpPageTitle(NULL)
, mpComment(NULL)
, mpTreeWidget(NULL)
, mpRootWidgetItem(NULL)
, mpAddAnActionItem(NULL)
, mpAddAMediaItem(NULL)
, mpAddALinkItem(NULL)
{
setObjectName(name);
mpLayout = new QVBoxLayout(this);
// tree basic configuration
mpDocumentTitle = new QLabel(this);
mpDocumentTitle->setText("title document");
mpDocumentTitle->setStyleSheet( "QWidget {background-color: white}");
mpLayout->addWidget(mpDocumentTitle);
mpPageTitle = new UBTGAdaptableText(0,this);
mpLayout->addWidget(mpPageTitle);
mpComment = new UBTGAdaptableText(0,this);
mpLayout->addWidget(mpComment);
mpTreeWidget = new QTreeWidget(this);
mpLayout->addWidget(mpTreeWidget);
mpRootWidgetItem = mpTreeWidget->invisibleRootItem();
mpTreeWidget->setRootIsDecorated(false);
mpTreeWidget->setIndentation(0);
mpTreeWidget->setDropIndicatorShown(false);
mpTreeWidget->header()->close();
mpTreeWidget->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
connect(mpTreeWidget,SIGNAL(itemClicked(QTreeWidgetItem*,int)),this,SLOT(onAddItemClicked(QTreeWidgetItem*,int)));
mpAddAnActionItem = new UBAddItem(tr("Add an action"),eUBTGAddSubItemWidgetType_Action,mpTreeWidget);
mpAddAMediaItem = new UBAddItem(tr("Add a media"),eUBTGAddSubItemWidgetType_Media,mpTreeWidget);
mpAddALinkItem = new UBAddItem(tr("Add a link"),eUBTGAddSubItemWidgetType_Url,mpTreeWidget);
mpRootWidgetItem->addChild(mpAddAnActionItem);
mpRootWidgetItem->addChild(mpAddAMediaItem);
mpRootWidgetItem->addChild(mpAddALinkItem);
}
UBTeacherGuideEditionWidget::~UBTeacherGuideEditionWidget()
{
DELETEPTR(mpDocumentTitle);
DELETEPTR(mpPageTitle);
DELETEPTR(mpComment);
DELETEPTR(mpAddAnActionItem);
DELETEPTR(mpAddAMediaItem);
DELETEPTR(mpAddALinkItem);
DELETEPTR(mpTreeWidget)
DELETEPTR(mpLayout);
}
void UBTeacherGuideEditionWidget::cleanData()
{
mpPageTitle->setText("");
mpComment->setText("");
QList<QTreeWidgetItem*> children = mpAddAnActionItem->takeChildren();
children << mpAddAMediaItem->takeChildren();
children << mpAddALinkItem->takeChildren();
foreach(QTreeWidgetItem* item, children){
DELETEPTR(item);
}
}
QList<QTreeWidgetItem*> UBTeacherGuideEditionWidget::getChildrenList(QTreeWidgetItem* widgetItem)
{
QList<QTreeWidgetItem*>result;
for(int i=0;i<widgetItem->childCount();i+=1)
result << widgetItem->child(i);
return result;
}
QVector<tUBGEElementNode*> UBTeacherGuideEditionWidget::getPageAndCommentData()
{
QVector<tUBGEElementNode*>result;
tUBGEElementNode* pageTitle = new tUBGEElementNode();
pageTitle->type = "pageTitle";
pageTitle->attributes.insert("value",mpPageTitle->toPlainText());
result << pageTitle;
tUBGEElementNode* comment = new tUBGEElementNode();
comment->type = "comment";
comment->attributes.insert("value",mpComment->toPlainText());
result << comment;
return result;
}
QVector<tUBGEElementNode*> UBTeacherGuideEditionWidget::getData()
{
QVector<tUBGEElementNode*>result;
QList<QTreeWidgetItem*> children = getChildrenList(mpAddAnActionItem);
children << getChildrenList(mpAddAMediaItem);
children << getChildrenList(mpAddALinkItem);
result << getPageAndCommentData();
foreach(QTreeWidgetItem* widgetItem, children){
result << dynamic_cast<iUBTGSavableData*>(mpTreeWidget->itemWidget(widgetItem,0))->saveData();
}
return result;
}
void UBTeacherGuideEditionWidget::onAddItemClicked(QTreeWidgetItem* widget, int column)
{
int addSubItemWidgetType = widget->data(column,Qt::UserRole).toInt();
if(column == 0 && addSubItemWidgetType != eUBTGAddSubItemWidgetType_None){
QTreeWidgetItem* newWidgetItem = new QTreeWidgetItem(widget);
newWidgetItem->setData(column,Qt::UserRole,eUBTGAddSubItemWidgetType_None);
switch(addSubItemWidgetType)
{
case eUBTGAddSubItemWidgetType_Action:
mpTreeWidget->setItemWidget(newWidgetItem,0,new UBTGActionWidget(widget));
break;
case eUBTGAddSubItemWidgetType_Media:
mpTreeWidget->setItemWidget(newWidgetItem,0,new UBTGMediaWidget(widget));
break;
case eUBTGAddSubItemWidgetType_Url:
mpTreeWidget->setItemWidget(newWidgetItem,0,new UBTGUrlWidget());
break;
default:
qDebug() << "onAddItemClicked no action set";
}
if(addSubItemWidgetType != eUBTGAddSubItemWidgetType_None && !widget->isExpanded() )
widget->setExpanded(true);
else{
//to update the tree and subtrees
widget->setExpanded(false);
widget->setExpanded(true);
}
}
}
/***************************************************************************
* class UBTeacherGuidePresentationWidget *
***************************************************************************/
typedef enum
{
tUBTGActionAssociateOnClickItem_NONE,
tUBTGActionAssociateOnClickItem_URL,
tUBTGActionAssociateOnClickItem_MEDIA,
tUBTGActionAssociateOnClickItem_EXPAND
}tUBTGActionAssociateOnClickItem;
typedef enum
{
tUBTGTreeWidgetItemRole_HasAnAction = Qt::UserRole,
tUBTGTreeWidgetItemRole_HasAnUrl
}tUBTGTreeWidgetItemRole;
UBTeacherGuidePresentationWidget::UBTeacherGuidePresentationWidget(QWidget *parent, const char *name) : QWidget(parent)
, mpPageTitle(NULL)
, mpComment(NULL)
, mpLayout(NULL)
, mpButtonTitleLayout(NULL)
, mpDocumentTile(NULL)
, mpModePushButton(NULL)
, mpTreeWidget(NULL)
, mpRootWidgetItem(NULL)
, mpMediaSwitchItem(NULL)
{
setObjectName(name);
mpLayout = new QVBoxLayout(this);
mpButtonTitleLayout = new QHBoxLayout(0);
mpModePushButton = new QPushButton(this);
mpModePushButton->setIcon(QIcon(":images/pencil.svg"));
connect(mpModePushButton,SIGNAL(clicked()),parentWidget(),SLOT(changeMode()));
mpDocumentTile = new QLabel(this);
mpDocumentTile->setText("Document title");
mpButtonTitleLayout->addWidget(mpModePushButton);
mpButtonTitleLayout->addWidget(mpDocumentTile);
mpLayout->addLayout(mpButtonTitleLayout);
mpPageTitle = new UBTGAdaptableText(0,this);
mpPageTitle->setReadOnly(true);
mpLayout->addWidget(mpPageTitle);
mpComment = new UBTGAdaptableText(0,this);
mpComment->setReadOnly(true);
mpLayout->addWidget(mpComment);
mpTreeWidget = new QTreeWidget(this);
mpLayout->addWidget(mpTreeWidget);
mpRootWidgetItem = mpTreeWidget->invisibleRootItem();
mpTreeWidget->setRootIsDecorated(false);
mpTreeWidget->setIndentation(0);
mpTreeWidget->setDropIndicatorShown(false);
mpTreeWidget->header()->close();
mpTreeWidget->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
connect(mpTreeWidget,SIGNAL(itemClicked(QTreeWidgetItem*,int)),this,SLOT(onAddItemClicked(QTreeWidgetItem*,int)));
}
UBTeacherGuidePresentationWidget::~UBTeacherGuidePresentationWidget()
{
DELETEPTR(mpComment);
DELETEPTR(mpPageTitle);
DELETEPTR(mpMediaSwitchItem);
DELETEPTR(mpModePushButton);
DELETEPTR(mpDocumentTile);
DELETEPTR(mpButtonTitleLayout);
DELETEPTR(mpTreeWidget);
DELETEPTR(mpLayout);
}
void UBTeacherGuidePresentationWidget::createMediaButtonItem()
{
if(!mpMediaSwitchItem){
//create the media button
mpMediaSwitchItem = new QTreeWidgetItem(mpRootWidgetItem);
mpMediaSwitchItem->setIcon(0,QIcon(":images/plus.svg"));
mpMediaSwitchItem->setExpanded(false);
mpMediaSwitchItem->setData(0,tUBTGTreeWidgetItemRole_HasAnAction,tUBTGActionAssociateOnClickItem_EXPAND);
mpRootWidgetItem->addChild(mpMediaSwitchItem);
}
}
void UBTeacherGuidePresentationWidget::showData(QVector<tUBGEElementNode*> data)
{
//tree clean
QList<QTreeWidgetItem*> itemToRemove = mpRootWidgetItem->takeChildren();
foreach(QTreeWidgetItem* eachItem, itemToRemove){
DELETEPTR(eachItem);
}
// the mpMediaSwitchItem is deleted by the previous loop but the pointer is not set to zero
mpMediaSwitchItem = NULL;
foreach(tUBGEElementNode* element, data){
if(element->type == "pageTitle")
mpPageTitle->showText(element->attributes.value("value"));
else if (element->type == "comment")
mpComment->showText(element->attributes.value("value"));
else if(element->type == "action"){
QTreeWidgetItem* newWidgetItem = new QTreeWidgetItem(mpRootWidgetItem);
newWidgetItem->setText(0,element->attributes.value("task"));
QColor color = element->attributes.value("owner").toInt()?QColor().red():QColor().green();
newWidgetItem->setTextColor(0,color);
newWidgetItem->setData(0,tUBTGTreeWidgetItemRole_HasAnAction,tUBTGActionAssociateOnClickItem_NONE);
mpRootWidgetItem->addChild(newWidgetItem);
}
else if(element->type == "media"){
createMediaButtonItem();
QTreeWidgetItem* newWidgetItem = new QTreeWidgetItem(mpMediaSwitchItem);
newWidgetItem->setText(0,element->attributes.value("title"));
newWidgetItem->setData(0,tUBTGTreeWidgetItemRole_HasAnAction,tUBTGActionAssociateOnClickItem_MEDIA);
mpRootWidgetItem->addChild(newWidgetItem);
QTreeWidgetItem* mediaItem = new QTreeWidgetItem(newWidgetItem);
mediaItem->setText(0,element->attributes.value("title"));
mediaItem->setData(0,tUBTGTreeWidgetItemRole_HasAnAction,tUBTGActionAssociateOnClickItem_NONE);
UBTGMediaWidget* mediaWidget = new UBTGMediaWidget(element->attributes.value("relativePath"),newWidgetItem);
newWidgetItem->setExpanded(false);
mpTreeWidget->setItemWidget(mediaItem,0,mediaWidget);
}
else if(element->type == "link"){
createMediaButtonItem();
QTreeWidgetItem* newWidgetItem = new QTreeWidgetItem(mpMediaSwitchItem);
newWidgetItem->setText(0,element->attributes.value("title"));
newWidgetItem->setData(0,tUBTGTreeWidgetItemRole_HasAnAction,tUBTGActionAssociateOnClickItem_URL);
newWidgetItem->setData(0,tUBTGTreeWidgetItemRole_HasAnUrl,QVariant(element->attributes.value("url")));
mpRootWidgetItem->addChild(newWidgetItem);
}
}
}
void UBTeacherGuidePresentationWidget::onAddItemClicked(QTreeWidgetItem* widget, int column)
{
int associateAction = widget->data(column,tUBTGTreeWidgetItemRole_HasAnAction).toInt();
if(column == 0 && associateAction != tUBTGActionAssociateOnClickItem_NONE){
switch(associateAction)
{
case tUBTGActionAssociateOnClickItem_EXPAND:
widget->setExpanded(!widget->isExpanded());
break;
case tUBTGActionAssociateOnClickItem_URL:
widget->data(column,tUBTGTreeWidgetItemRole_HasAnUrl).toString();
UBApplication::webController->loadUrl(QUrl(widget->data(column,tUBTGTreeWidgetItemRole_HasAnUrl).toString()));
break;
case tUBTGActionAssociateOnClickItem_MEDIA:
widget->setExpanded(!widget->isExpanded());
break;
default:
qDebug() << "associateAction no action set " << associateAction;
}
}
}
/***************************************************************************
* class UBTeacherGuideWidget *
***************************************************************************/
UBTeacherGuideWidget::UBTeacherGuideWidget(QWidget *parent, const char *name): QStackedWidget(parent)
, mpEditionWidget(NULL)
, mpPresentationWidget(NULL)
{
setObjectName(name);
mpEditionWidget = new UBTeacherGuideEditionWidget(this);
addWidget(mpEditionWidget);
mpPresentationWidget = new UBTeacherGuidePresentationWidget(this);
addWidget(mpPresentationWidget);
setCurrentWidget(mpEditionWidget);
connect(UBApplication::boardController->controlView(),SIGNAL(clickOnBoard()),this,SLOT(showPresentationMode()));
connectToStylusPalette();
}
UBTeacherGuideWidget::~UBTeacherGuideWidget()
{
DELETEPTR(mpEditionWidget);
DELETEPTR(mpPresentationWidget);
}
void UBTeacherGuideWidget::connectToStylusPalette()
{
if(UBApplication::boardController->paletteManager())
connect(UBApplication::boardController->paletteManager()->stylusPalette(),SIGNAL(itemOnActionPaletteChanged()),this,SLOT(showPresentationMode()));
else
QTimer::singleShot(500,this,SLOT(connectToStylusPalette()));
}
void UBTeacherGuideWidget::showPresentationMode()
{
if(currentWidget()!=mpPresentationWidget){
currentData = mpEditionWidget->getData();
mpPresentationWidget->showData(currentData);
setCurrentWidget(mpPresentationWidget);
}
}
void UBTeacherGuideWidget::changeMode()
{
if(currentWidget() == mpEditionWidget)
setCurrentWidget(mpPresentationWidget);
else
setCurrentWidget(mpEditionWidget);
}

@ -0,0 +1,114 @@
/*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef UBTEACHERGUIDEWIDGET_H
#define UBTEACHERGUIDEWIDGET_H
class QTreeWidget;
class QHeaderView;
class QLabel;
class QVBoxLayout;
class QPushButton;
#include "UBTeacherGuideWidgetsTools.h"
/***************************************************************************
* class UBTeacherGuideEditionWidget *
***************************************************************************/
class UBTeacherGuideEditionWidget : public QWidget
{
Q_OBJECT
public:
explicit UBTeacherGuideEditionWidget(QWidget* parent = 0, const char* name="UBTeacherGuideEditionWidget");
~UBTeacherGuideEditionWidget();
void cleanData();
QVector<tUBGEElementNode*> getData();
public slots:
void onAddItemClicked(QTreeWidgetItem* widget, int column);
private:
QList<QTreeWidgetItem*> getChildrenList(QTreeWidgetItem* widgetItem);
QVector<tUBGEElementNode*> getPageAndCommentData();
QVBoxLayout* mpLayout;
QLabel* mpDocumentTitle;
UBTGAdaptableText* mpPageTitle;
UBTGAdaptableText* mpComment;
QTreeWidget* mpTreeWidget;
QTreeWidgetItem* mpRootWidgetItem;
UBAddItem* mpAddAnActionItem;
UBAddItem* mpAddAMediaItem;
UBAddItem* mpAddALinkItem;
};
/***************************************************************************
* class UBTeacherGuidePresentationWidget *
***************************************************************************/
class UBTeacherGuidePresentationWidget : public QWidget
{
Q_OBJECT
public:
explicit UBTeacherGuidePresentationWidget(QWidget* parent, const char* name = "UBTeacherGuidePresentationName");
~UBTeacherGuidePresentationWidget();
void showData(QVector<tUBGEElementNode*>data);
public slots:
void onAddItemClicked(QTreeWidgetItem* widget, int column);
private:
void createMediaButtonItem();
UBTGAdaptableText* mpPageTitle;
UBTGAdaptableText* mpComment;
QVBoxLayout* mpLayout;
QHBoxLayout* mpButtonTitleLayout;
QLabel* mpDocumentTile;
QPushButton* mpModePushButton;
QTreeWidget* mpTreeWidget;
QTreeWidgetItem* mpRootWidgetItem;
QTreeWidgetItem* mpMediaSwitchItem;
};
/***************************************************************************
* class UBTeacherGuideWidget *
***************************************************************************/
class UBTeacherGuideWidget : public QStackedWidget
{
Q_OBJECT
public:
explicit UBTeacherGuideWidget(QWidget* parent = 0, const char* name="UBTeacherGuideWidget");
~UBTeacherGuideWidget();
public slots:
void changeMode();
void showPresentationMode();
void connectToStylusPalette();
private:
UBTeacherGuideEditionWidget* mpEditionWidget;
UBTeacherGuidePresentationWidget* mpPresentationWidget;
QVector<tUBGEElementNode*>currentData;
};
#endif // UBTEACHERGUIDEWIDGET_H

@ -0,0 +1,361 @@
/*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
#include <QTreeWidget>
#include <QVBoxLayout>
#include <QComboBox>
#include <QColor>
#include <QLabel>
#include <QDebug>
#include <QUrl>
#include <QWebSettings>
#include <QDomElement>
#include <QDomDocument>
#include "UBTeacherGuideWidgetsTools.h"
#include "globals/UBGlobals.h"
#include "frameworks/UBFileSystemUtils.h"
/***************************************************************************
* class UBAddItem *
***************************************************************************/
UBAddItem::UBAddItem(const QString &string, int addSubItemWidgetType, QTreeWidget* parent): QTreeWidgetItem(parent)
{
setIcon(0,QIcon(":images/increase.svg"));
setText(0,string);
setData(0,Qt::UserRole,QVariant(addSubItemWidgetType));
}
UBAddItem::~UBAddItem()
{
//NOOP
}
/***************************************************************************
* class UBTGActionWidget *
***************************************************************************/
UBTGActionWidget::UBTGActionWidget(QTreeWidgetItem* widget, QWidget* parent, const char* name) : QWidget(parent)
, mpLayout(NULL)
, mpOwner(NULL)
, mpTask(NULL)
{
setObjectName(name);
mpLayout = new QVBoxLayout(this);
mpOwner = new QComboBox(this);
QStringList qslOwner;
qslOwner << tr("Teacher") << tr("Student");
mpOwner->insertItems(0,qslOwner);
mpOwner->setCurrentIndex(0);
connect(mpOwner,SIGNAL(currentIndexChanged(int)),this,SLOT(onOwnerChange(int)));
mpTask = new UBTGAdaptableText(widget,this);
mpTask->setAcceptRichText(true);
mpTask->setTextColor(QColor().green());
mpTask->setObjectName("ActionWidgetTaskTextEdit");
mpLayout->addWidget(mpOwner,0);
mpLayout->addWidget(mpTask,1);
setStyleSheet( "QWidget {background-color: white}");
}
UBTGActionWidget::~UBTGActionWidget()
{
DELETEPTR(mpOwner);
DELETEPTR(mpTask);
DELETEPTR(mpLayout);
}
void UBTGActionWidget::onOwnerChange(int ownerId)
{
if(ownerId == 0)
mpTask->setTextColor(QColor().red());
else
mpTask->setTextColor(QColor().green());
}
tUBGEElementNode* UBTGActionWidget::saveData()
{
tUBGEElementNode* result = new tUBGEElementNode();
result->type = "action";
result->attributes.insert("owner",QString(mpOwner->currentIndex()));
result->attributes.insert("task",mpTask->toPlainText());
return result;
}
/***************************************************************************
* class UBTGAdaptableText *
***************************************************************************/
UBTGAdaptableText::UBTGAdaptableText(QTreeWidgetItem* widget, QWidget* parent, const char* name):QTextEdit(parent)
, mBottomMargin(5)
, mpTreeWidgetItem(widget)
{
setObjectName(name);
setStyleSheet( "QWidget {background-color: white}");
connect(this,SIGNAL(textChanged()),this,SLOT(onTextChanged()));
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
}
void UBTGAdaptableText::onTextChanged()
{
setFixedHeight(document()->size().height()+mBottomMargin);
updateGeometry();
//to trig the widget item to resize it
if(mpTreeWidgetItem){
mpTreeWidgetItem->setExpanded(false);
mpTreeWidgetItem->setExpanded(true);
setFocus();
}
}
void UBTGAdaptableText::showText(const QString & text)
{
setText(text);
//A first rendering has to be done to calculate the text's size.
show();
hide();
setReadOnly(true);
onTextChanged();
}
void UBTGAdaptableText::bottomMargin(int newValue)
{
mBottomMargin = newValue;
onTextChanged();
}
/***************************************************************************
* class UBTGMediaWidget *
***************************************************************************/
UBTGMediaWidget::UBTGMediaWidget(QTreeWidgetItem* widget, QWidget* parent,const char* name): QStackedWidget(parent)
, mpTreeWidgetItem(widget)
, mpDropMeWidget(NULL)
, mpWorkWidget(NULL)
, mpLayout(NULL)
, mpTitle(NULL)
, mpMediaLabelWidget(NULL)
, mpMediaWidget(NULL)
, mpWebView(NULL)
, mRelativePath(QString(""))
, mIsPresentationMode(false)
{
setObjectName(name);
setStyleSheet( "QWidget {background-color: white}");
mpDropMeWidget = new QLabel();
mpDropMeWidget->setText(tr("drop media here ..."));
mpDropMeWidget->setAlignment(Qt::AlignCenter);
setAcceptDrops(true);
addWidget(mpDropMeWidget);
setMinimumHeight(40);
}
UBTGMediaWidget::UBTGMediaWidget(QString relativePath, QTreeWidgetItem* widget, QWidget* parent,const char* name): QStackedWidget(parent)
, mpTreeWidgetItem(widget)
, mpDropMeWidget(NULL)
, mpWorkWidget(NULL)
, mpLayout(NULL)
, mpTitle(NULL)
, mpMediaLabelWidget(NULL)
, mpMediaWidget(NULL)
, mpWebView(NULL)
, mRelativePath(relativePath)
, mIsPresentationMode(true)
{
setObjectName(name);
setAcceptDrops(false);
createWorkWidget(mRelativePath);
}
UBTGMediaWidget::~UBTGMediaWidget()
{
DELETEPTR(mpTitle);
DELETEPTR(mpMediaLabelWidget);
DELETEPTR(mpMediaWidget);
DELETEPTR(mpWebView);
DELETEPTR(mpLayout);
removeWidget(mpDropMeWidget);
DELETEPTR(mpDropMeWidget);
removeWidget(mpWorkWidget);
DELETEPTR(mpWorkWidget);
}
tUBGEElementNode* UBTGMediaWidget::saveData()
{
tUBGEElementNode* result = new tUBGEElementNode();
result->type = "media";
result->attributes.insert("title",mpTitle->toPlainText());
result->attributes.insert("relativePath",mRelativePath);
return result;
}
void UBTGMediaWidget::dragEnterEvent(QDragEnterEvent *event)
{
event->accept();
}
void UBTGMediaWidget::createWorkWidget(QString& path)
{
QString mimeType = UBFileSystemUtils::mimeTypeFromFileName(path);
qDebug() << mimeType;
bool setMedia = true;
if(mimeType.contains("audio") || mimeType.contains("video")){
mpMediaWidget = new UBMediaWidget(mimeType.contains("audio")?eMediaType_Audio:eMediaType_Video);
mpMediaWidget->setFile(path);
}
else if(mimeType.contains("image")){
mpMediaLabelWidget = new QLabel();
mpMediaLabelWidget->setPixmap(QPixmap(QUrl(path).toLocalFile()));
mpMediaLabelWidget->setScaledContents(true);
}
else if(mimeType.contains("application")){
mpWebView = new QWebView(0);
mpWebView->setAcceptDrops(false);
mpWebView->settings()->setAttribute(QWebSettings::JavaEnabled, true);
mpWebView->settings()->setAttribute(QWebSettings::PluginsEnabled, true);
mpWebView->settings()->setAttribute(QWebSettings::LocalStorageDatabaseEnabled, true);
mpWebView->settings()->setAttribute(QWebSettings::OfflineWebApplicationCacheEnabled, true);
mpWebView->settings()->setAttribute(QWebSettings::OfflineStorageDatabaseEnabled, true);
mpWebView->settings()->setAttribute(QWebSettings::JavascriptCanAccessClipboard, true);
mpWebView->settings()->setAttribute(QWebSettings::DnsPrefetchEnabled, true);
mpWebView->load(QUrl(path));
mpWebView->show();
}
else{
qDebug() << "createWorkWidget mime type not handled" << mimeType;
setMedia=false;
}
if(setMedia){
mRelativePath = path;
setAcceptDrops(false);
mpWorkWidget = new QWidget(this);
mpLayout = new QVBoxLayout(mpWorkWidget);
if(!mIsPresentationMode){
mpTitle = new UBTGAdaptableText(mpTreeWidgetItem,mpWorkWidget);
mpLayout->addWidget(mpTitle);
}
if(mpMediaLabelWidget){
mpMediaLabelWidget->setParent(mpWorkWidget);
mpLayout->addWidget(mpMediaLabelWidget);
}
else if (mpMediaWidget){
mpMediaWidget->setParent(mpWorkWidget);
mpLayout->addWidget(mpMediaWidget);
}
else if (mpWebView){
mpWebView->setParent(mpWorkWidget);
mpLayout->addWidget(mpWebView);
}
addWidget(mpWorkWidget);
setCurrentWidget(mpWorkWidget);
updateSize();
}
}
void UBTGMediaWidget::parseMimeData(const QMimeData* pMimeData)
{
QString path;
if(pMimeData){
if(pMimeData->hasText()){
path = QUrl::fromLocalFile(pMimeData->text()).toString();
}
else if(pMimeData->hasUrls()){
path = pMimeData->urls().at(0).toString();
}
else if(pMimeData->hasImage()){
qDebug() << "Not yet implemented";
}
}
else
qDebug() << "No mime data present";
createWorkWidget(path);
QString mimeType = UBFileSystemUtils::mimeTypeFromFileName(path);
qDebug() << mimeType;
}
void UBTGMediaWidget::dropEvent(QDropEvent* event)
{
parseMimeData(event->mimeData());
event->accept();
}
void UBTGMediaWidget::mousePressEvent(QMouseEvent *event)
{
if (!mIsPresentationMode)
event->ignore();
else{
QDrag *drag = new QDrag(this);
QMimeData *mimeData = new QMimeData;
QList<QUrl> urlList;
urlList << QUrl::fromLocalFile(mRelativePath);
mimeData->setUrls(urlList);
drag->setMimeData(mimeData);
drag->exec();
event->accept();
}
}
void UBTGMediaWidget::updateSize()
{
if(mpTreeWidgetItem){
mpTreeWidgetItem->setExpanded(false);
mpTreeWidgetItem->setExpanded(true);
if(!mIsPresentationMode)
mpTitle->setFocus();
}
}
/***************************************************************************
* class UBTGUrlWdiget *
***************************************************************************/
UBTGUrlWidget::UBTGUrlWidget(QWidget* parent, const char* name ):QWidget(parent)
, mpLayout(NULL)
, mpTitle(NULL)
, mpUrl(NULL)
{
setObjectName(name);
setStyleSheet( "QWidget {background-color: white}");
mpLayout = new QVBoxLayout(this);
mpTitle = new QLineEdit("title",this);
mpUrl = new QLineEdit("url",this);
mpLayout->addWidget(mpTitle);
mpLayout->addWidget(mpUrl);
}
UBTGUrlWidget::~UBTGUrlWidget()
{
DELETEPTR(mpTitle);
DELETEPTR(mpUrl);
DELETEPTR(mpLayout);
}
tUBGEElementNode* UBTGUrlWidget::saveData()
{
tUBGEElementNode* result = new tUBGEElementNode();
result->type = "link";
result->attributes.insert("title",mpTitle->text());
result->attributes.insert("url",mpUrl->text());
return result;
}

@ -0,0 +1,144 @@
/*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef UBTEACHERGUIDEWIDGETSTOOLS_H
#define UBTEACHERGUIDEWIDGETSTOOLS_H
#include <QObject>
#include <QTreeWidgetItem>
#include <QTextEdit>
#include <QLabel>
#include <QDragEnterEvent>
#include <QDropEvent>
#include <QLineEdit>
#include <QMimeData>
#include <QStackedWidget>
#include <QWebView>
#include "customWidgets/UBMediaWidget.h"
class QTreeWidget;
class QVBoxLayout;
class QComboBox;
class QTextEdit;
class QWidget;
class UBTGAdaptableText;
class QDomElement;
typedef struct
{
QString type;
QMap<QString,QString> attributes;
}tUBGEElementNode;
class iUBTGSavableData
{
public:
virtual tUBGEElementNode* saveData() = 0;
};
class UBAddItem : public QTreeWidgetItem
{
public:
explicit UBAddItem(const QString &strings, int addSubItemWidgetType, QTreeWidget* parent = 0);
~UBAddItem();
signals:
public slots:
};
class UBTGActionWidget : public QWidget, public iUBTGSavableData
{
Q_OBJECT
public:
explicit UBTGActionWidget(QTreeWidgetItem* widget, QWidget* parent = 0,const char* name = "UBActionWidget");
~UBTGActionWidget();
void update();
tUBGEElementNode* saveData();
public slots:
void onOwnerChange(int ownerId);
private:
QVBoxLayout* mpLayout;
QComboBox* mpOwner;
UBTGAdaptableText* mpTask;
protected:
QTreeWidgetItem* mpTreeWidgetItem;
};
class UBTGAdaptableText : public QTextEdit
{
Q_OBJECT
public:
explicit UBTGAdaptableText(QTreeWidgetItem* widget = 0, QWidget *parent = 0, const char* name = "UBTGAdaptableText");
void showText(const QString & text);
void bottomMargin(int newValue);
signals:
public slots:
void onTextChanged();
private:
int mBottomMargin;
QTreeWidgetItem* mpTreeWidgetItem;
};
class UBTGMediaWidget : public QStackedWidget , public iUBTGSavableData
{
Q_OBJECT
public:
UBTGMediaWidget(QTreeWidgetItem* widget = 0, QWidget* parent = 0, const char* name = "UBTGMediaWidget");
UBTGMediaWidget(QString relativePath, QTreeWidgetItem* widget = 0, QWidget* parent = 0, const char* name = "UBTGMediaWidget");
~UBTGMediaWidget();
tUBGEElementNode* saveData();
protected:
void dragEnterEvent(QDragEnterEvent* event);
void dropEvent(QDropEvent* event);
void mousePressEvent(QMouseEvent* event);
private:
void parseMimeData(const QMimeData* pMimeData);
void createWorkWidget(QString& path);
void updateSize();
QTreeWidgetItem* mpTreeWidgetItem;
QLabel* mpDropMeWidget;
QWidget* mpWorkWidget;
QVBoxLayout* mpLayout;
UBTGAdaptableText* mpTitle;
QLabel* mpMediaLabelWidget;
UBMediaWidget* mpMediaWidget;
QWebView* mpWebView;
QString mRelativePath;
bool mIsPresentationMode;
};
class UBTGUrlWidget : public QWidget , public iUBTGSavableData
{
Q_OBJECT
public:
UBTGUrlWidget(QWidget* parent = 0, const char* name = "UBTGUrlWidget");
~UBTGUrlWidget();
tUBGEElementNode* saveData();
private:
QVBoxLayout* mpLayout;
QLineEdit* mpTitle;
QLineEdit* mpUrl;
};
#endif // UBTEACHERGUIDEWIDGETSTOOLS_H

@ -46,7 +46,11 @@ HEADERS += src/gui/UBThumbnailView.h \
src/gui/UBLibWebView.h \
src/gui/UBDownloadWidget.h \
src/gui/UBDockDownloadWidget.h \
src/gui/UBMediaPlayer.h
src/gui/UBMediaPlayer.h \
src/gui/UBDockTeacherGuideWidget.h \
src/gui/UBTeacherGuideWidget.h \
src/gui/UBTeacherGuideWidgetsTools.h \
src/gui/UBTeacherGuideDelegate.h
SOURCES += src/gui/UBThumbnailView.cpp \
src/gui/UBFloatingPalette.cpp \
@ -95,7 +99,11 @@ SOURCES += src/gui/UBThumbnailView.cpp \
src/gui/UBLibWebView.cpp \
src/gui/UBDownloadWidget.cpp \
src/gui/UBDockDownloadWidget.cpp \
src/gui/UBMediaPlayer.cpp
src/gui/UBMediaPlayer.cpp \
src/gui/UBDockTeacherGuideWidget.cpp \
src/gui/UBTeacherGuideWidget.cpp \
src/gui/UBTeacherGuideWidgetsTools.cpp \
src/gui/UBTeacherGuideDelegate.cpp
win32 {
@ -123,15 +131,3 @@ linux-g++-64 {
SOURCES += src/gui/UBKeyboardPalette_linux.cpp
}

Loading…
Cancel
Save