When the very first version of Server Core appeared, many administrators avoided it for the reason that they could only use the command line capabilities, and this is not always convenient. However, in Windows Server 2012 the situation has changed; it is now possible to use hybrid mode, i.e. It is possible to both disable and enable the graphical interface.

Disabling GUI

In Windows Server 2012, the GUI followed the general architecture of the operating system management interface and became a “feature.” This in turn makes the process of removing the graphical interface extremely simple. First you need to launch “Server Manager”.

Click "Manage" and then select "Remove Roles or Features" from the menu.

Since the GUI is not a role, click "Next" to skip the role wizard and go to the next section.

When you reach the Feature Wizard, you will need to uncheck the “User Interfaces and Infrastructure” checkbox and then click “Next”.

Check the “Restart Destination Server” checkbox and click “Remove”.

After this action the GUI will be removed.

After deleting all necessary data, the server will automatically reboot.

After the server boots up again and you log in, from now on you will only be able to use the command line to interact with the server.

Enabling GUI

After we have successfully removed the GUI, it would be very nice to know how to get it back. To do this, we use the "SConfig" utility - so just type "sconfig" in the command line and press Enter.

At the very bottom of the screen you can see menu item 12, which is responsible for restoring the graphical interface - all we have to do is type 12 and press “Enter”.

A notification will appear on the screen that if you enable the GUI, you will need to restart the server - feel free to click “Yes” to complete the GUI restoration operation.

After this, DISM will launch, which will add the necessary files to activate the graphical shell.

Once the above process is completed, you will be prompted to reboot the server, type “y” and click to reboot.

Disabling the GUI Using PowerShell

We can also carry out all of the above operations, both removing and returning the GUI, much faster if we use PowerShell commands. To do this, you need to open “Server Manager”, click on “Tools” and launch PowerShell.

In order to remove the GUI we use the Remove-WindowsFeature cmdlet:

Remove-WindowsFeature Server-Gui-Shell, Server-Gui-Mgmt-Infra

In turn, Remove-WindowsFeature is simply an alias of the command, which means we can also use the following commands:

Uninstall-WindowsFeature Server-Gui-Shell, Server-Gui-Mgmt-Infra

After entering the command and pressing the Enter key, the procedure for removing the graphical interface will begin.

Once the binary removal operation is complete, you will need to reboot for the changes to take effect. Type the following command and press “Enter”:

Shutdown –r -t 0

After the reboot, only the command line will be available for work.

Enabling GUI Using PowerShell

The first thing we need to do is get into PowerShell, type PowerShell from the command line and press “Enter”.

Now we need the Add-WindowsFeature cmdlet to bring the GUI back:

Add-WindowsFeature Server-Gui-Shell, Server-Gui-Mgmt-Infra

This is also an alias for the following commands:

Install-WindowsFeature Server-Gui-Shell, Server-Gui-Mgmt-Infra

After completing the procedure for adding components, you must reboot the server using the shutdown command:

Shutdown –r -t 0

After rebooting the server, the graphical interface will be available again.

P.S> You can download Windows Server 2012 RC

You are here because you have a file that has a file extension ending in .gui. Files with the .gui extension can only be launched by certain programs. It is possible that .gui are data files and not documents or media, which means they are not intended to be viewed at all.

what is a .gui file?

The GUI file extension is associated with the Dr. Explain program. This program is a development assistant tool for creating printable "Quick Start" information, Windows screenshots, illustrations with annotations and other related help data from a live application. GUI files are used by this program to hold articles and help section documents prepared with its developer documentation. Carreta Software LLC's GUI Design Studio and Id Software, Inc.'s Doom 3 computer game with programs that also use the GUI file format. GUI Design Studio is a program that opens and creates files with a graphical interface. It is a graphical user interface design tool that can automatically render windows and screens linked together to create sample storyboard workflows or models for desktop, web and mobile applications. GUI files are used by this program as document files that contain completed projects and other reference information. Doom 3 is a sci-fi horror game that simulates a first-person shooter point of view. The game uses GUI files to enable the game's Head Up Display or HUD, which shows information about the player's current weapon ammo, PDA, video disc, and player's health status.

