mirror of
https://github.com/SpartanJ/eepp.git
synced 2026-05-30 01:56:31 +03:00
457 lines
16 KiB
C++
457 lines
16 KiB
C++
#include "codeeditor.hpp"
|
|
#include <args/args.hxx>
|
|
|
|
App* appInstance = NULL;
|
|
|
|
void appLoop() {
|
|
appInstance->mainLoop();
|
|
}
|
|
|
|
bool App::onCloseRequestCallback( EE::Window::Window* ) {
|
|
if ( NULL != mCurEditor && mCurEditor->isDirty() ) {
|
|
mMsgBox = UIMessageBox::New(
|
|
UIMessageBox::OK_CANCEL,
|
|
"Do you really want to close the code editor?\nAll changes will be lost." );
|
|
mMsgBox->addEventListener( Event::MsgBoxConfirmClick,
|
|
[&]( const Event* ) { mWindow->close(); } );
|
|
mMsgBox->addEventListener( Event::OnClose, [&]( const Event* ) { mMsgBox = NULL; } );
|
|
mMsgBox->setTitle( "Close Code Editor?" );
|
|
mMsgBox->center();
|
|
mMsgBox->show();
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool App::onTabCloseRequestCallback( EE::Window::Window* ) {
|
|
if ( NULL != mCurEditor && mCurEditor->isDirty() ) {
|
|
mMsgBox =
|
|
UIMessageBox::New( UIMessageBox::OK_CANCEL,
|
|
"Do you really want to close this tab?\nAll changes will be lost." );
|
|
mMsgBox->addEventListener( Event::MsgBoxConfirmClick,
|
|
[&]( const Event* ) { closeCurrrentTab(); } );
|
|
mMsgBox->addEventListener( Event::OnClose, [&]( const Event* ) {
|
|
mMsgBox = NULL;
|
|
if ( mCurEditor )
|
|
mCurEditor->setFocus();
|
|
} );
|
|
mMsgBox->setTitle( "Close Editor Tab?" );
|
|
mMsgBox->center();
|
|
mMsgBox->show();
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void App::closeCurrrentTab() {
|
|
if ( mCurEditor ) {
|
|
UITabWidget* tabWidget = tabWidgetFromEditor( mCurEditor );
|
|
if ( tabWidget ) {
|
|
tabWidget->removeTab( (UITab*)mCurEditor->getData() );
|
|
if ( tabWidget->getTabCount() > 0 ) {
|
|
tabWidget->setTabSelected( tabWidget->getTabCount() - 1 );
|
|
tabWidget->getSelectedTab()->getOwnedWidget()->setFocus();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void App::splitEditor( const UIOrientation& orientation ) {
|
|
UITabWidget* tabWidget = tabWidgetFromEditor( mCurEditor );
|
|
if ( tabWidget ) {
|
|
UISplitter* splitter = (UISplitter*)tabWidget->getParent();
|
|
if ( splitter->getChildCount() < 3 ) {
|
|
splitter->setOrientation( orientation );
|
|
createEditorWithSplitter( splitter );
|
|
}
|
|
}
|
|
}
|
|
|
|
UICodeEditor* App::createCodeEditor() {
|
|
UICodeEditor* codeEditor = UICodeEditor::New();
|
|
codeEditor->setFontSize( 11 );
|
|
codeEditor->getDocument().setCommand( "find", [&]() { findTextMessageBox(); } );
|
|
codeEditor->getDocument().setCommand( "repeat-find", [&] { findText(); } );
|
|
codeEditor->getDocument().setCommand( "close-app", [&] { closeApp(); } );
|
|
codeEditor->getDocument().setCommand( "fullscreen-toggle",
|
|
[&]() { mWindow->toggleFullscreen(); } );
|
|
codeEditor->getDocument().setCommand( "open-file", [&] { openFileDialog(); } );
|
|
codeEditor->getDocument().setCommand( "console-toggle", [&] { mConsole->toggle(); } );
|
|
codeEditor->getDocument().setCommand( "close-doc", [&] {
|
|
if ( onTabCloseRequestCallback( mWindow ) ) {
|
|
closeCurrrentTab();
|
|
}
|
|
} );
|
|
codeEditor->getDocument().setCommand( "create-new", [&] {
|
|
auto d = createCodeEditorInTabWidget( tabWidgetFromEditor( mCurEditor ) );
|
|
d.first->getTabWidget()->setTabSelected( d.first );
|
|
d.second->setFocus();
|
|
} );
|
|
codeEditor->getDocument().setCommand( "next-doc", [&] {
|
|
UITabWidget* tabWidget = tabWidgetFromEditor( mCurEditor );
|
|
if ( tabWidget && tabWidget->getTabCount() > 1 ) {
|
|
UITab* tab = (UITab*)mCurEditor->getData();
|
|
Uint32 tabIndex = tabWidget->getTabIndex( tab );
|
|
if ( tabIndex + 1 == tabWidget->getTabCount() ) {
|
|
tab = tabWidget->setTabSelected( (Uint32)0 );
|
|
} else {
|
|
tab = tabWidget->setTabSelected( ( Uint32 )( tabIndex + 1 ) );
|
|
}
|
|
if ( tab )
|
|
tab->getOwnedWidget()->setFocus();
|
|
}
|
|
} );
|
|
codeEditor->getDocument().setCommand( "previous-doc", [&] {
|
|
UITabWidget* tabWidget = tabWidgetFromEditor( mCurEditor );
|
|
if ( tabWidget && tabWidget->getTabCount() > 1 ) {
|
|
UITab* tab = (UITab*)mCurEditor->getData();
|
|
Uint32 tabIndex = tabWidget->getTabIndex( tab );
|
|
if ( tabIndex == 0 ) {
|
|
tab = tabWidget->setTabSelected( (Uint32)tabWidget->getTabCount() - 1 );
|
|
} else {
|
|
tab = tabWidget->setTabSelected( ( Uint32 )( tabIndex - 1 ) );
|
|
}
|
|
if ( tab )
|
|
tab->getOwnedWidget()->setFocus();
|
|
}
|
|
} );
|
|
codeEditor->getDocument().setCommand( "split-horizontal",
|
|
[&] { splitEditor( UIOrientation::Horizontal ); } );
|
|
codeEditor->getDocument().setCommand( "split-vertical",
|
|
[&] { splitEditor( UIOrientation::Vertical ); } );
|
|
codeEditor->addKeyBindingString( "escape", "close-app", true );
|
|
codeEditor->addKeyBindingString( "f2", "open-file", true );
|
|
codeEditor->addKeyBindingString( "f3", "repeat-find", false );
|
|
codeEditor->addKeyBindingString( "f12", "console-toggle", true );
|
|
codeEditor->addKeyBindingString( "alt+return", "fullscreen-toggle", true );
|
|
codeEditor->addKeyBindingString( "ctrl+s", "save", false );
|
|
codeEditor->addKeyBindingString( "ctrl+f", "find", false );
|
|
codeEditor->addKeyBindingString( "ctrl+q", "close-app", true );
|
|
codeEditor->addKeyBindingString( "ctrl+o", "open-file", true );
|
|
codeEditor->addKeyBindingString( "ctrl+l", "lock-toggle", true );
|
|
codeEditor->addKeyBindingString( "ctrl+t", "create-new", true );
|
|
codeEditor->addKeyBindingString( "ctrl+w", "close-doc", true );
|
|
codeEditor->addKeyBindingString( "ctrl+tab", "next-doc", true );
|
|
codeEditor->addKeyBindingString( "ctrl+shift+tab", "previous-doc", true );
|
|
codeEditor->addKeyBindingString( "ctrl+shift+l", "split-horizontal", true );
|
|
codeEditor->addKeyBindingString( "ctrl+shift+k", "split-vertical", true );
|
|
codeEditor->addEventListener( Event::OnFocus, [&]( const Event* event ) {
|
|
mCurEditor = event->getNode()->asType<UICodeEditor>();
|
|
updateEditorTitle( mCurEditor );
|
|
} );
|
|
codeEditor->addEventListener( Event::OnTextChanged, [&]( const Event* event ) {
|
|
updateEditorTitle( event->getNode()->asType<UICodeEditor>() );
|
|
} );
|
|
codeEditor->addEventListener( Event::OnSelectionChanged, [&]( const Event* event ) {
|
|
updateEditorTitle( event->getNode()->asType<UICodeEditor>() );
|
|
} );
|
|
if ( NULL == mCurEditor ) {
|
|
mCurEditor = codeEditor;
|
|
}
|
|
return codeEditor;
|
|
}
|
|
|
|
std::string App::titleFromEditor( UICodeEditor* editor ) {
|
|
std::string title( editor->getDocument().getFilename() );
|
|
return editor->getDocument().isDirty() ? title + "*" : title;
|
|
}
|
|
|
|
void App::updateEditorTitle( UICodeEditor* editor ) {
|
|
std::string title( titleFromEditor( editor ) );
|
|
if ( editor->getData() ) {
|
|
UITab* tab = (UITab*)editor->getData();
|
|
tab->setText( title );
|
|
}
|
|
setAppTitle( title );
|
|
}
|
|
|
|
std::pair<UITab*, UICodeEditor*> App::createCodeEditorInTabWidget( UITabWidget* tabWidget ) {
|
|
if ( NULL == tabWidget )
|
|
return std::make_pair( (UITab*)NULL, (UICodeEditor*)NULL );
|
|
UICodeEditor* editor = createCodeEditor();
|
|
UITab* tab = tabWidget->add( editor->getDocument().getFilename(), editor );
|
|
editor->setData( (UintPtr)tab );
|
|
tabWidget->addEventListener( Event::OnTabClosed, [&]( const Event* event ) {
|
|
const TabEvent* tabEvent = static_cast<const TabEvent*>( event );
|
|
if ( tabEvent->getTab()->getOwnedWidget() == mCurEditor ) {
|
|
mCurEditor = NULL;
|
|
}
|
|
UITabWidget* tabWidget = tabEvent->getTab()->getTabWidget();
|
|
if ( tabWidget->getTabCount() == 0 ) {
|
|
auto d = createCodeEditorInTabWidget( tabWidget );
|
|
d.first->getTabWidget()->setTabSelected( d.first );
|
|
d.second->setFocus();
|
|
}
|
|
} );
|
|
return std::make_pair( tab, editor );
|
|
}
|
|
|
|
UITabWidget* App::createEditorWithTabWidget( UISplitter* splitter ) {
|
|
UITabWidget* tabWidget = UITabWidget::New();
|
|
tabWidget->setParent( splitter );
|
|
tabWidget->setTabsClosable( true );
|
|
tabWidget->addEventListener( Event::OnTabSelected, [&]( const Event* event ) {
|
|
UITabWidget* tabWidget = event->getNode()->asType<UITabWidget>();
|
|
mCurEditor = tabWidget->getSelectedTab()->getOwnedWidget()->asType<UICodeEditor>();
|
|
updateEditorTitle( mCurEditor );
|
|
mCurEditor->setFocus();
|
|
} );
|
|
createCodeEditorInTabWidget( tabWidget );
|
|
return tabWidget;
|
|
}
|
|
|
|
UISplitter* App::createEditorWithSplitter( Node* parent ) {
|
|
if ( NULL == parent )
|
|
return NULL;
|
|
UISplitter* splitter = UISplitter::New();
|
|
splitter->setLayoutSizePolicy( SizePolicy::MatchParent, SizePolicy::MatchParent );
|
|
splitter->setParent( parent );
|
|
auto d = createEditorWithTabWidget( splitter );
|
|
d->getSelectedTab()->getOwnedWidget()->setFocus();
|
|
return splitter;
|
|
}
|
|
|
|
UITabWidget* App::tabWidgetFromEditor( UICodeEditor* editor ) {
|
|
if ( editor )
|
|
return ( (UITab*)editor->getData() )->getTabWidget();
|
|
return NULL;
|
|
}
|
|
|
|
void App::setAppTitle( const std::string& title ) {
|
|
mWindow->setTitle( mWindowTitle + String( title.empty() ? "" : " - " + title ) );
|
|
}
|
|
|
|
void App::loadFileFromPath( const std::string& path, UICodeEditor* codeEditor ) {
|
|
if ( NULL == codeEditor )
|
|
codeEditor = mCurEditor;
|
|
codeEditor->loadFromFile( path );
|
|
updateEditorTitle( codeEditor );
|
|
}
|
|
|
|
void App::openFileDialog() {
|
|
UICommonDialog* TGDialog = UICommonDialog::New( UI_CDL_DEFAULT_FLAGS, "*" );
|
|
TGDialog->setWinFlags( UI_WIN_DEFAULT_FLAGS | UI_WIN_MAXIMIZE_BUTTON | UI_WIN_MODAL );
|
|
TGDialog->setTitle( "Open layout..." );
|
|
TGDialog->setCloseWithKey( KEY_ESCAPE );
|
|
TGDialog->addEventListener( Event::OpenFile, [&]( const Event* event ) {
|
|
auto d = createCodeEditorInTabWidget( tabWidgetFromEditor( mCurEditor ) );
|
|
UITabWidget* tabWidget = d.first->getTabWidget();
|
|
UITab* addedTab = d.first;
|
|
loadFileFromPath( event->getNode()->asType<UICommonDialog>()->getFullPath(), d.second );
|
|
tabWidget->setTabSelected( addedTab );
|
|
UITab* firstTab = tabWidget->getTab( 0 );
|
|
if ( addedTab != firstTab ) {
|
|
UICodeEditor* editor = (UICodeEditor*)firstTab->getOwnedWidget();
|
|
if ( editor->getDocument().isEmpty() ) {
|
|
tabWidget->removeTab( firstTab );
|
|
}
|
|
}
|
|
} );
|
|
TGDialog->addEventListener( Event::OnWindowClose, [&]( const Event* ) {
|
|
if ( mCurEditor )
|
|
mCurEditor->setFocus();
|
|
} );
|
|
TGDialog->center();
|
|
TGDialog->show();
|
|
}
|
|
|
|
void App::findText( String text ) {
|
|
if ( text.empty() )
|
|
text = mLastSearch;
|
|
if ( text.empty() )
|
|
return;
|
|
mLastSearch = text;
|
|
TextDocument& doc = mCurEditor->getDocument();
|
|
TextPosition found = doc.find( text, doc.getSelection( true ).end() );
|
|
if ( found.isValid() ) {
|
|
doc.setSelection( {{found.line(), found.column() + (Int64)text.size()}, found} );
|
|
} else {
|
|
found = doc.find( text, {0, 0} );
|
|
if ( found.isValid() ) {
|
|
doc.setSelection( {{found.line(), found.column() + (Int64)text.size()}, found} );
|
|
}
|
|
}
|
|
}
|
|
|
|
void App::findTextMessageBox() {
|
|
UIMessageBox* inputSearch = UIMessageBox::New( UIMessageBox::INPUT, "Find text..." );
|
|
inputSearch->getTextInput()->setHint( "Find text..." );
|
|
String text = mCurEditor->getDocument().getSelectedText();
|
|
if ( !text.empty() )
|
|
inputSearch->getTextInput()->setText( text );
|
|
inputSearch->setCloseWithKey( KEY_ESCAPE );
|
|
inputSearch->addEventListener( Event::MsgBoxConfirmClick, [&]( const Event* event ) {
|
|
findText( event->getNode()->asType<UIMessageBox>()->getTextInput()->getText() );
|
|
} );
|
|
inputSearch->addEventListener( Event::OnClose,
|
|
[&]( const Event* ) { mCurEditor->setFocus(); } );
|
|
inputSearch->setTitle( "Find" );
|
|
inputSearch->getButtonOK()->setText( "Search" );
|
|
inputSearch->center();
|
|
inputSearch->show();
|
|
}
|
|
|
|
void App::closeApp() {
|
|
if ( NULL == mMsgBox && onCloseRequestCallback( mWindow ) ) {
|
|
mWindow->close();
|
|
}
|
|
}
|
|
|
|
void App::mainLoop() {
|
|
Input* input = mWindow->getInput();
|
|
|
|
input->update();
|
|
|
|
if ( input->isKeyUp( KEY_F6 ) ) {
|
|
mUISceneNode->setHighlightFocus( !mUISceneNode->getHighlightFocus() );
|
|
mUISceneNode->setHighlightOver( !mUISceneNode->getHighlightOver() );
|
|
}
|
|
|
|
if ( input->isKeyUp( KEY_F7 ) ) {
|
|
mUISceneNode->setDrawBoxes( !mUISceneNode->getDrawBoxes() );
|
|
}
|
|
|
|
if ( input->isKeyUp( KEY_F8 ) ) {
|
|
mUISceneNode->setDrawDebugData( !mUISceneNode->getDrawDebugData() );
|
|
}
|
|
|
|
SceneManager::instance()->update();
|
|
|
|
if ( SceneManager::instance()->getUISceneNode()->invalidated() || mConsole->isActive() ||
|
|
mConsole->isFading() ) {
|
|
mWindow->clear();
|
|
SceneManager::instance()->draw();
|
|
mConsole->draw();
|
|
mWindow->display();
|
|
} else {
|
|
Sys::sleep( Milliseconds( mWindow->isVisible() ? 1 : 16 ) );
|
|
}
|
|
}
|
|
|
|
void App::onFileDropped( String file ) {
|
|
Vector2f mousePos( mUISceneNode->getEventDispatcher()->getMousePosf() );
|
|
Node* node = mUISceneNode->overFind( mousePos );
|
|
UICodeEditor* codeEditor = mCurEditor;
|
|
if ( node->isType( UI_TYPE_CODEEDITOR ) ) {
|
|
codeEditor = node->asType<UICodeEditor>();
|
|
if ( !codeEditor->getDocument().isEmpty() ) {
|
|
auto d = createCodeEditorInTabWidget( tabWidgetFromEditor( codeEditor ) );
|
|
codeEditor = d.second;
|
|
d.first->getTabWidget()->setTabSelected( d.first );
|
|
}
|
|
}
|
|
loadFileFromPath( file, codeEditor );
|
|
}
|
|
|
|
void App::onTextDropped( String text ) {
|
|
Vector2f mousePos( mUISceneNode->getEventDispatcher()->getMousePosf() );
|
|
Node* node = mUISceneNode->overFind( mousePos );
|
|
UICodeEditor* codeEditor = mCurEditor;
|
|
if ( node->isType( UI_TYPE_CODEEDITOR ) )
|
|
codeEditor = node->asType<UICodeEditor>();
|
|
if ( codeEditor && !text.empty() ) {
|
|
if ( text[text.size() - 1] != '\n' )
|
|
text += '\n';
|
|
codeEditor->getDocument().textInput( text );
|
|
}
|
|
}
|
|
|
|
App::~App() {
|
|
eeSAFE_DELETE( mConsole );
|
|
}
|
|
|
|
void App::init( const std::string& file ) {
|
|
DisplayManager* displayManager = Engine::instance()->getDisplayManager();
|
|
Display* currentDisplay = displayManager->getDisplayIndex( 0 );
|
|
Float pixelDensity = currentDisplay->getPixelDensity();
|
|
|
|
displayManager->enableScreenSaver();
|
|
displayManager->enableMouseFocusClickThrough();
|
|
|
|
std::string resPath( Sys::getProcessPath() );
|
|
|
|
mWindow = Engine::instance()->createWindow(
|
|
WindowSettings( 1280, 720, mWindowTitle, WindowStyle::Default, WindowBackend::Default, 32,
|
|
resPath + "assets/icon/ee.png", pixelDensity ),
|
|
ContextSettings( true ) );
|
|
|
|
if ( mWindow->isOpen() ) {
|
|
mWindow->setCloseRequestCallback(
|
|
[&]( auto* win ) -> bool { return onCloseRequestCallback( win ); } );
|
|
|
|
mWindow->getInput()->pushCallback( [&]( InputEvent* event ) {
|
|
if ( event->Type == InputEvent::FileDropped ) {
|
|
onFileDropped( event->file.file );
|
|
} else if ( event->Type == InputEvent::TextDropped ) {
|
|
onTextDropped( event->textdrop.text );
|
|
}
|
|
} );
|
|
|
|
PixelDensity::setPixelDensity( eemax( mWindow->getScale(), pixelDensity ) );
|
|
|
|
mUISceneNode = UISceneNode::New();
|
|
|
|
mUISceneNode->getUIThemeManager()->setDefaultFont( FontTrueType::New(
|
|
"NotoSans-Regular", resPath + "assets/fonts/NotoSans-Regular.ttf" ) );
|
|
|
|
Font* fontMono =
|
|
FontTrueType::New( "monospace", resPath + "assets/fonts/DejaVuSansMono.ttf" );
|
|
|
|
SceneManager::instance()->add( mUISceneNode );
|
|
|
|
StyleSheetParser cssParser;
|
|
if ( cssParser.loadFromFile( resPath + "assets/ui/breeze.css" ) ) {
|
|
mUISceneNode->setStyleSheet( cssParser.getStyleSheet() );
|
|
}
|
|
|
|
mUISceneNode->getRoot()->addClass( "appbackground" );
|
|
|
|
mBaseLayout = UILinearLayout::NewVertical();
|
|
mBaseLayout->setLayoutSizePolicy( SizePolicy::MatchParent, SizePolicy::MatchParent );
|
|
UISplitter* splitter = UISplitter::New();
|
|
splitter->setLayoutSizePolicy( SizePolicy::MatchParent, SizePolicy::MatchParent );
|
|
splitter->setParent( mBaseLayout );
|
|
|
|
createEditorWithSplitter( splitter );
|
|
|
|
if ( !file.empty() ) {
|
|
loadFileFromPath( file );
|
|
}
|
|
|
|
mConsole = eeNew( Console, ( fontMono, true, true, 1024 * 1000, 0, mWindow ) );
|
|
|
|
mWindow->runMainLoop( &appLoop );
|
|
}
|
|
}
|
|
|
|
EE_MAIN_FUNC int main( int argc, char* argv[] ) {
|
|
args::ArgumentParser parser( "eepp Code Editor" );
|
|
args::Positional<std::string> file( parser, "file", "The file path" );
|
|
|
|
try {
|
|
parser.ParseCLI( argc, argv );
|
|
} catch ( const args::Help& ) {
|
|
std::cout << parser;
|
|
return EXIT_SUCCESS;
|
|
} catch ( const args::ParseError& e ) {
|
|
std::cerr << e.what() << std::endl;
|
|
std::cerr << parser;
|
|
return EXIT_FAILURE;
|
|
} catch ( args::ValidationError& e ) {
|
|
std::cerr << e.what() << std::endl;
|
|
std::cerr << parser;
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
appInstance = eeNew( App, () );
|
|
appInstance->init( file.Get() );
|
|
eeSAFE_DELETE( appInstance );
|
|
|
|
Engine::destroySingleton();
|
|
MemoryManager::showResults();
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|