Free quotes software for linux

Text::Typography can markup ASCII text with correct typography for HTML.

SYNOPSIS

use Text::Typography qw(typography);

print typography($text);

This module is a thin wrapper for John Grubers SmartyPants plugin for various CMSs.

SmartyPants is a web publishing utility that translates plain ASCII punctuation characters into "smart" typographic punctuation HTML entities. SmartyPants can perform the following transformations:

Straight quotes ( " and ) into "curly" quote HTML entities
Backticks-style quotes (``like this) into "curly" quote HTML entities

Dashes (-- and ---) into en- and em-dash entities

Three consecutive dots (...) into an ellipsis entity
SmartyPants does not modify characters within < pre >, < code >, < kbd >, < script >, or < math > tag blocks. Typically, these tags are used to display text where smart quotes and other "smart punctuation" would not be appropriate, such as source code or example markup.

typography($text[, $attributes])

Returns a string marked up with the proper HTML entities for proper typography.

For fine grain control over what gets converted, use the $attributes option. The default value is 3.

The following numeric values set a group of options:

0 : do nothing
1 : set all
2 : set all, using old school en- and em- dash shortcuts (-- and ---)
3 : set all, using inverted old school en- and em- dash shortcuts (--- and --)

For even finer control, specify a string of one or more of the following characters:

q : quotes
b : backtick quotes (``double only)
B : backtick quotes (``double and `single)
d : dashes
D : old school dashes
i : inverted old school dashes
e : ellipses
w : convert " entities to " for Dreamweaver users

Backslash Escapes

If you need to use literal straight quotes (or plain hyphens and periods), SmartyPants accepts the following backslash escape sequences to force non-smart punctuation. It does so by transforming the escape sequence into a decimal-encoded HTML entity:

Escape Value Character
------ ----- ---------
\
" " "

. . .
- - -
` ` `

This is useful, for example, when you want to use straight quotes as foot and inch marks: 62" tall; a 17" iMac.

Algorithmic Shortcomings

One situation in which quotes will get curled the wrong way is when apostrophes are used at the start of leading contractions. For example:

Twas the night before Christmas.

In the case above, SmartyPants will turn the apostrophe into an opening single-quote, when in fact it should be a closing one. I dont think this problem can be solved in the general case -- every word processor Ive tried gets this wrong as well. In such cases, its best to use the proper HTML entity for closing single-quotes (’) by hand.

DBD::Informix::Summary is an updated version of the information about DBD::Informix in the DBI book.
Main features:
- Transactions Yes, if enabled when database was created
- Locking Yes, implicit and explicit
- Table joins Yes, inner and outer
- LONG/LOB data types Yes, upto 2GB
- Statement handle attributes available After prepare()
- Placeholders Yes, "?" (native)
- Stored procedures Yes
- Bind output values Yes
- Table name letter case Configurable
- Field name letter case Configurable
- Quoting of otherwise invalid names Yes, via double quotes
- Case insensitive "LIKE" operator No
- Server table ROW ID pseudocolumn Yes, "ROWID"
- Positioned update/delete Yes
- Concurrent use of multiple handles Unrestricted

WIKINDx is a single or multi-user research environment storing searchable bibliographies, notes, and citations, and integrated with a WYSIWYG word processor for the authoring of publication-ready articles automatically formatted to chosen citation styles. The system includes support for migrating to and from BibTeX and Endnote.
Main features:
- can manage all my bibliographic data allowing me to search through them with an accuracy and speed that cannot be duplicated with index cards.
- enables me to store unlimited quotes, paraphrases and thoughts and to efficiently cross-reference them in a searchable database.
- is free, stable and open source allowing me to cast off the shackles of commercial, licensed software.
- supports non-English multi-byte character sets.
- runs on all major operating systems (*NIX, OsX, Windows).
- runs not only on a desktop computer but also on a web server so I can access my bibliography from any networked point or share my bibliography with my research team.
- allows multiple attachments for each bibliographic resource.
- can export my bibliography in various bibliographic styles (APA, Chicago, IEEE for example).
- allows me to edit or create bibliographic styles through a graphical interface.
- integrates a WYSIWYG word processor with easy importation of quotes etc. so that at long last I can write an article, from draft through to publication with automatic citation formatting, entirely within the one software.
- at the click of a mouse button will reformat my article to another citation style whether that style uses footnotes, endnotes or in-text citation.

iMacros for Firefox is a Mozilla Firefox extension that relieves the repetition of checking on the same sites every day, remembering passwords and filling out Web forms, or doing Web screen scraping for data extraction.

It can automatically fill Web forms that span several pages. Passwords are stored securely with 256-Bit AES encryption. Web professionals can use the software for functional testing and regression testing of Web applications. It can also be used to automate Web data extraction, such as online stock quotes or Web store prices.

WWW::Facebook::API is a Facebook API implementation.

SYNOPSIS

use WWW::Facebook::API;

my $client = WWW::Facebook::API->new(
desktop => 1,
throw_errors => 1,
parse => 1,
);

print "Enter your public API key: ";
chomp( my $val = < STDIN > );
$client->api_key($val);
print "Enter your API secret: ";
chomp($val = < STDIN > );
$client->secret($val);

print "Enter your e-mail address: ";
chomp(my $email = < STDIN > );
$client->secret($val);
print "Enter your password: ";
chomp(my $pass = < STDIN > );

my $token = $client->auth->login( email => $email, pass => $pass );
$client->auth->get_session( $token );

use Data::Dumper;
my $friends_perl = $client->friends->get;
print Dumper $friends_perl;

my $notifications_perl = $client->notifications->get;
print Dumper $notifications_perl;

# Current users quotes
my $quotes_perl = $client->users->get_info(
uids => $friends_perl,
fields => [quotes]
);
print Dumper $quotes_perl;

$client->auth->logout;

A Perl implementation of the Facebook API, working off of the canonical Java and PHP implementations. By default it uses JSON::Any to parse the response returned by Facebooks server. There is an option to return the raw response in either XML or JSON (See the parse method below).

Stock Quote is a Firefox extension that allows you to get stock quote of selected ticker from any financial site that you define in the setting page.

Tcl provides a portable scripting environment for Unix, Windows, and Macintosh that supports string processing and pattern matching, native file system access, shell-like control over other programs, TCP/IP networking, timers, and event-driven I/O.
Tcl has traditional programming constructs like variables, loops, procedures, namespaces, error handling, script packages, and dynamic loading of DLLs. Tk provides portable GUIs on UNIX, Windows, and Macintosh.
A powerful widget set and the concise scripting interface to Tk make it a breeze to develop sophisticated user interfaces.
Tcl (Tool Command Language) is easy to learn and you can create a useful program in minutes! You are free to use Tcl/Tk however you wish, even in commercial applications.
Basic Syntax
Tcl scripts are made up of commands separated by newlines or semicolons. Commands all have the same basic form illustrated by the following example:
expr 20 + 10
This command computes the sum of 20 and 10 and returns the result, 30. You can try out this example and all the others in this page by typing them to a Tcl application such as tclsh; after a command completes, tclsh prints its result.
Each Tcl command consists of one or more words separated by spaces. In this example there are four words: expr, 20, +, and 10. The first word is the name of a command and the other words are arguments to that command. All Tcl commands consist of words, but different commands treat their arguments differently. The expr command treats all of its arguments together as an arithmetic expression, computes the result of that expression, and returns the result as a string. In the expr command the division into words isnt significant: you could just as easily have invoked the same command as
expr 20+10
However, for most commands the word structure is important, with each word used for a distinct purpose.
All Tcl commands return results. If a command has no meaningful result then it returns an empty string as its result.
Variables
Tcl allows you to store values in variables and use the values later in commands. The set command is used to write and read variables. For example, the following command modifies the variable x to hold the value 32:
set x 32
The command returns the new value of the variable. You can read the value of a variable by invoking set with only a single argument:
set x
You dont need to declare variables in Tcl: a variable is created automatically the first time it is set. Tcl variables dont have types: any variable can hold any value.
To use the value of a variable in a command, use variable substitution as in the following example:
expr $x*3
When a $ appears in a command, Tcl treats the letters and digits following it as a variable name, and substitutes the value of the variable in place of the name. In this example, the actual argument received by the expr command will be 32*3 (assuming that variable x was set as in the previous example). You can use variable substitution in any word of any command, or even multiple times within a word:
set cmd expr
set x 11
$cmd $x*$x
Command substitution
You can also use the result of one command in an argument to another command. This is called command substitution:
set a 44
set b [expr $a*4]
When a [ appears in a command, Tcl treats everything between it and the matching ] as a nested Tcl command. Tcl evaluates the nested command and substitutes its result into the enclosing command in place of the bracketed text. In the example above the second argument of the second set command will be 176.
Quotes and braces
Double-quotes allow you to specify words that contain spaces. For example, consider the following script:
set x 24
set y 18
set z "$x + $y is [expr $x + $y]"
After these three commands are evaluated variable z will have the value 24 + 18 is 42. Everything between the quotes is passed to the set command as a single word. Note that (a) command and variable substitutions are performed on the text between the quotes, and (b) the quotes themselves are not passed to the command. If the quotes were not present, the set command would have received 6 arguments, which would have caused an error.
Curly braces provide another way of grouping information into words. They are different from quotes in that no substitutions are performed on the text between the curly braces:
set z {$x + $y is [expr $x + $y]}
This command sets variable z to the value "$x + $y is [expr $x + $y]".
Control structures
Tcl provides a complete set of control structures including commands for conditional execution, looping, and procedures. Tcl control structures are just commands that take Tcl scripts as arguments. The example below creates a Tcl procedure called power, which raises a base to an integer power:
proc power {base p} {
set result 1
while {$p > 0} {
set result [expr $result * $base]
set p [expr $p - 1]
}
return $result
}
This script consists of a single command, proc. The proc command takes three arguments: the name of a procedure, a list of argument names, and the body of the procedure, which is a Tcl script. Note that everything between the curly brace at the end of the first line and the curly brace on the last line is passed verbatim to proc as a single argument. The proc command creates a new Tcl command named power that takes two arguments. You can then invoke power with commands like the following:
power 2 6
power 1.15 5
When power is invoked, the procedure body is evaluated. While the body is executing it can access its arguments as variables: base will hold the first argument and p will hold the second.
The body of the power procedure contains three Tcl commands: set, while, and return. The while command does most of the work of the procedure. It takes two arguments, an expression ($p > 0) and a body, which is another Tcl script. The while command evaluates its expression argument using rules similar to those of the C programming language and if the result is true (nonzero) then it evaluates the body as a Tcl script. It repeats this process over and over until eventually the expression evaluates to false (zero). In this case the body of the while command multiplied the result value by base and then decrements p. When p reaches zero the result contains the desired power of base. The return command causes the procedure to exit with the value of variable result as the procedures result.
Main features:
- More control structures, such as if, for, foreach, and switch.
- String manipulation, including a powerful regular expression matching facility. Arbitrary-length strings can be passed around and manipulated just as easily as numbers.
- I/O, including files on disk, network sockets, and devices such as serial ports. Tcl provides particularly simple facilities for socket communication over the Internet.
- File management: Tcl provides several commands for manipulating file names, reading and writing file attributes, copying files, deleting files, creating directories, and so on.
- Subprocess invocation: you can run other applications with the exec command and communicate with them while they run.
- Lists: Tcl makes it easy to create collections of values (lists) and manipulate them in a variety of ways.
- Arrays: you can create structured values consisting of name-value pairs with arbitrary string values for the names and values.
- Time and date manipulation.
- Events: Tcl allows scripts to wait for certain events to occur, such as an elapsed time or the availability of input data on a network socket.

eBay Blog This is an extension which enables easy blogging on eBay Blogs.

Once downloaded, you will be able to select content from any webpage, right click it, and choose the "Blog This" option! The eBay Blog This tool will... eBay Blog This enables easy blogging on eBay Blogs.

Once downloaded, you will be able to select content from any webpage, right click it, and choose the "Blog This" option!

The eBay Blog This tool will automatically insert the content, links and quotes into your blog posts.