how to open .gui file?

Launch the .gui file or any other file on your computer by double-clicking it. If your file associations are configured correctly, the application that is intended to open your .gui file will open it. You may need to download or purchase the correct application. It is also possible that you have the correct application on your computer, but the .gui files are not yet associated with it. In this case, when you try to open a .gui file, you can tell Windows which application is the correct one for this file. From then on, opening the .gui file will open the correct application.

applications that open .gui file

Indigo Byte Systems Dr.Explain

a word of warning

Be careful not to rename the extension on .gui files or any other files. This will not change the file type. Only a special conversion program can change a file from one file type to another.

what is the file extension?

A file extension is the set of three or four characters at the end of a file name, in this case, .gui. File extensions tell you what type of file it is, and tell Windows what programs you can open. Windows often associates a default program for each file extension, so that when you double-click a file, the program launches automatically. Even though a program is no longer on your computer, you may sometimes receive an error message when you try to open the file in question.

FIX .gui FILE ASSOCIATION ERRORS

Find and fix file extension errors, registry issues, and quickly and easily restore your PC to optimal performance.

try Registry Reviver® Free.

Start downloading

Otherwise it may be questioned and deleted.
You can edit this article by adding links to .
This mark is set March 21, 2017.

Graphical User Interface (GUI), graphical user interface (GUI)(English) graphical user interface GUI ) - a type of user interface in which interface elements (menus, buttons, icons, lists, etc.) presented to the user on the display are executed in the form of graphic images. Also called graphical control shell.

The graphical user interface is part of the user interface and defines the user interaction at the level of visualized information.

Story

Thanks to research conducted in the 1960s by Doug Engelbart at Stanford Research Institute, the graphical user interface was invented.

The GUI concept was subsequently adopted by scientists at the Xerox PARC research laboratory in the 1970s. In 1973, young scientists were gathered in the Xerox PARC laboratory and given freedom of research. As a result, among other things, the concept of the WIMP (Windows, Icons, Menus, Pointers) graphical interface was born and within the framework of this concept the Alto computer was created. It was not released as a commercial product, but was widely used within the company as a Xerox corporate tool.

The GUI concept was commercialized in 1984 in products from Apple Computer Corporation. Apple has been criticized for abandoning the command line in favor of a graphical interface. In 1985, an operating GUI with multitasking was used in the AmigaOS system.

GUI later became a standard part of most operating systems and applications available on the market. Examples of systems using GUI: Mac OS, GEM, Atari TOS, Microsoft Windows, Solaris, GNU/Linux, NeXTSTEP, OS/2, BeOS, Android, iOS, Bada, MeeGo.

Although in the vast majority of systems the GUI is an add-on to the operating system, there are also independent implementations of it. There is a known version of the graphical BIOS Setup program, when even before loading the OS, the settings of an IBM PC-compatible computer are controlled with the mouse, similar to a full-fledged GUI. There are also GUIs for MK that do not require an OS.

Classification

The following types of GUI can be distinguished:

• simple: standard screen forms and standard interface elements provided by the GUI subsystem itself;
• true-graphic, two-dimensional: non-standard interface elements and original metaphors implemented by the application’s own tools or a third-party library;
• three-dimensional.

DWIM

One of the requirements for a good graphical interface of a software system is the concept of "do what I mean" or DWIM(eng. Do What I Mean). DWIM requires that the system operate predictably so that the user intuitively knows in advance what action the program will perform upon receiving his command.

By the concept of a good website, webmasters understand a site that meets many rules, including a user-friendly interface. I think a user-friendly interface is one of the most important characteristics of a website. I think all webmasters will agree with me, because a website should be considered as a modified form of a regular program with a traditional graphical user interface. So we smoothly approached the definition of GUI.

