void GioLister::UpdateDeviceFreeSpace(const QString& id) {
{
QMutexLocker l(&mutex_);
if (!devices_.contains(id))
return;
DeviceInfo& device_info = devices_[id];
GFile* root = g_mount_get_root(device_info.mount);
GError* error = NULL;
GFileInfo* info = g_file_query_filesystem_info(
root, G_FILE_ATTRIBUTE_FILESYSTEM_FREE, NULL, &error);
if (error) {
qLog(Warning) << error->message;
g_error_free(error);
} else {
device_info.filesystem_free = g_file_info_get_attribute_uint64(
info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
g_object_unref(info);
}
g_object_unref(root);
}
emit DeviceChanged(id);
}
bool CDeviceKitDisksProvider::PumpDriveChangeEvents(IStorageEventsCallback *callback)
{
bool result = false;
if (m_connection)
{
dbus_connection_read_write(m_connection, 0);
DBusMessage *msg = dbus_connection_pop_message(m_connection);
if (msg)
{
char *object;
if (dbus_message_get_args (msg, NULL, DBUS_TYPE_OBJECT_PATH, &object, DBUS_TYPE_INVALID))
{
result = true;
if (dbus_message_is_signal(msg, "org.freedesktop.DeviceKit.Disks", "DeviceAdded"))
DeviceAdded(object, callback);
else if (dbus_message_is_signal(msg, "org.freedesktop.DeviceKit.Disks", "DeviceRemoved"))
DeviceRemoved(object, callback);
else if (dbus_message_is_signal(msg, "org.freedesktop.DeviceKit.Disks", "DeviceChanged"))
DeviceChanged(object, callback);
}
dbus_message_unref(msg);
}
}
return result;
}
void Udisks2Lister::UpdateDeviceFreeSpace(const QString& id) {
QWriteLocker locker(&device_data_lock_);
device_data_[id].free_space =
Utilities::FileSystemFreeSpace(device_data_[id].mount_paths.at(0));
emit DeviceChanged(id);
}
void GioLister::MountChanged(GMount* mount) {
QString id;
{
QMutexLocker l(&mutex_);
id = FindUniqueIdByMount(mount);
if (id.isNull())
return;
g_object_ref(mount);
DeviceInfo new_info;
new_info.ReadMountInfo(mount);
new_info.ReadVolumeInfo(g_mount_get_volume(mount));
new_info.ReadDriveInfo(g_mount_get_drive(mount));
// Ignore the change if the new info is useless
if (new_info.invalid_enclosing_mount ||
(devices_[id].filesystem_size != 0 && new_info.filesystem_size == 0) ||
(!devices_[id].filesystem_type.isEmpty() && new_info.filesystem_type.isEmpty()))
return;
devices_[id] = new_info;
}
emit DeviceChanged(id);
}
void WmdmLister::DoUpdateDriveFreeSpace(const QString& id) {
{
QMutexLocker l(&mutex_);
if (!devices_.contains(id))
return;
UpdateFreeSpace(&devices_[id]);
}
emit DeviceChanged(id);
}
void DeviceKitLister::UpdateDeviceFreeSpace(const QString& id) {
{
QMutexLocker l(&mutex_);
if (!device_data_.contains(id))
return;
DeviceData& data = device_data_[id];
if (!data.device_mount_paths.isEmpty())
data.free_space = Utilities::FileSystemFreeSpace(data.device_mount_paths[0]);
}
emit DeviceChanged(id);
}
void iLister::UpdateDeviceFreeSpace(const QString& id) {
{
QMutexLocker l(&mutex_);
if (!devices_.contains(id))
return;
DeviceInfo& info = devices_[id];
iMobileDeviceConnection conn(info.uuid);
info.free_bytes = conn.GetProperty("AmountDataAvailable", "com.apple.disk_usage").toULongLong();
}
emit DeviceChanged(id);
}
void GioLister::MountAdded(GMount* mount) {
g_object_ref(mount);
DeviceInfo info;
info.ReadVolumeInfo(g_mount_get_volume(mount));
#ifdef HAVE_AUDIOCD
if (info.volume_root_uri.startsWith("cdda"))
// Audio CD devices are already handled by CDDA lister
return;
#endif
info.ReadMountInfo(mount);
info.ReadDriveInfo(g_mount_get_drive(mount));
if (!info.is_suitable())
return;
QString old_id;
{
QMutexLocker l(&mutex_);
// The volume might already exist - either mounted or unmounted.
foreach (const QString& id, devices_.keys()) {
if (devices_[id].volume == info.volume) {
old_id = id;
break;
}
}
if (!old_id.isEmpty() && old_id != info.unique_id()) {
// If the ID has changed (for example, after it's been mounted), we need
// to remove the old device.
devices_.remove(old_id);
emit DeviceRemoved(old_id);
old_id = QString();
}
devices_[info.unique_id()] = info;
}
if (!old_id.isEmpty())
emit DeviceChanged(old_id);
else {
emit DeviceAdded(info.unique_id());
}
}
void DeviceKitLister::Init() {
interface_.reset(new OrgFreedesktopUDisksInterface(
OrgFreedesktopUDisksInterface::staticInterfaceName(),
"/org/freedesktop/UDisks", QDBusConnection::systemBus()));
// Get all the devices currently attached
QDBusPendingReply<QList<QDBusObjectPath> > reply =
interface_->EnumerateDevices();
reply.waitForFinished();
if (!reply.isValid()) {
qLog(Warning) << "Error enumerating DeviceKit-disks devices:"
<< reply.error().name() << reply.error().message();
interface_.reset();
return;
}
// Listen for changes
connect(interface_.get(), SIGNAL(DeviceAdded(QDBusObjectPath)),
SLOT(DBusDeviceAdded(QDBusObjectPath)));
connect(interface_.get(), SIGNAL(DeviceRemoved(QDBusObjectPath)),
SLOT(DBusDeviceRemoved(QDBusObjectPath)));
connect(interface_.get(), SIGNAL(DeviceChanged(QDBusObjectPath)),
SLOT(DBusDeviceChanged(QDBusObjectPath)));
// Get information about each one
QMap<QString, DeviceData> device_data;
for (const QDBusObjectPath& path : reply.value()) {
DeviceData data = ReadDeviceData(path);
if (data.suitable) device_data[data.unique_id()] = data;
}
// Update the internal cache
{
QMutexLocker l(&mutex_);
device_data_ = device_data;
}
// Notify about the changes
for (const QString& id : device_data.keys()) {
emit DeviceAdded(id);
}
}
void ColordEngine::init()
{
// Creates a ColorD interface, it must be created with new
// otherwise the object will be deleted when this block ends
QDBusInterface *interface;
interface = new QDBusInterface(QLatin1String("org.freedesktop.ColorManager"),
QLatin1String("/org/freedesktop/ColorManager"),
QLatin1String("org.freedesktop.ColorManager"),
QDBusConnection::systemBus(),
this);
// listen to colord for device events
connect(interface, SIGNAL(DeviceAdded(QDBusObjectPath)),
this, SLOT(deviceAdded(QDBusObjectPath)));
connect(interface, SIGNAL(DeviceRemoved(QDBusObjectPath)),
this, SLOT(deviceRemoved(QDBusObjectPath)));
connect(interface, SIGNAL(DeviceChanged(QDBusObjectPath)),
this, SLOT(deviceChanged(QDBusObjectPath)));
// listen to colord for profile events
connect(interface, SIGNAL(ProfileAdded(QDBusObjectPath)),
this, SLOT(profileAdded(QDBusObjectPath)));
connect(interface, SIGNAL(ProfileRemoved(QDBusObjectPath)),
this, SLOT(profileRemoved(QDBusObjectPath)));
connect(interface, SIGNAL(ProfileChanged(QDBusObjectPath)),
this, SLOT(profileChanged(QDBusObjectPath)));
// Ask for profiles
QDBusMessage msg;
msg = QDBusMessage::createMethodCall(QLatin1String("org.freedesktop.ColorManager"),
QLatin1String("/org/freedesktop/ColorManager"),
QLatin1String("org.freedesktop.ColorManager"),
QLatin1String("GetProfiles"));
QDBusConnection::systemBus().callWithCallback(msg, this, SLOT(gotProfiles(QDBusMessage)));
// Ask for devices
QDBusMessage message;
message = QDBusMessage::createMethodCall(QLatin1String("org.freedesktop.ColorManager"),
QLatin1String("/org/freedesktop/ColorManager"),
QLatin1String("org.freedesktop.ColorManager"),
QLatin1String("GetDevices"));
QDBusConnection::systemBus().callWithCallback(message, this, SLOT(gotDevices(QDBusMessage)));
}
void MainWindow::HandleMessage( os::Message * pcMessage )
{
// Get message code and act on it
switch ( pcMessage->GetCode() )
{
case M_MW_INPUT:
InputChange();
break;
case M_MW_VIDEOOUTPUT:
VideoOutputChange();
break;
case M_MW_AUDIOOUTPUT:
AudioOutputChange();
break;
case M_MW_APPLY:
Apply();
break;
case M_MW_DEFAULT:
Default();
break;
case M_MW_UNDO:
Undo();
break;
case M_MW_DEVICE:
DeviceChanged();
break;
case M_MW_CONTROLS:
os::MediaManager::GetInstance()->GetServerLink().SendMessage( os::MEDIA_SERVER_SHOW_CONTROLS );
break;
default:
os::Window::HandleMessage( pcMessage );
break;
}
}
void DeviceKitLister::DBusDeviceChanged(const QDBusObjectPath &path) {
bool already_known = false;
{
QMutexLocker l(&mutex_);
already_known = !FindUniqueIdByPath(path).isNull();
}
DeviceData data = ReadDeviceData(path);
if (already_known && !data.suitable)
DBusDeviceRemoved(path);
else if (!already_known && data.suitable)
DBusDeviceAdded(path);
else if (already_known && data.suitable) {
{
QMutexLocker l(&mutex_);
device_data_[data.unique_id()] = data;
}
emit DeviceChanged(data.unique_id());
}
}
void MainMenu::show()
{
Append(ManageBtn);
Append(SettingsBtn);
Append(HomebrewBtn);
Append(MusicPlayerBtn);
if (Settings.GodMode || !(Settings.ParentalBlocks & BLOCK_SD_RELOAD_BUTTON))
Append(SdCardBtn);
TaskBar::Instance()->show();
mainExplorer = new Explorer(MainMenu::Instance(), Settings.LastUsedPath);
std::string root = mainExplorer->GetRootDir();
root.erase(root.find_first_of(":"));
for(int i = 0; i < MAXDEVICES; i++)
{
if(!root.compare(DeviceName[i]))
DeviceChanged(i);
}
}
//-----------------------------------------------------------------------------
// Name: DialogProc
// Desc: Handle window messages in the dialog.
//-----------------------------------------------------------------------------
INT_PTR CD3DSettingsDialog::DialogProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
UNREFERENCED_PARAMETER( lParam );
switch( msg )
{
case WM_INITDIALOG:
{
m_hDlg = hDlg;
// Fill adapter combo box. Updating the selected adapter will trigger
// updates of the rest of the dialog.
for( UINT iai = 0; iai < m_pEnumeration->m_pAdapterInfoList->Count(); iai++ )
{
D3DAdapterInfo* pAdapterInfo;
pAdapterInfo = (D3DAdapterInfo*)m_pEnumeration->m_pAdapterInfoList->GetPtr(iai);
TCHAR strDescription[512];
DXUtil_ConvertAnsiStringToGenericCch( strDescription, pAdapterInfo->AdapterIdentifier.Description, 512 );
ComboBoxAdd( IDC_ADAPTER_COMBO, pAdapterInfo, strDescription );
if( pAdapterInfo->AdapterOrdinal == m_d3dSettings.AdapterOrdinal() )
ComboBoxSelect( IDC_ADAPTER_COMBO, pAdapterInfo );
}
if( !ComboBoxSomethingSelected( IDC_ADAPTER_COMBO ) &&
ComboBoxCount( IDC_ADAPTER_COMBO ) > 0 )
{
ComboBoxSelectIndex( IDC_ADAPTER_COMBO, 0 );
}
}
return TRUE;
case WM_COMMAND:
switch( LOWORD(wParam) )
{
case IDOK:
EndDialog( hDlg, IDOK );
break;
case IDCANCEL:
EndDialog( hDlg, IDCANCEL );
break;
case IDC_ADAPTER_COMBO:
if( CBN_SELCHANGE == HIWORD(wParam) )
AdapterChanged();
break;
case IDC_DEVICE_COMBO:
if( CBN_SELCHANGE == HIWORD(wParam) )
DeviceChanged();
break;
case IDC_ADAPTERFORMAT_COMBO:
if( CBN_SELCHANGE == HIWORD(wParam) )
AdapterFormatChanged();
break;
case IDC_RESOLUTION_COMBO:
if( CBN_SELCHANGE == HIWORD(wParam) )
ResolutionChanged();
break;
case IDC_REFRESHRATE_COMBO:
if( CBN_SELCHANGE == HIWORD(wParam) )
RefreshRateChanged();
break;
case IDC_BACKBUFFERFORMAT_COMBO:
if( CBN_SELCHANGE == HIWORD(wParam) )
BackBufferFormatChanged();
break;
case IDC_DEPTHSTENCILBUFFERFORMAT_COMBO:
if( CBN_SELCHANGE == HIWORD(wParam) )
DepthStencilBufferFormatChanged();
break;
case IDC_MULTISAMPLE_COMBO:
if( CBN_SELCHANGE == HIWORD(wParam) )
MultisampleTypeChanged();
break;
case IDC_MULTISAMPLE_QUALITY_COMBO:
if( CBN_SELCHANGE == HIWORD(wParam) )
MultisampleQualityChanged();
break;
case IDC_VERTEXPROCESSING_COMBO:
if( CBN_SELCHANGE == HIWORD(wParam) )
VertexProcessingChanged();
break;
case IDC_PRESENTINTERVAL_COMBO:
if( CBN_SELCHANGE == HIWORD(wParam) )
PresentIntervalChanged();
break;
case IDC_WINDOW:
case IDC_FULLSCREEN:
WindowedFullscreenChanged();
break;
}
return TRUE;
default:
return FALSE;
}
}
void AudioTest::recDeviceChanged(int index)
{
m_rec_device = m_rec_device_Box->itemData(index).value<QAudioDeviceInfo>();
DeviceChanged();
}