First things first, this articles are about WebGL2. If you're interested in WebGL 1.0 please go here. Note that WebGL 2 is nearly 100% backward compatible with WebGL 1. That said, once you enable WebGL 2 you might as well use it as it was meant to be used. These tutorials follow that path.
WebGL is often thought of as a 3D API. People think "I'll use WebGL and magic I'll get cool 3d". In reality WebGL is just a rasterization engine. It draws points, lines, and triangles based on code you supply. Getting WebGL to do anything else is up to you to provide code to use points, lines, and triangles to accomplish your task.
WebGL runs on the GPU on your computer. As such you need to provide the code that runs on that GPU. You provide that code in the form of pairs of functions. Those 2 functions are called a vertex shader and a fragment shader and they are each written in a very strictly typed C/C++ like language called GLSL. (GL Shader Language). Paired together they are called a program.
A vertex shader's job is to compute vertex positions. Based on the positions the function outputs WebGL can then rasterize various kinds of primitives including points, lines, or triangles. When rasterizing these primitives it calls a second user supplied function called a fragment shader. A fragment shader's job is to compute a color for each pixel of the primitive currently being drawn.
Nearly all of the entire WebGL API is about setting up state for these pairs of functions to run.

Any data you want those functions to have accesse to must be provided to the GPU. There are 4 ways a shader can receive data.
Attributes, Buffers, and Vertex Arrays
Buffers are arrays of binary data you upload to the GPU. Usually buffers contain things like positions, normals, texture coordinates, vertex colors, etc although you're free to put anything you want in them.
Attributes are used to specify how to pull data how of your buffers and provide them to your vertex shader. For example you might put positions in a buffer as three 32bit floats per position. You would tell a particular attribute which buffer to pull the positions out of, what type of data it should pull out (3 component 32 bit floating point numbers), what offset in the buffer the positions start, and how many bytes to get from one position to the next.
Buffers are not random access. Instead a vertex shaders is executed a specified number of times. Each time it's executed the next value from each specified buffers is pulled out assigned to an attribute.
The state of attributes, which buffers to use for each one and how to pull out data from those buffers, is collected into a vertex array object (VAO).
Uniforms
Uniforms are effectively global variables you set before you execute your shader program.
Textures
Textures are arrays of data you can randomly access in your shader program. The most common thing to put in a texture is image data but textures are just data and can just as easily contain something other than colors.
Varyings
Varyings are a way for a vertex shader to pass data to a fragment shader. Depending on what is being rendered, points, lines, or triangles, the values set on a varying by a vertex shader will be interpolated while executing the fragment shader.
WebGL only cares about 2 things. Clipspace coordinates and colors. Your job as a programmer using WebGL is to provide WebGL with those 2 things. You provide your 2 "shaders" to do this. A Vertex shader which provides the clipspace coordinates and a fragment shader that provides the color.
Clipspace coordinates always go from -1 to +1 no matter what size your canvas is. Here is a simple WebGL example that shows WebGL in its simplest form.
Let's start with a vertex shader
#version 300 es
// an attribute is an input (in) to a vertex shader.
// It will receive data from a buffer
in vec4 a_position;
// all shaders have a main function
void main() {
// gl_Position is a special variable a vertex shader
// is responsible for setting
gl_Position = a_position;
}
When executed, if the entire thing was written in JavaScript instead of GLSL you could imagine it would be used like this
// *** PSUEDO CODE!! ***
var positionBuffer = [
0, 0, 0, 0,
0, 0.5, 0, 0,
0.7, 0, 0, 0,
];
var attributes = {};
var gl_Position;
drawArrays(..., offset, count) {
var stride = 4;
var size = 4;
for (var i = 0; i < count; ++i) {
// copy the next 4 values from positionBuffer to the a_position attribute
attributes.a_position = positionBuffer.slice((offset + i) * stide, size);
runVertexShader();
...
doSomethingWith_gl_Position();
}
In reality it's not quite that simple because positionBuffer
would need to be converted to binary
data (see below) and so the actual computation for getting data out of the buffer
would be a little different but hopefully this gives you an idea of how a vertex
shader will be executed.
Next we need a fragment shader
#version 300 es
// fragment shaders don't have a default precision so we need
// to pick one. mediump is a good default. It means "medium precision"
precision mediump float;
// we need to declare an output for the fragment shader
out vec4 outColor;
void main() {
// Just set the ouput to a constant redish-purple
outColor = vec4(1, 0, 0.5, 1);
}
Above we declared outColor
as our fragment shader's output. We're setting outColor
to 1, 0, 0.5, 1
which is 1 for red, 0 for green, 0.5 for blue, 1 for alpha. Colors in WebGL go from 0 to 1.
Now that we have written the 2 shader functions lets get started with WebGL
First we need an HTML canvas element
<canvas id="c" width="400" height="300"></canvas>
Then in JavaScript we can look that up
var canvas = document.getElementById("c");
Now we can create a WebGLRenderingContext
var gl = canvas.getContext("webgl2");
if (!gl) {
// no webgl2 for you!
...
Now we need to compile those shaders to put them on the GPU so first we need to get them into strings. You can create your GLSL strings any way you normally create strings in JavaScript. For example by concatenating, by using AJAX to download them, by putting them in non-javascript script tags, or in this case in multiline template strings.
var vertexShaderSource = `#version 300 es
// an attribute is an input (in) to a vertex shader.
// It will receive data from a buffer
in vec4 a_position;
// all shaders have a main function
void main() {
// gl_Position is a special variable a vertex shader
// is responsible for setting
gl_Position = a_position;
}
`;
var fragmentShaderSource = `#version 300 es
// fragment shaders don't have a default precision so we need
// to pick one. mediump is a good default. It means "medium precision"
precision mediump float;
// we need to declare an output for the fragment shader
out vec4 outColor;
void main() {
// Just set the ouput to a constant redish-purple
outColor = vec4(1, 0, 0.5, 1);
}
`;
In fact, most 3D engines generate GLSL shaders on the fly using various types of templates, concatenation, etc. For the samples on this site though none of them are complex enough to need to generate GLSL at runtime.
NOTE:
#version 300 es
MUST BE THE VERY FIRST LINE OF YOUR SHADER. No comments or blank lines are allowed before it!#version 300 es
tells WebGL2 you want to use WebGL2's shader language called GLSL ES 3.00. If you don't put that as the first line the shader language defaults to WebGL 1.0's GLSL ES 1.00 which has many differences and far less features.
Next we need a function that will create a shader, upload the GLSL source, and compile the shader. Note I haven't written any comments because it should be clear from the names of the functions what is happening.
function createShader(gl, type, source) {
var shader = gl.createShader(type);
gl.shaderSource(shader, source);
gl.compileShader(shader);
var success = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
if (success) {
return shader;
}
console.log(gl.getShaderInfoLog(shader));
gl.deleteShader(shader);
}
We can now call that function to create the 2 shaders
var vertexShader = createShader(gl, gl.VERTEX_SHADER, vertexShaderSource);
var fragmentShader = createShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSource);
We then need to link those 2 shaders into a program
function createProgram(gl, vertexShader, fragmentShader) {
var program = gl.createProgram();
gl.attachShader(program, vertexShader);
gl.attachShader(program, fragmentShader);
gl.linkProgram(program);
var sucesss = gl.getProgramParameter(program, gl.LINK_STATUS);
if (success) {
return program;
}
console.log(gl.getProgramInfoLog(program));
gl.deleteProgram(program);
}
And call it
var program = createProgram(gl, vertexShader, fragmentShader);
Now that we've created a GLSL program on the GPU we need to supply data to it.
The majority of the WebGL API is about setting up state to supply data to our GLSL programs.
In this case our only input to our GLSL program is a_position
which is an attribute.
The first thing we should do is look up the location of the attribute for the program
we just created
var positionAttributeLocation = gl.getAttribLocation(program, "a_position");
Looking up attribute locations (and uniform locations) is something you should do during initialization, not in your render loop.
Attributes get their data from buffers so we need to create a buffer
var positionBuffer = gl.createBuffer();
WebGL lets us manipulate many WebGL resources on global bind points. You can think of bind points as internal global variables inside WebGL. First you bind a resource to a bind point. Then, all other functions refer to the resource through the bind point. So, let's bind the position buffer.
gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
Now we can put data in that buffer by referencing it through the bind point
// three 2d points
var positions = [
0, 0,
0, 0.5,
0.7, 0,
];
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STATIC_DRAW);
There's a lot going on here. The first thing is we have positions
which is a
JavaScript array. WebGL on other hand needs strongly typed data so the part
new Float32Array(positions)
creates a new array of 32bit floating point numbers
and copies the values from positions
. gl.bufferData
then copies that data to
the positionBuffer
on the GPU. It's using the position buffer because we bound
it to the ARRAY_BUFFER
bind point above.
The last argument, gl.STATIC_DRAW
is a hint to WebGL about how we'll use the data.
WebGL can try to use that hint to optimize certain things. gl.STATIC_DRAW
tells WebGL
we are not likely to change this data much.
Now that we've put data in the a buffer we need to tell the attribute how to get data out of it. First we need to create a collection of attributes called a Vertex Array Object.
var vao = gl.createVertexArray();
And we need to make that the current vertex array so that all of our attribute settings will apply to that set of attribute state
gl.bindVertexArray(vao);
Now we finally setup the attributes in the vertex array. First off we need to turn the attribute on
gl.enableVertexAttribArray(positionAttributeLocation);
Then we need to specify how to pull the data out
var size = 2; // 2 components per iteration
var type = gl.FLOAT; // the data is 32bit floats
var normalize = false; // don't normalize the data
var stride = 0; // 0 = move forward size * sizeof(type) each iteration to get the next position
var offset = 0; // start at the beginning of the buffer
gl.vertexAttribPointer(
positionAttributeLocation, size, type, normalize, stride, offset)
A hidden part of gl.vertexAttribPointer
is that it binds the current ARRAY_BUFFER
to the attribute. In other words now this attribute is bound to
positionBuffer
. That means we're free to bind something else to the ARRAY_BUFFER
bind point.
The attribute will continue to use positionBuffer
.
note that from the point of view of our GLSL vertex shader the a_position
attribute was a vec4
attribute vec4 a_position;
vec4
is a 4 float value. In JavaScript you could think of it something like
a_position = {x: 0, y: 0, z: 0, w: 0}
. Above we set size = 2
. Attributes
default to 0, 0, 0, 1
so this attribute will get its first 2 values (x and y)
from our buffer. The z, and w will be the default 0 and 1 respectively.
We need tell WebGL how to convert from the clip space
values we'll be setting gl_Position
to back into pixels, often called screen space.
To do this we call gl.viewport
gl.viewport(0, 0, gl.canvas.width, gl.canvas.height);
This tells WebGL the -1 +1 clip space maps to 0 -> gl.canvas.width
for x and 0 -> gl.canvas.height
for y. Note the viewport settings default to the initial size of our canvas. If we never
change the size of the canvas we might not need to set the viewport.
Finally we need to tell WebGL which shader program to execute.
gl.useProgram(program);
After all that we can finally ask WebGL to execute our GLSL program.
var primitiveType = gl.TRIANGLES;
var offset = 0;
var count = 3;
gl.drawArrays(primitiveType, offset, count);
Because the count is 3 this will execute our vertex shader 3 times. The first time a_position.x
and a_position.y
in our vertex shader attribute will be set to the first 2 values from the positionBuffer.
The 2nd time a_position.xy
will be set to the 2nd two values. The last time it will be
set to the last 2 values.
Because we set primitiveType
to gl.TRIANGLES
, each time our vertex shader is run 3 times
WebGL will draw a triangle based on the 3 values we set gl_Position
to. No matter what size
our canvas is those values are in clip space coordinates that go from -1 to 1 in each direction.
Because our vertex shader is simply copying our positionBuffer values to gl_Position
the
triangle will be drawn at clip space coordinates
0, 0,
0, 0.5,
0.7, 0,
Converting from clip space to screen sapce WebGL is going to draw a triangle at
clip space screen space
0, 0 -> 200, 150
0, 0.5 -> 200, 225
0.7, 0 -> 340, 150
WebGL will now render that triangle. For every pixel it is about to draw WebGL will call our fragment shader.
Our fragment shader just sets gl_FragColor
to 1, 0, 0.5, 1
. Since the Canvas is an 8bit
per channel canvas that means WebGL is going to write the values [255, 0, 127, 255]
into the canvas.
Here's a live version
In the case above you can see our vertex shader is doing nothing but passing on our position data directly. Since the position data is already in clipspace there is no work to do. If you want 3D it's up to you to supply shaders that convert from 3D to clipspace because WebGL is only a rasterization API.
You might be wondering why does the triangle start in the middle and go to toward the top right.
Clip space in x
goes from -1 to +1. That means 0 is in the center and positive values will
be to the right of that.
As for why it's on the top, in clip space -1 is at the bottom and +1 is at the top. That means 0 is in the center and so positive numbers will be above the center.
For 2D stuff you would probably rather work in pixels than clipspace so let's change the shader so we can supply the position in pixels and have it convert to clipspace for us. Here's the new vertex shader
- in vec4 a_position;
* in vec2 a_position;
+ uniform vec2 u_resolution;
void main() {
+ // convert the position from pixels to 0.0 to 1.0
+ vec2 zeroToOne = a_position / u_resolution;
+
+ // convert from 0->1 to 0->2
+ vec2 zeroToTwo = zeroToOne * 2.0;
+
+ // convert from 0->2 to -1->+1 (clipspace)
+ vec2 clipSpace = zeroToTwo - 1.0;
+
* gl_Position = vec4(clipSpace, 0, 1);
}
Some things to notice about the changes. We changed a_position
to a vec2
since we're
only using x
and y
anyway. A vec2
is similar to a vec4
but only has x
and y
.
Next we added a uniform
called u_resolution
. To set that we need to look up its location.
var resolutionUniformLocation = gl.getUniformLocation(program, "u_resolution");
The rest should be clear from the comments. By setting u_resolution
to the resolution
of our canvas the shader will now take the positions we put in positionBuffer
supplied
in pixels coordinates and convert them to clip space.
Now we can change our position values from clip space to pixels. This time we're going to draw a rectangle made from 2 triangles, 3 points each.
var positions = [
* 10, 20,
* 80, 20,
* 10, 30,
* 10, 30,
* 80, 20,
* 80, 30,
];
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STATIC_DRAW);
And after we set which program to use we can set the value for the uniform we created.
Use program is like gl.bindBuffer
above in that it sets the current program. After
that all the gl.uniformXXX
functions set uniforms on the current program.
gl.useProgram(program);
// Pass in the canvas resolution so we can convert from
// pixels to clipspace in the shader
gl.uniform2f(resolutionUniformLocation, gl.canvas.width, gl.canvas.height);
And of course to draw 2 triangles we need to have WebGL call our vertex shader 6 times
so we need to change the count
to 6
.
// draw
var primitiveType = gl.TRIANGLES;
var offset = 0;
*var count = 6;
gl.drawArrays(primitiveType, offset, count);
And here it is
Again you might notice the rectangle is near the bottom of that area. WebGL considers the bottom left corner to be 0,0. To get it to be the more traditional top left corner used for 2d graphics APIs we can just flip the clip space y coordinate.
* gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);
And now our rectangle is where we expect it.
Let's make the code that defines a rectangle into a function so we can call it for different sized rectangles. While we're at it we'll make the color settable.
First we make the fragment shader take a color uniform input.
#version 300 es
precision mediump float;
+ uniform vec4 u_color;
out vec4 outColor;
void main() {
- outColor = vec4(1, 0, 0.5, 1);
* outColor = u_color;
}
And here's the new code that draws 50 rectangles in random places and random colors.
var colorLocation = gl.getUniformLocation(program, "u_color");
...
// draw 50 random rectangles in random colors
for (var ii = 0; ii < 50; ++ii) {
// Setup a random rectangle
setRectangle(
gl, randomInt(300), randomInt(300), randomInt(300), randomInt(300));
// Set a random color.
gl.uniform4f(colorLocation, Math.random(), Math.random(), Math.random(), 1);
// Draw the rectangle.
gl.drawArrays(gl.TRIANGLES, 0, 6);
}
}
// Returns a random integer from 0 to range - 1.
function randomInt(range) {
return Math.floor(Math.random() * range);
}
// Fills the buffer with the values that define a rectangle.
function setRectangle(gl, x, y, width, height) {
var x1 = x;
var x2 = x + width;
var y1 = y;
var y2 = y + height;
// NOTE: gl.bufferData(gl.ARRAY_BUFFER, ...) will affect
// whatever buffer is bound to the `ARRAY_BUFFER` bind point
// but so far we only have one buffer. If we had more than one
// buffer we'd want to bind that buffer to `ARRAY_BUFFER` first.
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
x1, y1,
x2, y1,
x1, y2,
x1, y2,
x2, y1,
x2, y2]), gl.STATIC_DRAW);
}
And here's the rectangles.
I hope you can see that WebGL is actually a pretty simple API. Okay, simple might be the wrong word. What it does is simple. It just executes 2 user supplied functions, a vertex shader and fragment shader and draws triangles, lines, or points. While it can get more complicated to do 3D that complication is added by you, the programmer, in the form of more complex shaders. The WebGL API itself is just a rasterizer and conceptually fairly simple.
We covered a small example that showed how to supply data in an attribute and 2 uniforms. It's common to have multiple attributes and many uniforms. Near the top of this article we also mentioned varyings and textures. Those will show up in subsequent lessons.
Before we move on I want to mention that for most applications updating
the data in a buffer like we did in setRectangle
is not common. I used that
example because I thought it was easiest to explain since it shows pixel coordinates
as input and demonstrates doing a small amount of math in GLSL. It's not wrong, there
are plenty of cases where it's the right thing to do, but you should keep reading to find out
the more common way to position, orient and scale things in WebGL.
If you're 100% new to WebGL and have no idea what GLSL is or shaders or what the GPU does then checkout the basics of how WebGL really works.
You should also, at least briefly read about the boilerplate code used here that is used in most of the examples. You should also at least skim how to draw mulitple things to give you some idea of how more typical WebGL apps are structured because unfortunately nearly all the examples only draw one thing and so do not show that structure.
Otherwise from here you can go in 2 directions. If you are interested in image procesing I'll show you how to do some 2D image processing. If you are interesting in learning about translation, rotation and scale then start here.


