SkywayCC Class
SkywayCC is a implementation from Skyway to create a control center like use-case. Things to take note are:
- Skyway.init() is required to be called before connect()
- To disconnect users from the lobby or the room, call Skyway.leaveRoom() instead.
- If there's no lobbyRoom specified, 'MAIN' is the main lobby
- Check out the rest of the other functionalities in the Skyway documentation.
Constructor
SkywayCC
()
Example:
// Getting started on how to use Skyway // Note that init() is still required to be called as init() is to fetch // server connection information. var SkywayDemo = new SkywayCC(); SkywayDemo.init({ defaultRoom: 'default', apiKey: 'apiKey' });
Item Index
Methods
Events
Methods
_callStatusHandler
-
targetMid
-
message
-
isPrivate
Triggers:
peerCallRequestHandles all call status event changes
Parameters:
-
targetMid
StringPeerId of the peer that sent the call status message.
-
message
JSONThe message object.
-
data
JSON | StringThe data broadcasted.
-
mid
StringPeerId of the peer that sent the call status message.
-
cid
StringCredentialId for the room.
-
rid
StringRoomId of the room peer is connected to.
-
callStatus
StringIs the message a callStatus event.
-
type
StringThe type of the message.
-
-
isPrivate
BooleanIs the message a targeted message or not.
_handleCall
-
peerId
-
options
-
callback
Triggers:
peerCallRequestHandles all call states.
Parameters:
-
peerId
StringPeerId of the peer to send request to.
-
options
JSONPeer call status object.
-
status
JSONPeer call status [Rel: SkywayCC.CALL_STATUS]
-
peerType
BooleanPeer user type [Rel: SkywayCC.PEER_TYPE]
-
targetPeerId
StringPeerId of the peer the call request is directed to.
-
targetRoom
StringRoom that the peer requests to join.
-
-
callback
FunctionCallback function once call message is sent.
_inRoomHandler
-
message
Triggers:
peerJoinedWe just joined a room! Let's send a nice message to all to let them know I'm in.
Parameters:
-
message
JSON-
rid
StringRoomId of the connected room.
-
sid
StringPeerId of self.
-
mid
StringPeerId of the peer that is
-
pc_config
JSONThe peerconnection configuration sending the joinRoom message.
-
type
StringThe type of message received.
-
_privateMessageHandler
-
message
Triggers:
privateMessage, peerCallRequestThrow an event with the received private message
Parameters:
-
message
JSONThe message object.
-
data
JSON | StringThe data broadcasted.
-
mid
StringPeerId of the peer that sent the call status message.
-
cid
StringCredentialId for the room.
-
rid
StringRoomId of the room peer is connected to.
-
callStatus
StringIs the message a callStatus event.
-
type
StringThe type of the message.
-
_publicMessageHandler
-
message
Triggers:
publicMessage, peerCallRequestThrow an event with the received private message
Parameters:
-
message
JSONThe message object.
-
data
JSON | StringThe data broadcasted.
-
mid
StringPeerId of the peer that sent the call status message.
-
cid
StringCredentialId for the room.
-
rid
StringRoomId of the room peer is connected to.
-
callStatus
StringIs the message a callStatus event.
-
type
StringThe type of the message.
-
acceptRequestCall
-
agentPeerId
-
accept
Triggers:
peerCallRequestStep 2: Client to accept or reject the call.
Parameters:
-
agentPeerId
StringPeerId of the agent.
-
accept
BooleanIf client accepts agent request or not.
Example:
SkywayDemo.on('peerCallRequest', function (peerId, peerInfo, isSelf)) { if (!isSelf) { if (peerInfo.call.status === SkywayDemo.CALL_STATUS.REQUEST_CALL) { var result = confirm('Do you want to accept the call?'); SkywayDemo.acceptRequestCall(peerId, result); } } });
agentRequestCall
-
clientPeerId
-
room
Triggers:
peerCallRequestStep 1: Agent requests to start the call to client
Parameters:
-
clientPeerId
StringClient peerId to start call to.
-
room
StringRoom to ask client to join in
Example:
// Example 1: Request call SkywayDemo.agentRequestCall(peerId);
// Example 2: Request call with a specific room SkywayDemo.agentRequestCall(peerId, room);
connect
-
lobbyRoom
-
userData
-
peerType
Triggers:
peerJoinedConnect user to the main lobby.
- Please call this only after calling Skyway.init().
- To disconect from the lobby, please call Skyway.leaveRoom().
Parameters:
-
lobbyRoom
StringThe lobby all peers connect to before the call starts.
-
userData
JSON | StringThe user custom data.
-
peerType
StringDeprecated. The peer type [Rel: SkywayCC.PEER_TYPE]. This would be removed from the specs once agent and client is identified from the request url.
Example:
SkywayDemo.connect('main_lobby', { 'displayName': 'Agent Bob', 'timeStamp': (new Date()).toISOString, 'status': CALL_CENTER.EVENT.STARTING, 'UUID': 'XXX-XXX-XXXX' }, SkywayDemo.PEER_TYPE.AGENT);
startPeerEvent
-
userData
-
event
Triggers:
[customEvent]Trigger a event after updating userData.
Parameters:
-
userData
JSON | StringThe peer's updated user data to send over.
-
event
JSONThe event object. Event triggered will only be directed to self.
-
name
StringThe event to be trigged.
-
params
JSON | String | ArrayThe event params.
-
Example:
var userData = SkywayDemo.getUserData().userData; userData.status = 'newEvent'; SkywayDemo.startPeerEvent(userData, { name: 'newEvent', params: { 'startAdvert': true, 'UUID': 'XXXX-XXX-XXX' } }); SkywayDemo.on('newEvent', function (params) { // .... });
startRequestCall
-
room
-
callback
Triggers:
peerCallRequest, peerLeftStep 3: Start the call. You may call method
- "peerLeft" would be triggered because user left the lobby room
- Call Skyway.joinRoom() to start the call. Request a call for agent
Parameters:
-
room
StringRoom to ask client to join in
-
callback
FunctionCallback after the room is ready to join
Returns:
Peer information object
Example:
SkywayDemo.on('peerCallRequest', function (peerId, peerInfo, isSelf)) { if (!isSelf) { if (peerInfo.call.status === SkywayDemo.CALL_STATUS.START_CALL) { SkywayDemo.startRequestCall(peerId, function (userInfo, peerInfo) { SkywayDemo.joinRoom(peerInfo.call.targetRoom, { audio: true, video: true }); }); } } });
Attributes
_user
JSON
private
required
User object
Keys:
-
id
StringUser Session ID
-
peer
ObjectPeerConnection object
-
sid
StringUser Secret Session ID
-
apiOwner
StringOwner of the room
-
streams
ArrayArray of User's MediaStream
-
timestamp
StringUser's timestamp
-
token
StringUser access token
-
info
JSONOptional. User information
-
settings
JSONPeer stream settings
-
audio
Boolean | JSON -
audio.stereo
Boolean -
video
Boolean | JSON -
video.resolution
Bolean | JSON[Rel: SkywayCC.VIDEO_RESOLUTION] -
video.resolution.width
Integer -
video.resolution.height
Integer -
video.frameRate
Integer
-
-
mediaStatus
JSONPeer stream status.
-
audioMuted
BooleanIf Peer's Audio stream is muted. -
videoMuted
BooleanIf Peer's Video stream is muted.
-
-
userData
String | JSONPeer custom data
-
call
JSONPeer call status object.
-
status
IntegerThe current ready state of the user's call. [Rel: SkywayCC.CALL_READY_STATE] -
targetPeerId
StringPeerId the call to direct to. -
peerType
StringPeer type [Rel: SkywayCC.PEER_TYPE] -
targetRoom
StringThe targeted Room to join. Default is info.call.targetPeerId if not specified.
-
-
CALL_READY_STATE
JSON
readonly
The ready state of the peer's call if they are ready to join the room.
Keys:
-
LOBBY
IntegerStep 1. Peer is in lobby
-
REQUEST_CALL
IntegerStep 2. Agent requests to start the call
-
ACCEPTED_CALL
IntegerStep 3a. Client accepted the call
-
REJECTED_CALL
IntegerStep 3b. Client rejected the call.
-
START_CALL
IntegerStep 4. Agent and Client is ready to start the call.
-
UNKNOWN
Intger
Events
peerCallRequest
Event fired when a peer call request has changed.
Event Payload:
-
peerId
StringPeerId of the peer that has a call ready state changed.
-
peerInfo
JSONPeer information of the peer
-
settings
JSONPeer stream settings
-
audio
Boolean | JSON -
audio.stereo
Boolean -
video
Boolean | JSON -
video.resolution
JSON[Rel: Skyway.VIDEO_RESOLUTION] -
video.resolution.width
Integer -
video.resolution.height
Integer -
video.frameRate
Integer
-
-
mediaStatus
JSONPeer stream status.
-
audioMuted
BooleanIf Peer's audio stream is muted. -
videoMuted
BooleanIf Peer's video stream is muted.
-
-
userData
String | JSONPeer custom data
-
call
JSONPeer call status object.
-
status
IntegerPeer call status [Rel: SkywayCC.CALL_STATUS] -
peerType
StringPeer user type [Rel: SkywayCC.PEER_TYPE] -
targetPeerId
StringPeerId of the peer the call request is directed to. -
targetRoom
StringRoom that the peer requests to join.
-
-
-
isSelf
BooleanIs the peer self.


To view this content, you need to install Java from
java.com
Source code:
treesketch3b
Built with
Processing


Turning Off Composer Display
-
NobodySpecial
I hate, hate, hate that Synergy now shows the composer's name next to the artist's name. How can I turn it off?
-
Greg Hurrell
You can't, but I plan to add the option.
http://wincent.com/a/support/bugs/show_bug.cgi?id=177
I am going to close this topic. Please post any further comments against the bug report above so that all material related to this issue is in the one spot.
Reply
This topic is now closed.


BEVERLY HILLS COP III A film review by Michael John Legeros Copyright 1994 Michael John Legeros
Directed by John Landis Written by Steven E. de Souza, based on characters created by Danilo Bach and Daniel Petrie Jr. Cast: Eddie Murphy, Judge Reinhold Hector Elizondo, Theresa Randle, Bronson Pinchot, Timothy Carhart, John Saxon, and Alan Young (!) MPAA Rating "R" (presumably for language and violence) Running Time 103 minutes
==
Second sequels suck. No, not always, but they sure do disappoint. SUPERMAN III, GODFATHER III, ALIEN 3, LETHAL WEAPON 3, and, now, proudly, shamelessly, BEVERLY HILLS COP III.
Eddie Murphy is back as Axel Foley, that street-smart show-off who can't seem to shy from Bevery Hills. His target is the LA amusement park Wonder World and Foley is hot on the heels of a murderer he met in Detroit. Giving him grief are the FBI and the BHPD, neither of whom want Axel grease in their affairs.
Seven years have passed since our last visit to the COP shop; seven years of civil suits and bad press and all those things that have officially nixed the notion of the Maverick Cop. Can we *really* believe that enforcement agencies would even *dream* of condoning Axel's actions. Of course not.
As implausible as the premise plots, COP III works for a while. The pace is fast and the jokes are okay.
Not so.
Axel digs deeper into the ways and whys of Wonder World--courtesy of a few too many unlocked doors--and the plot holes grow and grow and grow until they swallow the film whole.
Are we to believe, courtesy of a counterfeit subplot, that Axel Foley can pull a digitized photo of himself out of thin air? Or that the "largest private police force in the country" doesn't have a soul on their staff who can shoot straight? Or that Axel and associates can kill person after person without even batting an 'brow?
I don't sink so.
The humor is sparse, but not absent. A cute bit bags four off-duty cartoon-characters playing poker under Wonder World. And there's a great scene where Murphy, dressed as an elephant (don't ask), pushes a mouthy moppet into a fountain.
For film fans, the director's trademark touches are few and far-between. If you *must* see the film, watch for a SWAT-team send-up, a soul-music shoot-out, and, as usual, cameos from a drove of directors including George Lucas, Joe Dante, John Singleton, and Barbet Schroeder.
Beyond Murphy's contractually efficient performance, Bronson Pinchot has two scenes as Serge, now selling arms instead of art. Judge Reinhold, back as Billy Rosewood, does a cute imitation of Jack Webb. And Hector Elizondo is agreeable as John Ashton's replacement Jon Flint, the obligatory family-man-character-with-nothing-else-to-do.
The surprise find is former "Mr. Ed" second-banana Alan Young, who plays Uncle Dave, designer and proprietor of Wonder World. Leave it Landis to inspire inspired casting.
LOOK: Watch for a minor reference to George Pal's THE TIME MACHINE, which also starred Young.
 Maybe the concept of an exciting second-sequel is an oxymoron.
