ProportionalLayout::~ProportionalLayout()
{
QLayoutItem *item;
while ((item = takeAt(0))) {
delete item;
}
}
void MainWindow::changeFilterSelectorsOrder(QList<std::tuple<int, int> > filtersInfo)
{
QSignalBlocker blocker(draggableBehaviour);
auto boxlayout = static_cast<QHBoxLayout*> (ui->horizontalLayout);
QList<QLayoutItem*> items;
for(std::tuple<int, int> groupAndType : filtersInfo)
{
int group = std::get<0>(groupAndType);
int type = std::get<1>(groupAndType);
auto rowsCount = boxlayout->count();
for(auto row = 0; row < rowsCount; ++row)
{
auto checkboxItem = boxlayout->itemAt(row);
if(checkboxItem->widget()->property("group") == group && checkboxItem->widget()->property("type") == type)
{
items.append(boxlayout->takeAt(row));
break;
}
}
};
for(auto item : items)
{
boxlayout->addItem(item);
}
}
// I know it's ugly and too expensive (to use this brute-force method)
// but now it all works (horizontal and vertical mode), moving of buttons,
// removing etc. And mainly - it places buttons into matrix if there is
// free space for it.
void QuickLaunchLayout::relayout()
{
int size = m_panel->isHorizontal() ? qobject_cast<QWidget*>(parent())->height() : qobject_cast<QWidget*>(parent())->width();
int div = size / QUICKLAUNCH_BUTTON_SIZE;
int col = 0;
int row = 0;
QLayoutItem *child;
while ((child = takeAt(0)) != 0)
{
delete child;
}
foreach (QuickLaunchButton *b, m_buttons)
{
QGridLayout::addWidget(b, row, col);
if (m_panel->isHorizontal())
{
++row;
if (row >= div)
{
row = 0;
++col;
}
}
else
{
++col;
if (col >= div)
{
col = 0;
++row;
}
}
}
QLayoutItem* QBoxLayout_QtDShell::__override_takeAt(int arg__1, bool static_call)
{
if (static_call) {
return QBoxLayout::takeAt((int )arg__1);
} else {
return takeAt((int )arg__1);
}
}
GridImageLayout::~GridImageLayout()
{
#if 0
QLayoutItem *item;
while ((item = takeAt(0)))
delete item;
#endif
}
void GameObjectManager::removeAt(int index, bool del)
{
if (index >= 0 && index < mGameObjects.size()) {
GameObject* obj = takeAt(index);
emit objectRemoved(obj, del);
if (del && obj)
delete obj;
}
}
bool ModList::update()
{
if (!isValid())
return false;
QList<Mod> newMods;
m_dir.refresh();
auto folderContents = m_dir.entryInfoList();
bool orderWasInvalid = false;
// first, process the ordered items (if any)
int currentOrderIndex = 0;
QStringList listOrder = readListFile();
for(auto item: listOrder)
{
QFileInfo info (m_dir.filePath(item));
int idx = folderContents.indexOf(info);
// if the file from the index file exists
if(idx != -1)
{
// remove from the actual folder contents list
folderContents.takeAt(idx);
// append the new mod
newMods.append(Mod(info));
}
else
{
orderWasInvalid = true;
}
}
for(auto entry: folderContents)
{
newMods.append(Mod(entry));
}
if(mods.size() != newMods.size())
{
orderWasInvalid = true;
}
else for(int i = 0; i < mods.size(); i++)
{
if(!mods[i].strongCompare(newMods[i]))
{
orderWasInvalid = true;
break;
}
}
beginResetModel();
mods.swap(newMods);
endResetModel();
if(orderWasInvalid)
{
saveListFile();
emit changed();
}
return true;
}
QIrQuadSplitterLayout::~QIrQuadSplitterLayout()
{
QLayoutItem * item;
while ((item = takeAt(0)))
delete item;
while ( m_structList.isEmpty() )
delete m_structList.takeFirst();
}
void MachinetalkService::updateComplexRepeatedField(QObject *object, const google::protobuf::Message &message, const google::protobuf::FieldDescriptor *field, const QString &tempDir)
{
const auto &name = QByteArray::fromStdString(field->camelcase_name());
const gpb::Reflection *reflection = message.GetReflection();
auto list = qvariant_cast<QVariant>(object->property(name)).toList();
QList<int> removeList; // store index of items to remove
bool lengthChanged = false;
for (int i = 0; i < reflection->FieldSize(message, field); ++i)
{
const gpb::Message &subMessage = reflection->GetRepeatedMessage(message, field, i);
const gpb::Descriptor *subDescriptor = subMessage.GetDescriptor();
const gpb::FieldDescriptor *subField = subDescriptor->FindFieldByName("index");
const gpb::Reflection *subReflection = subMessage.GetReflection();
const int index = subReflection->GetInt32(subMessage, subField);
while (list.size() < (index + 1))
{
QObject *newObject = recurseDescriptor(subDescriptor, object);
list.append(QVariant::fromValue(newObject));
lengthChanged = true;
}
QObject *item = qvariant_cast<QObject*>(list.at(index));
Q_ASSERT(item != nullptr);
if (recurseMessage(subMessage, item, tempDir) <= 1) // only index -> remove object
{
removeList.append(index);
}
}
// remove marked items
if (removeList.length() > 0)
{
std::sort(removeList.begin(), removeList.end());
for (int k = (removeList.length() - 1); k >= 0; k--)
{
QObject *item = qvariant_cast<QObject*>(list.takeAt(removeList[k]));
Q_ASSERT(item != nullptr);
item->deleteLater();
}
lengthChanged = true;
}
if (lengthChanged) // we need to notify property bindings about changes in length
{
object->setProperty(name, QVariant::fromValue(list));
}
}
void RTCurrentGameWidget::RTCounter::updateCounter(int count)
{
this->count = count;
QLayoutItem* item;
while ((item = takeAt(0)) != NULL)
{
delete item->widget();
delete item;
}
for (int i = 0; i < count; i++)
{
QLabel* label = new QLabel();
label->setPixmap(QPixmap::fromImage(image));
addWidget(label);
}
}
void DeckButtonsLayout::setRoundButton( QAbstractButton* button )
{
if ( RoundButton && button == RoundButton ) {
return;
}
if ( goItem ) {
delete takeAt( 1 );
}
if ( button ) {
addChildWidget( button );
}
goItem = new QWidgetItem( button );
RoundButton = button;
update();
}
void DeckButtonsLayout::setBackwardButton( QAbstractButton* button )
{
if ( backwardButton && button == backwardButton ) {
return;
}
if ( backwardItem ) {
delete takeAt( 0 );
}
if ( button ) {
addChildWidget( button );
}
backwardItem = new QWidgetItem( button );
backwardButton = button;
update();
}
void DeckButtonsLayout::setForwardButton( QAbstractButton* button )
{
if ( forwardButton && button == forwardButton ) {
return;
}
if ( forwardItem ) {
delete takeAt( 2 );
}
if ( button ) {
addChildWidget( button );
}
forwardItem = new QWidgetItem( button );
forwardButton = button;
update();
}
Node *LoadNodeFactory::getNode(const QString &tagContent, Parser *p) const
{
auto expr = tagContent.split(QLatin1Char(' '), QString::SkipEmptyParts);
if (expr.size() <= 1) {
throw Grantlee::Exception(
TagSyntaxError,
QStringLiteral("%1 expects at least one argument").arg(expr.first()));
}
expr.takeAt(0);
QListIterator<QString> i(expr);
while (i.hasNext()) {
auto libName = i.next();
p->loadLib(libName);
}
return new LoadNode(p);
}
FixedSizeGridLayout::~FixedSizeGridLayout()
{
QLayoutItem *item;
while ((item = takeAt(0)) != Q_NULLPTR)
delete item;
}
bool ModList::update()
{
if (!isValid())
return false;
QList<Mod> orderedMods;
QList<Mod> newMods;
m_dir.refresh();
auto folderContents = m_dir.entryInfoList();
bool orderOrStateChanged = false;
// first, process the ordered items (if any)
OrderList listOrder = readListFile();
for (auto item : listOrder)
{
QFileInfo infoEnabled(m_dir.filePath(item.id));
QFileInfo infoDisabled(m_dir.filePath(item.id + ".disabled"));
int idxEnabled = folderContents.indexOf(infoEnabled);
int idxDisabled = folderContents.indexOf(infoDisabled);
bool isEnabled;
// if both enabled and disabled versions are present, it's a special case...
if (idxEnabled >= 0 && idxDisabled >= 0)
{
// we only process the one we actually have in the order file.
// and exactly as we have it.
// THIS IS A CORNER CASE
isEnabled = item.enabled;
}
else
{
// only one is present.
// we pick the one that we found.
// we assume the mod was enabled/disabled by external means
isEnabled = idxEnabled >= 0;
}
int idx = isEnabled ? idxEnabled : idxDisabled;
QFileInfo & info = isEnabled ? infoEnabled : infoDisabled;
// if the file from the index file exists
if (idx != -1)
{
// remove from the actual folder contents list
folderContents.takeAt(idx);
// append the new mod
orderedMods.append(Mod(info));
if (isEnabled != item.enabled)
orderOrStateChanged = true;
}
else
{
orderOrStateChanged = true;
}
}
// if there are any untracked files...
if (folderContents.size())
{
// the order surely changed!
for (auto entry : folderContents)
{
newMods.append(Mod(entry));
}
std::sort(newMods.begin(), newMods.end(), [](const Mod & left, const Mod & right)
{ return left.name().localeAwareCompare(right.name()) <= 0; });
orderedMods.append(newMods);
orderOrStateChanged = true;
}
// otherwise, if we were already tracking some mods
else if (mods.size())
{
// if the number doesn't match, order changed.
if (mods.size() != orderedMods.size())
orderOrStateChanged = true;
// if it does match, compare the mods themselves
else
for (int i = 0; i < mods.size(); i++)
{
if (!mods[i].strongCompare(orderedMods[i]))
{
orderOrStateChanged = true;
break;
}
}
}
beginResetModel();
mods.swap(orderedMods);
endResetModel();
if (orderOrStateChanged && !m_list_file.isEmpty())
{
QLOG_INFO() << "Mod list " << m_list_file << " changed!";
saveListFile();
emit changed();
}
return true;
}
XKPPlacementLayout::~XKPPlacementLayout()
{
QLayoutItem *l;
while((l = takeAt(0)))
delete l;
}
void AbstractMediaList::move(int from, int to)
{
insert(to, takeAt(from));
}
ControlledLayout::~ControlledLayout() {
QLayoutItem *item;
while ((item = takeAt(0)))
delete item;
}
QLayoutItem *QAnimatedMainWindowLayout::takeAt(
int index)
{
return takeAt(index);
}
MainWindow::MainWindow(const QString &fileName, QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow),
m_taskbarButton(nullptr),
m_monospaceFont(false)
{
ui->setupUi(this);
QSettings settings;
m_monospaceFont = settings.value("monospaceFont", 0).toBool();
if (m_monospaceFont)
{
const QFont fixedFont = QFontDatabase::systemFont(QFontDatabase::FixedFont);
ui->tableView->setFont(fixedFont);
}
AbstractLogModel *model;
if (fileName.isEmpty())
{
auto logModel = new LogModel(this);
model = logModel;
if (settings.contains("autoSaveDirectory"))
{
logModel->setAutoSaveDirectory(settings.value("autoSaveDirectory").toString());
}
else
{
logModel->setAutoSaveDirectory(QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation));
}
logModel->setMaxMessages(settings.value("maxMessages", 10000).toInt());
logModel->setServerMode(settings.value("serverMode", false).toBool());
setWindowTitle(windowTitle().arg(model->isListening() ? "Listening" : "Not listening"));
connect(ui->actionDisconnectAll, &QAction::triggered, logModel, &LogModel::disconnectAll);
}
else
{
model = new LogMonitorFileModel(fileName, this);
setWindowTitle(windowTitle().arg(QFileInfo(fileName).fileName()));
}
model->setBreakLines(settings.value("breakLines", 0).toBool());
model->setColorBackground(LogColorBackground(settings.value("colorBackground", 0).toInt()));
model->setTimestampPrecision(TimestampPrecision(settings.value("timestampPrecision", 0).toInt()));
auto filtered = new LogFilter(this);
filtered->setFilterCaseSensitivity(Qt::CaseInsensitive);
filtered->setSourceModel(model);
ui->tableView->setModel(filtered);
connect(ui->errorFilter, &QToolButton::toggled, filtered, &LogFilter::showErrors);
connect(ui->warningFilter, &QToolButton::toggled, filtered, &LogFilter::showWarnings);
connect(ui->noticeFilter, &QToolButton::toggled, filtered, &LogFilter::showNotices);
connect(ui->infoFilter, &QToolButton::toggled, filtered, &LogFilter::showInfos);
ui->logMap->setModel(filtered);
ui->logMap->setBuddyView(ui->tableView);
auto src = ui->tableParent->layout();
auto dest = new OverlayLayout(ui->tableParent);
while (src->count())
{
dest->addItem(src->takeAt(0));
}
delete src;
ui->tableParent->setLayout(dest);
ui->searchBox->setVisible(false);
ui->tableView->setVerticalHeader(new FixedHeader(Qt::Vertical, ui->tableView));
ui->tableView->verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
ui->tableView->verticalHeader()->setDefaultSectionSize(23);
ui->tableView->verticalHeader()->setHighlightSections(true);
ui->tableView->verticalHeader()->setStretchLastSection(false);
ui->tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Interactive);
ui->tableView->horizontalHeader()->setStretchLastSection(false);
ui->tableView->horizontalHeader()->setSectionResizeMode(6, QHeaderView::Stretch);
ui->tableView->horizontalHeader()->setSectionsMovable(true);
auto order = settings.value("columnOrder").toByteArray();
for (int i = 0; i < order.size(); ++i)
{
ui->tableView->horizontalHeader()->moveSection(ui->tableView->horizontalHeader()->visualIndex(i), order[i]);
}
connect(ui->tableView->horizontalHeader(), &QHeaderView::sectionMoved, this, &MainWindow::columnMoved);
connect(ui->tableView->selectionModel(), &QItemSelectionModel::selectionChanged, this, &MainWindow::itemSelected);
connect(ui->messageText, &QTextBrowser::anchorClicked, this, &MainWindow::anchorClicked);
connect(ui->tableView, &QTableView::customContextMenuRequested, this, &MainWindow::itemMenu);
ui->errorFilter->setChecked(settings.value("quickFilter/error", true).toBool());
ui->warningFilter->setChecked(settings.value("quickFilter/warning", true).toBool());
ui->noticeFilter->setChecked(settings.value("quickFilter/notice", true).toBool());
ui->infoFilter->setChecked(settings.value("quickFilter/info", true).toBool());
ui->errorFilter->setToolTip("error");
ui->warningFilter->setToolTip("warning");
ui->noticeFilter->setToolTip("notice");
ui->infoFilter->setToolTip("info");
if (settings.contains("customFilter"))
{
auto name = settings.value("customFilter").toString();
auto& filters = Filter::getFilters();
for (auto it = filters.begin(); it != filters.end(); ++it)
{
if (it->m_name == name)
{
static_cast<LogFilter*>(ui->tableView->model())->setCustomFilter(&(*it));
ui->actionFilterNone->setChecked(false);
ui->filterButton->setIcon(QIcon(":/default/filter"));
ui->filterButton->setToolTip(name);
break;
}
}
}
if (settings.contains("customHighlight"))
{
auto name = settings.value("customHighlight").toString();
auto& highlights = HighlightSet::getSets();
for (auto it = highlights.begin(); it != highlights.end(); ++it)
{
if (it->m_name == name)
{
static_cast<LogFilter*>(ui->tableView->model())->setHighlight(&(*it));
ui->actionHighlightNone->setChecked(false);
ui->highlightsButton->setIcon(QIcon(":/default/highlights"));
ui->highlightsButton->setToolTip(name);
break;
}
}
}
m_quickFilterEdited.setSingleShot(true);
m_quickFilterEdited.setInterval(1000);
connect(ui->textFilter, &QLineEdit::textChanged, this, &MainWindow::textFilterChanged);
connect(ui->textFilter, &QLineEdit::editingFinished, this, &MainWindow::textFilterTimeout);
connect(&m_quickFilterEdited, &QTimer::timeout, this, &MainWindow::textFilterTimeout);
connect(ui->searchClose, &QToolButton::clicked, ui->searchBox, &QFrame::hide);
connect(ui->searchDown, &QToolButton::clicked, this, &MainWindow::findNext);
connect(ui->searchUp, &QToolButton::clicked, this, &MainWindow::findPrevious);
ui->searchText->installEventFilter(this);
ui->actionOpen->setShortcut(QKeySequence(QKeySequence::Open));
ui->actionSaveAs->setShortcut(QKeySequence(QKeySequence::Save));
ui->actionExit->setShortcut(QKeySequence(QKeySequence::Quit));
ui->actionSelectAll->setShortcut(QKeySequence(QKeySequence::SelectAll));
ui->actionFind->setShortcut(QKeySequence(QKeySequence::Find));
ui->actionCopy->setShortcut(QKeySequence(QKeySequence::Copy));
connect(ui->actionOpen, &QAction::triggered, this, &MainWindow::openFile);
connect(ui->actionSaveAs, &QAction::triggered, this, &MainWindow::saveFile);
connect(ui->actionExport, &QAction::triggered, this, &MainWindow::exportAsText);
connect(ui->actionExit, &QAction::triggered, this, &MainWindow::close);
connect(ui->actionFind, &QAction::triggered, this, &MainWindow::openFind);
connect(ui->actionCloseFind, &QAction::triggered, ui->searchBox, &QFrame::hide);
connect(ui->actionSelectAll, &QAction::triggered, this, &MainWindow::selectAll);
connect(ui->actionCopy, &QAction::triggered, this, &MainWindow::copySelection);
connect(ui->actionCopyMessagesOnly, &QAction::triggered, this, &MainWindow::copyMessages);
connect(ui->actionNextError, &QAction::triggered, ui->tableView, &LogView::nextError);
connect(ui->actionPreviousError, &QAction::triggered, ui->tableView, &LogView::previousError);
connect(ui->actionNextWarning, &QAction::triggered, ui->tableView, &LogView::nextWarning);
connect(ui->actionPreviousWarning, &QAction::triggered, ui->tableView, &LogView::previousWarning);
connect(ui->actionNextNotice, &QAction::triggered, ui->tableView, &LogView::nextNotice);
connect(ui->actionPreviousNotice, &QAction::triggered, ui->tableView, &LogView::previousNotice);
connect(ui->actionClear, &QAction::triggered, model, &AbstractLogModel::clear);
ui->actionServerMode->setChecked(settings.value("serverMode").toBool());
connect(ui->actionServerMode, &QAction::triggered, this, &MainWindow::setServerMode);
connect(ui->actionSplitByPIDs, &QAction::triggered, this, &MainWindow::splitByPids);
ui->actionSplitByPIDs->setChecked(settings.value("splitByPids").toBool());
splitByPids();
connect(ui->actionSettings, &QAction::triggered, this, &MainWindow::showSettings);
connect(ui->actionAboutLogLite, &QAction::triggered, this, &MainWindow::showAboutDialog);
connect(ui->actionScrollToBeginning, &QAction::triggered, ui->tableView, &LogView::scrollToBeginning);
connect(ui->actionScrollToEnd, &QAction::triggered, ui->tableView, &LogView::scrollToEnd);
QAction* columnActions[] = {
ui->actionTime,
ui->actionPID,
ui->actionExecutable,
ui->actionMachine,
ui->actionModule,
ui->actionChannel,
ui->actionMessage,
};
for (int i = 0; i < int(sizeof(columnActions)/sizeof(columnActions[0])); ++i)
{
if (i + 1 < int(sizeof(columnActions)/sizeof(columnActions[0])))
{
auto key = QString(columnSettings[i]) + "Width";
if (settings.contains(key))
{
ui->tableView->setColumnWidth(i, std::max(settings.value(key).toInt(), 32));
}
}
columnActions[i]->setProperty("columnIndex", i);
columnActions[i]->setProperty("setting", columnSettings[i]);
connect(columnActions[i], &QAction::toggled, this, &MainWindow::columnMenuChanged);
columnActions[i]->setChecked(settings.value(columnSettings[i], true).toBool());
if (!columnActions[i]->isChecked())
{
ui->tableView->hideColumn(i);
}
}
ui->tableView->horizontalHeader()->setContextMenuPolicy(Qt::CustomContextMenu);
connect(ui->tableView->horizontalHeader(), &QHeaderView::customContextMenuRequested, this, &MainWindow::columnMenu);
m_stats = new LogStatistics(this);
m_stats->setModel(model);
ui->statusBar->addPermanentWidget(m_stats);
ui->splitter->setCollapsible(0, false);
restoreGeometry(settings.value("geometry").toByteArray());
restoreState(settings.value("windowState").toByteArray());
ui->splitter->restoreState(settings.value("splitterSizes").toByteArray());
if (fileName.isEmpty())
{
ui->tableView->selectionModel()->setCurrentIndex(ui->tableView->model()->index(0, 0), QItemSelectionModel::SelectCurrent|QItemSelectionModel::Rows);
}
#ifdef _WIN32
auto timer = new QTimer(this);
connect(timer, &QTimer::timeout, this, &MainWindow::updateTaskbarIcon);
timer->start(1000);
generateOverlayIcons(m_icons);
#endif
connect(ui->actionEditFilters, &QAction::triggered, this, &MainWindow::editFilters);
connect(ui->actionEditHighlights, &QAction::triggered, this, &MainWindow::editHighlights);
connect(ui->menuFilters, &QMenu::aboutToShow, this, &MainWindow::buildFiltersMenu);
connect(ui->menuFilters, &QMenu::triggered, this, &MainWindow::customFilterSet);
connect(ui->menuHighlights, &QMenu::aboutToShow, this, &MainWindow::buildHighlightsMenu);
connect(ui->menuHighlights, &QMenu::triggered, this, &MainWindow::highlightSet);
connect(ui->filterButton, &QToolButton::clicked, this, &MainWindow::showFilterMenu);
connect(ui->highlightsButton, &QToolButton::clicked, this, &MainWindow::showHighlightsMenu);
connect(ui->menu_Disconnect_Client, &QMenu::aboutToShow, this, &MainWindow::buildClientsMenu);
connect(ui->actionAboutQt, &QAction::triggered, qApp, &QApplication::aboutQt);
setAcceptDrops(true);
}
// Description: Destructor.
//
KxGridLayout::~KxGridLayout()
{
QLayoutItem *item;
while ((item = takeAt(0)))
delete item;
}
void AsyncRequestList::removeAt(int i)
{
AsyncRequest* r=takeAt(i);
delete r;
}
OverlayLayout::~OverlayLayout()
{
QLayoutItem *item;
while ((item = takeAt(0)))
delete item;
}
FlowLayout::~FlowLayout()
{
QLayoutItem *item;
while ((item = takeAt(0)))
delete item;
}
QLayoutItem* DhQLayout::DvhtakeAt(int x1) {
return takeAt(x1);
}
ZBorderLayout::~ZBorderLayout()
{
QLayoutItem *l;
while ((l = takeAt(0)))
delete l;
}
MosaicLayout::~MosaicLayout()
{
QLayoutItem *item;
while ((item = takeAt(0)))
delete item;
}
void TuningLayout::clear()
{
QLayoutItem *l;
while ((l = takeAt(0)))
delete l;
}
void SWidgetManager::removeAt( int index )
{
takeAt( index );
}
