int TimelineModel::rowOffset(int rowNumber) const
{
return expanded() ? expandedRowOffset(rowNumber) : collapsedRowOffset(rowNumber);
}
FixtureRemap::FixtureRemap(Doc *doc, QWidget *parent)
: QDialog(parent)
, m_doc(doc)
{
Q_ASSERT(doc != NULL);
setupUi(this);
connect(m_addButton, SIGNAL(clicked()),
this, SLOT(slotAddTargetFixture()));
connect(m_removeButton, SIGNAL(clicked()),
this, SLOT(slotRemoveTargetFixture()));
connect(m_cloneButton, SIGNAL(clicked()),
this, SLOT(slotCloneSourceFixture()));
connect(m_remapButton, SIGNAL(clicked()),
this, SLOT(slotAddRemap()));
connect(m_unmapButton, SIGNAL(clicked()),
this, SLOT(slotRemoveRemap()));
m_cloneButton->setEnabled(false);
remapWidget = new RemapWidget(m_sourceTree, m_targetTree, this);
remapWidget->show();
m_remapLayout->addWidget(remapWidget);
m_targetDoc = new Doc(this);
/* Load user fixtures first so that they override system fixtures */
m_targetDoc->fixtureDefCache()->load(QLCFixtureDefCache::userDefinitionDirectory());
m_targetDoc->fixtureDefCache()->load(QLCFixtureDefCache::systemDefinitionDirectory());
m_sourceTree->setIconSize(QSize(24, 24));
m_sourceTree->setAllColumnsShowFocus(true);
fillFixturesTree(m_doc, m_sourceTree);
m_targetTree->setIconSize(QSize(24, 24));
m_targetTree->setAllColumnsShowFocus(true);
connect(m_sourceTree->verticalScrollBar(), SIGNAL(valueChanged(int)),
this, SLOT(slotUpdateConnections()));
connect(m_sourceTree, SIGNAL(clicked(QModelIndex)),
this, SLOT(slotUpdateConnections()));
connect(m_sourceTree, SIGNAL(expanded(QModelIndex)),
this, SLOT(slotUpdateConnections()));
connect(m_sourceTree, SIGNAL(collapsed(QModelIndex)),
this, SLOT(slotUpdateConnections()));
connect(m_sourceTree, SIGNAL(itemSelectionChanged()),
this, SLOT(slotSourceSelectionChanged()));
connect(m_targetTree->verticalScrollBar(), SIGNAL(valueChanged(int)),
this, SLOT(slotUpdateConnections()));
connect(m_targetTree, SIGNAL(clicked(QModelIndex)),
this, SLOT(slotUpdateConnections()));
connect(m_targetTree, SIGNAL(expanded(QModelIndex)),
this, SLOT(slotUpdateConnections()));
connect(m_targetTree, SIGNAL(collapsed(QModelIndex)),
this, SLOT(slotUpdateConnections()));
// retrieve the original project name for QLC+ main class
App *mainApp = (App *)m_doc->parent();
QString prjName = mainApp->fileName();
if (prjName.lastIndexOf(".") > 0)
prjName.insert(prjName.lastIndexOf("."), tr(" (remapped)"));
else
prjName.append(tr(" (remapped)"));
m_targetProjectLabel->setText(prjName);
}
int TimelineModel::row(int index) const
{
return expanded() ? expandedRow(index) : collapsedRow(index);
}
wxRect wxRibbonPanel::GetExpandedPosition(wxRect panel,
wxSize expanded_size,
wxDirection direction)
{
// Strategy:
// 1) Determine primary position based on requested direction
// 2) Move the position so that it sits entirely within a display
// (for single monitor systems, this moves it into the display region,
// but for multiple monitors, it does so without splitting it over
// more than one display)
// 2.1) Move in the primary axis
// 2.2) Move in the secondary axis
wxPoint pos;
bool primary_x = false;
int secondary_x = 0;
int secondary_y = 0;
switch(direction)
{
case wxNORTH:
pos.x = panel.GetX() + (panel.GetWidth() - expanded_size.GetWidth()) / 2;
pos.y = panel.GetY() - expanded_size.GetHeight();
primary_x = true;
secondary_y = 1;
break;
case wxEAST:
pos.x = panel.GetRight();
pos.y = panel.GetY() + (panel.GetHeight() - expanded_size.GetHeight()) / 2;
secondary_x = -1;
break;
case wxSOUTH:
pos.x = panel.GetX() + (panel.GetWidth() - expanded_size.GetWidth()) / 2;
pos.y = panel.GetBottom();
primary_x = true;
secondary_y = -1;
break;
case wxWEST:
default:
pos.x = panel.GetX() - expanded_size.GetWidth();
pos.y = panel.GetY() + (panel.GetHeight() - expanded_size.GetHeight()) / 2;
secondary_x = 1;
break;
}
wxRect expanded(pos, expanded_size);
wxRect best(expanded);
int best_distance = INT_MAX;
const unsigned display_n = wxDisplay::GetCount();
unsigned display_i;
for(display_i = 0; display_i < display_n; ++display_i)
{
wxRect display = wxDisplay(display_i).GetGeometry();
if(display.Contains(expanded))
{
return expanded;
}
else if(display.Intersects(expanded))
{
wxRect new_rect(expanded);
int distance = 0;
if(primary_x)
{
if(expanded.GetRight() > display.GetRight())
{
distance = expanded.GetRight() - display.GetRight();
new_rect.x -= distance;
}
else if(expanded.GetLeft() < display.GetLeft())
{
distance = display.GetLeft() - expanded.GetLeft();
new_rect.x += distance;
}
}
else
{
if(expanded.GetBottom() > display.GetBottom())
{
distance = expanded.GetBottom() - display.GetBottom();
new_rect.y -= distance;
}
else if(expanded.GetTop() < display.GetTop())
{
distance = display.GetTop() - expanded.GetTop();
new_rect.y += distance;
}
}
if(!display.Contains(new_rect))
{
// Tried moving in primary axis, but failed.
// Hence try moving in the secondary axis.
int dx = secondary_x * (panel.GetWidth() + expanded_size.GetWidth());
int dy = secondary_y * (panel.GetHeight() + expanded_size.GetHeight());
new_rect.x += dx;
new_rect.y += dy;
// Squaring makes secondary moves more expensive (and also
// prevents a negative cost)
distance += dx * dx + dy * dy;
}
if(display.Contains(new_rect) && distance < best_distance)
{
best = new_rect;
best_distance = distance;
}
}
}
return best;
}
//----------------------------------------------------------------------------
ctkDICOMAppWidget::ctkDICOMAppWidget(QWidget* _parent):Superclass(_parent),
d_ptr(new ctkDICOMAppWidgetPrivate(this))
{
Q_D(ctkDICOMAppWidget);
d->setupUi(this);
this->setSearchWidgetPopUpMode(false);
//Hide image previewer buttons
d->NextImageButton->hide();
d->PrevImageButton->hide();
d->NextSeriesButton->hide();
d->PrevSeriesButton->hide();
d->NextStudyButton->hide();
d->PrevStudyButton->hide();
//Enable sorting in tree view
d->TreeView->setSortingEnabled(true);
d->TreeView->setSelectionBehavior(QAbstractItemView::SelectRows);
d->DICOMProxyModel.setSourceModel(&d->DICOMModel);
d->TreeView->setModel(&d->DICOMModel);
d->ThumbnailsWidget->setThumbnailSize(
QSize(d->ThumbnailWidthSlider->value(), d->ThumbnailWidthSlider->value()));
connect(d->TreeView, SIGNAL(collapsed(QModelIndex)), this, SLOT(onTreeCollapsed(QModelIndex)));
connect(d->TreeView, SIGNAL(expanded(QModelIndex)), this, SLOT(onTreeExpanded(QModelIndex)));
//Set ToolBar button style
d->ToolBar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
//Initialize Q/R widget
d->QueryRetrieveWidget = new ctkDICOMQueryRetrieveWidget();
d->QueryRetrieveWidget->setWindowModality ( Qt::ApplicationModal );
//initialize directory from settings, then listen for changes
QSettings settings;
if ( settings.value("DatabaseDirectory", "") == "" )
{
QString directory = QString("./ctkDICOM-Database");
settings.setValue("DatabaseDirectory", directory);
settings.sync();
}
QString databaseDirectory = settings.value("DatabaseDirectory").toString();
this->setDatabaseDirectory(databaseDirectory);
d->DirectoryButton->setDirectory(databaseDirectory);
connect(d->DirectoryButton, SIGNAL(directoryChanged(QString)), this, SLOT(setDatabaseDirectory(QString)));
//Initialize import widget
d->ImportDialog = new ctkFileDialog();
QCheckBox* importCheckbox = new QCheckBox("Copy on import", d->ImportDialog);
d->ImportDialog->setBottomWidget(importCheckbox);
d->ImportDialog->setFileMode(QFileDialog::Directory);
d->ImportDialog->setLabelText(QFileDialog::Accept,"Import");
d->ImportDialog->setWindowTitle("Import DICOM files from directory ...");
d->ImportDialog->setWindowModality(Qt::ApplicationModal);
//connect signal and slots
connect(d->TreeView, SIGNAL(clicked(QModelIndex)), d->ThumbnailsWidget, SLOT(onModelSelected(QModelIndex)));
connect(d->TreeView, SIGNAL(clicked(QModelIndex)), d->ImagePreview, SLOT(onModelSelected(QModelIndex)));
connect(d->TreeView, SIGNAL(clicked(QModelIndex)), this, SLOT(onModelSelected(QModelIndex)));
connect(d->ThumbnailsWidget, SIGNAL(selected(ctkThumbnailLabel)), this, SLOT(onThumbnailSelected(ctkThumbnailLabel)));
connect(d->ThumbnailsWidget, SIGNAL(doubleClicked(ctkThumbnailLabel)), this, SLOT(onThumbnailDoubleClicked(ctkThumbnailLabel)));
connect(d->ImportDialog, SIGNAL(fileSelected(QString)),this,SLOT(onImportDirectory(QString)));
connect(d->QueryRetrieveWidget, SIGNAL(canceled()), d->QueryRetrieveWidget, SLOT(hide()) );
connect(d->QueryRetrieveWidget, SIGNAL(canceled()), this, SLOT(onQueryRetrieveFinished()) );
connect(d->ImagePreview, SIGNAL(requestNextImage()), this, SLOT(onNextImage()));
connect(d->ImagePreview, SIGNAL(requestPreviousImage()), this, SLOT(onPreviousImage()));
connect(d->ImagePreview, SIGNAL(imageDisplayed(int,int)), this, SLOT(onImagePreviewDisplayed(int,int)));
connect(d->SearchOption, SIGNAL(parameterChanged()), this, SLOT(onSearchParameterChanged()));
connect(d->PlaySlider, SIGNAL(valueChanged(int)), d->ImagePreview, SLOT(displayImage(int)));
}
void WGraphicsRectItem::mouseMoveEvent(WGraphicsSceneMouseEvent* event)
{
WMatrix matrix = getRotateMatrix_1();
WWorldPointF pos = matrix.map(event->scenePos());
if (isSelected())
{
if (event->buttons() & Ws::LeftButton) //drag move
{
_dragging = true;
WWorldPointF lastPos = matrix.map(event->lastScenePos());
WWorldPointF dragPos = matrix.map(scene()->dragStartPos());
WWorldRectF r = boundingRect();
if (_select_flag != SF_ROTATE) //矩形不是在旋转
{
if (_select_flag != SF_CONTENT || isMovable()) //矩形不是整个被选中
{
const int (&f)[4] = ADJUST_TABLE[bit(_select_flag)];
WWorldPointF offsetFrom = lastPos - dragPos;
WWorldPointF offsetTo = pos - dragPos;
WWorldRectF rectFrom = data()->rect.adjusted(offsetFrom.x() * f[0], offsetFrom.y() * f[1], offsetFrom.x() * f[2], offsetFrom.y() * f[3]);
WWorldRectF rectTo = data()->rect.adjusted(offsetTo.x() * f[0], offsetTo.y() * f[1], offsetTo.x() * f[2], offsetTo.y() * f[3]);
scene()->update(expanded(rectFrom | rectTo | boundingRect()));
}
}
else //矩形在旋转
{
double radius = std::max(data()->rect.width() / 2, data()->rect.height() / 2);
WWorldPointF c = data()->rect.center();
scene()->update(WWorldRectF(c.x(), c.y(), 0.0, 0.0).adjusted(-radius, -radius, radius, radius));
}
}
else //update select flag (status transfer)
{
int old_flag = _select_flag;
if (!contains(pos)) //other status ---> none selected
{
_select_flag = SF_NONE;
}
else
{
unsigned i=0;
unsigned size = array_size(_cp);
for (; i<size; ++i)
{
if (distance(pos, _cp[i]) < CP_RADIUS) //detect wheter control point is selected
{
_select_flag = (1 << i); //control point _cp[i] is presently selected
break;
}
}
if (i == size)
{
_select_flag = (distance(_rotate_pt, pos) < CP_RADIUS) ? SF_ROTATE : SF_CONTENT;
}
}
if (_select_flag != old_flag) //select status changed
{
scene()->update(boundingRect());
event->widget()->setCursor(WCursor(getCursorShape(_select_flag)));
}
}
}
}
static QImage qwtExpandImage(const QImage &image,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
const QRectF &area, const QRectF &area2, const QRectF &paintRect,
const QwtInterval &xInterval, const QwtInterval &yInterval )
{
const QRectF strippedRect = qwtStripRect(paintRect, area2,
xMap, yMap, xInterval, yInterval);
const QSize sz = strippedRect.toRect().size();
const int w = image.width();
const int h = image.height();
const QRectF r = QwtScaleMap::transform(xMap, yMap, area).normalized();
const double pw = ( r.width() - 1) / w;
const double ph = ( r.height() - 1) / h;
double px0, py0;
if ( !xMap.isInverting() )
{
px0 = xMap.transform( area2.left() );
px0 = qRound( px0 );
px0 = px0 - xMap.transform( area.left() );
}
else
{
px0 = xMap.transform( area2.right() );
px0 = qRound( px0 );
px0 -= xMap.transform( area.right() );
px0 -= 1.0;
}
px0 += strippedRect.left() - paintRect.left();
if ( !yMap.isInverting() )
{
py0 = yMap.transform( area2.top() );
py0 = qRound( py0 );
py0 -= yMap.transform( area.top() );
}
else
{
py0 = yMap.transform( area2.bottom() );
py0 = qRound( py0 );
py0 -= yMap.transform( area.bottom() );
py0 -= 1.0;
}
py0 += strippedRect.top() - paintRect.top();
QImage expanded(sz, image.format());
switch( image.depth() )
{
case 32:
{
for ( int y1 = 0; y1 < h; y1++ )
{
int yy1;
if ( y1 == 0 )
{
yy1 = 0;
}
else
{
yy1 = qRound( y1 * ph - py0 );
if ( yy1 < 0 )
yy1 = 0;
}
int yy2;
if ( y1 == h - 1 )
{
yy2 = sz.height();
}
else
{
yy2 = qRound( ( y1 + 1 ) * ph - py0 );
if ( yy2 > sz.height() )
yy2 = sz.height();
}
const quint32 *line1 = (const quint32 *) image.scanLine( y1 );
for ( int x1 = 0; x1 < w; x1++ )
{
int xx1;
if ( x1 == 0 )
{
xx1 = 0;
}
else
{
xx1 = qRound( x1 * pw - px0 );
if ( xx1 < 0 )
xx1 = 0;
}
int xx2;
if ( x1 == w - 1 )
{
xx2 = sz.width();
}
else
{
xx2 = qRound( ( x1 + 1 ) * pw - px0 );
if ( xx2 > sz.width() )
xx2 = sz.width();
}
const quint32 rgb( line1[x1] );
for ( int y2 = yy1; y2 < yy2; y2++ )
{
quint32 *line2 = ( quint32 *) expanded.scanLine( y2 );
for ( int x2 = xx1; x2 < xx2; x2++ )
line2[x2] = rgb;
}
}
}
break;
}
case 8:
{
for ( int y1 = 0; y1 < h; y1++ )
{
int yy1;
if ( y1 == 0 )
{
yy1 = 0;
}
else
{
yy1 = qRound( y1 * ph - py0 );
if ( yy1 < 0 )
yy1 = 0;
}
int yy2;
if ( y1 == h - 1 )
{
yy2 = sz.height();
}
else
{
yy2 = qRound( ( y1 + 1 ) * ph - py0 );
if ( yy2 > sz.height() )
yy2 = sz.height();
}
const uchar *line1 = image.scanLine( y1 );
for ( int x1 = 0; x1 < w; x1++ )
{
int xx1;
if ( x1 == 0 )
{
xx1 = 0;
}
else
{
xx1 = qRound( x1 * pw - px0 );
if ( xx1 < 0 )
xx1 = 0;
}
int xx2;
if ( x1 == w - 1 )
{
xx2 = sz.width();
}
else
{
xx2 = qRound( ( x1 + 1 ) * pw - px0 );
if ( xx2 > sz.width() )
xx2 = sz.width();
}
for ( int y2 = yy1; y2 < yy2; y2++ )
{
uchar *line2 = expanded.scanLine( y2 );
memset( line2 + xx1, line1[x1], xx2 - xx1 );
}
}
}
break;
}
default:
expanded = image;
}
return expanded;
}
VCSliderProperties::VCSliderProperties(VCSlider* slider, Doc* doc)
: QDialog(slider)
, m_doc(doc)
{
Q_ASSERT(doc != NULL);
Q_ASSERT(slider != NULL);
m_slider = slider;
setupUi(this);
QAction* action = new QAction(this);
action->setShortcut(QKeySequence(QKeySequence::Close));
connect(action, SIGNAL(triggered(bool)), this, SLOT(reject()));
addAction(action);
/* Level page connections */
connect(m_levelLowLimitSpin, SIGNAL(valueChanged(int)),
this, SLOT(slotLevelLowSpinChanged(int)));
connect(m_levelHighLimitSpin, SIGNAL(valueChanged(int)),
this, SLOT(slotLevelHighSpinChanged(int)));
connect(m_levelCapabilityButton, SIGNAL(clicked()),
this, SLOT(slotLevelCapabilityClicked()));
connect(m_levelList, SIGNAL(itemClicked(QTreeWidgetItem*,int)),
this, SLOT(slotLevelListClicked(QTreeWidgetItem*)));
connect(m_levelAllButton, SIGNAL(clicked()),
this, SLOT(slotLevelAllClicked()));
connect(m_levelNoneButton, SIGNAL(clicked()),
this, SLOT(slotLevelNoneClicked()));
connect(m_levelInvertButton, SIGNAL(clicked()),
this, SLOT(slotLevelInvertClicked()));
connect(m_levelByGroupButton, SIGNAL(clicked()),
this, SLOT(slotLevelByGroupClicked()));
connect(m_switchToLevelModeButton, SIGNAL(clicked()),
this, SLOT(slotModeLevelClicked()));
/* Playback page connections */
connect(m_switchToPlaybackModeButton, SIGNAL(clicked()),
this, SLOT(slotModePlaybackClicked()));
connect(m_attachPlaybackFunctionButton, SIGNAL(clicked()),
this, SLOT(slotAttachPlaybackFunctionClicked()));
connect(m_detachPlaybackFunctionButton, SIGNAL(clicked()),
this, SLOT(slotDetachPlaybackFunctionClicked()));
/* Submaster page connections */
connect(m_switchToSubmasterModeButton, SIGNAL(clicked()),
this, SLOT(slotModeSubmasterClicked()));
/*********************************************************************
* General page
*********************************************************************/
/* Name */
m_nameEdit->setText(m_slider->caption());
/* Widget appearance */
if (m_slider->widgetStyle() == VCSlider::WKnob)
m_widgetKnobRadio->setChecked(true);
else
m_widgetSliderRadio->setChecked(true);
/* Slider mode */
m_sliderMode = m_slider->sliderMode();
switch (m_sliderMode)
{
default:
case VCSlider::Level:
slotModeLevelClicked();
break;
case VCSlider::Playback:
slotModePlaybackClicked();
break;
case VCSlider::Submaster:
slotModeSubmasterClicked();
break;
}
/* Slider movement (Qt understands inverted appearance vice versa) */
if (m_slider->invertedAppearance() == true)
m_sliderMovementInvertedRadio->setChecked(true);
else
m_sliderMovementNormalRadio->setChecked(true);
/* Value display style */
switch (m_slider->valueDisplayStyle())
{
default:
case VCSlider::ExactValue:
m_valueExactRadio->setChecked(true);
break;
case VCSlider::PercentageValue:
m_valuePercentageRadio->setChecked(true);
break;
}
/********************************************************************
* External input
********************************************************************/
m_inputSelWidget = new InputSelectionWidget(m_doc, this);
m_inputSelWidget->setKeyInputVisibility(false);
m_inputSelWidget->setInputSource(m_slider->inputSource());
m_inputSelWidget->setWidgetPage(m_slider->page());
m_inputSelWidget->show();
m_extControlLayout->addWidget(m_inputSelWidget);
/*********************************************************************
* Level page
*********************************************************************/
/* Level limit spins */
m_levelLowLimitSpin->setValue(m_slider->levelLowLimit());
m_levelHighLimitSpin->setValue(m_slider->levelHighLimit());
/* Tree widget contents */
levelUpdateFixtures();
levelUpdateChannelSelections();
connect(m_levelList, SIGNAL(expanded(QModelIndex)),
this, SLOT(slotItemExpanded()));
connect(m_levelList, SIGNAL(collapsed(QModelIndex)),
this, SLOT(slotItemExpanded()));
m_monitorValuesCheck->setChecked(m_slider->channelsMonitorEnabled());
/*********************************************************************
* Playback page
*********************************************************************/
/* Function */
m_playbackFunctionId = m_slider->playbackFunction();
updatePlaybackFunctionName();
}
void QLCFixtureEditor::init()
{
/* General page */
m_manufacturerEdit->setText(m_fixtureDef->manufacturer());
m_manufacturerEdit->setValidator(CAPS_VALIDATOR(this));
connect(m_manufacturerEdit, SIGNAL(textEdited(const QString&)),
this, SLOT(slotManufacturerTextEdited(const QString&)));
m_modelEdit->setText(m_fixtureDef->model());
m_modelEdit->setValidator(CAPS_VALIDATOR(this));
connect(m_modelEdit, SIGNAL(textEdited(const QString&)),
this, SLOT(slotModelTextEdited(const QString&)));
m_typeCombo->setCurrentIndex(m_typeCombo->findText(m_fixtureDef->type()));
connect(m_typeCombo, SIGNAL(activated(const QString&)),
this, SLOT(slotTypeActivated(const QString&)));
// Display author name or suggest current user name if there isn't one.
// When the def already has an author, disable the field to prevent modification.
m_authorEdit->setText(m_fixtureDef->author());
if (m_authorEdit->text().length() > 0)
{
// Temporarily allow editing author name since most definitions contain wrong name:
// m_authorEdit->setEnabled(false);
}
else
{
m_authorEdit->setText(QLCFile::currentUserName());
}
connect(m_authorEdit, SIGNAL(textEdited(const QString&)),
this, SLOT(slotAuthorTextEdited(const QString&)));
/* Channel page */
connect(m_addChannelButton, SIGNAL(clicked()),
this, SLOT(slotAddChannel()));
connect(m_removeChannelButton, SIGNAL(clicked()),
this, SLOT(slotRemoveChannel()));
connect(m_editChannelButton, SIGNAL(clicked()),
this, SLOT(slotEditChannel()));
connect(m_copyChannelButton, SIGNAL(clicked()),
this, SLOT(slotCopyChannel()));
connect(m_pasteChannelButton, SIGNAL(clicked()),
this, SLOT(slotPasteChannel()));
connect(m_expandChannelsButton, SIGNAL(clicked()),
this, SLOT(slotExpandChannels()));
connect(m_channelList, SIGNAL(currentItemChanged(QTreeWidgetItem*,
QTreeWidgetItem*)),
this, SLOT(slotChannelListSelectionChanged(QTreeWidgetItem*)));
connect(m_channelList, SIGNAL(customContextMenuRequested(const QPoint&)),
this, SLOT(slotChannelListContextMenuRequested()));
connect(m_channelList, SIGNAL(itemActivated(QTreeWidgetItem*,int)),
this, SLOT(slotEditChannel()));
connect(m_channelList, SIGNAL(expanded(QModelIndex)),
this, SLOT(slotChannelItemExpanded()));
m_channelList->setContextMenuPolicy(Qt::CustomContextMenu);
m_channelList->setIconSize(QSize(24, 24));
refreshChannelList();
/* Mode page */
connect(m_addModeButton, SIGNAL(clicked()),
this, SLOT(slotAddMode()));
connect(m_removeModeButton, SIGNAL(clicked()),
this, SLOT(slotRemoveMode()));
connect(m_editModeButton, SIGNAL(clicked()),
this, SLOT(slotEditMode()));
connect(m_cloneModeButton, SIGNAL(clicked()),
this, SLOT(slotCloneMode()));
connect(m_expandModesButton, SIGNAL(clicked()),
this, SLOT(slotExpandModes()));
connect(m_modeList, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)),
this, SLOT(slotModeListSelectionChanged(QTreeWidgetItem*)));
connect(m_modeList, SIGNAL(customContextMenuRequested(const QPoint&)),
this, SLOT(slotModeListContextMenuRequested()));
connect(m_modeList, SIGNAL(itemActivated(QTreeWidgetItem*,int)),
this, SLOT(slotEditMode()));
connect(m_modeList, SIGNAL(expanded(QModelIndex)),
this, SLOT(slotModeItemExpanded()));
m_modeList->setContextMenuPolicy(Qt::CustomContextMenu);
refreshModeList();
}
void BookmarkWidget::setup(bool showButtons)
{
regExp.setPatternSyntax(QRegExp::FixedString);
regExp.setCaseSensitivity(Qt::CaseInsensitive);
QLayout *vlayout = new QVBoxLayout(this);
vlayout->setMargin(4);
QLabel *label = new QLabel(tr("Filter:"), this);
vlayout->addWidget(label);
searchField = new QLineEdit(this);
vlayout->addWidget(searchField);
connect(searchField, SIGNAL(textChanged(QString)), this,
SLOT(filterChanged()));
treeView = new TreeView(this);
vlayout->addWidget(treeView);
#ifdef Q_OS_MAC
# define SYSTEM "mac"
#else
# define SYSTEM "win"
#endif
if (showButtons) {
QLayout *hlayout = new QHBoxLayout();
vlayout->addItem(hlayout);
hlayout->addItem(new QSpacerItem(40, 20, QSizePolicy::Expanding));
addButton = new QToolButton(this);
addButton->setText(tr("Add"));
addButton->setIcon(QIcon(QLatin1String(":/assistant-icons/addtab.png")));
addButton->setAutoRaise(true);
addButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
hlayout->addWidget(addButton);
connect(addButton, SIGNAL(clicked()), this, SIGNAL(addBookmark()));
removeButton = new QToolButton(this);
removeButton->setText(tr("Remove"));
removeButton->setIcon(QIcon(QLatin1String(":/assistant-icons/closetab.png")));
removeButton->setAutoRaise(true);
removeButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
hlayout->addWidget(removeButton);
connect(removeButton, SIGNAL(clicked()), this, SLOT(removeClicked()));
}
filterBookmarkModel = new QSortFilterProxyModel(this);
treeView->setModel(filterBookmarkModel);
treeView->setDragEnabled(true);
treeView->setAcceptDrops(true);
treeView->setAutoExpandDelay(1000);
treeView->setDropIndicatorShown(true);
treeView->header()->setVisible(false);
treeView->viewport()->installEventFilter(this);
treeView->setContextMenuPolicy(Qt::CustomContextMenu);
connect(treeView, SIGNAL(expanded(QModelIndex)), this,
SLOT(expand(QModelIndex)));
connect(treeView, SIGNAL(collapsed(QModelIndex)), this,
SLOT(expand(QModelIndex)));
connect(treeView, SIGNAL(activated(QModelIndex)), this,
SLOT(activated(QModelIndex)));
connect(treeView, SIGNAL(customContextMenuRequested(QPoint)),
this, SLOT(customContextMenuRequested(QPoint)));
filterBookmarkModel->setFilterKeyColumn(0);
filterBookmarkModel->setDynamicSortFilter(true);
filterBookmarkModel->setSourceModel(bookmarkManager->treeBookmarkModel());
expandItems();
}
// QTreeView
void expanded_(const QModelIndex& index) { expanded(index); }
TimeWidget::TimeWidget(JointModel *model, QWidget *parent) :
QWidget(parent),
ui(new Ui::TimeWidget),
m_model(model),
m_delegate(new JointDelegate(this)),
m_leftProxy(new JointProxyModel(model, this)),
m_rightProxy(new JointProxyModel(model, this))
{
ui->setupUi(this);
QTreeView *namesView = ui->namesView;
QTreeView *timeLineView = ui->timeLineView;
// Sync views
connect(namesView->verticalScrollBar(), SIGNAL(valueChanged(int)), timeLineView->verticalScrollBar(), SLOT(setValue(int)));
connect(timeLineView->verticalScrollBar(), SIGNAL(valueChanged(int)), namesView->verticalScrollBar(), SLOT(setValue(int)));
connect(namesView, SIGNAL(expanded(QModelIndex)), SLOT(onExpanded(QModelIndex)));
connect(namesView, SIGNAL(collapsed(QModelIndex)), SLOT(onCollapsed(QModelIndex)));
// Configure names view
m_leftProxy->showAnims(false);
namesView->setModel(m_leftProxy);
// namesView->setModel(model);
namesView->setItemDelegate(m_delegate);
namesView->setHeader(new JointHeaderView(false));
namesView->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
namesView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
// Configure time line view
JointHeaderView *header = new JointHeaderView(true);
m_rightProxy->showVisibleColumn(false);
m_rightProxy->showAnim(0);
timeLineView->setModel(m_rightProxy);
timeLineView->setItemDelegate(m_delegate);
timeLineView->setHeader(header);
timeLineView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
timeLineView->hideColumn(JointModel::NameColumn);
timeLineView->setAutoScroll(false);
timeLineView->setMouseTracking(true);
timeLineView->setItemsExpandable(false);
connect(timeLineView, SIGNAL(entered(QModelIndex)), SLOT(openEditor(QModelIndex)));
connect(model->animModel(), SIGNAL(rowsInserted(QModelIndex, int, int)), SLOT(resetEditor()));
connect(model->animModel(), SIGNAL(rowsRemoved(QModelIndex, int, int)), SLOT(resetEditor()));
connect(model->animModel(), SIGNAL(dataChanged(QModelIndex,QModelIndex)), SLOT(resetEditor()));
connect(m_delegate, SIGNAL(currentFrameChanged(int)), header, SLOT(setCurrentFrame(int)));
connect(header, SIGNAL(currentFrameChanged(int)), m_delegate, SLOT(setCurrentFrame(int)));
connect(header, SIGNAL(currentFrameChanged(int)), timeLineView->viewport(), SLOT(update()));
connect(header, SIGNAL(currentFrameChanged(int)), SIGNAL(currentFrameChanged(int)));
// Configure push buttons
connect(ui->frameCount, SIGNAL(pressed()), SLOT(showFrameCountDialog()));
connect(ui->fps, SIGNAL(pressed()), SLOT(showFpsDialog()));
// Initialize
setCurrentAnim(-1);
}
void WTreeNode::collapse()
{
if (expanded())
doCollapse();
}
void GLEZData::read(const string& fname) throw(ParserError) {
string expanded(GLEExpandEnvironmentVariables(fname));
validate_file_name(expanded, false);
TokenizerLanguage lang;
std::auto_ptr<Tokenizer> tokens;
std::vector<GLEBYTE> contents;
if (str_i_ends_with(expanded, ".gz")) {
if (GLEReadFileBinaryGZIP(expanded, &contents)) {
contents.push_back(0);
tokens.reset(new StringTokenizer((const char*)&contents[0], &lang));
} else {
g_throw_parser_error("can't open: '", expanded.c_str(), "'");
}
} else {
StreamTokenizer* streamTokens = new StreamTokenizer(&lang);
tokens.reset(streamTokens);
streamTokens->open_tokens(expanded.c_str());
}
lang.setSpaceTokens(" \t\r,");
lang.setSingleCharTokens("\n!");
// Read the header of the z file
GLERectangle* bounds = getBounds();
tokens->ensure_next_token("!");
while (tokens->has_more_tokens()) {
string& token = tokens->next_token();
if (token == "\n") {
break;
} else if (str_i_equals(token, "NX")) {
m_NX = tokens->next_integer();
} else if (str_i_equals(token, "NY")) {
m_NY = tokens->next_integer();
} else if (str_i_equals(token, "XMIN")) {
bounds->setXMin(tokens->next_double());
} else if (str_i_equals(token, "XMAX")) {
bounds->setXMax(tokens->next_double());
} else if (str_i_equals(token, "YMIN")) {
bounds->setYMin(tokens->next_double());
} else if (str_i_equals(token, "YMAX")) {
bounds->setYMax(tokens->next_double());
} else {
stringstream str;
str << "unknown .z header token '" << token << "'";
throw tokens->error(str.str());
}
}
lang.setLineCommentTokens("!");
lang.setSingleCharTokens("");
lang.setSpaceTokens(" \t\n\r,");
// Allocate data
if (m_NX == 0 || m_NY == 0) {
throw tokens->error("data file header should contain valid NX and NY parameters");
}
m_Data = new double[m_NX * m_NY];
for (int y = 0; y < m_NY; y++) {
for (int x = 0; x < m_NX; x++) {
double v = tokens->next_double();
if (v < m_ZMin) m_ZMin = v;
if (v > m_ZMax) m_ZMax = v;
m_Data[x + y * m_NX] = v;
}
}
}
ThunderPanel::ThunderPanel(QWidget *parent) :
QWidget(parent),
ui(new Ui::ThunderPanel),
my_quickViewMode(true),
my_filterModel(new QSortFilterProxyModel),
my_model(new QStandardItemModel),
my_contextMenu(new QMenu(this))
{
ui->setupUi(this);
ui->filterPanel->hide();
QAction *action = new QAction (QIcon(":/resources/images/movie.png"),
tr("Preview"), this);
connect (action, SIGNAL(triggered()), SLOT(slotPreviewThisTask()));
my_contextMenu->addAction(action);
action = new QAction (tr("Download"), this);
connect (action, SIGNAL(triggered()), SLOT(slotDownloadThisTask()));
my_contextMenu->addAction(action);
my_contextMenu->addSeparator();
action = new QAction (QIcon(":/resources/images/user-trash.png"),
tr("Remove selected tasks"), this);
connect (action, SIGNAL(triggered()), SLOT(slotRemoveTheseTasks()));
my_contextMenu->addAction(action);
my_contextMenu->addSeparator();
action = new QAction (tr("Copy download address"), this);
connect (action, SIGNAL(triggered()), SLOT(slotCopyDownloadAddress()));
my_contextMenu->addSeparator();
my_contextMenu->addAction(action);
action = new QAction (tr("Copy source address"), this);
connect (action, SIGNAL(triggered()), SLOT(slotCopySourceAddress()));
my_contextMenu->addAction(action);
action = new QAction (tr("Copy task name"), this);
connect (action, SIGNAL(triggered()), SLOT(slotCopyTaskName()));
my_contextMenu->addAction(action);
action = new QAction (tr("Copy as Aria2c"), this);
connect (action, SIGNAL(triggered()), SLOT(slotCopyAria2cScript()));
my_contextMenu->addAction(action);
my_contextMenu->addSeparator();
action = new QAction (tr("Collapse all"), this);
connect (action, SIGNAL(triggered()), ui->treeView, SLOT(collapseAll()));
my_contextMenu->addAction(action);
action = new QAction (tr("Expand all"), this);
connect (action, SIGNAL(triggered()), ui->treeView, SLOT(expandAll()));
my_contextMenu->addAction(action);
action = new QAction (tr("Resize Columns"), this);
connect (action, SIGNAL(triggered()), this, SLOT(slotResizeAllColumnsOfTreeView()));
my_contextMenu->addAction(action);
connect (ui->treeView, SIGNAL(customContextMenuRequested(QPoint)),
SLOT(slotShowContextMenu(QPoint)));
my_model->setHorizontalHeaderLabels(QStringList()
<< tr("Size")
<< tr("Name"));
my_filterModel->setSourceModel(my_model);
ui->treeView->setModel(my_model);
ui->treeView->resizeColumnToContents(0);
connect (ui->treeView, SIGNAL(expanded(QModelIndex)), SLOT(slotResizeFirstColumnOfTreeView()));
}
DispValue *DispValue::_update(DispValue *source,
bool& was_changed, bool& was_initialized)
{
if (source == this)
{
// We're updated from ourselves -- ignore it all.
// This happens when a cluster is updated from the values of
// the clustered dislays.
if (descendant_changed())
was_changed = true;
return this;
}
if (changed)
{
// Clear `changed' flag
changed = false;
was_changed = true;
}
if (source->enabled() != enabled())
{
myenabled = source->enabled();
was_changed = true;
// We don't set CHANGED to true since enabled/disabled changes
// are merely a change in the view, not a change in the data.
}
if (source->full_name() == full_name() && source->type() == type())
{
switch (type())
{
case Simple:
case Text:
case Pointer:
// Atomic values
if (_value != source->value())
{
_value = source->value();
changed = was_changed = true;
}
return this;
case Array:
// Array. Check for 1st element, too.
if (_have_index_base != source->_have_index_base &&
(_have_index_base && _index_base != source->_index_base))
break;
// FALL THROUGH
case Reference:
case Sequence:
// Numbered children. If size changed, we assume
// the whole has been changed.
if (nchildren() == source->nchildren())
{
for (int i = 0; i < nchildren(); i++)
{
// Update each child
_children[i] = child(i)->update(source->child(i),
was_changed,
was_initialized);
}
return this;
}
break;
case List:
case Struct:
{
// Named children. Check whether names are the same.
bool same_members = (nchildren() == source->nchildren());
for (int i = 0; same_members && i < nchildren(); i++)
{
if (child(i)->full_name() != source->child(i)->full_name())
same_members = false;
}
if (same_members)
{
// Update each child
for (int i = 0; i < nchildren(); i++)
{
_children[i] = child(i)->update(source->child(i),
was_changed,
was_initialized);
}
return this;
}
// Members have changed.
// Be sure to mark only those members that actually have changed
// (i.e. don't mark the entire struct and don't mark new members)
// We do so by creating a new list of children. `Old' children
// that still are reported get updated; `new' children are added.
DispValueArray new_children;
DispValueArray processed_children;
for (int j = 0; j < source->nchildren(); j++)
{
DispValue *c = 0;
for (int i = 0; c == 0 && i < nchildren(); i++)
{
bool processed = false;
for (int k = 0; k < processed_children.size(); k++)
{
if (child(i) == processed_children[k])
processed = true;
}
if (processed)
continue;
if (child(i)->full_name() == source->child(j)->full_name())
{
c = child(i)->update(source->child(j),
was_changed,
was_initialized);
processed_children += child(i);
}
}
if (c == 0)
{
// Child not found -- use source child instead
c = source->child(j)->link();
}
new_children += c;
}
_children = new_children;
was_changed = was_initialized = true;
return this;
}
case UnknownType:
assert(0);
abort();
}
}
// Type, name or structure have changed -- use SOURCE instead of original
DispValue *ret = source->link();
ret->changed = was_changed = was_initialized = true;
// Copy the basic settings
ret->myexpanded = expanded();
ret->dereference(dereferenced());
ret->set_orientation(orientation());
ret->set_member_names(member_names());
// Have new DispValue take over the plotter
if (ret->plotter() == 0)
{
ret->_plotter = plotter();
_plotter = 0;
}
unlink();
return ret;
}