GUI translated from English (Graphical User Interface), graphical user interface. But don't think that the Internet is completely identical to a GUI-style software application.

In this article I will talk about how to create a website in the GUI style or switch to this style.

Those new to GUIs will probably want to simply apply the interface design rules that are used in classic software applications with a typical GUI to the web, and they will be partly right, given that a website is still a type of program. And yet, I would not draw such conclusions, because we should not forget that web design has its own conventions.

First, I suggest looking at what makes websites different from GUI applications. This is delivery. Delivery of information via the Internet. The website user receives information page by page (i.e., one page at a time), while desktop applications tend to be installed on the user’s computer completely after downloading the distribution via the Internet or via CD-ROM. And the fact that the desktop application is immediately completely installed on the user’s computer gives it undeniable advantages over the website. But the advantage of the latter is the opposite. Page-by-page loading of information gives the user the opportunity to receive only the information that he needs.

Let's now look at the difference in installing and uninstalling an application. This feature, or rather its absence, makes sites function very well, because the user can easily go to a competing website.

Principles of GUI design

Now I will talk about the basic principles of building a GUI, modified for the web (in other words, how to build a GUI application).

The most important of these principles is presenting metaphors from the outside world to the user. Let me explain. The user should have an idea of ​​how to use metaphors in a computer environment. In addition, the page interface should remind the user of a classic software interface

The next principle is direct control. Users want to feel like they are involved in controlling the computer's actions. The only drawback of this principle is the difficulties with delivery; it can take quite a long time.

Consistency. Anecdotally, even novice users believe that effective web applications are consistent both within themselves and with other applications. Websites must be internally consistent, and follow conventions established by other websites.

User control. It is important to remember that the user, not the computer, controls all actions. In my opinion, control should be handed over to the user, but actually following this principle again creates many control problems. In many situations, you should guide the user depending on the purpose of the site.

Every Internet user wants to get what he is looking for. But website owners should turn this rule into " what you see is what you want" Users should be able to view information the way they want to see it. In such a diverse environment as the web with many ways to access information (mobile phones, PDAs) this idea is difficult to implement (but worth it). A good example would be a printable page.

Feedback and dialogue. To maintain user interest in a website, it is necessary to use various feedback tools. These are surveys, forms, discussions. In the web environment, this is simply necessary, given the problem of response speed.

Perception of permanence. Users will feel more comfortable if the site design remains clear and familiar to them than if the site interface changes randomly. Unfortunately, not all sites provide consistency in the design of forms or buttons. If you do decide to change the style of a menu or other design element, then do it gradually. This simple rule can significantly improve the performance level of a website.

Promotion. Users make mistakes (they have, they do, they will) and it is the responsibility of every designer to encourage them to do so and give them the opportunity to undo or deter them from doing things that could be dangerous or destructive. As a site grows and becomes an application, this rule becomes one of the most important. An example would be closing a page with a completed form. The page should notify the user that it is impossible to return data without sending it to the server.

Quality of content. The content of websites greatly influences their ranking with the user. It should be simple and understandable, only then will the user have an incentive to return to this site again and again.

Time sensitivity. Information delivery time is the most important aspect of website performance. Users have little tolerance for ineffective delivery. Keeping the content and interface up-to-date can also be important.

Conclusion

Well, I talked about the basic principles of the GUI.

Now I propose to summarize all of the above. So. Here are the basic principles of the GUI:

1. Metaphors from the real world.
2. Direct control.
3. Consistency.
4. What you see is what you want.
5. User control.
6. Feedback and dialogue.
7. Encouragement.
8. Perception of permanence.
9. Quality of content.
10. Time sensitivity.

These simple rules will help to dramatically increase the level of website efficiency and users, as if by magic, will run to you. Good luck!

So far we have looked at examples related to the system console. Such programs are called console programs and are often used on servers, where interactivity is not needed, where the program’s task mainly consists of supporting the operation of some autonomous services and does not require frequent user interaction. Programs that can interact with the user must have some external interactive interface so that the user can work with it after starting the program. This interface is called a graphical user interface (GUI or GUI - Graphical User Interface). Most programs have a GUI, incl. and in NetBeans, all windows, buttons, menus, etc. are all GUI.

