Temptress Moon
(Feng Yue, 1996; China/Hong Kong--Chinese with English subtitles)
Chen Kaige's latest banned-in-China film is set in the China's turbulent 1920s, when that nation was forced to figure itself out after thousands of years of Imperial, patriarchal rule. But, nations under years of autocracy often appreciate it more than you might imagine, and often accommodate their everyday autocrats.
The story opens in 1911 when the Emperor abdicates. To avoid the chaos, Zhongliang Yu (Leslie Cheung) is sent to live and study at the country estate of the Pang family, where his sister Xiuyi (Saifei He) is married to Zhengda Pang (Zhou Yemang), an heir--and an opium addict. But the promise of study is not be kept and soon he is forced to be the preparer of Zhengda's opium pipe. Life at the estate is a life unto itself, but unbearable for outsiders, and soon Zhongliang flees into the turbulence, diverted from study in Beijing to the seediness of Shanghai.
Ten years later, the head of the Pang family dies. The Pang clan meets and decide to make Ruyi (Gong Li) the head of the family. She is the sister of the debilitated Zhengda. Her distant cousin Duanwu (Kevin Lin) is appointed to "help" her. Ruyi is also an addict, which makes it difficult to marry her off. Life at the estate become more and more insular when Ruyi dismisses all of the concubines and angers the clan elders.
In Shanghai, where it's the men versus the women, Zhongliang has become a dapper con man, using his sophistication to corner married women into extortion, starting by using his tongue to unhook their earrings. The boss (Xian Xie) of this gang of criminals is fond of Zhongliang and sends him to seduce Ruyi's fortune from her.
What unfolds is a rather unabsorbing tale of unfulfilled dreams and lost illusions. Well filmed, but boring. The actors do a good job but the script is not one to cause empathy.  Considering they are all leading lives that have been planned by others in a time of political chaos, you would think there would be something to work with there.
The innocent faces of Ruyi, Zhongliang, and Duanwu open the film.  All three go through the motions dictated to them, and all three are miserable. You would think that they would have connected on some sort of level. Only Zhongliang's sister expresses true feelings of being trapped in all this luxury, but she is shrill and her brother blames her for making him heartless.
Chen Kaige is best known for another snoozer--Farewell, My Concubine, which was rife with unconnected, unsympathetic characters. Kaige ought to pay close attention to compatriot Yimou Zhang, who directs films where people really talk to each other and make the suffering more empathetic.
Copyright 1997 Seth J. Bookey, New York, NY 10021
http://www.geocities.com/Athens/Acropolis/8588/kino.html
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


References
- Chapter1 (NASA's Apollo Plan directly aimed at the Soviet Union)
- Chapter2 (Preparations for the success of the Apollo Plan are underway)
- Chapter3 (Apollo 11 successfully landed on the Moon)
- Chapter4 (Neil Armstrong, Edwin Aldrin, explore the moon surface)
- Chapter5 (Apollo 11, Return to Earth)
- Chapter6 (The giant leap for humankind)
1. Video :
https://youtu.be/GmN1wO_24Ao |
"President Kennedy Challenges NASA to Go to the Moon" speech
2. Quote :
https://www.irishcentral.com/roots/history/john-f-kennedy-man-moon
| "President Kennedy Challenges NASA to Go to the Moon" speech article
1. Link :
https://www.nasa.gov/audience/forstudents/5-8/features/nasa-knows/what-was-project-mercury-58.html
| "What Was Project Mercury?" article
2. Link :
https://www.nasa.gov/audience/forstudents/5-8/features/nasa-knows/what-was-gemini-program-58.html
| "What Was the Gemini Program?" article
3. Image :
https://images-assets.nasa.gov/image/9139360/9139360~orig.jpg
| "Mercury Project-Atlas-Big Joe"
4. Image :
https://images-assets.nasa.gov/image/s64-25295/s64-25295~orig.jpg
| "Project Gemini-Simulator"
5. Image :
https://images-assets.nasa.gov/image/S69-19796/S69-19796~orig.jpg
| "APOLLO 9(art concept)"
6. Image :
https://images-assets.nasa.gov/image/as10-27-3890/as10-27-3890~orig.jpg
| "Apollo 10 view of the Earth from lunar horizon"
1. Image :
https://images-assets.nasa.gov/image/S69-31739/S69-31739~orig.jpg
| "APOLLO 11 CREW"
2. Video :
https://youtu.be/S3ufJ7lcr08 |
"Apollo 11 Launch Countdown"
3. Quote :
https://www.nasa.gov/mission_pages/apollo/apollo11_audio.html
| "Neil Armstrong's statement "
4. Audio :
https://www.nasa.gov/62283main_landing.wav
| "Houston...-Armstrong voice"
5. Image :
https://images-assets.nasa.gov/image/as11-40-5878/as11-40-5878~orig.jpg
| "astronauts footprint in lunar soil"
1. Quote :
https://www.nasa.gov/mission_pages/apollo/apollo11.html
| "July 20, 1969: One Giant Leap For Mankind" Article
2. Audio :
https://www.nasa.gov/62283main_landing.wav
| "That's one small step...-Armstrong voice"
3. Quote :
https://www.nasa.gov/mission_pages/apollo/apollo11.html
| "July 20, 1969: One Giant Leap For Mankind" Article
4. Image :
https://images-assets.nasa.gov/image/as11-40-5866/as11-40-5866~orig.jpg
| "Astronaut Edwin Aldrin descends the Lu"
5. Image :
https://images-assets.nasa.gov/image/as11-40-5874/as11-40-5874~orig.jpg
| "Astronaut Edwin Aldrin poses beside the flag"
6. Image :
https://images-assets.nasa.gov/image/as11-40-5927/as11-40-5927~orig.jpg
| "View Apollo 11 Lunar Module as it rested on lunar surface"
7. Image :
https://images-assets.nasa.gov/image/as11-40-5948/as11-40-5948~orig.jpg
| " explore the moon surface"
1. Image :
https://images-assets.nasa.gov/image/S69-21294/S69-21294~orig.jpg
| " Apollo 11 spacecraft Command Module hoisted aboard"
2. Link :
https://www.nasa.gov/image-feature/apollo-11-aboard-the-uss-hornet
| "U.S.S. Hornet" article
1. Video :
https://images-assets.nasa.gov/video/Apollo%2011%20Overview/Apollo%2011%20Overview~orig.mp4
| "Apollo 11 Overview - Highlights"


We'll send you a celebratory email if you give us your address (and forget we know you
otherwise).
This coolest game in the multiverse is currently in development — go stalk us on social media to
see how we're trying to wrangle quantum physics into an exciting puzzle game!
In the meantime, you can give the original Quantum Game with Photons a try!


Oops ... your browser doesn't support the HTML5 canvas element
Toggle Texture
Toggle Rotation
Camera and projection
zNear .01
3
radius 0.05
10
theta -90
90
phi -90
90
Scale
zFar 0
10
fov 10
120
aspect 0.5
2
Translation and rotation
x -5
5
y -5
5
z 0
10
Increase speed
Decrease speed
Rotate X
Rotate Y
Rotate Z
Light manipulation
Spotlight: cut off 1
80
Spotlight: angle 0
80


This is a demo site for the lab. Copying format of the course website.
| Activity | Day | Location |
|---|---|---|
| Demo Activity | Demo Day | Demo Location |
Some information about evaluations.
Information about projects this course has.
| Project | Due Date |
|---|---|
| Deliverable 1 | Some due date. |


BEYOND RANGOON A film review by Eric Grossman Copyright 1995 LOS ANGELES INDEPENDENT
John Boorman is a director who likes to take his audience on a harrowing adventure to a place they haven't been. Whether it's being chased by hillbillies through the backwoods of Appalachia (DELIVERANCE), following King Arthur as he fights for Camelot (EXCALIBUR), or taking a trip back to his childhood during World War II (HOPE AND GLORY), Boorman seeks out the exotic and pulls out all of the stops to envelop us in his story. BEYOND RANGOON, the director's latest effort, is not as solid as many of his previous works but despite its shortcomings, it is still an engaging picture.
Set against the Burmese civil unrest of 1988, the story centers around Laura Bowman (Patricia Arquette), a young American widower who has traveled to Burma with her sister, Andy (Frances McDormand), to try and put the recent murder of her husband and young boy behind her. Despite playing tourist, Laura cannot get past her tragedy which has left her in a state of emotional numbness.
One night, while venturing through Rangoon, Laura witnesses a protest led by Aung San Suu Kyi (the real life resistance leader played by Adelle Lutz), who fearlessly faces down soldiers despite having their rifles pointed at her. This event ignites a spark in Laura and she excitedly returns to her hotel where she unfortunately realizes that her passport has been lifted.
The situation in Burma quickly deteriorates and all tourists find themselves expelled, except for Laura who cannot exit without her passport. With her sister forced to leave, Laura soon finds herself alone in Rangoon. Her adventure begins when she meets U Aung Ko (a wonderful performance by a Burmese actor of the same name), a guide who agrees to take her into the countryside. There, through a series of events, she becomes swept up into the anti-government movement and through her struggles, finds the resolve to come to grips with her past.
The strengths of BEYOND RANGOON, are its interesting characters, exotic locales and suspenseful action scenes. Arquette gives a surprisingly strong but restrained performance that is crucial in keeping the film from becoming melodramatic. The supporting cast includes McDormand, who gives her usual credible performance, and Spalding Gray in an small role as the tourist guide. The real standout is U Aung Ko, who with his mix of authenticity and charm, really hooks us into caring about the warm-hearted ex-professor he portrays.
Where the movie fails is in its aim to be a political statement. Boorman, along with his co-screenwriter Bill Rubenstein, never elucidate the Burmese political scene and they are content to leave it at the level of army guys in green are bad, bald monks in robes are good.
While not one of his best films, BEYOND RANGOON still has many of the qualities that have made other Boorman pictures so captivating. We don't learn much about the reasons for Burma's problems but we certainly learn that there is a problem.
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


