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
2016-12-14 13:33:17 +01:00
parent 68a2cb08bc
commit 5482e56e82
191 changed files with 279 additions and 241 deletions
@@ -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