style: unify identifier naming per updated conventions

Automated with clang-tidy readability-identifier-naming (config added to
.clang-tidy) plus scripted passes, per the updated rules now documented
in CONTRIBUTING.md:

- types (class/struct/enum/alias/template params): PascalCase
- functions, variables, members: snake_case (incl. rational -> Rational)
- private/protected members: trailing underscore; static member
  variables likewise (instance_, available_themes_)
- constants and enum values: snake_case (kLinear -> k_linear,
  F32P -> f32p); ALL_CAPS reserved for macros
- macros: OAK_ prefix (OLIVE_ADD_TEST/OLIVE_ASSERT/OLIVE_CONFIG ->
  OAK_ADD_TEST/OAK_ASSERT/OAK_CONFIG, GL_PREAMBLE -> OAK_GL_PREAMBLE,
  include guards -> OAK_*)
- file names: all lowercase (Current/Plugin/OliveHost/OliveClip/
  OlivePluginInstance -> current/plugin/olivehost/oliveclip/
  oliveplugininstance)
- getters share the member name sans underscore, setters set_foo()
- Qt and third-party (OpenFX) virtual overrides and framework callbacks
  keep their original names (exempt in .clang-tidy)

Manual follow-ups required where automation could not reach:
- string-based QMetaObject/SIGNAL/SLOT references updated to renamed
  methods (AddTask, CreatedFile, DeleteSpecificFile, moveSelectionUp, ...)
- macro bodies referencing renamed methods (OLIVE_CONFIG,
  NODE_DEFAULT_DESTRUCTOR, MANAGEDDISPLAYWIDGET_*)
- self-shadowing locals renamed where signals/methods became same-named
  (size_changed, worker_count, selected_items, import param, filters)
- third_party OFX member/namespace usages restored (OFX::Host::*,
  _created, _clipPrefsDirty, createInstance, clearPersistentMessage)
- STL protocol aliases restored (const_iterator) with .clang-tidy
  ignore rules; qHash overloads restored

Full build and test suite pass: ctest 4/4, ~1960 gtest cases green.

app/window/mainwindow/mainmenu.cpp

@@ -48,36 +48,36 @@ MainMenu::MainMenu(MainWindow *parent)
 	//
 	// FILE MENU
 	//
-	file_menu_ = new Menu(this, this, &MainMenu::FileMenuAboutToShow);
+	file_menu_ = new Menu(this, this, &MainMenu::file_menu_about_to_show);
 	file_new_menu_ = new Menu(file_menu_);
-	MenuShared::instance()->AddItemsForNewMenu(file_new_menu_);
-	file_open_item_ = file_menu_->AddItem("openproj", Core::instance(),
-										  &Core::OpenProject, tr("Ctrl+O"));
+	MenuShared::instance()->add_items_for_new_menu(file_new_menu_);
+	file_open_item_ = file_menu_->add_item("openproj", Core::instance(),
+										  &Core::open_project, tr("Ctrl+O"));
 	file_open_recent_menu_ = new Menu(file_menu_);
 	file_open_recent_separator_ = file_open_recent_menu_->addSeparator();
-	file_open_recent_clear_item_ = file_open_recent_menu_->AddItem(
-		"clearopenrecent", Core::instance(), &Core::ClearOpenRecentList);
-	file_save_item_ = file_menu_->AddItem("saveproj", Core::instance(),
-										  &Core::SaveProject, tr("Ctrl+S"));
-	file_save_as_item_ = file_menu_->AddItem("saveprojas", Core::instance(),
-											 &Core::SaveProjectAs,
+	file_open_recent_clear_item_ = file_open_recent_menu_->add_item(
+		"clearopenrecent", Core::instance(), &Core::clear_open_recent_list);
+	file_save_item_ = file_menu_->add_item("saveproj", Core::instance(),
+										  &Core::save_project, tr("Ctrl+S"));
+	file_save_as_item_ = file_menu_->add_item("saveprojas", Core::instance(),
+											 &Core::save_project_as,
 											 tr("Ctrl+Shift+S"));
 	file_menu_->addSeparator();
-	file_revert_item_ = file_menu_->AddItem("revert", Core::instance(),
-											&Core::RevertProject, tr("F12"));
+	file_revert_item_ = file_menu_->add_item("revert", Core::instance(),
+											&Core::revert_project, tr("F12"));
 	file_menu_->addSeparator();
-	file_import_item_ = file_menu_->AddItem(
-		"import", Core::instance(), &Core::DialogImportShow, tr("Ctrl+I"));
+	file_import_item_ = file_menu_->add_item(
+		"import", Core::instance(), &Core::dialog_import_show, tr("Ctrl+I"));
 	file_menu_->addSeparator();
 	file_export_menu_ = new Menu(file_menu_);
-	file_export_media_item_ = file_export_menu_->AddItem(
-		"export", Core::instance(), &Core::DialogExportShow, tr("Ctrl+M"));
+	file_export_media_item_ = file_export_menu_->add_item(
+		"export", Core::instance(), &Core::dialog_export_show, tr("Ctrl+M"));
 	file_menu_->addSeparator();
-	file_project_properties_item_ = file_menu_->AddItem(
+	file_project_properties_item_ = file_menu_->add_item(
 		"projectproperties", Core::instance(),
-		&Core::DialogProjectPropertiesShow, tr("Shift+F10"));
+		&Core::dialog_project_properties_show, tr("Shift+F10"));
 	file_menu_->addSeparator();
-	file_exit_item_ = file_menu_->AddItem("exit", parent, &MainWindow::close);
+	file_exit_item_ = file_menu_->add_item("exit", parent, &MainWindow::close);
 
 	//
 	// EDIT MENU
@@ -85,25 +85,25 @@ MainMenu::MainMenu(MainWindow *parent)
 	edit_menu_ = new Menu(this);
 
 	connect(edit_menu_, &Menu::aboutToShow, this,
-			&MainMenu::EditMenuAboutToShow);
+			&MainMenu::edit_menu_about_to_show);
 	connect(edit_menu_, &Menu::aboutToHide, this,
-			&MainMenu::EditMenuAboutToHide);
+			&MainMenu::edit_menu_about_to_hide);
 
 	edit_undo_item_ = Core::instance()->undo_stack()->GetUndoAction();
-	Menu::ConformItem(edit_undo_item_, "undo", tr("Ctrl+Z"));
+	Menu::conform_item(edit_undo_item_, "undo", tr("Ctrl+Z"));
 	edit_menu_->addAction(edit_undo_item_);
 	edit_redo_item_ = Core::instance()->undo_stack()->GetRedoAction();
-	Menu::ConformItem(edit_redo_item_, "redo", tr("Ctrl+Shift+Z"));
+	Menu::conform_item(edit_redo_item_, "redo", tr("Ctrl+Shift+Z"));
 	edit_menu_->addAction(edit_redo_item_);
 
 	edit_menu_->addSeparator();