{{context.screen_name}}
Layout
D
Dashboard
Chart & Maps
FC
Chart
Pages
User-Base
Reports
Analyze
Bored of making graphs for your product? BrandStar draws them for you to analyze:)
Charts
Analyze!
Ratings
How users have rated your product
Emotions
What do users think about your product?
Locations
Where do your users reside??
Behavorial Traits
Behavorial traits found in your tweets based on the BIG-5 Analysis
Big-5 Analysis
Analytics of the BIG-5 traits found in your tweets
Analyze A Different Brand!
\


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object | +--java.lang.Throwable | +--java.lang.Exception | +--javax.xml.soap.SOAPException
An exception that signals that a SOAP exception has
occurred. A SOAPException
object may contain a
String
that gives the reason for the exception, an
embedded Throwable
object, or both. This class
provides methods for retrieving reason messages and for
retrieving the embedded Throwable
object.
Typical reasons for throwing a SOAPException
object are problems such as difficulty setting a header, not
being able to send a message, and not being able to get a
connection with the provider. Reasons for embedding a
Throwable
object include problems such as input/output
errors or a parsing problem, such as an error in parsing a
header.
| Constructor Summary | |
SOAPException()
Constructs a SOAPException object with no
reason or embedded Throwable object. |
|
SOAPException(java.lang.String reason)
Constructs a SOAPException object with the
given String as the reason for the exception
being thrown. |
|
SOAPException(java.lang.String reason,
java.lang.Throwable cause)
Constructs a SOAPException object with the
given String as the reason for the exception
being thrown and the given Throwable object as
an embedded exception. |
|
SOAPException(java.lang.Throwable cause)
Constructs a SOAPException object
initialized with the given Throwable
object. |
| Method Summary | |
java.lang.Throwable |
getCause()
Returns the Throwable object embedded in
this SOAPException if there is one. |
java.lang.String |
getMessage()
Returns the detail message for this
SOAPException object. |
java.lang.Throwable |
initCause(java.lang.Throwable cause)
Initializes the cause field of this
SOAPException object with the given
Throwable object. |
| Methods inherited from class java.lang.Throwable |
fillInStackTrace, getLocalizedMessage, printStackTrace, printStackTrace, printStackTrace, toString |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Constructor Detail |
public SOAPException()
SOAPException
object with no
reason or embedded Throwable
object.public SOAPException(java.lang.String reason)
SOAPException
object with the
given String
as the reason for the exception
being thrown.reason
- a description of what caused
the exceptionpublic SOAPException(java.lang.String reason, java.lang.Throwable cause)
SOAPException
object with the
given String
as the reason for the exception
being thrown and the given Throwable
object as
an embedded exception.reason
- a description of what caused
the exceptioncause
- a Throwable
object
that is to be embedded in this SOAPException
objectpublic SOAPException(java.lang.Throwable cause)
SOAPException
object
initialized with the given Throwable
object.cause
- a Throwable
object
that is to be embedded in this SOAPException
object| Method Detail |
public java.lang.String getMessage()
SOAPException
object.
If there is an embedded Throwable
object,
and if the SOAPException
object has no detail
message of its own, this method will return the detail
message from the embedded Throwable
object.
getMessage
in class java.lang.Throwable
SOAPException
or, if it has none, the message of
the embedded Throwable
object, if there is
onepublic java.lang.Throwable getCause()
Throwable
object embedded in
this SOAPException
if there is one. Otherwise,
this method returns null
.Throwable
object or
null
if there is nonepublic java.lang.Throwable initCause(java.lang.Throwable cause)
cause
field of this
SOAPException
object with the given
Throwable
object.
This method can be called at most once. It is generally
called from within the constructor or immediately after the
constructor has returned a new SOAPException
object. If this SOAPException
object was
created with the constructor SOAPException(java.lang.Throwable)
or SOAPException(java.lang.String, java.lang.Throwable)
, meaning
that its cause
field already has a value, this
method cannot be called even once.
cause
- the Throwable
object that caused this SOAPException
object
to be thrown. The value of this parameter is saved for
later retrieval by the
getCause()
method. A null value
is permitted and indicates that the cause is nonexistent
or unknown.SOAPException
instancejava.lang.IllegalArgumentException
- if
cause
is this Throwable
object.
(A Throwable
object cannot be its own
cause.)java.lang.IllegalStateException
- if this
SOAPException
object was created with SOAPException(java.lang.Throwable)
or SOAPException(java.lang.String, java.lang.Throwable)
, or this
method has already been called on this
SOAPException
object
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Assume that it is safe to append to this array. Appends made to this array
after calling this function may append in place, even if the array was a
slice of a larger array to begin with.
(Property) Get the current capacity of a slice. The capacity is the size
that the slice can grow to before the underlying array must be
reallocated or extended.
Destroys the given object and puts it in an invalid state. It's used to
destroy an object so that any cleanup which its destructor or finalizer
does is done and so that it no longer references any other objects. It does
not initiate a GC cycle or free any GC memory.
Calculates the hash value of arg with seed initial value.
Result may be non-equals with typeid(T).getHash(&arg)
The seed value may be used for hash chaining:


@* * This template is called from the `index` template. This template * handles the rendering of the page header and body tags. It takes * two arguments, a `String` for the title of the page and an `Html` * object to insert into the body of the page. *@ @(content: Html)
| Logged user: @session.get("username") @*| Email: {{ user.email }}*@ @*| Admin:{{ user.is_superuser }}*@ | Sign Out
}© 2017 Dusan Reljic


1) Write this receipt number on the paper sales receipt (right now!)
2)Then enter amount paid and payment method from paper sales receipt and click 'Save'->:
Payment Method:
3) Use the 'Add Line Item' button below to add individual line items. When you are done entering all lines, click 'Balance'->:
4) If a correction/description is entered or the total amount has been changed, click 'Balance' again (use negative number if total is > amount paid)
Status: {{invoice.status}}
Status: {{invoice.status}} additional correction needed: {{diff}}


Gear Check
The bare necessities: the foundation of a good run
Your "undies" are just as important as your other running clothes. You want undergarments that are comfortable and supportive for your training.
The importance of a runner's undergarments can't be overemphasized. Nope, they're not pretty, and they're not even all that flattering (and their ability to retain odor defies all detergents), but they hold the key to a comfortable and enjoyable run. Before you set one foot on the road or the treadmill, check what you've got going on under there and consider these guidelines:
Choose undergarments made of fabrics that move sweat away from the skin to the outer surface of the fabric (also called wicking), where it evaporates.
Explore all your undergarment options. Shop at a running or sporting-goods store for a wide selection.
Sports bras
- Running bras are often sized differently than everyday bras. Make sure you try on a bra before you buy it.
- A good running bra should have a snug fit. It should not ride up when you swing your arms.
- Look for bras that are seamless with no stitching. They reduce your chances of chafing.
- Look for bras made with fabrics that wick. This is great for moisture control and also reduces chafing.
Underwear*
- Many styles of briefs/panties are available for both men and women in stretchy fabrics that wick. Look for seamless construction.
- Running shorts have a built-in underwear liner. Rule of thumb: If they do not have a liner, they probably are not running shorts.
- Compression shorts aren't known to have liners (think biker shorts). These, too, should be made of fabric that wicks. They are great for preventing chafing and keeping your pants from riding up.
Shirts and Ts
- A word of caution: Often new runners, and even a couple of us old-schoolers, fall prey to the cotton T-shirt trap. Sure, cotton is soft and comfortable, but the minute you start to sweat, it will become wet, heavy, and clingy, and rub you in all the wrong places.
- Look for seamless, wicking fabrics with a comfortable fit.
* We use this term loosely. Traditional everyday "underwear" is usually made of cotton and therefore not suitable for running, as it easily chafes.


The document.write() function writes a string into our HTML document. This function can be used to write text, HTML, or both
You can output almost everything in the webpage using JavaScript. Many JavaScript frameworks use this to create HTML pages.


Dr. Norman Borlaug
Dr. Norman Borlaug advocating for the uneducated Women online.
Dr. Norman Borlaug resolve all your tribute problems
Look at some clients!


{% extends "seo_link/tests/test_base.html" %} {% block body %}
abc reg ex test case pattern containsabc abc abcabcabc
include startswith /link/testpage-reg in the path ###STARTS_WITH###
include exact /link/testpage-reg-ex-abc in the path ###EXACT###
include regular expression ex ###REG_EX### ###REG_EX###
include path contains abc abc ###CONTAINS_ABC###
exclude path contains def def ###CONTAINS_DEF###
inside plain p
This should be replaced
wordcount 1 test_me
wordcount 2 test me


Corporates: We would love for your company to collaborate with us in running our center and activities and in turn enable us to give back to society.
Other organisations and NGO's: Partnering with other organisations to create awareness and change would be a preferred mode of operation for us. We would love to hear from you on how we can work together towards the cause of battling mental illness.
We are looking for volunteers who are committed in making a difference. We welcome college students, professionals and other skilled candidates.
Volunteers are predominantly involved in organising event, assisting workshops among other things.
We are looking for volunteers who are committed in making a difference. We welcome college students, professionals and other skilled candidates.
Volunteers are predominantly involved in organising event, assisting workshops among other things.
In low income communities, where the financial resources are limited, the financial burden is high. Therefore, our long term goal is to provide financial aid for treatement for people with mental illness from low socioeconomic status.
We are working on this option for the long term.


