OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-01-21 22:13:25 -06:00
Code Issues Packages Projects Releases Wiki Activity
57b33b0d4c
ResInsight/ApplicationCode/ProjectDataModel/RimWellLogCurveCommonDataSource.cpp
Gaute Lindkvist 57b33b0d4c
First implementation of Headless (#4392) 
* Revert "#4377 Octave : Use RiaLogging for error messages instead of QErrorMessage "

This reverts commit f758a8edb2.

* Revert "#4380 Preferences : Changing scene font size when geo mech view is open causes crash"

This reverts commit df62a41397.

* Revert "#4379 Documentation : Update command line parser for import of summary files"

This reverts commit d0b5357ed4.

* Unfinished WIP

* Builds but crashes

* Refactored code now builds and runs

* ResInsight can now run the unittests headless

* Can run some command files successfully

* Build on Linux

* Extra headless hack header

* Moved PdmUiItem hack to cpp file

* Fix headless crash in RimWellAllocationPlot

* Handle error gracefully if ExportSnapshots command is executed from console

* Add caf::QIconProvider and remove some hacks

* Also made the greying out of disabled icons work for a couple of cases where it didn't.

* Linux build fix

* #4380 Reimplement fix df62a41397 by @magnesj on top of Headless code changes

* #4379 Reintroduce kode from d0b5357ed4 by @magnesj

* #4377 Restore f758a8edb2 in new Headless code
2019-05-06 10:36:05 +02:00

737 lines
26 KiB
C++
Raw Blame History

/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2016 Statoil ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RimWellLogCurveCommonDataSource.h"
#include "RimCase.h"
#include "RimDataSourceSteppingTools.h"
#include "RimEclipseCase.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimTools.h"
#include "RimWellLogExtractionCurve.h"
#include "RimWellLogFileCurve.h"
#include "RimWellLogPlot.h"
#include "RimWellLogPlotCollection.h"
#include "RimWellLogTrack.h"
#include "RimWellPath.h"
#include "RimWellPathCollection.h"
#include "RiaApplication.h"
#include "RiaSimWellBranchTools.h"
#include "cafPdmUiCheckBoxTristateEditor.h"
#include "cafPdmUiComboBoxEditor.h"
CAF_PDM_SOURCE_INIT(RimWellLogCurveCommonDataSource, "ChangeDataSourceFeatureUi");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellLogCurveCommonDataSource::RimWellLogCurveCommonDataSource()
{
CAF_PDM_InitObject("Change Data Source", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_case, "CurveCase", "Case", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_trajectoryType, "TrajectoryType", "Trajectory Type", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_wellPath, "CurveWellPath", "Well Name", "", "", "");
CAF_PDM_InitField(&m_simWellName, "SimulationWellName", QString("None"), "Well Name", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_branchDetection, "BranchDetection", "Branch Detection", "",
"Compute branches based on how simulation well cells are organized", "");
m_branchDetection.v() = caf::Tristate::State::PartiallyTrue;
m_branchDetection.uiCapability()->setUiEditorTypeName(caf::PdmUiCheckBoxTristateEditor::uiEditorTypeName());
CAF_PDM_InitField(&m_branchIndex, "Branch", -1, "Branch Index", "", "", "");
CAF_PDM_InitField(&m_timeStep, "CurveTimeStep", -1, "Time Step", "", "", "");
m_case = nullptr;
m_wellPath = nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimCase* RimWellLogCurveCommonDataSource::caseToApply() const
{
return m_case;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::setCaseToApply(RimCase* val)
{
m_case = val;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int RimWellLogCurveCommonDataSource::trajectoryTypeToApply() const
{
return m_trajectoryType();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::setTrajectoryTypeToApply(int val)
{
m_trajectoryType = val;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellPath* RimWellLogCurveCommonDataSource::wellPathToApply() const
{
return m_wellPath;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::setWellPathToApply(RimWellPath* val)
{
m_wellPath = val;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::setBranchIndexToApply(int val)
{
m_branchIndex = val;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::setBranchDetectionToApply(caf::Tristate::State val)
{
m_branchDetection.v() = val;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimWellLogCurveCommonDataSource::simWellNameToApply() const
{
return m_simWellName();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::setSimWellNameToApply(const QString& val)
{
m_simWellName = val;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int RimWellLogCurveCommonDataSource::timeStepToApply() const
{
return m_timeStep;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::setTimeStepToApply(int val)
{
m_timeStep = val;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::resetDefaultOptions()
{
setCaseToApply(nullptr);
setTrajectoryTypeToApply(-1);
setWellPathToApply(nullptr);
setBranchIndexToApply(-1);
setBranchDetectionToApply(caf::Tristate::State::PartiallyTrue);
setSimWellNameToApply(QString(""));
setTimeStepToApply(-1);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::updateDefaultOptions(const std::vector<RimWellLogCurve*>& curves, const std::vector<RimWellLogTrack*>& tracks)
{
// Reset all options in the UI
resetDefaultOptions();
// Check to see if the parameters are unique
std::set<RimCase*> uniqueCases;
std::set<int> uniqueTrajectoryTypes;
std::set<RimWellPath*> uniqueWellPaths;
std::set<QString> uniqueWellNames;
std::set<int> uniqueTimeSteps;
std::set<bool> uniqueBranchDetection;
std::set<int> uniqueBranchIndex;
for (RimWellLogCurve* curve : curves)
{
if (!curve->isCurveVisible())
{
continue;
}
RimWellLogExtractionCurve* extractionCurve = dynamic_cast<RimWellLogExtractionCurve*>(curve);
RimWellLogFileCurve* fileCurve = dynamic_cast<RimWellLogFileCurve*>(curve);
if (extractionCurve)
{
uniqueCases.insert(extractionCurve->rimCase());
uniqueTrajectoryTypes.insert(static_cast<int>(extractionCurve->trajectoryType()));
uniqueWellPaths.insert(extractionCurve->wellPath());
uniqueWellNames.insert(extractionCurve->wellName());
uniqueTimeSteps.insert(extractionCurve->currentTimeStep());
uniqueBranchDetection.insert(extractionCurve->branchDetection());
uniqueBranchIndex.insert(extractionCurve->branchIndex());
}
else if (fileCurve)
{
uniqueWellPaths.insert(fileCurve->wellPath());
uniqueWellNames.insert(fileCurve->wellName());
}
}
for (RimWellLogTrack* track : tracks)
{
if (track->showWellPathAttributes())
{
uniqueTrajectoryTypes.insert(static_cast<int>(RimWellLogExtractionCurve::WELL_PATH));
uniqueWellPaths.insert(track->wellPathAttributeSource());
}
if (track->showFormations())
{
uniqueCases.insert(track->formationNamesCase());
uniqueWellPaths.insert(track->formationWellPath());
}
}
if (uniqueCases.size() == 1u)
{
setCaseToApply(*uniqueCases.begin());
}
if (uniqueTrajectoryTypes.size() == 1u)
{
m_trajectoryType = *uniqueTrajectoryTypes.begin();
if (uniqueWellPaths.size() == 1u)
{
setWellPathToApply(*uniqueWellPaths.begin());
}
if (uniqueBranchIndex.size() == 1u)
{
setBranchIndexToApply(*uniqueBranchIndex.begin());
}
if (uniqueBranchDetection.size() == 1u)
{
setBranchDetectionToApply(*uniqueBranchDetection.begin() == true ?
caf::Tristate::State::True : caf::Tristate::State::False);
}
if (uniqueWellNames.size() == 1u)
{
setSimWellNameToApply(*uniqueWellNames.begin());
}
}
if (uniqueTimeSteps.size() == 1u)
{
setTimeStepToApply(*uniqueTimeSteps.begin());
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::updateDefaultOptions()
{
RimWellLogPlot* parentPlot = nullptr;
this->firstAncestorOrThisOfType(parentPlot);
if (parentPlot)
{
std::vector<RimWellLogCurve*> curves;
parentPlot->descendantsIncludingThisOfType(curves);
std::vector<RimWellLogTrack*> tracks;
parentPlot->descendantsIncludingThisOfType(tracks);
this->updateDefaultOptions(curves, tracks);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::updateCurvesAndTracks(std::vector<RimWellLogCurve*>& curves, std::vector<RimWellLogTrack*>& tracks)
{
std::set<RimWellLogPlot*> plots;
for (RimWellLogCurve* curve : curves)
{
if (!curve->isCurveVisible())
{
continue;
}
RimWellLogFileCurve* fileCurve = dynamic_cast<RimWellLogFileCurve*>(curve);
RimWellLogExtractionCurve* extractionCurve = dynamic_cast<RimWellLogExtractionCurve*>(curve);
if (fileCurve)
{
if (wellPathToApply() != nullptr)
{
fileCurve->setWellPath(wellPathToApply());
if (!fileCurve->wellLogChannelName().isEmpty())
{
RimWellLogFile* logFile = wellPathToApply()->firstWellLogFileMatchingChannelName(fileCurve->wellLogChannelName());
fileCurve->setWellLogFile(logFile);
RimWellLogPlot* parentPlot = nullptr;
fileCurve->firstAncestorOrThisOfTypeAsserted(parentPlot);
plots.insert(parentPlot);
}
}
}
else if (extractionCurve)
{
bool updatedSomething = false;
if (caseToApply() != nullptr)
{
extractionCurve->setCase(caseToApply());
updatedSomething = true;
}
if (wellPathToApply() != nullptr)
{
extractionCurve->setWellPath(wellPathToApply());
updatedSomething = true;
}
if (m_trajectoryType() != -1)
{
extractionCurve->setTrajectoryType(static_cast<RimWellLogExtractionCurve::TrajectoryType>(m_trajectoryType()));
if (m_trajectoryType() == (int)RimWellLogExtractionCurve::SIMULATION_WELL)
{
if (m_branchDetection().isTrue())
{
extractionCurve->setBranchDetection(true);
}
else if (m_branchDetection().isFalse())
{
extractionCurve->setBranchDetection(false);
}
if (m_branchIndex() != -1)
{
extractionCurve->setBranchIndex(m_branchIndex());
}
if (m_simWellName() != QString(""))
{
extractionCurve->setWellName(m_simWellName());
}
}
updatedSomething = true;
}
if (timeStepToApply() != -1)
{
extractionCurve->setCurrentTimeStep(timeStepToApply());
updatedSomething = true;
}
if (updatedSomething)
{
RimWellLogPlot* parentPlot = nullptr;
extractionCurve->firstAncestorOrThisOfTypeAsserted(parentPlot);
plots.insert(parentPlot);
curve->updateConnectedEditors();
}
}
}
for (RimWellLogTrack* track : tracks)
{
bool updatedSomething = false;
if (caseToApply() != nullptr)
{
if (track->showFormations())
{
track->setFormationCase(caseToApply());
updatedSomething = true;
}
}
if (wellPathToApply() != nullptr)
{
if (track->showWellPathAttributes())
{
track->setWellPathAttributesSource(wellPathToApply());
updatedSomething = true;
}
if (track->showFormations())
{
track->setFormationWellPath(wellPathToApply());
updatedSomething = true;
}
}
if (updatedSomething)
{
RimWellLogPlot* parentPlot = nullptr;
track->firstAncestorOrThisOfTypeAsserted(parentPlot);
plots.insert(parentPlot);
track->updateConnectedEditors();
}
}
for (RimWellLogPlot* plot : plots)
{
plot->loadDataAndUpdate();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::updateCurvesAndTracks()
{
RimWellLogPlot* parentPlot = nullptr;
this->firstAncestorOrThisOfType(parentPlot);
if (parentPlot)
{
std::vector<RimWellLogCurve*> curves;
parentPlot->descendantsIncludingThisOfType(curves);
std::vector<RimWellLogTrack*> tracks;
parentPlot->descendantsIncludingThisOfType(tracks);
this->updateCurvesAndTracks(curves, tracks);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::applyPrevCase()
{
modifyCurrentIndex(&m_case, -1);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::applyNextCase()
{
modifyCurrentIndex(&m_case, 1);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::applyPrevWell()
{
if (m_trajectoryType() == RimWellLogExtractionCurve::WELL_PATH)
{
modifyCurrentIndex(&m_wellPath, -1);
}
else if (m_trajectoryType() == RimWellLogExtractionCurve::SIMULATION_WELL)
{
modifyCurrentIndex(&m_simWellName, -1);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::applyNextWell()
{
if (m_trajectoryType() == RimWellLogExtractionCurve::WELL_PATH)
{
modifyCurrentIndex(&m_wellPath, 1);
}
else if (m_trajectoryType() == RimWellLogExtractionCurve::SIMULATION_WELL)
{
modifyCurrentIndex(&m_simWellName, 1);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::applyPrevTimeStep()
{
modifyCurrentIndex(&m_timeStep, -1);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::applyNextTimeStep()
{
modifyCurrentIndex(&m_timeStep, 1);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<caf::PdmFieldHandle *> RimWellLogCurveCommonDataSource::fieldsToShowInToolbar()
{
updateDefaultOptions();
std::vector<caf::PdmFieldHandle*> fieldsToDisplay;
fieldsToDisplay.push_back(&m_case);
if (trajectoryTypeToApply() == RimWellLogExtractionCurve::WELL_PATH)
{
fieldsToDisplay.push_back(&m_wellPath);
}
else if (trajectoryTypeToApply() == RimWellLogExtractionCurve::SIMULATION_WELL)
{
fieldsToDisplay.push_back(&m_simWellName);
}
fieldsToDisplay.push_back(&m_timeStep);
return fieldsToDisplay;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
RimWellLogPlot* parentPlot = nullptr;
this->firstAncestorOrThisOfType(parentPlot);
if (changedField == &m_branchDetection)
{
if (m_branchDetection().isPartiallyTrue())
{
// The Tristate is cycled from false -> partially true -> true
// Partially true is used for "Mixed state" and is not settable by the user so cycle on to true.
m_branchDetection.v() = caf::Tristate::State::True;
}
}
this->updateCurvesAndTracks();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RimWellLogCurveCommonDataSource::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly)
{
QList<caf::PdmOptionItemInfo> options;
this->updateDefaultOptions();
if (fieldNeedingOptions == &m_case)
{
RimTools::caseOptionItems(&options);
if (caseToApply() == nullptr)
{
options.push_front(caf::PdmOptionItemInfo("Mixed Cases", nullptr));
}
}
else if (fieldNeedingOptions == &m_trajectoryType)
{
if (m_trajectoryType() == -1)
{
options.push_back(caf::PdmOptionItemInfo("Mixed Trajectory Types", -1));
}
std::vector<RimWellLogExtractionCurve::TrajectoryType> trajectoryTypes =
{ RimWellLogExtractionCurve::WELL_PATH, RimWellLogExtractionCurve::SIMULATION_WELL };
for (RimWellLogExtractionCurve::TrajectoryType trajectoryType : trajectoryTypes)
{
caf::PdmOptionItemInfo item(caf::AppEnum<RimWellLogExtractionCurve::TrajectoryType>::uiText(trajectoryType),
static_cast<int>(trajectoryType));
options.push_back(item);
}
}
else if (fieldNeedingOptions == &m_wellPath)
{
RimTools::wellPathOptionItems(&options);
if (wellPathToApply() == nullptr)
{
options.push_front(caf::PdmOptionItemInfo("Mixed Well Paths", nullptr));
}
}
else if (fieldNeedingOptions == &m_timeStep)
{
QStringList timeStepNames;
if (m_case)
{
timeStepNames = m_case->timeStepStrings();
}
for (int i = 0; i < timeStepNames.size(); i++)
{
options.push_back(caf::PdmOptionItemInfo(timeStepNames[i], i));
}
if (timeStepToApply() == -1)
{
options.push_front(caf::PdmOptionItemInfo("Mixed Time Steps", -1));
}
}
else if (fieldNeedingOptions == &m_simWellName)
{
RimEclipseCase* eclipseCase = dynamic_cast<RimEclipseCase*>(m_case());
if (eclipseCase)
{
std::set<QString> sortedWellNames = eclipseCase->sortedSimWellNames();
caf::QIconProvider simWellIcon(":/Well.png");
for (const QString& wname : sortedWellNames)
{
options.push_back(caf::PdmOptionItemInfo(wname, wname, false, simWellIcon));
}
if (options.size() == 0)
{
options.push_front(caf::PdmOptionItemInfo("None", "None"));
}
if (m_simWellName == QString(""))
{
options.push_front(caf::PdmOptionItemInfo("Mixed Well Names", ""));
}
}
}
else if (fieldNeedingOptions == &m_branchIndex)
{
bool hasCommonBranchDetection = !m_branchDetection().isPartiallyTrue();
if (hasCommonBranchDetection)
{
bool doBranchDetection = m_branchDetection().isTrue();
auto branches = RiaSimWellBranchTools::simulationWellBranches(m_simWellName, doBranchDetection);
options = RiaSimWellBranchTools::valueOptionsForBranchIndexField(branches);
if (m_branchIndex() == -1)
{
options.push_front(caf::PdmOptionItemInfo("Mixed Branches", -1));
}
}
}
return options;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
updateDefaultOptions();
caf::PdmUiGroup* group = uiOrdering.addNewGroup("Data Source");
group->add(&m_case);
RimEclipseCase* eclipseCase = dynamic_cast<RimEclipseCase*>(m_case());
if (eclipseCase)
{
group->add(&m_trajectoryType);
if (trajectoryTypeToApply() == RimWellLogExtractionCurve::WELL_PATH)
{
group->add(&m_wellPath);
}
else if (trajectoryTypeToApply() == RimWellLogExtractionCurve::SIMULATION_WELL)
{
group->add(&m_simWellName);
if (RiaSimWellBranchTools::simulationWellBranches(m_simWellName(), true).size() > 1)
{
group->add(&m_branchDetection);
bool hasCommonBranchDetection = !m_branchDetection().isPartiallyTrue();
if (hasCommonBranchDetection)
{
bool doBranchDetection = m_branchDetection().isTrue();
if (RiaSimWellBranchTools::simulationWellBranches(m_simWellName(), doBranchDetection).size() > 1)
{
group->add(&m_branchIndex);
}
}
}
}
}
else
{
group->add(&m_wellPath);
}
group->add(&m_timeStep);
uiOrdering.skipRemainingFields(true);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::defineEditorAttribute(const caf::PdmFieldHandle* field,
QString uiConfigName,
caf::PdmUiEditorAttribute* attribute)
{
caf::PdmUiComboBoxEditorAttribute* myAttr = dynamic_cast<caf::PdmUiComboBoxEditorAttribute*>(attribute);
if (myAttr)
{
if (field == &m_case ||
field == &m_simWellName ||
field == &m_wellPath ||
field == &m_timeStep)
{
myAttr->showPreviousAndNextButtons = true;
}
QString modifierText;
if (field == &m_case)
{
modifierText = ("(Shift+");
}
else if (field == &m_wellPath || field == &m_simWellName)
{
modifierText = ("(Ctrl+");
}
else if (field == &m_timeStep)
{
modifierText = ("(");
}
if (!modifierText.isEmpty())
{
myAttr->nextButtonText = "Next " + modifierText + "PgDown)";
myAttr->prevButtonText = "Previous " + modifierText + "PgUp)";
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogCurveCommonDataSource::modifyCurrentIndex(caf::PdmValueField* field, int indexOffset)
{
bool useOptionsOnly;
QList<caf::PdmOptionItemInfo> options = calculateValueOptions(field, &useOptionsOnly);
RimDataSourceSteppingTools::modifyCurrentIndex(field, options, indexOffset);
}
Reference in New Issue View Git Blame Copy Permalink