Free ui software for linux

UI is an admin utility that renames existing users and adds users to a group.

ui is a user information utility that can display user information, list users from a given UID (or UID 500 by default), add a user to a group, rename a user along with his home directory and update his home directory files to reflect that change, list expired or locked users, change the shell for a user, and list users in an existing group.

Command line options:

-G group Adds user to a group.
-g group Shows users in the specified group.
-h This help.
-i Shows user information. This is the default option.
-l [UID] Lists users beginning with UID and upward. Defaults to 500.
-p Lists to default or specified printer.
-v Displayes version information.
-s Change users shell type.
-x Lists expired or locked user accounts.
-m newname Move user. Changes users name and updates all records and config files.

Some options may be stacked such as -ip username or -lp username.

GFC-UI is a C++ interface for GTK+.

The GTK+ Foundation Classes is an set of integrated C++ classes for developing GTK+ applications on UNIX-like systems such as Linux. GFC-UI is the user interface library and includes C++ wrappers for most objects in the ATK, GDK, GTK, GdkPixbuf and Pango libraries.

There is a standard string compatible UTF-8 string class, automatic memory management, an optimized virtual signal handler system and a typesafe system of C++ signal and slots. It comes with a full set of example programs, several test applications, a GNU Autotools test project, a C++ version of the GTK+ widget demonstration program, extensive reference documentation and a tutorial.

UI::Dialog project supports priority ordering of the backend detection process.

SYNOPSIS

use UI::Dialog;
my $d = new UI::Dialog ( backtitle => Demo, title => Default,
height => 20, width => 65 , listheight => 5,
order => [ zenity, xdialog ] );

# Either a Zenity or Xdialog msgbox widget should popup,
# with a preference for Zenity.
$d->msgbox( title => Welcome!, text => Welcome one and all! );

ABSTRACT

UI::Dialog is a OOPerl wrapper for the various dialog applications. These dialog backends are currently supported: Zenity, XDialog, GDialog, KDialog, CDialog, and Whiptail. There is also an ASCII backend provided as a last resort interface for the console based dialog variants. UI::Dialog is a class that provides a strict interface to these various backend modules. By using UI:Dialog (with its imposed limitations on the widgets) you can ensure that your Perl program will function with any available interfaces.

So if youd prefer that Xdialog should be used first if available, simply designate the desired order when creating the new object. The default order for detecting and utilization of the backends are as follows: (with DISPLAY env): Zenity, GDialog, XDialog, KDialog (without DISPLAY): CDialog, Whiptail, ASCII

UI::Dialog is the result of a complete re-write of the UDPM CPAN module. This was done to break away from the bad choice of name (UserDialogPerlModule) and to implement a cleaner, more detached, OOPerl interface.

This application is a Qt only version of the KDE application KUIViewer that ships with the KDE SDK. It is able to allow people to view Qt Designer UI files without having any of the Qt development tools installed.
The advantage of this tool is that developers can show customers what the user interface will not only look like, but how it will behave. Unlike screenshots that dont give a good feel for tab layout and key accelerators the UI viewer will let the user see it in action.
The utility also has the ability to print screen captures of the current user interface, save image snapshots of the user interface, and also to copy an image of the current user interface to the clipboard.
Main features:
- Print screen captures of the user interface.
- Save screen captures in various image formats.
- Capture directly to the clipboard.
- Support for modal dialogs.
- Support for preview in other Qt styles.
Enhancements:
- Fixed bug where QMainWindow based ui files would not close properly when closed via the window manager.
- Fixed bug where slots would connect to the main UI Viewer.

OpenInteract::UI::Main is the primary user interface assembly conductor.

SYNOPSIS

my $page = OpenInteract::UI::Main->handler();
send_http_headers();
print $page;

# Subclass to define a new method for looking up template names:

package OpenInteract::UI::LanguageChoice;

use base qw( OpenInteract::UI::Main );

my $DEFAULT_LANGUAGE = en;

sub choose_template {
my ( $class ) = @_;
my ( $language );
if ( $R->{auth}{is_logged_in} ) {
$language = $R->{auth}{user}->language;
}
$language ||= $R->apache->param( lang )
|| $R->{session}{lang}
|| $DEFAULT_LANGUAGE;
my $R = OpenInteract::Request->instance;
my $template = $R->{theme}->property_value( "template_$language" )
|| $R->{theme}->property_value( main_template );
return $template;
}

This is the handler that puts the main content generated together with the template that surrounds the content on every page.

The action has already been parsed from the URL for us so we look up the class/method used to generate the content and call them. We then put that content into the main template which is specified in our theme, unless we have received another directive to use a separate template or no template at all.

Another alternative is that the content handler needs to return a file that is not HTML, such as a PDF, graphic, word processing document, archive, or whatever. If so the content handler should put the complete filename in the $R->{page}->{send_file} key.

A content author can set a main template to use for the generated content by setting:

$R->{page}{_template_name_}

to the name of the template to use. This should be a fully-qualified template name -- such as mypkg::mytemplate. If you do not specify a package the OI template provider will try to find the template in the global template directory.

You can also set a template that might vary by theme. This is not the name of the template directly but rather a placeholder within the theme which holds the name of the template. For instance, say you created a spooky_template and implemented it in multiple themes. Even though you as an author do not know what theme will be used, you can still pick the right template by setting:

$R->{page}{_template_key_}

And to use the simple template, the author should set:

$R->{page}{_simple_}

to a true value. The default simple template is base_simple, although you can set its name under the template_names key of your server configuration.

Finally, the author can also set:

$R->{page}{_no_template_}

to display the content without a template at all.

Main Template Variables

Any content handler can send information to be placed directly onto the main template by setting information using the $R->{main_template_vars} hashref. For instance:

$R->{main_template_vars}{current_weather} = Rainy and cold;

would set the current_weather template variable for display on the main template and not on any of the content handlers.

Note that while this sounds useful (and it can be), you will probably use it only very rarely. The boxes concept is more comprehensive and full-featured and will almost certainly do what you need.

QTuneroid is a musical instrument tuner, designed to tune musical instruments on PC using a microphone or by directly connecting the instrument to the PCs sound card.
This program actually is a fork of Tuneroid by Jozef Kosoru (check his page at "http://www.uid0.sk/zyzstar/?tuneroid" ) which i made because i needed a good tuner, but dont want to use huge and sluggish KDE desktop, nor even install KDE libraries. So i ported Tuneroid to pure Qt and made some tweaks to UI slightly...
Enhancements:
- small ui fixes
- several build fixes