Grade: D+
.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


| Home | Libraries | People | FAQ | More |
dll-path
and hardcode-dll-paths
properties useful? 为什么 dll-path
和 hardcode-dll-paths
是有用的？ This is not possible, since Jamfile does not have "current"
value of any feature, be it toolset, build variant or anything else.
For a single invocation of bjam
,
any given main target can be built with several property sets. For
example, user can request two build variants on the command line. Or
one library is built as shared when used from one application, and as
static when used from another. Obviously, Jamfile is read only once, so
generally, there's no single value of a feature you can access in
Jamfile.
这是不可能的，因为 Jamfile 的任何特性都不存在 "当前"
值，无论是工具集、构建变体或其它东西。对于 bjam
的一次调用，任何给定的主目标可以按多个属性集来构建。例如，用户可以在命令行请求两个构建变体。或者，一个库可以在用于某个应用时构建为共享的，而在用
于另一个应用时又构建为静态的。显然，Jamfile 只被读入一次，因此通常来说，对于你在 Jamfile 中可以访问的特性，没有单一的值。
A feature has a specific value only when building a target,
and there are two ways how you can use that value:
只有在构建一个目标时，特性才具有一个特定的值，你有两种方法可以使用这个值：
The most likely case is that you're trying to compile the
same file twice, with almost the same, but differing properties. For
example:
最有可能的情况是，你试图以几乎相同的属性两次编译同一个文件。例如：
exe a : a.cpp : <include>/usr/local/include ;
exe b : a.cpp ;
The above snippet requires two different compilations of
'a.cpp', which differ only in 'include' property. Since the 'include'
property is free, Boost.Build can't generate two objects files into
different directories. On the other hand, it's dangerous to compile the
file only once -- maybe you really want to compile with different
includes.
以上片断要求
'a.cpp' 的两次不同编译，区别只在于 'include' 属性。因为 'include'
属性是自由的，所以 Boost.Build 不能在不同目录下生成两个目标文件。另一方面，只编译一次又是危险的 -- 也许你真的是想以不同的包含文件来编译。
To solve this issue, you need to decide if file should be
compiled once or twice.
要解决这个问题，你需要决定该文件是要编译一次还是两次。
Two compile file only once, make sure that properties are
the same:
两个编译文件只编译一次，则要确保两个属性完全一样：
exe a : a.cpp : <include>/usr/local/include ;
exe b : a.cpp : <include>/usr/local/include ;
If changing the properties is not desirable, for example
if 'a' and 'b' target have other sources which need specific
properties, separate 'a.cpp' into it's own target:
如果你不是想修改属性，例如，如果 'a' 和 'b' 目标具有不同的源，需要特定的属性，那么可以将 'a.cpp' 独立到一个目标中：
obj a_obj : a.cpp : <include>/usr/local/include ;
exe a : a_obj ;
To compile file twice, you can make the object file local
to the main target:
要编译文件两次，那么你可以让目标文件局部于主目标：
exe a : [ obj a_obj : a.cpp ] : <include>/usr/local/include ;
exe b : [ obj a_obj : a.cpp ] ;
A good question is why Boost.Build can't use some of the
above approaches automatically. The problem is that such magic would
require additional implementation complexities and would only help in
half of the cases, while in other half we'd be silently doing the wrong
thing. It's simpler and safe to ask user to clarify his intention in
such cases.
一个好问题是，为什么 Boost.Build 不能自动使用以上某个方法。问题是，这样的方式需要更多的实现复杂性，而只对一半的情况有帮助，而在另一半情况下，我们还是会无声无息地做错事。在这种情况下，要求用户澄清意图更为简单和安全。
Many users would like to use environment variables in
Jamfiles, for example, to control location of external libraries. In
many cases you better declare those external libraries in the
site-config.jam file, as documented in the recipes section.
However, if the users already have the environment variables set up,
it's not convenient to ask them to set up site-config.jam files as
well, and using environment variables might be reasonable.
许多用户喜欢在
Jamfiles 中使用环境变量，例如，控制外部库的位置。在多数情况下，你最好在
site-config.jam 文件中声明这些外部库，正如 recipes 一节 中所说的。不过，如果用户已经设置了环境变量，再让他们设置 site-config.jam 文件就不够方便了，这时使用环境变量可能是合理的。
In Boost.Build V2, each Jamfile is a separate namespace, and
the variables defined in environment is imported into the global
namespace. Therefore, to access environment variable from Jamfile,
you'd need the following code:
在 Boost.Build V2 中，每个 Jamfile 都有一个独立的名字空间，而环境变量则被导入到全局名字空间。因此，要从 Jamfile 访问环境变量，你需要以下代码：
import os ;
local SOME_LIBRARY_PATH = [ os.environ SOME_LIBRARY_PATH ] ;
exe a : a.cpp : <include>$(SOME_LIBRARY_PATH) ;
For internal reasons, Boost.Build sorts all the properties
alphabetically. This means that if you write:
由于内部原因，Boost.Build 会按字母序对所有属性进行排序。这意味着如果你写了：
exe a : a.cpp : <include>b <include>a ;
then the command line with first mention the "a" include
directory, and then "b", even though they are specified in the opposite
order. In most cases, the user doesn't care. But sometimes the order of
includes, or other properties, is important. For example, if one uses
both the C++ Boost library and the "boost-sandbox" (libraries in
development), then include path for boost-sandbox must come first,
because some headers may override ones in C++ Boost. For such cases, a
special syntax is provided:
那
么在命令行中首先会出现 "a" 包含目录，然后才是
"b"，虽然它们是按相反的顺序指定的。在多数情况下，用户并不关心这一点。但是有时候包含目录的顺序，或者其它属性的顺序是很重要的。例如，如果你同时
使用了 C++ Boost 库和 "boost-sandbox" (正在开发的库)，那么 boost-sandbox
的包含路径必须先出现，因为有些头文件可能要覆盖 C++ Boost 的头文件。为此，提供了一个特殊的语法：
exe a : a.cpp : <include>a&&b ;
The &&
symbols separate values of an property, and specify that the order of
the values should be preserved. You are advised to use this feature
only when the order of properties really matters, and not as a
convenient shortcut. Using it everywhere might negatively affect
performance.
符号 &&
用于分隔一个属性的值，并指定这些值的顺序要被保留。建议你只在属性的顺序确实重要时才使用此特性，而不是把它作为一个方便的缩写来用。到外使用它可能会产生负面的性能影响。
On the Unix-like operating systems, the order in which static
libraries are specified when invoking the linker is important, because
by default, the linker uses one pass though the libraries list. Passing
the libraries in the incorrect order will lead to a link error.
Further, this behaviour is often used to make one library override
symbols from another. So, sometimes it's necessary to force specific
order of libraries.
在类Unix的操作系统上，在调用链接器时所指定的静态库的顺序是很重要的，因为缺省情况下，链接器只会扫一遍库列表。以错误的顺序传递库文件会导致链接错误。而且，这一行为通常被用于以一个库覆盖另一个库的符号。所以，有时候必须强迫指定库的顺序。
Boost.Build tries to automatically compute the right order.
The primary rule is that if library a "uses" library b, then library a
will appear on the command line before library b. Library a is
considered to use b is b is present either in the sources of a or in
its requirements. To explicitly specify the use relationship one can
use the <use> feature. For example, both of the following
lines will cause a to appear before b on the command line:
Boost.Build 会尝试自动计算正确的顺序。主要的规则是，如果 a 库"使用"了 b 库，则 a
库在命令行中应出现在 b 库之前。a 库使用 b 库是指，b 出现在 a 的源中，或者出现在它的要求中。要明确指定这种使用关系，你可以用 <use> 特性。例如，下面两行都会导致在命令行中 a 在 b 之前出现：
lib a : a.cpp b ;
lib a : a.cpp : <use>b ;
The same approach works for searched libraries, too:
相同的方法也适用于库的查找：
lib z ;
lib png : : <use>z ;
exe viewer : viewer png z ;
The SHELL
builtin can be used for the purpose:
内建的 SHELL
可用于此目的：
local gtk_includes = [ SHELL "gtk-config --cflags" ] ;
You might want to use your project's root location in your
Jamfiles. To access it just declare a path constant in your Jamroot.jam
file using:
你可能想在你的 Jamfiles 中使用你的工程的根的位置。要获得它，只需在你的 Jamroot.jam
中如下声明一个路径常量：
path-constant TOP : . ;
After that, the TOP
variable can be used in every Jamfile.
然后，变量 TOP
就可以在各个 Jamfile 中使用了。
If one file must be compiled with special options, you need to
explicitly declare an obj
target for that file and then use that target in your exe
or lib
target:
如果一个文件必须以特定的选项来编译，你就需要为该文件明确声明一个 obj
目标，然后在你的 exe
或 lib
目标中使用该目标：
exe a : a.cpp b ;
obj b : b.cpp : <optimization>off ;
Of course you can use other properties, for example to
specify specific compiler options:
当然你可以使用其它属性，如指定特定的编译选项：
exe a : a.cpp b ;
obj b : b.cpp : <cflags>-g ;
You can also use conditional properties
for finer control:
你还可以用 条件属性
来更好地控制：
exe a : a.cpp b ;
obj b : b.cpp : <variant>release:<optimization>off ;
| Note 说明 | |
|---|---|
|
This entry is specific to Unix systems. |
Before answering the questions, let us recall a few points about shared
libraries. Shared libraries can be used by several applications, or other
libraries, without physically including the library in the application which can
greatly decrease the total application size. It is also possible to upgrade a
shared library when the application is already installed.
在回答这个问题之前，我们来回顾一下共享库。共享库可以被多个应用程序或其它库使用，不需要把库文件物理地包含在应用程序中，这样可以大大减少应用程序的大小。同时也可以在应用程序安装后对共享库进行升级。
However, in order for application depending on shared libraries to be started
the OS may need to find the shared library when the application is started. The
dynamic linker will search in a system-defined list of paths, load the library
and resolve the symbols. Which means that you should either change the
system-defined list, given by the LD_LIBRARY_PATH
environment variable, or install the libraries to a system location. This
can be inconvenient when developing, since the libraries are not yet ready to be
installed, and cluttering system paths may be undesirable. Luckily, on Unix
there is another way.
不过，由于应用程序要依赖于共享库，所以在应用程序启动时，OS必须找到要用的共享库。动态链接器会在一个系统定义的路径列表中查找，装入库并解释符号。这意味着你要么就修改由 LD_LIBRARY_PATH
环境变量给出的系统定义的列表，要么就将库安装到某个系统库的位置。这在开发的时候会不太方便，因为这些库还没有准备好被安装，而且把系统路径搞乱也是不受欢迎的。幸好，在
Unix 上还有其它的办法。
An executable can include a list of additional library paths,
which will be searched before system paths. This is excellent for
development, because the build system knows the paths to all libraries
and can include them in executables. That's done when the hardcode-dll-paths
feature has the true
value, which is the default. When the executables should be installed,
the story is different.
可执行文件可以包含一个额外库路径的列表，它会在系统路径之前被搜索。这对于开发是很适用的，因为构建系统知道所有库的路径，可以把它们包含到可执行文件中。当 hardcode-dll-paths
特性具有 true
值时就会这么做，这是缺省的。当可执行文件要被安装时，情况就不一样了。
Obviously, installed executable should not hardcode paths to
your development tree. (The stage
rule explicitly disables the hardcode-dll-paths
feature for that reason.) However, you can use the dll-path
feature to add
explicit paths manually. For example:
显然，已安装的可执行文件不应当对你的开发树的路径进行硬编码。(为此，stage
规则明确禁止了 hardcode-dll-paths
特性)。但是，你可以用 dll-path
特性来手工地显式增加路径。例如：
stage installed : application : <dll-path>/usr/lib/snake
<location>/usr/bin ;
will allow the application to find libraries placed to /usr/lib/snake
.
将允许应用程序查找位于 /usr/lib/snake
的库。
If you install libraries to a nonstandard location and add an
explicit path, you get more control over libraries which will be used.
A library of the same name in a system location will not be
inadvertently used. If you install libraries to a system location and
do not add any paths, the system administrator will have more control.
Each library can be individually upgraded, and all applications will
use the new library.
如果你将库安装在一个非标准的位置，并增加一个明确的路径，你就对使用哪个库有了更多的控制。在系统位置中的同名库不会被不小心使用。如果你将库安装在系统的位置且没有增加任何路径，则系统管理员具有更多的控制。每个库可以独立地升级，所有应用程序都将使用新的库。
Which approach is best depends on your situation. If the
libraries are relatively standalone and can be used by third party
applications, they should be installed in the system location. If you
have lots of libraries which can be used only by your application, it
makes sense to install it to a nonstandard directory and add an
explicit path, like the example above shows. Please also note that
guidelines for different systems differ in this respect. The Debian
guidelines prohibit any additional search paths, and Solaris guidelines
suggest that they should always be used.
哪
种方法最好，取决于你的具体情况。如果库是相对独立的，可以被第三方应用程序所使用，则应该安装在系统的位置。如果你有大量的库只被你的应用程序使用，则
安装在一个非标准目录中并增加明确路径是合理的，如上例所示。另请注意，不同的系统在这方面有不同的准则。Debian
的准则是禁止任何额外的搜索路径，而 Solaris 的准则是建议应该总是使用它们。
It is desirable to declare standard libraries available on a
given system. Putting target declaration in Jamfile is not really good,
since locations of the libraries can vary. The solution is to declare
the targets in site-config.jam:
对一个给定系统声明可用的标准库是可取的。将目标声明放在 Jamfile 中不太好，因为库的位置会变化。解决的方法是，将在 site-config.jam 中声明这些目标：
project site-config ;
lib zlib : : <name>z ;
Recall that both site-config.jam
and user-config.jam
are projects, and everything you can do in a Jamfile you can do in
those files. So, you declare a project id and a target. Now, one can
write:
回想一下，site-config.jam
和 user-config.jam
都是工程，你在一个 Jamfile 中可以做的任何事情，都可以在这两个文件中做。所以你声明了一个工程 id 和一个目标。现在，你可以在任何一个 Jamfile 中这样写：
exe hello : hello.cpp /site-config//zlib ;
in any Jamfile.
In modern C++, libraries often consist of just header files,
without any source files to compile. To use such libraries, you need to
add proper includes and, maybe, defines, to your project. But with
large number of external libraries it becomes problematic to remember
which libraries are header only, and which are "real" ones. However,
with Boost.Build a header-only library can be declared as Boost.Build
target and all dependents can use such library without remebering if
it's header-only or not.
在
现代 C++
中，库通常只包含有头文件，而没有任何要编译的源文件。要使用这种库，你需要向你的工程加入适当的包含，也许还有定义。但是，由于存在大量的外部库，要记
住哪些库是只有头文件的，哪些库是"真实"的，是很困难的。不过，对于 Boost.Build，一个只有头文件的库可以被声明为
Boost.Build
目标，所有依赖于它的目标可以使用这个库而无须记住它是否只有头文件。
Header-only libraries are declared using the alias
rule, that
specifies only usage requirements, for example:
只有头文件的库可以用 alias
规则来声明，它只指明了使用要求，例如：
alias mylib
: # no sources
: # no build requirements
: # no default build
: <include>whatever
;
The includes specified in usage requirements of mylib
are automatically
added to build properties of all dependents. The dependents need not
care if mylib
is header-only or not, and it's possible to later make mylib
into a regular
compiled library.
在 mylib
的使用要求中所指定的包含关系会自动被增加到所有依赖于它的目标的构建属性中。依赖目标无需关心 mylib
是否只有头文件，稍后还可以将 mylib
变成一个普通的已编译的库。
If you already have proper usage requirements declared for
project where header-only library is defined, you don't need to
duplicate them for the alias
target:
如果你已经为定义了只有头文件的库的工程声明了适当的使用要求，那么你就不需要为 alias
目标重复它们：
project my : usage-requirements <include>whatever ;
alias mylib ;


