cmd

M2Convert CMD description
Convert and compress files from any multimedia file to any format M2Convert supports using the command line. M2Convert CMD enables you to Convert and Compress Multimedia files and DVDs using the Command Line. Convert any Multimedia file format (including AVI, MPEG, WMV, MOV, MPG, ASF, MP4, OGG, WAV, MP2, DivX, etc.) to another format while maximizing compression.

Convert one or more media files to iPod, PSP, Zune, ZEN, Smartphone, web streaming, and many other multimedia formats in one easy process with complete control of the size, quality and compression.

Here are some key features of "M2Convert CMD":

· Batch Convert/compress files from any format (AVI, WMV, MPG, MPEG, ASF, OGG, MOV, MP4 and more) to any format using the command line.
· Convert to iPod , PSP, Zune, ZEN and Smartphone compatible formats.
· Use LEAD s or Windows Media Profiles to convert/compress your files.
· Backup DVD or VCD (convert from a DVD to any file format)
· Backup audio CD (convert from an audio CD to any file format).
· Compress music files so you can store more on your iPod, MP3 player, computer or dvd.
· Compress your videos (home videos use a large amount of hard drive space. Avoid this by compressing your files).
· Convert any existing DVD to any of the formats M2Convert CMD supports.
· Use LEAD s or Windows Media Profiles to convert/compress your files.
· Compress or recompress your multimedia files using the LEAD iCompress enhanced codecs included with M2Convert CMD (H.264, MPEG-4, MPEG-2, MCMP/MJPEG, MCMW, MJPEG2000, Vorbis, AAC, and more) or any existing codecs installed on your computer.
· Resize, De-Interlace, or Crop your multimedia files while converting/compressing.


Requirements:

· Pentium II 400MHz or better processor to handle video animation.
· 32 MB RAM.
· 36 MB free storage space.
· Internet connection (to download the program).
· Monitor capable of displaying 256 colors and 800x600 resolution or better.
· DirectX 8.0 or higher installed.

Limitations:

· 15 days trial
· Inserts watermark on the converted videos

Test::Cmd is a Perl module for portable testing of commands and scripts.

SYNOPSIS

use Test::Cmd;

$test = Test::Cmd->new(prog => program_or_script_to_test,
interpreter => script_interpreter,
string => identifier_string,
workdir => ,
subdir => dir,
match_sub => $code_ref,
verbose => 1);

$test->verbose(1);

$test->prog(program_or_script_to_test);

$test->basename(@suffixlist);

$test->interpreter(script_interpreter);

$test->string(identifier string);

$test->workdir(prefix);

$test->workpath(subdir, file);

$test->subdir(subdir, ...);
$test->subdir([sub, dir], ...);