Our Mission: To protect the interests of small business technology providers through mass mobilization.
Join SPARKMass Taxpayers Foundation #TechTax Analysis RELEASED. President Michael J. Widmer. "With Massachusetts losing 3,000 jobs since January, placing the highest tax burden in the country on innovation and technology - the state's greatest economic strength - is simply bad policy. Read it.
"The information super highway needs to be repaved, apparently" with this #techtax on #Fox25 this morning. pic.twitter.com/uJCMePPWEr
— sarahlummus (@sarahlummus) September 9, 2013
Two new law-firms are now considering to help the Tech Tax court case injunction against MA to stop it dead. Several state officials have admitted this cannot be fixed but DeLeo and Senate President Murray aren't moving to repeal it any time soon. Now a 2nd Beacon Hill Blitz is being lined-up and we're discussing viable opposition candidates to replace those who don't want to move toward growing the MA Technology Industry.
Joe Baz, President,<PHONE_NUMBER>
Andrew Mazzarella Faria, Vice President & Director of Technology<PHONE_NUMBER>
Scott Foster, Legal Counsel, Director<PHONE_NUMBER>
Jim Hendersen, Director<PHONE_NUMBER>
Joshua Opper, Director<PHONE_NUMBER>
SPARK is a coalition of small business technology companies that are motivated by a common thread: to protect the interests of the technology community. We are working with other trade organizations in Massachusetts to provide a first responder network for current and future contentious political issues that have an impact on the small business technology sector. Our first priority is to push an immediate injunctive relief; our second is supporting efforts to repeal the Tech Tax through the legislature AND through the ballot initiative.
Approachable, Constructive, Timely, Collaborative and Passionate.


