The Tigger Movie (2000)
A Movie Review by Mark O'Hara
Visit Online Film Critics Society at www.ofcs.org
Full of fun, great animation and fine voice-acting, Walt Disney Pictures' THE TIGGER MOVIE is a welcome addition to the bleak theater offerings of mid-February.
Taking full advantage of the solid Winnie the Pooh franchise, the producers have added new dimensions to many of its characters. We see the most of Tigger, of course, the namesake of the movie; he is friendly towards all the inhabitants of the Hundred Acre Wood. What's charming is that this treatment creates a close friendship between Tigger and Roo, the tiny son of Kanga, and the most child-like character, besides Tigger himself.
The main plot of the film has Tigger yearning for a family of his own: it's no longer the most wonderful thing about Tiggers, that he's the only one!
At first the group of animal friends goes off on little sorties, searching for other Tiggers, as though they are convinced of their existence. Finally - and this is perfect - the friends agree to write a letter to Tigger, from his family; the pompous Owl wields the pen, and the letter is co-written, one line from each of the major characters. It's heartfelt advice, stuff like "Eat well" (Pooh-bear's contribution), "Stay safe and sound," and other sentiments, reveals much about the true and important feeling imparted by membership in a family unit. Soon the letter is on its way, and Tigger is indeed convinced that his family is real. When Tigger readies his ramshackle house for a welcoming party, his motley friends end up donning Tigger costumes and try to trick their overactive tiger-like pal. Some of the most cinematically stunning effects in any Pooh installment follow Tigger's disappointment at discovering he's been hoodwinked by his overzealous pals.
The voices are among the most engaging aspects of the movie. Jim Cummings has done Pooh's voice since 1987, emulating well the hoarse mildness of the late Sterling Holloway. Now he has assumed the duties of Tigger as well, after Disney's dismissal of the inimitable Paul Winchell. It is amazing, however, how much Cummings sounds like the persona created by Winchell. The inflections, wacky asides and "hoo-hoo" laughter is nearly dead-on.
Nine year-old Nikita Hopkins supplies the voice of Roo, an innocent and likable voice that's perfectly cast. Kanga is Kath Soucie, the ever-patient and loving mother-figure.
Peter Cullen does a nice job with the pessimistic Eeyore, an amusing droop to his voice. Owl is voiced by Andre Stojka, a nice edge of pretension to his depiction. Tom Attenborough does not get much screen time as Christopher Robin, the human owner of the "dolls" that live in the Hundred Acre Wood. And veteran actor John Hurt does a decent turn as the narrator. I liked how this incarnation preserves the 1960's narrative technique of showing a storybook, letters and words pouring off the page at times. But Hurt is not used enough to exert a strong presence in the story.
The sole carry-over from the old cast (which originated the Disney version of A. A. Milne's classic stories with the Academy Award-winning short "Winnie the Pooh and the Blustery Day" in 1968) is John Fielder as Piglet, whose voice is even more light and humble than Pooh's. Long experience has added a subtle sheen of sympathy to the voice of the friendly little pig.
Another star is the animation. Much of it was done at Disney's Japan animation center, with other parts being shared around the globe. Featured are muted colors - hues that compliment well the simple and heart-warming narrative line. The green pastel trees and stylized backgrounds are unmistakably Disney, a quaint throwback mix of the "Disneyfied" and "Classic Pooh" styles in some ways.
Music is also excellent. The original team that has done all the music for previous Poohs is back: Richard M. Sherman and brother Robert B. Sherman. The pace and lyrics and overall effect of their original songs add a good deal to the enjoyment factor. Kenny Loggins collaborated on the closing ballad, while Harry Gregson-Williams capably supplied the rest of the score.
The film is rated G, another rare and welcome element in today's viewing culture. It is very watchable for all ages, as the story moves quickly forward, not without a generous sprinkling of wit along the way. See it now with a child or without; it's one of those films you will never be sorry you sat through!
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Postmodern Reference Manual
Table of Contents
- Connecting
- class database-connection
- function connect (database user password host &key (port 5432) pooled-p use-ssl)
- variable default-use-ssl
- method disconnect (database-connection)
- function connected-p (database-connection)
- method reconnect (database-connection)
- variable database
- macro with-connection (spec &body body)
- macro call-with-connection (spec thunk)
- function connect-toplevel (database user password host &key (port 5432))
- function disconnect-toplevel ()
- function clear-connection-pool ()
- variable max-pool-size
- function list-connections ()
- Querying
- macro query (query &rest args/format)
- macro execute (query &rest args)
- macro doquery (query (&rest names) &body body)
- macro prepare (query &optional (format :rows))
- macro defprepared (name query &optional (format :rows))
- macro defprepared-with-names (name (&rest args) (query &rest query-args) &optional (format :rows))
- macro with-transaction ((&optional name isolation-level) &body body)
- function commit-transaction (transaction)
- function abort-transaction (transaction)
- macro with-savepoint (name &body body)
- function release-savepoint (savepoint)
- function rollback-savepoint (savepoint)
- function commit-hooks (transaction-or-savepoint), setf (commit-hooks transaction-or-savepoint)
- function abort-hooks (transaction-or-savepoint), setf (abort-hooks transaction-or-savepoint)
- macro with-logical-transaction ((&optional name isolation-level) &body body)
- function abort-logical-transaction (transaction-or-savepoint)
- function commit-logical-transaction (transaction-or-savepoint)
- variable current-logical-transaction
- macro ensure-transaction (&body body)
- macro with-schema ((namespace &key :strict t :if-not-exist :create :drop-after) &body body)
- function sequence-next (sequence)
- function coalesce (&rest arguments)
- Inspecting the database
- function list-tables (&optional strings-p)
- function list-tables-in-schema (&optional strings-p)
- function table-exists-p (name)
- function table-description (name &optional schema-name)
- function list-sequences (&optional strings-p)
- function sequence-exists-p (name)
- function list-views (&optional strings-p)
- function view-exists-p (name)
- function list-schemata ()
- function schema-exist-p (schema) NOW DEPRECATED IN FAVOR OF schema-exists-p which is more consistent with naming of other functions.
- function schema-exists-p (schema)
- function database-version ()
- function num-records-in-database ()
- function current-database ()
- function database-exists-p (database-name)
- function database-size (&optional database-name)
- function list-databases (&key (order-by-size nil) (size t))
- function list-schemas ()
- function list-tablespaces ()
- function list-available-types ()
- function list-table-sizes (&key (schema "public") (order-by-size nil) (size t))
- function table-size (table-name)
- function more-table-info (table-name)
- function list-columns (table-name)
- function list-columns-with-types (table-name)
- function column-exists-p (table-name column-name)
- function describe-views (&optional (schema "public")
- function list-database-functions ()
- function list-indices (&optional strings-p)
- function list-table-indices (table-name &optional strings-p)
- function index-exists-p (name)
- function list-indexed-column-and-attributes (table-name)
- function list-index-definitions (table-name)
- function find-primary-key-info (table-name &optional (just-key nil))
- function list-foreign-keys (table-name)
- function list-unique-or-primary-constraints (table-name)
- function list-all-constraints (table-name)
- function describe-constraint (table-name constraint-name)
- function describe-foreign-key-constraints ()
- function list-triggers (&optional table-name)
- function list-detailed-triggers ()
- function list-database-users ()
- function list-available-extensions ()
- function list-installed-extensions ()
- function change-toplevel-database (new-database user password host)
- Database access objects
- metaclass dao-class
- method dao-keys (class)
- method dao-keys (dao)
- method dao-exists-p (dao)
- method make-dao (type &rest args &key &allow-other-keys)
- macro define-dao-finalization (((dao-name class) &rest keyword-args) &body body)
- method get-dao (type &rest keys)
- macro select-dao (type &optional (test t) &rest sort)
- macro do-select-dao (((type type-var) &optional (test t) &rest sort) &body body)
- macro query-dao (type query &rest args)
- function do-query-dao (((type type-var) query &rest args) &body body)
- variable ignore-unknown-columns
- method insert-dao (dao)
- method update-dao (dao)
- function save-dao (dao)
- function save-dao/transaction (dao)
- method upsert-dao (dao)
- method delete-dao (dao)
- function dao-table-name (class)
- function dao-table-definition (class)
- macro with-column-writers ((&rest writers) &body body)
- Table definition and creation
- macro deftable (name &body definition)
- function !dao-def ()
- function !index (&rest columns), !unique-index (&rest columns)
- function !foreign (target-table columns &optional target-columns &key on-delete on-update deferrable initially-deferred)
- function !unique (target-fields &key deferrable initially-deferred)
- function create-table (symbol)
- function create-all-tables ()
- function create-package-tables (package)
- variables table-name, table-symbol
- Schemata
This is the reference manual for the component named postmodern, which is part of a library of the same name.
Note that this package also exports the database-connection and database-error types from CL-postgres and a few operators from S-SQL.
query, execute, and any other function that would logically need to communicate with the database will raise a condition of the type database-error when something goes wrong. As a special case, errors that break the connection (socket errors, database shutdowns) will be raised as subtypes of database-connection-error, providing a :reconnect restart to re-try the operation that encountered to the error.
Connecting
class database-connection
Objects of this type represent database connections.
function connect (database user password host &key (port 5432) pooled-p use-ssl)
→ database-connection
Create a new database connection for the given user and the database. Port will default to 5432, which is where most PostgreSQL servers are running. If pooled-p is T, a connection will be taken from a pool of connections of this type, if one is available there, and when the connection is disconnected it will be put back into this pool instead. use-ssl can be :no, :yes, or :try, as in open-database, and defaults to the value of default-use-ssl.
variable default-use-ssl
The default for connect's use-ssl argument. This starts at :no. If you set it to anything else, be sure to also load the CL+SSL library.
method disconnect (database-connection)
Disconnects a normal database connection, or moves a pooled connection into the pool.
function connected-p (database-connection)
→ boolean
Returns a boolean indicating whether the given connection is still connected to the server.
method reconnect (database-connection)
Reconnect a disconnected database connection. This is not allowed for pooled connections ― after they are disconnected they might be in use by some other process, and should no longer be used.
variable database
Special variable holding the current database. Most functions and macros operating on a database assume this binds to a connected database.
macro with-connection (spec &body body)
Evaluates the body with database bound to a connection as specified by spec, which should be list that connect can be applied to.
macro call-with-connection (spec thunk)
The functional backend to with-connection. Binds database to a new connection as specified by spec, which should be a list that connect can be applied to, and runs the zero-argument function given as second argument in the new environment. When the function returns or throws, the new connection is disconnected.
function connect-toplevel (database user password host &key (port 5432))
Bind the database to a new connection. Use this if you only need one connection, or if you want a connection for debugging from the REPL.
function disconnect-toplevel ()
Disconnect the database.
function clear-connection-pool ()
Disconnect and remove all connections from the connection pools.
variable max-pool-size
Set the maximum amount of connections kept in a single connection pool, where a pool consists of all the stored connections with the exact same connect arguments. Defaults to NIL, which means there is no maximum.
function list-connections ()
→ list
List the current postgresql connections to the currently connected database.
Querying
macro query (query &rest args/format)
→ result
Execute the given query, which can be either a string or an S-SQL form (list starting with a keyword). If the query contains placeholders ($1, $2, etc) their values can be given as extra arguments. If one of these arguments is a keyword occurring in the table below, it will not be used as a query argument, but will determine the format in which the results are returned instead. Any of the following formats can be used, with the default being :rows:
| :none | Ignore the result values. |
| :lists, :rows | Return a list of lists, each list containing the values for a row. |
| :list, :row | Return a single row as a list. |
| :alists | Return a list of alists which map column names to values, with the names represented as keywords. |
| :alist | Return a single row as an alist. |
| :str-alists | Like :alists, but use the original column names. |
| :str-alist | Return a single row as an alist, with strings for names. |
| :plists | Return a list of plists which map column names to values,with the names represented as keywords. |
| :plist | Return a single row as a plist. |
| :column | Return a single column as a list. |
| :single | Return a single value. |
| :single! | Like :single, but raise an error when the number of selected rows is not equal to 1. |
| (:dao type) | Return a list of DAOs of the given type. The names of the fields returned by the query must match slots in the DAO class the same way as with query-dao. |
| (:dao type :single) | Return a single DAO of the given type. |
If the database returns information about the amount rows that were affected, such as with updating or deleting queries, this is returned as a second value.
macro execute (query &rest args)
Like query called with format :none. Returns the amount of affected rows as its first returned value. (Also returns this amount as the second returned value, but use of this is deprecated.)
macro doquery (query (&rest names) &body body)
Execute the given query (a string or a list starting with a keyword), iterating over the rows in the result. The body will be executed with the values in the row bound to the symbols given in names. To iterate over a parameterised query, one can specify a list whose car is the query, and whose cdr contains the arguments. For example:
(doquery (:select 'name 'score :from 'scores) (n s) (incf (gethash n *scores*) s)) (doquery ((:select 'name :from 'scores :where (:> 'score '$1)) 100) (name) (print name))
macro prepare (query &optional (format :rows))
→ function
Creates a function that can be used as the interface to a prepared statement. The given query (either a string or an S-SQL form) may contain placeholders, which look like $1, $2, etc. The resulting function takes one argument for every placeholder in the query, executes the prepared query, and returns the result in the format specified. (Allowed formats are the same as for query.)
For queries that have to be run very often, especially when they are complex, it may help performance since the server only has to plan them once. See the PostgreSQL manual for details.
In some cases, the server will complain about not being able to deduce the type of the arguments in a statement. In that case you should add type declarations (either with the PostgreSQL's CAST SQL-conforming syntax or historical :: syntax, or with S-SQL's :type construct) to help it out.
macro defprepared (name query &optional (format :rows))
This is the defun-style variant of prepare. It will define a top-level function for the prepared statement.
macro defprepared-with-names (name (&rest args) (query &rest query-args) &optional (format :rows))
Like defprepared, but allows to specify names of the function arguments as well as arguments supplied to the query.
(defprepared-with-names user-messages (user &key (limit 10)) ("select * from messages where user_id = $1 order by date desc limit $2" (user-id user) limit) :plists)
macro with-transaction ((&optional name isolation-level) &body body)
Execute the given body within a database transaction, committing it when the body exits normally, and aborting otherwise. An optional name and/or isolation-level can be given to the transaction. The name can be used to force a commit or abort before the body unwinds. The isolation-level will set the isolation-level used by the transaction.
You can specify the following isolation levels in postmodern transactions:
- :read-committed-rw (read committed with read and write)
- :read-committed-ro (read committed with read only)
- :repeatable-read-rw (repeatable read with read and write)
- :repeatable-read-ro (repeatable read with read only)
- :serializable (serializable with reand and write)
Sample usage where "george" is just the name given to the transaction (not quoted or a string) and … simply indicates other statements would be expected here:
(with-transaction () (execute (:insert-into 'test-data :set 'value 77)) ...) (with-transaction (george) (execute (:insert-into 'test-data :set 'value 22)) ...) (with-transaction (george :read-committed-rw) (execute (:insert-into 'test-data :set 'value 33)) (query (:select '* :from 'test-data)) ...) (with-transaction (:serializable) (execute (:insert-into 'test-data :set 'value 44)) ...)
Further discussion of transactions and isolation levels can found here.
function commit-transaction (transaction)
Commit the given transaction.
function abort-transaction (transaction)
Roll back the given transaction.
macro with-savepoint (name &body body)
Can only be used within a transaction. Establishes a savepoint with the given name at the start of body, and binds the same name to a handle for that savepoint. At the end of body, the savepoint is released, unless a condition is thrown, in which case it is rolled back.
function release-savepoint (savepoint)
Release the given savepoint.
function rollback-savepoint (savepoint)
Roll back the given savepoint.
function commit-hooks (transaction-or-savepoint), setf (commit-hooks transaction-or-savepoint)
An accessor for the transaction or savepoint's list of commit hooks, each of which should be a function with no required arguments. These functions will be executed when a transaction is committed or a savepoint released.
function abort-hooks (transaction-or-savepoint), setf (abort-hooks transaction-or-savepoint)
An accessor for the transaction or savepoint's list of abort hooks, each of which should be a function with no required arguments. These functions will be executed when a transaction is aborted or a savepoint rolled back (whether via a non-local transfer of control or explicitly by either abort-transaction or rollback-savepoint).
macro with-logical-transaction ((&optional name isolation-level) &body body)
Executes body within a with-transaction form if no transaction is currently in progress, otherwise simulates a nested transaction by executing it within a with-savepoint form. The transaction or savepoint is bound to name if one is supplied. The isolation-level will set the isolation-level used by the transaction.
You can specify the following isolation levels in postmodern transactions:
- :read-committed-rw (read committed with read and write)
- :read-committed-ro (read committed with read only)
- :repeatable-read-rw (repeatable read with read and write)
- :repeatable-read-ro (repeatable read with read only)
- :serializable (serializable with reand and write)
Sample usage where "george" is just the name given to the transaction (not quoted or a string) and … simply indicates other statements would be expected here:
(with-logical-transaction () (execute (:insert-into 'test-data :set 'value 77)) ...) (with-logical-transaction (george) (execute (:insert-into 'test-data :set 'value 22)) ...) (with-logical-transaction (george :read-committed-rw) (execute (:insert-into 'test-data :set 'value 33)) ...) (with-logical-transaction (:serializable) (execute (:insert-into 'test-data :set 'value 44)) ...)
function abort-logical-transaction (transaction-or-savepoint)
Roll back the given logical transaction, regardless of whether it is an actual transaction or a savepoint.
function commit-logical-transaction (transaction-or-savepoint)
Commit the given logical transaction, regardless of whether it is an actual transaction or a savepoint.
variable current-logical-transaction
This is bound to the current transaction-handle or savepoint-handle instance representing the innermost open logical transaction.
macro ensure-transaction (&body body)
Ensures that body is executed within a transaction, but does not begin a new transaction if one is already in progress.
macro with-schema ((namespace &key :strict t :if-not-exist :create :drop-after) &body body)
Sets the current schema to namespace and executes the body. Before executing body the PostgreSQL's session variable search_path is set to the given namespace. After executing body the search_path variable is restored to the original value. If the keyword :strict is set to T then the namespace is only the scheme on the search path upon the body execution. Otherwise the namespace is just first schema on the search path upon the the body execution. If :if-not-exist is NIL, an error is signaled. If :drop-after is T the namespace is dropped from the database after the body execution.
function sequence-next (sequence)
→ integer
Get the next value from a sequence. The sequence identifier can be either a string or a symbol, in the latter case it will be converted to a string according to S-SQL rules.
function coalesce (&rest arguments)
→ value
Returns the first non-NIL, non-NULL (as in :null) argument, or NIL if none are present. Useful for providing a fall-back value for the result of a query, or, when given only one argument, for transforming :nulls to NIL.
Inspecting the database
function list-tables (&optional strings-p)
→ list
Returns a list of the tables in the current database and schema. When strings-p is T, the names will be given as strings, otherwise as keywords.
function list-tables-in-schema (&optional strings-p)
→ list
Returns a list of the tables in the current database and the specified schema. When strings-p is T,the names will be given as strings, otherwise as keywords.
function table-exists-p (name)
→ boolean
Tests whether a table with the given name exists. The name can be either a string or a symbol. It can also be qualified in the form of 'schema.table or 'database.schema.table
function table-description (name &optional schema-name)
→ list
Returns a list of the fields in the named table. Each field is represented by a list of three elements: the field name, the type, and a boolean indicating whether the field may be NULL. Optionally, schema-name can be specified to restrict the result to fields from the named schema. Without it, all fields in the table are returned, regardless of their schema.
function list-sequences (&optional strings-p)
→ list
Returns a list of the sequences in the current database. When strings-p is T, the names will be given as strings, otherwise as keywords.
function sequence-exists-p (name)
→ boolean
Tests whether a sequence with the given name exists. The name can be either a string or a symbol.
function list-views (&optional strings-p)
→ list
Returns list of the user defined views in the current database. When strings-p is T, the names will be returned as strings, otherwise as keywords.
function view-exists-p (name)
→ boolean
Tests whether a view with the given name exists. The name can be either a string or a symbol.
function list-schemata ()
→ list
Returns list of the user defined schemata (as strings) and the quantity of existing schemata.
function schema-exist-p (schema) NOW DEPRECATED IN FAVOR OF schema-exists-p which is more consistent with naming of other functions.
→ boolean
Tests the existence of a given schema. Returns T if the schema exists or NIL otherwise.
function schema-exists-p (schema)
→ boolean
Tests the existence of a given schema. Returns T if the schema exists or NIL otherwise.
function database-version ()
→ string
Returns the version of the current postgresql database.
function num-records-in-database ()
→ list
Returns a list of lists with schema, table name and approximate number of records in the currently connected database.
function current-database ()
→ string
Returns the string name of the current database.
function database-exists-p (database-name)
→ boolean
Checks to see if a particular database exists.
function database-size (&optional database-name)
→ list
Given the name of a database, will return the name, a pretty-print string of the size of the database and the size in bytes. If a database name is not provided, it will return the result for the currently connected database.
function list-databases (&key (order-by-size nil) (size t))
→ list
Returns a list of lists where each sub-list contains the name of the database, a pretty-print string of the size of that database and the size in bytes. The default order is by database name. Pass t as a parameter to :order-by-size for order by size. Setting size to nil will return just the database names in a single list ordered by name. This function excludes the template databases
function list-schemas ()
→ list
List schemas in the current database, excluding the pg_* system schemas.
function list-tablespaces ()
→ list
Lists the tablespaces in the currently connected database.
function list-available-types ()
→ list
List the available types in this postgresql version.
function list-table-sizes (&key (schema "public") (order-by-size nil) (size t))
→ list
Returns a list of lists (table-name, size in 8k pages) of tables in the current database. Providing a name to the schema parameter will return just the information for tables in that schema. It defaults to just the tables in the public schema. Setting schema to nil will return all tables, indexes etc in the database in descending order of size. This would include system tables, so there are a lot more than you would expect. If :size is set to nil, it returns only a flat list of table names. Setting order-by-size to t will return the result in order of size instead of by table name.
function table-size (table-name)
→ list
Return the size of a postgresql table in k or m. Table-name can be either a string or quoted.
function more-table-info (table-name)
→ list
Returns more table info than table-description. Table can be either a string or quoted.
function list-columns (table-name)
→ list
Returns a list of strings of just the column names in a table. Pulls info from the postmodern table-description function rather than directly.
function list-columns-with-types (table-name)
→ list
Return a list of (name type) lists for the fields of a table. Goes directly to the pg-catalog tables.
function column-exists-p (table-name column-name)
→ boolean
Determine if a particular column exists. Table name and column-name can be either strings or symbols.
function describe-views (&optional (schema "public")
→ list
Describe the current views in the specified schema. Defaults to public schema.
function list-database-functions ()
→ list
Returns a list of the functions in the database from the information_schema.
function list-indices (&optional strings-p)
→ list
Return a list of the indexs in a database. Turn them into keywords if strings-p is not true.
function list-table-indices (table-name &optional strings-p)
→ list
List the index names and the related columns in a table.
function index-exists-p (name)
→ boolean
Tests whether an index with the given name exists. The name can be either a string or a symbol.
function list-indexed-column-and-attributes (table-name)
→ list
List the indexed columns and their attributes in a table. Includes primary key.
function list-index-definitions (table-name)
→ list
Returns a list of the definitions used to create the current indexes for the table
function find-primary-key-info (table-name &optional (just-key nil))
→ list
Returns a list of two strings. First the column name of the primary key of the table and second the string name for the datatype. Optionally, just-key can be set to t and it will return just the column name of the primary key as a string.
function list-foreign-keys (table-name)
→ list
Returns a list of sublists of foreign key info in the form of '((constraint-name local-table local-table-column foreign-table-name foreign-column-name))
function list-unique-or-primary-constraints (table-name)
→ list
List constraints on a table.
function list-all-constraints (table-name)
→ list
Users information_schema to list all the constraints in a table. Table-name can be either a string or quoted.
function describe-constraint (table-name constraint-name)
→ list
Return a list of alists of the descriptions a particular constraint given the table-name and the constraint name using the information_schema table.
function describe-foreign-key-constraints ()
→ list
Generates a list of lists of information on the foreign key constraints
function list-triggers (&optional table-name)
→ list
List distinct trigger names from the information_schema table. Table-name can be either quoted or string.
function list-detailed-triggers ()
→ list
List detailed information on the triggers from the information_schema table.
function list-database-users ()
→ list
List database users.
function list-available-extensions ()
→ list
List the postgresql extensions which are available in the system to the currently connected database. The extensions may or may not be installed.
function list-installed-extensions ()
→ list
List the postgresql extensions which are installed in the currently connected database.
function change-toplevel-database (new-database user password host)
→ string
Just changes the database assuming you are using a toplevel connection. Recommended only for development work. Returns the name of the newly connected database as a string.
Database access objects
Postmodern contains a simple system for defining CLOS classes that represent rows in the database. This is not intended as a full-fledged object-relational magic system ― while serious ORM systems have their place, they are notoriously hard to get right, and are outside of the scope of a humble SQL library like this.
metaclass dao-class
At the heart of Postmodern's DAO system is the dao-class metaclass. It allows you to define classes for your database-access objects as regular CLOS classes. Some of the slots in these classes will refer to columns in the database. To specify that a slot refers to a column, give it a :col-type option containing an S-SQL type expression (useful if you want to be able to derive a table definition from the class definition), or simply a :column option with value T. Such slots can also take a :col-default option, used to provide a database-side default value as an S-SQL expression. You can use the :col-name initarg (whose unevaluated value will be passed to to-sql-name) to specify the slot's column's name.
DAO class definitions support two extra class options: :table-name to give the name of the table that the class refers to (defaults to the class name), and :keys to provide a set of primary keys for the table. When no primary keys are defined, operations such as update-dao and get-dao will not work.
IMPORTANT: Class finalization for a dao class instance are wrapped with a thread lock. However, any time you are using threads and a class that inherits from other classes, you should ensure that classes are finalized before you start generating threads that create new instances of that class.
Simple example:
(defclass user () ((name :col-type string :initarg :name :accessor user-name) (creditcard :col-type (or db-null integer) :initarg :card :col-default :null) (score :col-type bigint :col-default 0 :accessor user-score)) (:metaclass dao-class) (:keys name))
The (or db-null integer) form is used to indicate a column can have NULL values.
When inheriting from DAO classes, a subclass' set of columns also contains all the columns of its superclasses. The primary key for such a class is the union of its own keys and all the keys from its superclasses. Classes inheriting from DAO classes should probably always use the dao-class metaclass themselves.
When a DAO is created with make-instance, the :fetch-defaults keyword argument can be passed, which, when T, will cause a query to fetch the default values for all slots that refers to columns with defaults and were not bound through initargs. In some cases, such as serial columns, which have an implicit default, this will not work. You can work around this by creating your own sequence, e.g. "my_sequence", and defining a (:nextval "my_sequence") default.
Finally, DAO class slots can have an option :ghost t to specify them as ghost slots. These are selected when retrieving instances, but not written when updating or inserting, or even included in the table definition. The only known use for this to date is for creating the table with (oids=true), and specify a slot like this:
(oid :col-type integer :ghost t :accessor get-oid)
method dao-keys (class)
→ list
Returns list of slot names that are the primary key of DAO class. This is likely interesting if you have primary keys which are composed of more than one slot. Pay careful attention to situations where the primary key not only has more than one column, but they are actually in a different order than they are in the database table itself. You can check this with the find-primary-key-info function.
(pomo:find-primary-key-info "country1") (("name" "text") ("id" "integer"))
method dao-keys (dao)
→ list
Returns list of values that are the primary key of dao.
method dao-exists-p (dao)
→ boolean
Test whether a row with the same primary key as the given dao exists in the database. Will also return NIL when any of the key slots in the object are unbound.
method make-dao (type &rest args &key &allow-other-keys)
→ dao
Combines make-instance with insert-dao. Return the created dao.
macro define-dao-finalization (((dao-name class) &rest keyword-args) &body body)
Create an :around-method for make-dao. The body is executed in a lexical environment where dao-name is bound to a freshly created and inserted DAO. The representation of the DAO in the database is then updated to reflect changes that body might have introduced. Useful for processing values of slots with the type serial, which are unknown before insert-dao.
method get-dao (type &rest keys)
→ dao
Select the DAO object from the row that has the given primary key values, or NIL if no such row exists. Objects created by this function will have initialize-instance called on them (after loading in the values from the database) without any arguments ― even :default-initargs are skipped. The same goes for select-dao and query-dao.
macro select-dao (type &optional (test t) &rest sort)
→ list
Select DAO objects for the rows in the associated table for which the given test (either an S-SQL expression or a string) holds. When sorting arguments are given, which can also be S-SQL forms or strings, these are used to sort the result.
(Note that, if you want to sort, you have to pass the test argument.)
(select-dao 'user (:> 'score 10000) 'name)
macro do-select-dao (((type type-var) &optional (test t) &rest sort) &body body)
Like select-dao, but iterates over the results rather than returning them. For each matching DAO, body is evaluated with type-var bound to the DAO instance.
(do-select-dao (('user user) (:> 'score 10000) 'name) (pushnew user high-scorers))
macro query-dao (type query &rest args)
→ list
Execute the given query (which can be either a string or an S-SQL expression) and return the result as DAOs of the given type. If the query contains placeholders ($1, $2, etc) their values can be given as extra arguments. The names of the fields returned by the query must either match slots in the DAO class, or be bound through with-column-writers.
function do-query-dao (((type type-var) query &rest args) &body body)
→ list
Like query-dao, but iterates over the results rather than returning them. For each matching DAO, body is evaluated with type-var bound to the instance.
(do-query-dao (('user user) (:order-by (:select '* :from 'user :where (:> 'score 10000)) 'name)) (pushnew user high-scorers))
variable ignore-unknown-columns
Normally, when get-dao, select-dao, or query-dao finds a column in the database that's not in the DAO class, it will raise an error. Setting this variable to a non-NIL will cause it to simply ignore the unknown column.
method insert-dao (dao)
→ dao
Insert the given dao into the database. Column slots of the object which are unbound implies the database defaults. Hence, if these columns has no defaults defined in the database, the the insertion of the dao will be failed. (This feature only works on PostgreSQL 8.2 and up.)
method update-dao (dao)
→ dao
Update the representation of the given dao in the database to the values in the object. This is not defined for tables that do not have any non-primary-key columns. Raises an error when no row matching the dao exists.
function save-dao (dao)
→ boolean
Tries to insert the given dao using insert-dao. If this raises a unique key violation error, it tries to update it by using update-dao instead. Be aware that there is a possible race condition here ― if some other process deletes the row at just the right moment, the update fails as well. Returns a boolean telling you whether a new row was inserted.
This function is unsafe to use inside of a transaction ― when a row with the given keys already exists, the transaction will be aborted. Use save-dao/transaction instead in such a situation.
See also: upsert-dao.
function save-dao/transaction (dao)
→ boolean
Acts exactly like save-dao, except that it protects its attempt to insert the object with a rollback point, so that a failure will not abort the transaction.
See also: upsert-dao.
method upsert-dao (dao)
→ dao
Like save-dao or save-dao/transaction but using a different method that doesn't involve a database exception. This is safe to use both in and outside a transaction, though it's advisable to always do it in a transaction to prevent a race condition. The way it works is:
If the object contains unbound slots, we call insert-dao directly, thus the behavior is like save-dao.
Otherwise we try to update a record with the same primary key. If the PostgreSQL returns a non-zero number of rows updated it treated as the record is already exists in the database, and we stop here.
If the PostgreSQL returns a zero number of rows updated, it treated as the record does not exist and we call insert-dao.
The race condition might occur at step 3 if there's no transaction: if UPDATE returns zero number of rows updated and another thread inserts the record at that moment, the insertion implied by step 3 will fail.
Note, that triggers and rules may affect the number of inserted or updated rows returned by PostgreSQL, so zero or non-zero number of affected rows may not actually indicate the existence of record in the database.
This method returns two values: the DAO object and a boolean (T if the object was inserted, NIL if it was updated).
method delete-dao (dao)
Delete the given dao from the database.
function dao-table-name (class)
→ string
Get the name of the table associated with the given DAO class (or symbol naming such a class).
function dao-table-definition (class)
→ string
Given a DAO class, or the name of one, this will produce an SQL query string with a definition of the table. This is just the bare simple definition, so if you need any extra indices or or constraints, you'll have to write your own queries to add them, in which case look to s-sql's create-table function.
macro with-column-writers ((&rest writers) &body body)
Provides control over the way get-dao, select-dao, and query-dao read values from the database. This is not commonly needed, but can be used to reduce the amount of queries a system makes. writers should be a list of alternating column names (strings or symbols) and writers, where writers are either symbols referring to a slot in the objects, or functions taking two arguments ― an instance and a value ― which can be used to somehow store the value in the new instance. When any DAO-fetching function is called in the body, and columns matching the given names are encountered in the result, the writers are used instead of the default behaviour (try and store the value in the slot that matches the column name).
An example of using this is to add some non-column slots to a DAO class, and use query-dao within a with-column-writers form to pull in extra information about the objects, and immediately store it in the new instances.
Table definition and creation
It can be useful to have the SQL statements needed to build an application's tables available from the source code, to do things like automatically deploying a database. The following macro and functions allow you to group sets of SQL statements under symbols, with some shortcuts for common elements in table definitions.
macro deftable (name &body definition)
Define a table. name can be either a symbol or a (symbol string) list. In the first case, the table name is derived from the symbol's name by S-SQL's rules. In the second case, the name is given explicitly. The body of definitions can contain anything that evaluates to a string, as well as S-SQL expressions. The variables table-name and table-symbol are bound to the relevant values in the body. Note that the evaluation of the definition is ordered, so you'll generally want to create your table first and then define indices on it.
function !dao-def ()
Should only be used inside deftable's body. Adds the result of calling dao-table-definition on table-symbol to the definition.
function !index (&rest columns), !unique-index (&rest columns)
Define an index on the table being defined. The columns can be given as symbols or strings.
function !foreign (target-table columns &optional target-columns &key on-delete on-update deferrable initially-deferred)
Add a foreign key to the table being defined. target-table is the referenced table. columns is a list of column names or single name in this table, and, if the columns have different names in the referenced table, target-columns must be another list of column names or single column name of the target-table, or :primary-key to denote the column(s) of the target-table's primary key as referenced column(s).
The on-delete and on-update arguments can be used to specify ON DELETE and ON UPDATE actions, as per the keywords allowed in create-table. In addition, the deferrable and initially-deferred arguments can be used to indicate whether constraint checking can be deferred until the current transaction completed, and whether this should be done by default. Note that none of these are really &key arguments, but rather are picked out of a &rest arg at runtime, so that they can be specified even when target-columns is not given.
function !unique (target-fields &key deferrable initially-deferred)
Constrains one or more columns to only contain unique (combinations of) values, with deferrable and initially-deferred defined as in !foreign
function create-table (symbol)
Creates the table identified by symbol by executing all forms in its definition.
function create-all-tables ()
Creates all defined tables.
function create-package-tables (package)
Creates all tables identified by symbols interned in the given package.
variables table-name, table-symbol
These variables are bound to the relevant name and symbol while the forms of a table definition are evaluated. Can be used to define shorthands like the ones below.
Schemata
Schema allow you to separate tables into differnet name spaces. In different schemata two tables with the same name are allowed to exists. The tables can be referred by fully qualified names or with the macro with-schema. You could also set the search path with set-search-path. For listing end checking there are also the functions list-schemata and schema-exist-p. The following functions allow you to create, drop schemata and to set the search path.
function create-schema (schema)
Creates a new schema. Raises an error if the schema is already exists.
function drop-schema (schema)
Removes a schema. Raises an error if the schema is not empty.
function get-search-path ()
Retrieve the current search path.
function set-search-path (path)
Sets the search path to the path. This function is used by with-schema.
function split-fully-qualified-table-name (name)
→ list Takes a name of the form database.schema.table or schema.table or just table and returns a list in the form '(table schema database)


Resolving synchronization issue.
You may take this text as a copied and pasted one, but it is not so. Appearances are deceitful. For real, this text was created by our copywriters, so you could see in details how would the final product look•••
16-07-2014
7 Comments


Main
Hello, how are you doing, journal? Well, it's been a long day, hasn't it? I need to tell you a story.
Earlier today I was exploring a museum in the unexplained mysteries section. I found an odd lever on the side of an amazing clay figure. I pulled the lever and oh my G-O-S-H! A passage appeared right where I was standing!


| First row/column |
|---|
| Second row |
| Third row |
| Fourth row |
| Fifth row |
| First column | Second column | Third column | Fourth column | Fifth column | Sixth column |
|---|---|---|---|---|---|
| First column | Second column | Third column | Fourth column | Fifth column | Sixth column |
| First column | Second column | Third column | Fourth column | Fifth column | Sixth column |
| First column | Second column | Third column | Fourth column | Fifth column | Sixth column |
| First column | Second column | Third column | Fourth column | Fifth column | Sixth column |


Page could not be loaded. Please try again later.
Refresh the page
Discord needs to be online. It looks like you're not.


{% include assignment/head.html %}
{% include assignment/header.html %} {% include assignment/call_info.html %} {% include assignment/footer.html %} {% include assignment/js.html %}


EasyTOI
Menu
Download
Features
Services
Contact
EasyTOI is a... beschreibung...
Download.
Download
inhalt features...
Features
inhalt features...
Services
inhalt services....
Contact Us
Be a Smarthome User
text für user...
us, like us.
Be a Manufacturer
text für kunden...
Send Message


WITNESS LIST Finance Committee April 6, 1999-9:00A Agricultural Experiment Station On: Hiler, Edward A. (Texas Agricultural Experiment Station), College Station Agricultural Extension Service On: Fehlis, Chester (Texas Agricultural Extension Service), College Station Engineering Experiment Station THIS LIST HAS NO WITNESSES. Engineering Extension Service On: Bennett, G. Kemble (Texas Engineering Extension Service), College Station Prock, Robert (Texas Engineering Extension Service), Bryan Forest Service THIS LIST HAS NO WITNESSES. General Academic Institutions THIS LIST HAS NO WITNESSES. Health-Related Institutions THIS LIST HAS NO WITNESSES. Transportation Institute On: Richardson, Herbert (Texas Transportation Institute), city not given Veterinary Medical Diagnostic Lab THIS LIST HAS NO WITNESSES. Wildlife Damage Management Service THIS LIST HAS NO WITNESSES.


--- layout: default title: 刘晓庆课题组-相册 categories: - photos --- {% for photo in site.categories.photos %}


Ok, we have several different scenarios and let’s say you’re the boss. In each of these scenarios we can assume that CI & CD are going to be mandatory to achieve the team’s greatest potential to deliver. So the question I’ll be attacking is, do we roll our own with Drone.io, TeamCity, continuous integration and delivery or do we get more advantage from utilizing a managed solution like CircleCI, Codeship, or related offerings. The following are the scenarios in relation to team size and project that you’re heading up:
Scenarios
Scenario 1: You have team of 4 people. All developers by trade and experienced. The team may, about 20% chance in the coming 3-6 months, grow to ~8 people, with 1-2 of those being automation experts that could prospectively manage CI/CD systems. Currently the project is just starting, and the decision on what language and tech stack has been determined and initial coding will be starting in the coming week. Currently, there is no CI/CD setup for this project.
Scenario 2: Another team has 33 developers, 4 are site reliability with 2 more working with them frequently on systems automation. No real growth for the team in the next 2-3 years. The application these developers work on has new feature development and maintenance, lot’s of ongoing maintenance. Currently there is also a fair amount of technical debt associated with the code base that needs paid off for each new feature implemented, or any significant changes during maintenance of the software. This team currently has no CI or CD of the application setup.
Scenario 3: The third team is 4 people, pairing, and they have the highest output and quality of the rest of the teams. Largely because they work well together but also they have minimal technical debt and can move quickly. The application has been under development for about 3 months and they currently have a CI process setup with Drone.io. No deployment is setup yet nor is any infrastructure or other tooling setup beyond what they’ve already setup with the Drone.io solution.
Scenario 4: Fourth scenario is a large team of 232 people. There are 9 organizations with multiple people in each of those organizations, split out to developers, project management, product development leads, and a core architecture team. Among the 232 there are also 17 people dedicated to automation and infrastructure management. This team manages one huge monolithic application that currently is built with manual build processes that are partially scripted. Of these build processes there are 11 of them, which then must be combined via some more scripts and more manual processes that are then pushed to a test development environment, where a subsequent 4 people work full time testing the test development environment.
Each of these scenarios has a clear and present need for continuous integration and delivery setup. Just for context, when I write continuous integration or continuous delivery I define these like this:
Continuous Integration - Wikipedia - Thoughtworks
…is the process of bringing together the assets of an application or service project to compile that code into a binary. In the case of JavaScript or other non-compiled language this process would include any transpiling or gathering of assets that are needed in order to execute the code via the integration process. In most cases I include unit testing, and sometimes certain types of or styles of behavior tests in a project to be included under the process of continuous integration.
Continuous Delivery - Wikipedia - Thoughtworks
…is the process of events that must be completed, in an automated fashion, after the continuous integration process to take code or a binary from the transpiled or binary state into a production environment in which it will be used or executed. This is fairly easy to outline with a services or web application, since there is an obvious way in which this code needs to be called (via http/https in a browser) but some other applications, like a CLI or desktop application are slightly more diverse in the way they may be delivered. These later applications we can safely assume have a continuous delivery process that would vary widely but be something like being packaged into an installer (in the case of OS-X a .pkg file or in the case of Windows into a .exe or .msi file.)
Also an excellent resource is available here.
Solutions & Discussion for Scenarios
Scenario 1: Considering there are 4 people, prospectively 8 at the most over the next 6 months, the team really should not spend time on putting together, automating, and building out systems they don’t absolutely need to. The emphasis with a small team needs to be lean, mean, and focused on the mission at hand. Continuous integration and delivery will help delivery that, but putting it together isn’t directly related to business value.
What to do? Well, the quickest and simplest way to get started and enable a core focus on the mission is to use a managed continuous integration and delivery provider. This is a great case to use Codeship, CircleCI, AppVeyor, or a host of providers.
Scenario 2: This is an interesting scenario in that there are people tasked with automation and what would be the effort of continuous integration and delivery. However, there are questions to ask. There are three questions that immediately come to mind. These would likely have the most weight on a managed or self-hosted CI & CD solution would be:
Would running our own CI and CD save the company money?
Does the team need specific features or capabilities inherent in self-hosted CI and CD solutions?
Would the self-hosted capabilities versus the managed enable the team to deliver more effectively?
Let’s dig through each question.
The first, is the cost question. If the team had enough demand for builds or other integration and delivery automation it is feasible that costs could be fairly huge. I myself have seen price tags in the $40-50k a month range, which more than validates self-hosting build and delivery solutions to more finely manage or even decrease costs. However, I’ll add that $40-50k does only pay for work equating to a part time effort on this work. That doesn’t go that far either. By proxy, the cost is a valid question, but it isn’t all that it’s cracked up to be. I tend to lean heavily toward using a hosted solution even if it costs 10-40% more as that cost is usually worth it to refocus efforts on business value instead of CI and CD management. Let’s say, for this 33+ person team in scenario 2, that CI and CD costs will be around $40k per month via hosted offerings and about $25k if it’s self-hosted.
The second is likely the most important that would be asked of the three. Case in point the market has provided very few .NET build solutions that are managed. This has limited the ability to gain CI and CD advantages for startups that choose .NET. This has likely been one of many reasons .NET has taken a massive nose dive in popularity over the last decade among startups. Even among the more popular build service one can use, there are certain limitations that can stop a project cold. In these cases, a team can be forced into a self-hosted option. Let’s say, for scenario 2 however there isn’t a legitimate need for self-hosted control, but some of the team think it would be a nice to have.
The third question, is more inclusive of the aforementioned other two questions plus other criteria. But just as I mentioned the team thinks it would be a nice to have that begs another question. If the team had the extra control would that give them a boost or assistance with certain CI or CD automation, or will they get into situations where someone will end up with managing or spending significant time toying about with capabilities? Would that time be worth it in the end, or be lost time sunk into something that could work without the investment? Let’s say that having full control in this situation, as if we were so fortunate to get a % of productivity increase, would give the team a 5% speed to delivery boost and 2% less bugs.
Alright, I’ve conjured up those few thougths about each of those questions. Based on the posed end statements of each questions what would you do as the boss? What would I do? Since this is a team that is largely maintaining existing software and building some features, I’d also ponder what would keep them happier. Maintaining a CI and CD system in hours or gettinga self-hosted service, then I’d look at the over under of $40k cost per month hosted or $25k self-hosted, then nice to have thought behind self-hosted, and the upside of 5% speed to deliver and 2% bugs boost. In the end here, it would come down to developer happiness, and anything, I may even mix usage. For instance a bit of Codeship and Drone.io together. Both have a similar usage style so the learning curve would be huge, but similar giving the team a conjoined experience. I’ll leave this solution in the democratic vote of the developer team.
Scenario 3: This scenario is easy for me. If someone is spending more than 30 minutes a week dealing with Drone.io management, I’d push a shift to a managed provider. However since the Drone.io solution is already in place, if the only thing people are doing is committing code, getting builds, and have their code delivered then I’m a happy camper. Drone.io would stay as the CI and CD tooling for the team.
Scenario 4: Ok, wow, this is a big team to implement for. My immediate reaction is everything will be dependent on individual teams within the big team vote. There’s no reason to force a large team of this size to use a single solution, but there’s also many downsides to using to many different technologies to implement CI and CD. Let’s say the code this 200+ person team is working on is a single language, single stack, and singular deployment path, with just a few builds occurring per hour. If that’s the case then that would change my response toward a managed and hosted solution. But with this size, it’s likely that costs are much higher, build demand is dramatically higher, and the various internal security, admin, and related management of users, individual features, and the like lend to a self-hosted internal solution to give more control over customization specific to needs.
Summary: These are just a few of the thoughts, notions, and issues that need reflected upon to make a useful and effective decision about CI and CD tooling. These scenarios I posed are merely from the perspective of team size, organization, costs, and these higher level notions are CI and CD. In a future article I’ll dive into the specifics of how CI and CD are implemented on various platforms, and we can dig even deeper into why, what, who, where, and when to implement CI and CD for your team(s). Whatever the case, CI and CD are a fundamentally and vitally important first step or ongoing step of any project. If you’d like to discuss more, feel free to reach out to me on Twitter @Adron or contact me.


Plug & Paint Basic Tools Example
The Basic Tools example is a static plugin for the Plug & Paint example. It provides a set of basic brushes, shapes, and filters. Through the Basic Tools example, we will review the four steps involved in writing a Qt plugin:
- Declare a plugin class.
- Implement the interfaces provided by the plugin.
- Export the plugin using the Q_PLUGIN_METADATA() macro.
- Build the plugin using an adequate
.pro
file.
Declaration of the Plugin Class
#include <interfaces.h> #include <QRect> #include <QObject> #include <QtPlugin> #include <QStringList> #include <QPainterPath> #include <QImage> class BasicToolsPlugin : public QObject, public BrushInterface, public ShapeInterface, public FilterInterface { Q_OBJECT Q_PLUGIN_METADATA(IID "org.qt-project.Qt.Examples.PlugAndPaint.BrushInterface" FILE "basictools.json") Q_INTERFACES(BrushInterface ShapeInterface FilterInterface)
We start by including interfaces.h
, which defines the plugin interfaces for the Plug & Paint application. For the #include
to work, we need to add an INCLUDEPATH
entry to the .pro
file with the path to the header file.
The BasicToolsPlugin
class is a QObject subclass that implements the BrushInterface
, the ShapeInterface
, and the FilterInterface
. This is done through multiple inheritance. The Q_INTERFACES()
macro is necessary to tell moc, Qt's meta-object compiler, that the base classes are plugin interfaces. Without the Q_INTERFACES()
macro, we couldn't use qobject_cast() in the Plug & Paint application to detect interfaces. For an explanation for the Q_PLUGIN_METADATA()
macro see Exporting the Plugin.
public: // BrushInterface QStringList brushes() const override; QRect mousePress(const QString &brush, QPainter &painter, const QPoint &pos) override; QRect mouseMove(const QString &brush, QPainter &painter, const QPoint &oldPos, const QPoint &newPos) override; QRect mouseRelease(const QString &brush, QPainter &painter, const QPoint &pos) override; // ShapeInterface QStringList shapes() const override; QPainterPath generateShape(const QString &shape, QWidget *parent) override; // FilterInterface QStringList filters() const override; QImage filterImage(const QString &filter, const QImage &image, QWidget *parent) override; };
In the public
section of the class, we declare all the functions from the three interfaces.
Implementation of the Brush Interface
Let's now review the implementation of the BasicToolsPlugin
member functions inherited from BrushInterface
.
QStringList BasicToolsPlugin::brushes() const { return QStringList() << tr("Pencil") << tr("Air Brush") << tr("Random Letters"); }
The brushes()
function returns a list of brushes provided by this plugin. We provide three brushes: Pencil, Air Brush, and Random Letters.
QRect BasicToolsPlugin::mousePress(const QString &brush, QPainter &painter, const QPoint &pos) { return mouseMove(brush, painter, pos, pos); }
On a mouse press event, we just call mouseMove()
to draw the spot where the event occurred.
QRect BasicToolsPlugin::mouseMove(const QString &brush, QPainter &painter, const QPoint &oldPos, const QPoint &newPos) { painter.save(); int rad = painter.pen().width() / 2; QRect boundingRect = QRect(oldPos, newPos).normalized() .adjusted(-rad, -rad, +rad, +rad); QColor color = painter.pen().color(); int thickness = painter.pen().width(); QColor transparentColor(color.red(), color.green(), color.blue(), 0);
In mouseMove()
, we start by saving the state of the QPainter and we compute a few variables that we'll need later.
if (brush == tr("Pencil")) { painter.drawLine(oldPos, newPos); } else if (brush == tr("Air Brush")) { int numSteps = 2 + (newPos - oldPos).manhattanLength() / 2; painter.setBrush(QBrush(color, Qt::Dense6Pattern)); painter.setPen(Qt::NoPen); for (int i = 0; i < numSteps; ++i) { int x = oldPos.x() + i * (newPos.x() - oldPos.x()) / (numSteps - 1); int y = oldPos.y() + i * (newPos.y() - oldPos.y()) / (numSteps - 1); painter.drawEllipse(x - (thickness / 2), y - (thickness / 2), thickness, thickness); } } else if (brush == tr("Random Letters")) { QChar ch('A' + (qrand() % 26)); QFont biggerFont = painter.font(); biggerFont.setBold(true); biggerFont.setPointSize(biggerFont.pointSize() + thickness); painter.setFont(biggerFont); painter.drawText(newPos, QString(ch)); QFontMetrics metrics(painter.font()); boundingRect = metrics.boundingRect(ch); boundingRect.translate(newPos); boundingRect.adjust(-10, -10, +10, +10); } painter.restore(); return boundingRect; }
Then comes the brush-dependent part of the code:
- If the brush is Pencil, we just call QPainter::drawLine() with the current QPen.
- If the brush is Air Brush, we start by setting the painter's QBrush to Qt::Dense6Pattern to obtain a dotted pattern.
- If the brush is Random Letters, we draw a random letter at the new cursor position. Most of the code is for setting the font to be bold and larger than the default font and for computing an appropriate bounding rect.
At the end, we restore the painter state to what it was upon entering the function and we return the bounding rectangle.
QRect BasicToolsPlugin::mouseRelease(const QString & /* brush */, QPainter & /* painter */, const QPoint & /* pos */) { return QRect(0, 0, 0, 0); }
When the user releases the mouse, we do nothing and return an empty QRect.
Implementation of the Shape Interface
QStringList BasicToolsPlugin::shapes() const { return QStringList() << tr("Circle") << tr("Star") << tr("Text..."); }
The plugin provides three shapes: Circle, Star, and Text.... The three dots after Text are there because the shape pops up a dialog asking for more information. We know that the shape names will end up in a menu, so we include the three dots in the shape name.
A cleaner but more complicated design would have been to distinguish between the internal shape name and the name used in the user interface.
QPainterPath BasicToolsPlugin::generateShape(const QString &shape, QWidget *parent) { QPainterPath path; if (shape == tr("Circle")) { path.addEllipse(0, 0, 50, 50); } else if (shape == tr("Star")) { path.moveTo(90, 50); for (int i = 1; i < 5; ++i) { path.lineTo(50 + 40 * std::cos(0.8 * i * Pi), 50 + 40 * std::sin(0.8 * i * Pi)); } path.closeSubpath(); } else if (shape == tr("Text...")) { QString text = QInputDialog::getText(parent, tr("Text Shape"), tr("Enter text:"), QLineEdit::Normal, tr("Qt")); if (!text.isEmpty()) { QFont timesFont("Times", 50); timesFont.setStyleStrategy(QFont::ForceOutline); path.addText(0, 0, timesFont, text); } } return path; }
The generateShape()
creates a QPainterPath for the specified shape. If the shape is Text, we pop up a QInputDialog to let the user enter some text.
Implementation of the Filter Interface
QStringList BasicToolsPlugin::filters() const { return QStringList() << tr("Invert Pixels") << tr("Swap RGB") << tr("Grayscale"); }
The plugin provides three filters: Invert Pixels, Swap RGB, and Grayscale.
QImage BasicToolsPlugin::filterImage(const QString &filter, const QImage &image, QWidget * /* parent */) { QImage result = image.convertToFormat(QImage::Format_RGB32); if (filter == tr("Invert Pixels")) { result.invertPixels(); } else if (filter == tr("Swap RGB")) { result = result.rgbSwapped(); } else if (filter == tr("Grayscale")) { for (int y = 0; y < result.height(); ++y) { for (int x = 0; x < result.width(); ++x) { int pixel = result.pixel(x, y); int gray = qGray(pixel); int alpha = qAlpha(pixel); result.setPixel(x, y, qRgba(gray, gray, gray, alpha)); } } } return result; }
The filterImage()
function takes a filter name and a QImage as parameters and returns an altered QImage. The first thing we do is to convert the image to a 32-bit RGB format, to ensure that the algorithms will work as expected. For example, QImage::invertPixels(), which is used to implement the Invert Pixels filter, gives counterintuitive results for 8-bit images, because they invert the indices into the color table instead of inverting the color table's entries.
Exporting the Plugin
To finally export your plugin you just have to add the Q_PLUGIN_METADATA()
macro right next to the Q_OBJECT()
macro into the header file of the plugin. It must contain the plugins IID and optionally a filename pointing to a json file containing the metadata for the plugin.
Q_PLUGIN_METADATA(IID "org.qt-project.Qt.Examples.PlugAndPaint.BrushInterface" FILE "basictools.json")
Within this example the json file does not need to export any metadata, so it just contains an empty json object.
{}
The .pro File
Here's the project file for building the Basic Tools plugin:
TEMPLATE = lib CONFIG += plugin static QT += widgets INCLUDEPATH += ../../app HEADERS = basictoolsplugin.h SOURCES = basictoolsplugin.cpp TARGET = $$qtLibraryTarget(pnp_basictools) DESTDIR = ../../plugins
The .pro
file differs from typical .pro
files in many respects. First, it starts with a TEMPLATE
entry specifying lib
. (The default template is app
.) It also adds plugin
to the CONFIG
variable. This is necessary on some platforms to avoid generating symbolic links with version numbers in the file name, which is appropriate for most dynamic libraries but not for plugins.
To make the plugin a static plugin, all that is required is to specify static
in addition to plugin
. The Extra Filters plugin, which is compiled as a dynamic plugin, doesn't specify static
in its .pro
file.
The INCLUDEPATH
variable sets the search paths for global headers (i.e., header files included using #include <...>
). We add ../../app
to the list, so that we can include <interfaces.h>
.
The TARGET
variable specifies which name we want to give the target library. We use pnp_
as the prefix to show that the plugin is designed to work with Plug & Paint. On Unix, lib
is also prepended to that name. On all platforms, a platform-specific suffix is appended (e.g., .dll
on Windows, .a
on Linux).
The CONFIG()
code at the end is necessary for this example because the example is part of the Qt distribution and Qt can be configured to be built simultaneously in debug and in release modes. You don't need to for your own plugins.
Files:


Linux Bootstrap Dashboard
General
Disk
CPU
RAM
Users
Network
A simple web dashboard to monitor your server.
General Info
Refresh
OS:
Uptime:
Hostname:
Load average
Refresh
Number of cores:
0
1 min
%
5 min
%
15 min
%
RAM
Refresh
Total
MB
Used
MB
%
Free
MB
%
Disk Usage
Refresh
Users
Refresh
Software
Refresh
IP
Refresh
Internet Speed
Refresh
0
Mbps
Online
Refresh
Processes
Refresh


- read() - Method in class info.ata4.util.io.ByteBufferInputStream
-
- read(byte[], int, int) - Method in class info.ata4.util.io.ByteBufferInputStream
-
- read() - Method in class org.apache.commons.io.input.BOMInputStream
-
Invokes the delegate's read()
method, detecting and optionally skipping BOM.
- read(byte[], int, int) - Method in class org.apache.commons.io.input.BOMInputStream
-
Invokes the delegate's read(byte[], int, int)
method, detecting and optionally skipping BOM.
- read(byte[]) - Method in class org.apache.commons.io.input.BOMInputStream
-
Invokes the delegate's read(byte[])
method, detecting and optionally skipping BOM.
- read() - Method in class org.apache.commons.io.input.BoundedInputStream
-
Invokes the delegate's read()
method if
the current position is less than the limit.
- read(byte[]) - Method in class org.apache.commons.io.input.BoundedInputStream
-
Invokes the delegate's read(byte[])
method.
- read(byte[], int, int) - Method in class org.apache.commons.io.input.BoundedInputStream
-
Invokes the delegate's read(byte[], int, int)
method.
- read() - Method in class org.apache.commons.io.input.BrokenInputStream
-
Throws the configured exception.
- read(byte[], int, int) - Method in class org.apache.commons.io.input.CharSequenceInputStream
-
- read() - Method in class org.apache.commons.io.input.CharSequenceInputStream
-
- read(byte[]) - Method in class org.apache.commons.io.input.CharSequenceInputStream
-
- read() - Method in class org.apache.commons.io.input.CharSequenceReader
-
Read a single character.
- read(char[], int, int) - Method in class org.apache.commons.io.input.CharSequenceReader
-
Read the sepcified number of characters into the array.
- read() - Method in class org.apache.commons.io.input.ClosedInputStream
-
Returns -1 to indicate that the stream is closed.
- read() - Method in class org.apache.commons.io.input.DemuxInputStream
-
Read byte from stream associated with current thread.
- read() - Method in class org.apache.commons.io.input.NullInputStream
-
Read a byte.
- read(byte[]) - Method in class org.apache.commons.io.input.NullInputStream
-
Read some bytes into the specified array.
- read(byte[], int, int) - Method in class org.apache.commons.io.input.NullInputStream
-
Read the specified number bytes into an array.
- read() - Method in class org.apache.commons.io.input.NullReader
-
Read a character.
- read(char[]) - Method in class org.apache.commons.io.input.NullReader
-
Read some characters into the specified array.
- read(char[], int, int) - Method in class org.apache.commons.io.input.NullReader
-
Read the specified number characters into an array.
- read() - Method in class org.apache.commons.io.input.ProxyInputStream
-
Invokes the delegate's read()
method.
- read(byte[]) - Method in class org.apache.commons.io.input.ProxyInputStream
-
Invokes the delegate's read(byte[])
method.
- read(byte[], int, int) - Method in class org.apache.commons.io.input.ProxyInputStream
-
Invokes the delegate's read(byte[], int, int)
method.
- read() - Method in class org.apache.commons.io.input.ProxyReader
-
Invokes the delegate's read()
method.
- read(char[]) - Method in class org.apache.commons.io.input.ProxyReader
-
Invokes the delegate's read(char[])
method.
- read(char[], int, int) - Method in class org.apache.commons.io.input.ProxyReader
-
Invokes the delegate's read(char[], int, int)
method.
- read(CharBuffer) - Method in class org.apache.commons.io.input.ProxyReader
-
Invokes the delegate's read(CharBuffer)
method.
- read(byte[], int, int) - Method in class org.apache.commons.io.input.ReaderInputStream
-
Read the specified number of bytes into an array.
- read(byte[]) - Method in class org.apache.commons.io.input.ReaderInputStream
-
Read the specified number of bytes into an array.
- read() - Method in class org.apache.commons.io.input.ReaderInputStream
-
Read a single byte.
- read() - Method in class org.apache.commons.io.input.TeeInputStream
-
Reads a single byte from the proxied input stream and writes it to
the associated output stream.
- read(byte[], int, int) - Method in class org.apache.commons.io.input.TeeInputStream
-
Reads bytes from the proxied input stream and writes the read bytes
to the associated output stream.
- read(byte[]) - Method in class org.apache.commons.io.input.TeeInputStream
-
Reads bytes from the proxied input stream and writes the read bytes
to the associated output stream.
- read(char[], int, int) - Method in class org.apache.commons.io.input.XmlStreamReader
-
Invokes the underlying reader's read(char[], int, int)
method.
- read(Reader, char[], int, int) - Static method in class org.apache.commons.io.IOUtils
-
Read characters from an input character stream.
- read(Reader, char[]) - Static method in class org.apache.commons.io.IOUtils
-
Read characters from an input character stream.
- read(InputStream, byte[], int, int) - Static method in class org.apache.commons.io.IOUtils
-
Read bytes from an input stream.
- read(InputStream, byte[]) - Static method in class org.apache.commons.io.IOUtils
-
Read bytes from an input stream.
- READ_ONLY - Static variable in class org.apache.commons.io.filefilter.CanReadFileFilter
-
Singleton instance of read-only filter
- readBoolean() - Method in class info.ata4.util.io.ByteBufferInput
-
- readBoolean() - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
- readByte() - Method in class info.ata4.util.io.ByteBufferInput
-
- readByte() - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
Invokes the delegate's read()
method.
- readChar() - Method in class info.ata4.util.io.ByteBufferInput
-
- readChar() - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
- readDouble() - Method in class info.ata4.util.io.ByteBufferInput
-
- readDouble() - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
- ReaderInputStream - Class in org.apache.commons.io.input
-
InputStream
implementation that reads a character stream from a Reader
and transforms it to a byte stream using a specified charset encoding.
- ReaderInputStream(Reader, CharsetEncoder) - Constructor for class org.apache.commons.io.input.ReaderInputStream
-
- ReaderInputStream(Reader, CharsetEncoder, int) - Constructor for class org.apache.commons.io.input.ReaderInputStream
-
- ReaderInputStream(Reader, Charset, int) - Constructor for class org.apache.commons.io.input.ReaderInputStream
-
- ReaderInputStream(Reader, Charset) - Constructor for class org.apache.commons.io.input.ReaderInputStream
-
Construct a new
ReaderInputStream
with a default input buffer size of
1024 characters.
- ReaderInputStream(Reader, String, int) - Constructor for class org.apache.commons.io.input.ReaderInputStream
-
- ReaderInputStream(Reader, String) - Constructor for class org.apache.commons.io.input.ReaderInputStream
-
Construct a new
ReaderInputStream
with a default input buffer size of
1024 characters.
- ReaderInputStream(Reader) - Constructor for class org.apache.commons.io.input.ReaderInputStream
-
Construct a new
ReaderInputStream
that uses the default character encoding
with a default input buffer size of 1024 characters.
- readFileToByteArray(File) - Static method in class org.apache.commons.io.FileUtils
-
Reads the contents of a file into a byte array.
- readFileToString(File, Charset) - Static method in class org.apache.commons.io.FileUtils
-
Reads the contents of a file into a String.
- readFileToString(File, String) - Static method in class org.apache.commons.io.FileUtils
-
Reads the contents of a file into a String.
- readFileToString(File) - Static method in class org.apache.commons.io.FileUtils
-
Reads the contents of a file into a String using the default encoding for the VM.
- readFloat() - Method in class info.ata4.util.io.ByteBufferInput
-
- readFloat() - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
- readFully(byte[]) - Method in class info.ata4.util.io.ByteBufferInput
-
- readFully(byte[], int, int) - Method in class info.ata4.util.io.ByteBufferInput
-
- readFully(byte[]) - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
Invokes the delegate's read(byte[] data, int, int)
method.
- readFully(byte[], int, int) - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
Invokes the delegate's read(byte[] data, int, int)
method.
- readFully(Reader, char[], int, int) - Static method in class org.apache.commons.io.IOUtils
-
Read the requested number of characters or fail if there are not enough left.
- readFully(Reader, char[]) - Static method in class org.apache.commons.io.IOUtils
-
Read the requested number of characters or fail if there are not enough left.
- readFully(InputStream, byte[], int, int) - Static method in class org.apache.commons.io.IOUtils
-
Read the requested number of bytes or fail if there are not enough left.
- readFully(InputStream, byte[]) - Static method in class org.apache.commons.io.IOUtils
-
Read the requested number of bytes or fail if there are not enough left.
- readInt() - Method in class info.ata4.util.io.ByteBufferInput
-
- readInt() - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
- readLine() - Method in class info.ata4.util.io.ByteBufferInput
-
- readLine() - Method in class org.apache.commons.io.input.ReversedLinesFileReader
-
Returns the lines of the file from bottom to top.
- readLine() - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
Not currently supported - throws UnsupportedOperationException
.
- readLines(File, Charset) - Static method in class org.apache.commons.io.FileUtils
-
Reads the contents of a file line by line to a List of Strings.
- readLines(File, String) - Static method in class org.apache.commons.io.FileUtils
-
Reads the contents of a file line by line to a List of Strings.
- readLines(File) - Static method in class org.apache.commons.io.FileUtils
-
Reads the contents of a file line by line to a List of Strings using the default encoding for the VM.
- readLines(InputStream) - Static method in class org.apache.commons.io.IOUtils
-
Get the contents of an InputStream
as a list of Strings,
one entry per line, using the default character encoding of the platform.
- readLines(InputStream, Charset) - Static method in class org.apache.commons.io.IOUtils
-
Get the contents of an InputStream
as a list of Strings,
one entry per line, using the specified character encoding.
- readLines(InputStream, String) - Static method in class org.apache.commons.io.IOUtils
-
Get the contents of an InputStream
as a list of Strings,
one entry per line, using the specified character encoding.
- readLines(Reader) - Static method in class org.apache.commons.io.IOUtils
-
Get the contents of a Reader
as a list of Strings,
one entry per line.
- readLong() - Method in class info.ata4.util.io.ByteBufferInput
-
- readLong() - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
- readShort() - Method in class info.ata4.util.io.ByteBufferInput
-
- readShort() - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
- readStringNull(int, String, boolean) - Method in class info.ata4.io.DataInputReader
-
Reads a null-terminated string.
- readStringNull(int, String) - Method in class info.ata4.io.DataInputReader
-
Reads a null-terminated string without byte padding.
- readStringNull(int) - Method in class info.ata4.io.DataInputReader
-
Reads a null-terminated string without byte padding, using the ASCII charset.
- readStringNull() - Method in class info.ata4.io.DataInputReader
-
Reads a null-terminated string without byte padding, using the ASCII
charset and with a limit of 256 bytes.
- readSwappedDouble(byte[], int) - Static method in class org.apache.commons.io.EndianUtils
-
Reads a "double" value from a byte array at a given offset.
- readSwappedDouble(InputStream) - Static method in class org.apache.commons.io.EndianUtils
-
Reads a "double" value from an InputStream.
- readSwappedFloat(byte[], int) - Static method in class org.apache.commons.io.EndianUtils
-
Reads a "float" value from a byte array at a given offset.
- readSwappedFloat(InputStream) - Static method in class org.apache.commons.io.EndianUtils
-
Reads a "float" value from an InputStream.
- readSwappedInteger(byte[], int) - Static method in class org.apache.commons.io.EndianUtils
-
Reads a "int" value from a byte array at a given offset.
- readSwappedInteger(InputStream) - Static method in class org.apache.commons.io.EndianUtils
-
Reads a "int" value from an InputStream.
- readSwappedLong(byte[], int) - Static method in class org.apache.commons.io.EndianUtils
-
Reads a "long" value from a byte array at a given offset.
- readSwappedLong(InputStream) - Static method in class org.apache.commons.io.EndianUtils
-
Reads a "long" value from an InputStream.
- readSwappedShort(byte[], int) - Static method in class org.apache.commons.io.EndianUtils
-
Reads a "short" value from a byte array at a given offset.
- readSwappedShort(InputStream) - Static method in class org.apache.commons.io.EndianUtils
-
Reads a "short" value from an InputStream.
- readSwappedUnsignedInteger(byte[], int) - Static method in class org.apache.commons.io.EndianUtils
-
Reads an unsigned integer (32-bit) value from a byte array at a given
offset.
- readSwappedUnsignedInteger(InputStream) - Static method in class org.apache.commons.io.EndianUtils
-
Reads a unsigned integer (32-bit) from an InputStream.
- readSwappedUnsignedShort(byte[], int) - Static method in class org.apache.commons.io.EndianUtils
-
Reads an unsigned short (16-bit) value from a byte array at a given
offset.
- readSwappedUnsignedShort(InputStream) - Static method in class org.apache.commons.io.EndianUtils
-
Reads a unsigned short (16-bit) from an InputStream.
- readUnsignedByte() - Method in class info.ata4.util.io.ByteBufferInput
-
- readUnsignedByte() - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
Invokes the delegate's read()
method.
- readUnsignedInt() - Method in class info.ata4.io.DataInputReader
-
- readUnsignedShort() - Method in class info.ata4.util.io.ByteBufferInput
-
- readUnsignedShort() - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
- readUTF() - Method in class info.ata4.util.io.ByteBufferInput
-
- readUTF() - Method in class org.apache.commons.io.input.SwappedDataInputStream
-
Not currently supported - throws UnsupportedOperationException
.
- ready() - Method in class org.apache.commons.io.input.ProxyReader
-
Invokes the delegate's ready()
method.
- refresh(File) - Method in class org.apache.commons.io.monitor.FileEntry
-
Refresh the attributes from the File
, indicating
whether the file has changed.
- RegexFileFilter - Class in org.apache.commons.io.filefilter
-
Filters files using supplied regular expression(s).
- RegexFileFilter(String) - Constructor for class org.apache.commons.io.filefilter.RegexFileFilter
-
Construct a new regular expression filter.
- RegexFileFilter(String, IOCase) - Constructor for class org.apache.commons.io.filefilter.RegexFileFilter
-
Construct a new regular expression filter with the specified flags case sensitivity.
- RegexFileFilter(String, int) - Constructor for class org.apache.commons.io.filefilter.RegexFileFilter
-
Construct a new regular expression filter with the specified flags.
- RegexFileFilter(Pattern) - Constructor for class org.apache.commons.io.filefilter.RegexFileFilter
-
Construct a new regular expression filter for a compiled regular expression
- remaining() - Method in class info.ata4.util.io.ByteBufferWrapper
-
Same as ByteBuffer
.remaining()
- remove() - Method in class org.apache.commons.io.LineIterator
-
Unsupported.
- removeExtension(String) - Static method in class org.apache.commons.io.FilenameUtils
-
Removes the extension from a filename.
- removeFileFilter(IOFileFilter) - Method in class org.apache.commons.io.filefilter.AndFileFilter
-
Removes the specified file filter.
- removeFileFilter(IOFileFilter) - Method in interface org.apache.commons.io.filefilter.ConditionalFileFilter
-
Removes the specified file filter.
- removeFileFilter(IOFileFilter) - Method in class org.apache.commons.io.filefilter.OrFileFilter
-
Removes the specified file filter.
- removeListener(FileAlterationListener) - Method in class org.apache.commons.io.monitor.FileAlterationObserver
-
Remove a file system listener.
- removeObserver(FileAlterationObserver) - Method in class org.apache.commons.io.monitor.FileAlterationMonitor
-
Remove a file system observer from this monitor.
- reset() - Method in class org.apache.commons.io.input.BOMInputStream
-
Invokes the delegate's reset()
method.
- reset() - Method in class org.apache.commons.io.input.BoundedInputStream
-
Invokes the delegate's reset()
method.
- reset() - Method in class org.apache.commons.io.input.BrokenInputStream
-
Throws the configured exception.
- reset() - Method in class org.apache.commons.io.input.CharSequenceInputStream
-
- reset() - Method in class org.apache.commons.io.input.CharSequenceReader
-
Reset the reader to the last marked position (or the beginning if
mark has not been called).
- reset() - Method in class org.apache.commons.io.input.NullInputStream
-
Reset the stream to the point when mark was last called.
- reset() - Method in class org.apache.commons.io.input.NullReader
-
Reset the stream to the point when mark was last called.
- reset() - Method in class org.apache.commons.io.input.ProxyInputStream
-
Invokes the delegate's reset()
method.
- reset() - Method in class org.apache.commons.io.input.ProxyReader
-
Invokes the delegate's reset()
method.
- reset() - Method in class org.apache.commons.io.output.ByteArrayOutputStream
-
- resetByteCount() - Method in class org.apache.commons.io.input.CountingInputStream
-
Set the byte count back to 0.
- resetByteCount() - Method in class org.apache.commons.io.output.CountingOutputStream
-
Set the byte count back to 0.
- resetByteCount() - Method in class org.apache.commons.io.output.ThresholdingOutputStream
-
Resets the byteCount to zero.
- resetCount() - Method in class org.apache.commons.io.input.CountingInputStream
-
Set the byte count back to 0.
- resetCount() - Method in class org.apache.commons.io.output.CountingOutputStream
-
Set the byte count back to 0.
- resolveClass(ObjectStreamClass) - Method in class org.apache.commons.io.input.ClassLoaderObjectInputStream
-
Resolve a class specified by the descriptor using the
specified ClassLoader or the super ClassLoader.
- resolveProxyClass(String[]) - Method in class org.apache.commons.io.input.ClassLoaderObjectInputStream
-
Create a proxy class that implements the specified interfaces using
the specified ClassLoader or the super ClassLoader.
- ReversedLinesFileReader - Class in org.apache.commons.io.input
-
Reads lines in a file reversely (similar to a BufferedReader, but starting at
the last line).
- ReversedLinesFileReader(File) - Constructor for class org.apache.commons.io.input.ReversedLinesFileReader
-
Creates a ReversedLinesFileReader with default block size of 4KB and the
platform's default encoding.
- ReversedLinesFileReader(File, int, Charset) - Constructor for class org.apache.commons.io.input.ReversedLinesFileReader
-
Creates a ReversedLinesFileReader with the given block size and encoding.
- ReversedLinesFileReader(File, int, String) - Constructor for class org.apache.commons.io.input.ReversedLinesFileReader
-
Creates a ReversedLinesFileReader with the given block size and encoding.
- run() - Method in class org.apache.commons.io.input.Tailer
-
Follows changes in the file, calling the TailerListener's handle method for each new line.
- run() - Method in class org.apache.commons.io.monitor.FileAlterationMonitor
-
Run.


This class provides access to help information in two forms: First, as a modeless dialog bearing whatever information, or "credits," the user desires to post there; this dialog is commonly called the "About Box", and it is made to appear whenever the IDM_HELP_ABOUT message is sent to the frame's OnCommand() method. This invokes the AppHelp::About() constructor. Typically, an application will invoke this form of help by activating the Help->About topic on the main menu.
The second form is the display of topical information held in a Compiled HTML (.chm) file. This file contains a set of "topics", or strings that may be searched for using a special htmlhelp object. When it is sent one of the topic strings, the .chm help file is searched for an entry matching the topic. If found, the corresponding manual page displays. String topics are made to correspond to control IDs by the AppHelp::AddHelpTopic() member.
Assistance in peparing the help guide to contain the application's topics may be found in the file
Adding HTML Help to MinGW.html
which is included in the help directory of this sample program. It may also be accessed at a number of sites using an internet search. While being oriented to the MinGW compiler specifically, this article relates, by inference, how to do this for other platforms.
This topical type of help is termed "context help mode", and may be invoked in one of several ways. The usual help mode is intended to use the F1 function key, either as F1 itself, or as Shift+F1. Whenever either one of these keys is pressed, the system sends the main window a IDM_F1 or IDM_SHIFT_F1 message, to which the application sends to the AppHelp class for response. When the F1 key is the one pressed, AppHelp responds by displaying any topic that has been assigned to the control having current keyboard or mouse focus.
When Shift+F1 is pressed, the AppHelp class causes the cursor to change its shape from the application cursor to the help-cursor, which takes the shape of a question mark. The next control that is selected by mouse, accelerator key, or tab navigation will cause the topic assigned to that control ID to be displayed. At this point the application cursor is restored.
The Shift+F1 style of context help may also be invoked by selecting either of the context help buttons, on the toolbar or on the caption bar.
The suite of files comprising the suite of help functions is composed of
AppHelp.h declaration of the AppHelp class AppHelp.cpp implementation of the AppHelp class ContextHelp.h declaration of context help part of AppHelp ContextHelp.cpp implementatin of the context help methods HelpAbout.h declaration of the AboutBox part of AppHelp HelpAbout.cpp implementation of the AboutBox dialog resource.h defines help function resource IDs resource.rc contains AppHelp resources
Consult the usage of these elements in the ContextHelp sample program for more information on using these features.


GUINEVERE A film review by Steve Rhodes Copyright 1999 Steve Rhodes RATING (0 TO ****): * 1/2
Harper Sloane (Sarah Polley from GO and THE SWEET HEREAFTER) is the unhappy product of a family of lawyers. ("My family, none of us, can do anything except doodle on legal pads.") This being the movies, her family is hopelessly dysfunctional, so she leaps at the opportunity to abandon her chances at Harvard in order to take up with a photographer, Connie Fitzpatrick (Stephen Rea from THE CRYING GAME), who is older than her father.
Writer and director Audrey Wells's GUINEVERE suffers from a paucity of ideas. After setting up the plot of an older man becoming the mentor and lover to a Lolita-style character just beyond the age of consent, Wells has trouble finding ways to make the predictable story interesting and to give her characters any credibility or depth. The result is a film that is as dull as dishwater.
Having just left a screening (ROMANCE by Catherine Breillat) in which the filmmaker took great risks but failed spectacularly, I found that even that film was in some ways preferable to GUINEVERE. At least Breillat tried. Wells, on the other hand, makes a movie that's as inert as outer space. Better to swing at the ball than just stare at it with the hope that the pitcher will walk you. GUINEVERE, except for a few random scenes that are sharply written, quickly becomes tedious.
One of the good scenes, which pales in contrast to similar ones in AMERICAN BEAUTY, happens at the Sloane's dinner table. Harper doesn't participate in her family's intellectual jousting match, offering no opinions on the subject at hand. "How does one get into Harvard without opinions," her father (Francis Guinan) asks in disdain.  "They'll teach her plenty of opinions."
Surreptitiously, Harper moves in with Connie, who calls her his Guinevere. Viewing himself as a one-man art institute, he wants her to take up any artistic endeavor and commit to stay with him for 5 years. This turns out to be a tradition. Gina Gershon plays Billie, one of his previous Guineveres.
 He lectures her constantly about photography and dedication to her art. "You take pictures when it hurts so bad you can't stand it any more," he instructs her -- an example of the film's typically stilted dialog.
"I've been thinking," Connie tells Harper in one of their many low points together. "You know what we need? What we really need here is some fun." And so does the audience. Needless to say, the fun does not materialize.
"You call me if anything happens," Billie says towards the end. My sentiments exactly. I'll be in the lobby.
GUINEVERE runs 1:44. It is rated R for strong language and sexuality and would be acceptable for older teenagers.
Email<EMAIL_ADDRESS>Web: http://www.InternetReviews.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


The father called his four sons back together, and said, “You see each of you have observed well the condition of a the tree at a particular season of the year, but your judgment of the tree was only partial, and made too quickly based on what you saw on only the one occasion. See to it that you never judge human beings this way. Never evaluate them too quickly or on the basis of one encounter, for it is unfair and unwise. Indeed all living things should only be evaluated over the course of time and after repeated careful inspection, for who knows but the ugliest and most unproductive of living things might some day turn into the most beautiful and fruitful.”


Welcome to PokerHUD
Home
Profiles
Stats
Please enter the names of the players you are playing with below:
HandID:
Pot Size:
Username:
Balance:
Hand:
Action:
Amount:
Board:
ThreeBet:
Four Plus Bet:


Add C.C Charges
Current C.C Charges {{CurrentItem.CCCharge}}
X
C.C Charge %
:
Add Item
Update Item
Select Sales Category
*
:
Category is required
Item Name
*
:
Name of item is required
Item Code
:
Select Company
*
:
Category is required
Item Type
*
:
Item type is required
Select Unit
*
:
Unit is required
Generic Name
*
:
Generic Name is required
Is Active
:
Is International Brand
:
C.C Charge %
:
IsNarcotic
:
Re-Order Quantity
:
re-order quantity is required
re-order quantity in numbers only
Min-Stock Quantity
:
Min-stock quantity is required
Min-stock quantity in numbers only
Dosage
:
Budgeted Quantity
:
Budgeted quantity is required
Budgeted quantity in numbers only
Is VAT Applicable
:
VAT Percentage(Purchase)
:
Percentage is not proper
VAT Percentage(Sales)
:
Percentage is not proper
Select Packing
:
{{data.PackingName}}
A,B or C
:
{{abc.text}}
V,E or D
:
{{ved.text}}
Custom Prices
Insurance Applicable
:
Government Insurance Price
*
:
required (minimum 1)
Save
Update
Add Item to Rack
X
Select Rack for Dispensary
:
{{rack.Name}}
Select Rack for Store
:
{{rack.Name}}