-	MenuShared::instance()->AddItemsForEditMenu(edit_menu_, true);
+	MenuShared::instance()->add_items_for_edit_menu(edit_menu_, true);
 	{
 		// Create "alternate delete" action so we can pick up backspace as well as delete while still
 		// keeping them configurable
 		edit_delete2_item_ = new QAction();
-		Menu::ConformItem(edit_delete2_item_, "delete2", MenuShared::instance(),
-						  &MenuShared::DeleteSelectedTriggered,
+		Menu::conform_item(edit_delete2_item_, "delete2", MenuShared::instance(),
+						  &MenuShared::delete_selected_triggered,
 						  tr("Backspace"));
 		auto actions = edit_menu_->actions();
 		edit_menu_->insertAction(
@@ -113,136 +113,136 @@ MainMenu::MainMenu(MainWindow *parent)
 			edit_delete2_item_);
 	}
 	edit_menu_->addSeparator();
-	edit_select_all_item_ = edit_menu_->AddItem(
-		"selectall", this, &MainMenu::SelectAllTriggered, tr("Ctrl+A"));
-	edit_deselect_all_item_ = edit_menu_->AddItem(
-		"deselectall", this, &MainMenu::DeselectAllTriggered,
+	edit_select_all_item_ = edit_menu_->add_item(
+		"selectall", this, &MainMenu::select_all_triggered, tr("Ctrl+A"));
+	edit_deselect_all_item_ = edit_menu_->add_item(
+		"deselectall", this, &MainMenu::deselect_all_triggered,
 		tr("Ctrl+Shift+A"));
 	edit_menu_->addSeparator();
-	MenuShared::instance()->AddItemsForClipEditMenu(edit_menu_);
+	MenuShared::instance()->add_items_for_clip_edit_menu(edit_menu_);
 	edit_menu_->addSeparator();
-	edit_insert_item_ = edit_menu_->AddItem(
-		"insert", this, &MainMenu::InsertTriggered, tr(","));
-	edit_overwrite_item_ = edit_menu_->AddItem(
-		"overwrite", this, &MainMenu::OverwriteTriggered, tr("."));
+	edit_insert_item_ = edit_menu_->add_item(
+		"insert", this, &MainMenu::insert_triggered, tr(","));
+	edit_overwrite_item_ = edit_menu_->add_item(
+		"overwrite", this, &MainMenu::overwrite_triggered, tr("."));
 	edit_menu_->addSeparator();
-	edit_ripple_to_in_item_ = edit_menu_->AddItem(
-		"rippletoin", this, &MainMenu::RippleToInTriggered, tr("Q"));
-	edit_ripple_to_out_item_ = edit_menu_->AddItem(
-		"rippletoout", this, &MainMenu::RippleToOutTriggered, tr("W"));
-	edit_edit_to_in_item_ = edit_menu_->AddItem(
-		"edittoin", this, &MainMenu::EditToInTriggered, tr("Ctrl+Alt+Q"));
-	edit_edit_to_out_item_ = edit_menu_->AddItem(
-		"edittoout", this, &MainMenu::EditToOutTriggered, tr("Ctrl+Alt+W"));
+	edit_ripple_to_in_item_ = edit_menu_->add_item(
+		"rippletoin", this, &MainMenu::ripple_to_in_triggered, tr("Q"));
+	edit_ripple_to_out_item_ = edit_menu_->add_item(
+		"rippletoout", this, &MainMenu::ripple_to_out_triggered, tr("W"));
+	edit_edit_to_in_item_ = edit_menu_->add_item(
+		"edittoin", this, &MainMenu::edit_to_in_triggered, tr("Ctrl+Alt+Q"));
+	edit_edit_to_out_item_ = edit_menu_->add_item(
+		"edittoout", this, &MainMenu::edit_to_out_triggered, tr("Ctrl+Alt+W"));
 	edit_menu_->addSeparator();
-	edit_nudge_left_item_ = edit_menu_->AddItem(
-		"nudgeleft", this, &MainMenu::NudgeLeftTriggered, tr("Alt+Left"));
-	edit_nudge_right_item_ = edit_menu_->AddItem(
-		"nudgeright", this, &MainMenu::NudgeRightTriggered, tr("Alt+Right"));
+	edit_nudge_left_item_ = edit_menu_->add_item(
+		"nudgeleft", this, &MainMenu::nudge_left_triggered, tr("Alt+Left"));
+	edit_nudge_right_item_ = edit_menu_->add_item(
+		"nudgeright", this, &MainMenu::nudge_right_triggered, tr("Alt+Right"));
 	edit_move_in_to_playhead_item_ =
-		edit_menu_->AddItem("moveintoplayhead", this,
-							&MainMenu::MoveInToPlayheadTriggered, tr("["));
+		edit_menu_->add_item("moveintoplayhead", this,
+							&MainMenu::move_in_to_playhead_triggered, tr("["));
 	edit_move_out_to_playhead_item_ =
-		edit_menu_->AddItem("moveouttoplayhead", this,
-							&MainMenu::MoveOutToPlayheadTriggered, tr("]"));
+		edit_menu_->add_item("moveouttoplayhead", this,
+							&MainMenu::move_out_to_playhead_triggered, tr("]"));
 	edit_menu_->addSeparator();
-	MenuShared::instance()->AddItemsForInOutMenu(edit_menu_);
-	edit_delete_inout_item_ = edit_menu_->AddItem(
-		"deleteinout", this, &MainMenu::DeleteInOutTriggered, tr(";"));
+	MenuShared::instance()->add_items_for_in_out_menu(edit_menu_);
+	edit_delete_inout_item_ = edit_menu_->add_item(
+		"deleteinout", this, &MainMenu::delete_in_out_triggered, tr(";"));
 	edit_ripple_delete_inout_item_ =
-		edit_menu_->AddItem("rippledeleteinout", this,
-							&MainMenu::RippleDeleteInOutTriggered, tr("'"));
+		edit_menu_->add_item("rippledeleteinout", this,
+							&MainMenu::ripple_delete_in_out_triggered, tr("'"));
 	edit_menu_->addSeparator();
-	edit_set_marker_item_ = edit_menu_->AddItem(
-		"marker", this, &MainMenu::SetMarkerTriggered, tr("M"));
+	edit_set_marker_item_ = edit_menu_->add_item(
+		"marker", this, &MainMenu::set_marker_triggered, tr("M"));
 
 	//
 	// VIEW MENU
 	//
-	view_menu_ = new Menu(this, this, &MainMenu::ViewMenuAboutToShow);
-	view_zoom_in_item_ = view_menu_->AddItem(
-		"zoomin", this, &MainMenu::ZoomInTriggered, tr("="));
-	view_zoom_out_item_ = view_menu_->AddItem(
-		"zoomout", this, &MainMenu::ZoomOutTriggered, tr("-"));
-	view_increase_track_height_item_ = view_menu_->AddItem(
-		"vzoomin", this, &MainMenu::IncreaseTrackHeightTriggered, tr("Ctrl+="));
-	view_decrease_track_height_item_ = view_menu_->AddItem(
-		"vzoomout", this, &MainMenu::DecreaseTrackHeightTriggered,
+	view_menu_ = new Menu(this, this, &MainMenu::view_menu_about_to_show);
+	view_zoom_in_item_ = view_menu_->add_item(
+		"zoomin", this, &MainMenu::zoom_in_triggered, tr("="));
+	view_zoom_out_item_ = view_menu_->add_item(
+		"zoomout", this, &MainMenu::zoom_out_triggered, tr("-"));
+	view_increase_track_height_item_ = view_menu_->add_item(
+		"vzoomin", this, &MainMenu::increase_track_height_triggered, tr("Ctrl+="));
+	view_decrease_track_height_item_ = view_menu_->add_item(
+		"vzoomout", this, &MainMenu::decrease_track_height_triggered,
 		tr("Ctrl+-"));
-	view_show_all_item_ = view_menu_->AddItem(
-		"showall", this, &MainMenu::ToggleShowAllTriggered, tr("\\"));
+	view_show_all_item_ = view_menu_->add_item(
+		"showall", this, &MainMenu::toggle_show_all_triggered, tr("\\"));
 	view_show_all_item_->setCheckable(true);
 
 	view_menu_->addSeparator();
 
-	view_full_screen_item_ = view_menu_->AddItem(
-		"fullscreen", parent, &MainWindow::SetFullscreen, tr("F11"));
+	view_full_screen_item_ = view_menu_->add_item(
+		"fullscreen", parent, &MainWindow::set_fullscreen, tr("F11"));
 	view_full_screen_item_->setCheckable(true);
 
-	view_full_screen_viewer_item_ = view_menu_->AddItem(
-		"fullscreenviewer", this, &MainMenu::FullScreenViewerTriggered);
+	view_full_screen_viewer_item_ = view_menu_->add_item(
+		"fullscreenviewer", this, &MainMenu::full_screen_viewer_triggered);
 
 	//
 	// PLAYBACK MENU
 	//
-	playback_menu_ = new Menu(this, this, &MainMenu::PlaybackMenuAboutToShow);
-	playback_gotostart_item_ = playback_menu_->AddItem(
-		"gotostart", this, &MainMenu::GoToStartTriggered, tr("Home"));
-	playback_prevframe_item_ = playback_menu_->AddItem(
-		"prevframe", this, &MainMenu::PrevFrameTriggered, tr("Left"));
-	playback_playpause_item_ = playback_menu_->AddItem(
-		"playpause", this, &MainMenu::PlayPauseTriggered, tr("Space"));
-	playback_playinout_item_ = playback_menu_->AddItem(
-		"playintoout", this, &MainMenu::PlayInToOutTriggered,
+	playback_menu_ = new Menu(this, this, &MainMenu::playback_menu_about_to_show);
+	playback_gotostart_item_ = playback_menu_->add_item(
+		"gotostart", this, &MainMenu::go_to_start_triggered, tr("Home"));
+	playback_prevframe_item_ = playback_menu_->add_item(
+		"prevframe", this, &MainMenu::prev_frame_triggered, tr("Left"));
+	playback_playpause_item_ = playback_menu_->add_item(
+		"playpause", this, &MainMenu::play_pause_triggered, tr("Space"));
+	playback_playinout_item_ = playback_menu_->add_item(
+		"playintoout", this, &MainMenu::play_in_to_out_triggered,
 		tr("Shift+Space"));
-	playback_nextframe_item_ = playback_menu_->AddItem(
-		"nextframe", this, &MainMenu::NextFrameTriggered, tr("Right"));
-	playback_gotoend_item_ = playback_menu_->AddItem(
-		"gotoend", this, &MainMenu::GoToEndTriggered, tr("End"));
+	playback_nextframe_item_ = playback_menu_->add_item(
+		"nextframe", this, &MainMenu::next_frame_triggered, tr("Right"));
+	playback_gotoend_item_ = playback_menu_->add_item(
+		"gotoend", this, &MainMenu::go_to_end_triggered, tr("End"));
 
 	playback_menu_->addSeparator();
 
-	playback_prevcut_item_ = playback_menu_->AddItem(
-		"prevcut", this, &MainMenu::GoToPrevCutTriggered, tr("Up"));
-	playback_nextcut_item_ = playback_menu_->AddItem(
-		"nextcut", this, &MainMenu::GoToNextCutTriggered, tr("Down"));
+	playback_prevcut_item_ = playback_menu_->add_item(
+		"prevcut", this, &MainMenu::go_to_prev_cut_triggered, tr("Up"));
+	playback_nextcut_item_ = playback_menu_->add_item(
+		"nextcut", this, &MainMenu::go_to_next_cut_triggered, tr("Down"));
 
 	playback_menu_->addSeparator();
 
-	playback_gotoin_item_ = playback_menu_->AddItem(
-		"gotoin", this, &MainMenu::GoToInTriggered, tr("Shift+I"));
-	playback_gotoout_item_ = playback_menu_->AddItem(
-		"gotoout", this, &MainMenu::GoToOutTriggered, tr("Shift+O"));
+	playback_gotoin_item_ = playback_menu_->add_item(
+		"gotoin", this, &MainMenu::go_to_in_triggered, tr("Shift+I"));
+	playback_gotoout_item_ = playback_menu_->add_item(
+		"gotoout", this, &MainMenu::go_to_out_triggered, tr("Shift+O"));
 
 	playback_menu_->addSeparator();
 
-	playback_shuttleleft_item_ = playback_menu_->AddItem(
-		"decspeed", this, &MainMenu::ShuttleLeftTriggered, tr("J"));
-	playback_shuttlestop_item_ = playback_menu_->AddItem(
-		"pause", this, &MainMenu::ShuttleStopTriggered, tr("K"));
-	playback_shuttleright_item_ = playback_menu_->AddItem(
-		"incspeed", this, &MainMenu::ShuttleRightTriggered, tr("L"));
+	playback_shuttleleft_item_ = playback_menu_->add_item(
+		"decspeed", this, &MainMenu::shuttle_left_triggered, tr("J"));
+	playback_shuttlestop_item_ = playback_menu_->add_item(
+		"pause", this, &MainMenu::shuttle_stop_triggered, tr("K"));
+	playback_shuttleright_item_ = playback_menu_->add_item(
+		"incspeed", this, &MainMenu::shuttle_right_triggered, tr("L"));
 
 	playback_menu_->addSeparator();
 
 	playback_loop_item_ =
-		playback_menu_->AddItem("loop", this, &MainMenu::LoopTriggered);
+		playback_menu_->add_item("loop", this, &MainMenu::loop_triggered);
 	playback_loop_item_->setCheckable(true);
 
 	//
 	// SEQUENCE MENU
 	//
 
-	sequence_menu_ = new Menu(this, this, &MainMenu::SequenceMenuAboutToShow);
-	sequence_cache_item_ = sequence_menu_->AddItem(
-		"seqcache", this, &MainMenu::SequenceCacheTriggered);
-	sequence_cache_in_to_out_item_ = sequence_menu_->AddItem(
-		"seqcacheinout", this, &MainMenu::SequenceCacheInOutTriggered);
+	sequence_menu_ = new Menu(this, this, &MainMenu::sequence_menu_about_to_show);
+	sequence_cache_item_ = sequence_menu_->add_item(
+		"seqcache", this, &MainMenu::sequence_cache_triggered);
+	sequence_cache_in_to_out_item_ = sequence_menu_->add_item(
+		"seqcacheinout", this, &MainMenu::sequence_cache_in_out_triggered);
 
 	sequence_menu_->addSeparator();
 
-	sequence_disk_cache_clear_item_ = sequence_menu_->AddItem(
-		"seqcacheclear", this, &MainMenu::SequenceCacheClearTriggered);
+	sequence_disk_cache_clear_item_ = sequence_menu_->add_item(
+		"seqcacheclear", this, &MainMenu::sequence_cache_clear_triggered);
 
 	// TEMP: Hide sequence cache items for now. Want to see if clip caching will supersede it.
 	sequence_cache_item_->setVisible(false);
@@ -251,98 +251,98 @@ MainMenu::MainMenu(MainWindow *parent)
 	//
 	// WINDOW MENU
 	//
-	window_menu_ = new Menu(this, this, &MainMenu::WindowMenuAboutToShow);
+	window_menu_ = new Menu(this, this, &MainMenu::window_menu_about_to_show);
 	window_menu_separator_ = window_menu_->addSeparator();
-	window_maximize_panel_item_ = window_menu_->AddItem(
-		"maximizepanel", parent, &MainWindow::ToggleMaximizedPanel, tr("`"));
+	window_maximize_panel_item_ = window_menu_->add_item(
+		"maximizepanel", parent, &MainWindow::toggle_maximized_panel, tr("`"));
 	window_menu_->addSeparator();
-	window_reset_layout_item_ = window_menu_->AddItem(
-		"resetdefaultlayout", parent, &MainWindow::SetDefaultLayout);
+	window_reset_layout_item_ = window_menu_->add_item(
+		"resetdefaultlayout", parent, &MainWindow::set_default_layout);
 
 	//
 	// TOOLS MENU
 	//
-	tools_menu_ = new Menu(this, this, &MainMenu::ToolsMenuAboutToShow);
+	tools_menu_ = new Menu(this, this, &MainMenu::tools_menu_about_to_show);
 	tools_menu_->setToolTipsVisible(true);
 
 	tools_group_ = new QActionGroup(this);
 
-	tools_pointer_item_ = tools_menu_->AddItem(
-		"pointertool", this, &MainMenu::ToolItemTriggered, tr("V"));
+	tools_pointer_item_ = tools_menu_->add_item(
+		"pointertool", this, &MainMenu::tool_item_triggered, tr("V"));
 	tools_pointer_item_->setCheckable(true);
-	tools_pointer_item_->setData(Tool::kPointer);
+	tools_pointer_item_->setData(Tool::k_pointer);
 	tools_group_->addAction(tools_pointer_item_);
 
-	tools_trackselect_item_ = tools_menu_->AddItem(
-		"trackselecttool", this, &MainMenu::ToolItemTriggered, tr("D"));
+	tools_trackselect_item_ = tools_menu_->add_item(
+		"trackselecttool", this, &MainMenu::tool_item_triggered, tr("D"));
 	tools_trackselect_item_->setCheckable(true);
-	tools_trackselect_item_->setData(Tool::kTrackSelect);
+	tools_trackselect_item_->setData(Tool::k_track_select);
 	tools_group_->addAction(tools_trackselect_item_);
 
-	tools_edit_item_ = tools_menu_->AddItem(
-		"edittool", this, &MainMenu::ToolItemTriggered, tr("X"));
+	tools_edit_item_ = tools_menu_->add_item(
+		"edittool", this, &MainMenu::tool_item_triggered, tr("X"));
 	tools_edit_item_->setCheckable(true);
-	tools_edit_item_->setData(Tool::kEdit);
+	tools_edit_item_->setData(Tool::k_edit);
 	tools_group_->addAction(tools_edit_item_);
 
-	tools_ripple_item_ = tools_menu_->AddItem(
-		"rippletool", this, &MainMenu::ToolItemTriggered, tr("B"));
+	tools_ripple_item_ = tools_menu_->add_item(
+		"rippletool", this, &MainMenu::tool_item_triggered, tr("B"));
 	tools_ripple_item_->setCheckable(true);
-	tools_ripple_item_->setData(Tool::kRipple);
+	tools_ripple_item_->setData(Tool::k_ripple);
 	tools_group_->addAction(tools_ripple_item_);
 
-	tools_rolling_item_ = tools_menu_->AddItem(
-		"rollingtool", this, &MainMenu::ToolItemTriggered, tr("N"));
+	tools_rolling_item_ = tools_menu_->add_item(
+		"rollingtool", this, &MainMenu::tool_item_triggered, tr("N"));
 	tools_rolling_item_->setCheckable(true);
-	tools_rolling_item_->setData(Tool::kRolling);
+	tools_rolling_item_->setData(Tool::k_rolling);
 	tools_group_->addAction(tools_rolling_item_);
 
-	tools_razor_item_ = tools_menu_->AddItem(
-		"razortool", this, &MainMenu::ToolItemTriggered, tr("C"));
+	tools_razor_item_ = tools_menu_->add_item(
+		"razortool", this, &MainMenu::tool_item_triggered, tr("C"));
 	tools_razor_item_->setCheckable(true);
-	tools_razor_item_->setData(Tool::kRazor);
+	tools_razor_item_->setData(Tool::k_razor);
 	tools_group_->addAction(tools_razor_item_);
 
-	tools_slip_item_ = tools_menu_->AddItem(
-		"sliptool", this, &MainMenu::ToolItemTriggered, tr("Y"));
+	tools_slip_item_ = tools_menu_->add_item(
+		"sliptool", this, &MainMenu::tool_item_triggered, tr("Y"));
 	tools_slip_item_->setCheckable(true);
-	tools_slip_item_->setData(Tool::kSlip);
+	tools_slip_item_->setData(Tool::k_slip);
 	tools_group_->addAction(tools_slip_item_);
 
-	tools_slide_item_ = tools_menu_->AddItem(
-		"slidetool", this, &MainMenu::ToolItemTriggered, tr("U"));
+	tools_slide_item_ = tools_menu_->add_item(
+		"slidetool", this, &MainMenu::tool_item_triggered, tr("U"));
 	tools_slide_item_->setCheckable(true);
-	tools_slide_item_->setData(Tool::kSlide);
+	tools_slide_item_->setData(Tool::k_slide);
 	tools_group_->addAction(tools_slide_item_);
 
-	tools_hand_item_ = tools_menu_->AddItem(
-		"handtool", this, &MainMenu::ToolItemTriggered, tr("H"));
+	tools_hand_item_ = tools_menu_->add_item(
+		"handtool", this, &MainMenu::tool_item_triggered, tr("H"));
 	tools_hand_item_->setCheckable(true);
-	tools_hand_item_->setData(Tool::kHand);
+	tools_hand_item_->setData(Tool::k_hand);
 	tools_group_->addAction(tools_hand_item_);
 
-	tools_zoom_item_ = tools_menu_->AddItem(
-		"zoomtool", this, &MainMenu::ToolItemTriggered, tr("Z"));
+	tools_zoom_item_ = tools_menu_->add_item(
+		"zoomtool", this, &MainMenu::tool_item_triggered, tr("Z"));
 	tools_zoom_item_->setCheckable(true);
-	tools_zoom_item_->setData(Tool::kZoom);
+	tools_zoom_item_->setData(Tool::k_zoom);
 	tools_group_->addAction(tools_zoom_item_);
 
-	tools_transition_item_ = tools_menu_->AddItem(
-		"transitiontool", this, &MainMenu::ToolItemTriggered, tr("T"));
+	tools_transition_item_ = tools_menu_->add_item(
+		"transitiontool", this, &MainMenu::tool_item_triggered, tr("T"));
 	tools_transition_item_->setCheckable(true);
-	tools_transition_item_->setData(Tool::kTransition);
+	tools_transition_item_->setData(Tool::k_transition);
 	tools_group_->addAction(tools_transition_item_);
 
-	tools_add_item_ = tools_menu_->AddItem(
-		"addtool", this, &MainMenu::ToolItemTriggered, tr("A"));
+	tools_add_item_ = tools_menu_->add_item(
+		"addtool", this, &MainMenu::tool_item_triggered, tr("A"));
 	tools_add_item_->setCheckable(true);
-	tools_add_item_->setData(Tool::kAdd);
+	tools_add_item_->setData(Tool::k_add);
 	tools_group_->addAction(tools_add_item_);
 
-	tools_record_item_ = tools_menu_->AddItem(
-		"recordtool", this, &MainMenu::ToolItemTriggered, tr("R"));
+	tools_record_item_ = tools_menu_->add_item(
+		"recordtool", this, &MainMenu::tool_item_triggered, tr("R"));
 	tools_record_item_->setCheckable(true);
-	tools_record_item_->setData(Tool::kRecord);
+	tools_record_item_->setData(Tool::k_record);
 	tools_group_->addAction(tools_record_item_);
 
 	tools_menu_->addSeparator();
@@ -350,27 +350,27 @@ MainMenu::MainMenu(MainWindow *parent)
 	tools_add_item_menu_ = new Menu(tools_menu_);
 	tools_menu_->addMenu(tools_add_item_menu_);
 
-	MenuShared::instance()->AddItemsForAddableObjectsMenu(tools_add_item_menu_);
+	MenuShared::instance()->add_items_for_addable_objects_menu(tools_add_item_menu_);
 
 	tools_menu_->addSeparator();
 
-	tools_snapping_item_ = tools_menu_->AddItem("snapping", Core::instance(),
-												&Core::SetSnapping, tr("S"));
+	tools_snapping_item_ = tools_menu_->add_item("snapping", Core::instance(),
+												&Core::set_snapping, tr("S"));
 	tools_snapping_item_->setCheckable(true);
 	tools_snapping_item_->setChecked(Core::instance()->snapping());
 
 	tools_menu_->addSeparator();
 
 	tools_proxy_settings_item_ = new QAction(this);
-	Menu::ConformItem(tools_proxy_settings_item_, "proxysettings");
+	Menu::conform_item(tools_proxy_settings_item_, "proxysettings");
 	connect(tools_proxy_settings_item_, &QAction::triggered, this, [this]() {
 		ProxyDialog d(this);
 		d.exec();
 	});
 	tools_menu_->addAction(tools_proxy_settings_item_);
 
-	tools_preferences_item_ = tools_menu_->AddItem(
-		"prefs", Core::instance(), &Core::DialogPreferencesShow, tr("Ctrl+,"));
+	tools_preferences_item_ = tools_menu_->add_item(
+		"prefs", Core::instance(), &Core::dialog_preferences_show, tr("Ctrl+,"));
 	// On macOS, Qt's text heuristic would relocate an English "Preferences"
 	// action to the application menu, making it disappear from the Tools menu.
 	// Pin it to this menu on all platforms.
@@ -378,7 +378,7 @@ MainMenu::MainMenu(MainWindow *parent)
 
 #ifndef NDEBUG
 	tools_magic_item_ =
-		tools_menu_->AddItem("magic", Core::instance(), &Core::SetMagic);
+		tools_menu_->add_item("magic", Core::instance(), &Core::set_magic);
 	tools_magic_item_->setCheckable(true);
 #endif
 
@@ -386,31 +386,31 @@ MainMenu::MainMenu(MainWindow *parent)
 	// HELP MENU
 	//
 	help_menu_ = new Menu(this);
-	help_action_search_item_ = help_menu_->AddItem(
-		"actionsearch", this, &MainMenu::ActionSearchTriggered, tr("/"));
+	help_action_search_item_ = help_menu_->add_item(
+		"actionsearch", this, &MainMenu::action_search_triggered, tr("/"));
 	help_menu_->addSeparator();
 	help_feedback_item_ =
-		help_menu_->AddItem("feedback", this, &MainMenu::HelpFeedbackTriggered);
+		help_menu_->add_item("feedback", this, &MainMenu::help_feedback_triggered);
 	help_menu_->addSeparator();
 	help_about_item_ =
-		help_menu_->AddItem("about", Core::instance(), &Core::DialogAboutShow);
+		help_menu_->add_item("about", Core::instance(), &Core::dialog_about_show);
 
-	connect(Core::instance(), &Core::OpenRecentListChanged, this,
-			&MainMenu::RepopulateOpenRecent);
-	PopulateOpenRecent();
+	connect(Core::instance(), &Core::open_recent_list_changed, this,
+			&MainMenu::repopulate_open_recent);
+	populate_open_recent();
 
-	Retranslate();
+	retranslate();
 }
 
 void MainMenu::changeEvent(QEvent *e)
 {
 	if (e->type() == QEvent::LanguageChange) {
-		Retranslate();
+		retranslate();
 	}
 	QMenuBar::changeEvent(e);
 }
 
-void MainMenu::ToolItemTriggered()
+void MainMenu::tool_item_triggered()
 {
 	// Assume the sender is a QAction
 	QAction *action = static_cast<QAction *>(sender());
@@ -419,12 +419,12 @@ void MainMenu::ToolItemTriggered()
 	Tool::Item tool = static_cast<Tool::Item>(action->data().toInt());
 
 	// Set the Tool in Core
-	Core::instance()->SetTool(tool);
+	Core::instance()->set_tool(tool);
 }
 
-void MainMenu::FileMenuAboutToShow()
+void MainMenu::file_menu_about_to_show()
 {
-	Project *active_project = Core::instance()->GetActiveProject();
+	Project *active_project = Core::instance()->get_active_project();
 
 	file_save_item_->setEnabled(active_project);
 	file_save_as_item_->setEnabled(active_project);
@@ -439,36 +439,36 @@ void MainMenu::FileMenuAboutToShow()
 	}
 }
 
-void MainMenu::EditMenuAboutToShow()
+void MainMenu::edit_menu_about_to_show()
 {
 	edit_delete2_item_->setVisible(false);
 }
 
-void MainMenu::EditMenuAboutToHide()
+void MainMenu::edit_menu_about_to_hide()
 {
 	edit_delete2_item_->setVisible(true);
 }
 
-void MainMenu::ViewMenuAboutToShow()
+void MainMenu::view_menu_about_to_show()
 {
 	// Parent is QMainWindow
 	view_full_screen_item_->setChecked(parentWidget()->isFullScreen());
 
 	// Make sure we're displaying the correct options for the timebase
 	TimeBasedPanel *p =
-		PanelManager::instance()->MostRecentlyFocused<TimeBasedPanel>();
+		PanelManager::instance()->most_recently_focused<TimeBasedPanel>();
 	if (p) {
 		if (p->timebase().denominator() != 0) {
 			view_menu_->addSeparator();
-			MenuShared::instance()->AddItemsForTimeRulerMenu(view_menu_);
+			MenuShared::instance()->add_items_for_time_ruler_menu(view_menu_);
 		}
 	}
 
 	// Ensure checked timecode display mode is correct
-	MenuShared::instance()->AboutToShowTimeRulerActions(p->timebase());
+	MenuShared::instance()->about_to_show_time_ruler_actions(p->timebase());
 }
 
-void MainMenu::ToolsMenuAboutToShow()
+void MainMenu::tools_menu_about_to_show()
 {
 	// Ensure checked Tool is correct
 	QList<QAction *> tool_actions = tools_group_->actions();
@@ -483,23 +483,23 @@ void MainMenu::ToolsMenuAboutToShow()
 	tools_snapping_item_->setChecked(Core::instance()->snapping());
 }
 
-void MainMenu::PlaybackMenuAboutToShow()
+void MainMenu::playback_menu_about_to_show()
 {
-	playback_loop_item_->setChecked(OLIVE_CONFIG("Loop").toBool());
+	playback_loop_item_->setChecked(OAK_CONFIG("Loop").toBool());
 }
 
-void MainMenu::SequenceMenuAboutToShow()
+void MainMenu::sequence_menu_about_to_show()
 {
 	TimeBasedPanel *p =
-		PanelManager::instance()->MostRecentlyFocused<TimeBasedPanel>();
+		PanelManager::instance()->most_recently_focused<TimeBasedPanel>();
 
-	bool can_cache_sequence = (p && p->GetConnectedViewer());
+	bool can_cache_sequence = (p && p->get_connected_viewer());
 
 	sequence_cache_item_->setEnabled(can_cache_sequence);
 	sequence_cache_in_to_out_item_->setEnabled(can_cache_sequence);
 }
 
-void MainMenu::WindowMenuAboutToShow()
+void MainMenu::window_menu_about_to_show()
 {
 	// Remove any previous items
 	while (window_menu_->actions().first() != window_menu_separator_) {
@@ -532,9 +532,9 @@ void MainMenu::WindowMenuAboutToShow()
 	window_menu_->insertActions(window_menu_separator_, panel_actions);
 }
 
-void MainMenu::PopulateOpenRecent()
+void MainMenu::populate_open_recent()
 {
-	if (Core::instance()->GetRecentProjects().isEmpty()) {
+	if (Core::instance()->get_recent_projects().isEmpty()) {
 		// Insert dummy/disabled action to show there's nothing
 		QAction *a = new QAction(tr("(None)"));
 		a->setEnabled(false);
@@ -542,25 +542,25 @@ void MainMenu::PopulateOpenRecent()
 
 	} else {
 		// Populate menu with recently opened projects
-		for (int i = 0; i < Core::instance()->GetRecentProjects().size(); i++) {
+		for (int i = 0; i < Core::instance()->get_recent_projects().size(); i++) {
 			QAction *a =
-				new QAction(Core::instance()->GetRecentProjects().at(i));
+				new QAction(Core::instance()->get_recent_projects().at(i));
 			a->setData(i);
 			connect(a, &QAction::triggered, this,
-					&MainMenu::OpenRecentItemTriggered);
+					&MainMenu::open_recent_item_triggered);
 			file_open_recent_menu_->insertAction(file_open_recent_separator_,
 												 a);
 		}
 	}
 }
 
-void MainMenu::RepopulateOpenRecent()
+void MainMenu::repopulate_open_recent()
 {
-	CloseOpenRecentMenu();
-	PopulateOpenRecent();
+	close_open_recent_menu();
+	populate_open_recent();
 }
 
-void MainMenu::CloseOpenRecentMenu()
+void MainMenu::close_open_recent_menu()
 {
 	while (file_open_recent_menu_->actions().first() !=
 		   file_open_recent_separator_) {
@@ -569,239 +569,239 @@ void MainMenu::CloseOpenRecentMenu()
 	}
 }
 
-void MainMenu::ZoomInTriggered()
+void MainMenu::zoom_in_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->ZoomIn();
+	PanelManager::instance()->currently_focused()->zoom_in();
 }
 
-void MainMenu::ZoomOutTriggered()
+void MainMenu::zoom_out_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->ZoomOut();
+	PanelManager::instance()->currently_focused()->zoom_out();
 }
 
-void MainMenu::IncreaseTrackHeightTriggered()
+void MainMenu::increase_track_height_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->IncreaseTrackHeight();
+	PanelManager::instance()->currently_focused()->increase_track_height();
 }
 
-void MainMenu::DecreaseTrackHeightTriggered()
+void MainMenu::decrease_track_height_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->DecreaseTrackHeight();
+	PanelManager::instance()->currently_focused()->decrease_track_height();
 }
 