Brief
To make a web based drawing application which allows the user to draw shapes and lines and to manage colours. This project needs to have a canvas environment and could include having animated drawing elements. This would be designed for 7 and 8 students to help make geometric shapes and patterns exciting so they'll be more enthused for Math.
What I had to consider:
Using agile processes by developing the project using sprints
Decomposing into smaller components by buliding the programme one function at a time (usually it was one function per sprint)
Coming up for multiple approaches to a function or fixing a component, as shown in the iterative deicsions
Testing regually, during and at the end of each sprint - so I can address problems as I discover them
Managing a product backlog so I can protise which features are most important
Using GitHub to reguarly commit my finished sprints on git hub
Sprint One
AIM
To allow the user to click with their mouse and then drag to draw a rectangle.
PLAN
KANBAN BOARD
TESTING
Test One:
I tested the colour array. I used 'console.log(colArray[1]);' and 'console.log(colArray[4]);' to test if the website returned the correct colour.
Test Two:
After I coded a Rectangle class in rectangle.js I tested it by instatiating a rectangle in main.js and calling it. This was a sucessful test. I was also able to check the colour, the 4th colour in the colArray.
Test Three:
I tested all the mouse listeners to make sure they work properly. As you can see, the console log shows that they are.
Test Four:
I tested that the outline for the rectangle worked correctly. It was good that the rectangle outlined appeared, but I did find a problem with this test. This problem happens when the drag extends beyond the boundaries of the canvas, as beyond the boundaries the mouse isn't registered because there is no mouse listeners on this part of the screen. So when the user tries to draw a rectangle outside of the canvas, the rectangle guide remains the same until the mouse returns to inside the boundaries again.
REFLECTION
I think that this sprint went smoothly as I didn't encounter many problems. Sprint one
is very simple and I can improve more through the subsequent sprints.
This was a very important sprint because I was able to get some major elements of my wed based drawing application working such as the canvas,
and secondly the ability to draw a rectangle guide and rectangle. Through testing it became apparant that the code that I have at the moment
for the canvas isn't suffient for a web application to go out into the real world. It's clear that in a later sprint that I will have to
fix the problem I found, that the rectangle guide is not updated when the mouse goes outside of the canvas. Although this problem should be fixed before
the project is finished, it isn't as high a priority as other basic functions this application is expected to have including buttons and
a colour selector. For this reason, I'll be adding this problem to my backlog. Next sprint, I think I'll focus on creating a drawing area inside
the canvas which will make my application look more structured and professional.
Sprint 2, working on a drawing page, is great because this will minimise the problem of the mouse not being registered outside of the canvas. This is because
having a separate box inside the whole canvas indicates to the user that they're expected to draw all the shapes inside the smaller box (the
drawing area) instead of anywhere on the canvas. And due to the fact that mouse listeners are on the canvas as whole then if the user happens to go over the
drawing area outline the rectangle will still draw the shape (although I predict I will have to code a function to make sure the shape stays inbounds).
The not updating of the shape outline will still occur if the user tries to draw the shape from the drawing box to outside
to the canvas and outside again to the document body. However, sprint 2 makes it less likely that this problem will occur for a regularly abiding user.
Sprint Two
AIM
To create a drawing area inside the canvas, so that the user can only make shapes in the drawing area, instead of the whole canvas area. The area outside of the drawing area will be for buttons deciding shapes and colours - all things to be made in further sprints.
PLAN
KANBAN BOARD
TESTING
Test One:
This was a problem with registering the proper coordinates when mouse is down. After considering the issue and the tests i've done, I realised it was a problem with updating the w and h of the rectangle. This is likely due to the fact that the update function can't run at the same time as the down function which causes the w and h to not always be updated.
While testing this I console loged the widths and the height as well as 'console.log(temp)' to understand this more. It became clear that the displacement of the mouse's position from the original click and next tap (check this) became the width and height for the random rectangle that appeared when I tapped.
I have two possible solutions. This first was to run 'update()' inside the 'down' function.... This is bad because essentially 'down()' will run twice which is not very efficient.
My second solution is to reset w and h to 0 inside the 'down' function. This is good becuase it fixed the problem. It is a better solution that my first solution as it's more efficient as it makes sure that my program only needs to run once. I chose the second soultion.
Test Two:
Test the boundraries. It works. I clicked on various parts of the screen particularly focusing on and around the boundrary of the drawing area and the whole canvas. I can tell my boundary check is working properly because whenever I click inside the drawing page, even close the barrier, it will return true. And then even 1 px outside of the boundary, the code will reture false (as it is not inside the drawing area).
Test Three:
I had this problem that the rectangle would still be created if I clicked inside the drawing area and draged out into the canvas (not apart of the drawing area).
Iterative decision to fix this problem
I chose option 2 which aims to keep the xMouse and yMouse values withn the border of the drawing area.
Test that my click and drag guide and rectangle only works for inside the drawing area. I tested this on every boundary. It works.
During this test, I found this problem when the mouse went outside of the canvas entirely and just on the webpage. The mouse wouldn't be registered until it went back on the canvas. This is because there are no mouse listeners on the entirety of the webpage. However, this is a small flaw so it's put to the bottom of the backlog. It's very clear that shape options and colour management are more important for the time being.
REFLECTION
Doing these tests there isn't any element of creativity yet. I think that while the next sprint nexts to work on another big idea, that it also needs to be creative too. To satistfy this need I would like to give the user an option. Going on further, I think i also need to work on more shapes because I let the user chose colours. I think that making sure my sprint focuses on two options, e.g. two shape buttons, will allow my project to reach a mimimum viable product level. I believe that all the work I put into making sure that the webpage and all the boundaries are working accuractly, allows me to focus on shapes and colours for the majority of the rest of my project.
Sprint Three
AIM
To allow the user to change the drag and drop shape. I will make two buttons, one for the rectangle drag a drop (already coded) and the other for an ellipse drag and drop (to be coded), for the user to switch between.
PLAN
KANBAN BOARD
TESTING
Testing the Ellipse
I want to test the ellipse function and then test the drag and drop of the ellipse. This is important to do before trying to implement the button code because it will make fixing any problems a million times easier.
Test One:
Testing the button:
It is clear that the button was instatiated properly. I also check in inbounds
for the button and it is clear that it worked. I using simple code (as shown below)
and to make my code more efficient. I will make sure to add buttons in a list, also
with another list with the button names in it. The loop will run through the list of the buttons
and the list of the button names. This will definetly be more efficient as
in the future sprints i'm expecting to have numerous buttons, and therefore, it make sense that
a better system of storing the button information is needed.
Iterative Decision
Option 1: to have a varaible defined in the constructor which can be true or false depending on whether or not
the button is selected.
Option 2: to have a static variable - so only one button is the chosen button. I have a static variable called 'Button.Clicked' to make it so only one button can be selected at one time.
There will also be a static variable called 'Button.Shape'. Which will equal the text of what's on the button, so either rectangle or ellipse.
Testing option 1:
Testing more than one button at the same time using the variable 'this.clicked'. And testing that the change of colours depending
if the mouse is hovering over the button is working. I'm using the idea of my first choice for this. I was sucessful in making two buttons appear on the page
and the hover over the buttons also works. As you ca see from my console log, the false and true is working properly.
However, there was a problem with the selection of the buttons as when I tried to select a button for the second time.
By this I mean that after already selecting a button and wanting to select the other button, the code wouldn't deselect the first button.
It was because of this that I decided that my first choice of the iteraive decison is inherted flawed, as it doesn't
deselect buttons when i'm selecting another one. I want to try the static variable. After incorprating the static variable
into my code, it seems like it is the better option as it makes sure that only one button is chosen at one point of time.
The static variable is at the very end after declaring the class. It is called 'Button.Clicked'. This is more practical. You see the selection
working properly in future tests.
Test 3
I wanted to test that the drag and drop of the ellipse worked, however when I drew it, it was very much so enlarged
and didn't fit the screen.
I then came across another problem, and that is that my ellipse's that I was drawing weren't changing depending
on the movements of the mouse and instead a fixed sized ellipse was drawn when I clicked.
I fixed this problem by fixing the variables for when I
instaitate the Ellipse inside the 'controlobject.js' just before it's pushed to the temp list.
Before the width and height was defined as 'w' and 'h', and to fix this I changed it to 'this.w' and 'this.h'.These are being updated from the mouse
move function. So the width and
height taken are the integers that are onces that are passed through controlobject.js rather than the w and h defined in main.js.
Another problem that I noticed during this test is that before selecting any buttons, it still draws the guide rectangle
and then doesn't draw any shape. I will put on the backlog to make sure that the guide will only draw after one of the buttons
is selected. This will make it less confusing for the user.
REFLECTION
A huge limitation of the program at the moment is that the shapes being clicked and dragged are only one colour.
It would be amazing for the user to have colour options. Firsly, it's boring to only have one colour; secondly, it doesn't give the user
much freedom to be creative if they don't get to chose a colour. A colour palette at the bottom
of the page - give a whole list of colour options - is the logical next step. This seems like it's the biggest priority because it's important for the
user to have different colours to draw with to foster creativity. So while the other things I've mention like more shape options and the guide not being the best
aren't important compared to not having any colour management system at present.
In this sprint I learnt alot, espeically about the importance of static variables which will help me in future sprints. I am expecting a future need
to make another set of buttons (or explore this option) in a future sprint, so it'll be good to remember the lesson I learnt about how effective static
variables are. Creating this button class, although very difficult, will help me in the future making another class about buttons (if I need) as I will have prior knowledge.
Sprint Four
AIM
To create a colour management system to allow the user to chose a variety of colours for their shapes.
PLAN
KANBAN BOARD
TESTING
Test One - Testing that two swatches work:
The process of writing the code was alright because Swatches are very similar to buttons. So I learnt from all my mistakes I made in sprint 3 while
creating two interactive buttons, and applied this while making swatches. A big part of this was reconigising the importantance
of static variables from very early on in the sprint. I learnt from the previous sprint that static variables are crucical
for interactive spaces on the canvas. As you can see, I didn't need a iterative decision as I knew from the get go that a static variable is the obvious way to go.
For this test, I clicked on both of the swatches to make sure that each swatch was deselected if another swatch was selected. I also tried to
draw a shape, but as you can see the colour of the shapes made didn't change with the swatch selection.
Test Two: Testing that the swatches connected with the controlobject
This will be testing that the two swatches work properly and have properly connected with the control object. If they have been connected correctly, clicking the the swatches will change the colour of the shapes being drawn. This has happened because the ellipses and rectangles that are being drawn now are green and yellow - the colour of the swatches. However, the next step is to make sure the user has more than 2 colour options.
Iterative decision
Now that I know two swatches work, I need to make sure that all colours from my three tiered colour array (in init.js) are displayed on the screen and that all of these function properly.
Option 1
This is to instantiate all swatches in main.js. Due to my 3 x 10 colour pallette /colour array, this will essentially
30 lines of code to instatiate all the colours (with the varing transparancys) and then push all 30 of these to a list,
from which we can create all of these on the canvas with a loop. Although this may be time consuming, it's a very logical
way to attatck the problem of getting so many swatches onto the canvas.
As you can see from the photo below, I coded 6 swatches like this. It was very time consuming for only a small pay off.
Further adding to the fact that option 1 is flawed, is that I only coded 6 out of 30 swatched, which only emphaisises
how many lines of code.
Option 2
This option is to make a loop that would instatiate all of the swatches. This may be more difficult to code and may take
more time to develop this code. However if I do consider this the better and more effective option, then I think it's worth
spending a bit more time on it to make it good. The benefits outweight the extra time, espeically as colours is a major
component of this program. From the last two screenshots, it shows that I can easily change the size of the colour palette by easily
changing a couple of numbers - so easy!
Decision
In the end I decided that Option 2 is more practical as the code is more compact. This is better for the code as it helps the code repeating itself so many time. This also makes it more functional, so another coder could come and work on my drawing app and know exactly which part of code to look for to help fix the program if there's a problem. And if there is a problem, they would only need to fix code in one place rather than 30 lines - which is way easier.
Test Three: Testing full palette
While coding the full colour palette, using option 2 I ran into a few problems. The first is that nothing appeared in terms of the colour palette and I also lost control of the buttons. However while console logging my code, I could deduct that the instatiating of the swatches was working perfectly as 30 swatches were instaitated. From this I know that there is a problem updating the swatches so they print. The problem was with the update function. I fixed this by throurgh testing through the use of 'console.log's.
It works now
REFLECTION
At this point I've coded all the major parts of this program including a drawing area, a choice of shapes and
a choice of colours. From the colour management that I completed this sprint, I don't think I'll need to improve on
it during this project as it's such a good colour managament system that doesn't have any flaws (from my testing).
I think that the next priority it to expand on the shapes options that I already have. Having more shape options seems
like a big priority to me as anyone who downloads a drawing app
would expect a reasonably variety of drawing options. Although that what I have at the moment is a viable project that I could release into the real world,
it isn't anything too special at the moment with only two options. Having a wide variety of shape options will attract users and then
more people will learn about Maths and geometric shapes.
As you can see from one of the testing videos that the drawing area gets filled up pretty fast,
I think that it would be helpful to make sure that the user has the option of an undo button which would
erase the shapes they drew. This would make the drawing app better as it would be more flexible as it
would let users to have the option to redraw their shapes and draw more than before. As you can see, I can think of
many other features to include in my project. I think this will become the next priority after making sure that we have more than 2
shape options. This is because with more than 2 shapes options the drawing area will definetly fill up faster and it will be
a bigger problem (a problem that will need immediate addressing) that needs fixing.
Sprint Five
AIM
To have options for more shapes and to include options for a range of polygons
PLAN
KANBAN BOARD
TESTING
Test One: To see if my Triangle Class works
Originally I did run into some problems testing to see if the triangle class worked. However after testing my code with creating the triangle at different points (e.g the begining, middle or end) of the 'function animate()' inside 'main.js'. The problem I had was that the triangle was showing up behind other page elements so it looked like I messed up some code up inside the Triangle class. When I moved to code to create the triangle to the end of the 'function animate()', the triangle was visible as it is printed after all other page elements.
After console logging I could see it wasn't a problem with the Triangle class as the triangle was instatiated properly as shown by the screenshot below. From doing this, I could look at other parts of the code to check - testing my programme in parts an efficient way to test.
Test Two: Test my triangle button
I encounted a problem which was that no matter which direction I dragged the mouse, from the mouse position of mouse down, it would create a triangle to the left, and down a bit. This problem is due to my x,y,w,h values inside the Triangle class not relating to where mouse is clicked or when mouse is released. The values for width and height were written as absoulte values, so the triangle won't be created in the designated position. To fix this I took away the absoulte value code. Now it works properly. As you'll see in a upcoming video.
Test Three: Testing a polygon class works
The Polygon class works. Now I was to test to get it into a button.
Test Three: Testing a polygon button works
The Polygon button works.
However, I found a problem,one of many I've encountered during this process. This problem was that the polygon wasn't drawn inside the bounding box. To fix this I had to make sure to make the radius half of h or w, depending whether the height or width is smallest.  The ideal polygon to be created is one within a square with a side length which is the width of the original bounding box. This ensures that the polygon created is fully inside the bounding box created by the user. To fully understand this idea, I have to understand that a polygon is made using a circle and the radius of this circle. To fix this problem I will have to put conditions on the radius value. This becomes a problem as the polygon might end up outside the drawing area, like shown in the image above. This happens as if the bounding box is drawn close to the edge of the drawing area and the radius value used to draw the polygon is big. When this occurs, the polygon can be created outside of the bounding box and therefore, there's a possibility that it could be drawn outside of the drawing area.
To fix this I had to make my code to account for this. So I made code (as shown below) that when the height (of the bounding box) is smaller than the width ( of the bounding box) it will draw a polygon with a radius half of the height (of the bounding box) which means that the diameter will length h. Since h is smaller that w, the polygon will fit into the bounding box well. Then if the width (of the bounding box) is smaller than height (of the bounding box) then the code will draw a polygon with radius hald of the width (of the bounding box) which means that the diameter will be a size of w. This means that the polygon will fit inside the bounding box dragged by the user. And if the bounding box doesn't fit either of these conditions, it will mean that the bounding box has an equal height and width. In this case, the radius will be half h, which is also equililent to half w. This will also have a accuractly sized polygon inside the bounding box.
After analysing this solution, I found that there too much repition within the code. because I have 3 conditions and then create a new polygon and then push it into the object list for each condition. It would be better to have a more functional code. I'm thinking that to do this I would have a condition on only one of the variables, this would be R (the radius) as this is the only value I was changing in the code. This worked better, as you can see below. I was having problems testing a condition on R in controlobject.js, so I decided to try a new approach and add this variable in my Polygon class. The code is shown below. For this new code, I had to define the variabe R inside class. Since R depends on the values of the width and height of the bounding box I had to pass this through the code. To do this I added h and w to the parameters to the class and the include these values in the constructor as well as put this.w and this.w inside the code instatiating the polygons inside control.object.js.
Iterative Decision
However as a polygon could mean so many shapes depending on the amount of sides the polygon has. For example, a six sideed polygon is a hexagon while a 10 sided polygon is a decagon. For this reason I think it makes the most sense for the user that they choose the amount of sides the polygon would have. If I do this the user won't have to wonder what type of polygon they'll get when clicking on this button.
Option One:
This option is to code 3 different buttons each with a different n value which I will distinguish in the code when instatiating the button. To do this I had buttons like Pentagon, Hexagon and Heptagon and I have manually change the n value for each button. The outcome for this is acceptable, so this is a valid option.
Option Two:
For this solution I create a new button set that is solely for different polygon options. This option is more complex than option 1 as I need to
create more button code, as there needs to be a different static variable. This is becasuse if these buttons with '4', '5' and '6' (ect) were in
same button set as the other shape buttons, then if the user clicks on one of the number of sides options it will deselect the polygon being selected.
This is due to the static variable making sure only one button being selected at one time.
Because these buttons operate a little differently I want there to
be a little bit of a distinction from these buttons compared to the other buttons. To do this I would like to have a gap, however that's not possible
with the code for the button placement in main.js. So I will have to improve this code as well for this option - however, this would be something I would've had
to do later on anyway.
Testing the button selection works
I created a new class called 'Polygon_buttons' that will be used to create the buttons that have the side length options for the polygon. I had to create a new side length buttons for this. It makes sense that these side length buttons to be smaller. For the new 'Polygon_buttons' class I had to make 2 new static variables; 1 to make sure that only one of these side length buttons can be selected at one time, and the other to make sure that the number of sides could be passed through to other sections of code.
As you can see that my new 'Polygon_buttons' class works as these side buttons can be selected when the shape buttons are also selected - which is a crucial part of this option. As mentioned, this is due to their being a new class of buttons that is separate to the original shape buttons. I haven't connected the actual instaitation of different sized polygons to the buttons yet. I see is that the side length button is still selected when the user decides to draw another shape, but this is advantageous because then the next time the user wants to draw a polygon the last selected side legnth will still be available.
Testing the side length buttons works
I connected the 'Polygon_buttons.Sides' static variable to the instatiation of the polygon. As you can see when I click on the Polygon button and then a side length, it creates the correct polygon. If the user only clicks a side length and not the polygon button, no shape is created if the user tries; this is what we want as we don't know if the user actually wants a polygon. If the user draws a polygon and the goes to select another shape, the number of sides button will remain selected - but this is fine because it draws the new shape and not a polygon. Also, if the user goes back to drawing polygons it will automatically draw polygons with the number of sides.
Decison:
I chose option 2 because it is a better solution in many ways. Most significantly option 2 is better because it useds a variable (Button.Sides) instead of a literal (e.g. 6 for a hexagon).
Option 2 allows me to easily add another polygon button for a side length without adding too many lines of code; all I would do is to create a new button conntecting it to the polygonbuttons set.
This is because the number of sides relates to the number (text) on the button, and this is connected to the 'n' side lengths. While option one depends on
each button being pushed to a list seperately, while in option 2 this can be done in a loop (more efficient and functional). Also, option 2 is better because it makes the
selection of the number of sides to be independent of the shape selection which gives more input to the user so they can have more creativity - which is what we want. This means that my program (option 2)
will be a lot more functional to the user, and it will be more future proofed as it's easier to understand and change the code in the future. Option 1 is clearly a bad option because there's a lot of repeated code
which is really bad for future proofing the
However, option two makes the buttons seem more asthetically pleasing on the page, as option 2 gives the option for the number of sides in smaller buttons. This is better than option 1, which
has seperate large buttons for each polygon options which contributes to the clutter of the page. Going into further sprints i can see that clutter is becoming a bigger problem,
so I should do what I can do now to minimise this.
REFLECTION
I believe that I made very big improvments in my code this sprint as I added more shape options which really adds to the possibility a user has while using this web application. I think I should revisit the idea I had last sprint about needing a clear and undo button because it's clearly more of a priority now as the user has so many shapes to click and drag with that the drawing area does get cluttered quickly. Since I have an adequite amount of shape options and a good colour management, I feel like I can dedicate my time to other features like a clear and undo button. These buttons will improve my program so much, much more than another shape button at this point in time.
Sprint Six
AIM
To have a undo and clear all button.
PLAN
KANBAN BOARD
TESTING
Test One: Testing the selection of the buttons work
The selection of the buttons works well. As when either the undo or clear all button is clicked, the orginal shapes buttons will be deselected.
Test Two: Making sure the buttons work
As you can see, my clear all and undo buttons are not completely functional. If i have a bunch of shapes on the page, and if I click on undo it won't work; but if I click up and down again (inside the drawing area), it'll remove a shape. This is also the same for the clear all button - as the shapes will only be cleared after I click inside the drawing area after clicking the clear all button. From this test, I know that there's a delay because the programme is not recognising when the mouse goes up the first time.
After some more testing, I know that this is because the code for the clear and undo buttons and the code that recognises what 'Button.Clicked' is (inside button.js), are running at the same time. Along with the fact that the clear all/undo code is place in the 'mUp' function inside the 'controlobject.js' at the moment. For example, for the undo button, the 'Button.Clicked = "undo"' is reconised at the same time as the 'if Button.Clicked = "undo"' code. Due to this, the result of the 'Button.Clicked = "undo"' is never carried out asnthe undo/clear all button isn't being processed until the 'mUp' function is called again and this occurs when the user clicks again. To fix this I will put the code for the clear all and undo inside the update function, so it is running all the time.
As you can see I fixed this problem, and now it works. So it will always undo the last drawn shape when clicking the undo button. Also the programme will always clear all the shapes on the screen if I click the clear all button.
I had to make sure to have 'Button.Shape = "";' at the end of each command for clearing or undoing. This is because if these buttons are not deselected then the code will keep poping the last drawn shape until there is no shapes on the drawing board. And this is something that the user did not ask for.
Reflection
I think the program is looking good at the moment but I do see room for improvment because there aren't that many features right now. Next thing to work on is another feature, I'm thinking that drawing a line would come in handy to the user.
Sprint Seven
AIM
To allow the user to be able to draw a line.
PLAN
KANBAN BOARD
TESTING
Test One: Testting the line function works.
It works.
Test Two: Testing the button works properly.
There is a problem. This is because I set the end coordinates of the line to be the width and height of the bounding box. When I did this, it took the values of the width and height of the bounding box and adjusted them according to the 0,0 (the top left corner) of the page. To fix this I need to set the end coordinates of the line to the position of the x and y mouse. This is because this will be the edge of the bounding box.
The line now works. But it seems like when the line has a thick width (for example, 10) the line could be created pass the boundary of the drawing area. This means that my solution, to the problem of the shapes could be made outside the drawin area, that makes the bounding box not being able to go outside of the drawing area - doesn't fix this problem. Because as the xMouse and yMouse values are kept within the border of the drawing area, the shapes instatiated using these xMouse and yMouse values can still go over the boundary. I will keep this problem in mind for later and put it on my backlog.
Test Two:
I'm also interested to take away the bounding box for the line as there's no reason to have it as it's drawing a line not a shape. This is because the user can use where their cursor is to figure out where the line is going to end up. This also makes my programme cleaner. I did this by adding a condition on the drawing 'drawRectGuide' inside the draw function inside 'controlobject.js'. This condition was the static variable 'Button.Shape' had to equal the shapes where I wanted the retangle guide like Polygon and rectangle ect (not line though).
REFLECTION
This is a picture that a user could create. However, there is a lack of curved lines. This is why I want to work on a brush button, so the user
could've created a better mouth and eyes as they would have access to curved/wiggly lines.
However it is important to note that I will keep in mind the problem that occured, that it is possible, even though unlikely, that a shape could disregard the boundary.
I decided to work on a brush for next sprint because it's another big step in my program, and this problem is only small at the moment. This is because the line isn't
very thick at the moment, so it will never go too much past the boundary and isn't causing any problems. All I know is that I will get this problem fixed because I finish this
project fully.
Sprint Eight
AIM
To create a brush button, and to give the user an option to different widths for the brush
PLAN
KANBAN BOARD
TESTING
Test One: Testing what brush will draw for a single moment of time
Perfect
Test Two: Test the button connects
I can see that the repeated circles that make up the brush work well. For the button to work I had to make sure to put the code to
instatiate the brush class was in the 'mMove' function as the circles need to called when the mouse moves not just when the move is clicked
and draged. The brush works well and the different colours work as well.
The problem I found that I wasn't able to limit the brush to keep inside the drawing area.
I decided to see if this was a problem for any of the other shapes. You can see that the other shapes kept inside the
drawing area. From this I can conclude that this is a problem with only the brush. Looking at what is different from the brush compared
to the other shapes, it's the fact that the brush is placed in the 'mMove' function and not 'mUp'. So I know I have to fix something involving
'mMove'.
The problem arised due to the fact that the inBoundsCheck, that runs when mouse is pressed down, is using the exact coordinates where
the mouse was clicked down. This is because I set the coordinates (this.xMouseStart, this.yMouseStart) and returned true or false depending
whether or not they are inside the drawing area. This works for the other shapes because for the shape to be created they have to click inside
the drawing area, secondly, I have code that makes sure that the values (this.w and this.h) used to create the shapes will never be larger than the boundaries. So this
solution only works the shapes and not the brush is because I don't use this.w and this.h to create the brush.
To fix this I put more conditions that have to occur before the brush is instaitated. As well as making sure the Brush button had to be selected
and the mouse was down, the inBoundsCheck has to return true for the current positions of the mouse (x and y coordinates). This way, the brush (the small circles)
will stop creating when the mouse goes out of the drawing area or if they lift their mouse. You can see the brush finally working properly.
I also tested the undo and clear all buttons here. The clear all works perfectly. But it clearly shows a limitation of the brush, which is that it can not be easily undo'd. This is because each circle created within the brush class is an object, therefore, only one circle (of the line drawn by the brush) is removed at one time. However, as seen by the test it doesn't take too long to remove a long brush line if a user needs to. Although redesigning this part of my project would be a huge task and isn't a priority right now. Comparing the pros and cons of having a brush feature, I can conclude that giving the user's the opportunity to use this brush is more important that this small flaw. My program is still very usable and it may just take a little bit more time for a user if they make a mistake.
Test 4: Looking at the line
After completing a lot of testing for the brush, I noticed that it is quite a bit confusing if there is no bounding box for the line. However, I still didn't like the look of the line with a bounding box. Because I this I seeked to find another solution. I decided that it would be better if the user could see the line that would be drawn before the line is instatiated and an element of the page.
I added this code. Which means that if the user selects Line, the code will create line that will represent the line that will be instatiated when the user's click goes up.
Iterative Decision
I want to make sure that the user has options of different sized widths for the brush. It is apparant there there is more than 1 way of doing this.
Option 1
Option 1 is to have a range of circle buttons that will determine the width of the brush. These circle buttons will need a new class and a new static variable that makes sure that only 1 brush option button can be selected at the same time, independent of the shape buttons. I think that having visual representations of how big the brush size will be good. Therefore these brush option buttons will be in a circle shape. I will definetely need to make a new class for these circle buttons, as the code will be very different compared to square buttons
Plan of the circle button:
Code:
As you can see all the buttons work well, and if the user only pushes the Brush button they'll draw with a brush that is all the same
width as 'M'. And then the brush width selected will stay selected even if the user selects on another shape. This is what I want,
as it makes it easier if the user wanted to use the large brush width all the time instead of the default medium brush width.
Although this is the same kind of idea as the polygon option (number of sides) buttons, it is different. A static varaible carries the text of the button.
Therefore for the polygon option buttons, i was able to put this static varaible straight into the instatiation code as a variable. However, for brush length this was
not possible as the text of the button is either S, M or L. And these sizes then correlate to the brush width. Because of this I had to adapt my code
to fit this.
Option 2
Option 2 is to have 5 square buttons that will determine the size of the brush. I will add 5 more options in controlobject.js, and for each I will change the radius of the circle. This is a more straightforward version and I will be able to carry this plan out quickly as I can connect the new buttons with the already made button class in buttons.js.
As you can see all the buttons work well, and if the user only pushes the Brush button they'll draw with a brush that is all the same width as 'M'.
Decision
I think option 1 is the better option because it is more functional as it would be super easy to add more buttons on that allow the user
to have different bursh widths. Secondly, it is better visually as the user will be able to see how big the brush is without having to go on a test
run first.
Test 3: Testing the brush
I found that my brush goes slightly over the edge of the drawing area. This is the same problem I had with the line in the previous sprint, however, with the brush it's more noticable as it has a bigger width so it can extend over the boundary further.
To fix this I made sure to clip whatever that is not inside the drawing area. To do this I added 'ctx.save()', 'ctx.clip()' and 'ctx.restore()' to the update function in control.object.js. This code will aslso help with same problem I had with the line.
Reflection:
I couldn't find anything else wrong with this version. I think that I could add a new button which gave the user a chance to do something new. For this reason,next sprint I will work on a rotatng shape.
I think that my Agile process is really improving my ability to continue through these sprints at a quick pace. I can find an example of this at the moment.
The early sprint about making previous shape classes, button classes and connect the buttons up with controlobject.js and testing these elements so I know they
have no bugs whatsoever. This confindence in my previous sprints, that I've recieved through sticking to the thorough testing processes of Agile (testing after each
feature/sprint has been added) have really helped me to write code for this sprint (in making a brush with multiple options) efficiently without many errors.
For what to work on next, another shape button would help to expand the program.
Sprint Nine
AIM
To create a diamond button
PLAN
A diamond is just a rotated square, so I know that i'll have research about how to rotated shapes. I looked at w3schools as shown below to gather a general idea about how to draw a rotated object.
KANBAN BOARD
TESTING
Test One: Testing that the diamond class works
I tried to instantiate a single diamond. Something went completely wrong and the whole page got rotated. This is because inside the Diamond class code I never saved and restored it. So all the page element got permantently rotated instead of just the rotation for the creation of the diamond.
To fix this I added 'ctx.save()'' to the begining of the draw function inside the Diamond class, and the 'ctx.restore()' to the end of the draw function inside the Diamond class. This makes sure that the orginal orientation of the page is saved so it then can be restored to this original orientation once the diamond is created.
Test Two: Testing the Diamond button works
The diamond works well. However, there is not bounding box which is something I think would add value to my drawing page program. I also noticed that the save, clip and restore commands I added to the upadte function inside the controlobject.js last sprint is useful here as well. This is because it clips off the end of any shapes that go outside of the drawing area.
The bounding box was added sucessfully, as shown below. However, I can see that the diamond now doesn't fit inside of the bounding box properly.
Solution to making sure the diamond is created inside the bounding box
I tried to fix it using a point to point drawing way to draw the diamond. When I tried to implement this into code, it didn't work. Through this test I was able to figure out that this was due to keeping in the code that was used to rotate the canvas. So the diamonds would've been created in the lower right corner of the canvas because the diamond were also drawn using the bounding box for reference. This doesn't work as previously in the code used to rotate the shape, I set the origin (0,0) of the x and y axis of the page to be the centre of the shape. To fix this I removed all of the rotation code.
It now works
REFLECTION
I am happy to add another shape button to my project as it improves the capabilties of my web program. Improving on this would to make a shape button with a twist, maybe a shape that spins or something.
Sprint Ten
AIM
To create a rotating ellipse button
PLAN
KANBAN BOARD
TESTING
Test One:Testing the rotating ellipse itself
What I supsect happened here was that ellipse kept getting bigger and bigger. This is because I increased the counter for 'xR' and 'yR'. To fix this I made sure that the counter was only impacting the angle used to create the ellipse.
I changed this and it worked.
Test Two:Testing the button for the rotating ellipse works
It works perfectly. Also, if the rotating ellipse goes over the boundary of the drawing area, the save, clip and restore also works here to clip the shape so it's inside the drawing area. Fortunately, the rotating ellipse works with the undo button. However, I would like to make sure that there's a bounding box for what the original position of the the ellipse would look like.
With bounding box. To do this I added code which said that if the Button.Shape = "Rotating Ellipse" then draw the rectangle guide.
Reflection:
Because I already had created the code for a regualar static ellipse, this made the process of getting it to spin easier. I'm pretty pleased with this web program now. All the features on it are really creative and any user would thrive in this environment. To improve this program would just include adding more features and maybe redeisgning the layout.
Sprint Eleven
AIM
To make a rotating star button
PLAN
TESTING
Test One: Test a static star works
It works
Test Two: Test a spinning star works
It works
Test Three: Test a button star works
The star doesn't stay inside the bounding box. This is due to the radius given being 'Math.abs(this.w/2)' which is only based on the w, assuming is is smaller than h. It become incredible noticle that the star isn't fitting inside of the bounding box when w is way larger than the height so the radius is huge, creating a huge star when it should be relative to h as well. To fix this I made sure that the star's radius is equal to 'Math.min(Math.abs(this.w),Math.abs(this.h))/2'. It now works better.
As this is my last sprint, I also dedicated some time at the end to make sure that I minimised all repeated code. To do this I made sure that all of my buttons
were all created in the same loop. I also made sure to take out any repeating code in the buttons.js. To do this I made an inherited class which is a copy of the
button class and the click and the update functions are overwritten, this makes sure that I can have different static variable for each class. E.g. 'Polygon_buttons'
replaced 'Button' for where the static variable appears.
Also to make the programme look better as a whole, I resized the buttons. I also made it so that the line button can be a small, medium or large width by
connecting the line button to the circle button options as well. In doing this I realised that the line drawn before the actual line object is created will
be a different width. To fix this I made sure that this line drawn while the user moves their mouse will be conditioned to be the correct width for the width
option they chose.
Final product
This sprint went smoothly as I had practiced coding similar concepts in previous sprints.
REFLECTION
It is perfectly clear that I've made a high quality outcome. This is true as highlighted by the effective backlog project management system (with kanbans),
version control system (repository that has my sprints for each new feature), and extensive trailing and testing processes. If I hadn't impliemented a backlog and kanbands (project
management system) I wouldn't have used prioritised my tasks well. I think it would've been easy getting caught coding countless shape buttons without considering the
important of other features like boundary checks and colourmanagment.
If I hadn't implimented a version control system, tracking and managing the changes made to my code, I
think that I would've encountered a lot more issues, and perhaps some fatal issues. My repository that has the history of all the edits i've made and historical versions is such as asset
as it allows me the freedom to change anything I want on the original source code and knowing that I could go into github and find my last commited verision of my project. Additionally, it
makes it easier to manage all the changes that have been made to my code and what those changes were. As I push my code every sprint I know that I can find out what lines of code have been added
to create each feature (of the sprint) and what code I could've removed to fix a error. I have kept track of modifications made to my code and because of this my code is organised.
The way I used iteration in the form of having a sprint for each additional feature added to the application has improved my productivity as it makes the
development process very efficient. It is efficient as I can make goals of completing each sprint inside a given timeframe, where I only have to focus on one feature
instead of coming across a whole lot of issues and geting distracted by wanting to fix every issue that comes up even if it's insignificant and doesn't largely impact the
functionality of the program.
My thorough trailling and testing processes were a very useful way to pick up small and big problems while iterating. I found testing the most helpful as
i managed to become aware of many issues while working on each sprint. Since I had this information and insight of what the problems were, I was able to distinguish between
what problems needed fixing immediately and what
problems were to go on the project backlog.
My trailing processes made sure that I had the best solutions and implementations of new features which minimises the amount
of problems I had in the future. By trialling alternative approaches I was able to deduct the best step forward and I didn't have to waste my time by implementing a ineffective
solution and then find out in the next sprint that it created more problems. For instance, I was able to figure out that having a new object set (a new button class with different static variables)
when introducing another set of options for polygons was the better option. It was good to figure out in the trailling process that this way was more functional and less cluttered than compared to
changing a variable inside the instatiation of the polygon (adding mulitple buttons). If I had chosen this less effective option I might've been at sprint 11 and struggling to find any room on the page
as well as sifting through an abundance of code repetitions. The thorough testing process allowed me to pinpoint problems in my code so I could make the appropriate corrections.
I made sure to test mulitple times throughout each sprint, more importantly I tested each time I added another element to the code. Another time where I explored different options is when I
decided how to limit the shapes to be only drawn inside the drawing area in one of the earlier sprints. I had one option to limit the bounding box from exceeding the drawing area and the other to save, clip and restore. I
chose limiting the bounding box from exceeding the drawing area to be the better solution because it indicated to the user that they should always stay inside of the drawing area because if their mouse went outside,
their bounding box would stop appearing. It was also important to keep testing these solutions in later sprints when more features had been added to see if this solution was still applicable. It was seen in
sprint 8 or so that for my program to work well I would actually need to incorprate both of these solution because both were needed for all of these shape options. This shows the intersection of maximising the advantages
of both trialling and testing. I was able to improve the functionality of my outcome through this.
Testing each element is very important because to get a high
quailty outcome all elements must perform is a efficient manner. When testing I found that objects could be created anywhere on the page and not just the drawing pages, in a early verision,
this lead to the incorpration for the bounds check function. Because I did so much testing, I am more certain about the accuracy of my code as if I solved all significant issues with the code, I can
expect the code to be reliable. I found that testing helped me personally as it helped me spend less time on debugging my code. This is because each time I cam across a bug I knew it would
be from something in the code I added sinced my last sucessful test. And since I tested so frequently I didn't need to sort through hundreds of lines of code to find where I went wrong. For example, when
I was testing my brush I noticed that it went outside of the drawing area, because I had only incorprated the brush code that was inside controlobject.js, it narrowed down where I
was looking for an error.
My working process (planning, testing, trialling) lead to the development of a high-quality digital outcome as you can see from my previous points. Planning each sprint allowed me to visulaise every step I
need to work on which made sure I thought of everything when actually coding and made the process quicker. I was able to fix problems efficiently due to my
systematic testing process during and after including a new feature. I was able to incorprate high quality solutions when I trialled two different components, so it would improve the quality of my project. For
instance, making sure to have objects that would code for most buttons instead of separate code.
How did I use the Agile process to improve the quality of my outcome. Agile Processes is used in software programming and is a great approach to project management.
It makes sure that work is done in iterations known as sprints, this is used to make sure a product is actually developed and that you're not stuck using all of your time fixing bugs that
aren't as important as creating a minimium viable product. I think ailge was super helpful because it allowed planning and developement to interact and occur together. The cycle of planning,
developing and testing was utilised to make sure that each step was carried out for each sprint. The first few sprints that I worked on were to make a basic drawing app, after this I was able to
focus on what features I could add - I used the backlog to document the features I wanted to add. Overall, the agile process was helpful because it allowed me to develop a simple interface at the beginning
that I could consider the mimimum viable project.
OTHER
Using Github as a project management
I used Github for a version control for my project so I could implement agile processes. In software development, agile practices revolve around adaptive planning, quick development and continual improvement. I bulit my project in the form of sprints where I did an iteration in a small timeframe for each sprint, making sure I continuously went through the development cycle (plan, develop, build and evaluate, until development is complete). I tested each sprint seperately before implementing it new functions/code into the main program, and when the main program was upto date I would test again. Agile processes encourage flexible responses to change. I was able to do this by changing my plan of what to focus on in the next sprint depending on what I uncovered during the testing stage. Each version of my code is stored on Github. My backlog Kanban sprint boards are also kept on Github, displaning my overall plan as well as my plan for each sprint. I commited each sprint to Github after I had completely finished each sprint. I can access each sprint as well as my main program at any point through Github and see it displayed in the 'Network' section (as shown below).
Shows my progress with all my kanban sprint boards
Network section: shows the commit history
Project Backlog:
I used a backlog to prioritise stages of work, this is an important part of an agile development. My backlog displays a prioritised list of features to implement into my project. It presents the important tasks that I have to do at the top of the list, which indicates to me which tasks I should be working on first. This made me able to manage my project more easily as it gave me an idea of what to work on every lesson. I was able to estimate what I would be working on and in which order, essiential a roadmap to the project. At the beginning of my project I had all my features I wanted to add in the To-Do column in a prioritised order. As I was working through each sprint I would move the card through the columns to completed. Sometimes during testing of the sprints I would find another feature I would have to add and add it to the To-Do column.
What my project backlog looked at the beginning:
What it looked like in the middle:
A backlog is a prioritized list of tasks that I needed to work on within the scope of this project. This strategy was incredible helpful for me to priorise what features
I had to add first. As you can see I priotised the major compments such as a couple of shape buttons, colour management and a working drawing area. Then I started to work on
more features such as other shape buttons such as Polygons and rotating ellipses. This is because the program would benefit significiantly more from a range of colour options than
a triangle option.
Through my testing and development of my program I have been able to think of new ideas during the process of making the web application. For this
reason, the backlog increases as I make the program. This is a good sign because I'm thinking of important features that a user would really appreciate and they
get added to this project backlog. This was very important because in sprint 5 I realised that the drawing page could get very cluttered and messy so I had to focus on
adding the feature of adding a clear and undo button.
I think the backlog helped me most while planning what I would work on each sprint. This project managament system taught me that the features that have the biggest yield,
the relatively biggest improvement to the program, would be the features that I should work on immediately. These high yield feature would include a drawing page and colour management
as these are huge componements of the web application. Getting further down my sprints, there was a trend on working on features that had lower yield, less significant improvments in my program. I
think that this signaled that I was coming to a nature reassing point of 'What is left to do?', other than test of more bugs. That is why you'll see that after sprint 5, the
majority of my energy is spent focused on developing more shape object buttons. I think that these features were crucial to fufilling my brief and making sure the user had enough freedom
to creat anything they wanted with geometric shapes. I think what's important to notes that this project management system really helped most in sprint 1 through to sprint 6.
Standups:
To make sure that I was on track and had a plan for the lesson, during the project i often had a short assessing timeslot at the beginning of class. It would consist of questions of 1. what I had already completed, 2. What I intend to work on today, and 3. what is blocking me for doing my task. This was incredibly helpful for me to manage my project as it allows me to divide tasks into short phases of work e.g. working on one part of the project in one lesson and other part in the next one. I can frequently reassess how I'm working and what is the most important at the present moment. It also allows me to adaptat plans easily, as if I'm consistently reassessing, I can quickly shift my attention to the prioritised task.
Relevant Implications
Usability
The relevant implication of usability is about making sure the program is easy to use which will help minimise errors. To address this implication, I made sure there were
ways my program tried to decrease the number of errors that the user could make - therefore, I made a simple interface. I did this by making sure that the user
was aware of what they were doing on the interface at each time. Firstly, I made sure that the user knows that they can interact with buttons (if they click on it something
will happen) as I had different hover colours and outline widths. Secondly, I made sure that the user knows that the drawing area is available to draw on as well, by making sure
that a bounding box is drawn when the user clicks down on there. Thirdly, I made sure that the options are in a logical place so the user is easily able to assess what to click
on first - the options for particular shapes e.g. number of sides for the polygons, is close to the general shape button, e.g. polgon button. I made These 3 decision about how
I designed the user interface to make the application more usable and easier to use.
Functionality
I had to make sure I addressed the relevant implication of functionality to make sure I built a functional program that works well. Important things to consider
while doing this is to make sure the program is free from bugs and loads quickly. I also tested my project to make sure it works on different browers e.g. Chrome and Safari.
I have addressed this relevant implication by doing regular and systematic tests to find bugs
in my program, so when it was finished I could ensure the user that there were no bugs. I tested at every single sprint inside the testing file and then again when
I implemented the new feature into the main file. Secondly, I tested the individual functions to make sure they worked before incorporating into the main program
crash so I wouldn’t make the main file have a bug. I tested using console logs, testing videos, user interactions ect. Console logging was crucial to making sure that my boundaries were correct, and
it helped me to locate the problematic parts of the code when a bug appeared. I also found it incredibly useful to test position by clicking and
dragging in various directions, carefully checking the boundaries, using 'Math.abs' when drawing circular shapes as these objection were orginally been given negative radius values.
To make sure that my drawing board loads quickly, I addressed this as my code is in pure javascript and has no graphics. I tested this by using the live web server (found on Github)
to test the loading performance. I can see that my project has a small file size which allows my program to run quickly.
Future Proofing
The relevant implication of future-proofing is all about the flexibility of the code. A program that is future-proofed well makes it easy to update or add new features and that old features are easy to remove.
The code also has to follow industry standards so it’s easy for different programmers to understand and even adapt the code. Fundamentally, future-proofing is
making sure that the code is ‘easy’ to understand.
I addressed this relevant implication by building my program around a structure that means that each new feauture or page element that is added (swatches, buttons ect.) are all added
to the code as objects. These objects are all individual modular bits of code, all taking set parameters and information to work. Since all objects that are added are bulit to
similar strucutres and all contain update functions, all objects appear on the interface when using the update call. To make sure that my code was future proofed, I made sure that the management
of most objects (that dictact page elements) are inside controlobject.js, a central place. The entire code is designed in a way that if another programmer looked at my prgram, they could easily interpret what my code means,
add components or remove featutres. It also helps that my comments are informative and frequent. I addressed this relevant implication as I was able to make sure the code fit industry standards. The code checker made sure that my code
fit with javascript conventions.
Adding new features is easy, especially considering that i have loops in main.js to make sure the addition of new similar feautres such as new buttons, is added easily. I have found it easy
myself to add new feautres in each sprint as my programme has been deisgned well, as addressed above.
evidence of my presice commenting:
Git commit evidence
As you can see I've done 12 commits for this project. This is important because if these files get lost or deleted I can easily go into github and find them again.
Javascript code style checker:
I uploaded my code in my separate files so as you can see I received a few errors, however I know that I do use all of these classes inside controlobject.js.
Then I got this:


 I enjoy trekking and solo-travelling
