- This lesson will teach you the following concepts
- SCM (Source Code Manager)
- Principle of SCM
- Creating the repository
- Integrating a project in SCM
- Adding the project into SCM
- Opening a project from SCM
- Configuring SCM
- Handling the project via SCM
- Modifying a project parameter
- Modifying a project window
- Checking the checked-out element back in
- Synchronizing the project
- Offline mode
- SCM administrator
- Disconnecting from SCM
This lesson will teach you the following concepts
- The Source Code Manager.
- Using the Source Code Manager.
Estimated time: 30 mn
|The Source Code Manager is not available in Express version.|
The development of a large IS system requires the participation of several developers. These developers must work on a single WINDEV project while sharing the different resources (windows, classes...).
WINDEV is supplied with a Source Code Manager named "SCM" used to share the source codes of different projects between developers and to find out the full history of modifications performed (in the code, in the interface, ...).
SCM (Source Code Manager)
Principle of SCM
The Source Code Manager is used to store and share the projects and their elements.
The principle is as follows:
- A reference version of each one of your projects is found on a server. This set of versions is called "Repository".
- Each developer has a local copy of different projects on his computer.
- Whenever a developer wants to modify a project element (window, report, query, ...), he informs the SCM that he is becoming the temporary owner of this element. To do so, the developer will check out the element from the repository.
- This developer gets exclusive rights on this element: all requested modifications can be performed on this element.
- The other developers are still working on the copy of the reference version of this element (found in the repository).
- Once the developer has finished, the checked-out element is checked back into the repository.
- The other developers are automatically notified of this check-in operation. They can now update their local copy.
The SCM supports teamwork and it allows you to find out the history of all modifications. The SCM can also be used to manage and control the elements shared between several projects.
Creating the repository
To share a project via the Source Code Manager, a repository must be created. This repository must be created once only on a server.
This repository can be created:
- when installing WINDEV.
- when creating a project that is using the SCM.
- when importing a project into the SCM.
- whenever you want, from WINDEV directly or from the SCM administrator.
The repository can be installed in the following modes:
- HFSQL Classic,
- HFSQL Client/Server,
- PCSCloud. The PCSCloud mode allows you to access the sources of projects from anywhere and at any time. This mode corresponds to a private Cloud and it proposes several options (dedicated platform, use of Control Centers, ...). Visit www.pcscloud.net for more details.
- SCM Drive. The SCM Drive mode allows you to access the sources of projects from anywhere and at any time. Visit www.pcscloud.net for more details.
- Our repository will be created when a project is imported into the SCM (next step).
|We advise you to make backup copies of the repository on a regular basis. To do so, you must: |
- connect as administrator to the management tool of SCM.
- on the "Management" pane, in the "Backups" group, select "Full backup".
Integrating a project in SCM
Adding the project into SCM
To use an existing project with the Source Code Manager, simply include it in the repository.
|If you did not perform the operations in the previous lessons, you can follow this lesson by opening a corrected project: in the WINDEV home page (Ctrl + <), click "Tutorial" and select "Full application (Answer)"|
- We are now going to include the "WD Full Application.WDP" project in the repository:
- On the "SCM" pane, in the "Add the project" group, click "Add the project into SCM". The wizard for adding projects into the SCM starts:
The repository was not created yet. We are going to create one.
Note: We are going to create a "local" repository (on the development computer). The operating mode would be similar for a network repository.
- Click on "Create a repository".
- The repository creation screen is displayed.
The repository can be in HFSQL Classic format (local or network) or in HFSQL Client/Server format. We are going to create a repository in HFSQL Classic format.
|If the repository is in HFSQL Client/Server format, it can be used remotely.|
- Select "Create a repository in network share mode " and specify the directory of this repository ("C:\My Projects\Local repository" for example).
- Validate the creation of the repository ("Create repository").
- The repository has now been created. We are going to include our project in this repository.
- Go to the next step.
- The wizard proposes to locate the project in the "WINDEV projects" subdirectory of the repository.
Accept this location. Go to the next step.
- The wizard asks you to select the project elements that will be added into the repository.
We want to add all project elements. Go to the next step.
- The wizard asks you to select the project dependencies that will be added into the repository. These dependencies correspond to all external elements required by the project (images, style sheets, etc.).
We want to add all project dependencies. Go to the next step.
- Validate the project integration in the SCM. The project and its elements have now been added into our repository.
A help window about the SCM toolbar is displayed. Read and validate this window.
|Sharing project elements|
When the projects that share the same resources (same analysis, same windows, etc.) are included in the SCM, the relevant elements can be shared between the different projects. Therefore, the same element is checked in once only into the SCM and the modifications are automatically applied to the other projects.
Opening a project from SCM
In our example, the project is integrated in the SCM and it can be used directly.
In a real case, in order for other developers to work on a project found in the Source Code Manager, they must get a copy of this project locally.
To do so, the following operations must be performed:
- Open the project from the Source Code Manager: on the "Home" pane, in the "General" group, expand "Open" and select "Open a project from the SCM".
- Specify the location parameters of the repository and validate (this step is required only if the current project in the editor does not belong to the SCM):
- In the screen that is displayed, specify (if necessary) the connection and the local directory:
: If the project was already opened from SCM, the SCM proposes to open the project as usual or to overwrite the content (to retrieve the entire project). This operation must be performed once only by each developer who is using the project. The developer who added the project into the Source Code Manager (you in this case!) has no operation to perform.
|The next openings of a project managed by SCM are identical to the openings of a project not managed by SCM: all you have to do is open the project (".WDP" file) corresponding to the local copy.|
Before you start working on the elements of project found in the SCM, you must configure the mode for checking out the project elements.
When working on the elements of a project in the SCM, the element must be checked out from the repository before it can be modified, then it must be checked back in once the changes have been made. Therefore, the modified element becomes available to all SCM users.
WINDEV proposes two modes for checking out the project elements:
- the standard mode: if you display a SCM element that is not checked out, a panel indicates that the element must be checked out before it can be modified. The element can be checked out immediately (check-out button found in the dialog box).
- the automatic mode: if you try to modify a SCM element that is not checked out, the SCM automatically proposes to check out this element. Once the check-out is validated, the element can be modified.
Remark: this mode is not recommended when using SCM with a slow Internet connection.
The automatic check-out will be used in this tutorial.
- To make sure that the automatic check-out is enabled, on the "Home" pane, in the "Environment" group, expand "Options" and select "General options of WINDEV". In the "General" tab, check (if necessary) "Check out elements during the first modification".
Handling the project via SCM
We are now going to work with SCM in real conditions by performing the following operations:
- Modify a project parameter.
- Modify a project window.
Modifying a project parameter
- We are going to modify the project by asking to display the skin template on the system windows:
- Display the project description: on the "Project" pane, in the "Project" group, click "Description".
- Click the "Style" tab.
- Check "Customize the system windows (Info, YesNo, Confirm, Dialog)".
- Validate the description window of project.
- Several SCM windows appear:
- First of all, the window for automatic project check-out is displayed. Indeed, we want to modify a project characteristic therefore the project must be checked out.
- The option "Automatically check the project back in at the end of operation" is used to automatically check the project back in at the end of modification. Keep this option.
- Validate this window.
- Different check-in and check-out windows open allowing you to add the internal component "WDFAA.wci" and its elements to the project in the repository and extract them to the local project. This component contains the different system windows to customize. Validate these different windows.
- The project description window is closed and the project is automatically checked back into the repository.
Modifying a project window
We are now going to modify the "WIN_Product_form" window: a click on the image must allow to modify the image (like the "Modify" button).
The method for modifying a checked-out element (GUI, code, ...) is the same as the method for modifying an element in a project not managed by SCM.
However, the modifications performed on a checked-out element are not visible to the other developers.
If another developer runs the checked-out element, the element that is currently found in the repository will be used.
This allows you to make an application evolve while keeping a stable version in the repository.
- Test your modifications.
- Run the project test ( among the quick access buttons).
- Select a product and click "Modify".
- In the form that is displayed, click the product image: the file picker is opened to modify the product image. This is the expected operating mode.
- Close the test window.
Checking the checked-out element back in
Now that the modifications have been made and tested, we are going to check the window back into the repository. Then, your modifications will be made accessible to the other developers.
- On the "SCM" pane, in the "Current element" group, click the "Check in" button. The following screen is displayed:
This screen is used to:
- find out the modifications performed by comparing the element found in the repository with the checked-out element ("My Modif" button).
You have the ability to compare an element to one of its earlier versions. This allows you to compare the code in order to retrieve a code section that was "lost" or accidentally deleted by another developer.
- access the history of the element found in the repository ("Properties" button).
- type a comment about the modifications performed. By default, WINDEV proposes the comment typed during the check-out.
- send a message to the other developers.
- check in the modifications made to the element while keeping the element checked out ("Keep the element checked out").
|If you are using the Control Centers, the current task can be ended when the element is checked back into the Source Code Manager. This feature is useful to follow the monitoring of tasks, the corrections of bugs, ...|
- Validate the check-in. The window is displayed in the editor.
Synchronizing the project
Several options can be used to configure a project handled by SCM. These options are grouped in the "SCM" tab of project description (to display it, click "Description" on the "Project" pane).
These options are as follows:
- Propose to get the latest version of the elements when the project is opened.
When opening a project found in the SCM, this option proposes to get the latest version of the project elements.
- Propose to check in the elements when the project is closed.
When the project is closed, this option is used to display the list of elements that are currently checked out in order for some of them (or all of them) to be checked back in.
By default, the checked-out elements are not checked back in when the project is closed.
- Check out/Check in the project automatically.
This option allows you to automatically check out or check in the project when using an element.
This option is selected by default.
The SCM allows you to work in offline mode. This mode allows a developer (who is using a laptop, for example) to continue working on a project found in the repository while being disconnected.
The principle is simple:
- before the disconnection, on the "SCM" pane, in the "Other actions" group, expand "Remote work" and select "Disconnect to work offline".
- during the reconnection, on the "SCM" pane, in the "Other actions" group, expand "Remote work" and select "Reconnect and synchronize". Then, all you have to do is check the modified elements back in.
In offline mode, there are two solutions to check out elements:
- No element is checked out from the SCM. The other developers will be able to work on the same elements as you while you are working in offline mode. When you reconnect to the SCM, the modifications made by yourself to the element will have to be merged with the modifications made by the other developers.
- The elements that you want to modify are checked out in exclusive mode. No one else can use the element while you are working in offline mode.
The SCM administrator is used to directly handle the different projects included in the source code manager.
It allows you to:
- manage the repositories (creation, connection to a repository).
- manage the files and directories found in a project of repository (add, delete, rename, ... files and directories).
- manage the different files of the repository (check-in, check-out, share, etc.).
- start some tools (options, maintenance, etc.).
- show the history of an element.
- show the status of elements.
- perform backups.
- grant rights to the different SCM users.
- list the projects in which you are taking part in order to dissociate from them (if necessary).
- Start the SCM administrator: on the "SCM" pane, in the "Repository" group, click "Manage". All project elements are listed in the administrator.
Disconnecting from SCM
In the rest of this tutorial, we will be using the "WD Full Application" application. To simplify the operations, we advise you to disconnect from SCM:
- Display the description window of project: On the "Project" pane, in the "Project" group, click "Description".
- In the "SCM" tab, select "No developer groupware and no SCM".
- Validate the description window of project.
We have presented the main steps for developing an application.
WINDEV proposes several tools to optimize your applications. See "Project audits"
for more details.