Note that the reload function cannot merge two GEDCOM files, it will only overwrite (and restore) existing data as identified by its ID.
message


{% extends 'microDonation/base.html' %} {% block title %} Success {% endblock %} {% block cart %}
Payment completed. Thanks for choosing MicroDonation!


{% extends 'users/base.html' %}{% load static %} {% block js %}{% if request.user.is_superuser %} {% endif %}{% endblock %} {% block content %} {% if not request.user.is_authenticated %}
This page is intended for authors and site administrators. If you would like to return to the home page, you may do so by clicking here.


| < Day Day Up > |
The MERGECOPY UtilityThe MERGECOPY utility combines multiple incremental image copy data sets into a new full or incremental image copy data set. See Listing 32.5 for sample JCL. The first control card depicts the merging of image copy data sets for the DSN8D81A.DSN8S81D table space into a full image copy. The second control card shows statements that create a new incremental image copy data set for the DSN8D81A.DSN8S81E table space. Listing 32.5. MERGECOPY JCL//DB2JOBU JOB (UTILITY), 'MERGECOPY',CLASS=X,MSGCLASS=X,NOTIFY=USER //* //**************************************************************** //* //* DB2 MERGECOPY UTILITY //* //**************************************************************** //* //COPY EXEC DSNUPROC,SYSTEM=DSN,UID='MERGCOPY',UTPROC=" //* //* UTILITY WORK DATASETS //* //DSNUPROC.SYSUT1 DD DSN=CAT.SYSUT1,DISP=(MOD,CATLG,CATLG), // UNIT=SYSDA,SPACE=(CYL,(10,1)),DCB=BUFNO=20 //DSNUPROC.SYSCOPY1 DD DSN=CAT.FULLCOPY.SEQ.DATASETD(+1), // DISP=(MOD,CATLG),DCB=(SYS1.MODEL, BUFNO=20), // SPACE=(CYL,(5,1),RLSE),UNIT=TAPE //DSNUPROC.SYSCOPY2 DD DSN=CAT.INCRCOPY.SEQ.DATASETE(+1), // DISP=(MOD,CATLG),DCB=(SYS1.MODEL, BUFNO=20), // SPACE=(CYL,(2,1),RLSE),UNIT=TAPE //* //* UTILITY INPUT CONTROL STATEMENTS //* The first MERGECOPY statement creates a new full //* image copy for the DSN8D81A. //* The second statement creates a new incremental copy //* for the named table space. //* //DSNUPROC.SYSIN DD * MERGECOPY TABLESPACE DSN8D81A.DSN8S81D DSNUM ALL NEWCOPY YES COPYDDN SYSCOPY1 MERGECOPY TABLESPACE DSN8D81A.DSN8S81E DSNUM ALL NEWCOPY NO COPYDDN SYSCOPY2 /* // MERGECOPY PhasesThe MERGECOPY utility runs in three phases:
Estimating SYSUT1 and SYSCOPY Data Set SizesThe MERGECOPY utility sometimes requires the use of the SYSUT1 work data set to merge image copies. If it is impossible to simultaneously allocate all the data sets to be merged, SYSUT1 is used to hold intermediate output from the merge. If not enough tape drives are available (to allocate the incremental copy data sets) when MERGECOPY runs, be sure to allocate a SYSUT1 data set. The SYSCOPY data set holds the final merged image copy data and must be specified. The space required for this data set is the same as would be required for the SYSCOPY data set for the COPY utility. A merged image copy and a full image copy should be functionally equivalent and therefore should consume the same amount of space. The following formula should be used to calculate an estimated size for this data set. This calculation is only an estimate. More complex and precise calculations are in the DB2 Utility Guide and Reference manual, but this formula should produce comparable results. SYSUT1 = (size of the largest data set to be merged) x 1.5 SYSCOPY = (number of formatted pages) x 4096 If the table space being merged uses 32K pages, multiply the result of the SYSCOPY calculation by 8. The total number of pages used by a table space can be retrieved from either the VSAM LISTCAT command or the DB2 Catalog as specified in the NACTIVE column of SYSIBM.SYSTABLESPACE. If you are using the DB2 Catalog method, ensure that the statistics are current by running the RUNSTATS utility (discussed in Chapter 34). After calculating the estimated size for the data sets, convert the number into cylinders, rounding up to the next whole cylinder. Allocating work data sets in cylinder increments enhances the utility's performance. ConcurrencyConcurrent read and write activity can occur during execution of the MERGECOPY utility. The MERGECOPY utility can run concurrently with any utility except the following:
MERGECOPY GuidelinesWhen running MERGECOPY, consider using the following techniques and guidelines. Merge Incremental Copies As Soon As PossibleDirectly after the execution of an incremental COPY, run the MERGECOPY utility to create a new full image copy. In this way, the resources to create a new full image copy are used at a non-critical time. If you decide to avoid the creation of full image copies until there is an error, valuable time can be consumed by processing that could have taken place at a less critical time. Use MERGECOPY to Create Full Image CopiesSpecify NEWCOPY YES to produce a new full image copy. NEWCOPY NO can be used to produce a new incremental copy. Favor the creation of new full image copies rather than incremental copies because less work must be performed to correct an error if full table space image copies exist. Specify the SYSUT1 Data SetAlways specify a data set for SYSUT1 to avoid rerunning MERGECOPY. If SYSUT1 is not specified, the MERGECOPY job might be unable to allocate all the data sets needed for the merge, thereby requiring that MERGECOPY be run again. This must continue until all incremental copies have been merged into a new image copy data set, either full or incremental. If SYSUT1 is not specified, the output of the MERGECOPY utility indicates whether another merge must be run. MERGECOPY produces a message indicating the number of existing data sets and the number of merged data sets. If these numbers are not equal, rerun the MERGECOPY utility. Again, this can be avoided by specifying a SYSUT1 data set. Buffer the SYSCOPY and SYSUT1 Data SetsFor large image copies, set the BUFNO parameter in the JCL for the SYSCOPY DD statements to a number greater than 20. The BUFNO parameter creates read and write buffers in main storage for the data set, thereby enhancing the performance of the COPY utility. Ensure that sufficient memory (real or expanded) is available, however, before increasing the BUFNO specification for your SYSCOPY data sets. Also, consider specifying a larger BUFNO for the SYSUT1 data set if you expect many incremental image copies to be required. |
| < Day Day Up > |