When indoors, I am trying to come up with innovative uses of technology and robotics


ADL SCORM 2004 RELOAD Editor Version 1.1 Readme File
Last updated: November 20, 2009
Send questions and/or comments regarding ADL SCORM 2004 RELOAD Editor to the ADL Technical Team through Ask the Experts
at
www.ADLNet.gov
.
Printable Readme


We study fluid dynamics phenomena using computer simulations, particularly fluid flows involving chemical reactions such as combustion. Our work extends from chemical kinetic reaction models for transportation fuels to computationally expensive, direct numerical simulations of turbulent combustion.
Our research focuses on numerical methods to reduce the computational expense of accurately simulating combustion and engineering fluid flows, as well as the actual physical phenomena like turbulence-chemistry interactions and smoldering combustion.
AJ successfully defended his PhD dissertation—congratulations Dr. Fillo!
Phil was featured in the Oregon State Honors Link about his second internship with Google!
AJ was featured in the Corvallis Gazette-Times for his recent Lib Lab episode on 3D printing of metal.


This is a sample contacts app. Really simple just to put in practice all the things from the Angular course.
Use the navbar to navigate to the options


2 writes to _members
System.Management.Automation (2)
engine\MshObject.cs (2)
748
_members
= new PSMemberInfoIntegratingCollection<PSMemberInfo>(this, s_memberCollection);
1606
returnValue.
_members
= new PSMemberInfoIntegratingCollection<PSMemberInfo>(returnValue, s_memberCollection);
3 references to _members
System.Management.Automation (3)
engine\MshObject.cs (3)
742
if (
_members
== null)
746
if (
_members
== null)
753
return
_members
;