-
Your room name is too short. At least four characters is required.
You successfully created room
Your username is too short. At least five characters is required.
Character sequence not allowed.
Spaces not allowed.
Your password is too short. At least six characters is required.
Wrong password
username already in use. Please choose another name.
Room already exists. Please create a room with another name


wtf_wikipedia.from_api() demo
supports cross-origin fetches from the client-side, and following of redirects.


In the following example, @someAnnotation()() is marked:
@someAnnotation()()
@someAnnotation()() object Test


Dimensions of Biodiversity
Code by Ben Weinstein
Stony Brook University
New York, USA
Aim: To compute and compare taxonomic, phylogenetic and trait betadiversity among all global grid cells for mammals.
Input Data
A cell by species matrix is needed for species distributions
A phylogeny with matching taxonomy to the species distributions
A trait matrix with matching taxonomy to the species distributions
Code
In general, these computations need to run on a supercomputing cluster.
The code below is formatted for the Stampede Supercomputing cluster at the University of Texas. All scripts and data inside the “cluster” folder were run in the stampede environment. See RunALL.sh for the job scheduler script.
uniqueSxpp.R
- This script finds the unique comparisons among all combinations of grid cells. It creates two files, a xytable with matching unique and original grid cells, adn the lat long coord of each cell. This data will be recombined at the end (see combinetable.R)
BetaSimBranches.R
- Courtesy of Ben Holt at Imperial College London. The idea is that calculating phylogenetic similairity among taxa is slow because the phylo objects are not matrices. We first convert the entire cell by branch structure into a single matrix, and then compute the betadiversity with the next script. This saves alot of time.
Beta.R
- The main workhourse function, which calls a series of source scripts from Input/BrazilSourceFunctions.R. The unique cell table is broken into pieces, based on the number of cores available, and each core computes the taxonomic, phylogenetic and trait betadiversity combinations on its own piece. The results are written with their unique code to beta_out.csv
Combinetable.R
- At this point we have all betadiveristy combinations, but we need to match them back to the original cells. We use the xytable created in the first script to merge the data.table structures.
AggregateMean.R
- We compute basic mean, var, and quantile statistic for each cell and return a file finaldata.csv to send to coauthors.


Something went wrong!
Our Engineers are on it.
Go Home
status
error
timestamp
path
message
exception


Some people have reported issues, so I've moved this page in an attempt to fix all issues. Don't want anything taking from requests!!. If you are not automatically redirected, please
click here
.


Don't Miss Out!
Products
SALE
£25.00
Add to Cart
SALE
£25.00
Add to Cart
SALE
£25.00
Add to Cart
SALE
£25.00
Add to Cart
SALE
£25.00
Add to Cart
SALE
£25.00
Add to Cart
SALE
£25.00
Add to Cart
SALE
£25.00
Add to Cart
SALE
£25.00
Add to Cart
SALE
£25.00
Add to Cart
SALE
£25.00
Add to Cart
SALE
£25.00
Add to Cart


THE GIRLS OF THE GARDEN CLUB
April 25-28,1991 at the Arabian Theatre
Director - Linda Walton
Assistant DIrector / Stage Manager - Suzanne Heflin
THE CAST
Rhoda - Pam Ward
Cora - Kathy Porter
Evie - Leah Friend
Dora - Charlotte Pitts
Dede - Teresa Kessler
Clara - Nelda Brewer
Lilllybelle - Kelly Bisnette
Bertie - Anne Maddox Sanders
Marigold - Partia Thompson
Dillson - Julian Malone
Vincent - Bo Asmar
The 'Other' Girls of the Garden Club
LaTricia Alvarez, Gina Bassett, Kaye Bolander, Sonya Dyess, Rae Ann Eggert,
Antha Estridge, Elaine B. Friend, Julie Harper, Maureen Ousley, Jeanelle Smith,
Dot Traweek


{% extends "admin/base.html" %}
{% block content %}
Team: {{ team.name }}
Challenge: {{ challenge.name }}
Description: {{ challenge.description }}
Challenge Info
| Category |
Value |
Solution |
Students Solved/{{ team.num_students() }} |
Points Earned From Challenge |
| {{ challenge.category }} |
{{ challenge.value }} |
{{ key }} |
{{ challenge.num_students_solve(team.id) }} |
{{ challenge.value * challenge.num_students_solve(team.id) }} |
Students Who Have Solved
| Name |
{% for student in students_solved %}
| {{ student.name }} |
{% endfor %}
Students Who Have Not Solved
| Name |
{% for student in students_unsolved %}
| {{ student.name }} |
{% endfor %}
{% endblock %}
{% block scripts %}
{% endblock %}


To be compliant, responsive and in control of personal data.
Propose personal data solutions tailored to your needs.
Implement privacy compliance and help fuel growth.
Guide employees on data privacy, compliance and security.
Manage privacy programs and mitigate potential incidents.


John Smith
StudyWithMe
My Group
Files
File 1
File 2
File 3
File 4
File 5
File 6
File 7
File 8
File 9
File 10
File 11
File 12
File 13
File 14
File 15
Chats
Chat 01
Lorem: lorem ipsum dolor sit amet asdfa sdfasdfasdfasdfasdfasdfasdf
Chat 02
Lorem: lorem ipsum dolor sit amet asdfa sdfasdfasdfasdfasdfasdfasdf
Chat 03
Lorem: lorem ipsum dolor sit amet asdfa sdfasdfasdfasdfasdfasdfasdf
Chat 04
Lorem: lorem ipsum dolor sit amet asdfa sdfasdfasdfasdfasdfasdfasdf
Chat 05
Lorem: lorem ipsum dolor sit amet asdfa sdfasdfasdfasdfasdfasdfasdf
+5 more channels
Flashcards
Set 01
Set 02
Set 03
Set 04
Set 05
Set 06
Set 07
Set 08
Set 09
Set 10
Set 11
Set 12
Set 13
Set 14
Set 15
Set 16
Set 17
Set 18
Set 19
Set 20
Home
Files
Chats
Flashcards
Lessons
Projects