My name is Konstantin, I'm from Russia, Yekaterinburg
This is my CS50 Final project. It's simple Web-to-Phone service.
Call Status


Chris McDonough is speculating on a "more perfect app server". Of course, I'd say that would be a WSGI stack (a-la Paste). But how that works might not be obvious. I thought I'd speculate on what a "transaction manager" might look like in this system. I'll just include part of the untested code:
class TransactionManagerMiddleware(object): def __init__(self, application): self.application = application def __call__(self, environ, start_response): environ['paste.transaction_manager'] = manager = Manager() # This makes sure nothing else traps unexpected exceptions: environ['paste.throw_errors'] = True return wsgilib.catch_errors(application, environ, start_response, error_callback=manager.error, ok_callback=manager.finish) class Manager(object): def __init__(self): self.aborted = False self.transactions = [] def abort(self): self.aborted = True def error(self, exc_info): self.aborted = True self.finish() def finish(self): for trans in self.transactions: if self.aborted: trans.rollback() else: trans.commit()
And you use it a little like this:
def my_app(environ, start_response): manager = environ['paste.transaction_manager'] manager.transactions.append(MakeTransactionObject()) ... application = TransactionManagerMiddleware(my_app)
I created the function paste.wsgilib.catch_errors for this, but only because it's something that's come up before. catch_errors would be pretty simple if it wasn't for the iterable that applications can produce.
This is only one of several features Chris mentions, but my point is one of proof-of-concept -- most of the features he wants can be implemented separately and in a highly decoupled way using WSGI middleware (or sometimes simply mundane libraries). The advantages aren't just testability, but also simplicity (include what you care about, replace what's broken for you) and the potential for the kind of distributed development that open source relies on.
The transaction manager in zope is decoupled and already provides a much more robust and well tested interface.
http://svn.zope.org/ZODB/trunk/src/transaction/
Only real dependency is the zope.interface package.
I know its fashionable to rewrite things from scratch in python, and to bash on zope, but its just sad sometimes how much stuff people put out that just can't meet any real world applications beyond their initial design constraints or toy apps, because they were never written with flexibility in mind or the needed domain expertise.
the zope developers are solving complex real world problems today, might as well learn something from their expertise.
# anonymous
Sure; this was just an example, and I wasn't proposing it replace anything; that's why it just went in a scratch directory. The code you link to would replace Manager, and provides interfaces for the transactions themselves; except it calls Manager a Transaction, and the objects it contains DataManager. A lot of the additional code it provides seems to be for logging and debugging, and two-phase commit. All good code, I'm sure.
In generally WSGI/middleware applies to the integration of code like that into the request cycle; if the transaction handling code was linked to WSGI that would be a bad sign. It's best that the integration code be short, since the transaction code should also be usable outside of a web request, and if the integration code is long then that's a sign the code being integrated is obtuse or incomplete.
# Ian Bicking
wrap the Zope transaction manager into a WSGI application interface as above and the world can take advantage of its great maturity.
I think for 90% of the use cases, Zope's implementation is far too complicated. In typical cases, you're using a DBAPI driver and you have a database connection (perhaps pooled, but this is an orthogonal issue) per request. In the end, if there is an exception, you rollback; otherwise you commit. It isn't that hard. I'd rather not include a huge chunk of code like that in my webserver unless I absolutely need it. Minimilism is a very good thing.
+100 on the pipelining of components ala WSGI/Paste to get some of this stuff done. I think wherever it's appropriate to factor something out into WSGI middleware (authentication is a great example, as are sessions, an error renderer, and maybe a txn manager), it feels really good to do so. I'm going to try to take a closer look at Paste as I continue thinking about what would make a great appserver stack.
# Chris McDonough


Shopping list application
Functionality:
Create new user
Log in to / logout from the application
Browse list of products
Add new product to the list
View details of the selected product
Check / uncheck, delete, edit product
Support for REST methods
Show product list


PyObjC can be used with InterfaceBuilder, the best way to use Interface Builder depends on the version of Xcode you are using.
When you’re running MacOSX 10.5, with Xcode 3 or later, Interface Builder has builtin support for Python and can extract class, action and outlet definitions from Python source code.
To define a class that will be picked up by Inteface Builder:
class MyModel (NSObject): window = objc.IBOutlet() @objc.IBAction def doSomething_(self, sender): pass
Inteface Builder obviously has to know about the source files that contain your Python classes. There are two ways to accomplisch this, depending on whether or not you use Xcode. If you use Xcode Interface Builder will automaticly pick up all source code that’s added to your project and it will also automaticly detect changes to those sources.
If you do not use Xcode you can add new source files to Interface Builder using the “File -> Read Class Files ...” menu. This will scan the sources, but will not automaticly detect changes to those sources, use the menu “File -> Reload All Class Files” to reload the class definitions.
This section is fairly minimal because I’ve stopped using Xcode 2 and do all my development on OSX 10.5
The version of Xcode that ships with Xcode 2 does not support Python code, which means that you will have to define your classes twice: one times in actual (Python) code, and then again in Interface Builder.
The module PyObjCTools.NibClassBuilder allows you to remove some of the duplication in class definitions between Python and Interface Builder. This module was used a lot before Xcode 3 was released, but is now deprecated and doesn’t work with NIB files created in Xcode 3.
Please migrate to manual class definitions (as described in the section about Xcode 3) as soon as possible. This is slightly more work, but ensures that your code will work with later versions of Xcode and PyObjC.


Implementation of API's and web servers.
Development of web pages for any type of company.
Design and creation of mobile applications for Android and IOS.


If you’re actively keeping records to manage your finances, to adjust your prices and keep track of your income and expenses, you’re more likely to be in business. Businesses must keep records, whereas a hobby may not need to but might want to for the future.


How to search for images, attachments and scans in Notes on iOS
by Sandy WrittenhouseWith some great new features that came with iOS 13 and iPadOS, the Notes app received a nice update. One of those improvements includes enhancements to the search feature. You can now search for items within images and scans you’ve attached to your notes.
Want to find that photo of your car in a note from last year? Need the invoice scan you sent Mr. Jones? If it’s attached to a note, you can find it easily. Here’s how to search for images, attachments, and scans in Notes on iOS.
Search images and scans
You can use a keyword to find an object in a photo or word in a scan that you attached to a note.
Open the Notes app on your iPhone or iPad and go to a folder where you believe the item is kept or use All iCloud to search them all.
Swipe down slightly on the screen to reveal the search box at the top and enter your search term.
The app should recognize objects in images that you have attached. For instance, you can see in the screenshot below that I searched for “crowd,” and that’s exactly the photo that was found.
You can enter a word to search for a document that you have scanned and attached. For example, in the screenshot below you can see that I searched for “receipt,” and Notes found both a scan and a note with my keyword.
Search for attachments with notes
Remember that you can also find notes that have attachments. For instance, you know that you scanned a document and attached it to a note, but can’t find that note.
- Go to a folder or pick All iCloud.
- Tap the More button and pick View Attachments.
- When you see the attachment for the note, tap and hold.
- Then pick Show in Note.
You’ll then be taken to the note containing the attachment.
Wrapping it up
Finding images, scans, and attachments in the Notes app is now easier than ever thanks to the search improvements that came with iOS 13 and iPadOS.
Do you have any tips or tricks for the Notes app that you’ve discovered and want to share? Feel free to comment below!