Forbidden
You don't have permission to access / on this server
Red Hat Linux at http://localhost Port 80


University Project
2017
Bogotá D.C. Colombia
Challenging Extremism Estuio 7
Design of social interaction for conflict management. Research on the forms of violence present in social networks within the University of the Andes. It was found that through memes on social networks, bullying was being carried out and expressing ideas of racism, classism, among others.
From this research, a series of activities was proposed to raise awareness in the community. I was one of the people in charge of creating one of the activities that focuses on dialogue. This activity is replicated every year at the university.
Design
Personal


VULNRΞPO is in beta version I apologize if something does not work. The project idea based on my experience of participating in bug bounty programs and in performing penetration tests.
ContributorsIf you would like to support the project just let me know!.
Contact
<EMAIL_ADDRESS>twitter.com/vulnrepo
github.com/kac89/vulnrepo
Project is working on latest browsers:
Google Chrome, Mozilla Firefox, Microsoft Edge (chromium), iOS Safari/Chrome, Android Chrome
All data are stored in browser (on local machine, nothing is send outside) using indexeddb and SessionStorage, reports by default are encrypted in AES.
Use bruteforce method or better remember the security key, otherwise there is no other option to decrypt data.
If you able to decrypt report where security key you want to change, yes!.
It's simple, all images are always displayed and *.txt files. All other file types will be displayed as a link.
Download HTML report, open and use 'print to pdf' feature in your browser (ctrl+p): Chrome/FireFox.
(.VULN) - File contains only issues.
(.VULNR) - File contains full report details e.g.: issues, metadata, author etc...


