Input events, what they mean, and how they are generated are discussed fully in the Input chapter. The visible world has some default behavior for handling input messages such as MSG_META_START_SELECT
,
MSG_META_END_SELECT
, and
MSG_META_PTR
. For the most part, however, visible objects that want to respond to input must subclass and handle the input messages that interest them.
Composite objects will automatically pass mouse messages on to the proper child directly under the mouse pointer. Non-composite objects (direct subclasses of
VisClass
) have no special default behavior for input handling.
Note that
VisClass
does not intelligently handle layering of objects. That is, if one object is visibly on top of another object, it will not necessarily receive the input events--the events may be passed to the partially hidden object. This is due to the order in which drawing and mouse events are handled by a visible object's children.
Take the example of a visible composite with two children.  The composite's declaration shows
... VCI_comp = LargeChild, SmallChild;
...
Because drawing occurs in the order the children are listed, the small child will be drawn over the large child, as shown in the figure below. If each object can intercept and handle mouse events (e.g.,
MSG_META_START_SELECT
), clicks will never reach the small object without special behavior added to the composite. This is because input events are handled in the same order as drawing; the input event will be given to the first child whose bounds include the event's coordinates.
So, a click event on (10, 10), which is in the middle of the small square, would first be passed to the LargeChild object. The large child would see that the click was within its bounds, and it would take the event. The event would never be handled by the small object.
Therefore, if you need to have overlapping objects which handle user input, you will have to add special features for bounds detection. In the example of the two squares, if neither were to move, the composite could simply pass the event to the small child first and then to the large child, assuming the small child is always on top. If the objects could be moved forward and back so they hide each other, the composite (or the objects themselves) will need some other, more complex, detection behavior.
MSG_META_PTR, MSG_META_START_SELECT, MSG_META_END_SELECT, MSG_META_DRAG_SELECT, MSG_META_DRAG, MSG_META_START_MOVE_COPY, MSG_META_DRAG_MOVE_COPY, MSG_META_START_OTHER, MSG_META_END_OTHER, MSG_META_DRAG_OTHER
Composite objects will automatically pass mouse messages on to the first child directly under the mouse pointer. Non-composite objects (direct subclasses of
VisClass
) have no special default behavior for input handling.
Typically, a visible object that needs to handle mouse input will subclass
MSG_META_START_SELECT
(or one of the other press events such as
MSG_META_START_MOVE_COPY
). This message is sent when the user presses on the "select" mouse button while the pointer is over the object. In this method, the object should grab the mouse (as shown below). When it has the mouse grab, it will receive
MSG_META_PTR
each time the mouse is moved; the object should subclass this message to provide the desired reaction to mouse moves. Finally, when the user releases the select button, the object will receive a
MSG_META_END_SELECT
. At this point, it should release the mouse grab.
Typically, mouse events will arrive with coordinates specified in 16 bits. This is the default graphics space, and it represents a coordinate system more than 25 yards on a side. Nearly all applications will find this graphic system big enough for their uses. However, if you need larger coordinates, you can use the large document space with 32-bit coordinates. To do this, you must set the GVA_WINDOW_COORDINATE_MOUSE_EVENTS in the
GVI_attrs
field of your GenView object and set up your visible objects correctly. For more information on supporting 32-bit graphic spaces with visible objects, see Visible Layers and 32-Bit Graphics
.
MSG_VIS_GRAB_MOUSE, MSG_VIS_FORCE_GRAB_MOUSE, MSG_VIS_GRAB_LARGE_MOUSE, MSG_VIS_FORCE_GRAB_LARGE_MOUSE, MSG_VIS_RELEASE_MOUSE
When an object "grabs the mouse," it requests that the UI send all future mouse events directly to that object. Normally, mouse events will travel down the visible object tree until they reach either the leaf object under the pointer or an object under the pointer that handles them. When an object has the mouse grab, the mouse events will go to the object with the grab regardless of the location of the pointer.
Typically, if an object wants to receive mouse events, it will subclass
MSG_META_START_SELECT
. This message is sent to the object when the pointer is over the object's bounds and the user presses the select button. In this handler, the object grabs the UI's gadget exclusive and then grabs the mouse. A good example of this can be found in the TicTac sample application's handler for
MSG_META_START_SELECT
.
After an object grabs the mouse, it receives all pointer and drag events that occur. These are primarily
MSG_META_PTR
messages, and the object must subclass
MSG_META_PTR
to achieve the proper behavior it wants. When the user lets go of the select button, the object will receive a
MSG_META_END_SELECT
. If it grabbed the mouse (which it probably did if it receives this message), it must relinquish both the gadget exclusive and its mouse grab.
An example of getting and releasing the mouse grab (taken from the TicTac sample application) is shown in Grabbing and Releasing the Mouse . The object subclasses these messages to let the user drag it around the screen.
The UI allows the visible object to get the normal mouse grab by using four different messages. Each of these is detailed below. If you're using a large document (32-bit coordinates), you will use the "large" mouse grabs. Otherwise, the normal mouse grab messages will do.
void MSG_VIS_GRAB_MOUSE();
A visible object sends itself this message (with
@call
) when it wants to acquire the normal mouse grab. The message
MSG_VIS_RELEASE_MOUSE
must be used to relinquish the grab.
Source: Unrestricted.
Destination: Any visible object--typically sent by the object to itself.
Interception: Highly unlikely.
void MSG_VIS_FORCE_GRAB_MOUSE();
A visible object sends itself this message (with
@call
) when it wants to forcibly grab the mouse input. The object will acquire the mouse grab even if another object currently has it; the other object will receive a
MSG_VIS_LOST_GADGET_EXCL
when it loses the mouse by a forced grab. The object must release the grab later with
MSG_VIS_RELEASE_MOUSE
.
Source: Unrestricted.
Destination: Any visible object--typically sent by the object to itself.
Interception: Highly unlikely.
void MSG_VIS_GRAB_LARGE_MOUSE();
A visible object sends itself this message (with
@call
) when it wants to acquire the mouse grab and when it wants 32-bit coordinates. If the object wants 16-bit coordinates, it should use
MSG_VIS_GRAB_MOUSE
, above. The object must relinquish the mouse grab with
MSG_VIS_RELEASE_MOUSE
.
Source: Unrestricted.
Destination: Any visible object--typically sent by the object to itself.
Interception: Highly unlikely.
void MSG_VIS_FORCE_GRAB_LARGE_MOUSE();
A visible object sends itself this message (with
@call
) when it wants to forcibly grab the mouse input and when it wants large (32-bit) input coordinates. If it wants normal (16-bit) coordinates, it should use
MSG_VIS_FORCE_GRAB_MOUSE
, above. The object will acquire the mouse grab even if another object currently has it; the other object will receive a
MSG_VIS_LOST_GADGET_EXCL
when it loses the mouse by a forced grab. The object must release the grab later with
MSG_VIS_RELEASE_MOUSE
.
Source: Unrestricted.
Destination: Any visible object--typically sent by the object to itself.
Interception: Highly unlikely.
void MSG_VIS_VUP_ALTER_INPUT_FLOW(@stack PointDWord translation, WindowHandle window, optr object, word grapTypeAndFlags);
This message is the primitive employed by the grab/release messages shown above. Objects will rarely use this unless they are large objects (using 32-bit coordinates). Large objects and composites should subclass this message. In the case of a mouse grab, they should add in their 32-bit offset amounts to the translation structure before passing the event on to their superclasses. This will result in large mouse events being properly translated for the duration of the mouse grab.
Source: Unrestricted.
Destination: Any visible object--typically a VisContent which uses a 32-bit graphics space for its children.
Parameters:
translation
The offsets to the origin of the "local" 16-bit graphics space.
window
object
grabTypeAndFlags
VisInputFlowGrabType
, described below; the low byte contains a
VisInputFlowGrabFlags
record, also described below.Return: Nothing.
Interception: Any VisContent object that uses a large graphics space should subclass this method. In the handler, it should apply the stated translation, then call its superclass. Each subsequent mouse event will have the translation applied before being passed on to the composite's children.
Structures:
The types of
VisInputFlowGrabType
are listed below:
VisInputFlowGrabFlags
are listed below:
object
must be passed--if a release, the grab will not be released unless the objects match. Note also that only one object may have the active grab, but many objects may have either passive grab at a given time.void MSG_VIS_RELEASE_MOUSE();
A visible object sends itself this message if it has the mouse grab and wants to release it. Typically, this message will be called in the object's
MSG_META_END_SELECT
handler. It works for both large and small grabs.
Source: Any visible object.
Destination: Any visible object--typically sent by the object to itself.
Interception: Unlikely.
Code Display 15-2 Grabbing and Releasing the Mouse
/* This code display shows the MSG_META_START_SELECT, MSG_META_END_SELECT, * and MSG_VIS_LOST_GADGET_EXCL handlers from the TicTac sample application. * * The sequence of input events and the messages they generate follow the * following basic patterns: * 1. User presses select button * MSG_META_START_SELECT generated, sent to object under mouse pointer * If object under pointer is a game piece, * Game piece grabs gadget exclusive * Game piece grabs mouse * 2. User holds button and drags mouse * MSG_META_DRAG_SELECT generated, sent to object with mouse grab * Game piece sets internal "dragging" flag * Game piece draws outline * MSG_META_PTR messages generated during drag, sent to object with mouse grab * Game piece erases previous outline * Game piece draws new outline at new pointer position * 3. User releases button * MSG_META_END_SELECT generated, sent to object with mouse grab * Game piece releases gadget exclusive (MSG_VIS_RELEASE_GADGET_EXCL) * MSG_VIS_LOST_GADGET_EXCL generated, sent to mouse grab (game piece) * Game piece erases old outline, if any * Game piece moves itself, erases old bounds, draws new bounds * Game piece releases mouse grab (MSG_VIS_RELEASE_MOUSE) */
/*********************************************************************** * MSG_META_START_SELECT for TicTacPieceClass *********************************************************************** * SYNOPSIS: Grabs the mouse and calls for future pointer events. * When the user clickes in the view, TicTacView will pass * the click event to TicTacBoard. Since TicTacBoardClass * does not intercept the event, VisContentClass passes * it on to its child object currently under the pointer. * PARAMETERS: * void (MouseReturnParams *retVal, * word xPosition, word yPosition, word inputState); * * STRATEGY: When the piece object receives this message, it means * it has been clicked on by the user and the mouse button * is still down. The piece must grab the mouse so that it * gets all future mouse events, and it must request that * all future mouse events be sent to it. This ensures * that if the pointer leaves the object's bounds while * the button is still pressed, the piece object will still * receive all the pointer events (otherwise they would be * sent to whatever object was under the new pointer position). ***********************************************************************/
@method TicTacPieceClass, MSG_META_START_SELECT {
/* Grab the gadget exclusive so we're allowed to grab the mouse. */ @call @visParent::MSG_VIS_TAKE_GADGET_EXCL(oself);
/* Grab the mouse. This requests that all future pointer * events be passed directly to this game piece. */ @call self::MSG_VIS_GRAB_MOUSE();
/* Finally, return that this particular click event has been processed. * If this flag is not returned, the system will send out the click * event again. */ retVal->flags = MRF_PROCESSED; /* this event processed */ }
/*********************************************************************** * MSG_META_END_SELECT for TicTacPieceClass *********************************************************************** * SYNOPSIS: This message is received when the selection button has * been released and this game piece had the mouse grab. * All it does is release the gadget exclusive. * PARAMETERS: * void (MouseReturnParams *retVal, * word xPosition, word yPosition, word inputState); ***********************************************************************/
@method TicTacPieceClass, MSG_META_END_SELECT { @call @visParent::MSG_VIS_RELEASE_GADGET_EXCL(oself); retVal->flags = MRF_PROCESSED; /* this event processed */ }
/*********************************************************************** * MSG_VIS_LOST_GADGET_EXCL for TicTacPieceClass *********************************************************************** * SYNOPSIS: This message is received when the selection button has * been released and this game piece had the mouse grab. * It first checks to see if the new, proposed bounds are * on the game board. If the bounds are valid, then * it sets the objects VI_bounds field to the new values * and causes the object to erase its original drawing * and draw itself at its new bounds. If the bounds are * not on the game board, it will retain the original bounds * and redraw using them. * PARAMETERS: void (); ***********************************************************************/
@method TicTacPieceClass, MSG_VIS_LOST_GADGET_EXCL { WindowHandle win; /* window handle of view window */ GStateHandle gstate; /* temporary gstate to draw to */
/* See if piece was being dragged or not. If so, clear the outline. */
if (pself->TTP_dragging) {
/* Get the window handle of the view window and create a * temporary gstate for it to draw to. */
win = @call TicTacView::MSG_GEN_VIEW_GET_WINDOW(); gstate = GrCreateState(win);
/* Set the line color and mode for drawing the outline. */
GrSetLineColor(gstate, CF_INDEX, C_BLACK, 0, 0); GrSetMixMode(gstate, MM_INVERT);
/* Erase outline on screen. */
/* If the game piece type is TTPT_BOX, draw a rectangle * outline. Otherwise draw an ellipse outline. */
if (pself->TTP_pieceType == TTPT_BOX) { GrDrawRect(gstate, pself->TTP_horizPos, pself->TTP_vertPos, ((pself->TTP_horizPos) + PIECE_WIDTH), ((pself->TTP_vertPos) + PIECE_HEIGHT)); } else { GrDrawEllipse(gstate, pself->TTP_horizPos, pself->TTP_vertPos, ((pself->TTP_horizPos) + PIECE_WIDTH), ((pself->TTP_vertPos) + PIECE_HEIGHT)); }
/* Check to see if the new bounds are on the game board. If * they are, set the object's bounds to the new values. If * the are not, retain the original values and set the values * to those last stored. */
if (@call TicTacBoard::MSG_TICTAC_VALIDATE_BOUNDS( ((pself->TTP_vertPos) + PIECE_HEIGHT), ((pself->TTP_horizPos) + PIECE_WIDTH), pself->TTP_vertPos, pself->TTP_horizPos)) {
/* Invalidate the original drawing of the game piece. Send * the VI_bounds rectangle as the parameters because they have * not been changed since the START_SELECT. This message is * the equivalent of calling GrInvalRect() with the same bounds */
@call self::MSG_VIS_BOUNDS_CHANGED(pself->VI_bounds.R_bottom, pself->VI_bounds.R_right, pself->VI_bounds.R_top, pself->VI_bounds.R_left);
/* Set the game piece object's bounds to the new coordinates. */
pself->VI_bounds.R_left = pself->TTP_horizPos; pself->VI_bounds.R_right = (pself->TTP_horizPos) + PIECE_WIDTH; pself->VI_bounds.R_top = pself->TTP_vertPos; pself->VI_bounds.R_bottom = (pself->TTP_vertPos) + PIECE_HEIGHT;
} else {
/* If the bounds are not on the game board, then reset the * current positions to be the original bounds. */
pself->TTP_horizPos = pself->VI_bounds.R_left; pself->TTP_vertPos = pself->VI_bounds.R_top; }
/* Now, the game piece must draw itself at its newly-set * bounds (will draw itself over its original picture if the * new bounds were invalid). */
@call self::MSG_VIS_DRAW(0, gstate);
/* Finally, destroy the temporary gstate used for drawing. */
GrDestroyState(gstate);
/* Clear flag to indicate we are no longer dragging. */
pself->TTP_dragging = FALSE; } /* Release the mouse grab now that the move has finished. * Other objects in the view (other game pieces, for example) * may now receive pointer, select, and drag events. */
@call self::MSG_VIS_RELEASE_MOUSE(); }
MSG_VIS_ADD_BUTTON_PRE_PASSIVE, MSG_VIS_REMOVE_BUTTON_PRE_PASSIVE, MSG_VIS_ADD_BUTTON_POST_PASSIVE, MSG_VIS_REMOVE_BUTTON_POST_PASSIVE
The type of mouse grab described in the previous section is also known as an "active" mouse grab. An object can also have two other types of mouse grabs: pre-passive and post-passive . While only one object may have the active mouse grab at any given time, any number of objects may have pre- or post-passive grabs on the mouse.
An object with a pre-passive mouse grab receives a copy of the input event before the event goes to its true destination. The copy will be a message of the form
MSG_META_PRE_PASSIVE_...
(e.g., if the event is
MSG_META_PTR
, the pre-passive event is
MSG_META_PRE_PASSIVE_PTR
). All pre-passive events will be handled before the true event is delivered to the object with the active grab. If any of the pre-passive copies of the event is returned with the flag MRF_PREVENT_PASS_THROUGH, the active event will not be sent to its destination. You can use this feature to set up input filters, having an object receive all mouse events pre-passive and filtering out those that should not be delivered. The message
MSG_VIS_REMOVE_BUTTON_PRE_PASSIVE
removes any pre-passive mouse grab from the object.
A post-passive mouse grab is similar to a pre-passive except that the post-passive object receives the event
after
it is sent to its normal destination. The post-passive object will receive a
MSG_META_POST_PASSIVE_...
with the same flags and position information as sent with the input event. An object that has the post-passive grab can release it by sending itself a
MSG_VIS_REMOVE_BUTTON_POST_PASSIVE
.
void MSG_VIS_ADD_BUTTON_PRE_PASSIVE();
A visible object sends itself this message (with
@call
) when it wants to gain a pre-passive mouse grab. The object will receive all subsequent mouse events in the form of
MSG_META_PRE_PASSIVE_...
before
the event's destination object receives them; this message will carry the same input information as passed with the input event. The object should handle
MSG_META_PRE_PASSIVE_...
and, if the event is not to be sent normally to its destination, should return the flag MRF_PREVENT_PASS_THROUGH from that handler. The pre-passive grab will be released when the object sends itself a
MSG_VIS_REMOVE_BUTTON_PRE_PASSIVE
.
Source: Unrestricted.
Destination: Any visible object--typically sent by a visible object to itself when it wants to gain a pre-passive mouse grab.
Interception: Unlikely--Note that the object must, however, intercept any
MSG_META_PRE_PASSIVE...
events it is interested in.
void MSG_VIS_REMOVE_BUTTON_PRE_PASSIVE();
This message removes the pre-passive grab from a visible object.
Source: Unrestricted.
Destination: Any visible object--typically sent by a visible object to itself when it has a pre-passive grab and wants to release it.
Interception: Unlikely.
void MSG_VIS_ADD_BUTTON_POST_PASSIVE();
A visible object sends itself this message (with
@call
) when it wants to gain the post-passive mouse grab. The object will receive all subsequent mouse events in the form of
MSG_META_POST_PASSIVE_...
after
the event's destination object receives them; this message will carry the same input information as passed with the input event. The object should handle the appropriate
MSG_META_POST_PASSIVE_...
to properly receive the events. The post-passive grab will be released when the object receives a
MSG_VIS_REMOVE_BUTTON_POST_PASSIVE
.
Source: Unrestricted.
Destination: Any visible object--typically sent by a visible object to itself when it wants to receive post-passive input events.
Interception: Unlikely--Note that the object must, however, handle any
MSG_META_POST_PASSIVE_...
events it is interested in.
void MSG_VIS_REMOVE_BUTTON_POST_PASSIVE();
This message removes any post-passive mouse grab from the object.
Source: Unrestricted.
Destination: Any visible object--typically sent by a visible object to itself to release a post-passive mouse grab.
Interception: Unlikely.
MSG_VIS_TAKE_GADGET_EXCL, MSG_VIS_RELEASE_GADGET_EXCL, MSG_VIS_LOST_GADGET_EXCL, MSG_VIS_VUP_QUERY_FOCUS_EXCL, MSG_VIS_FUP_QUERY_FOCUS_EXCL, MSG_VIS_VUP_ALLOW_GLOBAL_TRANSFER
The gadget exclusive is a marker in the system used by the UI to indicate which object has exclusive access to input gadget functionality. Only one gadget at a time may have the gadget exclusive, and the gadget exclusive may be forcibly taken from an object by another object (for example, when a system-modal dialog comes up during a drag operation).
At times, an object will force the mouse input to go to a different object from that which has the current active grab. This is done almost exclusively by the Specific UI library and is rarely, if ever, done by applications. Three messages can be used in determining which object has the current "gadget exclusive," or active mouse grab. These are shown below.
In addition, individual objects can get information about the current state of the Focus hierarchy with
MSG_VIS_VUP_QUERY_FOCUS_EXCL
and
MSG_VIS_FUP_QUERY_FOCUS_EXCL
, also shown below.
To deal with a quick-transfer operation, a visible object may also have to use the message
MSG_VIS_VUP_ALLOW_GLOBAL_TRANSFER
. This message may be used to remove the mouse grab from the GenView in which the visible object resides, thereby allowing mouse events to reach other objects outside the view window.
void MSG_VIS_TAKE_GADGET_EXCL( optr child);
This message causes the passed object to be given the gadget exclusive. Any object currently having the gadget exclusive will subsequently receive a
MSG_VIS_LOST_GADGET_EXCL
. This is used primarily by the Specific UI.
Source: Unrestricted. Typically sent by a visible object that will next grab the mouse.
Destination: Any visible object--normally sent by an object to its visible parent.
Parameters:
child
The optr of the object to which the gadget exclusive will be given (normally the calling object).
Return: Nothing.
Interception: Unlikely.
See Also:
MSG_VIS_GRAB_MOUSE
,
MSG_VIS_LOST_GADGET_EXCL
void MSG_VIS_RELEASE_GADGET_EXCL( optr child);
This message causes the passed object to release the gadget exclusive. The object specified by
child
will then receive a
MSG_VIS_LOST_GADGET_EXCL
.
Source: Unrestricted. Typically sent by an object that has a mouse grab and expects to release it.
Destination: Any visible object--normally sent by the object to it's parent.
Parameters:
child
The optr of the object which is to lose the gadget exclusive (normally the calling object).
Return: Nothing.
Interception: Unlikely.
See Also:
MSG_VIS_RELEASE_MOUSE
,
MSG_VIS_LOST_GADGET_EXCL
void MSG_VIS_LOST_GADGET_EXCL();
This message, when received, indicates that the recipient has lost its hold on the gadget exclusive. When an object receives this, it should release the active mouse grab, if appropriate.
Source: Unrestricted--typically sent by the UI.
Destination: The visible object losing the gadget exclusive.
Interception: Mouse grabs should be released in this handler.
void MSG_VIS_VUP_QUERY_FOCUS_EXCL( ObjectAndGrabParams *retValue);
This message queries up the visible hierarchy to find the object having the current focus in the current window. The current window is taken to be the window in which the object receiving the message resides.
Source: Unrestricted.
Destination: Any visible object--typically sent by a visible object to itself to find the focus optr in its window.
Parameters:
retValue
A pointer to an empty
ObjectAndGrabParams
structure, shown below.
Return: The
ObjectAndGrabParams
structure pointed to by
retVal
will be filled with the appropriate data.
Interception: Unlikely.
Structures:
The structure of the
ObjectAndGrabParams
is shown below:
typedef struct { word OAGP_grabFlags; /* flags */ word OAGP_unused; /* reserved */ optr OAGP_object; /* object with focus */ } ObjectAndGrabParams;
The
OAGP_grabFlags
field contains a record of
HierarchicalGrabFlags
OAGP_object
has the exclusive.void MSG_VIS_FUP_QUERY_FOCUS_EXCL( ObjectAndGrabParams *retValue);
This message queries the focus hierarchy to see which object has the current focus. The current focus object does not have to be in the caller's visible tree.
Source: Unrestricted.
Destination: Any visible object.
Parameters:
retValue
A pointer to an empty
ObjectAndGrabParams
structure, shown above in the entry for
MSG_VIS_VUP_QUERY_FOCUS_EXCL
.
Return: The
ObjectAndGrabParams
structure pointed to by
retVal
will be filled with the appropriate data.
Interception: Unlikely. This message is not deliverd to all visible objects, rather only those marked as VTF_WIN_GROUP or VTF_IS_INPUT_NODE. If you are implementing a new focus node, and need this message, and are not a window group, you will need to set the VTF_IS_INPUT_NODE bit in your init routine.
Structures: The structure of the
ObjectAndGrabParams
is shown in the entry for
MSG_VIS_VUP_QUERY_FOCUS_EXCL
.
void MSG_VIS_VUP_ALLOW_GLOBAL_TRANSFER();
This message is sent by a visible object to itself when a quick-transfer operation is underway and the pointer has to be allowed to leave the bounds of the object's view window. This message will travel up to the content object, which will indicate to the GenView that the pointer events must be allowed to go to other windows in the system.
Source: Unrestricted.
Destination: Any visible object--typically sent by a visible object to itself when the global transfer must be allowed outside its window.
Interception: Unlikely.
MSG_VIS_VUP_SET_MOUSE_INTERACTION_BOUNDS, MSG_VIS_VUP_GET_MOUSE_STATUS, MSG_VIS_VUP_TERMINATE_ACTIVE_MOUSE_FUNCTION, MSG_VIS_VUP_BUMP_MOUSE
The UI can control the mouse image and events as they occur. Because the UI is based on the visible classes, the messages that control the mouse status are also available to you, though they will probably be of very little utility. These messages are given below.
void MSG_VIS_VUP_SET_MOUSE_INTERACTION_BOUNDS(@stack int bottom, int right, int top, int left);
A visible object requesting the mouse grab sends this message up the visible tree. This message will be handled by a content object. It indicates a new set of draggable bounds in case the user initiates a drag-scrolling operation. This message is sent automatically when the visible object requests the grab.
Source: A visible object requesting a mouse grab.
Destination: The sender sends this message to itself.
Parameters:
bottom, right, top, left
The four bounds of the new bounding rectangle. Default is the bounds of the object sending the message.
Return: Nothing.
Interception: Unlikely.
word MSG_VIS_VUP_GET_MOUSE_STATUS();
This message is rarely used by any objects outside the UI library. It returns the information passed with the last mouse event. The word return value contains two byte-sized sets of flags. The high byte is a list of the active UI functions, and the low byte represents the current button information.
Source: Unrestricted.
Destination: Any visible object--typically sent by a visible object to itself when it can not locally store the latest mouse information.
Parameters: None.
Return: A word containing two values: The high word is a record of type
UIFunctionsActive
, and the low word is a word of
ButtonInfo
.
Interception: Unlikely.
void MSG_VIS_VUP_TERMINATE_ACTIVE_MOUSE_FUNCTION();
This message is sent by a visible object to itself to terminate any active mouse function, forcing it to be a function of type "other." This message is used only by the Specific UI library in cases where input synchronization problems occur in specific places. Applications should generally not use this message.
Source: A visible object handling active input events.
Destination: Sent by the visible object to itself.
Interception: This message should not be subclassed.
void MSG_VIS_VUP_BUMP_MOUSE( int xBump, int yBump);
This message causes the UI to bump the pointer image on the screen by the passed offsets as if the user had moved the mouse. It's unlikely your objects will subclass this message; you may, however, use it to bump the mouse. It is most often used by specific UI objects (menus, scrollers) that make the mouse follow their movements.
Source: Unrestricted.
Destination: Any visible object.
Parameters:
xBump
The horizontal amount to bump the mouse.
yBump
Return: Nothing.
Interception: Unlikely.
MSG_META_GRAB_KBD, MSG_META_FORCE_GRAB_KBD, MSG_META_RELEASE_KBD
The keyboard, like the mouse, may be grabbed by visible objects. Keyboard events arrive in the form
MSG_META_KBD_CHAR
; a single message represents all different types of keyboard events (unlike mouse events, which can be much more diverse).
To grab the keyboard, the visible object should send itself the message
MSG_META_GRAB_KBD
. If the grab should be made in any circumstances, the object should use
MSG_META_FORCE_GRAB_KBD
. To release the keyboard grab, the object should send itself
MSG_META_RELEASE_KBD
.
void MSG_META_GRAB_KBD();
A visible object will send itself this message (using
@call
) when it wants to gain the keyboard grab. To release the grab, it must send itself a
MSG_META_RELEASE_KBD
. If it wants to gain the exclusive regardless of whether another object has it, it should use
MSG_META_FORCE_GRAB_KBD
.
Source: Unrestricted.
Destination: Any visible object--typically sent by a visible object to itself to gain the keyboard grab.
Interception: Unlikely--Note that the object must, however, intercept
MSG_META_KBD_CHAR
to receive the subsequent keyboard events.
void MSG_META_FORCE_GRAB_KBD();
A visible object will send itself this message (using
@call
) when it wants to gain the keyboard grab whether or not another object currently has it. To release the grab, the object must later send itself
MSG_META_RELEASE_KBD
.
Source: Unrestricted.
Destination: Any visible object--typically sent by a visible object to itself to force a keyboard grab.
Interception: Unlikely.
void MSG_META_RELEASE_KBD();
A visible object that has the keyboard grab must send itself this message to release the grab.
Source: Unrestricted.
Destination: Any visible object--typically sent by a visible object to itself to release its keyboard grab.
Interception: Unlikely.
MSG_VIS_QUERY_IF_OBJECT_HANDLES_INK
If a visible object expects and wants Ink input, it should subclass the message
MSG_VIS_QUERY_IF_OBJECT_HANDLES_INK
. This message queries the visible object, which should return specific values based on the current input state and object bounds.
This message has two default handlers; the default
VisClass
handler always returns
false
, indicating that the visible object does not expect Ink input. You can, however, substitute a second default handler for the
VisClass
handler by adding the following line to your Goc file after the object's class definition:
@method VisObjectHandlesInkReply, <YourClass>, MSG_VIS_QUERY_IF_OBJECT_HANDLES_INK;
This will, in essence, substitute the system-provided routine
VisObjectHandlesInkReply()
for a subclassed message handler. This routine will do the right thing for the object in interacting with the input manager. All subsequent input events will be considered Ink events.
void MSG_VIS_QUERY_IF_OBJECT_HANDLES_INK( VisCallChildrenInBoundsFrame *data);
This message is subclassed by objects that handle Ink input. See above for directions on handling this message. The parameters are five data words that may be modified and the bounds of a rectangle. This message will be sent to all objects whose bounds fall within the passed rectangle.
Source: Unrestricted.
Destination: Any visible object.
Parameters:
data
A pointer to a
VisCallChildrenInBoundsFrame
structure containing the bounding rectangle and five words of data. This structure is described below.
Return: Three fields of the
VisCallChildrenInBoundsFrame
structure pointed to by
data
will have meaning on return. See the Interception paragraph below to determine whether the return values should be set or not in a subclassed handler.
VCCIBF_data1
VCCIBF_data2
VCCIBF_data3
Interception: If an object wants to receive ink messages, it should do the following things in its handler for this message: First compare the passed
VCCIBF_data3
value with the top bound of the object. Then, if the upper bound of the object is less than the
VCCIBF_data3
value (or if the value in
VCCIBF_data1
is zero), then the object should return the values indicated in the Return paragraph above. Otherwise, if these conditions are not met, it should return with the structures and registers unchanged.
Structures: The
VisCallChildrenInBoundsFrame
structure is shown below:
typedef struct { word VCCIBF_data1; word VCCIBF_data2; word VCCIBF_data3; word VCCIBF_data4; word VCCIBF_data5; /* Five data words as described above */ Rectangle VCCIBF_bounds; /* bounds must be in the coordinate * system of the parent of the caller */ } VisCallChildrenInBoundsFrame;


