build: deploy changes
* moved sample projects from data to user folder * added fallback files for app and window settings * implemented copying app and window settings to user folder when not found on app startup * fixed upgrading for windows installer
This commit is contained in:
malte_langkabel
@@ -0,0 +1,35 @@
|
||||
#ifndef CODE_TUTORIAL_1_H
|
||||
#define CODE_TUTORIAL_1_H
|
||||
|
||||
|
||||
|
||||
#include "utility.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 1 - THE CODE TUTORIAL
|
||||
// As you already know the Code View displays the snippets of code that are
|
||||
// related to your currently active symbol. These snippets show the relevant
|
||||
// lines in combination with some context.
|
||||
// In case you discover something interesting as part of the snippet's context
|
||||
// you can activate that symbol with a left-click. That way you dig deeper
|
||||
// through your code base.
|
||||
// Have you ever wondered what's the meaning of life, the universe and
|
||||
// everything? Click the respective symbol to find out.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
class CodeTutorial
|
||||
{
|
||||
public:
|
||||
CodeTutorial()
|
||||
{
|
||||
}
|
||||
|
||||
static int meaning_of_life_the_universe_and_everything;
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // CODE_TUTORIAL_1_H
|
||||
|
||||
@@ -0,0 +1,65 @@
|
||||
#ifndef CODE_TUTORIAL_2_H
|
||||
#define CODE_TUTORIAL_2_H
|
||||
|
||||
|
||||
|
||||
#include "code_tutorial_1.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 5 - NO MORE CONTEXT
|
||||
// At this stage you see the entire file and no more context can be expanded.
|
||||
// For the final part of this introduction please have a look at where the
|
||||
// "unrelated_but_very_important()" function is used.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
void unrelated_but_very_important()
|
||||
{
|
||||
};
|
||||
|
||||
|
||||
int calculate(int (*problem)())
|
||||
{
|
||||
return problem();
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 4 - MORE CONTEXT
|
||||
// Who would have expected such a simple question?
|
||||
// Note that expanding the view didn't change the active symbol. You can
|
||||
// proceed expanding the view until you hit the level of the file scope.
|
||||
// So go ahead and find out what else is hidden inside this file!
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
void deep_thought()
|
||||
{
|
||||
int (*the_question)() = [](){ return 6 * 7; };
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 2 - CONTEXT
|
||||
// We just talked about Coati providing context to the important lines of code.
|
||||
// But it feels like something is missing here. What is "the_question"? And
|
||||
// where does it come from?
|
||||
//
|
||||
// 3 - EXPANDING TO SCOPES
|
||||
// Do you see the first line of this snippet? I mean the one that has just two
|
||||
// dots as line number and reads "deep_thought". Actually that's the name of
|
||||
// the function's scope that encapsulates the snippet. By clicking that line
|
||||
// you can tell Coati to expand the view to show the entire scope.
|
||||
// Give it a try!
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
int the_answer = calculate(the_question);
|
||||
CodeTutorial::meaning_of_life_the_universe_and_everything = the_answer;
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif // CODE_TUTORIAL_2_H
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
#ifndef CODE_TUTORIAL_3_H
|
||||
#define CODE_TUTORIAL_3_H
|
||||
|
||||
|
||||
|
||||
#include "the_central_hub.h"
|
||||
#include "code_tutorial_2.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 6 - SNIPPETS AND FILES
|
||||
// It looks like this function is called in two different places inside the
|
||||
// same file. When two different snippets are located in the same file they
|
||||
// share a single file box. The line numbers to the left indicate where each of
|
||||
// these snippets is located inside the file.
|
||||
//
|
||||
// 7 - MERGING SNIPPETS
|
||||
// The top line of each snippet shows the name of its own parent's scope.
|
||||
// If you want to show the lines in between the two snippets below you can
|
||||
// either expand the upper snippet's scope to show the whole file or you can
|
||||
// tell the lower snippet to reveal its scope.
|
||||
// Try one of these approaches now.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
void function_with_snippets()
|
||||
{
|
||||
unrelated_but_very_important();
|
||||
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 8 - YOU FOUND THE HIDDEN COMMENT
|
||||
// Well done! As you see Coati merged the two snippets from before because
|
||||
// expanding a scope would have caused them to overlap. That's all for the code
|
||||
// view tutorial.
|
||||
//
|
||||
// 9 - EDIT YOUR CODE
|
||||
// In case you wondered if you can edit your code using Coati: You can't. Coati
|
||||
// is designed for code exploration, not as a text editor or an IDE. But there
|
||||
// is a chance that Coati can talk to your favorite editor (that you already
|
||||
// know how to operate) via plugin. For more information about available
|
||||
// plugins please take a look at Coati's documentation.
|
||||
//
|
||||
// We hope you enjoyed this tutorial. You can follow the call below to get back
|
||||
// to the central hub.
|
||||
//
|
||||
// P.S.
|
||||
// You can also click the file name above (i guess you need to scroll up a
|
||||
// little bit) to activate the file's node in case you want to explore your
|
||||
// include hierarchy.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
the_central_hub();
|
||||
|
||||
|
||||
|
||||
unrelated_but_very_important();
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // CODE_TUTORIAL_3_H
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
#ifndef GRAPH_TUTORIAL_1_H
|
||||
#define GRAPH_TUTORIAL_1_H
|
||||
|
||||
|
||||
|
||||
#include "utility.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 1 - THE GRAPH TUTORIAL
|
||||
// In Coati's default window layout the graph is shown to the left, next to the
|
||||
// code. It displays the structure of your project where all named symbols are
|
||||
// nodes and all relations are edges. Like the code view it shows only the
|
||||
// currently active symbol and all the incoming and outgoing dependencies.
|
||||
//
|
||||
// 2 - HOW DO I NAVIGATE THE GRAPH
|
||||
// You can activate a new symbol by left-clicking on the node you are
|
||||
// interested in. For example: to find out where the function
|
||||
// "where_am_i_called()" is called get over to the graph and click that
|
||||
// function's node.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
class GraphTutorial
|
||||
{
|
||||
public:
|
||||
GraphTutorial()
|
||||
{
|
||||
}
|
||||
|
||||
static void where_am_i_called()
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // GRAPH_TUTORIAL_1_H
|
||||
|
||||
@@ -0,0 +1,68 @@
|
||||
#ifndef GRAPH_TUTORIAL_2_H
|
||||
#define GRAPH_TUTORIAL_2_H
|
||||
|
||||
|
||||
|
||||
#include "graph_tutorial_1.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 3 - WELL DONE
|
||||
// You activated a node and both, the graph and the code view have been updated
|
||||
// accordingly.
|
||||
// Note that even though Coati provides a graph view it does not remove the
|
||||
// need for reading code. The graph view is great for gaining a quick overview
|
||||
// on relations and navigating code, but once you found something you are
|
||||
// interested in you should still consider the code view to actually read up on
|
||||
// all the important details.
|
||||
//
|
||||
// 4 - HIDDEN ELEMENTS
|
||||
// In order not to flood you with information the graph is hiding a lot of
|
||||
// elements. Do you see the "ClassWithHiddenMembers" for example? It actually
|
||||
// contains more members than you currently see. Members that are not important
|
||||
// for the current context are hidden. Nevertheless you can reveal them by
|
||||
// clicking the arrow next the the class name. Try that now and read those
|
||||
// members' names.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
class ClassWithHiddenMembers
|
||||
{
|
||||
public:
|
||||
void potential_caller()
|
||||
{
|
||||
GraphTutorial::where_am_i_called();
|
||||
}
|
||||
|
||||
void now_you_see_all_contents_of_this_class()
|
||||
{
|
||||
}
|
||||
|
||||
void coati_uses_different_colors()
|
||||
{
|
||||
}
|
||||
|
||||
void to_distinguish_between_functions()
|
||||
{
|
||||
}
|
||||
|
||||
int and_variables;
|
||||
|
||||
int to_continue_click;
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 5 - RELATIONS
|
||||
// As you see in the graph, this member is accessed at quite some places
|
||||
// throughout the code base. Lets say you wonder what code causes the edge
|
||||
// between "reading" and "this_last_member" to appear. What will happen if you
|
||||
// click the edge?
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
static int this_last_member;
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // GRAPH_TUTORIAL_2_H
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
#ifndef GRAPH_TUTORIAL_3_H
|
||||
#define GRAPH_TUTORIAL_3_H
|
||||
|
||||
|
||||
|
||||
#include "graph_tutorial_2.h"
|
||||
|
||||
class ProducerOfTheLastMember
|
||||
{
|
||||
public:
|
||||
void go()
|
||||
{
|
||||
ClassWithHiddenMembers::this_last_member = 42;
|
||||
}
|
||||
|
||||
void on()
|
||||
{
|
||||
ClassWithHiddenMembers::this_last_member++;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 6 - FOCUSING EDGES
|
||||
// Even though Coati doesn't allow to activate an edge, you can still focus on
|
||||
// edges. This doesn't change the currently active symbol (which would cause
|
||||
// Coati to hide everything but the edge). Instead Coati just highlights the
|
||||
// relation's location in the code and scrolls you there, so you don't lose
|
||||
// context.
|
||||
// Try to activate an edge that comes from the "ConsumerOfTheLastMember" class.
|
||||
// Which one you pick doesn't really matter for this tutorial.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
void reading()
|
||||
{
|
||||
ClassWithHiddenMembers::this_last_member *= 2;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // GRAPH_TUTORIAL_3_H
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
#ifndef GRAPH_TUTORIAL_4_H
|
||||
#define GRAPH_TUTORIAL_4_H
|
||||
|
||||
|
||||
|
||||
#include "graph_tutorial_2.h"
|
||||
#include "the_central_hub.h"
|
||||
|
||||
class ConsumerOfTheLastMember
|
||||
{
|
||||
public:
|
||||
void in()
|
||||
{
|
||||
ClassWithHiddenMembers::this_last_member--;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 7 - THAT'S IT
|
||||
// You completed the tutorial on the graph view. There is still more to learn
|
||||
// but I guess you will figure it out on your own. One last thing: If you see
|
||||
// an element with a hatched background please call us. It's a runaway!
|
||||
// Just kidding. Those are elements that are used within your code, but have no
|
||||
// definition anywhere in your source folder (like the "int" symbol on the
|
||||
// right hand side of the graph). So if you click them, Coati will display
|
||||
// all the relations for the element, but the code view won't show a
|
||||
// definition. If you want to learn more about Coati, go back to the central
|
||||
// hub. It is called in the function below but you can also try to get there
|
||||
// using only the graph.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
private:
|
||||
void the()
|
||||
{
|
||||
if (ClassWithHiddenMembers::this_last_member <= 0);
|
||||
{
|
||||
the_central_hub();
|
||||
}
|
||||
}
|
||||
|
||||
void codeview()
|
||||
{
|
||||
ClassWithHiddenMembers::this_last_member /= 2;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // GRAPH_TUTORIAL_4_H
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
#ifndef MAIN_H
|
||||
#define MAIN_H
|
||||
|
||||
|
||||
|
||||
#include "code_tutorial_1.h"
|
||||
#include "code_tutorial_2.h"
|
||||
#include "code_tutorial_3.h"
|
||||
#include "graph_tutorial_1.h"
|
||||
#include "graph_tutorial_2.h"
|
||||
#include "graph_tutorial_3.h"
|
||||
#include "graph_tutorial_4.h"
|
||||
#include "search_tutorial_1.h"
|
||||
#include "search_tutorial_2.h"
|
||||
#include "search_tutorial_3.h"
|
||||
#include "search_tutorial_4.h"
|
||||
#include "search_tutorial_5.h"
|
||||
|
||||
#include "my_first_step.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// WHAT IS THIS?
|
||||
// Now the Code View finally shows some real code of the tutorial project.
|
||||
// And who could think of a better place to start a tutorial that involves
|
||||
// code than a main function?
|
||||
//
|
||||
// WHAT CAN I DO NOW?
|
||||
// Left-click the "my_first_step()" function call inside the main function.
|
||||
// Lets see what happens.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
int main()
|
||||
{
|
||||
my_first_step();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif // MAIN_H
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
#ifndef MY_FIRST_STEP_H
|
||||
#define MY_FIRST_STEP_H
|
||||
|
||||
|
||||
|
||||
#include "my_next_step.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// WHAT JUST HAPPENED?
|
||||
// Coati uses the concept of an "active" symbol. You just changed the active
|
||||
// symbol by clicking on the name of a function.
|
||||
//
|
||||
// OK, BUT WHAT IS AN ACTIVE SYMBOL?
|
||||
// Coati doesn't show your entire code base on a single screen. Even for
|
||||
// relatively small projects that would be pointless - trust me on that. So
|
||||
// instead of showing everything at once, Coati keeps a strongly focused view
|
||||
// on your code. This focus only includes the currently active symbol and its
|
||||
// direct relations. Nothing more. By changing the active symbol as you just
|
||||
// did, Coati allows you to jump through the code base on your own.
|
||||
//
|
||||
// I THINK I GOT IT!
|
||||
// Now that you understand Coati's central concept you are ready to activate
|
||||
// the "my_next_step()" symbol below.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
void my_first_step()
|
||||
{
|
||||
my_next_step(2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif // MY_FIRST_STEP_H
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
#ifndef MY_NEXT_STEP_H
|
||||
#define MY_NEXT_STEP_H
|
||||
|
||||
|
||||
|
||||
#include "the_central_hub.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// ANYTING ELSE I SHOULD KNOW?
|
||||
// I'm glad that you asked. Take a look at the code below. You will notice two
|
||||
// different highlights when hovering different symbols in that snippet. One
|
||||
// is used for symbols that may be used everywhere throughout your code base
|
||||
// while the other one is used to quickly highlight references to local
|
||||
// symbols (like "foo" and "bar").
|
||||
//
|
||||
// MORE ON LOCAL SYMBOLS
|
||||
// These local symbols aren't covered by this tutorial. So don't you dare
|
||||
// clicking them! Just kidding. Even though this tutorial doesn't make
|
||||
// extensive use of local symbols these highlights prove really useful when
|
||||
// inspecting a real code project.
|
||||
//
|
||||
// THAT'S ALL FOR NOW
|
||||
// Your preliminary training is complete. You may proceed to
|
||||
// "the_central_hub()" of this tutorial.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
int my_next_step(int foo)
|
||||
{
|
||||
the_central_hub();
|
||||
|
||||
int bar = 2 * foo;
|
||||
|
||||
return bar;
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif // MY_NEXT_STEP_H
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
#ifndef SEARCH_TUTORIAL_1_H
|
||||
#define SEARCH_TUTORIAL_1_H
|
||||
|
||||
|
||||
|
||||
#include "utility.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 1 - THE SEARCH TUTORIAL
|
||||
// If you haven't messed up anything yet, you'll find the search bar to the
|
||||
// upper left of Coati's user interface. Initially it shows the name of the
|
||||
// currently active symbol.
|
||||
// Use the shortcut "CTRL/CMD + F" to focus the search bar. You can also just
|
||||
// click it. Try that now and enter the string "find_me_if_you_can" to search
|
||||
// for the respective symbol. Press enter or click the magnification glass to
|
||||
// execute the search.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
class SearchTutorial
|
||||
{
|
||||
public:
|
||||
SearchTutorial()
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // SEARCH_TUTORIAL_1_H
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
#ifndef SEARCH_TUTORIAL_2_H
|
||||
#define SEARCH_TUTORIAL_2_H
|
||||
|
||||
|
||||
|
||||
#include "utility.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 2 - THE AUTOCOMPLETION
|
||||
// I hope you have been lazy enough to not enter the whole string from start to
|
||||
// finish. So you already noticed Coati's autocompletion box.
|
||||
// While you enter your search request Coati already tries to find a subset of
|
||||
// matching symbols to help you get where you want pretty fast.
|
||||
// But that's not all Coati does. Keep an eye on the search bar while entering
|
||||
// the string "aux" and activate the symbol showing up.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
void find_me_if_you_can()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif // SEARCH_TUTORIAL_2_H
|
||||
|
||||
@@ -0,0 +1,28 @@
|
||||
#ifndef SEARCH_TUTORIAL_3_H
|
||||
#define SEARCH_TUTORIAL_3_H
|
||||
|
||||
|
||||
|
||||
#include "utility.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 3 - FUZZY MATCHING
|
||||
// While looking for matching symbols the search bar does not only consider
|
||||
// strict matches to the entered substring. Instead it uses a more fuzzy
|
||||
// approach. This is really helpful when you only have a rough idea of what the
|
||||
// element you are really looking for is called.
|
||||
// While showing the list of results the autocompletion also display the kind
|
||||
// of each of the results to the very right.
|
||||
// Try to activate the class with the name "NameConflict" next.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
void autocompletion_example()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif // SEARCH_TUTORIAL_3_H
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
#ifndef SEARCH_TUTORIAL_4_H
|
||||
#define SEARCH_TUTORIAL_4_H
|
||||
|
||||
|
||||
|
||||
#include "utility.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 4 - WHAT ARE THE OTHER BUTTONS?
|
||||
// Well done. Lets get over the other buttons left to the search bar really
|
||||
// quick.
|
||||
//
|
||||
// 5 - FORWARD AND BACKWARD
|
||||
// You can use the buttons to the very left to go forward and backward, like
|
||||
// in a web browser. They really come in handy in case you ask yourself
|
||||
// something like "How did I end up here?"
|
||||
//
|
||||
// 6 - REFRESH
|
||||
// The next button allows you to refresh the project in case you changed some
|
||||
// of your code.
|
||||
//
|
||||
// 7 - HOME
|
||||
// This last button takes you back to the initial overview screen.
|
||||
//
|
||||
// 8 - WHAT'S NEXT?
|
||||
// Instead of the class activate the struct with the same name as before.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
namespace a
|
||||
{
|
||||
class NameConflict
|
||||
{
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif // SEARCH_TUTORIAL_4_H
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
#ifndef SEARCH_TUTORIAL_5_H
|
||||
#define SEARCH_TUTORIAL_5_H
|
||||
|
||||
|
||||
|
||||
#include "utility.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// 9 - CONGRATULATONS
|
||||
// You have completed the challenge of search.
|
||||
// Oh, I almost forgot: You can only find nodes such as symbols via the search
|
||||
// bar. It doesn't allow you to find edges like calls or inheritance. At least
|
||||
// not yet.
|
||||
// Try to get back to the the central hub using the search bar!
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
namespace b
|
||||
{
|
||||
struct NameConflict
|
||||
{
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif // SEARCH_TUTORIAL_5_H
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
#ifndef START_EXPLORING_H
|
||||
#define START_EXPLORING_H
|
||||
|
||||
|
||||
|
||||
#include "utility.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// FURTHER EXPLORATION
|
||||
// If you completed all the other tutorials you might want to put your new
|
||||
// skills to use and do some exploration on your own.
|
||||
// Here comes the bad news: Even though this tutorial contains some code that
|
||||
// would compile, the code doesn't make much sense. So trying to explore this
|
||||
// project any further would be rather unproductive.
|
||||
// The good news is: In addition to this tutorial Coati also ships with a real
|
||||
// example project that implements the game Tic-Tac-Toe! You can open the
|
||||
// project via the "Project -> Recent Projects" menu.
|
||||
// You can also start exploring your own projects by creating a new Coati
|
||||
// project where you can add all your source and include paths.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
class StartExploring
|
||||
{
|
||||
public:
|
||||
StartExploring()
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // START_EXPLORING_H
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
#ifndef THE_CENTRAL_HUB_H
|
||||
#define THE_CENTRAL_HUB_H
|
||||
|
||||
|
||||
|
||||
#include "search_tutorial_1.h"
|
||||
#include "graph_tutorial_1.h"
|
||||
#include "code_tutorial_1.h"
|
||||
#include "start_exploring.h"
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// THE HUB
|
||||
// This is the central hub of Coati's tutorial. From here you can embark on
|
||||
// short trips to explore the different parts of Coati. Most important: You
|
||||
// will get to know how all the different parts of Coati interact.
|
||||
// The function below references all the available tutorials. So pick one and
|
||||
// jump right to action.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
void the_central_hub()
|
||||
{
|
||||
SearchTutorial* the_challenge_of_search;
|
||||
GraphTutorial* reading_the_map;
|
||||
CodeTutorial* explore_the_details;
|
||||
|
||||
StartExploring* going_beyond_this_tutorial;
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif // THE_CENTRAL_HUB_H
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
#ifndef UTILITY_H
|
||||
#define UTILITY_H
|
||||
|
||||
|
||||
|
||||
typedef unsigned int uint;
|
||||
|
||||
|
||||
|
||||
#endif // UTILITY_H
|
||||
@@ -0,0 +1,34 @@
|
||||
<?xml version="1.0" encoding="utf-8" ?>
|
||||
<config>
|
||||
<info>
|
||||
<description>
|
||||
WHAT IS THIS?\n
|
||||
\tThis is a tutorial and it is one of the fastest ways to get to know Coati.\n
|
||||
\n
|
||||
WHERE AM I?\n
|
||||
\tYou're looking at Coati's Code View which usually displays source code,\n
|
||||
\tbut every time a new project is loaded it gives a quick summary to\n
|
||||
\testimate the project's size. This is a fairly small project. It only\n
|
||||
\tcontains a few hundred lines of code as you can see by the numbers below.\n
|
||||
\n
|
||||
LET'S GET STARTED!\n
|
||||
\tTo keep things simple just click the "main" symbol below to start the tour.\n
|
||||
\n
|
||||
[main\tsint\tp()](); // <- start here\n\n
|
||||
</description>
|
||||
</info>
|
||||
<language_settings>
|
||||
<language>C++</language>
|
||||
<standard>c++1z</standard>
|
||||
</language_settings>
|
||||
<source>
|
||||
<extensions>
|
||||
<header_extensions>.h</header_extensions>
|
||||
<source_extensions>.cpp</source_extensions>
|
||||
</extensions>
|
||||
<source_paths>
|
||||
<source_path>./src</source_path>
|
||||
</source_paths>
|
||||
</source>
|
||||
<version>1</version>
|
||||
</config>
|
||||
Reference in New Issue
Block a user