diff --git a/docs/CSS.md b/docs/CSS.md
index 4ac3d9eebf5..a4f9d491845 100644
--- a/docs/CSS.md
+++ b/docs/CSS.md
@@ -106,7 +106,7 @@ They also show pseudo selectors which can be used to choose styling based on wid
 | setMaximized(boolean) | swt-maximized | CTabFolder { swt-maximized: true } |
 | setMinimized(boolean) | swt-minimized | CTabFolder { swt-minimized: true } |
 | setMaximizeVisible(boolean) | swt-maximize-visible | CTabFolder { swt-maximize-visible: true } |
-| setMinimizeVisible(boolean) | swt-minimize-visible | CTabFolder {swt- minimize-visible: true } |
+| setMinimizeVisible(boolean) | swt-minimize-visible | CTabFolder {swt-minimize-visible: true } |
 | setMRUVisible(boolean) | swt-mru-visible | CTabFolder { swt-mru-visible: true } |
 | setSimple(boolean) | swt-simple | CTabFolder { swt-simple: true } |
 | setSingle(boolean) | swt-single | CTabFolder { swt-single: true } |
diff --git a/docs/Command_Core_Expressions.md b/docs/Command_Core_Expressions.md
index 1291e144441..5133241cf65 100644
--- a/docs/Command_Core_Expressions.md
+++ b/docs/Command_Core_Expressions.md
@@ -19,7 +19,7 @@ The <with/> element can be used to change which variable the child expression el
 Variables and the Command Framework
 ===================================
 
