QList<QWidget*> DataProvider::toolboxPages() {
QList<QWidget*> l;
// ---------------- Info Table ---------------------------
QList<QString> keys = providerInformation.keys();
QTableWidget* table = new QTableWidget(keys.size(),2);
for (int i=0; i<keys.size(); i++) {
table->setItem(i, 0, new QTableWidgetItem(keys.at(i)));
table->setItem(i, 1, new QTableWidgetItem(providerInformation[keys.at(i)].toString()));
table->item(i,0)->setFlags(Qt::ItemIsEnabled);
table->item(i,1)->setFlags(Qt::ItemIsEnabled);
}
table->setObjectName("Info");
table->horizontalHeader()->setStretchLastSection(true);
table->verticalHeader()->setDefaultSectionSize(table->fontMetrics().lineSpacing()+5);
table->verticalHeader()->hide();
table->horizontalHeader()->hide();
l << table;
// ---------------------------------------------------------
return l;
}
MocapPlugin::MocapPlugin(QWidget *parent)
: rviz::Panel(parent) {
if (!ros::isInitialized()) {
int argc = 0;
char **argv = NULL;
ros::init(argc, argv, "MocapRvizPlugin",
ros::init_options::NoSigintHandler | ros::init_options::AnonymousName);
}
nh = new ros::NodeHandle;
spinner = new ros::AsyncSpinner(3);
camera_control_pub = nh->advertise<communication::CameraControl>("/mocap/camera_control", 100);
id_sub = nh->subscribe("/mocap/cameraID", 100, &MocapPlugin::updateId, this);
video_sub = nh->subscribe("/mocap/video", 1, &MocapPlugin::videoCB, this);
marker_position_sub = nh->subscribe("/mocap/marker_position", 100, &MocapPlugin::pipe2function, this);
rviz_marker_pub = nh->advertise<visualization_msgs::Marker>("/visualization_marker", 100);
pose_pub = nh->advertise<geometry_msgs::Pose>("/mocap/MarkerPose", 1);
// Create the main layout
QHBoxLayout *mainLayout = new QHBoxLayout;
// Create the frame to hold all the widgets
QFrame *mainFrame = new QFrame();
QVBoxLayout *frameLayout = new QVBoxLayout();
QComboBox *cameraIDs = new QComboBox();
cameraIDs->setObjectName("cameraIDs");
connect(cameraIDs, SIGNAL(currentIndexChanged(int)), this, SLOT(changeID(int)));
frameLayout->addWidget(cameraIDs);
QVBoxLayout *cameraStatusLayout = new QVBoxLayout();
LightWidget *mocapStatus = new LightWidget();
mocapStatus->setObjectName("mocapStatus");
cameraStatusLayout->addWidget(mocapStatus);
QSlider *slider = new QSlider(Qt::Horizontal, this);
connect(slider, SIGNAL(valueChanged(int)), this, SLOT(publishThreshold(int)));
slider->setTickInterval(1);
slider->setRange(0, 255);
slider->setSliderPosition(240);
frameLayout->addWidget(slider);
QTableWidget *table = new QTableWidget(3, 2);
table->setObjectName("table");
QTableWidgetItem *item0 = new QTableWidgetItem("marker visible");
QTableWidgetItem *item1 = new QTableWidgetItem("frames per second");
QTableWidgetItem *item2 = new QTableWidgetItem("reprojection error");
table->setItem(0, 0, item0);
table->setItem(1, 0, item1);
table->setItem(2, 0, item2);
cameraStatusLayout->addWidget(table);
frameLayout->addLayout(cameraStatusLayout);
QPushButton *initcameras = new QPushButton(tr("initialize cameras"));
initcameras->setObjectName("initwalkcontroller");
connect(initcameras, SIGNAL(clicked()), this, SLOT(initializeCameras()));
frameLayout->addWidget(initcameras);
QCheckBox *streamcamera = new QCheckBox(tr("stream camera"));
connect(streamcamera, SIGNAL(stateChanged(int)), this, SLOT(streamCamera(int)));
frameLayout->addWidget(streamcamera);
QLabel *camimage = new QLabel(tr("camimage"));
camimage->setObjectName("camimage");
frameLayout->addWidget(camimage);
// Add frameLayout to the frame
mainFrame->setLayout(frameLayout);
// Add the frame to the main layout
mainLayout->addWidget(mainFrame);
// Remove margins to reduce space
frameLayout->setContentsMargins(0, 0, 0, 0);
mainLayout->setContentsMargins(0, 0, 0, 0);
this->setLayout(mainLayout);
}
QWidget* WidgetStyle::createWidget(const QString& name)
{
if(name == "CheckBox")
{
QCheckBox* box = new QCheckBox("CheckBox");
box->setObjectName("CheckBox");
return setLayoutWidget({ box }, { 100, 30 });
}
else if(name == "ComboBox")
{
QComboBox* box = new QComboBox;
box->addItem("Item1");
box->addItem("Item3");
box->addItem("Item3");
box->setObjectName("ComboBox");
return setLayoutWidget({ box }, { 70, 30 });
}
else if(name == "DateEdit")
{
QDateEdit* date = new QDateEdit;
date->setObjectName("DateEdit");
return setLayoutWidget({ date }, { 110, 40 });
}
else if(name == "DateTimeEdit")
{
QDateTimeEdit* date = new QDateTimeEdit;
date->setObjectName("DateTimeEdit");
return setLayoutWidget({ date }, { 160, 30 });
}
else if(name == "Dialog")
{
QDialog* dialog = new QDialog;
dialog->setObjectName("Dialog");
return setLayoutWidget({ dialog }, { 160, 110 });
}
else if(name == "DockWidget") //?
{
QDockWidget* widget = new QDockWidget;
widget->setObjectName("DockWidget");
widget->resize(61, 22);
return widget;
}
else if(name == "DoubleSpinBox")
{
QDoubleSpinBox* box = new QDoubleSpinBox;
box->setObjectName("DoubleSpinBox");
return setLayoutWidget({ box }, { 90, 40 });
}
else if(name == "Frame") //??
{
QFrame* frame = new QFrame;
frame->setObjectName("Frame");
frame->resize(150, 100);
return frame;
}
else if(name == "GroupBox")
{
QGroupBox* box = new QGroupBox("GroupBox");
box->setObjectName("GroupBox");
return setLayoutWidget({ box }, { 160, 110 });
}
else if(name == "Label")
{
QLabel* label = new QLabel("Label");
label->setObjectName("Label");
return setLayoutWidget({ label }, { 40, 20});
}
else if(name == "LineEdit")
{
QLineEdit* line = new QLineEdit;
line->setObjectName("LineEdit");
return setLayoutWidget({ line }, { 30, 30 });
}
else if(name == "ListView") //??
{
QListView* view = new QListView;
view->setObjectName("ListView");
view->resize(71, 71);
return view;
}
else if(name == "ListWidget")
{
QListWidget* list = new QListWidget;
list->setObjectName("ListWidget");
for(int i = 0; i < 20; i++)
list->addItem(QString("Item %1").arg(i));
return setLayoutWidget({ list }, { 80, 80 });
}
else if(name == "MainWindow")
{
QMainWindow* window = new QMainWindow;
window->setObjectName("MainWindow");
return setLayoutWidget({ window }, { 160, 110 });
}
else if(name == "Menu")
{
QMenu* parentMenu = new QMenu;
parentMenu->setObjectName("Menu");
parentMenu->addMenu("Menu1");
QMenu* menu1 = parentMenu->addMenu("Menu2");
menu1->addMenu("Menu1");
menu1->addMenu("Menu2");
parentMenu->addSeparator();
parentMenu->addMenu("Menu3");
return setLayoutWidget({ parentMenu }, { 160, 110 });
}
else if(name == "MenuBar")
{
QMenuBar* bar = new QMenuBar;
bar->setObjectName("QMenuBar");
QMenu* menu1 = bar->addMenu("MenuBar1");
menu1->addMenu("Menu1");
menu1->addSeparator();
menu1->addMenu("Menu2");
QMenu* menu2 = bar->addMenu("MenuBar2");
menu2->addMenu("Menu1");
menu2->addSeparator();
menu2->addMenu("Menu2");
QMenu* menu3 = bar->addMenu("MenuBar3");
menu3->addMenu("Menu1");
menu3->addSeparator();
menu3->addMenu("Menu2");
return setLayoutWidget({ bar }, { 280, 60 });
}
else if(name == "ProgressBar")
{
QProgressBar* bar = new QProgressBar;
bar->setObjectName("ProgressBar");
bar->setRange(0, 100);
bar->setValue(0);
QTimer* timer = new QTimer(bar);
this->connect(timer, &QTimer::timeout, this, [bar]()
{
if(bar->value() == 100)
bar->setValue(0);
else
bar->setValue(bar->value() + 1);
});
timer->start(100);
return setLayoutWidget({ bar }, { 110, 30 });
}
else if(name == "PushButton")
{
QPushButton* button = new QPushButton("PushButton");
button->setObjectName("PushButton");
return setLayoutWidget({ button }, { 125, 30 });
}
else if(name == "RadioButton")
{
QRadioButton* button = new QRadioButton("RadioButton");
button->setObjectName("RadioButton");
return setLayoutWidget({ button }, { 125, 30 });
}
else if(name == "ScrollBar")
{
QScrollBar* barH = new QScrollBar(Qt::Horizontal);
QScrollBar* barV = new QScrollBar(Qt::Vertical);
barH->setObjectName("ScrollBarH");
barV->setObjectName("ScrollBarV");
return setLayoutWidget({ barH, barV }, { 200, 100 });
}
else if(name == "Slider")
{
QSlider* sliderH = new QSlider(Qt::Horizontal);
QSlider* sliderV = new QSlider(Qt::Vertical);
sliderH->setObjectName("SliderH");
sliderV->setObjectName("SliderV");
return setLayoutWidget({ sliderH, sliderV }, { 200, 100 });
}
else if(name == "SpinBox")
{
QSpinBox* spinBox = new QSpinBox;
spinBox->setObjectName("SpinBox");
return setLayoutWidget({ spinBox }, { 60, 35 });
}
else if(name == "Splitter")
{
QSplitter* splitterV = new QSplitter(Qt::Vertical);
QSplitter* splitterH = new QSplitter(Qt::Horizontal);
splitterV->setObjectName("SplitterV");
splitterH->setObjectName("SplitterH");
splitterV->addWidget(new QPushButton("PushButton1"));
splitterV->addWidget(new QPushButton("PushButton2"));
splitterH->addWidget(splitterV);
splitterH->addWidget(new QPushButton("PushButton3"));
return setLayoutWidget({ splitterH }, { 250, 110 });
}
else if(name == "TabWidget")
{
QTabWidget* tab = new QTabWidget;
tab->addTab(new QWidget, "Widget1");
tab->addTab(new QWidget, "Widget2");
tab->addTab(new QWidget, "Widget3");
tab->setObjectName("TabWidget");
return setLayoutWidget({ tab }, { 210, 110 });
}
else if(name == "TableView") //?
{
QTableView* view = new QTableView;
view->setObjectName("TableView");
view->resize(200, 100);
return view;
}
else if(name == "TableWidget")
{
const int n = 100;
QStringList list = { "one", "two", "three" };
QTableWidget* table = new QTableWidget(n, n);
table->setObjectName("TableWidget");
table->setHorizontalHeaderLabels(list);
table->setVerticalHeaderLabels(list);
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
table->setItem(i, j, new QTableWidgetItem(QString("%1, %2").arg(i).arg(j)));
return setLayoutWidget({ table }, { 210, 110 });
}
else if(name == "TextEdit")
{
QTextEdit* text = new QTextEdit;
text->setObjectName("TextEdit");
return setLayoutWidget({ text }, { 80, 80 });
}
else if(name == "TimeEdit")
{
QTimeEdit* time = new QTimeEdit;
time->setObjectName("TimeEdit");
return setLayoutWidget({ time }, { 80, 80 });
}
else if(name == "ToolButton")
{
QToolButton* button = new QToolButton;
button->setText("ToolButton");
button->setObjectName("ToolButton");
return setLayoutWidget({ button }, { 95, 25 });
}
else if(name == "ToolBox")
{
QToolBox* box = new QToolBox;
box->addItem(new QWidget, "Widget1");
box->addItem(new QWidget, "Widget2");
box->addItem(new QWidget, "Widget3");
box->setObjectName("ToolBox");
return setLayoutWidget({ box }, { 110, 180 });
}
else if(name == "TreeView") //?
{
QTreeView* tree = new QTreeView;
tree->setObjectName("TreeView");
tree->resize(200, 100);
return tree;
}
else if(name == "TreeWidget")
{
QTreeWidget* tree = new QTreeWidget;
tree->setObjectName("TreeWidget");
tree->setHeaderLabels({ "Folders", "Used Space" });
QTreeWidgetItem* item = new QTreeWidgetItem(tree);
item->setText(0, "Local Disk");
for(int i = 1; i < 20; i++)
{
QTreeWidgetItem* dir = new QTreeWidgetItem(item);
dir->setText(0, "Directory" + QString::number(i));
dir->setText(1, QString::number(i) + "MB");
}
tree->setItemExpanded(item, true);
return setLayoutWidget({ tree }, { 210, 110 });
}
else if(name == "Widget")
{
QWidget* widget = new QWidget;
widget->setObjectName("Widget");
return setLayoutWidget({ widget }, { 210, 110 });
}
return nullptr;
}
void model_import_dlg::create_mesh_tab(QTabWidget * parent, size_t index, render::lod lod)
{
QWidget * tab = new QWidget(parent);
tab->setObjectName("meshTab");
auto & geometry = conv.get(index).geometry.at(lod);
auto & material = conv.get(index).materials.at(lod);
QGroupBox * geometry_box = new QGroupBox(tab);
geometry_box->setGeometry(10, 10, 561, 115);
geometry_box->setTitle("Geometry");
QLabel * vertices = new QLabel(geometry_box);
vertices->setGeometry(20, 20, 200, 20);
vertices->setText("Vertices: " + QString::number(geometry.vertex_count));
QLabel * faces = new QLabel(geometry_box);
faces->setGeometry(20, 40, 200, 20);
faces->setText("Faces: " + QString::number(geometry.index_count / 3));
QLabel * indices = new QLabel(geometry_box);
indices->setGeometry(20, 60, 200, 20);
indices->setText("Indices: " + QString::number(geometry.index_count));
QLabel * layout = new QLabel(geometry_box);
layout->setGeometry(20, 80, 200, 20);
layout->setText("Layout: " + QString::fromStdString(render::vertex::str(geometry.vertex_type)));
QGroupBox * material_box = new QGroupBox(tab);
material_box->setGeometry(10, 130, 561, 400);
material_box->setTitle("Material");
QGroupBox * colors_box = new QGroupBox(material_box);
colors_box->setGeometry(15, 20, 455, 134);
colors_box->setTitle("Colors");
QTableWidget * colorsTable = new QTableWidget(colors_box);
colorsTable->setGeometry(15, 25, 237, 92);
colorsTable->setObjectName("colorsTable");
colorsTable->setRowCount(3);
colorsTable->setColumnCount(3);
colorsTable->setFrameShape(QFrame::NoFrame);
colorsTable->setShowGrid(false);
colorsTable->setSelectionBehavior(QAbstractItemView::SelectionBehavior::SelectRows);
colorsTable->setEditTriggers(QAbstractItemView::DoubleClicked);
colorsTable->horizontalHeader()->setDefaultSectionSize(60);
colorsTable->verticalHeader()->setDefaultSectionSize(23);
colorsTable->setSelectionMode(QAbstractItemView::SelectionMode::SingleSelection);
QStringList color_types;
color_types.append("Ambient");
color_types.append("Diffuse");
color_types.append("Specular");
QStringList color_channels;
color_channels.append("R");
color_channels.append("G");
color_channels.append("B");
colorsTable->setVerticalHeaderLabels(color_types);
colorsTable->setHorizontalHeaderLabels(color_channels);
colorsTable->setItem(0, 0, new QTableWidgetItem(QString::number(rgb_to_byte(material.ambient.x))));
colorsTable->setItem(0, 1, new QTableWidgetItem(QString::number(rgb_to_byte(material.ambient.y))));
colorsTable->setItem(0, 2, new QTableWidgetItem(QString::number(rgb_to_byte(material.ambient.z))));
colorsTable->setItem(1, 0, new QTableWidgetItem(QString::number(rgb_to_byte(material.diffuse.x))));
colorsTable->setItem(1, 1, new QTableWidgetItem(QString::number(rgb_to_byte(material.diffuse.y))));
colorsTable->setItem(1, 2, new QTableWidgetItem(QString::number(rgb_to_byte(material.diffuse.z))));
colorsTable->setItem(2, 0, new QTableWidgetItem(QString::number(rgb_to_byte(material.specular.x))));
colorsTable->setItem(2, 1, new QTableWidgetItem(QString::number(rgb_to_byte(material.specular.y))));
colorsTable->setItem(2, 2, new QTableWidgetItem(QString::number(rgb_to_byte(material.specular.z))));
QPushButton * colorPick = new QPushButton(colors_box);
colorPick->setGeometry(290, 24, 75, 23);
colorPick->setObjectName("colorPick");
colorPick->setText("Pick");
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
colorsTable->item(i, j)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
QObject::connect(colorsTable, SIGNAL(itemSelectionChanged()), this, SLOT(on_color_table_changed()));
QObject::connect(colorPick, SIGNAL(pressed()), this, SLOT(on_color_pick()));
QLabel * spec_power = new QLabel(colors_box);
spec_power->setGeometry(290, 89, 80, 23);
spec_power->setText("Specular power: ");
QDoubleSpinBox * spec_power_box = new QDoubleSpinBox(colors_box);
spec_power_box->setObjectName("specularSpinBox");
spec_power_box->setDecimals(2);
spec_power_box->setSingleStep(0.05);
spec_power_box->setFrame(false);
spec_power_box->setGeometry(390, 89, 50, 23);
spec_power_box->setValue(material.specular_power);
QGroupBox * textures_box = new QGroupBox(material_box);
textures_box->setGeometry(15, 159, 531, 225);
textures_box->setTitle("Textures");
QTableWidget * texturesTable = new QTableWidget(textures_box);
texturesTable->setObjectName("texturesTable");
texturesTable->setGeometry(15, 25, 500, 150);
texturesTable->setRowCount(material.textures.size());
texturesTable->setColumnCount(2);
texturesTable->setFrameShape(QFrame::NoFrame);
texturesTable->setShowGrid(false);
texturesTable->setSelectionBehavior(QAbstractItemView::SelectionBehavior::SelectRows);
texturesTable->setEditTriggers(QAbstractItemView::DoubleClicked);
texturesTable->horizontalHeader()->setDefaultSectionSize(60);
texturesTable->verticalHeader()->setDefaultSectionSize(23);
texturesTable->verticalHeader()->setVisible(false);
QStringList texture_headers;
texture_headers.append("File");
texture_headers.append("Type");
texturesTable->setHorizontalHeaderLabels(texture_headers);
int i = 0;
assimp::texture_type_map texture_map;
for (auto texture : material.textures)
{
texturesTable->setItem(i, 0, new QTableWidgetItem(QString::fromStdString(texture.second.texture_path.generic_string())));
texturesTable->setItem(i, 1, new QTableWidgetItem(QString::fromStdString(texture_map.get(texture.first))));
texturesTable->setColumnWidth(0, 350);
texturesTable->setColumnWidth(1, 150);
i++;
}
for (i = 0; i < texturesTable->rowCount(); i++)
for (int j = 0; j < texturesTable->columnCount(); j++)
texturesTable->item(i, j)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
QPushButton * add_texture = new QPushButton(textures_box);
add_texture->setGeometry(15, 185, 75, 23);
add_texture->setText("Add");
QPushButton * edit_texture = new QPushButton(textures_box);
edit_texture->setGeometry(100, 185, 75, 23);
edit_texture->setObjectName("textureEditButton");
edit_texture->setText("Edit");
edit_texture->setEnabled(false);
QPushButton * delete_texture = new QPushButton(textures_box);
delete_texture->setGeometry(185, 185, 75, 23);
delete_texture->setObjectName("textureDeleteButton");
delete_texture->setText("Delete");
delete_texture->setEnabled(false);
QObject::connect(texturesTable, SIGNAL(itemSelectionChanged()), this, SLOT(on_texture_table_changed()));
QObject::connect(add_texture, SIGNAL(pressed()), this, SLOT(on_texture_add()));
QObject::connect(edit_texture, SIGNAL(pressed()), this, SLOT(on_texture_edit()));
QObject::connect(delete_texture, SIGNAL(pressed()), this, SLOT(on_texture_delete()));
QString title = "Mesh " + QString::number(index);
parent->addTab(tab, title);
}
DocumentMetaConfigurationPage::DocumentMetaConfigurationPage(RosegardenDocument *doc,
QWidget *parent) :
TabbedConfigurationPage(doc, parent)
{
m_headersPage = new HeadersConfigurationPage(this, doc);
addTab(m_headersPage, tr("Headers"));
Composition &comp = doc->getComposition();
std::set
<TrackId> usedTracks;
int audioSegments = 0, internalSegments = 0;
for (Composition::iterator ci = comp.begin();
ci != comp.end(); ++ci) {
usedTracks.insert((*ci)->getTrack());
if ((*ci)->getType() == Segment::Audio)
++audioSegments;
else
++internalSegments;
}
QFrame *frame = new QFrame(m_tabWidget);
frame->setContentsMargins(10, 10, 10, 10);
QGridLayout *layout = new QGridLayout(frame);
layout->setSpacing(5);
layout->addWidget(new QLabel(tr("Filename:"), frame), 0, 0);
layout->addWidget(new QLabel(doc->getTitle(), frame), 0, 1);
layout->addWidget(new QLabel(tr("Formal duration (to end marker):"), frame), 1, 0);
timeT d = comp.getEndMarker();
RealTime rtd = comp.getElapsedRealTime(d);
layout->addWidget(new QLabel(durationToString(comp, 0, d, rtd), frame), 1, 1);
layout->addWidget(new QLabel(tr("Playing duration:"), frame), 2, 0);
d = comp.getDuration();
rtd = comp.getElapsedRealTime(d);
layout->addWidget(new QLabel(durationToString(comp, 0, d, rtd), frame), 2, 1);
layout->addWidget(new QLabel(tr("Tracks:"), frame), 3, 0);
layout->addWidget(new QLabel(tr("%1 used, %2 total")
.arg(usedTracks.size())
.arg(comp.getNbTracks()),
frame), 3, 1);
layout->addWidget(new QLabel(tr("Segments:"), frame), 4, 0);
layout->addWidget(new QLabel(tr("%1 MIDI, %2 audio, %3 total")
.arg(internalSegments)
.arg(audioSegments)
.arg(internalSegments + audioSegments),
frame), 4, 1);
layout->setRowStretch(5, 2);
addTab(frame, tr("Statistics"));
frame = new QFrame(m_tabWidget);
frame->setContentsMargins(10, 10, 10, 10);
layout = new QGridLayout(frame);
layout->setSpacing(5);
QTableWidget *table = new QTableWidget(1, 11, frame); // , "Segment Table"
table->setObjectName("StyledTable");
table->setAlternatingRowColors(true);
//table->setSelectionMode(QTableWidget::NoSelection);
table->setSelectionBehavior( QAbstractItemView::SelectRows );
table->setSelectionMode( QAbstractItemView::SingleSelection );
table->setSortingEnabled(true);
table->setHorizontalHeaderItem( 0, new QTableWidgetItem( tr("Type"))); // p1=column
table->setHorizontalHeaderItem( 1, new QTableWidgetItem( tr("Track")));
table->setHorizontalHeaderItem( 2, new QTableWidgetItem( tr("Label")));
table->setHorizontalHeaderItem( 3, new QTableWidgetItem( tr("Time")));
table->setHorizontalHeaderItem( 4, new QTableWidgetItem( tr("Duration")));
table->setHorizontalHeaderItem( 5, new QTableWidgetItem( tr("Events")));
table->setHorizontalHeaderItem( 6, new QTableWidgetItem( tr("Polyphony")));
table->setHorizontalHeaderItem( 7, new QTableWidgetItem( tr("Repeat")));
table->setHorizontalHeaderItem( 8, new QTableWidgetItem( tr("Quantize")));
table->setHorizontalHeaderItem( 9, new QTableWidgetItem( tr("Transpose")));
table->setHorizontalHeaderItem( 10, new QTableWidgetItem( tr("Delay")));
//table->setNumRows(audioSegments + internalSegments);
table->setRowCount(audioSegments + internalSegments);
table->setColumnWidth(0, 50);
table->setColumnWidth(1, 50);
table->setColumnWidth(2, 150);
table->setColumnWidth(3, 80);
table->setColumnWidth(4, 80);
table->setColumnWidth(5, 80);
table->setColumnWidth(6, 80);
table->setColumnWidth(7, 80);
table->setColumnWidth(8, 80);
table->setColumnWidth(9, 80);
table->setColumnWidth(10, 80);
int i = 0;
for (Composition::iterator ci = comp.begin();
ci != comp.end(); ++ci) {
Segment *s = *ci;
table->setItem(i, 0, new SegmentDataItem
(table,
s->getType() == Segment::Audio ?
tr("Audio") : tr("MIDI")));
table->setItem(i, 1, new SegmentDataItem
(table,
QString("%1").arg(s->getTrack() + 1)));
QPixmap colourPixmap(16, 16);
Colour colour =
comp.getSegmentColourMap().getColourByIndex(s->getColourIndex());
colourPixmap.fill(GUIPalette::convertColour(colour));
table->setItem(i, 2,
new QTableWidgetItem( colourPixmap, strtoqstr(s->getLabel())) );
// new QTableWidgetItem(table, QTableWidgetItem::Never,
// strtoqstr(s->getLabel()),
// colourPixmap));
table->setItem(i, 3, new SegmentDataItem
(table,
QString("%1").arg(s->getStartTime())));
table->setItem(i, 4, new SegmentDataItem
(table,
QString("%1").arg(s->getEndMarkerTime() -
s->getStartTime())));
std::set<long> notesOn;
std::multimap<timeT, long> noteOffs;
int events = 0, notes = 0, poly = 0, maxPoly = 0;
for (Segment::iterator si = s->begin();
s->isBeforeEndMarker(si); ++si) {
++events;
if ((*si)->isa(Note::EventType)) {
++notes;
timeT startTime = (*si)->getAbsoluteTime();
timeT endTime = startTime + (*si)->getDuration();
if (endTime == startTime) continue;
while (!noteOffs.empty() &&
(startTime >= noteOffs.begin()->first)) {
notesOn.erase(noteOffs.begin()->second);
noteOffs.erase(noteOffs.begin());
}
long pitch = 0;
(*si)->get<Int>(BaseProperties::PITCH, pitch);
notesOn.insert(pitch);
noteOffs.insert(std::multimap<timeT, long>::value_type(endTime, pitch));
poly = notesOn.size();
if (poly > maxPoly) maxPoly = poly;
}
}
table->setItem(i, 5, new SegmentDataItem
(table,
QString("%1").arg(events)));
table->setItem(i, 6, new SegmentDataItem
(table,
QString("%1").arg(maxPoly)));
table->setItem(i, 7, new SegmentDataItem
(table,
s->isRepeating() ? tr("Yes") : tr("No")));
timeT discard;
if (s->getQuantizer() && s->hasQuantization()) {
timeT unit = s->getQuantizer()->getUnit();
table->setItem(i, 8, new SegmentDataItem
(table,
NotationStrings::makeNoteMenuLabel
(unit, true, discard, false)));
} else {
table->setItem(i, 8, new SegmentDataItem
(table,
tr("Off")));
}
table->setItem(i, 9, new SegmentDataItem
(table,
QString("%1").arg(s->getTranspose())));
if (s->getDelay() != 0) {
if (s->getRealTimeDelay() != RealTime::zeroTime) {
table->setItem(i, 10, new SegmentDataItem
(table,
QString("%1 + %2 ms")
.arg(NotationStrings::makeNoteMenuLabel
(s->getDelay(), true, discard, false))
.arg(s->getRealTimeDelay().sec * 1000 +
s->getRealTimeDelay().msec())));
} else {
table->setItem(i, 10, new SegmentDataItem
(table,
NotationStrings::makeNoteMenuLabel
(s->getDelay(), true, discard, false)));
}
} else if (s->getRealTimeDelay() != RealTime::zeroTime) {
table->setItem(i, 10, new SegmentDataItem
(table,
QString("%2 ms")
.arg(s->getRealTimeDelay().sec * 1000 +
s->getRealTimeDelay().msec())));
} else {
table->setItem(i, 10, new SegmentDataItem
(table,
tr("None")));
}
++i;
}
layout->addWidget(table, 0, 0);
addTab(frame, tr("Segment Summary"));
}