The main element of the GUI is the window; any program must have at least one window.

6.1. Components and Containers

The main concept of a GUI is a graphics system component. A component is a class that has its own structure and behavior, and is also completely independent in relation to the others. All GUI objects are components, for example, a button, a text input field, a scroll bar, including a window. The JDK has two main component libraries - Awt and Swing. These classes are in the java package. When using their components, these libraries must be imported into the program. In total, these libraries contain several dozen classes representing GUI components and a full set of methods for working with them.

Each component is placed in a container before being displayed on the screen. The window class Frame (from Awt) or JFrame (from Swing), which we will use further, are top-level containers, that is, they do not need to be placed in the container themselves; the graphical interface that we will create will start from them.

The Container class is a descendant of the Component class, which is a direct descendant of the Object class - the top of the Java class hierarchy. From the container class, 3 main container classes are inherited: panel (Panel), scroll panel (ScrollPane) and window (Window). And the Frame class is inherited from the window class.

It should also be noted that similar containers with an unlimited number of such attachments can be placed in containers,

which allows for very flexible configuration of the location and interaction of components.

As a practical example, let's write the first window, which will be empty for now.

In order to describe your window, you simply need to extend the Frame class.

import java.awt.*; import java.awt.event.*;

public class FrameTest extends Frame( FrameTest(String str)(

setSize(500,300);

setVisible(true); addWindowListener(new WindowAdapter())(

public void windowClosing(WindowEvent evt)( System.exit(0);

public static void main(String args) ( new FrameTest("My first window");

At the very top of the program, we import the Awt library and the event class of this library, which contains the necessary methods for processing events. Next, we describe a new class named FrameTest and use the extensions keyword to indicate that it is an extension of the Frame class. In the class we describe the constructor manually - in the listing you see right at the beginning of the class body a method with the class name and a string parameter. Which later in the constructor itself is substituted into the superclass constructor call method super(str) , the constructor of the class Frame , this parameter str will be the title bar of our window. The window constructor is quite complex, and in order not to rewrite the entire constructor code, the super() operator is used, which refers to the superclass constructor. Next, using the setSize(500,300) method, we set the window dimensions to 500 pixels in width and 300 in height. Using the setVisible(true) method we make our window visible on the screen. And, one of the most basic actions of the constructor is the description of the event handler when trying to close the window. The addWindowListener() method adds a window “listener” to the constructor, which monitors the actions of this window. The structure of the listener is quite difficult to perceive, because... the processing process is entered into the parameters of the addWindowListener() method itself (note the code, the closing parenthesis of the parameters of this method is located immediately after the closing parenthesis of the body of the WindowAdapter() object. We will consider constructs of this type later. According to the rule, the parameters of the called method should be described using

one line, but since the parameter is not only the creation of a new object, but also its description, it is more reasonable to place the code according to the formatting rule on several lines. The created object of the WindowAdapter class (a class for working with windows) is overridden, more precisely, its abstract method WindowClosing is overridden, which is called when the cross in the upper right corner (the window close button) is clicked, unless it is overridden without writing the procedure System.exit(0) in the body of this method , which will exit the program and terminate it), the window will be impossible to close using the Java virtual machine, including even the Alt+F4 key combination. It will be possible to close it only using the operating system, i.e. forcefully “kill” the process, or crash the program.

After our window is described in the FrameTest class, all that remains is to create a new object based on this class. In the main() method, using the new command, we create an object of type FrameTest with a string parameter – My first window.

The execution result is shown in Fig. 22.

Rice. 22. Result of program execution

Each container has its own “layout manager” - Layout manager, which determines the location of components in the container. In order to improve the level of skills in independently placing components, we will not use such managers. To disable the placement manager, you need to set it to null in the container constructor using the method