--- layout: post title: "Website" date: 2009-02-04 04:53:29 +0000 permalink: /2009/02/04/website/ category: Meta redirect_from: - /blog/website/ ---
I haven't had a real personal website up in a long time, but I'm trying to get back on the ball. Not a whole lot of content yet, but it's coming along. Take a look at http://www.tuxteam.com.


{% extends 'sitewide/base.html' %} {% block title %}Bill Text - {{text.bill.identifier}}{% endblock %} {% load markdownify %} {% load react %} {% block body %}
{{text.bill.title}}
Bill text is published alongside proposed bills on the Missouri House and Senate web sites in PDF form. We scrape these PDFs and republish that information in plain text.


{% extends 'all/main.html' %} {% block content %}
Caption of this image : {{image.description}}.
Location: {{image.image_location}}
Category: {{image.image_category}}
Uploaded at: {{ image.date_created }}


This section is Before you start
{% if thirdparty %}Does {{firstname}}'s Universal Credit include a payment for any of these?
{% else %}Does your Universal Credit include a payment for any of these?
{% endif %}- a child or young person who lives with you
- a disability or health condition that makes it hard for {{partnerOrText}} to work - this is called limited capability for work


Thank you for purchasing Our Template. If you have any queries that are beyond the scope of this help file, kindly contact us through email.We will assist you for your requirements.
Note: The images used in demo site are not included in the template zip file, instead placeholder images were used.
The style.css is the main css file used in this template. This file also contains some general styling, such as anchor tag colors, font-sizes, etc., Note, that these properties might be overridden somewhere else in the file.
If you would like to edit a specific section of the site, simply find the appropriate label in the CSS file, and then scroll down until you find the appropriate style that needs to be edited.
This template imports following Javascript files.
Here is the Html structure for menu
- Our Story
An Inside Look at the Breaking2 KitLeverage agile frameworks to provide a robust synopsis for high level overviews. Iterative approaches to corporate strategy foster collaborative thinking to further…
Read moreUnpacking the Breaking2 Race StrategyLeverage agile frameworks to provide a robust synopsis for high level overviews. Iterative approaches to corporate strategy foster collaborative thinking to further…
Read moreNike’s Latest Football Cleat Breaks the MoldLeverage agile frameworks to provide a robust synopsis for high level overviews. Iterative approaches to corporate strategy foster collaborative thinking to further…
Read more
Trueshoes - eCommerce HTML5 Template. Refer
We have used font Montserrat, font awesome icons in our template. You can make use of those by refering font Montserrat,Archivo Narrow , ,Archivo Narrow , font awesome icons
Our Courtesy to


