(sender());
if (action)
loadFile(action->data().toString());
}
// Select all the text in the currently selected view
void MainWindow::selectAll()
{
crawlerWidget->selectAll();
}
// Copy the currently selected line into the clipboard
void MainWindow::copy()
{
static QClipboard* clipboard = QApplication::clipboard();
clipboard->setText( crawlerWidget->getSelectedText() );
// Put it in the global selection as well (X11 only)
clipboard->setText( crawlerWidget->getSelectedText(),
QClipboard::Selection );
}
// Display the QuickFind bar
void MainWindow::find()
{
crawlerWidget->displayQuickFindBar( QuickFindMux::Forward );
}
// Reload the current log file
void MainWindow::reload()
{
if ( !currentFile.isEmpty() )
loadFile( currentFile );
}
// Stop the loading operation
void MainWindow::stop()
{
crawlerWidget->stopLoading();
}
// Opens the 'Filters' dialog box
void MainWindow::filters()
{
FiltersDialog dialog(this);
connect(&dialog, SIGNAL( optionsChanged() ), crawlerWidget, SLOT( applyConfiguration() ));
dialog.exec();
}
// Opens the 'Options' modal dialog box
void MainWindow::options()
{
OptionsDialog dialog(this);
connect(&dialog, SIGNAL( optionsChanged() ), crawlerWidget, SLOT( applyConfiguration() ));
dialog.exec();
}
// Opens the 'About' dialog box.
void MainWindow::about()
{
QMessageBox::about(this, tr("About glogg"),
tr("glogg " GLOGG_VERSION "
"
"A fast, advanced log explorer."
#ifdef GLOGG_COMMIT
"
Built " GLOGG_DATE " from " GLOGG_COMMIT
#endif
"
Copyright © 2009, 2010, 2011, 2012, 2013 Nicolas Bonnefon and other contributors"
"
You may modify and redistribute the program under the terms of the GPL (version 3 or later)." ) );
}
// Opens the 'About Qt' dialog box.
void MainWindow::aboutQt()
{
}
void MainWindow::toggleOverviewVisibility( bool isVisible )
{
Configuration& config = Persistent( "settings" );
config.setOverviewVisible( isVisible );
emit optionsChanged();
}
void MainWindow::toggleMainLineNumbersVisibility( bool isVisible )
{
Configuration& config = Persistent( "settings" );
config.setMainLineNumbersVisible( isVisible );
emit optionsChanged();
}
void MainWindow::toggleFilteredLineNumbersVisibility( bool isVisible )
{
Configuration& config = Persistent( "settings" );
config.setFilteredLineNumbersVisible( isVisible );
emit optionsChanged();
}
void MainWindow::disableFollow()
{
followAction->setChecked( false );
}
void MainWindow::lineNumberHandler( int line )
{
// The line number received is the internal (starts at 0)
lineNbField->setText( tr( "Line %1" ).arg( line + 1 ) );
}
void MainWindow::updateLoadingProgress( int progress )
{
LOG(logDEBUG) << "Loading progress: " << progress;
// We ignore 0% and 100% to avoid a flash when the file (or update)
// is very short.
if ( progress > 0 && progress < 100 ) {
infoLine->setText( loadingFileName + tr( " - Indexing lines... (%1 %)" ).arg( progress ) );
infoLine->displayGauge( progress );
stopAction->setEnabled( true );
}
}
void MainWindow::displayNormalStatus( bool success )
{
QLocale defaultLocale;
LOG(logDEBUG) << "displayNormalStatus";
if ( success )
setCurrentFile( loadingFileName );
qint64 fileSize;
int fileNbLine;
QDateTime lastModified;
crawlerWidget->getFileInfo( &fileSize, &fileNbLine, &lastModified );
if ( lastModified.isValid() ) {
const QString date =
#if QT_VERSION > 0x040500
defaultLocale.toString( lastModified, QLocale::NarrowFormat );
#else
defaultLocale.toString( lastModified.date(), QLocale::ShortFormat )
.append( " " ).append( defaultLocale.toString(
lastModified.time(), QLocale::ShortFormat ) );
#endif
infoLine->setText( tr( "%1 (%2 - %3 lines - modified on %4)" )
.arg(currentFile).arg(readableSize(fileSize))
.arg(fileNbLine).arg( date ) );
}
else {
infoLine->setText( tr( "%1 (%2 - %3 lines)" )
.arg(currentFile).arg(readableSize(fileSize))
.arg(fileNbLine) );
}
infoLine->hideGauge();
stopAction->setEnabled( false );
}
//
// Events
//
// Closes the application
void MainWindow::closeEvent( QCloseEvent *event )
{
writeSettings();
event->accept();
}
// Accepts the drag event if it looks like a filename
void MainWindow::dragEnterEvent( QDragEnterEvent* event )
{
if ( event->mimeData()->hasFormat( "text/uri-list" ) )
event->acceptProposedAction();
}
// Tries and loads the file if the URL dropped is local
void MainWindow::dropEvent( QDropEvent* event )
{
QList urls = event->mimeData()->urls();
if ( urls.isEmpty() )
return;
QString fileName = urls.first().toLocalFile();
if ( fileName.isEmpty() )
return;
loadFile( fileName );
}
//
// Private functions
//
// Loads the passed file into the CrawlerWidget and update the title bar.
// The loading is done asynchronously.
bool MainWindow::loadFile( const QString& fileName )
{
LOG(logDEBUG) << "loadFile ( " << fileName.toStdString() << " )";
int topLine = 0;
// If we're loading the same file, put the same line on top.
if ( fileName == currentFile )
topLine = crawlerWidget->getTopLine();
// Load the file
loadingFileName = fileName;
if ( crawlerWidget->readFile( fileName, topLine ) ) {
LOG(logDEBUG) << "Success loading file " << fileName.toStdString();
return true;
}
else {
LOG(logWARNING) << "Cannot load file " << fileName.toStdString();
displayNormalStatus( false );
return false;
}
}
// Strips the passed filename from its directory part.
QString MainWindow::strippedName( const QString& fullFileName ) const
{
return QFileInfo( fullFileName ).fileName();
}
// Add the filename to the recent files list and update the title bar.
void MainWindow::setCurrentFile( const QString& fileName )
{
// Change the current file
currentFile = fileName;
QString shownName = tr( "Untitled" );
if ( !currentFile.isEmpty() ) {
// (reload the list first in case another glogg changed it)
GetPersistentInfo().retrieve( "recentFiles" );
recentFiles.addRecent( currentFile );
GetPersistentInfo().save( "recentFiles" );
updateRecentFileActions();
shownName = strippedName( currentFile );
}
setWindowTitle(
tr("%1 - %2").arg(shownName).arg(tr("glogg"))
#ifdef GLOGG_COMMIT
+ " (dev build " GLOGG_VERSION ")"
#endif
);
}
// Updates the actions for the recent files.
// Must be called after having added a new name to the list.
void MainWindow::updateRecentFileActions()
{
QStringList recent_files = recentFiles.recentFiles();
for ( int j = 0; j < MaxRecentFiles; ++j ) {
if ( j < recent_files.count() ) {
QString text = tr("&%1 %2").arg(j + 1).arg(strippedName(recent_files[j]));
recentFileActions[j]->setText( text );
recentFileActions[j]->setToolTip( recent_files[j] );
recentFileActions[j]->setData( recent_files[j] );
recentFileActions[j]->setVisible( true );
}
else {
recentFileActions[j]->setVisible( false );
}
}
// separatorAction->setVisible(!recentFiles.isEmpty());
}
// Write settings to permanent storage
void MainWindow::writeSettings()
{
// Save the session
SessionInfo& session = Persistent( "session" );
session.setGeometry( saveGeometry() );
session.setCrawlerState( crawlerWidget->saveState() );
session.setCurrentFile( currentFile );
GetPersistentInfo().save( QString( "session" ) );
// User settings
GetPersistentInfo().save( QString( "settings" ) );
}
// Read settings from permanent storage
void MainWindow::readSettings()
{
// Get and restore the session
GetPersistentInfo().retrieve( QString( "session" ) );
SessionInfo session = Persistent( "session" );
restoreGeometry( session.geometry() );
crawlerWidget->restoreState( session.crawlerState() );
previousFile = session.currentFile();
// History of recent files
GetPersistentInfo().retrieve( QString( "recentFiles" ) );
updateRecentFileActions();
GetPersistentInfo().retrieve( QString( "savedSearches" ) );
GetPersistentInfo().retrieve( QString( "settings" ) );
GetPersistentInfo().retrieve( QString( "filterSet" ) );
}
// Returns the size in human readable format
QString MainWindow::readableSize( qint64 size ) const
{
static const QString sizeStrs[] = {
tr("B"), tr("KiB"), tr("MiB"), tr("GiB"), tr("TiB") };
QLocale defaultLocale;
unsigned int i;
double humanSize = size;
for ( i=0; i+1 < (sizeof(sizeStrs)/sizeof(QString)) && (humanSize/1024.0) >= 1024.0; i++ )
humanSize /= 1024.0;
if ( humanSize >= 1024.0 ) {
humanSize /= 1024.0;
i++;
}
QString output;
if ( i == 0 )
// No decimal part if we display straight bytes.
output = defaultLocale.toString( (int) humanSize );
else
output = defaultLocale.toString( humanSize, 'f', 1 );
output += QString(" ") + sizeStrs[i];
return output;
}
glogg-0.9.2/mainwindow.h 0000664 0000000 0000000 00000010071 12223242463 0015145 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2009, 2010, 2011, 2013 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include
#include "crawlerwidget.h"
#include "infoline.h"
class QAction;
class RecentFiles;
class MenuActionToolTipBehavior;
// Main window of the application, creates menus, toolbar and
// the CrawlerWidget
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
MainWindow();
// Loads the initial file (parameter passed or from config file)
void loadInitialFile( QString fileName );
protected:
void closeEvent( QCloseEvent* event );
// Drag and drop support
void dragEnterEvent( QDragEnterEvent* event );
void dropEvent( QDropEvent* event );
private slots:
void open();
void openRecentFile();
void selectAll();
void copy();
void find();
void reload();
void stop();
void filters();
void options();
void about();
void aboutQt();
// Change the view settings
void toggleOverviewVisibility( bool isVisible );
void toggleMainLineNumbersVisibility( bool isVisible );
void toggleFilteredLineNumbersVisibility( bool isVisible );
// Disable the follow mode checkbox and send the followSet signal down
void disableFollow();
// Update the line number displayed in the status bar.
// Must be passed as the internal (starts at 0) line number.
void lineNumberHandler( int line );
// Instructs the widget to update the loading progress gauge
void updateLoadingProgress( int progress );
// Instructs the widget to display the 'normal' status bar,
// without the progress gauge and with file info
void displayNormalStatus( bool success );
signals:
// Is emitted when new settings must be used
void optionsChanged();
// Is emitted when the 'follow' option is enabled/disabled
void followSet( bool checked );
private:
void createActions();
void createMenus();
void createContextMenu();
void createToolBars();
void createStatusBar();
void createCrawler();
void createRecentFileToolTipTimer();
void readSettings();
void writeSettings();
bool loadFile( const QString& fileName );
void setCurrentFile( const QString& fileName );
void updateRecentFileActions();
QString strippedName( const QString& fullFileName ) const;
// Returns the size in human readable format
QString readableSize( qint64 size ) const;
SavedSearches *savedSearches;
CrawlerWidget *crawlerWidget;
RecentFiles& recentFiles;
QString loadingFileName;
QString currentFile;
QString previousFile;
enum { MaxRecentFiles = 5 };
QAction *recentFileActions[MaxRecentFiles];
MenuActionToolTipBehavior *recentFileActionBehaviors[MaxRecentFiles];
QAction *separatorAction;
QMenu *fileMenu;
QMenu *editMenu;
QMenu *viewMenu;
QMenu *toolsMenu;
QMenu *helpMenu;
InfoLine *infoLine;
QLabel* lineNbField;
QToolBar *toolBar;
QAction *openAction;
QAction *exitAction;
QAction *copyAction;
QAction *selectAllAction;
QAction *findAction;
QAction *overviewVisibleAction;
QAction *lineNumbersVisibleInMainAction;
QAction *lineNumbersVisibleInFilteredAction;
QAction *followAction;
QAction *reloadAction;
QAction *stopAction;
QAction *filtersAction;
QAction *optionsAction;
QAction *aboutAction;
QAction *aboutQtAction;
QIcon mainIcon_;
};
#endif
glogg-0.9.2/marks.cpp 0000664 0000000 0000000 00000004245 12223242463 0014447 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#include "marks.h"
#include "log.h"
#include "utils.h"
// This file implements the list of marks for a file.
// It is implemented as a QList which is kept in order when inserting,
// it is simpler than something fancy like a heap, and insertion are
// not done very often anyway. Oh and we need to iterate through the
// list, disqualifying a straight heap.
Marks::Marks() : marks_()
{
}
void Marks::addMark( qint64 line, QChar mark )
{
// Look for the index immediately before
int index;
if ( ! lookupLineNumber< QList >( marks_, line, &index ) )
{
// If a mark is not already set for this line
LOG(logDEBUG) << "Inserting mark at line " << line
<< " (index " << index << ")";
marks_.insert( index, Mark( line ) );
}
else
{
LOG(logERROR) << "Trying to add an existing mark at line " << line;
}
// 'mark' is not used yet
mark = mark;
}
qint64 Marks::getMark( QChar mark ) const
{
// 'mark' is not used yet
mark = mark;
return 0;
}
bool Marks::isLineMarked( qint64 line ) const
{
int index;
return lookupLineNumber< QList >( marks_, line, &index );
}
void Marks::deleteMark( QChar mark )
{
// 'mark' is not used yet
mark = mark;
}
void Marks::deleteMark( qint64 line )
{
int index;
if ( lookupLineNumber< QList >( marks_, line, &index ) )
{
marks_.removeAt( index );
}
}
void Marks::clear()
{
marks_.clear();
}
glogg-0.9.2/marks.h 0000664 0000000 0000000 00000006227 12223242463 0014116 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#ifndef MARKS_H
#define MARKS_H
#include
#include
// Class encapsulating a single mark
// Contains the line number the mark is identifying.
class Mark {
public:
Mark( int line ) { lineNumber_ = line; };
// Accessors
int lineNumber() const { return lineNumber_; }
private:
int lineNumber_;
};
// A list of marks, i.e. line numbers optionally associated to an
// identifying character.
class Marks {
public:
// Create an empty Marks
Marks();
// Add a mark at the given line, optionally identified by the given char
// If a mark for this char already exist, the previous one is replaced.
// It will happily add marks anywhere, even at stupid indexes.
void addMark( qint64 line, QChar mark = QChar() );
// Get the (unique) mark identified by the passed char.
qint64 getMark( QChar mark ) const;
// Returns wheither the passed line has a mark on it.
bool isLineMarked( qint64 line ) const;
// Delete the mark identified by the passed char.
void deleteMark( QChar mark );
// Delete the mark present on the passed line or do nothing if there is
// none.
void deleteMark( qint64 line );
// Get the line marked identified by the index (in this list) passed.
qint64 getLineMarkedByIndex( int index ) const
{ return marks_[index].lineNumber(); }
// Return the total number of marks
int size() const
{ return marks_.size(); }
// Completely clear the marks list.
void clear();
// Iterator
// Provide a const_iterator for the client to iterate through the marks.
class const_iterator {
public:
const_iterator( QList::const_iterator iter )
{ internal_iter_ = iter; }
const_iterator( const const_iterator& original )
{ internal_iter_ = original.internal_iter_; }
const Mark& operator*()
{ return *internal_iter_; }
const Mark* operator->()
{ return &(*internal_iter_); }
bool operator!=( const const_iterator& other ) const
{ return ( internal_iter_ != other.internal_iter_ ); }
const_iterator& operator++()
{ ++internal_iter_ ; return *this; }
private:
QList::const_iterator internal_iter_;
};
const_iterator begin() const
{ return const_iterator( marks_.begin() ); }
const_iterator end() const
{ return const_iterator( marks_.end() ); }
private:
// List of marks.
QList marks_;
};
#endif
glogg-0.9.2/menuactiontooltipbehavior.cpp 0000664 0000000 0000000 00000007331 12223242463 0020626 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2009, 2010 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#include
#include
#include
#include
#include "menuactiontooltipbehavior.h"
// It would be nice to only need action, and have action be the parent,
// however implementation needs the parent menu (see showToolTip), and
// since neither action nor parent is guaranteed to die before the other,
// for memory-management purposes the parent will have to be specified
// explicity (probably, the window owning the action and the menu).
MenuActionToolTipBehavior::MenuActionToolTipBehavior(QAction *action,
QMenu *parentMenu,
QObject *parent = 0)
: QObject(parent),
action(action),
parentMenu(parentMenu),
toolTipDelayMs(1000),
timerId(0),
hoverPoint()
{
connect(action, SIGNAL(hovered()), this, SLOT(onActionHovered()));
}
int MenuActionToolTipBehavior::toolTipDelay()
{
return toolTipDelayMs;
}
void MenuActionToolTipBehavior::setToolTipDelay(int delayMs)
{
toolTipDelayMs = delayMs;
}
void MenuActionToolTipBehavior::timerEvent(QTimerEvent *event)
{
// Not ours, don't touch
if (event->timerId() != timerId) {
QObject::timerEvent(event);
return;
}
killTimer(timerId); // interested in a single shot
timerId = 0;
// Has the mouse waited unmoved in one location for 'delay' ms?
const QPoint &mousePos = QCursor::pos();
if (hoverPoint == mousePos)
showToolTip(hoverPoint);
}
void MenuActionToolTipBehavior::onActionHovered()
{
const QPoint &mousePos = QCursor::pos();
// Hover is fired on keyboard focus over action in menu, ignore it
const QPoint &relativeMousePos = parentMenu->mapFromGlobal(mousePos);
if (!parentMenu->actionGeometry(action).contains(relativeMousePos)) {
if (timerId != 0) { // once timer expires its check will fail anyway
killTimer(timerId);
timerId = 0;
}
QToolTip::hideText(); // there might be one currently shown
return;
}
// Record location
hoverPoint = mousePos;
// Restart timer
if (timerId != 0)
killTimer(timerId);
timerId = startTimer(toolTipDelayMs);
}
void MenuActionToolTipBehavior::showToolTip(const QPoint &position)
{
const QString &toolTip = action->toolTip();
// Show tooltip until mouse moves at all
// NOTE: using action->parentWidget() which is the MainWindow,
// does not work (tooltip is not cleared when upon leaving the
// region). This is the only reason we need parentMenu here. Just
// a wild guess: maybe it isn't cleared because it would be
// cleared on a mouse move over the designated widget, but mouse
// move doesn't happen over MainWindow, since the mouse is over
// the menu even when out of the activeRegion.
QPoint relativePos = parentMenu->mapFromGlobal(position);
QRect activeRegion(relativePos.x(), relativePos.y(), 1, 1);
QToolTip::showText(position, toolTip, parentMenu, activeRegion);
}
glogg-0.9.2/menuactiontooltipbehavior.h 0000664 0000000 0000000 00000003251 12223242463 0020270 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2009, 2010 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#ifndef MANUACTIONTOOLTIPBEHAVIOR_H
#define MANUACTIONTOOLTIPBEHAVIOR_H
#include
#include
class QAction;
class QMenu;
class QTimerEvent;
// Provides a behavior to show an action's tooltip after mouse is unmoved for
// a specified number of 'ms'. E.g. used for tooltips with full-path for recent
// files in the file menu. Not thread-safe.
class MenuActionToolTipBehavior : public QObject
{
Q_OBJECT;
public:
MenuActionToolTipBehavior(QAction *action, QMenu *parentMenu,
QObject *parent);
// Time in ms that mouse needs to stay unmoved for tooltip to be shown
int toolTipDelay(); /* ms */
void setToolTipDelay(int ms);
private:
void timerEvent(QTimerEvent *event);
void showToolTip(const QPoint &position);
private slots:
void onActionHovered();
private:
QAction *action;
QMenu *parentMenu;
int toolTipDelayMs;
int timerId;
QPoint hoverPoint;
};
#endif
glogg-0.9.2/optionsdialog.cpp 0000664 0000000 0000000 00000012174 12223242463 0016205 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2009, 2010, 2011, 2013 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#include
#include "optionsdialog.h"
#include "log.h"
#include "persistentinfo.h"
#include "configuration.h"
// Constructor
OptionsDialog::OptionsDialog( QWidget* parent ) : QDialog(parent)
{
setupUi( this );
setupFontList();
setupRegexp();
connect(buttonBox, SIGNAL( clicked( QAbstractButton* ) ),
this, SLOT( onButtonBoxClicked( QAbstractButton* ) ) );
connect(fontFamilyBox, SIGNAL( currentIndexChanged(const QString& ) ),
this, SLOT( updateFontSize( const QString& ) ));
connect(incrementalCheckBox, SIGNAL( toggled( bool ) ),
this, SLOT( onIncrementalChanged() ) );
updateDialogFromConfig();
setupIncremental();
}
//
// Private functions
//
// Populates the 'family' ComboBox
void OptionsDialog::setupFontList()
{
QFontDatabase database;
// We only show the fixed fonts
foreach ( const QString &str, database.families() ) {
if ( database.isFixedPitch( str ) )
fontFamilyBox->addItem( str );
}
}
// Populate the regexp ComboBoxes
void OptionsDialog::setupRegexp()
{
QStringList regexpTypes;
regexpTypes << tr("Extended Regexp")
<< tr("Wildcards") << tr("Fixed Strings");
mainSearchBox->addItems( regexpTypes );
quickFindSearchBox->addItems( regexpTypes );
}
// Enable/disable the QuickFind options depending on the state
// of the "incremental" checkbox.
void OptionsDialog::setupIncremental()
{
if ( incrementalCheckBox->isChecked() ) {
quickFindSearchBox->setCurrentIndex(
getRegexpIndex( FixedString ) );
quickFindSearchBox->setEnabled( false );
}
else {
quickFindSearchBox->setEnabled( true );
}
}
// Convert a regexp type to its index in the list
int OptionsDialog::getRegexpIndex( SearchRegexpType syntax ) const
{
return static_cast( syntax );
}
// Convert the index of a regexp type to its type
SearchRegexpType OptionsDialog::getRegexpTypeFromIndex( int index ) const
{
return static_cast( index );;
}
// Updates the dialog box using values in global Config()
void OptionsDialog::updateDialogFromConfig()
{
Configuration& config = Persistent( "settings" );
// Main font
QFontInfo fontInfo = QFontInfo( config.mainFont() );
int familyIndex = fontFamilyBox->findText( fontInfo.family() );
if ( familyIndex != -1 )
fontFamilyBox->setCurrentIndex( familyIndex );
int sizeIndex = fontSizeBox->findText( QString::number(fontInfo.pointSize()) );
if ( sizeIndex != -1 )
fontSizeBox->setCurrentIndex( sizeIndex );
// Regexp types
mainSearchBox->setCurrentIndex(
getRegexpIndex( config.mainRegexpType() ) );
quickFindSearchBox->setCurrentIndex(
getRegexpIndex( config.quickfindRegexpType() ) );
incrementalCheckBox->setChecked( config.isQuickfindIncremental() );
}
//
// Slots
//
void OptionsDialog::updateFontSize(const QString& fontFamily)
{
QFontDatabase database;
QString oldFontSize = fontSizeBox->currentText();
QList sizes = database.pointSizes( fontFamily, "" );
fontSizeBox->clear();
foreach (int size, sizes) {
fontSizeBox->addItem( QString::number(size) );
}
// Now restore the size we had before
int i = fontSizeBox->findText(oldFontSize);
if ( i != -1 )
fontSizeBox->setCurrentIndex(i);
}
void OptionsDialog::updateConfigFromDialog()
{
Configuration& config = Persistent( "settings" );
QFont font = QFont(
fontFamilyBox->currentText(),
(fontSizeBox->currentText()).toInt() );
config.setMainFont(font);
config.setMainRegexpType(
getRegexpTypeFromIndex( mainSearchBox->currentIndex() ) );
config.setQuickfindRegexpType(
getRegexpTypeFromIndex( quickFindSearchBox->currentIndex() ) );
config.setQuickfindIncremental( incrementalCheckBox->isChecked() );
emit optionsChanged();
}
void OptionsDialog::onButtonBoxClicked( QAbstractButton* button )
{
QDialogButtonBox::ButtonRole role = buttonBox->buttonRole( button );
if ( ( role == QDialogButtonBox::AcceptRole )
|| ( role == QDialogButtonBox::ApplyRole ) ) {
updateConfigFromDialog();
}
if ( role == QDialogButtonBox::AcceptRole )
accept();
else if ( role == QDialogButtonBox::RejectRole )
reject();
}
void OptionsDialog::onIncrementalChanged()
{
setupIncremental();
}
glogg-0.9.2/optionsdialog.h 0000664 0000000 0000000 00000003543 12223242463 0015652 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2009, 2010, 2013 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#ifndef OPTIONSDIALOG_H
#define OPTIONSDIALOG_H
#include
#include "configuration.h"
#include "ui_optionsdialog.h"
// Implements the main option dialog box
class OptionsDialog : public QDialog, public Ui::OptionsDialog
{
Q_OBJECT
public:
OptionsDialog(QWidget* parent = 0);
signals:
// Is emitted when new settings must be used
void optionsChanged();
private slots:
// Clears and updates the font size box with the sizes allowed
// by the passed font family.
void updateFontSize(const QString& fontFamily);
// Update the content of the global Config() using parameters
// from the dialog box.
void updateConfigFromDialog();
// Called when a ok/cancel/apply button is clicked.
void onButtonBoxClicked( QAbstractButton* button );
// Called when the 'incremental' button is toggled.
void onIncrementalChanged();
private:
void setupFontList();
void setupRegexp();
void setupIncremental();
int getRegexpIndex( SearchRegexpType syntax ) const;
SearchRegexpType getRegexpTypeFromIndex( int index ) const;
void updateDialogFromConfig();
};
#endif
glogg-0.9.2/optionsdialog.ui 0000664 0000000 0000000 00000007505 12223242463 0016042 0 ustar 00root root 0000000 0000000
OptionsDialog
0
0
411
303
0
0
Options
60
260
341
32
Qt::Horizontal
QDialogButtonBox::Apply|QDialogButtonBox::Cancel|QDialogButtonBox::Ok
11
89
389
161
Search options
10
30
371
111
-
Main search type:
-
-
QuickFind search type:
-
-
Qt::LeftToRight
Incremental QuickFind
11
11
389
71
Font
10
30
371
31
-
Family:
-
-
Size:
-
10
10
true
true
true
glogg-0.9.2/overview.cpp 0000664 0000000 0000000 00000010131 12223242463 0015167 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011, 2012 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
// This file implements the Overview class.
// It provides support for drawing the match overview sidebar but
// the actual drawing is done in AbstractLogView which uses this class.
#include "log.h"
#include "overview.h"
Overview::Overview() : matchLines_(), markLines_()
{
logFilteredData_ = NULL;
linesInFile_ = 0;
topLine_ = 0;
nbLines_ = 0;
height_ = 0;
dirty_ = true;
visible_ = false;
}
Overview::~Overview()
{
}
void Overview::setFilteredData( const LogFilteredData* logFilteredData )
{
logFilteredData_ = logFilteredData;
}
void Overview::updateData( int totalNbLine )
{
LOG(logDEBUG) << "OverviewWidget::updateData " << totalNbLine;
linesInFile_ = totalNbLine;
dirty_ = true;
}
void Overview::updateView( int height )
{
// We don't touch the cache if the height hasn't changed
if ( ( height != height_ ) || ( dirty_ == true ) ) {
height_ = height;
recalculatesLines();
}
}
const QVector* Overview::getMatchLines() const
{
return &matchLines_;
}
const QVector* Overview::getMarkLines() const
{
return &markLines_;
}
std::pair Overview::getViewLines() const
{
int top = 0;
int bottom = height_ - 1;
if ( linesInFile_ > 0 ) {
top = (int)((qint64)topLine_ * height_ / linesInFile_);
bottom = (int)((qint64)top + nbLines_ * height_ / linesInFile_);
}
return std::pair(top, bottom);
}
int Overview::fileLineFromY( int position ) const
{
int line = (int)((qint64)position * linesInFile_ / height_);
return line;
}
int Overview::yFromFileLine( int file_line ) const
{
int position = 0;
if ( linesInFile_ > 0 )
position = (int)((qint64)file_line * height_ / linesInFile_);
return position;
}
// Update the internal cache
void Overview::recalculatesLines()
{
LOG(logDEBUG) << "OverviewWidget::recalculatesLines";
if ( logFilteredData_ != NULL ) {
matchLines_.clear();
markLines_.clear();
for ( int i = 0; i < logFilteredData_->getNbLine(); i++ ) {
LogFilteredData::FilteredLineType line_type =
logFilteredData_->filteredLineTypeByIndex( i );
int line = (int) logFilteredData_->getMatchingLineNumber( i );
int position = (int)( (qint64)line * height_ / linesInFile_ );
if ( line_type == LogFilteredData::Match ) {
if ( ( ! matchLines_.isEmpty() ) && matchLines_.last().position() == position ) {
// If the line is already there, we increase its weight
matchLines_.last().load();
}
else {
// If not we just add it
matchLines_.append( WeightedLine( position ) );
}
}
else {
if ( ( ! markLines_.isEmpty() ) && markLines_.last().position() == position ) {
// If the line is already there, we increase its weight
markLines_.last().load();
}
else {
// If not we just add it
markLines_.append( WeightedLine( position ) );
}
}
}
}
else
LOG(logERROR) << "Overview::recalculatesLines: logFilteredData_ == NULL";
dirty_ = false;
}
glogg-0.9.2/overview.h 0000664 0000000 0000000 00000007672 12223242463 0014654 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011, 2012 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#ifndef OVERVIEW_H
#define OVERVIEW_H
#include
#include "logfiltereddata.h"
// Class implementing the logic behind the matches overview bar.
// This class converts the matches found in a LogFilteredData in
// a screen dependent set of coloured lines, which is cached.
// This class is not a UI class, actual display is left to the client.
//
// This class is NOT thread-safe.
class Overview
{
public:
// A line with a position in pixel and a weight (darkness)
class WeightedLine {
public:
static const int WEIGHT_STEPS = 3;
WeightedLine() { pos_ = 0; weight_ = 0; }
// (Necessary for QVector)
WeightedLine( int pos ) { pos_ = pos; weight_ = 0; }
int position() const { return pos_; }
int weight() const { return weight_; }
void load() { weight_ = qMin( weight_ + 1, WEIGHT_STEPS - 1 ); }
private:
int pos_;
int weight_;
};
Overview();
~Overview();
// Associate the passed filteredData to this Overview
void setFilteredData( const LogFilteredData* logFilteredData );
// Signal the overview its attached LogFilteredData has been changed and
// the overview must be updated with the provided total number
// of line of the file.
void updateData( int totalNbLine );
// Set the visibility flag of this overview.
void setVisible( bool visible ) { visible_ = visible; dirty_ = visible; }
// Update the current position in the file (to draw the view line)
void updateCurrentPosition( int firstLine, int lastLine )
{ topLine_ = firstLine; nbLines_ = lastLine - firstLine; }
// Returns weither this overview is visible.
bool isVisible() { return visible_; }
// Signal the overview the height of the display has changed, triggering
// an update of its cache.
void updateView( int height );
// Returns a list of lines (between 0 and 'height') representing matches.
// (pointer returned is valid until next call to update*()
const QVector* getMatchLines() const;
// Returns a list of lines (between 0 and 'height') representing marks.
// (pointer returned is valid until next call to update*()
const QVector* getMarkLines() const;
// Return a pair of lines (between 0 and 'height') representing the current view.
std::pair getViewLines() const;
// Return the line number corresponding to the passed overview y coordinate.
int fileLineFromY( int y ) const;
// Return the y coordinate corresponding to the passed line number.
int yFromFileLine( int file_line ) const;
private:
// List of matches associated with this Overview.
const LogFilteredData* logFilteredData_;
// Total number of lines in the file.
int linesInFile_;
// Whether the overview is visible.
bool visible_;
// First and last line currently viewed.
int topLine_;
int nbLines_;
// Current height of view window.
int height_;
// Does the cache (matchesLines, markLines) need to be recalculated.
int dirty_;
// List of lines representing matches and marks (are shared with the client)
QVector matchLines_;
QVector markLines_;
void recalculatesLines();
};
#endif
glogg-0.9.2/overviewwidget.cpp 0000664 0000000 0000000 00000020447 12223242463 0016406 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011, 2012, 2013 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
// This file implements OverviewWidget. This class is responsable for
// managing and painting the matches overview widget.
#include
#include
#include
#include "log.h"
#include "overviewwidget.h"
#include "overview.h"
// Graphic parameters
const int OverviewWidget::LINE_MARGIN = 4;
const int OverviewWidget::STEP_DURATION_MS = 30;
const int OverviewWidget::INITIAL_TTL_VALUE = 5;
#define HIGHLIGHT_XPM_WIDTH 27
#define HIGHLIGHT_XPM_HEIGHT 9
#define S(x) #x
#define SX(x) S(x)
// width height colours char/pixel
// Colours
#define HIGHLIGHT_XPM_LEAD_LINE SX(HIGHLIGHT_XPM_WIDTH) " " SX(HIGHLIGHT_XPM_HEIGHT) " 2 1",\
" s mask c none",\
"x c #572F80"
const char* const highlight_xpm[][14] = {
{
HIGHLIGHT_XPM_LEAD_LINE,
" ",
" ",
" xxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxx ",
" xx xx ",
" xx xx ",
" xx xx ",
" xxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxx ",
" ",
" ",
},
{
HIGHLIGHT_XPM_LEAD_LINE,
" ",
" xxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxx ",
" xxx xxx ",
" xxx xxx ",
" xxx xxx ",
" xxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxx ",
" ",
},
{
HIGHLIGHT_XPM_LEAD_LINE,
" xxxxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxxxx ",
" xxxx xxxx ",
" xxxx xxxx ",
" xxxx xxxx ",
" xxxxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxxxx ",
},
{
HIGHLIGHT_XPM_LEAD_LINE,
" ",
" xxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxx ",
" xxx xxx ",
" xxx xxx ",
" xxx xxx ",
" xxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxxxx ",
" ",
},
{
HIGHLIGHT_XPM_LEAD_LINE,
" ",
" ",
" xxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxx ",
" xx xx ",
" xx xx ",
" xx xx ",
" xxxxxxxxxxxxxxxxxxxxx ",
" xxxxxxxxxxxxxxxxxxxxx ",
" ",
" ",
},
{
HIGHLIGHT_XPM_LEAD_LINE,
" ",
" ",
" ",
" xxxxxxxxxxxxxxxxxxx ",
" x x ",
" x x ",
" x x ",
" xxxxxxxxxxxxxxxxxxx ",
" ",
" ",
" ",
},
};
OverviewWidget::OverviewWidget( QWidget* parent ) :
QWidget( parent ), highlightTimer_()
{
overview_ = NULL;
setBackgroundRole( QPalette::Window );
// Highlight
highlightedLine_ = -1;
highlightedTTL_ = 0;
// We should be hidden by default (e.g. for the FilteredView)
hide();
}
void OverviewWidget::paintEvent( QPaintEvent* paintEvent )
{
LOG(logDEBUG) << "OverviewWidget::paintEvent";
static const QColor match_color("red");
static const QColor mark_color("dodgerblue");
static const QPixmap highlight_pixmap[] = {
QPixmap( highlight_xpm[0] ),
QPixmap( highlight_xpm[1] ),
QPixmap( highlight_xpm[2] ),
QPixmap( highlight_xpm[3] ),
QPixmap( highlight_xpm[4] ),
QPixmap( highlight_xpm[5] ), };
// We must be hidden until we have an Overview
assert( overview_ != NULL );
overview_->updateView( height() );
{
QPainter painter( this );
// The line separating from the main view
painter.setPen( palette().color(QPalette::Text) );
painter.drawLine( 0, 0, 0, height() );
// The 'match' lines
painter.setPen( match_color );
foreach (Overview::WeightedLine line, *(overview_->getMatchLines()) ) {
painter.setOpacity( ( 1.0 / Overview::WeightedLine::WEIGHT_STEPS )
* ( line.weight() + 1 ) );
// (allow multiple matches to look 'darker' than a single one.)
painter.drawLine( 1 + LINE_MARGIN,
line.position(), width() - LINE_MARGIN - 1, line.position() );
}
// The 'mark' lines
painter.setPen( mark_color );
foreach (Overview::WeightedLine line, *(overview_->getMarkLines()) ) {
painter.setOpacity( ( 1.0 / Overview::WeightedLine::WEIGHT_STEPS )
* ( line.weight() + 1 ) );
// (allow multiple matches to look 'darker' than a single one.)
painter.drawLine( 1 + LINE_MARGIN,
line.position(), width() - LINE_MARGIN - 1, line.position() );
}
// The 'view' lines
painter.setOpacity( 1 );
painter.setPen( palette().color(QPalette::Text) );
std::pair view_lines = overview_->getViewLines();
painter.drawLine( 1, view_lines.first, width(), view_lines.first );
painter.drawLine( 1, view_lines.second, width(), view_lines.second );
// The highlight
if ( highlightedLine_ >= 0 ) {
/*
QPen highlight_pen( palette().color(QPalette::Text) );
highlight_pen.setWidth( 4 - highlightedTTL_ );
painter.setOpacity( 1 );
painter.setPen( highlight_pen );
painter.drawRect( 2, position - 2, width() - 2 - 2, 4 );
*/
int position = overview_->yFromFileLine( highlightedLine_ );
painter.drawPixmap(
( width() - HIGHLIGHT_XPM_WIDTH ) / 2,
position - ( HIGHLIGHT_XPM_HEIGHT / 2 ),
highlight_pixmap[ INITIAL_TTL_VALUE - highlightedTTL_ ] );
}
}
}
void OverviewWidget::mousePressEvent( QMouseEvent* mouseEvent )
{
if ( mouseEvent->button() == Qt::LeftButton )
handleMousePress( mouseEvent->y() );
}
void OverviewWidget::mouseMoveEvent( QMouseEvent* mouseEvent )
{
if ( mouseEvent->buttons() |= Qt::LeftButton )
handleMousePress( mouseEvent->y() );
}
void OverviewWidget::handleMousePress( int position )
{
int line = overview_->fileLineFromY( position );
LOG(logDEBUG) << "OverviewWidget::handleMousePress y=" << position << " line=" << line;
emit lineClicked( line );
}
void OverviewWidget::highlightLine( qint64 line )
{
highlightTimer_.stop();
highlightedLine_ = line;
highlightedTTL_ = INITIAL_TTL_VALUE;
update();
highlightTimer_.start( STEP_DURATION_MS, this );
}
void OverviewWidget::removeHighlight()
{
highlightTimer_.stop();
highlightedLine_ = -1;
update();
}
void OverviewWidget::timerEvent( QTimerEvent* event )
{
if ( event->timerId() == highlightTimer_.timerId() ) {
LOG(logDEBUG) << "OverviewWidget::timerEvent";
if ( highlightedTTL_ > 0 ) {
--highlightedTTL_;
update();
}
else {
highlightTimer_.stop();
}
}
else {
QObject::timerEvent( event );
}
}
glogg-0.9.2/overviewwidget.h 0000664 0000000 0000000 00000003717 12223242463 0016054 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011, 2012, 2013 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#ifndef OVERVIEWWIDGET_H
#define OVERVIEWWIDGET_H
#include
#include
class Overview;
class OverviewWidget : public QWidget
{
Q_OBJECT
public:
OverviewWidget( QWidget* parent = 0 );
// Associate the widget with an Overview object.
void setOverview( Overview* overview ) { overview_ = overview; }
public slots:
// Sent when a match at the line passed must be highlighted in
// the overview
void highlightLine( qint64 line );
void removeHighlight();
protected:
void paintEvent( QPaintEvent* paintEvent );
void mousePressEvent( QMouseEvent* mouseEvent );
void mouseMoveEvent( QMouseEvent* mouseEvent );
void timerEvent( QTimerEvent* event );
signals:
// Sent when the user click on a line in the Overview.
void lineClicked( int line );
private:
// Constants
static const int LINE_MARGIN;
static const int STEP_DURATION_MS;
static const int INITIAL_TTL_VALUE;
Overview* overview_;
// Highlight:
// Which line is higlighted, or -1 if none
int highlightedLine_;
// Number of step until the highlight become static
int highlightedTTL_;
QBasicTimer highlightTimer_;
void handleMousePress( int position );
};
#endif
glogg-0.9.2/persistable.h 0000664 0000000 0000000 00000002205 12223242463 0015306 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#ifndef PERSISTABLE_H
#define PERSISTABLE_H
class QSettings;
// Must be implemented by classes which could be saved to persistent
// storage by PersistentInfo.
class Persistable {
public:
virtual ~Persistable() {}
// Must be implemented to save/retrieve from Qt Settings
virtual void saveToStorage( QSettings& settings ) const = 0;
virtual void retrieveFromStorage( QSettings& settings ) = 0;
};
#endif
glogg-0.9.2/persistentinfo.cpp 0000664 0000000 0000000 00000006220 12223242463 0016401 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
// Implements PersistentInfo, a singleton class which store/retrieve objects
// to persistent storage.
#include "persistentinfo.h"
#include
#include
#include "log.h"
#include "persistable.h"
PersistentInfo::PersistentInfo()
{
settings_ = NULL;
initialised_ = false;
}
PersistentInfo::~PersistentInfo()
{
if ( initialised_ )
delete settings_;
}
void PersistentInfo::migrateAndInit()
{
assert( initialised_ == false );
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
// On Windows, we use .ini files and import from the registry if no
// .ini file is found (glogg <= 0.9 used the registry).
// This store the config file in %appdata%
settings_ = new QSettings( QSettings::IniFormat,
QSettings::UserScope, "glogg", "glogg" );
if ( settings_->childKeys().count() == 0 ) {
LOG(logWARNING) << "INI file empty, trying to import from registry";
QSettings registry( "glogg", "glogg" );
foreach ( QString key, registry.allKeys() ) {
settings_->setValue( key, registry.value( key ) );
}
}
#else
// We use default Qt storage on proper OSes
settings_ = new QSettings( "glogg", "glogg" );
#endif
initialised_ = true;
}
void PersistentInfo::registerPersistable( Persistable* object,
const QString& name )
{
assert( initialised_ );
objectList_.insert( name, object );
}
Persistable* PersistentInfo::getPersistable( const QString& name )
{
assert( initialised_ );
Persistable* object = objectList_.value( name, NULL );
return object;
}
void PersistentInfo::save( const QString& name )
{
assert( initialised_ );
if ( objectList_.contains( name ) )
objectList_.value( name )->saveToStorage( *settings_ );
else
LOG(logERROR) << "Unregistered persistable " << name.toStdString();
// Sync to ensure it is propagated to other processes
settings_->sync();
}
void PersistentInfo::retrieve( const QString& name )
{
assert( initialised_ );
// Sync to ensure it has been propagated from other processes
settings_->sync();
if ( objectList_.contains( name ) )
objectList_.value( name )->retrieveFromStorage( *settings_ );
else
LOG(logERROR) << "Unregistered persistable " << name.toStdString();
}
// Friend function to construct/get the singleton
PersistentInfo& GetPersistentInfo()
{
static PersistentInfo pInfo;
return pInfo;
}
glogg-0.9.2/persistentinfo.h 0000664 0000000 0000000 00000004465 12223242463 0016057 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#ifndef PERSISTENTINFO_H
#define PERSISTENTINFO_H
#include
#include
class Persistable;
// Singleton class managing the saving of persistent data to permanent storage
// Clients must implement Persistable and register with this object, they can
// then be saved/loaded.
class PersistentInfo {
public:
// Initialise the storage backend for the Persistable, migrating the settings
// if needed. Must be called before any other function.
void migrateAndInit();
// Register a Persistable
void registerPersistable( Persistable* object, const QString& name );
// Get a Persistable (or NULL if it doesn't exist)
Persistable* getPersistable( const QString& name );
// Save a persistable to its permanent storage
void save( const QString& name );
// Retrieve a persistable from permanent storage
void retrieve( const QString& name );
private:
// Can't be constructed or copied (singleton)
PersistentInfo();
PersistentInfo( const PersistentInfo& );
~PersistentInfo();
// Has migrateAndInit() been called?
bool initialised_;
// List of persistables
QHash objectList_;
// Qt setting object
QSettings* settings_;
// allow this function to create one instance
friend PersistentInfo& GetPersistentInfo();
};
PersistentInfo& GetPersistentInfo();
// Global function used to get an object from the PersistentInfo store
template
T& Persistent( const char* name )
{
Persistable* p = GetPersistentInfo().getPersistable( QString( name ) );
return dynamic_cast(*p);
}
#endif
glogg-0.9.2/qfnotifications.h 0000664 0000000 0000000 00000004050 12223242463 0016171 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#ifndef QFNOTIFICATIONS_H
#define QFNOTIFICATIONS_H
#include
#include
#include
// Notifications sent by the QF for displaying to the user
// and their translation in UI text.
class QFNotification {
public:
virtual QString message() const = 0;
// Max width of the message (in pixels)
static int maxWidth( const QWidget* widget ) {
QFontMetrics fm = widget->fontMetrics();
return qMax( fm.size( Qt::TextSingleLine, REACHED_BOF ).width(),
fm.size( Qt::TextSingleLine, REACHED_EOF ).width() );
}
protected:
static const QString REACHED_EOF;
static const QString REACHED_BOF;
};
class QFNotificationReachedEndOfFile : public QFNotification
{
QString message() const {
return REACHED_EOF;
}
};
class QFNotificationReachedBegininningOfFile : public QFNotification
{
QString message() const {
return REACHED_BOF;
}
};
class QFNotificationProgress : public QFNotification {
public:
// Constructor taking the progress (in percent)
QFNotificationProgress( int progress_percent )
{ progressPercent_ = progress_percent; }
QString message() const {
return QString( QObject::tr("Searching (position %1 %)")
.arg( progressPercent_ ) );
}
private:
int progressPercent_;
};
#endif
glogg-0.9.2/quickfind.cpp 0000664 0000000 0000000 00000026155 12223242463 0015313 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2010, 2013 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
// This file implements QuickFind.
// This class implements the Quick Find mechanism using references
// to the logData, the QFP and the selection passed.
// Search is started just after the selection and the selection is updated
// if a match is found.
#include
#include "log.h"
#include "quickfindpattern.h"
#include "selection.h"
#include "quickfind.h"
void SearchingNotifier::reset()
{
dotToDisplay_ = 0;
startTime_ = QTime::currentTime();
}
void SearchingNotifier::sendNotification( qint64 current_line, qint64 nb_lines )
{
LOG( logDEBUG ) << "Emitting Searching....";
qint64 progress;
if ( current_line < 0 )
progress = ( nb_lines + current_line ) * 100 / nb_lines;
else
progress = current_line * 100 / nb_lines;
emit notify( QFNotificationProgress( progress ) );
QApplication::processEvents( QEventLoop::ExcludeUserInputEvents );
startTime_ = QTime::currentTime().addMSecs( -800 );
}
void QuickFind::LastMatchPosition::set( int line, int column )
{
if ( ( line_ == -1 ) ||
( ( line <= line_ ) && ( column < column_ ) ) )
{
line_ = line;
column_ = column;
}
}
void QuickFind::LastMatchPosition::set( const FilePosition &position )
{
set( position.line(), position.column() );
}
bool QuickFind::LastMatchPosition::isLater( int line, int column ) const
{
if ( line_ == -1 )
return false;
else if ( ( line == line_ ) && ( column >= column_ ) )
return true;
else if ( line > line_ )
return true;
else
return false;
}
bool QuickFind::LastMatchPosition::isLater( const FilePosition &position ) const
{
return isLater( position.line(), position.column() );
}
bool QuickFind::LastMatchPosition::isSooner( int line, int column ) const
{
if ( line_ == -1 )
return false;
else if ( ( line == line_ ) && ( column <= column_ ) )
return true;
else if ( line < line_ )
return true;
else
return false;
}
bool QuickFind::LastMatchPosition::isSooner( const FilePosition &position ) const
{
return isSooner( position.line(), position.column() );
}
QuickFind::QuickFind( const AbstractLogData* const logData,
Selection* selection,
const QuickFindPattern* const quickFindPattern ) :
logData_( logData ), selection_( selection ),
quickFindPattern_( quickFindPattern ),
lastMatch_(), firstMatch_(), searchingNotifier_(),
incrementalSearchStatus_()
{
connect( &searchingNotifier_, SIGNAL( notify( const QFNotification& ) ),
this, SIGNAL( notify( const QFNotification& ) ) );
}
void QuickFind::incrementalSearchStop()
{
if ( incrementalSearchStatus_.isOngoing() ) {
if ( selection_->isEmpty() ) {
// Nothing found?
// We reset the selection to what it was
*selection_ = incrementalSearchStatus_.initialSelection();
}
incrementalSearchStatus_ = IncrementalSearchStatus();
}
}
void QuickFind::incrementalSearchAbort()
{
if ( incrementalSearchStatus_.isOngoing() ) {
// We reset the selection to what it was
*selection_ = incrementalSearchStatus_.initialSelection();
incrementalSearchStatus_ = IncrementalSearchStatus();
}
}
qint64 QuickFind::incrementallySearchForward()
{
LOG( logDEBUG ) << "QuickFind::incrementallySearchForward";
// Position where we start the search from
FilePosition start_position = selection_->getNextPosition();
if ( incrementalSearchStatus_.direction() == Forward ) {
// An incremental search is active, we restart the search
// from the initial point
LOG( logDEBUG ) << "Restart search from initial point";
start_position = incrementalSearchStatus_.position();
}
else {
// It's a new search so we search from the selection
incrementalSearchStatus_ = IncrementalSearchStatus(
Forward,
start_position,
*selection_ );
}
qint64 line_found = doSearchForward( start_position );
if ( line_found >= 0 ) {
// We have found a result...
// ... the caller will jump to this line.
return line_found;
}
else {
// No result...
// ... we want the client to show the initial line.
selection_->clear();
return incrementalSearchStatus_.position().line();
}
}
qint64 QuickFind::incrementallySearchBackward()
{
LOG( logDEBUG ) << "QuickFind::incrementallySearchBackward";
// Position where we start the search from
FilePosition start_position = selection_->getPreviousPosition();
if ( incrementalSearchStatus_.direction() == Backward ) {
// An incremental search is active, we restart the search
// from the initial point
LOG( logDEBUG ) << "Restart search from initial point";
start_position = incrementalSearchStatus_.position();
}
else {
// It's a new search so we search from the selection
incrementalSearchStatus_ = IncrementalSearchStatus(
Backward,
start_position,
*selection_ );
}
qint64 line_found = doSearchBackward( start_position );
if ( line_found >= 0 ) {
// We have found a result...
// ... the caller will jump to this line.
return line_found;
}
else {
// No result...
// ... we want the client to show the initial line.
selection_->clear();
return incrementalSearchStatus_.position().line();
}
}
qint64 QuickFind::searchForward()
{
incrementalSearchStatus_ = IncrementalSearchStatus();
// Position where we start the search from
FilePosition start_position = selection_->getNextPosition();
return doSearchForward( start_position );
}
qint64 QuickFind::searchBackward()
{
incrementalSearchStatus_ = IncrementalSearchStatus();
// Position where we start the search from
FilePosition start_position = selection_->getPreviousPosition();
return doSearchBackward( start_position );
}
// Internal implementation of forward search,
// returns the line where the pattern is found or -1 if not found.
// Parameters are the position the search shall start
qint64 QuickFind::doSearchForward( const FilePosition &start_position )
{
bool found = false;
int found_start_col;
int found_end_col;
if ( ! quickFindPattern_->isActive() )
return -1;
// Optimisation: if we are already after the last match,
// we don't do any search at all.
if ( lastMatch_.isLater( start_position ) ) {
// Send a notification
emit notify( QFNotificationReachedEndOfFile() );
return -1;
}
qint64 line = start_position.line();
LOG( logDEBUG ) << "Start searching at line " << line;
// We look at the rest of the first line
if ( quickFindPattern_->isLineMatching(
logData_->getExpandedLineString( line ),
start_position.column() ) ) {
quickFindPattern_->getLastMatch( &found_start_col, &found_end_col );
found = true;
}
else {
searchingNotifier_.reset();
// And then the rest of the file
qint64 nb_lines = logData_->getNbLine();
line++;
while ( line < nb_lines ) {
if ( quickFindPattern_->isLineMatching(
logData_->getExpandedLineString( line ) ) ) {
quickFindPattern_->getLastMatch(
&found_start_col, &found_end_col );
found = true;
break;
}
line++;
// See if we need to notify of the ongoing search
searchingNotifier_.ping( line, nb_lines );
}
}
if ( found ) {
selection_->selectPortion(
line, found_start_col, found_end_col );
// Clear any notification
emit clearNotification();
return line;
}
else {
// Update the position of the last match
FilePosition last_match_position = selection_->getPreviousPosition();
lastMatch_.set( last_match_position );
// Send a notification
emit notify( QFNotificationReachedEndOfFile() );
return -1;
}
}
// Internal implementation of backward search,
// returns the line where the pattern is found or -1 if not found.
// Parameters are the position the search shall start
qint64 QuickFind::doSearchBackward( const FilePosition &start_position )
{
bool found = false;
int start_col;
int end_col;
if ( ! quickFindPattern_->isActive() )
return -1;
// Optimisation: if we are already before the first match,
// we don't do any search at all.
if ( firstMatch_.isSooner( start_position ) ) {
// Send a notification
emit notify( QFNotificationReachedBegininningOfFile() );
return -1;
}
qint64 line = start_position.line();
LOG( logDEBUG ) << "Start searching at line " << line;
// We look at the beginning of the first line
if ( ( start_position.column() > 0 )
&& ( quickFindPattern_->isLineMatchingBackward(
logData_->getExpandedLineString( line ),
start_position.column() ) )
) {
quickFindPattern_->getLastMatch( &start_col, &end_col );
found = true;
}
else {
searchingNotifier_.reset();
// And then the rest of the file
qint64 nb_lines = logData_->getNbLine();
line--;
while ( line >= 0 ) {
if ( quickFindPattern_->isLineMatchingBackward(
logData_->getExpandedLineString( line ) ) ) {
quickFindPattern_->getLastMatch( &start_col, &end_col );
found = true;
break;
}
line--;
// See if we need to notify of the ongoing search
searchingNotifier_.ping( -line, nb_lines );
}
}
if ( found )
{
selection_->selectPortion( line, start_col, end_col );
// Clear any notification
emit clearNotification();
return line;
}
else {
// Update the position of the first match
FilePosition first_match_position = selection_->getNextPosition();
firstMatch_.set( first_match_position );
// Send a notification
LOG( logDEBUG ) << "Send notification.";
emit notify( QFNotificationReachedBegininningOfFile() );
return -1;
}
}
void QuickFind::resetLimits()
{
lastMatch_.reset();
firstMatch_.reset();
}
glogg-0.9.2/quickfind.h 0000664 0000000 0000000 00000014266 12223242463 0014760 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2010, 2013 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#ifndef QUICKFIND_H
#define QUICKFIND_H
#include
#include
#include
#include "utils.h"
#include "qfnotifications.h"
#include "selection.h"
class QuickFindPattern;
class AbstractLogData;
class Portion;
// Handle "long processing" notifications to the UI.
// reset() shall be called at the beginning of the search
// and then ping() should be called periodically during the processing.
// The notify() signal should be forwarded to the UI.
class SearchingNotifier : public QObject
{
Q_OBJECT
public:
SearchingNotifier() {};
// Reset internal timers at the beiginning of the processing
void reset();
// Shall be called frequently during processing, send the notification
// and call the event loop when appropriate.
// Pass the current line number and total number of line so that
// a progress percentage is calculated and displayed.
// (line shall be negative if ging in reverse)
inline void ping( qint64 line, qint64 nb_lines ) {
if ( startTime_.msecsTo( QTime::currentTime() ) > 1000 )
sendNotification( line, nb_lines );
}
signals:
// Sent when the UI shall display a message to the user.
void notify( const QFNotification& message );
private:
void sendNotification( qint64 current_line, qint64 nb_lines );
QTime startTime_;
int dotToDisplay_;
};
// Represents a search made with Quick Find (without its results)
// it keeps a pointer to a set of data and to a QuickFindPattern which
// are used for the searches. (the caller retains ownership of both).
class QuickFind : public QObject
{
Q_OBJECT
public:
// Construct a search
QuickFind( const AbstractLogData* const logData, Selection* selection,
const QuickFindPattern* const quickFindPattern );
// Set the starting point that will be used by the next search
void setSearchStartPoint( QPoint startPoint );
// Used for incremental searches
// Return the first occurence of the passed pattern from the starting
// point. These searches don't use the QFP and don't change the
// starting point.
// TODO Update comment
qint64 incrementallySearchForward();
qint64 incrementallySearchBackward();
// Stop the currently ongoing incremental search, leave the selection
// where it is if a match has been found, restore the old one
// if not. Also throw away the start point associated with
// the search.
void incrementalSearchStop();
// Throw away the current search and restore the initial
// position/selection
void incrementalSearchAbort();
// Used for 'repeated' (n/N) QF searches using the current direction
// Return the line of the first occurence of the QFP and
// update the selection. It returns -1 if nothing is found.
/*
int searchNext();
int searchPrevious();
*/
// Idem but ignore the direction and always search in the
// specified direction
qint64 searchForward();
qint64 searchBackward();
// Make the object forget the 'no more match' flag.
void resetLimits();
signals:
// Sent when the UI shall display a message to the user.
void notify( const QFNotification& message );
// Sent when the UI shall clear the notification.
void clearNotification();
private:
enum QFDirection {
None,
Forward,
Backward,
};
class LastMatchPosition {
public:
LastMatchPosition() : line_( -1 ), column_( -1 ) {}
void set( int line, int column );
void set( const FilePosition& position );
void reset() { line_ = -1; column_ = -1; }
// Does the passed position come after the recorded one
bool isLater( int line, int column ) const;
bool isLater( const FilePosition& position ) const;
// Does the passed position come before the recorded one
bool isSooner( int line, int column ) const;
bool isSooner( const FilePosition& position ) const;
private:
int line_;
int column_;
};
class IncrementalSearchStatus {
public:
/* Constructors */
IncrementalSearchStatus() :
ongoing_( None ), position_(), initialSelection_() {}
IncrementalSearchStatus(
QFDirection direction,
const FilePosition& position,
const Selection& initial_selection ) :
ongoing_( direction ),
position_( position ),
initialSelection_( initial_selection ) {}
bool isOngoing() const { return ( ongoing_ != None ); }
QFDirection direction() const { return ongoing_; }
FilePosition position() const { return position_; }
Selection initialSelection() const { return initialSelection_; }
private:
QFDirection ongoing_;
FilePosition position_;
Selection initialSelection_;
};
// Pointers to external objects
const AbstractLogData* const logData_;
Selection* selection_;
const QuickFindPattern* const quickFindPattern_;
// Owned objects
// Position of the last match in the file
// (to avoid searching multiple times where there is no result)
LastMatchPosition lastMatch_;
LastMatchPosition firstMatch_;
SearchingNotifier searchingNotifier_;
// Incremental search status
IncrementalSearchStatus incrementalSearchStatus_;
// Private functions
qint64 doSearchForward( const FilePosition &start_position );
qint64 doSearchBackward( const FilePosition &start_position );
};
#endif
glogg-0.9.2/quickfindmux.cpp 0000664 0000000 0000000 00000012307 12223242463 0016037 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#include "log.h"
#include "persistentinfo.h"
#include "configuration.h"
#include "quickfindmux.h"
QuickFindMux::QuickFindMux( const QuickFindMuxSelectorInterface* selector ) :
QObject(), pattern_()
{
// The selector object we will use when forwarding search requests
selector_ = selector;
// Forward the pattern's signal to our listeners
connect( &pattern_, SIGNAL( patternUpdated() ),
this, SLOT( notifyPatternChanged() ) );
}
//
// Public member functions
//
void QuickFindMux::registerSearchable( QObject* searchable )
{
// The searchable can change our qf pattern
connect( searchable,
SIGNAL( changeQuickFind( const QString&, QuickFindMux::QFDirection ) ),
this, SLOT( changeQuickFind( const QString&, QuickFindMux::QFDirection ) ) );
// Send us notifications
connect( searchable, SIGNAL( notifyQuickFind( const QFNotification& ) ),
this, SIGNAL( notify( const QFNotification& ) ) );
// And clear them
connect( searchable, SIGNAL( clearQuickFindNotification() ),
this, SIGNAL( clearNotification() ) );
// Search can be initiated by the view itself
connect( searchable, SIGNAL( searchNext() ),
this, SLOT( searchNext() ) );
connect( searchable, SIGNAL( searchPrevious() ),
this, SLOT( searchPrevious() ) );
}
void QuickFindMux::unregisterSearchable( QObject* searchable )
{
disconnect( searchable );
}
void QuickFindMux::setDirection( QFDirection direction )
{
LOG(logDEBUG) << "QuickFindMux::setDirection: new direction: " << direction;
currentDirection_ = direction;
}
//
// Public slots
//
void QuickFindMux::searchNext()
{
LOG(logDEBUG) << "QuickFindMux::searchNext";
if ( currentDirection_ == Forward )
searchForward();
else
searchBackward();
}
void QuickFindMux::searchPrevious()
{
LOG(logDEBUG) << "QuickFindMux::searchPrevious";
if ( currentDirection_ == Forward )
searchBackward();
else
searchForward();
}
void QuickFindMux::searchForward()
{
LOG(logDEBUG) << "QuickFindMux::searchForward";
SearchableWidgetInterface* searchable = getSearchableWidget();
searchable->searchForward();
}
void QuickFindMux::searchBackward()
{
LOG(logDEBUG) << "QuickFindMux::searchBackward";
SearchableWidgetInterface* searchable = getSearchableWidget();
searchable->searchBackward();
}
void QuickFindMux::setNewPattern(
const QString& new_pattern, bool ignore_case )
{
static Configuration& config = Persistent( "settings" );
LOG(logDEBUG) << "QuickFindMux::setNewPattern";
pattern_.changeSearchPattern( new_pattern, ignore_case );
// If we must do an incremental search, we do it now
if ( config.isQuickfindIncremental() ) {
SearchableWidgetInterface* searchable = getSearchableWidget();
if ( currentDirection_ == Forward )
searchable->incrementallySearchForward();
else
searchable->incrementallySearchBackward();
}
}
void QuickFindMux::confirmPattern(
const QString& new_pattern, bool ignore_case )
{
static Configuration& config = Persistent( "settings" );
pattern_.changeSearchPattern( new_pattern, ignore_case );
// if non-incremental, we perform the search now
if ( ! config.isQuickfindIncremental() ) {
searchNext();
}
else {
SearchableWidgetInterface* searchable = getSearchableWidget();
searchable->incrementalSearchStop();
}
}
void QuickFindMux::cancelSearch()
{
static Configuration& config = Persistent( "settings" );
if ( config.isQuickfindIncremental() ) {
SearchableWidgetInterface* searchable = getSearchableWidget();
searchable->incrementalSearchAbort();
}
}
//
// Private slots
//
void QuickFindMux::changeQuickFind(
const QString& new_pattern, QFDirection new_direction )
{
pattern_.changeSearchPattern( new_pattern );
setDirection( new_direction );
}
void QuickFindMux::notifyPatternChanged()
{
emit patternChanged( pattern_.getPattern() );
}
//
// Private member functions
//
// Use the registered 'selector' to determine where to send the search requests.
SearchableWidgetInterface* QuickFindMux::getSearchableWidget() const
{
SearchableWidgetInterface* searchable = NULL;
if ( selector_ )
searchable = selector_->getActiveSearchable();
else
LOG(logERROR) << "QuickFindMux::getActiveSearchable() no registered selector";
return searchable;
}
glogg-0.9.2/quickfindmux.h 0000664 0000000 0000000 00000007523 12223242463 0015510 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2013 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#ifndef QUICKFINDMUX_H
#define QUICKFINDMUX_H
#include
#include
#include "quickfindpattern.h"
// Interface representing a widget searchable in both direction.
class SearchableWidgetInterface {
public:
virtual void searchForward() = 0;
virtual void searchBackward() = 0;
virtual void incrementallySearchForward() = 0;
virtual void incrementallySearchBackward() = 0;
virtual void incrementalSearchStop() = 0;
virtual void incrementalSearchAbort() = 0;
};
// Interface representing the selector. It will be called and asked
// who the search have to be forwarded to.
class QuickFindMuxSelectorInterface {
public:
virtual SearchableWidgetInterface* getActiveSearchable() const = 0;
};
class QFNotification;
// Represents a multiplexer (unique application wise) dispatching the
// Quick Find search from the UI to the relevant view.
// It is also its responsability to determine if an incremental search
// must be performed and to react accordingly.
// It owns the QuickFindPattern.
class QuickFindMux : public QObject
{
Q_OBJECT
public:
enum QFDirection {
Forward,
Backward,
};
// Construct the multiplexer, the selector class will be called
// and ask who the search have to be forwarded to.
QuickFindMux( const QuickFindMuxSelectorInterface* selector );
// Register/unregister this searchable widget with the mux for messages
// to be forwarded back to the client.
// The client should call this for each possible searchable widget.
void registerSearchable( QObject* searchable );
void unregisterSearchable( QObject* searchable );
// Set the direction that will be used by the search when searching
// forward.
void setDirection( QFDirection direction );
// Get a pointer to the pattern
QuickFindPattern* getPattern() { return &pattern_; }
signals:
void patternChanged( const QString& );
void notify( const QFNotification& );
void clearNotification();
public slots:
// Signal the current pattern must be altered (will start an incremental
// search if the options are configured in such a way).
void setNewPattern( const QString& new_pattern, bool ignore_case );
// Signal the current pattern must be altered and is confirmed
// (will stop an incremental search if needed)
void confirmPattern( const QString& new_pattern, bool ignore_case );
// Signal the user cancelled the search
// (used for incremental only)
void cancelSearch();
// Starts a search in the specified direction
void searchNext();
void searchPrevious();
// Idem but ignore the direction and always search in the
// specified direction
void searchForward();
void searchBackward();
private slots:
void changeQuickFind( const QString& new_pattern,
QuickFindMux::QFDirection new_direction );
void notifyPatternChanged();
private:
const QuickFindMuxSelectorInterface* selector_;
// The (application wide) quick find pattern
QuickFindPattern pattern_;
QFDirection currentDirection_;
SearchableWidgetInterface* getSearchableWidget() const;
};
#endif
glogg-0.9.2/quickfindpattern.cpp 0000664 0000000 0000000 00000006514 12223242463 0016706 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2010 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
// This file implements QuickFindPattern.
// This class implements part of the Quick Find mechanism, it only stores the
// current search pattern, once it has been confirmed (return pressed),
// it can be asked to return the matches in a specific string.
#include "quickfindpattern.h"
#include "persistentinfo.h"
#include "configuration.h"
QuickFindPattern::QuickFindPattern() : QObject(), regexp_()
{
active_ = false;
}
void QuickFindPattern::changeSearchPattern( const QString& pattern )
{
// Determine the type of regexp depending on the config
QRegExp::PatternSyntax syntax;
switch ( Persistent( "settings" ).quickfindRegexpType() ) {
case Wildcard:
syntax = QRegExp::Wildcard;
break;
case FixedString:
syntax = QRegExp::FixedString;
break;
default:
syntax = QRegExp::RegExp2;
break;
}
regexp_.setPattern( pattern );
regexp_.setPatternSyntax( syntax );
if ( regexp_.isValid() && ( ! regexp_.isEmpty() ) )
active_ = true;
else
active_ = false;
emit patternUpdated();
}
void QuickFindPattern::changeSearchPattern( const QString& pattern, bool ignoreCase )
{
regexp_.setCaseSensitivity(
ignoreCase ? Qt::CaseInsensitive : Qt::CaseSensitive );
changeSearchPattern( pattern );
}
bool QuickFindPattern::matchLine( const QString& line,
QList& matches ) const
{
matches.clear();
if ( active_ ) {
int pos = 0;
while ( ( pos = regexp_.indexIn( line, pos ) ) != -1 ) {
int length = regexp_.matchedLength();
matches << QuickFindMatch( pos, length );
pos += length;
}
}
return ( matches.count() > 0 );
}
bool QuickFindPattern::isLineMatching( const QString& line, int column ) const
{
int pos = 0;
if ( ! active_ )
return false;
if ( ( pos = regexp_.indexIn( line, column ) ) != -1 ) {
lastMatchStart_ = pos;
lastMatchEnd_ = pos + regexp_.matchedLength() - 1;
return true;
}
else
return false;
}
bool QuickFindPattern::isLineMatchingBackward(
const QString& line, int column ) const
{
int pos = 0;
if ( ! active_ )
return false;
if ( ( pos = regexp_.lastIndexIn( line, column ) ) != -1 ) {
lastMatchStart_ = pos;
lastMatchEnd_ = pos + regexp_.matchedLength() - 1;
return true;
}
else
return false;
}
void QuickFindPattern::getLastMatch( int* start_col, int* end_col ) const
{
*start_col = lastMatchStart_;
*end_col = lastMatchEnd_;
}
glogg-0.9.2/quickfindpattern.h 0000664 0000000 0000000 00000005577 12223242463 0016363 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2010, 2013 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#ifndef QUICKFINDPATTERN_H
#define QUICKFINDPATTERN_H
#include
#include
#include
#include
// Represents a match result for QuickFind
class QuickFindMatch
{
public:
// Construct a match (must be initialised)
QuickFindMatch( int start_column, int length )
{ startColumn_ = start_column; length_ = length; }
// Accessor functions
int startColumn() const { return startColumn_; }
int length() const { return length_; }
private:
int startColumn_;
int length_;
};
// Represents a search pattern for QuickFind (without its results)
class QuickFindPattern : public QObject
{
Q_OBJECT
public:
// Construct an empty search
QuickFindPattern();
// Set the search to a new pattern, using the current
// case status
void changeSearchPattern( const QString& pattern );
// Set the search to a new pattern, as well as the case status
void changeSearchPattern( const QString& pattern, bool ignoreCase );
// Returns whether the search is active (i.e. valid and non empty regexp)
bool isActive() const { return active_; }
// Return the text of the regex
QString getPattern() const { return regexp_.pattern(); }
// Returns whether the passed line match the quick find search.
// If so, it populate the passed list with the list of matches
// within this particular line.
bool matchLine( const QString& line,
QList& matches ) const;
// Returns whether there is a match in the passed line, starting at
// the passed column.
// Results are stored internally.
bool isLineMatching( const QString& line, int column = 0 ) const;
// Same as isLineMatching but search backward
bool isLineMatchingBackward( const QString& line, int column = -1 ) const;
// Must be called when isLineMatching returns 'true', returns
// the position of the first match found.
void getLastMatch( int* start_col, int* end_col ) const;
signals:
// Sent when the pattern is changed
void patternUpdated();
private:
bool active_;
QRegExp regexp_;
mutable int lastMatchStart_;
mutable int lastMatchEnd_;
};
#endif
glogg-0.9.2/quickfindwidget.cpp 0000664 0000000 0000000 00000013732 12223242463 0016514 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2010, 2013 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see .
*/
#include "log.h"
#include
#include
#include
#include
#include
#include "configuration.h"
#include "qfnotifications.h"
#include "quickfindwidget.h"
const int QuickFindWidget::NOTIFICATION_TIMEOUT = 5000;
const QString QFNotification::REACHED_EOF = "Reached end of file, no occurence found.";
const QString QFNotification::REACHED_BOF = "Reached beginning of file, no occurence found.";
QuickFindWidget::QuickFindWidget( QWidget* parent ) : QWidget( parent )
{
// ui_.setupUi( this );
// setFocusProxy(ui_.findEdit);
// setProperty("topBorder", true);
QHBoxLayout *layout = new QHBoxLayout( this );
layout->setMargin( 0 );
layout->setSpacing( 6 );
closeButton_ = setupToolButton(
QLatin1String(""), QLatin1String( ":/images/darkclosebutton.png" ) );
layout->addWidget( closeButton_ );
editQuickFind_ = new QLineEdit( this );
// FIXME: set MinimumSize might be to constraining
editQuickFind_->setMinimumSize( QSize( 150, 0 ) );
layout->addWidget( editQuickFind_ );
ignoreCaseCheck_ = new QCheckBox( "Ignore &case" );
layout->addWidget( ignoreCaseCheck_ );
previousButton_ = setupToolButton( QLatin1String("Previous"),
QLatin1String( ":/images/arrowup.png" ) );
layout->addWidget( previousButton_ );
nextButton_ = setupToolButton( QLatin1String("Next"),
QLatin1String( ":/images/arrowdown.png" ) );
layout->addWidget( nextButton_ );
notificationText_ = new QLabel( "" );
// FIXME: set MinimumSize might be too constraining
int width = QFNotification::maxWidth( notificationText_ );
notificationText_->setMinimumSize( width, 0 );
layout->addWidget( notificationText_ );
setMinimumWidth( minimumSizeHint().width() );
// Behaviour
connect( closeButton_, SIGNAL( clicked() ), SLOT( closeHandler() ) );
connect( editQuickFind_, SIGNAL( textEdited( QString ) ),
this, SLOT( textChanged() ) );
connect( ignoreCaseCheck_, SIGNAL( stateChanged( int ) ),
this, SLOT( textChanged() ) );
/*
connect( editQuickFind_. SIGNAL( textChanged( QString ) ), this,
SLOT( updateButtons() ) );
*/
connect( editQuickFind_, SIGNAL( returnPressed() ),
this, SLOT( returnHandler() ) );
connect( previousButton_, SIGNAL( clicked() ),
this, SLOT( doSearchBackward() ) );
connect( nextButton_, SIGNAL( clicked() ),
this, SLOT( doSearchForward() ) );
// Notification timer:
notificationTimer_ = new QTimer( this );
notificationTimer_->setSingleShot( true );
connect( notificationTimer_, SIGNAL( timeout() ),
this, SLOT( notificationTimeout() ) );
}
void QuickFindWidget::userActivate()
{
userRequested_ = true;
QWidget::show();
editQuickFind_->setFocus( Qt::ShortcutFocusReason );
}
//
// SLOTS
//
void QuickFindWidget::changeDisplayedPattern( const QString& newPattern )
{
editQuickFind_->setText( newPattern );
}
void QuickFindWidget::notify( const QFNotification& message )
{
LOG(logDEBUG) << "QuickFindWidget::notify()";
notificationText_->setText( message.message() );
QWidget::show();
notificationTimer_->start( NOTIFICATION_TIMEOUT );
}
void QuickFindWidget::clearNotification()
{
LOG(logDEBUG) << "QuickFindWidget::clearNotification()";
notificationText_->setText( "" );
}
// User clicks forward arrow
void QuickFindWidget::doSearchForward()
{
LOG(logDEBUG) << "QuickFindWidget::doSearchForward()";
// The user has clicked on a button, so we assume she wants
// the widget to stay visible.
userRequested_ = true;
emit patternConfirmed( editQuickFind_->text(), isIgnoreCase() );
emit searchForward();
}
// User clicks backward arrow
void QuickFindWidget::doSearchBackward()
{
LOG(logDEBUG) << "QuickFindWidget::doSearchBackward()";
// The user has clicked on a button, so we assume she wants
// the widget to stay visible.
userRequested_ = true;
emit patternConfirmed( editQuickFind_->text(), isIgnoreCase() );
emit searchBackward();
}
// Close and search when the user presses Return
void QuickFindWidget::returnHandler()
{
emit patternConfirmed( editQuickFind_->text(), isIgnoreCase() );
// Close the widget
userRequested_ = false;
this->hide();
emit close();
}
// Close and reset flag when the user clicks 'close'
void QuickFindWidget::closeHandler()
{
userRequested_ = false;
this->hide();
emit close();
emit cancelSearch();
}
void QuickFindWidget::notificationTimeout()
{
// We close the widget if the user hasn't explicitely requested it.
if ( userRequested_ == false )
this->hide();
}
void QuickFindWidget::textChanged()
{
emit patternUpdated( editQuickFind_->text(), isIgnoreCase() );
}
//
// Private functions
//
QToolButton* QuickFindWidget::setupToolButton(
const QString &text, const QString &icon)
{
QToolButton *toolButton = new QToolButton(this);
toolButton->setText(text);
toolButton->setAutoRaise(true);
toolButton->setIcon(QIcon(icon));
toolButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
return toolButton;
}
bool QuickFindWidget::isIgnoreCase() const
{
return ( ignoreCaseCheck_->checkState() == Qt::Checked );
}
glogg-0.9.2/quickfindwidget.h 0000664 0000000 0000000 00000005262 12223242463 0016160 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2010, 2013 Nicolas Bonnefon and other contributors
*
* This file is part of glogg.
*
* glogg is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* glogg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with glogg. If not, see