-void MainMenu::GoToStartTriggered()
+void MainMenu::go_to_start_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->GoToStart();
+	PanelManager::instance()->currently_focused()->go_to_start();
 }
 
-void MainMenu::PrevFrameTriggered()
+void MainMenu::prev_frame_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->PrevFrame();
+	PanelManager::instance()->currently_focused()->prev_frame();
 }
 
-void MainMenu::PlayPauseTriggered()
+void MainMenu::play_pause_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->PlayPause();
+	PanelManager::instance()->currently_focused()->play_pause();
 }
 
-void MainMenu::PlayInToOutTriggered()
+void MainMenu::play_in_to_out_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->PlayInToOut();
+	PanelManager::instance()->currently_focused()->play_in_to_out();
 }
 
-void MainMenu::LoopTriggered(bool enabled)
+void MainMenu::loop_triggered(bool enabled)
 {
-	OLIVE_CONFIG("Loop") = enabled;
+	OAK_CONFIG("Loop") = enabled;
 }
 
-void MainMenu::NextFrameTriggered()
+void MainMenu::next_frame_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->NextFrame();
+	PanelManager::instance()->currently_focused()->next_frame();
 }
 
-void MainMenu::GoToEndTriggered()
+void MainMenu::go_to_end_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->GoToEnd();
+	PanelManager::instance()->currently_focused()->go_to_end();
 }
 
-void MainMenu::SelectAllTriggered()
+void MainMenu::select_all_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->SelectAll();
+	PanelManager::instance()->currently_focused()->select_all();
 }
 
-void MainMenu::DeselectAllTriggered()
+void MainMenu::deselect_all_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->DeselectAll();
+	PanelManager::instance()->currently_focused()->deselect_all();
 }
 
-void MainMenu::InsertTriggered()
+void MainMenu::insert_triggered()
 {
 	FootageManagementPanel *project_panel =
-		PanelManager::instance()->MostRecentlyFocused<FootageManagementPanel>();
+		PanelManager::instance()->most_recently_focused<FootageManagementPanel>();
 	TimelinePanel *timeline_panel =
-		PanelManager::instance()->MostRecentlyFocused<TimelinePanel>();
+		PanelManager::instance()->most_recently_focused<TimelinePanel>();
 
 	if (project_panel && timeline_panel) {
-		timeline_panel->InsertFootageAtPlayhead(
-			project_panel->GetSelectedFootage());
+		timeline_panel->insert_footage_at_playhead(
+			project_panel->get_selected_footage());
 	}
 }
 