Month
Days
Season
January
31
Winter
February
28/29
Spring
March
31
Spring
April
30
Spring
May
31
Summer
June
30
Summer
July
31
Summer
August
31
Autumn
September
30
Autumn
October
31
Autumn
November
30
Winter
December
31
Winter


I am a Data Manager & CRM Administrator based in Southern California. I have experience in Excel, HubSpot, Salesforce, HTML, CSS, Looker, Tableau and SQL. I have worked with several businesses on managing their data and Customer Relationship Management software, producing new dashboards, reports, and workflows. Additionally, I have managed several websites for nonprofit organizations, and have created responsive HTML emails for marketing, newsletters, and special announcements.
What I know:
Before becoming an Analyst, I was working in Los Angeles as part of a tech startup.
During my time there, I discovered that I had a talent for learning new technology skills quickly and managing large amounts of data, and focused on expanding my knowledge in software and technology.
I have also worked in the nonprofit sector, and enjoy providing my technical skills in service to others.
I look forward to meeting and communicating with you.


Created alphun to sit with kids and teach them alphabets and basic numbers.. This can be improved like by adding more languages, phonetics, sounds, various colors to alphabet and relavent image.
If you are UI / UX expert please feel to improve this. https://github.com/manchikanti/alphun
If you want to contribute to any language please create an issue at https://github.com/manchikanti/alphun/issues