I2CSlaveMSP432 Object. More...
#include <I2CSlaveMSP432.h>
Data Fields | |
| SemaphoreP_Handle | mutex |
| SemaphoreP_Handle | transferComplete |
| HwiP_Handle | hwiHandle |
| I2CSlave_CallbackFxn | transferCallbackFxn |
| const uint8_t * | writeBufferIdx |
| uint8_t * | readBufferIdx |
| size_t | countIdx |
| volatile I2CSlave_Mode | mode |
| I2CSlave_TransferMode | transferMode |
| bool | isOpen |
| bool | transferInProgress |
I2CSlaveMSP432 Object.
The application must not access any member variables of this structure!
| SemaphoreP_Handle I2CSlaveMSP432_Object::mutex |
| SemaphoreP_Handle I2CSlaveMSP432_Object::transferComplete |
| HwiP_Handle I2CSlaveMSP432_Object::hwiHandle |
| I2CSlave_CallbackFxn I2CSlaveMSP432_Object::transferCallbackFxn |
| const uint8_t* I2CSlaveMSP432_Object::writeBufferIdx |
| uint8_t* I2CSlaveMSP432_Object::readBufferIdx |
| size_t I2CSlaveMSP432_Object::countIdx |
| volatile I2CSlave_Mode I2CSlaveMSP432_Object::mode |
| I2CSlave_TransferMode I2CSlaveMSP432_Object::transferMode |
| bool I2CSlaveMSP432_Object::isOpen |
| bool I2CSlaveMSP432_Object::transferInProgress |


RGB2YCBCR(1) RGB2YCBCR(1) NAME rgb2ycbcr - convert non-YCbCr TIFF images to a YCbCr TIFF image SYNOPSIS rgb2ycbcr [ options ] src1.tif src2.tif ... dst.tif DESCRIPTION rgb2ycbcr converts RGB color, greyscale, or bi-level TIFF images to YCbCr images by transforming and sampling pixel data. If multiple files are specified on the command line each source file is converted to a separate directory in the destination file. By default, chrominance samples are created by sampling 2 by 2 blocks of luminance values; this can be changed with the -h and -v options. Output data are compressed with the PackBits compression scheme, by default; an alternate scheme can be selected with the -c option. By default, output data are compressed in strips with the number of rows in each strip selected so that the size of a strip is never more than 8 kilobytes; the -r option can be used to explicitly set the number of rows per strip. OPTIONS -c Specify a compression scheme to use when writing image data: -c none for no compression, -c packbits for the PackBits compression algorithm (the default), -c jpeg for the JPEG compression algo‐ rithm, -c zip for the deflate compression algorithm, and -c lzw for Lempel-Ziv & Welch. -h Set the horizontal sampling dimension to one of: 1, 2 (default), or 4. -r Write data with a specified number of rows per strip; by default the number of rows/strip is selected so that each strip is approx‐ imately 8 kilobytes. -v Set the vertical sampling dimension to one of: 1, 2 (default), or 4. SEE ALSO tiffinfo(1), tiffcp(1), libtiff(3) Libtiff library home page: http://www.remotesensing.org/libtiff libtiff November 2, 2005 RGB2YCBCR(1)


I am an assistant professor in the Department of Computer Science and Engineering, University of Connecticut (UConn). Before that, I was a research staff member at NEC Labs America in Princeton, NJ, since July 2016. In June 2016, I received my Ph.D. degree in the Department of Electrical and Computer Engineering from University of California San Diego (UCSD) with the guidance of Prof. David A. Meyer. My thesis committee includes Prof. Lawrence Saul, Prof. Nuno Vasconcelos, Prof. Gert Lanckriet, and Prof. Julian McAuley. I also work closely with Prof. Dacheng Tao from the University of Sydney.
I have broad research interests in machine learning, data mining, deep learning, federated learning, and related applications for time series representation, similarity search, prediction/forecasting, and anomaly detection (with data from IoT devices, healthcare, smart city, environmental science, etc.). I am also interested in graph representation learning with applications to link prediction, node classification, recommendation, dynamic systems, etc.
Recruiting: Looking for Ph.D. students to jointly work with Prof. Bing Wang at UCONN CSE! If you are interested in working on machine learning/deep learning/reinforcement learning/federated learning, please send me an email with your CV and transcript.
| News | |
|---|---|
Feb 2023 |
One paper is accepted to Annual Conference on Information Sciences and System (CISS) 2023, Congratulations to Yushan! |
Jan 2023 |
Two papers are accepted to ICLR 2023! Congratulations to Chang, Yang, and all collaborators! |
Dec 2022 |
Our tutorial proposal about “Continual Graph Learning” is accepted to WWW 2023! Congratulations to Xikun, Yushan, and Zijie! |
Dec 2022 |
I am invited to serve as an Associate Editor for Neurocomputing journal (IF=5.719)! |
Dec 2022 |
I will serve as a Senior PC for IJCAI 2023! |
Nov 2022 |
I am invited to give a talk about “Continual Graph Learning” at the CS department of University of Central Florida on November 17th, 2022! |
Nov 2022 |
Our tutorial proposal about “Continual Graph Learning” is accepted to SDM 2023! Congratulations to Xikun, Yushan, and Zijie! |
Nov 2022 |
One paper is accepted to Smart Health and another paper gets accepted to Computational and Structural Biotechnology Journal! Congratulations to all collaborators! |
Oct 2022 |
One paper is accepted to IEEE International Conference on Big Data! Congratulations to Wei and all co-authors! |
Oct 2022 |
I am invited to give a talk about “Harnessing Deep Neural Networks forMultivariate Time Series Analysis” at the CS department of University of Georgia on Oct 28th, 2022! Link |
Oct 2022 |
I am honored to received another Gift Fund from NEC Labs America (NECLA) as Sole PI! Thanks for the support, NECLA! |
Sep 2022 |
Two papers are accepted to NeurIPS 2022 (one to the main track and one to the dataset and benchmark track)! Congratulations to Yang, Xikun, and all collaborators! |
Sep 2022 |
One paper about Continual Graph Learning (CGL) is accepted to ICDM 2022! Congratulations to Xikun! |
| More News… |
Ph.D. in ECE, 2016
University of California, San Diego (UCSD)
MPhil, 2010
The Hong Kong Polytechnic University
B.Eng, 2007
University of Science and Technology of China (USTC)
* denotes the student/intern I supervised/mentored.
Discover full publication list.


VISUALIZE Python, Java, JavaScript, TypeScript, Ruby, C, and C++Python Tutor, created by Philip Guo (@pgbovine), helps people overcome a fundamental barrier to learning programming: understanding what happens as the computer runs each line of source code. Using this tool, you can write Python 2, Python 3, Java, JavaScript, TypeScript, Ruby, C, and C++ code in your web browser and visualize what the computer is doing step-by-step as it executes. Over 3.5 million people in over 180 countries have used Python Tutor to visualize over 50 million pieces of code, often as a supplement to textbooks, lectures, and online tutorials. Here's a live example: Read the research paper – Philip J. Guo. Online Python Tutor: Embeddable Web-Based Program Visualization for CS Education. SIGCSE 2013. |
GET LIVE HELPClick the “Get live help!” button to allow anyone on the website to join your session, or start a private chat. Using this feature, you can chat about your code and navigate visualizations together to receive real-time tutoring. Watch this short video demo: You can also click the “Generate permanent link” button (at the bottom of this page) and paste that link in an email, social networking post, or forum question. When recipients click on your link, they will see the exact visualization you've created. For example, clicking this link brings you directly to step 44 of 57 in a program that finds prime numbers using the for-else construct. Read the paper – Philip J. Guo, Jeffery White, Renan Zanelatto. Codechella: Multi-User Program Visualizations for Real-Time Tutoring and Collaborative Learning. VL/HCC 2015. |
Details:
|


NOTE:
Do this on the trainer for the best results.
Do not eat anything heavy 2 hours before this test. You may eat a gel or sports drink 15 minutes prior to starting. This
is a good idea especially if you are doing this test first thing in the morning.
Do not do a hard workout the day before or after this test. Make sure you are well rested.
Take note of how you were feeling before, during and after the notes. Make a note of that in the post-activity comments.
WARM UP
- 15 minutes easy spin
- 3 x 30 second sprints, with 30 second easy spin between
- 2 minutes steady spin
MAIN
20 minute TT -
- work at the best sustainable effort you can maintain for this time period.
- Be sure to hit the lap button when you start and end this test. We will want the average and max HR and power information
from this segment. And, if you have power, we will want the average and max power info.
- work on maintaining effort throughout this test.
- It will be hard. Stick with it as best as you can.
- Cadence is ideally 85-95 rpm.
COOL Down
10-15 minutes easy, easy spin to clear out the lactic acid
Enter the average power and average heart rate below:


A Deep Learning based Stock Predictor which takes into account a company's past one year stock prices as well as public perception about the company on social media to predict their coming stock prices.
Team Members
Ravi Vats | Atif Adib | Shishira Maiya | Elson DSouza | Amogh Mannekote


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import models.TolerantAddress @import utils.countryOptions.CountryOptions @(fieldName: String, address: TolerantAddress, countryOptions: CountryOptions)
@if(address.addressLine1.isDefined) { @address.addressLine1 } @if(address.addressLine2.isDefined) { @address.addressLine2 } @if(address.addressLine3.isDefined) { @address.addressLine3 } @if(address.addressLine4.isDefined) { @address.addressLine4 } @if(address.postcode.isDefined) { @address.postcode } @if(address.countryOpt.isDefined) { @countryOptions.getCountryNameFromCode(address) }


Tabs are used to show similar content within the same view. The focused tab is done by setting [data-selected=*]
to "true"
class.
| Item | Applied to | Description |
|---|---|---|
aria-controls="[id]" |
tab | Identifies the tabpanel the tab controls. (Source) |
aria-hidden="[state]" |
tabpanel | Indicates to screen readers if a tabpanel should be visible. (Source) |
aria-labelledby="[id]" |
tabpanel | Indicates which tab controls the tabpanel. (Source) |
aria-orientation="[dir]" |
tabgroup | Indicates if the tabgroup is oriented horizontally or vertically. (Source) |
aria-selected="[state]" |
tab | Identifies if the tab is currently selected within the tabgroup. Only one tab can be set to true at a time. (Source) |
role="tab" |
tabgroup | To help with screen readers, applied to each tab item. (Source) |
role="tablist" |
tabgroup | To help with screen readers, declare the wrapping tab container for the tabs. (Source) |
role="tabpanel" |
tabpanel | To help with screen readers, applied to each tab content panel. (Source) |
Tabs should:
Tabs should:


Android Asset Studio
Icon generators — Make icons for your app
Icon generators allow you to quickly and easily generate icons from existing source images, clipart, or text.
- This page doesn't frikin refresh wtf Launcher icons
- Action bar and tab icons
- Notification icons
- Generic icons
Other generators — Miscellaneous asset creation tools
Community tools — Similar tools from the open source community
- Android Action Bar Style Generator by Jeff Gilfelt
- Android Holo Colors Generator by Jérôme Van Der Linden