rotodrag-js
A JavaScript library for one-finger SVG dragging and rotation
Have you ever wanted to manipulate both the location and orientation of an SVG object at the same time? Using only one finger or just your mouse?
rotodrag-js is a solution. It lets you drag SVG objects contained inside a parent SVG as if they were physical objects on a sheet of ice, such that they rotate around their center of mass as they are pulled one way or another.
This is exactly what you might want if you are building a web application for doing jigsaw puzzles, or for placing drawings from Greek mythology on top of their constellations in a picture of a starry sky, or for making animated movies about the lives of triangles and circles.
Example: Jigsaw puzzle
How does it work?
rotodrag-js provides a 1-pointer solution for simultaneous rotation and translation using two principles: the "sticky finger" and the "slippery center". Drigging is initiated on mouse-down or touch-start browser event handlers attached to each draggable SVG element. As the user subsequently drags their mouse or finger, the position of the SVG object is updated such that the pointer's location on the object is the same as when the drag was initiated (the "sticky finger"), and the new conter point of the object lies on the line segment between its previous location and the new location of the pointer, as in the figure below (a).
By updating the SVG position at the rate of incoming pointer events, this approach yeilds fluid and intuitive manipulation of each draggable object in most cases. However, if the dragging is initiated near the center point of the object, small and unctrollable movements of the pointer will tend to induce large, sporadic rotations. rotodrag-js implements a simple solution to this problem, which is to suppress the initation of dragging until the pointer has bee dragged sufficiently far away from the center point of an object (the "slippery center"), as in the figure above (b). The latency in an object's movement is largely imperceptible, and the ffect is that every attempt to drag an object affords a degree of expressive controll.
How do I use it on my website?
You need to have a good understanding of the XML specification of SVG to use rotodrag-js, as you will have to edit the raw code of your SVG file to get things to work. The basic steps are as follows:
- Add the
rotodrag.js
file to your header:
<script src="rotodrag.js"></script>
- Embed the code for your SVG image directly into the body of your webpage. Add a class to this SVG element "draggables" to indicate that this SVG has objects inside it that you'd like to make draggable.:
<svg class="draggables" xmlns="http://www.w3.org/2000/svg"> ... </svg>
- Position an object that you'd like to make draggable so that it's center point is located at 0,0 on the SVG. If you are importing complex SVG code from some SVG editor, you can wrap your complex object in a
<g>
element and use the "transform" property to position your object just right.
<g transform="translate(-69.25,-170.43)"> <path ... some complex path here ... /> </g>
- Finally, wrap this object in another <g> element, with a reverse transform attribute to position the object back to its starting location, a class of "draggable", and optional "data-dragstyle" and "data-slip-radius" attributes to enable and customize the size of the slippery center.
<g class="draggable" transform="translate(69.25,170.43)" data-dragstyle="slippery" data-slip-radius="20"> <g transform="translate(-69.25,-170.43)"> <path ... some complex path here ... /> </g> </g>
If all goes well, the auto-start functionality of rotodrag-js should kick in when you load your HTML page, and you should be able to drag an object around its containing SVG using your mouse or your finger. If you have trouble, see example embedded in the source code of this page.
Contributing
rotodrag-js was originally written by Andrew S. Gordon at the University of Southern California to support data-collection websites related to the automated interpretation of the famous "Heider-Simmel Film". These projects required a capacity for one-finger dragging and rotation of SVG objects, and none of the existing SVG or drag-and-drop libraries implemented the desired behavior. The code was made open-source to help others with the same needs.
rotodrag-js breaks frequently as browser vendors add and drop functionality from the desktop and mobile browsers, e.g. Chrome inexplicably dropped the javascript function "getTransformToElement" in late 2017, requiring the addition of a polyfill. Touch-action scrolling in Android Chrome was fixed in early 2021 by setting "style.touchAction" to "none". To keep things working smoothly in the face of constant change, rotodrag-js requires contributions from people like you.
GitHub Repository: https://github.com/asgordon/rotodrag-js