-The variables used for command framework evaluation are listed in [ISources.java](https://git.eclipse.org/c/platform/eclipse.platform.ui.git/tree/bundles/org.eclipse.ui.workbench/Eclipse%20UI/org/eclipse/ui/ISources.java)
+The variables used for command framework evaluation are listed in [ISources.java](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/bundles/org.eclipse.ui.workbench/eclipseui/org/eclipse/ui/ISources.java)
 
 Some of the variables may not be set, depending on the current application context when they are evaluated.
 
@@ -42,7 +42,7 @@ Some of the variables may not be set, depending on the current application conte
 | activeMenu | A `java.util.Collection` of `java.lang.String` |   This is the list of IDs of the showing context menu. Examples are like #TextEditorRuler or a part ID. Most commonly used with <iterate/>, <count/>, and <test/> with a combined `org.eclipse.common.expressions.PropertyTester`.   | 3.2 |
 | activeMenuSelection | `org.eclipse.jface.viewers.ISelection` |   This is a selection that is available while a context menu is showing. It is the selection from the selection provider used to register the context menu, usually from `getSite().registerContextMenu(*)`. It is usually the same as the `selection`variable, but not always. This is more for legacy compatibility.   | 3.3 |
 | activeMenuEditorInput | `org.eclipse.jface.viewers.ISelection` |   This is a selection that is available while a context menu is showing. It is the selection from the editor input, usually if includeEditorInput was set to `true` during `getEditorSite().registerContextMenu(*)`. This is more for legacy compatibility.   | 3.3 |
-| activeFocusControl | `org.eclipse.swt.widgets.Control` |   A control that has focus and has been registered with the [IFocusService](https://git.eclipse.org/c/platform/eclipse.platform.ui.git/tree/bundles/org.eclipse.ui.workbench/Eclipse%20UI/org/eclipse/ui/swt/IFocusService.java).   | 3.3 |
+| activeFocusControl | `org.eclipse.swt.widgets.Control` |   A control that has focus and has been registered with the [IFocusService](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/bundles/org.eclipse.ui.workbench/eclipseui/org/eclipse/ui/swt/IFocusService.java).   | 3.3 |
 | activeFocusControlId | `java.lang.String` |   The ID of a control that has focus and has been registered with the `org.eclipse.ui.swt.IFocusService`.   | 3.3 |
 
 Note: All these variables can be used with <test/> and a `org.eclipse.common.expressions.PropertyTester`.
@@ -60,13 +60,13 @@ For example, to test an IResource name the property would be `org.eclipse.core.r
 ||||
 | --- | --- | --- |
 | **Namespace** | **Type** | **Implementation** |
-| org.eclipse.core.runtime |   `org.eclipse.core.runtime.Platform`   |   [PlatformPropertyTester.java](https://git.eclipse.org/c/platform/eclipse.platform.runtime.git/tree/bundles/org.eclipse.core.expressions/src/org/eclipse/core/internal/expressions/propertytester/PlatformPropertyTester.java)   |
+| org.eclipse.core.runtime |   `org.eclipse.core.runtime.Platform`   |   [PlatformPropertyTester.java](https://github.com/eclipse-platform/eclipse.platform.runtime/blob/master/bundles/org.eclipse.core.expressions/src/org/eclipse/core/internal/expressions/propertytester/PlatformPropertyTester.java)   |
 | **Property** | **Description**| |
 |   product   |   Test the id of the currently active product.   ||
 |   isBundleInstalled   |   Test if a given bundle is installed in the running environment. Use the args attribute to pass in the bundle id.   ||
 |  |  |  |
 | **Namespace**| **Type**| **Implementation** |
-| org.eclipse.core.resources |   `org.eclipse.core.resources.IResource`   |   [ResourcePropertyTester.java](https://git.eclipse.org/c/platform/eclipse.platform.resources.git/tree/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/propertytester/ResourcePropertyTester.java)   |
+| org.eclipse.core.resources |   `org.eclipse.core.resources.IResource`   |   [ResourcePropertyTester.java](https://github.com/eclipse-platform/eclipse.platform.resources/blob/master/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/propertytester/ResourcePropertyTester.java)   |
 | **Property** | **Description** |  |
 |   name   |   A property indicating the file name (value `"name"`). "*" and "?" wild cards are supported.   |  |
 |   path   |   A property indicating the file path (value `"path"`). "*" and "?" wild cards are supported.   |  |
@@ -79,28 +79,28 @@ For example, to test an IResource name the property would be `org.eclipse.core.r
 |   projectSessionProperty   |   A property indicating a session property on the selected resource's project. (value `"projectSessionProperty"`). If two arguments are given, this treats the first as the property name, and the second as the expected property value. If only one argument (or just the expected value) is given, this treats it as the property name, and simply tests for existence of the property on the resource.   |  |
 |  |  |  |
 | **Namespace** | **Type** | **Implementation** |
-| org.eclipse.core.resources |   `org.eclipse.core.resources.IFile`   |   [FilePropertyTester.java](https://git.eclipse.org/c/platform/eclipse.platform.resources.git/tree/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/propertytester/FilePropertyTester.java)   |
+| org.eclipse.core.resources |   `org.eclipse.core.resources.IFile`   |   [FilePropertyTester.java](https://github.com/eclipse-platform/eclipse.platform.resources/blob/master/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/propertytester/FilePropertyTester.java)   |
 | **Property** | **Description** |  |
 |   contentTypeId   |   A property indicating that we are looking to verify that the file matches the content type matching the given identifier. The identifier is provided as the expected value.   |  |
 |  |  |  |
 | **Namespace** | **Type** | **Implementation** |
-| org.eclipse.core.resources |   `org.eclipse.core.resources.IProject`   |   [ProjectPropertyTester.java](https://git.eclipse.org/c/platform/eclipse.platform.resources.git/tree/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/propertytester/ProjectPropertyTester.java)   |
+| org.eclipse.core.resources |   `org.eclipse.core.resources.IProject`   |   [ProjectPropertyTester.java](https://github.com/eclipse-platform/eclipse.platform.resources/blob/master/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/propertytester/ProjectPropertyTester.java)   |
 | **Property**| **Description** |  |
 |   open   |   A property indicating whether the project is open (value `"open"`).   |  |
 |  |  |  |
 | **Namespace** | **Type** | **Implementation** |
-| org.eclipse.core.resources |   `org.eclipse.core.resources.mapping.ResourceMapping`   |   [ResourceMappingPropertyTester.java](https://git.eclipse.org/c/platform/eclipse.platform.resources.git/tree/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/propertytester/ResourceMappingPropertyTester.java)   |
+| org.eclipse.core.resources |   `org.eclipse.core.resources.mapping.ResourceMapping`   |   [ResourceMappingPropertyTester.java](https://github.com/eclipse-platform/eclipse.platform.resources/blob/master/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/propertytester/ResourceMappingPropertyTester.java)   |
 | **Property** | **Description** |  |
 |   projectPersistentProperty   |   A property indicating a persistent property on the selected resource's project. (value `"projectPersistentProperty"`). If two arguments are given, this treats the first as the property name, and the second as the expected property value. If only one argument (or just the expected value) is given, this treats it as the property name, and simply tests for existence of the property on the resource.   |  |
 |  |  |  |
 | **Namespace** | **Type** | **Implementation** |
-| org.eclipse.ui |   `org.eclipse.ui.IWorkbench`   |   [ActivityPropertyTester.java](https://git.eclipse.org/c/platform/eclipse.platform.ui.git/tree/bundles/org.eclipse.ui.workbench/Eclipse%20UI/org/eclipse/ui/internal/activities/ActivityPropertyTester.java)   |
+| org.eclipse.ui |   `org.eclipse.ui.IWorkbench`   |   [ActivityPropertyTester.java](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/bundles/org.eclipse.ui.workbench/eclipseui/org/eclipse/ui/internal/activities/ActivityPropertyTester.java)   |
 | **Property** | **Description** |  |
 |   isActivityEnabled   |   Test if the activity in args is enabled.   |  |
 |   isCategoryEnabled   |   Test if the category in args is enabled.   |  |
 |  |  |  |
 | **Namespace** | **Type** | **Implementation** |
-| org.eclipse.ui.workbenchWindow |   `org.eclipse.ui.IWorkbenchWindow`   |   [OpenPerspectivePropertyTester.java](https://git.eclipse.org/c/platform/eclipse.platform.ui.git/tree/bundles/org.eclipse.ui.workbench/Eclipse%20UI/org/eclipse/ui/internal/OpenPerspectivePropertyTester.java)   |
+| org.eclipse.ui.workbenchWindow |   `org.eclipse.ui.IWorkbenchWindow`   |   [OpenPerspectivePropertyTester.java](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/bundles/org.eclipse.ui.workbench/eclipseui/org/eclipse/ui/internal/OpenPerspectivePropertyTester.java)   |
 | **Property** | **Description** |  |
 |   isPerspectiveOpen   |   Tests if any perspective is open.   |  |
 
@@ -112,9 +112,9 @@ Here are some examples. I'll pretend all of the examples are deciding when a han
 Basic IStructuredSelection
 --------------------------
 
-A view provides a structured selection through its selection provider.
-An example would be the InfoView in **org.eclipse.ui.examples.contributions**.
-You can browse the [plugin.xml](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/tree/examples/org.eclipse.ui.examples.contributions/plugin.xml) and [InfoView.java](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/tree/examples/org.eclipse.ui.examples.contributions/src/org/eclipse/ui/examples/contributions/view/InfoView.java) files.
+A view provides a structured selection through its selection provider. 
+An example would be the InfoView in **org.eclipse.ui.examples.contributions**. 
+You can browse the [plugin.xml](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.ui.examples.contributions/plugin.xml) and [InfoView.java](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.ui.examples.contributions/src/org/eclipse/ui/examples/contributions/view/InfoView.java) files. 
 The InfoView provides an `IStructuredSelection` with 0 or more `org.eclipse.ui.examples.contributions.model.Person`.
 
 When using the default variable, you must treat it as an `java.util.Collection`.
diff --git a/docs/EclipsePluginDevelopmentFAQ.md b/docs/EclipsePluginDevelopmentFAQ.md
index ae56ff853b4..43f61e21e37 100644
--- a/docs/EclipsePluginDevelopmentFAQ.md
+++ b/docs/EclipsePluginDevelopmentFAQ.md
@@ -121,7 +121,7 @@ Also, Eclipse can handle jars within jars. It expands them into a temporary loca
 
 The articles below may be of your interest.
 
-*   [Adapters](http://www.eclipse.org/articles/article.php?file=Article-Adapters/index.html)
+*   [Adapters](https://www.eclipse.org/articles/article.php?file=Article-Adapters/index.html)
 
 ### How do I read from a file that I've included in my bundle/plug-in?
 
@@ -303,7 +303,7 @@ To leverage the workbench's browser capabilities, you will have to interact with
 ```java
     try {
         IWorkbenchBrowserSupport browserSupport = PlatformUI.getWorkbench().getBrowserSupport();
-        browserSupport.getExternalBrowser().openURL(new URL("http://www.eclipse.org"));
+        browserSupport.getExternalBrowser().openURL(new URL("https://www.eclipse.org"));
     } catch (PartInitException e) {
         // handle the exception
     }
diff --git a/docs/Eclipse_Corner.md b/docs/Eclipse_Corner.md
index 232c2aa7515..0233212331a 100644
--- a/docs/Eclipse_Corner.md
+++ b/docs/Eclipse_Corner.md
@@ -41,7 +41,7 @@ Custom Drawing Table and Tree Items
 
 Populating a table or tree widget involves creating items and setting their attributes (eg.- texts, images, etc.), after which the table or tree takes responsibility for displaying the items. This approach makes item creation straightforward and visually consistent. As of Eclipse 3.2, clients of Table and Tree can now custom draw their items, enabling a wide range of potential visual appearances. This article explores the custom draw mechanism for Table and Tree.
 
-*   [Custom Drawing Table and Tree Items](http://www.eclipse.org/articles/Article-CustomDrawingTableAndTreeItems/customDraw.htm)
+*   [Custom Drawing Table and Tree Items](https://www.eclipse.org/articles/Article-CustomDrawingTableAndTreeItems/customDraw.htm)
 
   
 
@@ -50,7 +50,7 @@ Extending WTP Using Project Facets
 
 The Faceted Project Framework allows the plugin developer to think of Web Tools Platform (WTP) projects as composed of units of functionality, otherwise known as facets, that can be added and removed by the user. This tutorial walks you through an example of creating a couple of basic facets and in the process covers the majority of the framework's extension points. This tutorial has been written for version 1.5 of the Web Tools Platform.
 
-*   [Extending WTP Using Project Facets](http://www.eclipse.org/articles/Article-BuildingProjectFacets/tutorial.html)
+*   [Extending WTP Using Project Facets](https://www.eclipse.org/articles/Article-BuildingProjectFacets/tutorial.html)
 
   
 
@@ -59,7 +59,7 @@ Implementing Model Integrity in EMF with EMFT OCL
 
 This article illustrates how the EMFT OCL parser/interpreter technology adds to the value of EMF/JET code generation as a foundation for model-driven development (MDD). We will see, with fully functional examples, how a metamodel can be generated from an Ecore model without requiring any post-generation custom code, including complete implementations of invariant constraints, derived attributes and references, and operations.
 
-*   [Implementing Model Integrity in EMF with EMFT OCL](http://www.eclipse.org/articles/article.php?file=Article-EMF-Codegen-with-OCL/index.html)
+*   [Implementing Model Integrity in EMF with EMFT OCL](https://www.eclipse.org/articles/article.php?file=Article-EMF-Codegen-with-OCL/index.html)
 
   
 
@@ -68,7 +68,7 @@ From Front End To Code - MDSD in Practice
 
 Model-driven software development (MDSD) is not just about generating code. Several additional challenges have to be mastered. These include: how to get usable graphical and textual editors for your domain specific language (DSL), how to validate your models against your metamodels, how to define model modifications and transformations and finally, how to write scalable, maintainable and extensible code generators. In this article we show how to tackle all these challenges, based on a collection of open source tools: Eclipse, Eclipse Modeling Framework (EMF), Graphical Modeling Framework (GMF) as well as openArchitectureWare. We believe that this tool chain provides a proven and stable stack for making MDSD a practical reality.
 
-*   [From Front End To Code - MDSD in Practice](http://www.eclipse.org/articles/Article-FromFrontendToCode-MDSDInPractice/article.html)
+*   [From Front End To Code - MDSD in Practice](https://www.eclipse.org/articles/Article-FromFrontendToCode-MDSDInPractice/article.html)
 
   
 
@@ -77,7 +77,7 @@ Virtual Tables and Trees
 
 Virtual Tables and Trees allow developers to quickly create Tables and Trees with large amounts of data and populate them efficiently. This article is an overview of how to use virtual Tables and Trees within SWT applications.
 
-*   [Virtual Tables and Trees](http://www.eclipse.org/articles/Article-SWT-Virtual/Virtual-in-SWT.html)
+*   [Virtual Tables and Trees](https://www.eclipse.org/articles/Article-SWT-Virtual/Virtual-in-SWT.html)
 
   
 
@@ -86,8 +86,8 @@ A Shape Diagram Editor
 
 Graphical Editing Framework (GEF) provides a powerful foundation for creating editors for visual editing of arbitrary models. Its effectiveness lies in a modular build, fitting use of design patterns, and decoupling of components that comprise a full, working editor. To a newcomer, the sheer number and variety of concepts and techniques present in GEF may feel intimidating. However, once learned and correctly used, they help to develop highly scalable and easy to maintain software. This article aims to provide a gentle yet comprehensive introduction to GEF. It describes a shape diagram editor - a small, fully functional test case of core concepts.
 
-*   [A Shape Diagram Editor](http://www.eclipse.org/articles/Article-GEF-diagram-editor/shape.html)
-*   [A Shape Diagram Editor](http://www.eclipse.org/articles/Article-GEF-diagram-editor/shape_cn.html)
+*   [A Shape Diagram Editor](https://www.eclipse.org/articles/Article-GEF-diagram-editor/shape.html)
+*   [A Shape Diagram Editor](https://www.eclipse.org/articles/Article-GEF-diagram-editor/shape_cn.html)
 
   
 
@@ -96,8 +96,8 @@ Eclipse Platform Technical Overview
 
 The Eclipse Platform is designed for building applications, integrated development environments (IDEs)and arbitrary tools. This paper is a general technical introduction to the Eclipse Platform. Part I presents a technical overview of its architecture. Part II is a case study of how the Eclipse Platform was used to build a full-featured Java development environment.
 
-*   [Eclipse Platform Technical Overview](http://www.eclipse.org/articles/Whitepaper-Platform-3.1/eclipse-platform-whitepaper.html)
-*   [Eclipse Platform Technical Overview](http://www.eclipse.org/articles/Whitepaper-Platform-3.1/eclipse-platform-whitepaper.pdf)
+*   [Eclipse Platform Technical Overview](https://www.eclipse.org/articles/Whitepaper-Platform-3.1/eclipse-platform-whitepaper.html)
+*   [Eclipse Platform Technical Overview](https://www.eclipse.org/articles/Whitepaper-Platform-3.1/eclipse-platform-whitepaper.pdf)
 
   
 
@@ -106,7 +106,7 @@ Eclipse Workbench: Using the Selection Service
 
 The selection service provided by the Eclipse workbench allows efficient linking of different parts within the workbench window. Knowing and using the existing selection mechanisms gives your plug-ins a clean design, smoothly integrates them into the workbench and opens them for future extensions.
 
-*   [Eclipse Workbench: Using the Selection Service](http://www.eclipse.org/articles/Article-WorkbenchSelections/article.html)
+*   [Eclipse Workbench: Using the Selection Service](https://www.eclipse.org/articles/Article-WorkbenchSelections/article.html)
 
   
 
@@ -115,7 +115,7 @@ The Language Toolkit: An API for Automated Refactorings in Eclipse-based IDEs
 
 Anyone who supports a programming language in an Eclipse-based IDE will be asked sooner or later to offer automated refactorings - similar to what is provided by the Java Development Tools (JDT). Since the release of Eclipse 3.1, at least part of this task--which is by no means simple--is supported by a language neutral API: the Language Toolkit (LTK). But how is this API used?
 
-*   [The Language Toolkit: An API for Automated Refactorings in Eclipse-based IDEs](http://www.eclipse.org/articles/Article-LTK/ltk.html)
+*   [The Language Toolkit: An API for Automated Refactorings in Eclipse-based IDEs](https://www.eclipse.org/articles/Article-LTK/ltk.html)
 
   
 
@@ -124,8 +124,8 @@ Creating Database Web Applications with Eclipse
 
 The Eclipse Web Tools Project delivers a feature-rich environment for developing J2EE database-driven web applications. This tutorial walks you through the process of creating a simple database web application using Eclipse WTP, Tomcat, and the Derby database engine.
 
-*   [Original article](http://www.eclipse.org/articles/Article-EclipseDbWebapps/2006-04-10/article.html)
-*   [Updated, April 2008](http://www.eclipse.org/articles/article.php?file=Article-EclipseDbWebapps/index.html)
+*   [Original article](https://www.eclipse.org/articles/Article-EclipseDbWebapps/2006-04-10/article.html)
+*   [Updated, April 2008](https://www.eclipse.org/articles/article.php?file=Article-EclipseDbWebapps/index.html)
 
   
 
@@ -134,7 +134,7 @@ Teach Your Eclipse to Speak the Local Lingo
 
 Translations for the Eclipse Project and several top-level projects are contributed to the Eclipse Foundation in every major release of Eclipse. This article provides step-by-step instructions describing what is available, where to download them, how to install them, and how to launch Eclipse in different languages.
 
-*   [Teach Your Eclipse to Speak the Local Lingo](http://www.eclipse.org/articles/Article-Speak-The-Local-Language/article.html)
+*   [Teach Your Eclipse to Speak the Local Lingo](https://www.eclipse.org/articles/Article-Speak-The-Local-Language/article.html)
 
   
 
@@ -143,7 +143,7 @@ Java Application Profiling using TPTP
 
 This article demonstrates how to use the TPTP Profiling tool to profile a Java application for identifying execution related hot spots. It shows how to start the profiling session, use the various TPTP views to analyze the data, identify methods with high execution time then jump to the source code to fix the performance problem.
 
-*   [Java Application Profiling using TPTP](http://www.eclipse.org/articles/Article-TPTP-Profiling-Tool/tptpProfilingArticle.html)
+*   [Java Application Profiling using TPTP](https://www.eclipse.org/articles/Article-TPTP-Profiling-Tool/tptpProfilingArticle.html)
 
   
 
@@ -152,7 +152,7 @@ The Eclipse Tabbed Properties View
 
 The Eclipse workbench provides a properties view which is used to view (and/or edit) properties of a selected item. In this article, you will learn how to use the tabbed properties view to create an enhanced user interface for the properties view.
 
-*   [The Eclipse Tabbed Properties View](http://www.eclipse.org/articles/Article-Tabbed-Properties/tabbed_properties_view.html)
+*   [The Eclipse Tabbed Properties View](https://www.eclipse.org/articles/Article-Tabbed-Properties/tabbed_properties_view.html)
 
   
 
@@ -161,7 +161,7 @@ How to Correctly and Uniformly Use Progress Monitors
 
 Handling a progress monitor instance is deceptively simple. It seems to be straightforward but it is easy to make a mistake when using them. And, depending on numerous factors such as the underlying implementation, how it is displayed, the result can range from completely ok, mildly confusing or outright silliness. In this article we lay down a few ground rules that will help anyone use progress monitors in a way that will work with the explicit and implicit contract of IProgressMonitor. Also, understanding the usage side makes it easier to understand how to implement a monitor.
 
-*   [How to Correctly and Uniformly Use Progress Monitors](http://www.eclipse.org/articles/Article-Progress-Monitors/article.html)
+*   [How to Correctly and Uniformly Use Progress Monitors](https://www.eclipse.org/articles/Article-Progress-Monitors/article.html)
 
   
 
@@ -170,7 +170,7 @@ Eclipse Forms: Rich UI for the Rich Client
 
 Spice up your rich client with rich user experience using Eclipse Forms. Written as a thin layer on top of SWT, Eclipse Forms allow you to achieve the Web look in your desktop applications without using the embedded browser. This allows you to retain full control of the widgets in the UI and to maintain portability across all operating systems Eclipse already runs on. This article will take you from baby steps to advanced topics of the rich user interface experience of Eclipse Forms.
 
-*   [Eclipse Forms: Rich UI for the Rich Client](http://www.eclipse.org/articles/Article-Forms/article.html)
+*   [Eclipse Forms: Rich UI for the Rich Client](https://www.eclipse.org/articles/Article-Forms/article.html)
 
   
 
@@ -179,7 +179,7 @@ Introducing the GMF Runtime
 
 Graphical Modeling Framework (GMF) is a new Eclipse project with the potential to become a keystone framework for the rapid development of standardized Eclipse graphical modeling editors. GMF is divided in two main components: the runtime, and the tooling used to generate editors capable of leveraging the runtime. Architects and developers involved in the development of graphical editors or of plug-ins integrating both EMF and GEF technologies should consider building their editors against the GMF Runtime component. This article is designed to help understand the benefits of the GMF Runtime by presenting its various value-added features.
 
-*   [Introducing the GMF Runtime](http://www.eclipse.org/articles/Article-Introducing-GMF/article.html)
+*   [Introducing the GMF Runtime](https://www.eclipse.org/articles/Article-Introducing-GMF/article.html)
 
   
 
@@ -188,7 +188,7 @@ Authoring with Eclipse
 
 The topic of technical publishing is relatively new to the world of Eclipse. One can make the argument that technical publishing is just another collaborative development process involving several people with different backgrounds and skills. This article will show that the Eclipse platform is a viable platform for technical publishing by discussing how to write documents such as an article or a book within Eclipse. In fact, this article was written using Eclipse.
 
-*   [Authoring with Eclipse](http://www.eclipse.org/articles/article.php?file=Article-Authoring-With-Eclipse/index.html)
+*   [Authoring with Eclipse](https://www.eclipse.org/articles/article.php?file=Article-Authoring-With-Eclipse/index.html)
 
   
 
@@ -197,7 +197,7 @@ Inside the Workbench: A guide to the workbench internals
 
 This article describes how the Eclipse 3.1 workbench works, in particular the infrastructure for views and editors. The goal is to teach you about important classes in the workbench, and how they interact. A familiarity with the basic workbench APIs for views, editors, action sets, and so forth is assumed.
 
-*   [Inside the Workbench: A guide to the workbench internals](http://www.eclipse.org/articles/Article-UI-Workbench/workbench.html)
+*   [Inside the Workbench: A guide to the workbench internals](https://www.eclipse.org/articles/Article-UI-Workbench/workbench.html)
 
   
 
@@ -206,7 +206,7 @@ Plugging into SourceForge.net
 
 Congratulations on taking the plunge and writing an open source plug-in for the Eclipse platform. SourceForge.net can provide a good home your plug-in, but information on how best to set up an Eclipse project there is sparse. This article is an introduction to SourceForge for the Eclipse developer. You will learn the features available to the SourceForge.net open source developer community and be guided through the process, from creating a SourceForge project to hosting your Eclipse Update site.
 
-*   [Plugging into SourceForge.net](http://www.eclipse.org/articles/Article-Plugging-into-SourceForge/sourceforge.html)
+*   [Plugging into SourceForge.net](https://www.eclipse.org/articles/Article-Plugging-into-SourceForge/sourceforge.html)
 
   
 
@@ -215,7 +215,7 @@ Persisting EMF models with WTP
 
 This article guides you through an example where an EMF model is created without serialization and the serialization is done with the framework from the web tools plug-in org.eclipse.wst.common.emf.
 
-*   [Persisting EMF models with WTP](http://www.eclipse.org/articles/Article-WTP-Persisting-EMF/persisting.html)
+*   [Persisting EMF models with WTP](https://www.eclipse.org/articles/Article-WTP-Persisting-EMF/persisting.html)
 
   
 
@@ -224,7 +224,7 @@ Extending The Visual Editor: Enabling support for a custom widget
 
 This tutorial shows how to extend the Visual Editor to support a custom widget. It covers topics such as adding to the Visual Editor's palette, building a BeanInfo class, and working with EMF .override files to introduce custom editor behavior.
 
-*   [Extending The Visual Editor: Enabling support for a custom widget](http://www.eclipse.org/articles/Article-VE-Custom-Widget/customwidget.html)
+*   [Extending The Visual Editor: Enabling support for a custom widget](https://www.eclipse.org/articles/Article-VE-Custom-Widget/customwidget.html)
 
   
 
@@ -233,7 +233,7 @@ Using GEF with EMF
 
 The Graphical Editing Framework (GEF) provides a framework for creating visual editors while being model agnostic. In most cases, people bring their own model which tend to be based on Plain Old Java Objects (POJOs). An alternative using POJOs is the Eclipse Modeling Framework (EMF), which provides many features for manipulating models that aren't found in POJOs. The purpose of this article is to build upon the shapes example provided by GEF using the Eclipse Modeling Framework (EMF) and to provide an introduction using EMF based models in GEF based editors.
 
-*   [Using GEF with EMF](http://www.eclipse.org/articles/Article-GEF-EMF/gef-emf.html)
+*   [Using GEF with EMF](https://www.eclipse.org/articles/Article-GEF-EMF/gef-emf.html)
 
   
 
@@ -242,7 +242,7 @@ Build and Test Automation for plug-ins and features
 
 Eclipse offers the possibility to build plug-ins automatically outside the Eclipse IDE, which is called "headless build". Eclipse itself is built headless and since Eclipse is an assembly of plug-ins, this feature is also available for any other plug-in. Although the set up of automatic building and testing requires only a couple of files, it can be tedious work to do nonetheless. This article shares the experiences and lessons learned while setting up automatic building and testing for an Open-Source Eclipse plug-in called RDT, Ruby Development Tools.
 
-*   [Build and Test Automation for plug-ins and features](http://www.eclipse.org/articles/Article-PDE-Automation/automation.html)
+*   [Build and Test Automation for plug-ins and features](https://www.eclipse.org/articles/Article-PDE-Automation/automation.html)
 
   
 
@@ -251,7 +251,7 @@ Using OpenGL with SWT
 
 OpenGL is a vendor-neutral, multi-platform standard for creating high-performance 2D and 3D graphics. Hardware and software implementations exist on various operating systems, including Windows, Linux and MacOS. OpenGL may be used to render simple 2D charts or complex 3D games. This article describes an experimental Eclipse plug-in that facilitates the use of OpenGL for drawing onto SWT widgets. A short history and overview of OpenGL is presented, followed by an example application.
 
-*   [Using OpenGL with SWT](http://www.eclipse.org/articles/Article-SWT-OpenGL/opengl.html)
+*   [Using OpenGL with SWT](https://www.eclipse.org/articles/Article-SWT-OpenGL/opengl.html)
 
   
 
@@ -260,7 +260,7 @@ Folding in Eclipse Text Editors
 
 Starting with release 3.0, Eclipse allows folding in its text editor. In this article, I explain the new projection infrastructure introduced in the JFace Text framework and show how to extend the XML Editor example provided with Eclipse to allow folding of text.
 
-*   [Folding in Eclipse Text Editors](http://www.eclipse.org/articles/Article-Folding-in-Eclipse-Text-Editors/folding.html)
+*   [Folding in Eclipse Text Editors](https://www.eclipse.org/articles/Article-Folding-in-Eclipse-Text-Editors/folding.html)
 
   
 
@@ -269,8 +269,8 @@ Eclipse User Interface Guidelines: Version 2.1
 
 The Eclipse platform is very flexible and extensible, but this flexibility has a serious drawback. In particular, there is no way within the program to ensure user interface consistency between the registered components within the platform.
 
-*   [Eclipse User Interface Guidelines: Version 2.1](http://www.eclipse.org/articles/Article-UI-Guidelines/Index.html)
-*   [Eclipse User Interface Guidelines: Version 2.1](http://www.eclipse.org/articles/Article-UI-Guidelines/index_cn.html)
+*   [Eclipse User Interface Guidelines: Version 2.1](https://www.eclipse.org/articles/Article-UI-Guidelines/Index.html)
+*   [Eclipse User Interface Guidelines: Version 2.1](https://www.eclipse.org/articles/Article-UI-Guidelines/index_cn.html)
 
   
 
@@ -288,7 +288,7 @@ Building Administrative Applications in Eclipse
 
 Eclipse is most commonly used as a platform for tools that allow the user to construct or assemble an end product out of development resources. It is less usual to use Eclipse as an administrative tool for monitoring existing runtime systems or applications. This article will describe some of the issues that arise in this case and illustrate possible solutions. It will show you can build an Eclipse perspective dedicated to the monitoring task. Running processes are shown in a dedicated view which always reflects their current state. You can start/stop the process, manage connections, invoke operations that the server exposes, examine server output and view events generated by the running applications.
 
-*   [Building Administrative Applications in Eclipse](http://www.eclipse.org/articles/Article-Monitor/monitorArticle.html)
+*   [Building Administrative Applications in Eclipse](https://www.eclipse.org/articles/Article-Monitor/monitorArticle.html)
 
   
 
@@ -297,7 +297,7 @@ EMF goes RCP
 
 This article explains how you can use EMF to generate RCP applications. It assumes that you have already used EMF, or have at least read the articles and references available on the documentation section of the EMF web site.
 
-*   [EMF goes RCP](http://www.eclipse.org/articles/Article-EMF-goes-RCP/rcp.html)
+*   [EMF goes RCP](https://www.eclipse.org/articles/Article-EMF-goes-RCP/rcp.html)
 
   
 
@@ -306,7 +306,7 @@ Building a Database Schema Diagram Editor with GEF
 
 GEF is a very powerful framework for visually creating and editing models. With a small initial investment, even the relative Eclipse novice can be quickly up and running, building applications with graphical editing capabilities. To illustrate, this article uses a relational database schema diagram editor with a deliberately simplified underlying model, but with enough bells and whistles to show some of the interesting features of GEF at work.
 
-*   [Building a Database Schema Diagram Editor with GEF](http://www.eclipse.org/articles/Article-GEF-editor/gef-schema-editor.html)
+*   [Building a Database Schema Diagram Editor with GEF](https://www.eclipse.org/articles/Article-GEF-editor/gef-schema-editor.html)
 
   
 
@@ -315,7 +315,7 @@ On the Job: The Eclipse Jobs API
 
 This article looks at the new Jobs API available as part of Eclipse 3.0. It describes the main portions of the Jobs API and the use of scheduling rules. It also describes some changes to Eclipse resource management including how the Resources plug-in integrates with the new API. Finally, it describes some new UI functionality that has been added to provide feedback to users about jobs that are run in the background.
 
-*   [On the Job: The Eclipse Jobs API](http://www.eclipse.org/articles/Article-Concurrency/jobs-api.html)
+*   [On the Job: The Eclipse Jobs API](https://www.eclipse.org/articles/Article-Concurrency/jobs-api.html)
 
   
 
@@ -324,7 +324,7 @@ Branding Your Application
 
 In this article we look at how to create branding for your Eclipse-based application. Branding is how you change the high level visual elements of your product. This includes items such as the splash screen, the about dialog, and the program executable.
 
-*   [Branding Your Application](http://www.eclipse.org/articles/Article-Branding/branding-your-application.html)
+*   [Branding Your Application](https://www.eclipse.org/articles/Article-Branding/branding-your-application.html)
 
   
 
@@ -333,7 +333,7 @@ How to Write an Eclipse Debugger
 
 One of the major tasks of adding a new language to an Eclipse-based IDE is debugging support. A debugger needs to start and stop the program being debugged, suspend and resume, single-step, manage breakpoints and watch points, and so on. This article explains the Eclipse Platform debug framework and steps through a simple, yet illustrative, example of adding debug support for a new language.
 
-*   [How to Write an Eclipse Debugger](http://www.eclipse.org/articles/Article-Debugger/how-to.html)
+*   [How to Write an Eclipse Debugger](https://www.eclipse.org/articles/Article-Debugger/how-to.html)
 
   
 
@@ -342,7 +342,7 @@ Viewing HTML pages with SWT Browser widget
 
 This article explains how to add HTML viewing capability to an SWT application. The Browser widget provides an easy way to integrate rich HTML content into your application.
 
-*   [Viewing HTML pages with SWT Browser widget](http://www.eclipse.org/articles/Article-SWT-browser-widget/browser.html)
+*   [Viewing HTML pages with SWT Browser widget](https://www.eclipse.org/articles/Article-SWT-browser-widget/browser.html)
 
   
 
@@ -351,9 +351,9 @@ Rich Client Tutorial
 
 The Rich Client Platform (RCP) is an exciting new way to build Java applications that can compete with native applications on any platform. This tutorial is designed to get you started building RCP applications quickly. It has been updated for Eclipse 3.1.2.
 
-*   [Part 1](http://www.eclipse.org/articles/Article-RCP-1/tutorial1.html)
-*   [Part 2](http://www.eclipse.org/articles/Article-RCP-2/tutorial2.html)
-*   [Part 3](http://www.eclipse.org/articles/Article-RCP-3/tutorial3.html)
+*   [Part 1](https://www.eclipse.org/articles/Article-RCP-1/tutorial1.html)
+*   [Part 2](https://www.eclipse.org/articles/Article-RCP-2/tutorial2.html)
+*   [Part 3](https://www.eclipse.org/articles/Article-RCP-3/tutorial3.html)
 
   
 
@@ -362,7 +362,7 @@ A Basic Image Viewer
 
 This article shows how to extend the SWT Canvas to implement a mini image viewer plug-in using Java2D transforms. The extended image canvas can be used to scroll and zoom large images, and can also be extended to apply other transforms. The implementation is based on SWT and the non-UI portions of AWT. The plug-in has been tested on Windows, Linux GTK, and Mac OS X Carbon with Eclipse 2.1 or better.
 
-*   [A Basic Image Viewer](http://www.eclipse.org/articles/Article-Image-Viewer/Image_viewer.html)
+*   [A Basic Image Viewer](https://www.eclipse.org/articles/Article-Image-Viewer/Image_viewer.html)
 
   
 
@@ -371,7 +371,7 @@ Mutatis mutandis - Using Preference Pages as Property Pages
 
 A common problem in the implementation of applications is the implementation of project-specific properties that override workbench-wide preferences on project or file level. The naive approach is to implement these pages from scratch. However, writing the same code twice is a boring task and leads to increased maintenance efforts. In this article we show how existing preferences pages (with or without field editors) can be easily converted into pages that can act as both preference and property pages. We demonstrate this by implementing the abstract class FieldEditorOverlayPage providing the necessary functionality.
 
-*   [Mutatis mutandis - Using Preference Pages as Property Pages](http://www.eclipse.org/articles/Article-Mutatis-mutandis/overlay-pages.html)
+*   [Mutatis mutandis - Using Preference Pages as Property Pages](https://www.eclipse.org/articles/Article-Mutatis-mutandis/overlay-pages.html)
 
   
 
@@ -380,7 +380,7 @@ A small cup of SWT: A bag of hints, tricks and recipes for developing SWT apps o
 
 Are you interested in developing applications for the Microsoft® Pocket PC? Are you a desktop developer curious about embedded user interfaces? A well-built embedded application is both user and resource friendly. User expectations are high. Resources are very limited...
 
-*   [A small cup of SWT: A bag of hints, tricks and recipes for developing SWT apps on the Pocket PC](http://www.eclipse.org/articles/Article-small-cup-of-swt/pocket-PC.html)
+*   [A small cup of SWT: A bag of hints, tricks and recipes for developing SWT apps on the Pocket PC](https://www.eclipse.org/articles/Article-small-cup-of-swt/pocket-PC.html)
 
   
 
@@ -389,7 +389,7 @@ Taking a look at SWT Images
 
 SWT's Image class can be used to display images in a GUI. The most common source of images is to load from a standard file format such as GIF, JPEG, PNG, or BMP. Some controls, including Buttons and TreeItems, are able to display an Image directly through the setImage(Image) method, but any control's paint event allows images to be drawn through the callback's graphic context. SWT's ImageData class represents the raw data making up an SWT Image and determines the color for each pixel coordinate. This article shows the correct uses of ImageData and Image, shows how to load images from files, and how to achieve graphic effects such as transparency, alpha blending, animation, scaling, and custom cursors.
 
-*   [Taking a look at SWT Images](http://www.eclipse.org/articles/Article-SWT-images/graphics-resources.html)
+*   [Taking a look at SWT Images](https://www.eclipse.org/articles/Article-SWT-images/graphics-resources.html)
 
   
 
@@ -398,7 +398,7 @@ PDE Does Plug-ins
 
 The Plug-in Development Environment (PDE) provides a set of tools that assist the developer in every stage of plug-in development from genesis to deployment. This article chronicles the creation, development, testing, building, and deployment of a simple "Hello World" plug-in using a subset of these tools.
 
-*   [PDE Does Plug-ins](http://www.eclipse.org/articles/Article-PDE-does-plugins/PDE-intro.html)
+*   [PDE Does Plug-ins](https://www.eclipse.org/articles/Article-PDE-does-plugins/PDE-intro.html)
 
   
 
@@ -407,7 +407,7 @@ How To Keep Up To Date
 
 This article shows you how to create and publish bundles of plug-ins (called features) to an update site so that customers can download and install them directly into Eclipse using the Eclipse update manager. This has many advantages over the low tech way of delivering new or updated plug-ins in a zip file that someone manually unzips into the directory where Eclipse is installed.
 
-*   [How To Keep Up To Date](http://www.eclipse.org/articles/Article-Update/keeping-up-to-date.html)
+*   [How To Keep Up To Date](https://www.eclipse.org/articles/Article-Update/keeping-up-to-date.html)
 
   
 
@@ -416,7 +416,7 @@ JET Tutorial Part 2 (Write Code that Writes Code)
 
 In Part 2 of this JET (Java Emitter Templates) tutorial, we will take a look at the JET engine API. You will learn how to write plug-ins that use the classes in the JET package to generate Java source code.As a real-world example, we will create a plug-in that takes user input and generates a Typesafe Enumeration class. The generated source code is based on a JET template that can be distributed with the plug-in, allowing users of the plug-in to customize the generated code by editing the template. This article also provides a short reference to the JET API.
 
-*   [JET Tutorial Part 2 (Write Code that Writes Code)](http://www.eclipse.org/articles/Article-JET2/jet_tutorial2.html)
+*   [JET Tutorial Part 2 (Write Code that Writes Code)](https://www.eclipse.org/articles/Article-JET2/jet_tutorial2.html)
 
   
 
@@ -425,7 +425,7 @@ Launching Java Applications Programmatically
 
 Application developers require the ability to run and debug code in order to test it. Tool developers require the ability to launch Java™ applications that assist in application development - for example, starting and stopping a Web server on which servlets, JSPs, and HTML pages can be tested; or launching a VM on which scrapbook evaluations can be performed. This article focuses on the high-level API provided by the Java launching plug-in that tool developers can leverage for the programmatic launching of local Java applications.
 
-*   [Launching Java Applications Programmatically](http://www.eclipse.org/articles/Article-Java-launch/launching-java.html)
+*   [Launching Java Applications Programmatically](https://www.eclipse.org/articles/Article-Java-launch/launching-java.html)
 
   
 
@@ -434,7 +434,7 @@ Adding Drag and Drop to an SWT Application
 
 Drag and drop provides a quick and easy mechanism for users to re-order and transfer data within an application and between applications. This article is an overview of how to implement Drag and Drop and Clipboard data transfers within an SWT application.
 
-*   [Adding Drag and Drop to an SWT Application](http://www.eclipse.org/articles/Article-SWT-DND/DND-in-SWT.html)
+*   [Adding Drag and Drop to an SWT Application](https://www.eclipse.org/articles/Article-SWT-DND/DND-in-SWT.html)
 
   
 
@@ -443,7 +443,7 @@ Display a UML Diagram using Draw2D
 
 The Graphical Editing Framework (GEF) ships with a painting and layout plug-in called Draw2D. Draw2D provides figures and layout managers which form the graphical layer of a GEF application. This article focuses only on the use of Draw2D to render a simple UML class diagram. While Draw2D can be used for standalone purposes, it is not an editing framework. Most applications will use the GEF plug-in as the editing layer.
 
-*   [Display a UML Diagram using Draw2D](http://www.eclipse.org/articles/Article-GEF-Draw2d/GEF-Draw2d.html)
+*   [Display a UML Diagram using Draw2D](https://www.eclipse.org/articles/Article-GEF-Draw2d/GEF-Draw2d.html)
 
   
 
@@ -452,7 +452,7 @@ Drag and Drop in the Eclipse UI
 
 In this article, we discuss the drag and drop facilities provided by JFace and the Eclipse platform UI. After reading this, you will know how to add drag and drop support to your own Eclipse views, and how that support will interact with the standard views in the Eclipse platform. Along the way, we'll also discuss that keyboard relative of drag and drop: cut and paste. You'll learn that putting your own custom objects on the clipboard is easy once you've figured out the basics of drag and drop.
 
-*   [Drag and Drop in the Eclipse UI](http://www.eclipse.org/articles/Article-Workbench-DND/drag_drop.html)
+*   [Drag and Drop in the Eclipse UI](https://www.eclipse.org/articles/Article-Workbench-DND/drag_drop.html)
 
   
 
@@ -461,7 +461,7 @@ Using Native Drag and Drop with GEF
 
 Native drag and drop provides the ability to drag data from one GUI object to another GUI object, which could potentially be in another application. GEF allows access to the operating system's underlying drag and drop infrastructure through SWT. This article will provide an in-depth look at GEF's drag and drop functionality and show some simple examples of how to take advantage of this API.
 
-*   [Using Native Drag and Drop with GEF](http://www.eclipse.org/articles/Article-GEF-dnd/GEF-dnd.html)
+*   [Using Native Drag and Drop with GEF](https://www.eclipse.org/articles/Article-GEF-dnd/GEF-dnd.html)
 
   
 
@@ -470,7 +470,7 @@ JET Tutorial Part 1 (Introduction to JET)
 
 Generating source code can save you time in your projects and can reduce the amount of tedious redundant programming. Generating source code can be powerful, but the program that writes the code can quickly become very complex and hard to understand. One way to reduce complexity and increase readability is to use templates. In this article you will learn how to create JET templates, how to use the JET Nature and JET Builder to automatically translate templates into Java classes, and how to use these classes to generate source code. This article also provides a short reference to the JET syntax.
 
-*   [JET Tutorial Part 1 (Introduction to JET)](http://www.eclipse.org/articles/Article-JET/jet_tutorial1.html)
+*   [JET Tutorial Part 1 (Introduction to JET)](https://www.eclipse.org/articles/Article-JET/jet_tutorial1.html)
 
   
 
@@ -479,7 +479,7 @@ Inside the Memory View: A Guide for Debug Providers
 
 There are many programming languages that allow access and discrete control of system memory. If you are a debug provider for one of these languages, then you probably have a requirement to provide support for debug-time memory inspection and manipulation. The Eclipse debug framework provides a Memory View, along with an extensible framework to simplify and standardize this task. This article introduces the Memory View and describes how to add your own customized memory support.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/article.php?file=Article-MemoryView/index.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/article.php?file=Article-MemoryView/index.html)
 
   
 
@@ -488,7 +488,7 @@ Building and delivering a table editor with SWT/JFace
 
 The JFace API provides several classes that can be used to build editable table views. In this article, we present a fairly extensive example that exercises the JFace and SWT classes needed to implement a table with cell editors for check-boxes, free text and combo-boxes. We also show how to package and deliver the classes into a stand-alone (non-Eclipse) Java application.
 
-*   [Building and delivering a table editor with SWT/JFace](http://www.eclipse.org/articles/Article-Table-viewer/table_viewer.html)
+*   [Building and delivering a table editor with SWT/JFace](https://www.eclipse.org/articles/Article-Table-viewer/table_viewer.html)
 
   
 
@@ -497,8 +497,8 @@ Graphics Context - Quick on the draw
 
 The package `org.eclipse.swt.graphics` contains classes that allow management of graphics resources. Graphics can be drawn on anything that implements `org.eclipse.swt.graphics.Drawable`, which includes `org.eclipse.swt.widgets.Control` and `org.eclipse.swt.graphics.Image`. The class `org.eclipse.swt.graphics.GC` encapsulates all of the drawing API, including how to draw lines and shapes, draw text and images and fill shapes. This article shows how to use a GC to draw onto an Image, or onto a control through its paintEvent callback. The Canvas control, specifically designed for drawing operations, has a number of constructor style bits that allow you to determine when and how painting occurs, and the article shows how to use these.
 
-*   [Graphics Context - Quick on the draw](http://www.eclipse.org/articles/Article-SWT-graphics/SWT_graphics.html)
-*   [Graphics Context - Quick on the draw](http://www.eclipse.org/articles/article.php?charset=utf-8&file=Article-SWT-graphics/index_cn.html)
+*   [Graphics Context - Quick on the draw](https://www.eclipse.org/articles/Article-SWT-graphics/SWT_graphics.html)
+*   [Graphics Context - Quick on the draw](https://www.eclipse.org/articles/article.php?charset=utf-8&file=Article-SWT-graphics/index_cn.html)
 
   
 
@@ -507,7 +507,7 @@ Notes on the Eclipse Plug-in Architecture
 
 Eclipse plug-ins embody an architectural pattern for building an application from constituent parts. This article presents an in-depth view of the participant roles and collaborations of this architectural pattern, as they exist in an instance of the Eclipse workbench. The goal is to provide an understanding of plug-ins, and of how plug-in extensions are defined and processed, independently of the mechanics of using the Eclipse workbench to produce plug-ins.
 
-*   [Notes on the Eclipse Plug-in Architecture](http://www.eclipse.org/articles/Article-Plug-in-architecture/plugin_architecture.html)
+*   [Notes on the Eclipse Plug-in Architecture](https://www.eclipse.org/articles/Article-Plug-in-architecture/plugin_architecture.html)
 
   
 
@@ -516,7 +516,7 @@ Designing Accessible Plug-ins in Eclipse
 
 Accessibility for disabled users is now a priority in application development as advances in techniques and support within operating systems have now made this possible. This article covers the Eclipse accessibility support, general tips for creating accessible plug-ins, and the types of disabilities that the Eclipse accessibility support assists. This is all illustrated using an example of making a view accessible.
 
-*   [Updated for Eclipse Platform 3.5](http://www.eclipse.org/articles/article.php?file=Article-Accessibility351/index.html)
+*   [Updated for Eclipse Platform 3.5](https://www.eclipse.org/articles/article.php?file=Article-Accessibility351/index.html)
 
   
 
@@ -525,7 +525,7 @@ Take control of your properties
 
 The Eclipse workbench provides a properties view which is used to view (and/or edit) properties of a selected item. In this article, you will learn how to use the properties view to dynamically modify the properties of a GUI button.
 
-*   [Take control of your properties](http://www.eclipse.org/articles/Article-Properties-View/properties-view.html)
+*   [Take control of your properties](https://www.eclipse.org/articles/Article-Properties-View/properties-view.html)
 
   
 
@@ -534,7 +534,7 @@ Project Builders and Natures
 
 This article discusses two central mechanisms that are associated with projects in an Eclipse workspace. The first of these is incremental project builders, which create some built state based on the project contents, and then keep that built state synchronized as the project contents change. The second is project natures, which define and manage the association between a given project and a particular plug-in or feature.
 
-*   [Project Builders and Natures](http://www.eclipse.org/articles/Article-Builders/builders.html)
+*   [Project Builders and Natures](https://www.eclipse.org/articles/Article-Builders/builders.html)
 
   
 
@@ -543,7 +543,7 @@ Understanding Decorators in Eclipse
 
 Decorators, as the name suggests, are used for adorning/annotating resources with useful information. Decorators can be used by plug-ins to convey more information about a resource and other objects displayed in different workbench views. This article, with the help of a simple plug-in example, will illustrate the steps involved in decorating resources, along with some best practice approaches for decorating resources. Finally, we will discuss performance issues that may arise when enabling decorators, and briefly go over the new lightweight decorators found in Eclipse 2.1.
 
-*   [Understanding Decorators in Eclipse](http://www.eclipse.org/articles/Article-Decorators/decorators.html)
+*   [Understanding Decorators in Eclipse](https://www.eclipse.org/articles/Article-Decorators/decorators.html)
 
   
 
@@ -552,7 +552,7 @@ We Have Lift-off: The Launching Framework in Eclipse
 
 The ability to launch (run or debug) code under development is fundamental to an IDE. But because Eclipse is more of a tools platform than a tool itself, Eclipse's launching capabilities depend entirely on the current set of installed plug-ins. This article describes the API available to build launching plug-ins and works through developing an example launcher using this API.
 
-*   [We Have Lift-off: The Launching Framework in Eclipse](http://www.eclipse.org/articles/Article-Launch-Framework/launch.html)
+*   [We Have Lift-off: The Launching Framework in Eclipse](https://www.eclipse.org/articles/Article-Launch-Framework/launch.html)
 
   
 
@@ -561,7 +561,7 @@ Creating JFace Wizards
 
 This article shows you how to implement a wizard using the JFace toolkit and how to contribute your wizard to the Eclipse workbench. A wizard whose page structure changes according to user input is implemented to demonstrate the flexibility of wizard support.
 
-*   [Creating JFace Wizards](http://www.eclipse.org/articles/Article-JFaceWizards/wizardArticle.html)
+*   [Creating JFace Wizards](https://www.eclipse.org/articles/Article-JFaceWizards/wizardArticle.html)
 
   
 
@@ -570,7 +570,7 @@ Using EMF
 
 This article introduces EMF, the Eclipse Modeling Framework, and will help you get started using EMF in your own Eclipse plug-ins.
 
-*   [Using EMF](http://www.eclipse.org/articles/Article-Using%20EMF/using-emf.html)
+*   [Using EMF](https://www.eclipse.org/articles/Article-Using%20EMF/using-emf.html)
 
   
 
@@ -579,7 +579,7 @@ How You've Changed!: Responding to resource changes in the Eclipse workspace
 
 Many tools and user interface elements are interested in processing resource changes as they happen. For example, the task list wants to update new or changed markers, the navigator wants to reflect added and deleted resources, and the Java compiler wants to recompile modified Java files. Such notifications are potentially costly to compute, manage and broadcast. The Eclipse Platform resource model includes a series of mechanisms for efficiently notifying clients of resource changes. This article outlines these facilities and gives some examples of their use.
 
-*   [How You've Changed!: Responding to resource changes in the Eclipse workspace](http://www.eclipse.org/articles/Article-Resource-deltas/resource-deltas.html)
+*   [How You've Changed!: Responding to resource changes in the Eclipse workspace](https://www.eclipse.org/articles/Article-Resource-deltas/resource-deltas.html)
 
   
 
@@ -588,7 +588,7 @@ How to Internationalize your Eclipse Plug-In
 
 This article is a roadmap for writing Eclipse plug-ins destined for the international market. We'll begin with a brief review of the motivations and technical challenges of internationalization, followed by step-by-step instructions of how to internationalize your Eclipse plug-in.
 
-*   [How to Internationalize your Eclipse Plug-In](http://www.eclipse.org/articles/Article-Internationalization/how2I18n.html)
+*   [How to Internationalize your Eclipse Plug-In](https://www.eclipse.org/articles/Article-Internationalization/how2I18n.html)
 *   [Ukrainian Translation](http://softdroid.net/how2I18n-ua)
 
   
@@ -598,7 +598,7 @@ How to Test Your Internationalized Eclipse Plug-In
 
 This article shows you how to validate your internationalized product and prepares you for the types of common problems you can expect during translation testing. It includes an Eclipse plug-in that defines a Properties File Compare view that can help your translation testers find errors more quickly.
 
-*   [How to Test Your Internationalized Eclipse Plug-In](http://www.eclipse.org/articles/Article-TVT/how2TestI18n.html)
+*   [How to Test Your Internationalized Eclipse Plug-In](https://www.eclipse.org/articles/Article-TVT/how2TestI18n.html)
 
   
 
@@ -607,7 +607,7 @@ Simplifying Preference Pages with Field Editors
 
 Even though preference pages can be simple to program, you can spend a lot of time getting them "just right." Field editors make this task faster and easier by providing the behavior for storing, loading, and validating preferences. Field editors also define some of the behavior for grouping and laying out widgets on a preference page.
 
-*   [Simplifying Preference Pages with Field Editors](http://www.eclipse.org/articles/Article-Field-Editors/field_editors.html)
+*   [Simplifying Preference Pages with Field Editors](https://www.eclipse.org/articles/Article-Field-Editors/field_editors.html)
 
   
 
@@ -616,7 +616,7 @@ Preferences in the Eclipse Workbench UI
 
 In the Eclipse Platform plug-in developers define preference pages for their plug-ins for use in the Workbench Preferences Dialog. This article explains when to use a preference and some of the features the Eclipse Platform provides to support preferences.
 
-*   [Preferences in the Eclipse Workbench UI](http://www.eclipse.org/articles/Article-Preferences/preferences.htm)
+*   [Preferences in the Eclipse Workbench UI](https://www.eclipse.org/articles/Article-Preferences/preferences.htm)
 
   
 
@@ -625,7 +625,7 @@ Help Part 1: Contributing a Little Help
 
 The Eclipse Platform's help system defines two extension points ("toc" and "contexts") that allow individual plug-ins to contribute online help and context-sensitive help for their components. In this article we will investigate the "toc" extension point and how you can use it to contribute documentation for your plug-in.
 
-*   [Help Part 1: Contributing a Little Help](http://www.eclipse.org/articles/Article-Online%20Help%20for%202_0/help1.htm)
+*   [Help Part 1: Contributing a Little Help](https://www.eclipse.org/articles/Article-Online%20Help%20for%202_0/help1.htm)
 
   
 
@@ -634,7 +634,7 @@ How to use the JFace Tree Viewer
 
 The goal of this article is to teach you how to use TreeViewers in your Eclipse plug-ins or stand-alone JFace/SWT applications. We'll start with a simple example and progressively add functionality.
 
-*   [How to use the JFace Tree Viewer](http://www.eclipse.org/articles/Article-TreeViewer/TreeViewerArticle.htm)
+*   [How to use the JFace Tree Viewer](https://www.eclipse.org/articles/Article-TreeViewer/TreeViewerArticle.htm)
 
   
 
@@ -643,7 +643,7 @@ Creating an Eclipse View
 
 In the Eclipse Platform a view is typically used to navigate a hierarchy of information, open an editor, or display properties for the active editor. In this article the design and implementation of a view will be examined in detail. You'll learn how to create a simple view based on SWT, and a more advanced view using the JFace viewer hierarchy. We'll also look at ways to achieve good integration with many of the existing features in the workbench, such as the window menu and toolbar, view linking, workbench persistence and action extension.
 
-*   [Creating an Eclipse View](http://www.eclipse.org/articles/viewArticle/ViewArticle2.html)
+*   [Creating an Eclipse View](https://www.eclipse.org/articles/viewArticle/ViewArticle2.html)
 
   
 
@@ -659,7 +659,7 @@ Into the Deep End of the SWT StyledText Widget
 
 The StyledText widget is a customizable widget that can be used to display and edit text with different colors and font styles. In this article we discuss why you might want to customize the StyledText widget and how you would do that.
 
-*   [Into the Deep End of the SWT StyledText Widget](http://www.eclipse.org/articles/StyledText%202/article2.html)
+*   [Into the Deep End of the SWT StyledText Widget](https://www.eclipse.org/articles/StyledText%202/article2.html)
 
   
 
@@ -668,7 +668,7 @@ Using Perspectives in the Eclipse UI
 
 In the Eclipse Platform a Perspective determines the visible actions and views within a window. Perspectives also go well beyond this by providing mechanisms for task oriented interaction with resources in the Eclipse Platform, multi-tasking and information filtering. In this article the concepts behind perspectives are examined. The process for perspective definition, extension and instantiation will also be covered in detail with coding examples and sample scenarios.
 
-*   [Using Perspectives in the Eclipse UI](http://www.eclipse.org/articles/using-perspectives/PerspectiveArticle.html)
+*   [Using Perspectives in the Eclipse UI](https://www.eclipse.org/articles/using-perspectives/PerspectiveArticle.html)
 
   
 
@@ -677,7 +677,7 @@ How to Use the Eclipse API
 
 The Eclipse Platform offers a comprehensive API (Application Programmer Interface) to developers writing plug-ins. This article discusses the general ground rules for using the Eclipse Platform API, including how to tell API from non-API, and how to stay in the API "sweet spot" to avoid the risk of being broken as the platform and its APIs evolve. These general ground rules are also recommended practice for plug-ins that must declare API elements of their own.
 
-*   [How to Use the Eclipse API](http://www.eclipse.org/articles/article.php?file=Article-API-Use/index.html)
+*   [How to Use the Eclipse API](https://www.eclipse.org/articles/article.php?file=Article-API-Use/index.html)
 
   
 
@@ -686,7 +686,7 @@ Getting Your Feet Wet with the SWT StyledText Widget
 
 The StyledText widget is a customizable widget that can be used to display and edit text with different colors and font styles. This article presents an overview of the concepts, issues, and rules that you should be aware of when using the StyledText widget.
 
-*   [Getting Your Feet Wet with the SWT StyledText Widget](http://www.eclipse.org/articles/StyledText%201/article1.html)
+*   [Getting Your Feet Wet with the SWT StyledText Widget](https://www.eclipse.org/articles/StyledText%201/article1.html)
 
   
 
@@ -695,7 +695,7 @@ SWT Color Model
 
 The combination of platforms, display devices and color depth makes providing an easy to use yet powerful and portable color model an interesting challenge. In this article we will examine the color management models of Windows® and X/Motif and then dig into the makings of the SWT color model and its implications for client code.
 
-*   [SWT Color Model](http://www.eclipse.org/articles/Article-SWT-Color-Model/swt-color-model.htm)
+*   [SWT Color Model](https://www.eclipse.org/articles/Article-SWT-Color-Model/swt-color-model.htm)
 
   
 
@@ -704,7 +704,7 @@ Using Images in the Eclipse UI
 
 Managing images in a large graphical application can be a daunting task. Since modern operating systems such as Windows® only support a small number of images in memory at once, an application's icons and background images must be carefully managed and sometimes shared between widgets. This article describes the image management facilities provided by the Eclipse Platform, along with some best practice guidelines to keep in mind when writing your own Eclipse UI plug-ins. We assume the reader already has a basic understanding of Eclipse, the UI extension points defined by the Eclipse Platform, and the Standard Widget Toolkit (SWT).
 
-*   [Using Images in the Eclipse UI](http://www.eclipse.org/articles/Article-Using%20Images%20In%20Eclipse/Using%20Images%20In%20Eclipse.html)
+*   [Using Images in the Eclipse UI](https://www.eclipse.org/articles/Article-Using%20Images%20In%20Eclipse/Using%20Images%20In%20Eclipse.html)
 
   
 
@@ -713,7 +713,7 @@ Mark My Words: Using markers to tell users about problems and tasks
 
 Eclipse workbench has a central mechanism for managing resource annotations. They are called markers. In this article, you will learn how to use markers to mark-up resources as well as how to define your own marker types and enhance the Tasks view to handle them in a special way.
 
-*   [Mark My Words: Using markers to tell users about problems and tasks](http://www.eclipse.org/articles/Article-Mark%20My%20Words/mark-my-words.html)
+*   [Mark My Words: Using markers to tell users about problems and tasks](https://www.eclipse.org/articles/Article-Mark%20My%20Words/mark-my-words.html)
 
   
 
@@ -722,7 +722,7 @@ Levels Of Integration: Five ways you can integrate with the Eclipse Platform
 
 The types of problems web application developers face today require the use of a diverse set of tools that operate in many domains. In order to provide flexible tool integration, a tool integration platform must allow tool developers to target different levels or integration based on the desired level of investment, time to market, and specific tool needs. Each integration level determines how a tool must behave, and what end users can expect as a result. This article defines the different levels of tool integration supported by Eclipse, and gives an overview of how they work.
 
-*   [Levels Of Integration: Five ways you can integrate with the Eclipse Platform](http://www.eclipse.org/articles/Article-Levels-Of-Integration/levels-of-integration.html)
+*   [Levels Of Integration: Five ways you can integrate with the Eclipse Platform](https://www.eclipse.org/articles/Article-Levels-Of-Integration/levels-of-integration.html)
 
   
 
@@ -738,7 +738,7 @@ Creating Your Own Widgets using SWT
 
 When writing applications, you typically use the standard widgets provided by SWT. On occasion, you will need to create your own custom widgets. For example, you might want to add a new type of widget not provided by the standard widgets, or extend the functionality of an existing widget. This article explains the different SWT extension strategies and shows you how to use them.
 
-*   [Creating Your Own Widgets using SWT](http://www.eclipse.org/articles/Article-Writing%20Your%20Own%20Widget/Writing%20Your%20Own%20Widget.htm)
+*   [Creating Your Own Widgets using SWT](https://www.eclipse.org/articles/Article-Writing%20Your%20Own%20Widget/Writing%20Your%20Own%20Widget.htm)
 
   
 
@@ -747,8 +747,8 @@ SWT: The Standard Widget Toolkit
 
 The two part series of articles describes the design ideas behind SWT. SWT is the software component that delivers native widget functionality for the Eclipse platform in an operating system independent manner. It is analogous to AWT/Swing in Java with a difference - SWT uses a rich set of native widgets. Even in an ideal situation, industrial strength cross platform widget libraries are very difficult to write and maintain. This is due to the inherent complexity of widget systems and the many subtle differences between platforms. There are several basic approaches that have helped significantly to reduce the complexity of the problem and deliver high quality libraries.
 
-*   [Part 1: Implementation Strategy](http://www.eclipse.org/articles/Article-SWT-Design-1/SWT-Design-1.html)
-*   [Part 2: Managing Operating System Resources](http://www.eclipse.org/articles/swt-design-2/swt-design-2.html)
+*   [Part 1: Implementation Strategy](https://www.eclipse.org/articles/Article-SWT-Design-1/SWT-Design-1.html)
+*   [Part 2: Managing Operating System Resources](https://www.eclipse.org/articles/swt-design-2/swt-design-2.html)
 
   
 
@@ -757,7 +757,7 @@ Understanding Layouts in SWT
 
 When writing applications in SWT, you may need to use layouts to give your windows a specific look. A layout controls the position and size of children in a Composite. Layout classes are subclasses of the abstract class Layout. This article shows you how to work with standard layouts, and write your own custom layout class.
 
-*   [Understanding Layouts in SWT](http://www.eclipse.org/articles/article.php?file=Article-Understanding-Layouts/index.html)
+*   [Understanding Layouts in SWT](https://www.eclipse.org/articles/article.php?file=Article-Understanding-Layouts/index.html)
 
   
 
@@ -766,7 +766,7 @@ Introducing AJDT: The AspectJ Development Tools
 
 The AspectJ Development Tools (AJDT) project is an Eclipse Tools project which enables the development of AspectJ applications in Eclipse. This article gives an overview of the capabilities of AJDT 1.4 for Eclipse 3.2 by describing several scenarios, including adding aspects to existing Java® projects, working with aspects across multiple projects, and using the load-time weaving capabilities of AspectJ 5.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/Article-Introducing-AJDT/article.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/Article-Introducing-AJDT/article.html)
 
   
 
@@ -775,7 +775,7 @@ Abstract Syntax Tree
 
 The Abstract Syntax Tree is the base framework for many powerful tools of the Eclipse IDE, including refactoring, Quick Fix and Quick Assist. The Abstract Syntax Tree maps plain Java source code in a tree form. This tree is more convenient and reliable to analyse and modify programmatically than text-based source. This article shows how you can use the Abstract Syntax Tree for your own applications.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/Article-JavaCodeManipulation_AST/index.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/Article-JavaCodeManipulation_AST/index.html)
 
   
 
@@ -784,7 +784,7 @@ Running Web Service Scenarios using Ant
 
 This tutorial shows how to run Web services scenarios (top down web service, bottom up web service and client generation) by way of an Ant task from within Eclipse.
 
-*   [Web Tools Platform Article](http://www.eclipse.org/webtools/jst/components/ws/1.0/tutorials/WebServiceAntTask/WebServiceAntTask.html)
+*   [Web Tools Platform Article](https://www.eclipse.org/webtools/jst/components/ws/1.0/tutorials/WebServiceAntTask/WebServiceAntTask.html)
 
   
 
@@ -793,7 +793,7 @@ Unleashing the Power of Refactoring
 
 In this article, Tobias Widmer sheds light on the services offered by the Eclipse Java Development Tools (JDT) and the Refactoring Language Toolkit (LTK) to support automated Java refactorings, explains how these services are used by refactorings to perform searches on the Java workspace, rewrite existing code and provide a rich user-interface to present the results of the refactoring. To demonstrate this combination of Java-specific and language-neutral frameworks, this article presents a simple but working refactoring implementation for an 'Introduce Indirection' refactoring designed to introduce an indirection method for existing method invocations.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/article.php?file=Article-Unleashing-the-Power-of-Refactoring/index.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/article.php?file=Article-Unleashing-the-Power-of-Refactoring/index.html)
 
   
 
@@ -802,7 +802,7 @@ Building Eclipse Plugins with Maven 2
 
 In a mature and agile development environment, it is vital that the developers are kept productive and that builds are done continuously and dependably. Eclipse is a great environment for developers and Maven 2 (in conjunction with Continuum or Cruise Control) is a great environment for continuous integration. As with most great software, both Eclipse and Maven 2 tend to be somewhat opinionated and the two don't always see eye to eye on how things should be done. This article describes how to use Maven 2 with Eclipse in general. In particular we will focus on how to develop, package and test Eclipse plugins using Eclipse (Callisto) and Maven 2 (2.0.4) efficiently.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/article.php?file=Article-Eclipse-and-Maven2/index.html)
 
   
 
@@ -811,7 +811,7 @@ Using TPTP to Automate Functional Testing
 
 This article provides an overview and some details of the design of a functional test automation solution that was built using testing frameworks available within the TPTP Testing Tools Project.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/article.php?file=Article-TPTPAutomateFunctionalTesting/index.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/article.php?file=Article-TPTPAutomateFunctionalTesting/index.html)
 
   
 
@@ -820,7 +820,7 @@ Simple Image Effects for SWT
 
 This article explores simple emboss, blur, glow, and drop shadow algorithms that can be applied to images in SWT.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/article.php?file=Article-SimpleImageEffectsForSWT/index.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/article.php?file=Article-SimpleImageEffectsForSWT/index.html)
 
   
 
@@ -829,7 +829,7 @@ Using the BIRT Chart Engine in Your Plug-in
 
 The BIRT Chart Engine is a powerful business chart generation tool that can be used as a standalone charting component. This article introduces the basic concepts of BIRT Chart Engine, explains what BIRT Chart Engine is composed of, and illustrates how to create a chart and use it as widget.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/article.php?file=Article-BIRTChartEngine/index.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/article.php?file=Article-BIRTChartEngine/index.html)
 
   
 
@@ -838,7 +838,7 @@ Swing/SWT Integration
 
 Swing and SWT are sometimes seen as strictly competing technologies. Some people have strong opinions on which UI toolkit to use exclusively for client applications. However, in the real world, ideological extremes are often impractical. Some valid use cases require both technologies to coexist in a single application. While mixing the two toolkits is not a simple task, it can be done, and it can be done such that the two toolkits are smoothly integrated. This article discusses the steps necessary to achieve good Swing/SWT integration. It focuses on the use case of embedding existing Swing components into an SWT-based Rich Client Platform application.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/article.php?file=Article-Swing-SWT-Integration/index.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/article.php?file=Article-Swing-SWT-Integration/index.html)
 
   
 
@@ -847,7 +847,7 @@ How to process OCL Abstract Syntax Trees
 
 The Model Development Tools Object Constraint Language (MDT OCL) project provides the building blocks for Model-Driven tools to weave OCL declarative specifications into software artifacts. We showcase some of these possibilities, taking as starting point a plug-in to visualize OCL abstract syntax trees (ASTs) in the form of annotated trees. This example motivates some practical tips about patterns for OCL visitors, including using Java 5 generics and achieving conciseness by letting MDT OCL take care of the "walking" order. To really reap the benefits of OCL-enriched specifications, tools in our modeling chain have to be able to transform such expressions into the target software platform (e.g. compile into Java, translate into SQL). Work in this area is summarized, to ease jump-starting your own OCL processing project.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/article.php?file=Article-HowToProcessOCLAbstractSyntaxTrees/index.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/article.php?file=Article-HowToProcessOCLAbstractSyntaxTrees/index.html)
 
   
 
@@ -856,8 +856,8 @@ Branching with Eclipse and CVS
 
 This two-part article describes how to use the branch and merge features provided by Eclipse's CVS support. Part one presents a brief branch-and-merge scenario designed to quickly illustrate some branch-and-merge features. Part two shows how to rebase a subbranch with changes from the main branch before merging the subbranch back into the main branch.
 
-*   [Part 1](http://www.eclipse.org/articles/article.php?file=Article-BranchingWithEclipseAndCVS/article1.html)
-*   [Part 2](http://www.eclipse.org/articles/article.php?file=Article-BranchingWithEclipseAndCVS/article2.html)
+*   [Part 1](https://www.eclipse.org/articles/article.php?file=Article-BranchingWithEclipseAndCVS/article1.html)
+*   [Part 2](https://www.eclipse.org/articles/article.php?file=Article-BranchingWithEclipseAndCVS/article2.html)
 
   
 
@@ -866,7 +866,7 @@ Adding Help Support to a Rich Client Platform (RCP) Application
 
 In this article we show you how you can incorporate the Eclipse help system into your Rich Client Application in a series of easy to follow steps. We also show you how to set up context help and how to fine tune your help settings.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/article.php?file=Article-AddingHelpToRCP/index.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/article.php?file=Article-AddingHelpToRCP/index.html)
 
   
 
@@ -875,7 +875,7 @@ Eclipse Forms: New in 3.3
 
 Eclipse Forms is a layer on top of SWT that allows you to achieve a web-like feel inside your desktop applications without having to resort to an embedded browser. In this article, the new features added to Eclipse Forms in version 3.3 are discussed. Readers are expected to be familiar with Eclipse Forms and its concepts.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/article.php?file=Article-Forms33/index.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/article.php?file=Article-Forms33/index.html)
 
   
 
@@ -884,7 +884,7 @@ Defining Generics with UML Templates
 
 Generics in Java have been around for a while but support for mapping generically specified artifacts in UML to their Ecore representation is new to UML2 2.1. This article will walk the reader through the details of the mapping process with the end goal of producing generically specified code. This article assumes some level of familiarity with generics and is not intended as a tutorial in Java generics.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/article.php?file=Article-Defining-Generics-with-UML-Templates/index.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/article.php?file=Article-Defining-Generics-with-UML-Templates/index.html)
 
   
 
@@ -893,7 +893,7 @@ Integrating EMF and GMF Generated Editors
 
 This article provides a walk-through example how to combine the editor plug-ins generated by the Eclipse Modeling Framework (EMF) and the Graphical Modeling Framework (GMF) to create an integrated editor that supports graphical and list- oder tree-based editing of the same information. The approach outlined in this article can easily be used as a starting point for the implementation of arbitrary multi-page editor solutions that contain GMF-based graphical editors.
 
-*   [Integrating EMF and GMF Generated Editors](http://www.eclipse.org/articles/article.php?file=Article-Integrating-EMF-GMF-Editors/index.html)
+*   [Integrating EMF and GMF Generated Editors](https://www.eclipse.org/articles/article.php?file=Article-Integrating-EMF-GMF-Editors/index.html)
 
   
 
@@ -902,7 +902,7 @@ Build your own textual DSL with Tools from the Eclipse Modeling Project
 
 Domain Specific Languages (DSLs) are a hot topic nowadays. While creating internal DSLs is no big deal, creating external DSLs have been said to be hard to create. In this tutorial we will show you how easy it is to create your own DSL with tools from the Eclipse Modeling Project (EMP) in less than one hour.
 
-*   [Build your own textual DSL with Tools from the Eclipse Modeling Project](http://www.eclipse.org/articles/article.php?file=Article-BuildYourOwnDSL/index.html)
+*   [Build your own textual DSL with Tools from the Eclipse Modeling Project](https://www.eclipse.org/articles/article.php?file=Article-BuildYourOwnDSL/index.html)
 
   
 
@@ -911,7 +911,7 @@ Automating Eclipse PDE Unit Tests using Ant
 
 This article outlines how to integrate your PDE unit tests into an Ant based automated build, using a simple Eclipse plug-in as an example, some simple java classes, basic Eclipse plug-in techniques and some standard Ant tasks.
 
-*   [Automating Eclipse PDE Unit Tests using Ant](http://www.eclipse.org/articles/article.php?file=Article-PDEJUnitAntAutomation/index.html)
+*   [Automating Eclipse PDE Unit Tests using Ant](https://www.eclipse.org/articles/article.php?file=Article-PDEJUnitAntAutomation/index.html)
 
   
 
@@ -920,7 +920,7 @@ Adapters
 
 The adapter pattern is used extensively in Eclipse. The use of this pattern allows plug-ins to be loosely coupled, yet still be tightly integrated in the extremely dynamic Eclipse runtime environment. In this article, we show you how to use the adapter framework to make your own objects adaptable, and adapt other objects.
 
-*   [Adapters](http://www.eclipse.org/articles/article.php?file=Article-Adapters/index.html)
+*   [Adapters](https://www.eclipse.org/articles/article.php?file=Article-Adapters/index.html)
 
   
 
@@ -929,7 +929,7 @@ Automating the embedding of Domain Specific Languages in Eclipse JDT
 
 The Eclipse Java Development Tools (JDT) excels at supporting the editing and navigation of Java code, setting the bar for newer IDEs, including those for Domain Specific Languages (DSLs). Although IDE generation keeps making progress, most developers still rely on traditional ways to encapsulate new language abstractions: frameworks and XML dialects. We explore an alternative path, Internal DSLs, by automating the generation of the required APIs from Ecore models describing the abstract syntax of the DSLs in question. To evaluate the approach, we present a case study (statecharts) and discuss the pros and cons with respect to other approaches.
 
-*   [Eclipse Corner Article](http://www.eclipse.org/articles/article.php?file=Article-AutomatingDSLEmbeddings/index.html)
+*   [Eclipse Corner Article](https://www.eclipse.org/articles/article.php?file=Article-AutomatingDSLEmbeddings/index.html)
 
   
 
@@ -938,7 +938,7 @@ Dynamic User Assistance in Eclipse Based Applications
 
 Development environments have become very complex. As a result, providing users with context relevant assistance is critical to helping them succeed with your tools and applications. This article will introduce you to Eclipse's powerful Dynamic Assistance framework and provide examples that illustrate how you can take full advantage of its capabilities.
 
-*   [Dynamic User Assistance in Eclipse Based Applications](http://www.eclipse.org/articles/article.php?file=Article-DynamicCSH/index.html)
+*   [Dynamic User Assistance in Eclipse Based Applications](https://www.eclipse.org/articles/article.php?file=Article-DynamicCSH/index.html)
 
   
 
@@ -947,7 +947,7 @@ BIRT Extension Mechanism, Part 1: Custom Report Items
 
 This article introduces the extension mechanism of BIRT report model, engine and designer, and shows how to create custom report items step-by-step.
 
-*   [BIRT Extension Mechanism, Part 1: Custom Report Items](http://www.eclipse.org/articles/article.php?file=Article-BIRT-ExtensionTutorial1/index.html)
+*   [BIRT Extension Mechanism, Part 1: Custom Report Items](https://www.eclipse.org/articles/article.php?file=Article-BIRT-ExtensionTutorial1/index.html)
 
   
 
@@ -956,7 +956,7 @@ BIRT Extension Mechanism, Part 2
 
 This article introduces the extension mechanism of BIRT report model, engine and designer, and shows how to create custom extended report items step-by-step.
 
-*   [BIRT Extension Mechanism, Part 2](http://www.eclipse.org/articles/article.php?file=Article-BIRT-ExtensionTutorial2/index.html)
+*   [BIRT Extension Mechanism, Part 2](https://www.eclipse.org/articles/article.php?file=Article-BIRT-ExtensionTutorial2/index.html)
 
   
 
@@ -965,7 +965,7 @@ How to Fix a Bug in Eclipse
 
 In this article, the reader will be guided through the entire process of a search for an open bug within one of the Eclipse projects and the steps that may be required in order to implement a fix to be contributed back to the Eclipse community. This article assumes that the reader is familiar with using CVS and Subversion in Eclipse as well as the basics required to develop Eclipse plug-ins.
 
-*   [How to Fix a Bug in Eclipse](http://www.eclipse.org/articles/article.php?file=Article-How-to-Fix-a-Bug-in-Eclipse/index.html)
+*   [How to Fix a Bug in Eclipse](https://www.eclipse.org/articles/article.php?file=Article-How-to-Fix-a-Bug-in-Eclipse/index.html)
 
   
 
@@ -974,5 +974,5 @@ Babel Pseudo Translations
 
 Babel Pseudo Translations are a very useful tool for globalization testing of Eclipse projects. This article provides step-by-step instructions and examples describing what are the Babel Pseudo Translations, where to download them, how to install them, and how to launch Eclipse in Babel Pseudo Translations. Eclipse developers can use the Babel Pseudo Translations to verify the translatability of their projects and make sure Eclipse excels in national language support.
 
-*   [Babel Pseudo Translations](http://www.eclipse.org/articles/article.php?file=Article-babel-pseudo-translations/article.html)
+*   [Babel Pseudo Translations](https://www.eclipse.org/articles/article.php?file=Article-babel-pseudo-translations/article.html)
 
diff --git a/docs/Event_Model.md b/docs/Event_Model.md
index 2e9e301c1c1..778d29c2f2a 100644
--- a/docs/Event_Model.md
+++ b/docs/Event_Model.md
@@ -109,7 +109,7 @@ UI Model Events
 
 The Eclipse 4 UI is a model based UI with an underlying EMF Model. Part of the UI framework, UIEventPublisher, listens to EMF events and publishes corresponding OSGi Events on the global event bus.
 
-The constants used to subscribe to and work with the UI model events are defined in [org.eclipse.e4.ui.workbench.UIEvents](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/tree/bundles/org.eclipse.e4.ui.workbench/src/org/eclipse/e4/ui/workbench/UIEvents.java). The bulk of the constants in this class are generated directly from the EMF model at development time using the utility org.eclipse.e4.ui.internal.workbench.swt.GenTopic. There are a few hand-crafted constants for non UI events such as the life cycle events.
+The constants used to subscribe to and work with the UI model events are defined in [org.eclipse.e4.ui.workbench.UIEvents](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/bundles/org.eclipse.e4.ui.workbench/src/org/eclipse/e4/ui/workbench/UIEvents.java). The bulk of the constants in this class are generated directly from the EMF model at development time using the utility org.eclipse.e4.ui.internal.workbench.swt.GenTopic. There are a few hand-crafted constants for non UI events such as the life cycle events.
 
 Late in the 4.2M4 milestone the hierarchy and usage pattern of UIEvents was significantly changed. This page discusses the new mechanism. For a discussion of the old mechanism and the changes you need to make to migrate from the old style to the new style take a look at [Eclipse4/UI/Event/Migration](/Eclipse4/UI/Event/Migration "Eclipse4/UI/Event/Migration").
 
diff --git a/docs/JFace.md b/docs/JFace.md
index 70853928651..19a16ea5741 100644
--- a/docs/JFace.md
+++ b/docs/JFace.md
@@ -87,7 +87,7 @@ To do this:
 In this step, we will create one project that will point to all of the JAR files needed for SWT and JFace development. 
 Here are the steps:
 
-1.  Download the SWT stable release for your Eclipse version and your operating system from [Eclipse SWT Project Page](http://www.eclipse.org/swt/). For example, for Eclipse version 3.3 and Windows, select the Windows link under Releases / Stable, as shown in the screenshot below.
+1.  Download the SWT stable release for your Eclipse version and your operating system from [Eclipse SWT Project Page](https://www.eclipse.org/swt/). For example, for Eclipse version 3.3 and Windows, select the Windows link under Releases / Stable, as shown in the screenshot below.
     
     ![Swt web page.png](images/Swt_web_page.png)
     
@@ -206,7 +206,7 @@ Deploying a SWT / JFace application is similar to deploying any Java application
 #### Step by Step Instructions
 
 1.  Create a runtime folder for the desired runtime target on your system (e.g., c:\\jface\\runtime-linux). Note that the target platform does not need to be the same as your development platform.
-2.  Find the correct SWT JAR file for the desired target platform. You can download the desired ZIP file from [the SWT Project Page](http://www.eclipse.org/swt). For example, for Eclipse 3.3 and a target platform of Linux, download the file swt-3.3.1.1-gtk-linux-x86.zip. Expand this ZIP file and copy the swt.jar file to the runtime folder.
+2.  Find the correct SWT JAR file for the desired target platform. You can download the desired ZIP file from [the SWT Project Page](https://www.eclipse.org/swt). For example, for Eclipse 3.3 and a target platform of Linux, download the file swt-3.3.1.1-gtk-linux-x86.zip. Expand this ZIP file and copy the swt.jar file to the runtime folder.
 3.  Copy the JAR files that JFace needs to the runtime folder. They are found in the Eclipse plugins subfolder under your Eclipse installation. For Eclipse version 3.3, these files are as follows:
     *   org.eclipse.core.commands_<version info>.jar
     *   org.eclipse.equinox.common_<version info>.jar
diff --git a/docs/JFaceDataBinding.md b/docs/JFaceDataBinding.md
index 80895acb54c..17add7c31af 100644
--- a/docs/JFaceDataBinding.md
+++ b/docs/JFaceDataBinding.md
@@ -232,49 +232,49 @@ Running the Snippets
 
 ### Basic
 
-*   [Hello World](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet000HelloWorld.java) \- the most basic of bindings
+*   [Hello World](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet000HelloWorld.java) \- the most basic of bindings
 
 ### WizardPage
 
-*   [Wizard Dialog](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet014WizardDialog.java) \- Shows how to use data binding in a wizard dialog so that validation results are displayed in the dialog's title area
+*   [Wizard Dialog](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet014WizardDialog.java) \- Shows how to use data binding in a wizard dialog so that validation results are displayed in the dialog's title area
 
 ### ComputedValue
 
-*   [Spreadsheet](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet006Spreadsheet.java) \- fills a Table updating cells upon change
-*   [Name Formatter](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet008ComputedValue.java) \- observable value that updates when the first or last name changes
+*   [Spreadsheet](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet006Spreadsheet.java) \- fills a Table updating cells upon change
+*   [Name Formatter](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet008ComputedValue.java) \- observable value that updates when the first or last name changes
 
 ### Bindings
 
-*   [Bind validation status to a Label](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet004DataBindingContextErrorLabel.java)
-*   [Validate observables across Bindings](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet011ValidateMultipleBindingsSnippet.java?view=markup)
+*   [Bind validation status to a Label](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet004DataBindingContextErrorLabel.java)
+*   [Validate observables across Bindings](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet011ValidateMultipleBindingsSnippet.java)
 
 ### Master Detail
 
-*   [Master detail](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet010MasterDetail.java) \- display the detail of the selection of a ListViewer in a Text widget
-*   [Nested Selection With ComboViewer](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet001NestedSelectionWithCombo.java)
+*   [Master detail](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet010MasterDetail.java) \- display the detail of the selection of a ListViewer in a Text widget
+*   [Nested Selection With ComboViewer](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet001NestedSelectionWithCombo.java)
 
 ### SWT
 
-*   [MenuUpdater](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet005MenuUpdater.java)
-*   [CompositeUpdater](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet012CompositeUpdater.java)
+*   [MenuUpdater](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet005MenuUpdater.java)
+*   [CompositeUpdater](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet012CompositeUpdater.java)
 
 ### Viewers
 
-*   [Model to TableViewer binding](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet009TableViewer.java) \- basic binding to a TableViewer
-*   [TableViewer binding with colors](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet007ColorLabelProvider.java) \- label provider that provides Colors and auto updates the viewer
-*   [TableViewer inline editing](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet013TableViewerEditing.java) \- TableViewer editing with the Eclipse 3.3 JFace viewer APIs. _(requires Eclipse 3.3)_
-*   [ComputedList and Combo](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet022ComputedListCombo.java) \- Filter the elements in one viewer based on the selection in another
-*   [ComboViewer and Java enum](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/plain/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet034ComboViewerAndEnum.java) \- Demonstrates binding the list of a ComboViewer to the values of an enum and the selected value to a simple model property.
+*   [Model to TableViewer binding](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet009TableViewer.java) \- basic binding to a TableViewer
+*   [TableViewer binding with colors](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet007ColorLabelProvider.java) \- label provider that provides Colors and auto updates the viewer
+*   [TableViewer inline editing](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet013TableViewerEditing.java) \- TableViewer editing with the Eclipse 3.3 JFace viewer APIs. _(requires Eclipse 3.3)_
+*   [ComputedList and Combo](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet022ComputedListCombo.java) \- Filter the elements in one viewer based on the selection in another
+*   [ComboViewer and Java enum](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet034ComboViewerAndEnum.java) \- Demonstrates binding the list of a ComboViewer to the values of an enum and the selected value to a simple model property.
 
 ### Additional Run Options
 
 A great way to learn is to look at concrete examples that you can run and experiment with.
 
-You can clone the [eclipse.platform.ui git repository](http://git.eclipse.org/c/platform/eclipse.platform.ui.git/) which contains the "org.eclipse.jface.examples.databinding" project with the JFace Databinding examples. For cloning a git repository you can use the [EGit](http://eclipse.org/egit/) tooling of Eclipse.
+You can clone the [eclipse.platform.ui git repository](https://github.com/eclipse-platform/eclipse.platform.ui) which contains the "org.eclipse.jface.examples.databinding" project with the JFace Databinding examples. For cloning a git repository you can use the [EGit](https://eclipse.org/egit/) tooling of Eclipse.
 
 Use the following URL to clone the repository via File -> Import -> Git repository
 
-*   [http://anonymous@git.eclipse.org/gitroot/platform/eclipse.platform.ui.git](http://anonymous@git.eclipse.org/gitroot/platform/eclipse.platform.ui.git)
+*   [https://github.com/eclipse-platform/eclipse.platform.ui.git](https://github.com/eclipse-platform/eclipse.platform.ui.git)
 
 After you cloned the project the clone wizard will allow you to import the included projects.
 For the databinding examples you only have to import the "org.eclipse.jface.examples.databinding" project.
@@ -463,7 +463,7 @@ Every getter on an observable object must make a call to ObservableTracker.gette
 
 This enables abstractions like ComputedValue or ComputedList: All you have to write is a piece of code that computes a value, or a list. As long as this code only accesses other observables, the framework will manager listeners for you automatically.
 
-For example, assume that your UI has text fields for the first name and the last name of a person, but you want to display a formatted version of the full name elsewhere in the UI. This is what you can write (see [Snippet008](http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet008ComputedValue.java?view=markup) for a complete example):
+For example, assume that your UI has text fields for the first name and the last name of a person, but you want to display a formatted version of the full name elsewhere in the UI. This is what you can write (see [Snippet008](https://github.com/eclipse-platform/eclipse.platform.ui/blob/master/examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/snippets/Snippet008ComputedValue.java) for a complete example):
 
 ```java
     final IObservableValue firstName = SWTObservables.observeText(firstNameField, SWT.Modify);
diff --git a/docs/JFaceDataBindingFAQ.md b/docs/JFaceDataBindingFAQ.md
index 27eeab63ad6..6a4de2e4293 100644
--- a/docs/JFaceDataBindingFAQ.md
+++ b/docs/JFaceDataBindingFAQ.md
@@ -4,7 +4,7 @@ JFace Data Binding/FAQ
 
 ### Where can I ask a question?
 
-You can ask questions on the [Eclipse JFace newsgroup](http://www.eclipse.org/newsportal/thread.php?group=eclipse.platform.jface). When you post please prefix the title with "\[DataBinding\]".
+You can ask questions on the [Eclipse JFace newsgroup](https://www.eclipse.org/newsportal/thread.php?group=eclipse.platform.jface). When you post please prefix the title with "\[DataBinding\]".
 
 ### How do I report a bug?
 
diff --git a/docs/PlatformCommandFramework.md b/docs/PlatformCommandFramework.md
index a28ca6a72be..78c3255cf52 100644
--- a/docs/PlatformCommandFramework.md
+++ b/docs/PlatformCommandFramework.md
@@ -198,7 +198,7 @@ We'll need a more robust implementation, but in 3.2 your action delegate needs t
       * All rights reserved. This program and the accompanying materials
       * are made available under the terms of the Eclipse Public License v1.0
       * which accompanies this distribution, and is available at
-      * http://www.eclipse.org/legal/epl-v10.html
+      * https://www.eclipse.org/legal/epl-v10.html
       *
       * Contributors:
       *     IBM Corporation - initial API and implementation
diff --git a/docs/Rich_Client_Platform.md b/docs/Rich_Client_Platform.md
index 24519a8a211..28ff27a181c 100644
--- a/docs/Rich_Client_Platform.md
+++ b/docs/Rich_Client_Platform.md
@@ -63,9 +63,9 @@ The usage of SWT and JFace is demonstrated in the following snippets:
 Text Editor Examples
 --------------------
 
-The [RCP text editor examples](http://www.eclipse.org/eclipse/platform-text/development/rcp/examples/index.html) are available from the [Platform Text Component Development Resources page](http://www.eclipse.org/eclipse/platform-text/development/dev.html).
+The [RCP text editor examples](https://www.eclipse.org/eclipse/platform-text/development/rcp/examples/index.html) are available from the [Platform Text Component Development Resources page](https://www.eclipse.org/eclipse/platform-text/development/dev.html).
 
-It illustrates how to use the [Platform Text](http://www.eclipse.org/eclipse/platform-text/index.php) components in a Rich Client Platform application.
+It illustrates how to use the [Platform Text](https://www.eclipse.org/eclipse/platform-text/index.php) components in a Rich Client Platform application.
 
 
 
@@ -74,8 +74,8 @@ Applications
 
 Several applications have been built using the Rich Client Platform.
 
-*   The RCP Catalog section of the [Eclipse Community page](http://eclipse.org/community) lists several apps, including case studies of a few.
-*   NASA/JPL is using Eclipse RCP as the foundation of their next version of Maestro, and more. See the [case study](http://eclipse.org/community/casestudies/NASAfinal.pdf). Jeff Norris from NASA/JPL also wrote a nice foreword to the [RCP Book](Rich_Client_Platform/Rich_Client_Platform_Book.md).
+*   The RCP Catalog section of the [Eclipse Community page](https://eclipse.org/community) lists several apps, including case studies of a few.
+*   NASA/JPL is using Eclipse RCP as the foundation of their next version of Maestro, and more. See the [case study](https://eclipse.org/community/casestudies/NASAfinal.pdf). Jeff Norris from NASA/JPL also wrote a nice foreword to the [RCP Book](Rich_Client_Platform/Rich_Client_Platform_Book.md).
 
 Blogs and other Resources
 -------------------------
diff --git a/docs/Rich_Client_Platform/Rich_Client_Platform_FAQ.md b/docs/Rich_Client_Platform/Rich_Client_Platform_FAQ.md
index 852374023ec..01685086317 100644
--- a/docs/Rich_Client_Platform/Rich_Client_Platform_FAQ.md
+++ b/docs/Rich_Client_Platform/Rich_Client_Platform_FAQ.md
@@ -1,11 +1,11 @@
 Rich Client Platform/FAQ
 ========================
 
-The following are **Frequently Asked Questions** (**FAQs**) about the Eclipse Rich Client Platform.
-For relevant tutorials, help topics, newsgroups, examples, and other resources, see the main [RCP page](Rich_Client_Platform.md).
+The following are **Frequently Asked Questions** (**FAQs**) about the Eclipse Rich Client Platform. 
+For relevant tutorials, help topics, newsgroups, examples, and other resources, see the main [RCP page](../Rich_Client_Platform.md).
 
-or general Eclipse FAQs, which address many RCP issues, see [The Official Eclipse FAQs](https://wiki.eclipse.org/The_Official_Eclipse_FAQs).
-For Eclipse 4, see the [Eclipse 4 RCP FAQ](Eclipse4_RCP_FAQ.md).
+For general Eclipse FAQs, which address many RCP issues, see [The Official Eclipse FAQs](https://wiki.eclipse.org/The_Official_Eclipse_FAQs).  
+For Eclipse 4, see the [Eclipse 4 RCP FAQ](../Eclipse4_RCP_FAQ.md).
 
 
 What is the Eclipse Rich Client Platform?
@@ -13,7 +13,7 @@ What is the Eclipse Rich Client Platform?
 
 While the Eclipse platform is designed to serve as an open tools platform, it is architected so that its components could be used to build just about any client application. The minimal set of plug-ins needed to build a rich client application is collectively known as the **Rich Client Platform**.
 
-For more details, see the main [RCP page](Rich_Client_Platform.md).
+For more details, see the main [RCP page](../Rich_Client_Platform.md).
 
 Why should I build my application on the Eclipse Rich Client Platform?
 ----------------------------------------------------------------------
@@ -31,18 +31,18 @@ The Eclipse Rich Client Platform consists of the following components:
 
 | Component    | Description    | Plug-ins    | Documentation    |
 | --- | --- | --- | --- |
-| Eclipse Runtime    | Provides the foundational support for plug-ins, extension points and extensions (among other facilities).  The Eclipse runtime is built on top of the [OSGi framework](https://www.osgi.org/resources/where-to-start/). | org.eclipse.core.runtime    org.eclipse.osgi   org.eclipse.osgi.services   | Dev guide: [Runtime overview](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/guide/runtime.htm)   Article: [Notes on the Eclipse Plug-in Architecture](http://eclipse.org/articles/Article-Plug-in-architecture/plugin_architecture.html)      |
+| Eclipse Runtime    | Provides the foundational support for plug-ins, extension points and extensions (among other facilities).  The Eclipse runtime is built on top of the [OSGi framework](https://www.osgi.org/resources/where-to-start/). | org.eclipse.core.runtime    org.eclipse.osgi   org.eclipse.osgi.services   | Dev guide: [Runtime overview](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/guide/runtime.htm)   Article: [Notes on the Eclipse Plug-in Architecture](https://eclipse.org/articles/Article-Plug-in-architecture/plugin_architecture.html)      |
 | SWT    | The Standard Widget Toolkit. SWT is designed to provide efficient, portable access to the user-interface facilities of the operating systems on which it is implemented | org.eclipse.swt    \+ platform-specific fragments      | [Platform SWT home page](https://www.eclipse.org/swt/) |
-| JFace    | A UI framework, layered on top of SWT, for handling many common UI programming tasks. | org.eclipse.jface | [JFace](JFace.md) |
+| JFace    | A UI framework, layered on top of SWT, for handling many common UI programming tasks. | org.eclipse.jface | [JFace](../JFace.md) |
 | Workbench | The Workbench builds on top of the Runtime, SWT and JFace to provide a highly scalable, open-ended, multi-window environment for managing views, editors, perspectives (task-oriented layouts), actions, wizards, preference pages, and more.    The Workbench is sometimes called the Generic Workbench, to distinguish it from the IDE Workbench facilities defined in the org.eclipse.ui.ide plug-in.   | org.eclipse.ui    org.eclipse.ui.workbench   | Dev guide: [Plugging into the workbench](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/guide/workbench.htm),[Dialogs and wizards](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/guide/dialogs.htm), [Advanced workbench concepts](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/guide/wrkAdv.htm)      |
 |   Other prerequisites for the Workbench   | Support for XML expressions language, commands, and help core content model.    | org.eclipse.core.expressions    org.eclipse.core.commands   org.eclipse.help   |     |
 
-Note that as of Eclipse 3.3M6, org.eclipse.help requires [com.ibm.icu](Rich_Client_Platform/Rich_Client_Platform_FAQ.md#What-is-ICU4J-and-is-it-required) which takes a sizeable amount of footprint (that [can be reduced](Rich_Client_Platform/Rich_Client_Platform_FAQ.md#What-is-ICU4J-and-is-it-required)). [Bug 183761](https://bugs.eclipse.org/bugs/show_bug.cgi?id=183761) has been filed to investigate removing this dependency from org.eclipse.help.
+Note that as of Eclipse 3.3M6, org.eclipse.help requires [com.ibm.icu](#What-is-ICU4J-and-is-it-required) which takes a sizeable amount of footprint (that [can be reduced](#What-is-ICU4J-and-is-it-required)). [Bug 183761](https://bugs.eclipse.org/bugs/show_bug.cgi?id=183761) has been filed to investigate removing this dependency from org.eclipse.help.
 
 What is the disk footprint for the Rich Client Platform?
 --------------------------------------------------------
 
-As of Eclipse 3.7, the disk footprint is about 20 Meg.
+The disk footprint for the Rich Client Platform varies depending on the included components and platform. A minimal RCP application can be around 11 MB, while typical applications with more components may require 30-50 MB or more, depending on the selection of dependencies and libraries.
 
 Is the resources plug-in (org.eclipse.core.resources) considered part of the Rich Client Platform?
 --------------------------------------------------------------------------------------------------
@@ -68,14 +68,14 @@ Here is a list of some of the reusable components in the broader Eclipse codebas
 | Help    | Web-app-based Help UI, with support for dynamic content.    | org.apache.lucene    org.eclipse.help.appserver   org.eclipse.help.base   org.eclipse.help.ui   org.eclipse.help.webapp   org.eclipse.tomcat   org.eclipse.ui.forms   | Dev guide: [Plugging in help](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/guide/help.htm)      |
 | Update Manager    | Allows users to discover and install updated versions of products and extensions. | org.eclipse.update.configurator    org.eclipse.update.core   org.eclipse.update.scheduler   org.eclipse.update.ui   \+ platform-specific fragments      | Dev guide: [Updating a product or extension](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/guide/product_update.htm)      |
 | Text    | Framework for building high-function text editors.    | org.eclipse.text    org.eclipse.jface.text   org.eclipse.workbench.texteditor   | Dev guide: [Text editors and platform text](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/guide/editors_jface.htm)      |
-| Forms    | Flat look control library and multi-page editor framework (used in PDE editors).    | org.eclipse.ui.forms | Article: [Eclipse Forms: Rich UI for the Rich Client](http://www.eclipse.org/articles/Article-Forms/article.html) |
+| Forms    | Flat look control library and multi-page editor framework (used in PDE editors).    | org.eclipse.ui.forms | Article: [Eclipse Forms: Rich UI for the Rich Client](https://www.eclipse.org/articles/Article-Forms/article.html) |
 | Welcome Page (aka Intro) | Initial welcome experience and guided assistance.    | org.eclipse.ui.intro    | Dev guide: [Intro support](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/guide/workbench_advext_intro.htm) |
 | Cheat Sheets    | A Cheat Sheet guides the user through a long-running, multi-step task.    | org.eclipse.ui.cheatsheets    | Dev guide: [Cheat Sheets](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/guide/workbench_advext_cheatsheets.htm) |
-| Resources    | Workspace resource model, with managed projects, folders and files.    | org.eclipse.core.resources    | [Platform Core home page](http://www.eclipse.org/eclipse/platform-core/)   Dev guide: [Resources overview](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/guide/resInt.htm) |
+| Resources    | Workspace resource model, with managed projects, folders and files.    | org.eclipse.core.resources    | [Platform Core home page](https://www.eclipse.org/eclipse/platform-core/)   Dev guide: [Resources overview](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/guide/resInt.htm) |
 | Console | Extensible console view.    | org.eclipse.ui.console    | Javadoc: [org.eclipse.ui.console](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/console/package-summary.html), [org.eclipse.ui.console.actions](http://help.eclipse.org/help31/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/console/actions/package-summary.html) |
 | Outline and Properties views | Outline and Properties views    | org.eclipse.ui.views    | TBD |
-| Graphical Editing Framework (GEF) | Framework for building graphical editors. Includes Draw2D, a vector graphics framework.    | org.eclipse.draw2d    org.eclipse.gef      | [GEF home page](http://www.eclipse.org/gef)      |
-| Eclipse Modeling Framework (EMF) and Service Data Objects (SDO) | EMF is a modeling framework and code generation facility for building tools and other applications based on a structured data model.  SDO is a framework that simplifies and unifies data application development in a service oriented architecture (SOA). | [EMF plug-in list from CVS](http://dev.eclipse.org/viewcvs/indextools.cgi/org.eclipse.emf/plugins/)    | [EMF home page](http://www.eclipse.org/emf/)   Overviews:[EMF, EMF Edit, EMF Validation ...](http://www.eclipse.org/modeling/emf/docs/#overviews), [SDO](http://www-106.ibm.com/developerworks/java/library/j-sdo/) |
+| Graphical Editing Framework (GEF) | Framework for building graphical editors. Includes Draw2D, a vector graphics framework.    | org.eclipse.draw2d    org.eclipse.gef      | [GEF home page](https://www.eclipse.org/gef)      |
+| Eclipse Modeling Framework (EMF) and Service Data Objects (SDO) | EMF is a modeling framework and code generation facility for building tools and other applications based on a structured data model.  SDO is a framework that simplifies and unifies data application development in a service oriented architecture (SOA). | [EMF plug-in list from CVS](http://dev.eclipse.org/viewcvs/indextools.cgi/org.eclipse.emf/plugins/)    | [EMF home page](https://www.eclipse.org/emf/)   Overviews:[EMF, EMF Edit, EMF Validation ...](https://www.eclipse.org/modeling/emf/docs/#overviews), [SDO](http://www-106.ibm.com/developerworks/java/library/j-sdo/) |
 
 How do I get started with RCP?
 ------------------------------
@@ -136,7 +136,7 @@ For example, the [Browser Example](/RCP_Browser_Example "RCP Browser Example") h
     </extension>
 ```
 
-For more details, see the [Branding Your Application](http://eclipse.org/articles/Article-Branding/branding-your-application.html) article.
+For more details, see the [Branding Your Application](https://eclipse.org/articles/Article-Branding/branding-your-application.html) article.
 
 How can I change the embedded app icon in my application?
 ---------------------------------------------------------
@@ -173,7 +173,7 @@ For example, to show the perspective bar and fast view bar on the left, and to u
 
 For a list of public preferences available on the UI plug-in and their valid values, see the interface [org.eclipse.ui.IWorkbenchPreferenceConstants](http://help.eclipse.org/galileo/index.jsp?topic=/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/IWorkbenchPreferenceConstants.html).
 
-For more details, see the [Branding Your Application](http://eclipse.org/articles/Article-Branding/branding-your-application.html) article and the [Customizing a product](http://help.eclipse.org/galileo/index.jsp?topic=/org.eclipse.platform.doc.isv/guide/product_configproduct.htm) section in Help.
+For more details, see the [Branding Your Application](https://eclipse.org/articles/Article-Branding/branding-your-application.html) article and the [Customizing a product](http://help.eclipse.org/galileo/index.jsp?topic=/org.eclipse.platform.doc.isv/guide/product_configproduct.htm) section in Help.
 
 How can I get action set menus to appear in the right order, between my app's main menus?
 -----------------------------------------------------------------------------------------
@@ -209,9 +209,9 @@ See [Tycho tutorial](https://www.vogella.com/tutorials/EclipseTycho/article.html
 When I try running, nothing happens, or it complains that the application could not be found in the registry, or that other plug-ins are missing. How can I track the problem down?
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
-Try running first from within Eclipse using the Runtime Workbench (3.0 and 3.0.1) or Eclipse Application (3.1) launch configuration (Run > Debug...). Ensure that the application's plug-in(s) and all its prerequisites are selected in the Plug-ins tab. The easiest way is to select "Choose plug-ins and fragments to launch from the list", press Deselect All, check off the application's plug-in(s), and press Add Required Plug-ins. In 3.1, there is also a Validate Plug-in Set button to check that all prerequisites have been satisfied, without having to launch first. On the Main tab, be sure that the correct product or application is selected (using a product is preferred -- see the [Branding Your Application](http://eclipse.org/articles/Article-Branding/branding-your-application.html) article).
+Try running first from within Eclipse using the Runtime Workbench (3.0 and 3.0.1) or Eclipse Application (3.1) launch configuration (Run > Debug...). Ensure that the application's plug-in(s) and all its prerequisites are selected in the Plug-ins tab. The easiest way is to select "Choose plug-ins and fragments to launch from the list", press Deselect All, check off the application's plug-in(s), and press Add Required Plug-ins. In 3.1, there is also a Validate Plug-in Set button to check that all prerequisites have been satisfied, without having to launch first. On the Main tab, be sure that the correct product or application is selected (using a product is preferred -- see the [Branding Your Application](https://eclipse.org/articles/Article-Branding/branding-your-application.html) article).
 
-When running a deployed RCP application (not running from within Eclipse), ensure that the config.ini file in the configuration directory points to the correct product or application extension via the eclipse.product or eclipse.application entry (using a product is preferred -- see the [Branding Your Application](http://eclipse.org/articles/Article-Branding/branding-your-application.html) article). Either all plug-ins need to be specified in the osgi.bundles entry of the config.ini, or the **org.eclipse.update.configurator** plug-in should be included to discover all available plug-ins the first time the application is run.
+When running a deployed RCP application (not running from within Eclipse), ensure that the config.ini file in the configuration directory points to the correct product or application extension via the eclipse.product or eclipse.application entry (using a product is preferred -- see the [Branding Your Application](https://eclipse.org/articles/Article-Branding/branding-your-application.html) article). Either all plug-ins need to be specified in the osgi.bundles entry of the config.ini, or the **org.eclipse.update.configurator** plug-in should be included to discover all available plug-ins the first time the application is run.
 
 If eclipse fails silently, look in the configuration and/or workspace directories for a .log file. If you use the eclipse.exe launcher (or equivalent on other platforms) it will tell you where to find any relevant log file.
 
@@ -232,7 +232,7 @@ or
 
 While these options are helpful for debugging, note that there is a performance penalty for -debug and -clean, so it is not recommended that they be used in the final product.
 
-For other troubleshooting hints, see the **Troubleshooting** section of the [RCP Tutorial, part 1](http://eclipse.org/articles/Article-RCP-1/tutorial1.html).
+For other troubleshooting hints, see the **Troubleshooting** section of the [RCP Tutorial, part 1](https://eclipse.org/articles/Article-RCP-1/tutorial1.html).
 
 My own RCP plug-ins are contributed by a feature. Why is the update manager complaining that my configuration is invalid?
 -------------------------------------------------------------------------------------------------------------------------
@@ -251,12 +251,12 @@ Editors can be used for any kind of model, and can be textual or graphical.
 
 The Text component provides support for text editors.
 See the entry for the Text component in the list of optional components above.
-See also the [RCP text editor example](Rich_Client_Platform.md#Examples).
+See also the [RCP text editor example](../Rich_Client_Platform.md#Examples).
 
 How can I integrate my existing Swing components into an RCP application?
 -------------------------------------------------------------------------
 
-See [this SWT FAQ entry](http://www.eclipse.org/swt/faq.php#swinginswt). Note, however, that the SWT_AWT bridge does not currently work on all platforms, e.g. Mac ([bug 67384](https://bugs.eclipse.org/bugs/show_bug.cgi?id=67384)).
+See [this SWT FAQ entry](https://www.eclipse.org/swt/faq.php#swinginswt). Note, however, that the SWT_AWT bridge does not currently work on all platforms, e.g. Mac ([bug 67384](https://bugs.eclipse.org/bugs/show_bug.cgi?id=67384)).
 
 Also take a look at [SwingWT](http://swingwt.sourceforge.net/), an SWT-based implementation of the Swing API.
 
@@ -264,7 +264,7 @@ How can I define key bindings for commands?
 -------------------------------------------
 
 As of 3.3, the preferred means of binding keys is to use commands, handlers, and contexts.
-See [Platform Command Framework#KeyBindings](PlatformCommandFramework.md#KeyBindings) for the extension points.
+See [Platform Command Framework#KeyBindings](../PlatformCommandFramework.md#KeyBindings) for the extension points.
 
 There are some wrinkles for the RCP case.
 See [Keybindings for Eclipse Commands](https://www.vogella.com/tutorials/EclipseCommands/article.html) for a tutorial.
@@ -389,6 +389,7 @@ How to add menu item, command and handler?
 
 MANIFEST.MF
 
+```
      Manifest-Version: 1.0
      Bundle-ManifestVersion: 2
      Bundle-Name: Sample Handler
@@ -397,7 +398,7 @@ MANIFEST.MF
      Bundle-Vendor: sample
      Bundle-RequiredExecutionEnvironment: JavaSE-1.6
      Require-Bundle: org.eclipse.ui
-
+```
 
 plugin.xml
 
diff --git a/docs/Rich_Client_Platform/Rich_Client_Platform_How_to.md b/docs/Rich_Client_Platform/Rich_Client_Platform_How_to.md
index d32301d35b0..114e230012f 100644
--- a/docs/Rich_Client_Platform/Rich_Client_Platform_How_to.md
+++ b/docs/Rich_Client_Platform/Rich_Client_Platform_How_to.md
@@ -9,7 +9,7 @@ This was tested on Eclipse 3.5 (Galileo).
 IDE
 ---
 
-[Eclipse Download site](http://www.eclipse.org/downloads/)
+[Eclipse Download site](https://www.eclipse.org/downloads/)
 
 Link "Eclipse for RCP/Plug-in Developers"
 
@@ -32,7 +32,7 @@ Create directory _target_ in a folder of your choice.
 Download and unzip in _target_: eclipse-RCP-SDK-*.zip, eclipse-*-delta-pack.zip
 
 *   Delta pack is needed for building to other platforms, or for automated [build](#Build).
-*   If Help or Update feature is needed, either replace RCP-SDK with platform-SDK, or download individual features from [here](http://www.eclipse.org/platform/)
+*   If Help or Update feature is needed, either replace RCP-SDK with platform-SDK, or download individual features from [here](https://www.eclipse.org/platform/)
 *   eclipse-RCP-SDK-*.zip is needed rather than eclipse-RCP-*.zip else extensions won't work in plug-in editor.
 
 Window > Preferences > Plug-in Development > Target Platform > Browse > _target_/eclipse > OK > Reload