You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
655 lines
23 KiB
655 lines
23 KiB
#include <utility> |
|
|
|
#include "SettingsDialog.h" |
|
|
|
#include "ButtonConfigGui.h" |
|
#include "gui/widgets/ZoomCallib.h" |
|
#include <DeviceListHelper.h> |
|
|
|
#include <config.h> |
|
#include <Util.h> |
|
#include <StringUtils.h> |
|
#include <i18n.h> |
|
|
|
SettingsDialog::SettingsDialog(GladeSearchpath* gladeSearchPath, Settings* settings, Control* control) |
|
: GladeGui(gladeSearchPath, "settings.glade", "settingsDialog"), |
|
settings(settings), |
|
control(control), |
|
callib(zoomcallib_new()) |
|
{ |
|
GtkWidget* vbox = get("zoomVBox"); |
|
g_return_if_fail(vbox != nullptr); |
|
|
|
GtkWidget* slider = get("zoomCallibSlider"); |
|
g_return_if_fail(slider != nullptr); |
|
|
|
g_signal_connect(slider, "change-value", G_CALLBACK( |
|
+[](GtkRange* range, GtkScrollType scroll, gdouble value, SettingsDialog* self) |
|
{ |
|
self->setDpi((int) value); |
|
}), this); |
|
|
|
g_signal_connect(get("cbAutosave"), "toggled", G_CALLBACK( |
|
+[](GtkToggleButton* togglebutton, SettingsDialog* self) |
|
{ |
|
self->enableWithCheckbox("cbAutosave", "boxAutosave"); |
|
}), this); |
|
|
|
|
|
g_signal_connect(get("btTestEnable"), "clicked", G_CALLBACK( |
|
+[](GtkButton* bt, SettingsDialog* self) |
|
{ |
|
system(gtk_entry_get_text(GTK_ENTRY(self->get("txtEnableTouchCommand")))); |
|
}), this); |
|
|
|
g_signal_connect(get("btTestDisable"), "clicked", G_CALLBACK( |
|
+[](GtkButton* bt, SettingsDialog* self) |
|
{ |
|
system(gtk_entry_get_text(GTK_ENTRY(self->get("txtDisableTouchCommand")))); |
|
}), this); |
|
|
|
g_signal_connect(get("cbAddVerticalSpace"), "toggled", G_CALLBACK( |
|
+[](GtkToggleButton* togglebutton, SettingsDialog* self) |
|
{ |
|
self->enableWithCheckbox("cbAddVerticalSpace", "spAddVerticalSpace"); |
|
}), this); |
|
|
|
g_signal_connect(get("cbAddHorizontalSpace"), "toggled", G_CALLBACK( |
|
+[](GtkToggleButton* togglebutton, SettingsDialog* self) |
|
{ |
|
self->enableWithCheckbox("cbAddHorizontalSpace", "spAddHorizontalSpace"); |
|
}), this); |
|
|
|
g_signal_connect(get("cbDrawDirModsEnabled"), "toggled", G_CALLBACK( |
|
+[](GtkToggleButton* togglebutton, SettingsDialog* self) |
|
{ |
|
self->enableWithCheckbox("cbDrawDirModsEnabled", "spDrawDirModsRadius"); |
|
}), this); |
|
|
|
g_signal_connect(get("cbStrokeFilterEnabled"), "toggled", G_CALLBACK( |
|
+[](GtkToggleButton* togglebutton, SettingsDialog* self) |
|
{ |
|
self->enableWithCheckbox("cbStrokeFilterEnabled", "spStrokeIgnoreTime"); |
|
self->enableWithCheckbox("cbStrokeFilterEnabled", "spStrokeIgnoreLength"); |
|
self->enableWithCheckbox("cbStrokeFilterEnabled", "spStrokeSuccessiveTime"); |
|
self->enableWithCheckbox("cbStrokeFilterEnabled", "cbDoActionOnStrokeFiltered"); |
|
self->enableWithCheckbox("cbStrokeFilterEnabled", "cbTrySelectOnStrokeFiltered"); |
|
}), this); |
|
|
|
g_signal_connect(get("cbDisableTouchOnPenNear"), "toggled", G_CALLBACK( |
|
+[](GtkToggleButton* togglebutton, SettingsDialog* self) |
|
{ |
|
self->enableWithCheckbox("cbDisableTouchOnPenNear", "boxInternalHandRecognition"); |
|
}), this); |
|
|
|
g_signal_connect(get("cbTouchDisableMethod"), "changed", G_CALLBACK( |
|
+[](GtkComboBox* comboBox, SettingsDialog* self) |
|
{ |
|
self->customHandRecognitionToggled(); |
|
}), this); |
|
|
|
gtk_box_pack_start(GTK_BOX(vbox), callib, false, true, 0); |
|
gtk_widget_show(callib); |
|
|
|
initMouseButtonEvents(); |
|
|
|
vector<InputDevice> deviceList = DeviceListHelper::getDeviceList(this->settings); |
|
GtkWidget* container = get("hboxInputDeviceClasses"); |
|
for (const InputDevice& inputDevice: deviceList) |
|
{ |
|
// Only add real devices (core pointers have vendor and product id nullptr) |
|
this->deviceClassConfigs.push_back( |
|
new DeviceClassConfigGui(getGladeSearchPath(), container, settings, inputDevice)); |
|
} |
|
if (deviceList.empty()) |
|
{ |
|
GtkWidget* label = gtk_label_new(""); |
|
gtk_label_set_markup(GTK_LABEL(label), _("<b>No devices were found. This seems wrong - maybe file a bug report?</b>")); |
|
gtk_box_pack_end(GTK_BOX(container), label, true, true, 0); |
|
gtk_widget_show(label); |
|
} |
|
} |
|
|
|
SettingsDialog::~SettingsDialog() |
|
{ |
|
for (ButtonConfigGui* bcg : this->buttonConfigs) |
|
{ |
|
delete bcg; |
|
} |
|
this->buttonConfigs.clear(); |
|
|
|
for (DeviceClassConfigGui* dev : this->deviceClassConfigs) |
|
{ |
|
delete dev; |
|
} |
|
this->deviceClassConfigs.clear(); |
|
|
|
// DO NOT delete settings! |
|
this->settings = nullptr; |
|
} |
|
|
|
void SettingsDialog::initMouseButtonEvents(const char* hbox, int button, bool withDevice) |
|
{ |
|
this->buttonConfigs.push_back(new ButtonConfigGui(getGladeSearchPath(), get(hbox), settings, button, withDevice)); |
|
} |
|
|
|
void SettingsDialog::initMouseButtonEvents() |
|
{ |
|
initMouseButtonEvents("hboxMidleMouse", 1); |
|
initMouseButtonEvents("hboxRightMouse", 2); |
|
initMouseButtonEvents("hboxEraser", 0); |
|
initMouseButtonEvents("hboxTouch", 3, true); |
|
initMouseButtonEvents("hboxPenButton1", 5); |
|
initMouseButtonEvents("hboxPenButton2", 6); |
|
|
|
initMouseButtonEvents("hboxDefaultTool", 4); |
|
} |
|
|
|
void SettingsDialog::setDpi(int dpi) |
|
{ |
|
if (this->dpi == dpi) |
|
{ |
|
return; |
|
} |
|
|
|
this->dpi = dpi; |
|
zoomcallib_set_val(ZOOM_CALLIB(callib), dpi); |
|
} |
|
|
|
void SettingsDialog::show(GtkWindow* parent) |
|
{ |
|
load(); |
|
|
|
gtk_window_set_transient_for(GTK_WINDOW(this->window), parent); |
|
int res = gtk_dialog_run(GTK_DIALOG(this->window)); |
|
|
|
if (res == 1) |
|
{ |
|
this->save(); |
|
} |
|
|
|
gtk_widget_hide(this->window); |
|
} |
|
|
|
void SettingsDialog::loadCheckbox(const char* name, gboolean value) |
|
{ |
|
GtkToggleButton* b = GTK_TOGGLE_BUTTON(get(name)); |
|
gtk_toggle_button_set_active(b, value); |
|
} |
|
|
|
bool SettingsDialog::getCheckbox(const char* name) |
|
{ |
|
GtkToggleButton* b = GTK_TOGGLE_BUTTON(get(name)); |
|
return gtk_toggle_button_get_active(b); |
|
} |
|
|
|
/** |
|
* Autosave was toggled, enable / disable autosave config |
|
*/ |
|
void SettingsDialog::enableWithCheckbox(string checkbox, string widget) |
|
{ |
|
GtkWidget* cbAutosave = get(std::move(checkbox)); |
|
bool autosaveEnabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cbAutosave)); |
|
gtk_widget_set_sensitive(get(std::move(widget)), autosaveEnabled); |
|
} |
|
|
|
void SettingsDialog::customHandRecognitionToggled() |
|
{ |
|
GtkWidget* cbTouchDisableMethod = get("cbTouchDisableMethod"); |
|
int touchMethod = gtk_combo_box_get_active(GTK_COMBO_BOX(cbTouchDisableMethod)); |
|
gtk_widget_set_sensitive(get("boxCustomTouchDisableSettings"), touchMethod == 2); |
|
} |
|
|
|
void SettingsDialog::load() |
|
{ |
|
loadCheckbox("cbSettingPresureSensitivity", settings->isPressureSensitivity()); |
|
loadCheckbox("cbEnableZoomGestures", settings->isZoomGesturesEnabled()); |
|
loadCheckbox("cbShowSidebarRight", settings->isSidebarOnRight()); |
|
loadCheckbox("cbShowScrollbarLeft", settings->isScrollbarOnLeft()); |
|
loadCheckbox("cbAutoloadXoj", settings->isAutloadPdfXoj()); |
|
loadCheckbox("cbAutosave", settings->isAutosaveEnabled()); |
|
loadCheckbox("cbAddVerticalSpace", settings->getAddVerticalSpace()); |
|
loadCheckbox("cbAddHorizontalSpace", settings->getAddHorizontalSpace()); |
|
loadCheckbox("cbDrawDirModsEnabled", settings->getDrawDirModsEnabled()); |
|
loadCheckbox("cbStrokeFilterEnabled", settings->getStrokeFilterEnabled()); |
|
loadCheckbox("cbDoActionOnStrokeFiltered", settings->getDoActionOnStrokeFiltered()); |
|
loadCheckbox("cbTrySelectOnStrokeFiltered", settings->getTrySelectOnStrokeFiltered()); |
|
loadCheckbox("cbBigCursor", settings->isShowBigCursor()); |
|
loadCheckbox("cbHighlightPosition", settings->isHighlightPosition()); |
|
loadCheckbox("cbDarkTheme", settings->isDarkTheme()); |
|
loadCheckbox("cbHideHorizontalScrollbar", settings->getScrollbarHideType() & SCROLLBAR_HIDE_HORIZONTAL); |
|
loadCheckbox("cbHideVerticalScrollbar", settings->getScrollbarHideType() & SCROLLBAR_HIDE_VERTICAL); |
|
loadCheckbox("cbDisableScrollbarFadeout", settings->isScrollbarFadeoutDisabled()); |
|
loadCheckbox("cbTouchWorkaround", settings->isTouchWorkaround()); |
|
loadCheckbox("cbNewInputSystem", settings->getExperimentalInputSystemEnabled()); |
|
loadCheckbox("cbInputSystemTPCButton", settings->getInputSystemTPCButtonEnabled()); |
|
loadCheckbox("cbInputSystemDrawOutsideWindow", settings->getInputSystemDrawOutsideWindowEnabled()); |
|
|
|
|
|
GtkWidget* txtDefaultSaveName = get("txtDefaultSaveName"); |
|
string txt = settings->getDefaultSaveName(); |
|
gtk_entry_set_text(GTK_ENTRY(txtDefaultSaveName), txt.c_str()); |
|
|
|
gtk_file_chooser_set_uri(GTK_FILE_CHOOSER(get("fcAudioPath")), settings->getAudioFolder().c_str()); |
|
|
|
GtkWidget* spAutosaveTimeout = get("spAutosaveTimeout"); |
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spAutosaveTimeout), settings->getAutosaveTimeout()); |
|
|
|
GtkWidget* spPairsOffset = get("spPairsOffset"); |
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spPairsOffset), settings->getPairsOffset()); |
|
|
|
GtkWidget* spSnapRotationTolerance = get("spSnapRotationTolerance"); |
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spSnapRotationTolerance), settings->getSnapRotationTolerance()); |
|
|
|
GtkWidget* spSnapGridTolerance = get("spSnapGridTolerance"); |
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spSnapGridTolerance), settings->getSnapGridTolerance()); |
|
|
|
GtkWidget* spZoomStep = get("spZoomStep"); |
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spZoomStep), settings->getZoomStep()); |
|
|
|
GtkWidget* spZoomStepScroll = get("spZoomStepScroll"); |
|
gtk_spin_button_set_value( |
|
GTK_SPIN_BUTTON(spZoomStepScroll), settings->getZoomStepScroll()); |
|
|
|
GtkWidget* spAddHorizontalSpace = get("spAddHorizontalSpace"); |
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spAddHorizontalSpace), settings->getAddHorizontalSpaceAmount()); |
|
|
|
GtkWidget* spAddVerticalSpace = get("spAddVerticalSpace"); |
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spAddVerticalSpace), settings->getAddVerticalSpaceAmount()); |
|
|
|
GtkWidget* spDrawDirModsRadius = get("spDrawDirModsRadius"); |
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spDrawDirModsRadius), settings->getDrawDirModsRadius()); |
|
|
|
{ |
|
int time = 0; |
|
double length = 0; |
|
int successive = 0; |
|
settings->getStrokeFilter( &time, &length, &successive); |
|
|
|
GtkWidget* spStrokeIgnoreTime = get("spStrokeIgnoreTime"); |
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spStrokeIgnoreTime), time); |
|
GtkWidget* spStrokeIgnoreLength = get("spStrokeIgnoreLength"); |
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spStrokeIgnoreLength), length); |
|
GtkWidget* spStrokeSuccessiveTime = get("spStrokeSuccessiveTime"); |
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spStrokeSuccessiveTime), successive); |
|
} |
|
|
|
GtkWidget* slider = get("zoomCallibSlider"); |
|
|
|
this->setDpi(settings->getDisplayDpi()); |
|
gtk_range_set_value(GTK_RANGE(slider), dpi); |
|
|
|
GdkRGBA color = Util::rgb_to_GdkRGBA(settings->getBorderColor()); |
|
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(get("colorBorder")), &color); |
|
color = Util::rgb_to_GdkRGBA(settings->getBackgroundColor()); |
|
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(get("colorBackground")), &color); |
|
color = Util::rgb_to_GdkRGBA(settings->getSelectionColor()); |
|
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(get("colorSelection")), &color); |
|
|
|
|
|
bool hideFullscreenMenubar = false; |
|
bool hideFullscreenSidebar = false; |
|
bool hidePresentationMenubar = false; |
|
bool hidePresentationSidebar = false; |
|
|
|
string hidden = settings->getFullscreenHideElements(); |
|
|
|
for (const string& element: StringUtils::split(hidden, ',')) |
|
{ |
|
if (element == "mainMenubar") |
|
{ |
|
hideFullscreenMenubar = true; |
|
} |
|
else if (element == "sidebarContents") |
|
{ |
|
hideFullscreenSidebar = true; |
|
} |
|
} |
|
|
|
hidden = settings->getPresentationHideElements(); |
|
for (const string& element: StringUtils::split(hidden, ',')) |
|
{ |
|
if (element == "mainMenubar") |
|
{ |
|
hidePresentationMenubar = true; |
|
} |
|
else if (element == "sidebarContents") |
|
{ |
|
hidePresentationSidebar = true; |
|
} |
|
} |
|
|
|
loadCheckbox("cbHideFullscreenMenubar", hideFullscreenMenubar); |
|
loadCheckbox("cbHideFullscreenSidebar", hideFullscreenSidebar); |
|
loadCheckbox("cbHidePresentationMenubar", hidePresentationMenubar); |
|
loadCheckbox("cbHidePresentationSidebar", hidePresentationSidebar); |
|
loadCheckbox("cbHideMenubarStartup", settings->isMenubarVisible()); |
|
|
|
enableWithCheckbox("cbAutosave", "boxAutosave"); |
|
enableWithCheckbox("cbAddVerticalSpace", "spAddVerticalSpace"); |
|
enableWithCheckbox("cbAddHorizontalSpace", "spAddHorizontalSpace"); |
|
enableWithCheckbox("cbDrawDirModsEnabled", "spDrawDirModsRadius"); |
|
enableWithCheckbox("cbStrokeFilterEnabled", "spStrokeIgnoreTime"); |
|
enableWithCheckbox("cbStrokeFilterEnabled", "spStrokeIgnoreLength"); |
|
enableWithCheckbox("cbStrokeFilterEnabled", "spStrokeSuccessiveTime"); |
|
enableWithCheckbox("cbStrokeFilterEnabled", "cbDoActionOnStrokeFiltered"); |
|
enableWithCheckbox("cbStrokeFilterEnabled", "cbTrySelectOnStrokeFiltered"); |
|
enableWithCheckbox("cbDisableTouchOnPenNear", "boxInternalHandRecognition"); |
|
customHandRecognitionToggled(); |
|
|
|
|
|
SElement& touch = settings->getCustomElement("touch"); |
|
bool disablePen = false; |
|
touch.getBool("disableTouch", disablePen); |
|
loadCheckbox("cbDisableTouchOnPenNear", disablePen); |
|
|
|
string disableMethod; |
|
touch.getString("method", disableMethod); |
|
int methodId = 0; |
|
if (disableMethod == "X11") |
|
{ |
|
methodId = 1; |
|
} |
|
else if (disableMethod == "custom") |
|
{ |
|
methodId = 2; |
|
} |
|
|
|
gtk_combo_box_set_active(GTK_COMBO_BOX(get("cbTouchDisableMethod")), methodId); |
|
|
|
string cmd; |
|
touch.getString("cmdEnable", cmd); |
|
gtk_entry_set_text(GTK_ENTRY(get("txtEnableTouchCommand")), cmd.c_str()); |
|
|
|
cmd = ""; |
|
touch.getString("cmdDisable", cmd); |
|
gtk_entry_set_text(GTK_ENTRY(get("txtDisableTouchCommand")), cmd.c_str()); |
|
|
|
int timeoutMs = 1000; |
|
touch.getInt("timeout", timeoutMs); |
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(get("spTouchDisableTimeout")), timeoutMs / 1000.0); |
|
|
|
this->audioInputDevices = this->control->getAudioController()->getInputDevices(); |
|
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(get("cbAudioInputDevice")), "", "System default"); |
|
gtk_combo_box_set_active(GTK_COMBO_BOX(get("cbAudioInputDevice")), 0); |
|
for (auto &audioInputDevice : this->audioInputDevices) |
|
{ |
|
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(get("cbAudioInputDevice")), "", audioInputDevice.getDeviceName().c_str()); |
|
} |
|
for (size_t i = 0; i < this->audioInputDevices.size(); i++) |
|
{ |
|
if (this->audioInputDevices[i].getSelected()) |
|
{ |
|
gtk_combo_box_set_active(GTK_COMBO_BOX(get("cbAudioInputDevice")), i + 1); |
|
} |
|
} |
|
|
|
this->audioOutputDevices = this->control->getAudioController()->getOutputDevices(); |
|
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(get("cbAudioOutputDevice")), "", "System default"); |
|
gtk_combo_box_set_active(GTK_COMBO_BOX(get("cbAudioOutputDevice")), 0); |
|
for (auto &audioOutputDevice : this->audioOutputDevices) |
|
{ |
|
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(get("cbAudioOutputDevice")), "", audioOutputDevice.getDeviceName().c_str()); |
|
} |
|
for (size_t i = 0; i < this->audioOutputDevices.size(); i++) |
|
{ |
|
if (this->audioOutputDevices[i].getSelected()) |
|
{ |
|
gtk_combo_box_set_active(GTK_COMBO_BOX(get("cbAudioOutputDevice")), i + 1); |
|
} |
|
} |
|
|
|
switch((int)settings->getAudioSampleRate()) |
|
{ |
|
case 96100: |
|
gtk_combo_box_set_active(GTK_COMBO_BOX(get("cbAudioSampleRate")), 1); |
|
break; |
|
case 192000: |
|
gtk_combo_box_set_active(GTK_COMBO_BOX(get("cbAudioSampleRate")), 2); |
|
break; |
|
case 44100: |
|
default: |
|
gtk_combo_box_set_active(GTK_COMBO_BOX(get("cbAudioSampleRate")), 0); |
|
break; |
|
} |
|
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(get("spAudioGain")), settings->getAudioGain()); |
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(get("spDefaultSeekTime")), settings->getDefaultSeekTime()); |
|
} |
|
|
|
string SettingsDialog::updateHideString(const string& hidden, bool hideMenubar, bool hideSidebar) |
|
{ |
|
string newHidden; |
|
|
|
for (const string& element: StringUtils::split(hidden, ',')) |
|
{ |
|
if (element == "mainMenubar") |
|
{ |
|
if (hideMenubar) |
|
{ |
|
hideMenubar = false; |
|
} |
|
else |
|
{ |
|
continue; |
|
} |
|
} |
|
else if (element == "sidebarContents") |
|
{ |
|
if (hideSidebar) |
|
{ |
|
hideSidebar = false; |
|
} |
|
else |
|
{ |
|
continue; |
|
} |
|
} |
|
|
|
if (!newHidden.empty()) |
|
{ |
|
newHidden += ","; |
|
} |
|
newHidden += element; |
|
} |
|
|
|
if (hideMenubar) |
|
{ |
|
if (!newHidden.empty()) |
|
{ |
|
newHidden += ","; |
|
} |
|
newHidden += "mainMenubar"; |
|
} |
|
|
|
if (hideSidebar) |
|
{ |
|
if (!newHidden.empty()) |
|
{ |
|
newHidden += ","; |
|
} |
|
newHidden += "sidebarContents"; |
|
} |
|
|
|
return newHidden; |
|
} |
|
|
|
void SettingsDialog::save() |
|
{ |
|
settings->transactionStart(); |
|
|
|
settings->setPressureSensitivity(getCheckbox("cbSettingPresureSensitivity")); |
|
settings->setZoomGesturesEnabled(getCheckbox("cbEnableZoomGestures")); |
|
settings->setSidebarOnRight(getCheckbox("cbShowSidebarRight")); |
|
settings->setScrollbarOnLeft(getCheckbox("cbShowScrollbarLeft")); |
|
settings->setAutoloadPdfXoj(getCheckbox("cbAutoloadXoj")); |
|
settings->setAutosaveEnabled(getCheckbox("cbAutosave")); |
|
settings->setAddVerticalSpace(getCheckbox("cbAddVerticalSpace")); |
|
settings->setAddHorizontalSpace(getCheckbox("cbAddHorizontalSpace")); |
|
settings->setDrawDirModsEnabled(getCheckbox("cbDrawDirModsEnabled")); |
|
settings->setStrokeFilterEnabled(getCheckbox("cbStrokeFilterEnabled")); |
|
settings->setDoActionOnStrokeFiltered(getCheckbox("cbDoActionOnStrokeFiltered")); |
|
settings->setTrySelectOnStrokeFiltered(getCheckbox("cbTrySelectOnStrokeFiltered")); |
|
settings->setShowBigCursor(getCheckbox("cbBigCursor")); |
|
settings->setHighlightPosition(getCheckbox("cbHighlightPosition")); |
|
settings->setDarkTheme(getCheckbox("cbDarkTheme")); |
|
settings->setTouchWorkaround(getCheckbox("cbTouchWorkaround")); |
|
settings->setExperimentalInputSystemEnabled(getCheckbox("cbNewInputSystem")); |
|
settings->setInputSystemTPCButtonEnabled(getCheckbox("cbInputSystemTPCButton")); |
|
settings->setInputSystemDrawOutsideWindowEnabled(getCheckbox("cbInputSystemDrawOutsideWindow")); |
|
settings->setScrollbarFadeoutDisabled(getCheckbox("cbDisableScrollbarFadeout")); |
|
|
|
auto scrollbarHideType = |
|
static_cast<std::make_unsigned<std::underlying_type<ScrollbarHideType>::type>::type>(SCROLLBAR_HIDE_NONE); |
|
if (getCheckbox("cbHideHorizontalScrollbar")) |
|
{ |
|
scrollbarHideType |= SCROLLBAR_HIDE_HORIZONTAL; |
|
} |
|
if (getCheckbox("cbHideVerticalScrollbar")) |
|
{ |
|
scrollbarHideType |= SCROLLBAR_HIDE_VERTICAL; |
|
} |
|
settings->setScrollbarHideType(static_cast<ScrollbarHideType>(scrollbarHideType)); |
|
|
|
GdkRGBA color; |
|
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(get("colorBorder")), &color); |
|
settings->setBorderColor(Util::gdkrgba_to_hex(color)); |
|
|
|
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(get("colorBackground")), &color); |
|
settings->setBackgroundColor(Util::gdkrgba_to_hex(color)); |
|
|
|
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(get("colorSelection")), &color); |
|
settings->setSelectionColor(Util::gdkrgba_to_hex(color)); |
|
|
|
|
|
bool hideFullscreenMenubar = getCheckbox("cbHideFullscreenMenubar"); |
|
bool hideFullscreenSidebar = getCheckbox("cbHideFullscreenSidebar"); |
|
settings->setFullscreenHideElements( |
|
updateHideString(settings->getFullscreenHideElements(), hideFullscreenMenubar, hideFullscreenSidebar)); |
|
|
|
bool hidePresentationMenubar = getCheckbox("cbHidePresentationMenubar"); |
|
bool hidePresentationSidebar = getCheckbox("cbHidePresentationSidebar"); |
|
settings->setPresentationHideElements( |
|
updateHideString(settings->getPresentationHideElements(), hidePresentationMenubar, |
|
hidePresentationSidebar)); |
|
|
|
settings->setMenubarVisible(getCheckbox("cbHideMenubarStartup")); |
|
|
|
settings->setDefaultSaveName(gtk_entry_get_text(GTK_ENTRY(get("txtDefaultSaveName")))); |
|
char* uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(get("fcAudioPath"))); |
|
if (uri != nullptr) |
|
{ |
|
settings->setAudioFolder(uri); |
|
g_free(uri); |
|
} |
|
|
|
GtkWidget* spAutosaveTimeout = get("spAutosaveTimeout"); |
|
int autosaveTimeout = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spAutosaveTimeout)); |
|
settings->setAutosaveTimeout(autosaveTimeout); |
|
|
|
GtkWidget* spPairsOffset = get("spPairsOffset"); |
|
int numPairsOffset = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spPairsOffset)); |
|
settings->setPairsOffset(numPairsOffset); |
|
|
|
GtkWidget* spZoomStep = get("spZoomStep"); |
|
double zoomStep = gtk_spin_button_get_value( |
|
GTK_SPIN_BUTTON(spZoomStep)); |
|
settings->setZoomStep(zoomStep); |
|
|
|
GtkWidget* spZoomStepScroll = get("spZoomStepScroll"); |
|
double zoomStepScroll = gtk_spin_button_get_value( |
|
GTK_SPIN_BUTTON(spZoomStepScroll)); |
|
settings->setZoomStepScroll(zoomStepScroll); |
|
|
|
|
|
GtkWidget* spAddHorizontalSpace = get("spAddHorizontalSpace"); |
|
int addHorizontalSpaceAmount = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spAddHorizontalSpace)); |
|
settings->setAddHorizontalSpaceAmount(addHorizontalSpaceAmount); |
|
|
|
GtkWidget* spAddVerticalSpace = get("spAddVerticalSpace"); |
|
int addVerticalSpaceAmount = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spAddVerticalSpace)); |
|
settings->setAddVerticalSpaceAmount(addVerticalSpaceAmount); |
|
|
|
GtkWidget* spDrawDirModsRadius = get("spDrawDirModsRadius"); |
|
int drawDirModsRadius = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spDrawDirModsRadius)); |
|
settings->setDrawDirModsRadius(drawDirModsRadius); |
|
|
|
GtkWidget* spStrokeIgnoreTime = get("spStrokeIgnoreTime"); |
|
int strokeIgnoreTime = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spStrokeIgnoreTime)); |
|
GtkWidget* spStrokeIgnoreLength = get("spStrokeIgnoreLength"); |
|
double strokeIgnoreLength = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spStrokeIgnoreLength)); |
|
GtkWidget* spStrokeSuccessiveTime = get("spStrokeSuccessiveTime"); |
|
int strokeSuccessiveTime = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spStrokeSuccessiveTime)); |
|
settings->setStrokeFilter( strokeIgnoreTime, strokeIgnoreLength, strokeSuccessiveTime); |
|
|
|
|
|
|
|
settings->setDisplayDpi(dpi); |
|
|
|
for (ButtonConfigGui* bcg : this->buttonConfigs) |
|
{ |
|
bcg->saveSettings(); |
|
} |
|
|
|
SElement& touch = settings->getCustomElement("touch"); |
|
touch.setBool("disableTouch", getCheckbox("cbDisableTouchOnPenNear")); |
|
int touchMethod = gtk_combo_box_get_active(GTK_COMBO_BOX(get("cbTouchDisableMethod"))); |
|
|
|
switch (touchMethod) |
|
{ |
|
case 1: |
|
touch.setString("method", "X11"); |
|
break; |
|
case 2: |
|
touch.setString("method", "custom"); |
|
break; |
|
case 0: |
|
default: |
|
touch.setString("method", "auto"); |
|
} |
|
touch.setString("cmdEnable", gtk_entry_get_text(GTK_ENTRY(get("txtEnableTouchCommand")))); |
|
touch.setString("cmdDisable", gtk_entry_get_text(GTK_ENTRY(get("txtDisableTouchCommand")))); |
|
|
|
touch.setInt("timeout", (int)(gtk_spin_button_get_value(GTK_SPIN_BUTTON(get("spTouchDisableTimeout"))) * 1000)); |
|
|
|
settings->setSnapRotationTolerance((double)gtk_spin_button_get_value(GTK_SPIN_BUTTON(get("spSnapRotationTolerance")))); |
|
settings->setSnapGridTolerance((double)gtk_spin_button_get_value(GTK_SPIN_BUTTON(get("spSnapGridTolerance")))); |
|
|
|
int selectedInputDeviceIndex = gtk_combo_box_get_active(GTK_COMBO_BOX(get("cbAudioInputDevice"))) - 1; |
|
if (selectedInputDeviceIndex >= 0 && selectedInputDeviceIndex < (int)this->audioInputDevices.size()) |
|
{ |
|
settings->setAudioInputDevice((int) this->audioInputDevices[selectedInputDeviceIndex].getIndex()); |
|
} |
|
|
|
int selectedOutputDeviceIndex = gtk_combo_box_get_active(GTK_COMBO_BOX(get("cbAudioOutputDevice"))) - 1; |
|
if (selectedOutputDeviceIndex >= 0 && selectedOutputDeviceIndex < (int)this->audioOutputDevices.size()) |
|
{ |
|
settings->setAudioOutputDevice((int) this->audioOutputDevices[selectedOutputDeviceIndex].getIndex()); |
|
} |
|
|
|
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(get("cbAudioSampleRate")))) |
|
{ |
|
case 1: |
|
settings->setAudioSampleRate(96100.0); |
|
break; |
|
case 2: |
|
settings->setAudioSampleRate(192000.0); |
|
break; |
|
case 0: |
|
default: |
|
settings->setAudioSampleRate(44100.0); |
|
break; |
|
} |
|
|
|
settings->setAudioGain((double)gtk_spin_button_get_value(GTK_SPIN_BUTTON(get("spAudioGain")))); |
|
settings->setDefaultSeekTime((double)gtk_spin_button_get_value(GTK_SPIN_BUTTON(get("spDefaultSeekTime")))); |
|
|
|
for (DeviceClassConfigGui* deviceClassConfigGui : this->deviceClassConfigs) |
|
{ |
|
deviceClassConfigGui->saveSettings(); |
|
} |
|
|
|
settings->transactionEnd(); |
|
|
|
this->control->getWindow()->setTouchscreenScrollingForDeviceMapping(); |
|
}
|
|
|