Proximity 4.3 is fully compatible with MonetDB 4.6.2, the version of MonetDB distributed with Proximity 4.0 through 4.2. Users updating from Proximity 4.0 or later versions can continue to use their existing MonetDB installation and databases and safely ignore this section. However, if you choose to update your MonetDB installation to one of the “Mars” versions, you must also update your databases to use the new database format. Users updating from Proximity 3.1 or earlier should contact technical support at<EMAIL_ADDRESS>for assistance.
Updating databases from MonetDB 4.6.2 to Monet Mars (4.18.2 or 4.20) requires exporting the current database to the Proximity plain text or XML data format and then importing the data into the new version of MonetDB. For most import or export operations, we recommend using the more robust Proximity XML format in order to take advantage of its error checking capabilities. In this case, because you are importing unchanged data exported from Proximity, the use of the plain text format is recommended for performance reasons. See Chapter 3, Importing and Exporting Proximity Data, for additional information on exporting and importing data using Proximity’s plain text and XML data formats.
Databases converted to MonetDB Mars may not be usable in older versions of MonetDB. We recommend that you backup any database that you might want to use in an older version of MonetDB before converting it to MonetDB Mars.
If you have not already done so, install the new versions of Proximity and MonetDB. Do not delete MonetDB 4.6.2.
Serve the database using MonetDB 4.6.2.
>/usr/local/Monet-46/bin/Mserver --dbname db-name
\
$PROX_HOME/resources/init-mserver.mil --set port=45678
where db-name
is the database name and
$PROX_HOME
is the location of your local Proximity
installation. Using a port number > 4000 tells Proximity
to use the MonetDB 4.6.2 protocol.
Windows users should substitute the appropriate path to their MonetDB 4.6.2 installation’s Mserver command.
Export the data to plain text files. You can only export data to the same machine as that serving the database.
>$PROX_HOME/bin/export-text.sh localhost:45678 data-dir
where data-dir
is the absolute path to the
directory that will hold the exported plain text data files.
Windows users should use export-text.bat instead of export-text.sh.
Quit the MonetDB server.
MonetDB> quit();
Serve the new (empty) database. Make sure that you use the
correct path to your new Mserver command either by changing
PATH
or by explicitly including the path on the command
line.
> /usr/local/Monet-mars/bin/Mserver --dbname db-name
\
$PROX_HOME/resources/init-mserver.mil.
where db-name
is the database name. Note
that Proximity 4.3 changes the default port number to
30000. Proximity 4.3 requires a port
number
Windows users should substitute the appropriate path to their MonetDB 4.18.2 installation’s Mserver command.
> $PROX_HOME/bin/db-util.sh localhost:45678 init-db
Import the plain text data. You can only import data residing on the same machine as that serving the database.
> $PROX_HOME/bin/import-text.sh localhost:30000 data-dir
where data-dir
is the absolute path to the
directory containing the plain text data files created in
step 3.
Windows users should use import-text.bat instead of import-text.sh.


What should your programming language be? Answer these simple questions and find out!
Name:
Choose a favorite animal!
Cat
Dog
Bird
Choose a favorite color!
Red
Blue
Green
Choose a favorite hobby!
Hiking
Reading
Crafts
Choose a favorite drink!
Alcoholic
Fruit Smoothies
Sparking Water
Choose a favorite food!
BBQ
Pasta
Veggies
Find your language!
Hey! You got Ruby!
Hey! You got Python!
Hey! You got C#!


About
Work
Contact
This is Welcome Section
Title of Project
Our Best Project
Click to go to the Projects
Click here to go our GitHub page


Daedalus and Icarus
One of the most successful works of the early creative period of Antonio Canova is the marble sculptural group Daedalus and Icarus, made in the then rococo style that was fashionable. At the age of eleven he was sent to Venice, where he studied art and created this sculpture.


Main page
Best scores
About project
Start
Reset
TYPING SPEED TEST
0.00
CHARS / MIN
120
SEC
×
Typing test is done
Insert your name


Oswe-Go was a proof of concept application designed to reserve parking spots on the SUNY Oswego campus. It was supposed to tackle the problem of finding parking spots without actually having to look manually. First, card sorting was performed to see what type of features the application should have, and where they should be placed. Second, prototyping using Balsamiq and Mockingbird was implemented to design the interface of the application. This project idea was presented to our research methods class in the Human Computer Interaction master’s program at SUNY Oswego.


This is a header
This is a card.
It has an easy to override visual style, and is appropriately subdued.


Creating disruptive technology through teamwork and dedication.
Shawn Wilkinson
Founder &
CEO & CTO
Tome Boshevski
Founder & Chief
Design Officer
James Prestwich
Founder &
COO & CFO
John Quinn
Founder & Chief
Development Officer
Anand Babu Periasamy
Advisory Board
Member
Tyler Scriven
Advisory Board
Member
Michael Cohn
Advisory Board
Member
Fabian Barkhau
Developer
Gordon Hall
Matthew Roberts
Developer
Ryan Foran
Developer
Jens Heimbürge
Developer
Robin Beckett
Developer
Dragan Jandreski
Developer
Samuel Batista
Developer
Nicola Minichiello
Operations
Don’t hesitate to join our Slack,
check our open-source code at GitHub,
take a peek at our 60 second video,
send us an email, read the Storj blog
and follow or connect with us.


#include <Stream.h>
◆ ~InputStream()
| Aws::Crt::Io::InputStream::~InputStream |
( |
| ) |
|
|
virtual |
◆ InputStream() [1/3]
| Aws::Crt::Io::InputStream::InputStream |
( |
const InputStream & |
| ) |
|
|
delete |
◆ InputStream() [2/3]
| Aws::Crt::Io::InputStream::InputStream |
( |
InputStream && |
| ) |
|
|
delete |
◆ InputStream() [3/3]
◆ GetLength()
| bool Aws::Crt::Io::InputStream::GetLength |
( |
int64_t & |
length | ) |
|
|
inline |
◆ GetLengthImpl()
| virtual int64_t Aws::Crt::Io::InputStream::GetLengthImpl |
( |
| ) |
const |
|
protectedpure virtualnoexcept |
◆ GetStatus()
| bool Aws::Crt::Io::InputStream::GetStatus |
( |
StreamStatus & |
status | ) |
|
|
inline |
◆ GetStatusImpl()
| virtual StreamStatus Aws::Crt::Io::InputStream::GetStatusImpl |
( |
| ) |
const |
|
protectedpure virtualnoexcept |
◆ GetUnderlyingStream()
| aws_input_stream * Aws::Crt::Io::InputStream::GetUnderlyingStream |
( |
| ) |
|
|
inlinenoexcept |
◆ IsValid()
| virtual bool Aws::Crt::Io::InputStream::IsValid |
( |
| ) |
const |
|
pure virtualnoexcept |
◆ operator bool()
| Aws::Crt::Io::InputStream::operator bool |
( |
| ) |
const |
|
inlineexplicitnoexcept |
◆ operator=() [1/2]
◆ operator=() [2/2]
◆ Read()
| bool Aws::Crt::Io::InputStream::Read |
( |
ByteBuf & |
dest | ) |
|
|
inline |
◆ ReadImpl()
| virtual bool Aws::Crt::Io::InputStream::ReadImpl |
( |
ByteBuf & |
buffer | ) |
|
|
protectedpure virtualnoexcept |
◆ Seek()
| bool Aws::Crt::Io::InputStream::Seek |
( |
int64_t |
offset, |
|
|
StreamSeekBasis |
seekBasis |
|
) |
| |
|
inline |
◆ SeekImpl()
| virtual bool Aws::Crt::Io::InputStream::SeekImpl |
( |
int64_t |
offset, |
|
|
StreamSeekBasis |
seekBasis |
|
) |
| |
|
protectedpure virtualnoexcept |
Seek's the stream to seekBasis based offset bytes.
It is expected, that if seeking to the beginning of a stream, all error's are cleared if possible.
- Returns
- true on success, false otherwise. You SHOULD raise an error via aws_raise_error() if a failure occurs.
◆ m_allocator
| Allocator* Aws::Crt::Io::InputStream::m_allocator |
|
protected |
◆ m_underlying_stream
| aws_input_stream Aws::Crt::Io::InputStream::m_underlying_stream |
|
protected |
The documentation for this class was generated from the following files:


Journey
of
#DailyCssImages
Day01
Bear Cub
Day02
Elephant
Day03
Beaver
Day04
Tiger
Day05
Favorite Animated Animal
Day06
Bear Cub
Day07
Elephant
Day08
Beaver
Day09
Tiger
Day10
Favorite Animated Animal
by
AlinaPant