$test->write(file, < contents of file
EOF
$test->write([subdir, file], < contents of file
EOF

$test->read($contents, file);
$test->read(@lines, file);
$test->read($contents, [subdir, file]);
$test->read(@lines, [subdir, file]);

$test->writable(dir);
$test->writable(dir, $rwflag);
$test->writable(dir, $rwflag, %errors);

$test->preserve(condition, ...);

$test->cleanup(condition);

$test->run(prog => program_or_script_to_test,
interpreter => script_interpreter,
chdir => dir, args => arguments, stdin => < input to program
EOF

$test->pass(condition);
$test->pass(condition, &func);

$test->fail(condition);
$test->fail(condition, &func);
$test->fail(condition, &func, $caller);

$test->no_result(condition);
$test->no_result(condition, &func);
$test->no_result(condition, &func, $caller);

$test->stdout;
$test->stdout($run_number);

$test->stderr;
$test->stderr($run_number);

$test->match(@lines, @matches);
$test->match($lines, $matches);

$test->match_exact(@lines, @matches);
$test->match_exact($lines, $matches);

$test->match_regex(@lines, @regexes);
$test->match_regex($lines, $regexes);

$test->diff_exact(@lines, @matches, @output);
$test->diff_exact($lines, $matches, @output);

$test->diff_regex(@lines, @regexes, @output);
$test->diff_regex($lines, $regexes, @output);

sub func {
my ($self, $lines, $matches) = @_;
# code to match $lines and $matches
}
$test->match_sub(&func);
$test->match_sub(sub { code to match $_[1] and $_[2] });

$test->here;

The Test::Cmd module provides a low-level framework for portable automated testing of executable commands and scripts (in any language, not just Perl), especially commands and scripts that interact with the file system.

The Test::Cmd module makes no assumptions about what constitutes a successful or failed test. Attempting to read a file that doesnt exist, for example, may or may not be an error, depending on the software being tested.

Consequently, no Test::Cmd methods (including the new() method) exit, die or throw any other sorts of exceptions (but they all do return useful error indications). Exceptions or other error status should be handled by a higher layer: a subclass of Test::Cmd, or another testing framework such as the Test or Test::Simple Perl modules, or by the test itself.
(That said, see the Test::Cmd::Common module if you want a similar module that provides exception handling, either to use directly in your own tests, or as an example of how to use Test::Cmd.)

In addition to running tests and evaluating conditions, the Test::Cmd module manages and cleans up one or more temporary workspace directories, and provides methods for creating files and directories in those workspace directories from in-line data (that is, here-documents), allowing tests to be completely self-contained. When used in conjunction with another testing framework, the Test::Cmd module can function as a fixture (common startup code for multiple tests) for simple management of command execution and temporary workspaces.

The Test::Cmd module inherits File::Spec methods (file_name_is_absolute(), catfile(), etc.) to support writing tests portably across a variety of operating and file systems.

A Test::Cmd environment object is created via the usual invocation:

$test = Test::Cmd->new();

Arguments to the Test::Cmd::new method are keyword-value pairs that may be used to initialize the object, typically by invoking the same-named method as the keyword.

Sys::Manage::Cmd - Systems management command volley.

SYNOPSIS

Command line script

use Sys::Manage::Cmd;
my $s =Sys::Manage::Cmd->new();

# Script associations (see also embedded in source):
$s->{-assoc}->{.ftp}=sub{[ftp,-n,-s:loginfile,!elem!,<,$_[1]->[0]]};

# Target collections:
$s->{-target}->{all} =[1,2,3,4,5,6];

# Target branches:
$s->{-branch}->{1} =[1,2];
$s->{-branch}->{2} =[3,4];
$s->{-branch}->{3} =[5,6];

# Command-line setup / loop:
$s->set([@ARGV]);

# Command assignments:
#$s->set(-k=>assign, -o=>b, -i=>0, -ping=>1);
#$s->execute(-a=>assignment name, -t=>[targets], -cline=>[command line]);
#...

# Command line execution:
$s->set(-k=>cmd, -o=>b, -i=>0, -ping=>0);
$s->execute([@ARGV]);

Command line

script -option -option... target command-line
script -option... -ttarget... command-line

Examples of command line

script all dir !elem!
script -ob -tall dir !elem!
script -rPrevId -tall dir !elem!
script -aTest -tall dir !elem!
script -l10 -tall dir !elem!

Options of command line

(see also -cline and -i, -k, -l, -o, -r, -t, -u, -x, -v, -g)

-kNameSpace - kind (namespace) of command
-rCommandId - redo command id (used also inside -l); or switch (for -a)
-aAssignName - assignment name, to use as command id
-lPauseSecs - loop with pause before each subsequent redo
-lg... - ... for pings usuccessful only
-lv, -lw... - ... console verbose or windowed subsequent turns
-o(s|c|b) - order of execution:
sequental
concurrent
branched (concurrent branches)
-tTargetName - target, may be several -t, instead of positional argument
-xTargetExcl - exclusion from target list, may be several -x
-uUser:pswd - user name and password for target
-g - ping target before command, also use -gPingTimeout
-gx - exclude unsuccessful targets sequentially
-i - ignore exit code
-v(0|1|2) - verbosity level
-vc... - ... cmdfile rows include
-vt... - ... date-time include

Embedded commands

(see also -cline and -assoc)

script.ext - interpreting of scripts alike .pl, .bat, .ftp, .rdo.*
rcmd, rdo, - commands to remote nodes using
fput, fget, Sys::Manage::Conn
mput, mget (!elem!, !user!, !pswd! substitutions not needed)
cmdfile - evaluate command lines file or Perl script
!elem!, < - target element and source file substitutions
!user!, !pswd! - user name and password substitutions
!log! - log filesystem name substitution

Embedding command line

(see also ENVIRONMENT and SLOTS)

if (!defined($ENV{SMELEM}) # command volley:
|| ($ENV{SMELEM} eq )) {
system($^X, script, -k0, target, $0)
} elsif (!$ENV{SMDIR}) {
die "Execute this script on Manager!"
} elsif ($ENV{SMDIR}) {
die "Execute this script on Agent!"
} else { # command script:
....
1 # success
}

RunOnceEx cmd Creator description
Creation of a RunOnceEx.cmd file for creating Unattended Windows installations The RunOnceEx.cmd Creator is a program that will help you to create the RunOnceEx.cmd file in order to automate the installation of programs durring an Unattended Windows 2000 or higher installation.

An unattended Installation is a special disc (cd or dvd) that contains the installation of windows and all of your other programs. Upon insertion of the disc in a drive, your pc will automaticly be installed with a fresh copy of windows including all updates, your programs and their updates and all of your personal settings.

Easy creation of a RunOnceEx.cmd file for creating Unattended Windows 2000 and higher installations. RunOnceEx.cmd has an internal library of the most commonly used program for easy creation of the file, also can the database be extended with your own programs.

d¡ will help you store and manage your tasks. d¡ is the new version of DO! which no longer will be build.

Shortcuts:
Cmd+N New
Cmd+shift+N New Task
Cmd+<- Delete
Cmd+shift+<- Delete Task

Open Unread Messages is an Entourage AppleScript which opens a Custom View titled "Unread Messages" with shortcut key Cmd-Control-U.

Completly freeware.

Cspot is a semantic annotator designed only for the C programming language. It is quite similar to cscope, but some more functionality.

Cspot project can be used to find the declarations, definitions, and usages of functions, variables, macros, typedefs, and structs.

It can also find visible identifiers at some position in the source, functions called by a function, global variables used by a function, usages of local variable declarations, unused global variables, unused function definitions, and more. Because it uses sparse, cspot knows more about semantics than cscope.

cspot usage ( cspot -h )
cspot -db spot.db -regexp reg ;; prints all identifiers of project matching reg (extended regexp)
cspot -db spot.db -fc printf ;; prints all declarations of function printf
cspot -db spot.db -fu printf ;; prints all usages of function printf
cspot -db spot.db -vu stdout ;; prints all usages of variable stdout
cspot -db spot.db -sc my_sruct ;; prints places of forward declaration of struct my_struct
cspot -db spot.db -sf my_sruct ;; prints places of definition of struct my_struct
cspot -db spot.db -su my_sruct ;; prints places of usage of struct my_struct
cspot -db spot.db -si my_sruct ;; prints places of definition and variables in struct my_struct
etc.

cspot -va source.c 254 21 ;; prints all visible identifiers at source.c line 254 pos 21
cspot -vla source.c 254 21 ;; prints all visible identifiers (declared in file source.c) at source.c line 254 pos 21

commands for visible functions, macros, variable, called functions by function, global variables used by function ...

cspot -db spot.db -fu printf
printfs all usages of function printf in project (usage = call, assigning to variable)

printf at `base/cmd/commands.h 249:7
printf at `base/cmd/commands.h 327:8
printf at `base/cmd/commands.h 337:8
printf at `base/cmd.c 313:3
printf at `base/cmd.c 318:7
printf at `base/cmd.c 319:36
printf at `base/cmd.c 321:36
printf at `base/cmd.c 322:36
printf at `base/cmd.c 323:36

Quick Lock is a mini app that will allow you to quickly disable your Windows Command Prompt (aka CMD), Registry editor and Task Manager.

Ideal for people who use share computer and have limited access to system resources.

See4task description
See4task is a small tool that will check if a specific task is running and will execute a program if it does or doesnt See4task is a small tool that will check if a specific task (program) is running and will execute a program if it does or doesnt (according to the users preference). Call it from a command prompt or a batch file.

Usage: see4task.exe /0|1 /task-name /command
e.g.:
see4task /0 /avgcc32.exe /cmd /c c:softpediasoftpedia.exe
If avgcc32.exe is not running then execute "cmd /c c:softpediasoftpedia.exe"

see4task /1 /avgcc32.exe /cmd /c c:softpediasoftpedia.exe
If avgcc32.exe is running then execute "cmd /c c:softpediasoftpedia.exe"

see4task /0 /calc /calc.exe
This means that if the calculator is not running then run it.
If you run it without arguments it displays a list of running processes.

CosyCMD is a powerful tool makes your use of cmd.exe and every console window much more convenient by adding something like graphical interface to it. CosyCMD offers you to visually select the file path that should be given to a command line. Selecting the current directory of the cmd.exe using folder tree instead of printing the sequence of cd commands is supported too.

Using CosyCMD you can paste any string from the clipboard to the command line having no problems with conversion between different code pages used by most part of Windows and consoles.

You can save and load input/output history not for only one "execution step" like using > and < symbols when working with cmd.exe but for several "execution steps" per time.

Black&Blue Icons (Add On 1) are Mac OS X application icons such as Chess, GarageBand, QuickTime Player, Mail, Pages and Preview in black and blue style.


This is an addition to popular Black&Blue icons from www.IconDrawer.com.

How to change icon:

1. Copy icon (Cmd+C)
2. Select Application
3. Right Click->Get Info (Cmd+i)
4. Select application icon in top left corner of window
5. Paste new icon (Cmd+V)

To revert default icon: Select icon in the top left corner of info window and delete it (backspace).