-void MainMenu::OverwriteTriggered()
+void MainMenu::overwrite_triggered()
 {
 	FootageManagementPanel *project_panel =
-		PanelManager::instance()->MostRecentlyFocused<FootageManagementPanel>();
+		PanelManager::instance()->most_recently_focused<FootageManagementPanel>();
 	TimelinePanel *timeline_panel =
-		PanelManager::instance()->MostRecentlyFocused<TimelinePanel>();
+		PanelManager::instance()->most_recently_focused<TimelinePanel>();
 
 	if (project_panel && timeline_panel) {
-		timeline_panel->OverwriteFootageAtPlayhead(
-			project_panel->GetSelectedFootage());
+		timeline_panel->overwrite_footage_at_playhead(
+			project_panel->get_selected_footage());
 	}
 }
 
-void MainMenu::RippleToInTriggered()
+void MainMenu::ripple_to_in_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->RippleToIn();
+	PanelManager::instance()->currently_focused()->ripple_to_in();
 }
 
-void MainMenu::RippleToOutTriggered()
+void MainMenu::ripple_to_out_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->RippleToOut();
+	PanelManager::instance()->currently_focused()->ripple_to_out();
 }
 
-void MainMenu::EditToInTriggered()
+void MainMenu::edit_to_in_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->EditToIn();
+	PanelManager::instance()->currently_focused()->edit_to_in();
 }
 
-void MainMenu::EditToOutTriggered()
+void MainMenu::edit_to_out_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->EditToOut();
+	PanelManager::instance()->currently_focused()->edit_to_out();
 }
 
-void MainMenu::NudgeLeftTriggered()
+void MainMenu::nudge_left_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->NudgeLeft();
+	PanelManager::instance()->currently_focused()->nudge_left();
 }
 
-void MainMenu::NudgeRightTriggered()
+void MainMenu::nudge_right_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->NudgeRight();
+	PanelManager::instance()->currently_focused()->nudge_right();
 }
 
-void MainMenu::MoveInToPlayheadTriggered()
+void MainMenu::move_in_to_playhead_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->MoveInToPlayhead();
+	PanelManager::instance()->currently_focused()->move_in_to_playhead();
 }
 
-void MainMenu::MoveOutToPlayheadTriggered()
+void MainMenu::move_out_to_playhead_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->MoveOutToPlayhead();
+	PanelManager::instance()->currently_focused()->move_out_to_playhead();
 }
 
-void MainMenu::ActionSearchTriggered()
+void MainMenu::action_search_triggered()
 {
 	ActionSearch as(parentWidget());
-	as.SetMenuBar(this);
+	as.set_menu_bar(this);
 	as.exec();
 }
 
-void MainMenu::ShuttleLeftTriggered()
+void MainMenu::shuttle_left_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->ShuttleLeft();
+	PanelManager::instance()->currently_focused()->shuttle_left();
 }
 
-void MainMenu::ShuttleStopTriggered()
+void MainMenu::shuttle_stop_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->ShuttleStop();
+	PanelManager::instance()->currently_focused()->shuttle_stop();
 }
 
-void MainMenu::ShuttleRightTriggered()
+void MainMenu::shuttle_right_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->ShuttleRight();
+	PanelManager::instance()->currently_focused()->shuttle_right();
 }
 
-void MainMenu::GoToPrevCutTriggered()
+void MainMenu::go_to_prev_cut_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->GoToPrevCut();
+	PanelManager::instance()->currently_focused()->go_to_prev_cut();
 }
 
-void MainMenu::GoToNextCutTriggered()
+void MainMenu::go_to_next_cut_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->GoToNextCut();
+	PanelManager::instance()->currently_focused()->go_to_next_cut();
 }
 
-void MainMenu::SetMarkerTriggered()
+void MainMenu::set_marker_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->SetMarker();
+	PanelManager::instance()->currently_focused()->set_marker();
 }
 
-void MainMenu::FullScreenViewerTriggered()
+void MainMenu::full_screen_viewer_triggered()
 {
 	PanelManager::instance()
-		->MostRecentlyFocused<ViewerPanel>()
-		->SetFullScreen();
+		->most_recently_focused<ViewerPanel>()
+		->set_full_screen();
 }
 
-void MainMenu::ToggleShowAllTriggered()
+void MainMenu::toggle_show_all_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->ToggleShowAll();
+	PanelManager::instance()->currently_focused()->toggle_show_all();
 }
 
-void MainMenu::DeleteInOutTriggered()
+void MainMenu::delete_in_out_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->DeleteInToOut();
+	PanelManager::instance()->currently_focused()->delete_in_to_out();
 }
 
-void MainMenu::RippleDeleteInOutTriggered()
+void MainMenu::ripple_delete_in_out_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->RippleDeleteInToOut();
+	PanelManager::instance()->currently_focused()->ripple_delete_in_to_out();
 }
 
-void MainMenu::GoToInTriggered()
+void MainMenu::go_to_in_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->GoToIn();
+	PanelManager::instance()->currently_focused()->go_to_in();
 }
 
-void MainMenu::GoToOutTriggered()
+void MainMenu::go_to_out_triggered()
 {
-	PanelManager::instance()->CurrentlyFocused()->GoToOut();
+	PanelManager::instance()->currently_focused()->go_to_out();
 }
 
-void MainMenu::OpenRecentItemTriggered()
+void MainMenu::open_recent_item_triggered()
 {
-	Core::instance()->OpenProjectFromRecentList(
+	Core::instance()->open_project_from_recent_list(
 		static_cast<QAction *>(sender())->data().toInt());
 }
 
-void MainMenu::SequenceCacheTriggered()
+void MainMenu::sequence_cache_triggered()
 {
-	Core::instance()->CacheActiveSequence(false);
+	Core::instance()->cache_active_sequence(false);
 }
 
-void MainMenu::SequenceCacheInOutTriggered()
+void MainMenu::sequence_cache_in_out_triggered()
 {
-	Core::instance()->CacheActiveSequence(true);
+	Core::instance()->cache_active_sequence(true);
 }
 
-void MainMenu::SequenceCacheClearTriggered()
+void MainMenu::sequence_cache_clear_triggered()
 {
-	DiskCacheDialog::ClearDiskCache(
-		Core::instance()->GetActiveProject()->cache_path(),
+	DiskCacheDialog::clear_disk_cache(
+		Core::instance()->get_active_project()->cache_path(),
 		Core::instance()->main_window());
 }
 
-void MainMenu::HelpFeedbackTriggered()
+void MainMenu::help_feedback_triggered()
 {
 	QDesktopServices::openUrl(QStringLiteral(
 		"https://github.com/OakVideoEditorCommunity/oak/issues"));
 }
 
-void MainMenu::Retranslate()
+void MainMenu::retranslate()
 {
 	// MenuShared is not a QWidget and therefore does not receive a LanguageEvent, we use MainMenu's to update it
-	MenuShared::instance()->Retranslate();
+	MenuShared::instance()->retranslate();
 
 	// File menu
 	file_menu_->setTitle(tr("&File"));
@@ -818,7 +818,7 @@ void MainMenu::Retranslate()
 
 	// Edit menu
 	edit_menu_->setTitle(tr("&Edit"));
-	Core::instance()->undo_stack()->UpdateActions(); // Update undo and redo
+	Core::instance()->undo_stack()->update_actions(); // Update undo and redo
 	edit_delete2_item_->setText(tr("Delete (alt)"));
 	edit_insert_item_->setText(tr("Insert"));
 	edit_overwrite_item_->setText(tr("Overwrite"));

app/window/mainwindow/mainmenu.h

@@ -19,8 +19,8 @@
 
 ***/
 
-#ifndef MAINMENU_H
-#define MAINMENU_H
+#ifndef OAK_MAINMENU_H
+#define OAK_MAINMENU_H
 
 #include <QMainWindow>
 #include <QMenuBar>
@@ -60,140 +60,140 @@ private slots:
    * Assumes a QAction* sender() and its data() is a member of enum Tool::Item. Uses the data() to signal a
    * Tool change throughout the rest of the application.
    */
-	void ToolItemTriggered();
+	void tool_item_triggered();
 
 	/**
    * @brief Slot triggered just before the File menu shows
    */
-	void FileMenuAboutToShow();
+	void file_menu_about_to_show();
 
 	/**
    * @brief Slot triggered just before the Edit menu shows
    */
-	void EditMenuAboutToShow();
-	void EditMenuAboutToHide();
+	void edit_menu_about_to_show();
+	void edit_menu_about_to_hide();
 
 	/**
    * @brief Slot triggered just before the View menu shows
    */
-	void ViewMenuAboutToShow();
+	void view_menu_about_to_show();
 
 	/**
    * @brief Slot triggered just before the Tools menu shows
    */
-	void ToolsMenuAboutToShow();
+	void tools_menu_about_to_show();
 
 	/**
    * @brief Slot triggered just before the Playback menu shows
    */
-	void PlaybackMenuAboutToShow();
+	void playback_menu_about_to_show();
 
 	/**
    * @brief Slot triggered just before the Sequence menu shows
    */
-	void SequenceMenuAboutToShow();
+	void sequence_menu_about_to_show();
 
 	/**
    * @brief Slot triggered just before the Window menu shows
    */
-	void WindowMenuAboutToShow();
+	void window_menu_about_to_show();
 
 	/**
    * @brief Adds items to open recent menu
    */
-	void PopulateOpenRecent();
+	void populate_open_recent();
 
-	void RepopulateOpenRecent();
+	void repopulate_open_recent();
 
 	/**
    * @brief Clears open recent items when menu closes
    */
-	void CloseOpenRecentMenu();
+	void close_open_recent_menu();
 
 	/**
    * @brief Slot for zooming in
    *
    * Finds the currently focused panel and sends it a "zoom in" signal
    */
-	void ZoomInTriggered();
+	void zoom_in_triggered();
 
 	/**
    * @brief Slot for zooming out
    *
    * Finds the currently focused panel and sends it a "zoom out" signal
    */
-	void ZoomOutTriggered();
+	void zoom_out_triggered();
 
-	void IncreaseTrackHeightTriggered();
-	void DecreaseTrackHeightTriggered();
+	void increase_track_height_triggered();
+	void decrease_track_height_triggered();
 
-	void GoToStartTriggered();
-	void PrevFrameTriggered();
+	void go_to_start_triggered();
+	void prev_frame_triggered();
 
 	/**
    * @brief Slot for play/pause
    *
    * Finds the currently focused panel and sends it a "play/pause" signal
    */
-	void PlayPauseTriggered();
+	void play_pause_triggered();
 
-	void PlayInToOutTriggered();
+	void play_in_to_out_triggered();
 
-	void LoopTriggered(bool enabled);
+	void loop_triggered(bool enabled);
 
-	void NextFrameTriggered();
-	void GoToEndTriggered();
+	void next_frame_triggered();
+	void go_to_end_triggered();
 
-	void SelectAllTriggered();
-	void DeselectAllTriggered();
+	void select_all_triggered();
+	void deselect_all_triggered();
 
-	void InsertTriggered();
-	void OverwriteTriggered();
+	void insert_triggered();
+	void overwrite_triggered();
 
-	void RippleToInTriggered();
-	void RippleToOutTriggered();
-	void EditToInTriggered();
-	void EditToOutTriggered();
+	void ripple_to_in_triggered();
+	void ripple_to_out_triggered();
+	void edit_to_in_triggered();
+	void edit_to_out_triggered();
 
-	void NudgeLeftTriggered();
-	void NudgeRightTriggered();
-	void MoveInToPlayheadTriggered();
-	void MoveOutToPlayheadTriggered();
+	void nudge_left_triggered();
+	void nudge_right_triggered();
+	void move_in_to_playhead_triggered();
+	void move_out_to_playhead_triggered();
 
-	void ActionSearchTriggered();
+	void action_search_triggered();
 
-	void ShuttleLeftTriggered();
-	void ShuttleStopTriggered();
-	void ShuttleRightTriggered();
+	void shuttle_left_triggered();
+	void shuttle_stop_triggered();
+	void shuttle_right_triggered();
 
-	void GoToPrevCutTriggered();
-	void GoToNextCutTriggered();
+	void go_to_prev_cut_triggered();
+	void go_to_next_cut_triggered();
 
-	void SetMarkerTriggered();
+	void set_marker_triggered();
 
-	void FullScreenViewerTriggered();
+	void full_screen_viewer_triggered();
 
-	void ToggleShowAllTriggered();
+	void toggle_show_all_triggered();
 
-	void DeleteInOutTriggered();
-	void RippleDeleteInOutTriggered();
+	void delete_in_out_triggered();
+	void ripple_delete_in_out_triggered();
 
-	void GoToInTriggered();
-	void GoToOutTriggered();
+	void go_to_in_triggered();
+	void go_to_out_triggered();
 
-	void OpenRecentItemTriggered();
+	void open_recent_item_triggered();
 
-	void SequenceCacheTriggered();
-	void SequenceCacheInOutTriggered();
-	void SequenceCacheClearTriggered();
+	void sequence_cache_triggered();
+	void sequence_cache_in_out_triggered();
+	void sequence_cache_clear_triggered();
 
-	void HelpFeedbackTriggered();
+	void help_feedback_triggered();
 
 private:
 	/**
    * @brief Set strings based on the current application language.
    */
-	void Retranslate();
+	void retranslate();
 
 	Menu *file_menu_;
 	Menu *file_new_menu_;
@@ -297,4 +297,4 @@ private:
 
 }
 
-#endif // MAINMENU_H
+#endif // OAK_MAINMENU_H

app/window/mainwindow/mainstatusbar.cpp

@@ -46,64 +46,64 @@ MainStatusBar::MainStatusBar(QWidget *parent)
 				10000);
 }
 