Quick Tip - Easily View your Logic by Editing Calcs in Notepad++
After Tableau Desktop the next most commonly used application on my computer is probably Notepad++. I use Notepad++ to take notes, edit HTML and XML files and to have a larger screen to review the logic from Tableau Calculated fields. I often get asked to help figure out why a calculated field is not producing the desired result. Sometimes, it's not feasible to review multi-line logic in Tableau, so I leverage Notepad++ for a larger window and some additional help.
I love how the tool has built in language support for common file types, to highlight different operators, keywords and more - it makes it incredibly easy to know when I've forgotten to close a tag in HTML. With a quick XML import you can make the tool reflect Tableau's display of calculated fields.
Notepad++ allows for User Defined Languages, and I've gone through and created a user defined language for Tableau Calculation logic. When the language is selected, it highlights the different functions, comments, LOD keywords and more as they would appear in the calculation window in Tableau Desktop (with the exception of Parameters). If you use Notepad++ either to write or review calculated fields, follow the steps below to import the XML file to leverage the custom language.
- First, download the XML file from here. Save the file to your desktop, or somewhere that is easy to navigate to. This file contains the info to specify the delimiters, key words, operators, etc.
- In Notepad++, go to the 'Language' menu, and click on 'Define your language...' at the bottom of the menu.
- Click the 'Import...' button on the dialog box that pops up.
- Browse for the XML file you downloaded a minute ago, then click 'Open' and 'Ok' on the dialog box that tells you your import was successful.
- Close the 'User Defined Language' dialog box by clicking the red X in the top right corner.
- Go to the 'Language' menu again in Notepad++, and 'Tableau Calcs' should now appear at the bottom of the menu. Note that if it does not, restarting Notepad++ should refresh the languages.
Now, while you edit calculations in Notepad++, the formatting will mimic Tableau Desktop. Check out the video below, and reach out if you have any questions! If you make any modifications or improvements, I'd love to hear them!
Some bonus content - to export the formatting to rich text format for use in emails or the Tableau forum, you can download the NPPExport plugin from here on GitHub. Check out this video for the export in action! Huge thanks to Ken Flerlage for pushing me to take this farther.


introduction-to-major-changes.Rmd
tidyLPA has received a major update. Your old function calls might not work as expected anymore. The new version of tidyLPA aims to make Latent Profile Analysis (LPA) even more accessible to a broad audience, by means of a user-friendly interface, and to fit more seamlessly into a ‘tidyverse’ workflow.
As before, tidyLPA offers a parallel workflow for the open-source package Mclust, and the commercial package Mplus.
These changes necessitated some simplification of the existing functions. Advanced options are still available, but require slightly more work on the user’s part. The upside of this is that, for most users, the tidyLPA workflow and documentation are substantially simplified.
There have been major changes to the two primary functions, estimate_profiles()
and compare_solutions()
estimate_profiles()
now estimates any number of profiles, for any number of models, using any algorithm. It has a simplified user interface. This makes it a more general function, of which the former version (which could only estimate one number of profiles for one model) is a special, restricted case.
compare_solutions()
now compares solutions estimated by estimate_profiles(), suggesting the optimal model and number of classes. This replaces its dual role of estimating AND comparing solutions. *
compare_solutions()gives you the same set of fit indices for Mclust and Mplus. It provides a broader range of fit indices than before *
compare_solutions()calls
AHP()``, a function which uses the Automatic Hierarchical Process to determine the optimal number of classes, based on several reputable fit indices
plot_profiles()
now incorporates best practices for plotting latent profile analyses: Visualizing cluster centroids, standard errors, cluster variances, and classification uncertainty by means of weighted raw data
impute_missing()
offers two easy-to-use single imputation options, for use with the Mclust package (which does not natively handle missing data). Mplus handles partially missing data by default.
The best way to understand these changes to tidyLPA, though, is by explaining the new workflow.
A full analysis might look like the following:
## tidyLPA is intended for academic use. We do not make any money on this and only ask that you please cite this in publications when you use the results. You can use the function citation('tidyLPA') to create a citation.Mplus is not installed. Use only package = 'mclust' when calling estimate_profiles().
##
## Attaching package: 'dplyr'
## The following objects are masked from 'package:stats':
##
## filter, lag
## The following objects are masked from 'package:base':
##
## intersect, setdiff, setequal, union
pisaUSA15[1:100, ] %>%
select(broad_interest, enjoyment, self_efficacy) %>%
single_imputation() %>%
estimate_profiles(3)
## tidyLPA analysis using mclust:
##
## Model Classes AIC BIC Entropy prob_min prob_max n_min n_max BLRT_p
## 1 3 637.97 674.45 0.82 0.86 0.95 0.05 0.66 0.01
You can use Mplus simply by changing the package argument for estimate_profiles()
:
pisaUSA15[1:100, ] %>%
select(broad_interest, enjoyment, self_efficacy) %>%
single_imputation() %>%
estimate_profiles(3, package = "MplusAutomation")
A simple summary of the analysis is printed to the console (and its posterior probability). The resulting object can be further passed down a pipeline to other functions, such as plot
, compare_solutions
, get_data
, get_fit
, etc. This is the “tidy” part, in that the function can be embedded in a tidy analysis pipeline.
If you have Mplus installed, you can call the version of this function that uses MPlus in the same way, by adding the argument package = "MplusAutomation
.
We can plot the profiles by piping the output to plot_profiles()
.
The function compare_solutions()
compares the fit of several estimated models, with varying numbers of profiles and model specifications:
compare_solutions()
no longer estimates profiles. It merely compares solutions estimated by estimate_profiles()
all Mplus-specific functions are deprecated. estimate_profiles()
offers a unified interface to Mclust and Mplus. These Mplus-specific functions are deprecated:
estimate_profiles_mplus()
compare_profiles_mplus()
plot_profiles_mplus()
estimate_profiles and compare_solutions no longer select variables, passed as unquoted variable names, from ‘df’. Instead, they use all variables in df. To select variables prior to analysis, use:
estimate_profiles and compare_solutions no longer center and scale the raw data. To center and scale variables prior to analysis, use scale(df, center = TRUE, scale = TRUE)
estimate_profiles no longer accepts arguments specific to Mplus or Mclust. Instead, you can specify additional arguments directly to the core functions mplusModeler()
and Mclust()
. See the help file for these functions for more details. Deprecated arguments, whose functionality is supplanted by passing arguments directly to these core functions, are:
For Mclust:
* prior_control
For Mplus:
* starts
* m_iterations
* st_iterations
* convergence_criterion
* optseed
* cluster_ID
* include_VLMR
* include_BLRT (but BLRT is returned by default now)


Ra-Beat is a rhythmic VR game where you control your familiar (Ra) through drum beats and defeat monsters. In this magical world, everything is controlled by the God of Metronome. Being a mythical rabbit, Ra only understands your command through drum beats and only when they follow the beats. You are now thrown into the mission to defeat monsters and there is just one rule to survive in this world: Follow the beats, not the rhythm!
Trivia: Ra-beat is actually the word play of Rabbit due to the uncanny resemblance of Ra, our main avatar looks to a rabbit.
My role was Sound & Effects Artist, Project Manager, Marketing. I created original sound tracks for the game using LMMS. This project was done in a group of 4 members, as part of CS4350 Game Development Project.
We won the Honourable Mention Award at the 13th STePS (NUS School of Computing Term Project Showcase)!
Unity3D | HTC VIve | LMMS


Actor and comedian Sacha Baron Cohen had harsh words for the country’s biggest tech companies while accepting the International Leadership Award from the Anti-Defamation League on Thursday.
Cohen criticised online platforms like Facebook, Twitter, and Google for generating “the greatest propaganda machine in history,” and giving violent extremists a platform to reach billions of people.
Cohen called Facebook CEO Mark Zuckerberg‘s stance on free speech “ludicrous,” referring to Facebook’s unwillingness to remove political ads and other social media posts that contain intentional lies and misinformation.
“Freedom of speech is not freedom of reach,” Cohen said during the 25-minute speech aimed at some of the world’s most powerful tech companies. You can watch Cohen’s full acceptance speech below, and read our complete breakdown for more context.


public class ClientInstance
extends java.lang.Object
This class defines a Client Instance that can
There are two threads in a ClientInstance:
ClientInstance.IncomingHandler
handles incoming messagesClientInstance.OutgoingHandler
handles outgoing messages| Modifier and Type | Class and Description |
|---|---|
private static class |
ClientInstance.IncomingHandler
IncomingHandler handles receiving and printing out messages from others.
|
private static class |
ClientInstance.OutgoingHandler
OutgoingHandler handles sending message to the server.
|
| Modifier and Type | Field and Description |
|---|---|
private static java.io.BufferedReader |
br
The BufferedReader for incoming streams.
|
private static int |
CODE
The code used in the encryption and decryption of messages.
|
private static boolean |
finished
Whether the client has finished the chat.
|
private static java.util.Scanner |
kb
The Scanner used to read input from user.
|
private static java.lang.String |
KICKED_OUT
A signal indicating that the client has been kicked out of the chat room
by Administrator.
|
private static boolean |
kickedOut
Whether the client is kicked out of the chat room by Administrator.
|
private static java.lang.String |
name
The user name.
|
private static java.lang.String |
NAME_CHECKED
A signal indicating that the user name entered the user has been
validated by the server.
|
private static boolean |
nameValidated
Whether the name has been validated by the server.
|
private static java.io.PrintWriter |
pw
The PrintWriter for outgoing streams.
|
private static java.lang.String |
SEPARATOR
A separator.
|
private static java.net.Socket |
socket
The socket used to connect to the server.
|
| Constructor and Description |
|---|
ClientInstance(java.lang.String serverIP,
int port)
Creates a new instance of ClientInstance.
|
| Modifier and Type | Method and Description |
|---|---|
private static void |
close()
Cuts off the connection with server, close the streams and program exits.
|
private static java.lang.String |
encode(java.lang.String str)
Uses XOR Cipher to encode or decode a message.
|
private static java.net.Socket socket
private static java.lang.String name
private static java.io.BufferedReader br
private static java.io.PrintWriter pw
private static final int CODE
private static final java.lang.String NAME_CHECKED
private static final java.lang.String KICKED_OUT
private static volatile boolean nameValidated
private static volatile boolean finished
private static volatile boolean kickedOut
private static java.util.Scanner kb
private static final java.lang.String SEPARATOR
public ClientInstance(java.lang.String serverIP, int port)
Creates a new instance of ClientInstance.
A ClientInstance has two threads:ClientInstance.IncomingHandler
handles receiving messages.ClientInstance.OutgoingHandler
handles sending messagesserverIP
- the IP Address of the serverport
- the port number of the serverprivate static void close()
Cuts off the connection with server, close the streams and program exits.
close()
will be called in three cases:
Reasons for why the Client program is going to exit will be printed out.
private static java.lang.String encode(java.lang.String str)
Uses XOR Cipher to encode or decode a message.
Since x ^ y ^ y = x (^ is XOR operation), XOR can be used as a cipher.When sending or receiving a message from each other, Server and Client will encode or decode it first to make sure that even if some people can get the message in some illegal ways, the message will just be some messy codes to them because of the lack of key to decode them.
Since that for XOR Cipher, the process of encryption and decryption are
exactly the same, we simply use encode(String)
for both encoding
and decoding.
str
- the original message in encryption or the encoded message in
decryption.


--- layout: page title: Past General Meetings permalink: /events/generalmeetings published: true ---
Can't make a general meeting?
Totally spaced and couldn't make it?
That's alright; we've got you covered. Check out the recordings of the past general meetings here!
{% for pastMeeting in site.data.pastGeneralMeetings %}