See: Description
| Class | Description |
|---|---|
| Chromaticity |
Class Chromaticity is a printing attribute class, an enumeration, that
specifies monochrome or color printing.
|
| ColorSupported |
Class ColorSupported is a printing attribute class, an enumeration, that
identifies whether the device is capable of any type of color printing at
all, including highlight color as well as full process color.
|
| Compression |
Class Compression is a printing attribute class, an enumeration, that
specifies how print data is compressed.
|
| Copies |
Class Copies is an integer valued printing attribute class that specifies the
number of copies to be printed.
|
| CopiesSupported |
Class CopiesSupported is a printing attribute class, a set of integers, that
gives the supported values for a
Copies attribute. |
| DateTimeAtCompleted |
Class DateTimeAtCompleted is a printing attribute class, a date-time
attribute, that indicates the date and time at which the Print Job completed
(or was canceled or aborted).
|
| DateTimeAtCreation |
Class DateTimeAtCreation is a printing attribute class, a date-time
attribute, that indicates the date and time at which the Print Job was
created.
|
| DateTimeAtProcessing |
Class DateTimeAtProcessing is a printing attribute class, a date-time
attribute, that indicates the date and time at which the Print Job first
began processing.
|
| Destination |
Class Destination is a printing attribute class, a URI, that is used to
indicate an alternate destination for the spooled printer formatted
data.
|
| DialogTypeSelection |
Class DialogTypeSelection is a printing attribute class, an enumeration,
that indicates the user dialog type to be used for specifying
printing options.
|
| DocumentName |
Class DocumentName is a printing attribute class, a text attribute, that
specifies the name of a document.
|
| Fidelity |
Class Fidelity is a printing attribute class, an enumeration,
that indicates whether total fidelity to client supplied print request
attributes is required.
|
| Finishings |
Class Finishings is a printing attribute class, an enumeration, that
identifies whether the printer applies a finishing operation of some kind
of binding to each copy of each printed document in the job.
|
| JobHoldUntil |
Class JobHoldUntil is a printing attribute class, a date-time attribute, that
specifies the exact date and time at which the job must become a candidate
for printing.
|
| JobImpressions |
Class JobImpressions is an integer valued printing attribute class that
specifies the total size in number of impressions of the document(s) being
submitted.
|
| JobImpressionsCompleted |
Class JobImpressionsCompleted is an integer valued printing attribute class
that specifies the number of impressions completed for the job so far.
|
| JobImpressionsSupported |
Class JobImpressionsSupported is a printing attribute class, a set of
integers, that gives the supported values for a
JobImpressions attribute. |
| JobKOctets |
Class JobKOctets is an integer valued printing attribute class that specifies
the total size of the document(s) in K octets, i.e., in units of 1024 octets
requested to be processed in the job.
|
| JobKOctetsProcessed |
Class JobKOctetsProcessed is an integer valued printing attribute class that
specifies the total number of print data octets processed so far in K octets,
i.e., in units of 1024 octets.
|
| JobKOctetsSupported |
Class JobKOctetsSupported is a printing attribute class, a set of integers,
that gives the supported values for a
JobKOctets
attribute. |
| JobMediaSheets |
Class JobMediaSheets is an integer valued printing attribute class that
specifies the total number of media sheets to be produced for this job.
|
| JobMediaSheetsCompleted |
Class JobMediaSheetsCompleted is an integer valued printing attribute class
that specifies the number of media sheets which have completed marking and
stacking for the entire job so far, whether those sheets have been processed
on one side or on both.
|
| JobMediaSheetsSupported |
Class JobMediaSheetsSupported is a printing attribute class, a set of
integers, that gives the supported values for a
JobMediaSheets attribute. |
| JobMessageFromOperator |
Class JobMessageFromOperator is a printing attribute class, a text attribute,
that provides a message from an operator, system administrator, or
"intelligent" process to indicate to the end user the reasons for
modification or other management action taken on a job.
|
| JobName |
Class JobName is a printing attribute class, a text attribute, that specifies
the name of a print job.
|
| JobOriginatingUserName |
Class JobOriginatingUserName is a printing attribute class, a text
attribute, that contains the name of the end user that submitted the
print job.
|
| JobPriority |
Class JobPriority is an integer valued printing attribute class that
specifies a print job's priority.
|
| JobPrioritySupported |
Class JobPrioritySupported is an integer valued printing attribute class
that specifies whether a Print Service instance supports the
JobPriority attribute and the number of different job priority
levels supported. |
| JobSheets |
Class JobSheets is a printing attribute class, an enumeration, that
determines which job start and end sheets, if any, must be printed with a
job.
|
| JobState |
JobState is a printing attribute class, an enumeration, that identifies
the current state of a print job.
|
| JobStateReason |
Class JobStateReason is a printing attribute class, an enumeration, that
provides additional information about the job's current state, i.e.,
information that augments the value of the job's
JobState
attribute. |
| JobStateReasons |
Class JobStateReasons is a printing attribute class, a set of enumeration
values, that provides additional information about the job's current state,
i.e., information that augments the value of the job's
JobState attribute. |
| Media |
Class Media is a printing attribute class that specifies the
medium on which to print.
|
| MediaName |
Class MediaName is a subclass of Media, a printing attribute class (an
enumeration) that specifies the media for a print job as a name.
|
| MediaPrintableArea |
Class MediaPrintableArea is a printing attribute used to distinguish
the printable and non-printable areas of media.
|
| MediaSize |
Class MediaSize is a two-dimensional size valued printing attribute class
that indicates the dimensions of the medium in a portrait orientation, with
the X dimension running along the bottom edge and the Y dimension running
along the left edge.
|
| MediaSize.Engineering |
Class MediaSize.Engineering includes
MediaSize values
for engineering media. |
| MediaSize.ISO |
Class MediaSize.ISO includes
MediaSize values for ISO
media. |
| MediaSize.JIS |
Class MediaSize.JIS includes
MediaSize values for JIS
(Japanese) media. |
| MediaSize.NA |
Class MediaSize.NA includes
MediaSize values for North
American media. |
| MediaSize.Other |
Class MediaSize.Other includes
MediaSize values for
miscellaneous media. |
| MediaSizeName |
Class MediaSizeName is a subclass of Media.
|
| MediaTray |
Class MediaTray is a subclass of Media.
|
| MultipleDocumentHandling |
Class MultipleDocumentHandling is a printing attribute class, an enumeration,
that controls finishing operations and the placement of one or more
print-stream pages into impressions and onto media sheets.
|
| NumberOfDocuments |
Class NumberOfDocuments is an integer valued printing attribute that
indicates the number of individual docs the printer has accepted for this
job, regardless of whether the docs' print data has reached the printer or
not.
|
| NumberOfInterveningJobs |
Class NumberOfInterveningJobs is an integer valued printing attribute that
indicates the number of jobs that are ahead of this job in the relative
chronological order of expected time to complete (i.e., the current
scheduled order).
|
| NumberUp |
Class NumberUp is an integer valued printing attribute class that specifies
the number of print-stream pages to impose upon a single side of an
instance of a selected medium.
|
| NumberUpSupported |
Class NumberUpSupported is a printing attribute class, a set of integers,
that gives the supported values for a
NumberUp attribute. |
| OrientationRequested |
Class OrientationRequested is a printing attribute class, an enumeration,
that indicates the desired orientation for printed print-stream pages; it
does not describe the orientation of the client-supplied print-stream
pages.
|
| OutputDeviceAssigned |
Class OutputDeviceAssigned is a printing attribute class, a text attribute,
that identifies the output device to which the service has assigned this
job.
|
| PageRanges |
Class PageRanges is a printing attribute class, a set of integers, that
identifies the range(s) of print-stream pages that the Printer object uses
for each copy of each document which are to be printed.
|
| PagesPerMinute |
Class PagesPerMinute is an integer valued printing attribute that indicates
the nominal number of pages per minute to the nearest whole number which may
be generated by this printer (e.g., simplex, black-and-white).
|
| PagesPerMinuteColor |
Class PagesPerMinuteColor is an integer valued printing attribute that
indicates the nominal number of pages per minute to the nearest whole number
which may be generated by this printer when printing color (e.g., simplex,
color).
|
| PDLOverrideSupported |
Class PDLOverrideSupported is a printing attribute class, an enumeration,
that expresses the printer's ability to attempt to override processing
instructions embedded in documents' print data with processing instructions
specified as attributes outside the print data.
|
| PresentationDirection |
Class PresentationDirection is a printing attribute class, an enumeration,
that is used in conjunction with the
NumberUp attribute to
indicate the layout of multiple print-stream pages to impose upon a
single side of an instance of a selected medium. |
| PrinterInfo |
Class PrinterInfo is a printing attribute class, a text attribute, that
provides descriptive information about a printer.
|
| PrinterIsAcceptingJobs |
Class PrinterIsAcceptingJobs is a printing attribute class, an enumeration,
that indicates whether the printer is currently able to accept jobs.
|
| PrinterLocation |
Class PrinterLocation is a printing attribute class, a text attribute, that
identifies the location of the device.
|
| PrinterMakeAndModel |
Class PrinterMakeAndModel is a printing attribute class, a text attribute,
that the make and model of the printer.
|
| PrinterMessageFromOperator |
Class PrinterMessageFromOperator is a printing attribute class, a text
attribute, that provides a message from an operator, system administrator,
or "intelligent" process to indicate to the end user information about or
status of the printer, such as why it is unavailable or when it is
expected to be available.
|
| PrinterMoreInfo |
Class PrinterMoreInfo is a printing attribute class, a URI, that is used to
obtain more information about this specific printer.
|
| PrinterMoreInfoManufacturer |
Class PrinterMoreInfoManufacturer is a printing attribute class, a URI,
that is used to obtain more information about this type of device.
|
| PrinterName |
Class PrinterName is a printing attribute class, a text attribute, that
specifies the name of a printer.
|
| PrinterResolution |
Class PrinterResolution is a printing attribute class that specifies an
exact resolution supported by a printer or to be used for a print job.
|
| PrinterState |
Class PrinterState is a printing attribute class, an enumeration, that
identifies the current state of a printer.
|
| PrinterStateReason |
Class PrinterStateReason is a printing attribute class, an enumeration,
that provides additional information about the printer's current state,
i.e., information that augments the value of the printer's
PrinterState attribute. |
| PrinterStateReasons |
Class PrinterStateReasons is a printing attribute class, a set of
enumeration values, that provides additional information about the
printer's current state, i.e., information that augments the value of the
printer's
PrinterState attribute. |
| PrinterURI |
Class PrinterURI is a printing attribute class, a URI, that specifies the
globally unique name of a printer.
|
| PrintQuality |
Class PrintQuality is a printing attribute class, an enumeration,
that specifies the print quality that the printer uses for the job.
|
| QueuedJobCount |
Class QueuedJobCount is an integer valued printing attribute that indicates
the number of jobs in the printer whose
JobState is either
PENDING, PENDING_HELD, PROCESSING, or PROCESSING_STOPPED. |
| ReferenceUriSchemesSupported |
Class ReferenceUriSchemesSupported is a printing attribute class
an enumeration, that indicates a "URI scheme," such as "http:" or "ftp:",
that a printer can use to retrieve print data stored at a URI location.
|
| RequestingUserName |
Class RequestingUserName is a printing attribute class, a text attribute,
that specifies the name of the end user that submitted the print job.
|
| Severity |
Class Severity is a printing attribute class, an enumeration, that denotes
the severity of a
PrinterStateReason attribute. |
| SheetCollate |
Class SheetCollate is a printing attribute class, an enumeration, that
specifies whether or not the media sheets of each copy of each printed
document in a job are to be in sequence, when multiple copies of the document
are specified by the
Copies attribute. |
| Sides |
Class Sides is a printing attribute class, an enumeration, that specifies
how print-stream pages are to be imposed upon the sides of an instance of a
selected medium, i.e., an impression.
|
An attribute represents a printing feature that a print service can provide. For each attribute, a print service either does or does not support the attribute. For each possible value of a supported attribute, a print service either does or does not support the value.
The API requires every print service to support certain attributes; other attributes are optional and the service can choose whether or not to support them. Each attribute has a set of values that it accepts. The API requires every print service to support certain values for certain attributes; other attribute values are optional and the service can choose whether or not to support them. These support requirements are recorded in the documentation for each attribute class.
Package javax.print.attribute.standard contains standard printing attributes and standard printing attribute values that are widely used in the printing domain. A print service vendor can provide new vendor-specific printing attributes in addition to the standard ones. A vendor can also provide vendor-specific extensions (subclasses) of the standard printing attributes -- for example, to provide additional vendor-specific values for an existing standard attribute. Of course, if a vendor wants clients to be able to use any added or extended attributes, the vendor must publish the new attribute classes.
Many of the standard attribute classes extend one of the abstract syntax classes of the javax.print.attribute package. These abstract syntax classes each represent a different type. The EnumSyntax class, for example, represents a type-safe enumeration. The abstract syntax class provides a wrapper for the attribute value.
If an attribute class extends EnumSyntax
, and the value of the
attribute is an IPP-compatible value, the attribute's toString
method returns the IPP string representation of the attribute value, such as
"processing-stopped" for the
JobState attribute. However, because the
EnumSyntax
class is extensible, vendors can define their own
attribute values. If an attribute uses the EnumSyntax
class
and is set to one of these vendor-defined values then the toString
method will not return the IPP string representation of the value.
A printing client application will typically not need to use all the printing attribute classes in package javax.print.attribute.standard, just the ones that pertain to the application.
The attribute classes in package javax.print.attribute.standard are based on the Internet Printing Protocol (IPP) attributes as defined in the Internet RFC document, RFC 2911 Internet Printing Protocol/1.1: Model and Semantics dated September 2000. See RFC 2911 for more information. The descriptive text for each attribute class was taken largely from the above documents. The above authors' contribution to the API is gratefully acknowledged.
Some attributes are doc attributes but not print request attributes and may only be specified at the doc level. Some attributes are print request attributes but not doc attributes and may only be specified at the Print Request level. Some attributes are both doc attributes and print request attributes and may be specified either at the doc level or at the Print Request level.
When specified at the doc level, an attribute applies just to that one doc. When specified at the Print Request level, an attribute applies to the whole job, including all the docs in the job. However, an attribute specified at the doc level overrides an attribute in the same category specified at the Print Request level.
Some attributes are both print request attributes and print job attributes; a client may include such attributes in a Print Request to specify characteristics for the ensuing Print Job, and those attributes then also appear in the Print Job's attribute set. Some attributes are print job attributes but not print request attributes; the print service itself adds these attributes to the Print Job's attribute set.
Please note: In the javax.print APIs, a null reference parameter to methods is incorrect unless explicitly documented on the method as having a meaningful interpretation. Usage to the contrary is incorrect coding and may result in a run time exception either immediately or at some later time. IllegalArgumentException and NullPointerException are examples of typical and acceptable run time exceptions for such cases.
Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2015, Oracle and/or its affiliates. All rights reserved.