Bad advice for positioning elements
Positioning elements is simple once you understand that of the positioning properties of relative, absolute and fixed, in most instances, you only need the fixed property. Combined with media queries, you can have complete control of the placement of any element on your page. Fixed positioning removes the element from the normal flow of the document, instead fixing it relative to the initial containing block, normally the body of the document.
You can see how with fixed positioning, you can dictate exactly where an element is on a page. You don’t have to worry about elements affecting one another as they are no longer in the normal flow of the document.
Absolute positioning is similar to fixed positioning in that it is removed from the normal document flow, but is instead positioned relative to the nearest positioned ancestor. This is problematic as ideally you want the elements positioned relative to the body of the document, but any children of a fixed element will be positioned relative to it, if you use absolute positioning, so stick to fixed positioning.
The last and worst of the positioning properties is the relative property. With relative positioning, the element is left in the normal flow of the document (I know…) and positioned relative to itself. The space allowed for it in the document remains in place, no mater its placement. You can see how this would quickly become unmanageable.


Life is Beautiful (1998) A Capsule Review by Nathaniel R. Atcheson
Director: Roberto Benigni Cast: Roberto Benigni, Nicoletta Braschi, Giorgio Cantarini, Giustino Durano, Serio Bini Bustric, Marisa Paredes, Horst Bucholz Screenplay: Vincenzo Cerami, Roberto Benigni Producers: Gianluigi Braschi, Elda Ferri Runtime: 114 min. US Distribution: Miramax Rated PG-13: holocaust-related thematic elements
Copyright 1998 Nathaniel R. Atcheson
Roberto Benigni won big this year at the Oscars, snagging up both Best Foreign Film and Best Actor for Life is Beautiful. The film is actually two pictures in one: the first is about Guido Orefice (Benigni), and his efforts to woo a young woman (played by Benigni's real-life wife, Nicoletta Braschi). This portion of the film is wonderfully funny and unrelenting slapstick comedy. But the slapstick tone is not even marginally appropriate for a Holocaust setting, and so any attempt at humor ends up failing (except for one superb moment in which Guido intentionally screws up in translating orders from a German soldier). Overall, Life is Beautiful is an ambitious and heartfelt artistic failure.
Psychosis Rating: 6/10
Visit FILM PSYCHOSIS at http://www.pyramid.net/natesmovies
Nathaniel R. Atcheson
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


Plugin Information |
|---|
No information for the plugin 'saltstack-plugin' is available. It may have been removed from distribution. |
This plugin sends a SaltStack API message as a build step
Screenshot
Basic usage
Components
Installing this plugin contributes following:
- Send a message to Salt API - Build step
Configuration
Simply fill out the connection details
Building
The Build debian package step has a main configuration parameter "Path to 'debian' catalog" that should point to a catalog that contains debian catalog.
For example, if checkout has structure like $WORKSPACE/myproject/util/debian/ you should use myproject/util as a configuration value.
By default, the build step will install all the requirements on its own, use pbuilder-satisfy-depends to install build-deps of a package and then use debuild to actually build package.
The package .deb will be added as a build artifact and badge with a version per backage built will be applied to the build:
Publishing
The Publish debian packages post-build step uses debrealease to publish package and according .changes to the selected repository. The dupload.conf will be automatically generated with configured GPG account data and used keys.
Automatic version manipulation
Plugin is capable of automatically starting new package version upon build, recording recent changes and commiting it back to SCM.
However, the only supported SCM so far is Subversion due to the absence of commit capabilities in Jenkins SCM core classes.
To use it, check the "Generate changelog" box on the build step and "Commit changes back to repository" on the post-build step.
Upon build, it will:
- start a new version, increasing last numeric component of version by 1 – i.e. version 1.2.8 will become 1.2.9;
- if SCM is SVN, append revision number to the version number in form of '1.2.r12345', where 12345 is the revision;
- record all the changes – from SVN revision history, starting from last recorded revision, or from Jenkins build history – to debian/changelog of a new version via dch;
To better handle failed builds, use 'Checkout fresh copy' SVN option (or similar for other SCM).
Known issues
None at this time
Changelog
Version 1.0 (Sep 4, 2014)
- Initial Version


Centre suspension rotates superconductor . Obviously, the mathematical pendulum scales intramolecular flow. Care gyroscope , despite some uncertainty , of course characterizes the bank, which is clearly visible on the phase trajectory . The literature has repeatedly described as a molecule dependent. The kinematic equation of Euler , as the system of equations to be involved in determining the error rate is less than the soliton . Angular velocity is reproducible in the laboratory.
Centre suspension rotates superconductor . Obviously, the mathematical pendulum scales intramolecular flow. Care gyroscope , despite some uncertainty , of course characterizes the bank, which is clearly visible on the phase trajectory . The literature has repeatedly described as a molecule dependent. The kinematic equation of Euler , as the system of equations to be involved in determining the error rate is less than the soliton . Angular velocity is reproducible in the laboratory.


This is LoxBerry's Emergency Webserver. If you have tried to reach LoxBerry's normal webinterface but see this page, your LoxBerry has a severe problem and cannot provide his webinterface anymore... You can run the Healthcheck from here to figure out what's wrong and you can also reboot the system from here.
Summary of the LoxBerry Healthcheck. This will be updated once a day automatically. You can use this link to check LoxBerry's health status with a Virtual HTTP Input from your Miniserver.
Performs a realtime / live healthcheck. Note! Never - really never! - use this with a Virtual HTTP Input from your Miniserver! The check needs a lot system performance and may slow down your LoxBerry extremely if it is performed to often!
Reboots your LoxBerry. Please enter your SecurePIN first for sercurity reasons.


HTML5 Course with CSS3
The HTML is a markup language for creating websites. Currently in version 5, it uses the semantics of the elements to create the content of a web page. With CSS, we create the visual configurations that a website will have
The HTML is a markup language for creating websites. Currently in version 5, it uses the semantics of the elements to create the content of a web page. With CSS, we create the visual configurations that a website will have
JavaScrip is a scripting language designed to increase interactivity between a website and its visitors. JS code is executed within the browser and gives access to HTML elements through the DOM.


I am using ActiveState Python 3 on Windows and wanted to connect to my MySQL database. I heard that mysqldb was the module to use. I can't find mysqldb for Python 3.
Is there a repository available where the binaries exist for mysqldb? How can I connect to MySQL in Python 3 on Windows?
I also tried using pymysql (on my Win7 x64 machine, Python 3.3), without too much luck. I downloaded the .tar.gz, extract, ran "setup.py install", and everything seemed fine. Until I tried connecting to a database, and got "KeyError [56]". An error which I was unable to find documented anywhere.


{% extends "base.html" %} {% block content %}
A place to store and view reviews for all your favourite games! Sign up today to start reading and writing reviews!
No reviews from potentially biased professional critics, just the honest opinions of real gamers


Performs multivariate normality tests and graphical approaches and implements multivariate outlier detection and univariate normality of marginal distributions through plots and tests (Korkmaz et al, (2014), <https://journal.r-project.org/archive/2014-2/korkmaz-goksuluk-zararsiz.pdf>).
| Version: | 5.5 |
| Depends: | R (≥ 3.3.0) |
| Imports: | methods, nortest, moments, MASS, robustbase, mvoutlier, plyr, psych, boot, energy, kableExtra, magrittr |
| Suggests: | knitr |
| Published: | 2018-06-14 |
| Author: | Selcuk Korkmaz [aut, cre], Dincer Goksuluk [aut], Gokmen Zararsiz [aut] |
| Maintainer: | Selcuk Korkmaz <selcukorkmaz at gmail.com> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| NeedsCompilation: | no |
| Citation: | MVN citation info |
| CRAN checks: | MVN results |
| Reference manual: | MVN.pdf |
| Vignettes: |
MVN: An R Package for Assessing Multivariate Normality |
| Package source: | MVN_5.5.tar.gz |
| Windows binaries: | r-devel: MVN_5.5.zip, r-release: MVN_5.5.zip, r-oldrel: MVN_5.5.zip |
| OS X binaries: | r-release: MVN_5.5.tgz, r-oldrel: MVN_5.5.tgz |
| Old sources: | MVN archive |
| Reverse imports: | KarsTS, smartdata |
| Reverse suggests: | micompr |
Please use the canonical form https://CRAN.R-project.org/package=MVN to link to this page.


Final Exam Contest #TomsProjects
Question 1: Explain why is it important to have GPUs and large labeled data sets in order to train CNNs [2]
Question 2: CNNs are usually preferential to MLPs because of their capability of down sampling and its shift-invariant property. Explain briefly how down sampling and the shift-invariant property are achieved in CNN. [4]
Question 3
(a) Outline the role of the nearest neighbor algorithm for self-driving cars. [2]
(b) Explain one limitation of the nearest neighbor algorithm [2]
Discussions


RANDY THE RAPTOR IS HUNGRY
Attack!
Add!
Kill!
Boys
Girls
Clean up!
Stomp!
Enrage!
Patrol!
Legend
boy
girl
raptor splat!


Service side application is a software that is running on servers.
Servers are applications running on powerful computer that can be communicated through a protocol. Each call is a request. Server responds to each request. Based on the request sent, a certain operation is performed and proper response is sent back
to requestor.
Most commonly used protocol is HTTP and it has 4 main types of requests (POST, GET, PUT and DELETE). A server when operational is known to be online.
To receive a request, servers would have an entry point exposed via network, otherwise known as endpoint. Each server has a unique IP as their address over network and can have its ports exposed. IP and port normally make up an endpoint.
Server application can host/deploy other applications. A thread in server is the application instance that could respond to a request at given endpoint. Application instance has coder’s function that is written using server side languages (C#/java)
and runs on its platform (JVM/CLI). There are concepts when implemented wisely would optimize server potential to its fullest .
Server applications comes in several names like microservices, web services, rest services, WCF services, JSON services, API endpoints, web application, etc… Server applications can also have user interface in them.
Servers can also host user forms, reports and other screens. These can be run only on a special software called Browsers in client computers. Browsers takes care of requesting and rendering user interface or web pages.
Originally, UI was part of server applications which involved overhead of postbacks. However, with new client technologies (like angularjs, ajax, HTML5 / Css3 and JSON) have more processing power which reduced the need for server to host
presentation layer or UI layer in itself.
Problem of postback is resolved with advent of asynchronous AJAX calls using robust client-side applications.
JSON did not completely replace XML. XML is primary way to communicate between systems and application layers. XML’s complexity automatically attributes to security between transactions.


Repeat till fade |


MouseTrack
: web page example
Based on https://github.com/dgacitua/MouseTrack
This is an example of how to use the
MouseTrack browser script
in a web site page (check the
README
for usage details)


UdemyDemo
Home
Page 1
Page 2
topic 1
topic 2
topic 3
topic 4
topic 5
topic 6
topic 7
topic 8
topic 9
topic 10
topic 11
topic 12
topic 13
topic 14
topic 15
topic 16
topic 17
topic 18
topic 19
topic 20
Advertisements 1
Advertisements 2


{% extends "base.html" %} {% load crispy_forms_tags %} {% block title %} Exchange Rate {% endblock %} {% block content %}
Here you can see exchange rates between EURO and USD for various dates. Please login or register for advanced features.
Use username: 'uhura' password: 'uhura1'
for test account.
| Date | EURO | USD |
|---|---|---|
| {{ update.exchange_date }} | {{ update.euro }} | {{ update.usd }} |


#include <reporting.h>
|
| | SearchReportingInterface (bool print_all, int max_num_solutions) |
| |
| virtual | ~SearchReportingInterface () |
| |
| virtual void | Init (int thread_id, const std::string &init_string)=0 |
| |
| virtual void | OnSearchStart (int thread_id, Type type)=0 |
| |
| virtual void | OnSatSolution (int thread_id, const std::string &solution_string)=0 |
| |
| virtual void | OnOptimizeSolution (int thread_id, int64 value, const std::string &solution_string)=0 |
| |
| virtual void | OnSearchEnd (int thread_id, bool interrupted)=0 |
| |
| virtual void | Log (int thread_id, const std::string &message) const =0 |
| |
| virtual void | Print (int thread_id, const std::string &output) const =0 |
| |
| virtual bool | ShouldFinish () const =0 |
| |
| virtual int64 | BestSolution () const =0 |
| |
| virtual bool | Interrupted () const =0 |
| |
| int | NumSolutions () const |
| |
| int | MaxNumSolutions () const |
| |
| bool | ShouldPrintAllSolutions () const |
| |
| virtual OptimizeVar * | CreateObjective (Solver *s, bool maximize, IntVar *var, int64 step, int thread_id) const =0 |
| |
| virtual SearchLimit * | CreateLimit (Solver *s, int thread_id) const =0 |
| |
Definition at line 34 of file reporting.h.
◆ Type
| Enumerator |
|---|
| UNDEF | |
| SATISFY | |
| MINIMIZE | |
| MAXIMIZE | |
Definition at line 36 of file reporting.h.
◆ SearchReportingInterface()
| operations_research::fz::SearchReportingInterface::SearchReportingInterface |
( |
bool |
print_all, |
|
|
int |
max_num_solutions |
|
) |
| |
|
inline |
◆ ~SearchReportingInterface()
| virtual operations_research::fz::SearchReportingInterface::~SearchReportingInterface |
( |
| ) |
|
|
inlinevirtual |
◆ Init()
| virtual void operations_research::fz::SearchReportingInterface::Init |
( |
int |
thread_id, |
|
|
const std::string & |
init_string |
|
) |
| |
|
pure virtual |
◆ OnSearchStart()
| virtual void operations_research::fz::SearchReportingInterface::OnSearchStart |
( |
int |
thread_id, |
|
|
Type |
type |
|
) |
| |
|
pure virtual |
◆ OnSatSolution()
| virtual void operations_research::fz::SearchReportingInterface::OnSatSolution |
( |
int |
thread_id, |
|
|
const std::string & |
solution_string |
|
) |
| |
|
pure virtual |
◆ OnOptimizeSolution()
| virtual void operations_research::fz::SearchReportingInterface::OnOptimizeSolution |
( |
int |
thread_id, |
|
|
int64 |
value, |
|
|
const std::string & |
solution_string |
|
) |
| |
|
pure virtual |
◆ OnSearchEnd()
| virtual void operations_research::fz::SearchReportingInterface::OnSearchEnd |
( |
int |
thread_id, |
|
|
bool |
interrupted |
|
) |
| |
|
pure virtual |
◆ Log()
| virtual void operations_research::fz::SearchReportingInterface::Log |
( |
int |
thread_id, |
|
|
const std::string & |
message |
|
) |
| const |
|
pure virtual |
◆ Print()
| virtual void operations_research::fz::SearchReportingInterface::Print |
( |
int |
thread_id, |
|
|
const std::string & |
output |
|
) |
| const |
|
pure virtual |
◆ ShouldFinish()
| virtual bool operations_research::fz::SearchReportingInterface::ShouldFinish |
( |
| ) |
const |
|
pure virtual |
◆ BestSolution()
| virtual int64 operations_research::fz::SearchReportingInterface::BestSolution |
( |
| ) |
const |
|
pure virtual |
◆ Interrupted()
| virtual bool operations_research::fz::SearchReportingInterface::Interrupted |
( |
| ) |
const |
|
pure virtual |
◆ NumSolutions()
| int operations_research::fz::SearchReportingInterface::NumSolutions |
( |
| ) |
const |
|
inline |
◆ MaxNumSolutions()
| int operations_research::fz::SearchReportingInterface::MaxNumSolutions |
( |
| ) |
const |
|
inline |
◆ ShouldPrintAllSolutions()
| bool operations_research::fz::SearchReportingInterface::ShouldPrintAllSolutions |
( |
| ) |
const |
|
inline |
◆ CreateObjective()
| virtual OptimizeVar* operations_research::fz::SearchReportingInterface::CreateObjective |
( |
Solver * |
s, |
|
|
bool |
maximize, |
|
|
IntVar * |
var, |
|
|
int64 |
step, |
|
|
int |
thread_id |
|
) |
| const |
|
pure virtual |
◆ CreateLimit()
| virtual SearchLimit* operations_research::fz::SearchReportingInterface::CreateLimit |
( |
Solver * |
s, |
|
|
int |
thread_id |
|
) |
| const |
|
pure virtual |
◆ IncrementSolutions()
| void operations_research::fz::SearchReportingInterface::IncrementSolutions |
( |
| ) |
|
|
inlineprotected |
The documentation for this class was generated from the following file:


|
Border Surviellance Bot Group V
An attempt to model border surviellance using Firebird-V robot and Python
|
Public Member Functions | |
| def | __init__ |
| def | __del__ |
| def | close |
| def | setBaudrate |
| def | inWaiting |
| def | read |
| def | write |
| def | flushInput |
| def | flushOutput |
| def | sendBreak |
| def | setRTS |
| def | setDTR |
| def | getCTS |
| def | getDSR |
| def | getRI |
| def | getCD |
| def | __repr__ |
Public Attributes | |
| portstr | |
| baud | |
| bytesize | |
| parity | |
| stop | |
| retry | |
| filename |
port: number of device; numbering starts at zero. if everything fails, the user can specify a device string, note that this isn't portable any more baudrate: baud rate bytesize: number of databits parity: enable parity checking stopbits: number of stopbits timeout: set a timeout (None for waiting forever) xonxoff: enable software flow control rtscts: enable RTS/CTS flow control retry: DOS retry mode
Definition at line 66 of file sermsdos.py.
| def serial::sermsdos::Serial::__del__ | ( | self | ) |
Destructor. Calls close().
Reimplemented from serial::serialutil::FileLike.
Definition at line 121 of file sermsdos.py.
| def serial::sermsdos::Serial::getCD | ( | self | ) |
Eead terminal status line
Definition at line 189 of file sermsdos.py.
| def serial::sermsdos::Serial::getCTS | ( | self | ) |
Eead terminal status line
Definition at line 177 of file sermsdos.py.
| def serial::sermsdos::Serial::getDSR | ( | self | ) |
Eead terminal status line
Definition at line 181 of file sermsdos.py.
| def serial::sermsdos::Serial::getRI | ( | self | ) |
Eead terminal status line
Definition at line 185 of file sermsdos.py.
| def serial::sermsdos::Serial::inWaiting | ( | self | ) |
returns the number of bytes waiting to be read
Definition at line 140 of file sermsdos.py.
| def serial::sermsdos::Serial::read | ( | self, | |
num = 1 |
|||
| ) |
Read num bytes from serial port
Definition at line 144 of file sermsdos.py.
| def serial::sermsdos::Serial::setDTR | ( | self, | |
level = 1 |
|||
| ) |
Set terminal status line
Definition at line 173 of file sermsdos.py.
| def serial::sermsdos::Serial::setRTS | ( | self, | |
level = 1 |
|||
| ) |
Set terminal status line
Definition at line 169 of file sermsdos.py.
| def serial::sermsdos::Serial::write | ( | self, | |
| s | |||
| ) |
Write string to serial port
Definition at line 152 of file sermsdos.py.


|
Terence Henriod
Lab 10: Heap and PriorityQueue
|
#include <Heap.h>
Public Member Functions | |
| Heap (int maxNumber=DEFAULT_MAX_HEAP_SIZE) | |
| Heap (const Heap &other) | |
| Heap & | operator= (const Heap &other) |
| ~Heap () | |
| void | insert (const DataType &newDataItem) throw ( logic_error ) |
| DataType | remove () throw ( logic_error ) |
| void | clear () |
| bool | isEmpty () const |
| bool | isFull () const |
| void | showStructure () const |
| void | writeLevels () const |
Static Public Attributes | |
| static const int | DEFAULT_MAX_HEAP_SIZE = 10 |
Private Member Functions | |
| void | showSubtree (int index, int level) const |
Private Attributes | |
| int | maxSize |
| int | size |
| DataType * | dataItems |
| Comparator | comparator |
A Heap ADT. The Heap is a data structure for storing data as though it were a tree whose requirements are that no parent is less than a child and that the tree must be completely full except for the bottom level. The data is stored in an array, granting fast access and easy reordering of data. Because the data is stored in an array, the bottom level of data fills up from left to right.
| Heap< DataType, KeyType, Comparator >::Heap | ( | int | maxNumber = DEFAULT_MAX_HEAP_SIZE | ) |
The default constructor for the heap. Instantiates an empty heap.
| maxNumber | The maximum capacity given to the heap. It is recommended that a size that is 2^n - 1 is chosen. This parameter defaults to DEFAULT_MAX_HEAP_SIZE (defined in Heap.h). |
| Heap< DataType, KeyType, Comparator >::Heap | ( | const Heap< DataType, KeyType, Comparator > & | other | ) |
The copy constructor for the heap. Instantiates a Heap that is a clone of the given other parameter.
| other | A Heap to be cloned into *this. |
| Heap< DataType, KeyType, Comparator >::~Heap | ( | ) |
~Heap
The destructor for the heap ADT. Ensures that all dynamically allocated memory is returned.
| void Heap< DataType, KeyType, Comparator >::clear | ( | ) |
clear
Empties the heap.
| void Heap< DataType, KeyType, Comparator >::insert | ( | const DataType & | newDataItem | ) | throw ( logic_error ) |
insert
Inserts the given value into the appropriate place in the array if there is room. Throws an expression of type logic_error if the Heap is full.
| newDataItem | The new item to be inserted into the Heap. |
| logic_error | This exception is thrown if an attempt is made to insert into a full heap. |
| bool Heap< DataType, KeyType, Comparator >::isEmpty | ( | ) | const |
| bool Heap< DataType, KeyType, Comparator >::isFull | ( | ) | const |
| Heap< DataType, KeyType, Comparator > & Heap< DataType, KeyType, Comparator >::operator= | ( | const Heap< DataType, KeyType, Comparator > & | other | ) |
operator=
The overloaded assignment operator for the Heap ADT. Clones the given Heap other parameter into *this.
| other | A Heap whose data will be cloned into this one. |
| DataType Heap< DataType, KeyType, Comparator >::remove | ( | ) | throw ( logic_error ) |
remove
Removes the item at the top ("root") of the Heap. The heap is then reorderd appropriately to maintain the properties of a heap. The removed item is returned. An exception is thrown if removal is attempted on an empty heap.
| logic_error | This exception is thrown if removal on an empty heap is attempted. |
| void Heap< DataType, KeyType, Comparator >::showStructure | ( | ) | const |
showStructure
Outputs the priorities of the data items in a heap in both array and tree form. If the heap is empty, outputs "Empty heap". This operation is intended for testing/debugging purposes only.
| void Heap< DataType, KeyType, Comparator >::showSubtree | ( | int | index, |
| int | level | ||
| ) | const [private] |
FunctionName
Helper function for the showStructure() function. Outputs the subtree (subheap) whose root is stored in dataItems[index]. Argument level is the level of this dataItems within the tree.
| void Heap< DataType, KeyType, Comparator >::writeLevels | ( | ) | const |
Comparator Heap< DataType, KeyType, Comparator >::comparator [private] |
DataType* Heap< DataType, KeyType, Comparator >::dataItems [private] |
const int Heap< DataType, KeyType, Comparator >::DEFAULT_MAX_HEAP_SIZE = 10 [static] |
int Heap< DataType, KeyType, Comparator >::maxSize [private] |
int Heap< DataType, KeyType, Comparator >::size [private] |


Snap the draggable to the inner or outer boundaries of a DOM element. Use the snap
, snapMode
(inner, outer, both), and snapTolerance
(distance in pixels the draggable must be from the element when snapping is invoked) options.
Or snap the draggable to a grid. Set the dimensions of grid cells (height and width in pixels) with the grid
option.


Welcome to the Parent Orientation Session!
Please click below to go to Session 5
Session 5 will begin at 1 pm
Go To Session >


Give me a business id and you shall know a lot more
{% csrf_token %} {{ form }}
{% if info %}
Found following info
{{ info }}
{% endif %}


Installing Apicurio Registry Operator using the OperatorHub
This chapter explains how to install Apicurio Registry Operator on Kubernetes or OpenShift. It also shows how to install the Strimzi or Java Persistence API (PostgreSQL) storage option:
Installing Apicurio Registry Operator using the OperatorHub on Kubernetes
This chapter focuses on installation procedures for OpenShift using OperatorHub UI. If you are deploying to Kubernetes, you can use command line tools to install Operator Lifecycle Manager (OLM), and instruct it to deploy the Apicurio Registry or other operators.
-
You must have cluster administrator access to a Kubernetes cluster.
-
Go to OperatorHub.io - Apicurio Registry page.
-
Select the Version you want to install
-
Read the information about the Operator, and click Install.
-
Follow the instructions on the installation page.
Installing Apicurio Registry Operator using Operator Lifecycle Manager
The recommended way to install Apicurio Registry Operator is to use the Operator Lifecycle Manager (OLM), which can automatically manage the Operator deployment and upgrades.
Apicurio Registry Operator is released to the OperatorHub, so if your cluster has the OLM and OperatorHub installed, the cluster administrator can use the OpenShift web console to deploy the Apicurio Registry Operator:
-
You must have cluster administrator access to an OpenShift cluster.
-
In the OpenShift Container Platform web console, log in using an account with cluster administrator privileges.
-
Create a new OpenShift project:
-
In the left navigation menu, click Home > Project > Create Project.
-
Enter a project name, for example,
my-project
, and click Create.
-
-
In the left navigation menu, click Operators > OperatorHub.
-
In the Filter by keyword text box, enter
registry
to find the Apicurio Registry Operator. -
Read the information about the Operator, and click Install. This displays the Create Operator Subscription page.
-
Select your subscription settings, for example:
-
Installation Mode > A specific namespace on the cluster > my-project
-
Update Channel > alpha
-
Approval Strategy > Automatic
-
-
Click Subscribe. This displays the Operators > Installed Operators page.
-
Wait a few moments until the Status for the Apicurio Registry Operator displays Succeeded and the subscription is Up to Date.
Installing Strimzi storage using OpenShift OperatorHub
The recommended Kafka Streams storage option requires that you provide connection information to a Kafka cluster. You can use any Kafka cluster with Kafka Streams support. However, it is recommended to use the Strimzi Operator to provide and maintain a Kafka cluster for you.
If you do not already have Kafka Streams installed, you can install the Strimzi Operator on your OpenShift cluster from the OperatorHub.
-
You must have cluster administrator access to an OpenShift cluster
-
In the OpenShift Container Platform web console, log in using an account with cluster administrator privileges.
-
Change to the OpenShift project in which Apicurio Registry is installed. For example, from the Project drop-down, select
my-project
. -
In the left navigation menu, click Operators > OperatorHub.
-
In the Filter by keyword text box, enter
Strimzi
to find the Strimzi Operator. -
Read the information about the Operator, and click Install. This displays the Create Operator Subscription page.
-
Select your subscription settings, for example:
-
Installation Mode > A specific namespace on the cluster > my-project
-
Update Channel > stable
-
Approval Strategy > Manual
-
-
Click Subscribe. This displays the Operators > Installed Operators page.
-
Wait a few moments until the Status for the Strimzi Operator displays Succeeded and the subscription is Up to Date.
Installing PostgreSQL database storage using OpenShift OperatorHub
One of the available storage options requires that you provide connection information to a PostgreSQL database. You can use any PostgreSQL database available on your OpenShift cluster, but it is recommended to use OperatorHub to choose and install an Operator that can manage a PostgreSQL database for you.
You can install your preferred PostgresQL Operator, but this section shows how to install the PostgreSQL Operator by Dev4Ddevs.com and create a new database for Apicurio Registry.
-
You must have cluster administrator access to an OpenShift cluster.
-
In the OpenShift Container Platform web console, log in using an account with cluster administrator privileges.
-
Change to the OpenShift project in which Apicurio Registry is installed. For example, from the Project drop-down, select
my-project
. -
In the left navigation menu, click Operators > OperatorHub.
-
In the Filter by keyword text box, enter
PostgreSQL
to find an Operator suitable for your environment, for example, PostgreSQL Operator by Dev4Ddevs.com or Crunchy PostgreSQL for OpenShift. -
Read the information about the Operator, and click Install. This displays the Create Operator Subscription page.
-
Select your subscription settings, for example:
-
Installation Mode > A specific namespace on the cluster > my-project
-
Update Channel > stable
-
Approval Strategy > Manual
-
-
Click Subscribe. This displays the Operators > Installed Operators page.
-
Wait a few moments until the Status for the PostgreSQL Operator displays Succeeded and the subscription is Up to Date.
You must read the documentation from your chosen PostgreSQL Operator for details on how to create and manage your database. -
Create a PostgreSQL database for your Apicurio Registry storage. For example, click Installed Operators > PostgreSQL Operator by Dev4Ddevs.com > Create database > YAML.
-
Edit the database settings as follows:
-
name
: Change the value toregistry
-
image
: Change the value tocentos/postgresql-10-centos7
-
-
Edit any other database settings as needed depending on your environment, for example:
apiVersion: postgresql.dev4devs.com/v1alpha1 kind: Database metadata: name: registry namespace: my-project spec: databaseCpu: 30m databaseCpuLimit: 60m databaseMemoryLimit: 512Mi databaseMemoryRequest: 128Mi databaseName: example databaseNameKeyEnvVar: POSTGRESQL_DATABASE databasePassword: postgres databasePasswordKeyEnvVar: POSTGRESQL_PASSWORD databaseStorageRequest: 1Gi databaseUser: postgres databaseUserKeyEnvVar: POSTGRESQL_USER image: centos/postgresql-10-centos7 size: 1
-
Click Create Database, and wait until the database is created.


JoystickButton()
Syntax
Result = JoystickButton(#Joystick, Button)Description
Returns the joystick button state.
Parameters
#Joystick The joystick to use. The first joystick index is 0. The number of available joysticks is returned by InitJoystick(). Button The joystick button to query. The first button index is 1.
Return zero if the specified button is not pressed, else it returns nonzero. Any number of buttons may be pressed at the same time.
Remarks
ExamineJoystick() has to be called before this function is used, to update the current joystick state.
See Also
ExamineJoystick()
Supported OS
All


T-shirt $24.99
Yep, your friends will be jealous when all the ladies are interested in you when you hit the club in this beauty. Buy 2 so you have an extra in case you spill a daquiri on your first
Cookie Cutter $12.99
Make your own salmon cookies with this stainless steel cookie cutter! For an additional $300, we will throw in our patented recipe for our delicious salmon cookies
Handmade Fish Thingies $2,500.00
These gorgeous hand painted fish will be admired by your friends for weeks until they end up in your junk drawer to be rediscovered years later at which time you can reminisce about the first time you ate a Pat's Salmon Cookie!


Liam Gallagher will vote Green Party in next month's election after famously backing New Labour
Liam has changed teams as he vowed to throw his support behind the Green Party in the election next month
by Lily Waddell, https://www.mirror.co.uk/authors/lily-waddell/Liam Gallagher knows a thing or two about toxic politics as he and his brother Noel continue to swap insults.
Before their spat, the Oasis lads famously backed Labour in 1997.
But, Liam will be voting for the Green Party in next month’s election.
He said: “It’s the only party that makes sense”.
The rocker has seen first-hand the destruction caused by climate change after being caught up in the Los Angeles wildfires on his Why Me? Why Not? tour last month.
Speaking to the Mirror as he backed our climate edition, Liam, 47, says: “I’m voting for the Green Party: the rest of them are all selfish and clueless.
“I’m a big fan of David Attenborough and watching his show on the Antarctic recently was really sad.
“It’s worrying.
Asked what he thought of climate activist Greta Thunberg, 16, right, he said: “I thinks she’s amazing. She means it, man.”


Welcome to Game Board!
Game Board is an application used to track games played, display statistics, and keep track of a player’s individual achievements within a group of friends.
{% extends "base.html" %} {% block title %} Game Board {% endblock %} {% block css %} {% load static %} {% endblock %} {% block page %}
Game Board is an application used to track games played, display statistics, and keep track of a player’s individual achievements within a group of friends.


{% load static %}
Login
{% csrf_token %}
Email
Password
Forget Password
Don't Have Account ?
Register Here
Or Login With


Gecode::Gist::Node Class Reference
Base class for nodes of the search tree.
More...
#include <node.hh>
List of all members.
Detailed Description
Base class for nodes of the search tree.
Definition at line 110 of file node.hh.
Member Typedef Documentation
Constructor & Destructor Documentation
| Gecode::Gist::Node::Node |
( |
int |
p, |
|
|
bool |
failed = false | |
|
) |
| | [inline] |
Construct node with parent p.
Definition at line 179 of file node.hpp.
Member Function Documentation
| bool Gecode::Gist::Node::isUndetermined |
( |
void |
|
) |
const [inline, protected] |
Return whether this node is undetermined.
Definition at line 196 of file node.hpp.
| int Gecode::Gist::Node::getChild |
( |
int |
n |
) |
const [inline, protected] |
Return index of child no n.
Definition at line 199 of file node.hpp.
| int Gecode::Gist::Node::getParent |
( |
void |
|
) |
const [inline] |
Return the parent.
Definition at line 186 of file node.hpp.
Return the parent.
Definition at line 191 of file node.hpp.
Return child no n.
Definition at line 210 of file node.hpp.
| int Gecode::Gist::Node::getIndex |
( |
const NodeAllocator & |
na |
) |
const [inline] |
Return index of this node.
Definition at line 231 of file node.hpp.
| bool Gecode::Gist::Node::isRoot |
( |
void |
|
) |
const [inline] |
Check if this node is the root of a tree.
Definition at line 215 of file node.hpp.
| void Gecode::Gist::Node::setNumberOfChildren |
( |
unsigned int |
n, |
|
|
NodeAllocator & |
na | |
|
) |
| | |
Set the number of children to n and initialize children.
Definition at line 46 of file node.cpp.
| unsigned int Gecode::Gist::Node::getNumberOfChildren |
( |
void |
|
) |
const [inline] |
Return the number of children.
Definition at line 218 of file node.hpp.
The documentation for this class was generated from the following files:


YouTube Archiver
New Request
Source
URL is required
Download
Both (MKV and MP3)
Video (MKV)
Audio (MP3)
Download Now
Downloads
No Downloads!
Files Available
No Downloads!
Name
Files
Management


Need to be open quickly and efficiently? We have ready to go retail merchandising units to host your brand. Grow your business while gaining exposure to thousands of shoppers. You can sell merchandise, gift certificates, or simply advertise, whatever suits your business needs.
View Portfolio


Amount
{{
element.amount | currency: element.currency.code:"code"
}}
Unit
{{ element.currency.unit }}
Purchase price
{{
element.currency.purchase_price
| currency: defaults.currency.code:"code":"1.4-4"
}}
Sell price
{{
element.currency.sell_price
| currency: defaults.currency.code:"code":"1.4-4"
}}
There is no data available.


My first major in college was Architectural Engineering. It was a long road, but I eventually found my passions in music and computer science. In Houston, I studied Music Theory, Audio Engineering, Arranging/Composition and Computer Engineering. Fall of 2015, I transferred to The Ohio State University to complete my degree in Computer Science and Engineering.
At Ohio State, I was crowned 2015 African-American Homecoming King in addition to participating in many on-campus organizations including Jazz Club, Collegiate Web Developers Group, Musicians Collective, and Hale Council. I am the current Webmaster for the HaleCouncil.org site.
+120
Dec. 2018


The Report review – claustrophobic tale of CIA interrogation failures
by Wendy IdeThis fact-based thriller about a US Senate investigation gets caught up in the detail
An excellent Adam Driver ties himself into knots of frustration in this factually based account of the Senate investigation into the CIA’s post 9/11 EIT (Enhanced Interrogation programme), a fiercely unforging denunciation. Writer and director Scott Z Burns condenses approaching 7,000 pages of information into an involving drama that has a kinship with films such as Spotlight and All the President’s Men but does get a little bogged down in paperwork at times.
The story of the investigation led by Daniel Jones (Driver) at the behest of Senator Dianne Feinstein (Annette Bening) unfolds against an unhealthy colour palette of grey blue pocked with toxic yellow. “You don’t have a legal problem, you have a sunlight problem,” says an attorney, cryptically. It’s true of the central character, who has spent five years excavating ugly truths for a report that may never see the light of day. And it’s true of the film, which, although compelling, feels a bit like being locked in an airless room with the walls closing in.


An interface of R to Klout API v2. It fetches Klout Score for a Twitter Username/handle in real time. Klout is a website and mobile app that uses social media analytics to rank its users according to online social influence via the "Klout Score", which is a numerical value between 1 and 100. In determining the user score, Klout measures the size of a user's social media network and correlates the content created to measure how other users interact with that content.
| Version: | 1.0 |
| Imports: | RCurl |
| Published: | 2015-07-24 |
| Author: | Binayak Goswami |
| Maintainer: | Binayak Goswami <bnayok at gmail.com> |
| License: | GPL-2 |
| NeedsCompilation: | no |
| CRAN checks: | RKlout results |
| Reference manual: | RKlout.pdf |
| Package source: | RKlout_1.0.tar.gz |
| Windows binaries: | r-devel: RKlout_1.0.zip, r-release: RKlout_1.0.zip, r-oldrel: RKlout_1.0.zip |
| OS X binaries: | r-release: RKlout_1.0.tgz, r-oldrel: RKlout_1.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=RKlout to link to this page.


Home
Tools
About
Check Github Repo Size
Full Repo link :
Check W3C validation
Web address :
Powered by
shields.io


| unitizer_ls {unitizer} | R Documentation |
Much like 'ls', except that it is designed to crawl up the `.new`
and
`.ref`
environments and display all the objects.
unitizer_ls( name, pos = -1L, envir = parent.frame(), all.names = FALSE, pattern )
This is used in `browseUnitizer,unitizer-unitizerBrowse-method`
,
and is re-assigned to `ls`
for use in the `unitizer`
prompt
environment.
list of object names, or a list with environments containing the objects


/** * @ignore * Json emulator for KISSY * @author<EMAIL_ADDRESS>*/ KISSY.add('json', function (S, stringify, parse) { /** * The Json object contains methods for converting values to JavaScript Object Notation (Json) * and for converting Json to values. * @class KISSY.JSON * @singleton */ return S.JSON = { /** * Convert a value to Json, optionally replacing values if a replacer function is specified, * or optionally including only the specified properties if a replacer array is specified. * @method * @param value The value to convert to a Json string. * @param [replacer] * The replacer parameter can be either a function or an array. As a function, it takes two parameters, the key and the value being stringified. Initially it gets called with an empty key representing the object being stringified, and it then gets called for each property on the object or array being stringified. It should return the value that should be added to the Json string, as follows: * - If you return a Number, the string corresponding to that number is used as the value for the property when added to the Json string. * - If you return a String, that string is used as the property's value when adding it to the Json string. * - If you return a Boolean, "true" or "false" is used as the property's value, as appropriate, when adding it to the Json string. * - If you return any other object, the object is recursively stringified into the Json string, calling the replacer function on each property, unless the object is a function, in which case nothing is added to the Json string. * - If you return undefined, the property is not included in the output Json string. * * **Note:** You cannot use the replacer function to remove values from an array. If you return undefined or a function then null is used instead. * * @param [space] space Causes the resulting string to be pretty-printed. * The space argument may be used to control spacing in the final string. * If it is a number, successive levels in the stringification will each be indented by this many space characters (up to 10). * If it is a string, successive levels will indented by this string (or the first ten characters of it). * @return {String} */ stringify: stringify, /** * Parse a string as Json, optionally transforming the value produced by parsing. * @param {String} text The string to parse as Json. * @param {Function} [reviver] If a function, prescribes how the value originally produced by parsing is transformed, * before being returned. */ parse: parse }; }, { requires: ['./json/stringify', './json/parse'] });


Graphical Illustraions have been custom made by the flowbase team. Upon purchase we grant you usage of these assets and welcome you to open SVGs and edit. If you would like the original Figma working files we can provide these to customers.
Icons have been sourced from flaticon, and freepix. If you require other location icons you can view here
Photography assets have been sourced from open libraries such as unsplash & pexels.


This field works in conjunction with the proxy host field to specify the username used to authenticate with
the proxy.
If this proxy requires Microsoft's NTLM
authentication scheme then the domain name can be encoded within the username by prefixing the domain name
followed by a back-slash \ before the username, e.g "ACME\John Doe".


COVID Explore
Home
(current)
The Dark Side
The Climate Side
The Finance Side
Contact
In case you want to contact me:


Mystery, Alaska (1999) Reviewed by Eugene Novikov http://www.ultimate-movie.com Member: Online Film Critics Society
"The Rangers taking their off-time to go to some cold village and play pond hockey with eskimos: it's a joke!"
Starring Russell Crowe, Burt Reynolds, Colm Meaney, Hank Azaria, Mary McKormick, Lolita Davidovich, Maury Chaykin. Rated R.
After watching Mystery, Alaska, I decided to do a little research. I ventured over to the Internet Movie Database, the premier source of movie information on the net, to test a theory. I searched for movies and tv series about hockey, baseball, football, and basketball. When I searched for baseball, it returned 145 movies and tv shows. Football gave me 145 and basketball came up with 68. But when I did a search on hockey, the result was a measly 44 references. Why is hockey so underrepresented in pop culture? Hard to say, but while audiences seem to be tired of sports movies of late, a hockey film or two is not unwelcome, provided it doesn't have the words "Mighty Ducks" in the title.
Mystery, Alaska is a hockey town. Life revolves around the "Saturday Game", a weekly pond hockey match-up. It's not a competition. They don't keep score. The teams are decided at random. The game is more than a tradition: it's a legend, a way of life. A veteran of the "Saturday Game", John Biebe, who has played for some thirteen years is about to be honorably discharged. He's a good player, but he is getting old and his agility on skates isn't what it used to be. He has to be liquidated to make room for an ambitious up-and-comer, a lighting- fast high-schooler with relationship issues.
Just then, a cocky former Mystery resident who has abandoned the town for a career in Hollywood returns -- on a helicopter, no less. But he doesn't come empty-handed. He brings word that the New York Rangers are going to fly to Alaska for a game of pond hockey with the "Mystery Boys". It seems some genius at the National Hockey League had an idea for some good, cheap promotion: why not fly the league's premier hockey team to the middle of nowhere and have them play a sort of charity game with mysterious "Eskimos"?
But not so fast. It seems the Rangers aren't too keen about taking their precious free time to play pond hockey in Alaska. The players' union files a grievance demanding that the arrangement be cancelled, and Mystery sends their lawyer (Maury Chaykin) to represent the town and hopefully maintain what dignity they have left. As if that wasn't enough, crises arise in the homeland as well. The team needs a coach. The town Mayor (Colm Meaney) wants John to do it as a sort of retribution, but John wants to play, thereby pressing the old hockey expert/town judge (Burt Reynolds) to take the job.
 I don't take notes when I watch movies, but I wish I had brought a notepad and a pen for this one just so I could write down at least a significant portion of the countless examples of idea recycling that goes on in this movie. To name a few: kids spontaneously cursing for laughs, a guy who piles an inordinate amount of [fill in food here; in this case, mashed potatoes] onto his plate when he is distracted during dinner, a guy watching sports during sex and screaming out when a goal is scored, and of course, the obligatory "Big Game" ending, which we know can turn out one of two ways. I'll leave it to you to guess which one is used here.
I've always thought of director Jay Roach as some kind of weird genius. He is the man behind the legend that is Austin Powers and its sequel. Both are delightful, no-holds-barred comedic masterpieces, always reveling in their own outrageousness. With Mystery, Alaska, Roach tries to get accustomed to the limitations of a more conventional narrative and he doesn't always succeed. I'm not saying that he is incapable of making good "standard" movies, far from it, I'm sure that if given the right project he could very well extend his range. But here, working from a script by tv vet David E. Kelley, he wants to burst out. As a matter of fact, he finds some outlets to do just that, one of them being -- whe else? -- Mike Myers, having oodles of fun with an exaggerated Canadian dialect as a smarmy hockey commentator. There are times when you sense the Jay Roach from Austin Powers coming out of the woodwork, and those tend to be the high points. But for much of the movie he has to restrain himself, and with a script as average as this one it feels forced.
Nevertheless the film stays afloat. There is something about its pure, well-intentioned affection for hockey that won me over. If, to a sports movie, the game it's portraying is nothing more than a part of a formula, it will not work, which is why none of the three Mighty Ducks movies ever went anywhere. But when we feel a love for the sport, the oldest of formulas can seem almost as good as new.
Grade: B-
©1999 Eugene Novikov
Sent via Deja.com http://www.deja.com/ Before you buy.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Look: Nationals have already damaged World Series trophy while partying
by TSD StaffThe Nationals won their first World Series in franchise history, and the team has sure been enjoying the 24 hours since winning Game 7 in Houston.
Washington fought back from a 2-0 deficit in the seventh inning of Wednesday’s game, coming back to score seven runs off Houston’s bullpen. They became the first-ever team to win four consecutive road games in a playoff series, a feat that may never happen again.
And they’ve been partying hard to celebrate the big win — so much so that they apparently damaged the World Series trophy. Sean Doolittle posted a photo of the trophy, and it appears a few of the flags are bent, while others are missing.
We wonder how the beer tasted.


pymerkle.tree module¶
Provides the main class for Merkle-tree objects and related functionalites
-
class
pymerkle.tree.
merkleTreeEncoder
(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)[source]¶ Bases:
json.encoder.JSONEncoder
Used implicitly in the JSON serialization of Merkle-trees. Extends the built-in JSON encoder for data structures.
-
class
pymerkle.tree.
merkle_tree
(*records, hash_type='sha256', encoding='utf-8', security=True, log_dir='/home/beast/projects/pymerkle/docs/source')[source]¶ Bases:
object
Class for Merkle-trees
Parameters: - hash_type (str) – [optional] Defaults to
'sha256'
. Should be included inhashing.HASH_TYPES
(upper- or mixed-case with ‘-‘ instead of ‘_’ allowed), otherwise an exception is thrown. - encoding (str) – [optional] Defaults to
'utf_8'
. Should be included inhashing.ENCODINGS
(upper- or mixed-case with ‘-‘ instead of ‘_’ allowed), otherwise an exception is thrown. - security (bool) – [optional] If
False
, it deactivates defense against second-preimage attack ifFalse
. Defaults toTrue
. - *records (str or bytes or bytearray) – [optional] The records initially stored by the Merkle-tree; usually empty at construction. If If provided, the tree is constructed with as many leafs from the beginning, storing the hashes of the inserted records in the respective order.
- log_dir (str) – [optional] Absolute path of the directory, where the Merkle-tree will receive log files to encrypt from. Defaults to the current working directory if unspecified.
Variables: - uuid – (str) uuid of the Merkle-tree (time-based)
- hash_type – (str) Type of hashing algorithm used by the Merkle-tree
- encoding – (str) Encoding type used by the Merkle-tree for encryption
- security – (bool) Iff
True
, security measures against second-preimage attack are activated - hash – (method) Core hash functionality of the Merkle-tree
- multi_hash – (method) Hash functionality used by the Merkle-tree for performing inclusion tests (explicitly or implicitly upon a request for consistency proof)
- log_dir – (bool) See homonymous argument of the constructor
-
JSONstring
()[source]¶ Returns a nicely stringified version of the Merkle-tree’s JSON serialized form
Note
The output of this function is to be passed into the
print
functionReturn type: str
-
audit_path
(index)[source]¶ Computes and returns the body for the audit-proof based upon the requested index.
Body of an audit-proof consist of an audit-path (a sequence of signed hashes) and a proof-index (the position within the above sequence where the validation procedure should start from).
Parameters: index (int) – index of the leaf where the audit-proof calculation should be based upon (provided from Client’s Side directly or indirectly in form of a record; cf. the .audit_proof
method)Returns: a tuple of signed hashes (pairs of the form (+1/-1, bytes)), the sign +1
or-1
indicating pairing with the right or left neighbour during proof validation respectively, along with the starting point for application of hashing during proof validation.Return type: (int, tuple) Note
If the requested index is either negative or exceeds the tree’s current length (
IndexError
), then the nonsensical tuple(None, None)
is returned.
-
audit_proof
(arg)[source]¶ Response of the Merkle-tree to the request of providing an audit-proof based upon the given argument
Parameters: arg (str or bytes or bytearray or int) – the record (if type is str or bytes or bytearray) or index of leaf (if type is int) where the proof calculation must be based upon (provided from Client’s Side) Returns: audit-proof appropriately formatted along with its validation parameters (so that it can be passed in as the second argument to the validations.validate_proof
method)Return type: proof.proof Warning
Raises
TypeError
if the argument’s type is not as prescribed
-
consistency_path
(sublength)[source]¶ Computes and returns the body for any consistency-proof based upon the requested sublength.
Parameters: sublength (int) – length (number of leaves) for a presumably valid previous state of the Merkle-tree Returns: the starting point for application of hashing during proof validation, a tuple of hashes signed with -1
(leftmost hashes for inclusion test to be performed from the Server’s Side, i.e., by the Merkle-tree itself) and a tuple of signed hashes for top-hash test to be performed from the Client’s Side (the sign+1
, resp.-1
indicating pairing with the right or left neigbour respectively during proof validation)Return type: (int, tuple of (-1 bytes) pairs, tuple of (+1/-1 bytes) pairs) Note
Returns
None
forsublength
equal to0
-
consistency_proof
(oldhash, sublength)[source]¶ Response of the Merkle-tree to the request of providing a consistency-proof for the given parameters
Arguments of this function amount to a presumed previous state of the Merkle-tree (root-hash and length respectively) provided from Client’s Side
Parameters: - oldhash (bytes or None) – root-hash of a presumably valid previous state of the Merkle-tree
- sublength (int) – presumable length (number of leaves) for the above previous state of the Merkle-tree
Returns: Consistency proof appropriately formatted along with its validation parameters (so that it it can be passed in as the second argument to the
validations.validate_proof
method)Return type: Note
During proof generation, an inclusion-test is performed for the presumed previous state of the Merke-tree corresponding to the provided parameters (If that test fails, then the returned proof is predestined to be found invalid upon validation). This is done implicitly and not by calling the
.inclusion_test
method (whose implementation differs in that no full path of signed hashes, as generated here by the.consistency_path
method, needs be taken into account.)Note
Type of
oldhash
will beNone
iff the presumed previous state happens be the empty oneWarning
Raises
TypeError
if any of the arguments’ type is not as prescribed
-
display
(indent=3)[source]¶ Prints the Merkle-tree in a terminal friendy way
Printing the tree is similar to what is printed at console when running the
tree
command of Unix based platformsParameters: indent (int) – [optional] the horizontal depth at which each level will be indented with respect to its previous one. Defaults to 3
.Note
The left parent of each node is printed above the right one
-
encrypt_log
(log_file)[source]¶ Encrypts the data of the provided log-file into the Merkle-tree
More accurately, it successively updates the Merkle-tree it with each line of the log-file provided (cf. doc of the
.update
method)Parameters: log_file (str) – relative path of the log-file under enryption, specified with respect to the configured Merkle-tree’s directory log_dir
Note
Raises
FileNotFoundError
if the specified file does not exist
-
height
()[source]¶ Calculates and returns the Merkle-tree’s current height
Note
Since the tree is by construction binary balanced, its height coincides with the length of its leftmost branch
Return type: int
-
inclusion_test
(oldhash, sublength)[source]¶ Verifies that the parameters provided from Client’s Side correspond to a previous state of the Merkle-tree
Parameters: - oldhash (bytes) – root-hash of a presumably valid previous state of the Merkle-tree
- sublength (int) – presumable length (number of leaves) for the above previous state of the Merkle-tree
Returns: True
iff an appropriate path of negatively signed hashes, generated internally for the providedsublength
, leads indeed to the providedoldhash
Return type: bool
-
length
()[source]¶ Returns the Merkle-tree’s current length, i.e., the number of its leaves
Return type: int
-
minimal_complement
(subroots)[source]¶ Complements optimally the subroot hashes detected by
.principal_subroots
with all necessary interior hashes of the Merkle-tree, so that a full consistency-path can be generatedParameters: subroots (list of nodes.node) – Should be some output of the .principal_subroots
methodReturns: a list of signed hashes complementing optimally the hashes detected by .principal_subroots
, so that a full consistency-path be generatedReturn type: list of signed pairs (+1/-1, bytes)
-
principal_subroots
(sublength)[source]¶ Detects and returns in corresponding order the roots of the successive, rightmost, full binary subtrees of maximum (and thus decreasing) ength, whose lengths sum up to the inserted argument
Returned nodes are prepended with a sign (
+1
or-1
), carrying information used in consistency-proof generation after extracting hashesParameters: sublength – Should be a non-negative integer smaller than or equal to the Merkle-tree’s current length Returns: The (signed) roots of the detected subtrees, whose hashes are to be used for the generation of consistency-proofs Return type: list of (+1/-1, nodes.node) Note
Returns
None
if the providedsublength
does not fulfill the required condition
-
root_hash
()[source]¶ Returns the current root-hash of the Merkle-tree, i.e., the hash stored by its current root
Returns: the tree’s current root-hash Return type: bytes Note
Returns
None
if the Merkle-tree is currently empty
-
serialize
()[source]¶ Returns a JSON structure with the Merkle-trees’s current characteristics as key-value pairs
Return type: dict Note
This method does not serialize the tree structure itself, but only the info about the tree’s current state (size, length, height, root-hash) and fixed configs (hash type, encoding type, security mode, uuid)
-
subroot
(start, height)[source]¶ Returns the root of the unique full binary subtree of the Merkle-tree, whose leftmost leaf is located at the given position
start
and whose height is equal to the givenheight
Parameters: - start (int) – index of leaf where detection of subtree should start from
- height (int) – height of candidate subtree to be detected
Returns: root of the detected subtree
Return type: Note
Returns
None
if the requestedstart
is out of range
-
update
(record)[source]¶ Updates the Merkle-tree by storing the hash of the inserted record in a newly-created leaf, restructeres the tree appropriately and recalculates all necessary interior hashes
Parameters: record (str or bytes or bytearray) – the record whose hash is to be stored into a new leaf
- hash_type (str) – [optional] Defaults to