Angular Material's stepper provides a wizard-like workflow by dividing content into logical steps.
Material stepper builds on the foundation of the CDK stepper that is responsible for the logic that drives a stepped workflow. Material stepper extends the CDK stepper and has Material Design styling.
There are two stepper variants: horizontal
and vertical
. You can switch between the two using
the orientation
attribute.
If a step's label is only text, then the label
attribute can be used.
For more complex labels, add a template with the matStepLabel
directive inside the
mat-step
.
For a horizontal mat-stepper
it's possible to define the position of the label. end
is the
default value, while bottom
will place it under the step icon instead of at its side.
This behaviour is controlled by labelPosition
property.
If you're using a horizontal stepper, you can control where the stepper's content is positioned
using the headerPosition
input. By default it's on top of the content, but it can also be placed
under it.
There are two button directives to support navigation between different steps:
matStepperPrevious
and matStepperNext
.
The linear
attribute can be set on mat-stepper
to create a linear stepper that requires the
user to complete previous steps before proceeding to following steps. For each mat-step
, the
stepControl
attribute can be set to the top level AbstractControl
that is used to check the
validity of the step.
There are two possible approaches. One is using a single form for stepper, and the other is using a different form for each step.
Alternatively, if you don't want to use the Angular forms, you can pass in the completed
property
to each of the steps which won't allow the user to continue until it becomes true
. Note that if
both completed
and stepControl
are set, the stepControl
will take precedence.
When using a single form for the stepper, matStepperPrevious
and matStepperNext
have to be
set to type="button"
in order to prevent submission of the form before all steps
are completed.
<form [formGroup]="formGroup">
<mat-stepper formArrayName="formArray" linear>
<mat-step formGroupName="0" [stepControl]="formArray.get([0])">
...

<button mat-button matStepperNext type="button">Next</button>

</mat-step>
<mat-step formGroupName="1" [stepControl]="formArray.get([1])">
...

<button mat-button matStepperPrevious type="button">Back</button>
<button mat-button matStepperNext type="button">Next</button>

</mat-step>
...
</mat-stepper>
</form>
<mat-stepper orientation="vertical" linear>
<mat-step [stepControl]="formGroup1">
<form [formGroup]="formGroup1">
...
</form>
</mat-step>
<mat-step [stepControl]="formGroup2">
<form [formGroup]="formGroup2">
...
</form>
</mat-step>
</mat-stepper>
If completion of a step in linear stepper is not required, then the optional
attribute can be set
on mat-step
.
By default, steps are editable, which means users can return to previously completed steps and
edit their responses. editable="false"
can be set on mat-step
to change the default.
By default, the completed
attribute of a step returns true
if the step is valid (in case of
linear stepper) and the user has interacted with the step. The user, however, can also override
this default completed
behavior by setting the completed
attribute as needed.
By default, the step headers will use the create
and done
icons from the Material design icon
set via <mat-icon>
elements. If you want to provide a different set of icons, you can do so
by placing a matStepperIcon
for each of the icons that you want to override. The index
,
active
, and optional
values of the individual steps are available through template variables:
Note that you aren't limited to using the mat-icon
component when providing custom icons.
You can control the duration of the stepper's animation using the animationDuration
input. If you
want to disable the animation completely, you can do so by setting the properties to 0ms
.
You can set the state of a step to whatever you want. The given state by default maps to an icon. However, it can be overridden the same way as mentioned above.
In order to use the custom step states, you must add the displayDefaultIndicatorType
option to
the global default stepper options which can be specified by providing a value for
STEPPER_GLOBAL_OPTIONS
in your application's root module.
@NgModule({
providers: [
{
provide: STEPPER_GLOBAL_OPTIONS,
useValue: { displayDefaultIndicatorType: false }
}
]
})
If you want to show an error when the user moved past a step that hasn't been filled out correctly,
you can set the error message through the errorMessage
input and configure the stepper to show
errors via the showError
option in the STEPPER_GLOBAL_OPTIONS
injection token. Note that since
linear
steppers prevent a user from advancing past an invalid step to begin with, this setting
will not affect steppers marked as linear
.
@NgModule({
providers: [
{
provide: STEPPER_GLOBAL_OPTIONS,
useValue: { showError: true }
}
]
})
By default, the stepper will render all of it's content when it's initialized. If you have some
content that you want to defer until the particular step is opened, you can put it inside
an ng-template
with the matStepContent
attribute.
If your app supports a wide variety of screens and a stepper's layout doesn't fit a particular
screen size, you can control its orientation
dynamically to change the layout based on the
viewport.
| Keyboard shortcut | Action |
|---|---|
| Left Arrow | Focus the previous step header. |
| Right Arrow | Focus the next step header. |
| Enter | Select the focused step. |
| Space | Select the focused step. |
Labels used by the stepper are provided through MatStepperIntl
. Localization of these messages
can be done by providing a subclass with translated values in your application root module.
@NgModule({
imports: [MatStepperModule],
providers: [
{provide: MatStepperIntl, useClass: MyIntl},
],
})
export class MyApp {}
The stepper is treated as a tabbed view for accessibility purposes, so it is given
role="tablist"
by default. The header of step that can be clicked to select the step
is given role="tab"
, and the content that can be expanded upon selection is given
role="tabpanel"
. aria-selected
attribute of step header is automatically set based on
step selection change.
The stepper and each step should be given a meaningful label via aria-label
or aria-labelledby
.
Prefer vertical steppers when building for small screen sizes, as horizontal steppers typically take up significantly more horizontal space thus introduce horizontal scrolling. Applications with multiple scrolling dimensions make content harder to consume for some users. See the Responsive Stepper section above for an example on building a stepper that adjusts its layout based on viewport size.
Steppers often contain forms and form controls. If validation errors inside of a
stepper's form prevents moving to another step, make sure that your form
controls communicate error messages to assistive technology. This helps the user
know why they can't advance to another step. You can accomplish this by using
<mat-error>
with <mat-form-field>
, or by using an ARIA live region.
When a step contains a forms validation error, MatStepper
will display the
error in the step's header if specified. See the Error State section
for an example of a stepper with an error message. For non-linear steppers, you
should use an ARIA live region to announce error messages when users navigate
away from a step with an error message.