-void MainStatusBar::ConnectTaskManager(TaskManager *manager)
+void MainStatusBar::connect_task_manager(TaskManager *manager)
 {
 	if (manager_) {
-		disconnect(manager_, &TaskManager::TaskListChanged, this,
-				   &MainStatusBar::UpdateStatus);
+		disconnect(manager_, &TaskManager::task_list_changed, this,
+				   &MainStatusBar::update_status);
 	}
 
 	manager_ = manager;
 
 	if (manager_) {
-		connect(manager_, &TaskManager::TaskListChanged, this,
-				&MainStatusBar::UpdateStatus);
+		connect(manager_, &TaskManager::task_list_changed, this,
+				&MainStatusBar::update_status);
 	}
 }
 
-void MainStatusBar::UpdateStatus()
+void MainStatusBar::update_status()
 {
 	if (!manager_) {
 		return;
 	}
 
-	if (manager_->GetTaskCount() == 0) {
+	if (manager_->get_task_count() == 0) {
 		clearMessage();
 		bar_->setVisible(false);
 		bar_->setValue(0);
 	} else {
-		Task *t = manager_->GetFirstTask();
+		Task *t = manager_->get_first_task();
 
-		if (manager_->GetTaskCount() == 1) {
-			showMessage(t->GetTitle());
+		if (manager_->get_task_count() == 1) {
+			showMessage(t->get_title());
 		} else {
 			showMessage(tr("Running %n background task(s)", nullptr,
-						   manager_->GetTaskCount()));
+						   manager_->get_task_count()));
 		}
 
 		bar_->setVisible(true);
 
 		if (connected_task_) {
-			disconnect(connected_task_, &Task::ProgressChanged, this,
-					   &MainStatusBar::SetProgressBarValue);
+			disconnect(connected_task_, &Task::progress_changed, this,
+					   &MainStatusBar::set_progress_bar_value);
 			disconnect(connected_task_, &Task::destroyed, this,
-					   &MainStatusBar::ConnectedTaskDeleted);
+					   &MainStatusBar::connected_task_deleted);
 		}
 
 		connected_task_ = t;
-		connect(connected_task_, &Task::ProgressChanged, this,
-				&MainStatusBar::SetProgressBarValue);
+		connect(connected_task_, &Task::progress_changed, this,
+				&MainStatusBar::set_progress_bar_value);
 		connect(connected_task_, &Task::destroyed, this,
-				&MainStatusBar::ConnectedTaskDeleted);
+				&MainStatusBar::connected_task_deleted);
 	}
 }
 
-void MainStatusBar::SetProgressBarValue(double d)
+void MainStatusBar::set_progress_bar_value(double d)
 {
 	bar_->setValue(qRound(100.0 * d));
 }
 
-void MainStatusBar::ConnectedTaskDeleted()
+void MainStatusBar::connected_task_deleted()
 {
 	connected_task_ = nullptr;
 }
@@ -112,7 +112,7 @@ void MainStatusBar::mouseDoubleClickEvent(QMouseEvent *e)
 {
 	QStatusBar::mouseDoubleClickEvent(e);
 
-	emit DoubleClicked();
+	emit double_clicked();
 }
 
 }

app/window/mainwindow/mainstatusbar.h

@@ -19,8 +19,8 @@
 
 ***/
 
-#ifndef MAINSTATUSBAR_H
-#define MAINSTATUSBAR_H
+#ifndef OAK_MAINSTATUSBAR_H
+#define OAK_MAINSTATUSBAR_H
 
 #include <QProgressBar>
 #include <QStatusBar>
@@ -38,20 +38,20 @@ class MainStatusBar : public QStatusBar {
 public:
 	MainStatusBar(QWidget *parent = nullptr);
 
-	void ConnectTaskManager(TaskManager *manager);
+	void connect_task_manager(TaskManager *manager);
 
 signals:
-	void DoubleClicked();
+	void double_clicked();
 
 protected:
 	virtual void mouseDoubleClickEvent(QMouseEvent *e) override;
 
 private slots:
-	void UpdateStatus();
+	void update_status();
 
-	void SetProgressBarValue(double d);
+	void set_progress_bar_value(double d);
 
-	void ConnectedTaskDeleted();
+	void connected_task_deleted();
 
 private:
 	TaskManager *manager_;
@@ -63,4 +63,4 @@ private:
 
 }
 
-#endif // MAINSTATUSBAR_H
+#endif // OAK_MAINSTATUSBAR_H

app/window/mainwindow/mainwindow.cpp

@@ -68,13 +68,13 @@ MainWindow::MainWindow(QWidget *parent)
 	MainMenu *main_menu = new MainMenu(this);
 	setMenuBar(main_menu);
 
-	LoadCustomShortcuts();
+	load_custom_shortcuts();
 
 	// Create and set status bar
 	MainStatusBar *status_bar = new MainStatusBar(this);
-	status_bar->ConnectTaskManager(TaskManager::instance());
-	connect(status_bar, &MainStatusBar::DoubleClicked, this,
-			&MainWindow::StatusBarDoubleClicked);
+	status_bar->connect_task_manager(TaskManager::instance());
+	connect(status_bar, &MainStatusBar::double_clicked, this,
+			&MainWindow::status_bar_double_clicked);
 	setStatusBar(status_bar);
 
 	// Create standard panels
@@ -88,7 +88,7 @@ MainWindow::MainWindow(QWidget *parent)
 	project_panel_ = new ProjectPanel(QStringLiteral("ProjectPanel"));
 	tool_panel_ = new ToolPanel();
 	task_man_panel_ = new TaskManagerPanel();
-	AppendTimelinePanel();
+	append_timeline_panel();
 	audio_monitor_panel_ = new AudioMonitorPanel();
 	scope_panel_ = new ScopePanel();
 	history_panel_ = new HistoryPanel();
@@ -101,44 +101,44 @@ MainWindow::MainWindow(QWidget *parent)
 	emit pixel_sampler_panel_->shown(Qt::OtherFocusReason);
 
 	// Make node-related connections
-	connect(node_panel_, &NodePanel::NodeSelectionChangedWithContexts,
-			param_panel_, &ParamPanel::SetSelectedNodes);
-	connect(node_panel_, &NodePanel::NodeGroupOpened, this,
-			&MainWindow::NodePanelGroupOpenedOrClosed);
-	connect(node_panel_, &NodePanel::NodeGroupClosed, this,
-			&MainWindow::NodePanelGroupOpenedOrClosed);
-	connect(param_panel_, &ParamPanel::FocusedNodeChanged,
-			sequence_viewer_panel_, &ViewerPanel::SetGizmos);
-	connect(param_panel_, &ParamPanel::RequestViewerToStartEditingText,
-			sequence_viewer_panel_, &ViewerPanel::RequestStartEditingText);
-	connect(param_panel_, &ParamPanel::FocusedNodeChanged, curve_panel_,
-			&CurvePanel::SetNode);
-	connect(param_panel_, &ParamPanel::SelectedNodesChanged, node_panel_,
-			&NodePanel::Select);
-	connect(project_panel_, &ProjectPanel::ProjectNameChanged, this,
-			&MainWindow::UpdateTitle);
+	connect(node_panel_, &NodePanel::node_selection_changed_with_contexts,
+			param_panel_, &ParamPanel::set_selected_nodes);
+	connect(node_panel_, &NodePanel::node_group_opened, this,
+			&MainWindow::node_panel_group_opened_or_closed);
+	connect(node_panel_, &NodePanel::node_group_closed, this,
+			&MainWindow::node_panel_group_opened_or_closed);
+	connect(param_panel_, &ParamPanel::focused_node_changed,
+			sequence_viewer_panel_, &ViewerPanel::set_gizmos);
+	connect(param_panel_, &ParamPanel::request_viewer_to_start_editing_text,
+			sequence_viewer_panel_, &ViewerPanel::request_start_editing_text);
+	connect(param_panel_, &ParamPanel::focused_node_changed, curve_panel_,
+			&CurvePanel::set_node);
+	connect(param_panel_, &ParamPanel::selected_nodes_changed, node_panel_,
+			&NodePanel::select);
+	connect(project_panel_, &ProjectPanel::project_name_changed, this,
+			&MainWindow::update_title);
 
-	connect(node_panel_, &NodePanel::NodeSelectionChanged,
-			sequence_viewer_panel_, &ViewerPanel::SetNodeViewSelections);
+	connect(node_panel_, &NodePanel::node_selection_changed,
+			sequence_viewer_panel_, &ViewerPanel::set_node_view_selections);
 
 	// Route play/pause/shuttle commands from these panels to the sequence viewer
-	sequence_viewer_panel_->ConnectTimeBasedPanel(param_panel_);
-	sequence_viewer_panel_->ConnectTimeBasedPanel(curve_panel_);
-	sequence_viewer_panel_->ConnectTimeBasedPanel(multicam_panel_);
+	sequence_viewer_panel_->connect_time_based_panel(param_panel_);
+	sequence_viewer_panel_->connect_time_based_panel(curve_panel_);
+	sequence_viewer_panel_->connect_time_based_panel(multicam_panel_);
 
-	connect(PanelManager::instance(), &PanelManager::FocusedPanelChanged, this,
-			&MainWindow::FocusedPanelChanged);
+	connect(PanelManager::instance(), &PanelManager::focused_panel_changed, this,
+			&MainWindow::focused_panel_changed);
 
-	sequence_viewer_panel_->AddPlaybackDevice(
-		multicam_panel_->GetMulticamWidget()->GetDisplayWidget());
-	sequence_viewer_panel_->ConnectMulticamWidget(
-		multicam_panel_->GetMulticamWidget());
+	sequence_viewer_panel_->add_playback_device(
+		multicam_panel_->get_multicam_widget()->get_display_widget());
+	sequence_viewer_panel_->connect_multicam_widget(
+		multicam_panel_->get_multicam_widget());
 
-	scope_panel_->SetViewerPanel(sequence_viewer_panel_);
+	scope_panel_->set_viewer_panel(sequence_viewer_panel_);
 
-	UpdateTitle();
+	update_title();
 
-	QMetaObject::invokeMethod(this, &MainWindow::SetDefaultLayout,
+	QMetaObject::invokeMethod(this, &MainWindow::set_default_layout,
 							  Qt::QueuedConnection);
 }
 
@@ -151,49 +151,49 @@ MainWindow::~MainWindow()
 #endif
 }
 
-void MainWindow::LoadLayout(const MainWindowLayoutInfo &info)
+void MainWindow::load_layout(const MainWindowLayoutInfo &info)
 {
 	foreach (Folder *folder, info.open_folders()) {
-		OpenFolder(folder, true);
+		open_folder(folder, true);
 	}
 
 	foreach (Sequence *sequence, info.open_sequences()) {
-		OpenSequence(sequence, info.open_sequences().size() == 1);
+		open_sequence(sequence, info.open_sequences().size() == 1);
 	}
 
 	foreach (ViewerOutput *viewer, info.open_viewers()) {
-		OpenNodeInViewer(viewer);
+		open_node_in_viewer(viewer);
 	}
 
 	for (auto it = info.panel_data().cbegin(); it != info.panel_data().cend();
 		 it++) {
 		// Find panel with this ID
 		if (PanelWidget *panel =
-				PanelManager::instance()->GetPanelWithName(it->first)) {
-			panel->LoadData(it->second);
+				PanelManager::instance()->get_panel_with_name(it->first)) {
+			panel->load_data(it->second);
 		}
 	}
 
 	KDDockWidgets::LayoutSaver().restoreLayout(qUncompress(info.state()));
 }
 
-QString TransformNameForSerialization(const QString &unique, int i)
+QString transform_name_for_serialization(const QString &unique, int i)
 {
 	return QStringLiteral("%1:%2").arg(unique.split(':').at(0),
 									   QString::number(i));
 }
 
