void PlaylistWidget::slot_show_filter_triggered()
{
//Debug::debug() << " [PlaylistWidget] slot_show_filter_triggered"
SETTINGS()->_playqueueShowFilter = m_action_show_filter->isChecked();
ui_filter_container->setVisible(SETTINGS()->_playqueueShowFilter);
}
/* ---------------------------------------------------------------------------*/
void UTIL::drawPlayingIcon(QPainter* painter, int size, int margin, QPoint pos)
{
painter->save();
painter->setPen( SETTINGS()->_baseColor );
painter->setBrush(QBrush( SETTINGS()->_baseColor ));
double raHeadHeight = size-2*margin;
double raHeadWidth = size-2*margin -(raHeadHeight*0.3);
QPointF raStartPoint = QPointF(pos) + QPointF(margin,margin);
QPointF raArrowPoints[3];
double x1 = raStartPoint.x();
double y1 = raStartPoint.y();
double x2 = raStartPoint.x();
double y2 = raStartPoint.y() + raHeadHeight;
double x3 = raStartPoint.x() + raHeadWidth;
double y3 = raStartPoint.y() + raHeadHeight/2;
raArrowPoints[0]=QPointF(x1,y1);
raArrowPoints[1]=QPointF(x2,y2);
raArrowPoints[2]=QPointF(x3,y3);
painter->setRenderHint(QPainter::Antialiasing, true);
painter->drawPolygon(raArrowPoints,3);
painter->restore();
}
static void
handle_preference_init_string (void)
{
MetaStringPreference *cursor = preferences_string;
while (cursor->base.key != NULL)
{
char *value;
/* Complex keys have a mapping function to check validity */
if (cursor->handler)
{
if (cursor->target)
meta_bug ("%s has both a target and a handler\n", cursor->base.key);
g_settings_get_mapped (SETTINGS (cursor->base.schema),
cursor->base.key, cursor->handler, NULL);
}
else
{
if (!cursor->target)
meta_bug ("%s must have handler or target\n", cursor->base.key);
if (*(cursor->target))
g_free (*(cursor->target));
value = g_settings_get_string (SETTINGS (cursor->base.schema),
cursor->base.key);
*(cursor->target) = value;
}
++cursor;
}
}
//! ----------------------- saveSettings ---------------------------------------
void Equalizer_Dialog::saveSettings()
{
if(!_settingChanged) return;
SETTINGS()->_enableEq = _enableCheckBox->isChecked();
SETTINGS()->_currentPreset = _comboBoxPreset->currentText();
SETTINGS()->_presetEq.clear();
foreach (const QString& name, _presetList.keys()) {
SETTINGS()->_presetEq[name] = _presetList[name];
}
}
std::string Environment::getLocalSettingsPath(const std::string& fileName)
{
if(EngineSettings::envProjectPath().empty()) return "";
Poco::Path p(getDownstreamDocumentsFolder());
p.append(SETTINGS()).append(EngineSettings::envProjectPath()).append(fileName);
return p.toString();
}
/*******************************************************************************
contextMenuEvent
*******************************************************************************/
void BrowserView::contextMenuEvent ( QContextMenuEvent * event )
{
//Debug::debug() << " [BrowserView] contextMenuEvent ";
SceneBase * scene = m_scenes[ VIEW::Id(SETTINGS()->_viewMode) ];
if(scene->mouseGrabberItem())
{
QGraphicsView::contextMenuEvent(event) ;
}
else
{
if(!m_menu)
m_menu = new QMenu(this);
m_menu->clear();
m_menu->addActions(scene->actions());
m_menu->addSeparator();
m_menu->addAction(ACTIONS()->value(BROWSER_JUMP_TO_ARTIST));
m_menu->addAction(ACTIONS()->value(BROWSER_JUMP_TO_ALBUM));
m_menu->addAction(ACTIONS()->value(BROWSER_JUMP_TO_TRACK));
m_menu->popup(mapToGlobal(event->pos()));
event->accept();
}
}
/*******************************************************************************
eventFilter
*******************************************************************************/
bool BrowserView::eventFilter(QObject *obj, QEvent *ev)
{
if(!is_started) return false;
//Debug::debug() << "BrowserView eventFilter obj" << obj;
int type = ev->type();
QWidget *wid = qobject_cast<QWidget*>(obj);
if (obj == this)
{
return false;
}
if (wid && (wid == m_scrollbar ))
{
if(type == QEvent::Hide || type == QEvent::Show)
{
SceneBase * scene = m_scenes.value( VIEW::Id(SETTINGS()->_viewMode) );
if( scene->isInit() )
scene->resizeScene();
}
}
return QWidget::eventFilter(obj, ev);
}
void
meta_prefs_set_num_workspaces (int n_workspaces)
{
g_settings_set_int (SETTINGS (SCHEMA_GENERAL),
KEY_NUM_WORKSPACES,
n_workspaces);
}
static void
handle_preference_update_enum (GSettings *settings,
gchar *key)
{
MetaEnumPreference *cursor = preferences_enum;
gint old_value;
while (cursor->base.key != NULL && strcmp (key, cursor->base.key) != 0)
++cursor;
if (cursor->base.key==NULL)
/* Didn't recognise that key. */
return;
/* We need to know whether the value changes, so
* store the current value away. */
old_value = * ((gint *) cursor->target);
*((gint *) cursor->target) =
g_settings_get_enum (SETTINGS (cursor->base.schema), key);
/* Did it change? If so, tell the listeners about it. */
if (old_value != *((gint *) cursor->target))
queue_changed (cursor->base.pref);
}
void LastFmService::init()
{
m_currentTrack = 0;
bool enable = SETTINGS()->_useLastFmScrobbler;
Debug::debug() << " [LastFmService] init enable " << enable;
disconnect(Engine::instance(), 0,this, 0);
/* load settings */
QSettings settings(UTIL::CONFIGFILE,QSettings::IniFormat,this);
settings.beginGroup("Scrobbler");
LastFm::GLOBAL::username = settings.value("username", QString()).toString();
LastFm::GLOBAL::session_key = settings.value("key", QString()).toString();
LastFm::GLOBAL::api_key = "b3717637c18071e1619e92ee2c3eb0f8";
LastFm::GLOBAL::secret_key = "8192599d44d34b27c520d597d34f3714";
settings.endGroup();
if( enable && isAuthenticated() )
{
connect(Engine::instance(), SIGNAL(engineStateChanged()), this, SLOT(slot_state_changed()));
connect(Engine::instance(), SIGNAL(mediaChanged()), this, SLOT(slot_track_changed()));
}
/* change status for send love action */
ACTIONS()->value(LASTFM_LOVE)->setEnabled(enable);
ACTIONS()->value(LASTFM_LOVE_NOW_PLAYING)->setEnabled(enable);
}
static gboolean
handle_create (LoomSettings *object,
GDBusMethodInvocation *invocation,
GVariant *arg_configuration)
{
Settings *settings = SETTINGS (object);
Setting *setting;
gs_free gchar **object_paths = NULL;
GError *error = NULL;
if (!validate_configuration (arg_configuration, &error))
{
g_dbus_method_invocation_take_error (invocation, error);
return TRUE;
}
setting = SETTING (setting_new (settings->daemon, arg_configuration));
setting_export (setting);
g_hash_table_insert (settings->settings,
(gchar *)setting_get_object_path (setting),
setting);
object_paths = (gchar **)g_hash_table_get_keys_as_array (settings->settings,
NULL);
loom_settings_set_settings (object, (const gchar* const*)object_paths);
loom_settings_complete_create (object, invocation,
setting_get_object_path (setting));
return TRUE;
}
static void
handle_preference_update_bool (GSettings *settings,
gchar *key)
{
MetaBoolPreference *cursor = preferences_bool;
gboolean old_value;
while (cursor->base.key != NULL && strcmp (key, cursor->base.key) != 0)
++cursor;
if (cursor->base.key==NULL || cursor->target==NULL)
/* Unknown key or no work for us to do. */
return;
/* We need to know whether the value changes, so
* store the current value away. */
old_value = *((gboolean *) cursor->target);
*((gboolean *) cursor->target) =
g_settings_get_boolean (SETTINGS (cursor->base.schema), key);
/* Did it change? If so, tell the listeners about it. */
if (old_value != *((gboolean *) cursor->target))
queue_changed (cursor->base.pref);
if (cursor->base.pref==META_PREF_DISABLE_WORKAROUNDS)
maybe_give_disable_workarounds_warning ();
}
MainWindow::MainWindow(QWidget *parent)
:QMainWindow(parent),
ui(new Ui::MainWindow),
message(this){
ui->setupUi(this);
ui->progressBar->hide();
thread.window=this;
QObject::connect(&thread, SIGNAL(Start()), this, SLOT(on_jobs_started()));
QObject::connect(&thread, SIGNAL(Finish()), this, SLOT(on_jobs_finished()));
QObject::connect(&thread, SIGNAL(Range(int, int)), ui->progressBar, SLOT(setRange(int, int)));
QObject::connect(&thread, SIGNAL(Value(int)), ui->progressBar, SLOT(setValue(int)));
QObject::connect(ui->actionAbout,SIGNAL(triggered()),this,SLOT(about()));
QObject::connect(ui->actionExit,SIGNAL(triggered()),this,SLOT(close()));
SETTINGS();
restoreGeometry(settings.value("main-window-geometry").toByteArray());
selectIso(settings.value("main-window-iso").toString());
QStringList items=settings.value("main-window-patch-files").toStringList();
for(int i=0;i<items.count();i++){
addFile(items.at(i));
}
}
void MainWindow::report(const QString & title,const QString & text,QList<ResourceData *> *resources,int success){
SETTINGS();
bool noshowonsuccess=settings.value("report-window-don't-show-on-success")==true;
if(success==1 && noshowonsuccess) return;
Ui_Dialog dui;
QDialog *dialog=new QDialog(this);
dui.setupUi(dialog);
if(resources)
for(int i=0;i<resources->count();i++){
ResourceData *data=resources->at(i);
dui.textBrowser->document()->addResource(data->type,data->name,data->data);
}
dui.textBrowser->setHtml(text);
dui.showOnSuccessBox->setChecked(noshowonsuccess);
dialog->setWindowTitle(title);
if(success==-1) dui.showOnSuccessBox->setVisible(false);
dialog->restoreGeometry(settings.value("report-window-geometry").toByteArray());
dialog->exec();
settings.setValue("report-window-geometry",dialog->saveGeometry());
settings.setValue("report-window-don't-show-on-success",dui.showOnSuccessBox->isChecked());
delete dialog;
}
static void
settings_finalize (GObject *object)
{
Settings *settings = SETTINGS (object);
settings = settings;
g_hash_table_unref (settings->settings);
G_OBJECT_CLASS (settings_parent_class)->finalize (object);
}
void TabInit::writeSettings(const QString &filename)
{
SETTINGS(filename);
XtalOpt *xtalopt = qobject_cast<XtalOpt*>(m_opt);
settings->beginGroup("xtalopt/init/");
const int VERSION = 2;
settings->setValue("version",VERSION);
settings->setValue("limits/a/min", xtalopt->a_min);
settings->setValue("limits/b/min", xtalopt->b_min);
settings->setValue("limits/c/min", xtalopt->c_min);
settings->setValue("limits/a/max", xtalopt->a_max);
settings->setValue("limits/b/max", xtalopt->b_max);
settings->setValue("limits/c/max", xtalopt->c_max);
settings->setValue("limits/alpha/min", xtalopt->alpha_min);
settings->setValue("limits/beta/min", xtalopt->beta_min);
settings->setValue("limits/gamma/min", xtalopt->gamma_min);
settings->setValue("limits/alpha/max", xtalopt->alpha_max);
settings->setValue("limits/beta/max", xtalopt->beta_max);
settings->setValue("limits/gamma/max", xtalopt->gamma_max);
settings->setValue("limits/volume/min", xtalopt->vol_min);
settings->setValue("limits/volume/max", xtalopt->vol_max);
settings->setValue("limits/volume/fixed", xtalopt->vol_fixed);
settings->setValue("limits/scaleFactor", xtalopt->scaleFactor);
settings->setValue("limits/minRadius", xtalopt->minRadius);
settings->setValue("using/fixedVolume", xtalopt->using_fixed_volume);
settings->setValue("using/interatomicDistanceLimit",
xtalopt->using_interatomicDistanceLimit);
// Composition
// We only want to save POTCAR info and Composition to the resume
// file, not the main config file, so only dump the data here if
// we are given a filename and it contains the string
// "xtalopt.state"
if (!filename.isEmpty() && filename.contains("xtalopt.state")) {
settings->beginWriteArray("composition");
QList<uint> keys = xtalopt->comp.keys();
for (int i = 0; i < keys.size(); i++) {
settings->setArrayIndex(i);
settings->setValue("atomicNumber", keys.at(i));
settings->setValue("quantity",
xtalopt->comp.value(keys.at(i)).quantity);
settings->setValue("minRadius",
xtalopt->comp.value(keys.at(i)).minRadius);
}
settings->endArray();
}
settings->endGroup();
DESTROY_SETTINGS(filename);
}
static void
handle_preference_update_string (GSettings *settings,
gchar *key)
{
MetaStringPreference *cursor = preferences_string;
char *value;
gboolean inform_listeners = FALSE;
while (cursor->base.key != NULL && strcmp (key, cursor->base.key) != 0)
++cursor;
if (cursor->base.key==NULL)
/* Didn't recognise that key. */
return;
/* Complex keys have a mapping function to check validity */
if (cursor->handler)
{
if (cursor->target)
meta_bug ("%s has both a target and a handler\n", cursor->base.key);
g_settings_get_mapped (SETTINGS (cursor->base.schema),
cursor->base.key, cursor->handler, NULL);
}
else
{
if (!cursor->target)
meta_bug ("%s must have handler or target\n", cursor->base.key);
value = g_settings_get_string (SETTINGS (cursor->base.schema),
cursor->base.key);
inform_listeners = (g_strcmp0 (value, *(cursor->target)) != 0);
if (*(cursor->target))
g_free (*(cursor->target));
*(cursor->target) = value;
}
if (inform_listeners)
queue_changed (cursor->base.pref);
}
/*******************************************************************************
resizeEvent
*******************************************************************************/
void BrowserView::resizeEvent( QResizeEvent * event)
{
Debug::debug() << " [BrowserView] resizeEvent";
if(!is_started) return;
SceneBase * scene = m_scenes.value( VIEW::Id(SETTINGS()->_viewMode) );
if( scene->isInit() )
scene->resizeScene();
event->accept();
}
/*******************************************************************************
Save / Restore settings
*******************************************************************************/
void BrowserView::restore_view()
{
Debug::debug() << " [BrowserView] restore_view";
BrowserParam param;
param.mode = VIEW::Id(SETTINGS()->_viewMode);
param.filter = QString();
if(param.mode == VIEW::ViewFileSystem)
param.data = QVariant( SETTINGS()->_filesystem_path );
else
param.data = QVariant();
add_history_entry(param);
switch_view(param);
is_started = true;
}
static void
settings_constructed (GObject *object)
{
Settings *settings = SETTINGS (object);
g_assert (settings_instance == NULL);
settings_instance = settings;
if (G_OBJECT_CLASS (settings_parent_class)->constructed != NULL)
G_OBJECT_CLASS (settings_parent_class)->constructed (object);
}
/* slot used by FileScene to load a directory inside view */
void BrowserView::slot_on_load_new_data(const QString& data)
{
Debug::debug() << " [BrowserView] slot_on_load_new_data data" << data;
BrowserParam param = BrowserParam(
VIEW::Id(SETTINGS()->_viewMode),
CentralToolBar::instance()->explorerFilter(),
QVariant( data ));
add_history_entry( param );
switch_view(param);
}
LastFmService::~LastFmService()
{
Debug::debug() << " [LastFmService] delete";
if(SETTINGS()->_useLastFmScrobbler && isAuthenticated())
scrobble();
//! save settings
QSettings settings(UTIL::CONFIGFILE,QSettings::IniFormat,this);
settings.beginGroup("Scrobbler");
settings.setValue("username", LastFm::GLOBAL::username);
settings.setValue("key", LastFm::GLOBAL::session_key);
settings.endGroup();
settings.sync();
}
MainWindow::~MainWindow(){
SETTINGS();
settings.setValue("main-window-geometry",saveGeometry());
settings.setValue("main-window-iso",isoFilename);
QStringList items;
for(int i=0,l=ui->listWidget->count();i<l;i++){
items.append(ui->listWidget->item(i)->text());
}
settings.setValue("main-window-patch-files",items);
delete ui;
}
/*******************************************************************************
paintEvent
*******************************************************************************/
void BottomContainer::paintEvent(QPaintEvent *event)
{
QPainter painter(this);
QColor m_brush_color = SETTINGS()->_baseColor;
m_brush_color.setAlphaF(0.6);
painter.setPen(QPen( m_brush_color, 0.1, Qt::SolidLine, Qt::RoundCap));
painter.setBrush(QBrush( m_brush_color ,Qt::SolidPattern));
painter.drawRect(this->rect().adjusted(0,0,-10,0));
QWidget::paintEvent(event);
}
/* ---------------------------------------------------------------------------*/
void EnginePhonon::setMediaItem(MEDIA::TrackPtr track)
{
Debug::debug() << "[EnginePhonon] -> setMediaItem";
m_mediaObject->blockSignals(true);
m_mediaObject->stop();
m_mediaObject->clearQueue();
m_mediaObject->blockSignals(false);
if(m_currentMediaItem)
{
MEDIA::registerTrackPlaying(m_currentMediaItem, false);
}
m_currentMediaItem = MEDIA::TrackPtr(track);
//Debug::debug() << "[EnginePhonon] -> setMediaItem mi url:" << mi->data.url;
if(m_nextMediaItem)
{
m_nextMediaItem = MEDIA::TrackPtr(0);
}
/* BEGIN crash on broken path with vlc backend*/
if( m_currentMediaItem->isBroken )
{
Debug::warning() << "[EnginePhonon] Track path seems to be broken:" << m_currentMediaItem->url;
m_mediaObject->blockSignals(false);
//stop(); no stop FOR VLC BACKEND
return;
}
/* END */
/* get replay gain info */
if ( (m_currentMediaItem->type() == TYPE_TRACK) &&
(SETTINGS()->_replaygain != SETTING::ReplayGainOff ) )
{
MEDIA::ReplayGainFromDataBase(m_currentMediaItem);
}
//const QString path = MEDIA::Track::path(track->url);
if( MEDIA::isLocal(track->url) )
m_mediaObject->setCurrentSource( QUrl::fromLocalFile(QFileInfo(track->url).canonicalFilePath()) );
else
m_mediaObject->setCurrentSource( QUrl(track->url) );
m_mediaObject->play();
}
static void
init_bindings (void)
{
int i;
gchar **strokes;
for (i = 0; key_bindings[i].name; i++)
{
strokes = g_settings_get_strv (SETTINGS (SCHEMA_BINDINGS),
key_bindings[i].name);
update_key_binding (key_bindings[i].name, strokes);
g_strfreev (strokes);
}
}
//! ----------------------- restoreSettings ------------------------------------
void Equalizer_Dialog::restoreSettings()
{
_presetList.clear();
_comboBoxPreset->clear();
QMap<QString, Equalizer::EqPreset> presetsEq = SETTINGS()->_presetEq;
//! Load presets
if ( presetsEq.isEmpty() ) {
addDefaultPreset();
}
else {
foreach (const QString& name, presetsEq.keys()) {
addPreset( name , presetsEq[name] );
}
}
//! Load selected preset
const QString selected_preset = SETTINGS()->_currentPreset;
const int selectedIdx = _comboBoxPreset->findText(selected_preset);
if (selectedIdx != -1) {
_comboBoxPreset->setCurrentIndex(selectedIdx);
for (int i=0 ; i < Equalizer::kBands ; ++i) {
eqSliderList[i]->setValue(_presetList[selected_preset].gain[i]);
}
}
//! Load Enabled state
_enableCheckBox->setChecked( SETTINGS()->_enableEq );
_slider_container->setEnabled(_enableCheckBox->isChecked());
//! signal loaded preset
if(_enableCheckBox->isChecked())
equalizerChanged();
}
static void
handle_preference_init_int (void)
{
MetaIntPreference *cursor = preferences_int;
while (cursor->base.key != NULL)
{
if (cursor->target)
*cursor->target = g_settings_get_int (SETTINGS (cursor->base.schema),
cursor->base.key);
++cursor;
}
}
static void
handle_preference_init_enum (void)
{
MetaEnumPreference *cursor = preferences_enum;
while (cursor->base.key != NULL)
{
if (cursor->target==NULL)
continue;
*((gint *) cursor->target) =
g_settings_get_enum (SETTINGS (cursor->base.schema), cursor->base.key);
++cursor;
}
}
static void
handle_preference_init_bool (void)
{
MetaBoolPreference *cursor = preferences_bool;
while (cursor->base.key != NULL)
{
if (cursor->target!=NULL)
*cursor->target =
g_settings_get_boolean (SETTINGS (cursor->base.schema),
cursor->base.key);
++cursor;
}
maybe_give_disable_workarounds_warning ();
}