| Trioctyl Phosphate General Information
-
| Synonyms: |
TOP, TOF; Trioctyl phosphate; Tri-(2-ethylhexyl) phosphate; 2-ethylhexyl di2-ethylhexyl phosphate |
| Molecular Formula: |
C24H51O4P |
| CAS Registry No.: |
78-42-2 |
| Chemical Category: |
Phosphates |
Usage and Performance Characteristics
-
| Volatility, wt. %: |
11 (24 h at 87°C, 70 phr) |
Physical Properties
-
| Specific Gravity: |
0.924 (20°C); 0.9229 (25°C) |
| Aggregate State at 25°C: |
Liquid |
| Boiling Point, °C: |
210 (decomposes) |
| Clash-Berg Temperature, °C: |
-70 (67 phr) |
| Dielectric Constant at 1 MHz: |
4.82 |
| Dynamic Viscosity, cP: |
15 (20°C) |
| Heat of Combustion at 25°C, kJ/kg: |
36,565 |
| Vapor Density, relative to H2: |
14.95 |
| Vapor Pressure, kPa: |
0.28 (20°C); 0.2533 (200°C) |
Chemical Properties
-
| Hansen Solubility Parameter dD at 25°C, MPa1/2: |
16.2 |
| Hansen Solubility Parameter dH at 25°C, MPa1/2: |
3.7 |
| Hansen Solubility Parameter dP at 25°C, MPa1/2: |
6.2 |
| Hildebrand Solubility Parameter, MPa1/2: |
16.83 |
| Solubility in Water at 25°C, g/L: |
<0.001 |
Optical Properties
-
| Color: |
Colorless to pale yellow |
| Refractive Index: |
1.441 (n25D); 1.4437 (n20D) |
Hazard-Related Data
-
| OSHA Hazard Class: |
Considered a hazardous substance |
| UN Risk Phrases: |
36/38,58 |
| UN Safety Phrases: |
24,35,39,401 |
| Autoignition Temperature, °C: |
370 |
| Eye Irritation (human): |
May cause irritation |
| Flash Point Temperature, °C: |
207 |
| HMIS Personal protection: |
Safety goggles, chemically resistant gloves, skin protection |
| Skin Irritation: |
May cause irritation |
| Carcinogenicity: |
Carcinogenic by RTECS criteria; NTP - some evidence |
Environmental Parameters
-
| Octanol-Water Partition Coeff., log Kow: |
9.49 |
| Theoretical Oxygen Demand, ThOD, g/g: |
2.65 |
Animal Toxicity
-
| Mouse Oral, LD50, mg/kg: |
12,800 |
| Rabbit Dermal, LD50, mg/kg: |
20,000 |
| Rat Oral, LD50, mg/kg: |
37,000 |
Plasticizers Database (2nd Electronic Edition) Copyright © 2004 by ChemTec Publishing |


|
Physics
|
A class that connects two rigidbodies by a series of springs More...
#include <Rope.h>
Public Member Functions | |
| Rope (PhysicsScene *scene, int length) | |
| Places the rope in a scene with a set length More... | |
| void | Build (RigidBody *obj1, RigidBody *obj2) |
| Connects two objects with the rope More... | |
| float | getSpacing () |
| float | getLength () |
Protected Attributes | |
| PhysicsScene * | m_scene |
| The scene that the rope is in More... | |
| Sphere ** | m_spheres = nullptr |
| An array that holds a pointer to every link in the rope More... | |
| Sphere * | ropeStart = nullptr |
| The link at the start of the rope More... | |
| Sphere * | ropeEnd = nullptr |
| The link at the end of the rope More... | |
| vec4 | m_colour |
| The colour of the rope More... | |
| double | m_spacing = 0.75f |
| The distance between each link More... | |
| float | m_springForce = 30.0f |
| The restoring force of each spring in the rope More... | |
| float | m_damping = 10.0f |
| The drag slowing down the restoring force of the springs More... | |
| int | m_length = 0 |
| The amount of links in a rope More... | |
| float | m_linkRadius = 0.005f |
| The size of the links More... | |
A class that connects two rigidbodies by a series of springs
| Rope::Rope | ( | PhysicsScene * | scene, |
| int | length | ||
| ) |
Places the rope in a scene with a set length
| scene | |
| length | The number of links in the rope |
Connects two objects with the rope
| obj1 | The object at the start of the rope |
| obj2 | The object at the end of the rope |
|
protected |
The colour of the rope
|
protected |
The drag slowing down the restoring force of the springs
|
protected |
The amount of links in a rope
|
protected |
The size of the links
|
protected |
The scene that the rope is in
|
protected |
The distance between each link
|
protected |
An array that holds a pointer to every link in the rope
|
protected |
The restoring force of each spring in the rope
|
protected |
The link at the end of the rope
|
protected |
The link at the start of the rope


References
1
Management of highland wetlands in central Kenya: The importance of community education, awareness and eco-tourism in biodiversity conservation
Download


Understanding Failed Request Trace(FREB)
learn to analyze
Rohith Rajan @debuggingio
debugging.io
Viewing the trace file
How the viewer
A look at the xslt file
Understanding the summary view
Status Code
Time Taken
Module which error occured
Compact view
Inspecting the HTTP Headers
Modules and Handlers
Module Set Response
Time taken by each Module
Press
Down
for more details
Inspecting the HTTP Headers
Modules and Handlers
Module Set Response
Time taken by each Module
Request Details
Request Trace-Complete
Performance View
Asp.net trace
Complete request details
Performance View
Asp.net page trace view
Refresh
How to find the time-taken and retrun status code
how to find which module processed the requet
how to find which module took more time to process
Rohith Rajan
Debugging.io


This page was inspired by Wes Bos's
collection of "Uses" pages
Gear
- 💻 13" MacBook Air 2017
- 🖥 Dell P Series 24-inch Monitor
- 🎧 Boat Rockerz 400 Headphone
- 📱Poco X2
- 💽 Toshiba 1TB External Hard disk
Softwares
Development
- Code Editor - VS Code with One Dark Pro Monokai theme and Prettier, ESLint, Gitlens,
Turbo Console Log, ReactJS Code Snippets, Comment Anchors,
Polacode & Settings Sync
- Terminal - iTerm2 with oh-my-zsh, homebrew & lot of custom aliases
- Illustration and Design - Figma, Adobe XD & photopea.com (Browser based free Photoshop
alternative)
- Postman
- Sourcetree
- CodeSandbox
- Draw.io
- Uptime Robot
Communication
- Slack - Team communication
- Zoom - conferencing
- Spark - Email Client
Misc
Productivity/Task Management
Mac Apps
- Bandwidth+ - Network speed in menubar
- Chrome with Momentum Dash, React Developer Tools, Wappalyzer, Adblock Plus, LastPass
- Cheatsheet - Shows list of available keyboard shortcuts
- Coffee Buzz - Keeps screen alive
- CopyClip - Clipboard Manager
- Dato - Better menubar clock
- Grammarly
- Keka - File Archiver
- Mounty - To mount NTFS Volumes
- RecordIt - Record and share short videos as mp4 and GIF
- Spectacle - window management
- VLC - Media Player
Mobile Apps
- Feedly - RSS Feed
- Pocket Casts - Podcast App
- Photoshop Express
- Snapseed
- TV Time - To track TV Shows and Movies
- Cred - Credit Card Management App
- Walnut - Expense Manager
- Splitwise - To manage shared expenses
Entertainment
- Netflix
- Amazon Prime Video
- YouTube Premium


Johan is playing a special version of the card game Yu-Gi-Oh! with Simon. In the game, each card has an attack value ATK and a defense value DEF.
A card can be in one of two modes, attack mode or defense mode. When a card A in attack mode attacks another card B in defense mode, card B is destroyed if ATK(A) is larger than DEF(B). When a card A in attack mode attacks another card B in attack mode, card B is destroyed if ATK(A) is larger than ATK(B), and the difference is dealt as damage to the defending players life points.
A card is only allowed to attack one other card per turn.
All of Johan's cards (there are 5 of them) are currently in attack mode, and all of Simon's cards (there are 5 of them) are currently in defense mode. Now, the following procedure will play out:
Johan obviously want to lose as little life points as possible the next turn. If he attacks optimally this turn, what is the maximum damage Simon can deal to him?