-void CorrectPanelDataIfNecessary(const QString &unique_name, int index,
+void correct_panel_data_if_necessary(const QString &unique_name, int index,
 								 MainWindowLayoutInfo &info, QByteArray &layout)
 {
-	QString corrected = TransformNameForSerialization(unique_name, index);
+	QString corrected = transform_name_for_serialization(unique_name, index);
 	if (corrected != unique_name) {
 		info.move_panel_data(unique_name, corrected);
 		layout.replace(unique_name.toUtf8(), corrected.toUtf8());
 	}
 }
 
-MainWindowLayoutInfo MainWindow::SaveLayout() const
+MainWindowLayoutInfo MainWindow::save_layout() const
 {
 	MainWindowLayoutInfo info;
 
@@ -202,25 +202,25 @@ MainWindowLayoutInfo MainWindow::SaveLayout() const
 							premaximized_state_;
 
 	foreach (PanelWidget *panel, PanelManager::instance()->panels()) {
-		info.set_panel_data(panel->uniqueName(), panel->SaveData());
+		info.set_panel_data(panel->uniqueName(), panel->save_data());
 	}
 
 	for (int i = 0; i < folder_panels_.size(); i++) {
 		auto panel = folder_panels_.at(i);
 		info.add_folder(panel->get_root());
-		CorrectPanelDataIfNecessary(panel->uniqueName(), i, info, layout);
+		correct_panel_data_if_necessary(panel->uniqueName(), i, info, layout);
 	}
 
 	for (int i = 0; i < timeline_panels_.size(); i++) {
 		auto panel = timeline_panels_.at(i);
-		info.add_sequence(panel->GetSequence());
-		CorrectPanelDataIfNecessary(panel->uniqueName(), i, info, layout);
+		info.add_sequence(panel->get_sequence());
+		correct_panel_data_if_necessary(panel->uniqueName(), i, info, layout);
 	}
 
 	for (int i = 0; i < viewer_panels_.size(); i++) {
 		auto panel = viewer_panels_.at(i);
-		info.add_viewer(panel->GetConnectedViewer());
-		CorrectPanelDataIfNecessary(panel->uniqueName(), i, info, layout);
+		info.add_viewer(panel->get_connected_viewer());
+		correct_panel_data_if_necessary(panel->uniqueName(), i, info, layout);
 	}
 
 	info.set_state(qCompress(layout));
@@ -228,11 +228,11 @@ MainWindowLayoutInfo MainWindow::SaveLayout() const
 	return info;
 }
 
-TimelinePanel *MainWindow::OpenSequence(Sequence *sequence, bool enable_focus)
+TimelinePanel *MainWindow::open_sequence(Sequence *sequence, bool enable_focus)
 {
 	// See if this sequence is already open, and switch to it if so
 	foreach (TimelinePanel *tl, timeline_panels_) {
-		if (tl->GetConnectedViewer() == sequence) {
+		if (tl->get_connected_viewer() == sequence) {
 			tl->raise();
 			return tl;
 		}
@@ -241,40 +241,40 @@ TimelinePanel *MainWindow::OpenSequence(Sequence *sequence, bool enable_focus)
 	// See if we have any sequences open or not
 	TimelinePanel *panel;
 
-	if (!timeline_panels_.first()->GetConnectedViewer()) {
+	if (!timeline_panels_.first()->get_connected_viewer()) {
 		panel = timeline_panels_.first();
 	} else {
-		panel = AppendTimelinePanel();
+		panel = append_timeline_panel();
 		//enable_focus = false;
 	}
 
-	panel->ConnectViewerNode(sequence);
+	panel->connect_viewer_node(sequence);
 
 	if (enable_focus) {
-		TimelineFocused(sequence);
-		UpdateAudioMonitorParams(sequence);
+		timeline_focused(sequence);
+		update_audio_monitor_params(sequence);
 	}
 
 	return panel;
 }
 
-void MainWindow::CloseSequence(Sequence *sequence)
+void MainWindow::close_sequence(Sequence *sequence)
 {
 	// We defer to RemoveTimelinePanel() to close the panels, which may delete and remove indices from timeline_panels_.
 	// We make a copy so that our array here doesn't get ruined by what RemoveTimelinePanel() does
 	QList<TimelinePanel *> copy = timeline_panels_;
 
 	foreach (TimelinePanel *tp, copy) {
-		if (tp->GetConnectedViewer() == sequence) {
-			RemoveTimelinePanel(tp);
+		if (tp->get_connected_viewer() == sequence) {
+			remove_timeline_panel(tp);
 		}
 	}
 }
 
-bool MainWindow::IsSequenceOpen(Sequence *sequence) const
+bool MainWindow::is_sequence_open(Sequence *sequence) const
 {
 	foreach (TimelinePanel *tp, timeline_panels_) {
-		if (tp->GetConnectedViewer() == sequence) {
+		if (tp->get_connected_viewer() == sequence) {
 			return true;
 		}
 	}
@@ -282,10 +282,10 @@ bool MainWindow::IsSequenceOpen(Sequence *sequence) const
 	return false;
 }
 
-void MainWindow::OpenFolder(Folder *i, bool floating)
+void MainWindow::open_folder(Folder *i, bool floating)
 {
 	ProjectPanel *panel =
-		AppendPanelInternal(QStringLiteral("FolderPanel"), folder_panels_);
+		append_panel_internal(QStringLiteral("FolderPanel"), folder_panels_);
 
 	panel->set_project(i->project());
 	panel->set_root(i);
@@ -297,17 +297,17 @@ void MainWindow::OpenFolder(Folder *i, bool floating)
 	}
 
 	// If the panel is closed, just destroy it
-	connect(panel, &ProjectPanel::CloseRequested, this,
-			&MainWindow::FolderPanelCloseRequested);
+	connect(panel, &ProjectPanel::close_requested, this,
+			&MainWindow::folder_panel_close_requested);
 }
 
-void MainWindow::OpenNodeInViewer(ViewerOutput *node)
+void MainWindow::open_node_in_viewer(ViewerOutput *node)
 {
 	ViewerPanel *existing = nullptr;
 
 	for (auto it = viewer_panels_.cbegin(); it != viewer_panels_.cend(); it++) {
 		ViewerPanel *it2 = (*it);
-		if (it2->GetConnectedViewer() == node) {
+		if (it2->get_connected_viewer() == node) {
 			existing = it2;
 			break;
 		}
@@ -319,18 +319,18 @@ void MainWindow::OpenNodeInViewer(ViewerOutput *node)
 	} else {
 		// Create a viewer for this node
 		ViewerPanel *viewer =
-			AppendPanelInternal(QStringLiteral("ViewerPanel"), viewer_panels_);
+			append_panel_internal(QStringLiteral("ViewerPanel"), viewer_panels_);
 
-		viewer->ConnectViewerNode(node);
+		viewer->connect_viewer_node(node);
 
-		connect(viewer, &ViewerPanel::CloseRequested, this,
-				&MainWindow::ViewerCloseRequested);
-		connect(node, &ViewerOutput::RemovedFromGraph, this,
-				&MainWindow::ViewerWithPanelRemovedFromGraph);
+		connect(viewer, &ViewerPanel::close_requested, this,
+				&MainWindow::viewer_close_requested);
+		connect(node, &ViewerOutput::removed_from_graph, this,
+				&MainWindow::viewer_with_panel_removed_from_graph);
 	}
 }
 
-void MainWindow::SetFullscreen(bool fullscreen)
+void MainWindow::set_fullscreen(bool fullscreen)
 {
 	if (fullscreen) {
 		setWindowState(windowState() | Qt::WindowFullScreen);
@@ -339,7 +339,7 @@ void MainWindow::SetFullscreen(bool fullscreen)
 	}
 }
 
-void MainWindow::ToggleMaximizedPanel()
+void MainWindow::toggle_maximized_panel()
 {
 	KDDockWidgets::LayoutSaver saver;
 
@@ -348,11 +348,11 @@ void MainWindow::ToggleMaximizedPanel()
 
 		// Find the currently focused panel
 		PanelWidget *currently_hovered =
-			PanelManager::instance()->CurrentlyHovered();
+			PanelManager::instance()->currently_hovered();
 
 		// If no panel is hovered, fallback to the currently active panel
 		if (!currently_hovered) {
-			currently_hovered = PanelManager::instance()->CurrentlyFocused();
+			currently_hovered = PanelManager::instance()->currently_focused();
 
 			// If no panel is hovered or focused, do nothing
 			if (!currently_hovered) {
@@ -377,21 +377,21 @@ void MainWindow::ToggleMaximizedPanel()
 	} else {
 		// Preserve currently focused panel
 		auto currently_focused_panel =
-			PanelManager::instance()->CurrentlyFocused(false);
+			PanelManager::instance()->currently_focused(false);
 
 		// Assume we are currently maximized, restore the state
-		PanelManager::instance()->SetSuppressChangedSignal(true);
+		PanelManager::instance()->set_suppress_changed_signal(true);
 		saver.restoreLayout(premaximized_state_);
 		premaximized_state_.clear();
 
 		currently_focused_panel->raise();
 		currently_focused_panel->setFocus(Qt::ActiveWindowFocusReason);
 
-		PanelManager::instance()->SetSuppressChangedSignal(false);
+		PanelManager::instance()->set_suppress_changed_signal(false);
 	}
 }
 
-void MainWindow::SetProject(Project *p)
+void MainWindow::set_project(Project *p)
 {
 	if (project_ == p) {
 		return;
@@ -399,21 +399,21 @@ void MainWindow::SetProject(Project *p)
 
 	if (project_) {
 		// Clear all data
-		param_panel_->SetContexts(QVector<Node *>());
-		node_panel_->SetContexts(QVector<Node *>());
+		param_panel_->set_contexts(QVector<Node *>());
+		node_panel_->set_contexts(QVector<Node *>());
 
 		// Close any nodes open in TimeBasedWidgets
 		foreach (PanelWidget *panel, PanelManager::instance()->panels()) {
 			TimeBasedPanel *tbp = dynamic_cast<TimeBasedPanel *>(panel);
 
-			if (tbp && tbp->GetConnectedViewer() &&
-				tbp->GetConnectedViewer()->project() == project_) {
+			if (tbp && tbp->get_connected_viewer() &&
+				tbp->get_connected_viewer()->project() == project_) {
 				if (dynamic_cast<TimelinePanel *>(tbp)) {
 					// Prefer our CloseSequence function which will delete any unnecessary timeline panels
-					CloseSequence(
-						static_cast<Sequence *>(tbp->GetConnectedViewer()));
+					close_sequence(
+						static_cast<Sequence *>(tbp->get_connected_viewer()));
 				} else {
-					tbp->DisconnectViewerNode();
+					tbp->disconnect_viewer_node();
 				}
 			}
 		}
@@ -437,7 +437,7 @@ void MainWindow::SetProject(Project *p)
 	}
 }
 
-void MainWindow::SetApplicationProgressStatus(ProgressStatus status)
+void MainWindow::set_application_progress_status(ProgressStatus status)
 {
 #if defined(Q_OS_WINDOWS)
 	if (taskbar_interface_) {
@@ -461,7 +461,7 @@ void MainWindow::SetApplicationProgressStatus(ProgressStatus status)
 #endif
 }
 
-void MainWindow::SetApplicationProgressValue(int value)
+void MainWindow::set_application_progress_value(int value)
 {
 #if defined(Q_OS_WINDOWS)
 	if (taskbar_interface_) {
@@ -472,27 +472,27 @@ void MainWindow::SetApplicationProgressValue(int value)
 #endif
 }
 
-void MainWindow::SelectFootage(const QVector<Footage *> &e)
+void MainWindow::select_footage(const QVector<Footage *> &e)
 {
-	SelectFootageForProjectPanel(e, project_panel_);
+	select_footage_for_project_panel(e, project_panel_);
 	for (ProjectPanel *p : folder_panels_) {
-		SelectFootageForProjectPanel(e, p);
+		select_footage_for_project_panel(e, p);
 	}
 }
 
 void MainWindow::closeEvent(QCloseEvent *e)
 {
 	// Try to close all projects (this will return false if the user chooses not to close)
-	if (!Core::instance()->CloseProject(false)) {
+	if (!Core::instance()->close_project(false)) {
 		e->ignore();
 		return;
 	}
 
-	scope_panel_->SetViewerPanel(nullptr);
+	scope_panel_->set_viewer_panel(nullptr);
 
-	PanelManager::instance()->DeleteAllPanels();
+	PanelManager::instance()->delete_all_panels();
 
-	SaveCustomShortcuts();
+	save_custom_shortcuts();
 
 	QMainWindow::closeEvent(e);
 }
@@ -526,66 +526,66 @@ bool MainWindow::nativeEvent(const QByteArray &eventType, void *message,
 }
 #endif
 
-void MainWindow::StatusBarDoubleClicked()
+void MainWindow::status_bar_double_clicked()
 {
 	task_man_panel_->show();
 	task_man_panel_->raise();
 }
 
-void MainWindow::NodePanelGroupOpenedOrClosed()
+void MainWindow::node_panel_group_opened_or_closed()
 {
 	NodePanel *p = static_cast<NodePanel *>(sender());
-	param_panel_->SetContexts(p->GetContexts());
+	param_panel_->set_contexts(p->get_contexts());
 }
 
-void MainWindow::TimelinePanelSelectionChanged(const QVector<Block *> &blocks)
+void MainWindow::timeline_panel_selection_changed(const QVector<Block *> &blocks)
 {
 	TimelinePanel *panel = static_cast<TimelinePanel *>(sender());
 
-	if (PanelManager::instance()->CurrentlyFocused(false) == panel) {
-		UpdateNodePanelContextFromTimelinePanel(panel);
-		sequence_viewer_panel_->SetTimelineSelectedBlocks(blocks);
+	if (PanelManager::instance()->currently_focused(false) == panel) {
+		update_node_panel_context_from_timeline_panel(panel);
+		sequence_viewer_panel_->set_timeline_selected_blocks(blocks);
 	}
 }
 
-void MainWindow::ShowWelcomeDialog()
+void MainWindow::show_welcome_dialog()
 {
-	if (OLIVE_CONFIG("ShowWelcomeDialog").toBool()) {
+	if (OAK_CONFIG("show_welcome_dialog").toBool()) {
 		AboutDialog ad(true, this);
 		ad.exec();
 	}
 }
 
-void MainWindow::RevealViewerInProject(ViewerOutput *r)
+void MainWindow::reveal_viewer_in_project(ViewerOutput *r)
 {
 	// Rather than just using the resident ProjectPanel, find the most recently focused one since
 	// that's probably the one people will want
-	auto panels = PanelManager::instance()->GetPanelsOfType<ProjectPanel>();
+	auto panels = PanelManager::instance()->get_panels_of_type<ProjectPanel>();
 	foreach (ProjectPanel *p, panels) {
-		if (p->SelectItem(r)) {
+		if (p->select_item(r)) {
 			break;
 		}
 	}
 }
 
-void MainWindow::RevealViewerInFootageViewer(ViewerOutput *r,
+void MainWindow::reveal_viewer_in_footage_viewer(ViewerOutput *r,
 											 const TimeRange &range)
 {
-	footage_viewer_panel_->ConnectViewerNode(r);
+	footage_viewer_panel_->connect_viewer_node(r);
 
 	auto command = new MultiUndoCommand();
-	if (!r->GetWorkArea()->enabled()) {
+	if (!r->get_work_area()->enabled()) {
 		command->add_child(new WorkareaSetEnabledCommand(
-			r->project(), r->GetWorkArea(), true));
+			r->project(), r->get_work_area(), true));
 	}
-	command->add_child(new WorkareaSetRangeCommand(r->GetWorkArea(), range));
+	command->add_child(new WorkareaSetRangeCommand(r->get_work_area(), range));
 	Core::instance()->undo_stack()->push(command, tr("Set Footage Workarea"));
 
-	r->SetPlayhead(range.in());
+	r->set_playhead(range.in());
 }
 
 #ifdef Q_OS_LINUX
-void MainWindow::ShowNouveauWarning()
+void MainWindow::show_nouveau_warning()
 {
 	QMessageBox::warning(
 		this, tr("Driver Warning"),
@@ -596,14 +596,14 @@ void MainWindow::ShowNouveauWarning()
 }
 #endif
 
-void MainWindow::UpdateTitle()
+void MainWindow::update_title()
 {
-	if (Core::instance()->GetActiveProject()) {
+	if (Core::instance()->get_active_project()) {
 		setWindowTitle(
 			QStringLiteral("%1 %2 - [*]%3")
 				.arg(QApplication::applicationName(),
 					 QApplication::applicationVersion(),
-					 Core::instance()->GetActiveProject()->pretty_filename()));
+					 Core::instance()->get_active_project()->pretty_filename()));
 	} else {
 		setWindowTitle(
 			QStringLiteral("%1 %2").arg(QApplication::applicationName(),
@@ -611,53 +611,53 @@ void MainWindow::UpdateTitle()
 	}
 }
 
-void MainWindow::TimelineCloseRequested()
+void MainWindow::timeline_close_requested()
 {
 	TimelinePanel *t = static_cast<TimelinePanel *>(sender());
-	RemoveTimelinePanel(t);
+	remove_timeline_panel(t);
 }
 
-void MainWindow::ViewerCloseRequested()
+void MainWindow::viewer_close_requested()
 {
 	ViewerPanel *panel = static_cast<ViewerPanel *>(sender());
 
-	if (panel == scope_panel_->GetConnectedViewerPanel()) {
-		scope_panel_->SetViewerPanel(sequence_viewer_panel_);
+	if (panel == scope_panel_->get_connected_viewer_panel()) {
+		scope_panel_->set_viewer_panel(sequence_viewer_panel_);
 	}
 
-	RemovePanelInternal(viewer_panels_, panel);
+	remove_panel_internal(viewer_panels_, panel);
 
 	panel->deleteLater();
 }
 
-void MainWindow::ViewerWithPanelRemovedFromGraph()
+void MainWindow::viewer_with_panel_removed_from_graph()
 {
 	ViewerOutput *vo = static_cast<ViewerOutput *>(sender());
 	ViewerPanel *panel = nullptr;
 
 	foreach (ViewerPanel *p, viewer_panels_) {
-		if (p->GetConnectedViewer() == vo) {
+		if (p->get_connected_viewer() == vo) {
 			panel = p;
 			break;
 		}
 	}
 
 	if (panel) {
-		RemovePanelInternal(viewer_panels_, panel);
+		remove_panel_internal(viewer_panels_, panel);
 		panel->deleteLater();
-		disconnect(vo, &ViewerOutput::RemovedFromGraph, this,
-				   &MainWindow::ViewerWithPanelRemovedFromGraph);
+		disconnect(vo, &ViewerOutput::removed_from_graph, this,
+				   &MainWindow::viewer_with_panel_removed_from_graph);
 	}
 }
 
-void MainWindow::FolderPanelCloseRequested()
+void MainWindow::folder_panel_close_requested()
 {
 	ProjectPanel *panel = static_cast<ProjectPanel *>(sender());
-	RemovePanelInternal(folder_panels_, panel);
+	remove_panel_internal(folder_panels_, panel);
 	panel->deleteLater();
 }
 
-TimelinePanel *MainWindow::AppendTimelinePanel()
+TimelinePanel *MainWindow::append_timeline_panel()
 {
 	TimelinePanel *previous = nullptr;
 	if (!timeline_panels_.empty()) {
@@ -665,64 +665,64 @@ TimelinePanel *MainWindow::AppendTimelinePanel()
 	}
 
 	TimelinePanel *panel =
-		AppendPanelInternal(QStringLiteral("TimelinePanel"), timeline_panels_);
+		append_panel_internal(QStringLiteral("TimelinePanel"), timeline_panels_);
 
 	if (previous) {
 		previous->addDockWidgetAsTab(panel);
 	} else {
-		panel->SetSignalInsteadOfClose(false);
+		panel->set_signal_instead_of_close(false);
 	}
 
-	connect(panel, &PanelWidget::CloseRequested, this,
-			&MainWindow::TimelineCloseRequested);
-	connect(panel, &TimelinePanel::RequestCaptureStart, sequence_viewer_panel_,
-			&SequenceViewerPanel::StartCapture);
-	connect(panel, &TimelinePanel::BlockSelectionChanged, this,
-			&MainWindow::TimelinePanelSelectionChanged);
-	connect(panel, &TimelinePanel::RevealViewerInProject, this,
-			&MainWindow::RevealViewerInProject);
-	connect(panel, &TimelinePanel::RevealViewerInFootageViewer, this,
-			&MainWindow::RevealViewerInFootageViewer);
+	connect(panel, &PanelWidget::close_requested, this,
+			&MainWindow::timeline_close_requested);
+	connect(panel, &TimelinePanel::request_capture_start, sequence_viewer_panel_,
+			&SequenceViewerPanel::start_capture);
+	connect(panel, &TimelinePanel::block_selection_changed, this,
+			&MainWindow::timeline_panel_selection_changed);
+	connect(panel, &TimelinePanel::reveal_viewer_in_project, this,
+			&MainWindow::reveal_viewer_in_project);
+	connect(panel, &TimelinePanel::reveal_viewer_in_footage_viewer, this,
+			&MainWindow::reveal_viewer_in_footage_viewer);
 
-	sequence_viewer_panel_->ConnectTimeBasedPanel(panel);
+	sequence_viewer_panel_->connect_time_based_panel(panel);
 
 	return panel;
 }
 
-void MainWindow::RemoveTimelinePanel(TimelinePanel *panel)
+void MainWindow::remove_timeline_panel(TimelinePanel *panel)
 {
 	// Stop showing this timeline in the viewer
-	TimelineFocused(nullptr);
-	panel->ConnectViewerNode(nullptr);
+	timeline_focused(nullptr);
+	panel->connect_viewer_node(nullptr);
 
 	if (timeline_panels_.size() != 1) {
-		RemovePanelInternal(timeline_panels_, panel);
+		remove_panel_internal(timeline_panels_, panel);
 		panel->deleteLater();
 	}
 }
 
-void MainWindow::TimelineFocused(ViewerOutput *viewer)
+void MainWindow::timeline_focused(ViewerOutput *viewer)
 {
-	sequence_viewer_panel_->ConnectViewerNode(viewer);
-	multicam_panel_->ConnectViewerNode(viewer);
-	param_panel_->ConnectViewerNode(viewer);
-	curve_panel_->ConnectViewerNode(viewer);
+	sequence_viewer_panel_->connect_viewer_node(viewer);
+	multicam_panel_->connect_viewer_node(viewer);
+	param_panel_->connect_viewer_node(viewer);
+	curve_panel_->connect_viewer_node(viewer);
 }
 
-QString MainWindow::GetCustomShortcutsFile()
+QString MainWindow::get_custom_shortcuts_file()
 {
-	return QDir(FileFunctions::GetConfigurationLocation())
+	return QDir(FileFunctions::get_configuration_location())
 		.filePath(QStringLiteral("shortcuts"));
 }
 
-void LoadCustomShortcutsInternal(QMenu *menu,
+void load_custom_shortcuts_internal(QMenu *menu,
 								 const QMap<QString, QString> &shortcuts)
 {
 	QList<QAction *> actions = menu->actions();
 
 	foreach (QAction *a, actions) {
 		if (a->menu()) {
-			LoadCustomShortcutsInternal(a->menu(), shortcuts);
+			load_custom_shortcuts_internal(a->menu(), shortcuts);
 		} else if (!a->isSeparator()) {
 			QString action_id = a->property("id").toString();
 
@@ -733,9 +733,9 @@ void LoadCustomShortcutsInternal(QMenu *menu,
 	}
 }
 
-void MainWindow::LoadCustomShortcuts()
+void MainWindow::load_custom_shortcuts()
 {
-	QFile shortcut_file(GetCustomShortcutsFile());
+	QFile shortcut_file(get_custom_shortcuts_file());
 	if (shortcut_file.exists() && shortcut_file.open(QFile::ReadOnly)) {
 		QMap<QString, QString> shortcuts;
 
@@ -756,19 +756,19 @@ void MainWindow::LoadCustomShortcuts()
 			QList<QAction *> menus = menuBar()->actions();
 
 			foreach (QAction *menu, menus) {
-				LoadCustomShortcutsInternal(menu->menu(), shortcuts);
+				load_custom_shortcuts_internal(menu->menu(), shortcuts);
 			}
 		}
 	}
 }
 
-void SaveCustomShortcutsInternal(QMenu *menu, QMap<QString, QString> *shortcuts)
+void save_custom_shortcuts_internal(QMenu *menu, QMap<QString, QString> *shortcuts)
 {
 	QList<QAction *> actions = menu->actions();
 
 	foreach (QAction *a, actions) {
 		if (a->menu()) {
-			SaveCustomShortcutsInternal(a->menu(), shortcuts);
+			save_custom_shortcuts_internal(a->menu(), shortcuts);
 		} else if (!a->isSeparator()) {
 			QString default_shortcut =
 				a->property("keydefault").value<QKeySequence>().toString();
@@ -781,16 +781,16 @@ void SaveCustomShortcutsInternal(QMenu *menu, QMap<QString, QString> *shortcuts)
 	}
 }
 
-void MainWindow::SaveCustomShortcuts()
+void MainWindow::save_custom_shortcuts()
 {
 	QMap<QString, QString> shortcuts;
 	QList<QAction *> menus = menuBar()->actions();
 
 	foreach (QAction *menu, menus) {
-		SaveCustomShortcutsInternal(menu->menu(), &shortcuts);
+		save_custom_shortcuts_internal(menu->menu(), &shortcuts);
 	}
 
-	QFile shortcut_file(GetCustomShortcutsFile());
+	QFile shortcut_file(get_custom_shortcuts_file());
 	if (shortcuts.isEmpty()) {
 		if (shortcut_file.exists()) {
 			// No custom shortcuts, remove any existing file
@@ -812,75 +812,75 @@ void MainWindow::SaveCustomShortcuts()
 	}
 }
 
-void MainWindow::UpdateAudioMonitorParams(ViewerOutput *viewer)
+void MainWindow::update_audio_monitor_params(ViewerOutput *viewer)
 {
-	if (!audio_monitor_panel_->IsPlaying()) {
-		audio_monitor_panel_->SetParams(viewer ? viewer->GetAudioParams() :
+	if (!audio_monitor_panel_->is_playing()) {
+		audio_monitor_panel_->set_params(viewer ? viewer->get_audio_params() :
 												 AudioParams());
 	}
 }
 
-void MainWindow::UpdateNodePanelContextFromTimelinePanel(TimelinePanel *panel)
+void MainWindow::update_node_panel_context_from_timeline_panel(TimelinePanel *panel)
 {
 	// Add selected blocks (if any)
-	const QVector<Block *> &blocks = panel->GetSelectedBlocks();
+	const QVector<Block *> &blocks = panel->get_selected_blocks();
 	QVector<Node *> context(blocks.size());
 	for (int i = 0; i < blocks.size(); i++) {
 		context[i] = blocks.at(i);
 	}
 
 	// If no selected blocks, set the context to the sequence
-	ViewerOutput *viewer = panel->GetConnectedViewer();
+	ViewerOutput *viewer = panel->get_connected_viewer();
 	if (viewer && context.isEmpty()) {
 		context.append(viewer);
 	}
 
-	node_panel_->SetContexts(context);
-	param_panel_->SetContexts(context);
+	node_panel_->set_contexts(context);
+	param_panel_->set_contexts(context);
 }
 
-void MainWindow::SelectFootageForProjectPanel(const QVector<Footage *> &e,
+void MainWindow::select_footage_for_project_panel(const QVector<Footage *> &e,
 											  ProjectPanel *p)
 {
-	p->DeselectAll();
+	p->deselect_all();
 	for (Footage *f : e) {
-		if (p->get_root()->HasChildRecursive(f)) {
-			p->SelectItem(f, false);
+		if (p->get_root()->has_child_recursive(f)) {
+			p->select_item(f, false);
 		}
 	}
 }
 
-void MainWindow::FocusedPanelChanged(PanelWidget *panel)
+void MainWindow::focused_panel_changed(PanelWidget *panel)
 {
 	// Update audio monitor panel
 	if (TimeBasedPanel *tbp = dynamic_cast<TimeBasedPanel *>(panel)) {
-		UpdateAudioMonitorParams(tbp->GetConnectedViewer());
+		update_audio_monitor_params(tbp->get_connected_viewer());
 	}
 
 	if (NodePanel *node_panel = dynamic_cast<NodePanel *>(panel)) {
 		// Set param view contexts to these
-		const QVector<Node *> &new_ctxs = node_panel->GetContexts();
+		const QVector<Node *> &new_ctxs = node_panel->get_contexts();
 
-		if (new_ctxs != param_panel_->GetContexts()) {
-			param_panel_->SetContexts(new_ctxs);
+		if (new_ctxs != param_panel_->get_contexts()) {
+			param_panel_->set_contexts(new_ctxs);
 		}
 	} else if (TimelinePanel *timeline = dynamic_cast<TimelinePanel *>(panel)) {
 		// Signal timeline focus
-		TimelineFocused(timeline->GetConnectedViewer());
+		timeline_focused(timeline->get_connected_viewer());
 
-		UpdateNodePanelContextFromTimelinePanel(timeline);
+		update_node_panel_context_from_timeline_panel(timeline);
 	} else if (ProjectPanel *project = dynamic_cast<ProjectPanel *>(panel)) {
 		// Signal project panel focus
 		Q_UNUSED(project)
-		UpdateTitle();
+		update_title();
 	} else if (ViewerPanelBase *viewer =
 				   dynamic_cast<ViewerPanelBase *>(panel)) {
 		// Update scopes for viewer
-		scope_panel_->SetViewerPanel(viewer);
+		scope_panel_->set_viewer_panel(viewer);
 	}
 }
 
-void MainWindow::SetDefaultLayout()
+void MainWindow::set_default_layout()
 {
 	KDDockWidgets::InitialOption o;
 	o.preferredSize = QSize(0, centralAreaGeometry().height());
@@ -943,7 +943,7 @@ void MainWindow::showEvent(QShowEvent *e)
 	QMainWindow::showEvent(e);
 
 	if (first_show_) {
-		QMetaObject::invokeMethod(Core::instance(), "CheckForAutoRecoveries",
+		QMetaObject::invokeMethod(Core::instance(), "check_for_auto_recoveries",
 								  Qt::QueuedConnection);
 
 #ifdef Q_OS_LINUX
@@ -957,12 +957,12 @@ void MainWindow::showEvent(QShowEvent *e)
 			context.functions()->glGetString(GL_VENDOR));
 		qDebug() << "Using graphics driver:" << vendor;
 		if (!strcmp(vendor, "nouveau")) {
-			QMetaObject::invokeMethod(this, "ShowNouveauWarning",
+			QMetaObject::invokeMethod(this, "show_nouveau_warning",
 									  Qt::QueuedConnection);
 		}
 #endif
 
-		QMetaObject::invokeMethod(this, "ShowWelcomeDialog",
+		QMetaObject::invokeMethod(this, "show_welcome_dialog",
 								  Qt::QueuedConnection);
 
 		first_show_ = false;
@@ -970,9 +970,9 @@ void MainWindow::showEvent(QShowEvent *e)
 }
 
 template <typename T>
-T *MainWindow::AppendPanelInternal(const QString &panel_name, QList<T *> &list)
+T *MainWindow::append_panel_internal(const QString &panel_name, QList<T *> &list)
 {
-	T *panel = new T(TransformNameForSerialization(panel_name, list.size()));
+	T *panel = new T(transform_name_for_serialization(panel_name, list.size()));
 
 	// For some reason raise() on its own doesn't do anything, we need both
 	panel->show();
@@ -981,13 +981,13 @@ T *MainWindow::AppendPanelInternal(const QString &panel_name, QList<T *> &list)
 	list.append(panel);
 
 	// Let us handle the panel closing rather than the panel itself
-	panel->SetSignalInsteadOfClose(true);
+	panel->set_signal_instead_of_close(true);
 
 	return panel;
 }
 
 template <typename T>
-void MainWindow::RemovePanelInternal(QList<T *> &list, T *panel)
+void MainWindow::remove_panel_internal(QList<T *> &list, T *panel)
 {
 	list.removeOne(panel);
 }

app/window/mainwindow/mainwindow.h

@@ -19,8 +19,8 @@
 
 ***/
 
-#ifndef MAINWINDOW_H
-#define MAINWINDOW_H
+#ifndef OAK_MAINWINDOW_H
+#define OAK_MAINWINDOW_H
 
 #include <kddockwidgets/Config.h>
 #include <kddockwidgets/MainWindow.h>
@@ -61,21 +61,21 @@ public:
 
 	virtual ~MainWindow() override;
 
-	void LoadLayout(const MainWindowLayoutInfo &info);
+	void load_layout(const MainWindowLayoutInfo &info);
 
-	MainWindowLayoutInfo SaveLayout() const;
+	MainWindowLayoutInfo save_layout() const;
 
-	TimelinePanel *OpenSequence(Sequence *sequence, bool enable_focus = true);
+	TimelinePanel *open_sequence(Sequence *sequence, bool enable_focus = true);
 
-	void CloseSequence(Sequence *sequence);
+	void close_sequence(Sequence *sequence);
 
-	bool IsSequenceOpen(Sequence *sequence) const;
+	bool is_sequence_open(Sequence *sequence) const;
 
-	void OpenFolder(Folder *i, bool floating);
+	void open_folder(Folder *i, bool floating);
 
-	void OpenNodeInViewer(ViewerOutput *node);
+	void open_node_in_viewer(ViewerOutput *node);
 
-	enum ProgressStatus { kProgressNone, kProgressShow, kProgressError };
+	enum ProgressStatus { k_progress_none, k_progress_show, k_progress_error };
 
 	/**
    * @brief Where applicable, show progress on an operating system level
@@ -83,25 +83,25 @@ public:
    * * For Windows, this is shown as progress in the taskbar.
    * * For macOS, this is shown as progress in the dock.
    */
-	void SetApplicationProgressStatus(ProgressStatus status);
+	void set_application_progress_status(ProgressStatus status);
 
 	/**
    * @brief If SetApplicationProgressStatus is set to kShowProgress, set the value with this
    *
    * Expects a percentage (0-100 inclusive).
    */
-	void SetApplicationProgressValue(int value);
+	void set_application_progress_value(int value);
 
-	void SelectFootage(const QVector<Footage *> &e);
+	void select_footage(const QVector<Footage *> &e);
 
 public slots:
-	void SetProject(Project *p);
+	void set_project(Project *p);
 
-	void SetFullscreen(bool fullscreen);
+	void set_fullscreen(bool fullscreen);
 
-	void ToggleMaximizedPanel();
+	void toggle_maximized_panel();
 
-	void SetDefaultLayout();
+	void set_default_layout();
 
 protected:
 	virtual void showEvent(QShowEvent *e) override;
@@ -119,28 +119,28 @@ protected:
 #endif
 
 private:
-	TimelinePanel *AppendTimelinePanel();
+	TimelinePanel *append_timeline_panel();
 
 	template <typename T>
-	T *AppendPanelInternal(const QString &panel_name, QList<T *> &list);
+	T *append_panel_internal(const QString &panel_name, QList<T *> &list);
 
-	template <typename T> void RemovePanelInternal(QList<T *> &list, T *panel);
+	template <typename T> void remove_panel_internal(QList<T *> &list, T *panel);
 
-	void RemoveTimelinePanel(TimelinePanel *panel);
+	void remove_timeline_panel(TimelinePanel *panel);
 
-	void TimelineFocused(ViewerOutput *viewer);
+	void timeline_focused(ViewerOutput *viewer);
 
-	static QString GetCustomShortcutsFile();
+	static QString get_custom_shortcuts_file();
 
-	void LoadCustomShortcuts();
+	void load_custom_shortcuts();
 
-	void SaveCustomShortcuts();
+	void save_custom_shortcuts();
 
-	void UpdateAudioMonitorParams(ViewerOutput *viewer);
+	void update_audio_monitor_params(ViewerOutput *viewer);
 
-	void UpdateNodePanelContextFromTimelinePanel(TimelinePanel *panel);
+	void update_node_panel_context_from_timeline_panel(TimelinePanel *panel);
 
-	void SelectFootageForProjectPanel(const QVector<Footage *> &e,
+	void select_footage_for_project_panel(const QVector<Footage *> &e,
 									  ProjectPanel *p);
 
 	QByteArray premaximized_state_;
@@ -174,32 +174,32 @@ private:
 	Project *project_;
 
 private slots:
-	void FocusedPanelChanged(PanelWidget *panel);
+	void focused_panel_changed(PanelWidget *panel);
 
-	void UpdateTitle();
+	void update_title();
 
-	void TimelineCloseRequested();
+	void timeline_close_requested();
 
-	void ViewerCloseRequested();
+	void viewer_close_requested();
 
-	void ViewerWithPanelRemovedFromGraph();
+	void viewer_with_panel_removed_from_graph();
 
-	void FolderPanelCloseRequested();
+	void folder_panel_close_requested();
 
-	void StatusBarDoubleClicked();
+	void status_bar_double_clicked();
 
-	void NodePanelGroupOpenedOrClosed();
+	void node_panel_group_opened_or_closed();
 
 #ifdef Q_OS_LINUX
-	void ShowNouveauWarning();
+	void show_nouveau_warning();
 #endif
 
-	void TimelinePanelSelectionChanged(const QVector<Block *> &blocks);
+	void timeline_panel_selection_changed(const QVector<Block *> &blocks);
 
-	void ShowWelcomeDialog();
+	void show_welcome_dialog();
 
-	void RevealViewerInProject(ViewerOutput *r);
-	void RevealViewerInFootageViewer(ViewerOutput *r, const TimeRange &range);
+	void reveal_viewer_in_project(ViewerOutput *r);
+	void reveal_viewer_in_footage_viewer(ViewerOutput *r, const TimeRange &range);
 };
 
 }

app/window/mainwindow/mainwindowlayoutinfo.cpp

@@ -21,10 +21,10 @@
 namespace olive
 {
 
-void MainWindowLayoutInfo::toXml(QXmlStreamWriter *writer) const
+void MainWindowLayoutInfo::to_xml(QXmlStreamWriter *writer) const
 {
 	writer->writeAttribute(QStringLiteral("version"),
-						   QString::number(kVersion));
+						   QString::number(k_version));
 
 	writer->writeStartElement(QStringLiteral("folders"));
 
@@ -84,7 +84,7 @@ void MainWindowLayoutInfo::toXml(QXmlStreamWriter *writer) const
 }
 
 MainWindowLayoutInfo
-MainWindowLayoutInfo::fromXml(QXmlStreamReader *reader,
+MainWindowLayoutInfo::from_xml(QXmlStreamReader *reader,
 							  const QHash<quintptr, Node *> &node_ptrs)
 {
 	MainWindowLayoutInfo info;
@@ -99,12 +99,12 @@ MainWindowLayoutInfo::fromXml(QXmlStreamReader *reader,
 	}
 
 	// Really basic version checking, in the future we may use this to parse multiple versions
-	if (file_version != kVersion) {
+	if (file_version != k_version) {
 	}
 
-	while (XMLReadNextStartElement(reader)) {
+	while (xml_read_next_start_element(reader)) {
 		if (reader->name() == QStringLiteral("folders")) {
-			while (XMLReadNextStartElement(reader)) {
+			while (xml_read_next_start_element(reader)) {
 				if (reader->name() == QStringLiteral("folder")) {
 					quintptr item_id = reader->readElementText().toULongLong();
 
@@ -117,7 +117,7 @@ MainWindowLayoutInfo::fromXml(QXmlStreamReader *reader,
 			}
 
 		} else if (reader->name() == QStringLiteral("timeline")) {
-			while (XMLReadNextStartElement(reader)) {
+			while (xml_read_next_start_element(reader)) {
 				if (reader->name() == QStringLiteral("sequence")) {
 					quintptr item_id = reader->readElementText().toULongLong();
 
@@ -130,7 +130,7 @@ MainWindowLayoutInfo::fromXml(QXmlStreamReader *reader,
 			}
 
 		} else if (reader->name() == QStringLiteral("viewers")) {
-			while (XMLReadNextStartElement(reader)) {
+			while (xml_read_next_start_element(reader)) {
 				if (reader->name() == QStringLiteral("viewer")) {
 					quintptr item_id = reader->readElementText().toULongLong();
 
@@ -147,7 +147,7 @@ MainWindowLayoutInfo::fromXml(QXmlStreamReader *reader,
 				QByteArray::fromBase64(reader->readElementText().toLatin1());
 
 		} else if (reader->name() == QStringLiteral("data")) {
-			while (XMLReadNextStartElement(reader)) {
+			while (xml_read_next_start_element(reader)) {
 				if (reader->name() == QStringLiteral("panel")) {
 					QString id;
 					XMLAttributeLoop(reader, attr)
@@ -160,7 +160,7 @@ MainWindowLayoutInfo::fromXml(QXmlStreamReader *reader,
 					if (!id.isEmpty()) {
 						PanelWidget::Info i;
 
-						while (XMLReadNextStartElement(reader)) {
+						while (xml_read_next_start_element(reader)) {
 							if (reader->name() == QStringLiteral("option")) {
 								QString name;
 

app/window/mainwindow/mainwindowlayoutinfo.h

@@ -16,8 +16,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef MAINWINDOWLAYOUTINFO_H
-#define MAINWINDOWLAYOUTINFO_H
+#ifndef OAK_MAINWINDOWLAYOUTINFO_H
+#define OAK_MAINWINDOWLAYOUTINFO_H
 
 #include "node/project/folder/folder.h"
 #include "node/project/sequence/sequence.h"
@@ -30,10 +30,10 @@ class MainWindowLayoutInfo {
 public:
 	MainWindowLayoutInfo() = default;
 
-	void toXml(QXmlStreamWriter *writer) const;
+	void to_xml(QXmlStreamWriter *writer) const;
 
 	static MainWindowLayoutInfo
-	fromXml(QXmlStreamReader *reader, const QHash<quintptr, Node *> &node_map);
+	from_xml(QXmlStreamReader *reader, const QHash<quintptr, Node *> &node_map);
 
 	void add_folder(Folder *f);
 
@@ -83,11 +83,11 @@ private:
 
 	std::map<QString, PanelWidget::Info> panel_data_;
 
-	static const unsigned int kVersion = 1;
+	static const unsigned int k_version = 1;
 };
 
 }
 
 Q_DECLARE_METATYPE(olive::MainWindowLayoutInfo)
 
-#endif // MAINWINDOWLAYOUTINFO_H
+#endif // OAK_MAINWINDOWLAYOUTINFO_H

app/window/mainwindow/mainwindowundo.cpp

@@ -29,22 +29,22 @@ namespace olive
 
 void OpenSequenceCommand::redo()
 {
-	Core::instance()->main_window()->OpenSequence(sequence_);
+	Core::instance()->main_window()->open_sequence(sequence_);
 }
 
 void OpenSequenceCommand::undo()
 {
-	Core::instance()->main_window()->CloseSequence(sequence_);
+	Core::instance()->main_window()->close_sequence(sequence_);
 }
 
 void CloseSequenceCommand::redo()
 {
-	Core::instance()->main_window()->CloseSequence(sequence_);
+	Core::instance()->main_window()->close_sequence(sequence_);
 }
 
 void CloseSequenceCommand::undo()
 {
-	Core::instance()->main_window()->OpenSequence(sequence_);
+	Core::instance()->main_window()->open_sequence(sequence_);
 }
 
 }

app/window/mainwindow/mainwindowundo.h

@@ -19,8 +19,8 @@
 
 ***/
 
-#ifndef MAINWINDOWUNDO_H
-#define MAINWINDOWUNDO_H
+#ifndef OAK_MAINWINDOWUNDO_H
+#define OAK_MAINWINDOWUNDO_H
 
 #include "node/project/sequence/sequence.h"
 
@@ -34,7 +34,7 @@ public:
 	{
 	}
 
-	virtual Project *GetRelevantProject() const override
+	virtual Project *get_relevant_project() const override
 	{
 		return nullptr;
 	}
@@ -55,7 +55,7 @@ public:
 	{
 	}
 
-	virtual Project *GetRelevantProject() const override
+	virtual Project *get_relevant_project() const override
 	{
 		return nullptr;
 	}
@@ -71,4 +71,4 @@ private:
 
 }
 
-#endif // MAINWINDOWUNDO_H
+#endif // OAK_MAINWINDOWUNDO_H