| GEOS SDK TechDocs
|
| 3 Basic View Attributes
| 3.2 Dimensional Attributes
GVI_attrs, MSG_GEN_VIEW_SET_ATTRS, MSG_GEN_VIEW_GET_ATTRS
The
GVI_attrs
field, as shown in GenView Instance Data
, controls many aspects of the view, including several features related to scrolling, input events, and the content object. It is implemented as a bitfield record, and any or all of its attributes may be set at once.
Generally, the attributes specified in this field are not changed at run-time; if your application needs to change or retrieve them, however, it may with the messages
MSG_GEN_VIEW_GET_ATTRS
and
MSG_GEN_VIEW_SET_ATTRS
, both of which are shown below.
The attributes that can be set in
GVI_attrs
are shown in the listing below. The default settings are given in GenView Instance Data
.
-
GVA_CONTROLLED
-
Set if the GenView is connected to a GenViewControl object and should therefore send out notification as appropriate and add itself to the proper GCN lists.
-
GVA_GENERIC_CONTENTS
-
Set if the content is a
GenContentClass
object. If this bit is set, the mouse grab mode and pointer sending mode are set by the specific UI, overriding whatever is set in the instance data.
-
GVA_TRACK_SCROLLING
-
Set if track scrolling is desired. If this is set, the view will send scrolling events to the content object. The content can then alter the scrolling behavior and send the event on to the view.
-
GVA_DRAG_SCROLLING
-
Set if drag scrolling is desired. If this bit is set, drag scrolling (when the user drags outside the window bounds, the window scrolls in that direction) is implemented by the view. The content does not have to do anything special; drag scrolling is implemented entirely by the view.
-
GVA_NO_WIN_FRAME
-
Set if no frame around the subview window is desired. This is set only if the view is meant to be a display view with its borders obscured (e.g. a text display that has no frame).
-
GVA_SAME_COLOR_AS_PARENT_WIN
-
Set if the background color of the view should be whatever color the parent window's background is. This is used in nearly every case where GVA_GENERIC_CONTENTS is also set.
-
GVA_VIEW_FOLLOWS_CONTENT_GEOMETRY
-
Set if the view should follow the size of the content in all non-scrollable dimensions. This can only be used if the view and the content are running in the same thread and if the content is not the process object.
-
GVA_WINDOW_COORDINATE_MOUSE_EVENTS
-
Set if mouse coordinates passed to the content are in window coordinates (relative to the window's origin) rather than document coordinates. If the document bounds are set outside the 16-bit boundaries of the standard graphics system, then this bit
must
be set. For full information on mouse event handling, see the Input chapter.
GVA_DONT_SEND_PTR_EVENTS
Set if pointer events should not be sent to the GenView's content. Use this for optimization if pointer events do not need to be sent through the view.
-
GVA_DONT_SEND_KBD_RELEASES
Set if no keyboard releases should be sent to the content. Applications will set this if they only care about presses, not releases.
-
GVA_SEND_ALL_KBD_CHARS
-
Set if the view should pass all keyboard presses and releases to the content before the Specific UI has a chance to interpret them. Normally, the Specific UI will receive keyboard events, filter out the ones it uses (including application-defined accelerators), and then pass the unused events on to the view. This flag will, in essence, override the authority of the Specific UI and therefore is generally highly undesirable. If an application finds a need for this flag, the application is responsible for passing unused characters on to the UI for proper processing. If the unused characters do not get passed on, synchronization problems could result; if an application decides to handle reserved characters, the specific UI's reaction will be unpredictable.
-
GVA_FOCUSABLE
-
Set if the view window can gain the input focus. This is set by default and should be set for nearly all views.
-
GVA_SCALE_TO_FIT
-
Set if the GenView should operate in "scale to fit" mode. In this mode, the vertical scale factor will automatically be set so the entire document fits vertically within the view window; the horizontal scale factor will then be set based on the vertical. This behavior can be modified by designating a page size (via
ATTR_GEN_VIEW_PAGE_SIZE
), by changing the scaling to be based on the horizontal (via the attribute
ATTR_GEN_VIEW_SCALE_TO_FIT_BASED_ON_X
), or by setting
ATTR_GEN_VIEW_SCALE_TO_FIT_BOTH_DIMENSIONS
.
-
GVA_ADJUST_FOR_ASPECT_RATIO
-
Set if the GenView should alter its scale factors appropriate to the aspect ratio of the screen.
MSG_GEN_VIEW_SET_ATTRS
void MSG_GEN_VIEW_SET_ATTRS(
word attrsToSet,
word attrsToClear,
VisUpdateMode updateMode);
This message changes the view's
GVI_attrs
record to new values.
Source: Unrestricted.
Destination: Any GenView object.
Parameters:
attrsToSet
A record of
GenViewAttrs
to set in
GVI_attrs
.
-
attrsToClear
- A record of
GenViewAttrs
; each flag set in this parameter will be cleared in
GVI_attrs
.
-
updateMode
- A
VisUpdateMode
indicating when the GenView should be visually updated.
Return: Nothing.
Interception: Generally not intercepted.
MSG_GEN_VIEW_GET_ATTRS
word MSG_GEN_VIEW_GET_ATTRS();
This message returns a word representing the current
GVI_attrs
record. To check whether an attribute is set, mask the returned word value against the attribute.
Source: Unrestricted.
Destination: Any GenView object.
Parameters: None.
Return: The current
GenViewAttrs
record in the GenView's
GVI_attrs
field.
Interception: Generally not intercepted.
| GEOS SDK TechDocs
|
| 3 Basic View Attributes
| 3.2 Dimensional Attributes


Foxconn teaches Wisconsin managers Chinese in Taiwan
Apple supplier is training 26 U.S. recruits
by Matthew StrongU.S. managers undergoing AI training in Taiwan (picture courtesy of Foxconn Technology). (CNA photo)
TAIPEI (Taiwan News) – As a major plant construction project in Wisconsin has been completed, 26 newly recruited managers from the United States have been at Foxconn Technology Group in Taiwan undergoing training, including Chinese language lessons.
The roof has recently been finished on a key plant part of the Apple Inc. supplier’s Wisconn Valley Science and Technology Park, the Central News Agency reported Tuesday (November 19).
A total of 26 managers from the U.S. destined to work at the site were undergoing 2,000 hours of training about subjects ranging from artificial intelligence and quality management to factory manufacturing and green products, the company said.
Their curriculum also included one hour of Chinese language per day, in the hope that would enable them to communicate with their Taiwanese colleagues in two languages.
The company’s “Foxconn Future Leaders Program” had been visiting campuses to recruit high technology talent, with Purdue, Northwestern, Michigan, Illinois and Wisconsin having already supplied talent.
The electronics giant recently said the finished plant had been built using 8,000 tons of steel, and occupied an area of 1 million square feet, as large as 13 American football fields.


City Kruiz
Login to your account
{{ main.successMsg || main.errorMsg || facebook.errorMsg || twitter.errorMsg || google.errorMsg }}

Email
Password
Remember me
LOGIN
Forgot password?
Activate license Key
City Kruiz
1
Your request has been approved
See all notifications
Help
Basic Use
Admin
My Profile
Logout
Home
User
Statistics
Settings
×
{{ main.modalHeader }}
{{ main.modalBody }}


Hi,
Attached is a short php script to monitor my Raspberry Pi that is running Emonhub+EmonCMS (with a hdd).
It posts the following data on EmonCMS: memory used, memory shared, memory buffers, memory cached, GPU temp, CPU temp, CPU usage. Just modify the node id that will receive data and put you APIKEY.
- Copy this script into the home pi directory (/home/pi)
- Rename it (php file can't be attached in that forum):
mv /home/pi/SCRIPT_Post_info_RPI.txt /home/pi/SCRIPT_Post_info_RPI.php
- Modify the nodeid, the APIKEY and the target
nano /home/pi/SCRIPT_Post_info_RPI.php (modify it, save and exit with Ctrl-X / Y / Enter)
- To post data on EmonCMS, run :
php /home/pi/SCRIPT_Post_info_RPI.php
To run this script every minute, add a cron task :
sudo crontab -e and add the following line at the end of the file : * * * * * php /home/pi/SCRIPT_Post_info_RPI.php. Save and exit with Ctrl-X / Y / Enter
Then restart cron service : sudo service cron restart
First observation
I noticed that the used RAM was always increasing on my RPI. So, I was worrying about a memory leak. In fact, it seems to be normal as it's only disk caching, a normal behavior on linux machine (See http://www.linuxatemyram.com/). When clearing the memory cache by running "sudo /sbin/sysctl vm.drop_caches=3", the RAM used magically comes back (see attached). Now, I will pay attention to the "real free memory" : mem free + mem buffer + mem cached.
Second observation
I put my RPI + a hub USB + a USB HDD in plastic junction box to make it cleaner. I'm using the pre-drilled holes for ventilation (see attached). When the box is in horizontal position, the RPI's CPU gets hot (65°C). When the box is in vertical position, the RPI's CPU gets colder (55°C). The natural chimney effect with aeration is better in that position. Do you think it can be a problem for the hdd (which is also in vertical position )
Eric
Re: Monitoring a Raspberry Pi on EmonCMS
Does the hdd have an accessible temp sensor maybe?
Does having the pi vertical within the horizontal box run any cooler if you can't have the box mounted vertically?
I don't think the either the pi or hdd will mind being mounted vertically, especially if it keeps the temp lower.
I think this is a pretty cool function that could be very useful thanks for sharing.
Paul
Re: Monitoring a Raspberry Pi on EmonCMS
Does the hdd have an accessible temp sensor maybe?
>>> I don't know
Does having the pi vertical within the horizontal box run any cooler if you can't have the box mounted vertically?
>>> I can't have the pi vertical within the horizontal box (too small). So I didn't test that. According to me, the most important thing is to have holes both at the bottom and the the top of the box to create a natural chimney effect.
I think this is a pretty cool function that could be very useful thanks for sharing.
>>> more data could be collected : disk usage, network usage, ...
Eric


|
The process to create an applet or an application using grins package is as follows:
1. SMIL documents
To start using the grins package you have to supply the license given to you. You do this by calling the setLicense() static method of GRiNSToolkit passing as argument the license string.
grins.GRiNSToolkit.setLicense(licenseStr);
After you have set the license you are ready to create a SMIL document using the createDocument() factory method of a GRiNSToolkit:
SMILDocument smil = null;
try { smil = grins.GRiNSToolkit.createDocument(filenameOrUrl); }
catch(GRiNSException e) {smil = null; System.out.println(""+e);}
From an instance of a SMILDocument object you can get all the necessary info to prepare things for document playback.
You request document's duration with the call
double dur = smil.getDuration();
But be careful. Check for a negative or zero return value. A dur = 0 means that document's duration its indefinite and a dur<0 means its unresolved.
You request the number of top-level windows of the document with the call
int viewportsCount = smil.getViewportCount();
You can omit this call if you are working with SMIL documents having one toplevel window.
Top-level windows are assigned an index.
You get top-level window's size associated with index 0 with the call
Dimension d = smil.getViewportSize(0);
and its title with the call
String title = smil.getViewportTitle(0)
For document playback you have to create a SMILCanvas object for each SMIL top-level window .
SMILCanvas canvas = new grins.SMILCanvas();
and set its dimensions to the that returned by smil.getViewportSize(). A SMILCanvas is a java.awt.Canvas implementing java.awt.event.MouseListener and java.awt.event.MouseMotionListener interfaces. It further overrides the paint() method. But its still a java.awt.Canvas and you can use it as such in your application.
SMIL canvases are associated to SMIL top-level windows with the following code fragment
try {smil.getRenderer().setCanvas(0, canvas);}
catch(GRiNSException e){System.out.println(""+e);}
2. Playback
To control playback you need a SMILController. You request a smil controller from the document object
SMILController player = smil.getController()
To receive playback notifications you have to register a class implementing the SMILListener interface
player.addListener(listenerObject);
See the api documentation for the interface a SMILListener object should implement.
You can then call play/pause/stop against the instance of a SMILController
player.play();
...
player.pause();
player.play();
...
player.stop()
3. Cleanup
And finally, you close the document to release the associated resources
smil.close();
Please see the demos for more details.
|


Action is one of the primary ways that plugins can use to enrich the build/project pages. This extension point has the longest history, and as such its meaning is somewhat confusing, and its use across places are somewhat inconsistent. This page attempts to clarify that.
What is Action?
The recurring UI pattern in Jenkins is to have a bunch of navigable links and command links to the left of the page. The extension point Action was born as a means to contribute custom entries here.
Three methods defined on Action are for obtaining information needed to render actions (icon, name of the link, and where it takes the user to.)
Action and URL space
Actions often want to define additional URL space into Jenkins to show information. For example, "test reports" action adds a whole bunch of subpages into Jenkins. To facilitate this common use case, Jenkins uses the Action.getUrlName()
method.
For example, if the host object of Action
(typically extends from Actionable) is at the URL /jenkins/foo/bar/
, then Action
that returns zot
from the getUrlName()
would be mapped to /jenkins/foo/bar/zot
(and thus entire sub-space is available for this action to control. This is how you can have Action
that shows information.
In some other cases, actions just want to link to existing URL (perhaps even outside Jenkins.) getUrlName()
javadoc explains how to do it.
Special views for the action host
Some host classes that host Action
designate a specific view, and when such a view is defined, it gets pulled into the host object's page rendering. For example, AbstractBuild allows actions to define summary.groovy
(or other languages), and when it is present, those views are merged into the top page of the build. For example, JUnit integration uses this to make the test report prominent.
See the javadoc of respective host classes for details. Similarly, some host classes define a marker interface that extends from Action
in addition to define additional interaction with actions. See ProminentProjectAction for an example. See the subypes of Action for all such marker interfaces.
Transient and Persistent actions
Depending on the host, Action
have different persistence semantics. In some hosts, such as AbstractBuild, actions are explicitly added (typically by BuildSteps that executed) and persisted along with it. In some other hosts, such as View, actions are assembled entirely from other configurations of the said object whenever it's changed and therefore not persisted. Still others have hybrid approach, such as AbstractProject, which supports some explicitly added actions as well as transient ones contributed from build steps and etc.
Unfortunately, the only way to really figure out which host behaves how is to look at the implementation of the getActions() method.
Transient actions can be discarded any moment, and new ones created to take the place of the old one. Therefore, it is not suitable to use it for synchronization, or for keeping other persisted records.
Persistent actions survive forever, until it's programmatically removed or the host object gets removed itself. So care must be taken to use 'transient' where appropriate. Those objects can be also used for synchronization.
Adding actions
How you insert your implementation of Action
to Jenkins depends on the type of the host, and whether it's transient or persistent.
Persistent actions are almost always added via Actionable.addAction()
.
Transient actions are added via callback. You implement other extension points that can contribute transient actions, such as LabelAtomProperty, Builder, and Publisher, then your host will call your methods and expect you to return a list of transient actions. The host may do this every so often when it thinks it needs to update its transient actions.
More recently, we are introducing a series of Transient***ActionFactory
, such as TransientViewActionFactory, so that transient actions can be contributed without implementing another stateful extension point like Builder. Most generally, TransientActionFactory can be used for any Actionable.
RootAction
Most actions are registered in one of the two ways described above, but there's a notable exception, which is RootAction. This is a stand-alone extension point of its own, that you'd put @Extension, and these gets automatically registered as transient actions of the root Jenkins object. There's a variant of this called UnprotectedRootAction that is made accessible even to anonymous users without the read access to Jenkins.
Actions as inputs to build
Actions are also used as a parameter/input (in a broad sense of the word) to the build, as can be seen in Queue.schedule(...)
, because these actions get added to the newly created AbstractBuild and then it can be accessed from build steps. For example, ParametersAction is one such use of Action
that's used to implement parameterized builds. Matrix Reloaded Plugin uses this mechanism similarly to remember what subset of the matrix build to execute.
There are several subtypes that allows this kind of actions to interact with the queue, such as FoldableAction and QueueAction.
Actions as the vehicle to keep information about builds
AbstractBuild is Actionable and it takes persisted actions. This is the primary means for plugins to attach any information to the build. This allows other plugins to use your action to understand what has happened (such Action
are also used to render information, the primary purpose of the Action
class.)
Even if your plugin doesn't use such record by itself, we highly recommend you do it, because that opens up interesting possibilities to build on top of your work.
Invisible actions
As can be seen in the section above, some use of actions emerge over the time that goes beyond the original purpose of extending the UI, and therefore it became convenient to be able to have actions that aren't visible in the UI at all. InvisibleAction is the convenient base class for such purposes. For example, InterruptedBuildAction records how the build was aborted, but this is currently invisible, so it extends from InvisibleAction
Change the way Action link is rendered
An Action object can have an optional action.groovy
/action.jelly
file. When this file is presented, that is used to render the action link instead of the default icon+text.
Use this with caution as it can create inconsistency in the user experience.


A callback function where settings can be made to the tools specified in the tools
property. The initTools
callback function is called twice for each
tool. On the first call, the settings are applied to the tool as it appears in the
toolbar. On the second call, the settings are applied to the tool when it is minimized.
This allows the tool to appear differently in both cases if different settings are
applied.
If you wish to disable the minimization of a tool, return { minimizable: false
}
in initTools
. If you wish the tool to be minimizable but
not to appear in the minimize pop-up menu, return { menuTool: false }
.
In these cases, there will only be one call of initTools
for this tool.
initTools
is passed four parameters:
type
- the type of the tool, as specified in tools
.
index
tool
- a jQuery object representing the tool.
menuToolIninitialization
- a boolean value, specifying whether initTools
is called for the toolbar tool (false
) or the pop-up
menu tool (true
).
Code example
Set the initTools
property.
$("#jqxToolBar").jqxToolBar({ width: "100%", height: 35, tools: 'button | dropdownlist combobox | input',
initTools: function (type, index, tool, menuToolIninitialization) {
switch (index) {
case 0:
tool.text("Button");
break;
case 1:
tool.jqxDropDownList({ width: 130, source: ["Affogato", "Breve", "Café Crema"], selectedIndex: 1 });
break;
case 2:
tool.jqxComboBox({ width: 50, source: [8, 9, 10, 11, 12, 14, 16, 18, 20], selectedIndex: 3 });
break;
case 3:
tool.jqxInput({ width: 200, placeHolder: "Type here..." });
break;
}
}
});
Get the initTools
property.
var displayFormat = $('#jqxToolBar').jqxToolBar('initTools');


[dscrd-hush] <MrWrong> Dear Berg
I can't see single reason for using/buying/holding BTCH. There is no real world use case for this coin. Why are you giving effort for this meaningless coin? Is there any hope for this coin although there are<PHONE_NUMBER> coins exist for payment, micropayment etc. To be honest I'm giving BTCH zero chance. You can blame me to be pessimistic, but I believe that. HUSH has a very good real world use case. I believe that we can success if community focus on only HUSH project. BTCH is distractor not much more.
Berg02.09.2018
Effort does not only go to one coin. Both are being worked on, BTCH is a runtime fork of Komodo, meaning it inherits upgrades that the Komodo team implements. Yes, we are looking at revamping some features of BTCH, but it doesn't mean all effort goes to one coin.


General
What is Go kit?
 It was originally conceived as a toolkit to help larger (so-called modern enterprise) organizations adopt Go as an implementation language. But it very quickly “grew downward”, and now serves smaller startups and organizations just as well. For more about the origins of Go kit, see Go kit: Go in the modern enterprise.
Why should I use Go kit?
 Go kit will help you structure and build out your services, avoid common pitfalls, and write code that grows with grace.
Go kit can also help to justify Go as an implementation language to stakeholders like engineering managers or tech leads.
Who is behind Go kit?
Go kit was originally conceived by Peter Bourgon, but is now built and maintained by a large group of contributors from a diverse set of backgrounds and organizations. Go kit is presently an all-volunteer effort, and has no commercial backing.
Is Go kit production-ready?
Yes. Go kit is being used in production in several organizations, large and small.
Which organizations are using Go kit?
Watch this space :)
How does Go kit compare to Micro?
Like Go kit, Micro describes itself as a microservice toolkit. But unlike Go kit, Micro also describes itself as a microservice ecosystem. It takes a broader view, encoding expectations and opinions about the infrastructure and architecture. In short, I think Micro wants to be a platform; Go kit, in contrast, wants to integrate into your platform.
Architecture and design
Introduction — Understanding Go kit key concepts
If you’re coming from Symfony (PHP), Rails (Ruby), Django (Python), or one of the many popular MVC-style frameworks out there, the first thing you should know is that Go kit is not an MVC framework. Instead, Go kit services are laid out in three layers:
- Transport layer
- Endpoint layer
- Service layer
Requests enter the service at layer 1, flow down to layer 3, and responses take the reverse course.
This may be a bit of an adjustment, but once you grok the concepts, you should see that the Go kit design is well-suited for modern software design: both microservices and so-called elegant monoliths.
Transports — What are Go kit transports?
The transport domain is bound to concrete transports like HTTP or gRPC. In a world where microservices may support one or more transports, this is very powerful; you can support a legacy HTTP API and a newer RPC service, all in a single microservice.
When implementing a REST-ish HTTP API, your routing is defined within a HTTP transport. It’s most common to see routes defined in a HTTP Router function like this:
r.Methods("POST").Path("/profiles/").Handler(httptransport.NewServer(
e.PostProfileEndpoint,
decodePostProfileRequest,
encodeResponse,
options...,
))
Endpoints — What are Go kit endpoints?
An endpoint is like an action/handler on a controller; it’s where safety and antifragile logic lives. If you implement two transports (HTTP and gRPC), you might have two methods of sending requests to the same endpoint.

Services are where all of the business logic is implemented. A service usually glues together multiple endpoints. In Go kit, services are typically modeled as interfaces, and implementations of those interfaces contain the business logic. Go kit services should strive to abide the Clean Architecture or the Hexagonal Architecture. That is, the business logic should have no knowledge of endpoint- or especially transport-domain concepts: your service shouldn’t know anything about HTTP headers, or gRPC error codes.
Middlewares — What are middlewares, in Go kit?
Go kit tries to enforce a strict separation of concerns through use of the middleware (or decorator) pattern. Middlewares can wrap endpoints or services to add functionality, such as logging, rate limiting, load balancing, or distributed tracing. It’s common to chain multiple middlewares around an endpoint or service.
Design — How is a Go kit microservice modeled?
Putting all these concepts together, we see that Go kit microservices are modeled like an onion, with many layers. The layers can be grouped into our three domains. The innermost service domain is where everything is based on your specific service definition, and where all of the business logic is implemented. The middle endpoint domain is where each method of your service is abstracted to the generic endpoint.Endpoint, and where safety and antifragile logic is implemented. Finally, the outermost transport domain is where endpoints are bound to concrete transports like HTTP or gRPC.
You implement the core business logic by defining an interface for your service and providing a concrete implementation. Then, you write service middlewares to provide additional functionality, like logging, analytics, instrumentation — anything that needs knowledge of your business domain.
Go kit provides endpoint and transport domain middlewares, for functionality like rate limiting, circuit breaking, load balancing, and distributed tracing — all of which are generally agnostic to your business domain.
In short, Go kit tries to enforce strict separation of concerns through studious use of the middleware (or decorator) pattern.
Dependency Injection — Why is func main always so big?
 Experience has taught us that the most comprehensible, maintainable, and expressive method of defining and wiring up the component graph in a microservice is through an explicit and declarative composition in a large func main.
Inversion of control is a common feature of other frameworks, implemented via Dependency Injection or Service Locator patterns.  This style reinforces two important virtues. By strictly keeping component lifecycles in main, you avoid leaning on global state as a shortcut, which is critical for testability. And if components are scoped to main, the only way to provide them as dependencies to other components is to pass them explicitly as parameters to constructors. This keeps dependencies explicit, which stops a lot of technical debt before it starts.
As an example, let’s say we have the following components:
- Logger
- TodoService, implementing the Service interface
- LoggingMiddleware, implementing the Service interface, requiring Logger and concrete TodoService
- Endpoints, requiring a Service interface
- HTTP (transport), requiring Endpoints
Your func main should be wired up as follows:
logger := log.NewLogger(...)
var service todo.Service // interface
service = todo.NewService() // concrete struct
service = todo.NewLoggingMiddleware(logger)(service)
endpoints := todo.NewEndpoints(service)
transport := todo.NewHTTPTransport(endpoints)
At the cost of having a potentially large func main, composition is explicit and declarative. For more general Go design tips, see Go best practices, six years in.
Deployment — How should I deploy Go kit services?
It’s totally up to you. You can build a static binary, scp it to your server, and use a supervisor like runit. Or you can use a tool like Packer to create an AMI, and deploy it into an EC2 autoscaling group. Or you can package your service up into a container, ship it to a registry, and deploy it onto a cloud-native platform like Kubernetes.
Go kit is mostly concerned with good software engineering within your service; it tries to integrate well with any kind of platform or infrastructure.
Errors — How should I encode errors?
Your service methods will probably return errors. You have two options for encoding them in your endpoints. You can include an error field in your response struct, and return your business domain errors there. Or, you can choose to return your business domain errors in the endpoint error return value.
Both methods can be made to work. But errors returned directly by endpoints are recognized by middlewares that check for failures, like circuit breakers. It’s unlikely that a business-domain error from your service should cause a circuit breaker to trip in a client. So, it’s likely that you want to encode errors in your response struct.
addsvc contains examples of both methods.
More specific topics
Transports — Which transports are supported?
Go kit ships with support for HTTP, gRPC, Thrift, and net/rpc. It’s straightforward to add support for new transports; just file an issue if you need something that isn’t already offered.
Service Discovery — Which service discovery systems are supported?
Go kit ships with support for Consul, etcd, ZooKeeper, and DNS SRV records.
Service Discovery — Do I even need to use package sd?
It depends on your infrastructure.
Some platforms, like Kubernetes, take care of registering services instances and making them discoverable automatically, via platform-specific concepts. So, if you run on Kubernetes, you probably don’t need to use package sd.
But if you’re putting together your own infrastructure or platform with open-source components, then your services will likely need to register themselves with the service registry. Or if you have reached a scale where internal load balancers become a bottleneck, you may need to have your services subscribe to the system of record directly, and maintain their own connection pools. (This is the client-side discovery pattern.) In these situations, package sd will be useful.
Observability — Which monitoring systems are supported?
Go kit ships with support for modern monitoring systems like Prometheus and InfluxDB, as well as more traditional systems like statsd, Graphite, and expvar, and hosted systems like Datadog via DogStatsD and Circonus.
Observability — Which monitoring system should I use?
Logging — Why is package log so different?
Experience has taught us that a good logging package should be based on a minimal interface and should enforce so-called structured logging. Based on these invariants, Go kit’s package log has evolved through many design iterations, extensive benchmarking, and plenty of real-world use to arrive at its current state.
With a well-defined core contract, ancillary concerns like levels, colorized output, and synchronization can be easily bolted on using the familiar decorator pattern. It may feel a little unfamiliar at first, but we believe package log strikes the ideal balance between usability, maintainability, and performance.
For more details on the evolution of package log, see issues and PRs 63, 76, 131, 157, and 252. For more on logging philosophy, see The Hunt for a Logger Interface, Let’s talk about logging, and Logging v. instrumentation.
Logging — How should I aggregate my logs?
Collecting, shipping, and aggregating logs is the responsibility of the platform, not individual services. So, just make sure you’re writing logs to stdout/stderr, and let another component handle the rest.
Panics — How should my service handle panics?
Panics indicate programmer error and signal corrputed program state. They shouldn’t be treated as errors, or ersatz exceptions. In general, you shouldn’t explicitly recover from panics: you should allow them to crash your program or handler goroutine, and allow your service to return a broken response to the calling client. Your observability stack should alert you to these problems as they occur, and you should fix them as soon as possible.
With that said, if you have the need to handle exceptions, the best strategy is probably to wrap the concrete transport with a transport-specific middleware that performs a recover. For example, with HTTP:
var h http.Handler
h = httptransport.NewServer(...)
h = newRecoveringMiddleware(h, ...)
// use h normally
Persistence — How should I work with databases and data stores?
Accessing databases is typically part of the core business logic. Therefore, it probably makes sense to include an e.g. *sql.DB pointer in the concrete implementation of your service.
type MyService struct {
db *sql.DB
value string
logger log.Logger
}
func NewService(db *sql.DB, value string, logger log.Logger) *MyService {
return &MyService{
db: db,
value: value,
logger: logger,
}
}
Even better: consider defining an interface to model your persistence operations. The interface will deal in business domain objects, and have an implementation that wraps the database handle. For example, consider a simple persistence layer for user profiles.
type Store interface {
Insert(Profile) error
Select(id string) (Profile, error)
Delete(id string) error
}
type databaseStore struct{ db *sql.DB }
func (s *databaseStore) Insert(p Profile) error { /* ... */ }
func (s *databaseStore) Select(id string) (Profile, error) { /* ... */ }
func (s *databaseStore) Delete(id string) error { /* ... */ }
In this case, you’d include a Store, rather than a *sql.DB, in your concrete implementation.