Custom Input Example
The Custom Input example shows how to customize the 3D graph controls in a widget application using a custom graph input handler to capture and process mouse events. The code in this example shows also how the camera is controlled by using QPropertyAnimation to animate the camera and item selection is done on mouseover rather than clicking any mouse buttons. Also the code shows how to implement similar zoom with mouse wheel functionality as the default input handler implements.
Running the Example
To run the example from Qt Creator, open the Welcome mode and select the example from Examples. For more information, visit Building and Running an Example.
Replacing Default Input Handling
The default input handling mechanism is replaced by setting the active input handler of Q3DScatter to CustomInputHandler
that implements the custom behavior.
m_graph->setActiveInputHandler(m_inputHandler);
Implementing Custom Selection Handling
The on mouseover selection handling is implemented in the CustomInputHandler
that captures the mouse events. It then stores the last known coordinates to the QAbstract3DInputHandler::inputPosition property.
void CustomInputHandler::mouseMoveEvent(QMouseEvent *event, const QPoint &mousePos) { Q_UNUSED(event) setInputPosition(mousePos); }
As the selection is one shot, and is cleared each time a 3D frame is rendered, a timer is setup to retrigger selection so that the selection moves to the item currently under the mouse cursor as the camera animates around the graph even when the mouse cursor is not moving.
m_selectionTimer = new QTimer(this); m_selectionTimer->setInterval(10); m_selectionTimer->setSingleShot(false); QObject::connect(m_selectionTimer, &QTimer::timeout, this, &ScatterDataModifier::triggerSelection); m_selectionTimer->start();
Implementing Custom Zoom Handling
The camera has a zoom factor that represents amount of zoom in percentages. In this example the zoom range is limited between 10% and 500%. This range is then divided to four subranges where angleDelta
is scaled to different amount of zoom change based on the current subrange.
void CustomInputHandler::wheelEvent(QWheelEvent *event) { // Adjust zoom level based on what zoom range we're in. int zoomLevel = scene()->activeCamera()->zoomLevel(); if (zoomLevel > 100) zoomLevel += event->angleDelta().y() / 12; else if (zoomLevel > 50) zoomLevel += event->angleDelta().y() / 60; else zoomLevel += event->angleDelta().y() / 120; if (zoomLevel > 500) zoomLevel = 500; else if (zoomLevel < 10) zoomLevel = 10; scene()->activeCamera()->setZoomLevel(zoomLevel); }
Implementing Custom Camera Handling
The camera is animated to constantly rotate around the graph with two animations. The rotation around the graph is done with a simple QPropertyAnimation that just increments during 20 seconds from 0 degrees to 360 degrees and sets the Q3DCamera::xRotation property.
m_animationCameraX = new QPropertyAnimation(m_graph->scene()->activeCamera(), "xRotation"); m_animationCameraX->setDuration(20000); m_animationCameraX->setStartValue(QVariant::fromValue(0.0f)); m_animationCameraX->setEndValue(QVariant::fromValue(360.0f)); m_animationCameraX->setLoopCount(-1);
The camera movement up and down is implemented with a QSequentialAnimationGroup that varies the Q3DCamera::yRotation property of the camera from 5 degrees to 45 degrees and back with in and out easing.
QPropertyAnimation *upAnimation = new QPropertyAnimation(m_graph->scene()->activeCamera(), "yRotation"); upAnimation->setDuration(9000); upAnimation->setStartValue(QVariant::fromValue(5.0f)); upAnimation->setEndValue(QVariant::fromValue(45.0f)); QPropertyAnimation *downAnimation = new QPropertyAnimation(m_graph->scene()->activeCamera(), "yRotation"); downAnimation->setDuration(9000); downAnimation->setStartValue(QVariant::fromValue(45.0f)); downAnimation->setEndValue(QVariant::fromValue(5.0f)); m_animationCameraY = new QSequentialAnimationGroup(); m_animationCameraY->setLoopCount(-1); m_animationCameraY->addAnimation(upAnimation); m_animationCameraY->addAnimation(downAnimation);
Files:


Installed as a browser plugin, you'll need this to make payments and sign messages.
Installed as a mobile app, you'll need this to use your reservation.
Metamask is an ethereum wallet installed as a browser plugin (chrome, firefox, brave). You'll need this to make payments and sign messages.
NestEgg's sharing economy platform runs on ethereum, meaning you first need to convert your euros into tokens so they can interact with smart contracts.
NestEgg's sharing economy platform runs on ethereum, meaning you first need to convert your euros into tokens so they can interact with smart contracts.


Some tools for running scripts¶
Run local batch¶
- Run all scenarios given home id will run all scenarios of homes given home id.
- Run all scenarios give filder name will run all scenarios of all homes inside one given folder.
Run on Compute Canada jobs¶
- Run scripts on Compute Canada solver when running simnulations on compute canada server like Graham, hearder file for assign compute resources for one job need to be added.
For more details about schedule jobs on compute canada, please refer to [running jobs on Compute Canada <https://docs.computecanada.ca/wiki/Running_jobs>`_
- List of all home id generate list of all home id which will be used to create seprate jobs for different homes on server.
- Create shell scripts for one given home will create shell scripts to run scenarios for all given home on server.
- Run indiviual jobs for all homes will create one single jobs for all homes so that mutiple jobs can be run simultaneously on Compute Canada server.


You can change how Holodeck Stress and Code Coverage tests your application by modifying the TestGeneration.xml file found in the Test Generation folder in the Holodeck install directory (default: C:\Program Files\Security Innovation\Holodeck Enterprise Edition\Test Generation).
This XML file holds all the settings for how Holodeck tests your application. Before making any changes to this file it is recommended that you make a backup copy.
TestInterval – Time between setting individual tests, in milliseconds.
TestDuration – Time to enable each test, in milliseconds.
AllowNetworkLimit – Boolean, allow or disallow network limits.
AllowDiskLimit - Boolean, allow or disallow disk limits.
AllowMemoryLimit - Boolean, allow or disallow memory faults.
AllowNetworkFaults - Boolean, allow or disallow network faults.
AllowRegistryFaults - Boolean, allow or disallow registry faults.
AllowProcessFaults - Boolean, allow or disallow process faults.
AllowCustomFaults - Boolean, allow or disallow custom faults.
AllowDiskFaults - Boolean, allow or disallow disk faults.
AllowMemoryFaults - Boolean, allow or disallow memory faults.
AllowNetworkCorruption - Boolean, allow or disallow network corruption.
NumOverlappingTests – The number of tests allowed to execute at the same time.
NetworkLowRange – Lowest the network limit can be, in bytes per second.
NetworkHighRange - Highest the network limit can be, in bytes per second.
DiskLimitSet – set value 0 for at current usage, set value 1 for above current usage
DiskLimitMax – limits will be set from current usage to current usage plus this number
MemoryLimitSet– set value 0 for at current usage, set value 1 for above current usage
MemoryLimitMax– limits will be set from current usage to current usage plus this number.


My Dearest One ,
It is my pleasure to contact you for a business venture which I am,intend to
establish in your country. Though I have not met with you before but I
believe, one has to risk confiding in someone to succeed sometimes in life.
There is this amount of FIFTEEN Million US Dollars ($<IP_ADDRESS>) which
my late grand father deposited with a security company in Abidjan Capital city of
Cote d'Ivoire which he wanted to used for his political ambition in our
Country before he was assassinated. Now I have decided to invest this
money in your country or anywhere safe enough outside Africa for
security and political reasons.
I want you to help me claim and receive the consignment which will be sent
to you through diplomatic means to your address to avoid any traces of the
funds and to enable you plan for the investment in your Country. I will like
to invest part of the money into these three investments in your Country
but, if there is any other business that is better than my suggestion, I will
be very glad to follow your advice.
1). Real estate
2). The transport industry
3). Five star hotel
If you can be of an assistance to me i will be pleased to offer to you 20%
Of the total fund while the balance will be invested by you. I await your
soonest response. Kindly get back to me in my prive mail box<EMAIL_ADDRESS>Respectfully yours,
Kouajo Aka