Sterling
EC-E
In geometry, a cube is a three-dimensional solid object bounded by six square faces, facets or sides, with three meeting at each vertex.


{{goalToChild.description}}
This goal will be completed in {{goalToChild.completeDate|dateCount}} days


--- title: BFTimeseriesChannel keywords: documentation theme, jekyll, technical writers, help authoring tools, hat replacements last_updated: Dec 03, 2018 sidebar: matlab_docs_sidebar permalink: bftimeserieschannel.html folder: mydoc ---
BFTimeseriesChannel Representation of a timeseries channel
| Superclasses | BFBaseDataNode |
| Sealed | true |
| Construct on load | false |
| BFTimeseriesChannel | Constructor of BFTIMESERIESCHANNEL class. |
| channelType | Type of channel |
| endTime | End time of channel in us |
| group | Group that channel belongs to |
| name | Name of the datanode |
| rate | Sampling rate of channel in Hz |
| session_ | Session ID |
| startTime | Start time of channel in us |
| type | Type of the datanode |
| unit | Boolean indicating channel is unit-data |
| Static | gotoSite | Opens the Blackfynn platform in an external browser. |
| Sealed | methods | Shows all methods associated with the object. |
| update | Updates the current object in the platform. |
| ObjectBeingDestroyed | Notifies listeners that a particular object has been destroyed. |


--- name: signup.html title: "Inventit Iot developer Network | Tools | Signup ♥" layout: tools ---
Let's choose your service account to signup. Please refer to the page regarding our privacy policy.


Registration
Register Here!
Name*
Email address*
We'll never share your email with anyone else.
Password*
Mobile no.*
Address*
Messege
(Optional)


---
layout: post
title: 111 direction the materials science boy band
date: '2014-02-11T19:10:41-08:00'
tags:
- science
- music
- frombrett
tumblr_url: http://beekley.xyz/post/76388837039/111-direction-the-materials-science-boy-band
---
[111] Direction, the materials science boy band.


{%extends 'base.html'%} {% load static%} {% block content %} {% load bootstrap4 %} {{block.super}}
{{business.description}}
{{alert.content}}
Do you confirm to leave this neighborhood?
{{hood.location}}