void
on_treeview0_row_deleted(GtkTreeModel *treemodel, GtkTreePath *arg1, gpointer user_data)
{
GtkTreeIter iter;
VF_FILTERS tag;
CONFcouple *conf = 0;
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(stores[0]), &iter);
AVDMGenericVideoStream *prevfilter = videofilters[0].filter;
for (uint32_t i = 1; i < nb_active_filter; i++)
{
gtk_tree_model_get (GTK_TREE_MODEL(stores[0]), &iter,
1, &tag,
2, &conf,
-1);
delete videofilters[i].filter;
videofilters[i].filter = filterCreateFromTag(tag,
conf,
prevfilter);
videofilters[i].conf = conf;
videofilters[i].tag = tag;
prevfilter = videofilters[i].filter;
gtk_tree_model_iter_next (GTK_TREE_MODEL(stores[0]), &iter);
}
updateFilterList();
//on_action(A_REORDERED);
}
void FilterEdit::bNewPressed()
{
CalFilter *newFilter = new CalFilter(i18n("New Filter %1").arg(mFilters->count()));
mFilters->append(newFilter);
updateFilterList();
mRulesList->setSelected(mRulesList->count() - 1, true);
emit filterChanged();
}
//most of the work is handled elsewhere. Need only to update the # of frames
//and maybe auto scroll
void MainWindow::gotFrames(int FPS, int framesSinceLastUpdate)
{
ui->lbNumFrames->setText(QString::number(model->rowCount()));
if (ui->cbAutoScroll->isChecked()) ui->canFramesView->scrollToBottom();
ui->lbFPS->setText(QString::number(FPS));
if (framesSinceLastUpdate > 0)
{
bDirty = true;
emit framesUpdated(framesSinceLastUpdate); //anyone care that frames were updated?
}
if (model->needsFilterRefresh()) updateFilterList();
}
FilterEditDialog::FilterEditDialog(QPtrList<CalFilter> *filters,
QWidget *parent, const char *name)
: KDialogBase(parent, name, false, i18n("Edit Calendar Filters"),
Ok | Apply | Cancel)
{
setMainWidget(mFilterEdit = new FilterEdit(filters, this));
connect(mFilterEdit, SIGNAL(dataConsistent(bool)),
SLOT(setDialogConsistent(bool)));
updateFilterList();
connect(mFilterEdit, SIGNAL(editCategories()), SIGNAL(editCategories()));
connect(mFilterEdit, SIGNAL(filterChanged()), SIGNAL(filterChanged()));
}
void FilterEdit::bDeletePressed()
{
if(mRulesList->currentItem() < 0) return; // nothing selected
if(mFilters->count() <= 1) return; // We need at least a default filter object.
int result = KMessageBox::warningContinueCancel(this,
i18n("This item will be permanently deleted."), i18n("Delete Confirmation"), KGuiItem(i18n("Delete"), "editdelete"));
if(result != KMessageBox::Continue)
return;
unsigned int selected = mRulesList->currentItem();
mFilters->remove(selected);
current = 0L;
updateFilterList();
mRulesList->setSelected(QMIN(mRulesList->count() - 1, selected), true);
emit filterChanged();
}
// Open the main filter dialog and call the handlers
// if needed.
int
GUI_handleVFilter (void)
{
getLastVideoFilter (); // expand video to full size
// sanity check
if (nb_active_filter == 0)
{
nb_active_filter = 1;
videofilters[0].filter =
new AVDMVideoStreamNull (video_body, frameStart,
frameEnd - frameStart);
}
dialog = createFilterDialog();
GdkWMDecoration decorations=(GdkWMDecoration)0;
gtk_widget_realize(dialog);
gdk_window_set_decorations(dialog->window, (GdkWMDecoration)(GDK_DECOR_ALL | GDK_DECOR_MINIMIZE));
GdkScreen* screen = gdk_screen_get_default();
gint width = gdk_screen_get_width(screen);
if(width>=1024)
gtk_window_set_default_size(GTK_WINDOW(dialog), 900, 600);
updateFilterList ();
gtk_register_dialog (dialog);
//gtk_widget_show (dialog);
int r;
while(1)
{
r=gtk_dialog_run(GTK_DIALOG(dialog));
if(r>A_BEGIN && r<A_END)
{
on_action((gui_act)r);
}
else break;
};
gtk_unregister_dialog (dialog);
gtk_widget_destroy(dialog);
dialog=NULL;
return 1;
}
//
// One of the button of the main dialog was pressed
// Retrieve also the associated filter and handle
// the action
//______________________________________________________
void on_action (gui_act action)
{
uint32_t action_parameter;
VF_FILTERS tag = VF_INVALID;
action_parameter = 0;
if (nb_active_filter > 1)
if (getSelectionNumber(nb_active_filter - 1,
WID(treeview0),
stores[0],
&action_parameter))
action_parameter++;
switch (action)
{
case A_ADD:
tag = getFilterFromSelection();
if (tag == VF_INVALID) break;
CONFcouple *coup;
videofilters[nb_active_filter].filter =
filterCreateFromTag (tag, NULL, videofilters[nb_active_filter - 1].filter);
videofilters[nb_active_filter].tag = tag;
if(!videofilters[nb_active_filter].filter->
configure (videofilters[nb_active_filter - 1].filter))
{
delete videofilters[nb_active_filter].filter;
break;
}
videofilters[nb_active_filter].filter->getCoupledConf (&coup);
videofilters[nb_active_filter].conf = coup;
nb_active_filter++;
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
break;
case A_VCD:
setVCD ();
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
break;
case A_SVCD:
setSVCD ();
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
break;
case A_DVD:
setDVD ();
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
break;
case A_HALFD1:
setHalfD1 ();
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
break;
default:
case A_DOUBLECLICK:
printf ("Double clicked..");
case A_CONFIGURE:
if(!action_parameter) break;
if(!videofilters[action_parameter].filter->
configure (videofilters[action_parameter - 1].filter)) break;
CONFcouple *couple;
videofilters[action_parameter].filter->getCoupledConf (&couple);
videofilters[action_parameter].conf = couple;
getFirstVideoFilter ();
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], action_parameter-1);
break;
case A_PARTIAL:
if (!action_parameter) break;
AVDMGenericVideoStream *replace;
CONFcouple *conf;
conf = videofilters[action_parameter].conf;
if (videofilters[action_parameter].tag == VF_PARTIAL_FILTER) // cannot recurse
{
GUI_Error_HIG (QT_TR_NOOP("The filter is already partial"), NULL);
break;
}
replace =
new ADMVideoPartial (videofilters[action_parameter - 1].
filter,
videofilters[action_parameter].tag,
conf);
if(replace->configure (videofilters[action_parameter - 1].filter))
{
delete videofilters[action_parameter].filter;
if (conf) delete conf;
videofilters[action_parameter].filter = replace;
replace->getCoupledConf (&conf);
videofilters[action_parameter].conf = conf;
videofilters[action_parameter].tag = VF_PARTIAL_FILTER;
getFirstVideoFilter ();
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], action_parameter-1);
}
else delete replace;
break;
case A_UP:
if (action_parameter < 2) break;
// swap action parameter & action parameter -1
FILTER tmp;
memcpy (&tmp, &videofilters[action_parameter - 1], sizeof (FILTER));
memcpy (&videofilters[action_parameter - 1],
&videofilters[action_parameter], sizeof (FILTER));
memcpy (&videofilters[action_parameter], &tmp, sizeof (FILTER));
getFirstVideoFilter ();
// select action_parameter -1
updateFilterList ();
setSelectionNumber (nb_active_filter - 1,
WID(treeview0),
stores[0], action_parameter - 2);
break;
case A_DOWN:
if (((int) action_parameter < (int) (nb_active_filter - 1)) && (action_parameter))
{
// swap action parameter & action parameter -1
FILTER tmp;
memcpy (&tmp, &videofilters[action_parameter + 1], sizeof (FILTER));
memcpy (&videofilters[action_parameter + 1],
&videofilters[action_parameter], sizeof (FILTER));
memcpy (&videofilters[action_parameter], &tmp, sizeof (FILTER));
getFirstVideoFilter ();
updateFilterList ();
setSelectionNumber (nb_active_filter - 1,
WID(treeview0),
stores[0], action_parameter);
}
break;
case A_REMOVE:
VF_FILTERS tag;
AVDMGenericVideoStream *old;
// we store the one we will delete
if (action_parameter < 1) break;
if (videofilters[action_parameter].conf)
{
delete videofilters[action_parameter].conf;
videofilters[action_parameter].conf = NULL;
}
// recreate derivated filters
for (uint32_t i = action_parameter + 1; i < nb_active_filter; i++)
{
delete videofilters[i - 1].filter;
videofilters[i - 1].filter = filterCreateFromTag(videofilters[i].tag,
videofilters[i].conf,
videofilters[i - 2].filter);
videofilters[i - 1].conf = videofilters[i].conf;
videofilters[i - 1].tag = videofilters[i].tag;
}
delete videofilters[nb_active_filter - 1].filter;
videofilters[nb_active_filter - 1].filter = NULL;
nb_active_filter--;
updateFilterList ();
if(!setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], action_parameter-1))
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], action_parameter-2);
break;
case A_DONE:
break;
case A_PREVIEW:
if (!action_parameter) break;
extern uint32_t curframe;
DIA_filterPreview(QT_TR_NOOP("Preview"), videofilters[action_parameter].filter, curframe);
break;
case A_LOAD:
#ifdef USE_LIBXML2
GUI_FileSelRead (QT_TR_NOOP("Load set of filters"), filterLoadXml);
#else
GUI_FileSelRead (QT_TR_NOOP("Load set of filters"), filterLoad);
#endif
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], 0);
break;
case A_CLOSE:
//gtk_widget_destroy(dialog);
gtk_signal_emit_by_name(GTK_OBJECT(dialog),"delete-event");
break;
case A_SAVE:
if (nb_active_filter < 2)
{
GUI_Error_HIG (QT_TR_NOOP("Nothing to save"), NULL);
}
else
#ifdef USE_LIBXML2
GUI_FileSelWrite (QT_TR_NOOP("Save set of filters"), filterSaveXml);
#else
GUI_FileSelWrite (QT_TR_NOOP("Save set of filters"), filterSave);
#endif
break;
#if 0
default:
printf ("Unknown action :%d, action param %d\n", action, action_parameter);
ADM_assert (0);
#endif
} //end of switch
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
useHex = true;
//These things are used by QSettings to set up setting storage
QCoreApplication::setOrganizationName("EVTV");
QCoreApplication::setOrganizationDomain("evtv.me");
QCoreApplication::setApplicationName("SavvyCAN");
selfRef = this;
this->setWindowTitle("Savvy CAN V" + QString::number(VERSION));
model = new CANFrameModel();
ui->canFramesView->setModel(model);
readSettings();
QStringList headers;
headers << "Timestamp" << "ID" << "Ext" << "Bus" << "Len" << "Data";
//model->setHorizontalHeaderLabels(headers);
ui->canFramesView->setColumnWidth(0, 110);
ui->canFramesView->setColumnWidth(1, 70);
ui->canFramesView->setColumnWidth(2, 40);
ui->canFramesView->setColumnWidth(3, 40);
ui->canFramesView->setColumnWidth(4, 40);
ui->canFramesView->setColumnWidth(5, 275);
QHeaderView *HorzHdr = ui->canFramesView->horizontalHeader();
HorzHdr->setStretchLastSection(true); //causes the data column to automatically fill the tableview
//enabling the below line kills performance in every way imaginable. Left here as a warning. Do not do this.
//ui->canFramesView->verticalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
ports = QSerialPortInfo::availablePorts();
for (int i = 0; i < ports.count(); i++)
{
ui->cbSerialPorts->addItem(ports[i].portName());
}
ui->cbSpeed1->addItem(tr("Disabled"));
ui->cbSpeed1->addItem(tr("125000"));
ui->cbSpeed1->addItem(tr("250000"));
ui->cbSpeed1->addItem(tr("500000"));
ui->cbSpeed1->addItem(tr("1000000"));
ui->cbSpeed1->addItem(tr("33333"));
ui->cbSpeed2->addItem(tr("Disabled"));
ui->cbSpeed2->addItem(tr("125000"));
ui->cbSpeed2->addItem(tr("250000"));
ui->cbSpeed2->addItem(tr("500000"));
ui->cbSpeed2->addItem(tr("1000000"));
ui->cbSpeed2->addItem(tr("33333"));
worker = new SerialWorker(model);
worker->moveToThread(&serialWorkerThread);
connect(&serialWorkerThread, &QThread::finished, worker, &QObject::deleteLater);
connect(this, &MainWindow::sendSerialPort, worker, &SerialWorker::setSerialPort, Qt::QueuedConnection);
connect(worker, &SerialWorker::frameUpdateTick, this, &MainWindow::gotFrames, Qt::QueuedConnection);
connect(this, &MainWindow::updateBaudRates, worker, &SerialWorker::updateBaudRates, Qt::QueuedConnection);
connect(this, &MainWindow::sendCANFrame, worker, &SerialWorker::sendFrame, Qt::QueuedConnection);
connect(worker, &SerialWorker::connectionSuccess, this, &MainWindow::connectionSucceeded, Qt::QueuedConnection);
connect(worker, &SerialWorker::connectionFailure, this, &MainWindow::connectionFailed, Qt::QueuedConnection);
connect(worker, &SerialWorker::deviceInfo, this, &MainWindow::gotDeviceInfo, Qt::QueuedConnection);
connect(this, &MainWindow::closeSerialPort, worker, &SerialWorker::closeSerialPort, Qt::QueuedConnection);
connect(this, &MainWindow::startFrameCapturing, worker, &SerialWorker::startFrameCapture);
connect(this, &MainWindow::stopFrameCapturing, worker, &SerialWorker::stopFrameCapture);
connect(this, &MainWindow::settingsUpdated, worker, &SerialWorker::readSettings);
serialWorkerThread.start();
serialWorkerThread.setPriority(QThread::HighPriority);
graphingWindow = NULL;
frameInfoWindow = NULL;
playbackWindow = NULL;
flowViewWindow = NULL;
frameSenderWindow = NULL;
dbcMainEditor = NULL;
comparatorWindow = NULL;
settingsDialog = NULL;
firmwareUploaderWindow = NULL;
discreteStateWindow = NULL;
dbcHandler = new DBCHandler;
bDirty = false;
inhibitFilterUpdate = false;
model->setDBCHandler(dbcHandler);
connect(ui->btnConnect, SIGNAL(clicked(bool)), this, SLOT(connButtonPress()));
connect(ui->actionOpen_Log_File, SIGNAL(triggered(bool)), this, SLOT(handleLoadFile()));
connect(ui->actionGraph_Dta, SIGNAL(triggered(bool)), this, SLOT(showGraphingWindow()));
connect(ui->actionFrame_Data_Analysis, SIGNAL(triggered(bool)), this, SLOT(showFrameDataAnalysis()));
connect(ui->btnClearFrames, SIGNAL(clicked(bool)), this, SLOT(clearFrames()));
connect(ui->actionSave_Log_File, SIGNAL(triggered(bool)), this, SLOT(handleSaveFile()));
connect(ui->actionSave_Filtered_Log_File, SIGNAL(triggered(bool)), this, SLOT(handleSaveFilteredFile()));
connect(ui->actionLoad_Filter_Definition, SIGNAL(triggered(bool)), this, SLOT(handleLoadFilters()));
connect(ui->actionSave_Filter_Definition, SIGNAL(triggered(bool)), this, SLOT(handleSaveFilters()));
connect(ui->action_Playback, SIGNAL(triggered(bool)), this, SLOT(showPlaybackWindow()));
connect(ui->btnBaudSet, SIGNAL(clicked(bool)), this, SLOT(changeBaudRates()));
connect(ui->actionFlow_View, SIGNAL(triggered(bool)), this, SLOT(showFlowViewWindow()));
connect(ui->action_Custom, SIGNAL(triggered(bool)), this, SLOT(showFrameSenderWindow()));
connect(ui->actionLoad_DBC_File, SIGNAL(triggered(bool)), this, SLOT(handleLoadDBC()));
connect(ui->actionSave_DBC_File, SIGNAL(triggered(bool)), this, SLOT(handleSaveDBC()));
connect(ui->canFramesView, SIGNAL(clicked(QModelIndex)), this, SLOT(gridClicked(QModelIndex)));
connect(ui->canFramesView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(gridDoubleClicked(QModelIndex)));
connect(ui->cbInterpret, SIGNAL(toggled(bool)), this, SLOT(interpretToggled(bool)));
connect(ui->cbOverwrite, SIGNAL(toggled(bool)), this, SLOT(overwriteToggled(bool)));
connect(ui->actionEdit_Messages_Signals, SIGNAL(triggered(bool)), this, SLOT(showDBCEditor()));
connect(ui->btnCaptureToggle, SIGNAL(clicked(bool)), this, SLOT(toggleCapture()));
connect(ui->actionExit_Application, SIGNAL(triggered(bool)), this, SLOT(exitApp()));
connect(ui->actionFuzzy_Scope, SIGNAL(triggered(bool)), this, SLOT(showFuzzyScopeWindow()));
connect(ui->actionRange_State, SIGNAL(triggered(bool)), this, SLOT(showRangeWindow()));
connect(ui->actionSave_Decoded_Frames, SIGNAL(triggered(bool)), this, SLOT(handleSaveDecoded()));
connect(ui->actionSingle_Multi_State, SIGNAL(triggered(bool)), this, SLOT(showSingleMultiWindow()));
connect(ui->actionFile_Comparison, SIGNAL(triggered(bool)), this, SLOT(showComparisonWindow()));
connect(ui->btnNormalize, SIGNAL(clicked(bool)), this, SLOT(normalizeTiming()));
connect(ui->actionPreferences, SIGNAL(triggered(bool)), this, SLOT(showSettingsDialog()));
connect(model, SIGNAL(updatedFiltersList()), this, SLOT(updateFilterList()));
connect(ui->listFilters, SIGNAL(itemChanged(QListWidgetItem*)), this, SLOT(filterListItemChanged(QListWidgetItem*)));
connect(ui->btnFilterAll, SIGNAL(clicked(bool)), this, SLOT(filterSetAll()));
connect(ui->btnFilterNone, SIGNAL(clicked(bool)), this, SLOT(filterClearAll()));
connect(ui->actionFirmware_Uploader, SIGNAL(triggered(bool)), this, SLOT(showFirmwareUploaderWindow()));
lbStatusConnected.setText(tr("Not connected"));
updateFileStatus();
lbStatusDatabase.setText(tr("No DBC database loaded"));
ui->statusBar->addWidget(&lbStatusConnected);
ui->statusBar->addWidget(&lbStatusFilename);
ui->statusBar->addWidget(&lbStatusDatabase);
ui->lbFPS->setText("0");
ui->lbNumFrames->setText("0");
isConnected = false;
allowCapture = true;
//create a temporary frame to be able to capture the correct
//default height of an item in the table. Need to do this in case
//of scaling or font differences between different computers.
CANFrame temp;
temp.bus = 0;
temp.ID = 0x100;
temp.len = 0;
model->addFrame(temp, true);
normalRowHeight = ui->canFramesView->rowHeight(0);
qDebug() << "normal row height = " << normalRowHeight;
model->clearFrames();
}