{{extend 'layout.html'}} Works with Chrome, problems have been reported with FF and IE. :-( {{cs=not 'function()' in source}}


Princess Shyngle’s ex-boyfriend threatens to commit suicide if she does not come back to him
by RASHADFrederick Badji, the immediate ex-boyfriend of Ghana-based Gambian Slay Queen, Princess Shyngle has taken to social media to weep over his breakup with the pretty lady.
According to Frederick Badji, the Senegalese young man, he will commit suicide if Princess Shyngle does not come back to him as soon as possible.
SEE ALSO: Madam Tapoli, Princess Shyngle now a lesbian- Explains what led to the decision (Screenshot)
Frederic Badji claims he never cheated on Princess Shyngle as she is claiming. He was faithful to her from day one and still faithful.

WATCH THE VIDEO BELOW
Princess Shyngle a few days ago took to her Instagram page to announce she has broken up with Frederic Badji just a couple of months after he proposed to her and she said yes.
She claimed Frederic Badji was cheating on her whiles they were together and even after he proposed. She claims she couldn’t take that disrespect anymore.


Components
Skin ships with a wide variety of components that you can use to build your pages. Use the topics navigation to read more about each component.
A good place to start is to get familiar with Skin's grid layout.
Default theme colors
Below is a list of the default colors used. These can be overridden by adding your own stylesheet with it's own rules.
| Color | HEX | Description |
|---|---|---|
| color-dark | #1a1a1a | Bold text |
| color-main | #404040 | Normal text |
| color-light | #808080 | Light text, image captions |
| color-xlight | #b3b3b3 | Extra light text, borders, dividers |
| border-main | #cecece | Borders, dividers |
| bg-main | #f2f2f2 | Body background, image frame background |
| a | #297ebd | Hyperlinks |
| a:hover | #58a3db | +3 monochromatic colors from a |
| a:active, a.active | #97c6e9 | +6 monochromatic colors from a |


Wiley's Resort
Photo Gallery
Find more information:
Home Page
Accommodations
Activities
Travel Arrangements
Contacts


CELTIC PRIDE A film review by Michael John Legeros Copyright 1996 Michael John Legeros
(Hollywood) Directed by Tom DeCerchio Written by Judd Apatow Cast Damon Wayans, Daniel Stern, Dan Aykroyd, Gail O'Grady, Christopher McDonald MPAA Rating "PG-13" Running Time 93 minutes Reviewed at General Cinemas at Pleasant Valley, Raleigh, NC (19APR96)
Dan Aykroyd and Daniel Stern are well-cast as a pair of rabid Celtics fans who kidnap the opposing team's star player (Damon Wayans) before the last game of a tied championship series.  The movie, unfortunately, doesn't give the pair nearly enough to do.  (To make matters worse, the distressingly underwritten film is distressingly overscored by composer Basil Poledouris.) Sports fans should find this funny, but lay people may want to lay off such a lame lay up. Now, if only someone would make a movie about rabid *ACC* fans...
Grade: C
--
Mike Legeros - Raleigh, NC
<EMAIL_ADDRESS>(h) -<EMAIL_ADDRESS>(w)
Visit me in MOVIE HELL
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


Home
About
Movie Night
Welcome to "Movie Night" where planning is not so stressful
Sign In
Email address
Password
Sign In
Forgot Your Password?


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use net.ontopia.topicmaps.entry | |
|---|---|
| net.ontopia.persistence.proxy | An object-relational mapping framework. |
| net.ontopia.topicmaps.core | Provides interfaces for topic map objects; the topic map API for all Ontopia topic map implementations. |
| net.ontopia.topicmaps.core.events | Provides an event interface to Ontopia where clients can receive notification about updates to topic maps. |
| net.ontopia.topicmaps.db2tm | The implementation of and public API to the DB2TM module for converting relational data (in CSV files or RDBMSs) to Topic Maps. |
| net.ontopia.topicmaps.entry | High level interfaces for locating and maintaining references to topic maps. |
| net.ontopia.topicmaps.impl.rdbms | Relational database implementation of the core topic map interfaces. |
| net.ontopia.topicmaps.impl.utils | INTERNAL: Classes that are used by many implementations. |
| net.ontopia.topicmaps.nav.utils.comparators | Provides Comparators which are used by the Navigator. |
| net.ontopia.topicmaps.nav2.core | Provides interfaces for the Navigator Tag Libraries and Framework. |
| net.ontopia.topicmaps.nav2.impl.basic | The basic implementation of the Navigator core interfaces. |
| net.ontopia.topicmaps.nav2.impl.framework | The implementation of the Navigator Framework related interfaces. |
| net.ontopia.topicmaps.nav2.taglibs.logic | Logic tags, which define the execution context, modify the context, and control the flow of execution. |
| net.ontopia.topicmaps.nav2.utils | Provides utility classes for the Navigator Tag Libraries and Framework. |
| net.ontopia.topicmaps.utils | This package provides topic map utility classes, which are a toolkit for working with the topic map model provided by the core interfaces. |
| net.ontopia.topicmaps.utils.ctm | Provides support for the ISO-standardized textual Compact Topic Maps syntax (or CTM) format for topic maps. |
| net.ontopia.topicmaps.utils.ltm | This package provides support for the textual Linear Topic Map Notation (or LTM) format for topic maps. |
| net.ontopia.topicmaps.utils.rdf | This package provides support for RDF (Resource Description Framework), a topic map-like data model for metadata defined by the W3C. |
| net.ontopia.topicmaps.utils.tmprefs | |
| net.ontopia.topicmaps.utils.tmrap | |
| net.ontopia.topicmaps.viz | |
| net.ontopia.topicmaps.webed.impl.utils | |
| net.ontopia.topicmaps.xml | Classes for importing and exporting topic maps in the XML interchange format. |
| ontopoly.conversion | |
| ontopoly.sysmodel |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.persistence.proxy | |
|---|---|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.core | |
|---|---|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.core.events | |
|---|---|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.db2tm | |
|---|---|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.entry | |
|---|---|
| AbstractPathTopicMapSource
INTERNAL: Abstract class implementing TopicMapSourceIF; locates topic map file references from a given directory on the local file system. |
|
| AbstractTopicMapReference
INTERNAL: An abstract topic map reference class that contains methods that handles the id and title properties. |
|
| AbstractURLTopicMapReference
INTERNAL: An abstract topic map reference class that retrieves topic maps referenced through URLs. |
|
| ResourceTopicMapSource.REF_TYPE
|
|
| SharedStoreRegistry
INTERNAL: Registry of topicmap repositories that are to be shared between web applications. |
|
| StoreFactoryReference
INTERNAL: A topic map reference that uses a topic map store factory to create stores. |
|
| StoreRegistry
Deprecated. |
|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
|
| TopicMapRepositoryIF
PUBLIC: Class used to provide easy access to references from one or more topic map sources. |
|
| TopicMapSourceIF
PUBLIC: Topic map sources collect references to topic maps. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.impl.rdbms | |
|---|---|
| AbstractTopicMapReference
INTERNAL: An abstract topic map reference class that contains methods that handles the id and title properties. |
|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
|
| TopicMapSourceIF
PUBLIC: Topic map sources collect references to topic maps. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.impl.utils | |
|---|---|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.nav.utils.comparators | |
|---|---|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.nav2.core | |
|---|---|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
|
| TopicMapRepositoryIF
PUBLIC: Class used to provide easy access to references from one or more topic map sources. |
|
| UserStoreRegistry
Deprecated. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.nav2.impl.basic | |
|---|---|
| SharedStoreRegistry
INTERNAL: Registry of topicmap repositories that are to be shared between web applications. |
|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
|
| TopicMapRepositoryIF
PUBLIC: Class used to provide easy access to references from one or more topic map sources. |
|
| UserStoreRegistry
Deprecated. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.nav2.impl.framework | |
|---|---|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.nav2.taglibs.logic | |
|---|---|
| TopicMapRepositoryIF
PUBLIC: Class used to provide easy access to references from one or more topic map sources. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.nav2.utils | |
|---|---|
| TopicMapRepositoryIF
PUBLIC: Class used to provide easy access to references from one or more topic map sources. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.utils | |
|---|---|
| AbstractTopicMapReference
INTERNAL: An abstract topic map reference class that contains methods that handles the id and title properties. |
|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
|
| TopicMapRepositoryIF
PUBLIC: Class used to provide easy access to references from one or more topic map sources. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.utils.ctm | |
|---|---|
| AbstractOntopolyTopicMapSource
INTERNAL: Common abstract superclass for sources that support what Ontopoly needs, which is full-text indexing and creation of new topic maps. |
|
| AbstractOntopolyURLReference
INTERNAL: Common abstract superclass for references from sources that support what Ontopoly needs. |
|
| AbstractPathTopicMapSource
INTERNAL: Abstract class implementing TopicMapSourceIF; locates topic map file references from a given directory on the local file system. |
|
| AbstractTopicMapReference
INTERNAL: An abstract topic map reference class that contains methods that handles the id and title properties. |
|
| AbstractURLTopicMapReference
INTERNAL: An abstract topic map reference class that retrieves topic maps referenced through URLs. |
|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
|
| TopicMapSourceIF
PUBLIC: Topic map sources collect references to topic maps. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.utils.ltm | |
|---|---|
| AbstractOntopolyTopicMapSource
INTERNAL: Common abstract superclass for sources that support what Ontopoly needs, which is full-text indexing and creation of new topic maps. |
|
| AbstractOntopolyURLReference
INTERNAL: Common abstract superclass for references from sources that support what Ontopoly needs. |
|
| AbstractPathTopicMapSource
INTERNAL: Abstract class implementing TopicMapSourceIF; locates topic map file references from a given directory on the local file system. |
|
| AbstractTopicMapReference
INTERNAL: An abstract topic map reference class that contains methods that handles the id and title properties. |
|
| AbstractURLTopicMapReference
INTERNAL: An abstract topic map reference class that retrieves topic maps referenced through URLs. |
|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
|
| TopicMapSourceIF
PUBLIC: Topic map sources collect references to topic maps. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.utils.rdf | |
|---|---|
| AbstractPathTopicMapSource
INTERNAL: Abstract class implementing TopicMapSourceIF; locates topic map file references from a given directory on the local file system. |
|
| AbstractTopicMapReference
INTERNAL: An abstract topic map reference class that contains methods that handles the id and title properties. |
|
| AbstractURLTopicMapReference
INTERNAL: An abstract topic map reference class that retrieves topic maps referenced through URLs. |
|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
|
| TopicMapSourceIF
PUBLIC: Topic map sources collect references to topic maps. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.utils.tmprefs | |
|---|---|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.utils.tmrap | |
|---|---|
| TopicMapRepositoryIF
PUBLIC: Class used to provide easy access to references from one or more topic map sources. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.viz | |
|---|---|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.webed.impl.utils | |
|---|---|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
| Classes in net.ontopia.topicmaps.entry used by net.ontopia.topicmaps.xml | |
|---|---|
| AbstractOntopolyTopicMapSource
INTERNAL: Common abstract superclass for sources that support what Ontopoly needs, which is full-text indexing and creation of new topic maps. |
|
| AbstractOntopolyURLReference
INTERNAL: Common abstract superclass for references from sources that support what Ontopoly needs. |
|
| AbstractPathTopicMapSource
INTERNAL: Abstract class implementing TopicMapSourceIF; locates topic map file references from a given directory on the local file system. |
|
| AbstractTopicMapReference
INTERNAL: An abstract topic map reference class that contains methods that handles the id and title properties. |
|
| AbstractURLTopicMapReference
INTERNAL: An abstract topic map reference class that retrieves topic maps referenced through URLs. |
|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
|
| TopicMapSourceIF
PUBLIC: Topic map sources collect references to topic maps. |
| Classes in net.ontopia.topicmaps.entry used by ontopoly.conversion | |
|---|---|
| TopicMapRepositoryIF
PUBLIC: Class used to provide easy access to references from one or more topic map sources. |
|
| TopicMapSourceIF
PUBLIC: Topic map sources collect references to topic maps. |
| Classes in net.ontopia.topicmaps.entry used by ontopoly.sysmodel | |
|---|---|
| TopicMapReferenceIF
PUBLIC: Represents a reference to a topic map. |
|
| TopicMapRepositoryIF
PUBLIC: Class used to provide easy access to references from one or more topic map sources. |
|
| TopicMapSourceIF
PUBLIC: Topic map sources collect references to topic maps. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


| command | Add | one of either 'Add' or 'Update' |
| user | bobsmith | Provided by me |
| key | p455w0rd | Provided by me |
| msgid |<PHONE_NUMBER>938 | Unique identifier for message. Provided by Broadbean |
| job.id |<EMAIL_ADDRESS>| Aplitrak support is mandatory for job board integrations. |
| job.apply | http://url.com/ad.asp?adid=12345123 | Apply-on-line support is advised for job board integrations. |
| job.reference | abc123 | Freetext, the reference number assigned to the advert by the recruiter |
| job.date.create | date object | Date and time the job was created |
| job.date.expire | date object | Expiry date of job |
| job.contact.name | Bob Smith | Free Text, recruiter name as stored on AdCourier |
| job.contact.email |<EMAIL_ADDRESS>| Freetext, recruiter email address as stored on AdCourier |
| job.contact.phone | 020 7987 6900 | Freetext, recruiter phone number as stored on AdCourier |
| job.info.title | Test Engineer | Freetext, the job title of the advert |
| job.info.type | Contract | one of: Contract, Permanent, Temporary |
| job.info.duration | 6 months | Freetext, duration of the position (Contract roles) |
| job.info.start | ASAP | Freetext, start date of the position |
| job.info.skills | vb, c++, perl, java | Freetext, specific skills/keywords relevant to the position |
| job.info.tags | developer, all-rounder, lead-role | Freetext, comma delimited list of tag names. |
| job.info.extended | | Freetext, 6000 char limit, detailed job description |
| job.info.location | London | Freetext, from list provided |
| job.info.industry | Marketing | Freetext, from list provided |
| job.salary.currency | gbp | one of: gbp, usd, eur |
| job.salary.from | 25000 | A number (float) for the lower salary |
| job.salary.to | 30000 | A number (float) for the upper salary |
| job.salary.per | annum | Salary term, one of: annum, month, week, day, hour |
| job.salary.benefits | + Bonus and Pension | Freetext, additional salary information |
| job.salary.extended | £25000 - £30000 per annum + Bonus and Pension | Freetext salary information for display purposes (build from other salary objects) |
| job.summary.point | text version of a summary point | Text entry sent as object array. Maximum of 5 points to a summary array. |


Publications
An updated list of my papers can be found below. Links of my academic network profiles: ResearchGate, Academia.
Conference Papers
- Kyriakos D. Tsoukalas, George P. Kontoudis, and Kyriakos G. Vamvoudakis, “Active-Bayesian Learning for Cooperation Connectivity in Dynamic Cyber-Physical-Human Systems,” IEEE Symposium on Adaptive Dynamic Programming and Reinforcement Learning (ADPRL), Hawaii, USA, 2017. (invited paper)
- George P. Kontoudis, Minas Liarokapis, Agisilaos G. Zisimatos, Christoforos I. Mavrogiannis and Kostas J. Kyriakopoulos, “Open-Source, Anthropomorphic, Underactuated Robot Hands with a Selectively Lockable Differential Mechanism: Towards Affordable Prostheses”, IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), Hamburg, Germany, 2015.
[BibTeX] [PDF] [Video]
Technical Reports
- George P. Kontoudis, Minas Liarokapis, Agisilaos G. Zisimatos, Christoforos I. Mavrogiannis and Kostas J. Kyriakopoulos, “How to Create Affordable, Anthropomorphic, Light-Weight Prosthetic Hands,” Control Systems Lab, School of Mechanical Engineering, National Technical University of Athens, Technical Report, Athens, Greece, October 2015.
[BibTeX] [PDF] - Agisilaos G. Zisimatos, Minas Liarokapis, Christoforos I. Mavrogiannis, George P. Kontoudis and Kostas J. Kyriakopoulos, “How to Create Affordable, Modular, Light-Weight, Underactuated, Compliant Robot Hands,” Control Systems Lab, School of Mechanical Engineering, National Technical University of Athens, Technical Report, Athens, Greece, January 2015.
[BibTeX] [PDF] [Video]
Theses
- George P. Kontoudis, “Design and Development of an Underactuated, Anthropomorphic Robot Hand,” Diploma Thesis, National Technical University of Athens (NTUA), Athens, Greece, March 2016 (In Greek).
[BibTeX] [PDF] - George P. Kontoudis, “Analysis of Compression and Air-Conditioning System at Short Take Off and Landing (STOL) Aircrafts,” Bachelor Thesis, Piraeus University of Applied Sciences (PUAS), Piraeus, Greece, October 2010.


{% extends "base.html" %} {% load static %} {% load i18n %} {% load crispy_forms_tags %} {% block title %} {% trans "Your shopping cart" %} {% endblock %} {% block content %}
{% trans "If you have a coupon code, please enter it in the box below" %}
Shipping and additional costs are calculated based on values you have entered.