Because I am a totally shameless nerd, I find myself writing applications in C from time to time just to make sure I still can. Aside from iOS development, I rarely have to work with C directly (without the help of a superset like C++ or Objective-C), but every once in a while I like to try and challenge myself to write an application in pure C.
I’ve found that doing this has led to a much more profound understanding of modern languages and has really opened my eyes to the challenges faced by developers who write their own languages or work with compiler optimization (I know a few…it sounds like tough work!).
I also continue to attend several universities in order to further my education and C seems to be the language of choice when trying to focus on the concepts of data structures and algorithms since much of the problem space is left up to the developer to solve as opposed to our modern languages of choice.
Ok enough babbling! The goal of this article is to describe how we would go about creating a generic implementation of a linked list in pure C. So without further ado, let’s take a look at the header file.
Line 5 declares a function pointer for a generic free
function that will be called for each element in the list when
it is destroyed. The function must be supplied by the caller when they call list_new
. Essentially we are saying that
the name freeFunction
will be used to mean “a pointer to a function that returns void and accepts a single void *
argument containing the item to be freed.” - More on this soon.
Next we define a bool type. C does not have a boolean, but things are truthy or false, like JavaScript or Ruby. We use this to our advantage by creating a bool type and specifying FALSE first. Feel free to write a quick test to show that !FALSE is truthy while !TRUE is falsy. (Slightly more info found here http://stackoverflow.com/questions/1921539/using-boolean-values-in-c).
Finally we define a listIterator
type that is a pointer to a method that returns a bool and accepts a void *
. This
function will be called for each element in the list during list_for_each
.
The next few lines define a couple of structs we will use for the list.
The first is a typical linked list node that has a void * field for storing whatever the implementer likes and a next
pointer pointing to the next node in the list. This struct will not be used by the caller, rather it will be used by the
internal implementation of the linked list.
The second struct is the actual list and is much more interesting. We start by defining a logicalLength
, which will be
used to keep track of the number of elements in the list, and elementSize
, which will store the size of each element.
The element size is important, since C’s generics are limited to void pointers, which means we need the caller to tell
us how big each element is in order to malloc/memcpy
values. This information should always be dynamically supplied.
Meaning, we (the caller) should use sizeof(int)
rather than 4
to allow for 32⁄64 bit implementations, etc.
Lastly we store two pointers to listNodes, head
and tail
respectively, and a pointer to a function that will be
called for each list element when the list is destroyed in order to support lists of complex items (like strings or
other structs).
When I develop C code, I’m always working with the premise that we should not rely on knowing anything about the
contents of a struct, rather we should use the supplied functions to gain access to the internal information (i.e. we
should use list_size(list *)
to get the size rather than list.logicalLength
or list->logicalLength
).
The next few lines define the function prototypes that will be available for working with linked lists. Here’s brief summary of each method:
list_new
- initializes a linked list to store elements of elementSize
and to call freeFunction
for each element when destroying a listlist_destroy
- frees dynamically allocated nodes and optionally calls freeFunction
with each node’s data
pointerlist_prepend
- adds a node to the head of the listlist_append
- adds a node to the tail of the listlist_size
- returns the number of items in the listlist_for_each
- calles the supplied iterator function with the data element of each node (iterates over the list)list_head
- returns the head of the list (optionally removing it at the same time)list_tail
- returns the tail of the listThat pretty much sums up the header file. Now down to brass tacks…the implementation.
We start by including some system headers and of course list.h
. I generally try to include as few headers as possible,
and only in the implementation files whenever possible. Here are the included headers and a quick description of why we
need them.
stdlib.h
- in order to use malloc/free
string.h
- in order to use memcpy
assert.h
- in order to use the assert
macrolist.h
- in order to have linked list typedefs, structs and function prototypes available to usThis function takes three arguments: a pointer to the list, the size of the elements being stored, and a function to be called for each element when the list is destroyed.
This function will assert that the elementSize
supplied is greater than 0. You could work with a list of elements of
size <= 0, but not with my implementation! It then sets the default values for logicalLength
, head
and tail
,
followed by the freeFunction
(which can be NULL
for simple/stack types).
This function takes a single argument; a pointer to the list to be destroyed.
It will free each node’s data
and the node itself. If a freeFunction was supplied with the call to list_new
for this list, it will be called on each node’s data
element before freeing any malloc’d (that’s now a word) memory.
This method takes two arguments; a pointer to the list and a void * pointing to the element to be inserted.
We start by creating a new node to store this data and dynamically allocating list->elementSize
bytes to store the
data. We then copy the raw bytes sent in via element to node->data
.
If the caller passes in an int
value (and presumably sizeof(int)
during list_new
), we copy that integer to
node->data
. If however the caller sends in a pointer to something (like a char **
) we copy the pointer, not the
thing being pointed to. These situations require the caller to pass in a custom freeFunction that will be
called to free the memory. (The example below shows how to store strings).
Lastly we update head
to point to the new node, and tail
and logicalLength
are updated to reflect the changes.
This method is almost identical to prepend, except that it puts the new node at the end of the list rather than at the beginning.
This method takes two arguments; a pointer to the list and a listIterator
function to be called for each node. We then
get a hold of head
, and store a boolean value indicating whether or not to continue.
The iterator function will be passed a pointer to the node’s data
element. I’ve elected not to copy the pointer here
as done in head/tail
, but to simply pass the original pointer to the iterator function. We stop iterating when either
we are out of nodes, or the iterator function returns FALSE
.
This method takes three arguments; a pointer to the list, a void * representing a place to populate with the node’s
data
and a bool indicating whether or not we should remove the item from the list.
We start by finding the head node (easy enough with list->head
) and copying list->elementSize
bytes from the node’s
data
into the address specified by element.
If the caller supplied TRUE
for the last argument, we remove the head node from the list, updating head/tail
values
along the way, and free the malloc’d memory for node->data
and node
.
This method accepts two arguments; a pointer to the list (this should start to seem like Deja Vu by now) and a void *
indicating the address to copy the tail node’s data
to.
The method take a single argument; a pointer to the list. It returns the number of nodes in that list (via
list->logicalLength
).


Director: Steven Soderbergh Screenwriter: Lem Dobbs sequel to Poor Cow (Ken Loach, GB, 1967) Country: USA; Year: 1999 Rating (4 star system): ***
As a follow-up to what many viewed as Soderbergh's mainstream breakthrough (although nine years after the film that put him on the map-- sex, lies, and videotape), Out of Sight, he has chosen as a sequel. Of course it isn't a sequel to one of his films, but to a 32 year old British film many had never heard of. This seems to be the way Soderbergh works, doing just what he pleases-- if it happens to fall into what the public is, at the time, considering "mainstream," so be it, perhaps. I somehow doubt Mr. Soderbergh cares very much. He is quite willing to make cinema for himself, and this film is a sure example of that. I think it is, indeed, very important to identify this film as a follow-up to Out of Sight. If you'll remember, that film contained a love scene in which not one extraneous body part was shown. All the chemistry of the scene came from the cinema used to build it. In fact, the scene took place in two different places and times, but these spatial and temporal boundaries meant nothing to Soderbergh. He freely mixed the audio of one time and space with the visual of another. In this way, the scene took places in both settings at once-- I am doing a poor job of explaining it, no doubt, so suffice it to say that it was probably my favorite single cinematic moment of 1998. Well, why is that scene so important to The Limey? Simply put, that scene is this entire film. It's as if Soderbergh became so fascinated with that one stylistic decision, that he decided to expound upon it throughout an entire film. The result is an experiment that, while uneven due to its inherent nature as an experiment, is rather interesting to watch just to see the final results. So, the film is constantly shifting it's spatial and temporal viewpoint through both its audio and visual elements. How does this effect the other parts of the film? The story, for one, I believe, suffers quite a bit. There's just not really all that much to it, although what is there is strengthened to a considerable extent by the "experiment." It's a tale of revenge and redemption with a rather strong conclusion, but the journey to that end is not always entirely engaging. Perhaps the performances did not help all too much, either. Of course, the presence of Terrence Stamp is necessary, as he was the main character of the first film, but his performance is quite stiff and doesn't really help one to align with his character (that is left to the direction, I believe, and perhaps that was the intent, but it jut didn't work for me, I'm afraid). Peter Fonda plays the equivalent of an antagonist and his performance is a far cry from his magnificent turn in Ulee's Gold. Where Stamp is stiff, Fonda simply falters. He never once really seems like any sort of character, but instead seems like an actor trying to find a character. The other performances were all throw-aways, in my opinion. I barely remember anything about them other than the performance were either bad or pretty much ineffective. Still, Soderbergh was somehow to carry this film through with his direction and make it interesting to watch. While, I think he could have spent more time on characters and story, his experiment was worth witnessing and, therefore, the film is far from a loss or failure.
-- TyroneZero's Movies, etc. http://members.tripod.com/~TyroneZero/film.html
Sent via Deja.com http://www.deja.com/ Before you buy.
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


AdoHelper
AdoHelper – a small ORM (objective-relational mapping), built on top of ADO.NET technology and making its use smarter.
Download links
Installation
To install a project, simply download the nuget package by running the Install-Package DevEvolution.AdoHelper
command in the Nuget packet manager or install dependencies manually by adding the dll file in the project dependency column in VisualStudio.
Documentation
Features
Automatic mapping query results to a collection of instances of the specified type:
public class SimpleTestEntity
{
public long Id { get; set; }
public string TextField { get; set; }
public double FloatField { get; set; }
public decimal NumericField { get; set; }
public long IntegerField { get; set; }
}
IEnumerable<SimpleTestEntity> entities = new AdoHelper<SimpleTestEntity>(_connection)
.Query("SELECT * FROM TestTable")
.ExecuteReader();
The displayed type can be a class, structure, tuple (System.Tuple
) or (System.ValueTuple
) or dynamic
type as well as a generic collection (IEnumerable<>
) or a list (List<>
). Mapping is made on public properties, available for writing (set;
) and public fields.
public class ClassEntity
{
public int Id {get; set;}
public string text;
}
public struct StructEntity
{
public int id;
public string Text {get; set;}
}
_connection.Open();
var classEntity = new AdoHelper<ClassEntity>(_connection)
.Query("SELECT * FROM TestTable WHERE id=@id")
.Parameters((“@id”, 1))
.ExecuteReader().First();
var structEntity = new AdoHelper<StructEntity>(_connection)
.Query("SELECT * FROM TestTable WHERE id=@id")
.Parameters((“@id”, 1))
.ExecuteReader().First();
var valueTupleEntity = new AdoHelper<(int id, string text)>(_connection)
.Query("SELECT id, text FROM TestTable WHERE id=@id")
.Parameters((“@id”, 1))
.ExecuteReader().First();
var tupleEntity = new AdoHelper<Tuple<int, string>>(_connection)
.Query("SELECT id, text FROM TestTable WHERE id=@id")
.Parameters((“@id”, 1))
.ExecuteReader().First();
var enumerableEntity = new AdoHelper<IEnumerable<string>>(_connection)
.Query("SELECT id, text FROM TestTable WHERE id=@id")
.Parameters((“@id”, 1))
.ExecuteReader().First();
var dynamicEntity = new AdoHelper<dynamic>(_connection)
.Query("SELECT * FROM TestTable")
.ExecuteReader().First();
Assert.AreEqual(classEntity.text, structEntity.Text);
Assert.AreEqual(structEntity.Text, valueTupleEntity.text);
Assert.AreEqual(valueTupleEntity.text, tupleEntity.Item2);
Assert.AreEqual(tupleEntity.Item2, dynamicEntity.Text);
Usage instruction
The query to the database (DB) is as follows:
[var Return value] = [await] new AdoHelper<Return value type>(DB connection object)
[.Parameters(Params)]
[.Transaction(Transaction object)]
.ExecuteNonQuery() || .ExecuteScalar() || .ExecuteReader() ||
.ExecuteNonQueryAsync([cancellation token]) || .ExecuteScalarAsync([cancellation token]) || .ExecuteReaderAsync([cancellation token])
Return value
is the value that will be returned as a result of the query. Depending on the type of request, it can be a collection of objects, a single value, and the value may not be returned at all. Important! The number of elements specified inValueTuple
orTuple
of thereturn value
, the order of declaration and the type of element must match the number of columns and the order of elements in the resulting query table.DB connection object
is an object of type IDbConnection (for example, SqlConnection).Params
- a collection of parameters that represent a pair (parameter - value). The default type of parameters isAdoParameter
. You can also use tuples (ValueTuple<string, object>
andTuple<string, object>
) andDbParameter
objects to specify each parameter.
Example code :
var entity = new AdoHelper<SimpleTestEntity>(_connection)
.Query("SELECT * FROM TestTable WHERE IntegerField = @intParam AND TextField = @textParam" +
"AND FloatField = @floatParam")
.Parameters(
new AdoParameter("@intParam", 123), // AdoHelper param
("@textParam", "Hello"), // ValueTuple param
new Tuple<string, object>("@floatParam", 123.123f)) // Tuple param
.ExecuteReader()
.FirstOrDefault();
Transaction object
is an object of typeIDbTransaction
(for example,SqlTransaction
).
The result of the query (return value
) may be as follows:
- A collection of rows of the resulting table in the form
IEnumerable<T>
. To get this return value, you must use theExecuteReader()
orExecuteReaderAsync()
command. - A single value in the form of object of type
T
. To get a single value, you must run the final commandExecuteScalar()
orExecuteScalarAsync()
. - Do not return value. For this, there are the
ExecuteNonQuery()
andExecuteNonQueryAsync()
methods.
Mapped objects
AdoHelper can independently match the names of class / structure members and columns of the resulting table, and the order of the columns does not matter. The comparison is not case sensitive. Example:
public struct TestEntity
{
public int id { get; set; }
public DateTime DeliverDate;
public double longitude { get; set; }
public double LATITUDE { get; set; }
public int customerId;
}
However, in some situations it makes sense to give the members of the mapping class names that differ from the column names of the resulting table. In this case, you should use the attributes [Field(Name="Name of the column in the table")]
. There are also cases in which it is necessary to abandon the mapping of some class members with table columns. For this there is an attribute [NonMapped]
.
An example of such a class:
public class ExcludedFieldTestEntity
{
public int Id { get; set; }
[NonMapped]
public string TextField { get; set; } // that property is excluded from mapping
[NonMapped]
public double FloatField { get; set; } // that property is excluded from mapping
public DateTime DateField { get; } // that property is excluded too because set property is unreachable
[Field(Name = "NumericField")]
public decimal Numeric { get; set; } // that property is mapped to NumericField column
[Field(Name = "IntegerField")]
public long Integer { get; set; } // that property is mapped to IntegerField column
}
Tuples can also be used as an object for matching. However, in this case, the elements of which the tuple consists must go in the same order as in the resulting table. Tuples of any size are fully supported.
Note. The names of the ValueTuple
elements do not participate in the comparison, as they are only syntactic sugar and are not used in the compiled application.
var entities = new AdoHelper<(int id, string name, int nextId)>(_connection)
.Query("SELECT current_id, category_name, next_id FROM categories WHERE category LIKE ‘TMP’")
.ExecuteReader();
Equals to:
var entities = new AdoHelper<Tuple<int, string, int>>(_connection)
.Query("SELECT current_id, category_name, next_id FROM categories WHERE category LIKE ‘TMP’")
.ExecuteReader();
It is also possible to use the dynamic
type as the return value. In this case, the result will be an object of type ExpandoObject
.
** Note: ** Element names are stored in the register in which they were returned from the database query.
Example:
FbConnection connection = new FbConnection(...);
connection.Open();
var entity = new AdoHelper<dynamic>(connection)
.Query("SELECT * FROM TestTable")
.ExecuteReader().First();
...
Assert.AreEqual("Hello", entity.TEXTFIELD);
Assert.AreEqual(123.123, entity.FLOATFIELD, 10e-5);
Assert.AreEqual(123, entity.NUMERICFIELD);
Assert.AreEqual(123, entity.INTEGERFIELD);
License
The project is published under the license MIT and is supplied as is, without any guarantees.


Hello. I'm Lee Gurley and this is my add-on repository for COM DLL modules intended to be consumed by the Jaba Mud Client (JMC) for use with the Multi-User Dimension (MUD) text-based game Return of the Shadow. These addons are written in C# and are designed to introduce quality of life changes to the game by automating simple tasks. Each module is designed to contain custom settings to make them nearly 100% user customizable.
This repository began with my realization that after writing 1200 lines of JScript, I can actually load up ActiveX COM components into JMC Mud client. At this point, it was time for me to start researching COM and determine how I could create a well-structured project that made the importing of all the JScript code feasible. Once I got the core library complete, creating a few sample modules hardly took any time at all.
Now that I've gotten the basics out of the way, I'm incredibly excited to continue porting the JScript code into C# modules while adding some extra functionality that was just not at all feasible using pure JScript. I'll be updating this page incrementally to try and keep you up to date with any changes as they occur with this project, and as I get used to using GitHub Pages. If anyone has any requests for features they would love to see implemented, I'd absolutely love to hear them. Stay tuned for more updates!


<nospares>
The <nospares> element specifies that no spare parts are needed to perform a task.
Category: Task requirements domain


This module allows you to configure the RP-PPPoE ADSL client program,
which can be used to establish an Internet connection via any
Ethernet-connected ADSL modem that supports the PPPoE (PPP over
Ethernet) protocol. It will not work with USB connected ADSL modems, nor
with those in bridging mode.
Before you can use it, you must have an account with an ADSL
service provider, and your modem must be connected to an un-used
Ethernet interface on your Linux system. This interface must be visible
to the kernel, but should not have any IP address assigned.


WITNESS LIST Natural Resources Committee February 14, 2001-3:00P Edwards Aquifer Authority On: Combs, Susan (Texas Department of Agriculture) Ellis, Gregory M. (Edwards Aquifer Authority) Hill Country Groundwater CDA On: Buckner, Luana (Medina County Groundwater District) Hollow, Jack A. (Hill Country Groundwater Conservation District Alliance) Jennings, Marshall (Hill Country Groundwater CDA & American Institute of Hydrology)


Could this be the finest couplet in rock music?
Well I've come back from the foundry and I find you in bed
With Chris and Tim and John and Lindsay, Dagmar and Fred
It's from the song “Group Sex” on the album The Gab—Gift Or Curse? by The Plain People Of England, an offshoot of the Orchestre Murphy. It is, I suppose, vaguely possible that some readers may not realise just who it is in the bed, so here is some further reading.


more path/to/file- Open a file displaying from a specific line:
more +line_number path/to/file- Display help:
more --help- Go to the next page:
- Search for a string (press `n` to go to the next match):
/something- Exit:
q- Display help about interactive commands:
h


If the following describes you, please leave your email address below and we will be in contact soon:
- You help beneficiaries over a period of time
- Your beneficiaries can answer questionnaires before and after 'intervention', or more frequently
- You are interested in understanding your impact on the beneficiary
- Your desired questionnaire is composed of Likert scales


Polyatomic Molecules
Important Facts:
*Blue highlighted are the more important notes
- Forms between many (>2) ions from representative elements
- You will need to memorize the names in the table under List of Polyatomics
- Both elements should make a neutral molecule
Polyatomic Formulas
- Parenthesis are used when you have multiple of a polyatomic
- Write the ion/polyatomics needed, then balance the charges as described in The Kamine Way
Naming Formulas
All you have to do for this is just get both of the names of the molecules.
Example:
Ammonium + Sulfate = NH41+ + SO42- = (NH4)2 SO4 = Ammonium Sulfate
Formula Exercises:
Click the names below to get the answer.
Sodium Hydroxide → NaOH
Ammonium Iodate → NH4IO3
Magnesium Nitrate→ Mg(NO3)2


{% extends "admin/base_site.html" %} {% load i18n staticfiles admin_list %} {% block breadcrumbs %}
{% endblock %} {% block content %} {% if current.planning_status == current.PLANNING_DRAFT %}Do you wish to apply corporate approval to this ePFP? This will prevent further modification of this information for the remainder of the ePFP process.
{% else %}Do you wish to delete the corporate approval to this ePFP? This will return the ePFP to Draft status.
{% endif %} {% endif %} {% endblock %}


+++ title = "Netherlands" lat = 51.762740 lon = 5.031738 +++
The Netherlands (otherwise known as Holland) is a very low and a very flat country — and of course it's the home of the Dutch. Famous for a long history of being socially liberal and super-progressive, the Netherlands is also home to bicycle mania, legal soft drugs, and ocean-stopping dykes. I popped in here between Belgium and Germany, on my lightning December train tour of Europe.


{{if eq $error "invalid"}}
Invalid. Please try again.
{{else if eq $error "emptywrongtype"}}
Please check that no field is empty, and that types are correct
{{else}}
Error. Please try again.
{{end}}


At 26 I just discovered the fascinating world of the web thanks to Interface3. In a few months I've learned more than in 15 years of use. With this, I've got the feeling to have found an area in which I feel I can blossom and be proud of my work.
I am a junior web developer but I am very excited about all the possibilities that programming brings. I intend to learn and be able to use with easy all the different techniques that are at my disposition.
Keep visiting my website and check out my evolution


{{method}} {{ resource }}
{{ compiledResource() }}
| Key | Value |
|---|---|
{{ datum.name }}
REQUIRED
|
{{ datum.value }}
reset
|
This endpoint does not have any {{key}}
+ Add {{ store.singular }}STATUS: {{ status() }}
No response body
An error has occurred, see console for more details.


In ancient times cats were worshipped as gods; they have not forgotten this.
I'm curious. Period. I find everything interesting. Real life. Fake life. Objects. Flowers. Cats. But mostly people. If you keep your eyes open and your mind open, everything can be interesting. And that's the wayyy, the news goes! I don't get it, and I don't need to. He's not pressing charges. That's gotta be the you shot me equivalent of not being mad.
In ancient times cats were worshipped as gods; they have not forgotten this.
There's a lot of cat videos. Cats are just hilarious.


ACT OF VIOLENCE (director: Fred Zinnemann; screenwriters: from a story by Collier Young/Robert L. Richards; cinematographer: Robert Surtees; editor: Conrad A. Nervig; cast: Van Heflin (Frank R. Enley), Robert Ryan (Joe Parkson), Janet Leigh (Edith Enley), Phyllis Thaxter (Ann Sturges), Mary Astor (Pat), Berry Kroeger (Johnny), Taylor Holmes (Gavery), Will Wright (Pop); Runtime: 82; MGM; 1949)
Reviewed by Dennis Schwartz
A tense melodrama about a crippled P.O.W, Joe Parkson (Ryan), armed with a gun, tracking down his former Air Force commander, Captain Frank Enley (Van Heflin), who moved from Syracuse to a small California town, Santa Lisa, just so he couldn't be found. Frank betrayed him and his fellow men by becoming an informer to the Nazis, as he naively told of their escape plans believing the men couldn't succeed and would make things worst for all of them by going ahead with the escape. He rats them out thinking the Nazis would honor their promises to him to go easy on the men.  Frank is now a respected building contractor and leading citizen in the community, with a loving wife, Edith (Leigh), and a young son.
When the embittered Joe shows up in his hometown to kill him, he's the only other person who knows of the incident. Frank panics and is filled with guilt, as he confesses his error to his wife. He tells her he can't blame Joe for feeling that way and that they can't go to the police and let the papers get hold of the story, because that would ruin his reputation.
He flees to nearby Los Angeles to attend a builder's convention, but when he learns from his wife that Joe's girlfriend Ann Sturges (Thaxter) told her that Joe knows where he is he panics and becomes drunk with self-pity and guilt. This leads him to a low-down bar, where a woman of the night, Pat (Astor), hears his sad story and how he would give away his $20,000 construction business just to be free of this problem. She takes him to a shady lawyer friend of hers, Gavery (Holmes), and he plans to get a contract killer for him, Johnny (Kroeger), for a fee of $10,000.
Warning: spoiler to follow in next paragraph.
When Frank sobers up in the morning, he realizes that he did the wrong thing again and goes back to his hometown to meet Joe and warn him of the danger he's in. But when he sees Johnny firing at Joe, he darts in front of him and takes one for Joe to atone for his past misdeed.
It was a taut, suspenseful story, ruined somewhat by the cop-out ending. It's still a superior film noir, with a meaningful social conscience theme.  His present successful life is wiped away by his cloudy past, but the film's problem is that it didn't try to deal with Frank's agitated state in a more profound way except for the surface reaction that it will cause an upheaval in Frank's current social position in the community. The characterizations of all concerned, never goes past a surface conclusion: that Joe chooses revenge over love; that Frank never faces why he became an informer and tries to compensate for that by pretending he's now a perfect citizen, as he represses his dark side.
The post-war boom in the economy is seen from the point of view of the troubled soldiers who came home physically and mentally wounded and eventually realize that money can't buy them everything. The director Fred Zinnemann (High Noon/The Men) came to America from Austria to escape the Nazis, but his parents remained behind and became Holocaust victims. The grimness of this tale is certainly something the director understood, and for most of the film that shows. The mood of the film is best captured in the capable hands of Bob Surtees' eloquent black and white photography.
REVIEWED ON 9/7/2001 GRADE: B
Dennis Schwartz: "Ozus' World Movie Reviews"
http://www.sover.net/~ozus
<EMAIL_ADDRESS>© ALL RIGHTS RESERVED DENNIS SCHWARTZ
========== X-RAMR-ID: 29410 X-Language: en X-RT-SourceID: 873 X-RT-AuthorID: 1315 X-RT-RatingText: B
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


Icons
The icons
field specifies one or more icon graphics which visually represent the application.
An icon may be used by a task switcher, in a notifications area, or in an application list on the device. The image below shows the icon for the townxelliot media player being used in the application list (left) and recent apps (right) contexts on Android:
The icons
field is compatible with the icons
field in the W3C manifest specification.
Note that this field has no effect when used in a manifest.json
file loaded into an embedded Crosswalk on Android.
The field is a list of icon objects, each of which defines a URL for the icon as a minimum (via a src
attribute). The icon's type
attribute can be specified, describing the graphics format of the icon; and the optimal rendering sizes
and screen pixel density
for which the icon is intended can also be set.
As an example, here is a simple Crosswalk manifest which specifies three icons: one to be used when a 64x64 pixel icon is needed; one to be used when a 128x128 pixel icon is needed; and one to be used when a 128x128 pixel icon is needed and the screen pixel density is 2:
{
"name": "simple_app",
"icons": [
{
"src": "icon_small.png",
"type": "image/png",
"sizes": "64x64"
},
{
"src": "icon_large.png",
"type": "image/png",
"sizes": "128x128"
},
{
"src": "icon_large_hd.png",
"type": "image/png",
"sizes": "128x128",
"density": "2"
}
],
"start_url": "index.html",
"display": "fullscreen",
"orientation": "landscape"
}
The properties for each object in the icons
array are described below.
src
The path to the icon file, relative to the manifest.
type
The MIME type of the icon.
sizes
The icon sizes for which this image is suitable, as space-separated <width>x<height>
substrings. For example:
"sizes": "128x128"
: this image is suitable for use as a 128x128 pixel icon."sizes": "128x128 256x256"
: this image is suitable for use as a 128x128 or 256x256 pixel icon.
Note that the value for the sizes
property is not the intrinsic size of the image (i.e. the pixel size stored in the image file): it is the set of icon sizes for which this image file is suitable. This means it is possible to have an image file with an intrinsic size smaller or larger than the icon it will serve as.
For example, an image file may be 128x128 pixels in size; but the manifest may state that this image can be used for 128x128 or 256x256 pixel icons. When used as a 256x256 pixel icon, the image file will be scaled up (2x) to fit the required icon size (which may result in some degradation in its appearance).
density
The density
property specifies which screen densities an icon should be used for. Coupled with the sizes
property, it makes it possible to adjust which image file is delivered for a particular icon size at a given screen density.
If you are unfamiliar with the concept of screen density, see the screen measurements page.
The property's value is a float representing the screen density for which the image is suitable, in dots per pixel (dppx). For example:
"density": "2"
: this image is suitable for screens with a density of 2dppx."density": "1.5"
: this image is suitable for screens with a density of 1.5dppx.
If density
is not set, the default is 1.0
.
To see how this works out in practice, imagine you have an icon which is 128x128 raw pixels. Now you put it on a device with one physical pixel per CSS pixel (1dppx) where a 128x128 pixel icon is required. Each raw pixel of the original image occupies one pixel in the icon on the device's screen.
Now imagine a different device with density of 2dppx, which also requires a 128x128 icon. If the same 128x128 image file is used to fill that space on the screen, each raw pixel of the image occupies 4 pixels (2x2) on the device screen. The result is a blurred image, as the same single pixel is used to fill 4 pixels on the screen.
To resolve this, the W3C specification recommends using images with different raw sizes, depending on the desired icon size and screen density. It provides this example:
"An icon that is 50 CSS pixels wide intended for displays with a device pixel density of two device pixels per CSS pixel (2x, 192dpi) would have a width of 100 raw pixels."
From this, we can derive a formula for working out how big a raw image file should be for a given icon size and density:
raw image file dimensions = dimensions of required icon in device-independent pixels * device screen pixel density
For our case, we use two image files:
foo.png
with raw size of 128x128 pixels, intended for use as a 128x128 dip icon on screens with density of 1dppx.foo_hd.png
with raw size of 256x256 pixels, intended for use as a 128x128 dip icon on screens with density of 2dppx.
And set the icons
property in the manifest as:
"icons": [
{
"src": "foo.png",
"type": "image/png",
"sizes": "128x128",
"density": "1.0"
},
{
"src": "foo_hd.png",
"type": "image/png",
"sizes": "128x128",
"density": "2.0"
}
]
Note that we don't mention anywhere that foo_hd.png
is 256x256 raw pixels in size: we just specify that it is suitable for a 128x128 pixel icon on a screen with density of 2dppx.
Effect on Android packaging
Rather than affecting the Crosswalk runtime on Android directly, the icons
field affects how an application is packaged by make_apk.py
. The make_apk.py
script discards some of the information included in the icon
field, for example the density
.
If the icons
field contains multiple icon sizes, the make_apk.py
script will map the corresponding icon files to Android drawable resources depending on their size.
When the application is installed, Android will use the file appropriate for the target's screen resolution as the application icon in the home screen, application list and other relevant locations.
Acknowledgements
The townxelliot media player icon was modified from an original icon created by wpzoom.com under a CC BY-SA licence. It was sourced from Find Icons.
The modified icon is made available here to satisfy the terms of the licence, and is released under the same CC BY-SA licence:


Home
Connected!
CompanyInfo
Refresh Token
Revoke Token
Invoicing
Managing Inventory
Pay Bills
Landing Jobs
Reports
Accounting


Topicstarter
Under the engineer weapon tab it should be an own section for the rockets (rpg,smaw,igla,stinger and javlin)
like this:
-----------
1. m4a1 1046 kills
2. Scar-h 769 kills
-----------
RPG 459 kills
Stinger 342 kills
-----------
Eod Bot 2 kills
Mines 124 kils
-----------
and maybe the same under the assult class, you have the m320 and m26 in one section.
and in the recon class you have the autosnipers in one section.
In other words, have sub sections of weapons.
BrainFooLong
Administrator
Was requested in the past.
Wait for next version, with it comes some new sort of filtering.